bughz/3proxy
1
0
Fork 0
mirror of https://github.com/3proxy/3proxy.git synced 2025-02-22 18:15:41 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

call local socket function

Browse Source
This commit is contained in:
Vladimir Dubrovin 2024-02-18 19:41:45 +03:00
parent 6dc145b16b
commit 375e3a74d0
11 changed files with 143 additions and 143 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/auth.c
View File

@ -739,7 +739,7 @@ int checkACL(struct clientparam * param){
dup = *acentry;
res = handleredirect(param, &dup);
if(!res) break;
if(param->remsock != INVALID_SOCKET) so._closesocket(param->sostate, param->remsock);
if(param->remsock != INVALID_SOCKET) param->srv->so._closesocket(param->sostate, param->remsock);
param->remsock = INVALID_SOCKET;
}
return res;
@ -1245,7 +1245,7 @@ unsigned long udpresolve(int af, unsigned char * name, unsigned char * value, un
*sinsr = nservers[i].addr;
}
if(usetcp){
if(connectwithpoll(so.state, sock,(struct sockaddr *)sinsr,SASIZE(sinsr),CONNECT_TO)) {
if(connectwithpoll(NULL, sock,(struct sockaddr *)sinsr,SASIZE(sinsr),CONNECT_TO)) {
so._shutdown(so.state, sock, SHUT_RDWR);
so._closesocket(so.state, sock);
break;

28
src/common.c
View File

@ -473,7 +473,7 @@ int parseconnusername(char *username, struct clientparam *param, int extpasswd,
}
int connectwithpoll(void *state, SOCKET sock, struct sockaddr *sa, SASIZETYPE size, int to){
int connectwithpoll(struct clientparam *param, SOCKET sock, struct sockaddr *sa, SASIZETYPE size, int to){
struct pollfd fds[1];
#ifdef _WIN32
unsigned long ul = 1;
@ -481,14 +481,14 @@ int connectwithpoll(void *state, SOCKET sock, struct sockaddr *sa, SASIZETYPE si
#else
fcntl(sock,F_SETFL, O_NONBLOCK | fcntl(sock,F_GETFL));
#endif
if(so._connect(state, sock,sa,size)) {
if(param?param->srv->so._connect(param->sostate, sock,sa,size) : so._connect(so.state, sock,sa,size)) {
if(errno != EAGAIN && errno != EINPROGRESS) return (13);
}
if(!errno) return 0;
memset(fds, 0, sizeof(fds));
fds[0].fd = sock;
fds[0].events = POLLOUT|POLLIN;
if(so._poll(state, fds, 1, to*1000) <= 0 || !(fds[0].revents & POLLOUT)) {
if((param?param->srv->so._poll(param->sostate, fds, 1, to*1000):so._poll(so.state, fds, 1, to*1000)) <= 0 || !(fds[0].revents & POLLOUT)) {
return (13);
}
return 0;
@ -506,7 +506,7 @@ int doconnect(struct clientparam * param){
return 0;
if (param->remsock != INVALID_SOCKET){
size = sizeof(param->sinsr);
if(so._getpeername(param->sostate, param->remsock, (struct sockaddr *)&param->sinsr, &size)==-1) {return (14);}
if(param->srv->so._getpeername(param->sostate, param->remsock, (struct sockaddr *)&param->sinsr, &size)==-1) {return (14);}
}
else {
struct linger lg = {1,conf.timeouts[SINGLEBYTE_S]};
@ -519,7 +519,7 @@ int doconnect(struct clientparam * param){
memcpy(SAADDR(&param->sinsr), SAADDR(&param->req), SAADDRLEN(&param->req));
}
if(!*SAPORT(&param->sinsr))*SAPORT(&param->sinsr) = *SAPORT(&param->req);
if ((param->remsock=so._socket(param->sostate, SASOCK(&param->sinsr), SOCK_STREAM, IPPROTO_TCP)) == INVALID_SOCKET) {return (11);}
if ((param->remsock=param->srv->so._socket(param->sostate, SASOCK(&param->sinsr), SOCK_STREAM, IPPROTO_TCP)) == INVALID_SOCKET) {return (11);}
if(SAISNULL(&param->sinsl)){
#ifndef NOIPV6
if(*SAFAMILY(&param->sinsr) == AF_INET6) param->sinsl = param->srv->extsa6;
@ -530,48 +530,48 @@ int doconnect(struct clientparam * param){
*SAPORT(&param->sinsl) = 0;
setopts(param->remsock, param->srv->srvsockopts);
so._setsockopt(param->sostate, param->remsock, SOL_SOCKET, SO_LINGER, (char *)&lg, sizeof(lg));
param->srv->so._setsockopt(param->sostate, param->remsock, SOL_SOCKET, SO_LINGER, (char *)&lg, sizeof(lg));
#ifdef REUSE
{
int opt;
#ifdef SO_REUSEADDR
opt = 1;
so._setsockopt(param->sostate, param->remsock, SOL_SOCKET, SO_REUSEADDR, (char *)&opt, sizeof(int));
param->srv->so._setsockopt(param->sostate, param->remsock, SOL_SOCKET, SO_REUSEADDR, (char *)&opt, sizeof(int));
#endif
#ifdef SO_REUSEPORT
opt = 1;
so._setsockopt(param->sostate, param->remsock, SOL_SOCKET, SO_REUSEPORT, (unsigned char *)&opt, sizeof(int));
param->srv->so._setsockopt(param->sostate, param->remsock, SOL_SOCKET, SO_REUSEPORT, (unsigned char *)&opt, sizeof(int));
#endif
}
#endif
#if defined SO_BINDTODEVICE
if(param->srv->obindtodevice) {
if(so._setsockopt(param->sostate, param->remsock, SOL_SOCKET, SO_BINDTODEVICE, param->srv->obindtodevice, strlen(param->srv->obindtodevice) + 1))
if(param->srv->so._setsockopt(param->sostate, param->remsock, SOL_SOCKET, SO_BINDTODEVICE, param->srv->obindtodevice, strlen(param->srv->obindtodevice) + 1))
return 12;
}
#elif defined IP_BOUND_IF
if(param->srv->obindtodevice) {
int idx;
idx = if_nametoindex(param->srv->obindtodevice);
if(!idx || (*SAFAMILY(&param->sinsl) == AF_INET && so._setsockopt(param->sostate, param->remsock, IPPROTO_IP, IP_BOUND_IF, &idx, sizeof(idx))))
if(!idx || (*SAFAMILY(&param->sinsl) == AF_INET && param->srv->so._setsockopt(param->sostate, param->remsock, IPPROTO_IP, IP_BOUND_IF, &idx, sizeof(idx))))
return 12;
#ifndef NOIPV6
if(*SAFAMILY(&param->sinsl) == AF_INET6 && so._setsockopt(param->sostate, param->remsock, IPPROTO_IPV6, IPV6_BOUND_IF, &idx, sizeof(idx))) return 12;
if(*SAFAMILY(&param->sinsl) == AF_INET6 && param->srv->so._setsockopt(param->sostate, param->remsock, IPPROTO_IPV6, IPV6_BOUND_IF, &idx, sizeof(idx))) return 12;
#endif
}
#endif
if(so._bind(param->sostate, param->remsock, (struct sockaddr*)&param->sinsl, SASIZE(&param->sinsl))==-1) {
if(param->srv->so._bind(param->sostate, param->remsock, (struct sockaddr*)&param->sinsl, SASIZE(&param->sinsl))==-1) {
return 12;
}
if(param->operation >= 256 || (param->operation & CONNECT)){
if(connectwithpoll(param->sostate, param->remsock,(struct sockaddr *)&param->sinsr,SASIZE(&param->sinsr),CONNECT_TO)) {
if(connectwithpoll(param, param->remsock,(struct sockaddr *)&param->sinsr,SASIZE(&param->sinsr),CONNECT_TO)) {
return 13;
}
}
size = sizeof(param->sinsl);
if(so._getsockname(param->sostate, param->remsock, (struct sockaddr *)&param->sinsl, &size)==-1) {return (15);}
if(param->srv->so._getsockname(param->sostate, param->remsock, (struct sockaddr *)&param->sinsl, &size)==-1) {return (15);}
}
return 0;
}

14
src/dnspr.c
View File

@ -39,16 +39,16 @@ void * dnsprchild(struct clientparam* param) {
}
buf = bbuf+2;
size = sizeof(param->sincr);
i = so._recvfrom(param->sostate, param->srv->srvsock, (char *)buf, BUFSIZE, 0, (struct sockaddr *)&param->sincr, &size);
i = param->srv->so._recvfrom(param->sostate, param->srv->srvsock, (char *)buf, BUFSIZE, 0, (struct sockaddr *)&param->sincr, &size);
size = sizeof(param->sinsl);
getsockname(param->srv->srvsock, (struct sockaddr *)&param->sincl, &size);
#ifdef _WIN32
if((param->clisock=so._socket(param->sostate, AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == INVALID_SOCKET) {
if((param->clisock=param->srv->so._socket(param->sostate, AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == INVALID_SOCKET) {
RETURN(818);
}
ioctlsocket(param->clisock, FIONBIO, &ul);
if(so._setsockopt(param->sostate, param->clisock, SOL_SOCKET, SO_REUSEADDR, (char *)&ul, sizeof(int))) {RETURN(820);};
if(so._bind(param->sostate, param->clisock,(struct sockaddr *)&param->sincl,SASIZE(&param->sincl))) {
if(param->srv->so._setsockopt(param->sostate, param->clisock, SOL_SOCKET, SO_REUSEADDR, (char *)&ul, sizeof(int))) {RETURN(820);};
if(param->srv->so._bind(param->sostate, param->clisock,(struct sockaddr *)&param->sincl,SASIZE(&param->sincl))) {
RETURN(822);
}
@ -130,17 +130,17 @@ void * dnsprchild(struct clientparam* param) {
else ip = 0;
}
if(!ip && numservers){
if((param->remsock=so._socket(param->sostate, SASOCK(&nservers[0].addr), nservers[0].usetcp? SOCK_STREAM:SOCK_DGRAM, nservers[0].usetcp?IPPROTO_TCP:IPPROTO_UDP)) == INVALID_SOCKET) {
if((param->remsock=param->srv->so._socket(param->sostate, SASOCK(&nservers[0].addr), nservers[0].usetcp? SOCK_STREAM:SOCK_DGRAM, nservers[0].usetcp?IPPROTO_TCP:IPPROTO_UDP)) == INVALID_SOCKET) {
RETURN(818);
}
memset(&param->sinsl, 0, sizeof(param->sinsl));
*SAFAMILY(&param->sinsl) = *SAFAMILY(&nservers[0].addr);
if(so._bind(param->sostate, param->remsock,(struct sockaddr *)&param->sinsl,SASIZE(&param->sinsl))) {
if(param->srv->so._bind(param->sostate, param->remsock,(struct sockaddr *)&param->sinsl,SASIZE(&param->sinsl))) {
RETURN(819);
}
param->sinsr = nservers[0].addr;
if(nservers[0].usetcp) {
if(connectwithpoll(param->sostate, param->remsock,(struct sockaddr *)&param->sinsr,SASIZE(&param->sinsr),CONNECT_TO)) RETURN(830);
if(connectwithpoll(param, param->remsock,(struct sockaddr *)&param->sinsr,SASIZE(&param->sinsr),CONNECT_TO)) RETURN(830);
buf-=2;
*(unsigned short*)buf = htons(i);
i+=2;

12
src/ftp.c
View File

@ -189,9 +189,9 @@ SOCKET ftpdata(struct clientparam *param){
if(!(sb = strchr(buf+4, '(')) || !(se= strchr(sb, ')'))) return INVALID_SOCKET;
if(sscanf(sb+1, "%lu,%lu,%lu,%lu,%hu,%hu", &b1, &b2, &b3, &b4, &b5, &b6)!=6) return INVALID_SOCKET;
sasize = sizeof(param->sinsl);
if(so._getsockname(param->sostate, param->remsock, (struct sockaddr *)&param->sinsl, &sasize)){return INVALID_SOCKET;}
if(param->srv->so._getsockname(param->sostate, param->remsock, (struct sockaddr *)&param->sinsl, &sasize)){return INVALID_SOCKET;}
sasize = sizeof(param->sinsr);
if(so._getpeername(param->sostate, param->remsock, (struct sockaddr *)&param->sinsr, &sasize)){return INVALID_SOCKET;}
if(param->srv->so._getpeername(param->sostate, param->remsock, (struct sockaddr *)&param->sinsr, &sasize)){return INVALID_SOCKET;}
rem = param->remsock;
param->remsock = INVALID_SOCKET;
param->req = param->sinsr;
@ -201,7 +201,7 @@ SOCKET ftpdata(struct clientparam *param){
param->operation = FTP_DATA;
if((param->res = (*param->srv->authfunc)(param))) {
if(param->remsock != INVALID_SOCKET) {
so._closesocket(param->sostate, param->remsock);
param->srv->so._closesocket(param->sostate, param->remsock);
param->remsock = INVALID_SOCKET;
}
memset(&param->sinsl, 0, sizeof(param->sinsl));
@ -228,7 +228,7 @@ SOCKET ftpcommand(struct clientparam *param, unsigned char * command, unsigned c
(unsigned char *)" ":(unsigned char *)"",
arg?arg:(unsigned char *)"");
if((int)socksend(param, param->remsock, (unsigned char *)buf, (int)strlen(buf), conf.timeouts[STRING_S]) != (int)strlen(buf)){
so._closesocket(param->sostate, s);
param->srv->so._closesocket(param->sostate, s);
return INVALID_SOCKET;
}
param->statscli64 += (int)strlen(buf);
@ -236,11 +236,11 @@ SOCKET ftpcommand(struct clientparam *param, unsigned char * command, unsigned c
while((i = sockgetlinebuf(param, SERVER, (unsigned char *)buf, sizeof(buf) - 1, '\n', conf.timeouts[STRING_L])) > 0 && (i < 3 || !isnumber(*buf) || buf[3] == '-')){
}
if(i < 3) {
so._closesocket(param->sostate, s);
param->srv->so._closesocket(param->sostate, s);
return INVALID_SOCKET;
}
if(buf[0] != '1') {
so._closesocket(param->sostate, s);
param->srv->so._closesocket(param->sostate, s);
return INVALID_SOCKET;
}
return s;

66
src/ftppr.c
View File

@ -44,8 +44,8 @@ void * ftpprchild(struct clientparam* param) {
if (!strncasecmp((char *)buf, "OPEN ", 5)){
if(parsehostname((char *)buf+5, param, 21)){RETURN(803);}
if(param->remsock != INVALID_SOCKET) {
so._shutdown(param->sostate, param->remsock, SHUT_RDWR);
so._closesocket(param->sostate, param->remsock);
param->srv->so._shutdown(param->sostate, param->remsock, SHUT_RDWR);
param->srv->so._closesocket(param->sostate, param->remsock);
param->remsock = INVALID_SOCKET;
}
if((res = (*param->srv->authfunc)(param))) {RETURN(res);}
@ -105,27 +105,27 @@ void * ftpprchild(struct clientparam* param) {
}
#endif
if(sc != INVALID_SOCKET) {
so._shutdown(param->sostate, sc, SHUT_RDWR);
so._closesocket(param->sostate, sc);
param->srv->so._shutdown(param->sostate, sc, SHUT_RDWR);
param->srv->so._closesocket(param->sostate, sc);
sc = INVALID_SOCKET;
}
if(ss != INVALID_SOCKET) {
so._shutdown(param->sostate, ss, SHUT_RDWR);
so._closesocket(param->sostate, ss);
param->srv->so._shutdown(param->sostate, ss, SHUT_RDWR);
param->srv->so._closesocket(param->sostate, ss);
ss = INVALID_SOCKET;
}
if(clidatasock != INVALID_SOCKET) {
so._shutdown(param->sostate, clidatasock, SHUT_RDWR);
so._closesocket(param->sostate, clidatasock);
param->srv->so._shutdown(param->sostate, clidatasock, SHUT_RDWR);
param->srv->so._closesocket(param->sostate, clidatasock);
clidatasock = INVALID_SOCKET;
}
if ((clidatasock=socket(SASOCK(&param->sincl), SOCK_STREAM, IPPROTO_TCP)) == INVALID_SOCKET) {RETURN(821);}
*SAPORT(&param->sincl) = 0;
if(so._bind(param->sostate, clidatasock, (struct sockaddr *)&param->sincl, SASIZE(&param->sincl))){RETURN(822);}
if(param->srv->so._bind(param->sostate, clidatasock, (struct sockaddr *)&param->sincl, SASIZE(&param->sincl))){RETURN(822);}
if (pasv) {
if(so._listen(param->sostate, clidatasock, 1)) {RETURN(823);}
if(param->srv->so._listen(param->sostate, clidatasock, 1)) {RETURN(823);}
sasize = sizeof(param->sincl);
if(so._getsockname(param->sostate, clidatasock, (struct sockaddr *)&param->sincl, &sasize)){RETURN(824);}
if(param->srv->so._getsockname(param->sostate, clidatasock, (struct sockaddr *)&param->sincl, &sasize)){RETURN(824);}
if(pasv == 1){
if(*SAFAMILY(&param->sincl) == AF_INET)
sprintf((char *)buf, "227 OK (%u,%u,%u,%u,%u,%u)\r\n",
@ -153,8 +153,8 @@ void * ftpprchild(struct clientparam* param) {
if(sscanf((char *)buf+5, "%lu,%lu,%lu,%lu,%hu,%hu", &b1, &b2, &b3, &b4, &b5, &b6)!=6) {RETURN(828);}
*SAPORT(&param->sincr) = htons((unsigned short)((b5<<8)^b6));
if(connectwithpoll(param->sostate, clidatasock, (struct sockaddr *)&param->sincr, SASIZE(&param->sincr),CONNECT_TO)) {
so._closesocket(param->sostate, clidatasock);
if(connectwithpoll(param, clidatasock, (struct sockaddr *)&param->sincr, SASIZE(&param->sincr),CONNECT_TO)) {
param->srv->so._closesocket(param->sostate, clidatasock);
clidatasock = INVALID_SOCKET;
RETURN(826);
}
@ -208,15 +208,15 @@ void * ftpprchild(struct clientparam* param) {
fds.fd = clidatasock;
fds.events = POLLIN;
res = so._poll (param->sostate, &fds, 1, conf.timeouts[STRING_L]*1000);
res = param->srv->so._poll (param->sostate, &fds, 1, conf.timeouts[STRING_L]*1000);
if(res != 1) {
RETURN(857);
}
sasize = sizeof(param->sincr);
ss = so._accept(param->sostate, clidatasock, (struct sockaddr *)&param->sincr, &sasize);
ss = param->srv->so._accept(param->sostate, clidatasock, (struct sockaddr *)&param->sincr, &sasize);
if (ss == INVALID_SOCKET) { RETURN (858);}
so._shutdown(param->sostate, clidatasock, SHUT_RDWR);
so._closesocket(param->sostate, clidatasock);
param->srv->so._shutdown(param->sostate, clidatasock, SHUT_RDWR);
param->srv->so._closesocket(param->sostate, clidatasock);
clidatasock = ss;
ss = INVALID_SOCKET;
}
@ -226,8 +226,8 @@ void * ftpprchild(struct clientparam* param) {
status = 3;
ss = ftpcommand(param, buf, arg? buf+5 : NULL);
if (ss == INVALID_SOCKET) {
so._shutdown(param->sostate, clidatasock, SHUT_RDWR);
so._closesocket(param->sostate, clidatasock);
param->srv->so._shutdown(param->sostate, clidatasock, SHUT_RDWR);
param->srv->so._closesocket(param->sostate, clidatasock);
clidatasock = INVALID_SOCKET;
if(socksend(param, param->ctrlsock, (unsigned char *)"550 err\r\n", 9, conf.timeouts[STRING_S])!=9) {RETURN (831);}
@ -247,17 +247,17 @@ void * ftpprchild(struct clientparam* param) {
}
sc = param->remsock;
param->remsock = ss;
so._setsockopt(param->sostate, param->remsock, SOL_SOCKET, SO_LINGER, (char *)&lg, sizeof(lg));
so._setsockopt(param->sostate, clidatasock, SOL_SOCKET, SO_LINGER, (char *)&lg, sizeof(lg));
param->srv->so._setsockopt(param->sostate, param->remsock, SOL_SOCKET, SO_LINGER, (char *)&lg, sizeof(lg));
param->srv->so._setsockopt(param->sostate, clidatasock, SOL_SOCKET, SO_LINGER, (char *)&lg, sizeof(lg));
param->clisock = clidatasock;
res = mapsocket(param, conf.timeouts[CONNECTION_S]);
if(param->remsock != INVALID_SOCKET) {
so._shutdown (param->sostate, param->remsock, SHUT_RDWR);
so._closesocket(param->sostate, param->remsock);
param->srv->so._shutdown (param->sostate, param->remsock, SHUT_RDWR);
param->srv->so._closesocket(param->sostate, param->remsock);
}
if(param->clisock != INVALID_SOCKET) {
so._shutdown (param->sostate, param->clisock, SHUT_RDWR);
so._closesocket(param->sostate, param->clisock);
param->srv->so._shutdown (param->sostate, param->clisock, SHUT_RDWR);
param->srv->so._closesocket(param->sostate, param->clisock);
}
param->clisock = param->ctrlsock;
param->remsock = sc;
@ -293,7 +293,7 @@ void * ftpprchild(struct clientparam* param) {
if(i < 3) {RETURN (813);}
}
sasize = sizeof(param->sincr);
if(so._getpeername(param->sostate, param->ctrlsock, (struct sockaddr *)&param->sincr, &sasize)){RETURN(819);}
if(param->srv->so._getpeername(param->sostate, param->ctrlsock, (struct sockaddr *)&param->sincr, &sasize)){RETURN(819);}
if(req && (param->statscli64 || param->statssrv64)){
dolog(param, (unsigned char *)req);
}
@ -302,19 +302,19 @@ void * ftpprchild(struct clientparam* param) {
CLEANRET:
if(sc != INVALID_SOCKET) {
so._shutdown(param->sostate, sc, SHUT_RDWR);
so._closesocket(param->sostate, sc);
param->srv->so._shutdown(param->sostate, sc, SHUT_RDWR);
param->srv->so._closesocket(param->sostate, sc);
}
if(ss != INVALID_SOCKET) {
so._shutdown(param->sostate, ss, SHUT_RDWR);
so._closesocket(param->sostate, ss);
param->srv->so._shutdown(param->sostate, ss, SHUT_RDWR);
param->srv->so._closesocket(param->sostate, ss);
}
if(clidatasock != INVALID_SOCKET) {
so._shutdown(param->sostate, clidatasock, SHUT_RDWR);
so._closesocket(param->sostate, clidatasock);
param->srv->so._shutdown(param->sostate, clidatasock, SHUT_RDWR);
param->srv->so._closesocket(param->sostate, clidatasock);
}
sasize = sizeof(param->sincr);
so._getpeername(param->sostate, param->ctrlsock, (struct sockaddr *)&param->sincr, &sasize);
param->srv->so._getpeername(param->sostate, param->ctrlsock, (struct sockaddr *)&param->sincr, &sasize);
if(param->res != 0 || param->statscli64 || param->statssrv64 ){
dolog(param, (unsigned char *)((req && (param->res > 802))? req:NULL));
}

24
src/proxy.c
View File

@ -253,15 +253,15 @@ for(;;){
fds[0].events = POLLIN;
fds[1].fd = param->remsock;
fds[1].events = POLLIN;
res = so._poll(param->sostate, fds, 2, conf.timeouts[STRING_S]*1000);
res = param->srv->so._poll(param->sostate, fds, 2, conf.timeouts[STRING_S]*1000);
if(res<=0) {
RETURN(555);
}
if((fds[1].revents & (POLLIN|POLLHUP|POLLERR|POLLNVAL))) {
if(param->transparent || (!param->redirected && param->redirtype == R_HTTP)) RETURN(555);
ckeepalive = 0;
so._shutdown(param->sostate, param->remsock, SHUT_RDWR);
so._closesocket(param->sostate, param->remsock);
param->srv->so._shutdown(param->sostate, param->remsock, SHUT_RDWR);
param->srv->so._closesocket(param->sostate, param->remsock);
param->remsock = INVALID_SOCKET;
param->redirected = 0;
param->redirtype = 0;
@ -282,8 +282,8 @@ for(;;){
if(!param->transparent && !param->srv->transparent && (i<=prefix || strncasecmp((char *)buf, (char *)req, prefix))){
ckeepalive = 0;
if(param->remsock != INVALID_SOCKET){
so._shutdown(param->sostate, param->remsock, SHUT_RDWR);
so._closesocket(param->sostate, param->remsock);
param->srv->so._shutdown(param->sostate, param->remsock, SHUT_RDWR);
param->srv->so._closesocket(param->sostate, param->remsock);
}
param->remsock = INVALID_SOCKET;
param->redirected = 0;
@ -530,7 +530,7 @@ for(;;){
if(param->srv->needuser > 1 && !param->username) {RETURN(4);}
if((res = (*param->srv->authfunc)(param))) {
if (res <= 10 || haveconnection || param->transparent) RETURN(res);
so._closesocket(param->sostate, param->remsock);
param->srv->so._closesocket(param->sostate, param->remsock);
param->remsock = INVALID_SOCKET;
param->redirected = 0;
param->redirtype = 0;
@ -650,7 +650,7 @@ for(;;){
if((param->operation == FTP_PUT) && (contentlength64 > 0)) param->waitclient64 = contentlength64;
res = mapsocket(param, conf.timeouts[CONNECTION_L]);
if (res == 99) res = 0;
so._closesocket(param->sostate, ftps);
param->srv->so._closesocket(param->sostate, ftps);
ftps = INVALID_SOCKET;
param->remsock = s;
}
@ -806,7 +806,7 @@ for(;;){
}
memcpy(buf+inbuf, "<hr>", 4);
inbuf += 4;
so._closesocket(param->sostate, ftps);
param->srv->so._closesocket(param->sostate, ftps);
ftps = INVALID_SOCKET;
param->remsock = s;
if(inbuf){
@ -854,7 +854,7 @@ for(;;){
else {
#ifdef TCP_CORK
int opt = 1;
so._setsockopt(param->sostate, param->remsock, IPPROTO_TCP, TCP_CORK, (unsigned char *)&opt, sizeof(int));
param->srv->so._setsockopt(param->sostate, param->remsock, IPPROTO_TCP, TCP_CORK, (unsigned char *)&opt, sizeof(int));
#endif
redirect = 1;
res = (int)strlen((char *)req);
@ -906,7 +906,7 @@ for(;;){
#ifdef TCP_CORK
{
int opt = 0;
so._setsockopt(param->sostate, param->remsock, IPPROTO_TCP, TCP_CORK, (unsigned char *)&opt, sizeof(int));
param->srv->so._setsockopt(param->sostate, param->remsock, IPPROTO_TCP, TCP_CORK, (unsigned char *)&opt, sizeof(int));
}
#endif
param->statscli64 += res;
@ -1107,8 +1107,8 @@ for(;;){
REQUESTEND:
if((!ckeepalive || !keepalive) && param->remsock != INVALID_SOCKET){
so._shutdown(param->sostate, param->remsock, SHUT_RDWR);
so._closesocket(param->sostate, param->remsock);
param->srv->so._shutdown(param->sostate, param->remsock, SHUT_RDWR);
param->srv->so._closesocket(param->sostate, param->remsock);
param->remsock = INVALID_SOCKET;
RETURN(0);
}

2
src/proxy.h
View File

@ -277,7 +277,7 @@ void srvinit2(struct srvparam * srv, struct clientparam *param);
void srvfree(struct srvparam * srv);
unsigned char * dologname (unsigned char *buf, unsigned char *name, const unsigned char *ext, ROTATION lt, time_t t);
int readconfig(FILE * fp);
int connectwithpoll(void *state, SOCKET sock, struct sockaddr *sa, SASIZETYPE size, int to);
int connectwithpoll(struct clientparam *param, SOCKET sock, struct sockaddr *sa, SASIZETYPE size, int to);
int myrand(void * entropy, int len);

78
src/proxymain.c
View File

@ -22,12 +22,12 @@ void * threadfunc (void *p) {
fds.events = POLLIN;
fds.revents = 0;
for(i=5+(param->srv->maxchild>>10); i; i--){
if(so._poll(param->sostate, &fds, 1, 1000*CONNBACK_TO)!=1){
if(param->srv->so._poll(param->sostate, &fds, 1, 1000*CONNBACK_TO)!=1){
dolog(param, (unsigned char *)"Connect back not received, check connback client");
i = 0;
break;
}
param->remsock = so._accept(param->sostate, param->srv->cbsock, (struct sockaddr*)&param->sinsr, &size);
param->remsock = param->srv->so._accept(param->sostate, param->srv->cbsock, (struct sockaddr*)&param->sinsr, &size);
if(param->remsock == INVALID_SOCKET) {
dolog(param, (unsigned char *)"Connect back accept() failed");
continue;
@ -45,14 +45,14 @@ void * threadfunc (void *p) {
if(param->srv->acl) param->res = checkACL(param);
if(param->res){
dolog(param, (unsigned char *)"Connect back ACL failed");
so._closesocket(param->sostate, param->remsock);
param->srv->so._closesocket(param->sostate, param->remsock);
param->remsock = INVALID_SOCKET;
continue;
}
#endif
if(socksendto(param, param->remsock, (struct sockaddr*)&param->sinsr, (unsigned char *)"C", 1, CONNBACK_TO*1000) != 1){
dolog(param, (unsigned char *)"Connect back sending command failed");
so._closesocket(param->sostate, param->remsock);
param->srv->so._closesocket(param->sostate, param->remsock);
param->remsock = INVALID_SOCKET;
continue;
}
@ -397,7 +397,7 @@ int MODULEMAINFUNC (int argc, char** argv){
#ifndef _WIN32
case 'I':
size = sizeof(defparam.sincl);
if(so._getsockname(srv.so.state, 0, (struct sockaddr*)&defparam.sincl, &size) ||
if(srv.so._getsockname(srv.so.state, 0, (struct sockaddr*)&defparam.sincl, &size) ||
*SAFAMILY(&defparam.sincl) != AF_INET) error = 1;
else inetd = 1;
@ -553,8 +553,8 @@ int MODULEMAINFUNC (int argc, char** argv){
if(!isudp){
lg.l_onoff = 1;
lg.l_linger = conf.timeouts[STRING_L];
so._setsockopt(srv.so.state, 0, SOL_SOCKET, SO_LINGER, (unsigned char *)&lg, sizeof(lg));
so._setsockopt(srv.so.state, 0, SOL_SOCKET, SO_OOBINLINE, (unsigned char *)&opt, sizeof(int));
srv.so._setsockopt(srv.so.state, 0, SOL_SOCKET, SO_LINGER, (unsigned char *)&lg, sizeof(lg));
srv.so._setsockopt(srv.so.state, 0, SOL_SOCKET, SO_OOBINLINE, (unsigned char *)&opt, sizeof(int));
}
defparam.clisock = 0;
if(! (newparam = myalloc (sizeof(defparam)))){
@ -594,10 +594,10 @@ int MODULEMAINFUNC (int argc, char** argv){
if(srv.srvsock == INVALID_SOCKET){
if(!isudp){
sock=so._socket(srv.so.state, SASOCK(&srv.intsa), SOCK_STREAM, IPPROTO_TCP);
sock=srv.so._socket(srv.so.state, SASOCK(&srv.intsa), SOCK_STREAM, IPPROTO_TCP);
}
else {
sock=so._socket(srv.so.state, SASOCK(&srv.intsa), SOCK_DGRAM, IPPROTO_UDP);
sock=srv.so._socket(srv.so.state, SASOCK(&srv.intsa), SOCK_DGRAM, IPPROTO_UDP);
}
if( sock == INVALID_SOCKET) {
perror("socket()");
@ -611,13 +611,13 @@ int MODULEMAINFUNC (int argc, char** argv){
#endif
srv.srvsock = sock;
opt = 1;
if(so._setsockopt(srv.so.state, sock, SOL_SOCKET, SO_REUSEADDR, (char *)&opt, sizeof(int)))perror("setsockopt()");
if(srv.so._setsockopt(srv.so.state, sock, SOL_SOCKET, SO_REUSEADDR, (char *)&opt, sizeof(int)))perror("setsockopt()");
#ifdef SO_REUSEPORT
opt = 1;
so._setsockopt(srv.so.state, sock, SOL_SOCKET, SO_REUSEPORT, (char *)&opt, sizeof(int));
srv.so._setsockopt(srv.so.state, sock, SOL_SOCKET, SO_REUSEPORT, (char *)&opt, sizeof(int));
#endif
#if defined SO_BINDTODEVICE
if(srv.ibindtodevice && so._setsockopt(srv.so.state, sock, SOL_SOCKET, SO_BINDTODEVICE, srv.ibindtodevice, strlen(srv.ibindtodevice) + 1)) {
if(srv.ibindtodevice && srv.so._setsockopt(srv.so.state, sock, SOL_SOCKET, SO_BINDTODEVICE, srv.ibindtodevice, strlen(srv.ibindtodevice) + 1)) {
dolog(&defparam, "failed to bind device");
return -12;
}
@ -630,7 +630,7 @@ int MODULEMAINFUNC (int argc, char** argv){
return -12;
}
#ifndef NOIPV6
if((*SAFAMILY(&srv.intsa) == AF_INET6 && so._setsockopt(srv.so.state, sock, IPPROTO_IPV6, IPV6_BOUND_IF, &idx, sizeof(idx)))) {
if((*SAFAMILY(&srv.intsa) == AF_INET6 && srv.so._setsockopt(srv.so.state, sock, IPPROTO_IPV6, IPV6_BOUND_IF, &idx, sizeof(idx)))) {
dolog(&defparam, (unsigned char *)"failed to bind device");
return -12;
}
@ -639,17 +639,17 @@ int MODULEMAINFUNC (int argc, char** argv){
#endif
}
size = sizeof(srv.intsa);
for(sleeptime = SLEEPTIME * 100; so._bind(srv.so.state, sock, (struct sockaddr*)&srv.intsa, SASIZE(&srv.intsa))==-1; usleep(sleeptime)) {
for(sleeptime = SLEEPTIME * 100; srv.so._bind(srv.so.state, sock, (struct sockaddr*)&srv.intsa, SASIZE(&srv.intsa))==-1; usleep(sleeptime)) {
sprintf((char *)buf, "bind(): %s", strerror(errno));
if(!srv.silent)dolog(&defparam, buf);
sleeptime = (sleeptime<<1);
if(!sleeptime) {
so._closesocket(srv.so.state, sock);
srv.so._closesocket(srv.so.state, sock);
return -3;
}
}
if(!isudp){
if(so._listen (srv.so.state, sock, srv.backlog?srv.backlog : 1+(srv.maxchild>>3))==-1) {
if(srv.so._listen (srv.so.state, sock, srv.backlog?srv.backlog : 1+(srv.maxchild>>3))==-1) {
sprintf((char *)buf, "listen(): %s", strerror(errno));
if(!srv.silent)dolog(&defparam, buf);
return -4;
@ -665,24 +665,24 @@ int MODULEMAINFUNC (int argc, char** argv){
}
if(iscbl){
parsehost(srv.family, cbl_string, (struct sockaddr *)&cbsa);
if((srv.cbsock=so._socket(srv.so.state, SASOCK(&cbsa), SOCK_STREAM, IPPROTO_TCP))==INVALID_SOCKET) {
if((srv.cbsock=srv.so._socket(srv.so.state, SASOCK(&cbsa), SOCK_STREAM, IPPROTO_TCP))==INVALID_SOCKET) {
dolog(&defparam, (unsigned char *)"Failed to allocate connect back socket");
return -6;
}
opt = 1;
so._setsockopt(srv.so.state, srv.cbsock, SOL_SOCKET, SO_REUSEADDR, (char *)&opt, sizeof(int));
srv.so._setsockopt(srv.so.state, srv.cbsock, SOL_SOCKET, SO_REUSEADDR, (char *)&opt, sizeof(int));
#ifdef SO_REUSEPORT
opt = 1;
so._setsockopt(srv.so.state, srv.cbsock, SOL_SOCKET, SO_REUSEPORT, (char *)&opt, sizeof(int));
srv.so._setsockopt(srv.so.state, srv.cbsock, SOL_SOCKET, SO_REUSEPORT, (char *)&opt, sizeof(int));
#endif
setopts(srv.cbsock, srv.cbssockopts);
if(so._bind(srv.so.state, srv.cbsock, (struct sockaddr*)&cbsa, SASIZE(&cbsa))==-1) {
if(srv.so._bind(srv.so.state, srv.cbsock, (struct sockaddr*)&cbsa, SASIZE(&cbsa))==-1) {
dolog(&defparam, (unsigned char *)"Failed to bind connect back socket");
return -7;
}
if(so._listen(srv.so.state, srv.cbsock, 1 + (srv.maxchild>>4))==-1) {
if(srv.so._listen(srv.so.state, srv.cbsock, 1 + (srv.maxchild>>4))==-1) {
dolog(&defparam, (unsigned char *)"Failed to listen connect back socket");
return -8;
}
@ -711,7 +711,7 @@ int MODULEMAINFUNC (int argc, char** argv){
if (iscbc) break;
if (conf.paused != srv.paused) break;
if (srv.fds.events & POLLIN) {
error = so._poll(srv.so.state, &srv.fds, 1, 1000);
error = srv.so._poll(srv.so.state, &srv.fds, 1, 1000);
}
else {
usleep(SLEEPTIME);
@ -730,20 +730,20 @@ int MODULEMAINFUNC (int argc, char** argv){
if(!isudp){
size = sizeof(defparam.sincr);
if(iscbc){
new_sock=so._socket(srv.so.state, SASOCK(&defparam.sincr), SOCK_STREAM, IPPROTO_TCP);
new_sock=so._socket(so.state, SASOCK(&defparam.sincr), SOCK_STREAM, IPPROTO_TCP);
if(new_sock != INVALID_SOCKET){
setopts(new_sock, srv.cbcsockopts);
parsehost(srv.family, cbc_string, (struct sockaddr *)&defparam.sincr);
if(connectwithpoll(srv.so.state, new_sock,(struct sockaddr *)&defparam.sincr,SASIZE(&defparam.sincr),CONNBACK_TO)) {
so._closesocket(srv.so.state, new_sock);
if(connectwithpoll(NULL, new_sock,(struct sockaddr *)&defparam.sincr,SASIZE(&defparam.sincr),CONNBACK_TO)) {
so._closesocket(so.state, new_sock);
new_sock = INVALID_SOCKET;
usleep(SLEEPTIME);
continue;
}
if(sockrecvfrom(NULL, new_sock,(struct sockaddr*)&defparam.sincr,buf,1,60*1000) != 1 || *buf!='C') {
so._closesocket(srv.so.state, new_sock);
so._closesocket(so.state, new_sock);
new_sock = INVALID_SOCKET;
usleep(SLEEPTIME);
continue;
@ -755,7 +755,7 @@ int MODULEMAINFUNC (int argc, char** argv){
}
}
else {
new_sock = so._accept(srv.so.state, sock, (struct sockaddr*)&defparam.sincr, &size);
new_sock = srv.so._accept(srv.so.state, sock, (struct sockaddr*)&defparam.sincr, &size);
if(new_sock == INVALID_SOCKET){
#ifdef _WIN32
switch(WSAGetLastError()){
@ -803,7 +803,7 @@ int MODULEMAINFUNC (int argc, char** argv){
setopts(new_sock, srv.clisockopts);
}
size = sizeof(defparam.sincl);
if(so._getsockname(srv.so.state, new_sock, (struct sockaddr *)&defparam.sincl, &size)){
if(srv.so._getsockname(srv.so.state, new_sock, (struct sockaddr *)&defparam.sincl, &size)){
sprintf((char *)buf, "getsockname(): %s", strerror(errno));
if(!srv.silent)dolog(&defparam, buf);
continue;
@ -816,14 +816,14 @@ int MODULEMAINFUNC (int argc, char** argv){
lg.l_onoff = 1;
lg.l_linger = conf.timeouts[STRING_L];
so._setsockopt(srv.so.state, new_sock, SOL_SOCKET, SO_LINGER, (char *)&lg, sizeof(lg));
so._setsockopt(srv.so.state, new_sock, SOL_SOCKET, SO_OOBINLINE, (char *)&opt, sizeof(int));
srv.so._setsockopt(srv.so.state, new_sock, SOL_SOCKET, SO_LINGER, (char *)&lg, sizeof(lg));
srv.so._setsockopt(srv.so.state, new_sock, SOL_SOCKET, SO_OOBINLINE, (char *)&opt, sizeof(int));
}
else {
srv.fds.events = 0;
}
if(! (newparam = myalloc (sizeof(defparam)))){
if(!isudp) so._closesocket(srv.so.state, new_sock);
if(!isudp) srv.so._closesocket(srv.so.state, new_sock);
defparam.res = 21;
if(!srv.silent)dolog(&defparam, (unsigned char *)"Memory Allocation Failed");
usleep(SLEEPTIME);
@ -1051,20 +1051,20 @@ void freeparam(struct clientparam * param) {
if(param->extusername) myfree(param->extusername);
if(param->extpassword) myfree(param->extpassword);
if(param->ctrlsocksrv != INVALID_SOCKET && param->ctrlsocksrv != param->remsock) {
so._shutdown(param->sostate, param->ctrlsocksrv, SHUT_RDWR);
so._closesocket(param->sostate, param->ctrlsocksrv);
param->srv->so._shutdown(param->sostate, param->ctrlsocksrv, SHUT_RDWR);
param->srv->so._closesocket(param->sostate, param->ctrlsocksrv);
}
if(param->ctrlsock != INVALID_SOCKET && param->ctrlsock != param->clisock) {
so._shutdown(param->sostate, param->ctrlsock, SHUT_RDWR);
so._closesocket(param->sostate, param->ctrlsock);
param->srv->so._shutdown(param->sostate, param->ctrlsock, SHUT_RDWR);
param->srv->so._closesocket(param->sostate, param->ctrlsock);
}
if(param->remsock != INVALID_SOCKET) {
so._shutdown(param->sostate, param->remsock, SHUT_RDWR);
so._closesocket(param->sostate, param->remsock);
param->srv->so._shutdown(param->sostate, param->remsock, SHUT_RDWR);
param->srv->so._closesocket(param->sostate, param->remsock);
}
if(param->clisock != INVALID_SOCKET) {
so._shutdown(param->sostate, param->clisock, SHUT_RDWR);
so._closesocket(param->sostate, param->clisock);
param->srv->so._shutdown(param->sostate, param->clisock, SHUT_RDWR);
param->srv->so._closesocket(param->sostate, param->clisock);
}
myfree(param);
}

12
src/sockmap.c
View File

@ -180,7 +180,7 @@ log(logbuf);
memset(fds, 0, sizeof(fds));
fds[0].fd = param->clisock;
fds[1].fd = param->remsock;
so._poll(param->sostate, fds, 2, sleeptime);
param->srv->so._poll(param->sostate, fds, 2, sleeptime);
sleeptime = 0;
}
if((param->srv->logdumpsrv && (param->statssrv64 > param->srv->logdumpsrv)) ||
@ -214,7 +214,7 @@ log("send to server from buf");
if(fromclient) TOCLIENTBUF = 1;
}
sasize = sizeof(param->sinsr);
res = so._sendto(param->sostate, param->remsock, (char *)param->clibuf + param->clioffset, (int)MIN(inclientbuf, fromclient), 0, (struct sockaddr*)&param->sinsr, sasize);
res = param->srv->so._sendto(param->sostate, param->remsock, (char *)param->clibuf + param->clioffset, (int)MIN(inclientbuf, fromclient), 0, (struct sockaddr*)&param->sinsr, sasize);
if(res <= 0) {
TOSERVER = 0;
if(errno && errno != EAGAIN && errno != EINTR){
@ -259,7 +259,7 @@ log("send to client from buf");
continue;
}
sasize = sizeof(param->sincr);
res = so._sendto(param->sostate, param->clisock, (char *)param->srvbuf + param->srvoffset, (int)MIN(inserverbuf,fromserver), 0, (struct sockaddr*)&param->sincr, sasize);
res = param->srv->so._sendto(param->sostate, param->clisock, (char *)param->srvbuf + param->srvoffset, (int)MIN(inserverbuf,fromserver), 0, (struct sockaddr*)&param->sincr, sasize);
if(res <= 0) {
TOCLIENT = 0;
if(errno && errno != EAGAIN && errno != EINTR){
@ -433,7 +433,7 @@ log("done read from server to pipe\n");
log("read from client to buf");
#endif
sasize = sizeof(param->sincr);
res = so._recvfrom(param->sostate, param->clisock, (char *)param->clibuf + param->cliinbuf, (int)MIN((uint64_t)param->clibufsize - param->cliinbuf, fromclient-inclientbuf), 0, (struct sockaddr *)&param->sincr, &sasize);
res = param->srv->so._recvfrom(param->sostate, param->clisock, (char *)param->clibuf + param->cliinbuf, (int)MIN((uint64_t)param->clibufsize - param->cliinbuf, fromclient-inclientbuf), 0, (struct sockaddr *)&param->sincr, &sasize);
if(res <= 0) {
FROMCLIENT = 0;
if(res == 0 || (errno && errno != EINTR && errno !=EAGAIN)){
@ -461,7 +461,7 @@ log("done read from client to buf");
log("read from server to buf");
#endif
sasize = sizeof(param->sinsr);
res = so._recvfrom(param->sostate, param->remsock, (char *)param->srvbuf + param->srvinbuf, (int)MIN((uint64_t)param->srvbufsize - param->srvinbuf, fromserver-inserverbuf), 0, (struct sockaddr *)&param->sinsr, &sasize);
res = param->srv->so._recvfrom(param->sostate, param->remsock, (char *)param->srvbuf + param->srvinbuf, (int)MIN((uint64_t)param->srvbufsize - param->srvinbuf, fromserver-inserverbuf), 0, (struct sockaddr *)&param->sinsr, &sasize);
if(res <= 0) {
FROMSERVER = 0;
if(res == 0 || (errno && errno != EINTR && errno !=EAGAIN)) {
@ -706,7 +706,7 @@ log("ready reading from server pipe");
#ifdef WITHLOG
log("entering poll");
#endif
res = so._poll(param->sostate, fds, fdsc, timeo*1000);
res = param->srv->so._poll(param->sostate, fds, fdsc, timeo*1000);
#ifdef WITHLOG
log("leaving poll");
#endif

34
src/socks.c
View File

@ -189,7 +189,7 @@ void * sockschild(struct clientparam* param) {
#else
param->sinsl = param->srv->extsa;
#endif
if ((param->remsock=so._socket(param->sostate, SASOCK(&param->req), command == 2? SOCK_STREAM:SOCK_DGRAM, command == 2?IPPROTO_TCP:IPPROTO_UDP)) == INVALID_SOCKET) {RETURN (11);}
if ((param->remsock=param->srv->so._socket(param->sostate, SASOCK(&param->req), command == 2? SOCK_STREAM:SOCK_DGRAM, command == 2?IPPROTO_TCP:IPPROTO_UDP)) == INVALID_SOCKET) {RETURN (11);}
param->operation = command == 2?BIND:UDPASSOC;
#ifdef REUSE
if (command == 2){
@ -197,11 +197,11 @@ void * sockschild(struct clientparam* param) {
#ifdef SO_REUSEADDR
opt = 1;
so._setsockopt(param->sostate, param->remsock, SOL_SOCKET, SO_REUSEADDR, (unsigned char *)&opt, sizeof(int));
param->srv->so._setsockopt(param->sostate, param->remsock, SOL_SOCKET, SO_REUSEADDR, (unsigned char *)&opt, sizeof(int));
#endif
#ifdef SO_REUSEPORT
opt = 1;
so._setsockopt(param->sostate, param->remsock, SOL_SOCKET, SO_REUSEPORT, (unsigned char *)&opt, sizeof(int));
param->srv->so._setsockopt(param->sostate, param->remsock, SOL_SOCKET, SO_REUSEPORT, (unsigned char *)&opt, sizeof(int));
#endif
}
#endif
@ -230,23 +230,23 @@ void * sockschild(struct clientparam* param) {
#endif
if(command > 1) {
if(so._bind(param->sostate, param->remsock,(struct sockaddr *)&param->sinsl,SASIZE(&param->sinsl))) {
if(param->srv->so._bind(param->sostate, param->remsock,(struct sockaddr *)&param->sinsl,SASIZE(&param->sinsl))) {
*SAPORT(&param->sinsl) = 0;
if(so._bind(param->sostate, param->remsock,(struct sockaddr *)&param->sinsl,SASIZE(&param->sinsl)))RETURN (12);
if(param->srv->so._bind(param->sostate, param->remsock,(struct sockaddr *)&param->sinsl,SASIZE(&param->sinsl)))RETURN (12);
#if SOCKSTRACE > 0
fprintf(stderr, "%hu bound to communicate with server\n", *SAPORT(&param->sins));
fflush(stderr);
#endif
}
sasize = SASIZE(&param->sinsl);
so._getsockname(param->sostate, param->remsock, (struct sockaddr *)&param->sinsl, &sasize);
param->srv->so._getsockname(param->sostate, param->remsock, (struct sockaddr *)&param->sinsl, &sasize);
if(command == 3) {
param->ctrlsock = param->clisock;
param->clisock = so._socket(param->sostate, SASOCK(&param->sincr), SOCK_DGRAM, IPPROTO_UDP);
param->clisock = param->srv->so._socket(param->sostate, SASOCK(&param->sincr), SOCK_DGRAM, IPPROTO_UDP);
if(param->clisock == INVALID_SOCKET) {RETURN(11);}
sin = param->sincl;
*SAPORT(&sin) = 0;
if(so._bind(param->sostate, param->clisock,(struct sockaddr *)&sin,SASIZE(&sin))) {RETURN (12);}
if(param->srv->so._bind(param->sostate, param->clisock,(struct sockaddr *)&sin,SASIZE(&sin))) {RETURN (12);}
#if SOCKSTRACE > 0
fprintf(stderr, "%hu binded to communicate with client\n",
ntohs(*SAPORT(&sin))
@ -268,8 +268,8 @@ CLEANRET:
int repcode;
sasize = sizeof(sin);
if(command != 3 && param->remsock != INVALID_SOCKET) so._getsockname(param->sostate, param->remsock, (struct sockaddr *)&sin, &sasize);
else so._getsockname(param->sostate, param->clisock, (struct sockaddr *)&sin, &sasize);
if(command != 3 && param->remsock != INVALID_SOCKET) param->srv->so._getsockname(param->sostate, param->remsock, (struct sockaddr *)&sin, &sasize);
else param->srv->so._getsockname(param->sostate, param->clisock, (struct sockaddr *)&sin, &sasize);
#if SOCKSTRACE > 0
fprintf(stderr, "Sending confirmation to client with code %d for %s with %s:%hu\n",
param->res,
@ -326,19 +326,19 @@ fflush(stderr);
param->res = mapsocket(param, conf.timeouts[CONNECTION_L]);
break;
case 2:
so._listen (param->sostate, param->remsock, 1);
param->srv->so._listen (param->sostate, param->remsock, 1);
fds[0].fd = param->remsock;
fds[1].fd = param->clisock;
fds[0].events = fds[1].events = POLLIN;
res = so._poll(param->sostate, fds, 2, conf.timeouts[CONNECTION_L] * 1000);
res = param->srv->so._poll(param->sostate, fds, 2, conf.timeouts[CONNECTION_L] * 1000);
if (res < 1 || fds[1].revents) {
res = 460;
break;
}
sasize = sizeof(param->sinsr);
s = so._accept(param->sostate, param->remsock, (struct sockaddr *)&param->sinsr, &sasize);
so._closesocket(param->sostate, param->remsock);
s = param->srv->so._accept(param->sostate, param->remsock, (struct sockaddr *)&param->sinsr, &sasize);
param->srv->so._closesocket(param->sostate, param->remsock);
param->remsock = s;
if(s == INVALID_SOCKET) {
param->res = 462;
@ -392,7 +392,7 @@ fflush(stderr);
fds[2].fd = param->ctrlsock;
fds[2].events = fds[1].events = fds[0].events = POLLIN;
res = so._poll(param->sostate, fds, 3, conf.timeouts[CONNECTION_L]*1000);
res = param->srv->so._poll(param->sostate, fds, 3, conf.timeouts[CONNECTION_L]*1000);
if(res <= 0) {
param->res = 463;
break;
@ -403,7 +403,7 @@ fflush(stderr);
}
if (fds[1].revents) {
sasize = sizeof(sin);
if((len = so._recvfrom(param->sostate, param->clisock, (char *)buf, 65535, 0, (struct sockaddr *)&sin, &sasize)) <= 10) {
if((len = param->srv->so._recvfrom(param->sostate, param->clisock, (char *)buf, 65535, 0, (struct sockaddr *)&sin, &sasize)) <= 10) {
param->res = 464;
break;
}
@ -464,7 +464,7 @@ fflush(stderr);
sasize = sizeof(param->sinsr);
buf[0]=buf[1]=buf[2]=0;
buf[3]=(*SAFAMILY(&param->sinsl) == AF_INET)?1:4;
if((len = so._recvfrom(param->sostate, param->remsock, (char *)buf+6+SAADDRLEN(&param->sinsl), 65535 - (6+SAADDRLEN(&param->sinsl)), 0, (struct sockaddr *)&param->sinsr, &sasize)) <= 0) {
if((len = param->srv->so._recvfrom(param->sostate, param->remsock, (char *)buf+6+SAADDRLEN(&param->sinsl), 65535 - (6+SAADDRLEN(&param->sinsl)), 0, (struct sockaddr *)&param->sinsr, &sasize)) <= 0) {
param->res = 468;
break;
}

12
src/udppm.c
View File

@ -56,15 +56,15 @@ void * udppmchild(struct clientparam* param) {
param->cliinbuf = i;
#ifdef _WIN32
if((param->clisock=so._socket(param->sostate, SASOCK(&param->sincr), SOCK_DGRAM, IPPROTO_UDP)) == INVALID_SOCKET) {
if((param->clisock=param->srv->so._socket(param->sostate, SASOCK(&param->sincr), SOCK_DGRAM, IPPROTO_UDP)) == INVALID_SOCKET) {
RETURN(818);
}
if(so._setsockopt(param->sostate, param->clisock, SOL_SOCKET, SO_REUSEADDR, (char *)&ul, sizeof(int))) {RETURN(820);};
if(param->srv->so._setsockopt(param->sostate, param->clisock, SOL_SOCKET, SO_REUSEADDR, (char *)&ul, sizeof(int))) {RETURN(820);};
ul = 1;
ioctlsocket(param->clisock, FIONBIO, &ul);
size = sizeof(param->sinsl);
if(so._getsockname(param->sostate, param->srv->srvsock, (struct sockaddr *)&param->sinsl, &size)) {RETURN(21);};
if(so._bind(param->sostate, param->clisock,(struct sockaddr *)&param->sinsl,SASIZE(&param->sinsl))) {
if(param->srv->so._getsockname(param->sostate, param->srv->srvsock, (struct sockaddr *)&param->sinsl, &size)) {RETURN(21);};
if(param->srv->so._bind(param->sostate, param->clisock,(struct sockaddr *)&param->sinsl,SASIZE(&param->sinsl))) {
RETURN(822);
}
#else
@ -77,8 +77,8 @@ void * udppmchild(struct clientparam* param) {
memcpy(&param->sinsl, &param->srv->extsa, SASIZE(&param->req));
#endif
*SAPORT(&param->sinsl) = 0;
if ((param->remsock=so._socket(param->sostate, SASOCK(&param->sinsl), SOCK_DGRAM, IPPROTO_UDP)) == INVALID_SOCKET) {RETURN (11);}
if(so._bind(param->sostate, param->remsock,(struct sockaddr *)&param->sinsl,SASIZE(&param->sinsl))) {RETURN (12);}
if ((param->remsock=param->srv->so._socket(param->sostate, SASOCK(&param->sinsl), SOCK_DGRAM, IPPROTO_UDP)) == INVALID_SOCKET) {RETURN (11);}
if(param->srv->so._bind(param->sostate, param->remsock,(struct sockaddr *)&param->sinsl,SASIZE(&param->sinsl))) {RETURN (12);}
#ifdef _WIN32
ul = 1;
ioctlsocket(param->remsock, FIONBIO, &ul);