slirp/misc.c

   1 /*
   2  * Copyright (c) 1995 Danny Gasparovski.
   3  *
   4  * Please read the file COPYRIGHT for the
   5  * terms and conditions of the copyright.
   6  */
   7
   8 #include "qemu/osdep.h"
   9 #include "slirp.h"
  10 #include "libslirp.h"
  11 #include "qemu/error-report.h"
  12 #include "qemu/main-loop.h"
  13
  14 inline void
  15 insque(void *a, void *b)
  16 {
  17         register struct quehead *element = (struct quehead *) a;
  18         register struct quehead *head = (struct quehead *) b;
  19         element->qh_link = head->qh_link;
  20         head->qh_link = (struct quehead *)element;
  21         element->qh_rlink = (struct quehead *)head;
  22         ((struct quehead *)(element->qh_link))->qh_rlink
  23         = (struct quehead *)element;
  24 }
  25
  26 inline void
  27 remque(void *a)
  28 {
  29   register struct quehead *element = (struct quehead *) a;
  30   ((struct quehead *)(element->qh_link))->qh_rlink = element->qh_rlink;
  31   ((struct quehead *)(element->qh_rlink))->qh_link = element->qh_link;
  32   element->qh_rlink = NULL;
  33 }
  34
  35 struct gfwd_list *
  36 add_guestfwd(struct gfwd_list **ex_ptr,
  37              SlirpWriteCb write_cb, void *opaque,
  38              struct in_addr addr, int port)
  39 {
  40     struct gfwd_list *f = g_new0(struct gfwd_list, 1);
  41
  42     f->write_cb = write_cb;
  43     f->opaque = opaque;
  44     f->ex_fport = port;
  45     f->ex_addr = addr;
  46     f->ex_next = *ex_ptr;
  47     *ex_ptr = f;
  48
  49     return f;
  50 }
  51
  52 struct gfwd_list *
  53 add_exec(struct gfwd_list **ex_ptr, const char *cmdline,
  54          struct in_addr addr, int port)
  55 {
  56     struct gfwd_list *f = add_guestfwd(ex_ptr, NULL, NULL, addr, port);
  57
  58     f->ex_exec = g_strdup(cmdline);
  59
  60     return f;
  61 }
  62
  63 static int
  64 slirp_socketpair_with_oob(int sv[2])
  65 {
  66     struct sockaddr_in addr = {
  67         .sin_family = AF_INET,
  68         .sin_port = 0,
  69         .sin_addr.s_addr = INADDR_ANY,
  70     };
  71     socklen_t addrlen = sizeof(addr);
  72     int ret, s;
  73
  74     sv[1] = -1;
  75     s = slirp_socket(AF_INET, SOCK_STREAM, 0);
  76     if (s < 0 || bind(s, (struct sockaddr *)&addr, addrlen) < 0 ||
  77         listen(s, 1) < 0 ||
  78         getsockname(s, (struct sockaddr *)&addr, &addrlen) < 0) {
  79         goto err;
  80     }
  81
  82     sv[1] = slirp_socket(AF_INET, SOCK_STREAM, 0);
  83     if (sv[1] < 0) {
  84         goto err;
  85     }
  86     /*
  87      * This connect won't block because we've already listen()ed on
  88      * the server end (even though we won't accept() the connection
  89      * until later on).
  90      */
  91     do {
  92         ret = connect(sv[1], (struct sockaddr *)&addr, addrlen);
  93     } while (ret < 0 && errno == EINTR);
  94     if (ret < 0) {
  95         goto err;
  96     }
  97
  98     do {
  99         sv[0] = accept(s, (struct sockaddr *)&addr, &addrlen);
 100     } while (sv[0] < 0 && errno == EINTR);
 101     if (sv[0] < 0) {
 102         goto err;
 103     }
 104
 105     slirp_closesocket(s);
 106     return 0;
 107
 108 err:
 109     g_critical("slirp_socketpair(): %s", strerror(errno));
 110     if (s >= 0) {
 111         slirp_closesocket(s);
 112     }
 113     if (sv[1] >= 0) {
 114         slirp_closesocket(sv[1]);
 115     }
 116     return -1;
 117 }
 118
 119 static void
 120 fork_exec_child_setup(gpointer data)
 121 {
 122 #ifndef _WIN32
 123     setsid();
 124 #endif
 125 }
 126
 127 int
 128 fork_exec(struct socket *so, const char *ex)
 129 {
 130     GError *err = NULL;
 131     char **argv;
 132     int opt, sp[2];
 133
 134     DEBUG_CALL("fork_exec");
 135     DEBUG_ARG("so = %p", so);
 136     DEBUG_ARG("ex = %p", ex);
 137
 138     if (slirp_socketpair_with_oob(sp) < 0) {
 139         return 0;
 140     }
 141
 142     argv = g_strsplit(ex, " ", -1);
 143     g_spawn_async_with_fds(NULL /* cwd */,
 144                            argv,
 145                            NULL /* env */,
 146                            G_SPAWN_SEARCH_PATH,
 147                            fork_exec_child_setup, NULL /* data */,
 148                            NULL /* child_pid */,
 149                            sp[1], sp[1], sp[1],
 150                            &err);
 151     g_strfreev(argv);
 152
 153     if (err) {
 154         g_critical("fork_exec: %s", err->message);
 155         g_error_free(err);
 156         slirp_closesocket(sp[0]);
 157         slirp_closesocket(sp[1]);
 158         return 0;
 159     }
 160
 161     so->s = sp[0];
 162     slirp_closesocket(sp[1]);
 163     slirp_socket_set_fast_reuse(so->s);
 164     opt = 1;
 165     slirp_setsockopt(so->s, SOL_SOCKET, SO_OOBINLINE, &opt, sizeof(int));
 166     slirp_set_nonblock(so->s);
 167     so->slirp->cb->register_poll_fd(so->s);
 168     return 1;
 169 }
 170
 171 char *slirp_connection_info(Slirp *slirp)
 172 {
 173     GString *str = g_string_new(NULL);
 174     const char * const tcpstates[] = {
 175         [TCPS_CLOSED]       = "CLOSED",
 176         [TCPS_LISTEN]       = "LISTEN",
 177         [TCPS_SYN_SENT]     = "SYN_SENT",
 178         [TCPS_SYN_RECEIVED] = "SYN_RCVD",
 179         [TCPS_ESTABLISHED]  = "ESTABLISHED",
 180         [TCPS_CLOSE_WAIT]   = "CLOSE_WAIT",
 181         [TCPS_FIN_WAIT_1]   = "FIN_WAIT_1",
 182         [TCPS_CLOSING]      = "CLOSING",
 183         [TCPS_LAST_ACK]     = "LAST_ACK",
 184         [TCPS_FIN_WAIT_2]   = "FIN_WAIT_2",
 185         [TCPS_TIME_WAIT]    = "TIME_WAIT",
 186     };
 187     struct in_addr dst_addr;
 188     struct sockaddr_in src;
 189     socklen_t src_len;
 190     uint16_t dst_port;
 191     struct socket *so;
 192     const char *state;
 193     char buf[20];
 194
 195     g_string_append_printf(str,
 196         "  Protocol[State]    FD  Source Address  Port   "
 197         "Dest. Address  Port RecvQ SendQ\n");
 198
 199     for (so = slirp->tcb.so_next; so != &slirp->tcb; so = so->so_next) {
 200         if (so->so_state & SS_HOSTFWD) {
 201             state = "HOST_FORWARD";
 202         } else if (so->so_tcpcb) {
 203             state = tcpstates[so->so_tcpcb->t_state];
 204         } else {
 205             state = "NONE";
 206         }
 207         if (so->so_state & (SS_HOSTFWD | SS_INCOMING)) {
 208             src_len = sizeof(src);
 209             getsockname(so->s, (struct sockaddr *)&src, &src_len);
 210             dst_addr = so->so_laddr;
 211             dst_port = so->so_lport;
 212         } else {
 213             src.sin_addr = so->so_laddr;
 214             src.sin_port = so->so_lport;
 215             dst_addr = so->so_faddr;
 216             dst_port = so->so_fport;
 217         }
 218         snprintf(buf, sizeof(buf), "  TCP[%s]", state);
 219         g_string_append_printf(str, "%-19s %3d %15s %5d ", buf, so->s,
 220                        src.sin_addr.s_addr ? inet_ntoa(src.sin_addr) : "*",
 221                        ntohs(src.sin_port));
 222         g_string_append_printf(str, "%15s %5d %5d %5d\n",
 223                        inet_ntoa(dst_addr), ntohs(dst_port),
 224                        so->so_rcv.sb_cc, so->so_snd.sb_cc);
 225     }
 226
 227     for (so = slirp->udb.so_next; so != &slirp->udb; so = so->so_next) {
 228         if (so->so_state & SS_HOSTFWD) {
 229             snprintf(buf, sizeof(buf), "  UDP[HOST_FORWARD]");
 230             src_len = sizeof(src);
 231             getsockname(so->s, (struct sockaddr *)&src, &src_len);
 232             dst_addr = so->so_laddr;
 233             dst_port = so->so_lport;
 234         } else {
 235             snprintf(buf, sizeof(buf), "  UDP[%d sec]",
 236                          (so->so_expire - curtime) / 1000);
 237             src.sin_addr = so->so_laddr;
 238             src.sin_port = so->so_lport;
 239             dst_addr = so->so_faddr;
 240             dst_port = so->so_fport;
 241         }
 242         g_string_append_printf(str, "%-19s %3d %15s %5d ", buf, so->s,
 243                        src.sin_addr.s_addr ? inet_ntoa(src.sin_addr) : "*",
 244                        ntohs(src.sin_port));
 245         g_string_append_printf(str, "%15s %5d %5d %5d\n",
 246                        inet_ntoa(dst_addr), ntohs(dst_port),
 247                        so->so_rcv.sb_cc, so->so_snd.sb_cc);
 248     }
 249
 250     for (so = slirp->icmp.so_next; so != &slirp->icmp; so = so->so_next) {
 251         snprintf(buf, sizeof(buf), "  ICMP[%d sec]",
 252                      (so->so_expire - curtime) / 1000);
 253         src.sin_addr = so->so_laddr;
 254         dst_addr = so->so_faddr;
 255         g_string_append_printf(str, "%-19s %3d %15s  -    ", buf, so->s,
 256                        src.sin_addr.s_addr ? inet_ntoa(src.sin_addr) : "*");
 257         g_string_append_printf(str, "%15s  -    %5d %5d\n", inet_ntoa(dst_addr),
 258                        so->so_rcv.sb_cc, so->so_snd.sb_cc);
 259     }
 260
 261     return g_string_free(str, FALSE);
 262 }