开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 代理服务器 > 查看源码
socket.c
资源名称：socks5.zip　[点击查看]
上传用户：sddyfurun
上传日期：2007-01-04
资源大小：525k
文件大小：21k
源码类别：

代理服务器

开发平台：

Unix_Linux

socket.c：源码内容
  1. /* Copyright (c) 1995,1996,1997 NEC Corporation.  All rights reserved.       */
  2. /*                                                                           */
  3. /* The redistribution, use and modification in source or binary forms of     */
  4. /* this software is subject to the conditions set forth in the copyright     */
  5. /* document ("Copyright") included with this distribution.                   */
  7. /*
  8.  * $Id: socket.c,v 1.94.2.2.2.12 1998/10/05 21:34:51 wlu Exp $
  9.  */
  11. /* This file contains all of the socket creation and configuration functions */
  12. /* that are used by the daemon.  There are a couple of utility functions     */
  13. /* here becuase they deal with the sockets themselves...                     */
  14. #include "socks5p.h"
  15. #include "daemon.h"
  16. #include "validate.h"
  17. #include "msgids.h"
  18. #include "socket.h"
  19. #include "proxy.h"
  20. #include "sema.h"
  21. #include "log.h"
  22. #include "threads.h"
  23. #include "sigfix.h"
  25. #if defined(linux) && defined(USE_THREADS)
  26. #undef SIGUSR1
  27. #define SIGUSR1 SIGUNUSED
  28. #endif
  30. /* Two server modes (threading & preforking) work in a master/slave mode,    */
  31. /* these macros make decisions based on that status easier to read           */
  32. #define ISMASTER() (!iamachild && (servermode == PREFORKING || servermode == THREADED))
  33. #define ISSLAVE()  (iamachild  && (servermode == PREFORKING || servermode == THREADED))
  35. static int acceptor  = 0;  /* the pid of the accepting process if threaded   */
  36. static int nconns    = 0;  /* the number of proxies the daemon has had...    */
  37. static int nchildren = 0;  /* the number of children the daemon has had...   */
  38. static int iamachild = 0;  /* Am I a child, or the parent...                 */
  39. static void *asem = NULL;
  40. static S5IOHandle in = S5InvalidIOHandle;
  42. static sig_atomic_t hadfatalsig = 0;  /* Has a sighup/sigusr1 occured?       */
  43. static sig_atomic_t hadsigint   = 0;  /* Has a sigint         occured?       */
  44. static sig_atomic_t hadresetsig = 0;  /* Has a sigusr1        occured?       */
  46. /* A function to collect dead children before they become zombies...  Also,  */
  47. /* It keeps track of how many children are around for preforking...          */
  48. /*                                                                           */
  49. /* On a non-posix system, I suppose calling wait3 or waitpid in a signal     */
  50. /* handler (according to APUE) might not be cool.  Someone will have to      */
  51. /* tell me if this is ever the case, and I'll write code so that reaping is  */
  52. /* done elsewhere.                                                           */
  53. static RETSIGTYPE gravedigger(void) {
  54.     int oerrno = errno, wval, wstatus;
  55.     Sigset_t set = SigBlock(SIGCHLD);
  57.     for (;;) {
  58. #ifdef HAVE_WAITPID
  59. wval = waitpid(-1, &wstatus, WNOHANG);
  60. #else
  61.         wval = wait3(&wstatus, WNOHANG, NULL);
  62. #endif
  64. switch (wval) {
  65.     case -1:
  66. if (errno == EINTR) continue;
  67.     case 0:
  68. errno = oerrno;
  69. SigUnblock(set);
  70. return;
  71.     default:
  72. if (servermode == THREADED) acceptor = 0;
  73. if (nchildren > 0) nchildren--;
  74. }
  75.     }
  76. }
  78. /* Indicate that we had a sigint, so we exit & clean up later                */
  79. static RETSIGTYPE markdone(void) {
  80.     if (hadresetsig) hadresetsig = 0;
  81.     else hadsigint = 1;
  82. }
  84. /* Indicate that we had a sighup, so we can re-read the config file later.   */
  85. static RETSIGTYPE die(void) {
  86.     hadfatalsig = 1;
  87. }
  89. /* Indicate that we had a sigusr, so we start a new server.                  */
  90. static RETSIGTYPE reset(void) {
  91.     hadresetsig = 1;
  92. }
  94. /* fork(), and do the right thing...the right thing is...handle errors and   */
  95. /* incremenent nchildren...pretty simple...                                  */
  96. static int DoFork(void) {
  97.     int pid;
  98.   
  99.     if (nchildren >= nservers) {
  100. errno = EAGAIN;
  101.         S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Total number of children is %d", nchildren);
  102. return -1;
  103.     }
  104.   
  105.     switch (pid = fork()) {
  106. case 0:
  107.     Signal(SIGHUP,  SIG_DFL);
  108.     Signal(SIGUSR1, SIG_DFL);
  109.     Signal(SIGINT,  SIG_DFL);
  110.             Signal(SIGTERM, SIG_DFL);
  112.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(15), 0, "Child: Starting");
  113.     iamachild = 1;
  114.     return 0;
  115. case -1:
  116.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_ERROR,     0, "Fork failed: %m");
  117.     return -1;
  118. default:
  119.     nchildren++; 
  120.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(15), 0, "Parent: %d child%s", nchildren, (nchildren != 1)?"ren":"");
  121.     return pid;
  122.     }
  123. }
  125. static int GetBindIntfc(S5NetAddr *bndaddr) {
  126.     u_short bindport = 0;
  127.     char *tmp = NULL, *tmpaddr = NULL, *tmpport = NULL;
  129.     if (bindif) tmp = strdup(bindif);
  130.     else {
  131.         MUTEX_LOCK(env_mutex);
  132.         tmp = getenv("SOCKS5_BINDINTFC");
  133.         if (tmp) tmp = strdup(tmp);
  134.         MUTEX_UNLOCK(env_mutex);
  135.     }
  137.     if (tmp) {
  138.         if ((tmpport = strchr(tmp, ':'))) {
  139.             *tmpport++ = '';
  140.             if (*tmp) tmpaddr = tmp;
  141.         } else {
  142.             if (isdigit(*tmp) && !strchr(tmp, '.')) tmpport = tmp;
  143.             else tmpaddr = tmp;
  144.         }
  145.     }
  146.  
  147.     if (!tmpaddr) {
  148.        memset((char *)bndaddr, 0, sizeof(S5NetAddr));
  149.        bndaddr->sin.sin_family       = AF_INET;
  150.        bndaddr->sin.sin_addr.s_addr  = htonl(INADDR_ANY);
  151.     } else if (lsName2Addr(tmpaddr, bndaddr) < 0 || bndaddr->sin.sin_addr.s_addr == INVALIDADDR ) {
  152.         S5LogUpdate(S5LogDefaultHandle, S5_LOG_ERROR, 0, " Invalid address %s specified", tmpaddr);
  153.         return -1;
  154.     }
  156.     if (tmpport) lsName2Port(tmpport, "tcp", &bindport);
  157.     else lsName2Port("socks", "tcp", &bindport);
  159.     if (bindport == INVALIDPORT) bindport = htons(SOCKS_DEFAULT_PORT);
  161.     lsAddrSetPort(bndaddr, bindport);
  163.     if (tmp) free(tmp);
  164.     return 0;
  165. }
  167. static void GetUdpPortRange(void) {
  168.     char *tmp = NULL, *tmpport = NULL;
  170.     tmp = getenv("SOCKS5_UDPPORTRANGE");
  171.     if (tmp) tmp = strdup(tmp);
  173.     if (tmp) {
  174. if ((tmpport = strchr(tmp, '-'))) *tmpport++ = '';
  176. if (*tmp && isdigit(*tmp)) ludpport = (u_short)atoi(tmp);
  177. else {
  178.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_ERROR, 0, " Invalid udp port range %s", tmp);
  179.     free(tmp);
  180.     return;
  181. }
  183. if (tmpport && *tmpport && isdigit(*tmpport)) hudpport = (u_short)atoi(tmpport);
  184. free(tmp);
  185.     }
  186. }
  188. /* Make a socket with the correct protocol (p), bind it to the right port    */
  189. /* (n, the name or port, the default), and set the function to be called the */
  190. /* socket becomes active (func)...store all this in an fdrec structure for   */
  191. /* convenience's sake...if for any reason something fails and this enry      */
  192. /* should become invalid, the r->fd should be set to -1, so other places     */
  193. /* know to ignore it...                                                      */
  194. static int MakeSocket(int start, S5IOHandle *infd) {
  195.     S5NetAddr bndaddr;
  196.     int on = 1;
  198.     if (!start) {
  199. time_t now = time(NULL);
  200. char tbuf[1024];
  202. MUTEX_LOCK(lt_mutex);
  203. strftime(tbuf, sizeof(tbuf), "%c", localtime(&now));
  204. MUTEX_UNLOCK(lt_mutex);
  205. S5LogUpdate(S5LogDefaultHandle, S5_LOG_INFO, MSGID_SERVER_RESTART, "Socks5 restarting at %s", tbuf);
  206.     }
  208.     if (*infd != S5InvalidIOHandle) {
  209. return 0;
  210.     }
  212.     if (start) {
  213.         if (GetBindIntfc(&bndaddr) < 0) goto cleanup;
  214.     } 
  216.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "Socks5 attempting to run on interface %s:%d", ADDRANDPORT(&bndaddr));
  218.     if ((*infd = socket(AF_INET, SOCK_STREAM, 0)) == S5InvalidIOHandle) {
  219. S5LogUpdate(S5LogDefaultHandle, S5_LOG_ERROR, 0, "Socket failed for %s:%d: %m", ADDRANDPORT(&bndaddr));
  220. goto cleanup;
  221.     }
  223.     if (setsockopt(*infd, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(int)) < 0) {
  224. S5LogUpdate(S5LogDefaultHandle, S5_LOG_ERROR, 0,  "Turning on address reuse failed for %s:%d: %m", ADDRANDPORT(&bndaddr));
  225. goto cleanup;
  226.     }
  227.   
  228.     if (bind(*infd, (ss *)&bndaddr, sizeof(ssi)) < 0) {
  229. S5LogUpdate(S5LogDefaultHandle, S5_LOG_ERROR, MSGID_SERVER_SOCKS_BIND, "Bind failed for %s:%d: %m", ADDRANDPORT(&bndaddr));
  230. goto cleanup;
  231.     }
  232.   
  233.     if (listen(*infd, 5) < 0) {
  234. S5LogUpdate(S5LogDefaultHandle, S5_LOG_ERROR, 0, "Listen failed for %s:%d: %m", ADDRANDPORT(&bndaddr));
  235. goto cleanup;
  236.     }
  238.     /* If we bound, we're the owner, so put our pid in the pidfile.          */
  239. #ifndef DONT_STORE_PID
  240.     if (start) {
  241. char abuf[64], *myfl, *ofile = NULL;
  242. S5IOHandle fd = S5InvalidIOHandle;
  243. pid_t pid = getpid();
  244. struct stat sbuf;
  245.       
  246. MUTEX_LOCK(env_mutex);
  247. myfl = getenv("SOCKS5_PIDFILE");
  248. myfl = myfl?strdup(myfl):strdup(SRVPID_FILE);
  249. MUTEX_UNLOCK(env_mutex);
  251. if ((ofile = malloc(strlen(myfl)+7))) {
  252.     sprintf(ofile, "%s-%d", myfl, (int)ntohs(bndaddr.sin.sin_port));
  253.     free(myfl);
  254.     myfl = ofile;
  255. } else {
  256.     free(myfl);
  257.     myfl = NULL;
  258. }
  259.       
  260. if (myfl) {
  261.     int flags = O_WRONLY | O_CREAT | O_TRUNC;
  262.     /* Open exclusively if the file doesn't exist or if it does, it  */
  263.     /* is a link, and someone else owns it                           */
  264.     if (lstat(myfl, &sbuf) || (S_ISLNK(sbuf.st_mode) && geteuid() != sbuf.st_uid)) flags |= O_EXCL;
  265.     fd = open(myfl, flags, 0644);
  266. }
  268. if (fd == S5InvalidIOHandle) {
  269.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_WARNING, 0, "Error: Failed to open pid file: %s: %m", myfl?myfl:"(null)");
  270. } else {
  271.     sprintf(abuf, "%dn", (int)pid);
  272.     WRITEFILE(fd, abuf, strlen(abuf));
  273.     close(fd);
  274. }
  276. if (myfl) free(myfl);
  277.     }
  278. #endif
  280.     return 0;
  281.     
  282.   cleanup:
  283.     if (*infd != S5InvalidIOHandle) CLOSESOCKET(*infd);
  284.     *infd = S5InvalidIOHandle;
  285.     return -1;
  286. }
  288. /* This is called whenever an error occurs that requires a signal to fix.    */
  289. /* If the server is preforking or threaded, the parent begins in this state, */
  290. /* and only children come out of it... If it is normal, this state is        */
  291. /* reached by having a fatal call to accept...                               */
  292. /*                                                                           */
  293. /* Children come here sometimes when they've had fatal signals and need to   */
  294. /* be killed off...                                                          */
  295. static int GetSignals(void *asem, S5IOHandle *infd) {
  296.     Sigset_t set;
  298.     if (iamachild) {
  299.         S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Childs exiting");
  300.         exit(0);
  301.     }
  303.     /* Block appropriate signals here so that we don't get interrupted while */
  304.     /* we're forking or setting things up...                                 */
  305.     for (set = SigBlock(SIGHUP); ; ) {
  306. /* Do our thing if everything is ok...                               */
  307. if (*infd != S5InvalidIOHandle) {
  308.     switch (servermode) {
  309. case THREADED:
  310.     if (acceptor == 0) acceptor = DoFork();
  311.     if (iamachild) goto done;
  312.     break;
  313. case PREFORKING:
  314.     while (DoFork() > 0);
  315.     if (iamachild) goto done;
  316.     break;
  317.     }
  318. }
  320.         if (servermode == THREADED && (acceptor < 0 && errno != EAGAIN)) {
  321.             S5LogUpdate(S5LogDefaultHandle, S5_LOG_ERROR, 0, "server exiting: fork failed");
  322.             hadsigint = 1;
  323.         }
  325. /* Wait for any signal to arrive, esp SIGCHLD and SIGHUP.  SIGHUP    */
  326. /* will cause a re-read of the config file, everything else: loop.   */
  327. if (!hadfatalsig && !hadsigint && !hadresetsig && *infd != S5InvalidIOHandle) {
  328.     SigPause();
  329. }
  331. if (hadsigint) {
  332.     time_t now = time(NULL);
  333.     char tbuf[1024];
  335.     MUTEX_LOCK(lt_mutex);
  336.     strftime(tbuf, sizeof(tbuf), "%c", localtime(&now));
  337.     MUTEX_UNLOCK(lt_mutex);
  338.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_INFO, MSGID_SERVER_STOP, "Socks5 Exiting at: %s", tbuf);
  340.     hadresetsig = 0;
  341.             kill(-getpid(), SIGINT);
  342.     if (ISMASTER()) { semdestroy(asem); }
  343.     exit(0);
  344. }
  346. if (!hadfatalsig && !hadresetsig) {
  347.             /* SIGCHLD received...                                           */
  348.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(15), 0, "Parent reaped? (%d child%s)", nchildren, (nchildren != 1)?"ren":"");
  349.             continue;
  350. }
  352. if (hadfatalsig) {
  353.     char *tmp = NULL;
  355.     if (servermode == PREFORKING || servermode == THREADED) {
  356. /* Kill whoever is accepting (all of them if preforking) */
  357. /* and reset the semaphore...                            */
  358. hadresetsig = 1;
  359.                 kill(-getpid(), SIGINT);
  360. if (ISMASTER()) { semreset(asem, 1); } 
  361. acceptor = 0;
  362.     }
  364.     ReadConfig();
  366.     if ((tmp = getenv("SOCKS5_TIMEOUT")) && *tmp) idletimeout = atoi(tmp);
  367.     GetUdpPortRange();
  368. }
  369.  
  370. if (hadresetsig && servermode == THREADED) acceptor = 0;
  372. hadfatalsig = 0;
  373. hadresetsig = 0;
  375.         if (servermode == NORMAL) break;
  376.     }
  378.   done:
  379.     SigUnblock(set);
  380.     return 0;
  381. }
  383. static void DoWork(S5IOHandle sd) {
  384.     int eval;
  386.     if (servermode == NORMAL && (eval = DoFork()) != 0) {
  387. CLOSESOCKET(sd);
  388. if (eval > 0 || errno == EAGAIN) return;
  389. exit(-1);
  390.     }
  392.     eval = HandlePxyConnection(sd);
  394.     if (servermode == PREFORKING || servermode == THREADED) {
  395. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Accept: Done with connection...");
  396. return;
  397.     }
  398.     
  399.     exit(eval);
  400. }
  402. #if defined(USE_THREADS) && defined(HAVE_PTHREAD_H)
  403. static void DoThreadWork(S5IOHandle sd) {
  404.     int len;
  405.     S5NetAddr source;
  406.     S5IOHandle afd = sd;
  408.     for (;;) {
  409. DoWork(afd);
  411. MUTEX_LOCK(accept_mutex);
  413. if (semacquire(asem)) {
  414.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(2), 0, "DoThreadWork: Semaphore failure.");
  415.     MUTEX_UNLOCK(accept_mutex);
  416.     THREAD_EXIT(-1);
  417. }
  419. len = sizeof(source);
  420. memset(&source, 0, len);
  421. while ((afd = accept(in, &source.sa, &len)) == S5InvalidIOHandle && ((errno == EINTR)||(errno == EAGAIN)));
  422. semrelease(asem);
  423. MUTEX_UNLOCK(accept_mutex);
  425. if (afd == S5InvalidIOHandle) {
  426.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(2), 0, "DoThreadWork: accept failure.");
  427.     THREAD_EXIT(-1);
  428. }
  429.     }
  430. }
  431. #endif
  433. /* Get a connection from our input socket.  Then based on the socket's       */
  434. /* data, handle the connection correctly, and go on waiting for more         */
  435. /* connetions...                                                             */
  436. static void GetNetConnection(void) {
  437.     Sigset_t set = SigBlock(ISMASTER()?SIGUSR1:SIGHUP);
  438.     S5IOHandle afd;
  439.     S5NetAddr source;
  440.     int aerrno;
  441.     char *tmp = NULL;
  443. #if !defined(USE_THREADS) || !defined(HAVE_PTHREAD_H)
  444.     if (servermode == THREADED) {
  445. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(0), 0, "Warning: Attempt to run server in threaded mode when threads were not a compile time option");
  446. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(0), 0, "Warning: Running as a normal standalone server");
  447.         SigUnblock(set);
  448.         set = SigBlock(SIGHUP);
  449. servermode = NORMAL;
  450.     }
  451. #endif
  453.     Signal(SIGUSR1, reset);
  454.     Signal(SIGHUP,  die);
  455.     Signal(SIGCHLD, gravedigger);
  457.     ReadConfig();
  459.     if (MakeSocket(1, &in) < 0) {
  460.         S5LogUpdate(S5LogDefaultHandle, S5_LOG_ERROR, 0, "Accept: Failed to make listening socket");
  461.         exit(-1);
  462.     }
  464.     if ((tmp = getenv("SOCKS5_TIMEOUT")) && *tmp) idletimeout = atoi(tmp);
  465.     GetUdpPortRange();
  467.     Signal(SIGINT,  markdone);
  468.     Signal(SIGTERM, markdone);
  470.     if (ISMASTER()) {
  471. asem = semcreate(1);
  472. GetSignals(asem, &in);
  473.     }
  475.     if (ISMASTER()) {
  476. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(0), 0, "Error: Master reached slave code in GetNetConnection");
  477. exit(EXIT_ERR);
  478.     }
  480.     if (ISSLAVE()) {
  481. hadsigint = 0;
  482. hadresetsig = 0;
  483.     }
  485.     for (;;) {
  486. int len = sizeof(S5NetAddr);
  488. /* If an important signal has arrived or the acc fd is corrupted,    */
  489. /* got into the signal waiting state (and possibly exit - if child). */
  490. if (hadfatalsig || hadsigint || in == S5InvalidIOHandle) {
  491.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(2), 0, "Accept: Processing exception");
  492.     GetSignals(asem, &in);
  493.     hadfatalsig = 0;
  494. }
  496. if (SigPending(ISSLAVE()?SIGUSR1:SIGHUP)) {
  497.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(2), 0, "Accept: Waiting for a pending fatal signal...");
  498.     while (!hadfatalsig) SigPause();
  499.     continue;
  500. }
  502. /* Try to accept a connection.  We may receive a signal (HUP or      */
  503. /* USR1) here, if that happens, accept should return -1, with errno  */
  504. /* set to EINTR.  We'll handle that later, after we release the      */
  505. /* semaphore.  If we've already received a signal, don't bother      */
  506. /* accepting the connection, just set pri->in to -1 and errno to     */
  507. /* EINTR, to simulate having received the signal here.               */
  508. if (hadfatalsig) {
  509.     afd    = S5InvalidIOHandle;
  510.     aerrno = EINTR;
  511. } else {
  512.     /* For some reason (thanks to Rich Stevens for pointing this     */
  513.     /* out), System 5 is unhappy about a bunch of people calling     */
  514.     /* accept.  So we'll add some locks around it to synchronize     */
  515.     /* access...                                                     */
  516.     if (servermode == THREADED) MUTEX_LOCK(accept_mutex);
  518.     if (ISSLAVE()) {
  519. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(15), 0, "Accept: Acquiring semaphore");
  520. SigUnblock(set);
  522. if (semacquire(asem)) {
  523.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(2), 0, "Accept: Semaphore failure.");
  524.          if (servermode == THREADED) {
  525. MUTEX_UNLOCK(accept_mutex);
  526. if (nconns < nthreads) kill(getppid(), SIGUSR1);
  527. THREAD_EXIT(-1);
  528.     } else { 
  529. CLOSESOCKET(in);
  530. exit(-1);
  531.     }
  532. }
  534. set = SigBlock((servermode == NORMAL)?SIGHUP:SIGUSR1);
  535.     }
  537.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Accept: Waiting on accept or a signal");
  539.     SigUnblock(set);
  540.     while ((afd = accept(in, &source.sa, &len)) == S5InvalidIOHandle && errno == EAGAIN);
  541.     if (afd == S5InvalidIOHandle) aerrno = errno;
  542.     set = SigBlock((servermode == NORMAL)?SIGHUP:SIGUSR1);
  543. }
  545. /* Since we've got the connection, release the semaphore.            */
  546. /*                                                                   */
  547. /* We don't have to worry about releasing a reset semaphore, if we   */
  548. /* received a signal in the meantime, since semreset *should* create */
  549. /* a whole new semaphore, so we'll be releasing one which no one     */
  550. /* else looks at anymore.                                            */
  551. if (ISSLAVE()) {
  552.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(15), 0, "Accept: Releasing semaphore");
  553.     semrelease(asem);
  554.     if (servermode == THREADED) MUTEX_UNLOCK(accept_mutex);
  555. }
  557. /* Do the work according to the protocol to be passed on pri->in.    */
  558. /* When we're done, clean things up so we can do it all again...     */
  559. if (afd == S5InvalidIOHandle) {
  560.     /* We have to make sure the error wasn't too serious.  If it     */
  561.     /* was, quit, unless we are the parent, in which caes we we wait */
  562.     /* for a HUP to tell us things are fixed.                        */
  563.     if (aerrno == EINTR) continue;
  565.     errno = aerrno;
  566.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_ERROR, MSGID_SERVER_SOCKS_ACCEPT, "Accept: Accept failed: %m");
  568.             if (ISSLAVE()) {
  569. if (servermode == THREADED) {
  570.     if (nconns < nthreads) kill(getppid(), SIGUSR1);
  571.     THREAD_EXIT(-1);
  572. } else {
  573.     CLOSESOCKET(in);
  574.     exit(-1);
  575. }
  576.     }
  578.             /* It is NORMAL mode and system resource is exhausted. sleep     */
  579.     /* while and continue...                                         */
  580.     sleep(180);
  581. } else if (servermode == THREADED) {
  582. #if defined(USE_THREADS) && defined(HAVE_PTHREAD_H)
  583.     THREAD_T tid;
  584.     ATTR_T attr;
  585.     sigset_t set, oset;
  587.     if ((nconns + 1) >= nthreads) {
  588. kill(getppid(), SIGUSR1);
  589. nconns++;
  590. DoThreadWork(afd);
  591.     }
  593.     sigemptyset(&set);
  595.             THREAD_ATTR_INIT(attr);
  596.             THREAD_ATTR_SETSTACKSIZE(&attr, 51200);
  597.             THREAD_ATTR_SETSCOPE(attr, PTHREAD_SCOPE_SYSTEM);
  598.             THREAD_ATTR_SETDETACHSTATE(attr, PTHREAD_CREATE_DETACHED);
  599.             THREAD_SIGMASK(SIG_BLOCK, set, oset);
  601.     
  602.             if (THREAD_CREATE(&tid, attr, (void *(*)P((void *)))DoThreadWork, (void *)afd) < 0) {
  603. S5LogUpdate(S5LogDefaultHandle, S5_LOG_ERROR, 0, "Accept: Thread creation failed: %m");
  605. kill(getppid(), SIGUSR1);
  606. nconns++;
  607. DoThreadWork(afd);
  608.     } else nconns++;
  610.             THREAD_DETACH(tid);
  611.     THREAD_SIGMASK(SIG_UNBLOCK, set, oset);
  612. #endif
  613.     afd = S5InvalidIOHandle;
  614. } else {
  615.     if (servermode == SINGLESHOT) CLOSESOCKET(in);
  616.          nconns++;
  617.     DoWork(afd);
  618. }
  619.     }
  620. }
  622. /* Setup a connection which has already been set up for us by inetd.         */
  623. /* Basically, we're just filling in the right structures and calling the     */
  624. /* work function, HandleProxyConnection...                                   */
  625. void GetStdioConnection(void) {
  626.     char *tmp = NULL;
  628.     ReadConfig();
  630.     if ((tmp = getenv("SOCKS5_TIMEOUT")) && *tmp) idletimeout = atoi(tmp);
  631.     GetUdpPortRange();
  633.     fclose(stdout);
  634.     fclose(stderr);
  635.     DoWork(STDIN_FILENO);
  636. }
  638. void GetConnection() {
  639.     Signal(SIGPIPE, SIG_IGN);
  641.     if (servermode == INETD) GetStdioConnection();
  642.     else                     GetNetConnection();
  643. }