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