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

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

代理服务器

开发平台：

Unix_Linux

sockd_request.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_request.c,v 1.110 1999/12/22 09:29:27 karls Exp $";
  49. /*
  50.  * Since it only handles one client at a time there is no possibility
  51.  * for the mother to send a new client before we have got rid of the
  52.  * old one and thus no need for locking even on broken systems.
  53.  * (#ifdef HAVE_SENDMSG_DEADLOCK)
  54.  * XXX I have started to work on fixing this, so this process too
  55.  * can support multiple clients, perhaps for a later release I will
  56.  * have time to complete it.  Will also fix the terrible fact
  57.  * that we just sit around and wait if the command is bind, wasting
  58.  * the whole process on practically nothing.
  59.  */
  61. __BEGIN_DECLS
  63. static void
  64. dorequest __P((int mother, const struct sockd_request_t *request));
  65. /*
  66.  * When a complete request has been read, this function can be
  67.  * called.  It will perform the request "request->req" and send the
  68.  * result to "mother".
  69.  */
  71. static void
  72. flushio __P((int mother, int clientcontrol, const struct response_t *response,
  73.  struct sockd_io_t *io));
  74. /*
  75.  * "flushes" a complete io object and free's any state/resources held by it.
  76.  * "mother" is connection to mother for sending the io.
  77.  * "clientcontrol" is the client connection.
  78.  * "response" is the response to be sent the client.
  79.  * "io" is the io object sent mother.
  80.  */
  82. static void
  83. proctitleupdate __P((const struct sockaddr *from));
  84. /*
  85.  * Updates the title of this process.
  86.  */
  88. static struct sockd_io_t *
  89. io_add __P((struct sockd_io_t *iolist, const struct sockd_io_t *newio));
  90. /*
  91.  * Adds _a copy_ of the object "newio" to the list "iolist".
  92.  * Returns a pointer to the (new) iolist.
  93.  */
  95. static struct sockd_io_t *
  96. io_remove __P((struct sockd_io_t *iolist, struct sockd_io_t *rmio));
  97. /*
  98.  * Removes the object "rmio" from the list "iolist".
  99.  * Returns a pointer to the (new) iolist.
  100.  */
  102. static struct sockd_io_t *
  103. io_find __P((struct sockd_io_t *iolist, const struct sockaddr *addr));
  104. /*
  105.  * Scans "iolist" for a object that contains "addr" as a local address.
  106.  * If "addr" is NULL, returns "iolist".
  107.  * Returns:
  108.  * On success: pointer to the matching io object.
  109.  * On failure: NULL.
  110.  */
  113. __END_DECLS
  116. void
  117. run_request(mother)
  118. struct sockd_mother_t *mother;
  119. {
  120. const char *function = "run_request()";
  121. struct sockd_request_t req;
  122. #if DIAGNOSTIC
  123. const int freec = freedescriptors(config.option.debug ? "start" : NULL);
  124. #endif /* DIAGNOSTIC */
  126. proctitleupdate(NULL);
  128. /* CONSTCOND */
  129. while (1) {
  130. /*
  131.  * Get request from mother, perform it, get next request.
  132.  */
  133. const char command = SOCKD_FREESLOT;
  135. proctitleupdate(NULL);
  137. if (recv_req(mother->s, &req) == -1)
  138. sockdexit(-EXIT_FAILURE);
  140. /* LINTED pointer casts may be troublesome */
  141. proctitleupdate((struct sockaddr *)&req.from);
  143. dorequest(mother->s, &req);
  145. if (writen(mother->ack, &command, sizeof(command)) != sizeof(command))
  146. serr(EXIT_FAILURE, "%s: sending ack to mother failed", function);
  148. #if DIAGNOSTIC
  149. SASSERTX(freec == freedescriptors(config.option.debug ? "end" : NULL));
  150. #endif /* DIAGNOSTIC */
  151. }
  152. }
  155. int
  156. recv_req(s, req)
  157. int s;
  158. struct sockd_request_t *req;
  159. {
  160. const char *function = "recv_req()";
  161. int fdexpect, fdreceived, r;
  162. struct iovec iovec[1];
  163. struct msghdr msg;
  164. CMSG_AALLOC(sizeof(int));
  166. iovec[0].iov_base = req;
  167. iovec[0].iov_len = sizeof(*req);
  169. msg.msg_iov = iovec;
  170. msg.msg_iovlen = ELEMENTS(iovec);
  171. msg.msg_name = NULL;
  172. msg.msg_namelen = 0;
  174. CMSG_SETHDR_RECV(sizeof(cmsgmem));
  176. if ((r = recvmsgn(s, &msg, 0, sizeof(*req))) != sizeof(*req)) {
  177. switch (r) {
  178. case -1:
  179. swarn("%s: recvmsg() from mother", function);
  180. break;
  182. case 0:
  183. slog(LOG_DEBUG, "%s: recvmsg(): mother closed connection",
  184. function);
  185. break;
  187. default:
  188. swarnx("%s: recvmsg(): unexpected %d/%d bytes from mother",
  189. function, r, sizeof(*req));
  190. }
  192. return -1;
  193. }
  194. fdexpect = 1;
  196. #if !HAVE_DEFECT_RECVMSG
  197. SASSERT(CMSG_GETLEN(msg) == sizeof(int) * fdexpect);
  198. #endif
  200. fdreceived = 0;
  201. CMSG_GETOBJECT(req->s, sizeof(req->s) * fdreceived++);
  203. /* pointer fixup */
  204. req->req.auth = &req->state.auth;
  206. return 0;
  207. }
  209. static void
  210. dorequest(mother, request)
  211. int mother;
  212. const struct sockd_request_t *request;
  213. {
  214. const char *function = "dorequest()";
  215. static const struct sockd_io_t ioinit;
  216. struct sockaddr_in bound;
  217. struct sockd_io_t io;
  218. struct response_t response;
  219. char a[MAXSOCKSHOSTSTRING], b[MAXSOCKSHOSTSTRING];
  220. int p, permit, out;
  222. slog(LOG_DEBUG, "received request: %s",
  223. socks_packet2string(&request->req, SOCKS_REQUEST));
  225. bzero(&response, sizeof(response));
  226. response.host = request->req.host;
  227. response.auth = request->req.auth;
  229. io = ioinit;
  230. io.acceptrule = request->rule;
  231. io.state = request->state;
  232. io.state.extension = config.extension;
  234. /*
  235.  * examine client request.
  236.  */
  238. /* supported version? */
  239. switch (request->req.version) {
  240. case SOCKS_V4:
  241. response.version = SOCKS_V4REPLY_VERSION;
  243. /* recognized command for this version? */
  244. switch (request->req.command) {
  245. case SOCKS_BIND:
  246. case SOCKS_CONNECT:
  247. io.state.protocol = SOCKS_TCP;
  248. break;
  250. default:
  251. /* LINTED pointer casts may be troublesome */
  252. slog(LOG_INFO, "%s: unrecognized v%d command: %d",
  253. sockaddr2string((const struct sockaddr *)&request->from,
  254. a, sizeof(a)), request->req.version, request->req.command);
  255. send_failure(request->s, &response, SOCKS_FAILURE);
  256. close(request->s);
  257. return;
  258. }
  260. /* supported address format for this version? */
  261. switch (request->req.host.atype) {
  262. case SOCKS_ADDR_IPV4:
  263. break;
  265. default:
  266. /* LINTED pointer casts may be troublesome */
  267. slog(LOG_INFO, "%s: unrecognized v%d address type: %d",
  268. sockaddr2string((const struct sockaddr *)&request->from,
  269. a, sizeof(a)), request->req.version, request->req.host.atype);
  270. send_failure(request->s, &response, SOCKS_ADDR_UNSUPP);
  271. close(request->s);
  272. return;
  273. }
  274. break; /* SOCKS_V4 */
  276. case SOCKS_V5:
  277. response.version = request->req.version;
  279. /* recognized command for this version? */
  280. switch (request->req.command) {
  281. case SOCKS_BIND:
  282. case SOCKS_CONNECT:
  283. io.state.protocol = SOCKS_TCP;
  284. break;
  286. case SOCKS_UDPASSOCIATE:
  287. io.state.protocol = SOCKS_UDP;
  288. break;
  290. default:
  291. /* LINTED pointer casts may be troublesome */
  292. slog(LOG_INFO, "%s: unrecognized v%d command: %d",
  293. sockaddr2string((const struct sockaddr *)&request->from,
  294. a, sizeof(a)), request->req.version, request->req.command);
  295. send_failure(request->s, &response, SOCKS_CMD_UNSUPP);
  296. close(request->s);
  297. return;
  298. }
  300. /* supported address format for this version? */
  301. switch (request->req.host.atype) {
  302. case SOCKS_ADDR_IPV4:
  303. case SOCKS_ADDR_DOMAIN:
  304. break;
  306. default:
  307. /* LINTED pointer casts may be troublesome */
  308. slog(LOG_INFO, "%s: unrecognized v%d address type: %d",
  309. sockaddr2string((const struct sockaddr *)&request->from,
  310. a, sizeof(a)), request->req.version, request->req.host.atype);
  311. send_failure(request->s, &response, SOCKS_ADDR_UNSUPP);
  312. close(request->s);
  313. return;
  314. }
  315. break; /* SOCKS_V5 */
  317. default:
  318. SERRX(request->req.version);
  319. }
  322. /*
  323.  * packet looks ok, fill in remaining bits needed to check rules.
  324.  */
  326. switch (request->req.command) {
  327. case SOCKS_BIND:
  328. /* LINTED pointer casts may be troublesome */
  329. sockaddr2sockshost((const struct sockaddr *)&request->from, &io.src);
  330. io.dst = request->req.host;
  332. if (io.dst.atype != SOCKS_ADDR_IPV4
  333. ||  io.dst.addr.ipv4.s_addr != htonl(0)
  334. ||  io.dst.port == htons(0))
  335. io.state.extension.bind = 0; /* not requesting bind extension. */
  336. break;
  338. case SOCKS_CONNECT:
  339. /* LINTED pointer casts may be troublesome */
  340. sockaddr2sockshost((const struct sockaddr *)&request->from, &io.src);
  341. io.dst = request->req.host;
  342. break;
  344. case SOCKS_UDPASSOCIATE:
  345. /*
  346.  * for UDP_ASSOCIATE we are getting clients udp address,
  347.  * not destination in request.
  348.  * Destination address will be checked in the i/o loop for
  349.  * each destination, for now just set it to INADDR_ANY.
  350.  */
  352. io.src = request->req.host;
  353. io.dst.atype = SOCKS_ADDR_IPV4;
  354. io.dst.addr.ipv4.s_addr = htonl(INADDR_ANY);
  355. io.dst.port = htons(0);
  356. break;
  358. default:
  359. SERRX(request->req.command);
  360. }
  362. /* socket to use for outgoing connection. */
  363. switch (io.state.protocol) {
  364. case SOCKS_TCP:
  365. if ((out = socket(AF_INET, SOCK_STREAM, 0)) == -1)
  366. swarn("%s: socket(SOCK_STREAM)", function);
  367. break;
  369. case SOCKS_UDP:
  370. if ((out = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
  371. swarn("%s: socket(SOCK_DGRAM)", function);
  372. break;
  374. default:
  375. SERRX(io.state.protocol);
  376. }
  378. if (out == -1) {
  379. send_failure(request->s, &response, SOCKS_FAILURE);
  380. close(request->s);
  381. return;
  382. }
  383. setsockoptions(out);
  385. /* find out what address to bind on clients behalf. */
  386. bound = *config.externalv;
  387. switch (request->req.command) {
  388. case SOCKS_BIND:
  389. /* find out what port to bind;  v4/v5 semantics?  bind extension? */
  390. switch (request->req.version) {
  391. case SOCKS_V4:
  392. if (io.state.extension.bind)
  393. bound.sin_port = io.dst.port;
  394. else
  395. /* best we can try for is to use same port as source. */
  396. bound.sin_port = request->from.sin_port;
  397. break;
  399. case SOCKS_V5:
  400. bound.sin_port = io.dst.port;
  401. break;
  403. default:
  404. SERRX(request->req.version);
  405. }
  406. break;
  408. case SOCKS_CONNECT:
  409. bound.sin_port = request->from.sin_port;
  410. break;
  412. case SOCKS_UDPASSOCIATE:
  413. bound.sin_port = request->req.host.port;
  414. break;
  416. default:
  417. SERRX(request->req.command);
  418. }
  421. /*
  422.  * bind socket.
  423.  */
  425. if (config.compat.reuseaddr) {
  426. p = 1;
  427. if (setsockopt(out, SOL_SOCKET, SO_REUSEADDR, &p, sizeof(p)) != 0)
  428. swarn("%s: setsockopt(SO_REUSEADDR)", function);
  429. }
  431. if (PORTISRESERVED(bound.sin_port) && config.compat.sameport) {
  432. uid_t euid;
  434. socks_seteuid(&euid, config.uid.privileged);
  435. p = bindresvport(out, &bound);
  436. socks_reseteuid(config.uid.privileged, euid);
  437. }
  438. else
  439. /* LINTED pointer casts may be troublesome */
  440. p = sockd_bind(out, (struct sockaddr *)&bound, 1);
  442. if (p != 0) { /* no such luck, bind any port and let client decide if ok. */
  443. bound.sin_port = htons(0);
  444. /* LINTED pointer casts may be troublesome */
  445. if ((p = sockd_bind(out, (struct sockaddr *)&bound, 0)) != 0)
  446. swarn("%s: bind(%s)",
  447. /* LINTED pointer casts may be troublesome */
  448. function, sockaddr2string((struct sockaddr *)&bound, a, sizeof(a)));
  449. }
  451. if (p != 0) {
  452. send_failure(request->s, &response, errno2reply(errno, response.version));
  453. close(request->s);
  454. close(out);
  455. return;
  456. }
  458. /* rules permit? */
  459. switch (request->req.command) {
  460. case SOCKS_BIND: {
  461. struct sockshost_t boundhost;
  462. socklen_t boundlen;
  464. boundlen = sizeof(bound);
  465. /* LINTED pointer casts may be troublesome */
  466. if (getsockname(out, (struct sockaddr *)&bound, &boundlen) != 0) {
  467. swarn("%s: getsockname(out)", function);
  468. close(request->s);
  469. close(out);
  470. return;
  471. }
  472. /* LINTED pointer casts may be troublesome */
  473. sockaddr2sockshost((struct sockaddr *)&bound, &boundhost);
  475. permit
  476. = rulespermit(request->s, &io.rule, &io.state, &io.src, &boundhost);
  477. iolog(&io.rule, &io.state, OPERATION_CONNECT, &io.src, &boundhost,
  478. NULL, 0);
  480. break;
  481. }
  483. case SOCKS_CONNECT:
  484. permit
  485. = rulespermit(request->s, &io.rule, &io.state, &io.src, &io.dst);
  486. iolog(&io.rule, &io.state, OPERATION_CONNECT, &io.src, &io.dst,
  487. NULL, 0);
  488. break;
  490. case SOCKS_UDPASSOCIATE: {
  491. struct sockshost_t *src;
  492. struct connectionstate_t replystate;
  494. /*
  495.  * Client is allowed to send a "incomplete" address.
  496.  */
  497. if (io.src.atype == SOCKS_ADDR_IPV4
  498. && (io.src.addr.ipv4.s_addr == htonl(0) || io.src.port == htons(0)))
  499. src = NULL;
  500. else
  501. src = &io.src;
  503. /* only set temporary here for one replypacket at a time. */
  504. replystate = io.state;
  505. replystate.command = SOCKS_UDPREPLY;
  507. /* one direction is atleast in theory good enough. */
  508. permit = rulespermit(request->s, &io.rule, &io.state, src, NULL)
  509. || rulespermit(request->s, &io.rule, &replystate, NULL, src);
  511. iolog(&io.rule, &io.state, OPERATION_CONNECT, &io.src, &io.dst, NULL,
  512. 0);
  513. break;
  514. }
  516. default:
  517. SERRX(request->req.command);
  518. }
  520. if (!permit) {
  521. send_failure(request->s, &response, SOCKS_NOTALLOWED);
  522. close(request->s);
  523. close(out);
  524. return;
  525. }
  527. /*
  528.  * Set up missing bits of io and send it to mother.
  529.  */
  530. switch (io.state.command) {
  531. case SOCKS_BIND: {
  532. struct sockd_io_t *iolist;
  533. struct sockd_io_t bindio; /* send this to proxyrelayer. */
  534. struct sockaddr boundaddr; /* address we listen on. */
  535. struct sockaddr clientaddr; /* clientaddress we forward to. */
  536. socklen_t len;
  537. int flags, emfile;
  538. enum socketindex { client, childpipe, ourpipe, reply, remote };
  539. /* array of sockets, indexed by above enums, -1 if not open. */
  540. int sv[(int)(remote) + 1] = { -1, -1, -1, -1, -1 };
  542. SASSERTX(sv[ELEMENTS(sv) - 1] == -1);
  543. sv[client] = request->s;
  545. if (listen(out, 5) != 0) {
  546. swarn("%s: listen(out)", function);
  547. send_failure(sv[client], &response, SOCKS_FAILURE);
  548. closev(sv, ELEMENTS(sv));
  549. break;
  550. }
  552. /* for accept(). */
  553. if ((flags = fcntl(out, F_GETFL, 0)) == -1
  554. || fcntl(out, F_SETFL, flags | O_NONBLOCK) == -1) {
  555. swarn("%s: fcntl()", function);
  556. send_failure(sv[client], &response, SOCKS_FAILURE);
  557. closev(sv, ELEMENTS(sv));
  558. break;
  559. }
  561. len = sizeof(boundaddr);
  562. if (getsockname(out, &boundaddr, &len) != 0) {
  563. swarn("%s: getsockname()", function);
  564. send_failure(sv[client], &response, SOCKS_FAILURE);
  565. closev(sv, ELEMENTS(sv));
  566. break;
  567. }
  569. sockaddr2sockshost(&boundaddr, &response.host);
  570. response.reply = (char)sockscode(response.version, SOCKS_SUCCESS);
  572. /* LINTED pointer casts may be troublesome */
  573. clientaddr = *(const struct sockaddr *)&request->from;
  575. if (io.state.extension.bind) {
  576. int pipev[2];
  578. /*
  579.  * The problem is that both we and the process which receives
  580.  * the io packet needs to know when the client closes it's
  581.  * connection, but _we_ need to receive a query from the
  582.  * client on the connection aswell, and the io process would
  583.  * get confused about that.  We try to hack around that
  584.  * by making a "dummy" descriptor that the io process can
  585.  * check as all other controlconnections and which we
  586.  * can close when the client closes the real controlconnection,
  587.  * so the io process can detect it.  Not very nice, no.
  588.  */
  590. if (socketpair(AF_LOCAL, SOCK_STREAM, 0, pipev) != 0) {
  591. swarn("%s: socketpair()", function);
  592. send_failure(sv[client], &response, SOCKS_FAILURE);
  593. closev(sv, ELEMENTS(sv));
  594. break;
  595. }
  597. sv[childpipe] = pipev[0];
  598. sv[ourpipe] = pipev[1];
  600. /* LINTED pointer casts may be troublesome */
  601. ((struct sockaddr_in *)&clientaddr)->sin_port = io.dst.port;
  602. }
  604. /* let client know what address we bound to on it's behalf. */
  605. if (send_response(sv[client], &response) != 0) {
  606. iolog(&io.rule, &io.state, OPERATION_ABORT, &io.src, &response.host,
  607. NULL, 0);
  608. closev(sv, ELEMENTS(sv));
  609. break;
  610. }
  612. setproctitle("bindrelayer: %s -> %s",
  613. sockaddr2string(&boundaddr, a, sizeof(a)),
  614. sockaddr2string(&clientaddr, b, sizeof(b)));
  616. /*
  617.  * regardless of what kind of bind semantics are in use,
  618.  * portnumber is something we ignore when checking remote peer.
  619.  */
  620. io.dst.port = htons(0);
  622. emfile = 0;
  623. iolist = NULL;
  625. /* CONSTCOND */
  626. while (1) {
  627. struct ruleaddress_t ruleaddr;
  628. struct sockaddr remoteaddr; /* remote address we accepted. */
  629. struct sockshost_t remotehost; /* remote address, sockhost form.*/
  630. struct sockaddr_in replyaddr; /* address of bindreply socket. */
  631. int fdbits = -1;
  632. fd_set rset;
  634. /* some sockets change, most remain the same. */
  635. sv[reply] = -1;
  636. sv[remote] = -1;
  638. FD_ZERO(&rset);
  639. FD_SET(sv[client], &rset);
  640. fdbits = MAX(fdbits, sv[client]);
  642. if (!emfile) {
  643. FD_SET(out, &rset);
  644. fdbits = MAX(fdbits, out);
  645. }
  647. ++fdbits;
  648. if ((p = selectn(fdbits, &rset, NULL, NULL, NULL)) <= 0)
  649. SERR(p);
  651. if (FD_ISSET(sv[client], &rset)) {
  652. /*
  653.  * nothing is normally expected on controlconnection so
  654.  * assume it's a bind extension query or eof.
  655.  */
  656. struct request_t query;
  657. struct response_t queryresponse;
  658. struct negotiate_state_t state;
  659. struct sockaddr queryaddr;
  661. bzero(&state, sizeof(state));
  662. bzero(&query, sizeof(query));
  663. bzero(&queryresponse, sizeof(queryresponse));
  665. query.auth = request->req.auth;
  666. switch (p = recv_sockspacket(sv[client], &query, &state)) {
  667. case -1:
  668. iolog(&io.rule, &io.state, OPERATION_ABORT, &io.src,
  669. &response.host, NULL, 0);
  670. break;
  672. case 0:
  673. p = -1; /* session ended. */
  674. break;
  676. default: {
  677. struct sockd_io_t *fio;
  679. slog(LOG_DEBUG, "received request: %s",
  680. socks_packet2string(&query, SOCKS_REQUEST));
  682. switch (query.version) {
  683. case SOCKS_V4:
  684. queryresponse.version = SOCKS_V4REPLY_VERSION;
  685. break;
  687. case SOCKS_V5:
  688. queryresponse.version = query.version;
  689. break;
  691. default:
  692. SERRX(query.version);
  693. }
  695. sockshost2sockaddr(&query.host, &queryaddr);
  696. if ((fio = io_find(iolist, &queryaddr)) == NULL) {
  697. queryresponse.host.atype = SOCKS_ADDR_IPV4;
  698. queryresponse.host.addr.ipv4.s_addr = htonl(0);
  699. queryresponse.host.port = htons(0);
  700. }
  701. else {
  702. SASSERTX(fio->state.command = SOCKS_BINDREPLY);
  704. /* LINTED pointer casts may be troublesome */
  705. SASSERTX(sockaddrareeq((struct sockaddr *)
  706. &fio->in.laddr, &queryaddr));
  708. /* LINTED pointer casts may be troublesome */
  709. sockaddr2sockshost((struct sockaddr *)&fio->out.raddr,
  710. &queryresponse.host);
  711. }
  713. if (fio != NULL) {
  714. flushio(mother, sv[client], &queryresponse, fio);
  715. emfile = MAX(0, emfile - 3); /* flushio() closes 3. */
  716. iolist = io_remove(iolist, fio);
  717. p = 0;
  718. }
  719. else
  720. if ((p = send_response(sv[client], &queryresponse))
  721. != 0)
  722. iolog(&io.rule, &io.state, OPERATION_ABORT, &io.src,
  723. &response.host, NULL, 0);
  724. }
  725. }
  727. if (p != 0)
  728. break;
  729. }
  731. if (!FD_ISSET(out, &rset))
  732. continue;
  734. len = sizeof(remoteaddr);
  735. if ((sv[remote] = acceptn(out, &remoteaddr, &len)) == -1) {
  736. swarn("%s: accept(out)", function);
  738. switch (errno) {
  739. #ifdef EPROTO
  740. case EPROTO: /* overloaded SVR4 error */
  741. #endif
  742. case EWOULDBLOCK: /* BSD */
  743. case ECONNABORTED: /* POSIX */
  745. /* rest appears to be linux stuff according to apache src. */
  746. #ifdef ECONNRESET
  747. case ECONNRESET:
  748. #endif
  749. #ifdef ETIMEDOUT
  750. case ETIMEDOUT:
  751. #endif
  752. #ifdef EHOSTUNREACH
  753. case EHOSTUNREACH:
  754. #endif
  755. #ifdef ENETUNREACH
  756. case ENETUNREACH:
  757. #endif
  758. continue;
  760. case EMFILE:
  761. case ENFILE:
  762. ++emfile;
  763. continue;
  764. }
  765. break; /* errno is not ok. */
  766. }
  767. sockaddr2sockshost(&remoteaddr, &remotehost);
  769. /* accepted connection; does remote address match requested? */
  770. if (io.state.extension.bind
  771. || addressmatch(sockshost2ruleaddress(&io.dst, &ruleaddr),
  772. &remotehost, SOCKS_TCP, 1)) {
  773. bindio = io; /* quick init of most stuff. */
  774. bindio.src = remotehost;
  775. sockaddr2sockshost(&clientaddr, &bindio.dst);
  776. bindio.state.command = SOCKS_BINDREPLY;
  778. permit = rulespermit(sv[client], &bindio.rule, &bindio.state,
  779. &bindio.src, &bindio.dst);
  781. iolog(&bindio.rule, &bindio.state, OPERATION_CONNECT,
  782. &bindio.src, &bindio.dst, NULL, 0);
  784. }
  785. else {
  786. slog(LOG_INFO, "%s(0): unexpected bindreply: %s -> %s",
  787. VERDICT_BLOCKs, sockaddr2string(&remoteaddr, a, sizeof(a)),
  788. sockshost2string(&io.src, b, sizeof(b)));
  789. permit = 0;
  790. }
  792. if (!permit) {
  793. close(sv[remote]);
  794. continue; /* wait for next connect, but will there be one? */
  795. }
  797. /*
  798.  * Someone connected to socket we listen to on behalf of client.
  799.  * If we are using the bind extension, connect to address client
  800.  * is listening on.  Otherwise, send the data on the connection
  801.  * we already have.
  802.  */
  804. if (bindio.state.extension.bind) {
  805. if ((sv[reply] = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
  806. swarn("%s: socket(SOCK_STREAM)", function);
  808. switch (errno) {
  809. case EMFILE:
  810. case ENFILE:
  811. ++emfile;
  812. /* FALLTHROUGH */
  814. case ENOBUFS:
  815. close(sv[remote]);
  816. continue;
  817. }
  818. break; /* errno is not ok. */
  819. }
  820. setsockoptions(sv[reply]);
  822. /* LINTED pointer casts may be troublesome */
  823. replyaddr = *(struct sockaddr_in *)&boundaddr;
  824. replyaddr.sin_port = htons(0);
  826. /* LINTED pointer casts may be troublesome */
  827. if (sockd_bind(sv[reply], (struct sockaddr *)&replyaddr, 0)
  828. != 0) {
  829. /* LINTED pointer casts may be troublesome */
  830. swarn("%s: bind(%s)", function,
  831. sockaddr2string((struct sockaddr *)&replyaddr, a, sizeof(a)));
  832. break;
  833. }
  835. len = sizeof(replyaddr);
  836. /* LINTED pointer casts may be troublesome */
  837. if (getsockname(sv[reply], (struct sockaddr *)&replyaddr, &len)
  838. != 0) {
  839. swarn("%s: getsockname(sv[reply])", function);
  840. if (errno == ENOBUFS) {
  841. close(sv[remote]);
  842. close(sv[reply]);
  843. continue;
  844. }
  845. break;
  846. }
  848. slog(LOG_DEBUG, "connecting to %s",
  849. sockaddr2string(&clientaddr, a, sizeof(a)));
  851. if (connect(sv[reply], &clientaddr, sizeof(clientaddr)) != 0) {
  852. iolog(&bindio.rule, &bindio.state, OPERATION_ABORT,
  853. &bindio.src, &bindio.dst, NULL, 0);
  854. break;
  855. }
  856. }
  858. if (bindio.state.extension.bind) {
  859. /*
  860.  * flushio() will close all descriptors set in io packet
  861.  * so dup what we need to keep going.
  862.  */
  864. if ((bindio.control.s = dup(sv[childpipe])) == -1) {
  865. switch (errno) {
  866. case EMFILE:
  867. case ENFILE:
  868. swarn("%s: dup()", function);
  869. ++emfile;
  870. continue;
  872. default:
  873. SERR(bindio.control.s);
  874. }
  875. }
  876. }
  877. else
  878. bindio.control.s = sv[client];
  880. bindio.control.laddr = request->to;
  881. bindio.control.raddr = request->from;
  882. bindio.control.state = bindio.state;
  884. /* back to blocking. */
  885. if (fcntl(sv[remote], F_SETFL, flags) == -1) {
  886. swarn("%s: fcntl()", function);
  887. break;
  888. }
  890. if (bindio.state.extension.bind) {
  891. bindio.in.s = sv[reply];
  892. bindio.in.laddr = replyaddr;
  893. bindio.in.state = bindio.state;
  894. }
  895. else {
  896. bindio.in = bindio.control;
  897. bindio.in.laddr = request->from;
  898. }
  899. /* LINTED pointer casts may be troublesome */
  900. bindio.in.raddr = *(struct sockaddr_in *)&clientaddr;
  902. bindio.out.s = sv[remote];
  903. /* LINTED pointer casts may be troublesome */
  904. bindio.out.laddr = *(struct sockaddr_in *)&boundaddr;
  905. /* LINTED pointer casts may be troublesome */
  906. bindio.out.raddr = *(struct sockaddr_in *)&remoteaddr;
  907. bindio.out.state.auth.method = AUTHMETHOD_NONE;
  909. if (bindio.state.extension.bind)
  910. /* add to list, client will query. */
  911. iolist = io_add(iolist, &bindio);
  912. else {
  913. response.host = bindio.dst;
  914. flushio(mother, sv[client], &response, &bindio);
  915. sv[client] = sv[remote] = -1; /* flushio() closes; closev(). */
  916. break; /* only one connection to relay and that is done. */
  917. }
  918. }
  920. if (bindio.state.extension.bind) {
  921. struct sockd_io_t *rmio;
  923. /* delete any connections we have queued. */
  924. while ((rmio = io_find(iolist, NULL)) != NULL) {
  925. close_iodescriptors(rmio);
  926. iolist = io_remove(iolist, rmio);
  927. }
  928. }
  930. closev(sv, ELEMENTS(sv));
  931. break;
  932. }
  934. case SOCKS_CONNECT: {
  935. socklen_t sinlen;
  937. if (socks_connect(out, &io.dst) != 0) {
  938. iolog(&io.rule, &io.state, OPERATION_ABORT, &io.src, &io.dst,
  939. NULL, 0);
  940. send_failure(request->s, &response,
  941. errno2reply(errno, response.version));
  942. close(request->s);
  943. break;
  944. }
  946. io.in.s = request->s;
  947. io.in.laddr = request->to;
  948. io.in.raddr = request->from;
  949. io.in.state = io.state;
  951. io.out.s = out;
  952. io.out.state = io.state;
  953. sinlen = sizeof(io.out.raddr);
  954. /* LINTED pointer casts may be troublesome */
  955. if (getpeername(io.out.s, (struct sockaddr *)&io.out.raddr, &sinlen)
  956. != 0) {
  957. swarn("%s: getpeername(io.out.s)", function);
  958. send_failure(request->s, &response, SOCKS_FAILURE);
  959. close(request->s);
  960. break;
  961. }
  963. sinlen = sizeof(io.out.laddr);
  964. /* LINTED pointer casts may be troublesome */
  965. if (getsockname(io.out.s, (struct sockaddr *)&io.out.laddr, &sinlen)
  966. != 0) {
  967. swarn("%s: getsockname(io.out.s)", function);
  968. send_failure(request->s, &response, SOCKS_FAILURE);
  969. close(request->s);
  970. break;
  971. }
  973. /* LINTED pointer casts may be troublesome */
  974. sockaddr2sockshost((struct sockaddr *)&io.out.laddr, &response.host);
  975. response.reply = (char)sockscode(response.version, SOCKS_SUCCESS);
  977. flushio(mother, request->s, &response, &io);
  978. break;
  979. }
  981. case SOCKS_UDPASSOCIATE: {
  982. struct sockaddr_in client;
  983. socklen_t boundlen;
  984. int clientfd;
  986. /* socket we receive datagram's from client on */
  987. if ((clientfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
  988. swarn("%s: socket(SOCK_DGRAM)", function);
  989. send_failure(request->s, &response, SOCKS_FAILURE);
  990. close(request->s);
  991. break;
  992. }
  993. setsockoptions(clientfd);
  995. /* LINTED pointer casts may be troublesome */
  996. sockshost2sockaddr(&request->req.host, (struct sockaddr *)&client);
  998. io.in.s = clientfd;
  999. io.in.state = io.state;
  1000. io.in.raddr = client;
  1001. io.in.laddr = request->to;
  1002. io.in.laddr.sin_port = htons(0);
  1004. /*
  1005.  * bind to address for receiving udp packets so we can tell client
  1006.  * where to send its packets.
  1007.  */
  1008. /* LINTED pointer casts may be troublesome */
  1009. if (sockd_bind(clientfd, (struct sockaddr *)&io.in.laddr, 0) != 0) {
  1010. /* LINTED pointer casts may be troublesome */
  1011. swarn("%s: bind(%s)", function,
  1012. sockaddr2string((struct sockaddr *)&io.in.laddr, a, sizeof(a)));
  1013. send_failure(request->s, &response, SOCKS_FAILURE);
  1014. close(request->s);
  1015. close(clientfd);
  1016. break;
  1017. }
  1019. boundlen = sizeof(io.in.laddr);
  1020. /* LINTED pointer casts may be troublesome */
  1021. if (getsockname(clientfd, (struct sockaddr *)&io.in.laddr, &boundlen)
  1022. != 0) {
  1023. swarn("%s: getsockname(clientfd)", function);
  1024. send_failure(request->s, &response, SOCKS_FAILURE);
  1025. close(request->s);
  1026. close(clientfd);
  1027. break;
  1028. }
  1030. io.out.s = out;
  1031. io.out.state = io.state;
  1032. io.out.state.auth.method = AUTHMETHOD_NONE;
  1034. boundlen = sizeof(io.out.laddr);
  1035. /* LINTED pointer casts may be troublesome */
  1036. if (getsockname(out, (struct sockaddr *)&io.out.laddr, &boundlen)
  1037. != 0) {
  1038. swarn("%s: getsockname(out)", function);
  1039. send_failure(request->s, &response, SOCKS_FAILURE);
  1040. close(request->s);
  1041. close(clientfd);
  1042. break;
  1043. }
  1045. /* remote out changes each time, set to INADDR_ANY for now. */
  1046. bzero(&io.out.raddr, sizeof(io.out.raddr));
  1047. io.out.raddr.sin_family = AF_INET;
  1048. io.out.raddr.sin_addr.s_addr = htonl(INADDR_ANY);
  1049. io.out.raddr.sin_port = htons(0);
  1051. io.control.s = request->s;
  1052. io.control.laddr = request->from;
  1053. io.control.raddr = request->to;
  1054. io.control.state = io.state;
  1056. if (request->req.flag & SOCKS_USECLIENTPORT)
  1057. if (client.sin_port == io.out.laddr.sin_port)
  1058. response.flag |= SOCKS_USECLIENTPORT;
  1060. /* LINTED pointer casts may be troublesome */
  1061. sockaddr2sockshost((struct sockaddr *)&io.in.laddr, &response.host);
  1062. response.reply = (char)sockscode(response.version, SOCKS_SUCCESS);
  1063. flushio(mother, request->s, &response, &io);
  1064. break;
  1065. }
  1067. default:
  1068. SERRX(request->req.command);
  1069. }
  1071. close(out);
  1072. }
  1075. static void
  1076. flushio(mother, clientcontrol, response, io)
  1077. int mother;
  1078. int clientcontrol;
  1079. const struct response_t *response;
  1080. struct sockd_io_t *io;
  1081. {
  1082. const char *function = "flushio()";
  1083. socklen_t len;
  1084. int sndlowat, value;
  1085. float skew;
  1087. switch (io->state.command) {
  1088. case SOCKS_UDPASSOCIATE:
  1089. sndlowat = SOCKD_BUFSIZEUDP;
  1090. skew = 1.0; /* no skew. */
  1091. break;
  1093. default:
  1094. sndlowat = SOCKD_BUFSIZETCP;
  1095. skew = LOWATSKEW;
  1096. }
  1098. /* set socket options for relay process. */
  1100. #if SOCKD_IOMAX == 1
  1101. /* only one client per process; doesn't matter much whether we block. */
  1102. io->in.sndlowat = sndlowat;
  1103. io->out.sndlowat = sndlowat;
  1105. #elif HAVE_SO_SNDLOWAT
  1107. len = sizeof(value);
  1108. if (getsockopt(io->in.s, SOL_SOCKET, SO_SNDBUF, &value, &len) != 0)
  1109. swarn("%s: getsockopt(in, SO_SNDBUF)", function);
  1110. sndlowat = MIN(sndlowat, value * skew);
  1112. if (setsockopt(io->in.s, SOL_SOCKET, SO_SNDLOWAT, &sndlowat,
  1113. sizeof(sndlowat)) != 0)
  1114. swarn("%s: setsockopt(in, SO_SNDLOWAT)", function);
  1116. len = sizeof(io->in.sndlowat);
  1117. if (getsockopt(io->in.s, SOL_SOCKET, SO_SNDLOWAT, &io->in.sndlowat, &len)
  1118. != 0)
  1119. swarn("%s: getsockopt(in, SO_SNDLOWAT)", function);
  1121. len = sizeof(value);
  1122. if (getsockopt(io->out.s, SOL_SOCKET, SO_SNDBUF, &value, &len) != 0)
  1123. swarn("%s: getsockopt(out, SO_SNDBUF)", function);
  1124. sndlowat = MIN(sndlowat, value * skew);
  1126. if (setsockopt(io->out.s, SOL_SOCKET, SO_SNDLOWAT, &sndlowat,
  1127. sizeof(sndlowat)) != 0)
  1128. swarn("%s: setsockopt(out, SO_SNDLOWAT", function);
  1130. len = sizeof(io->out.sndlowat);
  1131. if (getsockopt(io->in.s, SOL_SOCKET, SO_SNDLOWAT, &io->out.sndlowat, &len)
  1132. != 0)
  1133. swarn("%s: getsockopt(in, SO_SNDLOWAT", function);
  1135. #else /* SOCKD_IOMAX > 1 && !HAVE_SO_SNDLOWAT. */
  1136. switch (io->state.command) {
  1137. case SOCKS_UDPASSOCIATE:
  1138. len = sizeof(sndlowat);
  1139. if (getsockopt(io->in.s, SOL_SOCKET, SO_SNDBUF, &sndlowat, &len) != 0){
  1140. swarn("%s: getsockopt(SO_SNDBUF", function);
  1141. io->in.sndlowat = SOCKD_BUFSIZEUDP;
  1142. }
  1143. else if (sndlowat == 0)
  1144. io->in.sndlowat = SOCKD_BUFSIZEUDP;
  1145. else
  1146. io->in.sndlowat = sndlowat;
  1148. len = sizeof(sndlowat);
  1149. if (getsockopt(io->out.s, SOL_SOCKET, SO_SNDBUF, &sndlowat, &len)
  1150. != 0) {
  1151. swarn("%s: getsockopt(SO_SNDBUF", function);
  1152. io->out.sndlowat = SOCKD_BUFSIZEUDP;
  1153. }
  1154. else if (sndlowat == 0)
  1155. io->out.sndlowat = SOCKD_BUFSIZEUDP;
  1156. else
  1157. io->out.sndlowat = sndlowat;
  1159. break;
  1161. default:
  1162. /* TCP; use minimum guess. */
  1163. io->in.sndlowat = SO_SNDLOWAT_SIZE;
  1164. io->out.sndlowat = SO_SNDLOWAT_SIZE;
  1165. }
  1166. #endif  /* SOCKD_IOMAX > 1 && !HAVE_SO_SNDLOWAT */
  1168. SASSERTX(io->in.sndlowat > 0
  1169. && io->out.sndlowat >= sizeof(struct udpheader_t));
  1171. if (send_response(clientcontrol, response) == 0)
  1172. if (send_io(mother, io) != 0)
  1173. serr(EXIT_FAILURE, "%s: sending io to mother failed", function);
  1175. close_iodescriptors(io);
  1176. }
  1179. static void
  1180. proctitleupdate(from)
  1181. const struct sockaddr *from;
  1182. {
  1183. char fromstring[MAXSOCKADDRSTRING];
  1185. setproctitle("requestcompleter: %s",
  1186. from == NULL ?
  1187. "<idle>" : sockaddr2string(from, fromstring, sizeof(fromstring)));
  1188. }
  1190. static struct sockd_io_t *
  1191. io_add(iolist, newio)
  1192. struct sockd_io_t *iolist;
  1193. const struct sockd_io_t *newio;
  1194. {
  1195. const char *function = "io_add()";
  1196. struct sockd_io_t *io, *previo;
  1198. SASSERTX(newio->next == NULL);
  1200. previo = io = iolist;
  1201. while (io != NULL) {
  1202. previo = io;
  1203. io = io->next;
  1204. }
  1206. if ((io = (struct sockd_io_t *)malloc(sizeof(*newio))) == NULL)
  1207. swarnx("%s: %s", function, NOMEM);
  1208. else {
  1209. *io = *newio;
  1211. if (previo == NULL)
  1212. previo = io;
  1213. else
  1214. previo->next = io;
  1215. }
  1217. return iolist == NULL ? previo : iolist;
  1218. }
  1220. static struct sockd_io_t *
  1221. io_remove(iolist, rmio)
  1222. struct sockd_io_t *iolist;
  1223. struct sockd_io_t *rmio;
  1224. {
  1225. struct sockd_io_t *io, *previo;
  1227. SASSERTX(iolist != NULL);
  1229. if (iolist == rmio) {
  1230. iolist = rmio->next;
  1231. free(rmio);
  1232. return iolist;
  1233. }
  1235. previo = iolist;
  1236. io = iolist->next;
  1237. while (io != NULL) {
  1238. if (io == rmio) {
  1239. previo->next = rmio->next;
  1240. free(rmio);
  1241. break;
  1242. }
  1244. previo = io;
  1245. io = io->next;
  1246. }
  1248. return iolist;
  1249. }
  1251. static struct sockd_io_t *
  1252. io_find(iolist, addr)
  1253. struct sockd_io_t *iolist;
  1254. const struct sockaddr *addr;
  1255. {
  1256. struct sockd_io_t *io;
  1258. if (addr == NULL)
  1259. return iolist;
  1261. io = iolist;
  1262. while (io != NULL)
  1263. /* LINTED pointer casts may be troublesome */
  1264. if (sockaddrareeq((struct sockaddr *)&io->in.laddr, addr)
  1265. ||  sockaddrareeq((struct sockaddr *)&io->out.laddr, addr)
  1266. ||  sockaddrareeq((struct sockaddr *)&io->control.laddr, addr))
  1267. return io;
  1268. else
  1269. io = io->next;
  1271. /* XXX should actually check that the io is still "active". */
  1273. return NULL;
  1274. }