palacios/src/palacios/vmm_socket.c

   1 /*
   2  * This file is part of the Palacios Virtual Machine Monitor developed
   3  * by the V3VEE Project with funding from the United States National
   4  * Science Foundation and the Department of Energy.
   5  *
   6  * The V3VEE Project is a joint project between Northwestern University
   7  * and the University of New Mexico.  You can find out more at
   8  * http://www.v3vee.org
   9  *
  10  * Copyright (c) 2008, Jack Lange <jarusl@cs.northwestern.edu>
  11  * Copyright (c) 2008, The V3VEE Project <http://www.v3vee.org>
  12  * All rights reserved.
  13  *
  14  * Author: Jack Lange <jarusl@cs.northwestern.edu>
  15  *
  16  * This is free software.  You are permitted to use,
  17  * redistribute, and modify it as specified in the file "V3VEE_LICENSE".
  18  */
  19
  20
  21 #include <palacios/vmm_socket.h>
  22 #include <palacios/vmm.h>
  23 #include <palacios/vmm_debug.h>
  24 #include <palacios/vmm_types.h>
  25 #include <palacios/vm_guest.h>
  26
  27 static struct v3_socket_hooks * sock_hooks = 0;
  28
  29
  30 uint32_t v3_inet_addr(const char * ip_str) {
  31     uint32_t val;
  32     int base, n, c;
  33     uint32_t parts[4];
  34     uint32_t * pp = parts;
  35
  36     c = *ip_str;
  37     for (;;) {
  38         /*
  39          * Collect number up to ``.''.
  40          * Values are specified as for C:
  41          * 0x=hex, 0=octal, 1-9=decimal.
  42          */
  43         if (!isdigit(c)) {
  44             return (0);
  45         }
  46
  47         val = 0;
  48         base = 10;
  49
  50         if (c == '0') {
  51             c = *++ip_str;
  52             if ((c == 'x') || (c == 'X')) {
  53                 base = 16;
  54                 c = *++ip_str;
  55             } else {
  56                 base = 8;
  57             }
  58         }
  59
  60         for (;;) {
  61             if (isdigit(c)) {
  62                 val = (val * base) + (int)(c - '0');
  63                 c = *++ip_str;
  64             } else if ((base == 16) && (isxdigit(c))) {
  65                 val = (val << 4) | (int)(c + 10 - (islower(c) ? 'a' : 'A'));
  66                 c = *++ip_str;
  67             } else {
  68                 break;
  69             }
  70         }
  71
  72         if (c == '.') {
  73             /*
  74              * Internet format:
  75              *  a.b.c.d
  76              *  a.b.c   (with c treated as 16 bits)
  77              *  a.b (with b treated as 24 bits)
  78              */
  79             if (pp >= parts + 3) {
  80                 return 0;
  81             }
  82
  83             *pp++ = val;
  84             c = *++ip_str;
  85         } else {
  86             break;
  87         }
  88     }
  89
  90     /*
  91      * Check for trailing characters.
  92      */
  93     if ( (c != '\0') &&
  94          ( (!isprint(c)) || (!isspace(c)) ) ) {
  95         return 0;
  96     }
  97
  98     /*
  99      * Concoct the address according to
 100      * the number of parts specified.
 101      */
 102     n = pp - parts + 1;
 103
 104     switch (n) {
 105         case 0:
 106             return 0;       /* initial nondigit */
 107
 108         case 1:             /* a -- 32 bits */
 109             break;
 110
 111         case 2:             /* a.b -- 8.24 bits */
 112             if (val > 0xffffffUL) {
 113                 return 0;
 114             }
 115
 116             val |= parts[0] << 24;
 117             break;
 118
 119         case 3:             /* a.b.c -- 8.8.16 bits */
 120             if (val > 0xffff) {
 121                 return 0;
 122             }
 123
 124             val |= (parts[0] << 24) | (parts[1] << 16);
 125             break;
 126
 127         case 4:             /* a.b.c.d -- 8.8.8.8 bits */
 128             if (val > 0xff) {
 129                 return 0;
 130             }
 131
 132             val |= (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8);
 133             break;
 134     }
 135
 136     if (val) {
 137         return v3_htonl(val);
 138     }
 139
 140     return -1;
 141 }
 142
 143
 144 char * v3_inet_ntoa(uint32_t addr) {
 145     static char str[16];
 146     char inv[3];
 147     char * rp;
 148     uint8_t * ap;
 149     uint8_t rem;
 150     uint8_t n;
 151     uint8_t i;
 152
 153     rp = str;
 154     ap = (uint8_t *)&addr;
 155
 156     for (n = 0; n < 4; n++) {
 157         i = 0;
 158
 159         do {
 160             rem = *ap % (uint8_t)10;
 161
 162             *ap /= (uint8_t)10;
 163
 164             inv[i++] = '0' + rem;
 165         } while(*ap);
 166
 167         while(i--) {
 168             *rp++ = inv[i];
 169         }
 170
 171         *rp++ = '.';
 172         ap++;
 173     }
 174
 175     *--rp = 0;
 176
 177     return str;
 178 }
 179
 180
 181
 182
 183
 184 uint16_t v3_htons(uint16_t n) {
 185     return (((n & 0xff) << 8) | ((n & 0xff00) >> 8));
 186 }
 187
 188
 189 uint16_t v3_ntohs(uint16_t n) {
 190     return v3_htons(n);
 191 }
 192
 193
 194 uint32_t v3_htonl(uint32_t n) {
 195     return (((n & 0xff) << 24) |
 196             ((n & 0xff00) << 8) |
 197             ((n & 0xff0000UL) >> 8) |
 198             ((n & 0xff000000UL) >> 24));
 199 }
 200
 201
 202 uint32_t v3_ntohl(uint32_t n) {
 203   return v3_htonl(n);
 204 }
 205
 206
 207 v3_sock_t v3_create_udp_socket(struct v3_vm_info * vm) {
 208     V3_ASSERT(sock_hooks);
 209     V3_ASSERT(sock_hooks->udp_socket);
 210     void * priv_data = NULL;
 211
 212     if (vm) {
 213         priv_data = vm->host_priv_data;
 214     }
 215
 216     return sock_hooks->udp_socket(0, 0, priv_data);
 217 }
 218
 219 v3_sock_t v3_create_tcp_socket(struct v3_vm_info * vm) {
 220     V3_ASSERT(sock_hooks);
 221     V3_ASSERT(sock_hooks->tcp_socket);
 222     void * priv_data = NULL;
 223
 224     if (vm) {
 225         priv_data = vm->host_priv_data;
 226     }
 227
 228     return sock_hooks->tcp_socket(0, 1, 0, priv_data);
 229 }
 230
 231 void v3_socket_close(v3_sock_t sock) {
 232     V3_ASSERT(sock_hooks);
 233     V3_ASSERT(sock_hooks->close);
 234
 235     sock_hooks->close(sock);
 236 }
 237
 238 int v3_socket_bind(const v3_sock_t sock, uint16_t port) {
 239     V3_ASSERT(sock_hooks);
 240     V3_ASSERT(sock_hooks->bind);
 241
 242     return sock_hooks->bind(sock, port);
 243 }
 244
 245 int v3_socket_listen(const v3_sock_t sock, int backlog) {
 246     V3_ASSERT(sock_hooks);
 247     V3_ASSERT(sock_hooks->listen);
 248
 249     return sock_hooks->listen(sock, backlog);
 250 }
 251
 252 v3_sock_t v3_socket_accept(const v3_sock_t sock, uint32_t * remote_ip, uint32_t * port) {
 253     V3_ASSERT(sock_hooks);
 254     V3_ASSERT(sock_hooks->accept);
 255
 256     return sock_hooks->accept(sock, remote_ip, port);
 257 }
 258
 259 int v3_connect_to_ip(const v3_sock_t sock, const uint32_t hostip, const uint16_t port) {
 260     V3_ASSERT(sock_hooks);
 261     V3_ASSERT(sock_hooks->connect_to_ip);
 262
 263     return sock_hooks->connect_to_ip(sock, hostip, port);
 264 }
 265
 266 int v3_connect_to_host(const v3_sock_t sock, const char * hostname, const uint16_t port) {
 267     V3_ASSERT(sock_hooks);
 268     V3_ASSERT(sock_hooks->connect_to_host);
 269
 270     return sock_hooks->connect_to_host(sock, hostname, port);
 271 }
 272
 273 int v3_socket_send(const v3_sock_t sock, const uint8_t * buf, const uint32_t len) {
 274     V3_ASSERT(sock_hooks);
 275     V3_ASSERT(sock_hooks->send);
 276
 277     return sock_hooks->send(sock, buf, len);
 278 }
 279
 280 int v3_socket_recv(const v3_sock_t sock, uint8_t * buf, const uint32_t len) {
 281     V3_ASSERT(sock_hooks);
 282     V3_ASSERT(sock_hooks->recv);
 283
 284     return sock_hooks->recv(sock, buf, len);
 285 }
 286
 287 int v3_socket_send_to_host(const v3_sock_t sock, const char * hostname, const uint16_t port,
 288                            const uint8_t * buf, const uint32_t len) {
 289     V3_ASSERT(sock_hooks);
 290     V3_ASSERT(sock_hooks->sendto_host);
 291
 292     return sock_hooks->sendto_host(sock, hostname, port, buf, len);
 293 }
 294
 295 int v3_socket_send_to_ip(const v3_sock_t sock, const uint32_t ip, const uint16_t port,
 296                          const uint8_t * buf, const uint32_t len) {
 297     V3_ASSERT(sock_hooks);
 298     V3_ASSERT(sock_hooks->sendto_ip);
 299
 300     return sock_hooks->sendto_ip(sock, ip, port, buf, len);
 301 }
 302
 303 int v3_socket_recv_from_host(const v3_sock_t sock, const char * hostname, const uint16_t port,
 304                              uint8_t * buf, const uint32_t len) {
 305     V3_ASSERT(sock_hooks);
 306     V3_ASSERT(sock_hooks->recvfrom_host);
 307
 308     return sock_hooks->recvfrom_host(sock, hostname, port, buf, len);
 309 }
 310
 311 int v3_socket_recv_from_ip(const v3_sock_t sock, const uint32_t ip, const uint16_t port,
 312                            uint8_t * buf, const uint32_t len) {
 313     V3_ASSERT(sock_hooks);
 314     V3_ASSERT(sock_hooks->recvfrom_ip);
 315
 316     return sock_hooks->recvfrom_ip(sock, ip, port, buf, len);
 317 }
 318
 319
 320
 321
 322 void V3_Init_Sockets(struct v3_socket_hooks * hooks) {
 323     sock_hooks = hooks;
 324     PrintDebug("V3 sockets inited\n");
 325
 326     return;
 327 }