← Back to branch summary

~vcs-imports/qemu/git

« back to all changes in this revision

Viewing changes to net.c

  • Committer: ths
  • Date: 2007-06-17 15:32:30 UTC
  • Revision ID: git-v1:ffb04fcf089865952592f1f8855c2848d4514a89
Allow relative paths for the interpreter prefix in linux-user emulation.


git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@2984 c046a42c-6fe2-441c-8c8c-71466251a162

Show diffs side-by-side

added added

removed removed

Lines of Context:
net.c
1
 
/*
2
 
 * QEMU System Emulator
3
 
 *
4
 
 * Copyright (c) 2003-2008 Fabrice Bellard
5
 
 *
6
 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
7
 
 * of this software and associated documentation files (the "Software"), to deal
8
 
 * in the Software without restriction, including without limitation the rights
9
 
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10
 
 * copies of the Software, and to permit persons to whom the Software is
11
 
 * furnished to do so, subject to the following conditions:
12
 
 *
13
 
 * The above copyright notice and this permission notice shall be included in
14
 
 * all copies or substantial portions of the Software.
15
 
 *
16
 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17
 
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18
 
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19
 
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20
 
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21
 
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22
 
 * THE SOFTWARE.
23
 
 */
24
 
#include "hw/hw.h"
25
 
#include "hw/boards.h"
26
 
#include "hw/usb.h"
27
 
#include "hw/pcmcia.h"
28
 
#include "hw/pc.h"
29
 
#include "hw/audiodev.h"
30
 
#include "hw/isa.h"
31
 
#include "hw/baum.h"
32
 
#include "hw/bt.h"
33
 
#include "net.h"
34
 
#include "console.h"
35
 
#include "sysemu.h"
36
 
#include "gdbstub.h"
37
 
#include "qemu-timer.h"
38
 
#include "qemu-char.h"
39
 
#include "block.h"
40
 
#include "audio/audio.h"
41
 
#include "migration.h"
42
 
 
43
 
#include <unistd.h>
44
 
#include <fcntl.h>
45
 
#include <signal.h>
46
 
#include <time.h>
47
 
#include <errno.h>
48
 
#include <sys/time.h>
49
 
#include <zlib.h>
50
 
 
51
 
#ifndef _WIN32
52
 
#include <sys/times.h>
53
 
#include <sys/wait.h>
54
 
#include <termios.h>
55
 
#include <sys/mman.h>
56
 
#include <sys/ioctl.h>
57
 
#include <sys/resource.h>
58
 
#include <sys/socket.h>
59
 
#include <netinet/in.h>
60
 
#include <net/if.h>
61
 
#ifdef __NetBSD__
62
 
#include <net/if_tap.h>
63
 
#endif
64
 
#ifdef __linux__
65
 
#include <linux/if_tun.h>
66
 
#endif
67
 
#include <arpa/inet.h>
68
 
#include <dirent.h>
69
 
#include <netdb.h>
70
 
#include <sys/select.h>
71
 
#ifdef _BSD
72
 
#include <sys/stat.h>
73
 
#ifdef __FreeBSD__
74
 
#include <libutil.h>
75
 
#else
76
 
#include <util.h>
77
 
#endif
78
 
#elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
79
 
#include <freebsd/stdlib.h>
80
 
#else
81
 
#ifdef __linux__
82
 
#include <pty.h>
83
 
#include <malloc.h>
84
 
#include <linux/rtc.h>
85
 
 
86
 
/* For the benefit of older linux systems which don't supply it,
87
 
   we use a local copy of hpet.h. */
88
 
/* #include <linux/hpet.h> */
89
 
#include "hpet.h"
90
 
 
91
 
#include <linux/ppdev.h>
92
 
#include <linux/parport.h>
93
 
#endif
94
 
#ifdef __sun__
95
 
#include <sys/stat.h>
96
 
#include <sys/ethernet.h>
97
 
#include <sys/sockio.h>
98
 
#include <netinet/arp.h>
99
 
#include <netinet/in.h>
100
 
#include <netinet/in_systm.h>
101
 
#include <netinet/ip.h>
102
 
#include <netinet/ip_icmp.h> // must come after ip.h
103
 
#include <netinet/udp.h>
104
 
#include <netinet/tcp.h>
105
 
#include <net/if.h>
106
 
#include <syslog.h>
107
 
#include <stropts.h>
108
 
#endif
109
 
#endif
110
 
#endif
111
 
 
112
 
#include "qemu_socket.h"
113
 
 
114
 
#if defined(CONFIG_SLIRP)
115
 
#include "libslirp.h"
116
 
#endif
117
 
 
118
 
#if defined(__OpenBSD__)
119
 
#include <util.h>
120
 
#endif
121
 
 
122
 
#if defined(CONFIG_VDE)
123
 
#include <libvdeplug.h>
124
 
#endif
125
 
 
126
 
#ifdef _WIN32
127
 
#include <malloc.h>
128
 
#include <sys/timeb.h>
129
 
#include <mmsystem.h>
130
 
#define getopt_long_only getopt_long
131
 
#define memalign(align, size) malloc(size)
132
 
#endif
133
 
 
134
 
#define DEFAULT_NETWORK_SCRIPT "/etc/qemu-ifup"
135
 
#define DEFAULT_NETWORK_DOWN_SCRIPT "/etc/qemu-ifdown"
136
 
#ifdef __sun__
137
 
#define SMBD_COMMAND "/usr/sfw/sbin/smbd"
138
 
#else
139
 
#define SMBD_COMMAND "/usr/sbin/smbd"
140
 
#endif
141
 
 
142
 
static VLANState *first_vlan;
143
 
 
144
 
/***********************************************************/
145
 
/* network device redirectors */
146
 
 
147
 
#if defined(DEBUG_NET) || defined(DEBUG_SLIRP)
148
 
static void hex_dump(FILE *f, const uint8_t *buf, int size)
149
 
{
150
 
    int len, i, j, c;
151
 
 
152
 
    for(i=0;i<size;i+=16) {
153
 
        len = size - i;
154
 
        if (len > 16)
155
 
            len = 16;
156
 
        fprintf(f, "%08x ", i);
157
 
        for(j=0;j<16;j++) {
158
 
            if (j < len)
159
 
                fprintf(f, " %02x", buf[i+j]);
160
 
            else
161
 
                fprintf(f, "   ");
162
 
        }
163
 
        fprintf(f, " ");
164
 
        for(j=0;j<len;j++) {
165
 
            c = buf[i+j];
166
 
            if (c < ' ' || c > '~')
167
 
                c = '.';
168
 
            fprintf(f, "%c", c);
169
 
        }
170
 
        fprintf(f, "\n");
171
 
    }
172
 
}
173
 
#endif
174
 
 
175
 
static int parse_macaddr(uint8_t *macaddr, const char *p)
176
 
{
177
 
    int i;
178
 
    char *last_char;
179
 
    long int offset;
180
 
 
181
 
    errno = 0;
182
 
    offset = strtol(p, &last_char, 0);    
183
 
    if (0 == errno && '\0' == *last_char &&
184
 
            offset >= 0 && offset <= 0xFFFFFF) {
185
 
        macaddr[3] = (offset & 0xFF0000) >> 16;
186
 
        macaddr[4] = (offset & 0xFF00) >> 8;
187
 
        macaddr[5] = offset & 0xFF;
188
 
        return 0;
189
 
    } else {
190
 
        for(i = 0; i < 6; i++) {
191
 
            macaddr[i] = strtol(p, (char **)&p, 16);
192
 
            if (i == 5) {
193
 
                if (*p != '\0')
194
 
                    return -1;
195
 
            } else {
196
 
                if (*p != ':' && *p != '-')
197
 
                    return -1;
198
 
                p++;
199
 
            }
200
 
        }
201
 
        return 0;    
202
 
    }
203
 
 
204
 
    return -1;
205
 
}
206
 
 
207
 
static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
208
 
{
209
 
    const char *p, *p1;
210
 
    int len;
211
 
    p = *pp;
212
 
    p1 = strchr(p, sep);
213
 
    if (!p1)
214
 
        return -1;
215
 
    len = p1 - p;
216
 
    p1++;
217
 
    if (buf_size > 0) {
218
 
        if (len > buf_size - 1)
219
 
            len = buf_size - 1;
220
 
        memcpy(buf, p, len);
221
 
        buf[len] = '\0';
222
 
    }
223
 
    *pp = p1;
224
 
    return 0;
225
 
}
226
 
 
227
 
int parse_host_src_port(struct sockaddr_in *haddr,
228
 
                        struct sockaddr_in *saddr,
229
 
                        const char *input_str)
230
 
{
231
 
    char *str = strdup(input_str);
232
 
    char *host_str = str;
233
 
    char *src_str;
234
 
    const char *src_str2;
235
 
    char *ptr;
236
 
 
237
 
    /*
238
 
     * Chop off any extra arguments at the end of the string which
239
 
     * would start with a comma, then fill in the src port information
240
 
     * if it was provided else use the "any address" and "any port".
241
 
     */
242
 
    if ((ptr = strchr(str,',')))
243
 
        *ptr = '\0';
244
 
 
245
 
    if ((src_str = strchr(input_str,'@'))) {
246
 
        *src_str = '\0';
247
 
        src_str++;
248
 
    }
249
 
 
250
 
    if (parse_host_port(haddr, host_str) < 0)
251
 
        goto fail;
252
 
 
253
 
    src_str2 = src_str;
254
 
    if (!src_str || *src_str == '\0')
255
 
        src_str2 = ":0";
256
 
 
257
 
    if (parse_host_port(saddr, src_str2) < 0)
258
 
        goto fail;
259
 
 
260
 
    free(str);
261
 
    return(0);
262
 
 
263
 
fail:
264
 
    free(str);
265
 
    return -1;
266
 
}
267
 
 
268
 
int parse_host_port(struct sockaddr_in *saddr, const char *str)
269
 
{
270
 
    char buf[512];
271
 
    struct hostent *he;
272
 
    const char *p, *r;
273
 
    int port;
274
 
 
275
 
    p = str;
276
 
    if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
277
 
        return -1;
278
 
    saddr->sin_family = AF_INET;
279
 
    if (buf[0] == '\0') {
280
 
        saddr->sin_addr.s_addr = 0;
281
 
    } else {
282
 
        if (isdigit(buf[0])) {
283
 
            if (!inet_aton(buf, &saddr->sin_addr))
284
 
                return -1;
285
 
        } else {
286
 
            if ((he = gethostbyname(buf)) == NULL)
287
 
                return - 1;
288
 
            saddr->sin_addr = *(struct in_addr *)he->h_addr;
289
 
        }
290
 
    }
291
 
    port = strtol(p, (char **)&r, 0);
292
 
    if (r == p)
293
 
        return -1;
294
 
    saddr->sin_port = htons(port);
295
 
    return 0;
296
 
}
297
 
 
298
 
#ifndef _WIN32
299
 
int parse_unix_path(struct sockaddr_un *uaddr, const char *str)
300
 
{
301
 
    const char *p;
302
 
    int len;
303
 
 
304
 
    len = MIN(108, strlen(str));
305
 
    p = strchr(str, ',');
306
 
    if (p)
307
 
        len = MIN(len, p - str);
308
 
 
309
 
    memset(uaddr, 0, sizeof(*uaddr));
310
 
 
311
 
    uaddr->sun_family = AF_UNIX;
312
 
    memcpy(uaddr->sun_path, str, len);
313
 
 
314
 
    return 0;
315
 
}
316
 
#endif
317
 
 
318
 
VLANClientState *qemu_new_vlan_client(VLANState *vlan,
319
 
                                      IOReadHandler *fd_read,
320
 
                                      IOCanRWHandler *fd_can_read,
321
 
                                      void *opaque)
322
 
{
323
 
    VLANClientState *vc, **pvc;
324
 
    vc = qemu_mallocz(sizeof(VLANClientState));
325
 
    if (!vc)
326
 
        return NULL;
327
 
    vc->fd_read = fd_read;
328
 
    vc->fd_can_read = fd_can_read;
329
 
    vc->opaque = opaque;
330
 
    vc->vlan = vlan;
331
 
 
332
 
    vc->next = NULL;
333
 
    pvc = &vlan->first_client;
334
 
    while (*pvc != NULL)
335
 
        pvc = &(*pvc)->next;
336
 
    *pvc = vc;
337
 
    return vc;
338
 
}
339
 
 
340
 
void qemu_del_vlan_client(VLANClientState *vc)
341
 
{
342
 
    VLANClientState **pvc = &vc->vlan->first_client;
343
 
 
344
 
    while (*pvc != NULL)
345
 
        if (*pvc == vc) {
346
 
            *pvc = vc->next;
347
 
            free(vc);
348
 
            break;
349
 
        } else
350
 
            pvc = &(*pvc)->next;
351
 
}
352
 
 
353
 
int qemu_can_send_packet(VLANClientState *vc1)
354
 
{
355
 
    VLANState *vlan = vc1->vlan;
356
 
    VLANClientState *vc;
357
 
 
358
 
    for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
359
 
        if (vc != vc1) {
360
 
            if (vc->fd_can_read && vc->fd_can_read(vc->opaque))
361
 
                return 1;
362
 
        }
363
 
    }
364
 
    return 0;
365
 
}
366
 
 
367
 
void qemu_send_packet(VLANClientState *vc1, const uint8_t *buf, int size)
368
 
{
369
 
    VLANState *vlan = vc1->vlan;
370
 
    VLANClientState *vc;
371
 
 
372
 
#ifdef DEBUG_NET
373
 
    printf("vlan %d send:\n", vlan->id);
374
 
    hex_dump(stdout, buf, size);
375
 
#endif
376
 
    for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
377
 
        if (vc != vc1) {
378
 
            vc->fd_read(vc->opaque, buf, size);
379
 
        }
380
 
    }
381
 
}
382
 
 
383
 
#if defined(CONFIG_SLIRP)
384
 
 
385
 
/* slirp network adapter */
386
 
 
387
 
static int slirp_inited;
388
 
static VLANClientState *slirp_vc;
389
 
 
390
 
int slirp_can_output(void)
391
 
{
392
 
    return !slirp_vc || qemu_can_send_packet(slirp_vc);
393
 
}
394
 
 
395
 
void slirp_output(const uint8_t *pkt, int pkt_len)
396
 
{
397
 
#ifdef DEBUG_SLIRP
398
 
    printf("slirp output:\n");
399
 
    hex_dump(stdout, pkt, pkt_len);
400
 
#endif
401
 
    if (!slirp_vc)
402
 
        return;
403
 
    qemu_send_packet(slirp_vc, pkt, pkt_len);
404
 
}
405
 
 
406
 
int slirp_is_inited(void)
407
 
{
408
 
    return slirp_inited;
409
 
}
410
 
 
411
 
static void slirp_receive(void *opaque, const uint8_t *buf, int size)
412
 
{
413
 
#ifdef DEBUG_SLIRP
414
 
    printf("slirp input:\n");
415
 
    hex_dump(stdout, buf, size);
416
 
#endif
417
 
    slirp_input(buf, size);
418
 
}
419
 
 
420
 
static int net_slirp_init(VLANState *vlan)
421
 
{
422
 
    if (!slirp_inited) {
423
 
        slirp_inited = 1;
424
 
        slirp_init();
425
 
    }
426
 
    slirp_vc = qemu_new_vlan_client(vlan,
427
 
                                    slirp_receive, NULL, NULL);
428
 
    snprintf(slirp_vc->info_str, sizeof(slirp_vc->info_str), "user redirector");
429
 
    return 0;
430
 
}
431
 
 
432
 
void net_slirp_redir(const char *redir_str)
433
 
{
434
 
    int is_udp;
435
 
    char buf[256], *r;
436
 
    const char *p;
437
 
    struct in_addr guest_addr;
438
 
    int host_port, guest_port;
439
 
 
440
 
    if (!slirp_inited) {
441
 
        slirp_inited = 1;
442
 
        slirp_init();
443
 
    }
444
 
 
445
 
    p = redir_str;
446
 
    if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
447
 
        goto fail;
448
 
    if (!strcmp(buf, "tcp")) {
449
 
        is_udp = 0;
450
 
    } else if (!strcmp(buf, "udp")) {
451
 
        is_udp = 1;
452
 
    } else {
453
 
        goto fail;
454
 
    }
455
 
 
456
 
    if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
457
 
        goto fail;
458
 
    host_port = strtol(buf, &r, 0);
459
 
    if (r == buf)
460
 
        goto fail;
461
 
 
462
 
    if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
463
 
        goto fail;
464
 
    if (buf[0] == '\0') {
465
 
        pstrcpy(buf, sizeof(buf), "10.0.2.15");
466
 
    }
467
 
    if (!inet_aton(buf, &guest_addr))
468
 
        goto fail;
469
 
 
470
 
    guest_port = strtol(p, &r, 0);
471
 
    if (r == p)
472
 
        goto fail;
473
 
 
474
 
    if (slirp_redir(is_udp, host_port, guest_addr, guest_port) < 0) {
475
 
        fprintf(stderr, "qemu: could not set up redirection\n");
476
 
        exit(1);
477
 
    }
478
 
    return;
479
 
 fail:
480
 
    fprintf(stderr, "qemu: syntax: -redir [tcp|udp]:host-port:[guest-host]:guest-port\n");
481
 
    exit(1);
482
 
}
483
 
 
484
 
#ifndef _WIN32
485
 
 
486
 
static char smb_dir[1024];
487
 
 
488
 
static void erase_dir(char *dir_name)
489
 
{
490
 
    DIR *d;
491
 
    struct dirent *de;
492
 
    char filename[1024];
493
 
 
494
 
    /* erase all the files in the directory */
495
 
    if ((d = opendir(dir_name)) != 0) {
496
 
        for(;;) {
497
 
            de = readdir(d);
498
 
            if (!de)
499
 
                break;
500
 
            if (strcmp(de->d_name, ".") != 0 &&
501
 
                strcmp(de->d_name, "..") != 0) {
502
 
                snprintf(filename, sizeof(filename), "%s/%s",
503
 
                         smb_dir, de->d_name);
504
 
                if (unlink(filename) != 0)  /* is it a directory? */
505
 
                    erase_dir(filename);
506
 
            }
507
 
        }
508
 
        closedir(d);
509
 
        rmdir(dir_name);
510
 
    }
511
 
}
512
 
 
513
 
/* automatic user mode samba server configuration */
514
 
static void smb_exit(void)
515
 
{
516
 
    erase_dir(smb_dir);
517
 
}
518
 
 
519
 
/* automatic user mode samba server configuration */
520
 
void net_slirp_smb(const char *exported_dir)
521
 
{
522
 
    char smb_conf[1024];
523
 
    char smb_cmdline[1024];
524
 
    FILE *f;
525
 
 
526
 
    if (!slirp_inited) {
527
 
        slirp_inited = 1;
528
 
        slirp_init();
529
 
    }
530
 
 
531
 
    /* XXX: better tmp dir construction */
532
 
    snprintf(smb_dir, sizeof(smb_dir), "/tmp/qemu-smb.%d", getpid());
533
 
    if (mkdir(smb_dir, 0700) < 0) {
534
 
        fprintf(stderr, "qemu: could not create samba server dir '%s'\n", smb_dir);
535
 
        exit(1);
536
 
    }
537
 
    snprintf(smb_conf, sizeof(smb_conf), "%s/%s", smb_dir, "smb.conf");
538
 
 
539
 
    f = fopen(smb_conf, "w");
540
 
    if (!f) {
541
 
        fprintf(stderr, "qemu: could not create samba server configuration file '%s'\n", smb_conf);
542
 
        exit(1);
543
 
    }
544
 
    fprintf(f,
545
 
            "[global]\n"
546
 
            "private dir=%s\n"
547
 
            "smb ports=0\n"
548
 
            "socket address=127.0.0.1\n"
549
 
            "pid directory=%s\n"
550
 
            "lock directory=%s\n"
551
 
            "log file=%s/log.smbd\n"
552
 
            "smb passwd file=%s/smbpasswd\n"
553
 
            "security = share\n"
554
 
            "[qemu]\n"
555
 
            "path=%s\n"
556
 
            "read only=no\n"
557
 
            "guest ok=yes\n",
558
 
            smb_dir,
559
 
            smb_dir,
560
 
            smb_dir,
561
 
            smb_dir,
562
 
            smb_dir,
563
 
            exported_dir
564
 
            );
565
 
    fclose(f);
566
 
    atexit(smb_exit);
567
 
 
568
 
    snprintf(smb_cmdline, sizeof(smb_cmdline), "%s -s %s",
569
 
             SMBD_COMMAND, smb_conf);
570
 
 
571
 
    slirp_add_exec(0, smb_cmdline, 4, 139);
572
 
}
573
 
 
574
 
#endif /* !defined(_WIN32) */
575
 
void do_info_slirp(void)
576
 
{
577
 
    slirp_stats();
578
 
}
579
 
 
580
 
#endif /* CONFIG_SLIRP */
581
 
 
582
 
#if !defined(_WIN32)
583
 
 
584
 
typedef struct TAPState {
585
 
    VLANClientState *vc;
586
 
    int fd;
587
 
    char down_script[1024];
588
 
} TAPState;
589
 
 
590
 
static void tap_receive(void *opaque, const uint8_t *buf, int size)
591
 
{
592
 
    TAPState *s = opaque;
593
 
    int ret;
594
 
    for(;;) {
595
 
        ret = write(s->fd, buf, size);
596
 
        if (ret < 0 && (errno == EINTR || errno == EAGAIN)) {
597
 
        } else {
598
 
            break;
599
 
        }
600
 
    }
601
 
}
602
 
 
603
 
static void tap_send(void *opaque)
604
 
{
605
 
    TAPState *s = opaque;
606
 
    uint8_t buf[4096];
607
 
    int size;
608
 
 
609
 
#ifdef __sun__
610
 
    struct strbuf sbuf;
611
 
    int f = 0;
612
 
    sbuf.maxlen = sizeof(buf);
613
 
    sbuf.buf = buf;
614
 
    size = getmsg(s->fd, NULL, &sbuf, &f) >=0 ? sbuf.len : -1;
615
 
#else
616
 
    size = read(s->fd, buf, sizeof(buf));
617
 
#endif
618
 
    if (size > 0) {
619
 
        qemu_send_packet(s->vc, buf, size);
620
 
    }
621
 
}
622
 
 
623
 
/* fd support */
624
 
 
625
 
static TAPState *net_tap_fd_init(VLANState *vlan, int fd)
626
 
{
627
 
    TAPState *s;
628
 
 
629
 
    s = qemu_mallocz(sizeof(TAPState));
630
 
    if (!s)
631
 
        return NULL;
632
 
    s->fd = fd;
633
 
    s->vc = qemu_new_vlan_client(vlan, tap_receive, NULL, s);
634
 
    qemu_set_fd_handler(s->fd, tap_send, NULL, s);
635
 
    snprintf(s->vc->info_str, sizeof(s->vc->info_str), "tap: fd=%d", fd);
636
 
    return s;
637
 
}
638
 
 
639
 
#if defined (_BSD) || defined (__FreeBSD_kernel__)
640
 
static int tap_open(char *ifname, int ifname_size)
641
 
{
642
 
    int fd;
643
 
    char *dev;
644
 
    struct stat s;
645
 
 
646
 
    TFR(fd = open("/dev/tap", O_RDWR));
647
 
    if (fd < 0) {
648
 
        fprintf(stderr, "warning: could not open /dev/tap: no virtual network emulation\n");
649
 
        return -1;
650
 
    }
651
 
 
652
 
    fstat(fd, &s);
653
 
    dev = devname(s.st_rdev, S_IFCHR);
654
 
    pstrcpy(ifname, ifname_size, dev);
655
 
 
656
 
    fcntl(fd, F_SETFL, O_NONBLOCK);
657
 
    return fd;
658
 
}
659
 
#elif defined(__sun__)
660
 
#define TUNNEWPPA       (('T'<<16) | 0x0001)
661
 
/*
662
 
 * Allocate TAP device, returns opened fd.
663
 
 * Stores dev name in the first arg(must be large enough).
664
 
 */
665
 
int tap_alloc(char *dev, size_t dev_size)
666
 
{
667
 
    int tap_fd, if_fd, ppa = -1;
668
 
    static int ip_fd = 0;
669
 
    char *ptr;
670
 
 
671
 
    static int arp_fd = 0;
672
 
    int ip_muxid, arp_muxid;
673
 
    struct strioctl  strioc_if, strioc_ppa;
674
 
    int link_type = I_PLINK;;
675
 
    struct lifreq ifr;
676
 
    char actual_name[32] = "";
677
 
 
678
 
    memset(&ifr, 0x0, sizeof(ifr));
679
 
 
680
 
    if( *dev ){
681
 
       ptr = dev;
682
 
       while( *ptr && !isdigit((int)*ptr) ) ptr++;
683
 
       ppa = atoi(ptr);
684
 
    }
685
 
 
686
 
    /* Check if IP device was opened */
687
 
    if( ip_fd )
688
 
       close(ip_fd);
689
 
 
690
 
    TFR(ip_fd = open("/dev/udp", O_RDWR, 0));
691
 
    if (ip_fd < 0) {
692
 
       syslog(LOG_ERR, "Can't open /dev/ip (actually /dev/udp)");
693
 
       return -1;
694
 
    }
695
 
 
696
 
    TFR(tap_fd = open("/dev/tap", O_RDWR, 0));
697
 
    if (tap_fd < 0) {
698
 
       syslog(LOG_ERR, "Can't open /dev/tap");
699
 
       return -1;
700
 
    }
701
 
 
702
 
    /* Assign a new PPA and get its unit number. */
703
 
    strioc_ppa.ic_cmd = TUNNEWPPA;
704
 
    strioc_ppa.ic_timout = 0;
705
 
    strioc_ppa.ic_len = sizeof(ppa);
706
 
    strioc_ppa.ic_dp = (char *)&ppa;
707
 
    if ((ppa = ioctl (tap_fd, I_STR, &strioc_ppa)) < 0)
708
 
       syslog (LOG_ERR, "Can't assign new interface");
709
 
 
710
 
    TFR(if_fd = open("/dev/tap", O_RDWR, 0));
711
 
    if (if_fd < 0) {
712
 
       syslog(LOG_ERR, "Can't open /dev/tap (2)");
713
 
       return -1;
714
 
    }
715
 
    if(ioctl(if_fd, I_PUSH, "ip") < 0){
716
 
       syslog(LOG_ERR, "Can't push IP module");
717
 
       return -1;
718
 
    }
719
 
 
720
 
    if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) < 0)
721
 
        syslog(LOG_ERR, "Can't get flags\n");
722
 
 
723
 
    snprintf (actual_name, 32, "tap%d", ppa);
724
 
    pstrcpy(ifr.lifr_name, sizeof(ifr.lifr_name), actual_name);
725
 
 
726
 
    ifr.lifr_ppa = ppa;
727
 
    /* Assign ppa according to the unit number returned by tun device */
728
 
 
729
 
    if (ioctl (if_fd, SIOCSLIFNAME, &ifr) < 0)
730
 
        syslog (LOG_ERR, "Can't set PPA %d", ppa);
731
 
    if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) <0)
732
 
        syslog (LOG_ERR, "Can't get flags\n");
733
 
    /* Push arp module to if_fd */
734
 
    if (ioctl (if_fd, I_PUSH, "arp") < 0)
735
 
        syslog (LOG_ERR, "Can't push ARP module (2)");
736
 
 
737
 
    /* Push arp module to ip_fd */
738
 
    if (ioctl (ip_fd, I_POP, NULL) < 0)
739
 
        syslog (LOG_ERR, "I_POP failed\n");
740
 
    if (ioctl (ip_fd, I_PUSH, "arp") < 0)
741
 
        syslog (LOG_ERR, "Can't push ARP module (3)\n");
742
 
    /* Open arp_fd */
743
 
    TFR(arp_fd = open ("/dev/tap", O_RDWR, 0));
744
 
    if (arp_fd < 0)
745
 
       syslog (LOG_ERR, "Can't open %s\n", "/dev/tap");
746
 
 
747
 
    /* Set ifname to arp */
748
 
    strioc_if.ic_cmd = SIOCSLIFNAME;
749
 
    strioc_if.ic_timout = 0;
750
 
    strioc_if.ic_len = sizeof(ifr);
751
 
    strioc_if.ic_dp = (char *)&ifr;
752
 
    if (ioctl(arp_fd, I_STR, &strioc_if) < 0){
753
 
        syslog (LOG_ERR, "Can't set ifname to arp\n");
754
 
    }
755
 
 
756
 
    if((ip_muxid = ioctl(ip_fd, I_LINK, if_fd)) < 0){
757
 
       syslog(LOG_ERR, "Can't link TAP device to IP");
758
 
       return -1;
759
 
    }
760
 
 
761
 
    if ((arp_muxid = ioctl (ip_fd, link_type, arp_fd)) < 0)
762
 
        syslog (LOG_ERR, "Can't link TAP device to ARP");
763
 
 
764
 
    close (if_fd);
765
 
 
766
 
    memset(&ifr, 0x0, sizeof(ifr));
767
 
    pstrcpy(ifr.lifr_name, sizeof(ifr.lifr_name), actual_name);
768
 
    ifr.lifr_ip_muxid  = ip_muxid;
769
 
    ifr.lifr_arp_muxid = arp_muxid;
770
 
 
771
 
    if (ioctl (ip_fd, SIOCSLIFMUXID, &ifr) < 0)
772
 
    {
773
 
      ioctl (ip_fd, I_PUNLINK , arp_muxid);
774
 
      ioctl (ip_fd, I_PUNLINK, ip_muxid);
775
 
      syslog (LOG_ERR, "Can't set multiplexor id");
776
 
    }
777
 
 
778
 
    snprintf(dev, dev_size, "tap%d", ppa);
779
 
    return tap_fd;
780
 
}
781
 
 
782
 
static int tap_open(char *ifname, int ifname_size)
783
 
{
784
 
    char  dev[10]="";
785
 
    int fd;
786
 
    if( (fd = tap_alloc(dev, sizeof(dev))) < 0 ){
787
 
       fprintf(stderr, "Cannot allocate TAP device\n");
788
 
       return -1;
789
 
    }
790
 
    pstrcpy(ifname, ifname_size, dev);
791
 
    fcntl(fd, F_SETFL, O_NONBLOCK);
792
 
    return fd;
793
 
}
794
 
#else
795
 
static int tap_open(char *ifname, int ifname_size)
796
 
{
797
 
    struct ifreq ifr;
798
 
    int fd, ret;
799
 
 
800
 
    TFR(fd = open("/dev/net/tun", O_RDWR));
801
 
    if (fd < 0) {
802
 
        fprintf(stderr, "warning: could not open /dev/net/tun: no virtual network emulation\n");
803
 
        return -1;
804
 
    }
805
 
    memset(&ifr, 0, sizeof(ifr));
806
 
    ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
807
 
    if (ifname[0] != '\0')
808
 
        pstrcpy(ifr.ifr_name, IFNAMSIZ, ifname);
809
 
    else
810
 
        pstrcpy(ifr.ifr_name, IFNAMSIZ, "tap%d");
811
 
    ret = ioctl(fd, TUNSETIFF, (void *) &ifr);
812
 
    if (ret != 0) {
813
 
        fprintf(stderr, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
814
 
        close(fd);
815
 
        return -1;
816
 
    }
817
 
    pstrcpy(ifname, ifname_size, ifr.ifr_name);
818
 
    fcntl(fd, F_SETFL, O_NONBLOCK);
819
 
    return fd;
820
 
}
821
 
#endif
822
 
 
823
 
static int launch_script(const char *setup_script, const char *ifname, int fd)
824
 
{
825
 
    int pid, status;
826
 
    char *args[3];
827
 
    char **parg;
828
 
 
829
 
        /* try to launch network script */
830
 
        pid = fork();
831
 
        if (pid >= 0) {
832
 
            if (pid == 0) {
833
 
                int open_max = sysconf (_SC_OPEN_MAX), i;
834
 
                for (i = 0; i < open_max; i++)
835
 
                    if (i != STDIN_FILENO &&
836
 
                        i != STDOUT_FILENO &&
837
 
                        i != STDERR_FILENO &&
838
 
                        i != fd)
839
 
                        close(i);
840
 
 
841
 
                parg = args;
842
 
                *parg++ = (char *)setup_script;
843
 
                *parg++ = (char *)ifname;
844
 
                *parg++ = NULL;
845
 
                execv(setup_script, args);
846
 
                _exit(1);
847
 
            }
848
 
            while (waitpid(pid, &status, 0) != pid);
849
 
            if (!WIFEXITED(status) ||
850
 
                WEXITSTATUS(status) != 0) {
851
 
                fprintf(stderr, "%s: could not launch network script\n",
852
 
                        setup_script);
853
 
                return -1;
854
 
            }
855
 
        }
856
 
    return 0;
857
 
}
858
 
 
859
 
static int net_tap_init(VLANState *vlan, const char *ifname1,
860
 
                        const char *setup_script, const char *down_script)
861
 
{
862
 
    TAPState *s;
863
 
    int fd;
864
 
    char ifname[128];
865
 
 
866
 
    if (ifname1 != NULL)
867
 
        pstrcpy(ifname, sizeof(ifname), ifname1);
868
 
    else
869
 
        ifname[0] = '\0';
870
 
    TFR(fd = tap_open(ifname, sizeof(ifname)));
871
 
    if (fd < 0)
872
 
        return -1;
873
 
 
874
 
    if (!setup_script || !strcmp(setup_script, "no"))
875
 
        setup_script = "";
876
 
    if (setup_script[0] != '\0') {
877
 
        if (launch_script(setup_script, ifname, fd))
878
 
            return -1;
879
 
    }
880
 
    s = net_tap_fd_init(vlan, fd);
881
 
    if (!s)
882
 
        return -1;
883
 
    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
884
 
             "tap: ifname=%s setup_script=%s", ifname, setup_script);
885
 
    if (down_script && strcmp(down_script, "no"))
886
 
        snprintf(s->down_script, sizeof(s->down_script), "%s", down_script);
887
 
    return 0;
888
 
}
889
 
 
890
 
#endif /* !_WIN32 */
891
 
 
892
 
#if defined(CONFIG_VDE)
893
 
typedef struct VDEState {
894
 
    VLANClientState *vc;
895
 
    VDECONN *vde;
896
 
} VDEState;
897
 
 
898
 
static void vde_to_qemu(void *opaque)
899
 
{
900
 
    VDEState *s = opaque;
901
 
    uint8_t buf[4096];
902
 
    int size;
903
 
 
904
 
    size = vde_recv(s->vde, buf, sizeof(buf), 0);
905
 
    if (size > 0) {
906
 
        qemu_send_packet(s->vc, buf, size);
907
 
    }
908
 
}
909
 
 
910
 
static void vde_from_qemu(void *opaque, const uint8_t *buf, int size)
911
 
{
912
 
    VDEState *s = opaque;
913
 
    int ret;
914
 
    for(;;) {
915
 
        ret = vde_send(s->vde, buf, size, 0);
916
 
        if (ret < 0 && errno == EINTR) {
917
 
        } else {
918
 
            break;
919
 
        }
920
 
    }
921
 
}
922
 
 
923
 
static int net_vde_init(VLANState *vlan, const char *sock, int port,
924
 
                        const char *group, int mode)
925
 
{
926
 
    VDEState *s;
927
 
    char *init_group = strlen(group) ? (char *)group : NULL;
928
 
    char *init_sock = strlen(sock) ? (char *)sock : NULL;
929
 
 
930
 
    struct vde_open_args args = {
931
 
        .port = port,
932
 
        .group = init_group,
933
 
        .mode = mode,
934
 
    };
935
 
 
936
 
    s = qemu_mallocz(sizeof(VDEState));
937
 
    if (!s)
938
 
        return -1;
939
 
    s->vde = vde_open(init_sock, "QEMU", &args);
940
 
    if (!s->vde){
941
 
        free(s);
942
 
        return -1;
943
 
    }
944
 
    s->vc = qemu_new_vlan_client(vlan, vde_from_qemu, NULL, s);
945
 
    qemu_set_fd_handler(vde_datafd(s->vde), vde_to_qemu, NULL, s);
946
 
    snprintf(s->vc->info_str, sizeof(s->vc->info_str), "vde: sock=%s fd=%d",
947
 
             sock, vde_datafd(s->vde));
948
 
    return 0;
949
 
}
950
 
#endif
951
 
 
952
 
/* network connection */
953
 
typedef struct NetSocketState {
954
 
    VLANClientState *vc;
955
 
    int fd;
956
 
    int state; /* 0 = getting length, 1 = getting data */
957
 
    int index;
958
 
    int packet_len;
959
 
    uint8_t buf[4096];
960
 
    struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
961
 
} NetSocketState;
962
 
 
963
 
typedef struct NetSocketListenState {
964
 
    VLANState *vlan;
965
 
    int fd;
966
 
} NetSocketListenState;
967
 
 
968
 
/* XXX: we consider we can send the whole packet without blocking */
969
 
static void net_socket_receive(void *opaque, const uint8_t *buf, int size)
970
 
{
971
 
    NetSocketState *s = opaque;
972
 
    uint32_t len;
973
 
    len = htonl(size);
974
 
 
975
 
    send_all(s->fd, (const uint8_t *)&len, sizeof(len));
976
 
    send_all(s->fd, buf, size);
977
 
}
978
 
 
979
 
static void net_socket_receive_dgram(void *opaque, const uint8_t *buf, int size)
980
 
{
981
 
    NetSocketState *s = opaque;
982
 
    sendto(s->fd, buf, size, 0,
983
 
           (struct sockaddr *)&s->dgram_dst, sizeof(s->dgram_dst));
984
 
}
985
 
 
986
 
static void net_socket_send(void *opaque)
987
 
{
988
 
    NetSocketState *s = opaque;
989
 
    int l, size, err;
990
 
    uint8_t buf1[4096];
991
 
    const uint8_t *buf;
992
 
 
993
 
    size = recv(s->fd, buf1, sizeof(buf1), 0);
994
 
    if (size < 0) {
995
 
        err = socket_error();
996
 
        if (err != EWOULDBLOCK)
997
 
            goto eoc;
998
 
    } else if (size == 0) {
999
 
        /* end of connection */
1000
 
    eoc:
1001
 
        qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
1002
 
        closesocket(s->fd);
1003
 
        return;
1004
 
    }
1005
 
    buf = buf1;
1006
 
    while (size > 0) {
1007
 
        /* reassemble a packet from the network */
1008
 
        switch(s->state) {
1009
 
        case 0:
1010
 
            l = 4 - s->index;
1011
 
            if (l > size)
1012
 
                l = size;
1013
 
            memcpy(s->buf + s->index, buf, l);
1014
 
            buf += l;
1015
 
            size -= l;
1016
 
            s->index += l;
1017
 
            if (s->index == 4) {
1018
 
                /* got length */
1019
 
                s->packet_len = ntohl(*(uint32_t *)s->buf);
1020
 
                s->index = 0;
1021
 
                s->state = 1;
1022
 
            }
1023
 
            break;
1024
 
        case 1:
1025
 
            l = s->packet_len - s->index;
1026
 
            if (l > size)
1027
 
                l = size;
1028
 
            memcpy(s->buf + s->index, buf, l);
1029
 
            s->index += l;
1030
 
            buf += l;
1031
 
            size -= l;
1032
 
            if (s->index >= s->packet_len) {
1033
 
                qemu_send_packet(s->vc, s->buf, s->packet_len);
1034
 
                s->index = 0;
1035
 
                s->state = 0;
1036
 
            }
1037
 
            break;
1038
 
        }
1039
 
    }
1040
 
}
1041
 
 
1042
 
static void net_socket_send_dgram(void *opaque)
1043
 
{
1044
 
    NetSocketState *s = opaque;
1045
 
    int size;
1046
 
 
1047
 
    size = recv(s->fd, s->buf, sizeof(s->buf), 0);
1048
 
    if (size < 0)
1049
 
        return;
1050
 
    if (size == 0) {
1051
 
        /* end of connection */
1052
 
        qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
1053
 
        return;
1054
 
    }
1055
 
    qemu_send_packet(s->vc, s->buf, size);
1056
 
}
1057
 
 
1058
 
static int net_socket_mcast_create(struct sockaddr_in *mcastaddr)
1059
 
{
1060
 
    struct ip_mreq imr;
1061
 
    int fd;
1062
 
    int val, ret;
1063
 
    if (!IN_MULTICAST(ntohl(mcastaddr->sin_addr.s_addr))) {
1064
 
        fprintf(stderr, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
1065
 
                inet_ntoa(mcastaddr->sin_addr),
1066
 
                (int)ntohl(mcastaddr->sin_addr.s_addr));
1067
 
        return -1;
1068
 
 
1069
 
    }
1070
 
    fd = socket(PF_INET, SOCK_DGRAM, 0);
1071
 
    if (fd < 0) {
1072
 
        perror("socket(PF_INET, SOCK_DGRAM)");
1073
 
        return -1;
1074
 
    }
1075
 
 
1076
 
    val = 1;
1077
 
    ret=setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
1078
 
                   (const char *)&val, sizeof(val));
1079
 
    if (ret < 0) {
1080
 
        perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
1081
 
        goto fail;
1082
 
    }
1083
 
 
1084
 
    ret = bind(fd, (struct sockaddr *)mcastaddr, sizeof(*mcastaddr));
1085
 
    if (ret < 0) {
1086
 
        perror("bind");
1087
 
        goto fail;
1088
 
    }
1089
 
 
1090
 
    /* Add host to multicast group */
1091
 
    imr.imr_multiaddr = mcastaddr->sin_addr;
1092
 
    imr.imr_interface.s_addr = htonl(INADDR_ANY);
1093
 
 
1094
 
    ret = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
1095
 
                     (const char *)&imr, sizeof(struct ip_mreq));
1096
 
    if (ret < 0) {
1097
 
        perror("setsockopt(IP_ADD_MEMBERSHIP)");
1098
 
        goto fail;
1099
 
    }
1100
 
 
1101
 
    /* Force mcast msgs to loopback (eg. several QEMUs in same host */
1102
 
    val = 1;
1103
 
    ret=setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
1104
 
                   (const char *)&val, sizeof(val));
1105
 
    if (ret < 0) {
1106
 
        perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
1107
 
        goto fail;
1108
 
    }
1109
 
 
1110
 
    socket_set_nonblock(fd);
1111
 
    return fd;
1112
 
fail:
1113
 
    if (fd >= 0)
1114
 
        closesocket(fd);
1115
 
    return -1;
1116
 
}
1117
 
 
1118
 
static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan, int fd,
1119
 
                                          int is_connected)
1120
 
{
1121
 
    struct sockaddr_in saddr;
1122
 
    int newfd;
1123
 
    socklen_t saddr_len;
1124
 
    NetSocketState *s;
1125
 
 
1126
 
    /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
1127
 
     * Because this may be "shared" socket from a "master" process, datagrams would be recv()
1128
 
     * by ONLY ONE process: we must "clone" this dgram socket --jjo
1129
 
     */
1130
 
 
1131
 
    if (is_connected) {
1132
 
        if (getsockname(fd, (struct sockaddr *) &saddr, &saddr_len) == 0) {
1133
 
            /* must be bound */
1134
 
            if (saddr.sin_addr.s_addr==0) {
1135
 
                fprintf(stderr, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
1136
 
                        fd);
1137
 
                return NULL;
1138
 
            }
1139
 
            /* clone dgram socket */
1140
 
            newfd = net_socket_mcast_create(&saddr);
1141
 
            if (newfd < 0) {
1142
 
                /* error already reported by net_socket_mcast_create() */
1143
 
                close(fd);
1144
 
                return NULL;
1145
 
            }
1146
 
            /* clone newfd to fd, close newfd */
1147
 
            dup2(newfd, fd);
1148
 
            close(newfd);
1149
 
 
1150
 
        } else {
1151
 
            fprintf(stderr, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
1152
 
                    fd, strerror(errno));
1153
 
            return NULL;
1154
 
        }
1155
 
    }
1156
 
 
1157
 
    s = qemu_mallocz(sizeof(NetSocketState));
1158
 
    if (!s)
1159
 
        return NULL;
1160
 
    s->fd = fd;
1161
 
 
1162
 
    s->vc = qemu_new_vlan_client(vlan, net_socket_receive_dgram, NULL, s);
1163
 
    qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s);
1164
 
 
1165
 
    /* mcast: save bound address as dst */
1166
 
    if (is_connected) s->dgram_dst=saddr;
1167
 
 
1168
 
    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
1169
 
            "socket: fd=%d (%s mcast=%s:%d)",
1170
 
            fd, is_connected? "cloned" : "",
1171
 
            inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
1172
 
    return s;
1173
 
}
1174
 
 
1175
 
static void net_socket_connect(void *opaque)
1176
 
{
1177
 
    NetSocketState *s = opaque;
1178
 
    qemu_set_fd_handler(s->fd, net_socket_send, NULL, s);
1179
 
}
1180
 
 
1181
 
static NetSocketState *net_socket_fd_init_stream(VLANState *vlan, int fd,
1182
 
                                          int is_connected)
1183
 
{
1184
 
    NetSocketState *s;
1185
 
    s = qemu_mallocz(sizeof(NetSocketState));
1186
 
    if (!s)
1187
 
        return NULL;
1188
 
    s->fd = fd;
1189
 
    s->vc = qemu_new_vlan_client(vlan,
1190
 
                                 net_socket_receive, NULL, s);
1191
 
    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
1192
 
             "socket: fd=%d", fd);
1193
 
    if (is_connected) {
1194
 
        net_socket_connect(s);
1195
 
    } else {
1196
 
        qemu_set_fd_handler(s->fd, NULL, net_socket_connect, s);
1197
 
    }
1198
 
    return s;
1199
 
}
1200
 
 
1201
 
static NetSocketState *net_socket_fd_init(VLANState *vlan, int fd,
1202
 
                                          int is_connected)
1203
 
{
1204
 
    int so_type=-1, optlen=sizeof(so_type);
1205
 
 
1206
 
    if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type,
1207
 
        (socklen_t *)&optlen)< 0) {
1208
 
        fprintf(stderr, "qemu: error: getsockopt(SO_TYPE) for fd=%d failed\n", fd);
1209
 
        return NULL;
1210
 
    }
1211
 
    switch(so_type) {
1212
 
    case SOCK_DGRAM:
1213
 
        return net_socket_fd_init_dgram(vlan, fd, is_connected);
1214
 
    case SOCK_STREAM:
1215
 
        return net_socket_fd_init_stream(vlan, fd, is_connected);
1216
 
    default:
1217
 
        /* who knows ... this could be a eg. a pty, do warn and continue as stream */
1218
 
        fprintf(stderr, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type, fd);
1219
 
        return net_socket_fd_init_stream(vlan, fd, is_connected);
1220
 
    }
1221
 
    return NULL;
1222
 
}
1223
 
 
1224
 
static void net_socket_accept(void *opaque)
1225
 
{
1226
 
    NetSocketListenState *s = opaque;
1227
 
    NetSocketState *s1;
1228
 
    struct sockaddr_in saddr;
1229
 
    socklen_t len;
1230
 
    int fd;
1231
 
 
1232
 
    for(;;) {
1233
 
        len = sizeof(saddr);
1234
 
        fd = accept(s->fd, (struct sockaddr *)&saddr, &len);
1235
 
        if (fd < 0 && errno != EINTR) {
1236
 
            return;
1237
 
        } else if (fd >= 0) {
1238
 
            break;
1239
 
        }
1240
 
    }
1241
 
    s1 = net_socket_fd_init(s->vlan, fd, 1);
1242
 
    if (!s1) {
1243
 
        closesocket(fd);
1244
 
    } else {
1245
 
        snprintf(s1->vc->info_str, sizeof(s1->vc->info_str),
1246
 
                 "socket: connection from %s:%d",
1247
 
                 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
1248
 
    }
1249
 
}
1250
 
 
1251
 
static int net_socket_listen_init(VLANState *vlan, const char *host_str)
1252
 
{
1253
 
    NetSocketListenState *s;
1254
 
    int fd, val, ret;
1255
 
    struct sockaddr_in saddr;
1256
 
 
1257
 
    if (parse_host_port(&saddr, host_str) < 0)
1258
 
        return -1;
1259
 
 
1260
 
    s = qemu_mallocz(sizeof(NetSocketListenState));
1261
 
    if (!s)
1262
 
        return -1;
1263
 
 
1264
 
    fd = socket(PF_INET, SOCK_STREAM, 0);
1265
 
    if (fd < 0) {
1266
 
        perror("socket");
1267
 
        return -1;
1268
 
    }
1269
 
    socket_set_nonblock(fd);
1270
 
 
1271
 
    /* allow fast reuse */
1272
 
    val = 1;
1273
 
    setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
1274
 
 
1275
 
    ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
1276
 
    if (ret < 0) {
1277
 
        perror("bind");
1278
 
        return -1;
1279
 
    }
1280
 
    ret = listen(fd, 0);
1281
 
    if (ret < 0) {
1282
 
        perror("listen");
1283
 
        return -1;
1284
 
    }
1285
 
    s->vlan = vlan;
1286
 
    s->fd = fd;
1287
 
    qemu_set_fd_handler(fd, net_socket_accept, NULL, s);
1288
 
    return 0;
1289
 
}
1290
 
 
1291
 
static int net_socket_connect_init(VLANState *vlan, const char *host_str)
1292
 
{
1293
 
    NetSocketState *s;
1294
 
    int fd, connected, ret, err;
1295
 
    struct sockaddr_in saddr;
1296
 
 
1297
 
    if (parse_host_port(&saddr, host_str) < 0)
1298
 
        return -1;
1299
 
 
1300
 
    fd = socket(PF_INET, SOCK_STREAM, 0);
1301
 
    if (fd < 0) {
1302
 
        perror("socket");
1303
 
        return -1;
1304
 
    }
1305
 
    socket_set_nonblock(fd);
1306
 
 
1307
 
    connected = 0;
1308
 
    for(;;) {
1309
 
        ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
1310
 
        if (ret < 0) {
1311
 
            err = socket_error();
1312
 
            if (err == EINTR || err == EWOULDBLOCK) {
1313
 
            } else if (err == EINPROGRESS) {
1314
 
                break;
1315
 
#ifdef _WIN32
1316
 
            } else if (err == WSAEALREADY) {
1317
 
                break;
1318
 
#endif
1319
 
            } else {
1320
 
                perror("connect");
1321
 
                closesocket(fd);
1322
 
                return -1;
1323
 
            }
1324
 
        } else {
1325
 
            connected = 1;
1326
 
            break;
1327
 
        }
1328
 
    }
1329
 
    s = net_socket_fd_init(vlan, fd, connected);
1330
 
    if (!s)
1331
 
        return -1;
1332
 
    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
1333
 
             "socket: connect to %s:%d",
1334
 
             inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
1335
 
    return 0;
1336
 
}
1337
 
 
1338
 
static int net_socket_mcast_init(VLANState *vlan, const char *host_str)
1339
 
{
1340
 
    NetSocketState *s;
1341
 
    int fd;
1342
 
    struct sockaddr_in saddr;
1343
 
 
1344
 
    if (parse_host_port(&saddr, host_str) < 0)
1345
 
        return -1;
1346
 
 
1347
 
 
1348
 
    fd = net_socket_mcast_create(&saddr);
1349
 
    if (fd < 0)
1350
 
        return -1;
1351
 
 
1352
 
    s = net_socket_fd_init(vlan, fd, 0);
1353
 
    if (!s)
1354
 
        return -1;
1355
 
 
1356
 
    s->dgram_dst = saddr;
1357
 
 
1358
 
    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
1359
 
             "socket: mcast=%s:%d",
1360
 
             inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
1361
 
    return 0;
1362
 
 
1363
 
}
1364
 
 
1365
 
/* find or alloc a new VLAN */
1366
 
VLANState *qemu_find_vlan(int id)
1367
 
{
1368
 
    VLANState **pvlan, *vlan;
1369
 
    for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
1370
 
        if (vlan->id == id)
1371
 
            return vlan;
1372
 
    }
1373
 
    vlan = qemu_mallocz(sizeof(VLANState));
1374
 
    if (!vlan)
1375
 
        return NULL;
1376
 
    vlan->id = id;
1377
 
    vlan->next = NULL;
1378
 
    pvlan = &first_vlan;
1379
 
    while (*pvlan != NULL)
1380
 
        pvlan = &(*pvlan)->next;
1381
 
    *pvlan = vlan;
1382
 
    return vlan;
1383
 
}
1384
 
 
1385
 
int net_client_init(const char *device, const char *p)
1386
 
{
1387
 
    char buf[1024];
1388
 
    int vlan_id, ret;
1389
 
    VLANState *vlan;
1390
 
 
1391
 
    vlan_id = 0;
1392
 
    if (get_param_value(buf, sizeof(buf), "vlan", p)) {
1393
 
        vlan_id = strtol(buf, NULL, 0);
1394
 
    }
1395
 
    vlan = qemu_find_vlan(vlan_id);
1396
 
    if (!vlan) {
1397
 
        fprintf(stderr, "Could not create vlan %d\n", vlan_id);
1398
 
        return -1;
1399
 
    }
1400
 
    if (!strcmp(device, "nic")) {
1401
 
        NICInfo *nd;
1402
 
        uint8_t *macaddr;
1403
 
 
1404
 
        if (nb_nics >= MAX_NICS) {
1405
 
            fprintf(stderr, "Too Many NICs\n");
1406
 
            return -1;
1407
 
        }
1408
 
        nd = &nd_table[nb_nics];
1409
 
        macaddr = nd->macaddr;
1410
 
        macaddr[0] = 0x52;
1411
 
        macaddr[1] = 0x54;
1412
 
        macaddr[2] = 0x00;
1413
 
        macaddr[3] = 0x12;
1414
 
        macaddr[4] = 0x34;
1415
 
        macaddr[5] = 0x56 + nb_nics;
1416
 
 
1417
 
        if (get_param_value(buf, sizeof(buf), "macaddr", p)) {
1418
 
            if (parse_macaddr(macaddr, buf) < 0) {
1419
 
                fprintf(stderr, "invalid syntax for ethernet address\n");
1420
 
                return -1;
1421
 
            }
1422
 
        }
1423
 
        if (get_param_value(buf, sizeof(buf), "model", p)) {
1424
 
            nd->model = strdup(buf);
1425
 
        }
1426
 
        nd->vlan = vlan;
1427
 
        nb_nics++;
1428
 
        vlan->nb_guest_devs++;
1429
 
        ret = 0;
1430
 
    } else
1431
 
    if (!strcmp(device, "none")) {
1432
 
        /* does nothing. It is needed to signal that no network cards
1433
 
           are wanted */
1434
 
        ret = 0;
1435
 
    } else
1436
 
#ifdef CONFIG_SLIRP
1437
 
    if (!strcmp(device, "user")) {
1438
 
        if (get_param_value(buf, sizeof(buf), "hostname", p)) {
1439
 
            pstrcpy(slirp_hostname, sizeof(slirp_hostname), buf);
1440
 
        }
1441
 
        vlan->nb_host_devs++;
1442
 
        ret = net_slirp_init(vlan);
1443
 
    } else
1444
 
#endif
1445
 
#ifdef _WIN32
1446
 
    if (!strcmp(device, "tap")) {
1447
 
        char ifname[64];
1448
 
        if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
1449
 
            fprintf(stderr, "tap: no interface name\n");
1450
 
            return -1;
1451
 
        }
1452
 
        vlan->nb_host_devs++;
1453
 
        ret = tap_win32_init(vlan, ifname);
1454
 
    } else
1455
 
#else
1456
 
    if (!strcmp(device, "tap")) {
1457
 
        char ifname[64];
1458
 
        char setup_script[1024], down_script[1024];
1459
 
        int fd;
1460
 
        vlan->nb_host_devs++;
1461
 
        if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
1462
 
            fd = strtol(buf, NULL, 0);
1463
 
            fcntl(fd, F_SETFL, O_NONBLOCK);
1464
 
            ret = -1;
1465
 
            if (net_tap_fd_init(vlan, fd))
1466
 
                ret = 0;
1467
 
        } else {
1468
 
            if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
1469
 
                ifname[0] = '\0';
1470
 
            }
1471
 
            if (get_param_value(setup_script, sizeof(setup_script), "script", p) == 0) {
1472
 
                pstrcpy(setup_script, sizeof(setup_script), DEFAULT_NETWORK_SCRIPT);
1473
 
            }
1474
 
            if (get_param_value(down_script, sizeof(down_script), "downscript", p) == 0) {
1475
 
                pstrcpy(down_script, sizeof(down_script), DEFAULT_NETWORK_DOWN_SCRIPT);
1476
 
            }
1477
 
            ret = net_tap_init(vlan, ifname, setup_script, down_script);
1478
 
        }
1479
 
    } else
1480
 
#endif
1481
 
    if (!strcmp(device, "socket")) {
1482
 
        if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
1483
 
            int fd;
1484
 
            fd = strtol(buf, NULL, 0);
1485
 
            ret = -1;
1486
 
            if (net_socket_fd_init(vlan, fd, 1))
1487
 
                ret = 0;
1488
 
        } else if (get_param_value(buf, sizeof(buf), "listen", p) > 0) {
1489
 
            ret = net_socket_listen_init(vlan, buf);
1490
 
        } else if (get_param_value(buf, sizeof(buf), "connect", p) > 0) {
1491
 
            ret = net_socket_connect_init(vlan, buf);
1492
 
        } else if (get_param_value(buf, sizeof(buf), "mcast", p) > 0) {
1493
 
            ret = net_socket_mcast_init(vlan, buf);
1494
 
        } else {
1495
 
            fprintf(stderr, "Unknown socket options: %s\n", p);
1496
 
            return -1;
1497
 
        }
1498
 
        vlan->nb_host_devs++;
1499
 
    } else
1500
 
#ifdef CONFIG_VDE
1501
 
    if (!strcmp(device, "vde")) {
1502
 
        char vde_sock[1024], vde_group[512];
1503
 
        int vde_port, vde_mode;
1504
 
        vlan->nb_host_devs++;
1505
 
        if (get_param_value(vde_sock, sizeof(vde_sock), "sock", p) <= 0) {
1506
 
            vde_sock[0] = '\0';
1507
 
        }
1508
 
        if (get_param_value(buf, sizeof(buf), "port", p) > 0) {
1509
 
            vde_port = strtol(buf, NULL, 10);
1510
 
        } else {
1511
 
            vde_port = 0;
1512
 
        }
1513
 
        if (get_param_value(vde_group, sizeof(vde_group), "group", p) <= 0) {
1514
 
            vde_group[0] = '\0';
1515
 
        }
1516
 
        if (get_param_value(buf, sizeof(buf), "mode", p) > 0) {
1517
 
            vde_mode = strtol(buf, NULL, 8);
1518
 
        } else {
1519
 
            vde_mode = 0700;
1520
 
        }
1521
 
        ret = net_vde_init(vlan, vde_sock, vde_port, vde_group, vde_mode);
1522
 
    } else
1523
 
#endif
1524
 
    {
1525
 
        fprintf(stderr, "Unknown network device: %s\n", device);
1526
 
        return -1;
1527
 
    }
1528
 
    if (ret < 0) {
1529
 
        fprintf(stderr, "Could not initialize device '%s'\n", device);
1530
 
    }
1531
 
 
1532
 
    return ret;
1533
 
}
1534
 
 
1535
 
int net_client_parse(const char *str)
1536
 
{
1537
 
    const char *p;
1538
 
    char *q;
1539
 
    char device[64];
1540
 
 
1541
 
    p = str;
1542
 
    q = device;
1543
 
    while (*p != '\0' && *p != ',') {
1544
 
        if ((q - device) < sizeof(device) - 1)
1545
 
            *q++ = *p;
1546
 
        p++;
1547
 
    }
1548
 
    *q = '\0';
1549
 
    if (*p == ',')
1550
 
        p++;
1551
 
 
1552
 
    return net_client_init(device, p);
1553
 
}
1554
 
 
1555
 
void do_info_network(void)
1556
 
{
1557
 
    VLANState *vlan;
1558
 
    VLANClientState *vc;
1559
 
 
1560
 
    for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
1561
 
        term_printf("VLAN %d devices:\n", vlan->id);
1562
 
        for(vc = vlan->first_client; vc != NULL; vc = vc->next)
1563
 
            term_printf("  %s\n", vc->info_str);
1564
 
    }
1565
 
}
1566
 
 
1567
 
void net_cleanup(void)
1568
 
{
1569
 
    VLANState *vlan;
1570
 
 
1571
 
#if !defined(_WIN32)
1572
 
    /* close network clients */
1573
 
    for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
1574
 
        VLANClientState *vc;
1575
 
 
1576
 
        for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
1577
 
            if (vc->fd_read == tap_receive) {
1578
 
                char ifname[64];
1579
 
                TAPState *s = vc->opaque;
1580
 
 
1581
 
                if (sscanf(vc->info_str, "tap: ifname=%63s ", ifname) == 1 &&
1582
 
                    s->down_script[0])
1583
 
                    launch_script(s->down_script, ifname, s->fd);
1584
 
            }
1585
 
#if defined(CONFIG_VDE)
1586
 
            if (vc->fd_read == vde_from_qemu) {
1587
 
                VDEState *s = vc->opaque;
1588
 
                vde_close(s->vde);
1589
 
            }
1590
 
#endif
1591
 
        }
1592
 
    }
1593
 
#endif
1594
 
}
1595
 
 
1596
 
void net_client_check(void)
1597
 
{
1598
 
    VLANState *vlan;
1599
 
 
1600
 
    for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
1601
 
        if (vlan->nb_guest_devs == 0 && vlan->nb_host_devs == 0)
1602
 
            continue;
1603
 
        if (vlan->nb_guest_devs == 0)
1604
 
            fprintf(stderr, "Warning: vlan %d with no nics\n", vlan->id);
1605
 
        if (vlan->nb_host_devs == 0)
1606
 
            fprintf(stderr,
1607
 
                    "Warning: vlan %d is not connected to host network\n",
1608
 
                    vlan->id);
1609
 
    }
1610
 
}