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

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

代理服务器

开发平台：

Unix_Linux

util.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. /* XXX */
  47. #if HAVE_STRVIS
  48. #include <vis.h>
  49. #else
  50. #include "compat.h"
  51. #endif  /* HAVE_STRVIS */
  53. static const char rcsid[] =
  54. "$Id: util.c,v 1.98 1999/12/22 09:29:25 karls Exp $";
  56. /* fake "ip address", for clients without dns access. */
  57. static char **ipv;
  58. static in_addr_t ipc;
  60. const char *
  61. strcheck(string)
  62. const char *string;
  63. {
  64. return string == NULL ? NOMEM : string;
  65. }
  67. char *
  68. sockshost2string(host, string, len)
  69. const struct sockshost_t *host;
  70. char *string;
  71. size_t len;
  72. {
  74. if (string == NULL) { /* to ease debugging. */
  75. static char hstring[MAXSOCKSHOSTSTRING];
  77. string = hstring;
  78. len = sizeof(hstring);
  79. }
  81. switch (host->atype) {
  82. case SOCKS_ADDR_IPV4:
  83. snprintf(string, len, "%s.%d",
  84. inet_ntoa(host->addr.ipv4), ntohs(host->port));
  85. break;
  87. case SOCKS_ADDR_IPV6:
  88. snprintf(string, len, "%s.%d",
  89. "<IPV6 address not supported>", ntohs(host->port));
  90. break;
  92. case SOCKS_ADDR_DOMAIN:
  93. snprintf(string, len, "%s.%d",
  94. host->addr.domain, ntohs(host->port));
  95. break;
  97. default:
  98. SERRX(host->atype);
  99. }
  101. return string;
  102. }
  104. const char *
  105. command2string(command)
  106. int command;
  107. {
  109. switch (command) {
  110. case SOCKS_BIND:
  111. return SOCKS_BINDs;
  113. case SOCKS_CONNECT:
  114. return SOCKS_CONNECTs;
  116. case SOCKS_UDPASSOCIATE:
  117. return SOCKS_UDPASSOCIATEs;
  119. /* pseudo commands. */
  120. case SOCKS_ACCEPT:
  121. return SOCKS_ACCEPTs;
  123. case SOCKS_BINDREPLY:
  124. return SOCKS_BINDREPLYs;
  126. case SOCKS_UDPREPLY:
  127. return SOCKS_UDPREPLYs;
  129. case SOCKS_DISCONNECT:
  130. return SOCKS_DISCONNECTs;
  132. default:
  133. SERRX(command);
  134. }
  136. /* NOTREACHED */
  137. }
  139. const char *
  140. method2string(method)
  141. int method;
  142. {
  144. switch (method) {
  145. case AUTHMETHOD_NONE:
  146. return AUTHMETHOD_NONEs;
  148. case AUTHMETHOD_GSSAPI:
  149. return AUTHMETHOD_GSSAPIs;
  151. case AUTHMETHOD_UNAME:
  152. return AUTHMETHOD_UNAMEs;
  154. case AUTHMETHOD_NOACCEPT:
  155. return AUTHMETHOD_NOACCEPTs;
  157. case AUTHMETHOD_RFC931:
  158. return AUTHMETHOD_RFC931s;
  160. default:
  161. SERRX(method);
  162. }
  164. /* NOTREACHED */
  165. }
  167. int
  168. string2method(methodname)
  169. const char *methodname;
  170. {
  171. struct {
  172. char *methodname;
  173. int method;
  174. } method[] = {
  175. { AUTHMETHOD_NONEs, AUTHMETHOD_NONE },
  176. { AUTHMETHOD_UNAMEs, AUTHMETHOD_UNAME },
  177. { AUTHMETHOD_RFC931s, AUTHMETHOD_RFC931 }
  178. };
  179. size_t i;
  181. for (i = 0; i < ELEMENTS(method); ++i)
  182. if (strcmp(method[i].methodname, methodname) == 0)
  183. return method[i].method;
  185. return -1;
  186. }
  188. int
  189. sockscode(version, code)
  190. int version;
  191. int code;
  192. {
  194. switch (version) {
  195. case SOCKS_V4:
  196. case SOCKS_V4REPLY_VERSION:
  197. switch (code) {
  198. case SOCKS_SUCCESS:
  199. return SOCKSV4_SUCCESS;
  201. default:
  202. return SOCKSV4_FAIL; /* v4 is not very specific. */
  203. }
  204. /* NOTREACHED */
  206. case SOCKS_V5:
  207. switch (code) {
  208. default:
  209. return code; /* current codes are all V5. */
  210. }
  211. /* NOTREACHED */
  213. case MSPROXY_V2:
  214. switch (code) {
  215. case SOCKS_SUCCESS:
  216. return MSPROXY_SUCCESS;
  218. case SOCKS_FAILURE:
  219. return MSPROXY_FAILURE;
  221. default:
  222. SERRX(code);
  223. }
  224. /* NOTREACHED */
  226. default:
  227. SERRX(version);
  228. }
  230. /* NOTREACHED */
  231. }
  233. int
  234. errno2reply(errnum, version)
  235. int errnum;
  236. int version;
  237. {
  239. switch (errnum) {
  240. case ENETUNREACH:
  241. return sockscode(version, SOCKS_NETUNREACH);
  243. case EHOSTUNREACH:
  244. return sockscode(version, SOCKS_HOSTUNREACH);
  246. case ECONNREFUSED:
  247. return sockscode(version, SOCKS_CONNREFUSED);
  249. case ETIMEDOUT:
  250. return sockscode(version, SOCKS_TTLEXPIRED);
  251. }
  253. return sockscode(version, SOCKS_FAILURE);
  254. }
  257. struct sockaddr *
  258. sockshost2sockaddr(host, addr)
  259. const struct sockshost_t *host;
  260. struct sockaddr *addr;
  261. {
  262. const char *function = "sockshost2sockaddr()";
  264. bzero(addr, sizeof(*addr));
  265. /* LINTED pointer casts may be troublesome */
  266. ((struct sockaddr_in *)addr)->sin_family = AF_INET;
  268. switch (host->atype) {
  269. case SOCKS_ADDR_IPV4:
  270. /* LINTED pointer casts may be troublesome */
  271. ((struct sockaddr_in *)addr)->sin_addr = host->addr.ipv4;
  272. break;
  274. case SOCKS_ADDR_DOMAIN: {
  275. struct hostent *hostent;
  277. if ((hostent = gethostbyname(host->addr.domain)) == NULL
  278. ||   hostent->h_addr_list == NULL) {
  279. /* LINTED pointer casts may be troublesome */
  280. swarnx("%s: gethostbyname(%s): %s",
  281. function, host->addr.domain, hstrerror(h_errno));
  283. /* LINTED pointer casts may be troublesome */
  284. ((struct sockaddr_in *)addr)->sin_addr.s_addr = htonl(INADDR_ANY);
  286. break;
  287. }
  289. /* LINTED pointer casts may be troublesome */
  290. ((struct sockaddr_in *)addr)->sin_addr
  291. = *(struct in_addr *)(*hostent->h_addr_list);
  293. break;
  294. }
  296. default:
  297. SERRX(host->atype);
  298. }
  299. /* LINTED pointer casts may be troublesome */
  300. ((struct sockaddr_in *)addr)->sin_port = host->port;
  302. /* LINTED pointer casts may be troublesome */
  303. return addr;
  304. }
  306. struct sockaddr *
  307. fakesockshost2sockaddr(host, addr)
  308. const struct sockshost_t *host;
  309. struct sockaddr *addr;
  310. {
  311. const char *function = "fakesockshost2sockaddr()";
  313. #if SOCKS_CLIENT /* may be called before normal init, log to right place. */
  314. clientinit();
  315. #endif
  317. slog(LOG_DEBUG, "%s: %s", function, sockshost2string(host, NULL, 0));
  319. bzero(addr, sizeof(*addr));
  320. /* LINTED pointer casts may be troublesome */
  321. ((struct sockaddr_in *)addr)->sin_family = AF_INET;
  323. switch (host->atype) {
  324. case SOCKS_ADDR_DOMAIN:
  325. /* LINTED pointer casts may be troublesome */
  326. if (socks_getfakeip(host->addr.domain,
  327. &((struct sockaddr_in *)addr)->sin_addr)) {
  328. /* LINTED pointer casts may be troublesome */
  329. break;
  330. }
  331. /* else; */ /* FALLTHROUGH */
  333. default:
  334. return sockshost2sockaddr(host, addr);
  335. }
  336. /* LINTED pointer casts may be troublesome */
  337. ((struct sockaddr_in *)addr)->sin_port = host->port;
  339. return addr;
  340. }
  342. struct sockshost_t *
  343. sockaddr2sockshost(addr, host)
  344. const struct sockaddr *addr;
  345. struct sockshost_t *host;
  346. {
  348. switch (addr->sa_family) {
  349. case AF_INET:
  350. host->atype = SOCKS_ADDR_IPV4;
  351. /* LINTED pointer casts may be troublesome */
  352. host->addr.ipv4 = ((const struct sockaddr_in *)addr)->sin_addr;
  353. /* LINTED pointer casts may be troublesome */
  354. host->port = ((const struct sockaddr_in *)addr)->sin_port;
  355. break;
  357. default:
  358. SERRX(addr->sa_family);
  359. }
  361. return host;
  362. }
  364. const char *
  365. operator2string(operator)
  366. enum operator_t operator;
  367. {
  369. switch (operator) {
  370. case none:
  371. return "none";
  373. case eq:
  374. return "eq";
  376. case neq:
  377. return "neq";
  379. case ge:
  380. return "ge";
  382. case le:
  383. return "le";
  385. case gt:
  386. return "gt";
  388. case lt:
  389. return "lt";
  391. case range:
  392. return "range";
  394. default:
  395. SERRX(operator);
  396. }
  398. /* NOTREACHED */
  399. }
  401. enum operator_t
  402. string2operator(string)
  403. const char *string;
  404. {
  406. if (strcmp(string, "eq") == 0 || strcmp(string, "=") == 0)
  407. return eq;
  409. if (strcmp(string, "neq") == 0 || strcmp(string, "!=") == 0)
  410. return neq;
  412. if (strcmp(string, "ge") == 0 || strcmp(string, ">=") == 0)
  413. return ge;
  415. if (strcmp(string, "le") == 0 || strcmp(string, "<=") == 0)
  416. return le;
  418. if (strcmp(string, "gt") == 0 || strcmp(string, ">") == 0)
  419. return gt;
  421. if (strcmp(string, "lt") == 0 || strcmp(string, "<") == 0)
  422. return lt;
  424. /* parser should make sure this never happens. */
  425. SERRX(string);
  427. /* NOTREACHED */
  428. }
  431. const char *
  432. ruleaddress2string(address, string, len)
  433. const struct ruleaddress_t *address;
  434. char *string;
  435. size_t len;
  436. {
  438. switch (address->atype) {
  439. case SOCKS_ADDR_IPV4: {
  440. char *a, *b;
  442. snprintf(string, len, "%s/%s, tcp port: %d, udp port: %d op: %s %d",
  443. strcheck(a = strdup(inet_ntoa(address->addr.ipv4.ip))),
  444. strcheck(b = strdup(inet_ntoa(address->addr.ipv4.mask))),
  445. ntohs(address->port.tcp), ntohs(address->port.udp),
  446. operator2string(address->operator),
  447. ntohs(address->portend));
  448. free(a);
  449. free(b);
  450. break;
  451. }
  453. case SOCKS_ADDR_DOMAIN:
  454. snprintf(string, len, "%s, tcp port: %d, udp port: %d op: %s %d",
  455. address->addr.domain,
  456. ntohs(address->port.tcp), ntohs(address->port.udp),
  457. operator2string(address->operator),
  458. ntohs(address->portend));
  459. break;
  461. default:
  462. SERRX(address->atype);
  463. }
  465. return string;
  466. }
  468. struct sockshost_t *
  469. ruleaddress2sockshost(address, host, protocol)
  470. const struct ruleaddress_t *address;
  471. struct sockshost_t *host;
  472. int protocol;
  473. {
  475. switch (host->atype = address->atype) {
  476. case SOCKS_ADDR_IPV4:
  477. host->addr.ipv4 = address->addr.ipv4.ip;
  478. break;
  480. case SOCKS_ADDR_DOMAIN:
  481. SASSERTX(strlen(address->addr.domain) < sizeof(host->addr.domain));
  482. strcpy(host->addr.domain, address->addr.domain);
  483. break;
  485. default:
  486. SERRX(address->atype);
  487. }
  489. switch (protocol) {
  490. case SOCKS_TCP:
  491. host->port = address->port.tcp;
  492. break;
  494. case SOCKS_UDP:
  495. host->port = address->port.udp;
  496. break;
  498. default:
  499. SERRX(protocol);
  500. }
  502. return host;
  503. }
  505. struct ruleaddress_t *
  506. sockshost2ruleaddress(host, addr)
  507. const struct sockshost_t *host;
  508. struct ruleaddress_t *addr;
  509. {
  511. switch (addr->atype = host->atype) {
  512. case SOCKS_ADDR_IPV4:
  513. addr->addr.ipv4.ip = host->addr.ipv4;
  514. addr->addr.ipv4.mask.s_addr = htonl(0xffffffff);
  515. break;
  517. case SOCKS_ADDR_DOMAIN:
  518. SASSERTX(strlen(host->addr.domain) < sizeof(addr->addr.domain));
  519. strcpy(addr->addr.domain, host->addr.domain);
  520. break;
  522. default:
  523. SERRX(host->atype);
  524. }
  526. addr->port.tcp = host->port;
  527. addr->port.udp = host->port;
  528. addr->portend = host->port;
  530. if (host->port == htons(0))
  531. addr->operator = none;
  532. else
  533. addr->operator = eq;
  535. return addr;
  536. }
  538. struct ruleaddress_t *
  539. sockaddr2ruleaddress(addr, ruleaddr)
  540. const struct sockaddr *addr;
  541. struct ruleaddress_t *ruleaddr;
  542. {
  543. struct sockshost_t host;
  545. sockaddr2sockshost(addr, &host);
  546. sockshost2ruleaddress(&host, ruleaddr);
  548. return ruleaddr;
  549. }
  551. const char *
  552. protocol2string(protocol)
  553. int protocol;
  554. {
  556. switch (protocol) {
  557. case SOCKS_TCP:
  558. return PROTOCOL_TCPs;
  560. case SOCKS_UDP:
  561. return PROTOCOL_UDPs;
  563. default:
  564. SERRX(protocol);
  565. }
  567. /* NOTREACHED */
  568. }
  571. char *
  572. sockaddr2string(address, string, len)
  573. const struct sockaddr *address;
  574. char *string;
  575. size_t len;
  576. {
  578. if (string == NULL) {
  579. static char addrstring[MAXSOCKADDRSTRING];
  581. string = addrstring;
  582. len = sizeof(addrstring);
  583. }
  585. switch (address->sa_family) {
  586. case AF_UNIX: {
  587. /* LINTED pointer casts may be troublesome */
  588. const struct sockaddr_un *addr = (const struct sockaddr_un *)address;
  590. strncpy(string, addr->sun_path, len - 1);
  591. string[len - 1] = NUL;
  592. break;
  593. }
  595. case AF_INET: {
  596. /* LINTED pointer casts may be troublesome */
  597. const struct sockaddr_in *addr = (const struct sockaddr_in *)address;
  599. snprintf(string, len, "%s.%d",
  600. inet_ntoa(addr->sin_addr), ntohs(addr->sin_port));
  601. break;
  602. }
  604. default:
  605. SERRX(address->sa_family);
  606. }
  608. return string;
  609. }
  612. void
  613. #ifdef STDC_HEADERS
  614. serr(int eval, const char *fmt, ...)
  615. #else
  616. serr(eval, fmt, va_alist)
  617. int eval;
  618. const char *fmt;
  619. va_dcl
  620. #endif  /* STDC_HEADERS */
  621. {
  623. if (fmt != NULL) {
  624. va_list ap;
  625. char buf[2048];
  626. size_t bufused;
  628. #ifdef STDC_HEADERS
  629. /* LINTED pointer casts may be troublesome */
  630. va_start(ap, fmt);
  631. #else
  632. va_start(ap);
  633. #endif  /* STDC_HEADERS */
  635. bufused = vsnprintf(buf, sizeof(buf), fmt, ap);
  637. bufused += snprintf(&buf[bufused], sizeof(buf) - bufused,
  638. ": %s (errno = %d)", strerror(errno), errno);
  640. slog(LOG_ERR, buf);
  642. /* LINTED expression has null effect */
  643. va_end(ap);
  644. }
  646. #if SOCKS_SERVER
  647. sockdexit(-eval);
  648. #else
  649. exit(eval);
  650. #endif
  651. }
  653. void
  654. #ifdef STDC_HEADERS
  655. serrx(int eval, const char *fmt, ...)
  656. #else
  657. serrx(eval, fmt, va_alist)
  658.       int eval;
  659.       const char *fmt;
  660.       va_dcl
  661. #endif  /* STDC_HEADERS */
  662. {
  664. if (fmt != NULL) {
  665. va_list ap;
  667. #ifdef STDC_HEADERS
  668. /* LINTED pointer casts may be troublesome */
  669. va_start(ap, fmt);
  670. #else
  671. va_start(ap);
  672. #endif  /* STDC_HEADERS */
  673. vslog(LOG_ERR, fmt, ap);
  675. /* LINTED expression has null effect */
  676. va_end(ap);
  677. }
  679. #if SOCKS_SERVER
  680. sockdexit(-eval);
  681. #else
  682. exit(eval);
  683. #endif
  684. }
  686. void
  687. #ifdef STDC_HEADERS
  688. swarn(const char *fmt, ...)
  689. #else
  690. swarn(fmt, va_alist)
  691. const char *fmt;
  692. va_dcl
  693. #endif  /* STDC_HEADERS */
  694. {
  696. if (fmt != NULL) {
  697. va_list ap;
  698. char buf[2048];
  699. size_t bufused;
  701. #ifdef STDC_HEADERS
  702. /* LINTED pointer casts may be troublesome */
  703. va_start(ap, fmt);
  704. #else
  705. va_start(ap);
  706. #endif  /* STDC_HEADERS */
  708. bufused = vsnprintf(buf, sizeof(buf), fmt, ap);
  710. bufused += snprintf(&buf[bufused], sizeof(buf) - bufused,
  711. ": %s (errno = %d)", strerror(errno), errno);
  713. slog(LOG_ERR, buf);
  715. /* LINTED expression has null effect */
  716. va_end(ap);
  717. }
  718. }
  720. void
  721. #ifdef STDC_HEADERS
  722. swarnx(const char *fmt, ...)
  723. #else
  724. swarnx(fmt, va_alist)
  725. const char *fmt;
  726. va_dcl
  727. #endif  /* STDC_HEADERS */
  728. {
  730. if (fmt != NULL) {
  731. va_list ap;
  733. #ifdef STDC_HEADERS
  734. /* LINTED pointer casts may be troublesome */
  735. va_start(ap, fmt);
  736. #else
  737. va_start(ap);
  738. #endif  /* STDC_HEADERS */
  740. vslog(LOG_ERR, fmt, ap);
  742. /* LINTED expression has null effect */
  743. va_end(ap);
  744. }
  745. }
  747. in_addr_t
  748. socks_addfakeip(host)
  749. const char *host;
  750. {
  751. const char *function = "socks_addfakeip()";
  752. char **tmpmem;
  753. struct in_addr addr;
  755. if (socks_getfakeip(host, &addr) == 1)
  756. return addr.s_addr;
  758. #if FAKEIP_END < FAKEIP_START
  759. error ""FAKEIP_END" can't be smaller than "FAKEIP_START""
  760. #endif
  762. if (ipc >= FAKEIP_END - FAKEIP_START) {
  763. swarnx("%s: fakeip range (%d - %d) exhausted",
  764. function, FAKEIP_START, FAKEIP_END);
  765. return INADDR_NONE;
  766. }
  768. if ((tmpmem = (char **)realloc(ipv, sizeof(*ipv) * (ipc + 1))) == NULL
  769. || (tmpmem[ipc] = (char *)malloc(sizeof(*tmpmem) * (strlen(host) + 1)))
  770. == NULL) {
  771. swarnx("%s: %s", function, NOMEM);
  772. return INADDR_NONE;
  773. }
  774. ipv = tmpmem;
  776. strcpy(ipv[ipc], host);
  778. return htonl(ipc++ + FAKEIP_START);
  779. }
  781. const char *
  782. socks_getfakehost(addr)
  783. in_addr_t addr;
  784. {
  786. if (ntohl(addr) - FAKEIP_START < ipc)
  787. return ipv[ntohl(addr) - FAKEIP_START];
  788. return NULL;
  789. }
  791. int
  792. socks_getfakeip(host, addr)
  793. const char *host;
  794. struct in_addr *addr;
  795. {
  796. unsigned int i;
  798. for (i = 0; i < ipc; ++i)
  799. if (strcasecmp(host, ipv[i]) == 0) {
  800. addr->s_addr = htonl(i + FAKEIP_START);
  801. return 1;
  802. }
  804. return 0;
  805. }
  807. struct sockshost_t *
  808. fakesockaddr2sockshost(addr, host)
  809. const struct sockaddr *addr;
  810. struct sockshost_t *host;
  811. {
  812. const char *function = "fakesockaddr2sockshost()";
  814. #if SOCKS_CLIENT /* may be called before normal init, log to right place. */
  815. clientinit();
  816. #endif
  818. /* LINTED pointer casts may be troublesome */
  819. slog(LOG_DEBUG, "%s: %s -> %s",
  820. function, sockaddr2string(addr, NULL, 0),
  821. socks_getfakehost(((const struct sockaddr_in *)addr)->sin_addr.s_addr)
  822. == NULL ? sockaddr2string(addr, NULL, 0)
  823. : socks_getfakehost(((const struct sockaddr_in *)addr)->sin_addr.s_addr));
  825. /* LINTED pointer casts may be troublesome */
  826. if (socks_getfakehost(((const struct sockaddr_in *)addr)->sin_addr.s_addr)
  827. != NULL) {
  828. const char *ipname
  829. /* LINTED pointer casts may be troublesome */
  830. = socks_getfakehost(((const struct sockaddr_in *)addr)->sin_addr.s_addr);
  832. SASSERTX(ipname != NULL);
  834. host->atype = SOCKS_ADDR_DOMAIN;
  835. SASSERTX(strlen(ipname) < sizeof(host->addr.domain));
  836. strcpy(host->addr.domain, ipname);
  837. /* LINTED pointer casts may be troublesome */
  838. host->port = ((const struct sockaddr_in *)addr)->sin_port;
  839. }
  840. else
  841. sockaddr2sockshost(addr, host);
  843. return host;
  844. }
  846. const char *
  847. socks_packet2string(packet, type)
  848.   const void *packet;
  849.   int type;
  850. {
  851. static char buf[1024];
  852. char hstring[MAXSOCKSHOSTSTRING];
  853. unsigned char version;
  854. const struct request_t *request = NULL;
  855. const struct response_t *response = NULL;
  857. switch (type) {
  858. case SOCKS_REQUEST:
  859. request = (const struct request_t *)packet;
  860. version = request->version;
  861. break;
  863. case SOCKS_RESPONSE:
  864. response = (const struct response_t *)packet;
  865. version = response->version;
  866. break;
  868.   default:
  869.  SERRX(type);
  870.   }
  872. switch (version) {
  873. case SOCKS_V4:
  874. case SOCKS_V4REPLY_VERSION:
  875. switch (type) {
  876. case SOCKS_REQUEST:
  877. snprintf(buf, sizeof(buf),
  878. "(V4) VN: %d CD: %d address: %s",
  879. request->version, request->command,
  880. sockshost2string(&request->host, hstring, sizeof(hstring)));
  881. break;
  883. case SOCKS_RESPONSE:
  884. snprintf(buf, sizeof(buf), "(V4) VN: %d CD: %d address: %s",
  885. response->version, response->reply,
  886. sockshost2string(&response->host, hstring, sizeof(hstring)));
  887. break;
  888. }
  889. break;
  891. case SOCKS_V5:
  892. switch (type) {
  893. case SOCKS_REQUEST:
  894. snprintf(buf, sizeof(buf),
  895. "VER: %d CMD: %d FLAG: %d ATYP: %d address: %s",
  896. request->version, request->command, request->flag,
  897. request->host.atype,
  898. sockshost2string(&request->host, hstring, sizeof(hstring)));
  899. break;
  901. case SOCKS_RESPONSE:
  902. snprintf(buf, sizeof(buf),
  903. "VER: %d REP: %d FLAG: %d ATYP: %d address: %s",
  904. response->version, response->reply, response->flag,
  905. response->host.atype,
  906. sockshost2string(&response->host, hstring, sizeof(hstring)));
  907. break;
  908. }
  909. break;
  911. default:
  912. SERRX(version);
  913.   }
  915. return buf;
  916. }
  918. int
  919. socks_logmatch(d, log)
  920. unsigned int d;
  921. const struct logtype_t *log;
  922. {
  923. int i;
  925. for (i = 0; i < log->fpc; ++i)
  926. if (d == (unsigned int)log->fplockv[i]
  927. ||  d == (unsigned int)fileno(log->fpv[i]))
  928. return 1;
  929. return 0;
  930. }
  932. int
  933. sockaddrareeq(a, b)
  934. const struct sockaddr *a;
  935. const struct sockaddr *b;
  936. {
  938. if (a->sa_family != b->sa_family)
  939. return 0;
  941. switch (a->sa_family) {
  942. case AF_INET: {
  943. /* LINTED pointer casts may be troublesome */
  944. const struct sockaddr_in *in_a = (const struct sockaddr_in *)a;
  945. /* LINTED pointer casts may be troublesome */
  946. const struct sockaddr_in *in_b = (const struct sockaddr_in *)b;
  948. if (in_a->sin_addr.s_addr != in_b->sin_addr.s_addr
  949. ||  in_a->sin_port   != in_b->sin_port)
  950. return 0;
  951. return 1;
  952. }
  954. default:
  955. SERRX(a->sa_family);
  956. }
  958. /* NOTREACHED */
  959. }
  961. int
  962. sockshostareeq(a, b)
  963. const struct sockshost_t *a;
  964. const struct sockshost_t *b;
  965. {
  967. if (a->atype != b->atype)
  968. return 0;
  970. switch (a->atype) {
  971. case SOCKS_ADDR_IPV4:
  972. if (memcmp(&a->addr.ipv4, &b->addr.ipv4, sizeof(a->addr.ipv4)) != 0)
  973. return 0;
  974. break;
  976. case SOCKS_ADDR_IPV6:
  977. if (memcmp(a->addr.ipv6, b->addr.ipv6, sizeof(a->addr.ipv6)) != 0)
  978. return 0;
  979. break;
  981. case SOCKS_ADDR_DOMAIN:
  982. if (strcmp(a->addr.domain, b->addr.domain) != 0)
  983. return 0;
  984. break;
  986. default:
  987. SERRX(a->atype);
  988. }
  990. if (a->port != b->port)
  991. return 0;
  992. return 1;
  993. }
  995. int
  996. fdsetop(nfds, op, a, b, result)
  997. int nfds;
  998. int op;
  999. const fd_set *a;
  1000. const fd_set *b;
  1001. fd_set *result;
  1002. {
  1003. int i, bits;
  1005. FD_ZERO(result);
  1006. bits = -1;
  1008. switch (op) {
  1009. case '&':
  1010. for (i = 0; i < nfds; ++i)
  1011. if (FD_ISSET(i, a) && FD_ISSET(i, b)) {
  1012. FD_SET(i, result);
  1013. bits = MAX(i, bits);
  1014. }
  1015. break;
  1017. case '^':
  1018. for (i = 0; i < nfds; ++i)
  1019. if (FD_ISSET(i, a) != FD_ISSET(i, b)) {
  1020. FD_SET(i, result);
  1021. bits = MAX(i, bits);
  1022. }
  1023. break;
  1025. default:
  1026. SERRX(op);
  1027. }
  1029. return bits;
  1030. }
  1032. int
  1033. methodisset(method, methodv, methodc)
  1034. int method;
  1035. const int *methodv;
  1036. size_t methodc;
  1037. {
  1038. size_t i;
  1040. for (i = 0; i < methodc; ++i)
  1041. if (methodv[i] == method)
  1042. return 1;
  1043. return 0;
  1044. }
  1046. int
  1047. socketoptdup(s)
  1048. int s;
  1049. {
  1050. const char *function = "socketoptdup()";
  1051. unsigned int i;
  1052. int flags, new_s;
  1053. socklen_t len;
  1054. union {
  1055. int int_val;
  1056. struct linger linger_val;
  1057. struct timeval timeval_val;
  1058. struct in_addr in_addr_val;
  1059. u_char u_char_val;
  1060. struct sockaddr sockaddr_val;
  1061. struct ipoption ipoption;
  1062. } val;
  1063. int levelname[][2] = {
  1065. /* socket options */
  1067. #ifdef SO_BROADCAST
  1068. { SOL_SOCKET, SO_BROADCAST },
  1069. #endif
  1071. #ifdef SO_DEBUG
  1072. { SOL_SOCKET, SO_DEBUG },
  1073. #endif
  1075. #ifdef SO_DONTROUTE
  1076. { SOL_SOCKET, SO_DONTROUTE },
  1077. #endif
  1079. #ifdef SO_ERROR
  1080. { SOL_SOCKET, SO_ERROR },
  1081. #endif
  1083. #ifdef SO_KEEPALIVE
  1084. { SOL_SOCKET, SO_KEEPALIVE },
  1085. #endif
  1087. #ifdef SO_LINGER
  1088. { SOL_SOCKET, SO_LINGER },
  1089. #endif
  1091. #ifdef SO_OOBINLINE
  1092. { SOL_SOCKET, SO_OOBINLINE },
  1093. #endif
  1095. #ifdef SO_RCVBUF
  1096. { SOL_SOCKET, SO_RCVBUF },
  1097. #endif
  1099. #ifdef SO_SNDBUF
  1100. { SOL_SOCKET, SO_SNDBUF },
  1101. #endif
  1103. #ifdef SO_RCVLOWAT
  1104. { SOL_SOCKET, SO_RCVLOWAT },
  1105. #endif
  1107. #ifdef SO_SNDLOWAT
  1108. { SOL_SOCKET, SO_SNDLOWAT },
  1109. #endif
  1111. #ifdef SO_RCVTIMEO
  1112. { SOL_SOCKET, SO_RCVTIMEO },
  1113. #endif
  1115. #ifdef SO_SNDTIMEO
  1116. { SOL_SOCKET, SO_SNDTIMEO },
  1117. #endif
  1119. #ifdef SO_REUSEADDR
  1120. { SOL_SOCKET, SO_REUSEADDR },
  1121. #endif
  1123. #ifdef SO_REUSEPORT
  1124. { SOL_SOCKET, SO_REUSEPORT },
  1125. #endif
  1127. #ifdef SO_USELOOPBACK
  1128. { SOL_SOCKET, SO_USELOOPBACK },
  1129. #endif
  1131. /* IP options */
  1133. #ifdef IP_HDRINCL
  1134. { IPPROTO_IP, IP_HDRINCL },
  1135. #endif
  1137. #ifdef IP_OPTIONS
  1138. { IPPROTO_IP, IP_OPTIONS },
  1139. #endif
  1141. #ifdef IP_RECVDSTADDR
  1142. { IPPROTO_IP, IP_RECVDSTADDR },
  1143. #endif
  1145. #ifdef IP_RECVIF
  1146. { IPPROTO_IP, IP_RECVIF },
  1147. #endif
  1149. #ifdef IP_TOS
  1150. { IPPROTO_IP, IP_TOS },
  1151. #endif
  1153. #ifdef IP_TTL
  1154. { IPPROTO_IP, IP_TTL },
  1155. #endif
  1157. #ifdef IP_MULTICAST_IF
  1158. { IPPROTO_IP, IP_MULTICAST_IF },
  1159. #endif
  1161. #ifdef IP_MULTICAST_TTL
  1162. { IPPROTO_IP, IP_MULTICAST_TTL },
  1163. #endif
  1165. #ifdef IP_MULTICAST_LOOP
  1166. { IPPROTO_IP, IP_MULTICAST_LOOP },
  1167. #endif
  1169. /* TCP options */
  1171. #ifdef TCP_KEEPALIVE
  1172. { IPPROTO_TCP, TCP_KEEPALIVE },
  1173. #endif
  1175. #ifdef TCP_MAXRT
  1176. { IPPROTO_TCP, TCP_MAXRT },
  1177. #endif
  1179. #ifdef TCP_MAXSEG
  1180. { IPPROTO_TCP, TCP_MAXSEG },
  1181. #endif
  1183. #ifdef TCP_NODELAY
  1184. { IPPROTO_TCP, TCP_NODELAY },
  1185. #endif
  1187. #ifdef TCP_STDURG
  1188. { IPPROTO_TCP, TCP_STDURG }
  1189. #endif
  1191. };
  1193. len = sizeof(val);
  1194. if (getsockopt(s, SOL_SOCKET, SO_TYPE, &val, &len) == -1) {
  1195. swarn("%s: getsockopt(SO_TYPE)", function);
  1196. return -1;
  1197. }
  1199. if ((new_s = socket(AF_INET, val.int_val, 0)) == -1) {
  1200. swarn("%s: socket(AF_INET, %d)", function, val.int_val);
  1201. return -1;
  1202. }
  1204. for (i = 0; i < ELEMENTS(levelname); ++i) {
  1205. len = sizeof(val);
  1206. if (getsockopt(s, levelname[i][0], levelname[i][1], &val, &len) == -1) {
  1207. if (config.option.debug)
  1208. swarn("%s: getsockopt(%d, %d)",
  1209. function, levelname[i][0], levelname[i][1]);
  1210. continue;
  1211. }
  1213. if (setsockopt(new_s, levelname[i][0], levelname[i][1], &val, len) == -1)
  1214. swarn("%s: setsockopt(%d, %d)",
  1215. function, levelname[i][0], levelname[i][1]);
  1216. }
  1218. if ((flags = fcntl(s, F_GETFL, 0)) == -1
  1219. ||  fcntl(new_s, F_SETFL, flags) == -1)
  1220. swarn("%s: fcntl(F_GETFL/F_SETFL)", function);
  1222. #if SOCKS_SERVER && HAVE_LIBWRAP
  1223. if ((s = fcntl(new_s, F_GETFD, 0)) == -1
  1224. || fcntl(new_s, F_SETFD, s | FD_CLOEXEC) == -1)
  1225. swarn("%s: fcntl(F_GETFD/F_SETFD)", function);
  1226. #endif
  1228. return new_s;
  1229. }
  1231. char *
  1232. str2vis(string, len)
  1233. const char *string;
  1234. size_t len;
  1235. {
  1236. const int visflag = VIS_TAB | VIS_NL | VIS_CSTYLE | VIS_OCTAL;
  1237. char *visstring;
  1239. /* see vis(3) for "* 4" */
  1240. if ((visstring = (char *)malloc((sizeof(*visstring) * len * 4)
  1241. + sizeof(char))) != NULL)
  1242. strvisx(visstring, string, len, visflag);
  1243. return visstring;
  1244. }
  1246. int
  1247. socks_mklock(template)
  1248. const char *template;
  1249. {
  1250. const char *function = "socks_mklock()";
  1251. char *prefix, *newtemplate;
  1252. int s;
  1253. size_t len;
  1254. #if SOCKS_SERVER && HAVE_LIBWRAP
  1255. int flag;
  1256. #endif
  1258. if ((prefix = getenv("TMPDIR")) != NULL)
  1259. if (*prefix == NUL)
  1260. prefix = NULL;
  1262. if (prefix == NULL)
  1263. prefix = "/tmp";
  1265. len = strlen(prefix) + strlen("/") + strlen(template) + 1;
  1266. if ((newtemplate = (char *)malloc(sizeof(*newtemplate) * len)) == NULL)
  1267. return -1;
  1269. snprintf(newtemplate, len, "%s/%s", prefix, template);
  1271. if ((s = mkstemp(newtemplate)) == -1) {
  1272. swarn("%s: mkstemp(%s)", function, newtemplate);
  1273. free(newtemplate);
  1274. return -1;
  1275. }
  1277. if (unlink(newtemplate) == -1) {
  1278. swarn("%s: unlink(%s)", function, newtemplate);
  1279. free(newtemplate);
  1280. return -1;
  1281. }
  1283. free(newtemplate);
  1285. #if SOCKS_SERVER && HAVE_LIBWRAP
  1286. if ((flag = fcntl(s, F_GETFD, 0)) == -1
  1287. || fcntl(s, F_SETFD, flag | FD_CLOEXEC) == -1)
  1288. swarn("%s: fcntl(F_GETFD/F_SETFD)", function);
  1289. #endif
  1291. return s;
  1292. }
  1295. int
  1296. socks_lock(descriptor, type, timeout)
  1297. int descriptor;
  1298. int type;
  1299. int timeout;
  1300. {
  1301. /* const char *function = "socks_lock()"; */
  1302. struct flock lock;
  1303. int rc;
  1305. lock.l_type = (short)type;
  1306. lock.l_start = 0;
  1307. lock.l_whence = SEEK_SET;
  1308. lock.l_len = 0;
  1310. SASSERTX(timeout <= 0);
  1312. #if 0 /* missing some bits here to handle racecondition. */
  1313. if (timeout > 0) {
  1314. struct sigaction sigact;
  1316. #if SOCKS_CLIENT
  1317. if (sigaction(SIGALRM, NULL, &sigact) != 0)
  1318. return -1;
  1320. /* if handler already set for signal, don't override. */
  1321. if (sigact.sa_handler == SIG_DFL || sigact.sa_handler == SIG_IGN) {
  1322. #else /* !SOCKS_CLIENT */
  1323. /* CONSTCOND */
  1324. if (1) {
  1325. #endif /* !SOCKS_CLIENT */
  1327. sigemptyset(&sigact.sa_mask);
  1328. sigact.sa_flags = 0;
  1329. sigact.sa_handler = SIG_IGN;
  1331. if (sigaction(SIGALRM, &sigact, NULL) != 0)
  1332. return -1;
  1333. }
  1335. alarm((unsigned int)timeout);
  1336. }
  1337. #endif
  1339. do
  1340. rc = fcntl(descriptor, timeout ? F_SETLKW : F_SETLK, &lock);
  1341. while (rc == -1 && timeout == -1 && errno == EINTR);
  1343. if (rc == -1)
  1344. switch (errno) {
  1345. case EACCES:
  1346. case EAGAIN:
  1347. case EINTR:
  1348. break;
  1350. case ENOLCK:
  1351. sleep(1);
  1352. return socks_lock(descriptor, type, timeout);
  1354. default:
  1355. SERR(descriptor);
  1356. }
  1358. #if 0
  1359. if (timeout > 0)
  1360. alarm(0);
  1361. #endif
  1363. if (rc != 0 && timeout == -1)
  1364. abort();
  1366. return rc == -1 ? rc : 0;
  1367. }
  1369. void
  1370. socks_unlock(d)
  1371. int d;
  1372. {
  1374. socks_lock(d, F_UNLCK, -1);
  1375. }
  1378. int
  1379. socks_socketisbound(s)
  1380. int s;
  1381. {
  1382. struct sockaddr_in addr;
  1383. socklen_t len;
  1385. len = sizeof(addr);
  1386. /* LINTED pointer casts may be troublesome */
  1387. if (getsockname(s, (struct sockaddr *)&addr, &len) != 0)
  1388. return -1;
  1390. return ADDRISBOUND(addr);
  1391. }
  1393. int
  1394. freedescriptors(message)
  1395. const char *message;
  1396. {
  1397. const int errno_s = errno;
  1398. int i, freed, max;
  1400. /* LINTED expression has null effect */
  1401. for (freed = 0, i = 0, max = getdtablesize(); i < max; ++i)
  1402. if (!fdisopen(i))
  1403. ++freed;
  1405. if (message != NULL)
  1406. slog(LOG_DEBUG, "freedescriptors(%s): %d/%d", message, freed, max);
  1408. errno = errno_s;
  1410. return freed;
  1411. }
  1413. int
  1414. fdisopen(fd)
  1415. int fd;
  1416. {
  1417. if (fcntl(fd, F_GETFD, 0) == 0)
  1418. return 1;
  1419. return 0;
  1420. }
  1422. void
  1423. closev(array, count)
  1424. int *array;
  1425. int count;
  1426. {
  1428. for (--count; count >= 0; --count)
  1429. if (array[count] >= 0)
  1430. if (close(array[count]) != 0)
  1431. SERR(-1);
  1432. }