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

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

代理服务器

开发平台：

Unix_Linux

sockd_child.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_child.c,v 1.118 2000/01/05 10:38:58 michaels Exp $";
  49. #define MOTHER 0 /* descriptor mother reads/writes on. */
  50. #define CHILD 1 /* descriptor child reads/writes on. */
  52. __BEGIN_DECLS
  54. static int
  55. setchildtype __P((int type, struct sockd_child_t ***childv, int **childc,
  56. void (**function)(struct sockd_mother_t *mother)));
  57. /*
  58.  * Sets "childv", "childc" and "function" to the correct value depending
  59.  * on "type".
  60.  */
  63. static int
  64. findchild __P((pid_t pid, int childc, const struct sockd_child_t *childv));
  65. /*
  66.  * Finds the child with pid "pid" in the array "childv".  Searching
  67.  * Elements in "childv" is given by "childc".
  68.  * Returns:
  69.  * On success: the index of the child in "childv".
  70.  * On failure: -1.
  71.  */
  73. __END_DECLS
  76. static struct sockd_child_t *iochildv; /* all our iochildren */
  77. static int iochildc;
  79. static struct sockd_child_t *negchildv; /* all our negotiatorchildren */
  80. static int negchildc;
  82. static struct sockd_child_t *reqchildv; /* all our requestchildren */
  83. static int reqchildc;
  86. struct sockd_child_t *
  87. addchild(type)
  88. int type;
  89. {
  90. const char *function = "addchild()";
  91. /*
  92.     * It is better to reserve some descriptors for temporary use
  93.     * than to get errors when passing them and thus lose clients.
  94.     */
  95. const int reserved = FDPASS_MAX /* max descriptors we pass. */
  96.  + 1 /* need a descriptor for accept(). */
  97.  + 2; /* for each new child. */
  98. struct sockd_mother_t mother;
  99. struct sockd_child_t **childv;
  100. int *childc;
  101. void (*childfunction)(struct sockd_mother_t *mother);
  102. pid_t pid;
  103. int optval, flags;
  104. int pipev[] = { -1, -1 };
  105. int ackpipev[] = { -1, -1 };
  107. /*
  108.  * XXX This is a expensive test which shouldn't be hard to optimize
  109.  * away.  It only happens when we are running low on slots though,
  110.  * so assume it's "good enough" until I get the time to fix it.
  111.  */
  112. if (freedescriptors(NULL) < reserved) {
  113. errno = EMFILE;
  114. swarn(function);
  115. return NULL;
  116. }
  118. /* create datapipe. */
  119. if (socketpair(AF_LOCAL, SOCK_STREAM, 0, pipev) != 0) {
  120. swarn("%s: socketpair(AF_LOCAL, SOCK_STREAM)", function);
  121. return NULL;
  122. }
  124. /* and ackpipe. */
  125. if (pipe(ackpipev) != 0) {
  126. swarn("%s: pipe()", function);
  127. closev(pipev, ELEMENTS(pipev));
  128. return NULL;
  129. }
  131. /*
  132.  * Try to set socketbuffer and watermarks to a optimal size.
  133.  */
  134. switch (type = setchildtype(type, &childv, &childc, &childfunction)) {
  135. case CHILD_NEGOTIATE:
  136. /*
  137.  * A negotiator child receives only descriptors, so mothers
  138.  * send buffer can be small, and so can the child's receive buffer.
  139.  * The child sends a sockd_request_t struct back to mother, so
  140.  * mothers recv buffer has to be considerably bigger, as does
  141.  * childs send buffer.
  142.  */
  144. /* negotiator shouldn't block on sending to mother. */
  145. if ((flags = fcntl(pipev[CHILD], F_GETFL, 0)) == -1
  146. ||  fcntl(pipev[CHILD], F_SETFL, flags | O_NONBLOCK) == -1)
  147. swarn("%s: fcntl()", function);
  149. #if HAVE_SENDMSG_DEADLOCK
  150. if ((mother.lock = socks_mklock(SOCKS_LOCKFILE)) == -1) {
  151. swarn("%s: socks_mklock()", function);
  152. closev(pipev, ELEMENTS(pipev));
  153. closev(ackpipev, ELEMENTS(ackpipev));
  154. return NULL;
  155. }
  156. #endif /* HAVE_SENDMSG_DEADLOCK */
  158. optval = sizeof(struct sockd_request_t) * (SOCKD_NEGOTIATEMAX + 1);
  159. if (setsockopt(pipev[MOTHER], SOL_SOCKET, SO_RCVBUF, &optval,
  160. sizeof(optval)) != 0
  161. ||  setsockopt(pipev[CHILD], SOL_SOCKET, SO_SNDBUF, &optval,
  162. sizeof(optval)) != 0)
  163. swarn("%s: setsockopt(SO_RCVBUF/SO_SNDBUF)", function);
  165. #if HAVE_SO_SNDLOWAT
  166. optval = sizeof(struct sockd_request_t) * LOWATSKEW;
  167. if (setsockopt(pipev[CHILD], SOL_SOCKET, SO_SNDLOWAT, &optval,
  168. sizeof(optval)) != 0
  169. || setsockopt(pipev[MOTHER], SOL_SOCKET, SO_RCVLOWAT, &optval,
  170. sizeof(optval)) != 0)
  171. swarn("%s: setsockopt(SO_SNDLOWAT/SO_RCVLOWAT)", function);
  172. #endif
  173. break;
  175. case CHILD_REQUEST:
  176. /*
  177.  * A request child receives a sockd_request_t structure,
  178.  * it sends back a sockd_io_t structure.
  179.  */
  181. #if HAVE_SENDMSG_DEADLOCK
  182. mother.lock = -1; /* doesn't need lock. */
  183. #endif /* HAVE_SENDMSG_DEADLOCK */
  185. optval = sizeof(struct sockd_request_t) * (SOCKD_REQUESTMAX + 1);
  186. if (setsockopt(pipev[MOTHER], SOL_SOCKET, SO_SNDBUF, &optval,
  187. sizeof(optval)) != 0
  188. ||  setsockopt(pipev[CHILD], SOL_SOCKET, SO_RCVBUF, &optval,
  189. sizeof(optval)) != 0)
  190. swarn("%s: setsockopt()", function);
  192. optval = sizeof(struct sockd_io_t) * (SOCKD_REQUESTMAX + 1);
  193. if (setsockopt(pipev[MOTHER], SOL_SOCKET, SO_RCVBUF, &optval,
  194. sizeof(optval)) != 0
  195. ||  setsockopt(pipev[CHILD], SOL_SOCKET, SO_SNDBUF, &optval,
  196. sizeof(optval)) != 0)
  197. swarn("%s: setsockopt()", function);
  199. #if HAVE_SO_SNDLOWAT
  200. optval = sizeof(struct sockd_request_t) * LOWATSKEW;
  201. if (setsockopt(pipev[CHILD], SOL_SOCKET, SO_RCVLOWAT, &optval,
  202. sizeof(optval)) != 0
  203. || setsockopt(pipev[MOTHER], SOL_SOCKET, SO_SNDLOWAT, &optval,
  204. sizeof(optval)) != 0)
  205. swarn("%s: setsockopt(SO_RCVLOWAT)", function);
  207. optval = sizeof(struct sockd_io_t) * LOWATSKEW;
  208. if (setsockopt(pipev[CHILD], SOL_SOCKET, SO_SNDLOWAT, &optval,
  209. sizeof(optval)) != 0
  210. || setsockopt(pipev[MOTHER], SOL_SOCKET, SO_RCVLOWAT, &optval,
  211. sizeof(optval)) != 0)
  212. swarn("%s: setsockopt(SO_RCVLOWAT/SO_SNDLOWAT)", function);
  213. #endif
  214. break;
  216. case CHILD_IO:
  217. /*
  218.  * A io child receives a sockd_io_t structure,
  219.  * it sends back only a ack.
  220.  */
  222. #if HAVE_SENDMSG_DEADLOCK
  223. mother.lock = -1; /* doesn't need lock. */
  224. #endif /* HAVE_SENDMSG_DEADLOCK */
  226. optval = sizeof(struct sockd_io_t) * (SOCKD_IOMAX + 1);
  227. if (setsockopt(pipev[MOTHER], SOL_SOCKET, SO_SNDBUF, &optval,
  228. sizeof(optval)) != 0
  229. ||  setsockopt(pipev[CHILD], SOL_SOCKET, SO_RCVBUF, &optval,
  230. sizeof(optval)) != 0)
  231. swarn("%s: setsockopt(SO_SNDBUF/SO_RCVBUF)", function);
  233. optval = sizeof(int) * (SOCKD_IOMAX + 1);
  234. if (setsockopt(pipev[MOTHER], SOL_SOCKET, SO_RCVBUF, &optval,
  235. sizeof(optval)) != 0
  236. ||  setsockopt(pipev[CHILD], SOL_SOCKET, SO_SNDBUF, &optval,
  237. sizeof(optval)) != 0)
  238. swarn("%s: setsockopt(SO_RCVBUF/SO_SNDBUF)", function);
  240. #if HAVE_SO_SNDLOWAT
  241. optval = sizeof(struct sockd_io_t) * LOWATSKEW;
  242. if (setsockopt(pipev[CHILD], SOL_SOCKET, SO_RCVLOWAT, &optval,
  243. sizeof(optval)) != 0
  244. || setsockopt(pipev[MOTHER], SOL_SOCKET, SO_SNDLOWAT, &optval,
  245. sizeof(optval)) != 0)
  246. swarn("%s: setsockopt(SO_RCVLOWAT)", function);
  247. #endif
  248. break;
  250. default:
  251. SERRX(type);
  252. }
  254. switch ((pid = fork())) {
  255. case -1:
  256. swarn("%s: fork()", function);
  257. closev(pipev, ELEMENTS(pipev));
  258. closev(ackpipev, ELEMENTS(ackpipev));
  260. #if HAVE_SENDMSG_DEADLOCK
  261. if (mother.lock != -1)
  262. close(mother.lock);
  263. #endif /* HAVE_SENDMSG_DEADLOCK */
  265. return NULL;
  267. case 0: {
  268. size_t i, maxfd;
  269. struct sigaction sigact;
  271. config.state.type = type;
  272. config.state.pid = getpid();
  274. initlog();
  276. slog(LOG_DEBUG, "created new %schild", childtype2string(type));
  277. #if 0
  278. slog(LOG_DEBUG, "sleeping...");
  279. sleep(20);
  280. #endif
  282. mother.s = pipev[CHILD];
  283. mother.ack = ackpipev[CHILD];
  285. /*
  286.  * It would be nice to be able to lose all privileges here
  287.  * but unfortunately we can't, yet.
  288.  *
  289.  * negotiation children:
  290.  * could need privileges to check password.
  291.  *
  292.  * request children:
  293.  * could need privileges to bind port.
  294.  *
  295.  * io children:
  296.  * doesn't really need any, but a sighup() performs misc.
  297.  * seteuid() tests that would fail if we lose privileges.
  298.  */
  300. switch (type) {
  301. case CHILD_NEGOTIATE:
  302. #if HAVE_LIBWRAP
  303. #if SOCKD_NEGOTIATEMAX > 1
  304. resident = 1;
  305. #endif /* SOCKD_NEGOTIATEMAX > 1 */
  306. #endif  /* HAVE_LIBWRAP */
  307. break;
  309. case CHILD_REQUEST:
  310. #if HAVE_LIBWRAP
  311. #if SOCKD_REQUESTMAX > 1
  312. resident = 1;
  313. #endif /* SOCKD_REQUESTMAX > 1 */
  314. #endif  /* HAVE_LIBWRAP */
  315. break;
  317. case CHILD_IO:
  318. #if HAVE_LIBWRAP
  319. #if SOCKD_IOMAX > 1
  320. resident = 1;
  321. #endif /* SOCKD_IOMAX > 1 */
  322. #endif  /* HAVE_LIBWRAP */
  323. break;
  325. default:
  326. SERRX(type);
  327. }
  329. sigemptyset(&sigact.sa_mask);
  330. sigact.sa_flags = 0;
  332. /* signals mother has set up but which we ignore at this point. */
  333. sigact.sa_handler = SIG_IGN;
  335. #if HAVE_SIGNAL_SIGINFO
  336. if (sigaction(SIGINFO, &sigact, NULL) != 0)
  337. swarn("%s: sigaction(SIGINFO)", function);
  338. #endif  /* HAVE_SIGNAL_SIGINFO */
  340. if (sigaction(SIGUSR1, &sigact, NULL) != 0)
  341. swarn("%s: sigaction(USR1)", function);
  343. /* delete everything we got from parent. */
  344. for (i = 0, maxfd = getdtablesize(); i < maxfd; ++i) {
  345. /* exceptions */
  346. if (i == (size_t)mother.s
  347. #if HAVE_SENDMSG_DEADLOCK
  348. || i == (size_t)mother.lock
  349. #endif /* HAVE_SENDMSG_DEADLOCK */
  350. || i == (size_t)mother.ack)
  351. continue;
  353. if (socks_logmatch(i, &config.log))
  354. continue;
  356. close((int)i);
  357. }
  358. initlog(); /* for syslog. */
  360. childfunction(&mother);
  361. /* NOTREACHED */
  362. }
  364. default: {
  365. struct sockd_child_t *newchildv;
  367. if ((newchildv = (struct sockd_child_t *)realloc(*childv,
  368. sizeof(**childv) * (*childc + 1))) == NULL) {
  369. slog(LOG_WARNING, "%s: %s", function, NOMEM);
  370. closev(pipev, ELEMENTS(pipev));
  371. closev(ackpipev, ELEMENTS(ackpipev));
  372. return NULL;
  373. }
  374. *childv = newchildv;
  376. (*childv)[*childc].type = type;
  377. (*childv)[*childc].pid = pid;
  378. (*childv)[*childc].s = pipev[MOTHER];
  379. #if HAVE_SENDMSG_DEADLOCK
  380. (*childv)[*childc].lock = mother.lock;
  381. #endif /* HAVE_SENDMSG_DEADLOCK */
  382. (*childv)[*childc].ack = ackpipev[MOTHER];
  384. close(pipev[CHILD]);
  385. close(ackpipev[CHILD]);
  387. switch ((*childv)[*childc].type) {
  388. case CHILD_NEGOTIATE:
  389. (*childv)[*childc].freec = SOCKD_NEGOTIATEMAX;
  390. break;
  392. case CHILD_REQUEST:
  393. (*childv)[*childc].freec = SOCKD_REQUESTMAX;
  394. break;
  396. case CHILD_IO:
  397. (*childv)[*childc].freec = SOCKD_IOMAX;
  398. break;
  400. default:
  401. SERRX((*childv)[*childc].type);
  402. }
  404. return &(*childv)[(*childc)++];
  405. }
  406. }
  407. }
  409. int
  410. childcheck(type)
  411. int type;
  412. {
  413. int child, proxyc;
  414. int min, max;
  415. struct sockd_child_t **childv;
  416. int *childc;
  418. switch (type) {
  419. case -CHILD_NEGOTIATE:
  420. case CHILD_NEGOTIATE:
  421. childc = &negchildc;
  422. childv = &negchildv;
  423. min = SOCKD_FREESLOTS;
  424. max = SOCKD_NEGOTIATEMAX;
  425. break;
  427. case -CHILD_REQUEST:
  428. case CHILD_REQUEST:
  429. childc = &reqchildc;
  430. childv = &reqchildv;
  431. min = SOCKD_FREESLOTS;
  432. max = SOCKD_REQUESTMAX;
  433. break;
  435. case -CHILD_IO:
  436. case CHILD_IO:
  437. childc = &iochildc;
  438. childv = &iochildv;
  439. /* attempt to keep in a state where we can accept all requests. */
  440. min = MAX(SOCKD_FREESLOTS, childcheck(-CHILD_REQUEST));
  441. max = SOCKD_IOMAX;
  442. break;
  444. default:
  445. SERRX(type);
  446. }
  448. /*
  449.  * get a estimate over how many (new) clients our children are able to
  450.  * accept in total.
  451.     */
  452. for (child = 0, proxyc = 0; child < *childc; ++child) {
  453. SASSERTX((*childv)[child].freec <= max);
  454. proxyc += type < 0 ? max : (*childv)[child].freec;
  455. }
  457. if (type >= 0)
  458. if (proxyc < min && config.state.addchild)
  459. if (addchild(type) != NULL)
  460. return childcheck(type);
  461. else
  462. config.state.addchild = 0; /* don't retry until a child dies. */
  464. return proxyc;
  465. }
  467. int
  468. fillset(set)
  469. fd_set *set;
  470. {
  471. int negc, reqc, ioc;
  472. int i, dbits;
  474. /*
  475.  * There is no point in setting data descriptor of child N unless
  476.  * child N+1 is able to accept the data from child N.  So find
  477.  * out if we have slots of the various types available .
  478.  */
  480. ioc = childcheck(CHILD_IO);
  481. reqc = childcheck(CHILD_REQUEST);
  482. negc = childcheck(CHILD_NEGOTIATE);
  484. FD_ZERO(set);
  485. dbits = -1;
  487. /* new clients we accept. */
  488. if (negc > 0)
  489. for (i = 0; i < config.internalc; ++i) {
  490. SASSERTX(config.internalv[i].s >= 0);
  491. FD_SET(config.internalv[i].s, set);
  492. dbits = MAX(dbits, config.internalv[i].s);
  493. }
  495. /* negotiator children. */
  496. for (i = 0; i < negchildc; ++i) {
  497. if (reqc > 0) {
  498. SASSERTX(negchildv[i].s >= 0);
  499. FD_SET(negchildv[i].s, set);
  500. dbits = MAX(dbits, negchildv[i].s);
  501. }
  503. /* we can always accept a ack ofcourse. */
  504. SASSERTX(negchildv[i].ack >= 0);
  505. FD_SET(negchildv[i].ack, set);
  506. dbits = MAX(dbits, negchildv[i].ack);
  507. }
  509. /* request children. */
  510. for (i = 0; i < reqchildc; ++i) {
  511. if (ioc > 0) {
  512. SASSERTX(reqchildv[i].s >= 0);
  513. FD_SET(reqchildv[i].s, set);
  514. dbits = MAX(dbits, reqchildv[i].s);
  515. }
  517. /* we can always accept a ack ofcourse. */
  518. SASSERTX(reqchildv[i].ack >= 0);
  519. FD_SET(reqchildv[i].ack, set);
  520. dbits = MAX(dbits, reqchildv[i].ack);
  521. }
  523. /* io children, last in chain. */
  524. for (i = 0; i < iochildc; ++i) {
  525. SASSERTX(iochildv[i].s >= 0);
  526. FD_SET(iochildv[i].s, set);
  527. dbits = MAX(dbits, iochildv[i].s);
  529. SASSERTX(iochildv[i].ack >= 0);
  530. FD_SET(iochildv[i].ack, set);
  531. dbits = MAX(dbits, iochildv[i].ack);
  532. }
  534. return dbits;
  535. }
  537. void
  538. clearset(type, child, set)
  539. int type;
  540. const struct sockd_child_t *child;
  541. fd_set *set;
  542. {
  544. switch (type) {
  545. case SOCKD_FREESLOT:
  546. FD_CLR(child->ack, set);
  547. break;
  549. case SOCKD_NEWREQUEST:
  550. FD_CLR(child->s, set);
  551. break;
  553. default:
  554. SERRX(type);
  555. }
  556. }
  559. struct sockd_child_t *
  560. getset(type, set)
  561. int type;
  562. fd_set *set;
  563. {
  564. int i;
  566. /* check negotiator children for match. */
  567. for (i = 0; i < negchildc; ++i)
  568. switch (type) {
  569. case SOCKD_NEWREQUEST:
  570. if (FD_ISSET(negchildv[i].s, set))
  571. return &negchildv[i];
  572. break;
  574. case SOCKD_FREESLOT:
  575. if (FD_ISSET(negchildv[i].ack, set))
  576. return &negchildv[i];
  577. break;
  578. }
  580. /* check request children for match. */
  581. for (i = 0; i < reqchildc; ++i)
  582. switch (type) {
  583. case SOCKD_NEWREQUEST:
  584. if (FD_ISSET(reqchildv[i].s, set))
  585. return &reqchildv[i];
  586. break;
  588. case SOCKD_FREESLOT:
  589. if (FD_ISSET(reqchildv[i].ack, set))
  590. return &reqchildv[i];
  591. break;
  592. }
  594. /* check io children for match. */
  595. for (i = 0; i < iochildc; ++i)
  596. switch (type) {
  597. case SOCKD_NEWREQUEST:
  598. if (FD_ISSET(iochildv[i].s, set))
  599. return &iochildv[i];
  600. break;
  602. case SOCKD_FREESLOT:
  603. if (FD_ISSET(iochildv[i].ack, set))
  604. return &iochildv[i];
  605. break;
  606. }
  608. return NULL;
  609. }
  612. int
  613. removechild(pid)
  614. pid_t pid;
  615. {
  616. const char *function = "removechild()";
  617. struct sockd_child_t **childv;
  618. struct sockd_child_t *newchildv;
  619. int *childc;
  620. int child;
  622. slog(LOG_DEBUG, "%s: %d", function, (int)pid);
  624. setchildtype(childtype(pid), &childv, &childc, NULL);
  626. child = findchild(pid, *childc, *childv);
  627. SASSERTX(child >= 0);
  629. close((*childv)[child].s);
  630. close((*childv)[child].ack);
  632. /* shift all following one down */
  633. while (child < *childc - 1)
  634. (*childv)[child] = (*childv)[++child];
  635. --*childc;
  637. if ((newchildv = (struct sockd_child_t *)realloc(*childv,
  638. sizeof(**childv) * (*childc + 1))) == NULL) {
  639. slog(LOG_WARNING, NOMEM);
  640. return -1;
  641. }
  642. *childv = newchildv;
  644. return 0;
  645. }
  647. struct sockd_child_t *
  648. nextchild(type)
  649. int type;
  650. {
  651. const char *function = "nextchild()";
  652. struct timeval timeout;
  653. struct sockd_child_t **childv;
  654. int *childc;
  655. int i, maxd;
  656. fd_set wset;
  658. setchildtype(type, &childv, &childc, NULL);
  660. FD_ZERO(&wset);
  661. for (i = 0, maxd = -1; i < *childc; ++i)
  662. if ((*childv)[i].freec > 0) {
  663. FD_SET((*childv)[i].s, &wset);
  664. maxd = MAX(maxd, (*childv)[i].s);
  665. }
  667. if (maxd < 0)
  668. return NULL;
  669. ++maxd;
  671. timeout.tv_sec = 0;
  672. timeout.tv_usec = 0;
  674. switch (selectn(maxd, NULL, &wset, NULL, &timeout)) {
  675. case -1:
  676. SERR(-1);
  677. /* NOTREACHED */
  679. case 0:
  680. slog(LOG_DEBUG, "%s: no child writable", function);
  681. return NULL;
  682. }
  684. return getset(SOCKD_NEWREQUEST, &wset);
  685. }
  688. static int
  689. setchildtype(type, childv, childc, function)
  690. int type;
  691. struct sockd_child_t ***childv;
  692. int **childc;
  693. void (**function)(struct sockd_mother_t *mother);
  694. {
  696. switch (type) {
  697. case CHILD_IO:
  698. if (childv != NULL)
  699. *childv = &iochildv;
  701. if (childc != NULL)
  702. *childc = &iochildc;
  704. if (function != NULL)
  705. *function = &run_io;
  707. break;
  709. case CHILD_NEGOTIATE:
  710. if (childv != NULL)
  711. *childv = &negchildv;
  713. if (childc != NULL)
  714. *childc = &negchildc;
  716. if (function != NULL)
  717. *function = &run_negotiate;
  719. break;
  721. case CHILD_REQUEST:
  722. if (childv != NULL)
  723. *childv = &reqchildv;
  725. if (childc != NULL)
  726. *childc = &reqchildc;
  728. if (function != NULL)
  729. *function = &run_request;
  731. break;
  733. default:
  734. SASSERTX(type);
  735. }
  737. return type;
  738. }
  740. int
  741. childtype(pid)
  742. pid_t pid;
  743. {
  745. if (findchild(pid, iochildc, iochildv) != -1)
  746. return CHILD_IO;
  748. if (findchild(pid, negchildc, negchildv) != -1)
  749. return CHILD_NEGOTIATE;
  751. if (findchild(pid, reqchildc, reqchildv) != -1)
  752. return CHILD_REQUEST;
  754. if (pidismother(pid))
  755. return CHILD_MOTHER;
  757. SERRX(pid);
  758. /* NOTREACHED */
  759. }
  761. static int
  762. findchild(pid, childc, childv)
  763. pid_t pid;
  764. int childc;
  765. const struct sockd_child_t *childv;
  766. {
  767. int i;
  769. for (i = 0; i < childc; ++i)
  770. if (childv[i].pid == pid)
  771. return i;
  773. return -1;
  774. }
  776. struct sockd_child_t *
  777. getchild(pid)
  778. pid_t pid;
  779. {
  780. int child, type;
  781. int *childc;
  782. struct sockd_child_t **childv;
  784. switch (type = childtype(pid)) {
  785. case CHILD_IO:
  786. case CHILD_NEGOTIATE:
  787. case CHILD_REQUEST:
  788. break;
  790. case CHILD_MOTHER:
  791. return NULL;
  793. default:
  794. SERRX(type);
  795. }
  797. setchildtype(type, &childv, &childc, NULL);
  799. if ((child = findchild(pid, *childc, *childv)) != -1)
  800. return &(*childv)[child];
  801. return NULL;
  802. }
  804. int
  805. send_io(s, io)
  806. int s;
  807. const struct sockd_io_t *io;
  808. {
  809. const char *function = "send_io()";
  810. struct iovec iovec[1];
  811. struct msghdr msg;
  812. int w, fdsent, length;
  813. CMSG_AALLOC(sizeof(int) * FDPASS_MAX);
  816. length = 0;
  817. /* LINTED operands have incompatible pointer types */
  818. iovec[0].iov_base = (const void *)io;
  819. iovec[0].iov_len = sizeof(*io);
  820. length   += iovec[0].iov_len;
  822. fdsent = 0;
  823. CMSG_ADDOBJECT(io->in.s, sizeof(io->in.s) * fdsent++);
  824. CMSG_ADDOBJECT(io->out.s, sizeof(io->out.s) * fdsent++);
  826. switch (io->state.command) {
  827. case SOCKS_BIND:
  828. case SOCKS_BINDREPLY:
  829. if (!io->state.extension.bind)
  830. break;
  831. /* else: */ /* FALLTHROUGH */
  833. case SOCKS_UDPASSOCIATE:
  834. CMSG_ADDOBJECT(io->control.s, sizeof(io->control.s) * fdsent++);
  835. break;
  837. case SOCKS_CONNECT:
  838. break;
  840. default:
  841. SERRX(io->state.command);
  842. }
  844. msg.msg_iov = iovec;
  845. msg.msg_iovlen = ELEMENTS(iovec);
  846. msg.msg_name = NULL;
  847. msg.msg_namelen = 0;
  849. CMSG_SETHDR_SEND(sizeof(int) * fdsent);
  851. if ((w = sendmsg(s, &msg, 0)) != length) {
  852. swarn("%s: sendmsg(): %d of %d", function, w, length);
  853. return -1;
  854. }
  856. #if DEBUG
  857. printfd(io, "sent");
  858. #endif
  860. return 0;
  861. }
  864. int
  865. send_client(s, client)
  866. int s;
  867. int client;
  868. {
  869. const char *function = "send_client()";
  870. const char command = SOCKD_NEWREQUEST;
  871. struct iovec iovec[1];
  872. struct msghdr msg;
  873. CMSG_AALLOC(sizeof(int));
  874. int fdsent;
  876. /* LINTED operands have incompatible pointer types */
  877. iovec[0].iov_base = (const void *)&command;
  878. iovec[0].iov_len = sizeof(command);
  880. fdsent = 0;
  881. CMSG_ADDOBJECT(client, sizeof(client) * fdsent++);
  883. msg.msg_iov = iovec;
  884. msg.msg_iovlen = ELEMENTS(iovec);
  885. msg.msg_name = NULL;
  886. msg.msg_namelen = 0;
  888. CMSG_SETHDR_SEND(sizeof(int) * fdsent);
  890. if (sendmsg(s, &msg, 0) != sizeof(command)) {
  891. swarn("%s: sendmsg()", function);
  892. return -1;
  893. }
  895. return 0;
  896. }
  898. int
  899. send_req(s, req)
  900. int s;
  901. const struct sockd_request_t *req;
  902. {
  903. const char *function = "send_req()";
  904. struct iovec iovec[1];
  905. struct msghdr msg;
  906. int fdsent;
  907. CMSG_AALLOC(sizeof(int));
  909. /* LINTED operands have incompatible pointer types */
  910. iovec[0].iov_base = (const void *)req;
  911. iovec[0].iov_len = sizeof(*req);
  913. fdsent = 0;
  914. CMSG_ADDOBJECT(req->s, sizeof(req->s) * fdsent++);
  916. msg.msg_iov = iovec;
  917. msg.msg_iovlen = ELEMENTS(iovec);
  918. msg.msg_name = NULL;
  919. msg.msg_namelen = 0;
  921. CMSG_SETHDR_SEND(sizeof(int) * fdsent);
  923. if (sendmsg(s, &msg, 0) != sizeof(*req)) {
  924. swarn("%s: sendmsg()", function);
  925. return -1;
  926. }
  928. return 0;
  929. }
  931. const char *
  932. childtype2string(type)
  933. int type;
  934. {
  936. switch (type) {
  937. case CHILD_IO:
  938. return "io";
  940. case CHILD_MOTHER:
  941. return "mother";
  943. case CHILD_NEGOTIATE:
  944. return "negotiator";
  946. case CHILD_REQUEST:
  947. return "request";
  949. default:
  950. SERRX(type);
  951. }
  953. /* NOTREACHED */
  954. }
  956. void
  957. sigchildbroadcast(sig, childtype)
  958. int sig;
  959. int childtype;
  960. {
  961. int i;
  963. if (childtype & CHILD_NEGOTIATE)
  964. for (i = 0; i < negchildc; ++i)
  965. kill(negchildv[i].pid, sig);
  967. if (childtype & CHILD_REQUEST)
  968. for (i = 0; i < reqchildc; ++i)
  969. kill(reqchildv[i].pid, sig);
  971. if (childtype & CHILD_IO)
  972. for (i = 0; i < iochildc; ++i)
  973. kill(iochildv[i].pid, sig);
  974. }
  976. #if DEBUG
  977. void
  978. printfd(io, prefix)
  979. const struct sockd_io_t *io;
  980. const char *prefix;
  981. {
  982. const char *function = "printfd()";
  983. struct sockaddr name;
  984. socklen_t namelen;
  985. char namestring[MAXSOCKADDRSTRING];
  987. bzero(&name, sizeof(name));
  988. namelen = sizeof(name);
  989. /* LINTED pointer casts may be troublesome */
  990. if (getsockname(io->in.s, &name, &namelen) != 0)
  991. swarn("%s: getsockname(io->in)", function);
  992. else
  993. slog(LOG_DEBUG, "%s: io->in (%d), name: %s",
  994. prefix, io->in.s, sockaddr2string(&name, namestring, sizeof(namestring)));
  996. bzero(&name, sizeof(name));
  997. namelen = sizeof(name);
  998. /* LINTED pointer casts may be troublesome */
  999. if (getsockname(io->out.s, &name, &namelen) != 0)
  1000. swarn("%s: getsockname(io->out)", function);
  1001. else
  1002. slog(LOG_DEBUG, "%s: io->out (%d), name: %s",
  1003. prefix, io->out.s,
  1004. sockaddr2string(&name, namestring, sizeof(namestring)));
  1006. switch (io->state.command) {
  1007. case SOCKS_BIND:
  1008. case SOCKS_BINDREPLY:
  1009. if (!io->state.extension.bind)
  1010. break;
  1011. /* else: */ /* FALLTHROUGH */
  1013. case SOCKS_UDPASSOCIATE:
  1014. bzero(&name, sizeof(name));
  1015. namelen = sizeof(name);
  1016. /* LINTED pointer casts may be troublesome */
  1017. if (getpeername(io->control.s, &name, &namelen)
  1018. != 0)
  1019. swarn("%s: getpeername(io->control)", function);
  1020. else  {
  1021. if (namelen == 0)
  1022. slog(LOG_DEBUG, "%s: io->control (%d), name: <none>",
  1023. prefix, io->control.s);
  1024. else
  1025. slog(LOG_DEBUG, "%s: io->control (%d), name: %s",
  1026. prefix, io->control.s,
  1027. sockaddr2string(&name, namestring, sizeof(namestring)));
  1028. }
  1029. break;
  1031. case SOCKS_CONNECT:
  1032. break;
  1034. default:
  1035. SERRX(io->state.command);
  1036. }
  1037. }
  1038. #endif