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

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

代理服务器

开发平台：

Unix_Linux

common.h：源码内容
  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. /* $Id: common.h,v 1.218 1999/12/22 09:29:19 karls Exp $ */
  46. #ifndef _COMMON_H_
  47. #define _COMMON_H_
  48. #endif
  50. /* XXX ifdef, not if, defined on command line */
  51. #ifdef HAVE_CONFIG_H
  52. #include "autoconf.h"
  53. #endif  /* HAVE_CONFIG_H */
  55. #include <sys/types.h>
  56. #include <sys/time.h>
  57. #if HAVE_SYS_FILE_H
  58. #include <sys/file.h>
  59. #endif  /* HAVE_SYS_FILE_H */
  60. #include <sys/resource.h>
  61. #include <sys/ioctl.h>
  62. #include <sys/ipc.h>
  63. #include <sys/sem.h>
  64. /* XXX This is a hack. Avoid transparent sockaddr union used in linux
  65.    to avoid the use of the union in the code. Mainly used in
  66.    interposition.c*/
  67. #ifdef WE_DONT_WANT_NO_SOCKADDR_ARG_UNION
  68. #ifdef __GNUC__
  69. #define __HAD_GNUC __GNUC__
  70. #undef __GNUC__
  71. #endif  /* __GNUC__ */
  72. #endif  /* WE_DONT_WANT_NO_SOCKADDR_ARG_UNION */
  73. #include <sys/socket.h>
  74. #ifdef __HAD_GNUC
  75. #define __GNUC__ __HAD_GNUC
  76. #endif  /* __HAD_GNUC */
  77. #if NEED_SYS_SOCKIO_H
  78. #include <sys/sockio.h>
  79. #endif /* NEED_SYS_SOCKIO_H */
  80. #include <sys/mman.h>
  81. #include <sys/un.h>
  82. #include <sys/stat.h>
  83. #include <sys/uio.h>
  84. #include <sys/wait.h>
  85. #include <netinet/in.h>
  86. #if HAVE_NETINET_IP_H
  87. #include <netinet/ip.h>
  88. #endif  /* HAVE_NETINET_IP_H */
  89. #if HAVE_NETINET_IP_VAR_H
  90. #include <netinet/ip_var.h>
  91. #endif  /* HAVE_NETINET_IP_VAR_H */
  92. #include <arpa/inet.h>
  93. #include <arpa/nameser.h>
  95. #include <assert.h>
  96. #if HAVE_CRYPT_H
  97. #include <crypt.h>
  98. #endif  /* HAVE_CRYPT_H */
  99. #include <ctype.h>
  100. #ifdef SOCKSLIBRARY_DYNAMIC
  101. #include <dlfcn.h>
  102. #endif  /* SOCKSLIBRARY_DYNAMIC */
  103. #include <errno.h>
  104. #include <fcntl.h>
  105. #if HAVE_LIMITS_H
  106. #include <limits.h>
  107. #endif  /* HAVE_LIMITS_H */
  108. #include <netdb.h>
  109. #include <pwd.h>
  110. #include <setjmp.h>
  111. #include <signal.h>
  112. #ifdef STDC_HEADERS
  113. #include <stdarg.h>
  114. #else
  115. #include <varargs.h>
  116. #endif  /* STDC_HEADERS */
  117. #include <stdio.h>
  118. #include <stdlib.h>
  119. #if HAVE_STRINGS_H
  120. #include <strings.h>
  121. #endif  /* HAVE_STRINGS_H */
  122. #if STDC_HEADERS
  123. #include <string.h>
  124. #endif  /* STDC_HEADERS */
  125. #include <syslog.h>
  126. #if HAVE_LIBWRAP && HAVE_TCPD_H
  127. #include <tcpd.h>
  128. #endif  /* HAVE_LIBWRAP && HAVE_TCPD_H */
  129. #include <time.h>
  130. #if HAVE_UNISTD_H
  131. #ifdef HAVE_DEC_PROTO
  132. #undef  _XOPEN_SOURCE_EXTENDED
  133. #endif  /* HAVE_DEC_PROTO */
  134. #include <unistd.h>
  135. #ifdef HAVE_DEC_PROTO
  136. #define _XOPEN_SOURCE_EXTENDED
  137. #endif /* HAVE_DEC_PROTO */
  138. #endif  /* HAVE_UNISTD_H */
  139. #include <resolv.h>
  141. #include "yacconfig.h"
  143. #ifdef lint
  144. extern const int lintnoloop_common_h;
  145. #else
  146. #define lintnoloop_common_h 0
  147. #endif
  149. #include "config.h"
  151. #define SOCKS_TRYHARDER 0 /* XXX BUGS */ /* XXX should be configure option. */
  153. #ifndef RLIMIT_OFILE
  154. #define RLIMIT_OFILE RLIMIT_NOFILE
  155. #endif /* !RLIMIT_OFILE */
  158. #if NEED_GETSOCKOPT_CAST
  159. #define getsockopt(a,b,c,d,e) getsockopt((a),(b),(c),(char *)(d),(e))
  160. #define setsockopt(a,b,c,d,e) setsockopt((a),(b),(c),(char *)(d),(e))
  161. #endif  /* NEED_GETSOCKOPT_CAST */
  163. #if !HAVE_BZERO
  164. #define bzero(b, len) memset(b, 0, len)
  165. #endif  /* !HAVE_BZERO */
  167. #if !HAVE_SIG_ATOMIC_T
  168. typedef int sig_atomic_t;
  169. #endif  /* !HAVE_SIG_ATOMIC_T */
  171. #ifdef DIAGNOSTIC
  172. #undef DIAGNOSTIC
  173. #define DIAGNOSTIC 1
  174. #else
  175. #define DIAGNOSTIC 0
  176. #endif
  178. #ifdef DEBUG
  179. #undef DEBUG
  180. #define DEBUG 1
  181. #else
  182. #define DEBUG 0
  183. #endif
  185. #if DEBUG
  186. #if !DIAGNOSTIC
  187. #undef DIAGNOSTIC
  188. #define DIAGNOSTIC 1
  189. #endif  /* !DIAGNOSTIC */
  191. /*
  192.  * solaris 2.5.1 and it's stream stuff is broken and puts the processes
  193.  * into never-never land forever on half the sendmsg() calls if they
  194.  * involve ancillary data.  (it seems to deadlock the processes.)
  195.  */
  197. #ifndef HAVE_SENDMSG_DEADLOCK
  198. #define HAVE_SENDMSG_DEADLOCK 1
  199. #endif
  201. #ifndef HAVE_ACCEPTLOCK
  202. #define HAVE_ACCEPTLOCK 1
  203. #endif
  205. #endif  /* DEBUG */
  208. /* __P and __BEGIN_DECLS definitions taken from libtool manual */
  209. #undef __BEGIN_DECLS
  210. #undef __END_DECLS
  211. #ifdef __cplusplus
  212. # define __BEGIN_DECLS extern "C" {
  213. # define __END_DECLS }
  214. #else
  215. # define __BEGIN_DECLS /* empty */
  216. # define __END_DECLS /* empty */
  217. #endif
  219. #undef __P
  220. #if defined (__STDC__) || defined (_AIX) 
  221. || (defined (__mips) && defined (_SYSTYPE_SVR4)) 
  222. || defined(WIN32) || defined(__cplusplus)
  223. # define __P(protos) protos
  224. #else
  225. # define __P(protos) ()
  226. #endif
  228. #if SIZEOF_CHAR == 1
  229.  typedef unsigned char ubits_8;
  230.  typedef          char sbits_8;
  231. #else
  232. error "no known 8 bits wide datatype"
  233. #endif
  235. #if SIZEOF_SHORT == 2
  236.  typedef unsigned short ubits_16;
  237.  typedef          short sbits_16;
  238. #else
  239. # if SIZEOF_INT == 2
  240.   typedef unsigned int ubits_16;
  241.   typedef          int sbits_16;
  242. # else
  243. error "no known 16 bits wide datatype"
  244. # endif
  245. #endif
  248. #if SIZEOF_INT == 4
  249.  typedef unsigned int ubits_32;
  250.  typedef          int sbits_32;
  251. #else
  252. # if SIZEOF_SHORT == 4
  253.    typedef unsigned short ubits_32;
  254.    typedef          short sbits_32;
  255. # else
  256. #  if SIZEOF_LONG == 4
  257.     typedef unsigned long ubits_32;
  258.     typedef          long sbits_32;
  259. #  else
  260. error "no known 32 bits wide datatype"
  261. #  endif /* SIZEOF_LONG == 4 */
  262. # endif /* SIZEOF_SHORT == 4 */
  263. #endif /* SIZEOF_INT == 4 */
  265. #ifndef INADDR_NONE
  266. # define INADDR_NONE (ubits_32) 0xffffffff
  267. #endif  /* !INADDR_NONE */
  269. #ifndef MAX
  270. # define MAX(a,b) ((a) > (b) ? (a) : (b))
  271. #endif /* !MAX */
  273. #ifndef MIN
  274. # define MIN(a,b) ((a) < (b) ? (a) : (b))
  275. #endif /* !MIN */
  277. #if NEED_EXIT_FAILURE
  278. /* XXX assumes EXIT_SUCCESS is undefined too */
  279. #define EXIT_SUCCESS 0
  280. #define EXIT_FAILURE 1
  281. #endif /* NEED_EXIT_FAILURE */
  283. #if NEED_SA_RESTART
  284. #define SA_RESTART SV_INTERRUPT
  285. #endif  /* NEED_SA_RESTART */
  287. #if NEED_AF_LOCAL
  288. #define AF_LOCAL AF_UNIX
  289. #endif  /* NEED_AF_LOCAL */
  291. #if HAVE_NOMALLOC_REALLOC
  292. #define realloc(p,s) (((p) == NULL) ? (malloc(s)) : (realloc((p),(s))))
  293. #endif  /* HAVE_NOMALLOC_REALLOC */
  295. #if HAVE_NONULL_FREE
  296. #define free(p) (((p) == NULL) ? ((void)(p)) : (free(p)))
  297. #endif
  299. /* __CONCAT macro from anoncvs */
  300. #ifndef __CONCAT
  301. #if defined(__STDC__) || defined(__cplusplus)
  302. #define __CONCAT(x,y)    x ## y
  303. #else
  304. #define __CONCAT(x,y)    x/**/y
  305. #endif
  306. #endif
  308. #if !HAVE_STRUCT_IPOPTS
  309. #define MAX_IPOPTLEN 40
  310. struct ipoption {
  311. struct in_addr ipopt_dst;
  312. sbits_8 ipopt_list[MAX_IPOPTLEN];
  313. };
  314. #endif  /* !HAVE_STRUCT_IPOPTS */
  316. /* global variables needed by everyone. */
  317. extern struct config_t config;
  318. extern char *__progname;
  320. #if !HAVE_H_ERRNO
  321. extern int h_errno;
  322. #endif  /* !HAVE_H_ERRNO */
  324. /*
  325.  * defines
  326. */
  329. /*
  330.  * redefine system limits to match that of socks protocol.
  331.  * No need for these to be bigger than protocol allows, but they
  332.  * _must_ be atleast as big as protocol allows.
  333.  */
  335. #ifdef MAXHOSTNAMELEN
  336. #undef MAXHOSTNAMELEN
  337. #endif
  338. #define MAXHOSTNAMELEN (255 + 1) /* socks5: 255, +1 for len. */
  340. #ifdef MAXNAMELEN
  341. #undef MAXNAMELEN
  342. #endif
  343. #define MAXNAMELEN (255 + 1) /* socks5: 255, +1 for len. */
  345. #ifdef MAXPWLEN
  346. #undef MAXPWLEN
  347. #endif
  348. #define MAXPWLEN (255 + 1) /* socks5: 255, +1 for len. */
  351. /* "255." "255." "255." "255" "." "65535" + NUL */
  352. #define MAXSOCKADDRSTRING  (4   +   4   + 4   +  3  + 1 +    5   + 1)
  354. /*    "." + "65535" + NUL */
  355. #define MAXSOCKSHOSTSTRING (MAXHOSTNAMELEN + 1  +    5)
  357. #define MAXRULEADDRSTRING  (MAXSOCKSHOSTSTRING * 2)
  359. #ifndef NUL
  360. #define NUL ''
  361. #endif
  363. /*
  364.  * We don't care whether it's called O_NONBLOCK, FNDELAY or whatever.
  365.  * We just want to know whether the flags set give blocking or nonblocking
  366.  * semantics.
  367.  */
  368. #ifndef FNDELAY
  369. #define NONBLOCKING (O_NONBLOCK | O_NDELAY)
  370. #else
  371. #define NONBLOCKING (O_NONBLOCK | FNDELAY | O_NDELAY)
  372. #endif
  374. #define CONFIGTYPE_SERVER 1
  375. #define CONFIGTYPE_CLIENT 2
  377. #define PROTOCOL_TCPs "tcp"
  378. #define PROTOCOL_UDPs "udp"
  379. #define PROTOCOL_UNKNOWNs "unknown"
  381. #define RESOLVEPROTOCOL_UDP 0
  382. #define RESOLVEPROTOCOL_TCP 1
  383. #define RESOLVEPROTOCOL_FAKE 2
  385. #define LOGTYPE_SYSLOG 0x1
  386. #define LOGTYPE_FILE 0x2
  388. #define NOMEM "<memory exhausted>"
  391. /*
  392.  * macros
  393. */
  396. #define close(n) closen(n)
  398. #define PORTISRESERVED(port)
  399. (ntohs((port)) != 0 && ntohs((port)) < IPPORT_RESERVED)
  401. #define ADDRISBOUND(addr) 
  402. ((((struct sockaddr_in *)(&addr))->sin_addr.s_addr != htonl(INADDR_ANY)) 
  403. || (((struct sockaddr_in *)(&addr))->sin_port != htons(0)))
  405. #define ELEMENTS(array) (sizeof(array) / sizeof(array[0]))
  407. #if UCHAR_MAX > 0xff
  408. #define OCTETIFY(a) ((a) = ((a) & 0xff))
  409. #else
  410. #define OCTETIFY(a) ((a) = (a))
  411. #endif
  412. /*
  413.  * Note that it's the argument that will be truncated, not just the
  414.  * returnvalue.
  415.  */
  418. /*
  419.  * macros to manipulate ancillary data depending on if were on sysv or bsd.
  420.  */
  422. /* allocate memory for data.  "size" is the amount of memory to allocate. */
  423. #if HAVE_CMSGHDR
  424. #define CMSG_AALLOC(size) 
  425. union { 
  426. char cmsgmem[sizeof(struct cmsghdr) + (size)]; 
  427. struct cmsghdr align; 
  428. } cmsgmem; 
  429. struct cmsghdr *cmsg = &cmsgmem.align
  430. #else /* !HAVE_CMSGHDR */
  431. #define CMSG_AALLOC(size) 
  432. char cmsgmem[(size)]
  433. #endif /* !HAVE_CMSGHDR */
  436. /*
  437.  * add a object to data.  "object" is the object to add to data at
  438.  * offset "offset".
  439.  */
  440. #if HAVE_CMSGHDR
  441. #define CMSG_ADDOBJECT(object, offset) 
  442. do 
  443. memcpy(CMSG_DATA(cmsg) + (offset), &(object), sizeof(object)); 
  444. while (lintnoloop_common_h)
  445. #else /* !HAVE_CMSGHDR */
  446. #define CMSG_ADDOBJECT(object, offset) 
  447. do 
  448. memcpy(cmsgmem + (offset), &(object), sizeof((object))); 
  449. while (lintnoloop_common_h)
  450. #endif /* !HAVE_CMSGHDR */
  453. /*
  454.  * get a object from data.  "object" is the object to get from data at
  455.  * offset "offset".
  456.  */
  457. #if HAVE_CMSGHDR
  458. #define CMSG_GETOBJECT(object, offset) 
  459. do 
  460. memcpy(&(object), CMSG_DATA(cmsg) + (offset), sizeof((object))); 
  461. while (lintnoloop_common_h)
  462. #else /* !HAVE_CMSGHDR */
  463. #define CMSG_GETOBJECT(object, offset) 
  464. do 
  465. memcpy(&(object), cmsgmem + (offset), sizeof((object))); 
  466. while (lintnoloop_common_h)
  467. #endif /* !HAVE_CMSGHDR */
  471. /* set cmsg for sending */
  472. #if HAVE_CMSGHDR
  473. #define CMSG_SETHDR_SEND(size) 
  474. do { 
  475. cmsg->cmsg_level = SOL_SOCKET; 
  476. cmsg->cmsg_type = SCM_RIGHTS; 
  477. cmsg->cmsg_len = sizeof(struct cmsghdr) + (size); 
  479. msg.msg_control = (caddr_t)cmsg; 
  480. msg.msg_controllen = cmsg->cmsg_len; 
  481. } while (lintnoloop_common_h)
  482. #else /* !HAVE_CMSGHDR */
  483. #define CMSG_SETHDR_SEND(size) 
  484. do { 
  485. msg.msg_accrights = (caddr_t)cmsgmem; 
  486. msg.msg_accrightslen = (size); 
  487. } while (lintnoloop_common_h)
  488. #endif /* !HAVE_CMSGHDR */
  490. /* set cmsg for receiving */
  491. #if HAVE_CMSGHDR
  492. #define CMSG_SETHDR_RECV(size) 
  493. do { 
  494. msg.msg_control = (caddr_t)cmsg; 
  495. msg.msg_controllen = (size); 
  496. } while (lintnoloop_common_h)
  497. #else /* !HAVE_CMSGHDR */
  498. #define CMSG_SETHDR_RECV(size) 
  499. do { 
  500. msg.msg_accrights = (caddr_t)cmsgmem; 
  501. msg.msg_accrightslen = (size); 
  502. } while (lintnoloop_common_h)
  503. #endif /* !HAVE_CMSGHDR */
  506. /* returns length of controldata actually sent. */
  507. #if HAVE_CMSGHDR
  508. #define CMSG_GETLEN(msg) (msg.msg_controllen - sizeof(struct cmsghdr))
  509. #else
  510. #define CMSG_GETLEN(msg) (msg.msg_accrightslen)
  511. #endif
  514. #define INTERNAL_ERROR 
  515. "an internal error was detected at %s:%dnvalue = %ld, version = %s"
  517. #define SASSERT(expression)
  518. do {
  519. if (!(expression))
  520. SERR(expression);
  521. } while (lintnoloop_common_h)
  524. #define SASSERTX(expression)
  525. do {
  526. if (!(expression))
  527. SERRX(expression);
  528. } while (lintnoloop_common_h)
  531. /*
  532.  * wrappers around err()/errx()/warn()/warnx() for more consistent error
  533.  * messages.
  534.  * "failure" is the value that was wrong and which caused the internal error.
  535.  */
  538. #define SERR(failure)
  539. do {
  540. SWARN(failure);
  541. abort();
  542. } while (lintnoloop_common_h)
  544. #define SERRX(failure)
  545. do {
  546. SWARNX(failure);
  547. abort();
  548. } while (lintnoloop_common_h)
  551. #define SWARN(failure)
  552. swarn(INTERNAL_ERROR,
  553. __FILE__, __LINE__, (long int)(failure), rcsid)
  555. #define SWARNX(failure)
  556. swarnx(INTERNAL_ERROR,
  557. __FILE__, __LINE__, (long int)(failure), rcsid)
  561. #define ERR(failure)
  562. do {
  563. warn(INTERNAL_ERROR, __FILE__, __LINE__,
  564. (long int)(failure), rcsid);
  565. abort();
  566. } while (p)
  568. #define ERRX(failure)
  569. do {
  570. warnx(INTERNAL_ERROR, __FILE__, __LINE__, 
  571. (long int)(failure), rcsid);
  572. abort();
  573. } while (lintnoloop_common_h)
  576. #define WARN(failure) 
  577. warn(INTERNAL_ERROR, __FILE__, __LINE__, (long int)(failure), rcsid)
  579. #define WARNX(failure) 
  580. warnx(INTERNAL_ERROR, __FILE__, __LINE__, (long int)(failure), rcsid)
  582. #define ERRORMSG(failure) 
  583. error_msg(LOG_HIGH, INTERNAL_ERROR, __FILE__, __LINE__, (long int)(failure),
  584. rcsid)
  587. /* the size of a udp header "packet" (no padding) */
  588. #define PACKETSIZE_UDP(packet) (
  589. sizeof((packet)->flag) + sizeof((packet)->frag)
  590. + sizeof((packet)->host.atype) + sizeof((packet)->host.port)
  591. + (ADDRESSIZE_V5(packet)))
  594. /*
  595.  * returns the length of the current address field in socks packet "packet".
  596.  * "packet" can be one of pointer to response_t, request_t or udpheader_t.
  597.  */
  598. #define ADDRESSIZE(packet) ( 
  599.   ((packet)->version == SOCKS_V4 ? 
  600.   (ADDRESSIZE_V4(packet)) : (ADDRESSIZE_V5(packet))))
  602. /*
  603.  * version specifics
  604.  */
  605. #define ADDRESSIZE_V5(packet) (
  606.   (packet)->host.atype == SOCKS_ADDR_IPV4 ?
  607.   sizeof((packet)->host.addr.ipv4) :(packet)->host.atype == SOCKS_ADDR_IPV6 ?
  608.   sizeof((packet)->host.addr.ipv6) : (strlen((packet)->host.addr.domain) + 1))
  610. #define ADDRESSIZE_V4(packet) ( 
  611. (packet)->atype == SOCKS_ADDR_IPV4 ? 
  612. sizeof((packet)->addr.ipv4) : (strlen((packet)->addr.host) + 1))
  615. /*
  616.  * This is for Rgethostbyname() support for clients without access to
  617.  * dns.
  618.  * FAKEIP_START is the first address in the range of "fake" ip addresses,
  619.  * FAKEIP_END is the last.
  620.  * There can thus be FAKEIP_END - FAKEIP_START number of fake ip addresses
  621.  * supported per program.
  622.  *
  623.  * INADDR_NONE and INADDR_ANY may not be part of the range.
  624.  */
  625. #define FAKEIP_START 0x00000001
  626. #define FAKEIP_END 0x000000ff
  628. #define SOCKS_V4 4
  629. #define SOCKS_V4REPLY_VERSION 0
  630. #define SOCKS_V5 5
  631. #define MSPROXY_V2 2
  633. /* subnegotiation. */
  634. #define SOCKS_UNAMEVERSION 1
  636. /* authentication METHOD values. */
  637. #define AUTHMETHOD_NONE 0
  638. #define AUTHMETHOD_NONEs "none"
  639. #define AUTHMETHOD_GSSAPI 1
  640. #define AUTHMETHOD_GSSAPIs "gssapi"
  641. #define AUTHMETHOD_UNAME 2
  642. #define AUTHMETHOD_UNAMEs "username"
  644. /* X'03' to X'7F' IANA ASSIGNED */
  646. /* X'80' to X'FE' RESERVED FOR PRIVATE METHODS */
  648. #define AUTHMETHOD_NOACCEPT 255
  649. #define AUTHMETHOD_NOACCEPTs "no acceptable method"
  651. /* not standard methods, must be > 255. */
  652. #define AUTHMETHOD_RFC931 256
  653. #define AUTHMETHOD_RFC931s "rfc931"
  655. #define AUTHMETHOD_MAX (AUTHMETHOD_RFC931 + 1)
  657. /*
  658.  *  Response commands/codes
  659.  */
  660. #define SOCKS_CONNECT 1
  661. #define SOCKS_CONNECTs "connect"
  662. #define SOCKS_BIND 2
  663. #define SOCKS_BINDs "bind"
  664. #define SOCKS_UDPASSOCIATE       3
  665. #define SOCKS_UDPASSOCIATEs "udpassociate"
  667. /* pseudo commands */
  669. #define SOCKS_COMMANDEND 0xff
  671. #define SOCKS_BINDREPLY (SOCKS_COMMANDEND + 1)
  672. #define SOCKS_BINDREPLYs "bindreply"
  674. #define SOCKS_UDPREPLY (SOCKS_BINDREPLY + 1)
  675. #define SOCKS_UDPREPLYs "udpreply"
  677. /* misc stuff */
  678. #define SOCKS_ACCEPT (SOCKS_UDPREPLY + 1)
  679. #define SOCKS_ACCEPTs "accept"
  681. #define SOCKS_DISCONNECT (SOCKS_ACCEPT + 1)
  682. #define SOCKS_DISCONNECTs "disconnect"
  685. /* address types */
  686. #define SOCKS_ADDR_IPV4 0x01
  687. #define SOCKS_ADDR_DOMAIN 0x03
  688. #define SOCKS_ADDR_IPV6       0x04
  690. /* reply field values */
  691. #define SOCKS_SUCCESS 0x00
  692. #define SOCKS_FAILURE 0x01
  693. #define SOCKS_NOTALLOWED 0x02
  694. #define SOCKS_NETUNREACH 0x03
  695. #define SOCKS_HOSTUNREACH 0x04
  696. #define SOCKS_CONNREFUSED 0x05
  697. #define SOCKS_TTLEXPIRED 0x06
  698. #define SOCKS_CMD_UNSUPP 0x07
  699. #define SOCKS_ADDR_UNSUPP 0x08
  700. #define SOCKS_INVALID_ADDRESS 0x09
  702. /* version 4 codes. */
  703. #define SOCKSV4_SUCCESS 90
  704. #define SOCKSV4_FAIL 91
  705. #define SOCKSV4_NO_IDENTD 92
  706. #define SOCKSV4_BAD_ID 93
  711. #define MSPROXY_PINGINTERVAL (6 * 60)
  713. #define MSPROXY_SUCCESS 0
  714. #define MSPROXY_FAILURE 1
  715. #define MSPROXY_NOTALLOWED 2
  717. #define MSPROXY_MINLENGTH 172 /* minimum length of packet. */
  718. #define MSPROXY_VERSION 0x00010200 /* perhaps? */
  720. /* errors */
  721. #define MSPROXY_ADDRINUSE 0x0701
  722. #define MSPROXY_BIND_AUTHFAILED 0x0804 /* auth failed for connect. */
  723. #define MSPROXY_CONNECT_AUTHFAILED 0x081e /* auth failed for bind. */
  724. #define MSPROXY_CONNREFUSED 0x4 /* low 12 bits seem to vary. */
  726. /*
  727.  * Server seems to ignore loworder bits of a 0x47?? command, so take them
  728.  * for our own use.
  729.  */
  730. #define MSPROXY_HELLO 0x0500 /* packet 1 from client. */
  731. #define MSPROXY_HELLO_ACK 0x1000 /* packet 1 from server. */
  733. #define MSPROXY_USERINFO 0x1000 /* packet 2 from client. */
  734. #define MSPROXY_USERINFO_ACK 0x0400 /* packet 2 from server. */
  736. #define MSPROXY_SOMETHING 0x4700 /* packet 3 from client. */
  737. #define MSPROXY_SOMETHING_1_ACK 0x4714 /* packet 3 from server. */
  739. #define MSPROXY_SOMETHING_2 0x4701 /* packet 4 from client. */
  740. #define MSPROXY_SOMETHING_2_ACK 0x4715 /* packet 4 from server, high 8 bits
  741. seem to vary. */
  742. #define MSPROXY_SOMETHING_2_ACK2 0x4716 /* could be this too... dunno. */
  744. #define MSPROXY_RESOLVE 0x070d /* resolve request from client. */
  745. #define MSPROXY_RESOLVE_ACK 0x070f /* resolved info from server. */
  747. #define MSPROXY_BIND 0x0704 /* bind request. */
  748. #define MSPROXY_BIND_ACK 0x0706 /* bind request accepted. */
  750. #define MSPROXY_BIND2 0x0707 /* dunno. */
  751. #define MSPROXY_BIND2_ACK 0x0708 /* dunno. */
  753. #define MSPROXY_BIND2 0x0707 /* dunno. */
  754. #define MSPROXY_BIND2_ACK 0x0708 /* dunno. */
  756. #define MSPROXY_LISTEN 0x0406 /* listen() performed(?) */
  758. #define MSPROXY_BINDINFO 0x0709 /* info about client server accepted*/
  760. #define MSPROXY_BINDINFO_ACK 0x070a /* we got the info(?) */
  762. #define MSPROXY_CONNECT 0x071e /* connect request. */
  763. #define MSPROXY_CONNECT_ACK 0x0703 /* connect request accepted. */
  765. #define MSPROXY_UDPASSOCIATE 0x0705 /* udp associate request. */
  766. #define MSPROXY_UDPASSOCIATE_ACK 0x0706 /* udp associate request accepted. */
  768. #define MSPROXY_CONNECTED 0x042c /* client connected to server? */
  770. #define MSPROXY_SESSIONEND 0x251e /* maybe... */
  773. /* flag _bits_ */
  774. #define SOCKS_INTERFACEREQUEST 0x01
  775. #define SOCKS_USECLIENTPORT 0x04
  777. /* subcommands */
  778. #define SOCKS_INTERFACEDATA 0x01
  781. #define SOCKS_TCP 1
  782. #define SOCKS_UDP 2
  784. #define SOCKS_RECV 0
  785. #define SOCKS_SEND 1
  787. #if 0
  788. /* where is this from? (michaels) */
  789. #if defined(__alpha__)
  790. typedef unsigned int u_int32;
  791. #else
  792. typedef unsigned long u_int32;
  793. #endif
  794. #endif
  796. /* offsets into authentication packet */
  797. #define AUTH_VERSION 0 /* version of method packet. */
  799. /* request */
  800. #define AUTH_NMETHODS 1 /* number of methods to offer. */
  801. #define AUTH_METHODS 2 /* start of methods to offer. */
  803. /* reply */
  804. #define AUTH_VERSION 0 /* offset for version in reply. */
  805. #define AUTH_METHOD 1 /* offset for selected method in reply. */
  807. /* offsets into username/password negotiation packet */
  808. #define UNAME_VERSION 0
  809. #define UNAME_STATUS 1
  811. /* XXX no ivp6 support currently. */
  812. #define SOCKS_IPV6_ALEN 16
  814. #if !defined(SOCKSLIBRARY_DYNAMIC)
  815. #define sys_accept(s, addr, addrlen) accept(s, addr, addrlen)
  816. #define sys_bind(s, name, namelen) bind(s, name, namelen)
  817. #define sys_connect(s, name, namelen) connect(s, name, namelen)
  818. #define sys_bindresvport(sd, sin) bindresvport(sd, sin)
  819. #define sys_gethostbyname(name) gethostbyname(name)
  820. #define sys_gethostbyname2(name, af) gethostbyname2(name, af)
  821. #define sys_getpeername(s, name, namelen) getpeername(s, name, namelen)
  822. #define sys_getsockname(s, name, namelen) getsockname(s, name, namelen)
  823. #define sys_recvfrom(s, buf, len, flags, from, fromlen) 
  824.   recvfrom(s, buf, len, flags, from, fromlen)
  825. #define sys_rresvport(port) rresvport(port)
  826. #define sys_sendto(s, msg, len, flags, to, tolen) 
  827.   sendto(s, msg, len, flags, to, tolen)
  828. #endif
  830. enum operator_t { none = 0, eq, neq, ge, le, gt, lt, range };
  832. struct compat_t {
  833. unsigned reuseaddr:1; /* set SO_REUSEADDR? */
  834. unsigned sameport:1; /* always try to use same port as client? */
  835. unsigned :0;
  836. };
  839. struct logtype_t {
  840. int type; /* type of logging (where to). */
  841. FILE **fpv; /* if logging is to file, this is the open file.*/
  842. int fpc;
  843. int *fplockv; /* locking of logfiles. */
  844. int facility; /* if logging to syslog, this is the facility. */
  845. };
  849. /* extensions supported by us. */
  850. struct extension_t {
  851. unsigned bind:1; /* use bind extension? */
  852. unsigned :0;
  853. };
  857. /* the address part of a socks packet */
  858. union socksaddr_t {
  859. struct in_addr ipv4;
  860. char ipv6[SOCKS_IPV6_ALEN];
  861. char domain[MAXHOSTNAMELEN]; /* _always_ stored as C string. */
  862. };
  864. /* the hostspecific part of misc. things */
  865. struct sockshost_t {
  866. unsigned char atype;
  867. union socksaddr_t addr;
  868. in_port_t port;
  869. };
  873. struct msproxy_request_t {
  874. char username[MAXNAMELEN];
  875. char unknown[MAXNAMELEN];
  876. char executable[MAXNAMELEN];
  877. char clienthost[MAXHOSTNAMELEN];
  879. int32_t clientid; /* 1-4 */
  880. int32_t magic25; /* 5-8 */
  881. int32_t serverid; /* 9-12 */
  882. unsigned char serverack; /* 13: ack of last server packet */
  883. char pad10[3]; /* 14-16 */
  884. unsigned char sequence; /* 17: sequence # of this packet. */
  885. char pad11[7]; /* 18-24 */
  886. char RWSP[4]; /* 25-28: 0x52,0x57,0x53,0x50 */
  887. char pad15[8]; /* 29-36 */
  888. int16_t command; /* 37-38 */
  890. /* packet specifics start at 39. */
  891. union {
  892. struct {
  893. char pad1[18]; /* 39-56 */
  894. int16_t magic3; /* 57-58 */
  895. char           pad3[114]; /* 59-172 */
  896. int16_t magic5; /* 173-174: 0x4b, 0x00 */
  897. char pad5[2]; /* 175-176 */
  898. int16_t magic10; /* 177-178: 0x14, 0x00 */
  899. char pad6[2]; /* 179-180 */
  900. int16_t magic15; /* 181-182: 0x04, 0x00 */
  901. char pad10[6]; /* 183-188 */
  902. int16_t magic20; /* 189-190: 0x57, 0x04 */
  903. int16_t magic25; /* 191-192: 0x00, 0x04 */
  904. int16_t magic30; /* 193-194: 0x01, 0x00 */
  905. char pad20[2]; /* 195-196: 0x4a, 0x02 */
  906. int16_t magic35; /* 197-198: 0x4a, 0x02 */
  907. char pad30[10]; /* 199-208 */
  908. int16_t magic40; /* 209-210: 0x30, 0x00 */
  909. char pad40[2]; /* 211-212 */
  910. int16_t magic45; /* 213-214: 0x44, 0x00 */
  911. char pad45[2]; /* 215-216 */
  912. int16_t magic50; /* 217-218: 0x39, 0x00 */
  913. char pad50[2]; /* 219-220 */
  914. } _1;
  916. struct {
  917. char pad1[18]; /* 39-56 */
  918. int16_t magic3; /* 57-58 */
  919. char           pad3[114]; /* 59-172 */
  920. int16_t magic5; /* 173-174: 0x00, 0x4b */
  921. char pad5[2]; /* 175-176 */
  922. int16_t magic10; /* 177-178: 0x14, 0x00 */
  923. char pad10[2]; /* 179-180 */
  924. int16_t magic15; /* 181-182: 0x04, 0x00 */
  925. char pad15[6]; /* 183-188 */
  926. int16_t magic20; /* 189-190: 0x57, 0x04 */
  927. int16_t magic25; /* 191-192: 0x00, 0x04 */
  928. int16_t magic30; /* 193-194: 0x01, 0x00 */
  929. char pad20[2]; /* 195-196 */
  930. int16_t magic35; /* 197-198: 0x04, 0x00 */
  931. char pad25[10]; /* 199-208 */
  932. int16_t magic50; /* 209-210: 0x30, 0x00 */
  933. char pad50[2]; /* 211-212 */
  934. int16_t magic55; /* 213-214: 0x44, 0x00 */
  935. char pad55[2]; /* 215-216 */
  936. int16_t magic60; /* 217-218: 0x39, 0x00 */
  937. } _2;
  939. struct {
  940. char pad1[4]; /* 39-42 */
  941. int16_t magic2; /* 43-44 */
  942. char pad10[12]; /* 45-56 */
  943. in_addr_t bindaddr; /* 57-60: address to bind. */
  944. in_port_t bindport; /* 61-62: port to bind. */
  945. char           pad15[2]; /* 63-64 */
  946. int16_t magic3; /* 65-66 */
  947. in_port_t boundport; /* 67-68 */
  948. char           pad20[104]; /* 69-172 */
  949. char NTLMSSP[sizeof("NTLMSSP")]; /* 173-180: "NTLMSSP" */
  950. int16_t magic5; /* 181-182: 0x01, 0x00 */
  951. char pad25[2]; /* 183-184 */
  952. int16_t magic10; /* 185-186: 0x96, 0x82 */
  953. int16_t magic15; /* 187-188: 0x08, 0x00 */
  954. int16_t magic20; /* 189-190: 0x28, 0x00 */
  955. char pad30[2]; /* 191-192 */
  956. int16_t magic25; /* 193-194: 0x96, 0x82 */
  957. int16_t magic30; /* 195-196: 0x01, 0x00 */
  958. char pad40[12]; /* 197-208 */
  959. int16_t magic50; /* 209-210: 0x30, 0x00 */
  960. char pad50[6]; /* 211-216 */
  961. int16_t magic55; /* 217-218: 0x30, 0x00 */
  962. char pad55[2]; /* 219-220 */
  963. } _3;
  965. struct {
  966. char pad1[4]; /* 39-42 */
  967. int16_t magic1; /* 43-44 */
  968. int32_t magic2; /* 45-48 */
  969. char pad2[8]; /* 49-56 */
  970. int16_t magic3; /* 57-58 */
  971. char pad3[6]; /* 59-64 */
  972. int16_t magic4; /* 65-66 */
  973. in_port_t boundport; /* 67-68 */
  974. char           pad4[104]; /* 69-172 */
  975. char NTLMSSP[sizeof("NTLMSSP")]; /* 173-180: "NTLMSSP" */
  976. int16_t magic5; /* 181-182: 0x03, 0x00 */
  977. char pad5[2]; /* 183-184 */
  978. int16_t magic10; /* 185-186: 0x18, 0x00 */
  979. int16_t magic15; /* 187-188: 0x18, 0x00 */
  980. int16_t magic20; /* 189-190: 0x49, 0x00 */
  981. char pad10[6]; /* 191-196 */
  982. int16_t magic30; /* 197-198: 0x61, 0x00 */
  983. char pad15[2]; /* 199-200 */
  984. int16_t magic35; /* 201-202: 0x08, 0x00 */
  985. int16_t magic40; /* 203-204: 0x08, 0x00 */
  986. int16_t magic45; /* 205-206: 0x34, 0x00 */
  987. char pad20[2]; /* 207-208 */
  988. int16_t magic50; /* 209-210: 0x07, 0x00 */
  989. int16_t magic55; /* 211-212: 0x07, 0x00 */
  990. int16_t magic60; /* 213-214: 0x3c, 0x00 */
  991. char pad25[2]; /* 215-216 */
  992. int16_t magic65; /* 217-218: 0x06, 0x00 */
  993. int16_t magic70; /* 219-220: 0x06, 0x00 */
  994. int16_t magic75; /* 221-222: 0x43, 0x00 */
  995. } _4;
  997. struct {
  998. unsigned char hostlength; /* length of host, including NUL. */
  999. char pad1[17]; /* 39-56 */
  1000. char *host; /* 57-... */
  1001. } resolve;
  1003. struct {
  1004. int16_t magic1; /* 39-40 */
  1005. char pad1[4]; /* 41-45 */
  1006. int32_t magic3; /* 45-48 */
  1007. char pad5[8]; /* 48-56 */
  1008. int16_t magic6; /* 57-58: 0x0200 */
  1009. in_port_t destport; /* 59-60 */
  1010. in_addr_t destaddr; /* 61-64 */
  1011. char pad10[4]; /* 65-68 */
  1012. int16_t magic10; /* 69-70 */
  1013. char pad15[2]; /* 71-72 */
  1014. in_port_t srcport; /* 73-74: port client connects from */
  1015. char pad20[82]; /* 75-156 */
  1016. } _5;
  1018. struct {
  1019. int16_t magic1; /* 39-40 */
  1020. char pad5[2]; /* 41-42 */
  1021. int16_t magic5; /* 43-44 */
  1022. int32_t magic10; /* 45-48 */
  1023. char pad10[2]; /* 49-50 */
  1024. int16_t magic15; /* 51-52 */
  1025. int32_t magic16; /* 53-56 */
  1026. int16_t magic20; /* 57-58 */
  1027. in_port_t clientport; /* 59-60: forwarded port. */
  1028. in_addr_t clientaddr; /* 61-64: forwarded address. */
  1029. int32_t magic30; /* 65-68 */
  1030. int32_t magic35; /* 69-72 */
  1031. in_port_t serverport; /* 73-74: port server will connect
  1032.  *        to us from.
  1033. */
  1034. in_port_t srcport; /* 75-76: connect request; port used
  1035.  *  on client behalf.
  1036. */
  1037. in_port_t boundport; /* 77-78: bind request; port used
  1038.  *  on client behalf.
  1039. */
  1040. in_addr_t boundaddr; /* 79-82: addr used on client behalf*/
  1041. char pad30[90]; /* 83-172 */
  1042. } _6;
  1044. } packet;
  1045. };
  1047. struct msproxy_response_t {
  1048. int32_t packetid; /* 1-4 */
  1049. int32_t magic5; /* 5-8 */
  1050. int32_t              serverid; /* 9-12 */
  1051. char clientack; /* 13: ack of last client packet. */
  1052. char pad5[3]; /* 14-16 */
  1053. unsigned char sequence; /* 17: sequence # of this packet. */
  1054. char pad10[7]; /* 18-24 */
  1055. char RWSP[4]; /* 25-28: 0x52,0x57,0x53,0x50 */
  1056. char pad15[8]; /* 29-36 */
  1057. int16_t command; /* 37-38 */
  1059. union {
  1060. struct {
  1061. char pad5[18]; /* 39-56 */
  1062. int16_t magic20; /* 57-58: 0x02, 0x00 */
  1063. char pad10[6]; /* 59-64 */
  1064. int16_t magic30; /* 65-66: 0x74, 0x01 */
  1065. char pad15[2]; /* 67-68 */
  1066. int16_t magic35; /* 69-70: 0x0c, 0x00 */
  1067. char pad20[6]; /* 71-76 */
  1068. int16_t magic50; /* 77-78: 0x04, 0x00 */
  1069. char pad30[6]; /* 79-84 */
  1070. int16_t magic60; /* 85-86: 0x65, 0x05 */
  1071. char pad35[2]; /* 87-88 */
  1072. int16_t magic65; /* 89-90: 0x02, 0x00 */
  1073. char pad40[8]; /* 91-98 */
  1074. in_port_t udpport; /* 99-100 */
  1075. in_addr_t udpaddr; /* 101-104 */
  1076. } _1;
  1078. struct {
  1079. char pad5[18]; /* 39-56 */
  1080. int16_t magic5; /* 57-58: 0x01, 0x00 */
  1081. } _2;
  1083. struct {
  1084. char pad1[6]; /* 39-44 */
  1085. int32_t magic10; /* 45-48 */
  1086. char pad3[10]; /* 49-58 */
  1087. in_port_t boundport; /* 59-60: port server bound for us. */
  1088. in_addr_t boundaddr; /* 61-64: addr server bound for us. */
  1089. char pad10[4]; /* 65-68 */
  1090. int16_t magic15; /* 69-70 */
  1091. char pad15[102]; /* 70-172 */
  1092. char NTLMSSP[sizeof("NTLMSSP")]; /* 173-180: "NTLMSSP" */
  1093. int16_t magic50; /* 181-182: 0x02, 0x00 */
  1094. char pad50[2]; /* 183-184 */
  1095. int16_t magic55; /* 185-186: 0x08, 0x00 */
  1096. int16_t magic60; /* 187-188: 0x08, 0x00 */
  1097. int16_t magic65; /* 189-190: 0x28, 0x00 */
  1098. char pad60[2]; /* 191-192 */
  1099. int16_t magic70; /* 193-194: 0x96, 0x82 */
  1100. int16_t magic75; /* 195-196: 0x01, 0x00 */
  1101. char pad70[16]; /* 197-212 */
  1102. char ntdomain[257]; /* 213-EOP */
  1103. } _3;
  1105. struct {
  1106. char pad5[134]; /* 39-172 */
  1107. } _4;
  1109. struct {
  1110. unsigned char addroffset; /* 39: weird, probably wrong. */
  1111. char pad5[13]; /* 40-52 */
  1112. in_addr_t hostaddr; /* ?-?+4 */
  1113. } resolve;
  1115. struct {
  1116. int16_t magic1; /* 39-40 */
  1117. char pad5[18]; /* 41-58 */
  1118. in_port_t clientport; /* 59-60: forwarded port. */
  1119. in_addr_t clientaddr; /* 61-64: forwarded address. */
  1120. int32_t magic10; /* 65-68 */
  1121. int32_t magic15; /* 69-72 */
  1122. in_port_t serverport; /* 73-74: port server will connect
  1123.  *        to us from.
  1124. */
  1125. in_port_t srcport; /* 75-76: connect request; port used
  1126.  *  on client behalf.
  1127. */
  1128. in_port_t boundport; /* 77-78: bind request; port used
  1129.  *  on client behalf.
  1130. */
  1131. in_addr_t boundaddr; /* 79-82: addr used on client behalf*/
  1132. char pad10[90]; /* 83-172 */
  1133. } _5;
  1134. } packet;
  1135. };
  1137. struct request_t {
  1138. unsigned char version;
  1139. unsigned char command;
  1140. unsigned char flag;
  1141. struct sockshost_t host;
  1142. struct authmethod_t *auth; /* pointer to level above. */
  1143. };
  1146. struct response_t {
  1147. unsigned char version;
  1148. unsigned char reply;
  1149. unsigned char flag;
  1150. struct sockshost_t host;
  1151. struct authmethod_t *auth; /* pointer to level above. */
  1152. };
  1154. /* encapsulation for udp packets. */
  1155. struct udpheader_t {
  1156. unsigned char flag[2];
  1157. unsigned char frag;
  1158. struct sockshost_t host;
  1159. };
  1162. /* interface request packet. */
  1163. struct interfacerequest_t {
  1164. unsigned char rsv;
  1165. unsigned char sub;
  1166. unsigned char flag;
  1167. struct sockshost_t host;
  1168. };
  1171. /* method username */
  1172. struct uname_t {
  1173. unsigned char version;
  1174. char name[MAXNAMELEN];
  1175. char password[MAXPWLEN];
  1176. };
  1178. /* method rfc931 */
  1179. struct rfc931_t {
  1180. char name[MAXNAMELEN];
  1181. };
  1183. /* this must be big enough to hold a complete method request. */
  1184. struct authmethod_t {
  1185. int matched; /* authentication matched? */
  1186. int method; /* method in use. */
  1187. union {
  1188. struct uname_t uname;
  1189. struct rfc931_t rfc931;
  1190. } mdata;
  1191. };
  1194. struct method_t {
  1195. unsigned none:1;
  1196. unsigned uname:1;
  1197. unsigned :0;
  1198. };
  1201. struct protocol_t {
  1202. unsigned tcp:1;
  1203. unsigned udp:1;
  1204. unsigned :0;
  1205. };
  1208. struct command_t {
  1209. unsigned bind:1;
  1210. unsigned connect:1;
  1211. unsigned udpassociate:1;
  1213. /* not real commands as per standard, but they have their use. */
  1214. unsigned bindreply:1; /* reply to bind command. */
  1215. unsigned udpreply:1; /* reply to udp packet. */
  1216. unsigned :0;
  1217. };
  1220. struct proxyprotocol_t {
  1221. unsigned socks_v4:1;
  1222. unsigned socks_v5:1;
  1223. unsigned msproxy_v2:1;
  1224. unsigned :0;
  1225. };
  1228. struct serverstate_t {
  1229. struct command_t command;
  1230. struct extension_t extension;
  1231. struct protocol_t protocol;
  1232. int methodv[AUTHMETHOD_MAX];/* methods to offer. */
  1233. int methodc; /* number of methods set. */
  1234. struct proxyprotocol_t proxyprotocol;
  1235. };
  1238. struct msproxy_state_t {
  1239. struct sockaddr_in controladdr; /* udp address of proxyserver. */
  1240. int32_t magic25;
  1241. int32_t bindid;
  1242. int32_t clientid;
  1243. int32_t serverid;
  1244. unsigned char seq_recv; /* seq number of last packet recv. */
  1245. unsigned char seq_sent; /* seq number of last packet sent. */
  1246. };
  1249. struct gateway_t {
  1250. struct sockshost_t host;
  1251. struct serverstate_t state;
  1252. };
  1254. /* values in parentheses designate "don't care" values. */
  1255. struct socksstate_t {
  1256. int acceptpending; /* a accept pending? (-1) */
  1257. struct authmethod_t auth; /* authentication in use. */
  1258. int command; /* command (-1) */
  1259. int err; /* if request failed, errno. */
  1260. int inprogress; /* operation in progress? (-1) */
  1261. #ifdef SOCKS_TRYHARDER
  1262. int lock; /* some calls require a lock. */
  1263. #endif
  1264. struct msproxy_state_t msproxy; /* if msproxy, msproxy state. */
  1265. struct protocol_t protocol; /* protocol in use. */
  1266. unsigned udpconnect:1; /* connected udp socket? */
  1267. int system; /* don't check, use system call. */
  1268. int version; /* version */
  1269. };
  1272. struct ruleaddress_t {
  1273. char atype;
  1274. union {
  1276. char domain[MAXHOSTNAMELEN];
  1278. struct {
  1279. struct in_addr ip;
  1280. struct in_addr mask;
  1281. } ipv4;
  1283. } addr;
  1285. struct {
  1286. in_port_t tcp; /* tcp portstart or field to operator on. */
  1287. in_port_t udp; /* udp portstart or field to operator on. */
  1288. } port;
  1289. in_port_t portend; /* only used if operator is range. */
  1290. enum operator_t operator; /* operator to compare ports via. */
  1291. };
  1293. struct route_t {
  1294. int number; /* routenumber. */
  1296. struct {
  1297. unsigned bad:1; /* route is bad? */
  1298. unsigned direct:1; /* direct connection, no proxy. */
  1299. unsigned :0;
  1300. } state;
  1303. struct ruleaddress_t src;
  1304. struct ruleaddress_t dst;
  1305. struct gateway_t gw;
  1307. struct route_t *next; /* next route in list. */
  1308. };
  1311. struct socks_t {
  1312. unsigned char version;
  1313. /*
  1314.  * Negotiated version.  Each request and
  1315.  * response will also contain a version number, that
  1316.  * is the version number given for that particular
  1317.  * packet and should be checked to make sure it is
  1318.  *  the same as the negotiated version.
  1319. */
  1320. struct request_t req;
  1321. struct response_t res;
  1322. struct authmethod_t auth;
  1323. struct gateway_t gw;
  1324. struct socksstate_t state;
  1325. };
  1329. enum portcmp { e_lt, e_gt, e_eq, e_neq, e_le, e_ge, e_nil };
  1330. typedef enum portcmp Portcmp;
  1334. /*
  1335.  * for use in generic functions that take either reply or request
  1336.  * packets, include a field indicating what it is.
  1337.  */
  1338. #define SOCKS_REQUEST 0x1
  1339. #define SOCKS_RESPONSE 0x2
  1341. struct socksfd_t {
  1342. unsigned allocated:1;/* allocated? */
  1343. int control; /* control connection to server. */
  1344. struct socksstate_t state; /* state of this connection. */
  1345. unsigned :0;
  1346. struct sockaddr local; /* local address of data connection. */
  1347. unsigned :0;
  1348. struct sockaddr server; /* remote address of data connection. */
  1349. unsigned :0;
  1350. struct sockaddr remote; /* address server is using on our behalf. */
  1351. unsigned :0;
  1352. struct sockaddr reply; /* address to expect reply from. */
  1354. /* XXX union this. */
  1355. unsigned :0;
  1356. struct sockaddr accepted; /* address server accepted for us. */
  1357. unsigned :0;
  1358. struct sockaddr connected; /* address server connected to for us. */
  1360. struct route_t *route;
  1361. };
  1363. __BEGIN_DECLS
  1365. /*
  1366.  * versions of BSD's error functions that log via slog() instead.
  1367.  */
  1369. #ifdef STDC_HEADERS
  1370. void serr(int eval, const char *fmt, ...);
  1371. #else
  1372. void serr();
  1373. #endif  /* STDC_HEADERS */
  1375. #ifdef STDC_HEADERS
  1376. void serrx(int eval, const char *fmt, ...);
  1377. #else
  1378. void serrx();
  1379. #endif  /* STDC_HEADERS */
  1381. #ifdef STDC_HEADERS
  1382. void swarn(const char *fmt, ...);
  1383. #else
  1384. void swarn();
  1385. #endif  /* STDC_HEADERS */
  1387. #ifdef STDC_HEADERS
  1388. void swarnx(const char *fmt, ...);
  1389. #else
  1390. void swarnx();
  1391. #endif  /* STDC_HEADERS */
  1393. void
  1394. genericinit __P((void));
  1395. /*
  1396.  * Generic init, called after clientinit()/serverinit().
  1397.  */
  1399. void
  1400. initlog __P((void));
  1401. /*
  1402.  * (Re)initialize logging.
  1403.  */
  1406. struct udpheader_t *
  1407. sockaddr2udpheader __P((const struct sockaddr *to, struct udpheader_t *header));
  1408. /*
  1409.  * Writes a udpheader representation of "to" to "header".
  1410.  * Returns a pointer to "header".
  1411.  */
  1413. char *
  1414. udpheader_add __P((const struct sockshost_t *host, char *msg, size_t *len,
  1415.  size_t msgsize));
  1416. /*
  1417.  * Prefixes the udpheader_t version of "host" to a copy of "msg",
  1418.  * which is of length "len".
  1419.  * "msgsize" gives the size of the memory pointed to by "msg".
  1420.  * If "msgsize" is large enough the function will prepend the udpheader
  1421.  * to "msg" directly (moving the old contents to the right) rather than
  1422.  * allocating new memory.
  1423.  * Upon return "len" gives the length of the new "msg".
  1424.  *
  1425.  * Returns:
  1426.  * On success: "msg" with the udpheader prepended.
  1427.  * On failure: NULL (out of memory).
  1428.  */
  1430. struct udpheader_t *
  1431. string2udpheader __P((const char *data, size_t len,
  1432.  struct udpheader_t *header));
  1433. /*
  1434.  * Converts "data" to udpheader_t representation.
  1435.  * "len" is length of "data".
  1436.  * "data" is assumed to be in network order.
  1437.  * Returns:
  1438.  * On success: pointer to a udpheader_t in static memory.
  1439.  * On failure: NULL ("data" is not a complete udppacket).
  1440.  */
  1443. const char *
  1444. socks_packet2string __P((const void *packet, int type));
  1445. /*
  1446.  * debug function; dumps socks packet content
  1447.  * "packet" is a socks packet, "type" indicates it's type.
  1448.  * Returns:
  1449.  * On success: 0
  1450.  * On failure: -1
  1451.  */
  1453. int
  1454. socks_socketisbound __P((int s));
  1455. /*
  1456.  * Returns:
  1457.  * If "s" is bound: 1
  1458.  * If "s" is not bound: 0
  1459.  * If "s" is not socket or error occurred determining if bound: -1
  1460.  */
  1462. int
  1463. fdisopen __P((int fd));
  1464. /*
  1465.  * returns 1 if the filedescriptor "fd" currently references a open object.
  1466.  * returns 0 otherwise.
  1467.  */
  1469. void
  1470. closev __P((int *array, int count));
  1471. /*
  1472.  * Goes through "array", which contains "count" elements.
  1473.  * Each element that does not have a negative value is closed.
  1474.  */
  1476. int
  1477. socks_logmatch __P((unsigned int d, const struct logtype_t *log));
  1478. /*
  1479.  * Returns true if "d" is a descriptor matching any descriptor in "log".
  1480.  * Returns false otherwise.
  1481.  */
  1483. char *
  1484. sockaddr2string __P((const struct sockaddr *address, char *string, size_t len));
  1485. /*
  1486.  * Returns the ip address and port in "address" on string form.
  1487.  * "address" is assumed to be on network form and it will be
  1488.  * converted to host form before written to "string".
  1489.  * "len" gives length of the NUL terminated string.
  1490.  * Returns: "string".
  1491.  */
  1494. struct sockaddr *
  1495. sockshost2sockaddr __P((const struct sockshost_t *shost,
  1496. struct sockaddr *addr));
  1497. /*
  1498.  * Converts the sockhost_t "shost" to a sockaddr struct and stores it
  1499.  * in "addr".
  1500.  * Returns: "addr".
  1501.  */
  1503. struct sockaddr *
  1504. fakesockshost2sockaddr __P((const struct sockshost_t *host,
  1505.  struct sockaddr *addr));
  1506. /*
  1507.  * Like sockshost2sockaddr(), but checks whether the address in
  1508.  * "host" is fake when converting.
  1509.  */
  1511. struct sockshost_t *
  1512. sockaddr2sockshost __P((const struct sockaddr *addr, struct sockshost_t *host));
  1513. /*
  1514.  * Converts the sockaddr struct "shost" to a sockshost_t struct and stores it
  1515.  * in "host".
  1516.  * Returns: "host".
  1517.  */
  1519. struct sockshost_t *
  1520. ruleaddress2sockshost __P((const struct ruleaddress_t *address,
  1521. struct sockshost_t *host, int protocol));
  1522. /*
  1523.  * Converts the ruleaddress_t "address" to a sockshost_t struct and stores it
  1524.  * in "host".
  1525.  * Returns: "host".
  1526.  */
  1528. struct ruleaddress_t *
  1529. sockshost2ruleaddress __P((const struct sockshost_t *host,
  1530. struct ruleaddress_t *addr));
  1531. /*
  1532.  * Converts the sockshost_t "host" to a ruleaddress_t struct and stores it
  1533.  * in "addr".
  1534.  * Returns: "addr".
  1535.  */
  1537. struct ruleaddress_t *
  1538. sockaddr2ruleaddress __P((const struct sockaddr *addr,
  1539. struct ruleaddress_t *ruleaddr));
  1540. /*
  1541.  * Converts the struct sockaddr "addr" to a ruleaddress_t struct and stores it
  1542.  * in "ruleaddr".
  1543.  * Returns: "addr".
  1544.  */
  1546. int
  1547. sockatmark __P((int s));
  1548. /*
  1549.  * If "s" is at oob mark, return 1, otherwise 0.
  1550.  * Returns -1 if a error occurred.
  1551.  */
  1553. ssize_t
  1554. recvmsgn __P((int s, struct msghdr *msg, int flags, size_t len));
  1555. /*
  1556.  * Like recvmsg(), but tries to read until "len" has been read.
  1557.  * BUGS:
  1558.  *   Assumes msg->msg_iov[n] are laid out next to each others.
  1559.  */
  1561. ssize_t
  1562. readn __P((int, void *, size_t));
  1563. /*
  1564.  * Like read() but retries.
  1565.  */
  1567. ssize_t
  1568. writen __P((int, const void *, size_t));
  1569. /*
  1570.  * like write() but retries.
  1571.  */
  1573. int
  1574. closen __P((int));
  1575. /*
  1576.  * Wrapper around close().  Retries on EINTR.
  1577.  */
  1579. int
  1580. selectn __P((int, fd_set *, fd_set *, fd_set *, struct timeval *));
  1581. /*
  1582.  * Wrapper around select().  Retries on EINTR.
  1583.  */
  1585. int
  1586. acceptn __P((int, struct sockaddr *, socklen_t *));
  1587. /*
  1588.  * Wrapper around accept().  Retries on EINTR.
  1589.  */
  1592. char *
  1593. sockshost2string __P((const struct sockshost_t *host, char *string,
  1594.  size_t len));
  1595. /*
  1596.  * Writes "host" out as a string.  The string is written to "string",
  1597.  * which is of length "len", including NUL termination.
  1598.  * Returns: "string".
  1599.  */
  1601. const char *
  1602. strcheck __P((const char *string));
  1603. /*
  1604.  * Checks "string".  If it is NULL, returns a string indicating memory
  1605.  * exhausted, if not, returns the same string it was passed.
  1606.  */
  1608. const char *
  1609. command2string __P((int command));
  1610. /*
  1611.  * Returns a printable representation of the socks command "command".
  1612.  * Can't fail.
  1613.  */
  1615. const char *
  1616. protocol2string __P((int protocol));
  1617. /*
  1618.  * Returns a printable representation of "protocol".
  1619.  * Can't fail.
  1620.  */
  1624. const char *
  1625. method2string __P((int method));
  1626. /*
  1627.  * Returns a printable representation of the authmethod "method".
  1628.  * Can't fail.
  1629.  */
  1631. int
  1632. string2method __P((const char *methodname));
  1633. /*
  1634.  * If "methodname" is the name of a supported method, the protocol
  1635.  * value of that method is returned.
  1636.  * Otherwise, -1 is returned.
  1637.  */
  1640. char *
  1641. sockshost2mem __P((const struct sockshost_t *host, char *mem, int version));
  1642. /*
  1643.  * Writes "host" out to "mem".  The caller must make sure "mem"
  1644.  * is big enough to hold the contents of "host".
  1645.  * "version" gives the socks version "host" is to be written out in.
  1646.  * Returns a pointer to one element past the last byte written to "mem".
  1647.  */
  1649. const char *
  1650. mem2sockshost __P((struct sockshost_t *host, const char *mem, size_t len,
  1651.  int version));
  1652. /*
  1653.  * Writes "mem", which is assumed to be a sockshost string
  1654.  * of version "version" in network order, out to "host".
  1655.  * Returns:
  1656.  * On success: pointer to one element past last byte used of mem
  1657.  * and fills in "host" appropriately.
  1658.  * On failure: NULL ("mem" is not a valid sockshost.)
  1659.  */
  1661. #ifdef STDC_HEADERS
  1662. void slog(int priority, const char *message, ...);
  1663. #else
  1664. void slog();
  1665. #endif  /* STDC_HEADERS */
  1666. /*
  1667.  * Logs message "message" at priority "priority" to previously configured
  1668.  * outputdevice.
  1669.  * Checks settings and ignores message if it's of to low a priority.
  1670.  */
  1672. void vslog __P((int priority, const char *message, va_list ap));
  1673. /*
  1674.  * Same as slog() but assumes varargs/stdargs have already processed
  1675.  * the arguments.
  1676.  */
  1678. int
  1679. readconfig __P((const char *filename));
  1680. /*
  1681.  * Parses the config stored in in the filename "filename".
  1682.  * Returns:
  1683.  * On success: 0.
  1684.  * On failure: -1.
  1685.  */
  1687. void
  1688. yyerror __P((const char *s));
  1689. /*
  1690.  * Report a error related to (configfile) parsing and exit.
  1691.  */
  1693. int
  1694. addressmatch __P((const struct ruleaddress_t *rule,
  1695. const struct sockshost_t *address, int protocol,
  1696. int ipalias));
  1697. /*
  1698.  * Tries to match "address" against "rule".  "address" is resolved
  1699.  * if necessary.  "address" supports the wildcard INADDR_ANY and port of 0.
  1700.  * "protocol" is the protocol to compare under.
  1701.  * If "ipalias" is true, the function will try to match any ip alias
  1702.  * "address"'s might have if appropriate, this can be useful to match
  1703.  * multihomed hosts where the client requests e.g a bind connection.
  1704.  * Returns true if "rule" matched "address".
  1705.  */
  1707. struct hostent *
  1708. hostentdup __P((const struct hostent *hostent));
  1709. /*
  1710.  * Duplicates "hostent".
  1711.  * Returns:
  1712.  * On success: a pointer to the duplicated hostent.
  1713.  * On failure: NULL.
  1714.  */
  1716. void
  1717. hostentfree __P((struct hostent *hostent));
  1718. /*
  1719.  * Free's all resourced used by "hostent", including "hostent"
  1720.  * itself.  If "hostent" is NULL, nothing is done.
  1721.  */
  1725. int
  1726. socks_connect __P((int s, const struct sockshost_t *host));
  1727. /*
  1728.  * Tries to connect to "host".  If "host"'s address is not a ip address,
  1729.  * the function also tries to connect to any alias for "host"'s
  1730.  * name.  The connection is done using the open descriptor "s".
  1731.  * Returns:
  1732.  * On success: 0
  1733.  * On failure: -1
  1734.  */
  1736. struct route_t *
  1737. socks_connectroute __P((int s, struct socks_t *packet,
  1738. const struct sockshost_t *src,
  1739. const struct sockshost_t *dst));
  1740. /*
  1741.  * Finds a route from "src" to "dst" and connects to it "s".
  1742.  * If src or dst is NULL, that argument is ignored.
  1743.  *
  1744.  * The route used may take into account the contents of "packet->req",
  1745.  * which is assumed to be the packet that will be sent to a socksserver,
  1746.  * so it is recommended that it's contents be as conservative as possible.
  1747.  *
  1748.  * When it has successfully connected to a gateway it will set
  1749.  * the packet->method members to point to the methods the gateway
  1750.  * should be offered.
  1751.  *
  1752.  * Returns:
  1753.  * On success: the route that was used.
  1754.  * On failure: NULL.  If errno is 0, the reason for failure was
  1755.  * that no route was found.
  1756.  */
  1759. struct request_t *
  1760. socks_requestpolish __P((struct request_t *req, const struct sockshost_t *src,
  1761.    const struct sockshost_t *dst));
  1762. /*
  1763.  * Tries to "polish" the request "req" so that a later socks_getroute()
  1764.  * will succeed.
  1765.  * Returns:
  1766.  * On success: "req".
  1767.  * On failure: NULL.
  1768.  */
  1770. void
  1771. showstate __P((const struct serverstate_t *state));
  1772. /*
  1773.  * Shows "state".
  1774.  */
  1777. struct route_t *
  1778. addroute __P((const struct route_t *route));
  1779. /*
  1780.  * Appends a copy of "route" to our list of routes.
  1781.  * Returns a pointer to the added route.
  1782.  */
  1784. void
  1785. showroute __P((const struct route_t *route));
  1786. /*
  1787.  * prints the route "route".
  1788.  */
  1791. struct route_t *
  1792. socks_getroute __P((const struct request_t *req, const struct sockshost_t *src,
  1793.   const struct sockshost_t *dst));
  1794. /*
  1795.  * Tries to find a  route to be used for a connection going from
  1796.  * "src" to "dst".
  1797.  * If src or dst is NULL, that argument is ignored.
  1798.  *
  1799.  * The route used may take into account the contents of "req", which is
  1800.  * assumed to be the packet that will be sent to a socksserver, so it is
  1801.  * recommended that it's contents be as conservative as possible.
  1802.  *
  1803.  * Returns:
  1804.  * On success: pointer to route that should be used.
  1805.  * On failure: NULL (no socks route found).
  1806.  */
  1808. const char *
  1809. ruleaddress2string __P((const struct ruleaddress_t *rule, char *string,
  1810. size_t len));
  1811. /*
  1812.  * Writes "rule" out as a string.  The string is written to "string",
  1813.  * which is of length "len", including NUL termination.
  1814.  * Returns: "string".
  1815.  */
  1818. int
  1819. sockscode __P((int version, int code));
  1820. /*
  1821.  * Maps the socks replycode "code", which is in non-version specific format,
  1822.  * to the equivalent replycode in version "version".
  1823.  */
  1825. int
  1826. errno2reply __P((int errnum, int version));
  1827. /*
  1828.  * Returns the socks version "version" reply code for a error of type "errno".
  1829.  */
  1831. enum operator_t
  1832. string2operator __P((const char *operator));
  1833. /*
  1834.  * Returns the enum for the string representation of a operator.
  1835.  * Can't fail.
  1836.  */
  1838. const char *
  1839. operator2string __P((enum operator_t operator));
  1840. /*
  1841.  * Returns the string representation of the operator.
  1842.  * Can't fail.
  1843.  */
  1845. char *
  1846. str2vis __P((const char *string, size_t len));
  1847. /*
  1848.  * Visually encodes exactly "len" chars of "string".
  1849.  * Returns:
  1850.  * On success: the visually encoded string, to be free()'ed by caller.
  1851.  * On failure: NULL.  (out of memory).
  1852.  */
  1854. in_addr_t
  1855. socks_addfakeip __P((const char *name));
  1856. /*
  1857.  * Adds "name" to a internal table indexed by (fake)ip addresses.
  1858.  * Returns:
  1859.  * On success: "name"'s index.
  1860.  * On failure: INADDR_NONE
  1861.  */
  1863. const char *
  1864. socks_getfakehost __P((in_addr_t addr));
  1865. /*
  1866.  * If "addr" is a "fake" (non-resolved) addr, it returns the name
  1867.  * corresponding to it.
  1868.  * Else, NULL is returned.
  1869.  */
  1871. int
  1872. socks_getfakeip __P((const char *host, struct in_addr *addr));
  1873. /*
  1874.  * If "host" has a fake address entry, the address is written into
  1875.  * "addr".
  1876.  * Returns:
  1877.  * If a fake address exits: 1
  1878.  * Else: 0
  1879.  */
  1881. struct sockshost_t *
  1882. fakesockaddr2sockshost __P((const struct sockaddr *addr,
  1883.  struct sockshost_t *host));
  1884. /*
  1885.  * Identical to sockaddr2sockshost, but checks whether
  1886.  * the address in "addr" is a "fake" one when converting.
  1887.  */
  1889. int
  1890. sockaddrareeq __P((const struct sockaddr *a, const struct sockaddr *b));
  1891. /*
  1892.  * Compares the address "a" against "b".
  1893.  * Returns:
  1894.  * If "a" and "b" are equal: true
  1895.  * else: false
  1896.  */
  1898. int
  1899. sockshostareeq __P((const struct sockshost_t *a, const struct sockshost_t *b));
  1900. /*
  1901.  * Compares the address "a" against "b".
  1902.  * Returns:
  1903.  * If "a" and "b" are equal: true
  1904.  * else: false
  1905.  */
  1907. int
  1908. fdsetop __P((int nfds, int op, const fd_set *a, const fd_set *b,
  1909.  fd_set *result));
  1910. /*
  1911.  * Performs operation on descriptor sets.
  1912.  * "nfds" is the number of descriptors to perform "op" on in the sets
  1913.  * "a" and "b".
  1914.  * "op" is the operation to be performed on the descriptor sets and
  1915.  * can take on the value of standard C bitwise operators.
  1916.  * The result of the operation is stored in "result".
  1917.  *
  1918.  * Returns the number of the highest descriptor set in "result".
  1919.  * NOTES:
  1920.  * Operators supported is: AND ('&') and XOR ('^')
  1921.  */
  1923. int
  1924. methodisset __P((int method, const int *methodv, size_t methodc));
  1925. /*
  1926.  * Returns true if the method "method" is set in "methodv", false otherwise.
  1927.  * "methodc" is the length of "methodv".
  1928.  */
  1930. int
  1931. socketoptdup __P((int s));
  1932. /*
  1933.  * Duplicates the settings of "s" and returns a new socket with the
  1934.  * same settings.
  1935.  * Returns:
  1936.  * On success: the descriptor for the new socket
  1937.  * On failure: -1
  1938.  */
  1940. int
  1941. socks_mklock __P((const char *template));
  1942. /*
  1943.  * Creates a filedescriptor that can be used with socks_lock() and
  1944.  * socks_unlock().
  1945.  * Returns:
  1946.  * On success: filedescriptor
  1947.  * On failure: -1
  1948.  */
  1950. int
  1951. socks_lock __P((int fd, int type, int timeout));
  1952. /*
  1953.  * Looks the filedescriptor "fd".
  1954.  * "type" is the type of lock; F_RDLCK or F_WRLCK.
  1955.  * "timeout" is how long to wait for lock, supported values:
  1956.  * -1: forever.
  1957.  * 0 : don't wait.
  1958.  * Returns:
  1959.  * On success: 0
  1960.  * On error  : -1
  1961.  */
  1963. void
  1964. socks_unlock __P((int d));
  1965. /*
  1966.  * Unlocks the filedescriptor "d", previously locked by this process.
  1967.  */
  1970. #if defined(DEBUG) || HAVE_SOLARIS_BUGS
  1972. int
  1973. freedescriptors __P((const char *message));
  1974. /*
  1975.  * Returns the number on unallocated descriptors.
  1976.  */
  1978. #endif /* DEBUG) || HAVE_SOLARIS_BUGS */
  1981. #ifdef DEBUG
  1983. int
  1984. fd_isset __P((int fd, fd_set *fdset));
  1985. /* function version of FD_ISSET() */
  1987. #endif /* DEBUG */
  1989. /* replacements */
  1991. #if !HAVE_DAEMON
  1992. int daemon __P((int, int));
  1993. #endif  /* !HAVE_DAEMON */
  1995. #if !HAVE_GETDTABLESIZE
  1996. /* return upper limit on per-process open file descriptors */
  1997. int getdtablesize __P((void));
  1998. #endif  /* !HAVE_GETDTABLESIZE */
  2000. #if !HAVE_SNPRINTF
  2001. # ifdef STDC_HEADERS
  2002. int snprintf __P((char *, size_t, char const *, ...));
  2003. # else
  2004. int snprintf ();
  2005. # endif /* STDC_HEADERS */
  2006. int vsnprintf __P((char *, size_t, const char *, va_list));
  2007. #endif /* !HAVE_SNPRINTF */
  2009. #if !HAVE_SETPROCTITLE
  2010. #ifdef STDC_HEADERS
  2011. void setproctitle __P((const char *fmt, ...));
  2012. int initsetproctitle __P((int, char **, char **));
  2013. #else
  2014. void setproctitle();
  2015. int initsetproctitle __P((int, char **, char **));
  2016. #endif  /* STDC_HEADERS */
  2017. #endif  /* !HAVE_SETPROCTITLE */
  2019. #if !HAVE_SOCKATMARK
  2020. int sockatmark __P((int));
  2021. #endif  /* !HAVE_SOCKATMARK */
  2023. #if !HAVE_INET_ATON
  2024. int inet_aton __P((register const char *cp, struct in_addr *addr));
  2025. #endif  /* ! HAVE_ATON */
  2027. #if !HAVE_GETDTABLESIZE
  2028. int getdtablesize __P((void));
  2029. #endif  /* ! HAVE_GETDTABLESIZE */
  2031. #if !HAVE_STRERROR
  2032. char *__strerror __P((int, char *));
  2033. char *strerror __P((int));
  2034. const char *hstrerror __P((int));
  2035. #endif  /* !HAVE_STRERROR */
  2037. #if !HAVE_MEMMOVE
  2038. void * memmove __P((void *, const void *, register size_t));
  2039. #endif  /* !HAVE_MEMMOVE */
  2041. #if !HAVE_INET_PTON
  2042. int inet_pton __P((int af, const char *src, void *dst));
  2043. #endif
  2045. #if !HAVE_ISSETUGID
  2046. int issetugid __P((void));
  2047. #endif  /* !HAVE_ISSETUGID */
  2049. #if !HAVE_VSYSLOG
  2050. void vsyslog __P((int, const char *, va_list));
  2051. #endif  /* !HAVE_VSYSLOG */
  2053. __END_DECLS
  2055. /* XXX */
  2056. #if defined(SOCKS_CLIENT) || defined(SOCKS_SERVER)
  2057. #if SOCKS_CLIENT
  2058. #include "socks.h"
  2059. #endif
  2060. #if SOCKS_SERVER
  2061. #include "sockd.h"
  2062. #endif  /* SOCKS_CLIENT */
  2063. #endif  /* SOCKS_CLIENT || SOCKS_SERVER */