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