mirror of
https://github.com/3proxy/3proxy.git
synced 2025-02-23 18:45:40 +08:00
initial logging refatoring commit, should be very buggy
This commit is contained in:
z3APA3A
parent
fa4322afee
commit
8d73f977de
@ -8,7 +8,7 @@
|
||||
|
||||
BUILDDIR = ../bin/
|
||||
CC = cl
|
||||
CFLAGS = /nologo /MT /W3 /Ox /GS /EHs- /GA /GF /D "MSVC" /D "WITH_STD_MALLOC" /D "WITH_WSAPOLL" /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D "_WIN32" /D "PRINTF_INT64_MODIFIER=\"I64\"" /Fp"proxy.pch" /FD /c $(VERSION) $(BUILDDATE)
|
||||
CFLAGS = /nologo /MT /W3 /Ox /GS /EHs- /GA /GF /D "MSVC" /D "WITH_STD_MALLOC" /D "WITH_WSAPOLL" /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D "_WIN32" /Fp"proxy.pch" /FD /c $(VERSION) $(BUILDDATE)
|
||||
COUT = /Fo
|
||||
LN = link
|
||||
LDFLAGS = /nologo /subsystem:console /incremental:no /machine:I386
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
|
||||
BUILDDIR = ../bin64/
|
||||
CC = cl
|
||||
CFLAGS = /nologo /MT /W3 /Ox /EHs- /GS /GA /GF /D "MSVC" /D "WITH_STD_MALLOC" /D "WITH_WSAPOLL" /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D "_WIN32" /D "PRINTF_INT64_MODIFIER=\"I64\"" /Fp"proxy.pch" /FD /c $(VERSION) $(BUILDDATE)
|
||||
CFLAGS = /nologo /MT /W3 /Ox /EHs- /GS /GA /GF /D "MSVC" /D "WITH_STD_MALLOC" /D "WITH_WSAPOLL" /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D "_WIN32" /Fp"proxy.pch" /FD /c $(VERSION) $(BUILDDATE)
|
||||
COUT = /Fo
|
||||
LN = link
|
||||
LDFLAGS = /nologo /subsystem:console /incremental:no /machine:x64
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
|
||||
BUILDDIR = ../bin64/
|
||||
CC = cl
|
||||
CFLAGS = /nologo /MT /W3 /Ox /EHs- /GS /GA /GF /D "MSVC" /D "WITH_STD_MALLOC" /D "WITH_WSAPOLL" /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D "_WIN32" /D "PRINTF_INT64_MODIFIER=\"I64\"" /Fp"proxy.pch" /FD /c $(VERSION) $(BUILDDATE)
|
||||
CFLAGS = /nologo /MT /W3 /Ox /EHs- /GS /GA /GF /D "MSVC" /D "WITH_STD_MALLOC" /D "WITH_WSAPOLL" /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D "_WIN32" /Fp"proxy.pch" /FD /c $(VERSION) $(BUILDDATE)
|
||||
COUT = /Fo
|
||||
LN = link
|
||||
LDFLAGS = /nologo /subsystem:console /incremental:no /machine:arm64
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
|
||||
BUILDDIR = ../bin/
|
||||
CC = cl
|
||||
CFLAGS = /DARM /D "NOODBC" /nologo /MT /W3 /Wp64 /Ox /GS /EHs- /GA /GF /D "MSVC" /D "_WINCE" /D "WITH_STD_MALLOC" /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D "_WIN32" /D "PRINTF_INT64_MODIFIER=\"I64\"" /Fp"proxy.pch" /FD /c
|
||||
CFLAGS = /DARM /D "NOODBC" /nologo /MT /W3 /Wp64 /Ox /GS /EHs- /GA /GF /D "MSVC" /D "_WINCE" /D "WITH_STD_MALLOC" /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D "_WIN32" /Fp"proxy.pch" /FD /c
|
||||
COUT = /Fo
|
||||
LN = link
|
||||
LDFLAGS = /nologo /subsystem:console /incremental:no
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
|
||||
BUILDDIR = ../bin/
|
||||
CC = cl
|
||||
CFLAGS = /nologo /Ox /MT /D "NOIPV6" /D "NODEBUG" /D "NOODBC" /D "NORADIUS" /D"WATCOM" /D "MSVC" /D "WITH_STD_MALLOC" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D "_WIN32" /D "PRINTF_INT64_MODIFIER=\"I64\"" /c $(VERSION) $(BUILDDATE)
|
||||
CFLAGS = /nologo /Ox /MT /D "NOIPV6" /D "NODEBUG" /D "NOODBC" /D "NORADIUS" /D"WATCOM" /D "MSVC" /D "WITH_STD_MALLOC" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D "_WIN32" /c $(VERSION) $(BUILDDATE)
|
||||
COUT = /Fo
|
||||
LN = link
|
||||
LDFLAGS = /nologo /subsystem:console /incremental:no
|
||||
|
||||
21
src/3proxy.c
21
src/3proxy.c
@ -63,11 +63,6 @@ void __stdcall CommandHandler( DWORD dwCommand )
|
||||
conf.paused++;
|
||||
Sleep(2000);
|
||||
SetStatus( SERVICE_STOPPED, 0, 0 );
|
||||
#ifndef NOODBC
|
||||
pthread_mutex_lock(&log_mutex);
|
||||
close_sql();
|
||||
pthread_mutex_unlock(&log_mutex);
|
||||
#endif
|
||||
break;
|
||||
case SERVICE_CONTROL_PAUSE:
|
||||
SetStatus( SERVICE_PAUSE_PENDING, 0, 1 );
|
||||
@ -116,13 +111,7 @@ void mysigpause (int sig){
|
||||
|
||||
void mysigterm (int sig){
|
||||
conf.paused++;
|
||||
usleep(999*SLEEPTIME);
|
||||
usleep(999*SLEEPTIME);
|
||||
#ifndef NOODBC
|
||||
pthread_mutex_lock(&log_mutex);
|
||||
close_sql();
|
||||
pthread_mutex_unlock(&log_mutex);
|
||||
#endif
|
||||
usleep(2000*SLEEPTIME);
|
||||
conf.timetoexit = 1;
|
||||
}
|
||||
|
||||
@ -204,7 +193,7 @@ void dumpcounters(struct trafcount *tlin, int counterd){
|
||||
if(cfp){
|
||||
for(tl = tlin; cfp && tl; tl = tl->next){
|
||||
if(tl->type >= conf.countertype)
|
||||
fprintf(cfp, "%05d %020"PRINTF_INT64_MODIFIER"u%s%s\n", tl->number, tl->traf64, tl->comment?" #" : "", tl->comment? tl->comment : "");
|
||||
fprintf(cfp, "%05d %020" PRIu64 "%s%s\n", tl->number, tl->traf64, tl->comment?" #" : "", tl->comment? tl->comment : "");
|
||||
}
|
||||
fclose(cfp);
|
||||
}
|
||||
@ -235,7 +224,6 @@ void dumpcounters(struct trafcount *tlin, int counterd){
|
||||
void cyclestep(void){
|
||||
struct tm *tm;
|
||||
time_t minutecounter;
|
||||
unsigned char tmpbuf[8192];
|
||||
|
||||
minutecounter = time(0);
|
||||
for(;;){
|
||||
@ -248,7 +236,6 @@ void cyclestep(void){
|
||||
conf.needreload = 0;
|
||||
}
|
||||
doschedule();
|
||||
if(conf.stdlog)fflush(conf.stdlog);
|
||||
if(timechanged(minutecounter, conf.time, MINUTELY)) {
|
||||
struct filemon *fm;
|
||||
struct stat sb;
|
||||
@ -269,10 +256,6 @@ void cyclestep(void){
|
||||
tm->tm_hour = tm->tm_min = tm->tm_sec = 0;
|
||||
basetime = mktime(tm);
|
||||
}
|
||||
if(conf.logname) {
|
||||
if(timechanged(conf.logtime, conf.time, conf.logtype)) {
|
||||
}
|
||||
}
|
||||
if(conf.counterd >= 0 && conf.trafcounter) {
|
||||
if(timechanged(cheader.updated, conf.time, MINUTELY)){
|
||||
dumpcounters(conf.trafcounter, conf.counterd);
|
||||
|
||||
@ -298,10 +298,9 @@ typedef struct radius_packet_t {
|
||||
|
||||
#define RETURN(xxx) { res = xxx; goto CLEANRET; }
|
||||
|
||||
#define packet (*(radius_packet_t *buf))
|
||||
#define packet (*((radius_packet_t *)inbuf))
|
||||
|
||||
int radbuf(struct clientparam * param, unsigned char * buf, int auth, int stop){
|
||||
int loop;
|
||||
int radbuf(struct clientparam * param, unsigned char * inbuf, int auth, int stop){
|
||||
int id;
|
||||
int res = 4;
|
||||
SOCKET sockfd = -1;
|
||||
@ -310,19 +309,15 @@ int radbuf(struct clientparam * param, unsigned char * buf, int auth, int stop){
|
||||
int len;
|
||||
int op;
|
||||
char vector[AUTH_VECTOR_LEN];
|
||||
int data_len;
|
||||
uint8_t *vendor_len;
|
||||
int count=0;
|
||||
uint8_t *attr;
|
||||
long vendor=0;
|
||||
int vendorlen=0;
|
||||
char buf[64];
|
||||
|
||||
if(!radiussecret || !nradservers) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
memset(&packet, 0, sizeof(packet));
|
||||
memset(&packet, 0, sizeof(radius_packet_t));
|
||||
|
||||
|
||||
pthread_mutex_lock(&rad_mutex);
|
||||
@ -523,23 +518,25 @@ int radbuf(struct clientparam * param, unsigned char * buf, int auth, int stop){
|
||||
}
|
||||
|
||||
|
||||
int radsend(const char *buf, int total_length, int auth){
|
||||
int radsend(const unsigned char *inbuf, int total_length, int auth,
|
||||
#ifdef NOIPV6
|
||||
struct sockaddr_in* sinsl
|
||||
#else
|
||||
struct sockaddr_in6* sinsl
|
||||
#endif
|
||||
){
|
||||
|
||||
int loop;
|
||||
int id;
|
||||
int res = 4;
|
||||
SOCKET sockfd = -1;
|
||||
unsigned char *ptr;
|
||||
int len;
|
||||
int op;
|
||||
#ifdef NOIPV6
|
||||
struct sockaddr_in saremote;
|
||||
#else
|
||||
struct sockaddr_in6 saremote;
|
||||
#endif
|
||||
struct pollfd fds[1];
|
||||
char vector[AUTH_VECTOR_LEN];
|
||||
radius_packet_t packet, rpacket;
|
||||
radius_packet_t rpacket;
|
||||
SASIZETYPE salen;
|
||||
int data_len;
|
||||
uint8_t *vendor_len;
|
||||
@ -547,7 +544,6 @@ int radsend(const char *buf, int total_length, int auth){
|
||||
uint8_t *attr;
|
||||
long vendor=0;
|
||||
int vendorlen=0;
|
||||
char buf[64];
|
||||
|
||||
|
||||
|
||||
@ -578,7 +574,7 @@ int radsend(const char *buf, int total_length, int auth){
|
||||
}
|
||||
else remsock = radiuslist[loop].logsock;
|
||||
*/
|
||||
so._bind(param->remsock,(struct sockaddr *)&radiuslist[loop].localaddr,SASIZE(&radiuslist[loop].localaddr));
|
||||
so._bind(remsock,(struct sockaddr *)&radiuslist[loop].localaddr,SASIZE(&radiuslist[loop].localaddr));
|
||||
len = so._sendto(remsock, (char *)&packet, total_length, 0,
|
||||
(struct sockaddr *)&saremote, sizeof(saremote));
|
||||
if(len != ntohs(packet.length)){
|
||||
@ -645,13 +641,13 @@ int radsend(const char *buf, int total_length, int auth){
|
||||
}
|
||||
|
||||
if (!vendor && attr[0] == PW_FRAMED_IP_ADDRESS && attr[1] == 6) {
|
||||
*SAFAMILY(¶m->sinsl) = AF_INET;
|
||||
memcpy(SAADDR(¶m->sinsl), attr+2, 4);
|
||||
*SAFAMILY(sinsl) = AF_INET;
|
||||
memcpy(SAADDR(sinsl), attr+2, 4);
|
||||
}
|
||||
|
||||
else if (!vendor && attr[0] == PW_FRAMED_IPV6_ADDRESS && attr[1] == 18) {
|
||||
*SAFAMILY(¶m->sinsl) = AF_INET6;
|
||||
memcpy(SAADDR(¶m->sinsl), attr+2, 16);
|
||||
*SAFAMILY(sinsl) = AF_INET6;
|
||||
memcpy(SAADDR(sinsl), attr+2, 16);
|
||||
}
|
||||
else if (!vendor && attr[0] == PW_REPLY_MESSAGE && attr[1] >= 3 && isdigit(attr[2])) {
|
||||
res = 0;
|
||||
@ -681,11 +677,11 @@ CLEANRET:
|
||||
}
|
||||
|
||||
int radauth(struct clientparam * param){
|
||||
radius_packet_t packet;
|
||||
radius_packet_t ppacket;
|
||||
int len;
|
||||
/*radsend(param, 0, 0);*/
|
||||
len = radbuf(param, buf, 1, 0);
|
||||
return len?radsend(buf, len, 1):4;
|
||||
len = radbuf(param, (unsigned char *)&ppacket, 1, 0);
|
||||
return len?radsend((unsigned char *)&ppacket, len, 1, ¶m->sinsl):4;
|
||||
}
|
||||
|
||||
|
||||
@ -693,8 +689,8 @@ int raddobuf(struct clientparam * param, unsigned char * buf, const unsigned cha
|
||||
return radbuf(param, buf, 0, 1);
|
||||
}
|
||||
|
||||
void logradius(const unsigned char *buf, int len, LOGGER *logger){
|
||||
if(len)radsend(buf, len, 0);
|
||||
void logradius(const unsigned char *buf, int len, struct LOGGER *logger){
|
||||
if(len)radsend(buf, len, 0, NULL);
|
||||
}
|
||||
|
||||
|
||||
|
||||
68
src/common.c
68
src/common.c
@ -93,41 +93,45 @@ char *rotations[] = {
|
||||
|
||||
|
||||
struct extparam conf = {
|
||||
{1, 5, 30, 60, 180, 1800, 15, 60, 15, 5, 0, 0},
|
||||
NULL,
|
||||
NULL,
|
||||
NULL, NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
0,
|
||||
0, -1, 0, 0, 0, 0,
|
||||
0, 500, 0, 0, 0, 0,
|
||||
6, 600,
|
||||
1048576,
|
||||
NULL, NULL,
|
||||
NONE, NONE,
|
||||
NULL,
|
||||
{1, 5, 30, 60, 180, 1800, 15, 60, 15, 5, 0, 0}, /* int timeouts[12]; */
|
||||
NULL, /*struct ace * acl; */
|
||||
NULL, /* char * conffile; */
|
||||
NULL, NULL, /* struct bandlim * bandlimiter, *bandlimiterout; */
|
||||
NULL, /* struct connlim * connlimiter; */
|
||||
NULL, /* struct trafcount * trafcounter; */
|
||||
NULL, /* struct srvparam *services; */
|
||||
0, /* int stacksize, */
|
||||
0, -1, 0, 0, 0, 0, /* threadinit, counterd, haveerror, rotate, paused, archiverc, */
|
||||
0, 500, 0, 0, 0, 0, /* demon, maxchild, needreload, timetoexit, version, noforce; */
|
||||
6, 600, /* int authcachetype, authcachetime; */
|
||||
1048576, /* int filtermaxsize; */
|
||||
NULL, /* **archiver; */
|
||||
NONE, NONE, /* ROTATION logtype, countertype; */
|
||||
NULL, /* char * counterfile; */
|
||||
#ifndef NOIPV6
|
||||
{AF_INET},{AF_INET6},{AF_INET},
|
||||
{AF_INET},{AF_INET6},{AF_INET}, /* struct sockaddr_in6 intsa;
|
||||
struct sockaddr_in6 extsa6;
|
||||
struct sockaddr_in6 extsa; */
|
||||
|
||||
#else
|
||||
{AF_INET},{AF_INET},
|
||||
{AF_INET},{AF_INET}, /* struct sockaddr_in intsa;
|
||||
struct sockaddr_in extsa; */
|
||||
|
||||
#endif
|
||||
NULL,
|
||||
NULL,
|
||||
doconnect,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL, NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
(time_t)0, (time_t)0,
|
||||
0,0,
|
||||
'@',
|
||||
NULL, /* struct passwords *pwl; */
|
||||
NULL, /* struct auth * authenticate; */
|
||||
doconnect, /* AUTHFUNC authfunc; */
|
||||
NULL, /* BANDLIMFUNC bandlimfunc; */
|
||||
NULL, /* TRAFCOUNTFUNC trafcountfunc; */
|
||||
NULL, NULL, /* unsigned char *logtarget, *logformat; */
|
||||
NULL, /* struct filemon * fmon; */
|
||||
NULL, /* struct filter * filters; */
|
||||
NULL, /* struct auth *authfuncs; */
|
||||
NULL, /* char* demanddialprog; */
|
||||
NULL, /* unsigned char **stringtable; */
|
||||
(time_t)0, /* time_t time; */
|
||||
0,0, /* unsigned logdumpsrv, logdumpcli; */
|
||||
'@', /* char delimchar; */
|
||||
};
|
||||
|
||||
int numservers=0;
|
||||
|
||||
119
src/conf.c
119
src/conf.c
@ -101,49 +101,6 @@ int getrotate(char c){
|
||||
}
|
||||
|
||||
|
||||
unsigned char * dologname (unsigned char *buf, unsigned char *name, const unsigned char *ext, ROTATION lt, time_t t) {
|
||||
struct tm *ts;
|
||||
|
||||
ts = localtime(&t);
|
||||
if(strchr((char *)name, '%')){
|
||||
struct clientparam fakecli;
|
||||
|
||||
memset(&fakecli, 0, sizeof(fakecli));
|
||||
dobuf2(&fakecli, buf, NULL, NULL, ts, (char *)name);
|
||||
}
|
||||
else switch(lt){
|
||||
case NONE:
|
||||
sprintf((char *)buf, "%s", name);
|
||||
break;
|
||||
case ANNUALLY:
|
||||
sprintf((char *)buf, "%s.%04d", name, ts->tm_year+1900);
|
||||
break;
|
||||
case MONTHLY:
|
||||
sprintf((char *)buf, "%s.%04d.%02d", name, ts->tm_year+1900, ts->tm_mon+1);
|
||||
break;
|
||||
case WEEKLY:
|
||||
t = t - (ts->tm_wday * (60*60*24));
|
||||
ts = localtime(&t);
|
||||
sprintf((char *)buf, "%s.%04d.%02d.%02d", name, ts->tm_year+1900, ts->tm_mon+1, ts->tm_mday);
|
||||
break;
|
||||
case DAILY:
|
||||
sprintf((char *)buf, "%s.%04d.%02d.%02d", name, ts->tm_year+1900, ts->tm_mon+1, ts->tm_mday);
|
||||
break;
|
||||
case HOURLY:
|
||||
sprintf((char *)buf, "%s.%04d.%02d.%02d-%02d", name, ts->tm_year+1900, ts->tm_mon+1, ts->tm_mday, ts->tm_hour);
|
||||
break;
|
||||
case MINUTELY:
|
||||
sprintf((char *)buf, "%s.%04d.%02d.%02d-%02d.%02d", name, ts->tm_year+1900, ts->tm_mon+1, ts->tm_mday, ts->tm_hour, ts->tm_min);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
if(ext){
|
||||
strcat((char *)buf, ".");
|
||||
strcat((char *)buf, (char *)ext);
|
||||
}
|
||||
return buf;
|
||||
}
|
||||
|
||||
int start_proxy_thread(struct child * chp){
|
||||
pthread_t thread;
|
||||
@ -281,65 +238,12 @@ static int h_external(int argc, unsigned char ** argv){
|
||||
|
||||
|
||||
static int h_log(int argc, unsigned char ** argv){
|
||||
unsigned char tmpbuf[8192];
|
||||
int notchanged = 0;
|
||||
|
||||
|
||||
havelog = 1;
|
||||
if(argc > 1 && conf.logtarget && !strcmp((char *)conf.logtarget, (char *)argv[1])) {
|
||||
notchanged = 1;
|
||||
}
|
||||
if(!notchanged && conf.logtarget){
|
||||
myfree(conf.logtarget);
|
||||
conf.logtarget = NULL;
|
||||
}
|
||||
if(argc > 1) {
|
||||
if(!strcmp((char *) argv[1], "/dev/null")) {
|
||||
conf.logfunc = NULL;
|
||||
return 0;
|
||||
}
|
||||
if(!notchanged) conf.logtarget = (unsigned char *)mystrdup((char *)argv[1]);
|
||||
if(*argv[1]=='@'){
|
||||
#ifndef _WIN32
|
||||
conf.logfunc = logsyslog;
|
||||
if(notchanged) return 0;
|
||||
openlog((char *)conf.logtarget+1, LOG_PID, LOG_DAEMON);
|
||||
#endif
|
||||
}
|
||||
#ifndef NOODBC
|
||||
else if(*argv[1]=='&'){
|
||||
if(notchanged) return 0;
|
||||
conf.logfunc = logsql;
|
||||
pthread_mutex_lock(&log_mutex);
|
||||
close_sql();
|
||||
init_sql((char *)argv[1]+1);
|
||||
pthread_mutex_unlock(&log_mutex);
|
||||
}
|
||||
#endif
|
||||
#ifndef NORADIUS
|
||||
else if(!strcmp(argv[1],"radius")){
|
||||
conf.logfunc = logradius;
|
||||
}
|
||||
#endif
|
||||
else {
|
||||
if(argc < 2) conf.logtarget = (unsigned char *)mystrdup("");
|
||||
else conf.logtarget = (unsigned char *)mystrdup((char *)argv[1]);
|
||||
if(argc > 2) {
|
||||
conf.logtype = getrotate(*argv[2]);
|
||||
}
|
||||
conf.logfunc = logstdout;
|
||||
if(notchanged) return 0;
|
||||
conf.logtime = time(0);
|
||||
if(conf.logname)myfree(conf.logname);
|
||||
conf.logname = (unsigned char *)mystrdup((char *)argv[1]);
|
||||
if(conf.stdlog) conf.stdlog = freopen((char *)dologname (tmpbuf, conf.logname, NULL, conf.logtype, conf.logtime), "a", conf.stdlog);
|
||||
else conf.stdlog = fopen((char *)dologname (tmpbuf, conf.logname, NULL, conf.logtype, conf.logtime), "a");
|
||||
if(!conf.stdlog){
|
||||
perror((char *)tmpbuf);
|
||||
return 1;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
else conf.logfunc = logstdout;
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -1745,7 +1649,7 @@ void freeconf(struct extparam *confp){
|
||||
struct ace *acl;
|
||||
struct filemon *fm;
|
||||
int counterd, archiverc;
|
||||
unsigned char *logname, *logtarget;
|
||||
unsigned char *logtarget;
|
||||
unsigned char **archiver;
|
||||
unsigned char * logformat;
|
||||
|
||||
@ -1781,18 +1685,13 @@ void freeconf(struct extparam *confp){
|
||||
pthread_mutex_unlock(&pwl_mutex);
|
||||
|
||||
|
||||
/*
|
||||
logtarget = confp->logtarget;
|
||||
confp->logtarget = NULL;
|
||||
logname = confp->logname;
|
||||
confp->logname = NULL;
|
||||
*/
|
||||
confp->logfunc = NULL;
|
||||
logformat = confp->logformat;
|
||||
confp->logformat = NULL;
|
||||
confp->rotate = 0;
|
||||
confp->logtype = NONE;
|
||||
confp->logtime = confp->time = 0;
|
||||
confp->time = 0;
|
||||
|
||||
archiverc = confp->archiverc;
|
||||
confp->archiverc = 0;
|
||||
@ -1840,22 +1739,12 @@ void freeconf(struct extparam *confp){
|
||||
for(; fm; fm = (struct filemon *)itfree(fm, fm->next)){
|
||||
if(fm->path) myfree(fm->path);
|
||||
}
|
||||
/*
|
||||
if(logtarget) {
|
||||
myfree(logtarget);
|
||||
}
|
||||
if(logname) {
|
||||
myfree(logname);
|
||||
}
|
||||
*/
|
||||
if(logformat) {
|
||||
myfree(logformat);
|
||||
}
|
||||
if(archiver) {
|
||||
for(i = 0; i < archiverc; i++) myfree(archiver[i]);
|
||||
myfree(archiver);
|
||||
}
|
||||
havelog = 0;
|
||||
}
|
||||
|
||||
int reload (void){
|
||||
|
||||
@ -9,7 +9,7 @@
|
||||
|
||||
static void pr_unsigned64(struct node *node, CBFUNC cbf, void*cb){
|
||||
char buf[32];
|
||||
if(node->value)(*cbf)(cb, buf, sprintf(buf, "%"PRINTF_INT64_MODIFIER"u", *(uint64_t *)node->value));
|
||||
if(node->value)(*cbf)(cb, buf, sprintf(buf, "%"PRIu64, *(uint64_t *)node->value));
|
||||
}
|
||||
|
||||
static void pr_integer(struct node *node, CBFUNC cbf, void*cb){
|
||||
@ -523,19 +523,8 @@ static void * ef_server_childcount(struct node * node){
|
||||
}
|
||||
|
||||
static void * ef_server_log(struct node * node){
|
||||
if(((struct srvparam *)node->value) -> logfunc == NULL) return "none";
|
||||
#ifndef NORADIUS
|
||||
else if(((struct srvparam *)node->value) -> logfunc == logradius) return "radius";
|
||||
#endif
|
||||
else if(((struct srvparam *)node->value) -> logfunc == logstdout)
|
||||
return (((struct srvparam *)node->value) -> logtarget)?"file":"stdout";
|
||||
#ifndef _WIN32
|
||||
else if(((struct srvparam *)node->value) -> logfunc == logsyslog) return "syslog";
|
||||
#endif
|
||||
#ifndef NOODBC
|
||||
else if(((struct srvparam *)node->value) -> logfunc == logsql) return "odbc";
|
||||
#endif
|
||||
return NULL;
|
||||
if(((struct srvparam *)node->value) -> log == NULL) return "none";
|
||||
return ((struct srvparam *)node->value) -> log -> selector;
|
||||
}
|
||||
|
||||
static void * ef_server_logformat(struct node * node){
|
||||
@ -551,11 +540,6 @@ static void * ef_server_replacement(struct node * node){
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void * ef_server_logtarget(struct node * node){
|
||||
return ((struct srvparam *)node->value) -> logtarget;
|
||||
}
|
||||
|
||||
|
||||
static void * ef_server_target(struct node * node){
|
||||
return ((struct srvparam *)node->value) -> target;
|
||||
}
|
||||
@ -763,18 +747,17 @@ static struct property prop_server[] = {
|
||||
{prop_server + 7, "singlepacket", ef_server_singlepacket, TYPE_INTEGER, "is single packet redirection"},
|
||||
{prop_server + 8, "usentlm", ef_server_usentlm, TYPE_INTEGER, "allow NTLM authentication"},
|
||||
{prop_server + 9, "log", ef_server_log, TYPE_STRING, "type of logging"},
|
||||
{prop_server + 10, "logtarget", ef_server_logtarget, TYPE_STRING, "log target options"},
|
||||
{prop_server + 11, "logformat", ef_server_logformat, TYPE_STRING, "logging format string"},
|
||||
{prop_server + 12, "nonprintable", ef_server_nonprintable, TYPE_STRING, "non printable characters"},
|
||||
{prop_server + 13, "replacement", ef_server_replacement, TYPE_CHAR, "replacement character"},
|
||||
{prop_server + 14, "childcount", ef_server_childcount, TYPE_INTEGER, "number of servers connected"},
|
||||
{prop_server + 15, "intsa", ef_server_intsa, TYPE_SA, "ip address of internal interface"},
|
||||
{prop_server + 16, "extsa", ef_server_extsa, TYPE_SA, "ip address of external interface"},
|
||||
{prop_server + 10, "logformat", ef_server_logformat, TYPE_STRING, "logging format string"},
|
||||
{prop_server + 11, "nonprintable", ef_server_nonprintable, TYPE_STRING, "non printable characters"},
|
||||
{prop_server + 12, "replacement", ef_server_replacement, TYPE_CHAR, "replacement character"},
|
||||
{prop_server + 13, "childcount", ef_server_childcount, TYPE_INTEGER, "number of servers connected"},
|
||||
{prop_server + 14, "intsa", ef_server_intsa, TYPE_SA, "ip address of internal interface"},
|
||||
{prop_server + 15, "extsa", ef_server_extsa, TYPE_SA, "ip address of external interface"},
|
||||
#ifndef NOIPV6
|
||||
{prop_server + 17, "extsa6", ef_server_extsa6, TYPE_SA, "ipv6 address of external interface"},
|
||||
{prop_server + 18, "child", ef_server_child, TYPE_CLIENT, "connected clients"},
|
||||
#else
|
||||
{prop_server + 16, "extsa6", ef_server_extsa6, TYPE_SA, "ipv6 address of external interface"},
|
||||
{prop_server + 17, "child", ef_server_child, TYPE_CLIENT, "connected clients"},
|
||||
#else
|
||||
{prop_server + 16, "child", ef_server_child, TYPE_CLIENT, "connected clients"},
|
||||
#endif
|
||||
{NULL, "next", ef_server_next, TYPE_SERVER, "next"}
|
||||
};
|
||||
|
||||
289
src/log.c
289
src/log.c
@ -8,7 +8,25 @@
|
||||
|
||||
#include "proxy.h"
|
||||
pthread_mutex_t log_mutex;
|
||||
int havelog = 0;
|
||||
/*
|
||||
#ifdef _WIN32
|
||||
HANDLE log_sem;
|
||||
#else
|
||||
sem_t log_sem;
|
||||
#endif
|
||||
*/
|
||||
#define MAXLOG 64
|
||||
#define MAXLOGGERS 64
|
||||
#define LOGBUFSIZE 4096
|
||||
|
||||
struct logqueue {
|
||||
int event;
|
||||
int inbuf;
|
||||
char buf[LOGBUFSIZE];
|
||||
} logq[MAXLOG];
|
||||
|
||||
int loghead=0;
|
||||
int logtail=0;
|
||||
|
||||
|
||||
struct clientparam logparam;
|
||||
@ -27,12 +45,14 @@ void logradius(const char * buf, int len, struct LOGGER *logger);
|
||||
#define HAVERADIUS 1
|
||||
|
||||
#ifndef NOODBC
|
||||
#undef HAVESQL
|
||||
#define HAVESQL 1
|
||||
static int sqlinit(const char * selector, int logtype, struct LOGGER *logger);
|
||||
static int sqlinit(struct LOGGER *logger);
|
||||
static int sqldobuf(struct clientparam * param, unsigned char * buf, const unsigned char *s);
|
||||
static void sqllog(const char * buf, int len, struct LOGGER *logger);
|
||||
static void sqlrotate(struct LOGGER *logger);
|
||||
static void sqlclose(struct LOGGER *logger);
|
||||
#else
|
||||
#define HAVESQL 0
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -40,53 +60,121 @@ static void sqlclose(struct LOGGER *logger);
|
||||
#define HAVESYSLOG 0
|
||||
#else
|
||||
#define HAVESYSLOG 1
|
||||
static int sysloginit(const char * selector, int logtype, struct LOGGER *logger);
|
||||
static int sysloginit(struct LOGGER *logger);
|
||||
static void logsyslog(const char * buf, int len, struct LOGGER *logger);
|
||||
static void syslogrotate(struct LOGGER *logger);
|
||||
static void syslogclose(struct LOGGER *logger);
|
||||
#endif
|
||||
|
||||
static int stdloginit(const char * selector, int logtype, struct LOGGER *logger);
|
||||
static int stdloginit(struct LOGGER *logger);
|
||||
int stddobuf(struct clientparam * param, unsigned char * buf, const unsigned char *s);
|
||||
static void stdlog(const char * buf, int len, struct LOGGER *logger);
|
||||
static void stdlogrotate(struct LOGGER *logger);
|
||||
static void stdlogclose(struct LOGGER *logger);
|
||||
|
||||
|
||||
|
||||
struct LOGFUNC logfuncs = {
|
||||
struct LOGFUNC stdlogfuncs[] = {
|
||||
#if HAVESYSLOG > 0
|
||||
{logfuncs+1+HAVESYSLOG, sysloginit, stddobuf, logsyslog, syslogrotate, syslogclose, "@"},
|
||||
{stdlogfuncs+1, sysloginit, stddobuf, logsyslog, syslogrotate, syslogclose, "@"},
|
||||
#endif
|
||||
#if HAVERADIUS > 0
|
||||
{logfuncs+1+HAVESYSLOG+HAVERADIUS, NULL, raddobuf, logradius, NULL, NULL, "radius"},
|
||||
{stdlogfuncs+1+HAVESYSLOG, NULL, raddobuf, logradius, NULL, NULL, "radius"},
|
||||
#endif
|
||||
#if HAVESQL > 0
|
||||
{logfuncs+1+HAVESYSLOG+HAVERADIUS+HAVESQL, sqlinit, sqldobuf, sqllog, sqlrotate, sqlclose, "&"},
|
||||
{stdlogfuncs+1+HAVESYSLOG+HAVERADIUS, sqlinit, sqldobuf, sqllog, sqlrotate, sqlclose, "&"},
|
||||
#endif
|
||||
{NULL, stdloginit, stddobuf, stdlog, stdlogrotate, stdlogclose, ""}
|
||||
};
|
||||
|
||||
|
||||
|
||||
struct LOGGER *loggers = NULL;
|
||||
struct LOGFUNC *logfuncs = stdlogfuncs;
|
||||
|
||||
struct stdlogdata{
|
||||
FILE *fp;
|
||||
} errld= {stderr};
|
||||
} errld;
|
||||
|
||||
struct LOGGER {
|
||||
char * selector;
|
||||
void * data;
|
||||
struct LOGFUNC *logfunc;
|
||||
int rotate;
|
||||
time_t rotated;
|
||||
int registered;
|
||||
} errlogger = {"errlogger", &errld, logfuncs+1+HAVESYSLOG+HAVERADIUS+HAVESQL, 0, 0, 1};
|
||||
struct LOGGER errlogger = {NULL, "stderr", &errld, stdlogfuncs+1+HAVESYSLOG+HAVERADIUS+HAVESQL, 0, 0, 1};
|
||||
|
||||
struct LOGGER *loggers = &errlogger;
|
||||
|
||||
struct LOGGER * registerlog(const char * logstring, int logtype){
|
||||
struct LOGGER *log;
|
||||
struct LOGFUNC *funcs;
|
||||
|
||||
if(!logstring || !strcmp(logstring, "NUL") || !strcmp(logstring, "/dev/null")) return NULL;
|
||||
for(log = loggers; log; log=log->next){
|
||||
if(!strcmp(logstring, log->selector)){
|
||||
if(logtype >= 0) log->rotate = logtype;
|
||||
log->registered++;
|
||||
return log;
|
||||
}
|
||||
}
|
||||
log = malloc(sizeof(struct LOGGER));
|
||||
if(!log) return NULL;
|
||||
memset (log, 0, sizeof(struct LOGGER));
|
||||
log->selector = mystrdup(logstring);
|
||||
if(log->selector){
|
||||
if(logtype)log->rotate = logtype;
|
||||
for(funcs = logfuncs; funcs; funcs=funcs->next){
|
||||
if(!strncmp(logstring, funcs->prefix, strlen(funcs->prefix))){
|
||||
if(funcs->init && funcs->init(log)) break;
|
||||
log->registered++;
|
||||
return log;
|
||||
}
|
||||
}
|
||||
myfree(log->selector);
|
||||
}
|
||||
myfree(log);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void unregisterlog (struct LOGGER * log){
|
||||
if(log)log->registered--;
|
||||
}
|
||||
|
||||
#ifdef _WIN32
|
||||
DWORD WINAPI logthreadfunc(LPVOID p) {
|
||||
#else
|
||||
void * logthreadfunc (void *p) {
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
void initlog(void){
|
||||
pthread_t thread;
|
||||
|
||||
srvinit(&logsrv, &logparam);
|
||||
pthread_mutex_init(&log_mutex, NULL);
|
||||
errld.fp = stdout;
|
||||
/*
|
||||
#ifdef _WIN32
|
||||
{
|
||||
HANDLE h;
|
||||
log_sem = CreateSemaphore(NULL, 0, MAX_SEM_COUNT, NULL);
|
||||
sem_init(&log_sem, 0, 0);
|
||||
#ifndef _WINCE
|
||||
h = (HANDLE)_beginthreadex((LPSECURITY_ATTRIBUTES )NULL, 65536, (void *)logthreadfunc, NULL, 0, &thread);
|
||||
#else
|
||||
h = (HANDLE)CreateThread((LPSECURITY_ATTRIBUTES )NULL, 65536, (void *)logthreadfunc, NULL, 0, &thread);
|
||||
#endif
|
||||
if (h) {
|
||||
CloseHandle(h);
|
||||
}
|
||||
else {
|
||||
exit(10);
|
||||
}
|
||||
}
|
||||
#else
|
||||
{
|
||||
pthread_attr_t pa;
|
||||
pthread_attr_init(&pa);
|
||||
pthread_attr_setstacksize(&pa,PTHREAD_STACK_MIN + 1024*256);
|
||||
pthread_attr_setdetachstate(&pa,PTHREAD_CREATE_DETACHED);
|
||||
|
||||
if(pthread_create(&thread, &pa, logthreadfunc, (void *)newparam)) exit(10);
|
||||
}
|
||||
#endif
|
||||
*/
|
||||
}
|
||||
|
||||
void dolog(struct clientparam * param, const unsigned char *s){
|
||||
@ -94,12 +182,26 @@ void dolog(struct clientparam * param, const unsigned char *s){
|
||||
|
||||
/* TODO: dobuf */
|
||||
/* TODO: spooling */
|
||||
if(!param){
|
||||
stdlog(s, strlen(s), &stdlogger);
|
||||
if(!param || !param->srv){
|
||||
stdlog(s, strlen(s), &errlogger);
|
||||
}
|
||||
else if(!param->nolog && param->srv->logtarget){
|
||||
if(prelog)prelog(param);
|
||||
param->srv->logfunc(param, s);
|
||||
if(param->srv->log && param->srv->log->logfunc && param->srv->log->logfunc->log){
|
||||
char buf[LOGBUFSIZE];
|
||||
int inbuf = 0;
|
||||
|
||||
|
||||
/*
|
||||
int (*dobuf)(struct clientparam * param, unsigned char * buf, const unsigned char *s);
|
||||
int (*log)(const char * buf, int len, struct LOGGER *logger);
|
||||
*/
|
||||
if(param->srv->log->logfunc->dobuf){
|
||||
param->srv->log->logfunc->dobuf(param, buf, s);
|
||||
}
|
||||
|
||||
param->srv->log->logfunc->log(buf, inbuf, param->srv->log);
|
||||
}
|
||||
}
|
||||
if(param->trafcountfunc)(*param->trafcountfunc)(param);
|
||||
clearstat(param);
|
||||
@ -133,6 +235,49 @@ char months[12][4] = {
|
||||
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
|
||||
};
|
||||
|
||||
unsigned char * dologname (unsigned char *buf, unsigned char *name, const unsigned char *ext, ROTATION lt, time_t t) {
|
||||
struct tm *ts;
|
||||
|
||||
ts = localtime(&t);
|
||||
if(strchr((char *)name, '%')){
|
||||
struct clientparam fakecli;
|
||||
|
||||
memset(&fakecli, 0, sizeof(fakecli));
|
||||
dobuf2(&fakecli, buf, NULL, NULL, ts, (char *)name);
|
||||
}
|
||||
else switch(lt){
|
||||
case NONE:
|
||||
sprintf((char *)buf, "%s", name);
|
||||
break;
|
||||
case ANNUALLY:
|
||||
sprintf((char *)buf, "%s.%04d", name, ts->tm_year+1900);
|
||||
break;
|
||||
case MONTHLY:
|
||||
sprintf((char *)buf, "%s.%04d.%02d", name, ts->tm_year+1900, ts->tm_mon+1);
|
||||
break;
|
||||
case WEEKLY:
|
||||
t = t - (ts->tm_wday * (60*60*24));
|
||||
ts = localtime(&t);
|
||||
sprintf((char *)buf, "%s.%04d.%02d.%02d", name, ts->tm_year+1900, ts->tm_mon+1, ts->tm_mday);
|
||||
break;
|
||||
case DAILY:
|
||||
sprintf((char *)buf, "%s.%04d.%02d.%02d", name, ts->tm_year+1900, ts->tm_mon+1, ts->tm_mday);
|
||||
break;
|
||||
case HOURLY:
|
||||
sprintf((char *)buf, "%s.%04d.%02d.%02d-%02d", name, ts->tm_year+1900, ts->tm_mon+1, ts->tm_mday, ts->tm_hour);
|
||||
break;
|
||||
case MINUTELY:
|
||||
sprintf((char *)buf, "%s.%04d.%02d.%02d-%02d.%02d", name, ts->tm_year+1900, ts->tm_mon+1, ts->tm_mday, ts->tm_hour, ts->tm_min);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
if(ext){
|
||||
strcat((char *)buf, ".");
|
||||
strcat((char *)buf, (char *)ext);
|
||||
}
|
||||
return buf;
|
||||
}
|
||||
|
||||
int dobuf2(struct clientparam * param, unsigned char * buf, const unsigned char *s, const unsigned char * doublec, struct tm* tm, char * format){
|
||||
int i, j;
|
||||
@ -169,7 +314,7 @@ int dobuf2(struct clientparam * param, unsigned char * buf, const unsigned char
|
||||
|
||||
delay = param->time_start?((unsigned) ((sec - param->time_start))*1000 + msec) - param->msec_start : 0;
|
||||
*buf = 0;
|
||||
for(i=0, j=0; format[j] && i < 4040; j++){
|
||||
for(i=0, j=0; format[j] && i < (LOGBUFSIZE-70); j++){
|
||||
if(format[j] == '%' && format[j+1]){
|
||||
j++;
|
||||
switch(format[j]){
|
||||
@ -231,7 +376,7 @@ int dobuf2(struct clientparam * param, unsigned char * buf, const unsigned char
|
||||
break;
|
||||
case 'U':
|
||||
if(param->username && *param->username){
|
||||
for(len = 0; i< 4000 && param->username[len]; len++){
|
||||
for(len = 0; i< (LOGBUFSIZE - 3) && param->username[len]; len++){
|
||||
buf[i] = param->username[len];
|
||||
if(param->srv->nonprintable && (buf[i] < 0x20 || strchr((char *)param->srv->nonprintable, buf[i]))) buf[i] = param->srv->replace;
|
||||
if(doublec && strchr((char *)doublec, buf[i])) {
|
||||
@ -247,7 +392,7 @@ int dobuf2(struct clientparam * param, unsigned char * buf, const unsigned char
|
||||
break;
|
||||
case 'n':
|
||||
len = param->hostname? (int)strlen((char *)param->hostname) : 0;
|
||||
if (len > 0 && !strchr((char *)param->hostname, ':')) for(len = 0; param->hostname[len] && i < 256; len++, i++){
|
||||
if (len > 0 && !strchr((char *)param->hostname, ':')) for(len = 0; param->hostname[len] && i < (LOGBUFSIZE-3); len++, i++){
|
||||
buf[i] = param->hostname[len];
|
||||
if(param->srv->nonprintable && (buf[i] < 0x20 || strchr((char *)param->srv->nonprintable, buf[i]))) buf[i] = param->srv->replace;
|
||||
if(doublec && strchr((char *)doublec, buf[i])) {
|
||||
@ -276,7 +421,7 @@ int dobuf2(struct clientparam * param, unsigned char * buf, const unsigned char
|
||||
break;
|
||||
case 'T':
|
||||
if(s){
|
||||
for(len = 0; i<4000 && s[len]; len++){
|
||||
for(len = 0; i < (LOGBUFSIZE-3) && s[len]; len++){
|
||||
buf[i] = s[len];
|
||||
if(param->srv->nonprintable && (buf[i] < 0x20 || strchr((char *)param->srv->nonprintable, buf[i]))) buf[i] = param->srv->replace;
|
||||
if(doublec && strchr((char *)doublec, buf[i])) {
|
||||
@ -319,15 +464,15 @@ int dobuf2(struct clientparam * param, unsigned char * buf, const unsigned char
|
||||
i += (int)strlen((char *)buf+i);
|
||||
break;
|
||||
case 'L':
|
||||
sprintf((char *)buf+i, "%"PRINTF_INT64_MODIFIER"u", param->cycles);
|
||||
sprintf((char *)buf+i, "%"PRIu64, param->cycles);
|
||||
i += (int)strlen((char *)buf+i);
|
||||
break;
|
||||
case 'I':
|
||||
sprintf((char *)buf+i, "%"PRINTF_INT64_MODIFIER"u", param->statssrv64);
|
||||
sprintf((char *)buf+i, "%"PRIu64, param->statssrv64);
|
||||
i += (int)strlen((char *)buf+i);
|
||||
break;
|
||||
case 'O':
|
||||
sprintf((char *)buf+i, "%"PRINTF_INT64_MODIFIER"u", param->statscli64);
|
||||
sprintf((char *)buf+i, "%"PRIu64, param->statscli64);
|
||||
i += (int)strlen((char *)buf+i);
|
||||
break;
|
||||
case 'h':
|
||||
@ -354,13 +499,13 @@ int dobuf2(struct clientparam * param, unsigned char * buf, const unsigned char
|
||||
j = k;
|
||||
}
|
||||
if(!s || format[k]!='T') break;
|
||||
for(k = 0, len = 0; s[len] && i < 4000; len++){
|
||||
for(k = 0, len = 0; s[len]; len++){
|
||||
if(isspace(s[len])){
|
||||
k++;
|
||||
while(isspace(s[len+1]))len++;
|
||||
if(k == pmin) continue;
|
||||
}
|
||||
if(k>=pmin && k<=pmax) {
|
||||
if(k>=pmin && k<=pmax && i < (LOGBUFSIZE-3)) {
|
||||
buf[i] = s[len];
|
||||
if(param->srv->nonprintable && (buf[i] < 0x20 || strchr((char *)param->srv->nonprintable, buf[i]))) buf[i] = param->srv->replace;
|
||||
if(doublec && strchr((char *)doublec, buf[i])) {
|
||||
@ -399,19 +544,22 @@ int dobuf(struct clientparam * param, unsigned char * buf, const unsigned char *
|
||||
}
|
||||
|
||||
|
||||
static int stdloginit(const char * selector, int logtype, struct LOGGER *logger){
|
||||
char tmpuf[1024];
|
||||
static int stdloginit(struct LOGGER *logger){
|
||||
char tmpbuf[1024];
|
||||
struct stdlogdata *lp;
|
||||
lp = myalloc(sizeof(struct stdlogdata));
|
||||
if(!lp) return 1;
|
||||
logger->data = lp;
|
||||
if(!selector || !*selector){
|
||||
logger-rotate = NONE;
|
||||
if(!*logger->selector || !strstr(logger->selector, "stdout")){
|
||||
logger->rotate = NONE;
|
||||
lp->fp = stdout;
|
||||
}
|
||||
else if(!strcmp(logger->selector,"stderr")){
|
||||
logger->rotate = NONE;
|
||||
lp->fp = stderr;
|
||||
}
|
||||
else {
|
||||
logger->rotate = logtype;
|
||||
lp->fp = fopen((char *)dologname (tmpbuf, conf.logname, NULL, logtype, time(NULL)), "a");
|
||||
lp->fp = fopen((char *)dologname (tmpbuf, logger->selector, NULL, logger->rotate, time(NULL)), "a");
|
||||
if(!lp->fp){
|
||||
myfree(lp);
|
||||
return(2);
|
||||
@ -420,23 +568,23 @@ static int stdloginit(const char * selector, int logtype, struct LOGGER *logger)
|
||||
return 0;
|
||||
}
|
||||
|
||||
int stddobuf(struct clientparam * param, unsigned char * buf, const unsigned char *s){
|
||||
static int stddobuf(struct clientparam * param, unsigned char * buf, const unsigned char *s){
|
||||
return dobuf(param, buf, s, NULL);
|
||||
}
|
||||
|
||||
void stdlog(struct clientparam * param, const unsigned char *s, struct LOGGER *logger) {
|
||||
FILE *log = (struct stdlogdata *)logger->data;
|
||||
static void stdlog(const char * buf, int len, struct LOGGER *logger) {
|
||||
FILE *log = ((struct stdlogdata *)logger->data)->fp;
|
||||
|
||||
fprintf(log, "%s\n", buf);
|
||||
if(log == stdout || log == stderr)fflush(log);
|
||||
}
|
||||
|
||||
static void stdlogrotate(struct LOGGER *logger){
|
||||
char tmpuf[1024];
|
||||
struct stdlogdata *lp = (struct stdlogdata)logger->data;
|
||||
char tmpbuf[1024];
|
||||
struct stdlogdata *lp = (struct stdlogdata *)logger->data;
|
||||
if(lp->fp) lp->fp = freopen((char *)dologname (tmpbuf, logger->selector, NULL, logger->rotate, conf.time), "a", lp->fp);
|
||||
else lp->fp = fopen((char *)dologname (tmpbuf, logger->selector, NULL, logger->rotate, conf.time), "a");
|
||||
conf.logtime = conf.time;
|
||||
logger->rotated = conf.time;
|
||||
if(logger->rotate) {
|
||||
int t;
|
||||
t = 1;
|
||||
@ -456,7 +604,7 @@ static void stdlogrotate(struct LOGGER *logger){
|
||||
default:
|
||||
break;
|
||||
}
|
||||
dologname (tmpbuf, logger->selector, (conf.archiver)?conf.archiver[1]:NULL, logger->rotate, (conf.logtime - t * conf.rotate));
|
||||
dologname (tmpbuf, logger->selector, (conf.archiver)?conf.archiver[1]:NULL, logger->rotate, (logger->rotated - t * conf.rotate));
|
||||
remove ((char *) tmpbuf);
|
||||
if(conf.archiver) {
|
||||
int i;
|
||||
@ -465,12 +613,12 @@ static void stdlogrotate(struct LOGGER *logger){
|
||||
strcat((char *)tmpbuf, " ");
|
||||
if(!strcmp((char *)conf.archiver[i], "%A")){
|
||||
strcat((char *)tmpbuf, "\"");
|
||||
dologname (tmpbuf + strlen((char *)tmpbuf), logger->selector, conf.archiver[1], logger->rotate, (conf.logtime - t));
|
||||
dologname (tmpbuf + strlen((char *)tmpbuf), logger->selector, conf.archiver[1], logger->rotate, (logger->rotated - t));
|
||||
strcat((char *)tmpbuf, "\"");
|
||||
}
|
||||
else if(!strcmp((char *)conf.archiver[i], "%F")){
|
||||
strcat((char *)tmpbuf, "\"");
|
||||
dologname (tmpbuf+strlen((char *)tmpbuf), logger->selector, NULL, logger->rotate, (conf.logtime-t));
|
||||
dologname (tmpbuf+strlen((char *)tmpbuf), logger->selector, NULL, logger->rotate, (logger->rotated-t));
|
||||
strcat((char *)tmpbuf, "\"");
|
||||
}
|
||||
else
|
||||
@ -488,10 +636,9 @@ static void stdlogclose(struct LOGGER *logger){
|
||||
|
||||
#if HAVESYSLOG > 0
|
||||
|
||||
static int sysloginit(const char * selector, int logtype, struct LOGGER *logger){
|
||||
openlog(selector+1, LOG_PID, LOG_DAEMON);
|
||||
logger->rotate = logtype;
|
||||
logger->data = NULL;
|
||||
static int sysloginit(struct LOGGER *logger){
|
||||
openlog(logger->selector, LOG_PID, LOG_DAEMON);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void logsyslog(const char * buf, int len, struct LOGGER *logger) {
|
||||
@ -523,12 +670,8 @@ struct sqldata {
|
||||
|
||||
|
||||
|
||||
static int sqlinit(const char * selector, int logtype, struct LOGGER *logger);
|
||||
static void sqllog(struct clientparam * param, const unsigned char *s, LOGGER *logger);
|
||||
static void sqlrotate(struct LOGGER *logger);
|
||||
|
||||
|
||||
int sqlinit2(struct sqldata * sd, char * source){
|
||||
static int sqlinit2(struct sqldata * sd, char * source){
|
||||
SQLRETURN retcode;
|
||||
char * datasource;
|
||||
char * username;
|
||||
@ -537,18 +680,18 @@ int sqlinit2(struct sqldata * sd, char * source){
|
||||
int ret = 0;
|
||||
|
||||
retcode = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &sd->henv);
|
||||
if (!henv || (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)){
|
||||
if (!sd->henv || (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)){
|
||||
return 1;
|
||||
}
|
||||
retcode = SQLSetEnvAttr(sd->henv, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0);
|
||||
if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO) {
|
||||
ret = 2;
|
||||
goto CLOSEENV:
|
||||
goto CLOSEENV;
|
||||
}
|
||||
retcode = SQLAllocHandle(SQL_HANDLE_DBC, henv, &sd->hdbc);
|
||||
retcode = SQLAllocHandle(SQL_HANDLE_DBC, sd->henv, &sd->hdbc);
|
||||
if (!sd->hdbc || (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)) {
|
||||
ret = 3;
|
||||
goto CLOSEENV:
|
||||
goto CLOSEENV;
|
||||
}
|
||||
SQLSetConnectAttr(sd->hdbc, SQL_LOGIN_TIMEOUT, (void*)15, 0);
|
||||
|
||||
@ -583,29 +726,29 @@ int sqlinit2(struct sqldata * sd, char * source){
|
||||
return 0;
|
||||
|
||||
CLOSEHDBC:
|
||||
SQLFreeHandle(SQL_HANDLE_DBC, hdbc);
|
||||
SQLFreeHandle(SQL_HANDLE_DBC, sd->hdbc);
|
||||
sd->hdbc = 0;
|
||||
CLOSEENV:
|
||||
SQLFreeHandle(SQL_HANDLE_ENV, henv);
|
||||
SQLFreeHandle(SQL_HANDLE_ENV, sd->henv);
|
||||
sd->henv = 0;
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int sqlinit(const char * selector, int logtype, struct LOGGER *logger){
|
||||
static int sqlinit(struct LOGGER *logger){
|
||||
struct sqldata *sd;
|
||||
int res
|
||||
int res;
|
||||
|
||||
logger->rotate = logtype;
|
||||
sd = (struct sqldata *)myalloc(sizeof(struct sqldata));
|
||||
memset(sd, 0, sizeof(struct sqldata));
|
||||
loger->data = sd;
|
||||
if(!(res = sqlinit2(sd, selector+1))) {
|
||||
logger->data = sd;
|
||||
if((res = sqlinit2(sd, logger->selector))) {
|
||||
myfree(sd);
|
||||
return res;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sqldobuf(struct clientparam * param, unsigned char * buf, const unsigned char *s){
|
||||
static int sqldobuf(struct clientparam * param, unsigned char * buf, const unsigned char *s){
|
||||
return dobuf(param, buf, s, (unsigned char *)"\'");
|
||||
}
|
||||
|
||||
@ -633,7 +776,7 @@ static void sqllog(const char * buf, int len, struct LOGGER *logger){
|
||||
if(ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO){
|
||||
sqlrotate(logger);
|
||||
if(sd->hstmt) {
|
||||
ret = SQLExecDirect(hstmt, (SQLCHAR *)buf, (SQLINTEGER)len);
|
||||
ret = SQLExecDirect(sd->hstmt, (SQLCHAR *)buf, (SQLINTEGER)len);
|
||||
if(ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO){
|
||||
sd->attempt++;
|
||||
sd->attempt_time=conf.time;
|
||||
@ -649,12 +792,12 @@ static void sqlrotate(struct LOGGER *logger){
|
||||
sqlclose(logger);
|
||||
sd = (struct sqldata *)myalloc(sizeof(struct sqldata));
|
||||
memset(sd, 0, sizeof(struct sqldata));
|
||||
loger->data = sd;
|
||||
sqlinit2(sd, logger->selector+1)
|
||||
logger->data = sd;
|
||||
sqlinit2(sd, logger->selector+1);
|
||||
}
|
||||
|
||||
static void sqlclose(struct LOGGER *logger){
|
||||
struct sqldata *sd = (struct sqldata *)loger->data;
|
||||
struct sqldata *sd = (struct sqldata *)logger->data;
|
||||
if(sd->hstmt) {
|
||||
SQLFreeHandle(SQL_HANDLE_STMT, sd->hstmt);
|
||||
sd->hstmt = NULL;
|
||||
|
||||
@ -73,11 +73,11 @@ struct symbol symbols[] = {
|
||||
{symbols+46, "decodeurl", (void *) decodeurl},
|
||||
{symbols+47, "parsestr", (void *) parsestr},
|
||||
{symbols+48, "make_ace", (void *) make_ace},
|
||||
{symbols+49, "freeacl", (void *) freeacl}
|
||||
{symbols+49, "freeacl", (void *) freeacl},
|
||||
{symbols+50, "checkpreACL", (void *) checkpreACL},
|
||||
{symbols+51, "dolog", (void *) dolog},
|
||||
{symbols+52, "logfuncs", (void *) logfuncs},
|
||||
{symbols+53, "prelog", (void *) prelog},
|
||||
{symbols+52, "logfuncs", (void *) &logfuncs},
|
||||
{symbols+53, "prelog", (void *) &prelog},
|
||||
{NULL, "", NULL}
|
||||
};
|
||||
|
||||
|
||||
12
src/proxy.c
12
src/proxy.c
@ -392,7 +392,7 @@ for(;;){
|
||||
while( (i = sockgetlinebuf(param, CLIENT, buf, BUFSIZE - 1, '\n', conf.timeouts[STRING_S])) > 2){
|
||||
if(i> 15 && (!strncasecmp((char *)(buf), "content-length", 14))){
|
||||
buf[i]=0;
|
||||
sscanf((char *)buf + 15, "%"PRINTF_INT64_MODIFIER"u", &contentlength64);
|
||||
sscanf((char *)buf + 15, "%"PRIu64, &contentlength64);
|
||||
}
|
||||
}
|
||||
while( contentlength64 > 0 && (i = sockgetlinebuf(param, CLIENT, buf, (BUFSIZE < contentlength64)? BUFSIZE - 1:(int)contentlength64, '\n', conf.timeouts[STRING_S])) > 0){
|
||||
@ -502,7 +502,7 @@ for(;;){
|
||||
if(!sb)continue;
|
||||
++sb;
|
||||
while(isspace(*sb))sb++;
|
||||
sscanf((char *)sb, "%"PRINTF_INT64_MODIFIER"u",&contentlength64);
|
||||
sscanf((char *)sb, "%"PRIu64,&contentlength64);
|
||||
if(param->maxtrafout64 && (param->maxtrafout64 < param->statscli64 || contentlength64 > param->maxtrafout64 - param->statscli64)){
|
||||
RETURN(10);
|
||||
}
|
||||
@ -549,7 +549,7 @@ for(;;){
|
||||
contentlength64 = param->cliinbuf;
|
||||
param->ndatfilterscli = 0;
|
||||
}
|
||||
sprintf((char*)buf+strlen((char *)buf), "Content-Length: %"PRINTF_INT64_MODIFIER"u\r\n", contentlength64);
|
||||
sprintf((char*)buf+strlen((char *)buf), "Content-Length: %"PRIu64"\r\n", contentlength64);
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -923,7 +923,7 @@ for(;;){
|
||||
if(!sb)continue;
|
||||
++sb;
|
||||
while(isspace(*sb))sb++;
|
||||
sscanf((char *)sb, "%"PRINTF_INT64_MODIFIER"u", &contentlength64);
|
||||
sscanf((char *)sb, "%"PRIu64, &contentlength64);
|
||||
hascontent = 1;
|
||||
if(param->unsafefilter && param->ndatfilterssrv > 0) {
|
||||
hascontent = 2;
|
||||
@ -996,7 +996,7 @@ for(;;){
|
||||
}
|
||||
if(action != PASS) RETURN(517);
|
||||
contentlength64 = param->srvinbuf;
|
||||
sprintf((char*)buf+strlen((char *)buf), "Content-Length: %"PRINTF_INT64_MODIFIER"u\r\n", contentlength64);
|
||||
sprintf((char*)buf+strlen((char *)buf), "Content-Length: %"PRIu64"\r\n", contentlength64);
|
||||
hascontent = 1;
|
||||
}
|
||||
}
|
||||
@ -1043,7 +1043,7 @@ for(;;){
|
||||
}
|
||||
smallbuf[i] = 0;
|
||||
contentlength64 = 0;
|
||||
sscanf((char *)smallbuf, "%"PRINTF_INT64_MODIFIER"x", &contentlength64);
|
||||
sscanf((char *)smallbuf, "%"SCNx64, &contentlength64);
|
||||
if(contentlength64 == 0) {
|
||||
param->chunked = 2;
|
||||
}
|
||||
|
||||
@ -54,6 +54,7 @@
|
||||
#include <sys/time.h>
|
||||
#include <unistd.h>
|
||||
#include <pthread.h>
|
||||
#include <semaphore.h>
|
||||
#include <syslog.h>
|
||||
#include <errno.h>
|
||||
#endif
|
||||
|
||||
@ -312,28 +312,8 @@ int MODULEMAINFUNC (int argc, char** argv){
|
||||
break;
|
||||
#endif
|
||||
case 'l':
|
||||
if(srv.logtarget) myfree(srv.logtarget);
|
||||
myfree(srv.logtarget);
|
||||
srv.logtarget = (unsigned char *)mystrdup(argv[i] + 2);
|
||||
if(argv[i][2]) {
|
||||
if(argv[i][2]=='@'){
|
||||
|
||||
#ifdef STDMAIN
|
||||
#ifndef _WIN32
|
||||
openlog(argv[i]+3, LOG_PID, LOG_DAEMON);
|
||||
srv.logfunc = logsyslog;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
}
|
||||
else {
|
||||
fp = fopen(argv[i] + 2, "a");
|
||||
if (fp) {
|
||||
srv.stdlog = fp;
|
||||
fseek(fp, 0L, SEEK_END);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
break;
|
||||
case 'i':
|
||||
getip46(46, (unsigned char *)argv[i]+2, (struct sockaddr *)&srv.intsa);
|
||||
@ -844,7 +824,7 @@ int MODULEMAINFUNC (int argc, char** argv){
|
||||
if(isudp) while(!srv.fds.events)usleep(SLEEPTIME);
|
||||
}
|
||||
|
||||
if(!srv.silent) srv.logfunc(&defparam, (unsigned char *)"Exiting thread");
|
||||
if(!srv.silent) dolog(&defparam, (unsigned char *)"Exiting thread");
|
||||
|
||||
srvfree(&srv);
|
||||
|
||||
@ -873,18 +853,16 @@ void srvinit(struct srvparam * srv, struct clientparam *param){
|
||||
memset(srv, 0, sizeof(struct srvparam));
|
||||
srv->version = conf.version + 1;
|
||||
srv->paused = conf.paused;
|
||||
srv->logfunc = havelog?conf.logfunc:NULL;
|
||||
srv->noforce = conf.noforce;
|
||||
srv->logformat = conf.logformat? (unsigned char *)mystrdup((char *)conf.logformat) : NULL;
|
||||
srv->logtarget = conf.logtarget? (unsigned char *)mystrdup((char *)conf.logtarget) : NULL;
|
||||
srv->authfunc = conf.authfunc;
|
||||
srv->usentlm = 0;
|
||||
srv->maxchild = conf.maxchild;
|
||||
srv->stacksize = conf.stacksize;
|
||||
srv->time_start = time(NULL);
|
||||
if(havelog && conf.logtarget){
|
||||
srv->logtarget = (unsigned char *)mystrdup((char *)conf.logtarget);
|
||||
}
|
||||
srv->srvsock = INVALID_SOCKET;
|
||||
srv->logtype = conf.logtype;
|
||||
srv->logdumpsrv = conf.logdumpsrv;
|
||||
srv->logdumpcli = conf.logdumpcli;
|
||||
srv->cbsock = INVALID_SOCKET;
|
||||
@ -920,6 +898,10 @@ void srvinit2(struct srvparam * srv, struct clientparam *param){
|
||||
myfree(logformat);
|
||||
}
|
||||
}
|
||||
if(srv->logtarget){
|
||||
srv->log = registerlog(srv->logtarget, srv->logtype);
|
||||
}
|
||||
|
||||
memset(¶m->sinsl, 0, sizeof(param->sinsl));
|
||||
memset(¶m->sinsr, 0, sizeof(param->sinsr));
|
||||
memset(¶m->req, 0, sizeof(param->req));
|
||||
@ -941,6 +923,7 @@ void srvfree(struct srvparam * srv){
|
||||
srv->cbsock = INVALID_SOCKET;
|
||||
srv->service = S_ZOMBIE;
|
||||
while(srv->child) usleep(SLEEPTIME * 100);
|
||||
unregisterlog(srv->log);
|
||||
#ifndef STDMAIN
|
||||
if(srv->filter){
|
||||
while(srv->nfilters){
|
||||
|
||||
@ -15,9 +15,6 @@
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include <stdint.h>
|
||||
#ifndef PRINTF_INT64_MODIFIER
|
||||
#define PRINTF_INT64_MODIFIER "ll"
|
||||
#endif
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
@ -60,6 +57,15 @@ int mutex_unlock(int *val);
|
||||
#ifdef MSVC
|
||||
#pragma warning (disable : 4996)
|
||||
#endif
|
||||
#ifndef PRIu64
|
||||
#define PRIu64 "I64u"
|
||||
#endif
|
||||
#ifndef PRIi64
|
||||
#define PRIi64 "I64i"
|
||||
#endif
|
||||
#ifndef SCNx64
|
||||
#define SCNx64 "I64x"
|
||||
#endif
|
||||
#endif
|
||||
#define MAXBANDLIMS 10
|
||||
|
||||
@ -366,22 +372,26 @@ struct trafcount {
|
||||
|
||||
struct LOGFUNC {
|
||||
struct LOGFUNC* next;
|
||||
int (*init)(const char * selector, int logtype, struct LOGGER *logger);
|
||||
int (*init)(struct LOGGER *logger);
|
||||
int (*dobuf)(struct clientparam * param, unsigned char * buf, const unsigned char *s);
|
||||
int (*log)(const char * buf, int len, struct LOGGER *logger);
|
||||
int (*rotate)(struct LOGGER *logger);
|
||||
int (*close)(struct LOGGER *logger);
|
||||
void (*log)(const char * buf, int len, struct LOGGER *logger);
|
||||
void (*rotate)(struct LOGGER *logger);
|
||||
void (*close)(struct LOGGER *logger);
|
||||
char* prefix;
|
||||
};
|
||||
extern struct LOGFUNC *logfuncs;
|
||||
struct LOGGER {
|
||||
struct LOGGER *next;
|
||||
char * selector;
|
||||
void * data;
|
||||
struct LOGFUNC *logfunc;
|
||||
int rotate;
|
||||
time_t rotated;
|
||||
int registered;
|
||||
};
|
||||
extern struct LOGFUNC logfuncs;
|
||||
extern void(*prelog)(struct clientparam * param);
|
||||
struct LOGGER * registerlog(const char * logstring, int logtype);
|
||||
void unregisterlog (struct LOGGER * log);
|
||||
struct nserver {
|
||||
#ifndef NOIPV6
|
||||
struct sockaddr_in6 addr;
|
||||
@ -452,6 +462,7 @@ struct srvparam {
|
||||
int stacksize;
|
||||
int noforce;
|
||||
int anonymous;
|
||||
int logtype;
|
||||
int clisockopts, srvsockopts, lissockopts, cbcsockopts, cbssockopts;
|
||||
#ifdef WITHSPLICE
|
||||
int usesplice;
|
||||
@ -481,9 +492,10 @@ struct srvparam {
|
||||
struct ace *preacl, *acl;
|
||||
struct auth *authfuncs;
|
||||
struct filter *filter;
|
||||
unsigned char * logformat;
|
||||
unsigned char * logtarget;
|
||||
unsigned char * logformat;
|
||||
unsigned char * nonprintable;
|
||||
struct LOGGER *log;
|
||||
unsigned short targetport;
|
||||
unsigned char replace;
|
||||
time_t time_start;
|
||||
@ -593,7 +605,7 @@ struct extparam {
|
||||
demon, maxchild, needreload, timetoexit, version, noforce;
|
||||
int authcachetype, authcachetime;
|
||||
int filtermaxsize;
|
||||
unsigned char *logname, **archiver;
|
||||
unsigned char **archiver;
|
||||
ROTATION logtype, countertype;
|
||||
char * counterfile;
|
||||
#ifndef NOIPV6
|
||||
@ -613,10 +625,9 @@ struct extparam {
|
||||
struct filemon * fmon;
|
||||
struct filter * filters;
|
||||
struct auth *authfuncs;
|
||||
FILE *stdlog;
|
||||
char* demanddialprog;
|
||||
unsigned char **stringtable;
|
||||
time_t logtime, time;
|
||||
time_t time;
|
||||
unsigned logdumpsrv, logdumpcli;
|
||||
char delimchar;
|
||||
};
|
||||
|
||||
@ -474,9 +474,9 @@ void * adminchild(struct clientparam* param) {
|
||||
}
|
||||
else {
|
||||
inbuf += sprintf(buf+inbuf,
|
||||
"</td><td>%"PRINTF_INT64_MODIFIER"u</td>"
|
||||
"</td><td>%"PRIu64"</td>"
|
||||
"<td>MB%s</td>"
|
||||
"<td>%"PRINTF_INT64_MODIFIER"u.%"PRINTF_INT64_MODIFIER"u</td>"
|
||||
"<td>%"PRIu64".%"PRIu64"</td>"
|
||||
"<td>%s</td>",
|
||||
cp->traflim64 / (1024 * 1024),
|
||||
rotations[cp->type],
|
||||
|
||||
Loading…
Reference in New Issue
Block a user