gnustep/libs-gsweb
0
0
Fork 0
mirror of https://github.com/gnustep/libs-gsweb.git synced 2025-02-23 11:41:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
libs-gsweb/GSWAdaptors/common/GSWUtil.c
Dave Wetzel edfd34c489 Changed logging to include the file name and line number. 
A logfile with "[debug] ../common/GSWUtil.c(165)" does not make much sense :-)
- GSWLog(GSW_WARNING,p_pLogServerData,
+ GSWLog(__FILE__, __LINE__, GSW_WARNING,p_pLogServerData,



git-svn-id: svn+ssh://svn.gna.org/svn/gnustep/libs/gsweb/trunk@24219 72102866-910b-0410-8b05-ffd578937521
2006-12-19 22:41:28 +00:00

661 lines
16 KiB
C
Raw Blame History

/* GSWUtil.c - GSWeb: Util
Copyright (C) 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
Written by: Manuel Guesdon <mguesdon@orange-concept.com>
Date: July 1999
This file is part of the GNUstep Web Library.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <sys/param.h>
#include <stdarg.h>
#include <netdb.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "config.h"
#include "GSWLock.h"
#if defined(Netscape)
#include <frame/log.h>
#elif defined(Apache)
#include <httpd.h>
#include <http_log.h>
#endif
#include "config.h"
#include "GSWUtil.h"
#include "GSWDict.h"
#include "GSWString.h"
#include "GSWConfig.h"
// Hosts Cache
static GSWDict *g_pHostCache = NULL;
GSWTime GSWTime_now()
{
struct timeval tv;
gettimeofday(&tv, NULL);
return GSWTime_makeTimeFromSecAndUSec(tv.tv_sec,tv.tv_usec);
}
time_t GSWTime_secPart(GSWTime t)
{
return (time_t)(t/USEC_PER_SEC);
};
long GSWTime_usecPart(GSWTime t)
{
return (time_t)(t%USEC_PER_SEC);
};
long GSWTime_msecPart(GSWTime t)
{
return ((time_t)(t%USEC_PER_SEC))/1000;
};
// 2003/12/24 22:12:25.123
// date_str should be at least 24 characters (including \0)
char* GSWTime_format(char *date_str,GSWTime t)
{
struct tm stTM;
time_t timeSecPart=GSWTime_secPart(t);
long timeMSecPart=GSWTime_msecPart(t);
int real_year;
localtime_r(&timeSecPart,&stTM);
real_year = 1900 + stTM.tm_year;
date_str[0] = real_year / 1000 + '0';
date_str[1] = (real_year % 1000) / 100 + '0';
date_str[2] = (real_year % 100) / 10 + '0';
date_str[3] = real_year % 10 + '0';
date_str[4] = '/';
date_str[5] = (stTM.tm_mon+1) / 10 + '0';
date_str[6] = (stTM.tm_mon+1) % 10 + '0';
date_str[7] = '/';
date_str[8] = stTM.tm_mday / 10 + '0';
date_str[9] = stTM.tm_mday % 10 + '0';
date_str[10] = ' ';
date_str[11] = stTM.tm_hour / 10 + '0';
date_str[12] = stTM.tm_hour % 10 + '0';
date_str[13] = ':';
date_str[14] = stTM.tm_min / 10 + '0';
date_str[15] = stTM.tm_min % 10 + '0';
date_str[16] = ':';
date_str[17] = stTM.tm_sec / 10 + '0';
date_str[18] = stTM.tm_sec % 10 + '0';
date_str[19] = '.';
date_str[20] = timeMSecPart / 100 + '0';
date_str[21] = (timeMSecPart % 100) / 10 + '0';
date_str[22] = timeMSecPart % 10 + '0';
date_str[23] = 0;
return date_str;
}
//--------------------------------------------------------------------
void
GSWLog_Init(GSWDict *p_pDict,
int p_iLevel)
{
};
//--------------------------------------------------------------------
void
VGSWLogSizedIntern(char *file,
int line,
char *fn,
int p_iLevel,
#if defined(Apache)
server_rec *p_pLogServerData,
#else
void *p_pLogServerData,
#endif
int p_iBufferSize,
CONST char *p_pszFormat,
va_list ap)
{
if (p_iLevel!=GSW_DEBUG
|| GSWConfig_IsDebug())
{
FILE *pLog = NULL;
char szBuffer[p_iBufferSize+512];
szBuffer[0] = 0;
errno = 0;//Because Apache use it in ap_log_error to display the message.
vsnprintf(szBuffer, p_iBufferSize+511, p_pszFormat, ap);
szBuffer[p_iBufferSize+511] = 0;
#if defined(Netscape)
log_error(0,"GSWeb: ",NULL,NULL,szBuffer);
#endif
#if defined(Apache)
#if defined(Apache2)
ap_log_error(file,line,p_iLevel,0,
(server_rec *)p_pLogServerData,
"GSWeb[%lu]: %s",(unsigned long)getpid(),szBuffer);
#else
ap_log_error(file,line,p_iLevel,
(server_rec *)p_pLogServerData,
"GSWeb[%lu]: %s",(unsigned long)getpid(),szBuffer);
#endif
#endif
};
}
//--------------------------------------------------------------------
void
GSWLog(
char *file,
int line,
int p_iLevel,
#if defined(Apache)
server_rec *p_pLogServerData,
#else
void *p_pLogServerData,
#endif
CONST char *p_pszFormat, ...)
{
va_list ap;
va_start(ap,p_pszFormat);
VGSWLogSizedIntern(
file,
line,
NULL,
p_iLevel,
p_pLogServerData,
4096,
p_pszFormat,
ap);
va_end(ap);
};
//--------------------------------------------------------------------
void
GSWLogSized(int p_iLevel,
#if defined(Apache)
server_rec *p_pLogServerData,
#else
void *p_pLogServerData,
#endif
int p_iBufferSize,
CONST char *p_pszFormat, ...)
{
va_list ap;
va_start(ap,p_pszFormat);
VGSWLogSizedIntern(NULL,
0,
NULL,
p_iLevel,
p_pLogServerData,
p_iBufferSize,
p_pszFormat,
ap);
va_end(ap);
};
//--------------------------------------------------------------------
void
GSWLogIntern(char *file,
int line,
char *fn,
int p_iLevel,
#if defined(Apache)
server_rec *p_pLogServerData,
#else
void *p_pLogServerData,
#endif
CONST char *p_pszFormat,...)
{
va_list ap;
va_start(ap,p_pszFormat);
VGSWLogSizedIntern(file,
line,
fn,
p_iLevel,
p_pLogServerData,
4096,
p_pszFormat,
ap);
va_end(ap);
};
//--------------------------------------------------------------------
void
GSWLogSizedIntern(char *file,
int line,
char *fn,
int p_iLevel,
#if defined(Apache)
server_rec *p_pLogServerData,
#else
void *p_pLogServerData,
#endif
int p_iBufferSize,
CONST char *p_pszFormat,...)
{
va_list ap;
va_start(ap,p_pszFormat);
VGSWLogSizedIntern(file,
line,
fn,
p_iLevel,
p_pLogServerData,
p_iBufferSize,
p_pszFormat,
ap);
va_end(ap);
};
//--------------------------------------------------------------------
// return new len
int
DeleteTrailingCRNL(char *p_pszString)
{
int i=0;
if (p_pszString)
{
i=strlen(p_pszString)-1;
while (i>=0 && p_pszString[i] &&
(p_pszString[i]=='\r' || p_pszString[i]=='\n'))
p_pszString[i--]=0;
i++;
};
return i;
}
//--------------------------------------------------------------------
int
DeleteTrailingSlash(char *p_pszString)
{
int i=0;
if (p_pszString)
{
i=strlen(p_pszString)-1;
while (i>=0 && p_pszString[i] && p_pszString[i]=='/')
p_pszString[i--]=0;
i++;
};
return i;
}
//--------------------------------------------------------------------
int
DeleteTrailingSpaces(char *p_pszString)
{
int i=0;
if (p_pszString)
{
i=strlen(p_pszString)-1;
while (i>=0 && p_pszString[i] && p_pszString[i]==' ')
p_pszString[i--]=0;
i++;
};
return i;
}
//--------------------------------------------------------------------
int
SafeStrlen(CONST char *p_pszString)
{
return (p_pszString ? strlen(p_pszString) : 0);
};
//--------------------------------------------------------------------
char *
SafeStrdup(CONST char *p_pszString)
{
return (p_pszString ? strdup(p_pszString) : NULL);
};
char *
strcasestr(CONST char *p_pszString,CONST char *p_pszSearchedString)
{
if (p_pszString && p_pszSearchedString)
{
int i=0;
int iStringLen=strlen(p_pszString);
int iSearchedStringLen=strlen(p_pszSearchedString);
if (iStringLen>0 && iSearchedStringLen>0)
{
char ch1stUpper=toupper(p_pszSearchedString[0]);
for(i=0;i<iStringLen-iSearchedStringLen+1;i++)
{
if (toupper(p_pszString[i])==ch1stUpper)
{
BOOL fSame=TRUE;
int j=0;
for(j=1;j<iSearchedStringLen && fSame;j++)
fSame=toupper(p_pszString[i+j]) ==
toupper(p_pszSearchedString[j]);
if (fSame)
return p_pszString+i;
};
};
};
};
return NULL;
};
#if defined(HAS_REENTRANT_GETHOSTENT) && !defined(_REENTRANT)
#define _REENTRANT /* needs to be defined so proper structs get included */
#endif
//--------------------------------------------------------------------
void
GSWUtil_ClearHostCache()
{
if (g_pHostCache)
{
GSWDict_Free(g_pHostCache);
g_pHostCache=NULL;
};
};
//--------------------------------------------------------------------
PSTHostent
GSWUtil_FindHost(CONST char *p_pszHost,
void *p_pLogServerData)
{
PSTHostent pHost=NULL;
if (!p_pszHost)
p_pszHost="localhost";
pHost = (g_pHostCache) ?
(PSTHostent)GSWDict_ValueForKey(g_pHostCache,p_pszHost) : NULL;
if (!pHost)
{
pHost = GSWUtil_HostLookup(p_pszHost,p_pLogServerData);
if (pHost)
{
if (!g_pHostCache)
g_pHostCache = GSWDict_New(32);
GSWDict_Add(g_pHostCache,p_pszHost,pHost,TRUE);
GSWDebugLog(p_pLogServerData,"Caching hostent for %s",p_pszHost);
};
};
return pHost;
};
#define ROUND_UP(n, m) (((unsigned)(n)+(m)-1)&~((m)-1))
#define BUFLEN 4096
#if defined(NEEDS_HSTRERR)
#ifndef NETDB_SUCCESS
#define NETDB_SUCCESS 0
#endif
//--------------------------------------------------------------------
CONST char *
hstrerror(int herr)
{
if (herr == -1) // see errno
return strerror(errno);
else if (herr == HOST_NOT_FOUND)
return "Host not found";
else if (herr == TRY_AGAIN)
return "Try again"; // ?
else if (herr == NO_RECOVERY)
return "Non recoverable error";
else if (herr == NO_DATA)
return "No data";
else if (herr == NO_ADDRESS)
return "No address"; // same as no data
else if (herr == NETDB_SUCCESS)
return "No error"; // Gag !
else
return "unknown error";
}
#endif
//--------------------------------------------------------------------
static PSTHostent
GSWUtil_CopyHostent(PSTHostent p_pHost)
{
PSTHostent pNewHost=NULL;
int iSize=(ROUND_UP(sizeof(struct hostent),
sizeof(void *)))+strlen(p_pHost->h_name)+1;
int iAliasNb=0;
int iAddressesNb = 0;
char **ppszAliasOrAddress=NULL;
char **ppszNewHostAliasOrAddress=NULL;
void *pTmp=NULL;
// Aliases
for (ppszAliasOrAddress=p_pHost->h_aliases;
ppszAliasOrAddress && *ppszAliasOrAddress;
ppszAliasOrAddress++)
{
iSize+=strlen(*ppszAliasOrAddress)+1;
iAliasNb++;
};
// Aliases Pointers Null Terminated List
iSize=ROUND_UP(iSize,sizeof(char *));
iSize+=(iAliasNb+1)*sizeof(char *);
for (ppszAliasOrAddress=p_pHost->h_addr_list;
ppszAliasOrAddress && *ppszAliasOrAddress;
ppszAliasOrAddress++)
iAddressesNb++;
iSize+=iAddressesNb*(sizeof(char *)+p_pHost->h_length+1);
pNewHost=malloc(ROUND_UP(iSize,sizeof(char *)));
pTmp=pNewHost;
pNewHost->h_addrtype = p_pHost->h_addrtype;
pNewHost->h_length = p_pHost->h_length;
pTmp+=ROUND_UP(sizeof(struct hostent),sizeof(void *));
pNewHost->h_aliases = (char **)pTmp;
pTmp+=(iAliasNb+1)*sizeof(char *);
pNewHost->h_addr_list = (char **)pTmp;
pTmp+=(iAddressesNb+1)*sizeof(char *);
pNewHost->h_name = pTmp;
strcpy(pNewHost->h_name,p_pHost->h_name);
pTmp+=strlen(pNewHost->h_name)+1;
// Copy Aliases
for (ppszAliasOrAddress=p_pHost->h_aliases,
ppszNewHostAliasOrAddress=pNewHost->h_aliases;
ppszAliasOrAddress && *ppszAliasOrAddress;
ppszAliasOrAddress++,ppszNewHostAliasOrAddress++)
{
*ppszNewHostAliasOrAddress = (char *)pTmp;
strcpy((char *)pTmp,*ppszAliasOrAddress);
pTmp+=strlen(*ppszAliasOrAddress) + 1;
};
*ppszNewHostAliasOrAddress=NULL;
pTmp=(void *)ROUND_UP(pTmp,pNewHost->h_length);
for (ppszAliasOrAddress=p_pHost->h_addr_list,
ppszNewHostAliasOrAddress=pNewHost->h_addr_list;
ppszAliasOrAddress && *ppszAliasOrAddress;
ppszAliasOrAddress++,ppszNewHostAliasOrAddress++)
{
*ppszNewHostAliasOrAddress=(char *)pTmp;
memcpy(*ppszNewHostAliasOrAddress,*ppszAliasOrAddress,
pNewHost->h_length);
pTmp+=pNewHost->h_length;
};
*ppszNewHostAliasOrAddress=NULL;
return pNewHost;
};
//--------------------------------------------------------------------
PSTHostent
GSWUtil_HostLookup(CONST char *p_pszHost,
void *p_pLogServerData)
{
PSTHostent pHost=NULL;
struct in_addr hostaddr;
int error=0;
#if defined(HAS_REENTRANT_GETHOSTENT)
struct hostent stTmpHost;
char szBuffer[BUFLEN];
pHost = &stTmpHost; /* point to struct on the stack */
memset(pHost,0,sizeof(struct hostent));
memset(szBuffer,0,sizeof(szBuffer));
#endif
if (!p_pszHost)
p_pszHost="localhost";
if (isdigit(*p_pszHost))
hostaddr.s_addr=inet_addr(p_pszHost);
#if defined(HAS_REENTRANT_GETHOSTENT)
if (isdigit(*p_pszHost))
{
#if defined(SOLARIS)
pHost = gethostbyaddr_r((char *)&hostaddr.s_addr,
sizeof(hostaddr.s_addr),
AF_INET,
pHost,
szBuffer,
BUFLEN, &error);
#else // !SOLARIS
if (gethostbyaddr_r((char *)&hostaddr.s_addr,
sizeof(hostaddr.s_addr),
AF_INET,
&stTmpHost,
szBuffer) == 0)
{
pHost = &stTmpHost;
error = 0;
}
else
{
pHost=NULL;
error = h_errno;
};
#endif // SOLARIS
}
else
{
#if defined(SOLARIS)
pHost = gethostbyname_r(p_pszHost,
&stTmpHost,
szBuffer,
BUFLEN,
&error);
#else // !SOLARIS
pHost = (gethostbyname_r(p_pszHost,&stTmpHost,szBuffer)==0) ?
&stTmpHost : NULL;
error = (pHost) ? 0 : h_errno;
#endif // SOLARIS
};
#else // !HAS_REENTRANT_GETHOSTENT
if (isdigit(*p_pszHost))
{
pHost = gethostbyaddr((char *)&hostaddr.s_addr, sizeof(hostaddr.s_addr),
AF_INET);
error = (pHost) ? 0 : h_errno;
}
else
{
pHost = gethostbyname(p_pszHost);
error = (pHost) ? 0 : h_errno;
}
#endif // HAS_REENTRANT_GETHOSTENT
if (!pHost)
{
GSWLog(__FILE__, __LINE__,GSW_ERROR,p_pLogServerData,
"gethostbyname(%s) returns no host: %s",
p_pszHost,
hstrerror(error));
}
else if (pHost->h_addrtype != AF_INET)
{
GSWLog(__FILE__, __LINE__,GSW_ERROR,p_pLogServerData,"Wrong address type in hostptr for host %s",p_pszHost);
};
if (pHost)
pHost=GSWUtil_CopyHostent(pHost);
return pHost;
};
// buffer should be at leat 20 characters
// [dollar]Revision: 1.12 [dollar] ==> 1.12
char* RevisionStringToRevisionValue(char* buffer,const char* revisionString)
{
char* dstBuffer=buffer;
while(*revisionString && *revisionString!=':')
revisionString++;
if (*revisionString==':')
{
while(*revisionString && !isdigit(*revisionString))
revisionString++;
if (isdigit(*revisionString))
{
while(*revisionString && (isdigit(*revisionString) || *revisionString=='.') && (dstBuffer-buffer)<20)
{
*dstBuffer=*revisionString;
revisionString++;
dstBuffer++;
};
};
};
*dstBuffer=0;
return buffer;
};
#ifndef __USE_GNU
char* gsw_strndup(const char *s, size_t len)
{
char *dups=NULL;
// search end of string
const char *end = memchr(s, '\0', len);
if (end)
len=end-s;
dups = malloc(len+1); // +1 for \0
if (len>0)
memcpy(dups,s,len);
dups[len]='\0';
return dups;
}
#endif
Reference in a new issue View git blame Copy permalink