Statistics
| Branch: | Revision:

root / net.c @ 7cb7434b

History | View | Annotate | Download (43.3 kB)

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 "qemu-common.h"
25
#include "net.h"
26
#include "console.h"
27
#include "sysemu.h"
28
#include "qemu-timer.h"
29
#include "qemu-char.h"
30
#include "audio/audio.h"
31

    
32
#include <unistd.h>
33
#include <fcntl.h>
34
#include <signal.h>
35
#include <time.h>
36
#include <errno.h>
37
#include <sys/time.h>
38
#include <zlib.h>
39

    
40
#ifndef _WIN32
41
#include <sys/times.h>
42
#include <sys/wait.h>
43
#include <termios.h>
44
#include <sys/mman.h>
45
#include <sys/ioctl.h>
46
#include <sys/resource.h>
47
#include <sys/socket.h>
48
#include <netinet/in.h>
49
#include <net/if.h>
50
#ifdef __NetBSD__
51
#include <net/if_tap.h>
52
#endif
53
#ifdef __linux__
54
#include <linux/if_tun.h>
55
#endif
56
#include <arpa/inet.h>
57
#include <dirent.h>
58
#include <netdb.h>
59
#include <sys/select.h>
60
#ifdef _BSD
61
#include <sys/stat.h>
62
#ifdef __FreeBSD__
63
#include <libutil.h>
64
#else
65
#include <util.h>
66
#endif
67
#elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
68
#include <freebsd/stdlib.h>
69
#else
70
#ifdef __linux__
71
#include <pty.h>
72
#include <malloc.h>
73
#include <linux/rtc.h>
74

    
75
/* For the benefit of older linux systems which don't supply it,
76
   we use a local copy of hpet.h. */
77
/* #include <linux/hpet.h> */
78
#include "hpet.h"
79

    
80
#include <linux/ppdev.h>
81
#include <linux/parport.h>
82
#endif
83
#ifdef __sun__
84
#include <sys/stat.h>
85
#include <sys/ethernet.h>
86
#include <sys/sockio.h>
87
#include <netinet/arp.h>
88
#include <netinet/in.h>
89
#include <netinet/in_systm.h>
90
#include <netinet/ip.h>
91
#include <netinet/ip_icmp.h> // must come after ip.h
92
#include <netinet/udp.h>
93
#include <netinet/tcp.h>
94
#include <net/if.h>
95
#include <syslog.h>
96
#include <stropts.h>
97
#endif
98
#endif
99
#endif
100

    
101
#include "qemu_socket.h"
102

    
103
#if defined(CONFIG_SLIRP)
104
#include "libslirp.h"
105
#endif
106

    
107
#if defined(__OpenBSD__)
108
#include <util.h>
109
#endif
110

    
111
#if defined(CONFIG_VDE)
112
#include <libvdeplug.h>
113
#endif
114

    
115
#ifdef _WIN32
116
#include <malloc.h>
117
#include <sys/timeb.h>
118
#include <mmsystem.h>
119
#define getopt_long_only getopt_long
120
#define memalign(align, size) malloc(size)
121
#endif
122

    
123
static VLANState *first_vlan;
124

    
125
/***********************************************************/
126
/* network device redirectors */
127

    
128
#if defined(DEBUG_NET) || defined(DEBUG_SLIRP)
129
static void hex_dump(FILE *f, const uint8_t *buf, int size)
130
{
131
    int len, i, j, c;
132

    
133
    for(i=0;i<size;i+=16) {
134
        len = size - i;
135
        if (len > 16)
136
            len = 16;
137
        fprintf(f, "%08x ", i);
138
        for(j=0;j<16;j++) {
139
            if (j < len)
140
                fprintf(f, " %02x", buf[i+j]);
141
            else
142
                fprintf(f, "   ");
143
        }
144
        fprintf(f, " ");
145
        for(j=0;j<len;j++) {
146
            c = buf[i+j];
147
            if (c < ' ' || c > '~')
148
                c = '.';
149
            fprintf(f, "%c", c);
150
        }
151
        fprintf(f, "\n");
152
    }
153
}
154
#endif
155

    
156
static int parse_macaddr(uint8_t *macaddr, const char *p)
157
{
158
    int i;
159
    char *last_char;
160
    long int offset;
161

    
162
    errno = 0;
163
    offset = strtol(p, &last_char, 0);    
164
    if (0 == errno && '\0' == *last_char &&
165
            offset >= 0 && offset <= 0xFFFFFF) {
166
        macaddr[3] = (offset & 0xFF0000) >> 16;
167
        macaddr[4] = (offset & 0xFF00) >> 8;
168
        macaddr[5] = offset & 0xFF;
169
        return 0;
170
    } else {
171
        for(i = 0; i < 6; i++) {
172
            macaddr[i] = strtol(p, (char **)&p, 16);
173
            if (i == 5) {
174
                if (*p != '\0')
175
                    return -1;
176
            } else {
177
                if (*p != ':' && *p != '-')
178
                    return -1;
179
                p++;
180
            }
181
        }
182
        return 0;    
183
    }
184

    
185
    return -1;
186
}
187

    
188
static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
189
{
190
    const char *p, *p1;
191
    int len;
192
    p = *pp;
193
    p1 = strchr(p, sep);
194
    if (!p1)
195
        return -1;
196
    len = p1 - p;
197
    p1++;
198
    if (buf_size > 0) {
199
        if (len > buf_size - 1)
200
            len = buf_size - 1;
201
        memcpy(buf, p, len);
202
        buf[len] = '\0';
203
    }
204
    *pp = p1;
205
    return 0;
206
}
207

    
208
int parse_host_src_port(struct sockaddr_in *haddr,
209
                        struct sockaddr_in *saddr,
210
                        const char *input_str)
211
{
212
    char *str = strdup(input_str);
213
    char *host_str = str;
214
    char *src_str;
215
    const char *src_str2;
216
    char *ptr;
217

    
218
    /*
219
     * Chop off any extra arguments at the end of the string which
220
     * would start with a comma, then fill in the src port information
221
     * if it was provided else use the "any address" and "any port".
222
     */
223
    if ((ptr = strchr(str,',')))
224
        *ptr = '\0';
225

    
226
    if ((src_str = strchr(input_str,'@'))) {
227
        *src_str = '\0';
228
        src_str++;
229
    }
230

    
231
    if (parse_host_port(haddr, host_str) < 0)
232
        goto fail;
233

    
234
    src_str2 = src_str;
235
    if (!src_str || *src_str == '\0')
236
        src_str2 = ":0";
237

    
238
    if (parse_host_port(saddr, src_str2) < 0)
239
        goto fail;
240

    
241
    free(str);
242
    return(0);
243

    
244
fail:
245
    free(str);
246
    return -1;
247
}
248

    
249
int parse_host_port(struct sockaddr_in *saddr, const char *str)
250
{
251
    char buf[512];
252
    struct hostent *he;
253
    const char *p, *r;
254
    int port;
255

    
256
    p = str;
257
    if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
258
        return -1;
259
    saddr->sin_family = AF_INET;
260
    if (buf[0] == '\0') {
261
        saddr->sin_addr.s_addr = 0;
262
    } else {
263
        if (qemu_isdigit(buf[0])) {
264
            if (!inet_aton(buf, &saddr->sin_addr))
265
                return -1;
266
        } else {
267
            if ((he = gethostbyname(buf)) == NULL)
268
                return - 1;
269
            saddr->sin_addr = *(struct in_addr *)he->h_addr;
270
        }
271
    }
272
    port = strtol(p, (char **)&r, 0);
273
    if (r == p)
274
        return -1;
275
    saddr->sin_port = htons(port);
276
    return 0;
277
}
278

    
279
#if !defined(_WIN32) && 0
280
static int parse_unix_path(struct sockaddr_un *uaddr, const char *str)
281
{
282
    const char *p;
283
    int len;
284

    
285
    len = MIN(108, strlen(str));
286
    p = strchr(str, ',');
287
    if (p)
288
        len = MIN(len, p - str);
289

    
290
    memset(uaddr, 0, sizeof(*uaddr));
291

    
292
    uaddr->sun_family = AF_UNIX;
293
    memcpy(uaddr->sun_path, str, len);
294

    
295
    return 0;
296
}
297
#endif
298

    
299
void qemu_format_nic_info_str(VLANClientState *vc, uint8_t macaddr[6])
300
{
301
    snprintf(vc->info_str, sizeof(vc->info_str),
302
             "macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
303
             macaddr[0], macaddr[1], macaddr[2],
304
             macaddr[3], macaddr[4], macaddr[5]);
305
}
306

    
307
static char *assign_name(VLANClientState *vc1, const char *model)
308
{
309
    VLANState *vlan;
310
    char buf[256];
311
    int id = 0;
312

    
313
    for (vlan = first_vlan; vlan; vlan = vlan->next) {
314
        VLANClientState *vc;
315

    
316
        for (vc = vlan->first_client; vc; vc = vc->next)
317
            if (vc != vc1 && strcmp(vc->model, model) == 0)
318
                id++;
319
    }
320

    
321
    snprintf(buf, sizeof(buf), "%s.%d", model, id);
322

    
323
    return strdup(buf);
324
}
325

    
326
VLANClientState *qemu_new_vlan_client(VLANState *vlan,
327
                                      const char *model,
328
                                      IOReadHandler *fd_read,
329
                                      IOCanRWHandler *fd_can_read,
330
                                      void *opaque)
331
{
332
    VLANClientState *vc, **pvc;
333
    vc = qemu_mallocz(sizeof(VLANClientState));
334
    if (!vc)
335
        return NULL;
336
    vc->model = strdup(model);
337
    vc->name = assign_name(vc, model);
338
    vc->fd_read = fd_read;
339
    vc->fd_can_read = fd_can_read;
340
    vc->opaque = opaque;
341
    vc->vlan = vlan;
342

    
343
    vc->next = NULL;
344
    pvc = &vlan->first_client;
345
    while (*pvc != NULL)
346
        pvc = &(*pvc)->next;
347
    *pvc = vc;
348
    return vc;
349
}
350

    
351
void qemu_del_vlan_client(VLANClientState *vc)
352
{
353
    VLANClientState **pvc = &vc->vlan->first_client;
354

    
355
    while (*pvc != NULL)
356
        if (*pvc == vc) {
357
            *pvc = vc->next;
358
            free(vc->name);
359
            free(vc->model);
360
            free(vc);
361
            break;
362
        } else
363
            pvc = &(*pvc)->next;
364
}
365

    
366
int qemu_can_send_packet(VLANClientState *vc1)
367
{
368
    VLANState *vlan = vc1->vlan;
369
    VLANClientState *vc;
370

    
371
    for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
372
        if (vc != vc1) {
373
            if (vc->fd_can_read && vc->fd_can_read(vc->opaque))
374
                return 1;
375
        }
376
    }
377
    return 0;
378
}
379

    
380
void qemu_send_packet(VLANClientState *vc1, const uint8_t *buf, int size)
381
{
382
    VLANState *vlan = vc1->vlan;
383
    VLANClientState *vc;
384

    
385
#ifdef DEBUG_NET
386
    printf("vlan %d send:\n", vlan->id);
387
    hex_dump(stdout, buf, size);
388
#endif
389
    for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
390
        if (vc != vc1) {
391
            vc->fd_read(vc->opaque, buf, size);
392
        }
393
    }
394
}
395

    
396
static ssize_t vc_sendv_compat(VLANClientState *vc, const struct iovec *iov,
397
                               int iovcnt)
398
{
399
    uint8_t buffer[4096];
400
    size_t offset = 0;
401
    int i;
402

    
403
    for (i = 0; i < iovcnt; i++) {
404
        size_t len;
405

    
406
        len = MIN(sizeof(buffer) - offset, iov[i].iov_len);
407
        memcpy(buffer + offset, iov[i].iov_base, len);
408
        offset += len;
409
    }
410

    
411
    vc->fd_read(vc->opaque, buffer, offset);
412

    
413
    return offset;
414
}
415

    
416
ssize_t qemu_sendv_packet(VLANClientState *vc1, const struct iovec *iov,
417
                          int iovcnt)
418
{
419
    VLANState *vlan = vc1->vlan;
420
    VLANClientState *vc;
421
    ssize_t max_len = 0;
422

    
423
    for (vc = vlan->first_client; vc != NULL; vc = vc->next) {
424
        ssize_t len = 0;
425

    
426
        if (vc == vc1)
427
            continue;
428

    
429
        if (vc->fd_readv)
430
            len = vc->fd_readv(vc->opaque, iov, iovcnt);
431
        else if (vc->fd_read)
432
            len = vc_sendv_compat(vc, iov, iovcnt);
433

    
434
        max_len = MAX(max_len, len);
435
    }
436

    
437
    return max_len;
438
}
439

    
440
#if defined(CONFIG_SLIRP)
441

    
442
/* slirp network adapter */
443

    
444
static int slirp_inited;
445
static VLANClientState *slirp_vc;
446

    
447
int slirp_can_output(void)
448
{
449
    return !slirp_vc || qemu_can_send_packet(slirp_vc);
450
}
451

    
452
void slirp_output(const uint8_t *pkt, int pkt_len)
453
{
454
#ifdef DEBUG_SLIRP
455
    printf("slirp output:\n");
456
    hex_dump(stdout, pkt, pkt_len);
457
#endif
458
    if (!slirp_vc)
459
        return;
460
    qemu_send_packet(slirp_vc, pkt, pkt_len);
461
}
462

    
463
int slirp_is_inited(void)
464
{
465
    return slirp_inited;
466
}
467

    
468
static void slirp_receive(void *opaque, const uint8_t *buf, int size)
469
{
470
#ifdef DEBUG_SLIRP
471
    printf("slirp input:\n");
472
    hex_dump(stdout, buf, size);
473
#endif
474
    slirp_input(buf, size);
475
}
476

    
477
static int net_slirp_init(VLANState *vlan, const char *model)
478
{
479
    if (!slirp_inited) {
480
        slirp_inited = 1;
481
        slirp_init();
482
    }
483
    slirp_vc = qemu_new_vlan_client(vlan, model,
484
                                    slirp_receive, NULL, NULL);
485
    slirp_vc->info_str[0] = '\0';
486
    return 0;
487
}
488

    
489
void net_slirp_redir(const char *redir_str)
490
{
491
    int is_udp;
492
    char buf[256], *r;
493
    const char *p;
494
    struct in_addr guest_addr;
495
    int host_port, guest_port;
496

    
497
    if (!slirp_inited) {
498
        slirp_inited = 1;
499
        slirp_init();
500
    }
501

    
502
    p = redir_str;
503
    if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
504
        goto fail;
505
    if (!strcmp(buf, "tcp")) {
506
        is_udp = 0;
507
    } else if (!strcmp(buf, "udp")) {
508
        is_udp = 1;
509
    } else {
510
        goto fail;
511
    }
512

    
513
    if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
514
        goto fail;
515
    host_port = strtol(buf, &r, 0);
516
    if (r == buf)
517
        goto fail;
518

    
519
    if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
520
        goto fail;
521
    if (buf[0] == '\0') {
522
        pstrcpy(buf, sizeof(buf), "10.0.2.15");
523
    }
524
    if (!inet_aton(buf, &guest_addr))
525
        goto fail;
526

    
527
    guest_port = strtol(p, &r, 0);
528
    if (r == p)
529
        goto fail;
530

    
531
    if (slirp_redir(is_udp, host_port, guest_addr, guest_port) < 0) {
532
        fprintf(stderr, "qemu: could not set up redirection\n");
533
        exit(1);
534
    }
535
    return;
536
 fail:
537
    fprintf(stderr, "qemu: syntax: -redir [tcp|udp]:host-port:[guest-host]:guest-port\n");
538
    exit(1);
539
}
540

    
541
#ifndef _WIN32
542

    
543
static char smb_dir[1024];
544

    
545
static void erase_dir(char *dir_name)
546
{
547
    DIR *d;
548
    struct dirent *de;
549
    char filename[1024];
550

    
551
    /* erase all the files in the directory */
552
    if ((d = opendir(dir_name)) != 0) {
553
        for(;;) {
554
            de = readdir(d);
555
            if (!de)
556
                break;
557
            if (strcmp(de->d_name, ".") != 0 &&
558
                strcmp(de->d_name, "..") != 0) {
559
                snprintf(filename, sizeof(filename), "%s/%s",
560
                         smb_dir, de->d_name);
561
                if (unlink(filename) != 0)  /* is it a directory? */
562
                    erase_dir(filename);
563
            }
564
        }
565
        closedir(d);
566
        rmdir(dir_name);
567
    }
568
}
569

    
570
/* automatic user mode samba server configuration */
571
static void smb_exit(void)
572
{
573
    erase_dir(smb_dir);
574
}
575

    
576
/* automatic user mode samba server configuration */
577
void net_slirp_smb(const char *exported_dir)
578
{
579
    char smb_conf[1024];
580
    char smb_cmdline[1024];
581
    FILE *f;
582

    
583
    if (!slirp_inited) {
584
        slirp_inited = 1;
585
        slirp_init();
586
    }
587

    
588
    /* XXX: better tmp dir construction */
589
    snprintf(smb_dir, sizeof(smb_dir), "/tmp/qemu-smb.%d", getpid());
590
    if (mkdir(smb_dir, 0700) < 0) {
591
        fprintf(stderr, "qemu: could not create samba server dir '%s'\n", smb_dir);
592
        exit(1);
593
    }
594
    snprintf(smb_conf, sizeof(smb_conf), "%s/%s", smb_dir, "smb.conf");
595

    
596
    f = fopen(smb_conf, "w");
597
    if (!f) {
598
        fprintf(stderr, "qemu: could not create samba server configuration file '%s'\n", smb_conf);
599
        exit(1);
600
    }
601
    fprintf(f,
602
            "[global]\n"
603
            "private dir=%s\n"
604
            "smb ports=0\n"
605
            "socket address=127.0.0.1\n"
606
            "pid directory=%s\n"
607
            "lock directory=%s\n"
608
            "log file=%s/log.smbd\n"
609
            "smb passwd file=%s/smbpasswd\n"
610
            "security = share\n"
611
            "[qemu]\n"
612
            "path=%s\n"
613
            "read only=no\n"
614
            "guest ok=yes\n",
615
            smb_dir,
616
            smb_dir,
617
            smb_dir,
618
            smb_dir,
619
            smb_dir,
620
            exported_dir
621
            );
622
    fclose(f);
623
    atexit(smb_exit);
624

    
625
    snprintf(smb_cmdline, sizeof(smb_cmdline), "%s -s %s",
626
             SMBD_COMMAND, smb_conf);
627

    
628
    slirp_add_exec(0, smb_cmdline, 4, 139);
629
}
630

    
631
#endif /* !defined(_WIN32) */
632
void do_info_slirp(void)
633
{
634
    slirp_stats();
635
}
636

    
637
#endif /* CONFIG_SLIRP */
638

    
639
#if !defined(_WIN32)
640

    
641
typedef struct TAPState {
642
    VLANClientState *vc;
643
    int fd;
644
    char down_script[1024];
645
} TAPState;
646

    
647
#ifdef HAVE_IOVEC
648
static ssize_t tap_receive_iov(void *opaque, const struct iovec *iov,
649
                               int iovcnt)
650
{
651
    TAPState *s = opaque;
652
    ssize_t len;
653

    
654
    do {
655
        len = writev(s->fd, iov, iovcnt);
656
    } while (len == -1 && (errno == EINTR || errno == EAGAIN));
657

    
658
    return len;
659
}
660
#endif
661

    
662
static void tap_receive(void *opaque, const uint8_t *buf, int size)
663
{
664
    TAPState *s = opaque;
665
    int ret;
666
    for(;;) {
667
        ret = write(s->fd, buf, size);
668
        if (ret < 0 && (errno == EINTR || errno == EAGAIN)) {
669
        } else {
670
            break;
671
        }
672
    }
673
}
674

    
675
static void tap_send(void *opaque)
676
{
677
    TAPState *s = opaque;
678
    uint8_t buf[4096];
679
    int size;
680

    
681
#ifdef __sun__
682
    struct strbuf sbuf;
683
    int f = 0;
684
    sbuf.maxlen = sizeof(buf);
685
    sbuf.buf = buf;
686
    size = getmsg(s->fd, NULL, &sbuf, &f) >=0 ? sbuf.len : -1;
687
#else
688
    size = read(s->fd, buf, sizeof(buf));
689
#endif
690
    if (size > 0) {
691
        qemu_send_packet(s->vc, buf, size);
692
    }
693
}
694

    
695
/* fd support */
696

    
697
static TAPState *net_tap_fd_init(VLANState *vlan, const char *model, int fd)
698
{
699
    TAPState *s;
700

    
701
    s = qemu_mallocz(sizeof(TAPState));
702
    if (!s)
703
        return NULL;
704
    s->fd = fd;
705
    s->vc = qemu_new_vlan_client(vlan, model, tap_receive, NULL, s);
706
#ifdef HAVE_IOVEC
707
    s->vc->fd_readv = tap_receive_iov;
708
#endif
709
    qemu_set_fd_handler(s->fd, tap_send, NULL, s);
710
    snprintf(s->vc->info_str, sizeof(s->vc->info_str), "fd=%d", fd);
711
    return s;
712
}
713

    
714
#if defined (_BSD) || defined (__FreeBSD_kernel__)
715
static int tap_open(char *ifname, int ifname_size)
716
{
717
    int fd;
718
    char *dev;
719
    struct stat s;
720

    
721
    TFR(fd = open("/dev/tap", O_RDWR));
722
    if (fd < 0) {
723
        fprintf(stderr, "warning: could not open /dev/tap: no virtual network emulation\n");
724
        return -1;
725
    }
726

    
727
    fstat(fd, &s);
728
    dev = devname(s.st_rdev, S_IFCHR);
729
    pstrcpy(ifname, ifname_size, dev);
730

    
731
    fcntl(fd, F_SETFL, O_NONBLOCK);
732
    return fd;
733
}
734
#elif defined(__sun__)
735
#define TUNNEWPPA       (('T'<<16) | 0x0001)
736
/*
737
 * Allocate TAP device, returns opened fd.
738
 * Stores dev name in the first arg(must be large enough).
739
 */
740
int tap_alloc(char *dev, size_t dev_size)
741
{
742
    int tap_fd, if_fd, ppa = -1;
743
    static int ip_fd = 0;
744
    char *ptr;
745

    
746
    static int arp_fd = 0;
747
    int ip_muxid, arp_muxid;
748
    struct strioctl  strioc_if, strioc_ppa;
749
    int link_type = I_PLINK;;
750
    struct lifreq ifr;
751
    char actual_name[32] = "";
752

    
753
    memset(&ifr, 0x0, sizeof(ifr));
754

    
755
    if( *dev ){
756
       ptr = dev;
757
       while( *ptr && !qemu_isdigit((int)*ptr) ) ptr++;
758
       ppa = atoi(ptr);
759
    }
760

    
761
    /* Check if IP device was opened */
762
    if( ip_fd )
763
       close(ip_fd);
764

    
765
    TFR(ip_fd = open("/dev/udp", O_RDWR, 0));
766
    if (ip_fd < 0) {
767
       syslog(LOG_ERR, "Can't open /dev/ip (actually /dev/udp)");
768
       return -1;
769
    }
770

    
771
    TFR(tap_fd = open("/dev/tap", O_RDWR, 0));
772
    if (tap_fd < 0) {
773
       syslog(LOG_ERR, "Can't open /dev/tap");
774
       return -1;
775
    }
776

    
777
    /* Assign a new PPA and get its unit number. */
778
    strioc_ppa.ic_cmd = TUNNEWPPA;
779
    strioc_ppa.ic_timout = 0;
780
    strioc_ppa.ic_len = sizeof(ppa);
781
    strioc_ppa.ic_dp = (char *)&ppa;
782
    if ((ppa = ioctl (tap_fd, I_STR, &strioc_ppa)) < 0)
783
       syslog (LOG_ERR, "Can't assign new interface");
784

    
785
    TFR(if_fd = open("/dev/tap", O_RDWR, 0));
786
    if (if_fd < 0) {
787
       syslog(LOG_ERR, "Can't open /dev/tap (2)");
788
       return -1;
789
    }
790
    if(ioctl(if_fd, I_PUSH, "ip") < 0){
791
       syslog(LOG_ERR, "Can't push IP module");
792
       return -1;
793
    }
794

    
795
    if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) < 0)
796
        syslog(LOG_ERR, "Can't get flags\n");
797

    
798
    snprintf (actual_name, 32, "tap%d", ppa);
799
    pstrcpy(ifr.lifr_name, sizeof(ifr.lifr_name), actual_name);
800

    
801
    ifr.lifr_ppa = ppa;
802
    /* Assign ppa according to the unit number returned by tun device */
803

    
804
    if (ioctl (if_fd, SIOCSLIFNAME, &ifr) < 0)
805
        syslog (LOG_ERR, "Can't set PPA %d", ppa);
806
    if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) <0)
807
        syslog (LOG_ERR, "Can't get flags\n");
808
    /* Push arp module to if_fd */
809
    if (ioctl (if_fd, I_PUSH, "arp") < 0)
810
        syslog (LOG_ERR, "Can't push ARP module (2)");
811

    
812
    /* Push arp module to ip_fd */
813
    if (ioctl (ip_fd, I_POP, NULL) < 0)
814
        syslog (LOG_ERR, "I_POP failed\n");
815
    if (ioctl (ip_fd, I_PUSH, "arp") < 0)
816
        syslog (LOG_ERR, "Can't push ARP module (3)\n");
817
    /* Open arp_fd */
818
    TFR(arp_fd = open ("/dev/tap", O_RDWR, 0));
819
    if (arp_fd < 0)
820
       syslog (LOG_ERR, "Can't open %s\n", "/dev/tap");
821

    
822
    /* Set ifname to arp */
823
    strioc_if.ic_cmd = SIOCSLIFNAME;
824
    strioc_if.ic_timout = 0;
825
    strioc_if.ic_len = sizeof(ifr);
826
    strioc_if.ic_dp = (char *)&ifr;
827
    if (ioctl(arp_fd, I_STR, &strioc_if) < 0){
828
        syslog (LOG_ERR, "Can't set ifname to arp\n");
829
    }
830

    
831
    if((ip_muxid = ioctl(ip_fd, I_LINK, if_fd)) < 0){
832
       syslog(LOG_ERR, "Can't link TAP device to IP");
833
       return -1;
834
    }
835

    
836
    if ((arp_muxid = ioctl (ip_fd, link_type, arp_fd)) < 0)
837
        syslog (LOG_ERR, "Can't link TAP device to ARP");
838

    
839
    close (if_fd);
840

    
841
    memset(&ifr, 0x0, sizeof(ifr));
842
    pstrcpy(ifr.lifr_name, sizeof(ifr.lifr_name), actual_name);
843
    ifr.lifr_ip_muxid  = ip_muxid;
844
    ifr.lifr_arp_muxid = arp_muxid;
845

    
846
    if (ioctl (ip_fd, SIOCSLIFMUXID, &ifr) < 0)
847
    {
848
      ioctl (ip_fd, I_PUNLINK , arp_muxid);
849
      ioctl (ip_fd, I_PUNLINK, ip_muxid);
850
      syslog (LOG_ERR, "Can't set multiplexor id");
851
    }
852

    
853
    snprintf(dev, dev_size, "tap%d", ppa);
854
    return tap_fd;
855
}
856

    
857
static int tap_open(char *ifname, int ifname_size)
858
{
859
    char  dev[10]="";
860
    int fd;
861
    if( (fd = tap_alloc(dev, sizeof(dev))) < 0 ){
862
       fprintf(stderr, "Cannot allocate TAP device\n");
863
       return -1;
864
    }
865
    pstrcpy(ifname, ifname_size, dev);
866
    fcntl(fd, F_SETFL, O_NONBLOCK);
867
    return fd;
868
}
869
#elif defined (_AIX)
870
static int tap_open(char *ifname, int ifname_size)
871
{
872
    fprintf (stderr, "no tap on AIX\n");
873
    return -1;
874
}
875
#else
876
static int tap_open(char *ifname, int ifname_size)
877
{
878
    struct ifreq ifr;
879
    int fd, ret;
880

    
881
    TFR(fd = open("/dev/net/tun", O_RDWR));
882
    if (fd < 0) {
883
        fprintf(stderr, "warning: could not open /dev/net/tun: no virtual network emulation\n");
884
        return -1;
885
    }
886
    memset(&ifr, 0, sizeof(ifr));
887
    ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
888
    if (ifname[0] != '\0')
889
        pstrcpy(ifr.ifr_name, IFNAMSIZ, ifname);
890
    else
891
        pstrcpy(ifr.ifr_name, IFNAMSIZ, "tap%d");
892
    ret = ioctl(fd, TUNSETIFF, (void *) &ifr);
893
    if (ret != 0) {
894
        fprintf(stderr, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
895
        close(fd);
896
        return -1;
897
    }
898
    pstrcpy(ifname, ifname_size, ifr.ifr_name);
899
    fcntl(fd, F_SETFL, O_NONBLOCK);
900
    return fd;
901
}
902
#endif
903

    
904
static int launch_script(const char *setup_script, const char *ifname, int fd)
905
{
906
    int pid, status;
907
    char *args[3];
908
    char **parg;
909

    
910
        /* try to launch network script */
911
        pid = fork();
912
        if (pid >= 0) {
913
            if (pid == 0) {
914
                int open_max = sysconf (_SC_OPEN_MAX), i;
915
                for (i = 0; i < open_max; i++)
916
                    if (i != STDIN_FILENO &&
917
                        i != STDOUT_FILENO &&
918
                        i != STDERR_FILENO &&
919
                        i != fd)
920
                        close(i);
921

    
922
                parg = args;
923
                *parg++ = (char *)setup_script;
924
                *parg++ = (char *)ifname;
925
                *parg++ = NULL;
926
                execv(setup_script, args);
927
                _exit(1);
928
            }
929
            while (waitpid(pid, &status, 0) != pid);
930
            if (!WIFEXITED(status) ||
931
                WEXITSTATUS(status) != 0) {
932
                fprintf(stderr, "%s: could not launch network script\n",
933
                        setup_script);
934
                return -1;
935
            }
936
        }
937
    return 0;
938
}
939

    
940
static int net_tap_init(VLANState *vlan, const char *model, const char *ifname1,
941
                        const char *setup_script, const char *down_script)
942
{
943
    TAPState *s;
944
    int fd;
945
    char ifname[128];
946

    
947
    if (ifname1 != NULL)
948
        pstrcpy(ifname, sizeof(ifname), ifname1);
949
    else
950
        ifname[0] = '\0';
951
    TFR(fd = tap_open(ifname, sizeof(ifname)));
952
    if (fd < 0)
953
        return -1;
954

    
955
    if (!setup_script || !strcmp(setup_script, "no"))
956
        setup_script = "";
957
    if (setup_script[0] != '\0') {
958
        if (launch_script(setup_script, ifname, fd))
959
            return -1;
960
    }
961
    s = net_tap_fd_init(vlan, model, fd);
962
    if (!s)
963
        return -1;
964
    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
965
             "ifname=%s,script=%s,downscript=%s",
966
             ifname, setup_script, down_script);
967
    if (down_script && strcmp(down_script, "no"))
968
        snprintf(s->down_script, sizeof(s->down_script), "%s", down_script);
969
    return 0;
970
}
971

    
972
#endif /* !_WIN32 */
973

    
974
#if defined(CONFIG_VDE)
975
typedef struct VDEState {
976
    VLANClientState *vc;
977
    VDECONN *vde;
978
} VDEState;
979

    
980
static void vde_to_qemu(void *opaque)
981
{
982
    VDEState *s = opaque;
983
    uint8_t buf[4096];
984
    int size;
985

    
986
    size = vde_recv(s->vde, buf, sizeof(buf), 0);
987
    if (size > 0) {
988
        qemu_send_packet(s->vc, buf, size);
989
    }
990
}
991

    
992
static void vde_from_qemu(void *opaque, const uint8_t *buf, int size)
993
{
994
    VDEState *s = opaque;
995
    int ret;
996
    for(;;) {
997
        ret = vde_send(s->vde, buf, size, 0);
998
        if (ret < 0 && errno == EINTR) {
999
        } else {
1000
            break;
1001
        }
1002
    }
1003
}
1004

    
1005
static int net_vde_init(VLANState *vlan, const char *model, const char *sock,
1006
                        int port, const char *group, int mode)
1007
{
1008
    VDEState *s;
1009
    char *init_group = strlen(group) ? (char *)group : NULL;
1010
    char *init_sock = strlen(sock) ? (char *)sock : NULL;
1011

    
1012
    struct vde_open_args args = {
1013
        .port = port,
1014
        .group = init_group,
1015
        .mode = mode,
1016
    };
1017

    
1018
    s = qemu_mallocz(sizeof(VDEState));
1019
    if (!s)
1020
        return -1;
1021
    s->vde = vde_open(init_sock, "QEMU", &args);
1022
    if (!s->vde){
1023
        free(s);
1024
        return -1;
1025
    }
1026
    s->vc = qemu_new_vlan_client(vlan, model, vde_from_qemu, NULL, s);
1027
    qemu_set_fd_handler(vde_datafd(s->vde), vde_to_qemu, NULL, s);
1028
    snprintf(s->vc->info_str, sizeof(s->vc->info_str), "sock=%s,fd=%d",
1029
             sock, vde_datafd(s->vde));
1030
    return 0;
1031
}
1032
#endif
1033

    
1034
/* network connection */
1035
typedef struct NetSocketState {
1036
    VLANClientState *vc;
1037
    int fd;
1038
    int state; /* 0 = getting length, 1 = getting data */
1039
    int index;
1040
    int packet_len;
1041
    uint8_t buf[4096];
1042
    struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
1043
} NetSocketState;
1044

    
1045
typedef struct NetSocketListenState {
1046
    VLANState *vlan;
1047
    char *model;
1048
    int fd;
1049
} NetSocketListenState;
1050

    
1051
/* XXX: we consider we can send the whole packet without blocking */
1052
static void net_socket_receive(void *opaque, const uint8_t *buf, int size)
1053
{
1054
    NetSocketState *s = opaque;
1055
    uint32_t len;
1056
    len = htonl(size);
1057

    
1058
    send_all(s->fd, (const uint8_t *)&len, sizeof(len));
1059
    send_all(s->fd, buf, size);
1060
}
1061

    
1062
static void net_socket_receive_dgram(void *opaque, const uint8_t *buf, int size)
1063
{
1064
    NetSocketState *s = opaque;
1065
    sendto(s->fd, buf, size, 0,
1066
           (struct sockaddr *)&s->dgram_dst, sizeof(s->dgram_dst));
1067
}
1068

    
1069
static void net_socket_send(void *opaque)
1070
{
1071
    NetSocketState *s = opaque;
1072
    int l, size, err;
1073
    uint8_t buf1[4096];
1074
    const uint8_t *buf;
1075

    
1076
    size = recv(s->fd, buf1, sizeof(buf1), 0);
1077
    if (size < 0) {
1078
        err = socket_error();
1079
        if (err != EWOULDBLOCK)
1080
            goto eoc;
1081
    } else if (size == 0) {
1082
        /* end of connection */
1083
    eoc:
1084
        qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
1085
        closesocket(s->fd);
1086
        return;
1087
    }
1088
    buf = buf1;
1089
    while (size > 0) {
1090
        /* reassemble a packet from the network */
1091
        switch(s->state) {
1092
        case 0:
1093
            l = 4 - s->index;
1094
            if (l > size)
1095
                l = size;
1096
            memcpy(s->buf + s->index, buf, l);
1097
            buf += l;
1098
            size -= l;
1099
            s->index += l;
1100
            if (s->index == 4) {
1101
                /* got length */
1102
                s->packet_len = ntohl(*(uint32_t *)s->buf);
1103
                s->index = 0;
1104
                s->state = 1;
1105
            }
1106
            break;
1107
        case 1:
1108
            l = s->packet_len - s->index;
1109
            if (l > size)
1110
                l = size;
1111
            memcpy(s->buf + s->index, buf, l);
1112
            s->index += l;
1113
            buf += l;
1114
            size -= l;
1115
            if (s->index >= s->packet_len) {
1116
                qemu_send_packet(s->vc, s->buf, s->packet_len);
1117
                s->index = 0;
1118
                s->state = 0;
1119
            }
1120
            break;
1121
        }
1122
    }
1123
}
1124

    
1125
static void net_socket_send_dgram(void *opaque)
1126
{
1127
    NetSocketState *s = opaque;
1128
    int size;
1129

    
1130
    size = recv(s->fd, s->buf, sizeof(s->buf), 0);
1131
    if (size < 0)
1132
        return;
1133
    if (size == 0) {
1134
        /* end of connection */
1135
        qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
1136
        return;
1137
    }
1138
    qemu_send_packet(s->vc, s->buf, size);
1139
}
1140

    
1141
static int net_socket_mcast_create(struct sockaddr_in *mcastaddr)
1142
{
1143
    struct ip_mreq imr;
1144
    int fd;
1145
    int val, ret;
1146
    if (!IN_MULTICAST(ntohl(mcastaddr->sin_addr.s_addr))) {
1147
        fprintf(stderr, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
1148
                inet_ntoa(mcastaddr->sin_addr),
1149
                (int)ntohl(mcastaddr->sin_addr.s_addr));
1150
        return -1;
1151

    
1152
    }
1153
    fd = socket(PF_INET, SOCK_DGRAM, 0);
1154
    if (fd < 0) {
1155
        perror("socket(PF_INET, SOCK_DGRAM)");
1156
        return -1;
1157
    }
1158

    
1159
    val = 1;
1160
    ret=setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
1161
                   (const char *)&val, sizeof(val));
1162
    if (ret < 0) {
1163
        perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
1164
        goto fail;
1165
    }
1166

    
1167
    ret = bind(fd, (struct sockaddr *)mcastaddr, sizeof(*mcastaddr));
1168
    if (ret < 0) {
1169
        perror("bind");
1170
        goto fail;
1171
    }
1172

    
1173
    /* Add host to multicast group */
1174
    imr.imr_multiaddr = mcastaddr->sin_addr;
1175
    imr.imr_interface.s_addr = htonl(INADDR_ANY);
1176

    
1177
    ret = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
1178
                     (const char *)&imr, sizeof(struct ip_mreq));
1179
    if (ret < 0) {
1180
        perror("setsockopt(IP_ADD_MEMBERSHIP)");
1181
        goto fail;
1182
    }
1183

    
1184
    /* Force mcast msgs to loopback (eg. several QEMUs in same host */
1185
    val = 1;
1186
    ret=setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
1187
                   (const char *)&val, sizeof(val));
1188
    if (ret < 0) {
1189
        perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
1190
        goto fail;
1191
    }
1192

    
1193
    socket_set_nonblock(fd);
1194
    return fd;
1195
fail:
1196
    if (fd >= 0)
1197
        closesocket(fd);
1198
    return -1;
1199
}
1200

    
1201
static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan, const char *model,
1202
                                                int fd, int is_connected)
1203
{
1204
    struct sockaddr_in saddr;
1205
    int newfd;
1206
    socklen_t saddr_len;
1207
    NetSocketState *s;
1208

    
1209
    /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
1210
     * Because this may be "shared" socket from a "master" process, datagrams would be recv()
1211
     * by ONLY ONE process: we must "clone" this dgram socket --jjo
1212
     */
1213

    
1214
    if (is_connected) {
1215
        if (getsockname(fd, (struct sockaddr *) &saddr, &saddr_len) == 0) {
1216
            /* must be bound */
1217
            if (saddr.sin_addr.s_addr==0) {
1218
                fprintf(stderr, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
1219
                        fd);
1220
                return NULL;
1221
            }
1222
            /* clone dgram socket */
1223
            newfd = net_socket_mcast_create(&saddr);
1224
            if (newfd < 0) {
1225
                /* error already reported by net_socket_mcast_create() */
1226
                close(fd);
1227
                return NULL;
1228
            }
1229
            /* clone newfd to fd, close newfd */
1230
            dup2(newfd, fd);
1231
            close(newfd);
1232

    
1233
        } else {
1234
            fprintf(stderr, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
1235
                    fd, strerror(errno));
1236
            return NULL;
1237
        }
1238
    }
1239

    
1240
    s = qemu_mallocz(sizeof(NetSocketState));
1241
    if (!s)
1242
        return NULL;
1243
    s->fd = fd;
1244

    
1245
    s->vc = qemu_new_vlan_client(vlan, model, net_socket_receive_dgram, NULL, s);
1246
    qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s);
1247

    
1248
    /* mcast: save bound address as dst */
1249
    if (is_connected) s->dgram_dst=saddr;
1250

    
1251
    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
1252
            "socket: fd=%d (%s mcast=%s:%d)",
1253
            fd, is_connected? "cloned" : "",
1254
            inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
1255
    return s;
1256
}
1257

    
1258
static void net_socket_connect(void *opaque)
1259
{
1260
    NetSocketState *s = opaque;
1261
    qemu_set_fd_handler(s->fd, net_socket_send, NULL, s);
1262
}
1263

    
1264
static NetSocketState *net_socket_fd_init_stream(VLANState *vlan, const char *model,
1265
                                                 int fd, int is_connected)
1266
{
1267
    NetSocketState *s;
1268
    s = qemu_mallocz(sizeof(NetSocketState));
1269
    if (!s)
1270
        return NULL;
1271
    s->fd = fd;
1272
    s->vc = qemu_new_vlan_client(vlan, model,
1273
                                 net_socket_receive, NULL, s);
1274
    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
1275
             "socket: fd=%d", fd);
1276
    if (is_connected) {
1277
        net_socket_connect(s);
1278
    } else {
1279
        qemu_set_fd_handler(s->fd, NULL, net_socket_connect, s);
1280
    }
1281
    return s;
1282
}
1283

    
1284
static NetSocketState *net_socket_fd_init(VLANState *vlan, const char *model,
1285
                                          int fd, int is_connected)
1286
{
1287
    int so_type=-1, optlen=sizeof(so_type);
1288

    
1289
    if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type,
1290
        (socklen_t *)&optlen)< 0) {
1291
        fprintf(stderr, "qemu: error: getsockopt(SO_TYPE) for fd=%d failed\n", fd);
1292
        return NULL;
1293
    }
1294
    switch(so_type) {
1295
    case SOCK_DGRAM:
1296
        return net_socket_fd_init_dgram(vlan, model, fd, is_connected);
1297
    case SOCK_STREAM:
1298
        return net_socket_fd_init_stream(vlan, model, fd, is_connected);
1299
    default:
1300
        /* who knows ... this could be a eg. a pty, do warn and continue as stream */
1301
        fprintf(stderr, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type, fd);
1302
        return net_socket_fd_init_stream(vlan, model, fd, is_connected);
1303
    }
1304
    return NULL;
1305
}
1306

    
1307
static void net_socket_accept(void *opaque)
1308
{
1309
    NetSocketListenState *s = opaque;
1310
    NetSocketState *s1;
1311
    struct sockaddr_in saddr;
1312
    socklen_t len;
1313
    int fd;
1314

    
1315
    for(;;) {
1316
        len = sizeof(saddr);
1317
        fd = accept(s->fd, (struct sockaddr *)&saddr, &len);
1318
        if (fd < 0 && errno != EINTR) {
1319
            return;
1320
        } else if (fd >= 0) {
1321
            break;
1322
        }
1323
    }
1324
    s1 = net_socket_fd_init(s->vlan, s->model, fd, 1);
1325
    if (!s1) {
1326
        closesocket(fd);
1327
    } else {
1328
        snprintf(s1->vc->info_str, sizeof(s1->vc->info_str),
1329
                 "socket: connection from %s:%d",
1330
                 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
1331
    }
1332
}
1333

    
1334
static int net_socket_listen_init(VLANState *vlan, const char *model,
1335
                                  const char *host_str)
1336
{
1337
    NetSocketListenState *s;
1338
    int fd, val, ret;
1339
    struct sockaddr_in saddr;
1340

    
1341
    if (parse_host_port(&saddr, host_str) < 0)
1342
        return -1;
1343

    
1344
    s = qemu_mallocz(sizeof(NetSocketListenState));
1345
    if (!s)
1346
        return -1;
1347

    
1348
    fd = socket(PF_INET, SOCK_STREAM, 0);
1349
    if (fd < 0) {
1350
        perror("socket");
1351
        return -1;
1352
    }
1353
    socket_set_nonblock(fd);
1354

    
1355
    /* allow fast reuse */
1356
    val = 1;
1357
    setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
1358

    
1359
    ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
1360
    if (ret < 0) {
1361
        perror("bind");
1362
        return -1;
1363
    }
1364
    ret = listen(fd, 0);
1365
    if (ret < 0) {
1366
        perror("listen");
1367
        return -1;
1368
    }
1369
    s->vlan = vlan;
1370
    s->model = strdup(model);
1371
    s->fd = fd;
1372
    qemu_set_fd_handler(fd, net_socket_accept, NULL, s);
1373
    return 0;
1374
}
1375

    
1376
static int net_socket_connect_init(VLANState *vlan, const char *model,
1377
                                   const char *host_str)
1378
{
1379
    NetSocketState *s;
1380
    int fd, connected, ret, err;
1381
    struct sockaddr_in saddr;
1382

    
1383
    if (parse_host_port(&saddr, host_str) < 0)
1384
        return -1;
1385

    
1386
    fd = socket(PF_INET, SOCK_STREAM, 0);
1387
    if (fd < 0) {
1388
        perror("socket");
1389
        return -1;
1390
    }
1391
    socket_set_nonblock(fd);
1392

    
1393
    connected = 0;
1394
    for(;;) {
1395
        ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
1396
        if (ret < 0) {
1397
            err = socket_error();
1398
            if (err == EINTR || err == EWOULDBLOCK) {
1399
            } else if (err == EINPROGRESS) {
1400
                break;
1401
#ifdef _WIN32
1402
            } else if (err == WSAEALREADY) {
1403
                break;
1404
#endif
1405
            } else {
1406
                perror("connect");
1407
                closesocket(fd);
1408
                return -1;
1409
            }
1410
        } else {
1411
            connected = 1;
1412
            break;
1413
        }
1414
    }
1415
    s = net_socket_fd_init(vlan, model, fd, connected);
1416
    if (!s)
1417
        return -1;
1418
    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
1419
             "socket: connect to %s:%d",
1420
             inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
1421
    return 0;
1422
}
1423

    
1424
static int net_socket_mcast_init(VLANState *vlan, const char *model,
1425
                                 const char *host_str)
1426
{
1427
    NetSocketState *s;
1428
    int fd;
1429
    struct sockaddr_in saddr;
1430

    
1431
    if (parse_host_port(&saddr, host_str) < 0)
1432
        return -1;
1433

    
1434

    
1435
    fd = net_socket_mcast_create(&saddr);
1436
    if (fd < 0)
1437
        return -1;
1438

    
1439
    s = net_socket_fd_init(vlan, model, fd, 0);
1440
    if (!s)
1441
        return -1;
1442

    
1443
    s->dgram_dst = saddr;
1444

    
1445
    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
1446
             "socket: mcast=%s:%d",
1447
             inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
1448
    return 0;
1449

    
1450
}
1451

    
1452
/* find or alloc a new VLAN */
1453
VLANState *qemu_find_vlan(int id)
1454
{
1455
    VLANState **pvlan, *vlan;
1456
    for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
1457
        if (vlan->id == id)
1458
            return vlan;
1459
    }
1460
    vlan = qemu_mallocz(sizeof(VLANState));
1461
    if (!vlan)
1462
        return NULL;
1463
    vlan->id = id;
1464
    vlan->next = NULL;
1465
    pvlan = &first_vlan;
1466
    while (*pvlan != NULL)
1467
        pvlan = &(*pvlan)->next;
1468
    *pvlan = vlan;
1469
    return vlan;
1470
}
1471

    
1472
int net_client_init(const char *device, const char *p)
1473
{
1474
    char buf[1024];
1475
    int vlan_id, ret;
1476
    VLANState *vlan;
1477

    
1478
    vlan_id = 0;
1479
    if (get_param_value(buf, sizeof(buf), "vlan", p)) {
1480
        vlan_id = strtol(buf, NULL, 0);
1481
    }
1482
    vlan = qemu_find_vlan(vlan_id);
1483
    if (!vlan) {
1484
        fprintf(stderr, "Could not create vlan %d\n", vlan_id);
1485
        return -1;
1486
    }
1487
    if (!strcmp(device, "nic")) {
1488
        NICInfo *nd;
1489
        uint8_t *macaddr;
1490

    
1491
        if (nb_nics >= MAX_NICS) {
1492
            fprintf(stderr, "Too Many NICs\n");
1493
            return -1;
1494
        }
1495
        nd = &nd_table[nb_nics];
1496
        macaddr = nd->macaddr;
1497
        macaddr[0] = 0x52;
1498
        macaddr[1] = 0x54;
1499
        macaddr[2] = 0x00;
1500
        macaddr[3] = 0x12;
1501
        macaddr[4] = 0x34;
1502
        macaddr[5] = 0x56 + nb_nics;
1503

    
1504
        if (get_param_value(buf, sizeof(buf), "macaddr", p)) {
1505
            if (parse_macaddr(macaddr, buf) < 0) {
1506
                fprintf(stderr, "invalid syntax for ethernet address\n");
1507
                return -1;
1508
            }
1509
        }
1510
        if (get_param_value(buf, sizeof(buf), "model", p)) {
1511
            nd->model = strdup(buf);
1512
        }
1513
        nd->vlan = vlan;
1514
        nb_nics++;
1515
        vlan->nb_guest_devs++;
1516
        ret = 0;
1517
    } else
1518
    if (!strcmp(device, "none")) {
1519
        /* does nothing. It is needed to signal that no network cards
1520
           are wanted */
1521
        ret = 0;
1522
    } else
1523
#ifdef CONFIG_SLIRP
1524
    if (!strcmp(device, "user")) {
1525
        if (get_param_value(buf, sizeof(buf), "hostname", p)) {
1526
            pstrcpy(slirp_hostname, sizeof(slirp_hostname), buf);
1527
        }
1528
        vlan->nb_host_devs++;
1529
        ret = net_slirp_init(vlan, device);
1530
    } else
1531
#endif
1532
#ifdef _WIN32
1533
    if (!strcmp(device, "tap")) {
1534
        char ifname[64];
1535
        if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
1536
            fprintf(stderr, "tap: no interface name\n");
1537
            return -1;
1538
        }
1539
        vlan->nb_host_devs++;
1540
        ret = tap_win32_init(vlan, device, ifname);
1541
    } else
1542
#elif defined (_AIX)
1543
#else
1544
    if (!strcmp(device, "tap")) {
1545
        char ifname[64];
1546
        char setup_script[1024], down_script[1024];
1547
        int fd;
1548
        vlan->nb_host_devs++;
1549
        if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
1550
            fd = strtol(buf, NULL, 0);
1551
            fcntl(fd, F_SETFL, O_NONBLOCK);
1552
            ret = -1;
1553
            if (net_tap_fd_init(vlan, device, fd))
1554
                ret = 0;
1555
        } else {
1556
            if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
1557
                ifname[0] = '\0';
1558
            }
1559
            if (get_param_value(setup_script, sizeof(setup_script), "script", p) == 0) {
1560
                pstrcpy(setup_script, sizeof(setup_script), DEFAULT_NETWORK_SCRIPT);
1561
            }
1562
            if (get_param_value(down_script, sizeof(down_script), "downscript", p) == 0) {
1563
                pstrcpy(down_script, sizeof(down_script), DEFAULT_NETWORK_DOWN_SCRIPT);
1564
            }
1565
            ret = net_tap_init(vlan, device, ifname, setup_script, down_script);
1566
        }
1567
    } else
1568
#endif
1569
    if (!strcmp(device, "socket")) {
1570
        if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
1571
            int fd;
1572
            fd = strtol(buf, NULL, 0);
1573
            ret = -1;
1574
            if (net_socket_fd_init(vlan, device, fd, 1))
1575
                ret = 0;
1576
        } else if (get_param_value(buf, sizeof(buf), "listen", p) > 0) {
1577
            ret = net_socket_listen_init(vlan, device, buf);
1578
        } else if (get_param_value(buf, sizeof(buf), "connect", p) > 0) {
1579
            ret = net_socket_connect_init(vlan, device, buf);
1580
        } else if (get_param_value(buf, sizeof(buf), "mcast", p) > 0) {
1581
            ret = net_socket_mcast_init(vlan, device, buf);
1582
        } else {
1583
            fprintf(stderr, "Unknown socket options: %s\n", p);
1584
            return -1;
1585
        }
1586
        vlan->nb_host_devs++;
1587
    } else
1588
#ifdef CONFIG_VDE
1589
    if (!strcmp(device, "vde")) {
1590
        char vde_sock[1024], vde_group[512];
1591
        int vde_port, vde_mode;
1592
        vlan->nb_host_devs++;
1593
        if (get_param_value(vde_sock, sizeof(vde_sock), "sock", p) <= 0) {
1594
            vde_sock[0] = '\0';
1595
        }
1596
        if (get_param_value(buf, sizeof(buf), "port", p) > 0) {
1597
            vde_port = strtol(buf, NULL, 10);
1598
        } else {
1599
            vde_port = 0;
1600
        }
1601
        if (get_param_value(vde_group, sizeof(vde_group), "group", p) <= 0) {
1602
            vde_group[0] = '\0';
1603
        }
1604
        if (get_param_value(buf, sizeof(buf), "mode", p) > 0) {
1605
            vde_mode = strtol(buf, NULL, 8);
1606
        } else {
1607
            vde_mode = 0700;
1608
        }
1609
        ret = net_vde_init(vlan, device, vde_sock, vde_port, vde_group, vde_mode);
1610
    } else
1611
#endif
1612
    {
1613
        fprintf(stderr, "Unknown network device: %s\n", device);
1614
        return -1;
1615
    }
1616
    if (ret < 0) {
1617
        fprintf(stderr, "Could not initialize device '%s'\n", device);
1618
    }
1619

    
1620
    return ret;
1621
}
1622

    
1623
int net_client_parse(const char *str)
1624
{
1625
    const char *p;
1626
    char *q;
1627
    char device[64];
1628

    
1629
    p = str;
1630
    q = device;
1631
    while (*p != '\0' && *p != ',') {
1632
        if ((q - device) < sizeof(device) - 1)
1633
            *q++ = *p;
1634
        p++;
1635
    }
1636
    *q = '\0';
1637
    if (*p == ',')
1638
        p++;
1639

    
1640
    return net_client_init(device, p);
1641
}
1642

    
1643
void do_info_network(void)
1644
{
1645
    VLANState *vlan;
1646
    VLANClientState *vc;
1647

    
1648
    for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
1649
        term_printf("VLAN %d devices:\n", vlan->id);
1650
        for(vc = vlan->first_client; vc != NULL; vc = vc->next)
1651
            term_printf("  %s: %s\n", vc->name, vc->info_str);
1652
    }
1653
}
1654

    
1655
void net_cleanup(void)
1656
{
1657
    VLANState *vlan;
1658

    
1659
#if !defined(_WIN32)
1660
    /* close network clients */
1661
    for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
1662
        VLANClientState *vc;
1663

    
1664
        for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
1665
            if (vc->fd_read == tap_receive) {
1666
                char ifname[64];
1667
                TAPState *s = vc->opaque;
1668

    
1669
                if (strcmp(vc->model, "tap") == 0 &&
1670
                    sscanf(vc->info_str, "ifname=%63s ", ifname) == 1 &&
1671
                    s->down_script[0])
1672
                    launch_script(s->down_script, ifname, s->fd);
1673
            }
1674
#if defined(CONFIG_VDE)
1675
            if (vc->fd_read == vde_from_qemu) {
1676
                VDEState *s = vc->opaque;
1677
                vde_close(s->vde);
1678
            }
1679
#endif
1680
        }
1681
    }
1682
#endif
1683
}
1684

    
1685
void net_client_check(void)
1686
{
1687
    VLANState *vlan;
1688

    
1689
    for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
1690
        if (vlan->nb_guest_devs == 0 && vlan->nb_host_devs == 0)
1691
            continue;
1692
        if (vlan->nb_guest_devs == 0)
1693
            fprintf(stderr, "Warning: vlan %d with no nics\n", vlan->id);
1694
        if (vlan->nb_host_devs == 0)
1695
            fprintf(stderr,
1696
                    "Warning: vlan %d is not connected to host network\n",
1697
                    vlan->id);
1698
    }
1699
}