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

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

代理服务器

开发平台：

Unix_Linux

interposition.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. #define WE_DONT_WANT_NO_SOCKADDR_ARG_UNION
  46. #include "common.h"
  48. #if SOCKSLIBRARY_DYNAMIC
  50. #include "interposition.h"
  52. static const char rcsid[] =
  53. "$Id: interposition.c,v 1.53 1999/09/25 13:10:31 karls Exp $";
  55. #undef accept
  56. #undef bind
  57. #undef bindresvport
  58. #undef connect
  59. #undef gethostbyname
  60. #undef gethostbyname2
  61. #undef getpeername
  62. #undef getsockname
  63. #undef read
  64. #undef readv
  65. #undef recv
  66. #undef recvfrom
  67. #undef recvmsg
  68. #undef rresvport
  69. #undef send
  70. #undef sendmsg
  71. #undef sendto
  72. #undef write
  73. #undef writev
  75. #if NEED_DYNA_RTLD
  76. #define DL_LAZY RTLD_LAZY
  77. #endif  /* NEED_DYNA_RTLD */
  79. static struct libsymbol_t libsymbolv[] = {
  80. { SYMBOL_ACCEPT, LIBRARY_ACCEPT },
  81. { SYMBOL_BIND, LIBRARY_BIND },
  82. { SYMBOL_BINDRESVPORT, LIBRARY_BINDRESVPORT },
  83. { SYMBOL_CONNECT, LIBRARY_CONNECT },
  84. { SYMBOL_GETHOSTBYNAME, LIBRARY_GETHOSTBYNAME },
  85. { SYMBOL_GETHOSTBYNAME2, LIBRARY_GETHOSTBYNAME2 },
  86. { SYMBOL_GETPEERNAME, LIBRARY_GETPEERNAME },
  87. { SYMBOL_GETSOCKNAME, LIBRARY_GETSOCKNAME },
  88. { SYMBOL_READ, LIBRARY_READ },
  89. { SYMBOL_READV, LIBRARY_READV },
  90. { SYMBOL_RECV, LIBRARY_RECV },
  91. { SYMBOL_RECVMSG, LIBRARY_RECVMSG },
  92. { SYMBOL_RECVFROM, LIBRARY_RECVFROM },
  93. { SYMBOL_RRESVPORT, LIBRARY_RRESVPORT },
  94. { SYMBOL_SEND, LIBRARY_SEND },
  95. { SYMBOL_SENDMSG, LIBRARY_SENDMSG },
  96. { SYMBOL_SENDTO, LIBRARY_SENDTO },
  97. { SYMBOL_WRITE, LIBRARY_WRITE },
  98. { SYMBOL_WRITEV, LIBRARY_WRITEV },
  99. #if HAVE_EXTRA_OSF_SYMBOLS
  100. { SYMBOL_EACCEPT, LIBRARY_EACCEPT },
  101. { SYMBOL_EGETPEERNAME, LIBRARY_EGETPEERNAME },
  102. {  SYMBOL_EGETSOCKNAME, LIBRARY_EGETSOCKNAME },
  103. { SYMBOL_EREADV, LIBRARY_EREADV },
  104. { SYMBOL_ERECVFROM, LIBRARY_ERECVFROM },
  105. { SYMBOL_ERECVMSG, LIBRARY_ERECVMSG },
  106. {  SYMBOL_ESENDMSG, LIBRARY_ESENDMSG },
  107. { SYMBOL_EWRITEV, LIBRARY_EWRITEV },
  109. { SYMBOL_NACCEPT, LIBRARY_EACCEPT },
  110. { SYMBOL_NGETPEERNAME, LIBRARY_NGETPEERNAME },
  111. { SYMBOL_NGETSOCKNAME, LIBRARY_NGETSOCKNAME },
  112. {  SYMBOL_NRECVFROM, LIBRARY_NRECVFROM },
  113. {  SYMBOL_NRECVMSG, LIBRARY_NRECVMSG },
  114. { SYMBOL_NSENDMSG, LIBRARY_NSENDMSG },
  115. #endif  /* HAVE_EXTRA_OSF_SYMBOLS */
  118. };
  120. __BEGIN_DECLS
  122. static struct libsymbol_t *
  123. libsymbol __P((const char *symbol));
  124. /*
  125.  * Finds the libsymbol_t that "symbol" is defined in.
  126.  */
  128. __END_DECLS
  130. static struct libsymbol_t *
  131. libsymbol(symbol)
  132. const char *symbol;
  133. {
  134. const char *function = "libsymbol()";
  135. size_t i;
  137. for (i = 0; i < ELEMENTS(libsymbolv); ++i)
  138. if (strcmp(libsymbolv[i].symbol, symbol) == 0)
  139. return &libsymbolv[i];
  141. serrx(1, "%s: configuration error, can't find symbol %s", function, symbol);
  142. return NULL; /* please compiler. */
  143. }
  146. void *
  147. symbolfunction(symbol)
  148. char *symbol;
  149. {
  150. const char *function = "symbolfunction()";
  151. struct libsymbol_t *lib;
  153. lib = libsymbol(symbol);
  155. SASSERTX(lib != NULL);
  156. SASSERTX(lib->library != NULL);
  157. SASSERTX(strcmp(lib->symbol, symbol) == 0);
  159. if (lib->handle == NULL)
  160. if ((lib->handle = dlopen(lib->library, DL_LAZY)) == NULL)
  161. serrx(EXIT_FAILURE, "%s: %s: %s", function, lib->library, dlerror());
  163. if (lib->function == NULL)
  164. if ((lib->function = dlsym(lib->handle, symbol)) == NULL)
  165. serrx(EXIT_FAILURE, "%s: %s: %s", function, symbol, dlerror());
  167. #if 0
  168. if (strcmp(symbol, SYMBOL_WRITE) != 0)
  169. slog(LOG_DEBUG, "found symbol %s in library %s",
  170. lib->symbol, lib->library);
  171. #endif
  173. return lib->function;
  174. }
  177. /* the real system calls. */
  179. #if !HAVE_EXTRA_OSF_SYMBOLS
  180. HAVE_PROT_ACCEPT_0
  181. sys_accept(s, addr, addrlen)
  182. HAVE_PROT_ACCEPT_1 s;
  183. HAVE_PROT_ACCEPT_2 addr;
  184. HAVE_PROT_ACCEPT_3 addrlen;
  185. {
  186. int rc;
  187. HAVE_PROT_ACCEPT_0 (*function)(HAVE_PROT_ACCEPT_1 s, HAVE_PROT_ACCEPT_2 addr, HAVE_PROT_ACCEPT_3 addrlen);
  189. SYSCALL_START(s);
  190. function = symbolfunction(SYMBOL_ACCEPT);
  191. rc = function(s, addr, addrlen);
  192. SYSCALL_END(s);
  193. return rc;
  194. }
  195. #endif  /* !HAVE_EXTRA_OSF_SYMBOLS */
  197. #if !HAVE_EXTRA_OSF_SYMBOLS
  198. HAVE_PROT_BIND_0
  199. sys_bind(s, name, namelen)
  200. HAVE_PROT_BIND_1 s;
  201. HAVE_PROT_BIND_2 name;
  202. HAVE_PROT_BIND_3 namelen;
  203. {
  204. int rc;
  205. HAVE_PROT_BIND_0 (*function)(HAVE_PROT_BIND_1 s, HAVE_PROT_BIND_2 name, HAVE_PROT_BIND_3 namelen);
  207. SYSCALL_START(s);
  208. function = symbolfunction(SYMBOL_BIND);
  209. rc = function(s, name, namelen);
  210. SYSCALL_END(s);
  211. return rc;
  212. }
  213. #endif /* !HAVE_EXTRA_OSF_SYMBOLS */
  215. int
  216. sys_bindresvport(sd, sin)
  217. int sd;
  218. struct sockaddr_in *sin;
  219. {
  220. int rc;
  221. int (*function)(int sd, struct sockaddr_in *sin);
  223. SYSCALL_START(sd);
  224. function = symbolfunction(SYMBOL_BINDRESVPORT);
  225. rc = function(sd, sin);
  226. SYSCALL_END(sd);
  227. return rc;
  228. }
  230. #if !HAVE_EXTRA_OSF_SYMBOLS
  231. HAVE_PROT_CONNECT_0
  232. sys_connect(s, name, namelen)
  233. HAVE_PROT_CONNECT_1 s;
  234. HAVE_PROT_CONNECT_2 name;
  235. HAVE_PROT_CONNECT_3 namelen;
  236. {
  237. int rc;
  238. HAVE_PROT_CONNECT_0 (*function)(HAVE_PROT_CONNECT_1 s, HAVE_PROT_CONNECT_2 name, HAVE_PROT_CONNECT_3 namelen);
  240. SYSCALL_START(s);
  241. function = symbolfunction(SYMBOL_CONNECT);
  242. rc = function(s, name, namelen);
  243. SYSCALL_END(s);
  244. return rc;
  245. }
  246. #endif /* !HAVE_EXTRA_OSF_SYMBOLS */
  248. struct hostent *
  249. sys_gethostbyname(name)
  250. const char *name;
  251. {
  252. struct hostent *(*function)(const char *name);
  254. function = symbolfunction(SYMBOL_GETHOSTBYNAME);
  255. return function(name);
  256. }
  258. struct hostent *
  259. sys_gethostbyname2(name, af)
  260. const char *name;
  261. int af;
  262. {
  263. struct hostent *(*function)(const char *name, int af);
  265. function = symbolfunction(SYMBOL_GETHOSTBYNAME2);
  266. return function(name, af);
  267. }
  269. #if !HAVE_EXTRA_OSF_SYMBOLS
  270. HAVE_PROT_GETPEERNAME_0
  271. sys_getpeername(s, name, namelen)
  272. HAVE_PROT_GETPEERNAME_1 s;
  273. HAVE_PROT_GETPEERNAME_2 name;
  274. HAVE_PROT_GETPEERNAME_3 namelen;
  275. {
  276. int rc;
  277. HAVE_PROT_GETPEERNAME_0 (*function)(HAVE_PROT_GETPEERNAME_1 s, HAVE_PROT_GETPEERNAME_2 name, HAVE_PROT_GETPEERNAME_3 namelen);
  279. SYSCALL_START(s);
  280. function = symbolfunction(SYMBOL_GETPEERNAME);
  281. rc = function(s, name, namelen);
  282. SYSCALL_END(s);
  283. return rc;
  284. }
  285. #endif /* ! HAVE_EXTRA_OSF_SYMBOLS */
  287. #if !HAVE_EXTRA_OSF_SYMBOLS
  288. HAVE_PROT_GETSOCKNAME_0
  289. sys_getsockname(s, name, namelen)
  290. HAVE_PROT_GETSOCKNAME_1 s;
  291. HAVE_PROT_GETSOCKNAME_2 name;
  292. HAVE_PROT_GETSOCKNAME_3 namelen;
  293. {
  294. int rc;
  295. HAVE_PROT_GETSOCKNAME_0 (*function)(HAVE_PROT_GETSOCKNAME_1 s, HAVE_PROT_GETSOCKNAME_2 name, HAVE_PROT_GETSOCKNAME_3 namelen);
  297. SYSCALL_START(s);
  298. function = symbolfunction(SYMBOL_GETSOCKNAME);
  299. rc = function(s, name, namelen);
  300. SYSCALL_END(s);
  301. return rc;
  302. }
  303. #endif /* !HAVE_EXTRA_OSF_SYMBOLS */
  305. HAVE_PROT_READ_0
  306. sys_read(d, buf, nbytes)
  307. HAVE_PROT_READ_1 d;
  308. HAVE_PROT_READ_2 buf;
  309. HAVE_PROT_READ_3 nbytes;
  310. {
  311. ssize_t rc;
  312. HAVE_PROT_READ_0 (*function)(HAVE_PROT_READ_1 d, HAVE_PROT_READ_2 buf, HAVE_PROT_READ_3 nbytes);
  314. SYSCALL_START(d);
  315. function = symbolfunction(SYMBOL_READ);
  316. rc = function(d, buf, nbytes);
  317. SYSCALL_END(d);
  318. return rc;
  319. }
  321. #if !HAVE_EXTRA_OSF_SYMBOLS
  322. HAVE_PROT_READV_0
  323. sys_readv(d, iov, iovcnt)
  324. HAVE_PROT_READV_1 d;
  325. HAVE_PROT_READV_2 iov;
  326. HAVE_PROT_READV_3 iovcnt;
  327. {
  328. ssize_t rc;
  329. HAVE_PROT_READV_0 (*function)(HAVE_PROT_READV_1 d, HAVE_PROT_READV_2 iov, HAVE_PROT_READV_3 iovcnt);
  331. SYSCALL_START(d);
  332. function = symbolfunction(SYMBOL_READV);
  333. rc = function(d, iov, iovcnt);
  334. SYSCALL_END(d);
  335. return rc;
  336. }
  337. #endif /* HAVE_EXTRA_OSF_SYMBOLS */
  339. HAVE_PROT_RECV_0
  340. sys_recv(s, buf, len, flags)
  341. HAVE_PROT_RECV_1 s;
  342. HAVE_PROT_RECV_2 buf;
  343. HAVE_PROT_RECV_3 len;
  344. HAVE_PROT_RECV_4 flags;
  345. {
  346. ssize_t rc;
  347. HAVE_PROT_RECV_0 (*function)(HAVE_PROT_RECV_1 s, HAVE_PROT_RECV_2 buf, HAVE_PROT_RECV_3 len, HAVE_PROT_RECV_4 flags);
  349. SYSCALL_START(s);
  350. function = symbolfunction(SYMBOL_RECV);
  351. rc = function(s, buf, len, flags);
  352. SYSCALL_END(s);
  353. return rc;
  354. }
  356. #if !HAVE_EXTRA_OSF_SYMBOLS
  357. HAVE_PROT_RECVFROM_0
  358. sys_recvfrom(s, buf, len, flags, from, fromlen)
  359. HAVE_PROT_RECVFROM_1 s;
  360. HAVE_PROT_RECVFROM_2 buf;
  361. HAVE_PROT_RECVFROM_3 len;
  362. HAVE_PROT_RECVFROM_4 flags;
  363. HAVE_PROT_RECVFROM_5 from;
  364. HAVE_PROT_RECVFROM_6 fromlen;
  365. {
  366. int rc;
  367. HAVE_PROT_RECVFROM_0 (*function)(HAVE_PROT_RECVFROM_1 s, HAVE_PROT_RECVFROM_2 buf, HAVE_PROT_RECVFROM_3 len, HAVE_PROT_RECVFROM_4 flags, HAVE_PROT_RECVFROM_5 from, HAVE_PROT_RECVFROM_6 fromlen);
  369. SYSCALL_START(s);
  370. function = symbolfunction(SYMBOL_RECVFROM);
  371. rc = function(s, buf, len, flags, from, fromlen);
  372. SYSCALL_END(s);
  373. return rc;
  374. }
  375. #endif /* HAVE_EXTRA_OSF_SYMBOLS */
  377. #if !HAVE_EXTRA_OSF_SYMBOLS
  378. HAVE_PROT_RECVMSG_0
  379. sys_recvmsg(s, msg, flags)
  380. HAVE_PROT_RECVMSG_1 s;
  381. HAVE_PROT_RECVMSG_2 msg;
  382. HAVE_PROT_RECVMSG_3 flags;
  383. {
  384. ssize_t rc;
  385. HAVE_PROT_RECVMSG_0 (*function)(HAVE_PROT_RECVMSG_1 s, HAVE_PROT_RECVMSG_2 msg, HAVE_PROT_RECVMSG_3 flags);
  387. SYSCALL_START(s);
  388. function = symbolfunction(SYMBOL_RECVMSG);
  389. rc = function(s, msg, flags);
  390. SYSCALL_END(s);
  391. return rc;
  392. }
  393. #endif /* HAVE_EXTRA_OSF_SYMBOLS */
  395. int
  396. sys_rresvport(port)
  397. int *port;
  398. {
  399. int (*function)(int *port);
  401. function = symbolfunction(SYMBOL_RRESVPORT);
  402. return function(port);
  403. }
  405. HAVE_PROT_SEND_0
  406. sys_send(s, msg, len, flags)
  407. HAVE_PROT_SEND_1 s;
  408. HAVE_PROT_SEND_2 msg;
  409. HAVE_PROT_SEND_3 len;
  410. HAVE_PROT_SEND_4 flags;
  411. {
  412. ssize_t rc;
  413. HAVE_PROT_SEND_0 (*function)(HAVE_PROT_SEND_1 s, HAVE_PROT_SEND_2 msg, HAVE_PROT_SEND_3 len, HAVE_PROT_SEND_4 flags);
  415. SYSCALL_START(s);
  416. function = symbolfunction(SYMBOL_SEND);
  417. rc = function(s, msg, len, flags);
  418. SYSCALL_END(s);
  419. return rc;
  420. }
  422. #if !HAVE_EXTRA_OSF_SYMBOLS
  423. HAVE_PROT_SENDMSG_0
  424. sys_sendmsg(s, msg, flags)
  425. HAVE_PROT_SENDMSG_1 s;
  426. HAVE_PROT_SENDMSG_2 msg;
  427. HAVE_PROT_SENDMSG_3 flags;
  428. {
  429. ssize_t rc;
  430. HAVE_PROT_SENDMSG_0 (*function)(HAVE_PROT_SENDMSG_1 s, HAVE_PROT_SENDMSG_2 msg, HAVE_PROT_SENDMSG_3  flags);
  432. SYSCALL_START(s);
  433. function = symbolfunction(SYMBOL_SENDMSG);
  434. rc = function(s, msg, flags);
  435. SYSCALL_END(s);
  436. return rc;
  437. }
  438. #endif /* HAVE_EXTRA_OSF_SYMBOLS */
  440. #if !HAVE_EXTRA_OSF_SYMBOLS
  441. HAVE_PROT_SENDTO_0
  442. sys_sendto(s, msg, len, flags, to, tolen)
  443. HAVE_PROT_SENDTO_1 s;
  444. HAVE_PROT_SENDTO_2 msg;
  445. HAVE_PROT_SENDTO_3 len;
  446. HAVE_PROT_SENDTO_4 flags;
  447. HAVE_PROT_SENDTO_5 to;
  448. HAVE_PROT_SENDTO_6 tolen;
  449. {
  450. ssize_t rc;
  451. HAVE_PROT_SENDTO_0 (*function)(HAVE_PROT_SENDTO_1 s, HAVE_PROT_SENDTO_2 msg, HAVE_PROT_SENDTO_3 len, HAVE_PROT_SENDTO_4 flags, HAVE_PROT_SENDTO_5 to, HAVE_PROT_SENDTO_6 tolen);
  453. SYSCALL_START(s);
  454. function = symbolfunction(SYMBOL_SENDTO);
  455. rc = function(s, msg, len, flags, to, tolen);
  456. SYSCALL_END(s);
  457. return rc;
  458. }
  459. #endif /* !HAVE_EXTRA_OSF_SYMBOLS */
  461. HAVE_PROT_WRITE_0
  462. sys_write(d, buf, nbytes)
  463. HAVE_PROT_WRITE_1 d;
  464. HAVE_PROT_WRITE_2 buf;
  465. HAVE_PROT_WRITE_3 nbytes;
  466. {
  467. ssize_t rc;
  468. HAVE_PROT_WRITE_0 (*function)(HAVE_PROT_WRITE_1 d, HAVE_PROT_WRITE_2 buf, HAVE_PROT_WRITE_3 nbutes);
  470. SYSCALL_START(d);
  471. function = symbolfunction(SYMBOL_WRITE);
  472. rc = function(d, buf, nbytes);
  473. SYSCALL_END(d);
  474. return rc;
  475. }
  477. #if !HAVE_EXTRA_OSF_SYMBOLS
  478. HAVE_PROT_WRITEV_0
  479. sys_writev(d, iov, iovcnt)
  480. HAVE_PROT_WRITEV_1 d;
  481. HAVE_PROT_WRITEV_2 iov;
  482. HAVE_PROT_WRITEV_3 iovcnt;
  483. {
  484. ssize_t rc;
  485. HAVE_PROT_WRITEV_0 (*function)(HAVE_PROT_WRITEV_1 d, HAVE_PROT_WRITEV_2 buf, HAVE_PROT_WRITEV_3 iovcnt);
  487. SYSCALL_START(d);
  488. function = symbolfunction(SYMBOL_WRITEV);
  489. rc = function(d, iov, iovcnt);
  490. SYSCALL_END(d);
  491. return rc;
  492. }
  493. #endif /* HAVE_EXTRA_OSF_SYMBOLS */
  496. /*
  497.  * the interpositioned functions.
  498.  */
  500. #if !HAVE_EXTRA_OSF_SYMBOLS
  501. HAVE_PROT_ACCEPT_0
  502. accept(s, addr, addrlen)
  503. HAVE_PROT_ACCEPT_1 s;
  504. HAVE_PROT_ACCEPT_2 addr;
  505. HAVE_PROT_ACCEPT_3 addrlen;
  506. {
  507. if (ISSYSCALL(s))
  508. return sys_accept(s, addr, addrlen);
  509. return Raccept(s, addr, addrlen);
  510. }
  511. #endif /* HAVE_EXTRA_OSF_SYMBOLS */
  513. #if !HAVE_EXTRA_OSF_SYMBOLS
  514. HAVE_PROT_BIND_0
  515. bind(s, name, namelen)
  516. HAVE_PROT_BIND_1 s;
  517. HAVE_PROT_BIND_2 name;
  518. HAVE_PROT_BIND_3 namelen;
  519. {
  520. if (ISSYSCALL(s))
  521. return sys_bind(s, name, namelen);
  522. return Rbind(s, name, namelen);
  523. }
  524. #endif /* !HAVE_EXTRA_OSF_SYMBOLS */
  526. int
  527. bindresvport(sd, sin)
  528. int sd;
  529. struct sockaddr_in *sin;
  530. {
  531. if (ISSYSCALL(sd))
  532. return sys_bindresvport(sd, sin);
  533. return Rbindresvport(sd, sin);
  534. }
  536. #if !HAVE_EXTRA_OSF_SYMBOLS
  537. HAVE_PROT_CONNECT_0
  538. connect(s, name, namelen)
  539. HAVE_PROT_CONNECT_1 s;
  540. HAVE_PROT_CONNECT_2 name;
  541. HAVE_PROT_CONNECT_3 namelen;
  542. {
  543. if (ISSYSCALL(s))
  544. return sys_connect(s, name, namelen);
  545. return Rconnect(s, name, namelen);
  546. }
  547. #endif /* HAVE_EXTRA_OSF_SYMBOLS */
  549. struct hostent *
  550. gethostbyname(name)
  551. const char *name;
  552. {
  553. return Rgethostbyname(name);
  554. }
  556. struct hostent *
  557. gethostbyname2(name, af)
  558. const char *name;
  559. int af;
  560. {
  561. return Rgethostbyname2(name, af);
  562. }
  565. #if !HAVE_EXTRA_OSF_SYMBOLS
  566. HAVE_PROT_GETPEERNAME_0
  567. getpeername(s, name, namelen)
  568. HAVE_PROT_GETPEERNAME_1 s;
  569. HAVE_PROT_GETPEERNAME_2 name;
  570. HAVE_PROT_GETPEERNAME_3 namelen;
  571. {
  572. if (ISSYSCALL(s))
  573. return sys_getpeername(s, name, namelen);
  574. return Rgetpeername(s, name, namelen);
  575. }
  576. #endif /* HAVE_EXTRA_OSF_SYMBOLS */
  578. #if !HAVE_EXTRA_OSF_SYMBOLS
  579. HAVE_PROT_GETSOCKNAME_0
  580. getsockname(s, name, namelen)
  581. HAVE_PROT_GETSOCKNAME_1 s;
  582. HAVE_PROT_GETSOCKNAME_2 name;
  583. HAVE_PROT_GETSOCKNAME_3 namelen;
  584. {
  585. if (ISSYSCALL(s))
  586. return sys_getpeername(s, name, namelen);
  587. return Rgetsockname(s, name, namelen);
  588. }
  589. #endif /* HAVE_EXTRA_OSF_SYMBOLS */
  591. HAVE_PROT_READ_0
  592. read(d, buf, nbytes)
  593. HAVE_PROT_READ_1 d;
  594. HAVE_PROT_READ_2 buf;
  595. HAVE_PROT_READ_3 nbytes;
  596. {
  597. if (ISSYSCALL(d))
  598. return sys_read(d, buf, nbytes);
  599. return Rread(d, buf, nbytes);
  600. }
  602. #if !HAVE_EXTRA_OSF_SYMBOLS
  603. HAVE_PROT_READV_0
  604. readv(d, iov, iovcnt)
  605. HAVE_PROT_READV_1 d;
  606. HAVE_PROT_READV_2 iov;
  607. HAVE_PROT_READV_3 iovcnt;
  608. {
  609. if (ISSYSCALL(d))
  610. return sys_readv(d, iov, iovcnt);
  611. return Rreadv(d, iov, iovcnt);
  612. }
  613. #endif /* HAVE_EXTRA_OSF_SYMBOLS */
  615. HAVE_PROT_RECV_0
  616. recv(s, msg, len, flags)
  617. HAVE_PROT_RECV_1 s;
  618. HAVE_PROT_RECV_2 msg;
  619. HAVE_PROT_RECV_3 len;
  620. HAVE_PROT_RECV_4 flags;
  621. {
  622. if (ISSYSCALL(s))
  623. return sys_recv(s, msg, len, flags);
  624. return Rrecv(s, msg, len, flags);
  625. }
  627. #if !HAVE_EXTRA_OSF_SYMBOLS
  628. HAVE_PROT_RECVFROM_0
  629. recvfrom(s, buf, len, flags, from, fromlen)
  630. HAVE_PROT_RECVFROM_1 s;
  631. HAVE_PROT_RECVFROM_2 buf;
  632. HAVE_PROT_RECVFROM_3 len;
  633. HAVE_PROT_RECVFROM_4 flags;
  634. HAVE_PROT_RECVFROM_5 from;
  635. HAVE_PROT_RECVFROM_6 fromlen;
  636. {
  637. if (ISSYSCALL(s))
  638. return sys_recvfrom(s, buf, len, flags, from, fromlen);
  639. return Rrecvfrom(s, buf, len, flags, from, fromlen);
  640. }
  641. #endif /* HAVE_EXTRA_OSF_SYMBOLS */
  643. #if !HAVE_EXTRA_OSF_SYMBOLS
  644. HAVE_PROT_RECVMSG_0
  645. recvmsg(s, msg, flags)
  646. HAVE_PROT_RECVMSG_1 s;
  647. HAVE_PROT_RECVMSG_2 msg;
  648. HAVE_PROT_RECVMSG_3 flags;
  649. {
  650. if (ISSYSCALL(s))
  651. return sys_recvmsg(s, msg, flags);
  652. return Rrecvmsg(s, msg, flags);
  653. }
  654. #endif /* HAVE_EXTRA_OSF_SYMBOLS */
  656. int
  657. rresvport(port)
  658. int *port;
  659. {
  660. return Rrresvport(port);
  661. }
  663. HAVE_PROT_WRITE_0
  664. write(d, buf, nbytes)
  665. HAVE_PROT_WRITE_1 d;
  666. HAVE_PROT_WRITE_2 buf;
  667. HAVE_PROT_WRITE_3 nbytes;
  668. {
  669. if (ISSYSCALL(d))
  670. return sys_write(d, buf, nbytes);
  671. return Rwrite(d, buf, nbytes);
  672. }
  674. #if !HAVE_EXTRA_OSF_SYMBOLS
  675. HAVE_PROT_WRITEV_0
  676. writev(d, iov, iovcnt)
  677. HAVE_PROT_WRITEV_1 d;
  678. HAVE_PROT_WRITEV_2 iov;
  679. HAVE_PROT_WRITEV_3 iovcnt;
  680. {
  681. if (ISSYSCALL(d))
  682. return sys_writev(d, iov, iovcnt);
  683. return Rwritev(d, iov, iovcnt);
  684. }
  685. #endif /* HAVE_EXTRA_OSF_SYMBOLS */
  687. HAVE_PROT_SEND_0
  688. send(s, msg, len, flags)
  689. HAVE_PROT_SEND_1 s;
  690. HAVE_PROT_SEND_2 msg;
  691. HAVE_PROT_SEND_3 len;
  692. HAVE_PROT_SEND_4 flags;
  693. {
  694. if (ISSYSCALL(s))
  695. return sys_send(s, msg, len, flags);
  696. return Rsend(s, msg, len, flags);
  697. }
  699. #if !HAVE_EXTRA_OSF_SYMBOLS
  700. HAVE_PROT_SENDMSG_0
  701. sendmsg(s, msg, flags)
  702. HAVE_PROT_SENDMSG_1 s;
  703. HAVE_PROT_SENDMSG_2 msg;
  704. HAVE_PROT_SENDMSG_3 flags;
  705. {
  706. if (ISSYSCALL(s))
  707. return sys_sendmsg(s, msg, flags);
  708. return Rsendmsg(s, msg, flags);
  709. }
  710. #endif /* HAVE_EXTRA_OSF_SYMBOLS */
  712. #if !HAVE_EXTRA_OSF_SYMBOLS
  713. HAVE_PROT_SENDTO_0
  714. sendto(s, msg, len, flags, to, tolen)
  715. HAVE_PROT_SENDTO_1 s;
  716. HAVE_PROT_SENDTO_2 msg;
  717. HAVE_PROT_SENDTO_3 len;
  718. HAVE_PROT_SENDTO_4 flags;
  719. HAVE_PROT_SENDTO_5 to;
  720. HAVE_PROT_SENDTO_6 tolen;
  721. {
  722. if (ISSYSCALL(s))
  723. return sys_sendto(s, msg, len, flags, to, tolen);
  724. return Rsendto(s, msg, len, flags, to, tolen);
  725. }
  726. #endif /* !HAVE_EXTRA_OSF_SYMBOLS */
  728. #endif /* SOCKSLIBRARY_DYNAMIC */