bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 1995 Danny Gasparovski. |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 3 | * |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 4 | * Please read the file COPYRIGHT for the |
| 5 | * terms and conditions of the copyright. |
| 6 | */ |
| 7 | |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 8 | #include <slirp.h> |
Jan Kiszka | 6dbe553 | 2009-06-24 14:42:29 +0200 | [diff] [blame] | 9 | #include <libslirp.h> |
| 10 | |
| 11 | #include "monitor.h" |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 12 | |
Jan Kiszka | 9f34949 | 2009-06-24 14:42:29 +0200 | [diff] [blame] | 13 | #ifdef DEBUG |
| 14 | int slirp_debug = DBG_CALL|DBG_MISC|DBG_ERROR; |
| 15 | #endif |
| 16 | |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 17 | struct quehead { |
| 18 | struct quehead *qh_link; |
| 19 | struct quehead *qh_rlink; |
| 20 | }; |
| 21 | |
| 22 | inline void |
blueswir1 | 511d2b1 | 2009-03-07 15:32:56 +0000 | [diff] [blame] | 23 | insque(void *a, void *b) |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 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 |
blueswir1 | 511d2b1 | 2009-03-07 15:32:56 +0000 | [diff] [blame] | 35 | remque(void *a) |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 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; |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 41 | } |
| 42 | |
Jan Kiszka | a13a412 | 2009-06-24 14:42:28 +0200 | [diff] [blame] | 43 | int add_exec(struct ex_list **ex_ptr, int do_pty, char *exec, |
| 44 | struct in_addr addr, int port) |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 45 | { |
| 46 | struct ex_list *tmp_ptr; |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 47 | |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 48 | /* First, check if the port is "bound" */ |
| 49 | for (tmp_ptr = *ex_ptr; tmp_ptr; tmp_ptr = tmp_ptr->ex_next) { |
Jan Kiszka | a13a412 | 2009-06-24 14:42:28 +0200 | [diff] [blame] | 50 | if (port == tmp_ptr->ex_fport && |
| 51 | addr.s_addr == tmp_ptr->ex_addr.s_addr) |
| 52 | return -1; |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 53 | } |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 54 | |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 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; |
aliguori | e1c5a2b | 2009-01-08 19:18:21 +0000 | [diff] [blame] | 60 | (*ex_ptr)->ex_exec = (do_pty == 3) ? exec : strdup(exec); |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 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 | |
bellard | a3d4af0 | 2004-09-05 23:10:26 +0000 | [diff] [blame] | 87 | #ifdef _WIN32 |
| 88 | |
| 89 | int |
blueswir1 | 9634d90 | 2007-10-26 19:01:16 +0000 | [diff] [blame] | 90 | fork_exec(struct socket *so, const char *ex, int do_pty) |
bellard | a3d4af0 | 2004-09-05 23:10:26 +0000 | [diff] [blame] | 91 | { |
| 92 | /* not implemented */ |
| 93 | return 0; |
| 94 | } |
| 95 | |
| 96 | #else |
| 97 | |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 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. |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 104 | * |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 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 |
blueswir1 | 9634d90 | 2007-10-26 19:01:16 +0000 | [diff] [blame] | 110 | fork_exec(struct socket *so, const char *ex, int do_pty) |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 111 | { |
| 112 | int s; |
| 113 | struct sockaddr_in addr; |
balrog | 242acf3 | 2008-05-10 01:49:53 +0000 | [diff] [blame] | 114 | socklen_t addrlen = sizeof(addr); |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 115 | int opt; |
blueswir1 | 7ccfb2e | 2008-09-14 06:45:34 +0000 | [diff] [blame] | 116 | const char *argv[256]; |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 117 | /* don't want to clobber the original */ |
| 118 | char *bptr; |
blueswir1 | 9634d90 | 2007-10-26 19:01:16 +0000 | [diff] [blame] | 119 | const char *curarg; |
bellard | 7b91a17 | 2004-12-12 11:45:10 +0000 | [diff] [blame] | 120 | int c, i, ret; |
Paolo Bonzini | 4d54ec7 | 2011-03-09 18:21:10 +0100 | [diff] [blame] | 121 | pid_t pid; |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 122 | |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 123 | DEBUG_CALL("fork_exec"); |
| 124 | DEBUG_ARG("so = %lx", (long)so); |
| 125 | DEBUG_ARG("ex = %lx", (long)ex); |
| 126 | DEBUG_ARG("do_pty = %lx", (long)do_pty); |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 127 | |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 128 | if (do_pty == 2) { |
balrog | 3f9b2b1 | 2007-11-13 01:56:12 +0000 | [diff] [blame] | 129 | return 0; |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 130 | } else { |
| 131 | addr.sin_family = AF_INET; |
| 132 | addr.sin_port = 0; |
| 133 | addr.sin_addr.s_addr = INADDR_ANY; |
ths | 3b46e62 | 2007-09-17 08:09:54 +0000 | [diff] [blame] | 134 | |
Kevin Wolf | 40ff6d7 | 2009-12-02 12:24:42 +0100 | [diff] [blame] | 135 | if ((s = qemu_socket(AF_INET, SOCK_STREAM, 0)) < 0 || |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 136 | bind(s, (struct sockaddr *)&addr, addrlen) < 0 || |
| 137 | listen(s, 1) < 0) { |
| 138 | lprint("Error: inet socket: %s\n", strerror(errno)); |
bellard | 379ff53 | 2004-07-12 22:33:07 +0000 | [diff] [blame] | 139 | closesocket(s); |
ths | 3b46e62 | 2007-09-17 08:09:54 +0000 | [diff] [blame] | 140 | |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 141 | return 0; |
| 142 | } |
| 143 | } |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 144 | |
Paolo Bonzini | 4d54ec7 | 2011-03-09 18:21:10 +0100 | [diff] [blame] | 145 | pid = fork(); |
| 146 | switch(pid) { |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 147 | case -1: |
| 148 | lprint("Error: fork failed: %s\n", strerror(errno)); |
| 149 | close(s); |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 150 | return 0; |
ths | 3b46e62 | 2007-09-17 08:09:54 +0000 | [diff] [blame] | 151 | |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 152 | case 0: |
Jan Kiszka | 565465f | 2011-07-20 12:20:17 +0200 | [diff] [blame] | 153 | setsid(); |
| 154 | |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 155 | /* Set the DISPLAY */ |
Stefan Weil | 9f1134d | 2012-01-05 14:18:45 +0100 | [diff] [blame] | 156 | getsockname(s, (struct sockaddr *)&addr, &addrlen); |
| 157 | close(s); |
| 158 | /* |
| 159 | * Connect to the socket |
| 160 | * XXX If any of these fail, we're in trouble! |
| 161 | */ |
| 162 | s = qemu_socket(AF_INET, SOCK_STREAM, 0); |
| 163 | addr.sin_addr = loopback_addr; |
| 164 | do { |
| 165 | ret = connect(s, (struct sockaddr *)&addr, addrlen); |
| 166 | } while (ret < 0 && errno == EINTR); |
ths | 3b46e62 | 2007-09-17 08:09:54 +0000 | [diff] [blame] | 167 | |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 168 | dup2(s, 0); |
| 169 | dup2(s, 1); |
| 170 | dup2(s, 2); |
blueswir1 | 9634d90 | 2007-10-26 19:01:16 +0000 | [diff] [blame] | 171 | for (s = getdtablesize() - 1; s >= 3; s--) |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 172 | close(s); |
ths | 3b46e62 | 2007-09-17 08:09:54 +0000 | [diff] [blame] | 173 | |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 174 | i = 0; |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 175 | bptr = g_strdup(ex); /* No need to free() this */ |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 176 | if (do_pty == 1) { |
| 177 | /* Setup "slirp.telnetd -x" */ |
| 178 | argv[i++] = "slirp.telnetd"; |
| 179 | argv[i++] = "-x"; |
| 180 | argv[i++] = bptr; |
| 181 | } else |
| 182 | do { |
| 183 | /* Change the string into argv[] */ |
| 184 | curarg = bptr; |
| 185 | while (*bptr != ' ' && *bptr != (char)0) |
| 186 | bptr++; |
| 187 | c = *bptr; |
| 188 | *bptr++ = (char)0; |
| 189 | argv[i++] = strdup(curarg); |
| 190 | } while (c); |
ths | 3b46e62 | 2007-09-17 08:09:54 +0000 | [diff] [blame] | 191 | |
blueswir1 | 511d2b1 | 2009-03-07 15:32:56 +0000 | [diff] [blame] | 192 | argv[i] = NULL; |
blueswir1 | 7ccfb2e | 2008-09-14 06:45:34 +0000 | [diff] [blame] | 193 | execvp(argv[0], (char **)argv); |
ths | 3b46e62 | 2007-09-17 08:09:54 +0000 | [diff] [blame] | 194 | |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 195 | /* Ooops, failed, let's tell the user why */ |
Kirill A. Shutemov | f0d98b0 | 2009-12-25 18:19:18 +0000 | [diff] [blame] | 196 | fprintf(stderr, "Error: execvp of %s failed: %s\n", |
| 197 | argv[0], strerror(errno)); |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 198 | close(0); close(1); close(2); /* XXX */ |
| 199 | exit(1); |
ths | 3b46e62 | 2007-09-17 08:09:54 +0000 | [diff] [blame] | 200 | |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 201 | default: |
Paolo Bonzini | 4d54ec7 | 2011-03-09 18:21:10 +0100 | [diff] [blame] | 202 | qemu_add_child_watch(pid); |
Stefan Weil | 9f1134d | 2012-01-05 14:18:45 +0100 | [diff] [blame] | 203 | /* |
| 204 | * XXX this could block us... |
| 205 | * XXX Should set a timer here, and if accept() doesn't |
| 206 | * return after X seconds, declare it a failure |
| 207 | * The only reason this will block forever is if socket() |
| 208 | * of connect() fail in the child process |
| 209 | */ |
| 210 | do { |
| 211 | so->s = accept(s, (struct sockaddr *)&addr, &addrlen); |
| 212 | } while (so->s < 0 && errno == EINTR); |
| 213 | closesocket(s); |
| 214 | opt = 1; |
| 215 | setsockopt(so->s, SOL_SOCKET, SO_REUSEADDR, (char *)&opt, sizeof(int)); |
| 216 | opt = 1; |
| 217 | setsockopt(so->s, SOL_SOCKET, SO_OOBINLINE, (char *)&opt, sizeof(int)); |
Paolo Bonzini | 1c5970a | 2012-03-22 01:02:52 +0100 | [diff] [blame] | 218 | socket_set_nonblock(so->s); |
ths | 3b46e62 | 2007-09-17 08:09:54 +0000 | [diff] [blame] | 219 | |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 220 | /* Append the telnet options now */ |
blueswir1 | 511d2b1 | 2009-03-07 15:32:56 +0000 | [diff] [blame] | 221 | if (so->so_m != NULL && do_pty == 1) { |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 222 | sbappend(so, so->so_m); |
blueswir1 | 511d2b1 | 2009-03-07 15:32:56 +0000 | [diff] [blame] | 223 | so->so_m = NULL; |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 224 | } |
ths | 3b46e62 | 2007-09-17 08:09:54 +0000 | [diff] [blame] | 225 | |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 226 | return 1; |
| 227 | } |
| 228 | } |
| 229 | #endif |
| 230 | |
| 231 | #ifndef HAVE_STRDUP |
| 232 | char * |
| 233 | strdup(str) |
| 234 | const char *str; |
| 235 | { |
| 236 | char *bptr; |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 237 | |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 238 | bptr = (char *)malloc(strlen(str)+1); |
| 239 | strcpy(bptr, str); |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 240 | |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 241 | return bptr; |
| 242 | } |
| 243 | #endif |
| 244 | |
aliguori | 376253e | 2009-03-05 23:01:23 +0000 | [diff] [blame] | 245 | #include "monitor.h" |
ths | c9f1030 | 2007-10-30 23:19:52 +0000 | [diff] [blame] | 246 | |
blueswir1 | 31a60e2 | 2007-10-26 18:42:59 +0000 | [diff] [blame] | 247 | void lprint(const char *format, ...) |
| 248 | { |
| 249 | va_list args; |
| 250 | |
| 251 | va_start(args, format); |
Markus Armbruster | 8631b60 | 2010-02-18 11:41:55 +0100 | [diff] [blame] | 252 | monitor_vprintf(default_mon, format, args); |
blueswir1 | 31a60e2 | 2007-10-26 18:42:59 +0000 | [diff] [blame] | 253 | va_end(args); |
| 254 | } |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 255 | |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 256 | void |
blueswir1 | 511d2b1 | 2009-03-07 15:32:56 +0000 | [diff] [blame] | 257 | u_sleep(int usec) |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 258 | { |
| 259 | struct timeval t; |
| 260 | fd_set fdset; |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 261 | |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 262 | FD_ZERO(&fdset); |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 263 | |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 264 | t.tv_sec = 0; |
| 265 | t.tv_usec = usec * 1000; |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 266 | |
bellard | f0cbd3e | 2004-04-22 00:10:48 +0000 | [diff] [blame] | 267 | select(0, &fdset, &fdset, &fdset, &t); |
| 268 | } |
| 269 | |
Jan Kiszka | 9f8bd04 | 2009-06-24 14:42:31 +0200 | [diff] [blame] | 270 | void slirp_connection_info(Slirp *slirp, Monitor *mon) |
Jan Kiszka | 6dbe553 | 2009-06-24 14:42:29 +0200 | [diff] [blame] | 271 | { |
| 272 | const char * const tcpstates[] = { |
| 273 | [TCPS_CLOSED] = "CLOSED", |
| 274 | [TCPS_LISTEN] = "LISTEN", |
| 275 | [TCPS_SYN_SENT] = "SYN_SENT", |
| 276 | [TCPS_SYN_RECEIVED] = "SYN_RCVD", |
| 277 | [TCPS_ESTABLISHED] = "ESTABLISHED", |
| 278 | [TCPS_CLOSE_WAIT] = "CLOSE_WAIT", |
| 279 | [TCPS_FIN_WAIT_1] = "FIN_WAIT_1", |
| 280 | [TCPS_CLOSING] = "CLOSING", |
| 281 | [TCPS_LAST_ACK] = "LAST_ACK", |
| 282 | [TCPS_FIN_WAIT_2] = "FIN_WAIT_2", |
| 283 | [TCPS_TIME_WAIT] = "TIME_WAIT", |
| 284 | }; |
| 285 | struct in_addr dst_addr; |
| 286 | struct sockaddr_in src; |
| 287 | socklen_t src_len; |
| 288 | uint16_t dst_port; |
| 289 | struct socket *so; |
| 290 | const char *state; |
| 291 | char buf[20]; |
Jan Kiszka | 6dbe553 | 2009-06-24 14:42:29 +0200 | [diff] [blame] | 292 | |
| 293 | monitor_printf(mon, " Protocol[State] FD Source Address Port " |
| 294 | "Dest. Address Port RecvQ SendQ\n"); |
| 295 | |
Jan Kiszka | 460fec6 | 2009-06-24 14:42:31 +0200 | [diff] [blame] | 296 | for (so = slirp->tcb.so_next; so != &slirp->tcb; so = so->so_next) { |
Jan Kiszka | 6dbe553 | 2009-06-24 14:42:29 +0200 | [diff] [blame] | 297 | if (so->so_state & SS_HOSTFWD) { |
| 298 | state = "HOST_FORWARD"; |
| 299 | } else if (so->so_tcpcb) { |
| 300 | state = tcpstates[so->so_tcpcb->t_state]; |
| 301 | } else { |
| 302 | state = "NONE"; |
| 303 | } |
| 304 | if (so->so_state & (SS_HOSTFWD | SS_INCOMING)) { |
| 305 | src_len = sizeof(src); |
| 306 | getsockname(so->s, (struct sockaddr *)&src, &src_len); |
| 307 | dst_addr = so->so_laddr; |
| 308 | dst_port = so->so_lport; |
| 309 | } else { |
| 310 | src.sin_addr = so->so_laddr; |
| 311 | src.sin_port = so->so_lport; |
| 312 | dst_addr = so->so_faddr; |
| 313 | dst_port = so->so_fport; |
| 314 | } |
Alon Levy | f293d8b | 2012-02-24 13:33:49 +0200 | [diff] [blame] | 315 | snprintf(buf, sizeof(buf), " TCP[%s]", state); |
| 316 | monitor_printf(mon, "%-19s %3d %15s %5d ", buf, so->s, |
Jan Kiszka | 6dbe553 | 2009-06-24 14:42:29 +0200 | [diff] [blame] | 317 | src.sin_addr.s_addr ? inet_ntoa(src.sin_addr) : "*", |
| 318 | ntohs(src.sin_port)); |
| 319 | monitor_printf(mon, "%15s %5d %5d %5d\n", |
| 320 | inet_ntoa(dst_addr), ntohs(dst_port), |
| 321 | so->so_rcv.sb_cc, so->so_snd.sb_cc); |
| 322 | } |
| 323 | |
Jan Kiszka | 460fec6 | 2009-06-24 14:42:31 +0200 | [diff] [blame] | 324 | for (so = slirp->udb.so_next; so != &slirp->udb; so = so->so_next) { |
Jan Kiszka | 6dbe553 | 2009-06-24 14:42:29 +0200 | [diff] [blame] | 325 | if (so->so_state & SS_HOSTFWD) { |
Alon Levy | f293d8b | 2012-02-24 13:33:49 +0200 | [diff] [blame] | 326 | snprintf(buf, sizeof(buf), " UDP[HOST_FORWARD]"); |
Jan Kiszka | 6dbe553 | 2009-06-24 14:42:29 +0200 | [diff] [blame] | 327 | src_len = sizeof(src); |
| 328 | getsockname(so->s, (struct sockaddr *)&src, &src_len); |
| 329 | dst_addr = so->so_laddr; |
| 330 | dst_port = so->so_lport; |
| 331 | } else { |
Alon Levy | f293d8b | 2012-02-24 13:33:49 +0200 | [diff] [blame] | 332 | snprintf(buf, sizeof(buf), " UDP[%d sec]", |
Jan Kiszka | 6dbe553 | 2009-06-24 14:42:29 +0200 | [diff] [blame] | 333 | (so->so_expire - curtime) / 1000); |
| 334 | src.sin_addr = so->so_laddr; |
| 335 | src.sin_port = so->so_lport; |
| 336 | dst_addr = so->so_faddr; |
| 337 | dst_port = so->so_fport; |
| 338 | } |
Alon Levy | f293d8b | 2012-02-24 13:33:49 +0200 | [diff] [blame] | 339 | monitor_printf(mon, "%-19s %3d %15s %5d ", buf, so->s, |
Jan Kiszka | 6dbe553 | 2009-06-24 14:42:29 +0200 | [diff] [blame] | 340 | src.sin_addr.s_addr ? inet_ntoa(src.sin_addr) : "*", |
| 341 | ntohs(src.sin_port)); |
| 342 | monitor_printf(mon, "%15s %5d %5d %5d\n", |
| 343 | inet_ntoa(dst_addr), ntohs(dst_port), |
| 344 | so->so_rcv.sb_cc, so->so_snd.sb_cc); |
| 345 | } |
Jan Kiszka | e6d43cf | 2011-07-20 12:20:18 +0200 | [diff] [blame] | 346 | |
| 347 | for (so = slirp->icmp.so_next; so != &slirp->icmp; so = so->so_next) { |
Alon Levy | f293d8b | 2012-02-24 13:33:49 +0200 | [diff] [blame] | 348 | snprintf(buf, sizeof(buf), " ICMP[%d sec]", |
Jan Kiszka | e6d43cf | 2011-07-20 12:20:18 +0200 | [diff] [blame] | 349 | (so->so_expire - curtime) / 1000); |
| 350 | src.sin_addr = so->so_laddr; |
| 351 | dst_addr = so->so_faddr; |
Alon Levy | f293d8b | 2012-02-24 13:33:49 +0200 | [diff] [blame] | 352 | monitor_printf(mon, "%-19s %3d %15s - ", buf, so->s, |
Jan Kiszka | e6d43cf | 2011-07-20 12:20:18 +0200 | [diff] [blame] | 353 | src.sin_addr.s_addr ? inet_ntoa(src.sin_addr) : "*"); |
| 354 | monitor_printf(mon, "%15s - %5d %5d\n", inet_ntoa(dst_addr), |
| 355 | so->so_rcv.sb_cc, so->so_snd.sb_cc); |
| 356 | } |
Jan Kiszka | 6dbe553 | 2009-06-24 14:42:29 +0200 | [diff] [blame] | 357 | } |