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

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

代理服务器

开发平台：

Unix_Linux

sockd.c：源码内容
  1. /*
  2.  * Copyright (c) 1997, 1998, 1999
  3.  *      Inferno Nettverk A/S, Norway.  All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  * 1. The above copyright notice, this list of conditions and the following
  9.  *    disclaimer must appear in all copies of the software, derivative works
  10.  *    or modified versions, and any portions thereof, aswell as in all
  11.  *    supporting documentation.
  12.  * 2. All advertising materials mentioning features or use of this software
  13.  *    must display the following acknowledgement:
  14.  *      This product includes software developed by
  15.  *      Inferno Nettverk A/S, Norway.
  16.  * 3. The name of the author may not be used to endorse or promote products
  17.  *    derived from this software without specific prior written permission.
  18.  *
  19.  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  20.  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  21.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  22.  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  23.  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  24.  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  28.  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29.  *
  30.  * Inferno Nettverk A/S requests users of this software to return to
  31.  *
  32.  *  Software Distribution Coordinator  or  sdc@inet.no
  33.  *  Inferno Nettverk A/S
  34.  *  Oslo Research Park
  35.  *  Gaustadal閑n 21
  36.  *  N-0349 Oslo
  37.  *  Norway
  38.  *
  39.  * any improvements or extensions that they make and grant Inferno Nettverk A/S
  40.  * the rights to redistribute these changes.
  41.  *
  42.  */
  44. #include "common.h"
  46. static const char rcsid[] =
  47. "$Id: sockd.c,v 1.248 1999/12/20 13:07:42 karls Exp $";
  49. /*
  50.  * signal handlers
  51.     */
  53. __BEGIN_DECLS
  55. static void
  56. checksettings __P((void));
  58. static void
  59. siginfo __P((int sig));
  61. static void
  62. sigchld __P((int sig));
  64. static void
  65. sigalrm __P((int sig));
  67. static void
  68. sighup __P((int sig));
  71. static void
  72. sigserverbroadcast __P((int sig));
  73. /*
  74.  * Broadcasts "sig" to all other servers.
  75.  *
  76.  */
  78. static void
  79. serverinit __P((int argc, char *argv[], char *envp[]));
  80. /*
  81.  * Initialises options/config.  "argc" and "argv" should be
  82.  * the arguments passed to main().
  83.  * Exits on failure.
  84.  */
  86. static void
  87. usage __P((int code));
  88. /*
  89.  * print usage.
  90.  */
  92. static void
  93. showversion __P((void));
  94. /*
  95.  * show versioninfo and exits.
  96.  */
  99. static void
  100. showlicense __P((void));
  101. /*
  102.  * shows license and exits.
  103.  */
  105. #if DIAGNOSTIC && HAVE_MALLOC_OPTIONS
  106. extern char *malloc_options;
  107. #endif  /* DIAGNOSTIC && HAVE_MALLOC_OPTIONS */
  109. #if HAVE_PROGNAME
  110. extern char *__progname;
  111. #else
  112. char *__progname = "sockd"; /* default. */
  113. #endif  /* HAVE_PROGNAME */
  115. extern char *optarg;
  117. __END_DECLS
  119. int
  120. #if HAVE_SETPROCTITLE
  121. main(argc, argv)
  122. #else
  123. main(argc, argv, envp)
  124. #endif /* HAVE_SETPROCTITLE */
  125. int argc;
  126. char *argv[];
  127. #if !HAVE_SETPROCTITLE
  128. char    *envp[];
  129. #endif  /* HAVE_SETPROCTITLE */
  130. {
  131. struct sigaction sigact;
  132. int p, maxfd, dforchild;
  133. FILE *fp;
  134. #if HAVE_SETPROCTITLE
  135. char *envp[] = { NULL }; /* dummy. */
  136. #endif /* HAVE_SETPROCTITLE */
  138. const int exitsignalv[] = {
  139. SIGINT, SIGQUIT, SIGBUS, SIGSEGV, SIGTERM
  140. };
  141. const size_t exitsignalc = ELEMENTS(exitsignalv);
  143. const int ignoresignalv[] = {
  144. SIGPIPE
  145. };
  146. const size_t ignoresignalc = ELEMENTS(ignoresignalv);
  148. #if DIAGNOSTIC && HAVE_MALLOC_OPTIONS
  149. malloc_options = "AJ";
  150. #endif  /* DIAGNOSTIC && HAVE_MALLOC_OPTIONS */
  153. serverinit(argc, argv, envp);
  154. showconfig(&config);
  155. socks_seteuid(NULL, config.uid.unprivileged);
  157. /* for chroot and needing every descriptor we can get. */
  158. dforchild = config.log.type & LOGTYPE_SYSLOG ? -1 : 0; /* syslog takes one */
  159. for (p = 0, maxfd = getdtablesize(); p < maxfd; ++p) {
  160. int i;
  162. /* don't close config/log files. */
  163. if (socks_logmatch((size_t)p, &config.log))
  164. continue;
  166. ++dforchild; /* descriptor will be usable by child. */
  168. /* sockets we listen on. */
  169. for (i = 0; i < config.internalc; ++i) {
  170. if (p == config.internalv[i].s)
  171. break;
  173. #if NEED_ACCEPTLOCK
  174. if (config.option.serverc > 1)
  175. if (p == config.internalv[i].lock)
  176. break;
  177. #endif
  178. }
  180. if (i < config.internalc)
  181. continue;
  183. close(p);
  184. }
  185. initlog(); /* for syslog. */
  187. /*
  188.  * Check system limits against what we need.
  189.  * Enough descriptors for each childprocess?  +2 for mother connections.
  190.  */
  192. /* CONSTCOND */
  193. maxfd = MAX(SOCKD_NEGOTIATEMAX,
  194. MAX(SOCKD_REQUESTMAX, SOCKD_IOMAX * FDPASS_MAX)) + 2;
  196. if (dforchild < maxfd) {
  197. struct rlimit rlimit;
  199. rlimit.rlim_cur = maxfd;
  200. rlimit.rlim_max = maxfd;
  202. if (setrlimit(RLIMIT_OFILE, &rlimit) != 0) {
  203. if (errno != EPERM)
  204. serr(EXIT_FAILURE, "setrlimit(RLIMIT_OFILE, %d)", rlimit.rlim_max);
  205. else if (getdtablesize() < SOCKD_NEGOTIATEMAX + 2)
  206. serr(EXIT_FAILURE,
  207. "%d descriptors configured for negotiation, %d available",
  208. SOCKD_NEGOTIATEMAX + 2, getdtablesize());
  209. else if (getdtablesize() < SOCKD_REQUESTMAX + 2)
  210. serr(EXIT_FAILURE,
  211. "%d descriptors configured for requestcompletion, %d available",
  212. SOCKD_REQUESTMAX + 2, getdtablesize());
  213. else if (getdtablesize() < SOCKD_IOMAX * FDPASS_MAX + 2)
  214. serr(EXIT_FAILURE,
  215. "%d descriptors configured for i/o, %d available",
  216. SOCKD_IOMAX * FDPASS_MAX + 2, getdtablesize());
  217. else
  218. SERRX(getdtablesize());
  219. }
  220. }
  222. /* set up signalhandlers. */
  224. sigemptyset(&sigact.sa_mask);
  225. sigact.sa_flags = SA_RESTART | SA_NOCLDSTOP;
  227. sigact.sa_handler = siginfo;
  228. #if HAVE_SIGNAL_SIGINFO
  229. if (sigaction(SIGINFO, &sigact, NULL) != 0) {
  230. swarn("sigaction(SIGINFO)");
  231. return EXIT_FAILURE;
  232. }
  233. #endif  /* HAVE_SIGNAL_SIGINFO */
  235. /* same handler, for systems without SIGINFO. */
  236. if (sigaction(SIGUSR1, &sigact, NULL) != 0) {
  237. swarn("sigaction(SIGUSR1)");
  238. return EXIT_FAILURE;
  239. }
  241. sigact.sa_handler = sighup;
  242. if (sigaction(SIGHUP, &sigact, NULL) != 0) {
  243. swarn("sigaction(SIGHUP)");
  244. return EXIT_FAILURE;
  245. }
  247. sigact.sa_handler = sigchld;
  248. if (sigaction(SIGCHLD, &sigact, NULL) != 0) {
  249. swarn("sigaction(SIGCHLD)");
  250. return EXIT_FAILURE;
  251. }
  253. sigact.sa_handler = sockdexit;
  254. for (p = 0; (size_t)p < exitsignalc; ++p)
  255. if (sigaction(exitsignalv[p], &sigact, NULL) != 0)
  256. swarn("sigaction(%d)", exitsignalv[p]);
  258. sigact.sa_handler = SIG_IGN;
  259. for (p = 0; (size_t)p < ignoresignalc; ++p)
  260. if (sigaction(ignoresignalv[p], &sigact, NULL) != 0)
  261. swarn("sigaction(%d)", ignoresignalv[p]);
  263. sigact.sa_flags = 0; /* want to be interrupted. */
  264. sigact.sa_handler = sigalrm;
  265. if (sigaction(SIGALRM, &sigact, NULL) != 0) {
  266. swarn("sigaction(SIGALRM)");
  267. return EXIT_FAILURE;
  268. }
  270. socks_seteuid(NULL, config.uid.privileged);
  271. if ((fp = fopen(SOCKD_PIDFILE, "w")) == NULL)
  272. swarn("open(%s)", SOCKD_PIDFILE);
  273. socks_seteuid(NULL, config.uid.unprivileged);
  275. if (fp != NULL) {
  276. if (fprintf(fp, "%lun", (unsigned long)config.state.pid) == EOF)
  277. swarn("fprintf(%s)", SOCKD_PIDFILE);
  278. fclose(fp);
  279. }
  281. time(&config.stat.boot);
  283. /* fork of requested number of servers.  Start at one 'cause we are "it".  */
  284. for (p = 1; p < config.option.serverc; ++p) {
  285. pid_t pid;
  287. if ((pid = fork()) == -1)
  288. swarn("fork()");
  289. else if (pid == 0) {
  290. config.state.pid = getpid();
  291. break;
  292. }
  293. else
  294. config.state.motherpidv[p] = pid;
  295. }
  297. if (childcheck(CHILD_NEGOTIATE) <= 0
  298. ||  childcheck(CHILD_REQUEST) <= 0
  299. ||  childcheck(CHILD_IO) <= 0)
  300. serr(EXIT_FAILURE, "childcheck() failed");
  302. slog(LOG_INFO, "%s/server v%s running", PACKAGE, VERSION);
  304. /*
  305.  * main loop; accept new connections and handle our children.
  306.  */
  308. /* CONSTCOND */
  309. while (1) {
  310. int client;
  311. struct sockd_child_t *child;
  312. fd_set rset;
  313. int rbits;
  315. rbits = fillset(&rset);
  317. ++rbits;
  318. switch ((p = select(rbits, &rset, NULL, NULL, NULL))) {
  319. case 0:
  320. SERR(p);
  321. /* NOTREACHED */
  323. case -1:
  324. if (errno == EINTR)
  325. continue;
  326. SERR(p);
  327. /* NOTREACHED */
  328. }
  330. /*
  331.  * handle our children.
  332.  */
  334. /* first, get ack of free slots. */
  335. while ((child = getset(SOCKD_FREESLOT, &rset)) != NULL) {
  336. char command;
  337. int childisbad = 0;
  339. if ((p = readn(child->ack, &command, sizeof(command)))
  340. != sizeof(command)) {
  341. swarn("readn(child->ack) from %schild %lu failed",
  342. childtype2string(child->type), (unsigned long)child->pid);
  343. childisbad = 1;
  344. }
  345. else {
  346. SASSERTX(command == SOCKD_FREESLOT);
  347. ++child->freec;
  348. }
  350. clearset(SOCKD_FREESLOT, child, &rset);
  352. if (childisbad)
  353. removechild(child->pid);
  354. }
  356. /* next, get new requests. */
  357. while ((child = getset(SOCKD_NEWREQUEST, &rset)) != NULL) {
  358. int childisbad = 0;
  360. #if DIAGNOSTIC
  361. int freed = freedescriptors(config.option.debug ? "start" : NULL);
  362. #endif
  364. switch (child->type) {
  365. /*
  366.  * in the order a packet travels between children;
  367.  * negotiate -> request -> io.
  368.  */
  370. case CHILD_NEGOTIATE: {
  371. int flags;
  372. struct sockd_request_t req;
  373. struct sockd_child_t *reqchild;
  375. if ((reqchild = nextchild(CHILD_REQUEST)) == NULL)
  376. break; /* no child to accept a new request. */
  378. SASSERTX(reqchild->freec > 0);
  380. /* receive request from negotiator child... */
  381. if ((p = recv_req(child->s, &req)) != 0) {
  382. childisbad = 1;
  383. break;
  384. }
  385. ++config.stat.negotiate.received;
  387. /* set descriptor to blocking for request... */
  388. if ((flags = fcntl(req.s, F_GETFL, 0)) == -1
  389. ||  fcntl(req.s, F_SETFL, flags & ~O_NONBLOCK) == -1)
  390. swarn("%s: fcntl()");
  392. /* and send it to a request child. */
  393. if ((p = send_req(reqchild->s, &req)) == 0) {
  394. --reqchild->freec;
  395. ++config.stat.request.sendt;
  396. }
  397. else {
  398. clearset(SOCKD_NEWREQUEST, child, &rset);
  399. childisbad = 1;
  400. child = reqchild;
  401. }
  403. close(req.s);
  404. break;
  405. }
  407. case CHILD_REQUEST: {
  408. struct sockd_io_t io;
  409. struct sockd_child_t *iochild;
  411. if ((iochild = nextchild(CHILD_IO)) == NULL)
  412. break; /* no child to accept new io. */
  414. SASSERTX(iochild->freec > 0);
  416. /* get io from request child ... */
  417. if ((p = recv_io(child->s, &io)) != 0) {
  418. childisbad = 1;
  419. break;
  420. }
  421. ++config.stat.request.received;
  423. /* and send it to a io child. */
  424. if ((p = send_io(iochild->s, &io)) == 0) {
  425. --iochild->freec;
  426. ++config.stat.io.sendt;
  427. }
  428. else {
  429. clearset(SOCKD_NEWREQUEST, child, &rset);
  430. childisbad = 1;
  431. child = iochild;
  432. }
  434. close_iodescriptors(&io);
  435. break;
  436. }
  438. case CHILD_IO:
  439. /*
  440.  * the only thing a iochild should return is a ack each time
  441.  * it finishes with a io, that is handled in loop above.
  442.  */
  443. break;
  444. }
  446. #if DIAGNOSTIC
  447. SASSERTX(freed == freedescriptors(config.option.debug ? "end" : NULL));
  448. #endif
  449. clearset(SOCKD_NEWREQUEST, child, &rset);
  451. if (childisbad) /* error/eof from child. */
  452. switch (errno) {
  453. case EMFILE:
  454. case ENFILE:
  455. break; /* child is ok, we are not. */
  457. default:
  458. removechild(child->pid);
  459. }
  460. }
  462. /* handled our children.  Is there a new connection pending? */
  463. for (p = 0; p < config.internalc; ++p) {
  464. char accepted[MAXSOCKADDRSTRING];
  466. if (FD_ISSET(config.internalv[p].s, &rset)) {
  467. const struct listenaddress_t *l = &config.internalv[p];
  468. struct sockd_child_t *negchild;
  469. struct sockaddr from;
  470. socklen_t len;
  472. if ((negchild = nextchild(CHILD_NEGOTIATE)) == NULL)
  473. break;  /* no free negotiator children, don't accept(). */
  475. #if NEED_ACCEPTLOCK
  476. if (config.option.serverc > 1)
  477. if (socks_lock(l->lock, F_WRLCK, 0) != 0)
  478. continue;
  479. #endif
  481. #if HAVE_SENDMSG_DEADLOCK
  482. if (socks_lock(negchild->lock, F_WRLCK, 0) != 0) {
  483. #if NEED_ACCEPTLOCK
  484. if (config.option.serverc > 1)
  485. socks_unlock(l->lock);
  486. #endif /* NEED_ACCEPTLOCK */
  487. continue;
  488. }
  489. #endif /* HAVE_SENDMSG_DEADLOCK */
  491. len = sizeof(from);
  492. if ((client = acceptn(l->s, &from, &len)) == -1)
  493. switch (errno) {
  494. #ifdef EPROTO
  495. case EPROTO: /* overloaded SVR4 error */
  496. #endif
  497. case EWOULDBLOCK: /* BSD */
  498. case ECONNABORTED: /* POSIX */
  500. /* rest appears to be linux stuff according to apache src. */
  501. #ifdef ECONNRESET
  502. case ECONNRESET:
  503. #endif
  504. #ifdef ETIMEDOUT
  505. case ETIMEDOUT:
  506. #endif
  507. #ifdef EHOSTUNREACH
  508. case EHOSTUNREACH:
  509. #endif
  510. #ifdef ENETUNREACH
  511. case ENETUNREACH:
  512. #endif
  514. #if NEED_ACCEPTLOCK
  515. if (config.option.serverc > 1)
  516. socks_unlock(l->lock);
  517. #endif /* NEED_ACCEPTLOCK */
  519. #if HAVE_SENDMSG_DEADLOCK
  520. socks_unlock(negchild->lock);
  521. #endif /* HAVE_SENDMSG_DEADLOCK */
  523. continue; /* connection aborted/failed. */
  525. case ENFILE:
  526. continue;
  528. /*
  529.  * this should never happen since childcheck(), if
  530.  * initially successful, should make sure there is
  531.  * always enough descriptors available.
  532.  */
  533. case EMFILE:
  534. /* FALLTHROUGH */
  536. default:
  537. SERR(client);
  538. }
  540. #if HAVE_LINUX_BUGS
  541. /*
  542.  * yes, linux manages to lose the descriptor flags, workaround
  543.  * might be insufficient.
  544.  */
  545. if (fcntl(client, F_SETFL, fcntl(l->s, F_GETFL, 0)) != 0)
  546. swarn("tried to work around linux bug via fcntl()");
  547. #endif /* HAVE_LINUX_BUGS */
  549. ++config.stat.accepted;
  551. #if NEED_ACCEPTLOCK
  552. if (config.option.serverc > 1)
  553. socks_unlock(l->lock);
  554. #endif
  556. slog(LOG_DEBUG, "got accept(): %s",
  557. sockaddr2string(&from, accepted, sizeof(accepted)));
  559. if (send_client(negchild->s, client) == 0) {
  560. --negchild->freec;
  561. ++config.stat.negotiate.sendt;
  562. }
  563. else
  564. switch (errno) {
  565. case EMFILE:
  566. case ENFILE:
  567. break; /* child is ok, we are not. */
  569. default:
  570. removechild(negchild->pid);
  571. }
  573. #if HAVE_SENDMSG_DEADLOCK
  574. socks_unlock(negchild->lock);
  575. #endif /* HAVE_SENDMSG_DEADLOCK */
  577. close(client);
  578. }
  579. }
  580. }
  582. /* NOTREACHED */
  583. }
  585. int
  586. pidismother(pid)
  587. pid_t pid;
  588. {
  589. int i;
  591. for (i = 0; i < config.option.serverc; ++i)
  592. if (config.state.motherpidv[i] == pid)
  593. return i + 1;
  594. return 0;
  595. }
  598. static void
  599. usage(code)
  600. int code;
  601. {
  603. fprintf(code == 0 ? stdout : stderr,
  604. "%s: usage: %s [-DLNdfhlnv]n"
  605. "t -D             : run in daemon moden"
  606. "t -L             : shows the license for this programn"
  607.    "t -N <number>    : fork of <number> servers (default: 1)n"
  608. "t -d             : enable debuggingn"
  609. "t -f <filename>  : use <filename> as configuration filen"
  610. "t -h             : print this informationn"
  611. "t -l             : linebuffer outputn"
  612.    "t -n             : disable TCP keep-aliven"
  613. "t -v             : print version infon",
  614. __progname, __progname);
  616. exit(code);
  617. }
  619. static void
  620. showversion(void)
  621. {
  623. printf("%s: %s v%sn", __progname, PACKAGE, VERSION);
  624. exit(EXIT_SUCCESS);
  625. }
  628. static void
  629. showlicense(void)
  630. {
  632. printf("%s: %s v%sn%sn", __progname, PACKAGE, VERSION,
  633. "
  634. /*n
  635.  * Copyright (c) 1997, 1998, 1999n
  636.  *      Inferno Nettverk A/S, Norway.  All rights reserved.n
  637.  *n
  638.  * Redistribution and use in source and binary forms, with or withoutn
  639.  * modification, are permitted provided that the following conditionsn
  640.  * are met:n
  641.  * 1. The above copyright notice, this list of conditions and the followingn
  642.  *    disclaimer must appear in all copies of the software, derivative worksn
  643.  *    or modified versions, and any portions thereof, aswell as in alln
  644.  *    supporting documentation.n
  645.  * 2. All advertising materials mentioning features or use of this softwaren
  646.  *    must display the following acknowledgement:n
  647.  *      This product includes software developed byn
  648.  *      Inferno Nettverk A/S, Norway.n
  649.  * 3. The name of the author may not be used to endorse or promote productsn
  650.  *    derived from this software without specific prior written permission.n
  651.  *n
  652.  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS ORn
  653.  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIESn
  654.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. n
  655.  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,n
  656.  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUTn
  657.  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,n
  658.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANYn
  659.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT n
  660.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OFn
  661.  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.n
  662.  *n
  663.  * Inferno Nettverk A/S requests users of this software to return ton
  664.  * n
  665.  *  Software Distribution Coordinator  or  sdc@inet.non
  666.  *  Inferno Nettverk A/Sn
  667.  *  Oslo Research Parkn
  668.  *  Gaustadal閑n 21n
  669.  *  N-0349 Oslon
  670.  *  Norwayn
  671.  * n
  672.  * any improvements or extensions that they make and grant Inferno Nettverk A/Sn
  673.  * the rights to redistribute these changes.n
  674.  *n
  675.  */");
  677. exit(EXIT_SUCCESS);
  678. }
  680. /* ARGSUSED */ /* need envp if no HAVE_SETPROCTITLE */
  681. static void
  682. serverinit(argc, argv, envp)
  683. int argc;
  684. char *argv[];
  685. char *envp[];
  686. {
  687. const char *function = "serverinit()";
  688. uid_t euid;
  689. int ch, i;
  691. #if !HAVE_PROGNAME
  692. if (argv[0] != NULL)
  693. if ((__progname = strrchr(argv[0], '/')) == NULL)
  694. __progname = argv[0];
  695. else
  696. ++__progname;
  697. #endif  /* !HAVE_PROGNAME */
  699. #if !HAVE_SETPROCTITLE
  700. if (initsetproctitle(argc, argv, envp) == -1)
  701. serr(EXIT_FAILURE, "malloc");
  702. #endif  /* !HAVE_SETPROCTITLE*/
  704. config.state.addchild = 1;
  705. config.state.euid = geteuid();
  706. config.state.type = CHILD_MOTHER;
  707. config.option.serverc = 1; /* ourselves. ;-) */
  709. while ((ch = getopt(argc, argv, "DLN:df:hlnvw:")) != -1) {
  710. switch (ch) {
  711. case 'D':
  712. config.option.daemon = 1;
  713. break;
  715. case 'L':
  716. showlicense();
  717. /* NOTREACHED */
  719. case 'N':
  720. if ((config.option.serverc = atoi(optarg)) < 1)
  721. serrx(1, "%s: illegal value for -%c: %d",
  722. function, ch, config.option.serverc);
  723. break;
  725. case 'd':
  726. ++config.option.debug;
  727. break;
  729. case 'f':
  730. #if !HAVE_SETPROCTITLE
  731. /* let it point outside argv for replacement setproctitle(). */
  732. if ((config.option.configfile = strdup(optarg)) == NULL)
  733. serrx(EXIT_FAILURE, "%s: %s", function, NOMEM);
  734. #else
  735. config.option.configfile = optarg;
  736. #endif /* !HAVE_SETPROCTITLE */
  737. break;
  739. case 'h':
  740. usage(0);
  741. /* NOTREACHED */
  743. case 'l':
  744. config.option.lbuf = 1;
  745. break;
  747. case 'n':
  748. config.option.keepalive = 0;
  749. break;
  751. case 'v':
  752. showversion();
  753. /* NOTREACHED */
  755. case 'w':
  756. config.option.sleep = atoi(optarg);
  757. break;
  759. default:
  760. usage(1);
  761. }
  762. }
  764. if (config.option.daemon)
  765. if (daemon(1, 0) != 0)
  766. serr(EXIT_FAILURE, "daemon()");
  768. config.state.pid = getpid();
  769. if ((config.state.motherpidv
  770. = (pid_t *)malloc(sizeof(*config.state.motherpidv) * config.option.serverc))
  771. == NULL)
  772. serrx(EXIT_FAILURE, "%s: %s", function, NOMEM);
  773. *config.state.motherpidv = config.state.pid; /* main server. */
  775. if (config.option.configfile == NULL)
  776. config.option.configfile = SOCKD_CONFIGFILE;
  778. genericinit();
  779. checksettings();
  781. socks_seteuid(&euid, config.uid.privileged);
  782. for (i = 0; i < config.internalc; ++i) {
  783. int flags;
  784. struct listenaddress_t *l = &config.internalv[i];
  786. if ((l->s = socket(AF_INET, SOCK_STREAM, 0)) == -1)
  787. serr(EXIT_FAILURE, "%s: socket(SOCK_STREAM)", function);
  789. setsockoptions(l->s);
  791. ch = 1;
  792. if (setsockopt(l->s, SOL_SOCKET, SO_REUSEADDR, &ch, sizeof(ch))
  793. != 0)
  794. swarn("%s: setsockopt(SO_REUSEADDR)", function);
  796. /* LINTED pointer casts may be troublesome */
  797. if (sockd_bind(l->s, (struct sockaddr *)&l->addr, 0) != 0) {
  798. char badbind[MAXSOCKADDRSTRING];
  800. /* LINTED pointer casts may be troublesome */
  801. serr(EXIT_FAILURE, "%s: bind(%s)",
  802. function, sockaddr2string((struct sockaddr *)&l->addr, badbind,
  803. sizeof(badbind)));
  804. }
  806. if (listen(l->s, SOCKD_MAXCLIENTQUE) == -1)
  807. serr(EXIT_FAILURE, "%s: listen(%d)", function, SOCKD_MAXCLIENTQUE);
  809. if ((flags = fcntl(l->s, F_GETFL, 0)) == -1
  810. ||  fcntl(l->s, F_SETFL, flags | O_NONBLOCK) == -1)
  811. serr(EXIT_FAILURE, "%s: fcntl()", function);
  813. #if NEED_ACCEPTLOCK
  814. if (config.option.serverc > 1)
  815. if ((l->lock = socks_mklock(SOCKS_LOCKFILE)) == -1)
  816. serr(EXIT_FAILURE, "%s: socks_mklock()", function);
  817. #endif
  818. }
  819. socks_reseteuid(config.uid.privileged, euid);
  820. }
  822. static void
  823. checksettings(void)
  824. {
  825. const char *function = "checksettings()";
  826. int i;
  827. uid_t euid;
  829. /*
  830.  * Check arguments and settings, do they make sense?
  831.  */
  833. if (config.internalc == 0)
  834. serrx(EXIT_FAILURE, "%s: no internal address given", function);
  836. if (config.externalc == 0)
  837. serrx(EXIT_FAILURE, "%s: no external address given", function);
  838. for (i = 0; i < config.externalc; ++i) {
  839. int s;
  841. if ((s = socket(AF_INET, SOCK_STREAM, 0)) == -1)
  842. switch (errno) {
  843. case EMFILE:
  844. case ENFILE:
  845. case ENOBUFS:
  846. break; /* assume this is temporary, e.g. after sighup. */
  848. default:
  849. serrx(EXIT_FAILURE, "%s: socket()", function);
  850. }
  851. else {
  852. char addrstring[MAXSOCKADDRSTRING];
  854. if (bind(s, (struct sockaddr *)&config.externalv[i],
  855. sizeof(config.externalv[i])) != 0)
  856. serrx(EXIT_FAILURE, "%s: can't bind external address: %s",
  857. function, sockaddr2string((struct sockaddr *)&config.externalv[i],
  858. addrstring, sizeof(addrstring)));
  859. close(s);
  860. }
  861. }
  863. if (config.methodc == 0)
  864. swarnx("%s: no methods enabled (total block)", function);
  866. if (!config.uid.privileged_isset)
  867. serrx(EXIT_FAILURE, "%s: privileged user not set", function);
  868. socks_seteuid(&euid, config.uid.privileged);
  869. socks_reseteuid(config.uid.privileged, euid);
  871. if (!config.uid.unprivileged_isset)
  872. serrx(EXIT_FAILURE, "%s: unprivileged user not set", function);
  873. socks_seteuid(&euid, config.uid.unprivileged);
  874. socks_reseteuid(config.uid.unprivileged, euid);
  876. #if HAVE_LIBWRAP
  877. if (!config.uid.libwrap_isset)
  878. serrx(EXIT_FAILURE, "%s: libwrap user not set", function);
  879. socks_seteuid(&euid, config.uid.libwrap);
  880. socks_reseteuid(config.uid.libwrap, euid);
  881. #endif /* HAVE_LIBWRAP */
  883. }
  885. /* ARGSUSED */
  886. static void
  887. siginfo(sig)
  888. int sig;
  889. {
  890. unsigned long seconds, days, hours, minutes;
  891. size_t clients;
  893. clients = 0;
  894. clients += childcheck(-CHILD_NEGOTIATE);
  895. clients += childcheck(-CHILD_REQUEST);
  896. clients += childcheck(-CHILD_IO);
  898. clients -= childcheck(CHILD_NEGOTIATE);
  899. clients -= childcheck(CHILD_REQUEST);
  900. clients -= childcheck(CHILD_IO);
  902. seconds = difftime(time(NULL), config.stat.boot);
  904. if (seconds >= 3600 * 24) {
  905. days = seconds / (3600 * 24);
  906. seconds -= days * 3600 * 24;
  907. }
  908. else
  909. days = 0;
  911. if (seconds >= 3600) {
  912. hours = seconds / 3600;
  913. seconds -= hours * 3600;
  914. }
  915. else
  916. hours = 0;
  918. if (seconds >= 60) {
  919. minutes = seconds / 60;
  920. seconds -= minutes * 60;
  921. }
  922. else
  923. minutes = 0;
  925. slog(LOG_INFO, "%s v%s up %lu day%s, %lu:%.2lu, a: %lu, c: %lu",
  926. PACKAGE, VERSION, days, days == 1 ? "" : "s", hours, minutes,
  927. (unsigned long)config.stat.accepted, (unsigned long)clients);
  929. slog(LOG_INFO, "negotiators (%d): a: %lu, h: %lu, c: %lu",
  930. childcheck(-CHILD_NEGOTIATE) / SOCKD_NEGOTIATEMAX,
  931. (unsigned long)config.stat.negotiate.sendt,
  932. (unsigned long)config.stat.negotiate.received,
  933. (unsigned long)childcheck(-CHILD_NEGOTIATE) - childcheck(CHILD_NEGOTIATE));
  935. slog(LOG_INFO, "requests (%d): a: %lu, h: %lu, c: %lu",
  936. childcheck(-CHILD_REQUEST) / SOCKD_REQUESTMAX,
  937. (unsigned long)config.stat.request.sendt,
  938. (unsigned long)config.stat.request.received,
  939. (unsigned long)childcheck(-CHILD_REQUEST) - childcheck(CHILD_REQUEST));
  941. slog(LOG_INFO, "iorelayers (%d): a: %lu, h: %lu, c: %lu",
  942. childcheck(-CHILD_IO) / SOCKD_IOMAX,
  943. (unsigned long)config.stat.io.sendt, (unsigned long)config.stat.io.sendt,
  944. (unsigned long)childcheck(-CHILD_IO) - childcheck(CHILD_IO));
  946. if (*config.state.motherpidv == config.state.pid) /* main mother */
  947. sigserverbroadcast(sig);
  949. sigchildbroadcast(sig, CHILD_NEGOTIATE | CHILD_REQUEST | CHILD_IO);
  950. }
  953. /* ARGSUSED */
  954. static void
  955. sighup(sig)
  956. int sig;
  957. {
  958. const char *function = "sighup()";
  959. uid_t euid;
  960. int p;
  962. slog(LOG_INFO, function);
  964. resetconfig();
  966. socks_seteuid(&euid, config.state.euid);
  967. genericinit();
  968. socks_reseteuid(config.state.euid, euid);
  970. checksettings();
  972. /* LINTED assignment in conditional context */
  973. if ((p = pidismother(config.state.pid))) {
  974. if (p == 1) { /* main mother. */
  975. showconfig(&config);
  976. sigserverbroadcast(sig);
  977. }
  979. sigchildbroadcast(sig, CHILD_NEGOTIATE | CHILD_REQUEST | CHILD_IO);
  980. }
  981. }
  983. /* ARGSUSED */
  984. static void
  985. sigchld(sig)
  986. int sig;
  987. {
  988. const char *function = "sigchld()";
  989. static time_t deathtime;
  990. static int deaths;
  991. int status;
  992. pid_t pid;
  995. while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
  996. int i;
  998. /*
  999.  * No child should normally die, but try to cope with it happening.
  1000.  */
  1002. /* LINTED assignment in conditional context */
  1003. if ((i = pidismother(pid)))
  1004. config.state.motherpidv[i - 1] = 0;
  1005. else
  1006. ; /* assume relay child. */
  1008. ++deaths;
  1009. }
  1011. /*
  1012.  * If we get alot of childdeaths in a short time, assume something
  1013.  * is wrong.
  1014.  */
  1016. if (deathtime == 0)
  1017. time(&deathtime);
  1019. if (difftime(time(NULL), deathtime) > 60) { /* enough time passed; reset. */
  1020. deaths = 0;
  1021. time(&deathtime);
  1022. }
  1024. if (deaths >= 10) {
  1025. if (deaths == 10) { /* log once. */
  1026. slog(LOG_ERR, "%s: %d childdeaths in %.0fs; locking count for a while",
  1027. function, deaths, difftime(time(NULL), deathtime));
  1028. config.state.addchild = 0;
  1029. }
  1030. time(&deathtime); /* once the ball starts rolling... */
  1031. alarm(60);
  1032. }
  1033. else
  1034. config.state.addchild = 1; /* can try to add a new one. */
  1035. }
  1037. /* ARGSUSED */
  1038. static void
  1039. sigalrm(sig)
  1040. int sig;
  1041. {
  1043. config.state.addchild = 1;
  1044. }
  1046. void
  1047. sigserverbroadcast(sig)
  1048. int sig;
  1049. {
  1050. int i;
  1052. SASSERTX(*config.state.motherpidv == config.state.pid);
  1054. for (i = 1; i < config.option.serverc; ++i)
  1055. if (config.state.motherpidv[i] != 0)
  1056. kill(config.state.motherpidv[i], sig);
  1057. }