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

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

代理服务器

开发平台：

Unix_Linux

wrap.c：源码内容
  1. /* Copyright (c) 1995,1996,1997 NEC Corporation.  All rights reserved.       */
  2. /*                                                                           */
  3. /* The redistribution, use and modification in source or binary forms of     */
  4. /* this software is subject to the conditions set forth in the copyright     */
  5. /* document ("Copyright") included with this distribution.                   */
  7. /*
  8.  * $Id: wrap.c,v 1.53.2.1.2.6 1998/11/04 00:03:28 steve Exp $
  9.  */
  11. #define HIDEORIG
  12. #include "socks5p.h"
  13. #include "protocol.h"
  14. #include "buffer.h"
  15. #include "addr.h"
  16. #include "wrap.h"
  17. #include "wrap_tcp.h"
  18. #include "wrap_udp.h"
  19. #include "confutil.h"
  20. #include "cache.h"
  21. #include "hostname.h"
  22. #include "log.h"
  24. int lsInRLDFunctions = 0;
  25. int lsInWrapFunction = 0;
  27. /* This macro (w/o do...while(0)) scares me, but it gets rid of a lot of     */
  28. /* warnings with Solaris's cc.                                               */
  29. #define DLRETURN(var, rval, exp) (rval) = (exp); (var) = 0; return (rval)
  31. static int lsSocketType(S5IOHandle fd, const ss *name) {
  32.     int optval, optlen = sizeof(int), slen = sizeof(S5NetAddr), eno = GETERRNO();
  33.     S5NetAddr na;
  35.     memset(&na, 0, sizeof(na));
  37.     if (REAL(getsockname)(fd, &na.sa, &slen) < 0) return -1;
  39.     if ((!ISINET(&na.sa) && !ISUNSPEC(&na.sa)) || (ISUNSPEC(&na.sa) && (!name || !ISINET(name)))) return -1;
  41.     if (getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&optval, &optlen) < 0) return -1;
  43.     SETERRNO(eno);
  44.     return optval;
  45. }
  47. /* wrapper around the shutdown system call.  This could be kind of tricky:   */
  48. /* may be we should keep track of SHUTDOWN status as read or write may be    */
  49. /* still allowed even after shutdown, depending on the value of howto XXX    */
  50. int LIBPREFIX(shutdown)(S5IOHandle fd, int howto) {
  51. #ifdef FOR_SHARED_LIBRARY
  52.     if (lsInRLDFunctions || lsInWrapFunction) return REAL(shutdown)(fd, howto);
  53. #endif
  54.     if (!lsConnectionCached(fd)) return REAL(shutdown)(fd, howto);
  56.     lsInWrapFunction = 1;
  57.     LIBPREFIX2(init)("libsocks5");
  58.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS shutdown: FAKE");
  59.     lsConnectionDel(fd);
  60.     lsInWrapFunction = 0;
  62.     return REAL(shutdown)(fd, howto);
  63. }
  65. /* wrapper around the connect system call.                                   */
  66. int LIBPREFIX(connect)(S5IOHandle sd, CONST ss *name, int namelen) {
  67.     int rval;
  69. #ifdef FOR_SHARED_LIBRARY
  70.     if (lsInRLDFunctions || lsInWrapFunction) return REAL(connect)(sd, (ss *)name, namelen);
  71. #endif
  73.     lsInWrapFunction = 1;
  74.     LIBPREFIX2(init)("libsocks5");
  76.     switch (lsSocketType(sd, name)) {
  77.     case SOCK_DGRAM:
  78. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS connect: FAKE");
  79.         DLRETURN(lsInWrapFunction, rval, lsUdpConnect(sd, name, namelen));
  80.     case SOCK_STREAM:
  81. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS connect: FAKE");
  82.         DLRETURN(lsInWrapFunction, rval, lsTcpConnect(sd, name, namelen));
  83.     default:
  84.         S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS connect: REAL");
  85.         DLRETURN(lsInWrapFunction, rval, REAL(connect)(sd, (ss *)name, namelen));
  86.     }
  87. }
  89. /* wrapper around the bind system call.                                      */
  90. int LIBPREFIX(bind)(S5IOHandle sd, CONST ss *name, int namelen) {
  91.     int rval;
  93. #ifdef FOR_SHARED_LIBRARY
  94.     if (lsInRLDFunctions || lsInWrapFunction) return REAL(bind)(sd, (ss *)name, namelen);
  95. #endif
  97.     lsInWrapFunction = 1;
  98.     LIBPREFIX2(init)("libsocks5");
  100.     switch (lsSocketType(sd, name)) {
  101.     case SOCK_STREAM:
  102. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS bind: FAKE");
  103.         DLRETURN(lsInWrapFunction, rval, lsTcpBind(sd, name, namelen));
  104.     case SOCK_DGRAM:
  105. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS bind: FAKE");
  106.         DLRETURN(lsInWrapFunction, rval, lsUdpBind(sd, name, namelen));
  107.     default:
  108. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS bind: REAL");
  109.         DLRETURN(lsInWrapFunction, rval, REAL(bind)(sd, (ss *)name, namelen));
  110.     }
  111. }
  113. /* wrapper around the getsockname system call.                               */
  114. int LIBPREFIX(getsockname)(S5IOHandle sd, struct sockaddr *name, int *namelen) {
  115.     int rval;
  117. #ifdef FOR_SHARED_LIBRARY
  118.     if (lsInRLDFunctions || lsInWrapFunction) return REAL(getsockname)(sd, name, namelen);
  119. #endif
  120.     if (!lsConnectionCached(sd)) return REAL(getsockname)(sd, name, namelen);
  122.     lsInWrapFunction = 1;
  123.     LIBPREFIX2(init)("libsocks5");
  125.     switch (lsSocketType(sd, NULL)) {
  126.     case SOCK_STREAM:
  127. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS getsockname: FAKE");
  128.         DLRETURN(lsInWrapFunction, rval, lsTcpGetsockname(sd, name, namelen));
  129.     case SOCK_DGRAM:
  130. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS getsockname: FAKE");
  131.         DLRETURN(lsInWrapFunction, rval, lsUdpGetsockname(sd, name, namelen));
  132.     default:
  133.         S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS getsockname: REAL");
  134.         DLRETURN(lsInWrapFunction, rval, REAL(getsockname)(sd, name, namelen));
  135.     }
  136. }
  138. /* wrapper around the getpeername system call.                               */
  139. int LIBPREFIX(getpeername)(S5IOHandle sd, struct sockaddr *name, int *namelen) {
  140.     int rval;
  142. #ifdef FOR_SHARED_LIBRARY
  143.     if (lsInRLDFunctions || lsInWrapFunction) return REAL(getpeername)(sd, name, namelen);
  144. #endif
  145.     if (!lsConnectionCached(sd)) return REAL(getpeername)(sd, name, namelen);
  147.     lsInWrapFunction = 1;
  148.     LIBPREFIX2(init)("libsocks5");
  150.     switch (lsSocketType(sd, NULL)) {
  151.     case SOCK_DGRAM:
  152. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS getpeername: FAKE");
  153.         DLRETURN(lsInWrapFunction, rval, lsUdpGetpeername(sd, name, namelen)); 
  154.     case SOCK_STREAM:
  155. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS getpeername: FAKE");
  156.         DLRETURN(lsInWrapFunction, rval, lsTcpGetpeername(sd, name, namelen));
  157.     default:
  158.         S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS getpeername: REAL");
  159.         DLRETURN(lsInWrapFunction, rval, REAL(getpeername)(sd, name, namelen));
  160.     }
  161. }
  163. /* wrapper around the send system call.                                      */
  164. IORETTYPE LIBPREFIX(send)(S5IOHandle sd, const IOPTRTYPE msg, IOLENTYPE len, int flags) {
  165.     int rval;
  167. #ifdef FOR_SHARED_LIBRARY
  168.     if (lsInRLDFunctions || lsInWrapFunction) return REAL(send)(sd, msg, len, flags);
  169. #endif
  171.     lsInWrapFunction = 1;
  172.     LIBPREFIX2(init)("libsocks5");
  174.     switch (lsSocketType(sd, NULL)) {
  175.     case SOCK_DGRAM:
  176. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS write: FAKE: Udp");
  177.         DLRETURN(lsInWrapFunction, rval, lsUdpSend(sd, msg, len, flags));
  178.     case SOCK_STREAM:
  179. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS write: FAKE: Tcp");
  180.         DLRETURN(lsInWrapFunction, rval, lsTcpSend(sd, msg, len, flags));
  181.     default:
  182. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS send: REAL: Wrong type");
  183.         DLRETURN(lsInWrapFunction, rval, -1);
  184.     }
  185. }
  187. /* wrapper around the sendto system call.                                    */
  188. IORETTYPE LIBPREFIX(sendto)(S5IOHandle sd, const IOPTRTYPE msg, IOLENTYPE len, int flags, struct sockaddr *to, int tolen) {
  189.     int rval;
  191. #ifdef FOR_SHARED_LIBRARY
  192.     if (lsInRLDFunctions || lsInWrapFunction) return REAL(sendto)(sd, msg, len, flags, to, tolen);
  193. #endif
  195.     lsInWrapFunction = 1;
  196.     LIBPREFIX2(init)("libsocks5");
  198.     switch (lsSocketType(sd, NULL)) {
  199.     case SOCK_DGRAM:
  200. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS sendto: FAKE: Udp");
  201.         DLRETURN(lsInWrapFunction, rval, lsUdpSendto(sd, msg, len, flags, to, tolen));
  202.     case SOCK_STREAM:
  203. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS sendto: FAKE: Tcp");
  204.         DLRETURN(lsInWrapFunction, rval, lsTcpSend(sd, msg, len, flags));
  205.     default:
  206. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS sendto: REAL: Wrong type");
  207.         DLRETURN(lsInWrapFunction, rval, -1);
  208.     }
  209. }
  211. /* wrapper around the recv system call.                                      */
  212. IORETTYPE LIBPREFIX(recv)(S5IOHandle sd, IOPTRTYPE msg, IOLENTYPE len, int flags) {
  213.     int rval;
  214.     
  215. #ifdef FOR_SHARED_LIBRARY
  216.     if (lsInRLDFunctions || lsInWrapFunction) return REAL(recv)(sd, msg, len, flags);
  217. #endif
  219.     lsInWrapFunction = 1;
  220.     LIBPREFIX2(init)("libsocks5");
  222.     switch (lsSocketType(sd, NULL)) {
  223.     case SOCK_DGRAM:
  224. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS recv: FAKE: Udp");
  225.         DLRETURN(lsInWrapFunction, rval, lsUdpRecvfrom(sd, msg, len, flags, NULL, NULL, 1));
  226.     case SOCK_STREAM:
  227. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS recv: FAKE: Tcp");
  228.         DLRETURN(lsInWrapFunction, rval, lsTcpRecv(sd, msg, len, flags));
  229.     default:
  230. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS recv: REAL: Wrong type");
  231. SETSOCKETERROR(EBADF);
  232.         DLRETURN(lsInWrapFunction, rval, -1);
  233.     }
  234. }
  236. /* wrapper around the recvfrom system call.                                  */
  237. IORETTYPE 
  238. LIBPREFIX(recvfrom)(S5IOHandle sd, IOPTRTYPE msg, IOLENTYPE len, int flags, ss *from, int *fromlen) 
  239. {
  240.     int rval;
  242. #ifdef FOR_SHARED_LIBRARY
  243.     if (lsInRLDFunctions || lsInWrapFunction) return REAL(recvfrom)(sd, msg, len, flags, from, fromlen);
  244. #endif
  246.     lsInWrapFunction = 1;
  247.     LIBPREFIX2(init)("libsocks5");
  249.     switch (lsSocketType(sd, NULL)) {
  251. case SOCK_DGRAM:
  252. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0,
  253. "SOCKS recv: FAKE: Udp");
  254. DLRETURN(lsInWrapFunction, rval, 
  255. lsUdpRecvfrom(sd, msg, len, flags, from, fromlen, 0));
  256.      case SOCK_STREAM:
  257.          S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS recv: FAKE: Tcp");
  258.          DLRETURN(lsInWrapFunction, rval, 
  259. lsTcpRecvfrom(sd, msg, len, flags, from, fromlen));
  260.      default:
  261. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0,
  262. "SOCKS recv: REAL: Wrong type");
  263. SETSOCKETERROR(EBADF);
  264. DLRETURN(lsInWrapFunction, rval, -1);
  265.     }
  266. }
  268. #ifdef HAVE_SENDMSG
  269. /* wrapper around the recvmsg system call.                                  */
  271. IORETTYPE
  272. LIBPREFIX(recvmsg)(S5IOHandle sd, ms *msg, int flags)
  273. {
  274. int rval;
  275.  
  276. #ifdef FOR_SHARED_LIBRARY
  277.     if(lsInRLDFunctions || lsInWrapFunction)
  278.      return REAL(recvmsg)(sd, msg, flags);
  279. #endif
  280.  
  281.     lsInWrapFunction = 1;
  282.     LIBPREFIX2(init)("libsocks5");
  283.  
  284.     switch (lsSocketType(sd, NULL)) {
  285. case SOCK_DGRAM:
  286.             S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0,
  287. "SOCKS recvmsg: FAKE: Udp");
  288.             DLRETURN(lsInWrapFunction, rval, lsUdpRecvmsg(sd, msg, flags));
  290.         case SOCK_STREAM:
  291.             S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0,
  292. "SOCKS recvmsg: FAKE: Tcp");
  293.             DLRETURN(lsInWrapFunction, rval, lsTcpRecvmsg(sd, msg, flags));
  295.         default:
  296.             S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0,
  297. "SOCKS recvmsg: REAL: Wrong type");
  298. SETSOCKETERROR(EBADF);
  299.             DLRETURN(lsInWrapFunction, rval, -1);
  300.     }
  301. }
  303. /* wrapper around the sendmsg system call.                                  */
  304. IORETTYPE
  305. LIBPREFIX(sendmsg)(S5IOHandle sd,ms *msg, int flags)
  306. {
  307. int rval;
  308.  
  309. #ifdef FOR_SHARED_LIBRARY
  310.     if(lsInRLDFunctions || lsInWrapFunction)
  311.      return REAL(sendmsg)(sd, msg, flags);
  312. #endif
  313.  
  314.     lsInWrapFunction = 1;
  315.     LIBPREFIX2(init)("libsocks5");
  316.  
  317.     switch (lsSocketType(sd, NULL)) {
  319.         case SOCK_DGRAM:
  320.             S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0,
  321. "SOCKS sendmsg: FAKE: Udp");
  322.             DLRETURN(lsInWrapFunction, rval, lsUdpSendmsg(sd, msg, flags));
  324.         case SOCK_STREAM:
  325.             S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0,
  326. "SOCKS sendmsg: FAKE: Tcp");
  327.             DLRETURN(lsInWrapFunction, rval, lsTcpSendmsg(sd, msg, flags));
  329.         default:
  330.             S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0,
  331. "SOCKS sendmsg: REAL: Wrong type");
  332. SETSOCKETERROR(EBADF);
  333.             DLRETURN(lsInWrapFunction, rval, -1);
  334.     }
  335. }
  336. #endif  /* HAVE_SENDMSG */
  339. /* wrapper around the close system call.  Not strictly necessary, but it     */
  340. /* cleans up some things, so it is kind of nice to call...                   */
  341. int LIBPREFIX(close)(S5IOHandle fd) {
  342.     int rval;
  344. #ifdef FOR_SHARED_LIBRARY
  345.     if (lsInRLDFunctions || lsInWrapFunction) return REAL(close)(fd);
  346. #endif
  347.     if (!lsConnectionCached(fd)) return REAL(close)(fd);
  349.     lsInWrapFunction = 1;
  350.     LIBPREFIX2(init)("libsocks5");
  351.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS close: FAKE");
  353.     if (getenv("SOCKS5_PRESERVE_STDERR") && fd == STDERR_FILENO) {
  354. DLRETURN(lsInWrapFunction, rval, 0);
  355.     }
  357.     lsConnectionDel(fd);
  358.     DLRETURN(lsInWrapFunction, rval, REAL(close)(fd));
  359. }
  361. /* wrapper around the fclose stdio library function...See comment for close. */
  362. int LIBPREFIX(fclose)(FILE *fp) {
  363.     int rval;
  365. #ifdef FOR_SHARED_LIBRARY
  366.     if (lsInRLDFunctions || lsInWrapFunction || fp == NULL) return REAL(fclose)(fp);
  367. #endif
  368.     if (!lsConnectionCached(fileno(fp))) return REAL(fclose)(fp);
  370.     lsInWrapFunction = 1;
  371.     LIBPREFIX2(init)("libsocks5");
  372.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS fclose: FAKE");
  374.     if (getenv("SOCKS5_PRESERVE_STDERR") && fileno(fp) == STDERR_FILENO) {
  375. DLRETURN(lsInWrapFunction, rval, 0);
  376.     }
  378.     lsConnectionDel(fileno(fp));
  379.     DLRETURN(lsInWrapFunction, rval, REAL(fclose)(fp));
  380. }
  382. IORETTYPE LIBPREFIX(write)(S5IOHandle sd, const IOPTRTYPE buf, IOLENTYPE buflen) {
  383.     int rval;
  385. #ifdef FOR_SHARED_LIBRARY
  386.     if (lsInRLDFunctions || lsInWrapFunction) return REAL(write)(sd, buf, buflen);
  387. #endif
  389.     lsInWrapFunction = 1;
  390.     LIBPREFIX2(init)("libsocks5");
  392.     switch (lsSocketType(sd, NULL)) {
  393.     case SOCK_DGRAM:
  394. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS write: FAKE: Udp");
  395. DLRETURN(lsInWrapFunction, rval, lsUdpSend(sd, buf, buflen, 0));
  396.     case SOCK_STREAM:
  397. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS write: FAKE: Tcp");
  398. DLRETURN(lsInWrapFunction, rval, lsTcpSend(sd, buf, buflen, 0));
  399.     default:
  400. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS write: REAL: Wrong type");
  401. DLRETURN(lsInWrapFunction, rval, REAL(write)(sd, buf, buflen));
  402.     }
  403. }
  405. IORETTYPE LIBPREFIX(read)(S5IOHandle sd, IOPTRTYPE buf, IOLENTYPE buflen) {
  406.     int rval;
  407.     
  408. #ifdef FOR_SHARED_LIBRARY
  409.     if (lsInRLDFunctions || lsInWrapFunction) return REAL(read)(sd, buf, buflen);
  410. #endif
  412.     lsInWrapFunction = 1;
  413.     LIBPREFIX2(init)("libsocks5");
  415.     switch (lsSocketType(sd, NULL)) {
  416.     case SOCK_DGRAM:
  417. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS read: FAKE: Udp");
  418. DLRETURN(lsInWrapFunction, rval, lsUdpRecvfrom(sd, buf, buflen, 0, NULL, NULL, 1));
  419.     case SOCK_STREAM:
  420. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS read: FAKE: Tcp");
  421. DLRETURN(lsInWrapFunction, rval, lsTcpRecv(sd, buf, buflen, 0));
  422.     default:
  423. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS read: REAL: Wrong type");
  424. DLRETURN(lsInWrapFunction, rval, REAL(read)(sd, buf, buflen));
  425.     }
  426. }
  428. S5IOHandle LIBPREFIX(dup)(S5IOHandle sd) {
  429.     lsSocksInfo *pcon, *ncon, *q;
  430.     lsProxyInfo *pri;
  431.     S5IOHandle s2;
  433. #ifdef FOR_SHARED_LIBRARY
  434.     if (lsInRLDFunctions || lsInWrapFunction) return REAL(dup)(sd);
  435. #endif
  436.     if (!lsConnectionCached(sd)) return REAL(dup)(sd);
  438.     lsInWrapFunction = 1;
  439.     LIBPREFIX2(init)("libsocks5");
  441.     /* Solaris (who knows why) occasionally gives you back a different type  */
  442.     /* of file descriptor after a DUP (e.g. SOCK_STREAM vs SOCK_DGRAM).  It  */
  443.     /* seems to mistakenly leave whatever label was there beforehand.  So,   */
  444.     /* we'll dup2 over a socket that we know is the right type instead...    */
  445.     /*                                                                       */
  446.     /* XXX Proposed new fix - Not tested - blob                              */
  447. #if defined(sun) && defined(__svr4__)
  448.     {
  449.      S5IOHandle tmpsd;
  450. int type = lsSocketType(sd, NULL);
  452.      if (type == -1 || (tmpsd = socket(AF_INET, type, 0)) == S5InvalidIOHandle) {
  453.     s2 = REAL(dup)(sd);
  454. } else if ((s2 = REAL(dup2)(sd, tmpsd)) == S5InvalidIOHandle) {
  455.          REAL(close)(tmpsd);
  456. }
  457.     }
  458. #else
  459.     s2 = REAL(dup)(sd);
  460. #endif
  461.     if (s2 == S5InvalidIOHandle) {
  462. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS dup: dup failed: %m");
  463.      lsInWrapFunction = 0;
  464. return S5InvalidIOHandle;
  465.     }
  466.     
  467.     if ((pcon = lsConnectionFind(sd)) == NULL) {
  468. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS dup: no connection found");
  469.      lsInWrapFunction = 0;
  470. return s2;
  471.     }
  473.     if ((ncon = lsConnectionFind(s2)) != NULL) {
  474. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS dup: deleting invalid connection found");
  475. lsConnectionDel(s2);
  476.     }
  478.     if ((ncon = lsConnectionAdd(s2)) == NULL) {
  479. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS dup: couldn't add connection");
  480. REAL(close)(s2);
  481. SETSOCKETERROR(EMFILE);
  482.      lsInWrapFunction = 0;
  483. return S5InvalidIOHandle;
  484.     }
  486.     q = ncon->next;
  487.     *ncon = *pcon;
  488.     ncon->fd = s2;
  489.     ncon->next = q;
  491.     for (pri = ncon->pri; pri; pri = pri->next) pri->refcount++;
  492.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS dup: done");
  493.     lsInWrapFunction = 0;
  494.     return s2;
  495. }
  497. S5IOHandle LIBPREFIX(dup2)(S5IOHandle sd, S5IOHandle s2) {
  498.     lsSocksInfo *pcon, *ncon, *q;
  499.     lsProxyInfo *pri;
  501. #ifdef FOR_SHARED_LIBRARY
  502.     if (lsInRLDFunctions || lsInWrapFunction) return REAL(dup2)(sd, s2);
  503. #endif
  504.     if (!lsConnectionCached(sd)) return REAL(dup2)(sd, s2);
  506.     lsInWrapFunction = 1;
  507.     LIBPREFIX2(init)("libsocks5");
  509.     if (getenv("SOCKS5_PRESERVE_STDERR") && s2 == STDERR_FILENO) {
  510. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS dup2: leaving stderr alone (by request)");
  511.      lsInWrapFunction = 0;
  512. return s2;
  513.     }
  515.     if ((s2 = REAL(dup2)(sd, s2)) == S5InvalidIOHandle) {
  516. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS dup2: dup2 failed");
  517.      lsInWrapFunction = 0;
  518. return S5InvalidIOHandle;
  519.     }
  520.     
  521.     if ((pcon = lsConnectionFind(sd)) == NULL) {
  522. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS dup2: no connection found");
  523.      lsInWrapFunction = 0;
  524. return s2;
  525.     }
  527.     if ((ncon = lsConnectionFind(s2)) != NULL) {
  528. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS dup2: deleting invalid connection found");
  529. lsConnectionDel(s2);
  530.     }
  532.     if ((ncon = lsConnectionAdd(s2)) == NULL) {
  533. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS dup2: couldn't add connection");
  534. REAL(close)(s2);
  535. SETSOCKETERROR(EMFILE);
  536.      lsInWrapFunction = 0;
  537. return S5InvalidIOHandle;
  538.     }
  540.     q = ncon->next;
  541.     *ncon = *pcon;
  542.     ncon->fd = s2;
  543.     ncon->next = q;
  545.     for (pri = ncon->pri; pri; pri = pri->next) pri->refcount++;
  546.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS dup2: done");
  547.     lsInWrapFunction = 0;
  548.     return s2;
  549. }
  551. struct tm *LIBPREFIX(localtime)(const time_t *clock) {
  552.     struct tm *rval;
  554. #ifdef FOR_SHARED_LIBRARY
  555.     if (lsInRLDFunctions || lsInWrapFunction) return REAL(localtime)(clock);
  556. #endif
  558.     lsInWrapFunction = 1;
  559.     LIBPREFIX2(init)("libsocks5");
  560.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS localtime: FAKE");
  562.     rval = REAL(localtime)(clock);
  563.     lsInWrapFunction = 0;
  564.     return rval;
  565. }
  567. void LIBPREFIX(longjmp)(jmp_buf env, int val) {
  568. #ifdef FOR_SHARED_LIBRARY
  569.     if (!lsInWrapHostname) lsInWrapFunction = 0;
  570. #endif
  572.     LIBPREFIX2(init)("libsocks5");
  573.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(12), 0, "SOCKS longjmp: FAKE");
  574.     REAL(longjmp)(env, val);
  575. }
  577. #ifndef FOR_SHARED_LIBRARY
  578. #ifdef HAVE_STDARG_H
  579. #include <stdarg.h>
  580. #define VA_START(a, b) va_start((a), (b))
  581. #define va_alist ...
  582. #define va_dcl
  583. #else
  584. #include <varargs.h>
  585. #define VA_START(a, b) va_start((a))
  586. #endif
  588. int LIBPREFIX(fprintf)(FILE *fp, const char *format, va_alist) va_dcl {
  589.     char buf[2048];
  590.     va_list pvar;
  591.     int retval, optval;
  592.     int optlen = sizeof(int);
  593.     S5IOHandle sd = fileno(fp);
  595. #ifdef HAVE_STDARG_H
  596.     va_start(pvar, format);
  597. #else
  598.     VA_START(pvar, format);
  599. #endif
  601.     if (getsockopt(fileno(fp), SOL_SOCKET, SO_TYPE, (char *)&optval, &optlen) < 0)
  602. retval = REAL(vfprintf)(fp, format, pvar);
  603.     else {
  604. vsprintf(buf, format, pvar);
  605. retval = LIBPREFIX(write)(sd, buf, strlen(buf));
  606.     }
  608.     va_end(pvar);
  609.     return retval;
  610. }
  612. int LIBPREFIX(vfprintf)(FILE *fp, const char *format, va_list pvar) {
  613.     char buf[2048];
  614.     int optval;
  615.     int optlen = sizeof(int);
  616.     S5IOHandle sd = fileno(fp);
  618.     if (getsockopt(fileno(fp), SOL_SOCKET, SO_TYPE, (char *)&optval, &optlen) < 0)
  619. return REAL(vfprintf)(fp, format, pvar);
  620.     else {
  621. vsprintf(buf, format, pvar);
  622. return LIBPREFIX(write)(sd, buf, strlen(buf));
  623.     }
  624. }
  626. int LIBPREFIX(getc)(FILE *fp) {
  627.     u_char c;
  628.     int optval;
  629.     int optlen = sizeof(int);
  630.     S5IOHandle sd = fileno(fp);
  632.     if (getsockopt(fileno(fp), SOL_SOCKET, SO_TYPE, (char *)&optval, &optlen) < 0)
  633. return REAL(getc)(fp);
  634.     else {
  635. if (LIBPREFIX(read)(sd, &c, 1) != 1) return EOF;
  636. return (int)c;
  637.     }
  638. }
  640. #endif /* FOR_SHARED_LIBRARY */