mirror of
https://github.com/3proxy/3proxy.git
synced 2026-11-22 23:59:41 +08:00
Merge remote-tracking branch 'refs/remotes/origin/devel'
This commit is contained in:
commit
01857354c8
36 files changed
+390
-268
No files matched your search
+9
-12
@@ -87,7 +87,7 @@ void __stdcall CommandHandler( DWORD dwCommand )
|
||||
void __stdcall ServiceMain(int argc, unsigned char* argv[] )
|
||||
{
|
||||
|
||||
hSrv = RegisterServiceCtrlHandler(conf.stringtable[1], (LPHANDLER_FUNCTION)CommandHandler);
|
||||
hSrv = RegisterServiceCtrlHandler((LPCSTR)conf.stringtable[1], (LPHANDLER_FUNCTION)CommandHandler);
|
||||
if( hSrv == 0 ) return;
|
||||
|
||||
SetStatus( SERVICE_START_PENDING, 0, 1 );
|
||||
@@ -139,7 +139,7 @@ int timechanged (time_t oldtime, time_t newtime, ROTATION lt){
|
||||
struct tm tmold;
|
||||
struct tm *tm;
|
||||
tm = localtime(&oldtime);
|
||||
memcpy(&tmold, tm, sizeof(tmold));
|
||||
tmold = *tm;
|
||||
tm = localtime(&newtime);
|
||||
switch(lt){
|
||||
case MINUTELY:
|
||||
@@ -394,7 +394,7 @@ int WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int
|
||||
"By clicking Yes you confirm you read and accepted License Agreement.\n"
|
||||
"You can use Administration/Services to control %s service.",
|
||||
conf.stringtable[1], conf.stringtable[2]);
|
||||
if(MessageBox(NULL, (char *)tmpbuf, conf.stringtable[2], MB_YESNO|MB_ICONASTERISK) != IDYES) return 1;
|
||||
if(MessageBox(NULL, (LPCSTR)tmpbuf, (LPCSTR)conf.stringtable[2], MB_YESNO|MB_ICONASTERISK) != IDYES) return 1;
|
||||
|
||||
|
||||
*tmpbuf = '\"';
|
||||
@@ -415,7 +415,7 @@ int WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int
|
||||
perror("Failed to open Service Manager");
|
||||
RETURN(101);
|
||||
}
|
||||
if (!(sch = CreateService(sch, conf.stringtable[1], conf.stringtable[2], GENERIC_EXECUTE, SERVICE_WIN32_OWN_PROCESS, SERVICE_AUTO_START, SERVICE_ERROR_IGNORE, (char *)tmpbuf, NULL, NULL, NULL, NULL, NULL))){
|
||||
if (!(sch = CreateService(sch, (LPCSTR)conf.stringtable[1], (LPCSTR)conf.stringtable[2], GENERIC_EXECUTE, SERVICE_WIN32_OWN_PROCESS, SERVICE_AUTO_START, SERVICE_ERROR_IGNORE, (char *)tmpbuf, NULL, NULL, NULL, NULL, NULL))){
|
||||
perror("Failed to create service");
|
||||
RETURN(103);
|
||||
}
|
||||
@@ -436,10 +436,10 @@ int WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int
|
||||
RETURN(104);
|
||||
}
|
||||
if(RegSetValueEx( runsrv,
|
||||
conf.stringtable[1],
|
||||
(LPCSTR)conf.stringtable[1],
|
||||
0,
|
||||
REG_EXPAND_SZ,
|
||||
(char *)tmpbuf,
|
||||
(BYTE *)tmpbuf,
|
||||
(int)strlen((char *)tmpbuf)+1)!=ERROR_SUCCESS){
|
||||
perror("Failed to set registry value");
|
||||
RETURN(105);
|
||||
@@ -457,7 +457,7 @@ int WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int
|
||||
perror("Failed to open Service Manager\n");
|
||||
RETURN(106);
|
||||
}
|
||||
if (!(sch = OpenService(sch, conf.stringtable[1], DELETE))){
|
||||
if (!(sch = OpenService(sch, (LPCSTR)conf.stringtable[1], DELETE))){
|
||||
perror("Failed to open service");
|
||||
RETURN(107);
|
||||
}
|
||||
@@ -476,7 +476,7 @@ int WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int
|
||||
perror("Failed to open registry");
|
||||
RETURN(109);
|
||||
}
|
||||
if(RegDeleteValue(runsrv, conf.stringtable[1]) != ERROR_SUCCESS){
|
||||
if(RegDeleteValue(runsrv, (LPCSTR)conf.stringtable[1]) != ERROR_SUCCESS){
|
||||
perror("Failed to clear registry");
|
||||
RETURN(110);
|
||||
}
|
||||
@@ -510,9 +510,6 @@ int WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int
|
||||
return 1;
|
||||
}
|
||||
|
||||
pthread_mutex_init(&log_mutex, NULL);
|
||||
logmutexinit = 1;
|
||||
|
||||
pthread_mutex_init(&config_mutex, NULL);
|
||||
pthread_mutex_init(&bandlim_mutex, NULL);
|
||||
pthread_mutex_init(&hash_mutex, NULL);
|
||||
@@ -531,7 +528,7 @@ int WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int
|
||||
if(service){
|
||||
SERVICE_TABLE_ENTRY ste[] =
|
||||
{
|
||||
{ conf.stringtable[1], (LPSERVICE_MAIN_FUNCTION)ServiceMain},
|
||||
{ (LPSTR)conf.stringtable[1], (LPSERVICE_MAIN_FUNCTION)ServiceMain},
|
||||
{ NULL, NULL }
|
||||
};
|
||||
if(!StartServiceCtrlDispatcher( ste ))cyclestep();
|
||||
|
||||
+47
-43
@@ -43,9 +43,9 @@ int clientnegotiate(struct chain * redir, struct clientparam * param, struct soc
|
||||
len = sprintf((char *)buf, "CONNECT ");
|
||||
if(redir->type == R_CONNECTP && param->hostname) {
|
||||
char * needreplace;
|
||||
needreplace = strchr(param->hostname, ':');
|
||||
needreplace = strchr((char *)param->hostname, ':');
|
||||
if(needreplace) buf[len++] = '[';
|
||||
len =+ sprintf((char *)buf + len, "%.256s", param->hostname);
|
||||
len += sprintf((char *)buf + len, "%.256s", (char *)param->hostname);
|
||||
if(needreplace) buf[len++] = ']';
|
||||
}
|
||||
else {
|
||||
@@ -241,7 +241,12 @@ int handleredirect(struct clientparam * param, struct ace * acentry){
|
||||
r2 = (myrand(param, sizeof(struct clientparam))%1000);
|
||||
}
|
||||
if(!connected){
|
||||
if(SAISNULL(&cur->addr) && !*SAPORT(&cur->addr)){
|
||||
if(cur->type == R_EXTIP){
|
||||
param->sinsl = cur->addr;
|
||||
if(cur->next)continue;
|
||||
return 0;
|
||||
}
|
||||
else if(SAISNULL(&cur->addr) && !*SAPORT(&cur->addr)){
|
||||
if(cur->extuser){
|
||||
if(param->extusername)
|
||||
myfree(param->extusername);
|
||||
@@ -266,11 +271,9 @@ int handleredirect(struct clientparam * param, struct ace * acentry){
|
||||
case R_ICQ:
|
||||
param->redirectfunc = icqprchild;
|
||||
break;
|
||||
/*
|
||||
case R_MSN:
|
||||
param->redirectfunc = msnprchild;
|
||||
case R_SMTP:
|
||||
param->redirectfunc = smtppchild;
|
||||
break;
|
||||
*/
|
||||
default:
|
||||
param->redirectfunc = proxychild;
|
||||
}
|
||||
@@ -279,12 +282,12 @@ int handleredirect(struct clientparam * param, struct ace * acentry){
|
||||
}
|
||||
else if(!*SAPORT(&cur->addr) && !SAISNULL(&cur->addr)) {
|
||||
unsigned short port = *SAPORT(¶m->sinsr);
|
||||
memcpy(¶m->sinsr, &cur->addr, SASIZE(&cur->addr));
|
||||
param->sinsr = cur->addr;
|
||||
*SAPORT(¶m->sinsr) = port;
|
||||
}
|
||||
else if(SAISNULL(&cur->addr) && *SAPORT(&cur->addr)) *SAPORT(¶m->sinsr) = *SAPORT(&cur->addr);
|
||||
else {
|
||||
memcpy(¶m->sinsr, &cur->addr, SASIZE(&cur->addr));
|
||||
param->sinsr = cur->addr;
|
||||
}
|
||||
|
||||
if((res = alwaysauth(param))){
|
||||
@@ -369,19 +372,19 @@ int ACLmatches(struct ace* acentry, struct clientparam * param){
|
||||
for(hstentry = acentry->dstnames; hstentry; hstentry = hstentry->next){
|
||||
switch(hstentry->matchtype){
|
||||
case 0:
|
||||
if(strstr(param->hostname, hstentry->name)) match = 1;
|
||||
if(strstr((char *)param->hostname, (char *)hstentry->name)) match = 1;
|
||||
break;
|
||||
|
||||
case 1:
|
||||
if(strstr(param->hostname, hstentry->name) == (char *)param->hostname) match = 1;
|
||||
if(strstr((char *)param->hostname, (char *)hstentry->name) == (char *)param->hostname) match = 1;
|
||||
break;
|
||||
|
||||
case 2:
|
||||
if(strstr(param->hostname, hstentry->name) == (char *)(param->hostname + i - (strlen(hstentry->name)))) match = 1;
|
||||
if(strstr((char *)param->hostname, (char *)hstentry->name) == (char *)(param->hostname + i - (strlen((char *)hstentry->name)))) match = 1;
|
||||
break;
|
||||
|
||||
default:
|
||||
if(!strcmp(param->hostname, hstentry->name)) match = 1;
|
||||
if(!strcmp((char *)param->hostname, (char *)hstentry->name)) match = 1;
|
||||
break;
|
||||
}
|
||||
if(match) break;
|
||||
@@ -608,7 +611,7 @@ int checkACL(struct clientparam * param){
|
||||
if(param->redirected && acentry->chains && SAISNULL(&acentry->chains->addr) && !*SAPORT(&acentry->chains->addr)) {
|
||||
continue;
|
||||
}
|
||||
memcpy(&dup, acentry, sizeof(struct ace));
|
||||
dup = *acentry;
|
||||
return handleredirect(param, &dup);
|
||||
}
|
||||
return acentry->action;
|
||||
@@ -651,13 +654,13 @@ int cacheauth(struct clientparam * param){
|
||||
continue;
|
||||
|
||||
}
|
||||
if(((!(conf.authcachetype&2)) || (param->username && ac->username && !strcmp(ac->username, param->username))) &&
|
||||
if(((!(conf.authcachetype&2)) || (param->username && ac->username && !strcmp(ac->username, (char *)param->username))) &&
|
||||
((!(conf.authcachetype&1)) || (*SAFAMILY(&ac->sa) == *SAFAMILY(¶m->sincr) && !memcmp(SAADDR(&ac->sa), ¶m->sincr, SAADDRLEN(&ac->sa)))) &&
|
||||
(!(conf.authcachetype&4) || (ac->password && param->password && !strcmp(ac->password, param->password)))) {
|
||||
(!(conf.authcachetype&4) || (ac->password && param->password && !strcmp(ac->password, (char *)param->password)))) {
|
||||
if(param->username){
|
||||
myfree(param->username);
|
||||
}
|
||||
param->username = mystrdup(ac->username);
|
||||
param->username = (unsigned char *)mystrdup(ac->username);
|
||||
pthread_mutex_unlock(&hash_mutex);
|
||||
return 0;
|
||||
}
|
||||
@@ -685,21 +688,21 @@ int doauth(struct clientparam * param){
|
||||
if(conf.authcachetype && authfuncs->authenticate && authfuncs->authenticate != cacheauth && param->username && (!(conf.authcachetype&4) || (!param->pwtype && param->password))){
|
||||
pthread_mutex_lock(&hash_mutex);
|
||||
for(ac = authc; ac; ac = ac->next){
|
||||
if((!(conf.authcachetype&2) || !strcmp(ac->username, param->username)) &&
|
||||
if((!(conf.authcachetype&2) || !strcmp(ac->username, (char *)param->username)) &&
|
||||
(!(conf.authcachetype&1) || (*SAFAMILY(&ac->sa) == *SAFAMILY(¶m->sincr) && !memcmp(SAADDR(&ac->sa), ¶m->sincr, SAADDRLEN(&ac->sa)))) &&
|
||||
(!(conf.authcachetype&4) || (ac->password && !strcmp(ac->password, param->password)))) {
|
||||
(!(conf.authcachetype&4) || (ac->password && !strcmp(ac->password, (char *)param->password)))) {
|
||||
ac->expires = conf.time + conf.authcachetime;
|
||||
if(strcmp(ac->username, param->username)){
|
||||
if(strcmp(ac->username, (char *)param->username)){
|
||||
tmp = ac->username;
|
||||
ac->username = mystrdup(param->username);
|
||||
ac->username = mystrdup((char *)param->username);
|
||||
myfree(tmp);
|
||||
}
|
||||
if((conf.authcachetype&4)){
|
||||
tmp = ac->password;
|
||||
ac->password = mystrdup(param->password);
|
||||
ac->password = mystrdup((char *)param->password);
|
||||
myfree(tmp);
|
||||
}
|
||||
memcpy(&ac->sa, ¶m->sincr, SASIZE(¶m->sincr));
|
||||
ac->sa = param->sincr;
|
||||
break;
|
||||
}
|
||||
}
|
||||
@@ -707,10 +710,10 @@ int doauth(struct clientparam * param){
|
||||
ac = myalloc(sizeof(struct authcache));
|
||||
if(ac){
|
||||
ac->expires = conf.time + conf.authcachetime;
|
||||
ac->username = mystrdup(param->username);
|
||||
memcpy(&ac->sa, ¶m->sincr, SASIZE(¶m->sincr));
|
||||
ac->username = mystrdup((char *)param->username);
|
||||
ac->sa = param->sincr;
|
||||
ac->password = NULL;
|
||||
if((conf.authcachetype&4) && param->password) ac->password = mystrdup(param->password);
|
||||
if((conf.authcachetype&4) && param->password) ac->password = mystrdup((char *)param->password);
|
||||
}
|
||||
ac->next = authc;
|
||||
authc = ac;
|
||||
@@ -772,7 +775,7 @@ int dnsauth(struct clientparam * param){
|
||||
((u&0xFF000000)>>24));
|
||||
|
||||
}
|
||||
if(!udpresolve(*SAFAMILY(¶m->sincr), buf, addr, NULL, param, 1)) return 6;
|
||||
if(!udpresolve(*SAFAMILY(¶m->sincr), (unsigned char *)buf, (unsigned char *)addr, NULL, param, 1)) return 6;
|
||||
if(!memcmp(SAADDR(¶m->sincr), addr, SAADDRLEN(¶m->sincr))) return 6;
|
||||
|
||||
return param->username? 0:4;
|
||||
@@ -1037,17 +1040,18 @@ unsigned long udpresolve(int af, unsigned char * name, unsigned char * value, un
|
||||
unsigned ttl;
|
||||
#ifndef NOIPV6
|
||||
struct sockaddr_in6 addr;
|
||||
struct sockaddr_in6 *sinsr, *sinsl;
|
||||
#else
|
||||
struct sockaddr_in addr;
|
||||
struct sockaddr_in *sinsr, *sinsl;
|
||||
#endif
|
||||
struct sockaddr *sinsr, *sinsl;
|
||||
int usetcp = 0;
|
||||
unsigned short serial = 1;
|
||||
|
||||
buf = b+2;
|
||||
|
||||
sinsl = (param && !makeauth)? (struct sockaddr *)¶m->sinsl : (struct sockaddr *)&addr;
|
||||
sinsr = (param && !makeauth)? (struct sockaddr *)¶m->sinsr : (struct sockaddr *)&addr;
|
||||
sinsl = (param && !makeauth)? ¶m->sinsl : &addr;
|
||||
sinsr = (param && !makeauth)? ¶m->sinsr : &addr;
|
||||
memset(sinsl, 0, sizeof(addr));
|
||||
memset(sinsr, 0, sizeof(addr));
|
||||
|
||||
@@ -1061,19 +1065,19 @@ unsigned long udpresolve(int af, unsigned char * name, unsigned char * value, un
|
||||
*SAFAMILY(sinsl) = *SAFAMILY(&nservers[i].addr);
|
||||
}
|
||||
if((sock=so._socket(SASOCK(sinsl), usetcp?SOCK_STREAM:SOCK_DGRAM, usetcp?IPPROTO_TCP:IPPROTO_UDP)) == INVALID_SOCKET) break;
|
||||
if(so._bind(sock,sinsl,SASIZE(sinsl))){
|
||||
if(so._bind(sock,(struct sockaddr *)sinsl,SASIZE(sinsl))){
|
||||
so._shutdown(sock, SHUT_RDWR);
|
||||
so._closesocket(sock);
|
||||
break;
|
||||
}
|
||||
if(makeauth && !SAISNULL(&authnserver.addr)){
|
||||
memcpy(sinsr, &authnserver.addr, sizeof(authnserver.addr));
|
||||
*sinsr = authnserver.addr;
|
||||
}
|
||||
else {
|
||||
memcpy(sinsr, &nservers[i].addr, sizeof(nservers[i].addr));
|
||||
*sinsr = nservers[i].addr;
|
||||
}
|
||||
if(usetcp){
|
||||
if(so._connect(sock,sinsr,SASIZE(sinsr))) {
|
||||
if(so._connect(sock,(struct sockaddr *)sinsr,SASIZE(sinsr))) {
|
||||
so._shutdown(sock, SHUT_RDWR);
|
||||
so._closesocket(sock);
|
||||
break;
|
||||
@@ -1109,13 +1113,13 @@ unsigned long udpresolve(int af, unsigned char * name, unsigned char * value, un
|
||||
len+=2;
|
||||
}
|
||||
|
||||
if(socksendto(sock, sinsr, buf, len, conf.timeouts[SINGLEBYTE_L]*1000) != len){
|
||||
if(socksendto(sock, (struct sockaddr *)sinsr, buf, len, conf.timeouts[SINGLEBYTE_L]*1000) != len){
|
||||
so._shutdown(sock, SHUT_RDWR);
|
||||
so._closesocket(sock);
|
||||
continue;
|
||||
}
|
||||
if(param) param->statscli64 += len;
|
||||
len = sockrecvfrom(sock, sinsr, buf, 4096, conf.timeouts[DNS_TO]*1000);
|
||||
len = sockrecvfrom(sock, (struct sockaddr *)sinsr, buf, 4096, conf.timeouts[DNS_TO]*1000);
|
||||
so._shutdown(sock, SHUT_RDWR);
|
||||
so._closesocket(sock);
|
||||
if(len <= 13) {
|
||||
@@ -1127,7 +1131,7 @@ unsigned long udpresolve(int af, unsigned char * name, unsigned char * value, un
|
||||
us = ntohs(*(unsigned short*)buf);
|
||||
len-=2;
|
||||
buf+=2;
|
||||
if(us > 4096 || us < len || (us > len && sockrecvfrom(sock, sinsr, buf+len, us-len, conf.timeouts[DNS_TO]*1000) != us-len)) {
|
||||
if(us > 4096 || us < len || (us > len && sockrecvfrom(sock, (struct sockaddr *)sinsr, buf+len, us-len, conf.timeouts[DNS_TO]*1000) != us-len)) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
@@ -1183,7 +1187,7 @@ unsigned long udpresolve(int af, unsigned char * name, unsigned char * value, un
|
||||
}
|
||||
*s2 = 0;
|
||||
if(param->username)myfree(param->username);
|
||||
param->username = mystrdup (buf + k + 13);
|
||||
param->username = (unsigned char *)mystrdup ((char *)buf + k + 13);
|
||||
|
||||
return udpresolve(af,param->username, value, NULL, NULL, 2);
|
||||
}
|
||||
@@ -1320,20 +1324,20 @@ void logsql(struct clientparam * param, const unsigned char *s) {
|
||||
|
||||
if(param->nolog) return;
|
||||
pthread_mutex_lock(&log_mutex);
|
||||
len = dobuf(param, tmpbuf, s, "\'");
|
||||
len = dobuf(param, tmpbuf, s, (unsigned char *)"\'");
|
||||
|
||||
if(attempt > 5){
|
||||
time_t t;
|
||||
|
||||
t = time(0);
|
||||
if (t - attempt_time < 180){
|
||||
sqlerr(tmpbuf);
|
||||
sqlerr((char *)tmpbuf);
|
||||
return;
|
||||
}
|
||||
}
|
||||
if(!hstmt){
|
||||
if(!init_sql(sqlstring)) {
|
||||
sqlerr(tmpbuf);
|
||||
sqlerr((char *)tmpbuf);
|
||||
return;
|
||||
}
|
||||
}
|
||||
@@ -1342,13 +1346,13 @@ void logsql(struct clientparam * param, const unsigned char *s) {
|
||||
if(ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO){
|
||||
close_sql();
|
||||
if(!init_sql(sqlstring)){
|
||||
sqlerr(tmpbuf);
|
||||
sqlerr((char *)tmpbuf);
|
||||
return;
|
||||
}
|
||||
if(hstmt) {
|
||||
ret = SQLExecDirect(hstmt, (SQLCHAR *)tmpbuf, (SQLINTEGER)len);
|
||||
if(ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO){
|
||||
sqlerr(tmpbuf);
|
||||
sqlerr((char *)tmpbuf);
|
||||
return;
|
||||
}
|
||||
attempt = 0;
|
||||
|
||||
+27
-30
@@ -58,6 +58,11 @@ struct extparam conf = {
|
||||
NULL, NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
#ifdef __FreeBSD__
|
||||
8192,
|
||||
#else
|
||||
0,
|
||||
#endif
|
||||
0, -1, 0, 0, 0, 0, 0, 500, 0, 0, 0,
|
||||
6, 600,
|
||||
1048576,
|
||||
@@ -84,7 +89,7 @@ struct extparam conf = {
|
||||
NULL,
|
||||
(time_t)0, (time_t)0,
|
||||
0,0,
|
||||
'@'
|
||||
'@',
|
||||
};
|
||||
|
||||
int numservers=0;
|
||||
@@ -157,10 +162,10 @@ struct sockfuncs so = {
|
||||
#else
|
||||
mypoll,
|
||||
#endif
|
||||
send,
|
||||
sendto,
|
||||
recv,
|
||||
recvfrom,
|
||||
(void *)send,
|
||||
(void *)sendto,
|
||||
(void *)recv,
|
||||
(void *)recvfrom,
|
||||
shutdown,
|
||||
#ifdef _WIN32
|
||||
closesocket
|
||||
@@ -216,12 +221,12 @@ int ceparseargs(const char *str){
|
||||
|
||||
#endif
|
||||
|
||||
void parsehost(int family, char *host, struct sockaddr *sa){
|
||||
void parsehost(int family, unsigned char *host, struct sockaddr *sa){
|
||||
char *sp=NULL,*se=NULL;
|
||||
unsigned short port;
|
||||
|
||||
if(*host == '[') se=strchr(host, ']');
|
||||
if ( (sp = strchr(se?se:host, ':')) ) *sp = 0;
|
||||
if(*host == '[') se=strchr((char *)host, ']');
|
||||
if ( (sp = strchr(se?se:(char *)host, ':')) ) *sp = 0;
|
||||
if(se){
|
||||
*se = 0;
|
||||
}
|
||||
@@ -297,7 +302,7 @@ int parseconnusername(char *username, struct clientparam *param, int extpasswd,
|
||||
if(!username || !*username) return 1;
|
||||
if ((sb=strchr(username, conf.delimchar)) == NULL){
|
||||
if(!param->hostname && param->remsock == INVALID_SOCKET) return 2;
|
||||
if(param->hostname)parsehostname(param->hostname, param, port);
|
||||
if(param->hostname)parsehostname((char *)param->hostname, param, port);
|
||||
return parseusername(username, param, extpasswd);
|
||||
}
|
||||
while ((se=strchr(sb+1, conf.delimchar)))sb=se;
|
||||
@@ -466,7 +471,7 @@ int dobuf2(struct clientparam * param, unsigned char * buf, const unsigned char
|
||||
break;
|
||||
|
||||
case 'N':
|
||||
if(param->service >=0 && param->service < 15) {
|
||||
if(param->service < 15) {
|
||||
len = (conf.stringtable)? (int)strlen((char *)conf.stringtable[SERVICES + param->service]) : 0;
|
||||
if(len > 20) len = 20;
|
||||
memcpy(buf+i, (len)?conf.stringtable[SERVICES + param->service]:(unsigned char*)"-", (len)?len:1);
|
||||
@@ -601,17 +606,11 @@ void lognone(struct clientparam * param, const unsigned char *s) {
|
||||
if(param->trafcountfunc)(*param->trafcountfunc)(param);
|
||||
clearstat(param);
|
||||
}
|
||||
pthread_mutex_t log_mutex;
|
||||
int logmutexinit = 0;
|
||||
unsigned char tmpbuf[8192];
|
||||
|
||||
void logstdout(struct clientparam * param, const unsigned char *s) {
|
||||
FILE *log;
|
||||
|
||||
if(!logmutexinit){
|
||||
pthread_mutex_init(&log_mutex, NULL);
|
||||
logmutexinit = 1;
|
||||
}
|
||||
pthread_mutex_lock(&log_mutex);
|
||||
log = param->srv->stdlog?param->srv->stdlog:conf.stdlog?conf.stdlog:stdout;
|
||||
dobuf(param, tmpbuf, s, NULL);
|
||||
@@ -624,10 +623,6 @@ void logstdout(struct clientparam * param, const unsigned char *s) {
|
||||
#ifndef _WIN32
|
||||
void logsyslog(struct clientparam * param, const unsigned char *s) {
|
||||
|
||||
if(!logmutexinit){
|
||||
pthread_mutex_init(&log_mutex, NULL);
|
||||
logmutexinit = 1;
|
||||
}
|
||||
pthread_mutex_lock(&log_mutex);
|
||||
dobuf(param, tmpbuf, s, NULL);
|
||||
if(!param->nolog)syslog(LOG_INFO, "%s", tmpbuf);
|
||||
@@ -658,14 +653,14 @@ int doconnect(struct clientparam * param){
|
||||
}
|
||||
if(!*SAPORT(¶m->sinsr))*SAPORT(¶m->sinsr) = *SAPORT(¶m->req);
|
||||
if ((param->remsock=so._socket(SASOCK(¶m->sinsr), SOCK_STREAM, IPPROTO_TCP)) == INVALID_SOCKET) {return (11);}
|
||||
so._setsockopt(param->remsock, SOL_SOCKET, SO_LINGER, (unsigned char *)&lg, sizeof(lg));
|
||||
so._setsockopt(param->remsock, SOL_SOCKET, SO_LINGER, (char *)&lg, sizeof(lg));
|
||||
#ifdef REUSE
|
||||
{
|
||||
int opt;
|
||||
|
||||
#ifdef SO_REUSEADDR
|
||||
opt = 1;
|
||||
so._setsockopt(param->remsock, SOL_SOCKET, SO_REUSEADDR, (unsigned char *)&opt, sizeof(int));
|
||||
so._setsockopt(param->remsock, SOL_SOCKET, SO_REUSEADDR, (char *)&opt, sizeof(int));
|
||||
#endif
|
||||
#ifdef SO_REUSEPORT
|
||||
opt = 1;
|
||||
@@ -674,12 +669,14 @@ int doconnect(struct clientparam * param){
|
||||
}
|
||||
#endif
|
||||
|
||||
if(SAISNULL(¶m->sinsl)){
|
||||
#ifndef NOIPV6
|
||||
if(*SAFAMILY(¶m->sinsr) == AF_INET6) memcpy(¶m->sinsl, ¶m->srv->extsa6, sizeof(param->srv->extsa6));
|
||||
else
|
||||
if(*SAFAMILY(¶m->sinsr) == AF_INET6) param->sinsl = param->srv->extsa6;
|
||||
else
|
||||
#endif
|
||||
memcpy(¶m->sinsl, ¶m->srv->extsa, sizeof(param->srv->extsa));
|
||||
*SAPORT(¶m->sinsl) = 0;
|
||||
param->sinsl = param->srv->extsa;
|
||||
*SAPORT(¶m->sinsl) = 0;
|
||||
}
|
||||
if(so._bind(param->remsock, (struct sockaddr*)¶m->sinsl, SASIZE(¶m->sinsl))==-1) {
|
||||
return 12;
|
||||
}
|
||||
@@ -828,11 +825,11 @@ unsigned long getip46(int family, unsigned char *name, struct sockaddr *sa){
|
||||
if(!name[i]){
|
||||
if(ndots == 3 && ncols == 0 && nhex == 0){
|
||||
*SAFAMILY(sa)=(family == 6)?AF_INET6 : AF_INET;
|
||||
return inet_pton(*SAFAMILY(sa), name, SAADDR(sa))? *SAFAMILY(sa) : 0;
|
||||
return inet_pton(*SAFAMILY(sa), (char *)name, SAADDR(sa))? *SAFAMILY(sa) : 0;
|
||||
}
|
||||
if(ncols >= 2) {
|
||||
*SAFAMILY(sa)=AF_INET6;
|
||||
return inet_pton(AF_INET6, name, SAADDR(sa))?(family==4? 0:AF_INET6) : 0;
|
||||
return inet_pton(AF_INET6, (char *)name, SAADDR(sa))?(family==4? 0:AF_INET6) : 0;
|
||||
}
|
||||
}
|
||||
if((tmpresolv = resolvfunc)){
|
||||
@@ -847,10 +844,10 @@ unsigned long getip46(int family, unsigned char *name, struct sockaddr *sa){
|
||||
}
|
||||
memset(&hint, 0, sizeof(hint));
|
||||
hint.ai_family = (family == 6 || family == 64)?AF_INET6:AF_INET;
|
||||
if (getaddrinfo(name, NULL, &hint, &ai)) {
|
||||
if (getaddrinfo((char *)name, NULL, &hint, &ai)) {
|
||||
if(family == 64 || family == 46){
|
||||
hint.ai_family = (family == 64)?AF_INET:AF_INET6;
|
||||
if (getaddrinfo(name, NULL, &hint, &ai)) return 0;
|
||||
if (getaddrinfo((char *)name, NULL, &hint, &ai)) return 0;
|
||||
}
|
||||
else return 0;
|
||||
}
|
||||
|
||||
+20
-11
@@ -32,6 +32,7 @@ struct proxydef childdef = {NULL, 0, 0, S_NOSERVICE, ""};
|
||||
|
||||
#ifndef _WIN32
|
||||
char *chrootp = NULL;
|
||||
static pthread_attr_t pa;
|
||||
#endif
|
||||
char * curconf = NULL;
|
||||
|
||||
@@ -142,14 +143,14 @@ int start_proxy_thread(struct child * chp){
|
||||
conf.threadinit = 1;
|
||||
#ifdef _WIN32
|
||||
#ifndef _WINCE
|
||||
h = (HANDLE)_beginthreadex((LPSECURITY_ATTRIBUTES )NULL, 16384, startsrv, (void *) chp, (DWORD)0, &thread);
|
||||
h = (HANDLE)_beginthreadex((LPSECURITY_ATTRIBUTES )NULL, 16384+conf.stacksize, (void *)startsrv, (void *) chp, (DWORD)0, &thread);
|
||||
#else
|
||||
h = (HANDLE)CreateThread((LPSECURITY_ATTRIBUTES )NULL, 16384, startsrv, (void *) chp, (DWORD)0, &thread);
|
||||
h = (HANDLE)CreateThread((LPSECURITY_ATTRIBUTES )NULL, 16384+conf.stacksize, (void *)startsrv, (void *) chp, (DWORD)0, &thread);
|
||||
#endif
|
||||
if(h)CloseHandle(h);
|
||||
#else
|
||||
pthread_attr_init(&pa);
|
||||
pthread_attr_setstacksize(&pa,PTHREAD_STACK_MIN + 16384);
|
||||
pthread_attr_setstacksize(&pa,PTHREAD_STACK_MIN + (16384+conf.stacksize));
|
||||
pthread_attr_setdetachstate(&pa,PTHREAD_CREATE_DETACHED);
|
||||
pthread_create(&thread, &pa, startsrv, (void *)chp);
|
||||
#endif
|
||||
@@ -274,7 +275,8 @@ static int h_external(int argc, unsigned char ** argv){
|
||||
memset(&sa6, 0, sizeof(sa6));
|
||||
res = getip46(46, argv[1], (struct sockaddr *)&sa6);
|
||||
if(!res) return 1;
|
||||
memcpy((*SAFAMILY(&sa6)==AF_INET)?(void *)&conf.extsa:(void *)&conf.extsa6, &sa6, sizeof(sa6));
|
||||
if (*SAFAMILY(&sa6)==AF_INET) conf.extsa = sa6;
|
||||
else conf.extsa6 = sa6;
|
||||
#else
|
||||
res = getip46(46, argv[1], (struct sockaddr *)&conf.extsa);
|
||||
if(!res) return 1;
|
||||
@@ -333,6 +335,11 @@ static int h_log(int argc, unsigned char ** argv){
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int h_stacksize(int argc, unsigned char **argv){
|
||||
conf.stacksize = atoi((char *)argv[1]);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int h_service(int argc, unsigned char **argv){
|
||||
return 0;
|
||||
}
|
||||
@@ -705,7 +712,8 @@ static int h_parent(int argc, unsigned char **argv){
|
||||
else if(!strcmp((char *)argv[2], "ftp"))chains->type = R_FTP;
|
||||
else if(!strcmp((char *)argv[2], "admin"))chains->type = R_ADMIN;
|
||||
else if(!strcmp((char *)argv[2], "icq"))chains->type = R_ICQ;
|
||||
else if(!strcmp((char *)argv[2], "msn"))chains->type = R_MSN;
|
||||
else if(!strcmp((char *)argv[2], "extip"))chains->type = R_EXTIP;
|
||||
else if(!strcmp((char *)argv[2], "smtp"))chains->type = R_SMTP;
|
||||
else {
|
||||
fprintf(stderr, "Chaining error: bad chain type (%s)\n", argv[2]);
|
||||
return(4);
|
||||
@@ -727,7 +735,7 @@ static int h_nolog(int argc, unsigned char **argv){
|
||||
return(1);
|
||||
}
|
||||
while(acl->next) acl = acl->next;
|
||||
if(!strcmp(argv[0],"nolog")) acl->nolog = 1;
|
||||
if(!strcmp((char *)argv[0],"nolog")) acl->nolog = 1;
|
||||
else acl->weight = atoi((char*)argv[1]);
|
||||
return 0;
|
||||
}
|
||||
@@ -740,14 +748,14 @@ int scanipl(unsigned char *arg, struct iplist *dst){
|
||||
#endif
|
||||
char * slash, *dash;
|
||||
int masklen, addrlen;
|
||||
if((slash = strchr(arg, '/'))) *slash = 0;
|
||||
if((dash = strchr(arg,'-'))) *dash = 0;
|
||||
if((slash = strchr((char *)arg, '/'))) *slash = 0;
|
||||
if((dash = strchr((char *)arg,'-'))) *dash = 0;
|
||||
|
||||
if(!getip46(46, arg, (struct sockaddr *)&sa)) return 1;
|
||||
memcpy(&dst->ip_from, SAADDR(&sa), SAADDRLEN(&sa));
|
||||
dst->family = *SAFAMILY(&sa);
|
||||
if(dash){
|
||||
if(!getip46(46, dash+1, (struct sockaddr *)&sa)) return 2;
|
||||
if(!getip46(46, (unsigned char *)dash+1, (struct sockaddr *)&sa)) return 2;
|
||||
memcpy(&dst->ip_to, SAADDR(&sa), SAADDRLEN(&sa));
|
||||
if(*SAFAMILY(&sa) != dst->family || memcmp(&dst->ip_to, &dst->ip_from, SAADDRLEN(&sa)) < 0) return 3;
|
||||
return 0;
|
||||
@@ -1254,7 +1262,7 @@ static int h_plugin(int argc, unsigned char **argv){
|
||||
#ifdef _WINCE
|
||||
hi = LoadLibraryW((LPCWSTR)CEToUnicode(argv[1]));
|
||||
#else
|
||||
hi = LoadLibrary(argv[1]);
|
||||
hi = LoadLibrary((char *)argv[1]);
|
||||
#endif
|
||||
if(!hi) {
|
||||
fprintf(stderr, "Failed to load %s, code %d\n", argv[1], (int)GetLastError());
|
||||
@@ -1263,7 +1271,7 @@ static int h_plugin(int argc, unsigned char **argv){
|
||||
#ifdef _WINCE
|
||||
fp = GetProcAddressW(hi, (LPCWSTR)CEToUnicode(argv[2]));
|
||||
#else
|
||||
fp = GetProcAddress(hi, argv[2]);
|
||||
fp = GetProcAddress(hi, (char *)argv[2]);
|
||||
#endif
|
||||
if(!fp) {
|
||||
printf("%s not found in %s, code: %d\n", argv[2], argv[1], (int)GetLastError());
|
||||
@@ -1390,6 +1398,7 @@ struct commands commandhandlers[]={
|
||||
{commandhandlers+55, "msnpr", h_proxy, 4, 0},
|
||||
{commandhandlers+56, "delimchar",h_delimchar, 2, 2},
|
||||
{commandhandlers+57, "authnserver", h_authnserver, 2, 2},
|
||||
{commandhandlers+58, "stacksize", h_stacksize, 2, 2},
|
||||
{specificcommands, "", h_noop, 1, 0}
|
||||
};
|
||||
|
||||
|
||||
+1
-1
@@ -74,7 +74,7 @@ static void pr_sa(struct node *node, CBFUNC cbf, void*cb){
|
||||
buf[0] = '[';
|
||||
buf[1] = 0;
|
||||
inet_ntop(*SAFAMILY(node->value), node->value, buf+1, sizeof(buf)-10);
|
||||
sprintf(buf + strlen(buf), "]:hu", (unsigned short)*SAPORT(node->value));
|
||||
sprintf(buf + strlen(buf), "]:%hu", (unsigned short)*SAPORT(node->value));
|
||||
if(node->value)(*cbf)(cb, buf, strlen(buf));
|
||||
#endif
|
||||
}
|
||||
|
||||
+3
-2
@@ -6,6 +6,7 @@
|
||||
*/
|
||||
|
||||
#include "proxy.h"
|
||||
pthread_mutex_t log_mutex;
|
||||
|
||||
|
||||
int sockgetchar(SOCKET sock, int timeosec, int timeousec){
|
||||
@@ -18,7 +19,7 @@ int sockgetchar(SOCKET sock, int timeosec, int timeousec){
|
||||
FD_ZERO(&fds);
|
||||
FD_SET(sock, &fds);
|
||||
if (select (((int)sock)+1, &fds, NULL, NULL, &tv)!=1) return EOF;
|
||||
if (recv(sock, &buf, 1, 0)!=1) return EOF;
|
||||
if (recv(sock, (char *)&buf, 1, 0)!=1) return EOF;
|
||||
return((int)buf);
|
||||
}
|
||||
|
||||
@@ -94,7 +95,7 @@ int main(int argc, char *argv[]){
|
||||
fprintf(stderr, "Unable to connect: %s\n", host);
|
||||
return 8;
|
||||
}
|
||||
if(send(sock, buf, (int)strlen((char *)buf), 0) != (int)strlen((char *)buf)) return 9;
|
||||
if(send(sock, (char *)buf, (int)strlen((char *)buf), 0) != (int)strlen((char *)buf)) return 9;
|
||||
while( (i = sockgetline(sock, buf, sizeof(buf) - 1, '\n', 30)) > 2);
|
||||
if(i<1) return 9;
|
||||
if(!(fp = fopen(argv[argc-1], "w"))) {
|
||||
|
||||
+5
-5
@@ -39,7 +39,7 @@ void * dnsprchild(struct clientparam* param) {
|
||||
}
|
||||
buf = bbuf+2;
|
||||
size = sizeof(param->sincr);
|
||||
i = so._recvfrom(param->srv->srvsock, buf, BUFSIZE, 0, (struct sockaddr *)¶m->sincr, &size);
|
||||
i = so._recvfrom(param->srv->srvsock, (char *)buf, BUFSIZE, 0, (struct sockaddr *)¶m->sincr, &size);
|
||||
size = sizeof(param->sinsl);
|
||||
getsockname(param->srv->srvsock, (struct sockaddr *)¶m->sincl, &size);
|
||||
#ifdef _WIN32
|
||||
@@ -47,7 +47,7 @@ void * dnsprchild(struct clientparam* param) {
|
||||
RETURN(818);
|
||||
}
|
||||
ioctlsocket(param->clisock, FIONBIO, &ul);
|
||||
if(so._setsockopt(param->clisock, SOL_SOCKET, SO_REUSEADDR, (unsigned char *)&ul, sizeof(int))) {RETURN(820);};
|
||||
if(so._setsockopt(param->clisock, SOL_SOCKET, SO_REUSEADDR, (char *)&ul, sizeof(int))) {RETURN(820);};
|
||||
if(so._bind(param->clisock,(struct sockaddr *)¶m->sincl,SASIZE(¶m->sincl))) {
|
||||
RETURN(822);
|
||||
}
|
||||
@@ -138,7 +138,7 @@ void * dnsprchild(struct clientparam* param) {
|
||||
if(so._bind(param->remsock,(struct sockaddr *)¶m->sinsl,SASIZE(¶m->sinsl))) {
|
||||
RETURN(819);
|
||||
}
|
||||
memcpy(¶m->sinsr, &nservers[0].addr, sizeof(param->sinsr));
|
||||
param->sinsr = nservers[0].addr;
|
||||
if(nservers[0].usetcp) {
|
||||
if(so._connect(param->remsock,(struct sockaddr *)¶m->sinsr,SASIZE(¶m->sinsr))) RETURN(830);
|
||||
buf-=2;
|
||||
@@ -195,8 +195,8 @@ CLEANRET:
|
||||
sprintf((char *)buf, "%04x/%s/",
|
||||
(unsigned)type,
|
||||
host?host:"");
|
||||
if(ip && type == 0x01 || type == 0x1c){
|
||||
myinet_ntop(type == 0x01? AF_INET:AF_INET6, addr, buf+strlen(buf), 64);
|
||||
if((ip && type == 0x01) || type == 0x1c){
|
||||
myinet_ntop(type == 0x01? AF_INET:AF_INET6, addr, (char *)buf+strlen((char *)buf), 64);
|
||||
}
|
||||
(*param->srv->logfunc)(param, buf);
|
||||
}
|
||||
|
||||
@@ -189,7 +189,7 @@ SOCKET ftpdata(struct clientparam *param){
|
||||
if(sscanf(sb+1, "%lu,%lu,%lu,%lu,%hu,%hu", &b1, &b2, &b3, &b4, &b5, &b6)!=6) return INVALID_SOCKET;
|
||||
rem = param->remsock;
|
||||
param->remsock = INVALID_SOCKET;
|
||||
memcpy(¶m->req,¶m->sinsr,sizeof(param->req));
|
||||
param->req = param->sinsr;
|
||||
*SAPORT(¶m->req) = *SAPORT(¶m->sinsr) = htons((unsigned short)((b5<<8)^b6));
|
||||
i = param->operation;
|
||||
param->operation = FTP_DATA;
|
||||
|
||||
+7
-7
@@ -76,7 +76,7 @@ void * ftpprchild(struct clientparam* param) {
|
||||
{
|
||||
int action, reqbufsize, reqsize;
|
||||
reqbufsize = BUFSIZE;
|
||||
reqsize = (int)strlen(buf) + 1;
|
||||
reqsize = (int)strlen((char *)buf) + 1;
|
||||
|
||||
action = handlereqfilters(param, &buf, &reqbufsize, 0, &reqsize);
|
||||
if(action == HANDLED){
|
||||
@@ -94,7 +94,7 @@ void * ftpprchild(struct clientparam* param) {
|
||||
{
|
||||
int action, reqbufsize, reqsize;
|
||||
reqbufsize = BUFSIZE;
|
||||
reqsize = (int)strlen(buf) + 1;
|
||||
reqsize = (int)strlen((char *)buf) + 1;
|
||||
|
||||
action = handlehdrfilterscli(param, &buf, &reqbufsize, 0, &reqsize);
|
||||
if(action == HANDLED){
|
||||
@@ -150,13 +150,13 @@ void * ftpprchild(struct clientparam* param) {
|
||||
clidatasock = INVALID_SOCKET;
|
||||
RETURN(826);
|
||||
}
|
||||
sprintf(buf, "200 OK\r\n");
|
||||
sprintf((char *)buf, "200 OK\r\n");
|
||||
}
|
||||
#ifndef WITHMAIN
|
||||
{
|
||||
int action, reqbufsize, reqsize;
|
||||
reqbufsize = BUFSIZE;
|
||||
reqsize = (int)strlen(buf) + 1;
|
||||
reqsize = (int)strlen((char *)buf) + 1;
|
||||
|
||||
action = handlehdrfilterssrv(param, &buf, &reqbufsize, 0, &reqsize);
|
||||
if(action == HANDLED){
|
||||
@@ -184,7 +184,7 @@ void * ftpprchild(struct clientparam* param) {
|
||||
{
|
||||
int action, reqbufsize, reqsize;
|
||||
reqbufsize = BUFSIZE;
|
||||
reqsize = (int)strlen(buf) + 1;
|
||||
reqsize = (int)strlen((char *)buf) + 1;
|
||||
|
||||
action = handlehdrfilterscli(param, &buf, &reqbufsize, 0, &reqsize);
|
||||
if(action == HANDLED){
|
||||
@@ -239,8 +239,8 @@ void * ftpprchild(struct clientparam* param) {
|
||||
}
|
||||
sc = param->remsock;
|
||||
param->remsock = ss;
|
||||
so._setsockopt(param->remsock, SOL_SOCKET, SO_LINGER, (unsigned char *)&lg, sizeof(lg));
|
||||
so._setsockopt(clidatasock, SOL_SOCKET, SO_LINGER, (unsigned char *)&lg, sizeof(lg));
|
||||
so._setsockopt(param->remsock, SOL_SOCKET, SO_LINGER, (char *)&lg, sizeof(lg));
|
||||
so._setsockopt(clidatasock, SOL_SOCKET, SO_LINGER, (char *)&lg, sizeof(lg));
|
||||
param->clisock = clidatasock;
|
||||
res = sockmap(param, conf.timeouts[CONNECTION_S]);
|
||||
if(param->remsock != INVALID_SOCKET) {
|
||||
|
||||
+10
-10
@@ -128,11 +128,11 @@ static int searchcookie(struct clientparam *param, struct flap_header * flap, in
|
||||
icq_cookie_mutex_init = 1;
|
||||
}
|
||||
pthread_mutex_lock(&icq_cookie_mutex);
|
||||
for(ic = icq_cookies; ic; ic = ic->next)if(!strcmp(param->username, ic->id))break;
|
||||
for(ic = icq_cookies; ic; ic = ic->next)if(!strcmp((char *)param->username, ic->id))break;
|
||||
if(!ic){
|
||||
ic = myalloc(sizeof(struct icq_cookie));
|
||||
memset(ic, 0, sizeof(struct icq_cookie));
|
||||
ic->id = mystrdup(param->username);
|
||||
ic->id = mystrdup((char *)param->username);
|
||||
ic->next = icq_cookies;
|
||||
icq_cookies = ic;
|
||||
}
|
||||
@@ -202,10 +202,10 @@ static FILTER_ACTION icq_srv(void *fc, struct clientparam * param, unsigned char
|
||||
state->state = ONCHAN;
|
||||
}
|
||||
else {
|
||||
if(!state->leftinstate)param->srv->logfunc(param, "Warning: need resync");
|
||||
if(!state->leftinstate)param->srv->logfunc(param, (unsigned char *)"Warning: need resync");
|
||||
state->leftinstate++;
|
||||
if(state->leftinstate > 65535){
|
||||
param->srv->logfunc(param, "Out of Sync");
|
||||
param->srv->logfunc(param, (unsigned char *)"Out of Sync");
|
||||
return REJECT;
|
||||
}
|
||||
}
|
||||
@@ -214,7 +214,7 @@ static FILTER_ACTION icq_srv(void *fc, struct clientparam * param, unsigned char
|
||||
break;
|
||||
case ONCHAN:
|
||||
if (*start >= 10){
|
||||
param->srv->logfunc(param, "Warning: Wrong channel");
|
||||
param->srv->logfunc(param, (unsigned char *)"Warning: Wrong channel");
|
||||
state->state = ONBEGIN;
|
||||
}
|
||||
else {
|
||||
@@ -234,15 +234,15 @@ static FILTER_ACTION icq_srv(void *fc, struct clientparam * param, unsigned char
|
||||
case ONSEQ2:
|
||||
state->gotseq += *start;
|
||||
if(state->gotseq != state->srvseq){
|
||||
char smallbuf[64];
|
||||
unsigned char smallbuf[64];
|
||||
if(((state->gotseq < state->srvseq) || ((state->gotseq - state->srvseq) > 10 )) && (!state->resyncseq || state->gotseq != state->resyncseq)){
|
||||
sprintf(smallbuf, "Warning: Wrong sequence, expected: %04hx got: %04hx", state->srvseq, state->gotseq);
|
||||
sprintf((char *)smallbuf, "Warning: Wrong sequence, expected: %04hx got: %04hx", state->srvseq, state->gotseq);
|
||||
param->srv->logfunc(param, smallbuf);
|
||||
state->state = ONBEGIN;
|
||||
state->resyncseq = state->gotseq;
|
||||
break;
|
||||
}
|
||||
sprintf(smallbuf, "Warning: %hu flaps are lost on resync", state->gotseq - state->srvseq );
|
||||
sprintf((char *)smallbuf, "Warning: %d flaps are lost on resync", state->gotseq - state->srvseq );
|
||||
param->srv->logfunc(param, smallbuf);
|
||||
state->srvseq = state->gotseq;
|
||||
*(start-1) = (state->seq>>8);
|
||||
@@ -339,7 +339,7 @@ static int readflap(struct clientparam * param, int direction, unsigned char *bu
|
||||
if(flap->id != 0x2a) return 2;
|
||||
len = ntohs(flap->size);
|
||||
if(len > buflen-6) return 3;
|
||||
i = sockgetlinebuf(param, direction, flap->data, len, EOF, conf.timeouts[STRING_S]);
|
||||
i = sockgetlinebuf(param, direction, (unsigned char *)flap->data, len, EOF, conf.timeouts[STRING_S]);
|
||||
if(len != i) return 4;
|
||||
return 0;
|
||||
|
||||
@@ -418,7 +418,7 @@ void * icqprchild(struct clientparam* param) {
|
||||
for(ic = icq_cookies; ic; ic=ic->next){
|
||||
if(ic->size && ic->size == tlv->size && !memcmp(ic->cookie, tlv->data, ntohs(tlv->size))){
|
||||
parsehostname((char *)ic->connectstring, param, ntohs(param->srv->targetport));
|
||||
if(!param->username && ic->id) param->username = mystrdup(ic->id);
|
||||
if(!param->username && ic->id) param->username = (unsigned char *)mystrdup(ic->id);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -144,7 +144,7 @@ static FILTER_ACTION pcre_filter_buffer(void *fc, struct clientparam *param, uns
|
||||
if(!pcrefd->re) return pcrefd->action;
|
||||
for(; offset < *length_p; nreplaces++){
|
||||
|
||||
count = pcre_exec(pcrefd->re, NULL, *buf_p, *length_p, offset, 0, ovector, 48);
|
||||
count = pcre_exec(pcrefd->re, NULL, (char *)*buf_p, *length_p, offset, 0, ovector, 48);
|
||||
if(count <= 0) break;
|
||||
if(!(replace = pcrefd->replace) || param->nooverwritefilter) return pcrefd->action;
|
||||
|
||||
@@ -195,7 +195,7 @@ static FILTER_ACTION pcre_filter_buffer(void *fc, struct clientparam *param, uns
|
||||
}
|
||||
memcpy(newbuf, *buf_p, ovector[0]);
|
||||
(*pl->myfree)(*buf_p);
|
||||
*buf_p = newbuf;
|
||||
*buf_p = (unsigned char *)newbuf;
|
||||
*bufsize_p = ovector[0] + replen + 1;
|
||||
}
|
||||
memcpy(*buf_p + ovector[0], tmpbuf, replen);
|
||||
@@ -229,15 +229,15 @@ static int h_pcre(int argc, unsigned char **argv){
|
||||
struct filter *newf;
|
||||
char *replace = NULL;
|
||||
|
||||
if(!strncmp(argv[2], "allow",5)) action = PASS;
|
||||
else if(!strncmp(argv[2], "deny",4)) action = REJECT;
|
||||
else if(!strncmp(argv[2], "remove",6)) action = REMOVE;
|
||||
else if(!strncmp(argv[2], "dunno",5)) action = CONTINUE;
|
||||
if(!strncmp((char *)argv[2], "allow",5)) action = PASS;
|
||||
else if(!strncmp((char *)argv[2], "deny",4)) action = REJECT;
|
||||
else if(!strncmp((char *)argv[2], "remove",6)) action = REMOVE;
|
||||
else if(!strncmp((char *)argv[2], "dunno",5)) action = CONTINUE;
|
||||
else return 1;
|
||||
if(!strncmp(argv[0], "pcre_rewrite", 12)) {
|
||||
if(!strncmp((char *)argv[0], "pcre_rewrite", 12)) {
|
||||
int i,j;
|
||||
offset = 5;
|
||||
replace = pl->mystrdup(argv[4]);
|
||||
replace = pl->mystrdup((char *)argv[4]);
|
||||
if(!replace) return 9;
|
||||
for(i=0, j=0; replace[i]; i++, j++){
|
||||
if(replace[i] == '\\'){
|
||||
@@ -266,7 +266,7 @@ static int h_pcre(int argc, unsigned char **argv){
|
||||
replace[j] = 0;
|
||||
}
|
||||
if(!(acl = pl->make_ace(argc - offset, argv + offset))) return 2;
|
||||
acl->nolog = (strstr(argv[2],"log") == 0);
|
||||
acl->nolog = (strstr((char *)argv[2],"log") == 0);
|
||||
if(*argv[3] && !(*argv[3] == '*' && !argv[3][1]) ){
|
||||
re = pcre_compile((char *)argv[3], pcre_options, &errptr, &offset, NULL);
|
||||
if(!re) {
|
||||
@@ -296,11 +296,11 @@ static int h_pcre(int argc, unsigned char **argv){
|
||||
newf->data = flt;
|
||||
newf->filter_open = pcre_filter_open;
|
||||
newf->filter_client = pcre_filter_client;
|
||||
if(strstr(argv[1], "request"))newf->filter_request = pcre_filter_buffer;
|
||||
if(strstr(argv[1], "cliheader"))newf->filter_header_cli = pcre_filter_buffer;
|
||||
if(strstr(argv[1], "clidata"))newf->filter_data_cli = pcre_filter_buffer;
|
||||
if(strstr(argv[1], "srvheader"))newf->filter_header_srv = pcre_filter_buffer;
|
||||
if(strstr(argv[1], "srvdata"))newf->filter_data_srv = pcre_filter_buffer;
|
||||
if(strstr((char *)argv[1], "request"))newf->filter_request = pcre_filter_buffer;
|
||||
if(strstr((char *)argv[1], "cliheader"))newf->filter_header_cli = pcre_filter_buffer;
|
||||
if(strstr((char *)argv[1], "clidata"))newf->filter_data_cli = pcre_filter_buffer;
|
||||
if(strstr((char *)argv[1], "srvheader"))newf->filter_header_srv = pcre_filter_buffer;
|
||||
if(strstr((char *)argv[1], "srvdata"))newf->filter_data_srv = pcre_filter_buffer;
|
||||
newf->filter_clear = pcre_filter_clear;
|
||||
newf->filter_close = pcre_filter_close;
|
||||
|
||||
@@ -334,7 +334,7 @@ static int h_pcre_options(int argc, unsigned char **argv){
|
||||
pcre_options = 0;
|
||||
for(j=1; j<argc; j++)
|
||||
for(i=0; pcreopts[i].name; i++)
|
||||
if(!strcmp(pcreopts[i].name, argv[j]))
|
||||
if(!strcmp(pcreopts[i].name, (char *)argv[j]))
|
||||
pcre_options |= pcreopts[i].value;
|
||||
|
||||
return 0;
|
||||
|
||||
@@ -47,7 +47,6 @@ static FILTER_ACTION transparent_filter_client(void *fo, struct clientparam * pa
|
||||
|
||||
len = sizeof(addr);
|
||||
if(getsockopt(param->clisock, SOL_IP, SO_ORIGINAL_DST,(struct sockaddr *) &addr, &len) || !addr.sin_addr.s_addr){
|
||||
perror("getsockopt()");
|
||||
return PASS;
|
||||
}
|
||||
u = ntohl(addr.sin_addr.s_addr);
|
||||
@@ -59,8 +58,6 @@ perror("getsockopt()");
|
||||
((u&0x000000FF)),
|
||||
p);
|
||||
|
||||
param->srv->logfunc(param, (unsigned char *)"transparent_filter_client() Success");
|
||||
param->srv->logfunc(param, (unsigned char *)addrbuf);
|
||||
pl->parsehostname(addrbuf, param, 0);
|
||||
return PASS;
|
||||
#else
|
||||
|
||||
@@ -41,7 +41,7 @@ extern "C" {
|
||||
if(dom)*dom++=0;
|
||||
if(!LogonUser( dom?dom:(char *)param->username,
|
||||
dom?(char *)param->username:NULL,
|
||||
param->password,
|
||||
(char *)param->password,
|
||||
LOGON32_LOGON_NETWORK,
|
||||
LOGON32_PROVIDER_DEFAULT,
|
||||
&h))return 5;
|
||||
@@ -54,7 +54,7 @@ extern "C" {
|
||||
if(GetLengthSid(ptg->Groups[i].Sid)==sidlen){
|
||||
if(!memcmp((void *)ptg->Groups[i].Sid, (void *)psid, sidlen)) {
|
||||
setlocale(LC_CTYPE, ".ACP");
|
||||
_strlwr(param->username);
|
||||
_strlwr((char *)param->username);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -26,7 +26,7 @@ extern "C" {
|
||||
#endif
|
||||
|
||||
unsigned char * conv_utf8_to_cp1251(unsigned char *s){
|
||||
int i, j=0, n=(int)strlen(s);
|
||||
int i, j=0, n=(int)strlen((char *)s);
|
||||
int byte2 = 0;
|
||||
int c1, new_c1, new_c2, new_i;
|
||||
for(i = 0; i < n; i++){
|
||||
|
||||
+20
-15
@@ -328,7 +328,7 @@ for(;;){
|
||||
prefix = (int)(se - buf);
|
||||
su = (unsigned char*)strrchr((char *)sb, '@');
|
||||
if(su) {
|
||||
su = mystrdup(sb);
|
||||
su = (unsigned char *)mystrdup((char *)sb);
|
||||
decodeurl(su, 0);
|
||||
parseconnusername((char *)su, (struct clientparam *)param, 1, (unsigned short)((ftp)?21:80));
|
||||
myfree(su);
|
||||
@@ -443,12 +443,16 @@ for(;;){
|
||||
continue;
|
||||
}
|
||||
if(param->transparent && i > 6 && !strncasecmp((char *)buf + inbuf, "Host:", 5)){
|
||||
unsigned char c;
|
||||
sb = (unsigned char *)strchr((char *)(buf+inbuf), ':');
|
||||
if(!sb)continue;
|
||||
++sb;
|
||||
while(isspace(*sb))sb++;
|
||||
se = (unsigned char *)strchr((char *)sb, '\r');
|
||||
if(se) *se = 0;
|
||||
(se = (unsigned char *)strchr((char *)sb, '\r')) || (se = (unsigned char *)strchr((char *)sb, '\n'));
|
||||
if(se) {
|
||||
c = *se;
|
||||
*se = 0;
|
||||
}
|
||||
if(!param->hostname){
|
||||
parsehostname((char *)sb, param, 80);
|
||||
}
|
||||
@@ -460,7 +464,7 @@ for(;;){
|
||||
myfree(req);
|
||||
req = newbuf;
|
||||
}
|
||||
if(se)*se = '\r';
|
||||
if(se)*se = c;
|
||||
}
|
||||
if(ftp && i > 13 && (!strncasecmp((char *)(buf+inbuf), "authorization", 13))){
|
||||
sb = (unsigned char *)strchr((char *)(buf+inbuf), ':');
|
||||
@@ -490,7 +494,7 @@ for(;;){
|
||||
if(!sb)continue;
|
||||
++sb;
|
||||
while(isspace(*sb))sb++;
|
||||
sscanf(sb, "%"PRINTF_INT64_MODIFIER"u",&contentlength64);
|
||||
sscanf((char *)sb, "%"PRINTF_INT64_MODIFIER"u",&contentlength64);
|
||||
if(param->maxtrafout64 && (param->maxtrafout64 < param->statscli64 || contentlength64 > param->maxtrafout64 - param->statscli64)){
|
||||
RETURN(10);
|
||||
}
|
||||
@@ -510,7 +514,7 @@ for(;;){
|
||||
|
||||
buf[inbuf] = 0;
|
||||
|
||||
reqsize = (int)strlen(req);
|
||||
reqsize = (int)strlen((char *)req);
|
||||
reqbufsize = reqsize + 1;
|
||||
|
||||
#ifndef WITHMAIN
|
||||
@@ -529,7 +533,7 @@ for(;;){
|
||||
uint64_t newlen64;
|
||||
newlen64 = sockfillbuffcli(param, (unsigned long)contentlength64, CONNECTION_S);
|
||||
if(newlen64 == contentlength64) {
|
||||
action = handledatfltcli(param, ¶m->clibuf, ¶m->clibufsize, 0, ¶m->cliinbuf);
|
||||
action = handledatfltcli(param, ¶m->clibuf, (int *)¶m->clibufsize, 0, (int *)¶m->cliinbuf);
|
||||
if(action == HANDLED){
|
||||
RETURN(0);
|
||||
}
|
||||
@@ -803,7 +807,8 @@ for(;;){
|
||||
|
||||
else {
|
||||
redirect = 1;
|
||||
if(socksend(param->remsock, req , (res = (int)strlen((char *)req)), conf.timeouts[STRING_L]) != res) {
|
||||
res = (int)strlen((char *)req);
|
||||
if(socksend(param->remsock, req , res, conf.timeouts[STRING_L]) != res) {
|
||||
RETURN(518);
|
||||
}
|
||||
param->statscli64 += res;
|
||||
@@ -893,7 +898,7 @@ for(;;){
|
||||
if(!sb)continue;
|
||||
++sb;
|
||||
while(isspace(*sb))sb++;
|
||||
sscanf(sb, "%"PRINTF_INT64_MODIFIER"u", &contentlength64);
|
||||
sscanf((char *)sb, "%"PRINTF_INT64_MODIFIER"u", &contentlength64);
|
||||
hascontent = 1;
|
||||
if(param->unsafefilter && param->ndatfilterssrv > 0) {
|
||||
hascontent = 2;
|
||||
@@ -909,7 +914,7 @@ for(;;){
|
||||
if(!sb)continue;
|
||||
++sb;
|
||||
while(isspace(*sb))sb++;
|
||||
if(!strncasecmp(sb, "chunked", 7)){
|
||||
if(!strncasecmp((char *)sb, "chunked", 7)){
|
||||
param->chunked = 1;
|
||||
}
|
||||
}
|
||||
@@ -959,7 +964,7 @@ for(;;){
|
||||
uint64_t newlen;
|
||||
newlen = (uint64_t)sockfillbuffsrv(param, (unsigned long) contentlength64, CONNECTION_S);
|
||||
if(newlen == contentlength64) {
|
||||
action = handledatfltsrv(param, ¶m->srvbuf, ¶m->srvbufsize, 0, ¶m->srvinbuf);
|
||||
action = handledatfltsrv(param, ¶m->srvbuf, (int *)¶m->srvbufsize, 0, (int *)¶m->srvinbuf);
|
||||
param->nolongdatfilter = 1;
|
||||
if(action == HANDLED){
|
||||
RETURN(0);
|
||||
@@ -992,7 +997,7 @@ for(;;){
|
||||
if((param->chunked || contentlength64 > 0) && param->operation != HTTP_HEAD && res != 204 && res != 304) {
|
||||
do {
|
||||
if(param->chunked){
|
||||
char smallbuf[32];
|
||||
unsigned char smallbuf[32];
|
||||
while ((i = sockgetlinebuf(param, SERVER, smallbuf, 30, '\n', conf.timeouts[STRING_S])) == 2) {
|
||||
if (socksend(param->clisock, smallbuf, i, conf.timeouts[STRING_S]) != i){
|
||||
RETURN(533);
|
||||
@@ -1015,7 +1020,7 @@ for(;;){
|
||||
}
|
||||
smallbuf[i] = 0;
|
||||
contentlength64 = 0;
|
||||
sscanf(smallbuf, "%"PRINTF_INT64_MODIFIER"x", &contentlength64);
|
||||
sscanf((char *)smallbuf, "%"PRINTF_INT64_MODIFIER"x", &contentlength64);
|
||||
if(contentlength64 == 0) {
|
||||
param->chunked = 2;
|
||||
}
|
||||
@@ -1048,7 +1053,7 @@ REQUESTEND:
|
||||
RETURN(0);
|
||||
}
|
||||
if(param->transparent && (!ckeepalive || !keepalive)) {RETURN (0);}
|
||||
logurl(param, buf, (char *)req, ftp);
|
||||
logurl(param, (char *)buf, (char *)req, ftp);
|
||||
param->status = 0;
|
||||
|
||||
}
|
||||
@@ -1095,7 +1100,7 @@ CLEANRET:
|
||||
socksend(param->clisock, (unsigned char *)proxy_stringtable[0], (int)strlen(proxy_stringtable[0]), conf.timeouts[STRING_S]);
|
||||
}
|
||||
}
|
||||
logurl(param, buf, (char *)req, ftp);
|
||||
logurl(param, (char *)buf, (char *)req, ftp);
|
||||
if(req)myfree(req);
|
||||
if(buf)myfree(buf);
|
||||
if(ftpbase)myfree(ftpbase);
|
||||
|
||||
+2
-5
@@ -104,7 +104,7 @@
|
||||
#define PTHREAD_STACK_MIN 32768
|
||||
#define sockerror strerror
|
||||
#endif
|
||||
#define daemonize() daemon(1,1)
|
||||
#define daemonize() {if(fork())exit(0); else setsid();}
|
||||
#define SLEEPTIME 1000
|
||||
#ifndef O_BINARY
|
||||
#define O_BINARY 0
|
||||
@@ -122,8 +122,6 @@
|
||||
#ifdef _WIN32
|
||||
#define strcasecmp stricmp
|
||||
#define strncasecmp strnicmp
|
||||
#else
|
||||
extern pthread_attr_t pa;
|
||||
#endif
|
||||
|
||||
#ifndef SOCKET_ERROR
|
||||
@@ -235,7 +233,7 @@ void mschap(const unsigned char *win_password,
|
||||
struct hashtable;
|
||||
void hashadd(struct hashtable *ht, const unsigned char* name, unsigned char* value, time_t expires);
|
||||
|
||||
void parsehost(int family, char *host, struct sockaddr *sa);
|
||||
void parsehost(int family, unsigned char *host, struct sockaddr *sa);
|
||||
int parsehostname(char *hostname, struct clientparam *param, unsigned short port);
|
||||
int parseusername(char *username, struct clientparam *param, int extpasswd);
|
||||
int parseconnusername(char *username, struct clientparam *param, int extpasswd, unsigned short port);
|
||||
@@ -316,7 +314,6 @@ extern pthread_mutex_t hash_mutex;
|
||||
extern pthread_mutex_t tc_mutex;
|
||||
extern pthread_mutex_t pwl_mutex;
|
||||
extern pthread_mutex_t log_mutex;
|
||||
extern int logmutexinit;
|
||||
|
||||
extern struct datatype datatypes[64];
|
||||
|
||||
|
||||
+60
-44
@@ -8,6 +8,8 @@
|
||||
|
||||
#include "proxy.h"
|
||||
|
||||
pthread_mutex_t log_mutex;
|
||||
int logmutexinit = 0;
|
||||
|
||||
#define param ((struct clientparam *) p)
|
||||
#ifdef _WIN32
|
||||
@@ -22,21 +24,21 @@ void * threadfunc (void *p) {
|
||||
param->remsock = so._accept(param->srv->cbsock, (struct sockaddr*)¶m->sinsr, &size);
|
||||
if(param->remsock == INVALID_SOCKET) {
|
||||
param->res = 13;
|
||||
param->srv->logfunc(param, "Connect back accept() failed");
|
||||
param->srv->logfunc(param, (unsigned char *)"Connect back accept() failed");
|
||||
continue;
|
||||
}
|
||||
#ifndef WITHMAIN
|
||||
memcpy(¶m->req, ¶m->sinsr, size);
|
||||
param->req = param->sinsr;
|
||||
if(param->srv->acl) param->res = checkACL(param);
|
||||
if(param->res){
|
||||
param->srv->logfunc(param, "Connect back ACL failed");
|
||||
param->srv->logfunc(param, (unsigned char *)"Connect back ACL failed");
|
||||
so._closesocket(param->remsock);
|
||||
param->remsock = INVALID_SOCKET;
|
||||
continue;
|
||||
}
|
||||
#endif
|
||||
if(so._sendto(param->remsock, "C", 1, 0, (struct sockaddr*)¶m->sinsr, size) != 1){
|
||||
param->srv->logfunc(param, "Connect back sending command failed");
|
||||
param->srv->logfunc(param, (unsigned char *)"Connect back sending command failed");
|
||||
so._closesocket(param->remsock);
|
||||
param->remsock = INVALID_SOCKET;
|
||||
continue;
|
||||
@@ -124,7 +126,8 @@ int MODULEMAINFUNC (int argc, char** argv){
|
||||
" -fFORMAT logging format (see documentation)\n"
|
||||
" -l log to stderr\n"
|
||||
" -lFILENAME log to FILENAME\n"
|
||||
" -bBUFSIZE size of network buffer (default 4096 for TCP, 16384 for UDP)\n"
|
||||
" -b(BUFSIZE) size of network buffer (default 4096 for TCP, 16384 for UDP)\n"
|
||||
" -S(STACKSIZE) value to add to default client thread stack size\n"
|
||||
" -t be silent (do not log service start/stop)\n"
|
||||
" -iIP ip address or internal interface (clients are expected to connect)\n"
|
||||
" -eIP ip address or external interface (outgoing connection will have this)\n"
|
||||
@@ -138,6 +141,7 @@ int MODULEMAINFUNC (int argc, char** argv){
|
||||
#ifdef _WIN32
|
||||
unsigned long ul = 1;
|
||||
#else
|
||||
pthread_attr_t pa;
|
||||
#ifdef STDMAIN
|
||||
int inetd = 0;
|
||||
#endif
|
||||
@@ -173,12 +177,13 @@ int MODULEMAINFUNC (int argc, char** argv){
|
||||
#else
|
||||
signal(SIGPIPE, SIG_IGN);
|
||||
|
||||
pthread_attr_init(&pa);
|
||||
pthread_attr_setstacksize(&pa,PTHREAD_STACK_MIN + 8192);
|
||||
pthread_attr_setdetachstate(&pa,PTHREAD_CREATE_DETACHED);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
if(!logmutexinit){
|
||||
pthread_mutex_init(&log_mutex, NULL);
|
||||
logmutexinit = 1;
|
||||
}
|
||||
|
||||
srvinit(&srv, &defparam);
|
||||
srv.pf = childdef.pf;
|
||||
@@ -209,7 +214,7 @@ int MODULEMAINFUNC (int argc, char** argv){
|
||||
case 'l':
|
||||
srv.logfunc = logstdout;
|
||||
if(srv.logtarget) myfree(srv.logtarget);
|
||||
srv.logtarget = mystrdup((unsigned char*)argv[i] + 2);
|
||||
srv.logtarget = (unsigned char *)mystrdup(argv[i] + 2);
|
||||
if(argv[i][2]) {
|
||||
if(argv[i][2]=='@'){
|
||||
|
||||
@@ -232,17 +237,20 @@ int MODULEMAINFUNC (int argc, char** argv){
|
||||
}
|
||||
break;
|
||||
case 'i':
|
||||
getip46(46, argv[i]+2, (struct sockaddr *)&srv.intsa);
|
||||
getip46(46, (unsigned char *)argv[i]+2, (struct sockaddr *)&srv.intsa);
|
||||
break;
|
||||
case 'e':
|
||||
{
|
||||
#ifndef NOIPV6
|
||||
struct sockaddr_in6 sa6;
|
||||
memset(&sa6, 0, sizeof(sa6));
|
||||
error = !getip46(46, argv[i]+2, (struct sockaddr *)&sa6);
|
||||
if(!error) memcpy((*SAFAMILY(&sa6)==AF_INET)?(void *)&srv.extsa:(void *)&srv.extsa6, &sa6, sizeof(sa6));
|
||||
error = !getip46(46, (unsigned char *)argv[i]+2, (struct sockaddr *)&sa6);
|
||||
if(!error) {
|
||||
if (*SAFAMILY(&sa6)==AF_INET) srv.extsa = sa6;
|
||||
else srv.extsa6 = sa6;
|
||||
}
|
||||
#else
|
||||
error = !getip46(46, argv[i]+2, (struct sockaddr *)&srv.extsa);
|
||||
error = !getip46(46, (unsigned char *)argv[i]+2, (struct sockaddr *)&srv.extsa);
|
||||
#endif
|
||||
}
|
||||
break;
|
||||
@@ -264,7 +272,7 @@ int MODULEMAINFUNC (int argc, char** argv){
|
||||
case 'I':
|
||||
size = sizeof(defparam.sincl);
|
||||
if(so._getsockname(0, (struct sockaddr*)&defparam.sincl, &size) ||
|
||||
SAFAMILY(&defparam.sincl) != AF_INET) error = 1;
|
||||
*SAFAMILY(&defparam.sincl) != AF_INET) error = 1;
|
||||
|
||||
else inetd = 1;
|
||||
break;
|
||||
@@ -272,7 +280,7 @@ int MODULEMAINFUNC (int argc, char** argv){
|
||||
#endif
|
||||
case 'f':
|
||||
if(srv.logformat)myfree(srv.logformat);
|
||||
srv.logformat = mystrdup((unsigned char *)argv[i] + 2);
|
||||
srv.logformat = (unsigned char *)mystrdup(argv[i] + 2);
|
||||
break;
|
||||
case 't':
|
||||
srv.silent = 1;
|
||||
@@ -281,11 +289,11 @@ int MODULEMAINFUNC (int argc, char** argv){
|
||||
hostname = argv[i] + 2;
|
||||
break;
|
||||
case 'r':
|
||||
cbc_string = mystrdup(argv[i] + 2);
|
||||
cbc_string = (unsigned char *)mystrdup(argv[i] + 2);
|
||||
iscbc = 1;
|
||||
break;
|
||||
case 'R':
|
||||
cbl_string = mystrdup(argv[i] + 2);
|
||||
cbl_string = (unsigned char *)mystrdup(argv[i] + 2);
|
||||
iscbl = 1;
|
||||
break;
|
||||
case 'u':
|
||||
@@ -295,6 +303,9 @@ int MODULEMAINFUNC (int argc, char** argv){
|
||||
case 'T':
|
||||
srv.transparent = 1;
|
||||
break;
|
||||
case 'S':
|
||||
srv.stacksize = atoi(argv[i]+2);
|
||||
break;
|
||||
case 's':
|
||||
case 'a':
|
||||
srv.singlepacket = 1 + atoi(argv[i]+2);
|
||||
@@ -386,7 +397,7 @@ int MODULEMAINFUNC (int argc, char** argv){
|
||||
if(! (newparam = myalloc (sizeof(defparam)))){
|
||||
return 2;
|
||||
};
|
||||
memcpy(newparam, &defparam, sizeof(defparam));
|
||||
*newparam = defparam;
|
||||
return((*srv.pf)((void *)newparam)? 1:0);
|
||||
|
||||
}
|
||||
@@ -438,10 +449,10 @@ int MODULEMAINFUNC (int argc, char** argv){
|
||||
#endif
|
||||
srv.srvsock = sock;
|
||||
opt = 1;
|
||||
if(so._setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (unsigned char *)&opt, sizeof(int)))perror("setsockopt()");
|
||||
if(so._setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *)&opt, sizeof(int)))perror("setsockopt()");
|
||||
#ifdef SO_REUSEPORT
|
||||
opt = 1;
|
||||
so._setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, (unsigned char *)&opt, sizeof(int));
|
||||
so._setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, (char *)&opt, sizeof(int));
|
||||
#endif
|
||||
}
|
||||
size = sizeof(srv.intsa);
|
||||
@@ -472,22 +483,22 @@ int MODULEMAINFUNC (int argc, char** argv){
|
||||
if(iscbl){
|
||||
parsehost(srv.family, cbl_string, (struct sockaddr *)&cbsa);
|
||||
if((srv.cbsock=so._socket(SASOCK(&cbsa), SOCK_STREAM, IPPROTO_TCP))==INVALID_SOCKET) {
|
||||
(*srv.logfunc)(&defparam, "Failed to allocate connect back socket");
|
||||
(*srv.logfunc)(&defparam, (unsigned char *)"Failed to allocate connect back socket");
|
||||
return -6;
|
||||
}
|
||||
opt = 1;
|
||||
so._setsockopt(srv.cbsock, SOL_SOCKET, SO_REUSEADDR, (unsigned char *)&opt, sizeof(int));
|
||||
so._setsockopt(srv.cbsock, SOL_SOCKET, SO_REUSEADDR, (char *)&opt, sizeof(int));
|
||||
#ifdef SO_REUSEPORT
|
||||
opt = 1;
|
||||
so._setsockopt(srv.cbsock, SOL_SOCKET, SO_REUSEPORT, (unsigned char *)&opt, sizeof(int));
|
||||
so._setsockopt(srv.cbsock, SOL_SOCKET, SO_REUSEPORT, (char *)&opt, sizeof(int));
|
||||
#endif
|
||||
|
||||
if(so._bind(srv.cbsock, (struct sockaddr*)&cbsa, SASIZE(&cbsa))==-1) {
|
||||
(*srv.logfunc)(&defparam, "Failed to bind connect back socket");
|
||||
(*srv.logfunc)(&defparam, (unsigned char *)"Failed to bind connect back socket");
|
||||
return -7;
|
||||
}
|
||||
if(so._listen(srv.cbsock, 1 + (srv.maxchild>>4))==-1) {
|
||||
(*srv.logfunc)(&defparam, "Failed to listen connect back socket");
|
||||
(*srv.logfunc)(&defparam, (unsigned char *)"Failed to listen connect back socket");
|
||||
return -8;
|
||||
}
|
||||
}
|
||||
@@ -495,6 +506,11 @@ int MODULEMAINFUNC (int argc, char** argv){
|
||||
srv.fds.fd = sock;
|
||||
srv.fds.events = POLLIN;
|
||||
|
||||
#ifndef _WIN32
|
||||
pthread_attr_init(&pa);
|
||||
pthread_attr_setstacksize(&pa,PTHREAD_STACK_MIN + (16384 + srv.stacksize));
|
||||
pthread_attr_setdetachstate(&pa,PTHREAD_CREATE_DETACHED);
|
||||
#endif
|
||||
|
||||
for (;;) {
|
||||
for(;;){
|
||||
@@ -538,7 +554,7 @@ int MODULEMAINFUNC (int argc, char** argv){
|
||||
usleep(SLEEPTIME);
|
||||
continue;
|
||||
}
|
||||
if(so._recvfrom(new_sock,buf,1,0,(struct sockaddr*)&defparam.sincr, &size) != 1) {
|
||||
if(so._recvfrom(new_sock,(char *)buf,1,0,(struct sockaddr*)&defparam.sincr, &size) != 1) {
|
||||
so._closesocket(new_sock);
|
||||
new_sock = INVALID_SOCKET;
|
||||
usleep(SLEEPTIME);
|
||||
@@ -608,8 +624,8 @@ int MODULEMAINFUNC (int argc, char** argv){
|
||||
#else
|
||||
fcntl(new_sock,F_SETFL,O_NONBLOCK);
|
||||
#endif
|
||||
so._setsockopt(new_sock, SOL_SOCKET, SO_LINGER, (unsigned char *)&lg, sizeof(lg));
|
||||
so._setsockopt(new_sock, SOL_SOCKET, SO_OOBINLINE, (unsigned char *)&opt, sizeof(int));
|
||||
so._setsockopt(new_sock, SOL_SOCKET, SO_LINGER, (char *)&lg, sizeof(lg));
|
||||
so._setsockopt(new_sock, SOL_SOCKET, SO_OOBINLINE, (char *)&opt, sizeof(int));
|
||||
}
|
||||
else {
|
||||
srv.fds.events = 0;
|
||||
@@ -621,8 +637,8 @@ int MODULEMAINFUNC (int argc, char** argv){
|
||||
usleep(SLEEPTIME);
|
||||
continue;
|
||||
};
|
||||
memcpy(newparam, &defparam, sizeof(defparam));
|
||||
if(defparam.hostname)newparam->hostname=strdup(defparam.hostname);
|
||||
*newparam = defparam;
|
||||
if(defparam.hostname)newparam->hostname=(unsigned char *)strdup((char *)defparam.hostname);
|
||||
clearstat(newparam);
|
||||
if(!isudp) newparam->clisock = new_sock;
|
||||
#ifndef STDMAIN
|
||||
@@ -642,9 +658,9 @@ int MODULEMAINFUNC (int argc, char** argv){
|
||||
}
|
||||
#ifdef _WIN32
|
||||
#ifndef _WINCE
|
||||
h = (HANDLE)_beginthreadex((LPSECURITY_ATTRIBUTES )NULL, (unsigned)16384, threadfunc, (void *) newparam, 0, &thread);
|
||||
h = (HANDLE)_beginthreadex((LPSECURITY_ATTRIBUTES )NULL, (unsigned)(16384 + srv.stacksize), (void *)threadfunc, (void *) newparam, 0, &thread);
|
||||
#else
|
||||
h = (HANDLE)CreateThread((LPSECURITY_ATTRIBUTES )NULL, (unsigned)16384, threadfunc, (void *) newparam, 0, &thread);
|
||||
h = (HANDLE)CreateThread((LPSECURITY_ATTRIBUTES )NULL, (unsigned)(16384 + srv.stacksize), (void *)threadfunc, (void *) newparam, 0, &thread);
|
||||
#endif
|
||||
srv.childcount++;
|
||||
if (h) {
|
||||
@@ -702,14 +718,15 @@ void srvinit(struct srvparam * srv, struct clientparam *param){
|
||||
srv->version = conf.paused;
|
||||
srv->logfunc = conf.logfunc;
|
||||
if(srv->logformat)myfree(srv->logformat);
|
||||
srv->logformat = conf.logformat? mystrdup(conf.logformat) : NULL;
|
||||
srv->logformat = conf.logformat? (unsigned char *)mystrdup((char *)conf.logformat) : NULL;
|
||||
srv->authfunc = conf.authfunc;
|
||||
srv->usentlm = 0;
|
||||
srv->maxchild = conf.maxchild;
|
||||
srv->stacksize = conf.stacksize;
|
||||
srv->time_start = time(NULL);
|
||||
if(conf.logtarget){
|
||||
if(srv->logtarget) myfree(srv->logtarget);
|
||||
srv->logtarget = mystrdup(conf.logtarget);
|
||||
srv->logtarget = (unsigned char *)mystrdup((char *)conf.logtarget);
|
||||
}
|
||||
srv->srvsock = INVALID_SOCKET;
|
||||
srv->logdumpsrv = conf.logdumpsrv;
|
||||
@@ -721,10 +738,10 @@ void srvinit(struct srvparam * srv, struct clientparam *param){
|
||||
param->remsock = param->clisock = param->ctrlsock = param->ctrlsocksrv = INVALID_SOCKET;
|
||||
*SAFAMILY(¶m->req) = *SAFAMILY(¶m->sinsl) = *SAFAMILY(¶m->sinsr) = *SAFAMILY(¶m->sincr) = *SAFAMILY(¶m->sincl) = AF_INET;
|
||||
pthread_mutex_init(&srv->counter_mutex, NULL);
|
||||
memcpy(&srv->intsa, &conf.intsa, sizeof(srv->intsa));
|
||||
memcpy(&srv->extsa, &conf.extsa, sizeof(srv->extsa));
|
||||
srv->intsa = conf.intsa;
|
||||
srv->extsa = conf.extsa;
|
||||
#ifndef NOIPV6
|
||||
memcpy(&srv->extsa6, &conf.extsa6, sizeof(srv->extsa6));
|
||||
srv->extsa6 = conf.extsa6;
|
||||
#endif
|
||||
}
|
||||
|
||||
@@ -732,7 +749,7 @@ void srvinit2(struct srvparam * srv, struct clientparam *param){
|
||||
if(srv->logformat){
|
||||
char *s;
|
||||
if(*srv->logformat == '-' && (s = strchr((char *)srv->logformat + 1, '+')) && s[1]){
|
||||
char* logformat = srv->logformat;
|
||||
unsigned char* logformat = srv->logformat;
|
||||
|
||||
*s = 0;
|
||||
srv->nonprintable = (unsigned char *)mystrdup((char *)srv->logformat + 1);
|
||||
@@ -748,13 +765,12 @@ void srvinit2(struct srvparam * srv, struct clientparam *param){
|
||||
*SAFAMILY(¶m->sinsl) = AF_INET;
|
||||
*SAFAMILY(¶m->sinsr) = AF_INET;
|
||||
*SAFAMILY(¶m->req) = AF_INET;
|
||||
memcpy(¶m->sincr, &srv->intsa, sizeof(param->sincr));
|
||||
memcpy(¶m->sincl, &srv->intsa, sizeof(param->sincl));
|
||||
param->sincr = param->sincl = srv->intsa;
|
||||
#ifndef NOIPV6
|
||||
memcpy(¶m->sinsr, (srv->family == 6 || srv->family == 64)? (void *)&srv->extsa6: (void *)&srv->extsa, sizeof(param->sinsl));
|
||||
#else
|
||||
memcpy(¶m->sinsr, &srv->extsa, sizeof(param->sinsl));
|
||||
if (srv->family == 6 || srv->family == 64) param->sinsr = srv->extsa6;
|
||||
else
|
||||
#endif
|
||||
param->sinsr = srv->extsa;
|
||||
}
|
||||
|
||||
void srvfree(struct srvparam * srv){
|
||||
@@ -911,7 +927,7 @@ void copyfilter (struct filter *filter, struct srvparam *srv){
|
||||
|
||||
if(!filter->filter_open || !(data = (*filter->filter_open)(filter->data, srv))) continue;
|
||||
|
||||
memcpy(srv->filter + srv->nfilters, filter, sizeof(struct filter));
|
||||
srv->filter[srv->nfilters] = *filter;
|
||||
srv->filter[srv->nfilters].data = data;
|
||||
if(srv->nfilters>0)srv->filter[srv->nfilters - 1].next = srv->filter + srv->nfilters;
|
||||
srv->nfilters++;
|
||||
|
||||
+30
-30
@@ -37,7 +37,7 @@ int readreply (struct clientparam* param) {
|
||||
return 0;
|
||||
}
|
||||
buf[i] = 0;
|
||||
res = atoi(buf);
|
||||
res = atoi((char *)buf);
|
||||
myfree(buf);
|
||||
return res;
|
||||
}
|
||||
@@ -51,7 +51,7 @@ int readcommand (struct clientparam* param) {
|
||||
i = sockgetlinebuf(param, CLIENT, buf, bufsize-1, '\n', conf.timeouts[STRING_L]);
|
||||
if(i < 4) return 0;
|
||||
#ifndef WITHMAIN
|
||||
if(!strncasecmp(buf, "MAIL", 4) || !strncasecmp(buf, "RCPT", 4) || !strncasecmp(buf, "STARTTLS", 8) || !strncasecmp(buf, "TURN", 4)){
|
||||
if(!strncasecmp((char *)buf, "MAIL", 4) || !strncasecmp((char *)buf, "RCPT", 4) || !strncasecmp((char *)buf, "STARTTLS", 8) || !strncasecmp((char *)buf, "TURN", 4)){
|
||||
res = handlehdrfilterscli(param, &buf, &bufsize, 0, &i);
|
||||
if(res != PASS) {
|
||||
myfree(buf);
|
||||
@@ -62,7 +62,7 @@ int readcommand (struct clientparam* param) {
|
||||
#endif
|
||||
socksend(param->remsock, buf, i, conf.timeouts[STRING_S]);
|
||||
myfree(buf);
|
||||
if(!strncasecmp(buf, "STARTTLS", 8) || !strncasecmp(buf, "TURN", 4)){
|
||||
if(!strncasecmp((char *)buf, "STARTTLS", 8) || !strncasecmp((char *)buf, "TURN", 4)){
|
||||
ret = 22;
|
||||
}
|
||||
return ret;
|
||||
@@ -118,22 +118,22 @@ void * smtppchild(struct clientparam* param) {
|
||||
else {
|
||||
login = -1;
|
||||
buf[i] = 0;
|
||||
command = mystrdup(buf);
|
||||
command = mystrdup((char *)buf);
|
||||
break;
|
||||
}
|
||||
i = sockgetlinebuf(param, CLIENT, buf, sizeof(buf) - 10, '\n', conf.timeouts[STRING_S]);
|
||||
}
|
||||
if(!login) {RETURN(662);}
|
||||
if(login == 1){
|
||||
socksend(param->clisock, "334 VXNlcm5hbWU6\r\n", 18,conf.timeouts[STRING_S]);
|
||||
socksend(param->clisock, (unsigned char *)"334 VXNlcm5hbWU6\r\n", 18,conf.timeouts[STRING_S]);
|
||||
i = sockgetlinebuf(param, CLIENT, buf, sizeof(buf) - 10, '\n', conf.timeouts[STRING_S]);
|
||||
if(i < 3) {RETURN(663);}
|
||||
buf[i-2] = 0;
|
||||
i = de64(buf,username,255);
|
||||
if(i < 1) {RETURN(664);}
|
||||
username[i] = 0;
|
||||
parseconnusername(username, param, 0, 25);
|
||||
socksend(param->clisock, "334 UGFzc3dvcmQ6\r\n", 18,conf.timeouts[STRING_S]);
|
||||
parseconnusername((char *)username, param, 0, 25);
|
||||
socksend(param->clisock, (unsigned char *)"334 UGFzc3dvcmQ6\r\n", 18,conf.timeouts[STRING_S]);
|
||||
i = sockgetlinebuf(param, CLIENT, buf, sizeof(buf) - 10, '\n', conf.timeouts[STRING_S]);
|
||||
if(i < 2) {RETURN(665);}
|
||||
buf[i-2] = 0;
|
||||
@@ -141,7 +141,7 @@ void * smtppchild(struct clientparam* param) {
|
||||
if(i < 0) {RETURN(666);}
|
||||
username[i] = 0;
|
||||
if(param->extpassword) myfree(param->extpassword);
|
||||
param->extpassword = mystrdup(username);
|
||||
param->extpassword = (unsigned char *)mystrdup((char *)username);
|
||||
}
|
||||
else if(login == 2){
|
||||
if(i > 13) {
|
||||
@@ -149,7 +149,7 @@ void * smtppchild(struct clientparam* param) {
|
||||
i = de64(buf+11,username,255);
|
||||
}
|
||||
else {
|
||||
socksend(param->clisock, "334\r\n", 5,conf.timeouts[STRING_S]);
|
||||
socksend(param->clisock, (unsigned char *)"334\r\n", 5,conf.timeouts[STRING_S]);
|
||||
i = sockgetlinebuf(param, CLIENT, buf, sizeof(buf) - 10, '\n', conf.timeouts[STRING_S]);
|
||||
if(i < 3) {RETURN(667);}
|
||||
buf[i-2] = 0;
|
||||
@@ -157,18 +157,18 @@ void * smtppchild(struct clientparam* param) {
|
||||
}
|
||||
if(i < 3 || *username) {RETURN(668);}
|
||||
username[i] = 0;
|
||||
parseconnusername(username+1, param, 0, 25);
|
||||
res = (int)strlen(username+1) + 2;
|
||||
parseconnusername((char *)username+1, param, 0, 25);
|
||||
res = (int)strlen((char *)username+1) + 2;
|
||||
if(res < i){
|
||||
if(param->extpassword) myfree(param->extpassword);
|
||||
param->extpassword = mystrdup(username + res);
|
||||
param->extpassword = (unsigned char *)mystrdup((char *)username + res);
|
||||
}
|
||||
}
|
||||
|
||||
#ifndef WITHMAIN
|
||||
{
|
||||
int action, reqbufsize, reqsize;
|
||||
reqbufsize = reqsize = (int)strlen(param->hostname) + 1;
|
||||
reqbufsize = reqsize = (int)strlen((char *)param->hostname) + 1;
|
||||
action = handlereqfilters(param, ¶m->hostname, &reqbufsize, 0, &reqsize);
|
||||
if(action == HANDLED){
|
||||
RETURN(0);
|
||||
@@ -186,9 +186,9 @@ void * smtppchild(struct clientparam* param) {
|
||||
if( i < 3 ) {RETURN(671);}
|
||||
buf[i] = 0;
|
||||
if(strncasecmp((char *)buf, "220", 3)||!strncasecmp((char *)buf+4, "PROXY", 5)){RETURN(672);}
|
||||
i = sprintf(buf, "EHLO [");
|
||||
i += myinet_ntop(*SAFAMILY(¶m->sinsl), SAADDR(¶m->sinsl), buf+strlen(buf), 64);
|
||||
i += sprintf(buf+strlen(buf), "]\r\n");
|
||||
i = sprintf((char *)buf, "EHLO [");
|
||||
i += myinet_ntop(*SAFAMILY(¶m->sinsl), SAADDR(¶m->sinsl), (char *)buf+strlen((char *)buf), 64);
|
||||
i += sprintf((char *)buf+strlen((char *)buf), "]\r\n");
|
||||
if(socksend(param->remsock, buf, i, conf.timeouts[STRING_S])!= i) {RETURN(673);}
|
||||
param->statscli64+=i;
|
||||
param->nwrites++;
|
||||
@@ -204,44 +204,44 @@ void * smtppchild(struct clientparam* param) {
|
||||
if(i<3) {RETURN(672);}
|
||||
if(!command || (param->extusername && param->extpassword)){
|
||||
if(!param->extusername || !*param->extusername || !param->extpassword || !*param->extpassword || !login){
|
||||
socksend(param->clisock, "235 auth required\r\n", 19,conf.timeouts[STRING_S]);
|
||||
socksend(param->clisock, (unsigned char *)"235 auth required\r\n", 19,conf.timeouts[STRING_S]);
|
||||
}
|
||||
if ((login & 1)) {
|
||||
socksend(param->remsock, "AUTH LOGIN\r\n", 12, conf.timeouts[STRING_S]);
|
||||
socksend(param->remsock, (unsigned char *)"AUTH LOGIN\r\n", 12, conf.timeouts[STRING_S]);
|
||||
param->statscli64+=12;
|
||||
param->nwrites++;
|
||||
i = sockgetlinebuf(param, SERVER, buf, sizeof(buf) - 1, '\n', conf.timeouts[STRING_L]);
|
||||
if(i<4 || strncasecmp((char *)buf, "334", 3)) {RETURN(680);}
|
||||
en64(param->extusername, buf, (int)strlen(param->extusername));
|
||||
socksend(param->remsock, buf, (int)strlen(buf), conf.timeouts[STRING_S]);
|
||||
socksend(param->remsock, "\r\n", 2, conf.timeouts[STRING_S]);
|
||||
en64(param->extusername, buf, (int)strlen((char *)param->extusername));
|
||||
socksend(param->remsock, buf, (int)strlen((char *)buf), conf.timeouts[STRING_S]);
|
||||
socksend(param->remsock, (unsigned char *)"\r\n", 2, conf.timeouts[STRING_S]);
|
||||
param->statscli64+=(i+2);
|
||||
param->nwrites+=2;
|
||||
i = sockgetlinebuf(param, SERVER, buf, sizeof(buf) - 1, '\n', conf.timeouts[STRING_L]);
|
||||
if(i<4 || strncasecmp((char *)buf, "334", 3)) {RETURN(681);}
|
||||
en64(param->extpassword, buf, (int)strlen(param->extpassword));
|
||||
socksend(param->remsock, buf, (int)strlen(buf), conf.timeouts[STRING_S]);
|
||||
socksend(param->remsock, "\r\n", 2, conf.timeouts[STRING_S]);
|
||||
en64(param->extpassword, buf, (int)strlen((char *)param->extpassword));
|
||||
socksend(param->remsock, buf, (int)strlen((char *)buf), conf.timeouts[STRING_S]);
|
||||
socksend(param->remsock, (unsigned char *)"\r\n", 2, conf.timeouts[STRING_S]);
|
||||
param->statscli64+=(i+2);
|
||||
param->nwrites+=2;
|
||||
}
|
||||
else if((login & 2)){
|
||||
socksend(param->remsock, "AUTH PLAIN\r\n", 12, conf.timeouts[STRING_S]);
|
||||
socksend(param->remsock, (unsigned char *)"AUTH PLAIN\r\n", 12, conf.timeouts[STRING_S]);
|
||||
param->statscli64+=(12);
|
||||
param->nwrites++;
|
||||
i = sockgetlinebuf(param, SERVER, buf, sizeof(buf) - 1, '\n', conf.timeouts[STRING_L]);
|
||||
if(i<4 || strncasecmp((char *)buf, "334", 3)) {RETURN(682);}
|
||||
*username = 0;
|
||||
i = (int)strlen(param->extusername) + 1;
|
||||
i = (int)strlen((char *)param->extusername) + 1;
|
||||
memcpy(username+1, param->extusername, i);
|
||||
i++;
|
||||
res = (int)strlen(param->extpassword);
|
||||
res = (int)strlen((char *)param->extpassword);
|
||||
memcpy(username + i, param->extpassword, res);
|
||||
i+=res;
|
||||
en64(username, buf, i);
|
||||
i = (int)strlen(buf);
|
||||
i = (int)strlen((char *)buf);
|
||||
socksend(param->remsock, buf, i, conf.timeouts[STRING_S]);
|
||||
socksend(param->remsock, "\r\n", 2, conf.timeouts[STRING_S]);
|
||||
socksend(param->remsock, (unsigned char *)"\r\n", 2, conf.timeouts[STRING_S]);
|
||||
param->statscli64+=(i+2);
|
||||
param->nwrites+=2;
|
||||
}
|
||||
@@ -266,7 +266,7 @@ void * smtppchild(struct clientparam* param) {
|
||||
}
|
||||
#endif
|
||||
i = (int)strlen(command);
|
||||
if(res != 2) socksend(param->remsock, command, i, conf.timeouts[STRING_S]);
|
||||
if(res != 2) socksend(param->remsock, (unsigned char *)command, i, conf.timeouts[STRING_S]);
|
||||
}
|
||||
#ifndef WITHMAIN
|
||||
|
||||
|
||||
+3
-3
@@ -22,7 +22,7 @@ int socksend(SOCKET sock, unsigned char * buf, int bufsize, int to){
|
||||
res = so._poll(&fds, 1, to*1000);
|
||||
if(res < 0 && (errno == EAGAIN || errno == EINTR)) continue;
|
||||
if(res < 1) break;
|
||||
res = so._send(sock, buf + sent, bufsize - sent, 0);
|
||||
res = so._send(sock, (char *)buf + sent, bufsize - sent, 0);
|
||||
if(res < 0) {
|
||||
if(errno == EAGAIN || errno == EINTR) continue;
|
||||
break;
|
||||
@@ -45,7 +45,7 @@ int socksendto(SOCKET sock, struct sockaddr * sin, unsigned char * buf, int bufs
|
||||
res = so._poll(&fds, 1, to);
|
||||
if(res < 0 && (errno == EAGAIN || errno == EINTR)) continue;
|
||||
if(res < 1) break;
|
||||
res = so._sendto(sock, buf + sent, bufsize - sent, 0, sin, SASIZE(sin));
|
||||
res = so._sendto(sock, (char *)buf + sent, bufsize - sent, 0, sin, SASIZE(sin));
|
||||
if(res < 0) {
|
||||
if(errno != EAGAIN && errno != EINTR) break;
|
||||
continue;
|
||||
@@ -66,7 +66,7 @@ int sockrecvfrom(SOCKET sock, struct sockaddr * sin, unsigned char * buf, int bu
|
||||
if (so._poll(&fds, 1, to)<1) return 0;
|
||||
sasize = SASIZE(sin);
|
||||
do {
|
||||
res = so._recvfrom(sock, buf, bufsize, 0, (struct sockaddr *)sin, &sasize);
|
||||
res = so._recvfrom(sock, (char *)buf, bufsize, 0, (struct sockaddr *)sin, &sasize);
|
||||
} while (res < 0 && (errno == EAGAIN || errno == EINTR));
|
||||
return res;
|
||||
}
|
||||
|
||||
+8
-8
@@ -49,14 +49,14 @@ int sockmap(struct clientparam * param, int timeo){
|
||||
if(action != PASS) return 19;
|
||||
if(!param->nolongdatfilter){
|
||||
if(param->cliinbuf > param->clioffset){
|
||||
action = handledatfltcli(param, ¶m->clibuf, ¶m->clibufsize, param->clioffset, ¶m->cliinbuf);
|
||||
action = handledatfltcli(param, ¶m->clibuf, (int *)¶m->clibufsize, param->clioffset, (int *)¶m->cliinbuf);
|
||||
if(action == HANDLED){
|
||||
return 0;
|
||||
}
|
||||
if(action != PASS) return 19;
|
||||
}
|
||||
if(param->srvinbuf > param->srvoffset){
|
||||
action = handledatfltsrv(param, ¶m->srvbuf, ¶m->srvbufsize, param->srvoffset, ¶m->srvinbuf);
|
||||
action = handledatfltsrv(param, ¶m->srvbuf, (int *)¶m->srvbufsize, param->srvoffset, (int *)¶m->srvinbuf);
|
||||
if(action == HANDLED){
|
||||
return 0;
|
||||
}
|
||||
@@ -127,7 +127,7 @@ int sockmap(struct clientparam * param, int timeo){
|
||||
if(param->bandlimfunc) {
|
||||
sleeptime = (*param->bandlimfunc)(param, param->srvinbuf - param->srvoffset, 0);
|
||||
}
|
||||
res = so._sendto(param->clisock, param->srvbuf + param->srvoffset,(!param->waitserver64 || (param->waitserver64 - received) > (param->srvinbuf - param->srvoffset))? param->srvinbuf - param->srvoffset : (int)(param->waitserver64 - received), 0, (struct sockaddr*)¶m->sincr, sasize);
|
||||
res = so._sendto(param->clisock, (char *)param->srvbuf + param->srvoffset,(!param->waitserver64 || (param->waitserver64 - received) > (param->srvinbuf - param->srvoffset))? param->srvinbuf - param->srvoffset : (int)(param->waitserver64 - received), 0, (struct sockaddr*)¶m->sincr, sasize);
|
||||
if(res < 0) {
|
||||
if(errno != EAGAIN && errno != EINTR) return 96;
|
||||
if(errno == EINTR) usleep(SLEEPTIME);
|
||||
@@ -153,7 +153,7 @@ int sockmap(struct clientparam * param, int timeo){
|
||||
sl1 = (*param->bandlimfunc)(param, 0, param->cliinbuf - param->clioffset);
|
||||
if(sl1 > sleeptime) sleeptime = sl1;
|
||||
}
|
||||
res = so._sendto(param->remsock, param->clibuf + param->clioffset, (!param->waitclient64 || (param->waitclient64 - sent) > (param->cliinbuf - param->clioffset))? param->cliinbuf - param->clioffset : (int)(param->waitclient64 - sent), 0, (struct sockaddr*)¶m->sinsr, sasize);
|
||||
res = so._sendto(param->remsock, (char *)param->clibuf + param->clioffset, (!param->waitclient64 || (param->waitclient64 - sent) > (param->cliinbuf - param->clioffset))? param->cliinbuf - param->clioffset : (int)(param->waitclient64 - sent), 0, (struct sockaddr*)¶m->sinsr, sasize);
|
||||
if(res < 0) {
|
||||
if(errno != EAGAIN && errno != EINTR) return 97;
|
||||
if(errno == EINTR) usleep(SLEEPTIME);
|
||||
@@ -172,7 +172,7 @@ int sockmap(struct clientparam * param, int timeo){
|
||||
#if DEBUGLEVEL > 2
|
||||
(*param->srv->logfunc)(param, "recv from client");
|
||||
#endif
|
||||
res = so._recvfrom(param->clisock, param->clibuf + param->cliinbuf, param->clibufsize - param->cliinbuf, 0, (struct sockaddr *)¶m->sincr, &sasize);
|
||||
res = so._recvfrom(param->clisock, (char *)param->clibuf + param->cliinbuf, param->clibufsize - param->cliinbuf, 0, (struct sockaddr *)¶m->sincr, &sasize);
|
||||
if (res==0) {
|
||||
so._shutdown(param->clisock, SHUT_RDWR);
|
||||
so._closesocket(param->clisock);
|
||||
@@ -187,7 +187,7 @@ int sockmap(struct clientparam * param, int timeo){
|
||||
}
|
||||
param->cliinbuf += res;
|
||||
if(!param->nolongdatfilter){
|
||||
action = handledatfltcli(param, ¶m->clibuf, ¶m->clibufsize, param->cliinbuf - res, ¶m->cliinbuf);
|
||||
action = handledatfltcli(param, ¶m->clibuf, (int *)¶m->clibufsize, param->cliinbuf - res, (int *)¶m->cliinbuf);
|
||||
if(action == HANDLED){
|
||||
return 0;
|
||||
}
|
||||
@@ -203,7 +203,7 @@ int sockmap(struct clientparam * param, int timeo){
|
||||
#endif
|
||||
|
||||
sasize = sizeof(sin);
|
||||
res = so._recvfrom(param->remsock, param->srvbuf + param->srvinbuf, param->srvbufsize - param->srvinbuf, 0, (struct sockaddr *)&sin, &sasize);
|
||||
res = so._recvfrom(param->remsock, (char *)param->srvbuf + param->srvinbuf, param->srvbufsize - param->srvinbuf, 0, (struct sockaddr *)&sin, &sasize);
|
||||
if (res==0) {
|
||||
so._shutdown(param->remsock, SHUT_RDWR);
|
||||
so._closesocket(param->remsock);
|
||||
@@ -220,7 +220,7 @@ int sockmap(struct clientparam * param, int timeo){
|
||||
param->nreads++;
|
||||
param->statssrv64 += res;
|
||||
if(!param->nolongdatfilter){
|
||||
action = handledatfltsrv(param, ¶m->srvbuf, ¶m->srvbufsize, param->srvinbuf - res, ¶m->srvinbuf);
|
||||
action = handledatfltsrv(param, ¶m->srvbuf, (int *)¶m->srvbufsize, param->srvinbuf - res, (int *)¶m->srvinbuf);
|
||||
if(action == HANDLED){
|
||||
return 0;
|
||||
}
|
||||
|
||||
+8
-8
@@ -133,7 +133,7 @@ void * sockschild(struct clientparam* param) {
|
||||
}
|
||||
buf[i] = 0;
|
||||
if(!getip46(param->srv->family, buf, (struct sockaddr *) ¶m->req)) RETURN(100);
|
||||
memcpy(¶m->sinsr, ¶m->req, sizeof(param->req));
|
||||
param->sinsr = param->req;
|
||||
break;
|
||||
default:
|
||||
RETURN(997);
|
||||
@@ -159,7 +159,7 @@ void * sockschild(struct clientparam* param) {
|
||||
if(param->hostname)myfree(param->hostname);
|
||||
param->hostname = (unsigned char *)mystrdup((char *)buf);
|
||||
if(!getip46(param->srv->family, buf, (struct sockaddr *) ¶m->req)) RETURN(100);
|
||||
memcpy(¶m->sinsr, ¶m->req, sizeof(¶m->req));
|
||||
param->sinsr = param->req;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -173,9 +173,9 @@ void * sockschild(struct clientparam* param) {
|
||||
case 3:
|
||||
|
||||
#ifndef NOIPV6
|
||||
memcpy(¶m->sinsl, *SAFAMILY(¶m->req)==AF_INET6? (struct sockaddr *)¶m->srv->extsa6:(struct sockaddr *)¶m->srv->extsa, SASIZE(¶m->req));
|
||||
param->sinsl = *SAFAMILY(¶m->req)==AF_INET6? param->srv->extsa6 : param->srv->extsa;
|
||||
#else
|
||||
memcpy(¶m->sinsl, ¶m->srv->extsa, SASIZE(¶m->req));
|
||||
param->sinsl = param->srv->extsa;
|
||||
#endif
|
||||
if ((param->remsock=so._socket(SASOCK(¶m->req), command == 2? SOCK_STREAM:SOCK_DGRAM, command == 2?IPPROTO_TCP:IPPROTO_UDP)) == INVALID_SOCKET) {RETURN (11);}
|
||||
param->operation = command == 2?BIND:UDPASSOC;
|
||||
@@ -218,7 +218,7 @@ fflush(stderr);
|
||||
param->ctrlsock = param->clisock;
|
||||
param->clisock = so._socket(SASOCK(¶m->sincr), SOCK_DGRAM, IPPROTO_UDP);
|
||||
if(param->clisock == INVALID_SOCKET) {RETURN(11);}
|
||||
memcpy(&sin, ¶m->sincl, sizeof(&sin));
|
||||
sin = param->sincl;
|
||||
*SAPORT(&sin) = 0;
|
||||
if(so._bind(param->clisock,(struct sockaddr *)&sin,SASIZE(&sin))) {RETURN (12);}
|
||||
#if SOCKSTRACE > 0
|
||||
@@ -328,7 +328,7 @@ fflush(stderr);
|
||||
param->res = sockmap(param, conf.timeouts[CONNECTION_S]);
|
||||
break;
|
||||
case 3:
|
||||
memcpy(¶m->sinsr, ¶m->req, sizeof(param->sinsr));
|
||||
param->sinsr = param->req;
|
||||
myfree(buf);
|
||||
if(!(buf = myalloc(LARGEBUFSIZE))) {RETURN(21);}
|
||||
|
||||
@@ -349,7 +349,7 @@ fflush(stderr);
|
||||
}
|
||||
if (fds[1].revents) {
|
||||
sasize = sizeof(sin);
|
||||
if((len = so._recvfrom(param->clisock, buf, 65535, 0, (struct sockaddr *)&sin, &sasize)) <= 10) {
|
||||
if((len = so._recvfrom(param->clisock, (char *)buf, 65535, 0, (struct sockaddr *)&sin, &sasize)) <= 10) {
|
||||
param->res = 464;
|
||||
break;
|
||||
}
|
||||
@@ -413,7 +413,7 @@ fflush(stderr);
|
||||
sasize = sizeof(param->sinsr);
|
||||
buf[0]=buf[1]=buf[2]=0;
|
||||
buf[3]=(*SAFAMILY(¶m->sinsl) == AF_INET)?1:4;
|
||||
if((len = so._recvfrom(param->remsock, buf+6+SAADDRLEN(¶m->sinsl), 65535 - 10, 0, (struct sockaddr *)¶m->sinsr, &sasize)) <= 0) {
|
||||
if((len = so._recvfrom(param->remsock, (char *)buf+6+SAADDRLEN(¶m->sinsl), 65535 - 10, 0, (struct sockaddr *)¶m->sinsr, &sasize)) <= 0) {
|
||||
param->res = 468;
|
||||
break;
|
||||
}
|
||||
|
||||
+13
-10
@@ -217,6 +217,7 @@ typedef enum {
|
||||
R_SOCKS5,
|
||||
R_HTTP,
|
||||
R_POP3,
|
||||
R_SMTP,
|
||||
R_FTP,
|
||||
R_CONNECTP,
|
||||
R_SOCKS4P,
|
||||
@@ -225,7 +226,7 @@ typedef enum {
|
||||
R_SOCKS5B,
|
||||
R_ADMIN,
|
||||
R_ICQ,
|
||||
R_MSN
|
||||
R_EXTIP
|
||||
} REDIRTYPE;
|
||||
|
||||
struct chain {
|
||||
@@ -371,6 +372,7 @@ struct srvparam {
|
||||
int transparent;
|
||||
int nfilters, nreqfilters, nhdrfilterscli, nhdrfilterssrv, npredatfilters, ndatfilterscli, ndatfilterssrv;
|
||||
int family;
|
||||
int stacksize;
|
||||
unsigned bufsize;
|
||||
unsigned logdumpsrv, logdumpcli;
|
||||
#ifndef NOIPV6
|
||||
@@ -421,6 +423,9 @@ struct clientparam {
|
||||
|
||||
REDIRTYPE redirtype;
|
||||
|
||||
uint64_t waitclient64,
|
||||
waitserver64;
|
||||
|
||||
int redirected,
|
||||
operation,
|
||||
nfilters, nreqfilters, nhdrfilterscli, nhdrfilterssrv, npredatfilters, ndatfilterscli, ndatfilterssrv,
|
||||
@@ -428,8 +433,6 @@ struct clientparam {
|
||||
|
||||
int res,
|
||||
status;
|
||||
uint64_t waitclient64,
|
||||
waitserver64;
|
||||
int pwtype,
|
||||
threadid,
|
||||
weight,
|
||||
@@ -490,7 +493,7 @@ struct extparam {
|
||||
struct bandlim * bandlimiter, *bandlimiterout;
|
||||
struct trafcount * trafcounter;
|
||||
struct srvparam *services;
|
||||
int threadinit, counterd, haveerror, rotate, paused, archiverc,
|
||||
int stacksize, threadinit, counterd, haveerror, rotate, paused, archiverc,
|
||||
demon, maxchild, singlepacket, needreload, timetoexit;
|
||||
int authcachetype, authcachetime;
|
||||
int filtermaxsize;
|
||||
@@ -610,13 +613,13 @@ struct sockfuncs {
|
||||
int (WINAPI *_connect)(SOCKET s, const struct sockaddr *name, int namelen);
|
||||
int (WINAPI *_getpeername)(SOCKET s, struct sockaddr * name, int * namelen);
|
||||
int (WINAPI *_getsockname)(SOCKET s, struct sockaddr * name, int * namelen);
|
||||
int (WINAPI *_getsockopt)(SOCKET s, int level, int optname, void * optval, int * optlen);
|
||||
int (WINAPI *_setsockopt)(SOCKET s, int level, int optname, const void *optval, int optlen);
|
||||
int (WINAPI *_getsockopt)(SOCKET s, int level, int optname, char * optval, int * optlen);
|
||||
int (WINAPI *_setsockopt)(SOCKET s, int level, int optname, const char *optval, int optlen);
|
||||
int (WINAPI *_poll)(struct pollfd *fds, unsigned int nfds, int timeout);
|
||||
int (WINAPI *_send)(SOCKET s, const void *msg, int len, int flags);
|
||||
int (WINAPI *_sendto)(SOCKET s, const void *msg, int len, int flags, const struct sockaddr *to, int tolen);
|
||||
int (WINAPI *_recv)(SOCKET s, void *buf, int len, int flags);
|
||||
int (WINAPI *_recvfrom)(SOCKET s, void * buf, int len, int flags, struct sockaddr * from, int * fromlen);
|
||||
int (WINAPI *_send)(SOCKET s, const char *msg, int len, int flags);
|
||||
int (WINAPI *_sendto)(SOCKET s, const char *msg, int len, int flags, const struct sockaddr *to, int tolen);
|
||||
int (WINAPI *_recv)(SOCKET s, char *buf, int len, int flags);
|
||||
int (WINAPI *_recvfrom)(SOCKET s, char * buf, int len, int flags, struct sockaddr * from, int * fromlen);
|
||||
int (WINAPI *_shutdown)(SOCKET s, int how);
|
||||
int (WINAPI *_closesocket)(SOCKET s);
|
||||
#else
|
||||
|
||||
+1
-1
@@ -59,7 +59,7 @@ void * udppmchild(struct clientparam* param) {
|
||||
if((param->clisock=so._socket(SASOCK(¶m->sincr), SOCK_DGRAM, IPPROTO_UDP)) == INVALID_SOCKET) {
|
||||
RETURN(818);
|
||||
}
|
||||
if(so._setsockopt(param->clisock, SOL_SOCKET, SO_REUSEADDR, (unsigned char *)&ul, sizeof(int))) {RETURN(820);};
|
||||
if(so._setsockopt(param->clisock, SOL_SOCKET, SO_REUSEADDR, (char *)&ul, sizeof(int))) {RETURN(820);};
|
||||
ioctlsocket(param->clisock, FIONBIO, &ul);
|
||||
size = sizeof(param->sinsl);
|
||||
if(so._getsockname(param->srv->srvsock, (struct sockaddr *)¶m->sinsl, &size)) {RETURN(21);};
|
||||
|
||||
Reference in new issue
Block a user