]>
Commit | Line | Data |
---|---|---|
f0cbd3ec FB |
1 | /* |
2 | * Copyright (c) 1995 Danny Gasparovski. | |
5fafdf24 | 3 | * |
f0cbd3ec FB |
4 | * Please read the file COPYRIGHT for the |
5 | * terms and conditions of the copyright. | |
6 | */ | |
7 | ||
f0cbd3ec | 8 | #include <slirp.h> |
6dbe553f JK |
9 | #include <libslirp.h> |
10 | ||
11 | #include "monitor.h" | |
f0cbd3ec | 12 | |
9634d903 | 13 | u_int curtime, time_fasttimo, last_slowtimo; |
f0cbd3ec | 14 | |
f0cbd3ec FB |
15 | /* |
16 | * Get our IP address and put it in our_addr | |
17 | */ | |
18 | void | |
511d2b14 | 19 | getouraddr(void) |
f0cbd3ec FB |
20 | { |
21 | char buff[256]; | |
f4e15b4b | 22 | struct hostent *he = NULL; |
5fafdf24 | 23 | |
f4e15b4b PB |
24 | if (gethostname(buff,256) == 0) |
25 | he = gethostbyname(buff); | |
26 | if (he) | |
27 | our_addr = *(struct in_addr *)he->h_addr; | |
8dbca8dd FB |
28 | if (our_addr.s_addr == 0) |
29 | our_addr.s_addr = loopback_addr.s_addr; | |
f0cbd3ec FB |
30 | } |
31 | ||
f0cbd3ec FB |
32 | struct quehead { |
33 | struct quehead *qh_link; | |
34 | struct quehead *qh_rlink; | |
35 | }; | |
36 | ||
37 | inline void | |
511d2b14 | 38 | insque(void *a, void *b) |
f0cbd3ec FB |
39 | { |
40 | register struct quehead *element = (struct quehead *) a; | |
41 | register struct quehead *head = (struct quehead *) b; | |
42 | element->qh_link = head->qh_link; | |
43 | head->qh_link = (struct quehead *)element; | |
44 | element->qh_rlink = (struct quehead *)head; | |
45 | ((struct quehead *)(element->qh_link))->qh_rlink | |
46 | = (struct quehead *)element; | |
47 | } | |
48 | ||
49 | inline void | |
511d2b14 | 50 | remque(void *a) |
f0cbd3ec FB |
51 | { |
52 | register struct quehead *element = (struct quehead *) a; | |
53 | ((struct quehead *)(element->qh_link))->qh_rlink = element->qh_rlink; | |
54 | ((struct quehead *)(element->qh_rlink))->qh_link = element->qh_link; | |
55 | element->qh_rlink = NULL; | |
f0cbd3ec FB |
56 | } |
57 | ||
a13a4126 JK |
58 | int add_exec(struct ex_list **ex_ptr, int do_pty, char *exec, |
59 | struct in_addr addr, int port) | |
f0cbd3ec FB |
60 | { |
61 | struct ex_list *tmp_ptr; | |
5fafdf24 | 62 | |
f0cbd3ec FB |
63 | /* First, check if the port is "bound" */ |
64 | for (tmp_ptr = *ex_ptr; tmp_ptr; tmp_ptr = tmp_ptr->ex_next) { | |
a13a4126 JK |
65 | if (port == tmp_ptr->ex_fport && |
66 | addr.s_addr == tmp_ptr->ex_addr.s_addr) | |
67 | return -1; | |
f0cbd3ec | 68 | } |
5fafdf24 | 69 | |
f0cbd3ec FB |
70 | tmp_ptr = *ex_ptr; |
71 | *ex_ptr = (struct ex_list *)malloc(sizeof(struct ex_list)); | |
72 | (*ex_ptr)->ex_fport = port; | |
73 | (*ex_ptr)->ex_addr = addr; | |
74 | (*ex_ptr)->ex_pty = do_pty; | |
e1c5a2b3 | 75 | (*ex_ptr)->ex_exec = (do_pty == 3) ? exec : strdup(exec); |
f0cbd3ec FB |
76 | (*ex_ptr)->ex_next = tmp_ptr; |
77 | return 0; | |
78 | } | |
79 | ||
80 | #ifndef HAVE_STRERROR | |
81 | ||
82 | /* | |
83 | * For systems with no strerror | |
84 | */ | |
85 | ||
86 | extern int sys_nerr; | |
87 | extern char *sys_errlist[]; | |
88 | ||
89 | char * | |
90 | strerror(error) | |
91 | int error; | |
92 | { | |
93 | if (error < sys_nerr) | |
94 | return sys_errlist[error]; | |
95 | else | |
96 | return "Unknown error."; | |
97 | } | |
98 | ||
99 | #endif | |
100 | ||
101 | ||
a3d4af03 FB |
102 | #ifdef _WIN32 |
103 | ||
104 | int | |
9634d903 | 105 | fork_exec(struct socket *so, const char *ex, int do_pty) |
a3d4af03 FB |
106 | { |
107 | /* not implemented */ | |
108 | return 0; | |
109 | } | |
110 | ||
111 | #else | |
112 | ||
f0cbd3ec FB |
113 | /* |
114 | * XXX This is ugly | |
115 | * We create and bind a socket, then fork off to another | |
116 | * process, which connects to this socket, after which we | |
117 | * exec the wanted program. If something (strange) happens, | |
118 | * the accept() call could block us forever. | |
5fafdf24 | 119 | * |
f0cbd3ec FB |
120 | * do_pty = 0 Fork/exec inetd style |
121 | * do_pty = 1 Fork/exec using slirp.telnetd | |
122 | * do_ptr = 2 Fork/exec using pty | |
123 | */ | |
124 | int | |
9634d903 | 125 | fork_exec(struct socket *so, const char *ex, int do_pty) |
f0cbd3ec FB |
126 | { |
127 | int s; | |
128 | struct sockaddr_in addr; | |
242acf3a | 129 | socklen_t addrlen = sizeof(addr); |
f0cbd3ec | 130 | int opt; |
9634d903 | 131 | int master = -1; |
7ccfb2eb | 132 | const char *argv[256]; |
f0cbd3ec FB |
133 | /* don't want to clobber the original */ |
134 | char *bptr; | |
9634d903 | 135 | const char *curarg; |
7b91a172 | 136 | int c, i, ret; |
5fafdf24 | 137 | |
f0cbd3ec FB |
138 | DEBUG_CALL("fork_exec"); |
139 | DEBUG_ARG("so = %lx", (long)so); | |
140 | DEBUG_ARG("ex = %lx", (long)ex); | |
141 | DEBUG_ARG("do_pty = %lx", (long)do_pty); | |
5fafdf24 | 142 | |
f0cbd3ec | 143 | if (do_pty == 2) { |
3f9b2b1f | 144 | return 0; |
f0cbd3ec FB |
145 | } else { |
146 | addr.sin_family = AF_INET; | |
147 | addr.sin_port = 0; | |
148 | addr.sin_addr.s_addr = INADDR_ANY; | |
3b46e624 | 149 | |
f0cbd3ec FB |
150 | if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0 || |
151 | bind(s, (struct sockaddr *)&addr, addrlen) < 0 || | |
152 | listen(s, 1) < 0) { | |
153 | lprint("Error: inet socket: %s\n", strerror(errno)); | |
379ff53d | 154 | closesocket(s); |
3b46e624 | 155 | |
f0cbd3ec FB |
156 | return 0; |
157 | } | |
158 | } | |
5fafdf24 | 159 | |
f0cbd3ec FB |
160 | switch(fork()) { |
161 | case -1: | |
162 | lprint("Error: fork failed: %s\n", strerror(errno)); | |
163 | close(s); | |
164 | if (do_pty == 2) | |
165 | close(master); | |
166 | return 0; | |
3b46e624 | 167 | |
f0cbd3ec FB |
168 | case 0: |
169 | /* Set the DISPLAY */ | |
170 | if (do_pty == 2) { | |
171 | (void) close(master); | |
172 | #ifdef TIOCSCTTY /* XXXXX */ | |
173 | (void) setsid(); | |
174 | ioctl(s, TIOCSCTTY, (char *)NULL); | |
175 | #endif | |
176 | } else { | |
177 | getsockname(s, (struct sockaddr *)&addr, &addrlen); | |
178 | close(s); | |
179 | /* | |
180 | * Connect to the socket | |
181 | * XXX If any of these fail, we're in trouble! | |
182 | */ | |
183 | s = socket(AF_INET, SOCK_STREAM, 0); | |
184 | addr.sin_addr = loopback_addr; | |
7b91a172 FB |
185 | do { |
186 | ret = connect(s, (struct sockaddr *)&addr, addrlen); | |
187 | } while (ret < 0 && errno == EINTR); | |
f0cbd3ec | 188 | } |
3b46e624 | 189 | |
f0cbd3ec FB |
190 | dup2(s, 0); |
191 | dup2(s, 1); | |
192 | dup2(s, 2); | |
9634d903 | 193 | for (s = getdtablesize() - 1; s >= 3; s--) |
f0cbd3ec | 194 | close(s); |
3b46e624 | 195 | |
f0cbd3ec FB |
196 | i = 0; |
197 | bptr = strdup(ex); /* No need to free() this */ | |
198 | if (do_pty == 1) { | |
199 | /* Setup "slirp.telnetd -x" */ | |
200 | argv[i++] = "slirp.telnetd"; | |
201 | argv[i++] = "-x"; | |
202 | argv[i++] = bptr; | |
203 | } else | |
204 | do { | |
205 | /* Change the string into argv[] */ | |
206 | curarg = bptr; | |
207 | while (*bptr != ' ' && *bptr != (char)0) | |
208 | bptr++; | |
209 | c = *bptr; | |
210 | *bptr++ = (char)0; | |
211 | argv[i++] = strdup(curarg); | |
212 | } while (c); | |
3b46e624 | 213 | |
511d2b14 | 214 | argv[i] = NULL; |
7ccfb2eb | 215 | execvp(argv[0], (char **)argv); |
3b46e624 | 216 | |
f0cbd3ec FB |
217 | /* Ooops, failed, let's tell the user why */ |
218 | { | |
219 | char buff[256]; | |
3b46e624 | 220 | |
363a37d5 BS |
221 | snprintf(buff, sizeof(buff), |
222 | "Error: execvp of %s failed: %s\n", | |
223 | argv[0], strerror(errno)); | |
f0cbd3ec FB |
224 | write(2, buff, strlen(buff)+1); |
225 | } | |
226 | close(0); close(1); close(2); /* XXX */ | |
227 | exit(1); | |
3b46e624 | 228 | |
f0cbd3ec FB |
229 | default: |
230 | if (do_pty == 2) { | |
231 | close(s); | |
232 | so->s = master; | |
233 | } else { | |
234 | /* | |
235 | * XXX this could block us... | |
236 | * XXX Should set a timer here, and if accept() doesn't | |
237 | * return after X seconds, declare it a failure | |
238 | * The only reason this will block forever is if socket() | |
239 | * of connect() fail in the child process | |
240 | */ | |
7b91a172 FB |
241 | do { |
242 | so->s = accept(s, (struct sockaddr *)&addr, &addrlen); | |
243 | } while (so->s < 0 && errno == EINTR); | |
244 | closesocket(s); | |
f0cbd3ec FB |
245 | opt = 1; |
246 | setsockopt(so->s,SOL_SOCKET,SO_REUSEADDR,(char *)&opt,sizeof(int)); | |
247 | opt = 1; | |
248 | setsockopt(so->s,SOL_SOCKET,SO_OOBINLINE,(char *)&opt,sizeof(int)); | |
249 | } | |
250 | fd_nonblock(so->s); | |
3b46e624 | 251 | |
f0cbd3ec | 252 | /* Append the telnet options now */ |
511d2b14 | 253 | if (so->so_m != NULL && do_pty == 1) { |
f0cbd3ec | 254 | sbappend(so, so->so_m); |
511d2b14 | 255 | so->so_m = NULL; |
f0cbd3ec | 256 | } |
3b46e624 | 257 | |
f0cbd3ec FB |
258 | return 1; |
259 | } | |
260 | } | |
261 | #endif | |
262 | ||
263 | #ifndef HAVE_STRDUP | |
264 | char * | |
265 | strdup(str) | |
266 | const char *str; | |
267 | { | |
268 | char *bptr; | |
5fafdf24 | 269 | |
f0cbd3ec FB |
270 | bptr = (char *)malloc(strlen(str)+1); |
271 | strcpy(bptr, str); | |
5fafdf24 | 272 | |
f0cbd3ec FB |
273 | return bptr; |
274 | } | |
275 | #endif | |
276 | ||
376253ec | 277 | #include "monitor.h" |
c9f10306 | 278 | |
31a60e22 BS |
279 | void lprint(const char *format, ...) |
280 | { | |
281 | va_list args; | |
282 | ||
283 | va_start(args, format); | |
376253ec | 284 | monitor_vprintf(cur_mon, format, args); |
31a60e22 BS |
285 | va_end(args); |
286 | } | |
f0cbd3ec FB |
287 | |
288 | #ifdef BAD_SPRINTF | |
289 | ||
290 | #undef vsprintf | |
291 | #undef sprintf | |
292 | ||
293 | /* | |
294 | * Some BSD-derived systems have a sprintf which returns char * | |
295 | */ | |
296 | ||
297 | int | |
298 | vsprintf_len(string, format, args) | |
299 | char *string; | |
300 | const char *format; | |
301 | va_list args; | |
302 | { | |
303 | vsprintf(string, format, args); | |
304 | return strlen(string); | |
305 | } | |
306 | ||
307 | int | |
308 | #ifdef __STDC__ | |
309 | sprintf_len(char *string, const char *format, ...) | |
310 | #else | |
311 | sprintf_len(va_alist) va_dcl | |
312 | #endif | |
313 | { | |
314 | va_list args; | |
315 | #ifdef __STDC__ | |
316 | va_start(args, format); | |
317 | #else | |
318 | char *string; | |
319 | char *format; | |
320 | va_start(args); | |
321 | string = va_arg(args, char *); | |
322 | format = va_arg(args, char *); | |
323 | #endif | |
324 | vsprintf(string, format, args); | |
325 | return strlen(string); | |
326 | } | |
327 | ||
328 | #endif | |
329 | ||
330 | void | |
511d2b14 | 331 | u_sleep(int usec) |
f0cbd3ec FB |
332 | { |
333 | struct timeval t; | |
334 | fd_set fdset; | |
5fafdf24 | 335 | |
f0cbd3ec | 336 | FD_ZERO(&fdset); |
5fafdf24 | 337 | |
f0cbd3ec FB |
338 | t.tv_sec = 0; |
339 | t.tv_usec = usec * 1000; | |
5fafdf24 | 340 | |
f0cbd3ec FB |
341 | select(0, &fdset, &fdset, &fdset, &t); |
342 | } | |
343 | ||
344 | /* | |
345 | * Set fd blocking and non-blocking | |
346 | */ | |
347 | ||
348 | void | |
511d2b14 | 349 | fd_nonblock(int fd) |
f0cbd3ec FB |
350 | { |
351 | #ifdef FIONBIO | |
b9e82a59 | 352 | #ifdef _WIN32 |
c5b76b38 | 353 | unsigned long opt = 1; |
b9e82a59 BS |
354 | #else |
355 | int opt = 1; | |
356 | #endif | |
5fafdf24 | 357 | |
379ff53d | 358 | ioctlsocket(fd, FIONBIO, &opt); |
f0cbd3ec FB |
359 | #else |
360 | int opt; | |
5fafdf24 | 361 | |
f0cbd3ec FB |
362 | opt = fcntl(fd, F_GETFL, 0); |
363 | opt |= O_NONBLOCK; | |
364 | fcntl(fd, F_SETFL, opt); | |
365 | #endif | |
366 | } | |
367 | ||
368 | void | |
511d2b14 | 369 | fd_block(int fd) |
f0cbd3ec FB |
370 | { |
371 | #ifdef FIONBIO | |
c5b76b38 BS |
372 | #ifdef _WIN32 |
373 | unsigned long opt = 0; | |
374 | #else | |
f0cbd3ec | 375 | int opt = 0; |
c5b76b38 | 376 | #endif |
5fafdf24 | 377 | |
379ff53d | 378 | ioctlsocket(fd, FIONBIO, &opt); |
f0cbd3ec FB |
379 | #else |
380 | int opt; | |
5fafdf24 | 381 | |
f0cbd3ec FB |
382 | opt = fcntl(fd, F_GETFL, 0); |
383 | opt &= ~O_NONBLOCK; | |
384 | fcntl(fd, F_SETFL, opt); | |
385 | #endif | |
386 | } | |
387 | ||
6dbe553f JK |
388 | void slirp_connection_info(Monitor *mon) |
389 | { | |
390 | const char * const tcpstates[] = { | |
391 | [TCPS_CLOSED] = "CLOSED", | |
392 | [TCPS_LISTEN] = "LISTEN", | |
393 | [TCPS_SYN_SENT] = "SYN_SENT", | |
394 | [TCPS_SYN_RECEIVED] = "SYN_RCVD", | |
395 | [TCPS_ESTABLISHED] = "ESTABLISHED", | |
396 | [TCPS_CLOSE_WAIT] = "CLOSE_WAIT", | |
397 | [TCPS_FIN_WAIT_1] = "FIN_WAIT_1", | |
398 | [TCPS_CLOSING] = "CLOSING", | |
399 | [TCPS_LAST_ACK] = "LAST_ACK", | |
400 | [TCPS_FIN_WAIT_2] = "FIN_WAIT_2", | |
401 | [TCPS_TIME_WAIT] = "TIME_WAIT", | |
402 | }; | |
403 | struct in_addr dst_addr; | |
404 | struct sockaddr_in src; | |
405 | socklen_t src_len; | |
406 | uint16_t dst_port; | |
407 | struct socket *so; | |
408 | const char *state; | |
409 | char buf[20]; | |
410 | int n; | |
411 | ||
412 | monitor_printf(mon, " Protocol[State] FD Source Address Port " | |
413 | "Dest. Address Port RecvQ SendQ\n"); | |
414 | ||
415 | for (so = tcb.so_next; so != &tcb; so = so->so_next) { | |
416 | if (so->so_state & SS_HOSTFWD) { | |
417 | state = "HOST_FORWARD"; | |
418 | } else if (so->so_tcpcb) { | |
419 | state = tcpstates[so->so_tcpcb->t_state]; | |
420 | } else { | |
421 | state = "NONE"; | |
422 | } | |
423 | if (so->so_state & (SS_HOSTFWD | SS_INCOMING)) { | |
424 | src_len = sizeof(src); | |
425 | getsockname(so->s, (struct sockaddr *)&src, &src_len); | |
426 | dst_addr = so->so_laddr; | |
427 | dst_port = so->so_lport; | |
428 | } else { | |
429 | src.sin_addr = so->so_laddr; | |
430 | src.sin_port = so->so_lport; | |
431 | dst_addr = so->so_faddr; | |
432 | dst_port = so->so_fport; | |
433 | } | |
434 | n = snprintf(buf, sizeof(buf), " TCP[%s]", state); | |
435 | memset(&buf[n], ' ', 19 - n); | |
436 | buf[19] = 0; | |
437 | monitor_printf(mon, "%s %3d %15s %5d ", buf, so->s, | |
438 | src.sin_addr.s_addr ? inet_ntoa(src.sin_addr) : "*", | |
439 | ntohs(src.sin_port)); | |
440 | monitor_printf(mon, "%15s %5d %5d %5d\n", | |
441 | inet_ntoa(dst_addr), ntohs(dst_port), | |
442 | so->so_rcv.sb_cc, so->so_snd.sb_cc); | |
443 | } | |
444 | ||
445 | for (so = udb.so_next; so != &udb; so = so->so_next) { | |
446 | if (so->so_state & SS_HOSTFWD) { | |
447 | n = snprintf(buf, sizeof(buf), " UDP[HOST_FORWARD]"); | |
448 | src_len = sizeof(src); | |
449 | getsockname(so->s, (struct sockaddr *)&src, &src_len); | |
450 | dst_addr = so->so_laddr; | |
451 | dst_port = so->so_lport; | |
452 | } else { | |
453 | n = snprintf(buf, sizeof(buf), " UDP[%d sec]", | |
454 | (so->so_expire - curtime) / 1000); | |
455 | src.sin_addr = so->so_laddr; | |
456 | src.sin_port = so->so_lport; | |
457 | dst_addr = so->so_faddr; | |
458 | dst_port = so->so_fport; | |
459 | } | |
460 | memset(&buf[n], ' ', 19 - n); | |
461 | buf[19] = 0; | |
462 | monitor_printf(mon, "%s %3d %15s %5d ", buf, so->s, | |
463 | src.sin_addr.s_addr ? inet_ntoa(src.sin_addr) : "*", | |
464 | ntohs(src.sin_port)); | |
465 | monitor_printf(mon, "%15s %5d %5d %5d\n", | |
466 | inet_ntoa(dst_addr), ntohs(dst_port), | |
467 | so->so_rcv.sb_cc, so->so_snd.sb_cc); | |
468 | } | |
469 | } |