1 /*
2 * Copyright (c) 1997, 1998, 1999, 2000, 2001, 2004, 2008, 2009, 2010, 2011,
3 * 2012, 2013, 2016, 2017, 2020
4 * Inferno Nettverk A/S, Norway. All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. The above copyright notice, this list of conditions and the following
10 * disclaimer must appear in all copies of the software, derivative works
11 * or modified versions, and any portions thereof, aswell as in all
12 * supporting documentation.
13 * 2. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by
16 * Inferno Nettverk A/S, Norway.
17 * 3. The name of the author may not be used to endorse or promote products
18 * derived from this software without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
21 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
22 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
23 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
24 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
25 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
29 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 *
31 * Inferno Nettverk A/S requests users of this software to return to
32 *
33 * Software Distribution Coordinator or sdc@inet.no
34 * Inferno Nettverk A/S
35 * Oslo Research Park
36 * Gaustadall�en 21
37 * NO-0349 Oslo
38 * Norway
39 *
40 * any improvements or extensions that they make and grant Inferno Nettverk A/S
41 * the rights to redistribute these changes.
42 *
43 */
44
45 #define _NO_SUN_PRAGMA
46
47 #include "common.h"
48
49 static const char rcsid[] =
50 "$Id: interposition.c,v 1.183.6.11.4.4 2020/11/11 16:11:56 karls Exp $";
51
52 #if SOCKSLIBRARY_DYNAMIC
53
54 #if (defined __sun) && (defined _XPG4_2)
55
56 HAVE_PROT_BIND_0
57 bind(HAVE_PROT_BIND_1, HAVE_PROT_BIND_2, HAVE_PROT_BIND_3);
58
59 HAVE_PROT_CONNECT_0
60 connect(HAVE_PROT_CONNECT_1, HAVE_PROT_CONNECT_2, HAVE_PROT_CONNECT_3);
61
62 HAVE_PROT_LISTEN_0
63 listen(HAVE_PROT_LISTEN_1, HAVE_PROT_LISTEN_2);
64
65 HAVE_PROT_RECVMSG_0
66 recvmsg(HAVE_PROT_RECVMSG_1, HAVE_PROT_RECVMSG_2, HAVE_PROT_RECVMSG_3);
67
68 HAVE_PROT_SENDMSG_0
69 sendmsg(HAVE_PROT_SENDMSG_1, HAVE_PROT_SENDMSG_2, HAVE_PROT_SENDMSG_3);
70
71 HAVE_PROT_SENDTO_0
72 sendto(HAVE_PROT_SENDTO_1, HAVE_PROT_SENDTO_2, HAVE_PROT_SENDTO_3,
73 HAVE_PROT_SENDTO_4, HAVE_PROT_SENDTO_5, HAVE_PROT_SENDTO_6);
74
75 #endif /* (defined __sun) && (defined _XPG4_2) */
76
77 #if HAVE_DARWIN
78
79 HAVE_PROT_CONNECT_0
80 connect$NOCANCEL(HAVE_PROT_CONNECT_1, HAVE_PROT_CONNECT_2,
81 HAVE_PROT_CONNECT_3);
82 HAVE_PROT_READ_0
83 read$NOCANCEL(HAVE_PROT_READ_1, HAVE_PROT_READ_2, HAVE_PROT_READ_3);
84 HAVE_PROT_RECVFROM_0
85 recvfrom$NOCANCEL(HAVE_PROT_RECVFROM_1, HAVE_PROT_RECVFROM_2,
86 HAVE_PROT_RECVFROM_3, HAVE_PROT_RECVFROM_4,
87 HAVE_PROT_RECVFROM_5, HAVE_PROT_RECVFROM_6);
88 HAVE_PROT_SENDTO_0
89 sendto$NOCANCEL(HAVE_PROT_SENDTO_1, HAVE_PROT_SENDTO_2, HAVE_PROT_SENDTO_3,
90 HAVE_PROT_SENDTO_4, HAVE_PROT_SENDTO_5, HAVE_PROT_SENDTO_6);
91 HAVE_PROT_WRITE_0
92 write$NOCANCEL(HAVE_PROT_WRITE_1, HAVE_PROT_WRITE_2, HAVE_PROT_WRITE_3);
93
94 #endif /* HAVE_DARWIN */
95
96 #ifndef __USE_GNU
97 #define __USE_GNU /* XXX for RTLD_NEXT on Linux */
98 #endif /* !__USE_GNU */
99
100
101 #include <dlfcn.h>
102
103 #ifdef __COVERITY__
104 /*
105 * Coverity naturally has no idea what the function sys_foo calls does,
106 * so let it pretend sys_foo is the same as foo.
107 * Means Coverity can't catch errors in the code around the call to
108 * sys_foo(), but avoids dozens of false positives because Coverity has no
109 * idea what the dlopen(3)-ed functions do.
110 */
111 #undef sys_accept
112 #undef sys_bind
113 #undef sys_bindresvport
114 #undef sys_connect
115 #undef sys_gethostbyname
116 #undef sys_gethostbyname2
117 #undef sys_getaddrinfo
118 #undef sys_getnameinfo
119 #undef sys_getipnodebyname
120 #undef sys_getpeername
121 #undef sys_getsockname
122 #undef sys_getsockopt
123 #undef sys_listen
124 #undef sys_read
125 #undef sys_readv
126 #undef sys_recv
127 #undef sys_recvfrom
128 #undef sys_recvfrom
129 #undef sys_recvmsg
130 #undef sys_rresvport
131 #undef sys_send
132 #undef sys_sendmsg
133 #undef sys_sendto
134 #undef sys_write
135 #undef sys_writev
136 #endif /* __COVERITY__ */
137
138 #undef accept
139 #undef bind
140 #undef bindresvport
141 #undef connect
142 #undef gethostbyaddr
143 #undef gethostbyname
144 #undef gethostbyname2
145 #undef getaddrinfo
146 #undef getnameinfo
147 #undef getipnodebyname
148 #undef freehostent
149 #undef getpeername
150 #undef getsockname
151 #undef getsockopt
152 #undef listen
153 #undef read
154 #undef readv
155 #undef recv
156 #undef recvfrom
157 #undef recvmsg
158 #undef rresvport
159 #undef send
160 #undef sendmsg
161 #undef sendto
162 #undef write
163 #undef writev
164 #if HAVE_GSSAPI && HAVE_LINUX_GLIBC_WORKAROUND
165 #undef getc
166 #undef fgetc
167 #undef gets
168 #undef fgets
169 #undef putc
170 #undef fputc
171 #undef puts
172 #undef fputs
173 #undef printf
174 #undef vprintf
175 #undef fprintf
176 #undef vfprintf
177 #undef fwrite
178 #undef fread
179 #undef fflush
180 #undef fclose
181
182 #if HAVE__IO_GETC
183
184 #if !HAVE_DECL__IO_GETC
185 HAVE_PROT__IO_GETC_0 _IO_getc (HAVE_PROT__IO_GETC_1 stream);
186 #endif /* !HAVE_DECL__IO_GETC */
187
188 #undef _IO_getc
189
190 #endif /* HAVE__IO_GETC */
191
192 #if HAVE__IO_PUTC
193
194 #if !HAVE_DECL__IO_PUTC
195 HAVE_PROT__IO_PUTC_0 _IO_putc (HAVE_PROT__IO_PUTC_1 c, HAVE_PROT__IO_PUTC_2 stream);
196 #endif /* !HAVE_DECL__IO_PUTC */
197
198 #undef _IO_putc
199
200 #endif /* HAVE__IO_PUTC */
201
202 #if HAVE___FPRINTF_CHK
203 #undef __fprintf_chk
204 #endif /* HAVE___FPRINTF_CHK */
205 #if HAVE___VFPRINTF_CHK
206 #undef __vfprintf_chk
207 #endif /* HAVE___VFPRINTF_CHK */
208 #if HAVE___READ_CHK
209 #undef __read_chk
210 #endif /* HAVE___READ_CHK */
211 #endif /* HAVE_GSSAPI && HAVE_LINUX_GLIBC_WORKAROUND */
212
213 static libsymbol_t libsymbolv[] = {
214 #if SOCKS_CLIENT
215 { SYMBOL_ACCEPT, LIBRARY_ACCEPT, NULL, NULL, NULL },
216 { SYMBOL_BIND, LIBRARY_BIND, NULL, NULL, NULL },
217 { SYMBOL_BINDRESVPORT, LIBRARY_BINDRESVPORT, NULL, NULL, NULL },
218 { SYMBOL_CONNECT, LIBRARY_CONNECT, NULL, NULL, NULL },
219 { SYMBOL_GETPEERNAME, LIBRARY_GETPEERNAME, NULL, NULL, NULL },
220 { SYMBOL_GETSOCKNAME, LIBRARY_GETSOCKNAME, NULL, NULL, NULL },
221 { SYMBOL_GETSOCKOPT, LIBRARY_GETSOCKOPT, NULL, NULL, NULL },
222 { SYMBOL_LISTEN, LIBRARY_LISTEN, NULL, NULL, NULL },
223 { SYMBOL_READ, LIBRARY_READ, NULL, NULL, NULL },
224 { SYMBOL_READV, LIBRARY_READV, NULL, NULL, NULL },
225 { SYMBOL_RECV, LIBRARY_RECV, NULL, NULL, NULL },
226 { SYMBOL_RECVMSG, LIBRARY_RECVMSG, NULL, NULL, NULL },
227 { SYMBOL_RECVFROM, LIBRARY_RECVFROM, NULL, NULL, NULL },
228
229 #if HAVE_RRESVPORT
230 { SYMBOL_RRESVPORT, LIBRARY_RRESVPORT, NULL, NULL, NULL },
231 #endif /* HAVE_RRESVPORT */
232
233 { SYMBOL_SEND, LIBRARY_SEND, NULL, NULL, NULL },
234 { SYMBOL_SENDMSG, LIBRARY_SENDMSG, NULL, NULL, NULL },
235 { SYMBOL_SENDTO, LIBRARY_SENDTO, NULL, NULL, NULL },
236 { SYMBOL_WRITE, LIBRARY_WRITE, NULL, NULL, NULL },
237 { SYMBOL_WRITEV, LIBRARY_WRITEV, NULL, NULL, NULL },
238
239 { SYMBOL_GETHOSTBYNAME, LIBRARY_GETHOSTBYNAME, NULL, NULL, NULL },
240
241 #if HAVE_GETHOSTBYNAME2
242 { SYMBOL_GETHOSTBYNAME2, LIBRARY_GETHOSTBYNAME2, NULL, NULL, NULL },
243 #endif /* HAVE_GETHOSTBYNAME2 */
244
245 #if HAVE_GETIPNODEBYNAME
246 { SYMBOL_GETIPNODEBYNAME, LIBRARY_GETIPNODEBYNAME,NULL, NULL, NULL },
247 { SYMBOL_FREEHOSTENT, LIBRARY_FREEHOSTENT, NULL, NULL, NULL },
248 #endif /* HAVE_GETIPNODEBYNAME */
249
250 #if HAVE_GETADDRINFO
251 { SYMBOL_GETADDRINFO, LIBRARY_GETADDRINFO, NULL, NULL, NULL },
252 #endif /* HAVE_GETADDRINFO */
253
254 #if HAVE_GETNAMEINFO
255 { SYMBOL_GETNAMEINFO, LIBRARY_GETNAMEINFO, NULL, NULL, NULL },
256 #endif /* HAVE_GETNAMEINFO */
257
258 #ifdef __sun
259 { SYMBOL_XNET_BIND, LIBRARY_BIND, NULL, NULL, NULL },
260 { SYMBOL_XNET_CONNECT, LIBRARY_CONNECT, NULL, NULL, NULL },
261 { SYMBOL_XNET_LISTEN, LIBRARY_LISTEN, NULL, NULL, NULL },
262 { SYMBOL_XNET_RECVMSG, LIBRARY_RECVMSG, NULL, NULL, NULL },
263 { SYMBOL_XNET_SENDMSG, LIBRARY_SENDMSG, NULL, NULL, NULL },
264 { SYMBOL_XNET_SENDTO, LIBRARY_SENDTO, NULL, NULL, NULL },
265 #endif /* __sun */
266
267 #if HAVE_DARWIN
268 { SYMBOL_CONNECT_NOCANCEL, LIBRARY_CONNECT, NULL, NULL, NULL },
269 { SYMBOL_READ_NOCANCEL, LIBRARY_READ, NULL, NULL, NULL },
270 { SYMBOL_RECVFROM_NOCANCEL, LIBRARY_RECVFROM, NULL, NULL, NULL },
271 { SYMBOL_SENDTO_NOCANCEL, LIBRARY_SENDTO, NULL, NULL, NULL },
272 { SYMBOL_WRITE_NOCANCEL, LIBRARY_WRITE, NULL, NULL, NULL },
273 #endif /* HAVE_DARWIN */
274
275 #if HAVE_EXTRA_OSF_SYMBOLS
276 { SYMBOL_EACCEPT, LIBRARY_EACCEPT, NULL, NULL, NULL },
277 { SYMBOL_EGETPEERNAME, LIBRARY_EGETPEERNAME, NULL, NULL, NULL },
278 { SYMBOL_EGETSOCKNAME, LIBRARY_EGETSOCKNAME, NULL, NULL, NULL },
279 { SYMBOL_EREADV, LIBRARY_EREADV, NULL, NULL, NULL },
280 { SYMBOL_ERECVFROM, LIBRARY_ERECVFROM, NULL, NULL, NULL },
281 { SYMBOL_ERECVMSG, LIBRARY_ERECVMSG, NULL, NULL, NULL },
282 { SYMBOL_ESENDMSG, LIBRARY_ESENDMSG, NULL, NULL, NULL },
283 { SYMBOL_EWRITEV, LIBRARY_EWRITEV, NULL, NULL, NULL },
284 { SYMBOL_NACCEPT, LIBRARY_EACCEPT, NULL, NULL, NULL },
285 { SYMBOL_NGETPEERNAME, LIBRARY_NGETPEERNAME, NULL, NULL, NULL },
286 { SYMBOL_NGETSOCKNAME, LIBRARY_NGETSOCKNAME, NULL, NULL, NULL },
287 { SYMBOL_NRECVFROM, LIBRARY_NRECVFROM, NULL, NULL, NULL },
288 { SYMBOL_NRECVMSG, LIBRARY_NRECVMSG, NULL, NULL, NULL },
289 { SYMBOL_NSENDMSG, LIBRARY_NSENDMSG, NULL, NULL, NULL },
290 #endif /* HAVE_EXTRA_OSF_SYMBOLS */
291
292 #if HAVE_GSSAPI && HAVE_LINUX_GLIBC_WORKAROUND
293 { SYMBOL_GETC, LIBRARY_GETC, NULL, NULL, NULL },
294 { SYMBOL_FGETC, LIBRARY_FGETC, NULL, NULL, NULL },
295 { SYMBOL_GETS, LIBRARY_GETS, NULL, NULL, NULL },
296 { SYMBOL_FGETS, LIBRARY_FGETS, NULL, NULL, NULL },
297 { SYMBOL_PUTC, LIBRARY_PUTC, NULL, NULL, NULL },
298 { SYMBOL_FPUTC, LIBRARY_FPUTC, NULL, NULL, NULL },
299 { SYMBOL_PUTS, LIBRARY_PUTS, NULL, NULL, NULL },
300 { SYMBOL_FPUTS, LIBRARY_FPUTS, NULL, NULL, NULL },
301 { SYMBOL_PRINTF, LIBRARY_PRINTF, NULL, NULL, NULL },
302 { SYMBOL_VPRINTF, LIBRARY_VPRINTF, NULL, NULL, NULL },
303 { SYMBOL_FPRINTF, LIBRARY_FPRINTF, NULL, NULL, NULL },
304 { SYMBOL_VFPRINTF, LIBRARY_VFPRINTF, NULL, NULL, NULL },
305 { SYMBOL_FWRITE, LIBRARY_FWRITE, NULL, NULL, NULL },
306 { SYMBOL_FREAD, LIBRARY_FREAD, NULL, NULL, NULL },
307 { SYMBOL_FFLUSH, LIBRARY_FFLUSH, NULL, NULL, NULL },
308 { SYMBOL_FCLOSE, LIBRARY_FCLOSE, NULL, NULL, NULL },
309
310 #if HAVE__IO_GETC
311 { SYMBOL__IO_GETC, LIBRARY__IO_GETC, NULL, NULL, NULL },
312 #endif /* HAVE__IO_GETC */
313
314 #if HAVE__IO_PUTC
315 { SYMBOL__IO_PUTC, LIBRARY__IO_PUTC, NULL, NULL, NULL },
316 #endif /* HAVE__IO_PUTC */
317
318 #if HAVE___FPRINTF_CHK
319 { SYMBOL___FPRINTF_CHK, LIBRARY___FPRINTF_CHK, NULL, NULL, NULL },
320 #endif /* HAVE___FPRINTF_CHK */
321
322 #if HAVE___VFPRINTF_CHK
323 { SYMBOL___VFPRINTF_CHK, LIBRARY___VFPRINTF_CHK, NULL, NULL, NULL },
324 #endif /* HAVE___VFPRINTF_CHK */
325
326 #if HAVE___READ_CHK
327 { SYMBOL___READ_CHK, LIBRARY___READ_CHK, NULL, NULL, NULL },
328 #endif /* HAVE___READ_CHK */
329
330 #endif /* HAVE_GSSAPI && HAVE_LINUX_GLIBC_WORKAROUND */
331
332 #else /* SERVER */
333
334 /*
335 * symbols we want to interpose in the server for library functions
336 * that might call them (e.g. pam/ldap/gssapi). Lets them use our
337 * superior caching versions. Unfortunately, getaddrinfo(3) does
338 * lend itself easily to that, so even if we would have liked to
339 * let that also use our cached data, the only solutions I can
340 * think of seem to fragile to be usable. So regarding that newer api,
341 * only getnameinfo(3) uses our cached version.
342 */
343
344
345 /*
346 * No point in having it in the client as either the system-calls used by
347 * gethostbyaddr(3) gets socksified, in which case there is nothing special
348 * for us to do related to gethostbyaddr(3), or they do not get socksified,
349 * in which case we have no idea what hostname the address resolves to and
350 * there is nothing we can reasonably fake anyway.
351 */
352 { SYMBOL_GETHOSTBYADDR, LIBRARY_GETHOSTBYADDR, NULL, NULL, NULL },
353 { SYMBOL_GETHOSTBYNAME, LIBRARY_GETHOSTBYNAME, NULL, NULL, NULL },
354
355 #endif /* SERVER */
356 };
357
358 #if SOCKS_CLIENT
359
360 /*
361 * During init, we need to let all system calls resolve to the native
362 * version. I.e., socks_shouldcallasnative() need to always return
363 * true as long as we are initing. Use this object for holding that
364 * knowledge.
365 */
366 #ifdef HAVE_VOLATILE_SIG_ATOMIC_T
367
368 extern sig_atomic_t doing_addrinit;
369
370 #else
371
372 extern volatile sig_atomic_t doing_addrinit;
373
374 #endif /* HAVE_VOLATILE_SIG_ATOMIC_T */
375
376 #define DNSCODE_START() \
377 do { \
378 slog(LOG_DEBUG, \
379 "DNSCODE_START: %d", (int)++sockscf.state.executingdnscode); \
380 } while (/* CONSTCOND */ 0)
381
382 #define DNSCODE_END() \
383 do { \
384 slog(LOG_DEBUG, \
385 "DNSCODE_END: %d", (int)--sockscf.state.executingdnscode); \
386 } while (/* CONSTCOND */ 0)
387
388
389 static void
390 addtolist(const char *functionname, const socks_id_t *id);
391 /*
392 * Add "id" to the list of id's for which function name should resolve
393 * to the native system call directly.
394 */
395
396 static void
397 removefromlist(const char *functionname, const socks_id_t *id);
398 /*
399 * Add "id" to the list of id's for which function name should resolve
400 * to the native system call directly.
401 */
402
403 static int
404 idsareequal(const socks_id_t *a, const socks_id_t *b);
405 /*
406 * If "a" and "b" refer to the same thread/pid, return true. Else, false.
407 */
408
409
410
411 #else /* !SOCKS_CLIENT */
412
413 #define DNSCODE_START()
414 #define DNSCODE_END()
415
416 #endif /* !SOCKS_CLIENT */
417
418 static libsymbol_t *
419 libsymbol(const char *symbol);
420 /*
421 * Finds the libsymbol that "symbol" is defined in.
422 */
423
424
425 #if SOCKS_CLIENT
426
427 int
socks_issyscall(s,name)428 socks_issyscall(s, name)
429 const int s;
430 const char *name;
431 {
432 socksfd_t socksfd;
433
434 if (s < 0)
435 return 1;
436
437 if (socks_shouldcallasnative(name))
438 return 1;
439
440 if (!fd_is_network_socket(s))
441 return 1;
442
443 if (socks_getaddr(s, &socksfd, 1) != NULL
444 && socksfd.state.syscalldepth > 0)
445 return 1;
446
447 return 0;
448 }
449
450 void
socks_syscall_start(s)451 socks_syscall_start(s)
452 const int s;
453 {
454 socksfd_t *p;
455 addrlockopaque_t opaque;
456
457 if (doing_addrinit || sockscf.state.executingdnscode)
458 return;
459
460 if (s < 0)
461 return;
462
463 if (socks_logmatch(s, &sockscf.log)
464 || socks_logmatch(s, &sockscf.errlog))
465 return; /* don't set up things for our logging fd's - creates problems. */
466
467 socks_addrlock(F_WRLCK, &opaque);
468
469 if ((p = socks_getaddr(s, NULL, 0)) == NULL) {
470 socksfd_t socksfd;
471
472 bzero(&socksfd, sizeof(socksfd));
473 socksfd.state.command = -1;
474 socksfd.state.issyscall = 1;
475 p = socks_addaddr(s, &socksfd, 0);
476 }
477
478 SASSERTX(p != NULL);
479
480 ++(p->state.syscalldepth);
481 socks_addaddr(s, p, 0);
482
483 socks_addrunlock(&opaque);
484 }
485
486 void
socks_syscall_end(s)487 socks_syscall_end(s)
488 const int s;
489 {
490 addrlockopaque_t opaque;
491 socksfd_t socksfd, *p;
492
493 if (doing_addrinit || sockscf.state.executingdnscode)
494 return;
495
496 if (s < 0)
497 return;
498
499 if (socks_logmatch(s, &sockscf.log)
500 || socks_logmatch(s, &sockscf.errlog))
501 return; /* don't set up things for our logging fd's, creates problems. */
502
503 socks_addrlock(F_WRLCK, &opaque);
504
505 p = socks_getaddr(s, &socksfd, 0);
506
507 if (p == NULL) { /* should not happen ... */
508 socks_addrunlock(&opaque);
509 return;
510 }
511
512 if (p->state.syscalldepth <= 0)
513 ; /* should not happen ... */
514 else
515 --(p->state.syscalldepth);
516
517 if (p->state.syscalldepth <= 0) { /* all finished. */
518 if (p->state.issyscall) /* started out as a syscall, remove now. */
519 socks_rmaddr(s, 0);
520 else
521 socks_addaddr(s, &socksfd, 0); /* update. */
522 }
523 else
524 socks_addaddr(s, &socksfd, 0); /* update. */
525
526 socks_addrunlock(&opaque);
527 }
528
529 static void
addtolist(functionname,id)530 addtolist(functionname, id)
531 const char *functionname;
532 const socks_id_t *id;
533 {
534 const char *function = "addtolist()";
535 libsymbol_t *lib;
536 socks_id_t *newid;
537
538 addrlockopaque_t opaque;
539
540 lib = libsymbol(functionname);
541 SASSERTX(lib != NULL);
542
543 if ((newid = malloc(sizeof(*newid))) == NULL)
544 serr("%s: failed to malloc %lu bytes",
545 function, (unsigned long)sizeof(*newid));
546
547 *newid = *id;
548
549 socks_addrlock(F_WRLCK, &opaque);
550
551 if (lib->dosyscall == NULL) {
552 lib->dosyscall = newid;
553 lib->dosyscall->next = NULL;
554 }
555 else {
556 newid->next = lib->dosyscall->next;
557 lib->dosyscall->next = newid;
558 }
559
560 socks_addrunlock(&opaque);
561 }
562
563 static void
removefromlist(functionname,removeid)564 removefromlist(functionname, removeid)
565 const char *functionname;
566 const socks_id_t *removeid;
567 {
568 /* const char *function = "removefromlist()"; */
569 libsymbol_t *lib;
570 socks_id_t *id, *previous;
571 addrlockopaque_t opaque;
572
573 lib = libsymbol(functionname);
574 SASSERTX(lib != NULL);
575 SASSERTX(lib->dosyscall != NULL);
576
577 socks_addrlock(F_WRLCK, &opaque);
578
579 SASSERTX(idsareequal(lib->dosyscall, removeid));
580
581 previous = lib->dosyscall;
582
583 if (idsareequal(lib->dosyscall, removeid)) {
584 lib->dosyscall = lib->dosyscall->next;
585 free(previous);
586 }
587 else {
588 for (id = previous->next; id != NULL; previous = id, id = id->next) {
589 if (idsareequal(id, removeid)) {
590 previous->next = id->next;
591 free(id);
592
593 break;
594 }
595 }
596
597 SASSERTX(id != NULL);
598 }
599
600 socks_addrunlock(&opaque);
601 }
602
603 #endif /* SOCKS_CLIENT */
604
605 void
symbolcheck(void)606 symbolcheck(void)
607 {
608 size_t i;
609
610 for (i = 0; i < ELEMENTS(libsymbolv); ++i)
611 symbolfunction(libsymbolv[i].symbol);
612 }
613
614
615 int
socks_shouldcallasnative(symbol)616 socks_shouldcallasnative(symbol)
617 const char *symbol;
618 {
619 #if SOCKS_CLIENT
620 socks_id_t myid, *fid;
621 libsymbol_t *lib;
622
623 if (doing_addrinit || sockscf.state.executingdnscode)
624 return 1;
625
626 lib = libsymbol(symbol);
627 SASSERTX(lib != NULL);
628
629 if ((fid = lib->dosyscall) == NULL)
630 return 0;
631
632 socks_whoami(&myid);
633
634 for (; fid != NULL; fid = fid->next)
635 if (idsareequal(&myid, fid))
636 return 1;
637
638 return 0;
639
640 #else /* ! SOCKS_CLIENT */
641
642 return 1;
643
644 #endif /* !SOCKS_CLIENT */
645
646 }
647
648 void
socks_markasnative(symbol)649 socks_markasnative(symbol)
650 const char *symbol;
651 {
652 #if SOCKS_CLIENT
653 const char *function = "socks_markasnative()";
654 socks_id_t myid;
655
656 if (sockscf.option.debug > DEBUG_VERBOSE)
657 slog(LOG_DEBUG, "%s: marking %s as native for current id",
658 function, symbol);
659
660 if (strcmp(symbol, "*") == 0) {
661 size_t i;
662
663 for (i = 0; i < ELEMENTS(libsymbolv); ++i)
664 socks_markasnative(libsymbolv[i].symbol);
665
666 return;
667 }
668
669 socks_whoami(&myid);
670 addtolist(symbol, &myid);
671 #endif /* !SOCKS_CLIENT */
672 }
673
674 void
socks_markasnormal(symbol)675 socks_markasnormal(symbol)
676 const char *symbol;
677 {
678 #if SOCKS_CLIENT
679 const char *function = "socks_markasnormal()";
680 socks_id_t myid;
681
682 if (sockscf.option.debug > DEBUG_VERBOSE)
683 slog(LOG_DEBUG, "%s: marking %s as normal for current id",
684 function, symbol);
685
686 if (strcmp(symbol, "*") == 0) {
687 size_t i;
688
689 for (i = 0; i < ELEMENTS(libsymbolv); ++i)
690 socks_markasnormal(libsymbolv[i].symbol);
691
692 return;
693 }
694
695 socks_whoami(&myid);
696 removefromlist(symbol, &myid);
697 #endif /* !SOCKS_CLIENT */
698 }
699
700 void
socks_mark_io_as_native()701 socks_mark_io_as_native()
702 {
703 #if SOCKS_CLIENT
704 const char *function = "socks_mark_io_as_native()";
705
706 slog(LOG_DEBUG, "%s: marking i/o calls as native ...", function);
707 socks_markasnative("*");
708 #endif /* !SOCKS_CLIENT */
709 }
710
711 void
socks_mark_io_as_normal()712 socks_mark_io_as_normal()
713 {
714 #if SOCKS_CLIENT
715 const char *function = "socks_mark_io_as_normal()";
716
717 slog(LOG_DEBUG, "%s: marking io-related calls as normal again", function);
718 socks_markasnormal("*");
719 #endif /* !SOCKS_CLIENT */
720 }
721
722 void *
symbolfunction(symbol)723 symbolfunction(symbol)
724 const char *symbol;
725 {
726 const char *function = "symbolfunction()";
727 libsymbol_t *lib;
728
729 lib = libsymbol(symbol);
730
731 SASSERTX(lib != NULL);
732 SASSERTX(lib->library != NULL);
733 SASSERTX(strcmp(lib->symbol, symbol) == 0);
734
735 #if HAVE_RTLD_NEXT
736 if (lib->function == NULL) {
737 if ((lib->function = dlsym(RTLD_NEXT, symbol)) == NULL) {
738 if (strcmp(symbol, SYMBOL_WRITE) != 0)
739 serrx("%s: compile time configuration error? "
740 "Failed to find \"%s\" using RTLD_NEXT: %s",
741 function, symbol, dlerror());
742 }
743 #if 0
744 else {
745 if (strcmp(symbol, SYMBOL_WRITE) != 0)
746 slog(LOG_DEBUG, "found symbol %s using RTLD_NEXT", lib->symbol);
747 }
748 #endif
749 }
750
751 #else /* !HAVE_RTLD_NEXT */
752 if (lib->handle == NULL)
753 if ((lib->handle = dlopen(lib->library, DL_LAZY)) == NULL)
754 serrx("%s: compile time configuration error? "
755 "Failed to open library \"%s\": %s",
756 function, lib->library, dlerror());
757
758 if (lib->function == NULL)
759 if ((lib->function = dlsym(lib->handle, symbol)) == NULL)
760 serrx("%s: compile time configuration error? "
761 "Failed to find \"%s\" in \"%s\": %s",
762 function, symbol, lib->library, dlerror());
763
764 #if 0
765 if (strcmp(symbol, SYMBOL_WRITE) != 0)
766 slog(LOG_DEBUG, "found symbol %s in library %s",
767 lib->symbol, lib->library);
768 #endif
769
770 #endif /* !HAVE_RLTD_NEXT */
771
772 return lib->function;
773 }
774
775 #if SOCKS_CLIENT
776 /* the real system calls. */
777
778
779 #if !HAVE_EXTRA_OSF_SYMBOLS
780 HAVE_PROT_ACCEPT_0
sys_accept(s,addr,addrlen)781 sys_accept(s, addr, addrlen)
782 HAVE_PROT_ACCEPT_1 s;
783 HAVE_PROT_ACCEPT_2 addr;
784 HAVE_PROT_ACCEPT_3 addrlen;
785 {
786 int rc;
787 typedef HAVE_PROT_ACCEPT_0 (*ACCEPT_FUNC_T)(HAVE_PROT_ACCEPT_1,
788 HAVE_PROT_ACCEPT_2,
789 HAVE_PROT_ACCEPT_3);
790 ACCEPT_FUNC_T function = (ACCEPT_FUNC_T)symbolfunction(SYMBOL_ACCEPT);
791 const int tagged = (doing_addrinit ? 0 : 1);
792
793 if (tagged)
794 socks_syscall_start(s);
795
796 rc = function(s, addr, addrlen);
797
798 if (tagged)
799 socks_syscall_end(s);
800
801 return rc;
802 }
803 #endif /* !HAVE_EXTRA_OSF_SYMBOLS */
804
805 #if !HAVE_EXTRA_OSF_SYMBOLS
806 HAVE_PROT_BIND_0
sys_bind(s,name,namelen)807 sys_bind(s, name, namelen)
808 HAVE_PROT_BIND_1 s;
809 HAVE_PROT_BIND_2 name;
810 HAVE_PROT_BIND_3 namelen;
811 {
812 int rc;
813 typedef HAVE_PROT_BIND_0 (*BIND_FUNC_T)(HAVE_PROT_BIND_1,
814 HAVE_PROT_BIND_2,
815 HAVE_PROT_BIND_3);
816 BIND_FUNC_T function = (BIND_FUNC_T)symbolfunction(SYMBOL_BIND);
817 const int tagged = (doing_addrinit ? 0 : 1);
818
819 if (tagged)
820 socks_syscall_start(s);
821
822 rc = function(s, name, namelen);
823
824 if (tagged)
825 socks_syscall_end(s);
826
827 return rc;
828 }
829 #endif /* !HAVE_EXTRA_OSF_SYMBOLS */
830
831 int
sys_bindresvport(sd,sin)832 sys_bindresvport(sd, sin)
833 int sd;
834 struct sockaddr_in *sin;
835 {
836 int rc;
837 typedef int (*BINDRESVPORT_FUNC_T)(int, struct sockaddr_in *);
838 BINDRESVPORT_FUNC_T function
839 = (BINDRESVPORT_FUNC_T)symbolfunction(SYMBOL_BINDRESVPORT);
840 const int tagged = (doing_addrinit ? 0 : 1);
841
842 if (tagged)
843 socks_syscall_start(sd);
844
845 rc = function(sd, sin);
846
847 if (tagged)
848 socks_syscall_end(sd);
849
850 return rc;
851 }
852
853 #if !HAVE_EXTRA_OSF_SYMBOLS
854 HAVE_PROT_CONNECT_0
sys_connect(s,name,namelen)855 sys_connect(s, name, namelen)
856 HAVE_PROT_CONNECT_1 s;
857 HAVE_PROT_CONNECT_2 name;
858 HAVE_PROT_CONNECT_3 namelen;
859 {
860 int rc;
861 typedef HAVE_PROT_CONNECT_0 (*CONNECT_FUNC_T)(HAVE_PROT_CONNECT_1,
862 HAVE_PROT_CONNECT_2,
863 HAVE_PROT_CONNECT_3);
864 CONNECT_FUNC_T function = (CONNECT_FUNC_T)symbolfunction(SYMBOL_CONNECT);
865 const int tagged = (doing_addrinit ? 0 : 1);
866
867 if (tagged)
868 socks_syscall_start(s);
869
870 rc = function(s, name, namelen);
871
872 if (tagged)
873 socks_syscall_end(s);
874
875 return rc;
876 }
877 #endif /* !HAVE_EXTRA_OSF_SYMBOLS */
878
879 #if !HAVE_EXTRA_OSF_SYMBOLS
880 HAVE_PROT_GETPEERNAME_0
sys_getpeername(s,name,namelen)881 sys_getpeername(s, name, namelen)
882 HAVE_PROT_GETPEERNAME_1 s;
883 HAVE_PROT_GETPEERNAME_2 name;
884 HAVE_PROT_GETPEERNAME_3 namelen;
885 {
886 int rc;
887 typedef HAVE_PROT_GETPEERNAME_0
888 (*GETPEERNAME_FUNC_T)(HAVE_PROT_GETPEERNAME_1,
889 HAVE_PROT_GETPEERNAME_2,
890 HAVE_PROT_GETPEERNAME_3);
891 GETPEERNAME_FUNC_T function
892 = (GETPEERNAME_FUNC_T)symbolfunction(SYMBOL_GETPEERNAME);
893 const int tagged = (doing_addrinit ? 0 : 1);
894
895 if (tagged)
896 socks_syscall_start(s);
897
898 rc = function(s, name, namelen);
899
900 if (tagged)
901 socks_syscall_end(s);
902
903 return rc;
904 }
905 #endif /* !HAVE_EXTRA_OSF_SYMBOLS */
906
907 #if !HAVE_EXTRA_OSF_SYMBOLS
908 HAVE_PROT_GETSOCKNAME_0
sys_getsockname(s,name,namelen)909 sys_getsockname(s, name, namelen)
910 HAVE_PROT_GETSOCKNAME_1 s;
911 HAVE_PROT_GETSOCKNAME_2 name;
912 HAVE_PROT_GETSOCKNAME_3 namelen;
913 {
914 int rc;
915 typedef HAVE_PROT_GETSOCKNAME_0
916 (*GETSOCKNAME_FUNC_T)(HAVE_PROT_GETSOCKNAME_1,
917 HAVE_PROT_GETSOCKNAME_2,
918 HAVE_PROT_GETSOCKNAME_3);
919 GETSOCKNAME_FUNC_T function
920 = (GETSOCKNAME_FUNC_T)symbolfunction(SYMBOL_GETSOCKNAME);
921 const int tagged = (doing_addrinit ? 0 : 1);
922
923 if (tagged)
924 socks_syscall_start(s);
925
926 rc = function(s, name, namelen);
927
928 if (tagged)
929 socks_syscall_end(s);
930
931 return rc;
932 }
933
934 HAVE_PROT_GETSOCKNAME_0
sys_getsockname_notracking(s,name,namelen)935 sys_getsockname_notracking(s, name, namelen)
936 HAVE_PROT_GETSOCKNAME_1 s;
937 HAVE_PROT_GETSOCKNAME_2 name;
938 HAVE_PROT_GETSOCKNAME_3 namelen;
939 {
940 typedef HAVE_PROT_GETSOCKNAME_0
941 (*GETSOCKNAME_FUNC_T)(HAVE_PROT_GETSOCKNAME_1,
942 HAVE_PROT_GETSOCKNAME_2,
943 HAVE_PROT_GETSOCKNAME_3);
944 GETSOCKNAME_FUNC_T function
945 = (GETSOCKNAME_FUNC_T)symbolfunction(SYMBOL_GETSOCKNAME);
946
947 return function(s, name, namelen);
948 }
949
950
951 #endif /* !HAVE_EXTRA_OSF_SYMBOLS */
952
953 HAVE_PROT_GETSOCKOPT_0
sys_getsockopt(s,level,optname,optval,optlen)954 sys_getsockopt(s, level, optname, optval, optlen)
955 HAVE_PROT_GETSOCKOPT_1 s;
956 HAVE_PROT_GETSOCKOPT_2 level;
957 HAVE_PROT_GETSOCKOPT_3 optname;
958 HAVE_PROT_GETSOCKOPT_4 optval;
959 HAVE_PROT_GETSOCKOPT_5 optlen;
960 {
961 int rc;
962 typedef HAVE_PROT_GETSOCKOPT_0
963 (*GETSOCKOPT_FUNC_T)(HAVE_PROT_GETSOCKOPT_1,
964 HAVE_PROT_GETSOCKOPT_2,
965 HAVE_PROT_GETSOCKOPT_3,
966 HAVE_PROT_GETSOCKOPT_4,
967 HAVE_PROT_GETSOCKOPT_5);
968 GETSOCKOPT_FUNC_T function
969 = (GETSOCKOPT_FUNC_T)symbolfunction(SYMBOL_GETSOCKOPT);
970 const int tagged = (doing_addrinit ? 0 : 1);
971
972 if (tagged)
973 socks_syscall_start(s);
974
975 rc = function(s, level, optname, optval, optlen);
976
977 if (tagged)
978 socks_syscall_end(s);
979
980 return rc;
981 }
982
983 HAVE_PROT_LISTEN_0
sys_listen(s,backlog)984 sys_listen(s, backlog)
985 HAVE_PROT_LISTEN_1 s;
986 HAVE_PROT_LISTEN_2 backlog;
987 {
988 HAVE_PROT_LISTEN_0 rc;
989 typedef HAVE_PROT_LISTEN_0 (*LISTEN_FUNC_T)(HAVE_PROT_LISTEN_1,
990 HAVE_PROT_LISTEN_2);
991 LISTEN_FUNC_T function = (LISTEN_FUNC_T)symbolfunction(SYMBOL_LISTEN);
992 const int tagged = (doing_addrinit ? 0 : 1);
993
994 if (tagged)
995 socks_syscall_start(s);
996
997 rc = function(s, backlog);
998
999 if (tagged)
1000 socks_syscall_end(s);
1001
1002 return rc;
1003 }
1004
1005 HAVE_PROT_READ_0
sys_read(d,buf,nbytes)1006 sys_read(d, buf, nbytes)
1007 HAVE_PROT_READ_1 d;
1008 HAVE_PROT_READ_2 buf;
1009 HAVE_PROT_READ_3 nbytes;
1010 {
1011 ssize_t rc;
1012 typedef HAVE_PROT_READ_0 (*READ_FUNC_T)(HAVE_PROT_READ_1,
1013 HAVE_PROT_READ_2,
1014 HAVE_PROT_READ_3);
1015 READ_FUNC_T function = (READ_FUNC_T)symbolfunction(SYMBOL_READ);
1016
1017 const int tagged = (doing_addrinit ? 0 : 1);
1018
1019 if (tagged)
1020 socks_syscall_start(d);
1021
1022 rc = function(d, buf, nbytes);
1023
1024 if (tagged)
1025 socks_syscall_end(d);
1026
1027 return rc;
1028 }
1029
1030 #if !HAVE_EXTRA_OSF_SYMBOLS
1031 HAVE_PROT_READV_0
sys_readv(d,iov,iovcnt)1032 sys_readv(d, iov, iovcnt)
1033 HAVE_PROT_READV_1 d;
1034 HAVE_PROT_READV_2 iov;
1035 HAVE_PROT_READV_3 iovcnt;
1036 {
1037 ssize_t rc;
1038 typedef HAVE_PROT_READV_0 (*READV_FUNC_T)(HAVE_PROT_READV_1,
1039 HAVE_PROT_READV_2,
1040 HAVE_PROT_READV_3);
1041 READV_FUNC_T function = (READV_FUNC_T)symbolfunction(SYMBOL_READV);
1042 const int tagged = (doing_addrinit ? 0 : 1);
1043
1044 if (tagged)
1045 socks_syscall_start(d);
1046
1047 rc = function(d, iov, iovcnt);
1048
1049 if (tagged)
1050 socks_syscall_end(d);
1051
1052 return rc;
1053 }
1054 #endif /* HAVE_EXTRA_OSF_SYMBOLS */
1055
1056 HAVE_PROT_RECV_0
sys_recv(s,buf,len,flags)1057 sys_recv(s, buf, len, flags)
1058 HAVE_PROT_RECV_1 s;
1059 HAVE_PROT_RECV_2 buf;
1060 HAVE_PROT_RECV_3 len;
1061 HAVE_PROT_RECV_4 flags;
1062 {
1063 ssize_t rc;
1064 typedef HAVE_PROT_RECV_0 (*RECV_FUNC_T)(HAVE_PROT_RECV_1,
1065 HAVE_PROT_RECV_2,
1066 HAVE_PROT_RECV_3,
1067 HAVE_PROT_RECV_4);
1068 RECV_FUNC_T function = (RECV_FUNC_T)symbolfunction(SYMBOL_RECV);
1069 const int tagged = (doing_addrinit ? 0 : 1);
1070
1071 if (tagged)
1072 socks_syscall_start(s);
1073
1074 rc = function(s, buf, len, flags);
1075
1076 if (tagged)
1077 socks_syscall_end(s);
1078
1079 return rc;
1080 }
1081
1082 #if !HAVE_EXTRA_OSF_SYMBOLS
1083 HAVE_PROT_RECVFROM_0
sys_recvfrom(s,buf,len,flags,from,fromlen)1084 sys_recvfrom(s, buf, len, flags, from, fromlen)
1085 HAVE_PROT_RECVFROM_1 s;
1086 HAVE_PROT_RECVFROM_2 buf;
1087 HAVE_PROT_RECVFROM_3 len;
1088 HAVE_PROT_RECVFROM_4 flags;
1089 HAVE_PROT_RECVFROM_5 from;
1090 HAVE_PROT_RECVFROM_6 fromlen;
1091 {
1092 HAVE_PROT_RECVFROM_0 rc;
1093 typedef HAVE_PROT_RECVFROM_0 (*RECVFROM_FUNC_T)(HAVE_PROT_RECVFROM_1,
1094 HAVE_PROT_RECVFROM_2,
1095 HAVE_PROT_RECVFROM_3,
1096 HAVE_PROT_RECVFROM_4,
1097 HAVE_PROT_RECVFROM_5,
1098 HAVE_PROT_RECVFROM_6);
1099 RECVFROM_FUNC_T function = (RECVFROM_FUNC_T)symbolfunction(SYMBOL_RECVFROM);
1100 const int tagged = (doing_addrinit ? 0 : 1);
1101
1102 if (tagged)
1103 socks_syscall_start(s);
1104
1105 rc = function(s, buf, len, flags, from, fromlen);
1106
1107 if (tagged)
1108 socks_syscall_end(s);
1109
1110 return rc;
1111 }
1112 #endif /* HAVE_EXTRA_OSF_SYMBOLS */
1113
1114 #if !HAVE_EXTRA_OSF_SYMBOLS
1115 HAVE_PROT_RECVMSG_0
sys_recvmsg(s,msg,flags)1116 sys_recvmsg(s, msg, flags)
1117 HAVE_PROT_RECVMSG_1 s;
1118 HAVE_PROT_RECVMSG_2 msg;
1119 HAVE_PROT_RECVMSG_3 flags;
1120 {
1121 ssize_t rc;
1122 typedef HAVE_PROT_RECVMSG_0 (*RECVMSG_FUNC_T)(HAVE_PROT_RECVMSG_1,
1123 HAVE_PROT_RECVMSG_2,
1124 HAVE_PROT_RECVMSG_3);
1125 RECVMSG_FUNC_T function = (RECVMSG_FUNC_T)symbolfunction(SYMBOL_RECVMSG);
1126 const int tagged = (doing_addrinit ? 0 : 1);
1127
1128 if (tagged)
1129 socks_syscall_start(s);
1130
1131 rc = function(s, msg, flags);
1132
1133 if (tagged)
1134 socks_syscall_end(s);
1135
1136 return rc;
1137 }
1138 #endif /* HAVE_EXTRA_OSF_SYMBOLS */
1139
1140 #if HAVE_RRESVPORT
1141 int
sys_rresvport(port)1142 sys_rresvport(port)
1143 int *port;
1144 {
1145 typedef int (*RRESVPORT_FUNC_T)(int *);
1146 RRESVPORT_FUNC_T function;
1147
1148 function = (RRESVPORT_FUNC_T)symbolfunction(SYMBOL_RRESVPORT);
1149 return function(port);
1150 }
1151 #endif /* HAVE_RRESVPORT */
1152
1153 HAVE_PROT_SEND_0
sys_send(s,msg,len,flags)1154 sys_send(s, msg, len, flags)
1155 HAVE_PROT_SEND_1 s;
1156 HAVE_PROT_SEND_2 msg;
1157 HAVE_PROT_SEND_3 len;
1158 HAVE_PROT_SEND_4 flags;
1159 {
1160 ssize_t rc;
1161 typedef HAVE_PROT_SEND_0 (*SEND_FUNC_T)(HAVE_PROT_SEND_1,
1162 HAVE_PROT_SEND_2,
1163 HAVE_PROT_SEND_3,
1164 HAVE_PROT_SEND_4);
1165 SEND_FUNC_T function = (SEND_FUNC_T)symbolfunction(SYMBOL_SEND);
1166 const int tagged = (doing_addrinit ? 0 : 1);
1167
1168 if (tagged)
1169 socks_syscall_start(s);
1170
1171 rc = function(s, msg, len, flags);
1172
1173 if (tagged)
1174 socks_syscall_end(s);
1175
1176 return rc;
1177 }
1178
1179 #if !HAVE_EXTRA_OSF_SYMBOLS
1180 HAVE_PROT_SENDMSG_0
sys_sendmsg(s,msg,flags)1181 sys_sendmsg(s, msg, flags)
1182 HAVE_PROT_SENDMSG_1 s;
1183 HAVE_PROT_SENDMSG_2 msg;
1184 HAVE_PROT_SENDMSG_3 flags;
1185 {
1186 ssize_t rc;
1187 typedef HAVE_PROT_SENDMSG_0 (*SENDMSG_FUNC_T)(HAVE_PROT_SENDMSG_1,
1188 HAVE_PROT_SENDMSG_2,
1189 HAVE_PROT_SENDMSG_3);
1190 SENDMSG_FUNC_T function = (SENDMSG_FUNC_T)symbolfunction(SYMBOL_SENDMSG);
1191 const int tagged = (doing_addrinit ? 0 : 1);
1192
1193 if (tagged)
1194 socks_syscall_start(s);
1195
1196 rc = function(s, msg, flags);
1197
1198 if (tagged)
1199 socks_syscall_end(s);
1200
1201 return rc;
1202 }
1203 #endif /* HAVE_EXTRA_OSF_SYMBOLS */
1204
1205 #if !HAVE_EXTRA_OSF_SYMBOLS
1206 HAVE_PROT_SENDTO_0
sys_sendto(s,msg,len,flags,to,tolen)1207 sys_sendto(s, msg, len, flags, to, tolen)
1208 HAVE_PROT_SENDTO_1 s;
1209 HAVE_PROT_SENDTO_2 msg;
1210 HAVE_PROT_SENDTO_3 len;
1211 HAVE_PROT_SENDTO_4 flags;
1212 HAVE_PROT_SENDTO_5 to;
1213 HAVE_PROT_SENDTO_6 tolen;
1214 {
1215 ssize_t rc;
1216 typedef HAVE_PROT_SENDTO_0 (*SENDTO_FUNC_T)(HAVE_PROT_SENDTO_1,
1217 HAVE_PROT_SENDTO_2,
1218 HAVE_PROT_SENDTO_3,
1219 HAVE_PROT_SENDTO_4,
1220 HAVE_PROT_SENDTO_5,
1221 HAVE_PROT_SENDTO_6);
1222 SENDTO_FUNC_T function = (SENDTO_FUNC_T)symbolfunction(SYMBOL_SENDTO);
1223 const int tagged = (doing_addrinit ? 0 : 1);
1224
1225 if (tagged)
1226 socks_syscall_start(s);
1227
1228 rc = function(s, msg, len, flags, to, tolen);
1229
1230 if (tagged)
1231 socks_syscall_end(s);
1232
1233 return rc;
1234 }
1235 #endif /* !HAVE_EXTRA_OSF_SYMBOLS */
1236
1237 HAVE_PROT_WRITE_0
sys_write(d,buf,nbytes)1238 sys_write(d, buf, nbytes)
1239 HAVE_PROT_WRITE_1 d;
1240 HAVE_PROT_WRITE_2 buf;
1241 HAVE_PROT_WRITE_3 nbytes;
1242 {
1243 ssize_t rc;
1244 typedef HAVE_PROT_WRITE_0 (*WRITE_FUNC_T)(HAVE_PROT_WRITE_1,
1245 HAVE_PROT_WRITE_2,
1246 HAVE_PROT_WRITE_3);
1247 WRITE_FUNC_T function = (WRITE_FUNC_T)symbolfunction(SYMBOL_WRITE);
1248 const int tagged = (doing_addrinit ? 0 : 1);
1249
1250 if (tagged)
1251 socks_syscall_start(d);
1252
1253 rc = function(d, buf, nbytes);
1254
1255 if (tagged)
1256 socks_syscall_end(d);
1257
1258 return rc;
1259 }
1260
1261 #if DEBUG
1262 HAVE_PROT_WRITE_0 syssys_write(HAVE_PROT_WRITE_1 d, HAVE_PROT_WRITE_2 buf,
1263 HAVE_PROT_WRITE_3 nbytes);
1264 HAVE_PROT_WRITE_0
syssys_write(d,buf,nbytes)1265 syssys_write(d, buf, nbytes)
1266 HAVE_PROT_WRITE_1 d;
1267 HAVE_PROT_WRITE_2 buf;
1268 HAVE_PROT_WRITE_3 nbytes;
1269 {
1270 typedef HAVE_PROT_WRITE_0 (*WRITE_FUNC_T)(HAVE_PROT_WRITE_1,
1271 HAVE_PROT_WRITE_2,
1272 HAVE_PROT_WRITE_3);
1273 WRITE_FUNC_T function;
1274
1275 function = (WRITE_FUNC_T)symbolfunction(SYMBOL_WRITE);
1276 return function(d, buf, nbytes);
1277 }
1278 #endif /* DEBUG */
1279
1280 #if !HAVE_EXTRA_OSF_SYMBOLS
1281 HAVE_PROT_WRITEV_0
sys_writev(d,iov,iovcnt)1282 sys_writev(d, iov, iovcnt)
1283 HAVE_PROT_WRITEV_1 d;
1284 HAVE_PROT_WRITEV_2 iov;
1285 HAVE_PROT_WRITEV_3 iovcnt;
1286 {
1287 ssize_t rc;
1288 typedef HAVE_PROT_WRITEV_0 (*WRITEV_FUNC_T)(HAVE_PROT_WRITEV_1,
1289 HAVE_PROT_WRITEV_2,
1290 HAVE_PROT_WRITEV_3);
1291 WRITEV_FUNC_T function = (WRITEV_FUNC_T)symbolfunction(SYMBOL_WRITEV);
1292 const int tagged = (doing_addrinit ? 0 : 1);
1293
1294 if (tagged)
1295 socks_syscall_start(d);
1296
1297 rc = function(d, iov, iovcnt);
1298
1299 if (tagged)
1300 socks_syscall_end(d);
1301
1302 return rc;
1303 }
1304 #endif /* HAVE_EXTRA_OSF_SYMBOLS */
1305
1306 #if HAVE_GSSAPI && HAVE_LINUX_GLIBC_WORKAROUND
1307 HAVE_PROT_GETC_0
sys_getc(stream)1308 sys_getc(stream)
1309 HAVE_PROT_GETC_1 stream;
1310 {
1311 const int d = fileno(stream);
1312 HAVE_PROT_GETC_0 rc;
1313 typedef HAVE_PROT_GETC_0 (*GETC_FUNC_T)(HAVE_PROT_GETC_1);
1314 GETC_FUNC_T function = (GETC_FUNC_T)symbolfunction(SYMBOL_GETC);
1315 const int tagged = (doing_addrinit ? 0 : 1);
1316
1317 if (tagged)
1318 socks_syscall_start(d);
1319
1320 rc = function(stream);
1321
1322 if (tagged)
1323 socks_syscall_end(d);
1324
1325 return rc;
1326 }
1327
1328 HAVE_PROT_FGETC_0
sys_fgetc(stream)1329 sys_fgetc(stream)
1330 HAVE_PROT_FGETC_1 stream;
1331 {
1332 const int d = fileno(stream);
1333 HAVE_PROT_FGETC_0 rc;
1334 typedef HAVE_PROT_FGETC_0 (*FGETC_FUNC_T)(HAVE_PROT_FGETC_1);
1335 FGETC_FUNC_T function = (FGETC_FUNC_T)symbolfunction(SYMBOL_FGETC);
1336 const int tagged = (doing_addrinit ? 0 : 1);
1337
1338 if (tagged)
1339 socks_syscall_start(d);
1340
1341 rc = function(stream);
1342
1343 if (tagged)
1344 socks_syscall_end(d);
1345
1346 return rc;
1347 }
1348
1349 HAVE_PROT_GETS_0
sys_gets(buf)1350 sys_gets(buf)
1351 HAVE_PROT_GETS_1 buf;
1352 {
1353 const int d = fileno(stdin);
1354 HAVE_PROT_GETS_0 rv;
1355 typedef HAVE_PROT_GETS_0(*GETS_FUNC_T)(HAVE_PROT_GETS_1);
1356 GETS_FUNC_T function = (GETS_FUNC_T)symbolfunction(SYMBOL_GETS);
1357 const int tagged = (doing_addrinit ? 0 : 1);
1358
1359 if (tagged)
1360 socks_syscall_start(d);
1361
1362 rv = function(buf);
1363
1364 if (tagged)
1365 socks_syscall_end(d);
1366
1367 return rv;
1368 }
1369
1370 HAVE_PROT_FGETS_0
sys_fgets(buf,size,stream)1371 sys_fgets(buf, size, stream)
1372 HAVE_PROT_FGETS_1 buf;
1373 HAVE_PROT_FGETS_2 size;
1374 HAVE_PROT_FGETS_3 stream;
1375 {
1376 const int d = fileno(stream);
1377 HAVE_PROT_FGETS_0 rc;
1378 typedef HAVE_PROT_FGETS_0(*FGETS_FUNC_T)(HAVE_PROT_FGETS_1,
1379 HAVE_PROT_FGETS_2,
1380 HAVE_PROT_FGETS_3);
1381 FGETS_FUNC_T function = (FGETS_FUNC_T)symbolfunction(SYMBOL_FGETS);
1382 const int tagged = (doing_addrinit ? 0 : 1);
1383
1384 if (tagged)
1385 socks_syscall_start(d);
1386
1387 rc = function(buf, size, stream);
1388
1389 if (tagged)
1390 socks_syscall_end(d);
1391
1392 return rc;
1393 }
1394
1395 HAVE_PROT_PUTC_0
sys_putc(c,stream)1396 sys_putc(c, stream)
1397 HAVE_PROT_PUTC_1 c;
1398 HAVE_PROT_PUTC_2 stream;
1399 {
1400 const int d = fileno(stream);
1401 HAVE_PROT_PUTC_0 rc;
1402 typedef HAVE_PROT_PUTC_0(*PUTC_FUNC_T)(HAVE_PROT_PUTC_1, HAVE_PROT_PUTC_2);
1403 PUTC_FUNC_T function = (PUTC_FUNC_T)symbolfunction(SYMBOL_PUTC);
1404 const int tagged = (doing_addrinit ? 0 : 1);
1405
1406 if (tagged)
1407 socks_syscall_start(d);
1408
1409 rc = function(c, stream);
1410
1411 if (tagged)
1412 socks_syscall_end(d);
1413
1414 return rc;
1415 }
1416
1417 HAVE_PROT_FPUTC_0
sys_fputc(c,stream)1418 sys_fputc(c, stream)
1419 HAVE_PROT_FPUTC_1 c;
1420 HAVE_PROT_FPUTC_2 stream;
1421 {
1422 const int d = fileno(stream);
1423 HAVE_PROT_FPUTC_0 rc;
1424 typedef HAVE_PROT_FPUTC_0 (*FPUTC_FUNC_T)(HAVE_PROT_FPUTC_1,
1425 HAVE_PROT_FPUTC_2);
1426 FPUTC_FUNC_T function = (FPUTC_FUNC_T)symbolfunction(SYMBOL_FPUTC);
1427 const int tagged = (doing_addrinit ? 0 : 1);
1428
1429 if (tagged)
1430 socks_syscall_start(d);
1431
1432 rc = function(c, stream);
1433
1434 if (tagged)
1435 socks_syscall_end(d);
1436
1437 return rc;
1438 }
1439
1440 HAVE_PROT_PUTS_0
sys_puts(buf)1441 sys_puts(buf)
1442 HAVE_PROT_PUTS_1 buf;
1443 {
1444 const int d = fileno(stdout);
1445 HAVE_PROT_PUTS_0 rc;
1446 typedef HAVE_PROT_PUTS_0 (*PUTS_FUNC_T)(HAVE_PROT_PUTS_1);
1447 PUTS_FUNC_T function = (PUTS_FUNC_T)symbolfunction(SYMBOL_PUTS);
1448 const int tagged = (doing_addrinit ? 0 : 1);
1449
1450 if (tagged)
1451 socks_syscall_start(d);
1452
1453 rc = function(buf);
1454
1455 if (tagged)
1456 socks_syscall_end(d);
1457
1458 return rc;
1459 }
1460
1461 HAVE_PROT_FPUTS_0
sys_fputs(buf,stream)1462 sys_fputs(buf, stream)
1463 HAVE_PROT_FPUTS_1 buf;
1464 HAVE_PROT_FPUTS_2 stream;
1465 {
1466 const int d = fileno(stream);
1467 HAVE_PROT_FPUTS_0 rc;
1468 typedef HAVE_PROT_FPUTS_0 (*FPUTS_FUNC_T)(HAVE_PROT_FPUTS_1,
1469 HAVE_PROT_FPUTS_2);
1470 FPUTS_FUNC_T function = (FPUTS_FUNC_T)symbolfunction(SYMBOL_FPUTS);
1471 const int tagged = (doing_addrinit ? 0 : 1);
1472
1473 if (tagged)
1474 socks_syscall_start(d);
1475
1476 rc = function(buf, stream);
1477
1478 if (tagged)
1479 socks_syscall_end(d);
1480
1481 return rc;
1482 }
1483
1484 HAVE_PROT_FFLUSH_0
sys_fflush(stream)1485 sys_fflush(stream)
1486 HAVE_PROT_FFLUSH_1 stream;
1487 {
1488 HAVE_PROT_FFLUSH_0 rc;
1489 typedef HAVE_PROT_FFLUSH_0 (*FFLUSH_FUNC_T)(HAVE_PROT_FFLUSH_1);
1490 FFLUSH_FUNC_T function = (FFLUSH_FUNC_T)symbolfunction(SYMBOL_FFLUSH);
1491 const int tagged = (doing_addrinit ? 0 : 1);
1492
1493 if (stream != NULL && tagged)
1494 socks_syscall_start(fileno(stream));
1495
1496 rc = function(stream);
1497
1498 if (stream != NULL && tagged)
1499 socks_syscall_end(fileno(stream));
1500
1501 return rc;
1502 }
1503
1504 HAVE_PROT_FCLOSE_0
sys_fclose(stream)1505 sys_fclose(stream)
1506 HAVE_PROT_FCLOSE_1 stream;
1507 {
1508 const int d = fileno(stream);
1509 HAVE_PROT_FCLOSE_0 rc;
1510 typedef HAVE_PROT_FCLOSE_0 (*FCLOSE_FUNC_T)(HAVE_PROT_FCLOSE_1);
1511 FCLOSE_FUNC_T function = (FCLOSE_FUNC_T)symbolfunction(SYMBOL_FCLOSE);
1512 const int tagged = (doing_addrinit ? 0 : 1);
1513
1514 if (tagged)
1515 socks_syscall_start(d);
1516
1517 rc = function(stream);
1518
1519 if (tagged)
1520 socks_syscall_end(d);
1521
1522 return rc;
1523 }
1524
1525 HAVE_PROT_PRINTF_0
sys_printf(HAVE_PROT_PRINTF_1 format,...)1526 sys_printf(HAVE_PROT_PRINTF_1 format, ...)
1527 {
1528 va_list ap;
1529 HAVE_PROT_FPRINTF_0 rc;
1530
1531 va_start(ap, format);
1532 rc = sys_vprintf(format, ap);
1533 va_end(ap);
1534 return rc;
1535 }
1536
1537 HAVE_PROT_VPRINTF_0
sys_vprintf(format,ap)1538 sys_vprintf(format, ap)
1539 HAVE_PROT_VPRINTF_1 format;
1540 HAVE_PROT_VPRINTF_2 ap;
1541 {
1542 const int d = fileno(stdout);
1543 HAVE_PROT_VFPRINTF_0 rc;
1544 typedef HAVE_PROT_VPRINTF_0 (*VPRINTF_FUNC_T)(HAVE_PROT_VPRINTF_1,
1545 HAVE_PROT_VPRINTF_2);
1546 VPRINTF_FUNC_T function = (VPRINTF_FUNC_T)symbolfunction(SYMBOL_VPRINTF);
1547 const int tagged = (doing_addrinit ? 0 : 1);
1548
1549 if (tagged)
1550 socks_syscall_start(d);
1551
1552 rc = function(format, ap);
1553
1554 if (tagged)
1555 socks_syscall_end(d);
1556
1557 return rc;
1558 }
1559
1560 HAVE_PROT_FPRINTF_0
sys_fprintf(HAVE_PROT_FPRINTF_1 stream,HAVE_PROT_FPRINTF_2 format,...)1561 sys_fprintf(HAVE_PROT_FPRINTF_1 stream, HAVE_PROT_FPRINTF_2 format, ...)
1562 {
1563 va_list ap;
1564 HAVE_PROT_FPRINTF_0 rc;
1565
1566 va_start(ap, format);
1567 rc = sys_vfprintf(stream, format, ap);
1568 va_end(ap);
1569 return rc;
1570 }
1571
1572 HAVE_PROT_VFPRINTF_0
sys_vfprintf(stream,format,ap)1573 sys_vfprintf(stream, format, ap)
1574 HAVE_PROT_VFPRINTF_1 stream;
1575 HAVE_PROT_VFPRINTF_2 format;
1576 HAVE_PROT_VFPRINTF_3 ap;
1577 {
1578 HAVE_PROT_VFPRINTF_0 rc;
1579 int d = fileno(stream);
1580 typedef HAVE_PROT_VFPRINTF_0 (*VFPRINTF_FUNC_T)(HAVE_PROT_VFPRINTF_1,
1581 HAVE_PROT_VFPRINTF_2,
1582 HAVE_PROT_VFPRINTF_3);
1583 VFPRINTF_FUNC_T function = (VFPRINTF_FUNC_T)symbolfunction(SYMBOL_VFPRINTF);
1584 const int tagged = (doing_addrinit ? 0 : 1);
1585
1586 if (tagged)
1587 socks_syscall_start(d);
1588
1589 rc = function(stream, format, ap);
1590
1591 if (tagged)
1592 socks_syscall_end(d);
1593
1594 return rc;
1595 }
1596
1597 HAVE_PROT_FWRITE_0
sys_fwrite(ptr,size,nmb,stream)1598 sys_fwrite(ptr, size, nmb, stream)
1599 HAVE_PROT_FWRITE_1 ptr;
1600 HAVE_PROT_FWRITE_2 size;
1601 HAVE_PROT_FWRITE_3 nmb;
1602 HAVE_PROT_FWRITE_4 stream;
1603 {
1604 const int d = fileno(stream);
1605 HAVE_PROT_FWRITE_0 rc;
1606 typedef HAVE_PROT_FWRITE_0 (*FWRITE_FUNC_T)(HAVE_PROT_FWRITE_1,
1607 HAVE_PROT_FWRITE_2,
1608 HAVE_PROT_FWRITE_3,
1609 HAVE_PROT_FWRITE_4);
1610 FWRITE_FUNC_T function = (FWRITE_FUNC_T)symbolfunction(SYMBOL_FWRITE);
1611 const int tagged = (doing_addrinit ? 0 : 1);
1612
1613 if (tagged)
1614 socks_syscall_start(d);
1615
1616 rc = function(ptr, size, nmb, stream);
1617
1618 if (tagged)
1619 socks_syscall_end(d);
1620
1621 return rc;
1622 }
1623
1624 HAVE_PROT_FREAD_0
sys_fread(ptr,size,nmb,stream)1625 sys_fread(ptr, size, nmb, stream)
1626 HAVE_PROT_FREAD_1 ptr;
1627 HAVE_PROT_FREAD_2 size;
1628 HAVE_PROT_FREAD_3 nmb;
1629 HAVE_PROT_FREAD_4 stream;
1630 {
1631 const int d = fileno(stream);
1632 HAVE_PROT_FREAD_0 rc;
1633 typedef HAVE_PROT_FREAD_0 (*FREAD_FUNC_T)(HAVE_PROT_FREAD_1,
1634 HAVE_PROT_FREAD_2,
1635 HAVE_PROT_FREAD_3,
1636 HAVE_PROT_FREAD_4);
1637 FREAD_FUNC_T function = (FREAD_FUNC_T)symbolfunction(SYMBOL_FREAD);
1638 const int tagged = (doing_addrinit ? 0 : 1);
1639
1640 if (tagged)
1641 socks_syscall_start(d);
1642
1643 rc = function(ptr, size, nmb, stream);
1644
1645 if (tagged)
1646 socks_syscall_end(d);
1647
1648 return rc;
1649 }
1650 #endif /* HAVE_GSSAPI && HAVE_LINUX_GLIBC_WORKAROUND */
1651
1652 /*
1653 * the interpositioned functions.
1654 */
1655
1656 #if !HAVE_EXTRA_OSF_SYMBOLS
1657 HAVE_PROT_ACCEPT_0
accept(s,addr,addrlen)1658 accept(s, addr, addrlen)
1659 HAVE_PROT_ACCEPT_1 s;
1660 HAVE_PROT_ACCEPT_2 addr;
1661 HAVE_PROT_ACCEPT_3 addrlen;
1662 {
1663 if (socks_issyscall(s, SYMBOL_ACCEPT))
1664 return sys_accept(s, addr, addrlen);
1665 return Raccept(s, addr, (socklen_t *)addrlen);
1666 }
1667 #endif /* HAVE_EXTRA_OSF_SYMBOLS */
1668
1669 #if !HAVE_EXTRA_OSF_SYMBOLS
1670 HAVE_PROT_BIND_0
bind(s,name,namelen)1671 bind(s, name, namelen)
1672 HAVE_PROT_BIND_1 s;
1673 HAVE_PROT_BIND_2 name;
1674 HAVE_PROT_BIND_3 namelen;
1675 {
1676 if (socks_issyscall(s, SYMBOL_BIND))
1677 return sys_bind(s, name, namelen);
1678 return Rbind(s, name, namelen);
1679 }
1680 #endif /* !HAVE_EXTRA_OSF_SYMBOLS */
1681
1682 int
bindresvport(sd,sin)1683 bindresvport(sd, sin)
1684 int sd;
1685 struct sockaddr_in *sin;
1686 {
1687 if (socks_issyscall(sd, SYMBOL_BINDRESVPORT))
1688 return sys_bindresvport(sd, sin);
1689 return Rbindresvport(sd, sin);
1690 }
1691
1692 #if !HAVE_EXTRA_OSF_SYMBOLS
1693 HAVE_PROT_CONNECT_0
connect(s,name,namelen)1694 connect(s, name, namelen)
1695 HAVE_PROT_CONNECT_1 s;
1696 HAVE_PROT_CONNECT_2 name;
1697 HAVE_PROT_CONNECT_3 namelen;
1698 {
1699 if (socks_issyscall(s, SYMBOL_CONNECT))
1700 return sys_connect(s, name, namelen);
1701 return Rconnect(s, name, namelen);
1702 }
1703 #endif /* HAVE_EXTRA_OSF_SYMBOLS */
1704
1705 #if !HAVE_EXTRA_OSF_SYMBOLS
1706 HAVE_PROT_GETPEERNAME_0
getpeername(s,name,namelen)1707 getpeername(s, name, namelen)
1708 HAVE_PROT_GETPEERNAME_1 s;
1709 HAVE_PROT_GETPEERNAME_2 name;
1710 HAVE_PROT_GETPEERNAME_3 namelen;
1711 {
1712 if (socks_issyscall(s, SYMBOL_GETPEERNAME))
1713 return sys_getpeername(s, name, namelen);
1714 return Rgetpeername(s, name, namelen);
1715 }
1716 #endif /* HAVE_EXTRA_OSF_SYMBOLS */
1717
1718 #if !HAVE_EXTRA_OSF_SYMBOLS
1719 HAVE_PROT_GETSOCKNAME_0
getsockname(s,name,namelen)1720 getsockname(s, name, namelen)
1721 HAVE_PROT_GETSOCKNAME_1 s;
1722 HAVE_PROT_GETSOCKNAME_2 name;
1723 HAVE_PROT_GETSOCKNAME_3 namelen;
1724 {
1725 if (socks_issyscall(s, SYMBOL_GETSOCKNAME))
1726 return sys_getsockname(s, name, namelen);
1727 return Rgetsockname(s, name, namelen);
1728 }
1729 #endif /* HAVE_EXTRA_OSF_SYMBOLS */
1730
1731 HAVE_PROT_GETSOCKOPT_0
getsockopt(s,level,optname,optval,optlen)1732 getsockopt(s, level, optname, optval, optlen)
1733 HAVE_PROT_GETSOCKOPT_1 s;
1734 HAVE_PROT_GETSOCKOPT_2 level;
1735 HAVE_PROT_GETSOCKOPT_3 optname;
1736 HAVE_PROT_GETSOCKOPT_4 optval;
1737 HAVE_PROT_GETSOCKOPT_5 optlen;
1738 {
1739 if (socks_issyscall(s, SYMBOL_GETSOCKNAME))
1740 return sys_getsockopt(s, level, optname, optval, optlen);
1741 return Rgetsockopt(s, level, optname, optval, optlen);
1742 }
1743
1744 HAVE_PROT_LISTEN_0
listen(s,backlog)1745 listen(s, backlog)
1746 HAVE_PROT_LISTEN_1 s;
1747 HAVE_PROT_LISTEN_2 backlog;
1748 {
1749 if (socks_issyscall(s, SYMBOL_LISTEN))
1750 return sys_listen(s, backlog);
1751 return Rlisten(s, backlog);
1752 }
1753
1754 HAVE_PROT_READ_0
read(d,buf,nbytes)1755 read(d, buf, nbytes)
1756 HAVE_PROT_READ_1 d;
1757 HAVE_PROT_READ_2 buf;
1758 HAVE_PROT_READ_3 nbytes;
1759 {
1760 if (socks_issyscall(d, SYMBOL_READ))
1761 return sys_read(d, buf, nbytes);
1762 return Rread(d, buf, nbytes);
1763 }
1764
1765 #if !HAVE_EXTRA_OSF_SYMBOLS
1766 HAVE_PROT_READV_0
readv(d,iov,iovcnt)1767 readv(d, iov, iovcnt)
1768 HAVE_PROT_READV_1 d;
1769 HAVE_PROT_READV_2 iov;
1770 HAVE_PROT_READV_3 iovcnt;
1771 {
1772 if (socks_issyscall(d, SYMBOL_READV))
1773 return sys_readv(d, iov, iovcnt);
1774 return Rreadv(d, iov, iovcnt);
1775 }
1776 #endif /* HAVE_EXTRA_OSF_SYMBOLS */
1777
1778 HAVE_PROT_RECV_0
recv(s,msg,len,flags)1779 recv(s, msg, len, flags)
1780 HAVE_PROT_RECV_1 s;
1781 HAVE_PROT_RECV_2 msg;
1782 HAVE_PROT_RECV_3 len;
1783 HAVE_PROT_RECV_4 flags;
1784 {
1785 if (socks_issyscall(s, SYMBOL_RECV))
1786 return sys_recv(s, msg, len, flags);
1787 return Rrecv(s, msg, len, flags);
1788 }
1789
1790 #if !HAVE_EXTRA_OSF_SYMBOLS
1791 HAVE_PROT_RECVFROM_0
recvfrom(s,buf,len,flags,from,fromlen)1792 recvfrom(s, buf, len, flags, from, fromlen)
1793 HAVE_PROT_RECVFROM_1 s;
1794 HAVE_PROT_RECVFROM_2 buf;
1795 HAVE_PROT_RECVFROM_3 len;
1796 HAVE_PROT_RECVFROM_4 flags;
1797 HAVE_PROT_RECVFROM_5 from;
1798 HAVE_PROT_RECVFROM_6 fromlen;
1799 {
1800 if (socks_issyscall(s, SYMBOL_RECVFROM))
1801 return sys_recvfrom(s, buf, len, flags, from, fromlen);
1802 return Rrecvfrom(s, buf, len, flags, from, fromlen);
1803 }
1804 #endif /* HAVE_EXTRA_OSF_SYMBOLS */
1805
1806 #if !HAVE_EXTRA_OSF_SYMBOLS
1807 HAVE_PROT_RECVMSG_0
recvmsg(s,msg,flags)1808 recvmsg(s, msg, flags)
1809 HAVE_PROT_RECVMSG_1 s;
1810 HAVE_PROT_RECVMSG_2 msg;
1811 HAVE_PROT_RECVMSG_3 flags;
1812 {
1813 if (socks_issyscall(s, SYMBOL_RECVMSG))
1814 return sys_recvmsg(s, msg, flags);
1815 return Rrecvmsg(s, msg, flags);
1816 }
1817 #endif /* HAVE_EXTRA_OSF_SYMBOLS */
1818
1819 #if HAVE_RRESVPORT
1820 int
rresvport(port)1821 rresvport(port)
1822 int *port;
1823 {
1824 return Rrresvport(port);
1825 }
1826 #endif /* HAVE_RRESVPORT */
1827
1828 HAVE_PROT_WRITE_0
write(d,buf,nbytes)1829 write(d, buf, nbytes)
1830 HAVE_PROT_WRITE_1 d;
1831 HAVE_PROT_WRITE_2 buf;
1832 HAVE_PROT_WRITE_3 nbytes;
1833 {
1834 if (socks_issyscall(d, SYMBOL_WRITE))
1835 return sys_write(d, buf, nbytes);
1836 return Rwrite(d, buf, nbytes);
1837 }
1838
1839 #if !HAVE_EXTRA_OSF_SYMBOLS
1840 HAVE_PROT_WRITEV_0
writev(d,iov,iovcnt)1841 writev(d, iov, iovcnt)
1842 HAVE_PROT_WRITEV_1 d;
1843 HAVE_PROT_WRITEV_2 iov;
1844 HAVE_PROT_WRITEV_3 iovcnt;
1845 {
1846 if (socks_issyscall(d, SYMBOL_WRITEV))
1847 return sys_writev(d, iov, iovcnt);
1848 return Rwritev(d, iov, iovcnt);
1849 }
1850 #endif /* HAVE_EXTRA_OSF_SYMBOLS */
1851
1852 HAVE_PROT_SEND_0
send(s,msg,len,flags)1853 send(s, msg, len, flags)
1854 HAVE_PROT_SEND_1 s;
1855 HAVE_PROT_SEND_2 msg;
1856 HAVE_PROT_SEND_3 len;
1857 HAVE_PROT_SEND_4 flags;
1858 {
1859 if (socks_issyscall(s, SYMBOL_SEND))
1860 return sys_send(s, msg, len, flags);
1861 return Rsend(s, msg, len, flags);
1862 }
1863
1864 #if !HAVE_EXTRA_OSF_SYMBOLS
1865 HAVE_PROT_SENDMSG_0
sendmsg(s,msg,flags)1866 sendmsg(s, msg, flags)
1867 HAVE_PROT_SENDMSG_1 s;
1868 HAVE_PROT_SENDMSG_2 msg;
1869 HAVE_PROT_SENDMSG_3 flags;
1870 {
1871 if (socks_issyscall(s, SYMBOL_SENDMSG))
1872 return sys_sendmsg(s, msg, flags);
1873 return Rsendmsg(s, msg, flags);
1874 }
1875 #endif /* HAVE_EXTRA_OSF_SYMBOLS */
1876
1877 #if !HAVE_EXTRA_OSF_SYMBOLS
1878 HAVE_PROT_SENDTO_0
sendto(s,msg,len,flags,to,tolen)1879 sendto(s, msg, len, flags, to, tolen)
1880 HAVE_PROT_SENDTO_1 s;
1881 HAVE_PROT_SENDTO_2 msg;
1882 HAVE_PROT_SENDTO_3 len;
1883 HAVE_PROT_SENDTO_4 flags;
1884 HAVE_PROT_SENDTO_5 to;
1885 HAVE_PROT_SENDTO_6 tolen;
1886 {
1887 if (socks_issyscall(s, SYMBOL_SENDTO))
1888 return sys_sendto(s, msg, len, flags, to, tolen);
1889 return Rsendto(s, msg, len, flags, to, tolen);
1890 }
1891 #endif /* !HAVE_EXTRA_OSF_SYMBOLS */
1892
1893 #ifdef __sun
1894 /* __xnet_foo variants of some functions exist on Solaris if _XPG4_2 is set */
1895
1896 HAVE_PROT_BIND_0
sys_xnet_bind(s,name,namelen)1897 sys_xnet_bind(s, name, namelen)
1898 HAVE_PROT_BIND_1 s;
1899 HAVE_PROT_BIND_2 name;
1900 HAVE_PROT_BIND_3 namelen;
1901 {
1902 int rc;
1903 typedef HAVE_PROT_BIND_0 (*BIND_FUNC_T)(HAVE_PROT_BIND_1,
1904 HAVE_PROT_BIND_2,
1905 HAVE_PROT_BIND_3);
1906 BIND_FUNC_T function = (BIND_FUNC_T)symbolfunction(SYMBOL_XNET_BIND);
1907 const int tagged = (doing_addrinit ? 0 : 1);
1908
1909 if (tagged)
1910 socks_syscall_start(s);
1911
1912 rc = function(s, name, namelen);
1913
1914 if (tagged)
1915 socks_syscall_end(s);
1916
1917 return rc;
1918 }
1919
1920 HAVE_PROT_BIND_0
__xnet_bind(s,name,namelen)1921 __xnet_bind(s, name, namelen)
1922 HAVE_PROT_BIND_1 s;
1923 HAVE_PROT_BIND_2 name;
1924 HAVE_PROT_BIND_3 namelen;
1925 {
1926 if (socks_issyscall(s, SYMBOL_XNET_BIND))
1927 return sys_xnet_bind(s, name, namelen);
1928 return Rbind(s, name, namelen);
1929 }
1930
1931 HAVE_PROT_CONNECT_0
sys_xnet_connect(s,name,namelen)1932 sys_xnet_connect(s, name, namelen)
1933 HAVE_PROT_CONNECT_1 s;
1934 HAVE_PROT_CONNECT_2 name;
1935 HAVE_PROT_CONNECT_3 namelen;
1936 {
1937 int rc;
1938 typedef HAVE_PROT_CONNECT_0 (*CONNECT_FUNC_T)(HAVE_PROT_CONNECT_1,
1939 HAVE_PROT_CONNECT_2,
1940 HAVE_PROT_CONNECT_3);
1941 CONNECT_FUNC_T function
1942 = (CONNECT_FUNC_T)symbolfunction(SYMBOL_XNET_CONNECT);
1943 const int tagged = (doing_addrinit ? 0 : 1);
1944
1945 if (tagged)
1946 socks_syscall_start(s);
1947
1948 rc = function(s, name, namelen);
1949
1950 if (tagged)
1951 socks_syscall_end(s);
1952
1953 return rc;
1954 }
1955
1956 HAVE_PROT_CONNECT_0
__xnet_connect(s,name,namelen)1957 __xnet_connect(s, name, namelen)
1958 HAVE_PROT_CONNECT_1 s;
1959 HAVE_PROT_CONNECT_2 name;
1960 HAVE_PROT_CONNECT_3 namelen;
1961 {
1962 if (socks_issyscall(s, SYMBOL_XNET_CONNECT))
1963 return sys_xnet_connect(s, name, namelen);
1964 return Rconnect(s, name, namelen);
1965 }
1966
1967 HAVE_PROT_LISTEN_0
sys_xnet_listen(s,backlog)1968 sys_xnet_listen(s, backlog)
1969 HAVE_PROT_LISTEN_1 s;
1970 HAVE_PROT_LISTEN_2 backlog;
1971 {
1972 HAVE_PROT_LISTEN_0 rc;
1973 typedef HAVE_PROT_LISTEN_0 (*LISTEN_FUNC_T)(HAVE_PROT_LISTEN_1,
1974 HAVE_PROT_LISTEN_2);
1975 LISTEN_FUNC_T function = (LISTEN_FUNC_T)symbolfunction(SYMBOL_XNET_LISTEN);
1976 const int tagged = (doing_addrinit ? 0 : 1);
1977
1978 if (tagged)
1979 socks_syscall_start(s);
1980
1981 rc = function(s, backlog);
1982
1983 if (tagged)
1984 socks_syscall_end(s);
1985
1986 return rc;
1987 }
1988
1989 HAVE_PROT_LISTEN_0
__xnet_listen(s,backlog)1990 __xnet_listen(s, backlog)
1991 HAVE_PROT_LISTEN_1 s;
1992 HAVE_PROT_LISTEN_2 backlog;
1993 {
1994 if (socks_issyscall(s, SYMBOL_XNET_LISTEN))
1995 return sys_xnet_listen(s, backlog);
1996 return Rlisten(s, backlog);
1997 }
1998
1999 HAVE_PROT_RECVMSG_0
sys_xnet_recvmsg(s,msg,flags)2000 sys_xnet_recvmsg(s, msg, flags)
2001 HAVE_PROT_RECVMSG_1 s;
2002 HAVE_PROT_RECVMSG_2 msg;
2003 HAVE_PROT_RECVMSG_3 flags;
2004 {
2005 ssize_t rc;
2006 typedef HAVE_PROT_RECVMSG_0 (*RECVMSG_FUNC_T)(HAVE_PROT_RECVMSG_1,
2007 HAVE_PROT_RECVMSG_2,
2008 HAVE_PROT_RECVMSG_3);
2009 RECVMSG_FUNC_T function
2010 = (RECVMSG_FUNC_T)symbolfunction(SYMBOL_XNET_RECVMSG);
2011 const int tagged = (doing_addrinit ? 0 : 1);
2012
2013 if (tagged)
2014 socks_syscall_start(s);
2015
2016 rc = function(s, msg, flags);
2017
2018 if (tagged)
2019 socks_syscall_end(s);
2020
2021 return rc;
2022 }
2023
2024 HAVE_PROT_RECVMSG_0
__xnet_recvmsg(s,msg,flags)2025 __xnet_recvmsg(s, msg, flags)
2026 HAVE_PROT_RECVMSG_1 s;
2027 HAVE_PROT_RECVMSG_2 msg;
2028 HAVE_PROT_RECVMSG_3 flags;
2029 {
2030 if (socks_issyscall(s, SYMBOL_XNET_RECVMSG))
2031 return sys_xnet_recvmsg(s, msg, flags);
2032 return Rrecvmsg(s, msg, flags);
2033 }
2034
2035 HAVE_PROT_SENDMSG_0
sys_xnet_sendmsg(s,msg,flags)2036 sys_xnet_sendmsg(s, msg, flags)
2037 HAVE_PROT_SENDMSG_1 s;
2038 HAVE_PROT_SENDMSG_2 msg;
2039 HAVE_PROT_SENDMSG_3 flags;
2040 {
2041 ssize_t rc;
2042 typedef HAVE_PROT_SENDMSG_0 (*SENDMSG_FUNC_T)(HAVE_PROT_SENDMSG_1,
2043 HAVE_PROT_SENDMSG_2,
2044 HAVE_PROT_SENDMSG_3);
2045 SENDMSG_FUNC_T function
2046 = (SENDMSG_FUNC_T)symbolfunction(SYMBOL_XNET_SENDMSG);
2047 const int tagged = (doing_addrinit ? 0 : 1);
2048
2049 if (tagged)
2050 socks_syscall_start(s);
2051
2052 rc = function(s, msg, flags);
2053
2054 if (tagged)
2055 socks_syscall_end(s);
2056
2057 return rc;
2058 }
2059
2060 HAVE_PROT_SENDMSG_0
__xnet_sendmsg(s,msg,flags)2061 __xnet_sendmsg(s, msg, flags)
2062 HAVE_PROT_SENDMSG_1 s;
2063 HAVE_PROT_SENDMSG_2 msg;
2064 HAVE_PROT_SENDMSG_3 flags;
2065 {
2066 if (socks_issyscall(s, SYMBOL_XNET_SENDMSG))
2067 return sys_xnet_sendmsg(s, msg, flags);
2068 return Rsendmsg(s, msg, flags);
2069 }
2070
2071 HAVE_PROT_SENDTO_0
sys_xnet_sendto(s,msg,len,flags,to,tolen)2072 sys_xnet_sendto(s, msg, len, flags, to, tolen)
2073 HAVE_PROT_SENDTO_1 s;
2074 HAVE_PROT_SENDTO_2 msg;
2075 HAVE_PROT_SENDTO_3 len;
2076 HAVE_PROT_SENDTO_4 flags;
2077 HAVE_PROT_SENDTO_5 to;
2078 HAVE_PROT_SENDTO_6 tolen;
2079 {
2080 ssize_t rc;
2081 typedef HAVE_PROT_SENDTO_0 (*SENDTO_FUNC_T)(HAVE_PROT_SENDTO_1,
2082 HAVE_PROT_SENDTO_2,
2083 HAVE_PROT_SENDTO_3,
2084 HAVE_PROT_SENDTO_4,
2085 HAVE_PROT_SENDTO_5,
2086 HAVE_PROT_SENDTO_6);
2087 SENDTO_FUNC_T function = (SENDTO_FUNC_T)symbolfunction(SYMBOL_XNET_SENDTO);
2088 const int tagged = (doing_addrinit ? 0 : 1);
2089
2090 if (tagged)
2091 socks_syscall_start(s);
2092
2093 rc = function(s, msg, len, flags, to, tolen);
2094
2095 if (tagged)
2096 socks_syscall_end(s);
2097
2098 return rc;
2099 }
2100
2101 HAVE_PROT_SENDTO_0
__xnet_sendto(s,msg,len,flags,to,tolen)2102 __xnet_sendto(s, msg, len, flags, to, tolen)
2103 HAVE_PROT_SENDTO_1 s;
2104 HAVE_PROT_SENDTO_2 msg;
2105 HAVE_PROT_SENDTO_3 len;
2106 HAVE_PROT_SENDTO_4 flags;
2107 HAVE_PROT_SENDTO_5 to;
2108 HAVE_PROT_SENDTO_6 tolen;
2109 {
2110 if (socks_issyscall(s, SYMBOL_XNET_SENDTO))
2111 return sys_xnet_sendto(s, msg, len, flags, to, tolen);
2112 return Rsendto(s, msg, len, flags, to, tolen);
2113 }
2114
2115 #endif /* __sun */
2116
2117 #ifdef __FreeBSD__
2118 HAVE_PROT_ACCEPT_0
_accept(s,addr,addrlen)2119 _accept(s, addr, addrlen)
2120 HAVE_PROT_ACCEPT_1 s;
2121 HAVE_PROT_ACCEPT_2 addr;
2122 HAVE_PROT_ACCEPT_3 addrlen;
2123 {
2124 if (socks_issyscall(s, SYMBOL_ACCEPT))
2125 return sys_accept(s, addr, addrlen);
2126 return Raccept(s, addr, (socklen_t *)addrlen);
2127 }
2128
2129 HAVE_PROT_BIND_0
_bind(s,name,namelen)2130 _bind(s, name, namelen)
2131 HAVE_PROT_BIND_1 s;
2132 HAVE_PROT_BIND_2 name;
2133 HAVE_PROT_BIND_3 namelen;
2134 {
2135 if (socks_issyscall(s, SYMBOL_BIND))
2136 return sys_bind(s, name, namelen);
2137 return Rbind(s, name, namelen);
2138 }
2139
2140 HAVE_PROT_CONNECT_0
_connect(s,name,namelen)2141 _connect(s, name, namelen)
2142 HAVE_PROT_CONNECT_1 s;
2143 HAVE_PROT_CONNECT_2 name;
2144 HAVE_PROT_CONNECT_3 namelen;
2145 {
2146 if (socks_issyscall(s, SYMBOL_CONNECT))
2147 return sys_connect(s, name, namelen);
2148 return Rconnect(s, name, namelen);
2149 }
2150
2151 HAVE_PROT_GETPEERNAME_0
_getpeername(s,name,namelen)2152 _getpeername(s, name, namelen)
2153 HAVE_PROT_GETPEERNAME_1 s;
2154 HAVE_PROT_GETPEERNAME_2 name;
2155 HAVE_PROT_GETPEERNAME_3 namelen;
2156 {
2157 if (socks_issyscall(s, SYMBOL_GETPEERNAME))
2158 return sys_getpeername(s, name, namelen);
2159 return Rgetpeername(s, name, namelen);
2160 }
2161
2162 HAVE_PROT_GETSOCKNAME_0
_getsockname(s,name,namelen)2163 _getsockname(s, name, namelen)
2164 HAVE_PROT_GETSOCKNAME_1 s;
2165 HAVE_PROT_GETSOCKNAME_2 name;
2166 HAVE_PROT_GETSOCKNAME_3 namelen;
2167 {
2168 if (socks_issyscall(s, SYMBOL_GETSOCKNAME))
2169 return sys_getsockname(s, name, namelen);
2170 return Rgetsockname(s, name, namelen);
2171 }
2172
2173 HAVE_PROT_LISTEN_0
_listen(s,backlog)2174 _listen(s, backlog)
2175 HAVE_PROT_LISTEN_1 s;
2176 HAVE_PROT_LISTEN_2 backlog;
2177 {
2178 if (socks_issyscall(s, SYMBOL_LISTEN))
2179 return sys_listen(s, backlog);
2180 return Rlisten(s, backlog);
2181 }
2182
2183 HAVE_PROT_READ_0
_read(d,buf,nbytes)2184 _read(d, buf, nbytes)
2185 HAVE_PROT_READ_1 d;
2186 HAVE_PROT_READ_2 buf;
2187 HAVE_PROT_READ_3 nbytes;
2188 {
2189 if (socks_issyscall(d, SYMBOL_READ))
2190 return sys_read(d, buf, nbytes);
2191 return Rread(d, buf, nbytes);
2192 }
2193
2194 HAVE_PROT_READV_0
_readv(d,iov,iovcnt)2195 _readv(d, iov, iovcnt)
2196 HAVE_PROT_READV_1 d;
2197 HAVE_PROT_READV_2 iov;
2198 HAVE_PROT_READV_3 iovcnt;
2199 {
2200 if (socks_issyscall(d, SYMBOL_READV))
2201 return sys_readv(d, iov, iovcnt);
2202 return Rreadv(d, iov, iovcnt);
2203 }
2204
2205 HAVE_PROT_RECV_0
_recv(s,msg,len,flags)2206 _recv(s, msg, len, flags)
2207 HAVE_PROT_RECV_1 s;
2208 HAVE_PROT_RECV_2 msg;
2209 HAVE_PROT_RECV_3 len;
2210 HAVE_PROT_RECV_4 flags;
2211 {
2212 if (socks_issyscall(s, SYMBOL_RECV))
2213 return sys_recv(s, msg, len, flags);
2214 return Rrecv(s, msg, len, flags);
2215 }
2216
2217 HAVE_PROT_RECVFROM_0
_recvfrom(s,buf,len,flags,from,fromlen)2218 _recvfrom(s, buf, len, flags, from, fromlen)
2219 HAVE_PROT_RECVFROM_1 s;
2220 HAVE_PROT_RECVFROM_2 buf;
2221 HAVE_PROT_RECVFROM_3 len;
2222 HAVE_PROT_RECVFROM_4 flags;
2223 HAVE_PROT_RECVFROM_5 from;
2224 HAVE_PROT_RECVFROM_6 fromlen;
2225 {
2226 if (socks_issyscall(s, SYMBOL_RECVFROM))
2227 return sys_recvfrom(s, buf, len, flags, from, fromlen);
2228 return Rrecvfrom(s, buf, len, flags, from, fromlen);
2229 }
2230
2231 HAVE_PROT_RECVMSG_0
_recvmsg(s,msg,flags)2232 _recvmsg(s, msg, flags)
2233 HAVE_PROT_RECVMSG_1 s;
2234 HAVE_PROT_RECVMSG_2 msg;
2235 HAVE_PROT_RECVMSG_3 flags;
2236 {
2237 if (socks_issyscall(s, SYMBOL_RECVMSG))
2238 return sys_recvmsg(s, msg, flags);
2239 return Rrecvmsg(s, msg, flags);
2240 }
2241
2242 HAVE_PROT_WRITE_0
_write(d,buf,nbytes)2243 _write(d, buf, nbytes)
2244 HAVE_PROT_WRITE_1 d;
2245 HAVE_PROT_WRITE_2 buf;
2246 HAVE_PROT_WRITE_3 nbytes;
2247 {
2248 if (socks_issyscall(d, SYMBOL_WRITE))
2249 return sys_write(d, buf, nbytes);
2250 return Rwrite(d, buf, nbytes);
2251 }
2252
2253 HAVE_PROT_WRITEV_0
_writev(d,iov,iovcnt)2254 _writev(d, iov, iovcnt)
2255 HAVE_PROT_WRITEV_1 d;
2256 HAVE_PROT_WRITEV_2 iov;
2257 HAVE_PROT_WRITEV_3 iovcnt;
2258 {
2259 if (socks_issyscall(d, SYMBOL_WRITEV))
2260 return sys_writev(d, iov, iovcnt);
2261 return Rwritev(d, iov, iovcnt);
2262 }
2263
2264 HAVE_PROT_SEND_0
_send(s,msg,len,flags)2265 _send(s, msg, len, flags)
2266 HAVE_PROT_SEND_1 s;
2267 HAVE_PROT_SEND_2 msg;
2268 HAVE_PROT_SEND_3 len;
2269 HAVE_PROT_SEND_4 flags;
2270 {
2271 if (socks_issyscall(s, SYMBOL_SEND))
2272 return sys_send(s, msg, len, flags);
2273 return Rsend(s, msg, len, flags);
2274 }
2275
2276 HAVE_PROT_SENDMSG_0
_sendmsg(s,msg,flags)2277 _sendmsg(s, msg, flags)
2278 HAVE_PROT_SENDMSG_1 s;
2279 HAVE_PROT_SENDMSG_2 msg;
2280 HAVE_PROT_SENDMSG_3 flags;
2281 {
2282 if (socks_issyscall(s, SYMBOL_SENDMSG))
2283 return sys_sendmsg(s, msg, flags);
2284 return Rsendmsg(s, msg, flags);
2285 }
2286
2287 HAVE_PROT_SENDTO_0
_sendto(s,msg,len,flags,to,tolen)2288 _sendto(s, msg, len, flags, to, tolen)
2289 HAVE_PROT_SENDTO_1 s;
2290 HAVE_PROT_SENDTO_2 msg;
2291 HAVE_PROT_SENDTO_3 len;
2292 HAVE_PROT_SENDTO_4 flags;
2293 HAVE_PROT_SENDTO_5 to;
2294 HAVE_PROT_SENDTO_6 tolen;
2295 {
2296 if (socks_issyscall(s, SYMBOL_SENDTO))
2297 return sys_sendto(s, msg, len, flags, to, tolen);
2298 return Rsendto(s, msg, len, flags, to, tolen);
2299 }
2300 #endif /* __FreeBSD__ */
2301
2302
2303 #else /* !SOCKS_CLIENT */
2304
2305 /*
2306 * For a few functions interposed into external libraries (libwrap, ldap, etc.)
2307 * used by the server.
2308 */
2309
2310 struct hostent *
sys_gethostbyaddr(addr,len,af)2311 sys_gethostbyaddr(addr, len, af)
2312 const char *addr;
2313 socklen_t len;
2314 int af;
2315 {
2316 typedef struct hostent *(*GETHOSTBYADDR_FUNC_T)(const char *, int, int);
2317 GETHOSTBYADDR_FUNC_T function
2318 = (GETHOSTBYADDR_FUNC_T)symbolfunction(SYMBOL_GETHOSTBYADDR);
2319
2320 return function(addr, len, af);
2321 }
2322
2323 HAVE_PROT_GETHOSTBYADDR_0
gethostbyaddr(addr,len,af)2324 gethostbyaddr(addr, len, af)
2325 HAVE_PROT_GETHOSTBYADDR_1 addr;
2326 HAVE_PROT_GETHOSTBYADDR_2 len;
2327 HAVE_PROT_GETHOSTBYADDR_3 af;
2328 {
2329
2330 if (socks_shouldcallasnative(SYMBOL_GETHOSTBYADDR))
2331 return sys_gethostbyaddr(addr, len, af);
2332 return cgethostbyaddr(addr, len, af);
2333 }
2334
2335 #endif /* !SOCKS_CLIENT */
2336
2337 struct hostent *
sys_gethostbyname(name)2338 sys_gethostbyname(name)
2339 const char *name;
2340 {
2341 struct hostent *rc;
2342 typedef struct hostent *(*GETHOSTBYNAME_FUNC_T)(const char *);
2343 GETHOSTBYNAME_FUNC_T function
2344 = (GETHOSTBYNAME_FUNC_T)symbolfunction(SYMBOL_GETHOSTBYNAME);
2345
2346 DNSCODE_START();
2347 rc = function(name);
2348 DNSCODE_END();
2349
2350 return rc;
2351 }
2352
2353 struct hostent *
gethostbyname(name)2354 gethostbyname(name)
2355 const char *name;
2356 {
2357 #if !SOCKS_CLIENT
2358 return cgethostbyname(name);
2359
2360 #else /* SOCKS_CLIENT */
2361 if (socks_shouldcallasnative(SYMBOL_GETHOSTBYNAME)) {
2362 struct hostent *rc;
2363
2364 DNSCODE_START();
2365 rc = sys_gethostbyname(name);
2366 DNSCODE_END();
2367
2368 return rc;
2369 }
2370
2371 return Rgethostbyname(name);
2372 #endif /* SOCKS_CLIENT */
2373 }
2374
2375 #if SOCKS_CLIENT
2376
2377 #if HAVE_GETADDRINFO
2378 int
sys_getaddrinfo(nodename,servname,hints,res)2379 sys_getaddrinfo(nodename, servname, hints, res)
2380 const char *nodename;
2381 const char *servname;
2382 const struct addrinfo *hints;
2383 struct addrinfo **res;
2384 {
2385 typedef int (*GETADDRINFO_FUNC_T)(const char *, const char *,
2386 const struct addrinfo *,
2387 struct addrinfo **);
2388 GETADDRINFO_FUNC_T function
2389 = (GETADDRINFO_FUNC_T)symbolfunction(SYMBOL_GETADDRINFO);
2390 int rc;
2391
2392 DNSCODE_START();
2393 rc = function(nodename, servname, hints, res);
2394 DNSCODE_END();
2395
2396 return rc;
2397 }
2398
2399 int
getaddrinfo(nodename,servname,hints,res)2400 getaddrinfo(nodename, servname, hints, res)
2401 const char *nodename;
2402 const char *servname;
2403 const struct addrinfo *hints;
2404 struct addrinfo **res;
2405 {
2406 int rc;
2407
2408 if (socks_shouldcallasnative(SYMBOL_GETADDRINFO)) {
2409 DNSCODE_START();
2410 rc = sys_getaddrinfo(nodename, servname, hints, res);
2411 DNSCODE_END();
2412
2413 return rc;
2414 }
2415
2416 return Rgetaddrinfo(nodename, servname, hints, res);
2417 }
2418
2419 #endif /* HAVE_GETADDRINFO */
2420
2421 #if HAVE_GETNAMEINFO
2422
2423 HAVE_PROT_GETNAMEINFO_0
sys_getnameinfo(sa,salen,host,hostlen,serv,servlen,flags)2424 sys_getnameinfo(sa, salen, host, hostlen, serv, servlen, flags)
2425 HAVE_PROT_GETNAMEINFO_1 sa;
2426 HAVE_PROT_GETNAMEINFO_2 salen;
2427 HAVE_PROT_GETNAMEINFO_3 host;
2428 HAVE_PROT_GETNAMEINFO_4 hostlen;
2429 HAVE_PROT_GETNAMEINFO_5 serv;
2430 HAVE_PROT_GETNAMEINFO_6 servlen;
2431 HAVE_PROT_GETNAMEINFO_7 flags;
2432 {
2433 typedef HAVE_PROT_GETNAMEINFO_0 (*GETNAMEINFO_FUNC_T)(
2434 HAVE_PROT_GETNAMEINFO_1,
2435 HAVE_PROT_GETNAMEINFO_2,
2436 HAVE_PROT_GETNAMEINFO_3,
2437 HAVE_PROT_GETNAMEINFO_4,
2438 HAVE_PROT_GETNAMEINFO_5,
2439 HAVE_PROT_GETNAMEINFO_6,
2440 HAVE_PROT_GETNAMEINFO_7);
2441 GETNAMEINFO_FUNC_T function
2442 = (GETNAMEINFO_FUNC_T)symbolfunction(SYMBOL_GETNAMEINFO);
2443 int rc;
2444
2445 DNSCODE_START();
2446 rc = function(sa, salen, host, hostlen, serv, servlen, flags);
2447 DNSCODE_END();
2448
2449 return rc;
2450 }
2451
2452 #endif /* HAVE_GETNAMEINFO */
2453
2454
2455 struct hostent *
sys_gethostbyname2(name,af)2456 sys_gethostbyname2(name, af)
2457 const char *name;
2458 int af;
2459 {
2460 struct hostent *rc;
2461 typedef struct hostent *(*GETHOSTBYNAME2_FUNC_T)(const char *, int);
2462 GETHOSTBYNAME2_FUNC_T function
2463 = (GETHOSTBYNAME2_FUNC_T)symbolfunction(SYMBOL_GETHOSTBYNAME2);
2464
2465 DNSCODE_START();
2466 rc = function(name, af);
2467 DNSCODE_END();
2468
2469 return rc;
2470 }
2471
2472 struct hostent *
gethostbyname2(name,af)2473 gethostbyname2(name, af)
2474 const char *name;
2475 int af;
2476 {
2477 if (socks_shouldcallasnative(SYMBOL_GETHOSTBYNAME2)) {
2478 struct hostent *rc;
2479
2480 DNSCODE_START();
2481 rc = sys_gethostbyname2(name, af);
2482 DNSCODE_END();
2483
2484 return rc;
2485 }
2486
2487 return Rgethostbyname2(name, af);
2488 }
2489
2490 #if HAVE_GETIPNODEBYNAME
2491
2492 struct hostent *
sys_getipnodebyname(name,af,flags,error_num)2493 sys_getipnodebyname(name, af, flags, error_num)
2494 const char *name;
2495 int af;
2496 int flags;
2497 int *error_num;
2498 {
2499 struct hostent *rc;
2500 typedef struct hostent *(*GETIPNODEBYNAME_FUNC_T)(const char *, int, int,
2501 int *);
2502 GETIPNODEBYNAME_FUNC_T function
2503 = (GETIPNODEBYNAME_FUNC_T)symbolfunction(SYMBOL_GETIPNODEBYNAME);
2504
2505 DNSCODE_START();
2506 rc = function(name, af, flags, error_num);
2507 DNSCODE_END();
2508
2509 return rc;
2510
2511 }
2512
2513 struct hostent *
getipnodebyname(name,af,flags,error_num)2514 getipnodebyname(name, af, flags, error_num)
2515 const char *name;
2516 int af;
2517 int flags;
2518 int *error_num;
2519 {
2520
2521 if (socks_shouldcallasnative(SYMBOL_GETIPNODEBYNAME)) {
2522 struct hostent *rc;
2523
2524 DNSCODE_START();
2525 rc = sys_getipnodebyname(name, af, flags, error_num);
2526 DNSCODE_END();
2527
2528 return rc;
2529 }
2530
2531 return Rgetipnodebyname(name, af, flags, error_num);
2532 }
2533
2534 void
sys_freehostent(ptr)2535 sys_freehostent(ptr)
2536 struct hostent *ptr;
2537 {
2538 typedef struct hostent *(*FREEHOSTENT_FUNC_T)(struct hostent *);
2539
2540 FREEHOSTENT_FUNC_T function
2541 = (FREEHOSTENT_FUNC_T)symbolfunction(SYMBOL_FREEHOSTENT);
2542
2543 function(ptr);
2544 }
2545
2546 void
freehostent(ptr)2547 freehostent(ptr)
2548 struct hostent *ptr;
2549 {
2550
2551 if (socks_shouldcallasnative(SYMBOL_FREEHOSTENT))
2552 sys_freehostent(ptr);
2553 else
2554 Rfreehostent(ptr);
2555 }
2556
2557 #endif /* HAVE_GETIPNODEBYNAME */
2558
2559 #if HAVE_GSSAPI && HAVE_LINUX_GLIBC_WORKAROUND
2560
2561 #ifdef getc
2562 #undef getc
2563 #endif /* getc */
2564
2565 HAVE_PROT_GETC_0
getc(stream)2566 getc(stream)
2567 HAVE_PROT_GETC_1 stream;
2568 {
2569 const int d = fileno(stream);
2570
2571 if (!sockscf.state.havegssapisockets || socks_issyscall(d, SYMBOL_GETC))
2572 return sys_getc(stream);
2573 return Rfgetc(stream);
2574 }
2575
2576 #if HAVE__IO_GETC
2577 HAVE_PROT__IO_GETC_0
_IO_getc(stream)2578 _IO_getc(stream)
2579 HAVE_PROT__IO_GETC_1 stream;
2580 {
2581 const int d = fileno(stream);
2582
2583 if (!sockscf.state.havegssapisockets || socks_issyscall(d, SYMBOL__IO_GETC))
2584 return sys_getc(stream);
2585 return Rfgetc(stream);
2586 }
2587 #endif /* HAVE__IO_GETC */
2588
2589 HAVE_PROT_FGETC_0
fgetc(stream)2590 fgetc(stream)
2591 HAVE_PROT_FGETC_1 stream;
2592 {
2593 const int d = fileno(stream);
2594
2595 if (!sockscf.state.havegssapisockets || socks_issyscall(d, SYMBOL_FGETC))
2596 return sys_getc(stream);
2597 return Rfgetc(stream);
2598 }
2599
2600 HAVE_PROT_GETS_0
gets(buf)2601 gets(buf)
2602 HAVE_PROT_GETS_1 buf;
2603 {
2604 const int d = fileno(stdin);
2605
2606 if (!sockscf.state.havegssapisockets || socks_issyscall(d, SYMBOL_GETS))
2607 return sys_gets(buf);
2608 return Rgets(buf);
2609 }
2610
2611 HAVE_PROT_FGETS_0
fgets(buf,size,stream)2612 fgets(buf, size, stream)
2613 HAVE_PROT_FGETS_1 buf;
2614 HAVE_PROT_FGETS_2 size;
2615 HAVE_PROT_FGETS_3 stream;
2616 {
2617 const int d = fileno(stream);
2618
2619 if (!sockscf.state.havegssapisockets || socks_issyscall(d, SYMBOL_FGETS))
2620 return sys_fgets(buf, size, stream);
2621 return Rfgets(buf, size, stream);
2622 }
2623
2624 HAVE_PROT_PUTC_0
putc(c,stream)2625 putc(c, stream)
2626 HAVE_PROT_PUTC_1 c;
2627 HAVE_PROT_PUTC_2 stream;
2628 {
2629 const int d = fileno(stream);
2630
2631 if (!sockscf.state.havegssapisockets || socks_issyscall(d, SYMBOL_PUTC))
2632 return sys_putc(c, stream);
2633 return Rfputc(c, stream);
2634 }
2635
2636 #if HAVE__IO_PUTC
2637 HAVE_PROT__IO_PUTC_0
_IO_putc(c,stream)2638 _IO_putc(c, stream)
2639 HAVE_PROT__IO_PUTC_1 c;
2640 HAVE_PROT__IO_PUTC_2 stream;
2641 {
2642 const int d = fileno(stream);
2643
2644 if (!sockscf.state.havegssapisockets || socks_issyscall(d, SYMBOL__IO_PUTC))
2645 return sys_putc(c, stream);
2646 return Rfputc(c, stream);
2647 }
2648 #endif /* HAVE__IO_PUTC */
2649
2650 HAVE_PROT_FPUTC_0
fputc(c,stream)2651 fputc(c, stream)
2652 HAVE_PROT_FPUTC_1 c;
2653 HAVE_PROT_FPUTC_2 stream;
2654 {
2655 const int d = fileno(stream);
2656
2657 if (!sockscf.state.havegssapisockets || socks_issyscall(d, SYMBOL_FPUTC))
2658 return sys_fputc(c, stream);
2659 return Rfputc(c, stream);
2660 }
2661
2662 HAVE_PROT_PUTS_0
puts(buf)2663 puts(buf)
2664 HAVE_PROT_PUTS_1 buf;
2665 {
2666 const int d = fileno(stdout);
2667
2668 if (!sockscf.state.havegssapisockets || socks_issyscall(d, SYMBOL_PUTS))
2669 return sys_puts(buf);
2670 return Rfputs(buf, stdout);
2671 }
2672
2673 HAVE_PROT_FPUTS_0
fputs(buf,stream)2674 fputs(buf, stream)
2675 HAVE_PROT_FPUTS_1 buf;
2676 HAVE_PROT_FPUTS_2 stream;
2677 {
2678 const int d = fileno(stream);
2679
2680 if (!sockscf.state.havegssapisockets || socks_issyscall(d, SYMBOL_FPUTS))
2681 return sys_fputs(buf, stream);
2682 return Rfputs(buf, stream);
2683 }
2684
2685 HAVE_PROT_FFLUSH_0
fflush(stream)2686 fflush(stream)
2687 HAVE_PROT_FFLUSH_1 stream;
2688 {
2689
2690 if (!sockscf.state.havegssapisockets
2691 || stream == NULL
2692 || socks_issyscall(fileno(stream), SYMBOL_FFLUSH))
2693 return sys_fflush(stream);
2694 return Rfflush(stream);
2695 }
2696
2697 HAVE_PROT_FCLOSE_0
fclose(stream)2698 fclose(stream)
2699 HAVE_PROT_FCLOSE_1 stream;
2700 {
2701 const int d = fileno(stream);
2702
2703 if (!sockscf.state.havegssapisockets || socks_issyscall(d, SYMBOL_FCLOSE))
2704 return sys_fclose(stream);
2705 return Rfclose(stream);
2706 }
2707
2708 HAVE_PROT_PRINTF_0
printf(HAVE_PROT_PRINTF_1 format,...)2709 printf(HAVE_PROT_PRINTF_1 format, ...)
2710 {
2711 const int d = fileno(stdout);
2712 va_list ap;
2713 int rc;
2714
2715 va_start(ap, format);
2716
2717 if (!sockscf.state.havegssapisockets || socks_issyscall(d, SYMBOL_PRINTF)) {
2718 rc = sys_vprintf(format, ap);
2719 va_end(ap);
2720 return rc;
2721 }
2722
2723 rc = Rvfprintf(stdout, format, ap);
2724 va_end(ap);
2725
2726 return rc;
2727 }
2728
2729 HAVE_PROT_FPRINTF_0
fprintf(HAVE_PROT_FPRINTF_1 stream,HAVE_PROT_FPRINTF_2 format,...)2730 fprintf(HAVE_PROT_FPRINTF_1 stream, HAVE_PROT_FPRINTF_2 format, ...)
2731 {
2732 const int d = fileno(stream);
2733 va_list ap;
2734 int rc;
2735
2736 va_start(ap, format);
2737
2738 if (!sockscf.state.havegssapisockets || socks_issyscall(d, SYMBOL_FPRINTF)) {
2739 rc = sys_vfprintf(stream, format, ap);
2740 va_end(ap);
2741 return rc;
2742 }
2743
2744 rc = Rvfprintf(stream, format, ap);
2745 va_end(ap);
2746 return rc;
2747 }
2748
2749 #if HAVE___FPRINTF_CHK
2750 HAVE_PROT_FPRINTF_0
__fprintf_chk(HAVE_PROT_FPRINTF_1 stream,int dummy,HAVE_PROT_FPRINTF_2 format,...)2751 __fprintf_chk(HAVE_PROT_FPRINTF_1 stream, int dummy,
2752 HAVE_PROT_FPRINTF_2 format, ...)
2753 {
2754 const int d = fileno(stream);
2755 va_list ap;
2756 int rc;
2757
2758 va_start(ap, format);
2759
2760 if (!sockscf.state.havegssapisockets
2761 || socks_issyscall(d, SYMBOL___FPRINTF_CHK)) {
2762 rc = sys_vfprintf(stream, format, ap);
2763 va_end(ap);
2764 return rc;
2765 }
2766
2767 rc = Rvfprintf(stream, format, ap);
2768 va_end(ap);
2769 return rc;
2770 }
2771 #endif /* HAVE___FPRINTF_CHK */
2772
2773 HAVE_PROT_VPRINTF_0
vprintf(format,ap)2774 vprintf(format, ap)
2775 HAVE_PROT_VPRINTF_1 format;
2776 HAVE_PROT_VPRINTF_2 ap;
2777 {
2778 const int d = fileno(stdout);
2779
2780 if (!sockscf.state.havegssapisockets || socks_issyscall(d, SYMBOL_VPRINTF))
2781 return sys_vprintf(format, ap);
2782 return Rvfprintf(stdout, format, ap);
2783 }
2784
2785 HAVE_PROT_VFPRINTF_0
vfprintf(stream,format,ap)2786 vfprintf(stream, format, ap)
2787 HAVE_PROT_VFPRINTF_1 stream;
2788 HAVE_PROT_VFPRINTF_2 format;
2789 HAVE_PROT_VFPRINTF_3 ap;
2790 {
2791 const int d = fileno(stream);
2792
2793 if (!sockscf.state.havegssapisockets || socks_issyscall(d, SYMBOL_VFPRINTF))
2794 return sys_vfprintf(stream, format, ap);
2795 return Rvfprintf(stream, format, ap);
2796 }
2797
2798 #if HAVE___VFPRINTF_CHK
2799 HAVE_PROT_VFPRINTF_0
__vfprintf_chk(stream,dummy,format,ap)2800 __vfprintf_chk(stream, dummy, format, ap)
2801 HAVE_PROT_VFPRINTF_1 stream;
2802 int dummy;
2803 HAVE_PROT_VFPRINTF_2 format;
2804 HAVE_PROT_VFPRINTF_3 ap;
2805 {
2806 const int d = fileno(stream);
2807
2808 if (!sockscf.state.havegssapisockets
2809 || socks_issyscall(d, SYMBOL___VFPRINTF_CHK))
2810 return sys_vfprintf(stream, format, ap);
2811 return Rvfprintf(stream, format, ap);
2812 }
2813 #endif /* HAVE___VFPRINTF_CHK */
2814
2815 HAVE_PROT_FWRITE_0
fwrite(ptr,size,nmb,stream)2816 fwrite(ptr, size, nmb, stream)
2817 HAVE_PROT_FWRITE_1 ptr;
2818 HAVE_PROT_FWRITE_2 size;
2819 HAVE_PROT_FWRITE_3 nmb;
2820 HAVE_PROT_FWRITE_4 stream;
2821 {
2822 const int d = fileno(stream);
2823
2824 if (!sockscf.state.havegssapisockets || socks_issyscall(d, SYMBOL_FWRITE))
2825 return sys_fwrite(ptr, size, nmb, stream);
2826 return Rfwrite(ptr, size, nmb, stream);
2827 }
2828
2829 HAVE_PROT_FREAD_0
fread(ptr,size,nmb,stream)2830 fread(ptr, size, nmb, stream)
2831 HAVE_PROT_FREAD_1 ptr;
2832 HAVE_PROT_FREAD_2 size;
2833 HAVE_PROT_FREAD_3 nmb;
2834 HAVE_PROT_FREAD_4 stream;
2835 {
2836 const int d = fileno(stream);
2837
2838 if (!sockscf.state.havegssapisockets || socks_issyscall(d, SYMBOL_FREAD))
2839 return sys_fread(ptr, size, nmb, stream);
2840 return Rfread(ptr, size, nmb, stream);
2841 }
2842
2843 #if HAVE___READ_CHK
2844 HAVE_PROT__READ_CHK_0
__read_chk(d,buf,nbytes,buflen)2845 __read_chk(d, buf, nbytes, buflen)
2846 HAVE_PROT__READ_CHK_1 d;
2847 HAVE_PROT__READ_CHK_2 buf;
2848 HAVE_PROT__READ_CHK_3 nbytes;
2849 HAVE_PROT__READ_CHK_4 buflen;
2850 {
2851 SASSERTX(nbytes <= buflen);
2852
2853 if (!sockscf.state.havegssapisockets ||
2854 socks_issyscall(d, SYMBOL___READ_CHK))
2855 return sys_read(d, buf, nbytes);
2856
2857 return Rread(d, buf, nbytes);
2858 }
2859 #endif /* HAVE___READ_CHK */
2860
2861 #endif /* HAVE_GSSAPI && HAVE_LINUX_GLIBC_WORKAROUND */
2862
2863 #if HAVE_DARWIN
2864
2865 HAVE_PROT_READ_0
sys_read_nocancel(d,buf,nbytes)2866 sys_read_nocancel(d, buf, nbytes)
2867 HAVE_PROT_READ_1 d;
2868 HAVE_PROT_READ_2 buf;
2869 HAVE_PROT_READ_3 nbytes;
2870 {
2871 ssize_t rc;
2872 typedef HAVE_PROT_READ_0 (*READ_FUNC_T)(HAVE_PROT_READ_1,
2873 HAVE_PROT_READ_2,
2874 HAVE_PROT_READ_3);
2875 READ_FUNC_T function = (READ_FUNC_T)symbolfunction(SYMBOL_READ_NOCANCEL);
2876 const int tagged = (doing_addrinit ? 0 : 1);
2877
2878 if (tagged)
2879 socks_syscall_start(d);
2880
2881 rc = function(d, buf, nbytes);
2882
2883 if (tagged)
2884 socks_syscall_end(d);
2885
2886 return rc;
2887 }
2888
2889 HAVE_PROT_CONNECT_0
sys_connect_nocancel(s,name,namelen)2890 sys_connect_nocancel(s, name, namelen)
2891 HAVE_PROT_CONNECT_1 s;
2892 HAVE_PROT_CONNECT_2 name;
2893 HAVE_PROT_CONNECT_3 namelen;
2894 {
2895 int rc;
2896 typedef HAVE_PROT_CONNECT_0 (*CONNECT_FUNC_T)(HAVE_PROT_CONNECT_1,
2897 HAVE_PROT_CONNECT_2,
2898 HAVE_PROT_CONNECT_3);
2899 CONNECT_FUNC_T function =
2900 (CONNECT_FUNC_T)symbolfunction(SYMBOL_CONNECT_NOCANCEL);
2901 const int tagged = (doing_addrinit ? 0 : 1);
2902
2903 if (tagged)
2904 socks_syscall_start(s);
2905
2906 rc = function(s, name, namelen);
2907
2908 if (tagged)
2909 socks_syscall_end(s);
2910
2911 return rc;
2912 }
2913
2914 HAVE_PROT_RECVFROM_0
sys_recvfrom_nocancel(s,buf,len,flags,from,fromlen)2915 sys_recvfrom_nocancel(s, buf, len, flags, from, fromlen)
2916 HAVE_PROT_RECVFROM_1 s;
2917 HAVE_PROT_RECVFROM_2 buf;
2918 HAVE_PROT_RECVFROM_3 len;
2919 HAVE_PROT_RECVFROM_4 flags;
2920 HAVE_PROT_RECVFROM_5 from;
2921 HAVE_PROT_RECVFROM_6 fromlen;
2922 {
2923 int rc;
2924 typedef HAVE_PROT_RECVFROM_0 (*RECVFROM_FUNC_T)(HAVE_PROT_RECVFROM_1,
2925 HAVE_PROT_RECVFROM_2,
2926 HAVE_PROT_RECVFROM_3,
2927 HAVE_PROT_RECVFROM_4,
2928 HAVE_PROT_RECVFROM_5,
2929 HAVE_PROT_RECVFROM_6);
2930 RECVFROM_FUNC_T function =
2931 (RECVFROM_FUNC_T)symbolfunction(SYMBOL_RECVFROM_NOCANCEL);
2932 const int tagged = (doing_addrinit ? 0 : 1);
2933
2934 if (tagged)
2935 socks_syscall_start(s);
2936
2937 rc = function(s, buf, len, flags, from, fromlen);
2938
2939 if (tagged)
2940 socks_syscall_end(s);
2941
2942 return rc;
2943 }
2944
2945 HAVE_PROT_SENDTO_0
sys_sendto_nocancel(s,msg,len,flags,to,tolen)2946 sys_sendto_nocancel(s, msg, len, flags, to, tolen)
2947 HAVE_PROT_SENDTO_1 s;
2948 HAVE_PROT_SENDTO_2 msg;
2949 HAVE_PROT_SENDTO_3 len;
2950 HAVE_PROT_SENDTO_4 flags;
2951 HAVE_PROT_SENDTO_5 to;
2952 HAVE_PROT_SENDTO_6 tolen;
2953 {
2954 ssize_t rc;
2955 typedef HAVE_PROT_SENDTO_0 (*SENDTO_FUNC_T)(HAVE_PROT_SENDTO_1,
2956 HAVE_PROT_SENDTO_2,
2957 HAVE_PROT_SENDTO_3,
2958 HAVE_PROT_SENDTO_4,
2959 HAVE_PROT_SENDTO_5,
2960 HAVE_PROT_SENDTO_6);
2961 SENDTO_FUNC_T function =
2962 (SENDTO_FUNC_T)symbolfunction(SYMBOL_SENDTO_NOCANCEL);
2963 const int tagged = (doing_addrinit ? 0 : 1);
2964
2965 if (tagged)
2966 socks_syscall_start(s);
2967
2968 rc = function(s, msg, len, flags, to, tolen);
2969
2970 if (tagged)
2971 socks_syscall_end(s);
2972
2973 return rc;
2974 }
2975
2976 HAVE_PROT_WRITE_0
sys_write_nocancel(s,buf,nbytes)2977 sys_write_nocancel(s, buf, nbytes)
2978 HAVE_PROT_WRITE_1 s;
2979 HAVE_PROT_WRITE_2 buf;
2980 HAVE_PROT_WRITE_3 nbytes;
2981 {
2982 ssize_t rc;
2983 typedef HAVE_PROT_WRITE_0 (*WRITE_FUNC_T)(HAVE_PROT_WRITE_1,
2984 HAVE_PROT_WRITE_2,
2985 HAVE_PROT_WRITE_3);
2986 WRITE_FUNC_T function = (WRITE_FUNC_T)symbolfunction(SYMBOL_WRITE_NOCANCEL);
2987 const int tagged = (doing_addrinit ? 0 : 1);
2988
2989 if (tagged)
2990 socks_syscall_start(s);
2991
2992 rc = function(s, buf, nbytes);
2993
2994 if (tagged)
2995 socks_syscall_end(s);
2996
2997 return rc;
2998 }
2999
3000 HAVE_PROT_CONNECT_0
connect$NOCANCEL(s,name,namelen)3001 connect$NOCANCEL(s, name, namelen)
3002 HAVE_PROT_CONNECT_1 s;
3003 HAVE_PROT_CONNECT_2 name;
3004 HAVE_PROT_CONNECT_3 namelen;
3005 {
3006 if (!sockscf.state.havegssapisockets
3007 || socks_issyscall(s, SYMBOL_CONNECT_NOCANCEL))
3008 return sys_connect_nocancel(s, name, namelen);
3009
3010 return Rconnect(s, name, namelen);
3011 }
3012
3013 #if 1
3014 HAVE_PROT_READ_0
read$NOCANCEL(d,buf,nbytes)3015 read$NOCANCEL(d, buf, nbytes)
3016 HAVE_PROT_READ_1 d;
3017 HAVE_PROT_READ_2 buf;
3018 HAVE_PROT_READ_3 nbytes;
3019 {
3020 if (!sockscf.state.havegssapisockets
3021 || socks_issyscall(d, SYMBOL_READ_NOCANCEL))
3022 return sys_read_nocancel(d, buf, nbytes);
3023
3024 return Rread(d, buf, nbytes);
3025 }
3026 #endif
3027
3028 HAVE_PROT_RECVFROM_0
recvfrom$NOCANCEL(s,buf,len,flags,from,fromlen)3029 recvfrom$NOCANCEL(s, buf, len, flags, from, fromlen)
3030 HAVE_PROT_RECVFROM_1 s;
3031 HAVE_PROT_RECVFROM_2 buf;
3032 HAVE_PROT_RECVFROM_3 len;
3033 HAVE_PROT_RECVFROM_4 flags;
3034 HAVE_PROT_RECVFROM_5 from;
3035 HAVE_PROT_RECVFROM_6 fromlen;
3036 {
3037 if (!sockscf.state.havegssapisockets
3038 || socks_issyscall(s, SYMBOL_RECVFROM_NOCANCEL))
3039 return sys_recvfrom_nocancel(s, buf, len, flags, from, fromlen);
3040
3041 return Rrecvfrom(s, buf, len, flags, from, fromlen);
3042 }
3043
3044 HAVE_PROT_SENDTO_0
sendto$NOCANCEL(s,msg,len,flags,to,tolen)3045 sendto$NOCANCEL(s, msg, len, flags, to, tolen)
3046 HAVE_PROT_SENDTO_1 s;
3047 HAVE_PROT_SENDTO_2 msg;
3048 HAVE_PROT_SENDTO_3 len;
3049 HAVE_PROT_SENDTO_4 flags;
3050 HAVE_PROT_SENDTO_5 to;
3051 HAVE_PROT_SENDTO_6 tolen;
3052 {
3053 if (!sockscf.state.havegssapisockets
3054 || socks_issyscall(s, SYMBOL_SENDTO_NOCANCEL))
3055 return sys_sendto_nocancel(s, msg, len, flags, to, tolen);
3056
3057 return Rsendto(s, msg, len, flags, to, tolen);
3058 }
3059
3060 #if 1
3061 HAVE_PROT_WRITE_0
write$NOCANCEL(d,buf,nbytes)3062 write$NOCANCEL(d, buf, nbytes)
3063 HAVE_PROT_WRITE_1 d;
3064 HAVE_PROT_WRITE_2 buf;
3065 HAVE_PROT_WRITE_3 nbytes;
3066 {
3067 if (!sockscf.state.havegssapisockets
3068 || socks_issyscall(d, SYMBOL_WRITE_NOCANCEL))
3069 return sys_write_nocancel(d, buf, nbytes);
3070
3071 return Rwrite(d, buf, nbytes);
3072 }
3073 #endif
3074
3075 #endif /* HAVE_DARWIN */
3076
3077 static int
idsareequal(a,b)3078 idsareequal(a, b)
3079 const socks_id_t *a;
3080 const socks_id_t *b;
3081 {
3082
3083 switch (a->whichid) {
3084 case pid:
3085 if (a->id.pid == b->id.pid)
3086 return 1;
3087
3088 return 0;
3089
3090 case thread:
3091 /* pthread_equal() is more correct, but this should also work. */
3092 if (memcmp(&a->id.thread, &b->id.thread, sizeof(a->id.thread)) == 0)
3093 return 1;
3094 return 0;
3095
3096 default:
3097 SERRX(a->whichid);
3098 }
3099
3100 /* NOTREACHED */
3101 }
3102 #endif /* SOCKS_CLIENT */
3103
3104
3105 static libsymbol_t *
libsymbol(symbol)3106 libsymbol(symbol)
3107 const char *symbol;
3108 {
3109 /* const char *function = "libsymbol()"; */
3110 size_t i;
3111
3112 for (i = 0; i < ELEMENTS(libsymbolv); ++i)
3113 if (strcmp(libsymbolv[i].symbol, symbol) == 0)
3114 return &libsymbolv[i];
3115
3116 SERRX(0); /* should never happen. */
3117
3118 /* NOTREACHED */
3119 return NULL; /* please compiler. */
3120 }
3121
3122 #endif /* SOCKSLIBRARY_DYNAMIC */
3123