]>
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 | ||
7df7482b | 8 | #include "qemu/osdep.h" |
f0cbd3ec | 9 | #include <slirp.h> |
6dbe553f JK |
10 | #include <libslirp.h> |
11 | ||
83c9089e | 12 | #include "monitor/monitor.h" |
d49b6836 | 13 | #include "qemu/error-report.h" |
6a1751b7 | 14 | #include "qemu/main-loop.h" |
f0cbd3ec | 15 | |
9f349498 JK |
16 | #ifdef DEBUG |
17 | int slirp_debug = DBG_CALL|DBG_MISC|DBG_ERROR; | |
18 | #endif | |
19 | ||
f0cbd3ec FB |
20 | struct quehead { |
21 | struct quehead *qh_link; | |
22 | struct quehead *qh_rlink; | |
23 | }; | |
24 | ||
25 | inline void | |
511d2b14 | 26 | insque(void *a, void *b) |
f0cbd3ec FB |
27 | { |
28 | register struct quehead *element = (struct quehead *) a; | |
29 | register struct quehead *head = (struct quehead *) b; | |
30 | element->qh_link = head->qh_link; | |
31 | head->qh_link = (struct quehead *)element; | |
32 | element->qh_rlink = (struct quehead *)head; | |
33 | ((struct quehead *)(element->qh_link))->qh_rlink | |
34 | = (struct quehead *)element; | |
35 | } | |
36 | ||
37 | inline void | |
511d2b14 | 38 | remque(void *a) |
f0cbd3ec FB |
39 | { |
40 | register struct quehead *element = (struct quehead *) a; | |
41 | ((struct quehead *)(element->qh_link))->qh_rlink = element->qh_rlink; | |
42 | ((struct quehead *)(element->qh_rlink))->qh_link = element->qh_link; | |
43 | element->qh_rlink = NULL; | |
f0cbd3ec FB |
44 | } |
45 | ||
a13a4126 JK |
46 | int add_exec(struct ex_list **ex_ptr, int do_pty, char *exec, |
47 | struct in_addr addr, int port) | |
f0cbd3ec FB |
48 | { |
49 | struct ex_list *tmp_ptr; | |
5fafdf24 | 50 | |
f0cbd3ec FB |
51 | /* First, check if the port is "bound" */ |
52 | for (tmp_ptr = *ex_ptr; tmp_ptr; tmp_ptr = tmp_ptr->ex_next) { | |
a13a4126 JK |
53 | if (port == tmp_ptr->ex_fport && |
54 | addr.s_addr == tmp_ptr->ex_addr.s_addr) | |
55 | return -1; | |
f0cbd3ec | 56 | } |
5fafdf24 | 57 | |
f0cbd3ec | 58 | tmp_ptr = *ex_ptr; |
2fd5d864 | 59 | *ex_ptr = g_new(struct ex_list, 1); |
f0cbd3ec FB |
60 | (*ex_ptr)->ex_fport = port; |
61 | (*ex_ptr)->ex_addr = addr; | |
62 | (*ex_ptr)->ex_pty = do_pty; | |
2fd5d864 | 63 | (*ex_ptr)->ex_exec = (do_pty == 3) ? exec : g_strdup(exec); |
f0cbd3ec FB |
64 | (*ex_ptr)->ex_next = tmp_ptr; |
65 | return 0; | |
66 | } | |
67 | ||
68 | #ifndef HAVE_STRERROR | |
69 | ||
70 | /* | |
71 | * For systems with no strerror | |
72 | */ | |
73 | ||
74 | extern int sys_nerr; | |
75 | extern char *sys_errlist[]; | |
76 | ||
77 | char * | |
78 | strerror(error) | |
79 | int error; | |
80 | { | |
81 | if (error < sys_nerr) | |
82 | return sys_errlist[error]; | |
83 | else | |
84 | return "Unknown error."; | |
85 | } | |
86 | ||
87 | #endif | |
88 | ||
89 | ||
a3d4af03 FB |
90 | #ifdef _WIN32 |
91 | ||
92 | int | |
9634d903 | 93 | fork_exec(struct socket *so, const char *ex, int do_pty) |
a3d4af03 FB |
94 | { |
95 | /* not implemented */ | |
96 | return 0; | |
97 | } | |
98 | ||
99 | #else | |
100 | ||
f0cbd3ec FB |
101 | /* |
102 | * XXX This is ugly | |
103 | * We create and bind a socket, then fork off to another | |
104 | * process, which connects to this socket, after which we | |
105 | * exec the wanted program. If something (strange) happens, | |
106 | * the accept() call could block us forever. | |
5fafdf24 | 107 | * |
f0cbd3ec FB |
108 | * do_pty = 0 Fork/exec inetd style |
109 | * do_pty = 1 Fork/exec using slirp.telnetd | |
110 | * do_ptr = 2 Fork/exec using pty | |
111 | */ | |
112 | int | |
9634d903 | 113 | fork_exec(struct socket *so, const char *ex, int do_pty) |
f0cbd3ec FB |
114 | { |
115 | int s; | |
116 | struct sockaddr_in addr; | |
242acf3a | 117 | socklen_t addrlen = sizeof(addr); |
f0cbd3ec | 118 | int opt; |
7ccfb2eb | 119 | const char *argv[256]; |
f0cbd3ec FB |
120 | /* don't want to clobber the original */ |
121 | char *bptr; | |
9634d903 | 122 | const char *curarg; |
7b91a172 | 123 | int c, i, ret; |
4d54ec78 | 124 | pid_t pid; |
5fafdf24 | 125 | |
f0cbd3ec | 126 | DEBUG_CALL("fork_exec"); |
ecc804ca SW |
127 | DEBUG_ARG("so = %p", so); |
128 | DEBUG_ARG("ex = %p", ex); | |
129 | DEBUG_ARG("do_pty = %x", do_pty); | |
5fafdf24 | 130 | |
f0cbd3ec | 131 | if (do_pty == 2) { |
3f9b2b1f | 132 | return 0; |
f0cbd3ec FB |
133 | } else { |
134 | addr.sin_family = AF_INET; | |
135 | addr.sin_port = 0; | |
136 | addr.sin_addr.s_addr = INADDR_ANY; | |
3b46e624 | 137 | |
40ff6d7e | 138 | if ((s = qemu_socket(AF_INET, SOCK_STREAM, 0)) < 0 || |
f0cbd3ec FB |
139 | bind(s, (struct sockaddr *)&addr, addrlen) < 0 || |
140 | listen(s, 1) < 0) { | |
02d16089 | 141 | error_report("Error: inet socket: %s", strerror(errno)); |
379ff53d | 142 | closesocket(s); |
3b46e624 | 143 | |
f0cbd3ec FB |
144 | return 0; |
145 | } | |
146 | } | |
5fafdf24 | 147 | |
4d54ec78 PB |
148 | pid = fork(); |
149 | switch(pid) { | |
f0cbd3ec | 150 | case -1: |
02d16089 | 151 | error_report("Error: fork failed: %s", strerror(errno)); |
f0cbd3ec | 152 | close(s); |
f0cbd3ec | 153 | return 0; |
3b46e624 | 154 | |
f0cbd3ec | 155 | case 0: |
565465fc JK |
156 | setsid(); |
157 | ||
f0cbd3ec | 158 | /* Set the DISPLAY */ |
9f1134d4 SW |
159 | getsockname(s, (struct sockaddr *)&addr, &addrlen); |
160 | close(s); | |
161 | /* | |
162 | * Connect to the socket | |
163 | * XXX If any of these fail, we're in trouble! | |
164 | */ | |
165 | s = qemu_socket(AF_INET, SOCK_STREAM, 0); | |
166 | addr.sin_addr = loopback_addr; | |
167 | do { | |
168 | ret = connect(s, (struct sockaddr *)&addr, addrlen); | |
169 | } while (ret < 0 && errno == EINTR); | |
3b46e624 | 170 | |
f0cbd3ec FB |
171 | dup2(s, 0); |
172 | dup2(s, 1); | |
173 | dup2(s, 2); | |
9634d903 | 174 | for (s = getdtablesize() - 1; s >= 3; s--) |
f0cbd3ec | 175 | close(s); |
3b46e624 | 176 | |
f0cbd3ec | 177 | i = 0; |
7267c094 | 178 | bptr = g_strdup(ex); /* No need to free() this */ |
f0cbd3ec FB |
179 | if (do_pty == 1) { |
180 | /* Setup "slirp.telnetd -x" */ | |
181 | argv[i++] = "slirp.telnetd"; | |
182 | argv[i++] = "-x"; | |
183 | argv[i++] = bptr; | |
184 | } else | |
185 | do { | |
186 | /* Change the string into argv[] */ | |
187 | curarg = bptr; | |
188 | while (*bptr != ' ' && *bptr != (char)0) | |
189 | bptr++; | |
190 | c = *bptr; | |
191 | *bptr++ = (char)0; | |
2fd5d864 | 192 | argv[i++] = g_strdup(curarg); |
f0cbd3ec | 193 | } while (c); |
3b46e624 | 194 | |
511d2b14 | 195 | argv[i] = NULL; |
7ccfb2eb | 196 | execvp(argv[0], (char **)argv); |
3b46e624 | 197 | |
f0cbd3ec | 198 | /* Ooops, failed, let's tell the user why */ |
f0d98b05 KS |
199 | fprintf(stderr, "Error: execvp of %s failed: %s\n", |
200 | argv[0], strerror(errno)); | |
f0cbd3ec FB |
201 | close(0); close(1); close(2); /* XXX */ |
202 | exit(1); | |
3b46e624 | 203 | |
f0cbd3ec | 204 | default: |
4d54ec78 | 205 | qemu_add_child_watch(pid); |
9f1134d4 SW |
206 | /* |
207 | * XXX this could block us... | |
208 | * XXX Should set a timer here, and if accept() doesn't | |
209 | * return after X seconds, declare it a failure | |
210 | * The only reason this will block forever is if socket() | |
211 | * of connect() fail in the child process | |
212 | */ | |
213 | do { | |
214 | so->s = accept(s, (struct sockaddr *)&addr, &addrlen); | |
215 | } while (so->s < 0 && errno == EINTR); | |
216 | closesocket(s); | |
aad1239a | 217 | socket_set_fast_reuse(so->s); |
9f1134d4 | 218 | opt = 1; |
9957fc7f | 219 | qemu_setsockopt(so->s, SOL_SOCKET, SO_OOBINLINE, &opt, sizeof(int)); |
f9e8cacc | 220 | qemu_set_nonblock(so->s); |
3b46e624 | 221 | |
f0cbd3ec | 222 | /* Append the telnet options now */ |
511d2b14 | 223 | if (so->so_m != NULL && do_pty == 1) { |
f0cbd3ec | 224 | sbappend(so, so->so_m); |
511d2b14 | 225 | so->so_m = NULL; |
f0cbd3ec | 226 | } |
3b46e624 | 227 | |
f0cbd3ec FB |
228 | return 1; |
229 | } | |
230 | } | |
231 | #endif | |
232 | ||
9f8bd042 | 233 | void slirp_connection_info(Slirp *slirp, Monitor *mon) |
6dbe553f JK |
234 | { |
235 | const char * const tcpstates[] = { | |
236 | [TCPS_CLOSED] = "CLOSED", | |
237 | [TCPS_LISTEN] = "LISTEN", | |
238 | [TCPS_SYN_SENT] = "SYN_SENT", | |
239 | [TCPS_SYN_RECEIVED] = "SYN_RCVD", | |
240 | [TCPS_ESTABLISHED] = "ESTABLISHED", | |
241 | [TCPS_CLOSE_WAIT] = "CLOSE_WAIT", | |
242 | [TCPS_FIN_WAIT_1] = "FIN_WAIT_1", | |
243 | [TCPS_CLOSING] = "CLOSING", | |
244 | [TCPS_LAST_ACK] = "LAST_ACK", | |
245 | [TCPS_FIN_WAIT_2] = "FIN_WAIT_2", | |
246 | [TCPS_TIME_WAIT] = "TIME_WAIT", | |
247 | }; | |
248 | struct in_addr dst_addr; | |
249 | struct sockaddr_in src; | |
250 | socklen_t src_len; | |
251 | uint16_t dst_port; | |
252 | struct socket *so; | |
253 | const char *state; | |
254 | char buf[20]; | |
6dbe553f JK |
255 | |
256 | monitor_printf(mon, " Protocol[State] FD Source Address Port " | |
257 | "Dest. Address Port RecvQ SendQ\n"); | |
258 | ||
460fec67 | 259 | for (so = slirp->tcb.so_next; so != &slirp->tcb; so = so->so_next) { |
6dbe553f JK |
260 | if (so->so_state & SS_HOSTFWD) { |
261 | state = "HOST_FORWARD"; | |
262 | } else if (so->so_tcpcb) { | |
263 | state = tcpstates[so->so_tcpcb->t_state]; | |
264 | } else { | |
265 | state = "NONE"; | |
266 | } | |
267 | if (so->so_state & (SS_HOSTFWD | SS_INCOMING)) { | |
268 | src_len = sizeof(src); | |
269 | getsockname(so->s, (struct sockaddr *)&src, &src_len); | |
270 | dst_addr = so->so_laddr; | |
271 | dst_port = so->so_lport; | |
272 | } else { | |
273 | src.sin_addr = so->so_laddr; | |
274 | src.sin_port = so->so_lport; | |
275 | dst_addr = so->so_faddr; | |
276 | dst_port = so->so_fport; | |
277 | } | |
f293d8b1 AL |
278 | snprintf(buf, sizeof(buf), " TCP[%s]", state); |
279 | monitor_printf(mon, "%-19s %3d %15s %5d ", buf, so->s, | |
6dbe553f JK |
280 | src.sin_addr.s_addr ? inet_ntoa(src.sin_addr) : "*", |
281 | ntohs(src.sin_port)); | |
282 | monitor_printf(mon, "%15s %5d %5d %5d\n", | |
283 | inet_ntoa(dst_addr), ntohs(dst_port), | |
284 | so->so_rcv.sb_cc, so->so_snd.sb_cc); | |
285 | } | |
286 | ||
460fec67 | 287 | for (so = slirp->udb.so_next; so != &slirp->udb; so = so->so_next) { |
6dbe553f | 288 | if (so->so_state & SS_HOSTFWD) { |
f293d8b1 | 289 | snprintf(buf, sizeof(buf), " UDP[HOST_FORWARD]"); |
6dbe553f JK |
290 | src_len = sizeof(src); |
291 | getsockname(so->s, (struct sockaddr *)&src, &src_len); | |
292 | dst_addr = so->so_laddr; | |
293 | dst_port = so->so_lport; | |
294 | } else { | |
f293d8b1 | 295 | snprintf(buf, sizeof(buf), " UDP[%d sec]", |
6dbe553f JK |
296 | (so->so_expire - curtime) / 1000); |
297 | src.sin_addr = so->so_laddr; | |
298 | src.sin_port = so->so_lport; | |
299 | dst_addr = so->so_faddr; | |
300 | dst_port = so->so_fport; | |
301 | } | |
f293d8b1 | 302 | monitor_printf(mon, "%-19s %3d %15s %5d ", buf, so->s, |
6dbe553f JK |
303 | src.sin_addr.s_addr ? inet_ntoa(src.sin_addr) : "*", |
304 | ntohs(src.sin_port)); | |
305 | monitor_printf(mon, "%15s %5d %5d %5d\n", | |
306 | inet_ntoa(dst_addr), ntohs(dst_port), | |
307 | so->so_rcv.sb_cc, so->so_snd.sb_cc); | |
308 | } | |
e6d43cfb JK |
309 | |
310 | for (so = slirp->icmp.so_next; so != &slirp->icmp; so = so->so_next) { | |
f293d8b1 | 311 | snprintf(buf, sizeof(buf), " ICMP[%d sec]", |
e6d43cfb JK |
312 | (so->so_expire - curtime) / 1000); |
313 | src.sin_addr = so->so_laddr; | |
314 | dst_addr = so->so_faddr; | |
f293d8b1 | 315 | monitor_printf(mon, "%-19s %3d %15s - ", buf, so->s, |
e6d43cfb JK |
316 | src.sin_addr.s_addr ? inet_ntoa(src.sin_addr) : "*"); |
317 | monitor_printf(mon, "%15s - %5d %5d\n", inet_ntoa(dst_addr), | |
318 | so->so_rcv.sb_cc, so->so_snd.sb_cc); | |
319 | } | |
6dbe553f | 320 | } |