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

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

代理服务器

开发平台：

Unix_Linux

config.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: config.c,v 1.119 1999/12/20 13:07:41 karls Exp $";
  49. __BEGIN_DECLS
  51. static int
  52. addrisinlist __P((const struct in_addr *addr, const struct in_addr *mask,
  53.   const struct in_addr **list));
  54. /*
  55.  * Compares "addr" bitwise anded with "mask" against each element in
  56.  * "list" bitwise anded with "mask".  "list" is NULL terminated.
  57.  * Returns:
  58.  * If "list" contains a element matching "addr" and "mask": true
  59.  * else: false
  60.  */
  62. static int
  63. addrareeq __P((const struct in_addr *addr, const struct in_addr *mask,
  64. const struct in_addr *against));
  65. /*
  66.  * Compares "addr" bitwise anded with "mask" against "against" bitwise
  67.  * anded with "mask".
  68.  * Returns:
  69.  * If "against" matches "addr" and "mask": true
  70.  * else: false
  71.  */
  73. static int
  74. hostisinlist __P((const char *host, const char **list));
  75. /*
  76.  * Compares "host" against each element in "list", which is NULL
  77.  * terminated.
  78.  * Note that if "host" starts with a dot, it will match "list" if the
  79.  * last part of "list" matches the part after the dot in "host".
  80.  * Returns:
  81.  * If "list" contains a element matching "host": true
  82.  * else: false
  83.  */
  85. static int
  86. hostareeq __P((const char *domain, const char *remotedomain));
  87. /*
  88.  * Compares the rulegiven domain "domain" against "remotedomain".
  89.  * Note that if "domain" starts with a dot, it will match
  90.  * "remotedomain" if the last part of "remotedomain" matches
  91.  * the part after the dot in "domain".
  92.  * Returns:
  93.  * on match: true
  94.  * else: false
  95.  */
  98. __END_DECLS
  100. void
  101. genericinit(void)
  102. {
  103. const char *function = "genericinit()";
  104. int i;
  106. if (!config.state.init) {
  107. #if !HAVE_SETPROCTITLE
  108. /* create a backup to avoid setproctitle replacement overwriting it. */
  109. if ((__progname = strdup(__progname)) == NULL)
  110. serrx(EXIT_FAILURE, "%s: %s", function, NOMEM);
  111. #endif /* !HAVE_SETPROCTITLE */
  112. }
  114. if (readconfig(config.option.configfile) != 0)
  115. #if SOCKS_SERVER
  116. exit(EXIT_FAILURE);
  117. #else
  118. return;
  119. #endif
  121. initlog();
  123. #if !HAVE_NO_RESOLVESTUFF
  124. res_init();
  125. #endif /* !HAVE_NO_RESOLVSTUFF */
  127. switch (config.resolveprotocol) {
  128. case RESOLVEPROTOCOL_TCP:
  129. #if !HAVE_NO_RESOLVESTUFF
  130. _res.options |= RES_USEVC;
  131. #else /* HAVE_NO_RESOLVESTUFF */
  132. SERRX(config.resolveprotocol);
  133. #endif  /* HAVE_NO_RESOLVESTUFF */
  134. break;
  136. case RESOLVEPROTOCOL_UDP:
  137. case RESOLVEPROTOCOL_FAKE:
  138. break;
  140. default:
  141. SERRX(config.resolveprotocol);
  142. }
  144. if (!config.state.init)
  145. if (config.option.lbuf)
  146. for (i = 0; i < config.log.fpc; ++i)
  147. if (setvbuf(config.log.fpv[i], NULL, _IOLBF, 0) != 0)
  148. swarn("%s: setvbuf(_IOLBF)", function);
  150. config.state.init = 1;
  151. }
  153. int
  154. addressmatch(rule, address, protocol, alias)
  155. const struct ruleaddress_t *rule;
  156. const struct sockshost_t *address;
  157. int protocol;
  158. int alias;
  159. {
  160. const char *function = "addressmatch()";
  161. struct hostent *hostent;
  162. in_port_t ruleport;
  163. int matched, doresolve;
  165. /* test port first since we have all info needed for that locally. */
  166. switch (protocol) {
  167. case SOCKS_TCP:
  168. ruleport = rule->port.tcp;
  169. break;
  171. case SOCKS_UDP:
  172. ruleport = rule->port.udp;
  173. break;
  175. default:
  176. SERRX(protocol);
  177. }
  179. switch (rule->operator) {
  180. case none:
  181. break;
  183. case eq:
  184. if (address->port == ruleport)
  185. break;
  186. return 0;
  188. case neq:
  189. if (address->port != ruleport)
  190. break;
  191. return 0;
  193. case ge:
  194. if (ntohs(address->port) >= ntohs(ruleport))
  195. break;
  196. return 0;
  198. case le:
  199. if (ntohs(address->port) <= ntohs(ruleport))
  200. break;
  201. return 0;
  203. case gt:
  204. if (ntohs(address->port) > ntohs(ruleport))
  205. break;
  206. return 0;
  208. case lt:
  209. if (ntohs(address->port) < ntohs(ruleport))
  210. break;
  211. return 0;
  213. case range:
  214. if (ntohs(address->port) >= ntohs(ruleport)
  215. &&  ntohs(address->port) <= ntohs(rule->portend))
  216. break;
  217. return 0;
  219. default:
  220. SERRX(rule->operator);
  221. }
  223. /* only needed for client really... */
  224. switch (config.resolveprotocol) {
  225. case RESOLVEPROTOCOL_TCP:
  226. case RESOLVEPROTOCOL_UDP:
  227. doresolve = 1;
  228. break;
  230. case RESOLVEPROTOCOL_FAKE:
  231. doresolve = 0;
  232. break;
  234. default:
  235. SERRX(config.resolveprotocol);
  236. }
  238. /*
  239.  * The hard work begins.
  240.  */
  242. matched = 0;
  243. if (rule->atype == SOCKS_ADDR_IPV4 && address->atype == SOCKS_ADDR_DOMAIN) {
  244. /*
  245.  * match(rule.ipaddress, address.hostname)
  246.  * resolve address to ipaddress(es) and try to match each
  247.  * resolved ipaddress against rule.
  248.  * rule is in address->ipaddress(es)
  249.  */
  251. if (!doresolve)
  252. return 0;
  254. /* LINTED pointer casts may be troublesome */
  255. if ((hostent = gethostbyname(address->addr.domain)) == NULL) {
  256. slog(LOG_DEBUG, "%s: gethostbyname(%s): %s",
  257. function, address->addr.domain, hstrerror(h_errno));
  258. return 0;
  259. }
  261. if (addrisinlist(&rule->addr.ipv4.ip, &rule->addr.ipv4.mask,
  262. (const struct in_addr **)hostent->h_addr_list))
  263. matched = 1;
  264. }
  265. else if (rule->atype == SOCKS_ADDR_IPV4
  266. && address->atype == SOCKS_ADDR_IPV4) {
  267. /*
  268.  * match(rule.ipaddress, address.ipaddress)
  269.  * try first a simple comparison, address against rule.
  270.  */
  271. if (addrareeq(&rule->addr.ipv4.ip, &rule->addr.ipv4.mask,
  272. &address->addr.ipv4))
  273. matched = 1;
  274. else {
  275. /*
  276.  * Didn't match.  If alias is set, try to resolve address
  277.  * to hostname(s), the hostname back to ipaddress(es) and
  278.  * then match those ipaddress(es) against rule.
  279.  * rule is in address->hostname(s)->ipaddress(es)
  280.  */
  282. if (!doresolve)
  283. return 0;
  285. if (alias) {
  286. char *nexthost;
  287. int i;
  289. /* LINTED pointer casts may be troublesome */
  290. if ((hostent = gethostbyaddr((const char *)&address->addr.ipv4,
  291. sizeof(address->addr.ipv4), AF_INET)) == NULL) {
  292. slog(LOG_DEBUG, "%s: %s: %s",
  293. function, inet_ntoa(address->addr.ipv4), hstrerror(h_errno));
  294. return 0;
  295. }
  297. if ((hostent = hostentdup(hostent)) == NULL) {
  298. swarnx("%s: hostentdup()", function);
  299. return 0;
  300. }
  302. nexthost = hostent->h_name;
  303. i = 0;
  304. do {
  305. struct hostent *iphostent;
  307. /* iphostent = address->hostname(s)->ipaddress(es) */
  308. if ((iphostent = gethostbyname(nexthost)) == NULL) {
  309. slog(LOG_DEBUG, "%s: gethostbyname(%s): %s",
  310. function, nexthost, hstrerror(h_errno));
  311. continue;
  312. }
  314. /* rule is in address->hostname(s)->ipaddress(es) */
  315. if (addrisinlist(&rule->addr.ipv4.ip, &rule->addr.ipv4.mask,
  316. (const struct in_addr **)iphostent->h_addr_list)) {
  317. matched = 1;
  318. break;
  319. }
  320. } while (hostent->h_aliases != NULL
  321. && (nexthost = hostent->h_aliases[i++]) != NULL);
  323. hostentfree(hostent);
  324. }
  326. if (!matched)
  327. return 0;
  328. }
  329. }
  330. else if (rule->atype == SOCKS_ADDR_DOMAIN
  331. && address->atype == SOCKS_ADDR_DOMAIN) {
  332. /*
  333.  * match(rule.hostname, address.hostname)
  334.  * Try simple match first.
  335.  *
  336.  * If no go and rule is a hostname rather than a domain,
  337.  * resolve both rule and address to ipaddress(es) and compare
  338.  * each ipaddress of resolved rule against each ipaddress of
  339.  * resolved address.
  340.  * rule->ipaddress(es) is in address->ipaddress(es)
  341.  *
  342.  */
  343. if (hostareeq(rule->addr.domain, address->addr.domain))
  344. matched = 1;
  345. else if (doresolve && *rule->addr.domain != '.') {
  346. struct hostent *addresshostent;
  347. struct in_addr mask;
  348. int i;
  350. if ((hostent = gethostbyname(rule->addr.domain)) == NULL) {
  351. slog(LOG_DEBUG, "%s: gethostbyname(%s): %s",
  352. function, rule->addr.domain, hstrerror(h_errno));
  353. return 0;
  354. }
  356. if ((hostent = hostentdup(hostent)) == NULL) {
  357. swarnx("%s: hostentdup()", function);
  358. return 0;
  359. }
  361. if ((addresshostent = gethostbyname(address->addr.domain)) == NULL) {
  362. slog(LOG_DEBUG, "%s: gethostbyname(%s): %s",
  363. function, address->addr.domain, hstrerror(h_errno));
  364. hostentfree(hostent);
  365. return 0;
  366. }
  368. /*
  369.  * rule->ipaddress(es) is in address->ipaddress(es)
  370.  */
  372. for (i = 0, mask.s_addr = htonl(0xffffffff);
  373. hostent->h_addr_list != NULL && hostent->h_addr_list[i] != NULL;
  374. ++i) {
  375. /* LINTED pointer casts may be troublesome */
  376. if (addrisinlist((const struct in_addr *)hostent->h_addr_list[i],
  377. &mask, (const struct in_addr **)addresshostent->h_addr_list)) {
  378. matched = 1;
  379. break;
  380. }
  381. }
  383. hostentfree(hostent);
  384. }
  386. if (!matched)
  387. return 0;
  388. }
  389. else if (rule->atype == SOCKS_ADDR_DOMAIN
  390. && address->atype == SOCKS_ADDR_IPV4) {
  391. /*
  392.  * match(rule.hostname, address.ipaddress)
  393.  * If rule is not a domain, try resolving rule to ipaddress(es)
  394.  * and match against address.
  395.  * address is in rule->ipaddress
  396.  *
  397.  * If no match, resolve address to hostname(s) and match each
  398.  * against rule.
  399.  * rule is in address->hostname
  400.  *
  401.  * If still no match and alias is set, resolve all ipaddresses
  402.  * of all hostname(s) resolved from address back to hostname(s)
  403.  * and match them against rule.
  404.  * rule is in address->hostname->ipaddress->hostname
  405.  */
  407. if (!doresolve)
  408. return 0;
  410. if (*rule->addr.domain != '.') {
  411. /* address is in rule->ipaddress */
  412. struct in_addr mask;
  414. if ((hostent = gethostbyname(rule->addr.domain)) == NULL) {
  415. slog(LOG_DEBUG, "%s: gethostbyname(%s): %s",
  416. function, rule->addr.domain, hstrerror(h_errno));
  417. return 0;
  418. }
  420. mask.s_addr = htonl(0xffffffff);
  421. if (addrisinlist(&address->addr.ipv4, &mask,
  422. (const struct in_addr **)hostent->h_addr_list))
  423. matched = 1;
  424. }
  426. if (!matched) {
  427. /* rule is in address->hostname */
  429. /* LINTED pointer casts may be troublesome */
  430. if ((hostent = gethostbyaddr((const char *)&address->addr.ipv4,
  431. sizeof(address->addr.ipv4), AF_INET)) == NULL) {
  432. slog(LOG_DEBUG, "%s: gethostbyaddr(%s): %s",
  433. function, inet_ntoa(address->addr.ipv4), hstrerror(h_errno));
  434. return 0;
  435. }
  437. if (hostareeq(rule->addr.domain, hostent->h_name)
  438. ||  hostisinlist(rule->addr.domain, (const char **)hostent->h_aliases))
  439. matched = 1;
  440. }
  442. if (!matched && alias) {
  443. /*
  444.  * rule is in address->hostname->ipaddress->hostname.
  445.  * hostent is already address->hostname due to above.
  446.  */
  447. char *nexthost;
  448. int i;
  450. if ((hostent = hostentdup(hostent)) == NULL) {
  451. swarnx("%s: hostentdup()", function);
  452. return 0;
  453. }
  455. nexthost = hostent->h_name;
  456. i = 0;
  457. do {
  458. int ii;
  459. struct hostent *host;
  461. /* host; address->hostname->ipaddress */
  462. if ((host = gethostbyname(nexthost)) == NULL) {
  463. slog(LOG_DEBUG, "%s: gethostbyname(%s): %s",
  464. function, nexthost, hstrerror(h_errno));
  465. continue;
  466. }
  468. if ((host = hostentdup(host)) == NULL) {
  469. swarnx("%s: hostentdup()", function);
  470. break;
  471. }
  473. /* LINTED pointer casts may be troublesome */
  474. for (ii = 0;
  475. host->h_addr_list != NULL && host->h_addr_list[ii] != NULL;
  476. ++ii) {
  477. struct hostent *ip;
  479. /* ip; address->hostname->ipaddress->hostname */
  480. if ((ip = gethostbyaddr(host->h_addr_list[ii],
  481. sizeof(struct in_addr), AF_INET)) == NULL) {
  482. /* LINTED pointer casts may be troublesome */
  483. slog(LOG_DEBUG, "%s: gethostbyaddr(%s): %s",
  484. function, inet_ntoa(*(struct in_addr *)host->h_addr_list[ii]),
  485. hstrerror(h_errno));
  486. continue;
  487. }
  489. if (hostareeq(rule->addr.domain, ip->h_name)
  490. ||  hostisinlist(rule->addr.domain,
  491. (const char **)ip->h_aliases)) {
  492. matched = 1;
  493. break;
  494. }
  495. }
  497. hostentfree(host);
  498. } while (!matched && hostent->h_aliases != NULL
  499. && (nexthost = hostent->h_aliases[i++]) != NULL);
  501. hostentfree(hostent);
  502. }
  503. if (!matched)
  504. return 0;
  505. }
  506. else
  507. SERRX(0);
  509. return matched;
  510. }
  512. static int
  513. addrisinlist(addr, mask, list)
  514. const struct in_addr *addr;
  515. const struct in_addr *mask;
  516. const struct in_addr **list;
  517. {
  519. if (list == NULL)
  520. return 0;
  522. while (*list != NULL)
  523. if (addrareeq(addr, mask, *list))
  524. return 1;
  525. else
  526. ++list;
  527. return 0;
  528. }
  530. static int
  531. addrareeq(addr, mask, against)
  532. const struct in_addr *addr;
  533. const struct in_addr *mask;
  534. const struct in_addr *against;
  535. {
  537. if ((addr->s_addr & mask->s_addr) == (against->s_addr & mask->s_addr))
  538. return 1;
  539. return 0;
  540. }
  542. static int
  543. hostisinlist(host, list)
  544. const char *host;
  545. const char **list;
  546. {
  548. if (list == NULL)
  549. return 0;
  551. while (*list != NULL)
  552. if (hostareeq(host, *list))
  553. return 1;
  554. else
  555. ++list;
  556. return 0;
  557. }
  559. static int
  560. hostareeq(domain, remotedomain)
  561. const char *domain;
  562. const char *remotedomain;
  563. {
  564. const int domainlen = strlen(domain);
  565. const int remotedomainlen = strlen(remotedomain);
  567. if (*domain == '.') { /* match everything ending in domain */
  568. if (domainlen - 1 > remotedomainlen)
  569. return 0; /* address to compare against too short, can't match. */
  570. return strcasecmp(domain + 1,
  571. remotedomain + (remotedomainlen - (domainlen - 1))) == 0;
  572. }
  573. else /* need exact match. */
  574. return strcasecmp(domain, remotedomain) == 0;
  575. }
  578. #if SOCKS_CLIENT
  580. struct route_t *
  581. addroute(newroute)
  582. const struct route_t *newroute;
  583. {
  584. const char *function = "addroute()";
  585. static const struct serverstate_t state;
  586. struct route_t *route;
  588. if ((route = (struct route_t *)malloc(sizeof(*route))) == NULL)
  589. serrx(1, "%s: %s", function, NOMEM);
  590. *route = *newroute;
  592. /* check gateway. */
  594. /* if no command set, set all. */
  595. if (memcmp(&state.command, &route->gw.state.command, sizeof(state.command))
  596. == 0)
  597. memset(&route->gw.state.command, UCHAR_MAX,
  598. sizeof(route->gw.state.command));
  600. /* if no protocol set, set all. */
  601. if (memcmp(&state.protocol, &route->gw.state.protocol,
  602. sizeof(state.protocol)) == 0)
  603. memset(&route->gw.state.protocol, UCHAR_MAX,
  604. sizeof(route->gw.state.protocol));
  606. /* if no proxyprotocol set, set all except msproxy. */
  607. if (memcmp(&state.proxyprotocol, &route->gw.state.proxyprotocol,
  608. sizeof(state.proxyprotocol)) == 0) {
  609. memset(&route->gw.state.proxyprotocol, UCHAR_MAX,
  610. sizeof(route->gw.state.proxyprotocol));
  611. route->gw.state.proxyprotocol.msproxy_v2 = 0;
  612. }
  614. /* if no method set, set all we support. */
  615. if (route->gw.state.methodc == 0) {
  616. int *methodv = route->gw.state.methodv;
  617. int *methodc = &route->gw.state.methodc;
  619. methodv[(*methodc)++] = AUTHMETHOD_NONE;
  620. methodv[(*methodc)++] = AUTHMETHOD_UNAME;
  621. }
  623. if (config.route == NULL) {
  624. config.route = route;
  625. config.route->number = 1;
  626. }
  627. else {
  628. /* append rule to the end of list. */
  629. struct route_t *lastroute;
  631. lastroute = config.route;
  632. while (lastroute->next != NULL)
  633. lastroute = lastroute->next;
  635. route->number = lastroute->number + 1;
  636. lastroute->next = route;
  637. }
  638. route->next = NULL;
  640. return route;
  641. }
  644. void
  645. showroute(route)
  646. const struct route_t *route;
  647. {
  648. char hstring[MAXSOCKSHOSTSTRING];
  649. char addr[MAXRULEADDRSTRING];
  651. slog(LOG_INFO, "route #%d", route->number);
  653. slog(LOG_INFO, "src: %s",
  654. ruleaddress2string(&route->src, addr, sizeof(addr)));
  656. slog(LOG_INFO, "dst: %s",
  657. ruleaddress2string(&route->dst, addr, sizeof(addr)));
  659. slog(LOG_INFO, "gateway: %s",
  660. sockshost2string(&route->gw.host, hstring, sizeof(hstring)));
  662. showstate(&route->gw.state);
  663. }
  666. struct route_t *
  667. socks_getroute(req, src, dst)
  668. const struct request_t *req;
  669. const struct sockshost_t *src;
  670. const struct sockshost_t *dst;
  671. {
  672. struct route_t *route;
  673. int protocol;
  675. #if SOCKS_CLIENT
  676. clientinit();
  677. #endif
  679. for (route = config.route; route != NULL; route = route->next) {
  680. if (route->state.bad)
  681. continue; /* XXX code to retry and remove bad status when ok. */
  683. switch (req->version) {
  684. case SOCKS_V4:
  685. if (!route->gw.state.proxyprotocol.socks_v4)
  686. continue;
  688. switch (req->host.atype) {
  689. case SOCKS_ADDR_IPV4:
  690. break;
  692. case SOCKS_ADDR_IPV6:
  693. case SOCKS_ADDR_DOMAIN:
  694. continue; /* not failure, just checking. */
  696. default:
  697. SERRX(req->host.atype); /* failure, nothing else exists. */
  698. }
  699. break;
  701. case SOCKS_V5:
  702. if (!route->gw.state.proxyprotocol.socks_v5)
  703. continue;
  705. switch (req->host.atype) {
  706. case SOCKS_ADDR_IPV4:
  707. case SOCKS_ADDR_IPV6:
  708. case SOCKS_ADDR_DOMAIN:
  709. break;
  711. default:
  712. SERRX(req->host.atype); /* failure, nothing else exists. */
  713. }
  714. break;
  716. case MSPROXY_V2:
  717. if (!route->gw.state.proxyprotocol.msproxy_v2)
  718. continue;
  719. break;
  721. default:
  722. SERRX(req->version);
  723. }
  725. switch (req->command) {
  726. case SOCKS_BIND:
  727. if (!route->gw.state.command.bind)
  728. continue;
  730. if (req->host.atype == SOCKS_ADDR_IPV4
  731. &&  req->host.addr.ipv4.s_addr == htonl(0))
  732. if (req->version == MSPROXY_V2)
  733. ; /* supports binding wildcard */
  734. else if (!route->gw.state.extension.bind)
  735. continue;
  736. break;
  738. case SOCKS_CONNECT:
  739. if (!route->gw.state.command.connect)
  740. continue;
  741. break;
  743. case SOCKS_UDPASSOCIATE:
  744. if (!route->gw.state.command.udpassociate)
  745. continue;
  746. break;
  748. default:
  749. SERRX(req->command);
  750. }
  752. /* server supports protocol? */
  753. switch (req->command) {
  754. case SOCKS_BIND:
  755. case SOCKS_CONNECT:
  756. if (!route->gw.state.protocol.tcp)
  757. continue;
  758. protocol = SOCKS_TCP;
  759. break;
  761. case SOCKS_UDPASSOCIATE:
  762. if (!route->gw.state.protocol.udp)
  763. continue;
  764. protocol = SOCKS_UDP;
  765. break;
  767. default:
  768. SERRX(req->command);
  769. }
  771. if (src != NULL)
  772. if (!addressmatch(&route->src, src, protocol, 0))
  773. continue;
  775. if (dst != NULL)
  776. if (!addressmatch(&route->dst, dst, protocol, 0))
  777. continue;
  779. if (route->state.direct)
  780. return NULL; /* don't use any route, connect directly. */
  782. break; /* all matched */
  783. }
  785. return route;
  786. }
  789. struct route_t *
  790. socks_connectroute(s, packet, src, dst)
  791. int s;
  792. struct socks_t *packet;
  793. const struct sockshost_t *src;
  794. const struct sockshost_t *dst;
  795. {
  796. const char *function = "socks_connectroute()";
  797. int sdup, current_s, errno_s;
  798. struct route_t *route;
  800. /*
  801.  * This is a little tricky since we attempt to support trying
  802.  * more than one socksserver.  If the first one fails, we try
  803.  * the next, etc.  Ofcourse, if connect() on one socket fails,
  804.  * that socket can no longer be used, so we need to be able to
  805.  * copy/dup the original socket as much as possible.  Later,
  806.  * if it turned out a connection failed and we had to use a
  807.  * different socket than the orignal 's', we try to dup the
  808.  * differently numbered socket to 's' and hope the best.
  809.  *
  810.  * sdup: copy of the original socket.  Need to create this
  811.  * before the first connectattempt since the connectattempt
  812.  *    could prevent us from doing it later, depending on failure
  813.  * reason.
  814.  *
  815.  * current_s: socket to use for next connection attempt.  For the
  816.  * first attempt this is 's'.
  817.  */
  819. errno = 0; /* let caller differentiate between missing route and not.*/
  820. current_s = s;
  821. sdup = -1;
  823. while ((route = socks_getroute(&packet->req, src, dst)) != NULL) {
  824. char hstring[MAXSOCKSHOSTSTRING];
  826. /* inside loop since if no route, no need for it. */
  827. if (sdup == -1)
  828. sdup = socketoptdup(s);
  830. if (current_s == -1)
  831. if ((current_s = socketoptdup(sdup == -1 ? s : sdup)) == -1)
  832. return NULL;
  834. slog(LOG_DEBUG, "%s: trying route #%d (%s)",
  835. function, route->number,
  836. sockshost2string(&route->gw.host, hstring, sizeof(hstring)));
  838. if (socks_connect(current_s, &route->gw.host) == 0)
  839. break;
  840. else
  841. /*
  842.  * Check whether the error indicates bad socksserver or
  843.  * something else.
  844.  */
  845. if (errno == EINPROGRESS) {
  846. SASSERTX(current_s == s);
  847. break;
  848. }
  849. else if (errno == EADDRINUSE) {
  850. /* see Rbind() for explanation. */
  851. SASSERTX(current_s == s);
  852. route = NULL;
  853. break;
  854. }
  855. else {
  856. swarn("%s: socks_connect(%s)",
  857. function, sockshost2string(&route->gw.host, hstring,
  858. sizeof(hstring)));
  859. socks_badroute(route);
  860. close(current_s);
  861. current_s = -1;
  862. }
  863. }
  865. errno_s = errno;
  867. if (sdup != -1)
  868. close(sdup);
  870. if (current_s != s && current_s != -1) {
  871. /* created a new socket for connect, need to make it same descriptor #. */
  872. if (dup2(current_s, s) == -1) {
  873. close(current_s);
  874. return NULL;
  875. }
  876. close(current_s);
  878. #if SOCKS_SERVER && HAVE_LIBWRAP
  879. if ((current_s = fcntl(s, F_GETFD, 0)) == -1
  880. || fcntl(s, F_SETFD, current_s | FD_CLOEXEC) == -1)
  881. swarn("%s: fcntl(F_GETFD/F_SETFD)", function);
  882. #endif
  883. }
  885. if (route != NULL) {
  886. static int init;
  888. packet->gw = route->gw;
  890. /* need to set up misc. crap for msproxy stuff. */
  891. if (!init && route->gw.state.proxyprotocol.msproxy_v2) {
  892. if (msproxy_init() != 0)
  893. ; /* yes, then what? */
  894. init = 1;
  895. }
  896. }
  898. errno = errno_s;
  899. return route;
  900. }
  902. void
  903. socks_badroute(route)
  904. struct route_t *route;
  905. {
  906. const char *function = "socks_badroute()";
  908. slog(LOG_DEBUG, "%s: badrouting route #%d", function, route->number);
  909. route->state.bad = 1;
  910. }
  913. struct request_t *
  914. socks_requestpolish(req, src, dst)
  915. struct request_t *req;
  916. const struct sockshost_t *src;
  917. const struct sockshost_t *dst;
  918. {
  919. const char *function = "socks_requestpolish()";
  920. unsigned char version;
  922. if (socks_getroute(req, src, dst) != NULL)
  923. return req;
  925. switch (req->command) {
  926. case SOCKS_BIND:
  927. case SOCKS_CONNECT:
  928. break;
  930. case SOCKS_UDPASSOCIATE:
  931. SERRX(req->command); /* currently not implemented, shouldn't happen. */
  932. /* NOTREACHED */
  934. default:
  935. SERRX(req->command);
  936. }
  938. /* unsupported version? */
  939. switch (req->version) {
  940. case SOCKS_V4:
  941. req->version = SOCKS_V5;
  942. break;
  944. case SOCKS_V5:
  945. req->version = SOCKS_V4;
  946. break;
  947. }
  949. if (socks_getroute(req, src, dst) != NULL)
  950. return req;
  952. SASSERTX(req->version != MSPROXY_V2); /* never gets set outside function. */
  953. version = req->version;
  954. req->version = MSPROXY_V2;
  955. if (socks_getroute(req, src, dst) != NULL)
  956. return req;
  957. req->version = version;
  959. switch (req->command) {
  960. case SOCKS_BIND:
  961. if (req->host.addr.ipv4.s_addr == htonl(0)) {
  962. const in_port_t originalport = req->host.port;
  963. const int originalversion = req->version;
  965. /* attempting to use bind extension, can we retry without it? */
  966. /* LINTED pointer casts may be troublesome */
  967. if (ADDRISBOUND(config.state.lastconnect)) {
  969. fakesockaddr2sockshost(&config.state.lastconnect, &req->host);
  971. /*
  972.  * v4 and v5 differ in how portnumber is treated
  973.  * so we need to be a little smarter than just returning
  974.  * the result of the next socks_requestpolish()
  975.  * while we still have the original portnumber.
  976.  */
  978. switch (req->version) {
  979. case SOCKS_V4:
  980. /* LINTED pointer casts may be troublesome */
  981. req->host.port = ((struct sockaddr_in *)
  982. &config.state.lastconnect)->sin_port;
  983. break;
  985. case SOCKS_V5:
  986. /* only wants ip address. */
  987. req->host.port = originalport;
  988. break;
  990. default:
  991. SERRX(req->version);
  992. }
  994. if (socks_requestpolish(req, src, dst) == NULL)
  995. return NULL;
  997. /*
  998.  * else, it may be that socks_requestpolish() was
  999.  * forced to change req.version to succeed, we then
  1000.  * need to change req->host.port due to difference in
  1001.  * v4 and v5 semantics.
  1002. */
  1004. if (req->version != originalversion) { /* version changed. */
  1005. /* currently it can only change from 4 to 5, or 5 to 4. */
  1006. switch (req->version) {
  1007. case SOCKS_V4:
  1008. /* LINTED pointer casts may be troublesome */
  1009. req->host.port = ((struct sockaddr_in *)
  1010. &config.state.lastconnect)->sin_port;
  1011. break;
  1013. case SOCKS_V5:
  1014. req->host.port = originalport;
  1015. break;
  1017. default:
  1018. SERRX(req->version);
  1019. }
  1021. }
  1023. return socks_requestpolish(req, src, dst);
  1024. }
  1025. else
  1026. slog(LOG_DEBUG,
  1027. "%s: couldn't find route for bind, try enabling bind extension?",
  1028. function);
  1029. }
  1030. break;
  1031. }
  1033. return NULL;
  1034. }
  1036. #endif /* SOCKS_CLIENT */
  1038. void
  1039. showstate(state)
  1040. const struct serverstate_t *state;
  1041. {
  1042. int i;
  1043. char buf[1024];
  1044. size_t bufused;
  1046. bufused = snprintf(buf, sizeof(buf), "command(s): ");
  1047. if (state->command.bind)
  1048. bufused += snprintf(&buf[bufused], sizeof(buf) - bufused, "%s, ",
  1049. SOCKS_BINDs);
  1050. if (state->command.bindreply)
  1051. bufused += snprintf(&buf[bufused], sizeof(buf) - bufused, "%s, ",
  1052. SOCKS_BINDREPLYs);
  1053. if (state->command.connect)
  1054. bufused += snprintf(&buf[bufused], sizeof(buf) - bufused, "%s, ",
  1055. SOCKS_CONNECTs);
  1056. if (state->command.udpassociate)
  1057. bufused += snprintf(&buf[bufused], sizeof(buf) - bufused, "%s, ",
  1058. SOCKS_UDPASSOCIATEs);
  1059. if (state->command.udpreply)
  1060. bufused += snprintf(&buf[bufused], sizeof(buf) - bufused, "%s, ",
  1061. SOCKS_UDPREPLYs);
  1062. slog(LOG_INFO, buf);
  1064. bufused = snprintf(buf, sizeof(buf), "extension(s): ");
  1065. if (state->extension.bind)
  1066. bufused += snprintf(&buf[bufused], sizeof(buf) - bufused, "bind");
  1067. slog(LOG_INFO, buf);
  1069. bufused = snprintf(buf, sizeof(buf), "protocol(s): ");
  1070. if (state->protocol.tcp)
  1071. bufused += snprintf(&buf[bufused], sizeof(buf) - bufused, "%s, ",
  1072. PROTOCOL_TCPs);
  1073. if (state->protocol.udp)
  1074. bufused += snprintf(&buf[bufused], sizeof(buf) - bufused, "%s, ",
  1075. PROTOCOL_UDPs);
  1076. slog(LOG_INFO, buf);
  1078. bufused = snprintf(buf, sizeof(buf), "method(s): ");
  1079. for (i = 0; i < state->methodc; ++i)
  1080. bufused += snprintf(&buf[bufused], sizeof(buf) - bufused, "%s, ",
  1081. method2string(state->methodv[i]));
  1082. slog(LOG_INFO, buf);
  1084. bufused = snprintf(buf, sizeof(buf), "proxyprotocol(s): ");
  1085. if (state->proxyprotocol.socks_v4)
  1086. bufused += snprintf(&buf[bufused], sizeof(buf) - bufused, "socks v4, ");
  1087. if (state->proxyprotocol.socks_v5)
  1088. bufused += snprintf(&buf[bufused], sizeof(buf) - bufused, "socks v5, ");
  1089. if (state->proxyprotocol.msproxy_v2)
  1090. bufused += snprintf(&buf[bufused], sizeof(buf) - bufused, "msproxy v2");
  1091. slog(LOG_INFO, buf);
  1092. }