Statistics
| Branch: | Revision:

root / vl.c @ 1ae26a18

History | View | Annotate | Download (241.8 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 "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

    
42
#include <unistd.h>
43
#include <fcntl.h>
44
#include <signal.h>
45
#include <time.h>
46
#include <errno.h>
47
#include <sys/time.h>
48
#include <zlib.h>
49

    
50
#ifndef _WIN32
51
#include <sys/times.h>
52
#include <sys/wait.h>
53
#include <termios.h>
54
#include <sys/poll.h>
55
#include <sys/mman.h>
56
#include <sys/ioctl.h>
57
#include <sys/socket.h>
58
#include <netinet/in.h>
59
#include <dirent.h>
60
#include <netdb.h>
61
#include <sys/select.h>
62
#include <arpa/inet.h>
63
#ifdef _BSD
64
#include <sys/stat.h>
65
#if !defined(__APPLE__) && !defined(__OpenBSD__)
66
#include <libutil.h>
67
#endif
68
#ifdef __OpenBSD__
69
#include <net/if.h>
70
#endif
71
#elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
72
#include <freebsd/stdlib.h>
73
#else
74
#ifndef __sun__
75
#include <linux/if.h>
76
#include <linux/if_tun.h>
77
#include <pty.h>
78
#include <malloc.h>
79
#include <linux/rtc.h>
80

    
81
/* For the benefit of older linux systems which don't supply it,
82
   we use a local copy of hpet.h. */
83
/* #include <linux/hpet.h> */
84
#include "hpet.h"
85

    
86
#include <linux/ppdev.h>
87
#include <linux/parport.h>
88
#else
89
#include <sys/stat.h>
90
#include <sys/ethernet.h>
91
#include <sys/sockio.h>
92
#include <netinet/arp.h>
93
#include <netinet/in.h>
94
#include <netinet/in_systm.h>
95
#include <netinet/ip.h>
96
#include <netinet/ip_icmp.h> // must come after ip.h
97
#include <netinet/udp.h>
98
#include <netinet/tcp.h>
99
#include <net/if.h>
100
#include <syslog.h>
101
#include <stropts.h>
102
#endif
103
#endif
104
#endif
105

    
106
#include "qemu_socket.h"
107

    
108
#if defined(CONFIG_SLIRP)
109
#include "libslirp.h"
110
#endif
111

    
112
#if defined(__OpenBSD__)
113
#include <util.h>
114
#endif
115

    
116
#if defined(CONFIG_VDE)
117
#include <libvdeplug.h>
118
#endif
119

    
120
#ifdef _WIN32
121
#include <malloc.h>
122
#include <sys/timeb.h>
123
#include <mmsystem.h>
124
#define getopt_long_only getopt_long
125
#define memalign(align, size) malloc(size)
126
#endif
127

    
128
#ifdef CONFIG_SDL
129
#ifdef __APPLE__
130
#include <SDL/SDL.h>
131
#endif
132
#endif /* CONFIG_SDL */
133

    
134
#ifdef CONFIG_COCOA
135
#undef main
136
#define main qemu_main
137
#endif /* CONFIG_COCOA */
138

    
139
#include "disas.h"
140

    
141
#include "exec-all.h"
142

    
143
#define DEFAULT_NETWORK_SCRIPT "/etc/qemu-ifup"
144
#define DEFAULT_NETWORK_DOWN_SCRIPT "/etc/qemu-ifdown"
145
#ifdef __sun__
146
#define SMBD_COMMAND "/usr/sfw/sbin/smbd"
147
#else
148
#define SMBD_COMMAND "/usr/sbin/smbd"
149
#endif
150

    
151
//#define DEBUG_UNUSED_IOPORT
152
//#define DEBUG_IOPORT
153

    
154
#ifdef TARGET_PPC
155
#define DEFAULT_RAM_SIZE 144
156
#else
157
#define DEFAULT_RAM_SIZE 128
158
#endif
159

    
160
/* Max number of USB devices that can be specified on the commandline.  */
161
#define MAX_USB_CMDLINE 8
162

    
163
/* XXX: use a two level table to limit memory usage */
164
#define MAX_IOPORTS 65536
165

    
166
const char *bios_dir = CONFIG_QEMU_SHAREDIR;
167
const char *bios_name = NULL;
168
void *ioport_opaque[MAX_IOPORTS];
169
IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS];
170
IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];
171
/* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available
172
   to store the VM snapshots */
173
DriveInfo drives_table[MAX_DRIVES+1];
174
int nb_drives;
175
/* point to the block driver where the snapshots are managed */
176
BlockDriverState *bs_snapshots;
177
int vga_ram_size;
178
enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB;
179
static DisplayState display_state;
180
int nographic;
181
int curses;
182
const char* keyboard_layout = NULL;
183
int64_t ticks_per_sec;
184
ram_addr_t ram_size;
185
int pit_min_timer_count = 0;
186
int nb_nics;
187
NICInfo nd_table[MAX_NICS];
188
int vm_running;
189
static int rtc_utc = 1;
190
static int rtc_date_offset = -1; /* -1 means no change */
191
int cirrus_vga_enabled = 1;
192
int vmsvga_enabled = 0;
193
#ifdef TARGET_SPARC
194
int graphic_width = 1024;
195
int graphic_height = 768;
196
int graphic_depth = 8;
197
#else
198
int graphic_width = 800;
199
int graphic_height = 600;
200
int graphic_depth = 15;
201
#endif
202
int full_screen = 0;
203
int no_frame = 0;
204
int no_quit = 0;
205
CharDriverState *serial_hds[MAX_SERIAL_PORTS];
206
CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
207
#ifdef TARGET_I386
208
int win2k_install_hack = 0;
209
#endif
210
int usb_enabled = 0;
211
static VLANState *first_vlan;
212
int smp_cpus = 1;
213
const char *vnc_display;
214
#if defined(TARGET_SPARC)
215
#define MAX_CPUS 16
216
#elif defined(TARGET_I386)
217
#define MAX_CPUS 255
218
#else
219
#define MAX_CPUS 1
220
#endif
221
int acpi_enabled = 1;
222
int fd_bootchk = 1;
223
int no_reboot = 0;
224
int no_shutdown = 0;
225
int cursor_hide = 1;
226
int graphic_rotate = 0;
227
int daemonize = 0;
228
const char *option_rom[MAX_OPTION_ROMS];
229
int nb_option_roms;
230
int semihosting_enabled = 0;
231
int autostart = 1;
232
#ifdef TARGET_ARM
233
int old_param = 0;
234
#endif
235
const char *qemu_name;
236
int alt_grab = 0;
237
#ifdef TARGET_SPARC
238
unsigned int nb_prom_envs = 0;
239
const char *prom_envs[MAX_PROM_ENVS];
240
#endif
241
int nb_drives_opt;
242
struct drive_opt {
243
    const char *file;
244
    char opt[1024];
245
} drives_opt[MAX_DRIVES];
246

    
247
static CPUState *cur_cpu;
248
static CPUState *next_cpu;
249
static int event_pending = 1;
250
/* Conversion factor from emulated instructions to virtual clock ticks.  */
251
static int icount_time_shift;
252
/* Arbitrarily pick 1MIPS as the minimum allowable speed.  */
253
#define MAX_ICOUNT_SHIFT 10
254
/* Compensate for varying guest execution speed.  */
255
static int64_t qemu_icount_bias;
256
QEMUTimer *icount_rt_timer;
257
QEMUTimer *icount_vm_timer;
258

    
259
uint8_t qemu_uuid[16];
260

    
261
#define TFR(expr) do { if ((expr) != -1) break; } while (errno == EINTR)
262

    
263
/***********************************************************/
264
/* x86 ISA bus support */
265

    
266
target_phys_addr_t isa_mem_base = 0;
267
PicState2 *isa_pic;
268

    
269
static IOPortReadFunc default_ioport_readb, default_ioport_readw, default_ioport_readl;
270
static IOPortWriteFunc default_ioport_writeb, default_ioport_writew, default_ioport_writel;
271

    
272
static uint32_t ioport_read(int index, uint32_t address)
273
{
274
    static IOPortReadFunc *default_func[3] = {
275
        default_ioport_readb,
276
        default_ioport_readw,
277
        default_ioport_readl
278
    };
279
    IOPortReadFunc *func = ioport_read_table[index][address];
280
    if (!func)
281
        func = default_func[index];
282
    return func(ioport_opaque[address], address);
283
}
284

    
285
static void ioport_write(int index, uint32_t address, uint32_t data)
286
{
287
    static IOPortWriteFunc *default_func[3] = {
288
        default_ioport_writeb,
289
        default_ioport_writew,
290
        default_ioport_writel
291
    };
292
    IOPortWriteFunc *func = ioport_write_table[index][address];
293
    if (!func)
294
        func = default_func[index];
295
    func(ioport_opaque[address], address, data);
296
}
297

    
298
static uint32_t default_ioport_readb(void *opaque, uint32_t address)
299
{
300
#ifdef DEBUG_UNUSED_IOPORT
301
    fprintf(stderr, "unused inb: port=0x%04x\n", address);
302
#endif
303
    return 0xff;
304
}
305

    
306
static void default_ioport_writeb(void *opaque, uint32_t address, uint32_t data)
307
{
308
#ifdef DEBUG_UNUSED_IOPORT
309
    fprintf(stderr, "unused outb: port=0x%04x data=0x%02x\n", address, data);
310
#endif
311
}
312

    
313
/* default is to make two byte accesses */
314
static uint32_t default_ioport_readw(void *opaque, uint32_t address)
315
{
316
    uint32_t data;
317
    data = ioport_read(0, address);
318
    address = (address + 1) & (MAX_IOPORTS - 1);
319
    data |= ioport_read(0, address) << 8;
320
    return data;
321
}
322

    
323
static void default_ioport_writew(void *opaque, uint32_t address, uint32_t data)
324
{
325
    ioport_write(0, address, data & 0xff);
326
    address = (address + 1) & (MAX_IOPORTS - 1);
327
    ioport_write(0, address, (data >> 8) & 0xff);
328
}
329

    
330
static uint32_t default_ioport_readl(void *opaque, uint32_t address)
331
{
332
#ifdef DEBUG_UNUSED_IOPORT
333
    fprintf(stderr, "unused inl: port=0x%04x\n", address);
334
#endif
335
    return 0xffffffff;
336
}
337

    
338
static void default_ioport_writel(void *opaque, uint32_t address, uint32_t data)
339
{
340
#ifdef DEBUG_UNUSED_IOPORT
341
    fprintf(stderr, "unused outl: port=0x%04x data=0x%02x\n", address, data);
342
#endif
343
}
344

    
345
/* size is the word size in byte */
346
int register_ioport_read(int start, int length, int size,
347
                         IOPortReadFunc *func, void *opaque)
348
{
349
    int i, bsize;
350

    
351
    if (size == 1) {
352
        bsize = 0;
353
    } else if (size == 2) {
354
        bsize = 1;
355
    } else if (size == 4) {
356
        bsize = 2;
357
    } else {
358
        hw_error("register_ioport_read: invalid size");
359
        return -1;
360
    }
361
    for(i = start; i < start + length; i += size) {
362
        ioport_read_table[bsize][i] = func;
363
        if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
364
            hw_error("register_ioport_read: invalid opaque");
365
        ioport_opaque[i] = opaque;
366
    }
367
    return 0;
368
}
369

    
370
/* size is the word size in byte */
371
int register_ioport_write(int start, int length, int size,
372
                          IOPortWriteFunc *func, void *opaque)
373
{
374
    int i, bsize;
375

    
376
    if (size == 1) {
377
        bsize = 0;
378
    } else if (size == 2) {
379
        bsize = 1;
380
    } else if (size == 4) {
381
        bsize = 2;
382
    } else {
383
        hw_error("register_ioport_write: invalid size");
384
        return -1;
385
    }
386
    for(i = start; i < start + length; i += size) {
387
        ioport_write_table[bsize][i] = func;
388
        if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
389
            hw_error("register_ioport_write: invalid opaque");
390
        ioport_opaque[i] = opaque;
391
    }
392
    return 0;
393
}
394

    
395
void isa_unassign_ioport(int start, int length)
396
{
397
    int i;
398

    
399
    for(i = start; i < start + length; i++) {
400
        ioport_read_table[0][i] = default_ioport_readb;
401
        ioport_read_table[1][i] = default_ioport_readw;
402
        ioport_read_table[2][i] = default_ioport_readl;
403

    
404
        ioport_write_table[0][i] = default_ioport_writeb;
405
        ioport_write_table[1][i] = default_ioport_writew;
406
        ioport_write_table[2][i] = default_ioport_writel;
407
    }
408
}
409

    
410
/***********************************************************/
411

    
412
void cpu_outb(CPUState *env, int addr, int val)
413
{
414
#ifdef DEBUG_IOPORT
415
    if (loglevel & CPU_LOG_IOPORT)
416
        fprintf(logfile, "outb: %04x %02x\n", addr, val);
417
#endif
418
    ioport_write(0, addr, val);
419
#ifdef USE_KQEMU
420
    if (env)
421
        env->last_io_time = cpu_get_time_fast();
422
#endif
423
}
424

    
425
void cpu_outw(CPUState *env, int addr, int val)
426
{
427
#ifdef DEBUG_IOPORT
428
    if (loglevel & CPU_LOG_IOPORT)
429
        fprintf(logfile, "outw: %04x %04x\n", addr, val);
430
#endif
431
    ioport_write(1, addr, val);
432
#ifdef USE_KQEMU
433
    if (env)
434
        env->last_io_time = cpu_get_time_fast();
435
#endif
436
}
437

    
438
void cpu_outl(CPUState *env, int addr, int val)
439
{
440
#ifdef DEBUG_IOPORT
441
    if (loglevel & CPU_LOG_IOPORT)
442
        fprintf(logfile, "outl: %04x %08x\n", addr, val);
443
#endif
444
    ioport_write(2, addr, val);
445
#ifdef USE_KQEMU
446
    if (env)
447
        env->last_io_time = cpu_get_time_fast();
448
#endif
449
}
450

    
451
int cpu_inb(CPUState *env, int addr)
452
{
453
    int val;
454
    val = ioport_read(0, addr);
455
#ifdef DEBUG_IOPORT
456
    if (loglevel & CPU_LOG_IOPORT)
457
        fprintf(logfile, "inb : %04x %02x\n", addr, val);
458
#endif
459
#ifdef USE_KQEMU
460
    if (env)
461
        env->last_io_time = cpu_get_time_fast();
462
#endif
463
    return val;
464
}
465

    
466
int cpu_inw(CPUState *env, int addr)
467
{
468
    int val;
469
    val = ioport_read(1, addr);
470
#ifdef DEBUG_IOPORT
471
    if (loglevel & CPU_LOG_IOPORT)
472
        fprintf(logfile, "inw : %04x %04x\n", addr, val);
473
#endif
474
#ifdef USE_KQEMU
475
    if (env)
476
        env->last_io_time = cpu_get_time_fast();
477
#endif
478
    return val;
479
}
480

    
481
int cpu_inl(CPUState *env, int addr)
482
{
483
    int val;
484
    val = ioport_read(2, addr);
485
#ifdef DEBUG_IOPORT
486
    if (loglevel & CPU_LOG_IOPORT)
487
        fprintf(logfile, "inl : %04x %08x\n", addr, val);
488
#endif
489
#ifdef USE_KQEMU
490
    if (env)
491
        env->last_io_time = cpu_get_time_fast();
492
#endif
493
    return val;
494
}
495

    
496
/***********************************************************/
497
void hw_error(const char *fmt, ...)
498
{
499
    va_list ap;
500
    CPUState *env;
501

    
502
    va_start(ap, fmt);
503
    fprintf(stderr, "qemu: hardware error: ");
504
    vfprintf(stderr, fmt, ap);
505
    fprintf(stderr, "\n");
506
    for(env = first_cpu; env != NULL; env = env->next_cpu) {
507
        fprintf(stderr, "CPU #%d:\n", env->cpu_index);
508
#ifdef TARGET_I386
509
        cpu_dump_state(env, stderr, fprintf, X86_DUMP_FPU);
510
#else
511
        cpu_dump_state(env, stderr, fprintf, 0);
512
#endif
513
    }
514
    va_end(ap);
515
    abort();
516
}
517

    
518
/***********************************************************/
519
/* keyboard/mouse */
520

    
521
static QEMUPutKBDEvent *qemu_put_kbd_event;
522
static void *qemu_put_kbd_event_opaque;
523
static QEMUPutMouseEntry *qemu_put_mouse_event_head;
524
static QEMUPutMouseEntry *qemu_put_mouse_event_current;
525

    
526
void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque)
527
{
528
    qemu_put_kbd_event_opaque = opaque;
529
    qemu_put_kbd_event = func;
530
}
531

    
532
QEMUPutMouseEntry *qemu_add_mouse_event_handler(QEMUPutMouseEvent *func,
533
                                                void *opaque, int absolute,
534
                                                const char *name)
535
{
536
    QEMUPutMouseEntry *s, *cursor;
537

    
538
    s = qemu_mallocz(sizeof(QEMUPutMouseEntry));
539
    if (!s)
540
        return NULL;
541

    
542
    s->qemu_put_mouse_event = func;
543
    s->qemu_put_mouse_event_opaque = opaque;
544
    s->qemu_put_mouse_event_absolute = absolute;
545
    s->qemu_put_mouse_event_name = qemu_strdup(name);
546
    s->next = NULL;
547

    
548
    if (!qemu_put_mouse_event_head) {
549
        qemu_put_mouse_event_head = qemu_put_mouse_event_current = s;
550
        return s;
551
    }
552

    
553
    cursor = qemu_put_mouse_event_head;
554
    while (cursor->next != NULL)
555
        cursor = cursor->next;
556

    
557
    cursor->next = s;
558
    qemu_put_mouse_event_current = s;
559

    
560
    return s;
561
}
562

    
563
void qemu_remove_mouse_event_handler(QEMUPutMouseEntry *entry)
564
{
565
    QEMUPutMouseEntry *prev = NULL, *cursor;
566

    
567
    if (!qemu_put_mouse_event_head || entry == NULL)
568
        return;
569

    
570
    cursor = qemu_put_mouse_event_head;
571
    while (cursor != NULL && cursor != entry) {
572
        prev = cursor;
573
        cursor = cursor->next;
574
    }
575

    
576
    if (cursor == NULL) // does not exist or list empty
577
        return;
578
    else if (prev == NULL) { // entry is head
579
        qemu_put_mouse_event_head = cursor->next;
580
        if (qemu_put_mouse_event_current == entry)
581
            qemu_put_mouse_event_current = cursor->next;
582
        qemu_free(entry->qemu_put_mouse_event_name);
583
        qemu_free(entry);
584
        return;
585
    }
586

    
587
    prev->next = entry->next;
588

    
589
    if (qemu_put_mouse_event_current == entry)
590
        qemu_put_mouse_event_current = prev;
591

    
592
    qemu_free(entry->qemu_put_mouse_event_name);
593
    qemu_free(entry);
594
}
595

    
596
void kbd_put_keycode(int keycode)
597
{
598
    if (qemu_put_kbd_event) {
599
        qemu_put_kbd_event(qemu_put_kbd_event_opaque, keycode);
600
    }
601
}
602

    
603
void kbd_mouse_event(int dx, int dy, int dz, int buttons_state)
604
{
605
    QEMUPutMouseEvent *mouse_event;
606
    void *mouse_event_opaque;
607
    int width;
608

    
609
    if (!qemu_put_mouse_event_current) {
610
        return;
611
    }
612

    
613
    mouse_event =
614
        qemu_put_mouse_event_current->qemu_put_mouse_event;
615
    mouse_event_opaque =
616
        qemu_put_mouse_event_current->qemu_put_mouse_event_opaque;
617

    
618
    if (mouse_event) {
619
        if (graphic_rotate) {
620
            if (qemu_put_mouse_event_current->qemu_put_mouse_event_absolute)
621
                width = 0x7fff;
622
            else
623
                width = graphic_width - 1;
624
            mouse_event(mouse_event_opaque,
625
                                 width - dy, dx, dz, buttons_state);
626
        } else
627
            mouse_event(mouse_event_opaque,
628
                                 dx, dy, dz, buttons_state);
629
    }
630
}
631

    
632
int kbd_mouse_is_absolute(void)
633
{
634
    if (!qemu_put_mouse_event_current)
635
        return 0;
636

    
637
    return qemu_put_mouse_event_current->qemu_put_mouse_event_absolute;
638
}
639

    
640
void do_info_mice(void)
641
{
642
    QEMUPutMouseEntry *cursor;
643
    int index = 0;
644

    
645
    if (!qemu_put_mouse_event_head) {
646
        term_printf("No mouse devices connected\n");
647
        return;
648
    }
649

    
650
    term_printf("Mouse devices available:\n");
651
    cursor = qemu_put_mouse_event_head;
652
    while (cursor != NULL) {
653
        term_printf("%c Mouse #%d: %s\n",
654
                    (cursor == qemu_put_mouse_event_current ? '*' : ' '),
655
                    index, cursor->qemu_put_mouse_event_name);
656
        index++;
657
        cursor = cursor->next;
658
    }
659
}
660

    
661
void do_mouse_set(int index)
662
{
663
    QEMUPutMouseEntry *cursor;
664
    int i = 0;
665

    
666
    if (!qemu_put_mouse_event_head) {
667
        term_printf("No mouse devices connected\n");
668
        return;
669
    }
670

    
671
    cursor = qemu_put_mouse_event_head;
672
    while (cursor != NULL && index != i) {
673
        i++;
674
        cursor = cursor->next;
675
    }
676

    
677
    if (cursor != NULL)
678
        qemu_put_mouse_event_current = cursor;
679
    else
680
        term_printf("Mouse at given index not found\n");
681
}
682

    
683
/* compute with 96 bit intermediate result: (a*b)/c */
684
uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
685
{
686
    union {
687
        uint64_t ll;
688
        struct {
689
#ifdef WORDS_BIGENDIAN
690
            uint32_t high, low;
691
#else
692
            uint32_t low, high;
693
#endif
694
        } l;
695
    } u, res;
696
    uint64_t rl, rh;
697

    
698
    u.ll = a;
699
    rl = (uint64_t)u.l.low * (uint64_t)b;
700
    rh = (uint64_t)u.l.high * (uint64_t)b;
701
    rh += (rl >> 32);
702
    res.l.high = rh / c;
703
    res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
704
    return res.ll;
705
}
706

    
707
/***********************************************************/
708
/* real time host monotonic timer */
709

    
710
#define QEMU_TIMER_BASE 1000000000LL
711

    
712
#ifdef WIN32
713

    
714
static int64_t clock_freq;
715

    
716
static void init_get_clock(void)
717
{
718
    LARGE_INTEGER freq;
719
    int ret;
720
    ret = QueryPerformanceFrequency(&freq);
721
    if (ret == 0) {
722
        fprintf(stderr, "Could not calibrate ticks\n");
723
        exit(1);
724
    }
725
    clock_freq = freq.QuadPart;
726
}
727

    
728
static int64_t get_clock(void)
729
{
730
    LARGE_INTEGER ti;
731
    QueryPerformanceCounter(&ti);
732
    return muldiv64(ti.QuadPart, QEMU_TIMER_BASE, clock_freq);
733
}
734

    
735
#else
736

    
737
static int use_rt_clock;
738

    
739
static void init_get_clock(void)
740
{
741
    use_rt_clock = 0;
742
#if defined(__linux__)
743
    {
744
        struct timespec ts;
745
        if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
746
            use_rt_clock = 1;
747
        }
748
    }
749
#endif
750
}
751

    
752
static int64_t get_clock(void)
753
{
754
#if defined(__linux__)
755
    if (use_rt_clock) {
756
        struct timespec ts;
757
        clock_gettime(CLOCK_MONOTONIC, &ts);
758
        return ts.tv_sec * 1000000000LL + ts.tv_nsec;
759
    } else
760
#endif
761
    {
762
        /* XXX: using gettimeofday leads to problems if the date
763
           changes, so it should be avoided. */
764
        struct timeval tv;
765
        gettimeofday(&tv, NULL);
766
        return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
767
    }
768
}
769
#endif
770

    
771
/* Return the virtual CPU time, based on the instruction counter.  */
772
static int64_t cpu_get_icount(void)
773
{
774
    int64_t icount;
775
    CPUState *env = cpu_single_env;;
776
    icount = qemu_icount;
777
    if (env) {
778
        if (!can_do_io(env))
779
            fprintf(stderr, "Bad clock read\n");
780
        icount -= (env->icount_decr.u16.low + env->icount_extra);
781
    }
782
    return qemu_icount_bias + (icount << icount_time_shift);
783
}
784

    
785
/***********************************************************/
786
/* guest cycle counter */
787

    
788
static int64_t cpu_ticks_prev;
789
static int64_t cpu_ticks_offset;
790
static int64_t cpu_clock_offset;
791
static int cpu_ticks_enabled;
792

    
793
/* return the host CPU cycle counter and handle stop/restart */
794
int64_t cpu_get_ticks(void)
795
{
796
    if (use_icount) {
797
        return cpu_get_icount();
798
    }
799
    if (!cpu_ticks_enabled) {
800
        return cpu_ticks_offset;
801
    } else {
802
        int64_t ticks;
803
        ticks = cpu_get_real_ticks();
804
        if (cpu_ticks_prev > ticks) {
805
            /* Note: non increasing ticks may happen if the host uses
806
               software suspend */
807
            cpu_ticks_offset += cpu_ticks_prev - ticks;
808
        }
809
        cpu_ticks_prev = ticks;
810
        return ticks + cpu_ticks_offset;
811
    }
812
}
813

    
814
/* return the host CPU monotonic timer and handle stop/restart */
815
static int64_t cpu_get_clock(void)
816
{
817
    int64_t ti;
818
    if (!cpu_ticks_enabled) {
819
        return cpu_clock_offset;
820
    } else {
821
        ti = get_clock();
822
        return ti + cpu_clock_offset;
823
    }
824
}
825

    
826
/* enable cpu_get_ticks() */
827
void cpu_enable_ticks(void)
828
{
829
    if (!cpu_ticks_enabled) {
830
        cpu_ticks_offset -= cpu_get_real_ticks();
831
        cpu_clock_offset -= get_clock();
832
        cpu_ticks_enabled = 1;
833
    }
834
}
835

    
836
/* disable cpu_get_ticks() : the clock is stopped. You must not call
837
   cpu_get_ticks() after that.  */
838
void cpu_disable_ticks(void)
839
{
840
    if (cpu_ticks_enabled) {
841
        cpu_ticks_offset = cpu_get_ticks();
842
        cpu_clock_offset = cpu_get_clock();
843
        cpu_ticks_enabled = 0;
844
    }
845
}
846

    
847
/***********************************************************/
848
/* timers */
849

    
850
#define QEMU_TIMER_REALTIME 0
851
#define QEMU_TIMER_VIRTUAL  1
852

    
853
struct QEMUClock {
854
    int type;
855
    /* XXX: add frequency */
856
};
857

    
858
struct QEMUTimer {
859
    QEMUClock *clock;
860
    int64_t expire_time;
861
    QEMUTimerCB *cb;
862
    void *opaque;
863
    struct QEMUTimer *next;
864
};
865

    
866
struct qemu_alarm_timer {
867
    char const *name;
868
    unsigned int flags;
869

    
870
    int (*start)(struct qemu_alarm_timer *t);
871
    void (*stop)(struct qemu_alarm_timer *t);
872
    void (*rearm)(struct qemu_alarm_timer *t);
873
    void *priv;
874
};
875

    
876
#define ALARM_FLAG_DYNTICKS  0x1
877
#define ALARM_FLAG_EXPIRED   0x2
878

    
879
static inline int alarm_has_dynticks(struct qemu_alarm_timer *t)
880
{
881
    return t->flags & ALARM_FLAG_DYNTICKS;
882
}
883

    
884
static void qemu_rearm_alarm_timer(struct qemu_alarm_timer *t)
885
{
886
    if (!alarm_has_dynticks(t))
887
        return;
888

    
889
    t->rearm(t);
890
}
891

    
892
/* TODO: MIN_TIMER_REARM_US should be optimized */
893
#define MIN_TIMER_REARM_US 250
894

    
895
static struct qemu_alarm_timer *alarm_timer;
896

    
897
#ifdef _WIN32
898

    
899
struct qemu_alarm_win32 {
900
    MMRESULT timerId;
901
    HANDLE host_alarm;
902
    unsigned int period;
903
} alarm_win32_data = {0, NULL, -1};
904

    
905
static int win32_start_timer(struct qemu_alarm_timer *t);
906
static void win32_stop_timer(struct qemu_alarm_timer *t);
907
static void win32_rearm_timer(struct qemu_alarm_timer *t);
908

    
909
#else
910

    
911
static int unix_start_timer(struct qemu_alarm_timer *t);
912
static void unix_stop_timer(struct qemu_alarm_timer *t);
913

    
914
#ifdef __linux__
915

    
916
static int dynticks_start_timer(struct qemu_alarm_timer *t);
917
static void dynticks_stop_timer(struct qemu_alarm_timer *t);
918
static void dynticks_rearm_timer(struct qemu_alarm_timer *t);
919

    
920
static int hpet_start_timer(struct qemu_alarm_timer *t);
921
static void hpet_stop_timer(struct qemu_alarm_timer *t);
922

    
923
static int rtc_start_timer(struct qemu_alarm_timer *t);
924
static void rtc_stop_timer(struct qemu_alarm_timer *t);
925

    
926
#endif /* __linux__ */
927

    
928
#endif /* _WIN32 */
929

    
930
/* Correlation between real and virtual time is always going to be
931
   fairly approximate, so ignore small variation.
932
   When the guest is idle real and virtual time will be aligned in
933
   the IO wait loop.  */
934
#define ICOUNT_WOBBLE (QEMU_TIMER_BASE / 10)
935

    
936
static void icount_adjust(void)
937
{
938
    int64_t cur_time;
939
    int64_t cur_icount;
940
    int64_t delta;
941
    static int64_t last_delta;
942
    /* If the VM is not running, then do nothing.  */
943
    if (!vm_running)
944
        return;
945

    
946
    cur_time = cpu_get_clock();
947
    cur_icount = qemu_get_clock(vm_clock);
948
    delta = cur_icount - cur_time;
949
    /* FIXME: This is a very crude algorithm, somewhat prone to oscillation.  */
950
    if (delta > 0
951
        && last_delta + ICOUNT_WOBBLE < delta * 2
952
        && icount_time_shift > 0) {
953
        /* The guest is getting too far ahead.  Slow time down.  */
954
        icount_time_shift--;
955
    }
956
    if (delta < 0
957
        && last_delta - ICOUNT_WOBBLE > delta * 2
958
        && icount_time_shift < MAX_ICOUNT_SHIFT) {
959
        /* The guest is getting too far behind.  Speed time up.  */
960
        icount_time_shift++;
961
    }
962
    last_delta = delta;
963
    qemu_icount_bias = cur_icount - (qemu_icount << icount_time_shift);
964
}
965

    
966
static void icount_adjust_rt(void * opaque)
967
{
968
    qemu_mod_timer(icount_rt_timer,
969
                   qemu_get_clock(rt_clock) + 1000);
970
    icount_adjust();
971
}
972

    
973
static void icount_adjust_vm(void * opaque)
974
{
975
    qemu_mod_timer(icount_vm_timer,
976
                   qemu_get_clock(vm_clock) + QEMU_TIMER_BASE / 10);
977
    icount_adjust();
978
}
979

    
980
static void init_icount_adjust(void)
981
{
982
    /* Have both realtime and virtual time triggers for speed adjustment.
983
       The realtime trigger catches emulated time passing too slowly,
984
       the virtual time trigger catches emulated time passing too fast.
985
       Realtime triggers occur even when idle, so use them less frequently
986
       than VM triggers.  */
987
    icount_rt_timer = qemu_new_timer(rt_clock, icount_adjust_rt, NULL);
988
    qemu_mod_timer(icount_rt_timer,
989
                   qemu_get_clock(rt_clock) + 1000);
990
    icount_vm_timer = qemu_new_timer(vm_clock, icount_adjust_vm, NULL);
991
    qemu_mod_timer(icount_vm_timer,
992
                   qemu_get_clock(vm_clock) + QEMU_TIMER_BASE / 10);
993
}
994

    
995
static struct qemu_alarm_timer alarm_timers[] = {
996
#ifndef _WIN32
997
#ifdef __linux__
998
    {"dynticks", ALARM_FLAG_DYNTICKS, dynticks_start_timer,
999
     dynticks_stop_timer, dynticks_rearm_timer, NULL},
1000
    /* HPET - if available - is preferred */
1001
    {"hpet", 0, hpet_start_timer, hpet_stop_timer, NULL, NULL},
1002
    /* ...otherwise try RTC */
1003
    {"rtc", 0, rtc_start_timer, rtc_stop_timer, NULL, NULL},
1004
#endif
1005
    {"unix", 0, unix_start_timer, unix_stop_timer, NULL, NULL},
1006
#else
1007
    {"dynticks", ALARM_FLAG_DYNTICKS, win32_start_timer,
1008
     win32_stop_timer, win32_rearm_timer, &alarm_win32_data},
1009
    {"win32", 0, win32_start_timer,
1010
     win32_stop_timer, NULL, &alarm_win32_data},
1011
#endif
1012
    {NULL, }
1013
};
1014

    
1015
static void show_available_alarms(void)
1016
{
1017
    int i;
1018

    
1019
    printf("Available alarm timers, in order of precedence:\n");
1020
    for (i = 0; alarm_timers[i].name; i++)
1021
        printf("%s\n", alarm_timers[i].name);
1022
}
1023

    
1024
static void configure_alarms(char const *opt)
1025
{
1026
    int i;
1027
    int cur = 0;
1028
    int count = (sizeof(alarm_timers) / sizeof(*alarm_timers)) - 1;
1029
    char *arg;
1030
    char *name;
1031
    struct qemu_alarm_timer tmp;
1032

    
1033
    if (!strcmp(opt, "?")) {
1034
        show_available_alarms();
1035
        exit(0);
1036
    }
1037

    
1038
    arg = strdup(opt);
1039

    
1040
    /* Reorder the array */
1041
    name = strtok(arg, ",");
1042
    while (name) {
1043
        for (i = 0; i < count && alarm_timers[i].name; i++) {
1044
            if (!strcmp(alarm_timers[i].name, name))
1045
                break;
1046
        }
1047

    
1048
        if (i == count) {
1049
            fprintf(stderr, "Unknown clock %s\n", name);
1050
            goto next;
1051
        }
1052

    
1053
        if (i < cur)
1054
            /* Ignore */
1055
            goto next;
1056

    
1057
        /* Swap */
1058
        tmp = alarm_timers[i];
1059
        alarm_timers[i] = alarm_timers[cur];
1060
        alarm_timers[cur] = tmp;
1061

    
1062
        cur++;
1063
next:
1064
        name = strtok(NULL, ",");
1065
    }
1066

    
1067
    free(arg);
1068

    
1069
    if (cur) {
1070
        /* Disable remaining timers */
1071
        for (i = cur; i < count; i++)
1072
            alarm_timers[i].name = NULL;
1073
    } else {
1074
        show_available_alarms();
1075
        exit(1);
1076
    }
1077
}
1078

    
1079
QEMUClock *rt_clock;
1080
QEMUClock *vm_clock;
1081

    
1082
static QEMUTimer *active_timers[2];
1083

    
1084
static QEMUClock *qemu_new_clock(int type)
1085
{
1086
    QEMUClock *clock;
1087
    clock = qemu_mallocz(sizeof(QEMUClock));
1088
    if (!clock)
1089
        return NULL;
1090
    clock->type = type;
1091
    return clock;
1092
}
1093

    
1094
QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque)
1095
{
1096
    QEMUTimer *ts;
1097

    
1098
    ts = qemu_mallocz(sizeof(QEMUTimer));
1099
    ts->clock = clock;
1100
    ts->cb = cb;
1101
    ts->opaque = opaque;
1102
    return ts;
1103
}
1104

    
1105
void qemu_free_timer(QEMUTimer *ts)
1106
{
1107
    qemu_free(ts);
1108
}
1109

    
1110
/* stop a timer, but do not dealloc it */
1111
void qemu_del_timer(QEMUTimer *ts)
1112
{
1113
    QEMUTimer **pt, *t;
1114

    
1115
    /* NOTE: this code must be signal safe because
1116
       qemu_timer_expired() can be called from a signal. */
1117
    pt = &active_timers[ts->clock->type];
1118
    for(;;) {
1119
        t = *pt;
1120
        if (!t)
1121
            break;
1122
        if (t == ts) {
1123
            *pt = t->next;
1124
            break;
1125
        }
1126
        pt = &t->next;
1127
    }
1128
}
1129

    
1130
/* modify the current timer so that it will be fired when current_time
1131
   >= expire_time. The corresponding callback will be called. */
1132
void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
1133
{
1134
    QEMUTimer **pt, *t;
1135

    
1136
    qemu_del_timer(ts);
1137

    
1138
    /* add the timer in the sorted list */
1139
    /* NOTE: this code must be signal safe because
1140
       qemu_timer_expired() can be called from a signal. */
1141
    pt = &active_timers[ts->clock->type];
1142
    for(;;) {
1143
        t = *pt;
1144
        if (!t)
1145
            break;
1146
        if (t->expire_time > expire_time)
1147
            break;
1148
        pt = &t->next;
1149
    }
1150
    ts->expire_time = expire_time;
1151
    ts->next = *pt;
1152
    *pt = ts;
1153

    
1154
    /* Rearm if necessary  */
1155
    if (pt == &active_timers[ts->clock->type]) {
1156
        if ((alarm_timer->flags & ALARM_FLAG_EXPIRED) == 0) {
1157
            qemu_rearm_alarm_timer(alarm_timer);
1158
        }
1159
        /* Interrupt execution to force deadline recalculation.  */
1160
        if (use_icount && cpu_single_env) {
1161
            cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
1162
        }
1163
    }
1164
}
1165

    
1166
int qemu_timer_pending(QEMUTimer *ts)
1167
{
1168
    QEMUTimer *t;
1169
    for(t = active_timers[ts->clock->type]; t != NULL; t = t->next) {
1170
        if (t == ts)
1171
            return 1;
1172
    }
1173
    return 0;
1174
}
1175

    
1176
static inline int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
1177
{
1178
    if (!timer_head)
1179
        return 0;
1180
    return (timer_head->expire_time <= current_time);
1181
}
1182

    
1183
static void qemu_run_timers(QEMUTimer **ptimer_head, int64_t current_time)
1184
{
1185
    QEMUTimer *ts;
1186

    
1187
    for(;;) {
1188
        ts = *ptimer_head;
1189
        if (!ts || ts->expire_time > current_time)
1190
            break;
1191
        /* remove timer from the list before calling the callback */
1192
        *ptimer_head = ts->next;
1193
        ts->next = NULL;
1194

    
1195
        /* run the callback (the timer list can be modified) */
1196
        ts->cb(ts->opaque);
1197
    }
1198
}
1199

    
1200
int64_t qemu_get_clock(QEMUClock *clock)
1201
{
1202
    switch(clock->type) {
1203
    case QEMU_TIMER_REALTIME:
1204
        return get_clock() / 1000000;
1205
    default:
1206
    case QEMU_TIMER_VIRTUAL:
1207
        if (use_icount) {
1208
            return cpu_get_icount();
1209
        } else {
1210
            return cpu_get_clock();
1211
        }
1212
    }
1213
}
1214

    
1215
static void init_timers(void)
1216
{
1217
    init_get_clock();
1218
    ticks_per_sec = QEMU_TIMER_BASE;
1219
    rt_clock = qemu_new_clock(QEMU_TIMER_REALTIME);
1220
    vm_clock = qemu_new_clock(QEMU_TIMER_VIRTUAL);
1221
}
1222

    
1223
/* save a timer */
1224
void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
1225
{
1226
    uint64_t expire_time;
1227

    
1228
    if (qemu_timer_pending(ts)) {
1229
        expire_time = ts->expire_time;
1230
    } else {
1231
        expire_time = -1;
1232
    }
1233
    qemu_put_be64(f, expire_time);
1234
}
1235

    
1236
void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
1237
{
1238
    uint64_t expire_time;
1239

    
1240
    expire_time = qemu_get_be64(f);
1241
    if (expire_time != -1) {
1242
        qemu_mod_timer(ts, expire_time);
1243
    } else {
1244
        qemu_del_timer(ts);
1245
    }
1246
}
1247

    
1248
static void timer_save(QEMUFile *f, void *opaque)
1249
{
1250
    if (cpu_ticks_enabled) {
1251
        hw_error("cannot save state if virtual timers are running");
1252
    }
1253
    qemu_put_be64(f, cpu_ticks_offset);
1254
    qemu_put_be64(f, ticks_per_sec);
1255
    qemu_put_be64(f, cpu_clock_offset);
1256
}
1257

    
1258
static int timer_load(QEMUFile *f, void *opaque, int version_id)
1259
{
1260
    if (version_id != 1 && version_id != 2)
1261
        return -EINVAL;
1262
    if (cpu_ticks_enabled) {
1263
        return -EINVAL;
1264
    }
1265
    cpu_ticks_offset=qemu_get_be64(f);
1266
    ticks_per_sec=qemu_get_be64(f);
1267
    if (version_id == 2) {
1268
        cpu_clock_offset=qemu_get_be64(f);
1269
    }
1270
    return 0;
1271
}
1272

    
1273
#ifdef _WIN32
1274
void CALLBACK host_alarm_handler(UINT uTimerID, UINT uMsg,
1275
                                 DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2)
1276
#else
1277
static void host_alarm_handler(int host_signum)
1278
#endif
1279
{
1280
#if 0
1281
#define DISP_FREQ 1000
1282
    {
1283
        static int64_t delta_min = INT64_MAX;
1284
        static int64_t delta_max, delta_cum, last_clock, delta, ti;
1285
        static int count;
1286
        ti = qemu_get_clock(vm_clock);
1287
        if (last_clock != 0) {
1288
            delta = ti - last_clock;
1289
            if (delta < delta_min)
1290
                delta_min = delta;
1291
            if (delta > delta_max)
1292
                delta_max = delta;
1293
            delta_cum += delta;
1294
            if (++count == DISP_FREQ) {
1295
                printf("timer: min=%" PRId64 " us max=%" PRId64 " us avg=%" PRId64 " us avg_freq=%0.3f Hz\n",
1296
                       muldiv64(delta_min, 1000000, ticks_per_sec),
1297
                       muldiv64(delta_max, 1000000, ticks_per_sec),
1298
                       muldiv64(delta_cum, 1000000 / DISP_FREQ, ticks_per_sec),
1299
                       (double)ticks_per_sec / ((double)delta_cum / DISP_FREQ));
1300
                count = 0;
1301
                delta_min = INT64_MAX;
1302
                delta_max = 0;
1303
                delta_cum = 0;
1304
            }
1305
        }
1306
        last_clock = ti;
1307
    }
1308
#endif
1309
    if (alarm_has_dynticks(alarm_timer) ||
1310
        (!use_icount &&
1311
            qemu_timer_expired(active_timers[QEMU_TIMER_VIRTUAL],
1312
                               qemu_get_clock(vm_clock))) ||
1313
        qemu_timer_expired(active_timers[QEMU_TIMER_REALTIME],
1314
                           qemu_get_clock(rt_clock))) {
1315
#ifdef _WIN32
1316
        struct qemu_alarm_win32 *data = ((struct qemu_alarm_timer*)dwUser)->priv;
1317
        SetEvent(data->host_alarm);
1318
#endif
1319
        CPUState *env = next_cpu;
1320

    
1321
        alarm_timer->flags |= ALARM_FLAG_EXPIRED;
1322

    
1323
        if (env) {
1324
            /* stop the currently executing cpu because a timer occured */
1325
            cpu_interrupt(env, CPU_INTERRUPT_EXIT);
1326
#ifdef USE_KQEMU
1327
            if (env->kqemu_enabled) {
1328
                kqemu_cpu_interrupt(env);
1329
            }
1330
#endif
1331
        }
1332
        event_pending = 1;
1333
    }
1334
}
1335

    
1336
static int64_t qemu_next_deadline(void)
1337
{
1338
    int64_t delta;
1339

    
1340
    if (active_timers[QEMU_TIMER_VIRTUAL]) {
1341
        delta = active_timers[QEMU_TIMER_VIRTUAL]->expire_time -
1342
                     qemu_get_clock(vm_clock);
1343
    } else {
1344
        /* To avoid problems with overflow limit this to 2^32.  */
1345
        delta = INT32_MAX;
1346
    }
1347

    
1348
    if (delta < 0)
1349
        delta = 0;
1350

    
1351
    return delta;
1352
}
1353

    
1354
#if defined(__linux__) || defined(_WIN32)
1355
static uint64_t qemu_next_deadline_dyntick(void)
1356
{
1357
    int64_t delta;
1358
    int64_t rtdelta;
1359

    
1360
    if (use_icount)
1361
        delta = INT32_MAX;
1362
    else
1363
        delta = (qemu_next_deadline() + 999) / 1000;
1364

    
1365
    if (active_timers[QEMU_TIMER_REALTIME]) {
1366
        rtdelta = (active_timers[QEMU_TIMER_REALTIME]->expire_time -
1367
                 qemu_get_clock(rt_clock))*1000;
1368
        if (rtdelta < delta)
1369
            delta = rtdelta;
1370
    }
1371

    
1372
    if (delta < MIN_TIMER_REARM_US)
1373
        delta = MIN_TIMER_REARM_US;
1374

    
1375
    return delta;
1376
}
1377
#endif
1378

    
1379
#ifndef _WIN32
1380

    
1381
#if defined(__linux__)
1382

    
1383
#define RTC_FREQ 1024
1384

    
1385
static void enable_sigio_timer(int fd)
1386
{
1387
    struct sigaction act;
1388

    
1389
    /* timer signal */
1390
    sigfillset(&act.sa_mask);
1391
    act.sa_flags = 0;
1392
    act.sa_handler = host_alarm_handler;
1393

    
1394
    sigaction(SIGIO, &act, NULL);
1395
    fcntl(fd, F_SETFL, O_ASYNC);
1396
    fcntl(fd, F_SETOWN, getpid());
1397
}
1398

    
1399
static int hpet_start_timer(struct qemu_alarm_timer *t)
1400
{
1401
    struct hpet_info info;
1402
    int r, fd;
1403

    
1404
    fd = open("/dev/hpet", O_RDONLY);
1405
    if (fd < 0)
1406
        return -1;
1407

    
1408
    /* Set frequency */
1409
    r = ioctl(fd, HPET_IRQFREQ, RTC_FREQ);
1410
    if (r < 0) {
1411
        fprintf(stderr, "Could not configure '/dev/hpet' to have a 1024Hz timer. This is not a fatal\n"
1412
                "error, but for better emulation accuracy type:\n"
1413
                "'echo 1024 > /proc/sys/dev/hpet/max-user-freq' as root.\n");
1414
        goto fail;
1415
    }
1416

    
1417
    /* Check capabilities */
1418
    r = ioctl(fd, HPET_INFO, &info);
1419
    if (r < 0)
1420
        goto fail;
1421

    
1422
    /* Enable periodic mode */
1423
    r = ioctl(fd, HPET_EPI, 0);
1424
    if (info.hi_flags && (r < 0))
1425
        goto fail;
1426

    
1427
    /* Enable interrupt */
1428
    r = ioctl(fd, HPET_IE_ON, 0);
1429
    if (r < 0)
1430
        goto fail;
1431

    
1432
    enable_sigio_timer(fd);
1433
    t->priv = (void *)(long)fd;
1434

    
1435
    return 0;
1436
fail:
1437
    close(fd);
1438
    return -1;
1439
}
1440

    
1441
static void hpet_stop_timer(struct qemu_alarm_timer *t)
1442
{
1443
    int fd = (long)t->priv;
1444

    
1445
    close(fd);
1446
}
1447

    
1448
static int rtc_start_timer(struct qemu_alarm_timer *t)
1449
{
1450
    int rtc_fd;
1451
    unsigned long current_rtc_freq = 0;
1452

    
1453
    TFR(rtc_fd = open("/dev/rtc", O_RDONLY));
1454
    if (rtc_fd < 0)
1455
        return -1;
1456
    ioctl(rtc_fd, RTC_IRQP_READ, &current_rtc_freq);
1457
    if (current_rtc_freq != RTC_FREQ &&
1458
        ioctl(rtc_fd, RTC_IRQP_SET, RTC_FREQ) < 0) {
1459
        fprintf(stderr, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
1460
                "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
1461
                "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
1462
        goto fail;
1463
    }
1464
    if (ioctl(rtc_fd, RTC_PIE_ON, 0) < 0) {
1465
    fail:
1466
        close(rtc_fd);
1467
        return -1;
1468
    }
1469

    
1470
    enable_sigio_timer(rtc_fd);
1471

    
1472
    t->priv = (void *)(long)rtc_fd;
1473

    
1474
    return 0;
1475
}
1476

    
1477
static void rtc_stop_timer(struct qemu_alarm_timer *t)
1478
{
1479
    int rtc_fd = (long)t->priv;
1480

    
1481
    close(rtc_fd);
1482
}
1483

    
1484
static int dynticks_start_timer(struct qemu_alarm_timer *t)
1485
{
1486
    struct sigevent ev;
1487
    timer_t host_timer;
1488
    struct sigaction act;
1489

    
1490
    sigfillset(&act.sa_mask);
1491
    act.sa_flags = 0;
1492
    act.sa_handler = host_alarm_handler;
1493

    
1494
    sigaction(SIGALRM, &act, NULL);
1495

    
1496
    ev.sigev_value.sival_int = 0;
1497
    ev.sigev_notify = SIGEV_SIGNAL;
1498
    ev.sigev_signo = SIGALRM;
1499

    
1500
    if (timer_create(CLOCK_REALTIME, &ev, &host_timer)) {
1501
        perror("timer_create");
1502

    
1503
        /* disable dynticks */
1504
        fprintf(stderr, "Dynamic Ticks disabled\n");
1505

    
1506
        return -1;
1507
    }
1508

    
1509
    t->priv = (void *)host_timer;
1510

    
1511
    return 0;
1512
}
1513

    
1514
static void dynticks_stop_timer(struct qemu_alarm_timer *t)
1515
{
1516
    timer_t host_timer = (timer_t)t->priv;
1517

    
1518
    timer_delete(host_timer);
1519
}
1520

    
1521
static void dynticks_rearm_timer(struct qemu_alarm_timer *t)
1522
{
1523
    timer_t host_timer = (timer_t)t->priv;
1524
    struct itimerspec timeout;
1525
    int64_t nearest_delta_us = INT64_MAX;
1526
    int64_t current_us;
1527

    
1528
    if (!active_timers[QEMU_TIMER_REALTIME] &&
1529
                !active_timers[QEMU_TIMER_VIRTUAL])
1530
        return;
1531

    
1532
    nearest_delta_us = qemu_next_deadline_dyntick();
1533

    
1534
    /* check whether a timer is already running */
1535
    if (timer_gettime(host_timer, &timeout)) {
1536
        perror("gettime");
1537
        fprintf(stderr, "Internal timer error: aborting\n");
1538
        exit(1);
1539
    }
1540
    current_us = timeout.it_value.tv_sec * 1000000 + timeout.it_value.tv_nsec/1000;
1541
    if (current_us && current_us <= nearest_delta_us)
1542
        return;
1543

    
1544
    timeout.it_interval.tv_sec = 0;
1545
    timeout.it_interval.tv_nsec = 0; /* 0 for one-shot timer */
1546
    timeout.it_value.tv_sec =  nearest_delta_us / 1000000;
1547
    timeout.it_value.tv_nsec = (nearest_delta_us % 1000000) * 1000;
1548
    if (timer_settime(host_timer, 0 /* RELATIVE */, &timeout, NULL)) {
1549
        perror("settime");
1550
        fprintf(stderr, "Internal timer error: aborting\n");
1551
        exit(1);
1552
    }
1553
}
1554

    
1555
#endif /* defined(__linux__) */
1556

    
1557
static int unix_start_timer(struct qemu_alarm_timer *t)
1558
{
1559
    struct sigaction act;
1560
    struct itimerval itv;
1561
    int err;
1562

    
1563
    /* timer signal */
1564
    sigfillset(&act.sa_mask);
1565
    act.sa_flags = 0;
1566
    act.sa_handler = host_alarm_handler;
1567

    
1568
    sigaction(SIGALRM, &act, NULL);
1569

    
1570
    itv.it_interval.tv_sec = 0;
1571
    /* for i386 kernel 2.6 to get 1 ms */
1572
    itv.it_interval.tv_usec = 999;
1573
    itv.it_value.tv_sec = 0;
1574
    itv.it_value.tv_usec = 10 * 1000;
1575

    
1576
    err = setitimer(ITIMER_REAL, &itv, NULL);
1577
    if (err)
1578
        return -1;
1579

    
1580
    return 0;
1581
}
1582

    
1583
static void unix_stop_timer(struct qemu_alarm_timer *t)
1584
{
1585
    struct itimerval itv;
1586

    
1587
    memset(&itv, 0, sizeof(itv));
1588
    setitimer(ITIMER_REAL, &itv, NULL);
1589
}
1590

    
1591
#endif /* !defined(_WIN32) */
1592

    
1593
#ifdef _WIN32
1594

    
1595
static int win32_start_timer(struct qemu_alarm_timer *t)
1596
{
1597
    TIMECAPS tc;
1598
    struct qemu_alarm_win32 *data = t->priv;
1599
    UINT flags;
1600

    
1601
    data->host_alarm = CreateEvent(NULL, FALSE, FALSE, NULL);
1602
    if (!data->host_alarm) {
1603
        perror("Failed CreateEvent");
1604
        return -1;
1605
    }
1606

    
1607
    memset(&tc, 0, sizeof(tc));
1608
    timeGetDevCaps(&tc, sizeof(tc));
1609

    
1610
    if (data->period < tc.wPeriodMin)
1611
        data->period = tc.wPeriodMin;
1612

    
1613
    timeBeginPeriod(data->period);
1614

    
1615
    flags = TIME_CALLBACK_FUNCTION;
1616
    if (alarm_has_dynticks(t))
1617
        flags |= TIME_ONESHOT;
1618
    else
1619
        flags |= TIME_PERIODIC;
1620

    
1621
    data->timerId = timeSetEvent(1,         // interval (ms)
1622
                        data->period,       // resolution
1623
                        host_alarm_handler, // function
1624
                        (DWORD)t,           // parameter
1625
                        flags);
1626

    
1627
    if (!data->timerId) {
1628
        perror("Failed to initialize win32 alarm timer");
1629

    
1630
        timeEndPeriod(data->period);
1631
        CloseHandle(data->host_alarm);
1632
        return -1;
1633
    }
1634

    
1635
    qemu_add_wait_object(data->host_alarm, NULL, NULL);
1636

    
1637
    return 0;
1638
}
1639

    
1640
static void win32_stop_timer(struct qemu_alarm_timer *t)
1641
{
1642
    struct qemu_alarm_win32 *data = t->priv;
1643

    
1644
    timeKillEvent(data->timerId);
1645
    timeEndPeriod(data->period);
1646

    
1647
    CloseHandle(data->host_alarm);
1648
}
1649

    
1650
static void win32_rearm_timer(struct qemu_alarm_timer *t)
1651
{
1652
    struct qemu_alarm_win32 *data = t->priv;
1653
    uint64_t nearest_delta_us;
1654

    
1655
    if (!active_timers[QEMU_TIMER_REALTIME] &&
1656
                !active_timers[QEMU_TIMER_VIRTUAL])
1657
        return;
1658

    
1659
    nearest_delta_us = qemu_next_deadline_dyntick();
1660
    nearest_delta_us /= 1000;
1661

    
1662
    timeKillEvent(data->timerId);
1663

    
1664
    data->timerId = timeSetEvent(1,
1665
                        data->period,
1666
                        host_alarm_handler,
1667
                        (DWORD)t,
1668
                        TIME_ONESHOT | TIME_PERIODIC);
1669

    
1670
    if (!data->timerId) {
1671
        perror("Failed to re-arm win32 alarm timer");
1672

    
1673
        timeEndPeriod(data->period);
1674
        CloseHandle(data->host_alarm);
1675
        exit(1);
1676
    }
1677
}
1678

    
1679
#endif /* _WIN32 */
1680

    
1681
static void init_timer_alarm(void)
1682
{
1683
    struct qemu_alarm_timer *t;
1684
    int i, err = -1;
1685

    
1686
    for (i = 0; alarm_timers[i].name; i++) {
1687
        t = &alarm_timers[i];
1688

    
1689
        err = t->start(t);
1690
        if (!err)
1691
            break;
1692
    }
1693

    
1694
    if (err) {
1695
        fprintf(stderr, "Unable to find any suitable alarm timer.\n");
1696
        fprintf(stderr, "Terminating\n");
1697
        exit(1);
1698
    }
1699

    
1700
    alarm_timer = t;
1701
}
1702

    
1703
static void quit_timers(void)
1704
{
1705
    alarm_timer->stop(alarm_timer);
1706
    alarm_timer = NULL;
1707
}
1708

    
1709
/***********************************************************/
1710
/* host time/date access */
1711
void qemu_get_timedate(struct tm *tm, int offset)
1712
{
1713
    time_t ti;
1714
    struct tm *ret;
1715

    
1716
    time(&ti);
1717
    ti += offset;
1718
    if (rtc_date_offset == -1) {
1719
        if (rtc_utc)
1720
            ret = gmtime(&ti);
1721
        else
1722
            ret = localtime(&ti);
1723
    } else {
1724
        ti -= rtc_date_offset;
1725
        ret = gmtime(&ti);
1726
    }
1727

    
1728
    memcpy(tm, ret, sizeof(struct tm));
1729
}
1730

    
1731
int qemu_timedate_diff(struct tm *tm)
1732
{
1733
    time_t seconds;
1734

    
1735
    if (rtc_date_offset == -1)
1736
        if (rtc_utc)
1737
            seconds = mktimegm(tm);
1738
        else
1739
            seconds = mktime(tm);
1740
    else
1741
        seconds = mktimegm(tm) + rtc_date_offset;
1742

    
1743
    return seconds - time(NULL);
1744
}
1745

    
1746
/***********************************************************/
1747
/* character device */
1748

    
1749
static void qemu_chr_event(CharDriverState *s, int event)
1750
{
1751
    if (!s->chr_event)
1752
        return;
1753
    s->chr_event(s->handler_opaque, event);
1754
}
1755

    
1756
static void qemu_chr_reset_bh(void *opaque)
1757
{
1758
    CharDriverState *s = opaque;
1759
    qemu_chr_event(s, CHR_EVENT_RESET);
1760
    qemu_bh_delete(s->bh);
1761
    s->bh = NULL;
1762
}
1763

    
1764
void qemu_chr_reset(CharDriverState *s)
1765
{
1766
    if (s->bh == NULL) {
1767
        s->bh = qemu_bh_new(qemu_chr_reset_bh, s);
1768
        qemu_bh_schedule(s->bh);
1769
    }
1770
}
1771

    
1772
int qemu_chr_write(CharDriverState *s, const uint8_t *buf, int len)
1773
{
1774
    return s->chr_write(s, buf, len);
1775
}
1776

    
1777
int qemu_chr_ioctl(CharDriverState *s, int cmd, void *arg)
1778
{
1779
    if (!s->chr_ioctl)
1780
        return -ENOTSUP;
1781
    return s->chr_ioctl(s, cmd, arg);
1782
}
1783

    
1784
int qemu_chr_can_read(CharDriverState *s)
1785
{
1786
    if (!s->chr_can_read)
1787
        return 0;
1788
    return s->chr_can_read(s->handler_opaque);
1789
}
1790

    
1791
void qemu_chr_read(CharDriverState *s, uint8_t *buf, int len)
1792
{
1793
    s->chr_read(s->handler_opaque, buf, len);
1794
}
1795

    
1796
void qemu_chr_accept_input(CharDriverState *s)
1797
{
1798
    if (s->chr_accept_input)
1799
        s->chr_accept_input(s);
1800
}
1801

    
1802
void qemu_chr_printf(CharDriverState *s, const char *fmt, ...)
1803
{
1804
    char buf[4096];
1805
    va_list ap;
1806
    va_start(ap, fmt);
1807
    vsnprintf(buf, sizeof(buf), fmt, ap);
1808
    qemu_chr_write(s, (uint8_t *)buf, strlen(buf));
1809
    va_end(ap);
1810
}
1811

    
1812
void qemu_chr_send_event(CharDriverState *s, int event)
1813
{
1814
    if (s->chr_send_event)
1815
        s->chr_send_event(s, event);
1816
}
1817

    
1818
void qemu_chr_add_handlers(CharDriverState *s,
1819
                           IOCanRWHandler *fd_can_read,
1820
                           IOReadHandler *fd_read,
1821
                           IOEventHandler *fd_event,
1822
                           void *opaque)
1823
{
1824
    s->chr_can_read = fd_can_read;
1825
    s->chr_read = fd_read;
1826
    s->chr_event = fd_event;
1827
    s->handler_opaque = opaque;
1828
    if (s->chr_update_read_handler)
1829
        s->chr_update_read_handler(s);
1830
}
1831

    
1832
static int null_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1833
{
1834
    return len;
1835
}
1836

    
1837
static CharDriverState *qemu_chr_open_null(void)
1838
{
1839
    CharDriverState *chr;
1840

    
1841
    chr = qemu_mallocz(sizeof(CharDriverState));
1842
    if (!chr)
1843
        return NULL;
1844
    chr->chr_write = null_chr_write;
1845
    return chr;
1846
}
1847

    
1848
/* MUX driver for serial I/O splitting */
1849
static int term_timestamps;
1850
static int64_t term_timestamps_start;
1851
#define MAX_MUX 4
1852
#define MUX_BUFFER_SIZE 32        /* Must be a power of 2.  */
1853
#define MUX_BUFFER_MASK (MUX_BUFFER_SIZE - 1)
1854
typedef struct {
1855
    IOCanRWHandler *chr_can_read[MAX_MUX];
1856
    IOReadHandler *chr_read[MAX_MUX];
1857
    IOEventHandler *chr_event[MAX_MUX];
1858
    void *ext_opaque[MAX_MUX];
1859
    CharDriverState *drv;
1860
    unsigned char buffer[MUX_BUFFER_SIZE];
1861
    int prod;
1862
    int cons;
1863
    int mux_cnt;
1864
    int term_got_escape;
1865
    int max_size;
1866
} MuxDriver;
1867

    
1868

    
1869
static int mux_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1870
{
1871
    MuxDriver *d = chr->opaque;
1872
    int ret;
1873
    if (!term_timestamps) {
1874
        ret = d->drv->chr_write(d->drv, buf, len);
1875
    } else {
1876
        int i;
1877

    
1878
        ret = 0;
1879
        for(i = 0; i < len; i++) {
1880
            ret += d->drv->chr_write(d->drv, buf+i, 1);
1881
            if (buf[i] == '\n') {
1882
                char buf1[64];
1883
                int64_t ti;
1884
                int secs;
1885

    
1886
                ti = get_clock();
1887
                if (term_timestamps_start == -1)
1888
                    term_timestamps_start = ti;
1889
                ti -= term_timestamps_start;
1890
                secs = ti / 1000000000;
1891
                snprintf(buf1, sizeof(buf1),
1892
                         "[%02d:%02d:%02d.%03d] ",
1893
                         secs / 3600,
1894
                         (secs / 60) % 60,
1895
                         secs % 60,
1896
                         (int)((ti / 1000000) % 1000));
1897
                d->drv->chr_write(d->drv, (uint8_t *)buf1, strlen(buf1));
1898
            }
1899
        }
1900
    }
1901
    return ret;
1902
}
1903

    
1904
static const char * const mux_help[] = {
1905
    "% h    print this help\n\r",
1906
    "% x    exit emulator\n\r",
1907
    "% s    save disk data back to file (if -snapshot)\n\r",
1908
    "% t    toggle console timestamps\n\r"
1909
    "% b    send break (magic sysrq)\n\r",
1910
    "% c    switch between console and monitor\n\r",
1911
    "% %  sends %\n\r",
1912
    NULL
1913
};
1914

    
1915
static int term_escape_char = 0x01; /* ctrl-a is used for escape */
1916
static void mux_print_help(CharDriverState *chr)
1917
{
1918
    int i, j;
1919
    char ebuf[15] = "Escape-Char";
1920
    char cbuf[50] = "\n\r";
1921

    
1922
    if (term_escape_char > 0 && term_escape_char < 26) {
1923
        snprintf(cbuf, sizeof(cbuf), "\n\r");
1924
        snprintf(ebuf, sizeof(ebuf), "C-%c", term_escape_char - 1 + 'a');
1925
    } else {
1926
        snprintf(cbuf, sizeof(cbuf),
1927
                 "\n\rEscape-Char set to Ascii: 0x%02x\n\r\n\r",
1928
                 term_escape_char);
1929
    }
1930
    chr->chr_write(chr, (uint8_t *)cbuf, strlen(cbuf));
1931
    for (i = 0; mux_help[i] != NULL; i++) {
1932
        for (j=0; mux_help[i][j] != '\0'; j++) {
1933
            if (mux_help[i][j] == '%')
1934
                chr->chr_write(chr, (uint8_t *)ebuf, strlen(ebuf));
1935
            else
1936
                chr->chr_write(chr, (uint8_t *)&mux_help[i][j], 1);
1937
        }
1938
    }
1939
}
1940

    
1941
static int mux_proc_byte(CharDriverState *chr, MuxDriver *d, int ch)
1942
{
1943
    if (d->term_got_escape) {
1944
        d->term_got_escape = 0;
1945
        if (ch == term_escape_char)
1946
            goto send_char;
1947
        switch(ch) {
1948
        case '?':
1949
        case 'h':
1950
            mux_print_help(chr);
1951
            break;
1952
        case 'x':
1953
            {
1954
                 const char *term =  "QEMU: Terminated\n\r";
1955
                 chr->chr_write(chr,(uint8_t *)term,strlen(term));
1956
                 exit(0);
1957
                 break;
1958
            }
1959
        case 's':
1960
            {
1961
                int i;
1962
                for (i = 0; i < nb_drives; i++) {
1963
                        bdrv_commit(drives_table[i].bdrv);
1964
                }
1965
            }
1966
            break;
1967
        case 'b':
1968
            qemu_chr_event(chr, CHR_EVENT_BREAK);
1969
            break;
1970
        case 'c':
1971
            /* Switch to the next registered device */
1972
            chr->focus++;
1973
            if (chr->focus >= d->mux_cnt)
1974
                chr->focus = 0;
1975
            break;
1976
       case 't':
1977
           term_timestamps = !term_timestamps;
1978
           term_timestamps_start = -1;
1979
           break;
1980
        }
1981
    } else if (ch == term_escape_char) {
1982
        d->term_got_escape = 1;
1983
    } else {
1984
    send_char:
1985
        return 1;
1986
    }
1987
    return 0;
1988
}
1989

    
1990
static void mux_chr_accept_input(CharDriverState *chr)
1991
{
1992
    int m = chr->focus;
1993
    MuxDriver *d = chr->opaque;
1994

    
1995
    while (d->prod != d->cons &&
1996
           d->chr_can_read[m] &&
1997
           d->chr_can_read[m](d->ext_opaque[m])) {
1998
        d->chr_read[m](d->ext_opaque[m],
1999
                       &d->buffer[d->cons++ & MUX_BUFFER_MASK], 1);
2000
    }
2001
}
2002

    
2003
static int mux_chr_can_read(void *opaque)
2004
{
2005
    CharDriverState *chr = opaque;
2006
    MuxDriver *d = chr->opaque;
2007

    
2008
    if ((d->prod - d->cons) < MUX_BUFFER_SIZE)
2009
        return 1;
2010
    if (d->chr_can_read[chr->focus])
2011
        return d->chr_can_read[chr->focus](d->ext_opaque[chr->focus]);
2012
    return 0;
2013
}
2014

    
2015
static void mux_chr_read(void *opaque, const uint8_t *buf, int size)
2016
{
2017
    CharDriverState *chr = opaque;
2018
    MuxDriver *d = chr->opaque;
2019
    int m = chr->focus;
2020
    int i;
2021

    
2022
    mux_chr_accept_input (opaque);
2023

    
2024
    for(i = 0; i < size; i++)
2025
        if (mux_proc_byte(chr, d, buf[i])) {
2026
            if (d->prod == d->cons &&
2027
                d->chr_can_read[m] &&
2028
                d->chr_can_read[m](d->ext_opaque[m]))
2029
                d->chr_read[m](d->ext_opaque[m], &buf[i], 1);
2030
            else
2031
                d->buffer[d->prod++ & MUX_BUFFER_MASK] = buf[i];
2032
        }
2033
}
2034

    
2035
static void mux_chr_event(void *opaque, int event)
2036
{
2037
    CharDriverState *chr = opaque;
2038
    MuxDriver *d = chr->opaque;
2039
    int i;
2040

    
2041
    /* Send the event to all registered listeners */
2042
    for (i = 0; i < d->mux_cnt; i++)
2043
        if (d->chr_event[i])
2044
            d->chr_event[i](d->ext_opaque[i], event);
2045
}
2046

    
2047
static void mux_chr_update_read_handler(CharDriverState *chr)
2048
{
2049
    MuxDriver *d = chr->opaque;
2050

    
2051
    if (d->mux_cnt >= MAX_MUX) {
2052
        fprintf(stderr, "Cannot add I/O handlers, MUX array is full\n");
2053
        return;
2054
    }
2055
    d->ext_opaque[d->mux_cnt] = chr->handler_opaque;
2056
    d->chr_can_read[d->mux_cnt] = chr->chr_can_read;
2057
    d->chr_read[d->mux_cnt] = chr->chr_read;
2058
    d->chr_event[d->mux_cnt] = chr->chr_event;
2059
    /* Fix up the real driver with mux routines */
2060
    if (d->mux_cnt == 0) {
2061
        qemu_chr_add_handlers(d->drv, mux_chr_can_read, mux_chr_read,
2062
                              mux_chr_event, chr);
2063
    }
2064
    chr->focus = d->mux_cnt;
2065
    d->mux_cnt++;
2066
}
2067

    
2068
static CharDriverState *qemu_chr_open_mux(CharDriverState *drv)
2069
{
2070
    CharDriverState *chr;
2071
    MuxDriver *d;
2072

    
2073
    chr = qemu_mallocz(sizeof(CharDriverState));
2074
    if (!chr)
2075
        return NULL;
2076
    d = qemu_mallocz(sizeof(MuxDriver));
2077
    if (!d) {
2078
        free(chr);
2079
        return NULL;
2080
    }
2081

    
2082
    chr->opaque = d;
2083
    d->drv = drv;
2084
    chr->focus = -1;
2085
    chr->chr_write = mux_chr_write;
2086
    chr->chr_update_read_handler = mux_chr_update_read_handler;
2087
    chr->chr_accept_input = mux_chr_accept_input;
2088
    return chr;
2089
}
2090

    
2091

    
2092
#ifdef _WIN32
2093

    
2094
static void socket_cleanup(void)
2095
{
2096
    WSACleanup();
2097
}
2098

    
2099
static int socket_init(void)
2100
{
2101
    WSADATA Data;
2102
    int ret, err;
2103

    
2104
    ret = WSAStartup(MAKEWORD(2,2), &Data);
2105
    if (ret != 0) {
2106
        err = WSAGetLastError();
2107
        fprintf(stderr, "WSAStartup: %d\n", err);
2108
        return -1;
2109
    }
2110
    atexit(socket_cleanup);
2111
    return 0;
2112
}
2113

    
2114
static int send_all(int fd, const uint8_t *buf, int len1)
2115
{
2116
    int ret, len;
2117

    
2118
    len = len1;
2119
    while (len > 0) {
2120
        ret = send(fd, buf, len, 0);
2121
        if (ret < 0) {
2122
            int errno;
2123
            errno = WSAGetLastError();
2124
            if (errno != WSAEWOULDBLOCK) {
2125
                return -1;
2126
            }
2127
        } else if (ret == 0) {
2128
            break;
2129
        } else {
2130
            buf += ret;
2131
            len -= ret;
2132
        }
2133
    }
2134
    return len1 - len;
2135
}
2136

    
2137
#else
2138

    
2139
static int unix_write(int fd, const uint8_t *buf, int len1)
2140
{
2141
    int ret, len;
2142

    
2143
    len = len1;
2144
    while (len > 0) {
2145
        ret = write(fd, buf, len);
2146
        if (ret < 0) {
2147
            if (errno != EINTR && errno != EAGAIN)
2148
                return -1;
2149
        } else if (ret == 0) {
2150
            break;
2151
        } else {
2152
            buf += ret;
2153
            len -= ret;
2154
        }
2155
    }
2156
    return len1 - len;
2157
}
2158

    
2159
static inline int send_all(int fd, const uint8_t *buf, int len1)
2160
{
2161
    return unix_write(fd, buf, len1);
2162
}
2163
#endif /* !_WIN32 */
2164

    
2165
#ifndef _WIN32
2166

    
2167
typedef struct {
2168
    int fd_in, fd_out;
2169
    int max_size;
2170
} FDCharDriver;
2171

    
2172
#define STDIO_MAX_CLIENTS 1
2173
static int stdio_nb_clients = 0;
2174

    
2175
static int fd_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
2176
{
2177
    FDCharDriver *s = chr->opaque;
2178
    return unix_write(s->fd_out, buf, len);
2179
}
2180

    
2181
static int fd_chr_read_poll(void *opaque)
2182
{
2183
    CharDriverState *chr = opaque;
2184
    FDCharDriver *s = chr->opaque;
2185

    
2186
    s->max_size = qemu_chr_can_read(chr);
2187
    return s->max_size;
2188
}
2189

    
2190
static void fd_chr_read(void *opaque)
2191
{
2192
    CharDriverState *chr = opaque;
2193
    FDCharDriver *s = chr->opaque;
2194
    int size, len;
2195
    uint8_t buf[1024];
2196

    
2197
    len = sizeof(buf);
2198
    if (len > s->max_size)
2199
        len = s->max_size;
2200
    if (len == 0)
2201
        return;
2202
    size = read(s->fd_in, buf, len);
2203
    if (size == 0) {
2204
        /* FD has been closed. Remove it from the active list.  */
2205
        qemu_set_fd_handler2(s->fd_in, NULL, NULL, NULL, NULL);
2206
        return;
2207
    }
2208
    if (size > 0) {
2209
        qemu_chr_read(chr, buf, size);
2210
    }
2211
}
2212

    
2213
static void fd_chr_update_read_handler(CharDriverState *chr)
2214
{
2215
    FDCharDriver *s = chr->opaque;
2216

    
2217
    if (s->fd_in >= 0) {
2218
        if (nographic && s->fd_in == 0) {
2219
        } else {
2220
            qemu_set_fd_handler2(s->fd_in, fd_chr_read_poll,
2221
                                 fd_chr_read, NULL, chr);
2222
        }
2223
    }
2224
}
2225

    
2226
static void fd_chr_close(struct CharDriverState *chr)
2227
{
2228
    FDCharDriver *s = chr->opaque;
2229

    
2230
    if (s->fd_in >= 0) {
2231
        if (nographic && s->fd_in == 0) {
2232
        } else {
2233
            qemu_set_fd_handler2(s->fd_in, NULL, NULL, NULL, NULL);
2234
        }
2235
    }
2236

    
2237
    qemu_free(s);
2238
}
2239

    
2240
/* open a character device to a unix fd */
2241
static CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out)
2242
{
2243
    CharDriverState *chr;
2244
    FDCharDriver *s;
2245

    
2246
    chr = qemu_mallocz(sizeof(CharDriverState));
2247
    if (!chr)
2248
        return NULL;
2249
    s = qemu_mallocz(sizeof(FDCharDriver));
2250
    if (!s) {
2251
        free(chr);
2252
        return NULL;
2253
    }
2254
    s->fd_in = fd_in;
2255
    s->fd_out = fd_out;
2256
    chr->opaque = s;
2257
    chr->chr_write = fd_chr_write;
2258
    chr->chr_update_read_handler = fd_chr_update_read_handler;
2259
    chr->chr_close = fd_chr_close;
2260

    
2261
    qemu_chr_reset(chr);
2262

    
2263
    return chr;
2264
}
2265

    
2266
static CharDriverState *qemu_chr_open_file_out(const char *file_out)
2267
{
2268
    int fd_out;
2269

    
2270
    TFR(fd_out = open(file_out, O_WRONLY | O_TRUNC | O_CREAT | O_BINARY, 0666));
2271
    if (fd_out < 0)
2272
        return NULL;
2273
    return qemu_chr_open_fd(-1, fd_out);
2274
}
2275

    
2276
static CharDriverState *qemu_chr_open_pipe(const char *filename)
2277
{
2278
    int fd_in, fd_out;
2279
    char filename_in[256], filename_out[256];
2280

    
2281
    snprintf(filename_in, 256, "%s.in", filename);
2282
    snprintf(filename_out, 256, "%s.out", filename);
2283
    TFR(fd_in = open(filename_in, O_RDWR | O_BINARY));
2284
    TFR(fd_out = open(filename_out, O_RDWR | O_BINARY));
2285
    if (fd_in < 0 || fd_out < 0) {
2286
        if (fd_in >= 0)
2287
            close(fd_in);
2288
        if (fd_out >= 0)
2289
            close(fd_out);
2290
        TFR(fd_in = fd_out = open(filename, O_RDWR | O_BINARY));
2291
        if (fd_in < 0)
2292
            return NULL;
2293
    }
2294
    return qemu_chr_open_fd(fd_in, fd_out);
2295
}
2296

    
2297

    
2298
/* for STDIO, we handle the case where several clients use it
2299
   (nographic mode) */
2300

    
2301
#define TERM_FIFO_MAX_SIZE 1
2302

    
2303
static uint8_t term_fifo[TERM_FIFO_MAX_SIZE];
2304
static int term_fifo_size;
2305

    
2306
static int stdio_read_poll(void *opaque)
2307
{
2308
    CharDriverState *chr = opaque;
2309

    
2310
    /* try to flush the queue if needed */
2311
    if (term_fifo_size != 0 && qemu_chr_can_read(chr) > 0) {
2312
        qemu_chr_read(chr, term_fifo, 1);
2313
        term_fifo_size = 0;
2314
    }
2315
    /* see if we can absorb more chars */
2316
    if (term_fifo_size == 0)
2317
        return 1;
2318
    else
2319
        return 0;
2320
}
2321

    
2322
static void stdio_read(void *opaque)
2323
{
2324
    int size;
2325
    uint8_t buf[1];
2326
    CharDriverState *chr = opaque;
2327

    
2328
    size = read(0, buf, 1);
2329
    if (size == 0) {
2330
        /* stdin has been closed. Remove it from the active list.  */
2331
        qemu_set_fd_handler2(0, NULL, NULL, NULL, NULL);
2332
        return;
2333
    }
2334
    if (size > 0) {
2335
        if (qemu_chr_can_read(chr) > 0) {
2336
            qemu_chr_read(chr, buf, 1);
2337
        } else if (term_fifo_size == 0) {
2338
            term_fifo[term_fifo_size++] = buf[0];
2339
        }
2340
    }
2341
}
2342

    
2343
/* init terminal so that we can grab keys */
2344
static struct termios oldtty;
2345
static int old_fd0_flags;
2346
static int term_atexit_done;
2347

    
2348
static void term_exit(void)
2349
{
2350
    tcsetattr (0, TCSANOW, &oldtty);
2351
    fcntl(0, F_SETFL, old_fd0_flags);
2352
}
2353

    
2354
static void term_init(void)
2355
{
2356
    struct termios tty;
2357

    
2358
    tcgetattr (0, &tty);
2359
    oldtty = tty;
2360
    old_fd0_flags = fcntl(0, F_GETFL);
2361

    
2362
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
2363
                          |INLCR|IGNCR|ICRNL|IXON);
2364
    tty.c_oflag |= OPOST;
2365
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
2366
    /* if graphical mode, we allow Ctrl-C handling */
2367
    if (nographic)
2368
        tty.c_lflag &= ~ISIG;
2369
    tty.c_cflag &= ~(CSIZE|PARENB);
2370
    tty.c_cflag |= CS8;
2371
    tty.c_cc[VMIN] = 1;
2372
    tty.c_cc[VTIME] = 0;
2373

    
2374
    tcsetattr (0, TCSANOW, &tty);
2375

    
2376
    if (!term_atexit_done++)
2377
        atexit(term_exit);
2378

    
2379
    fcntl(0, F_SETFL, O_NONBLOCK);
2380
}
2381

    
2382
static void qemu_chr_close_stdio(struct CharDriverState *chr)
2383
{
2384
    term_exit();
2385
    stdio_nb_clients--;
2386
    qemu_set_fd_handler2(0, NULL, NULL, NULL, NULL);
2387
    fd_chr_close(chr);
2388
}
2389

    
2390
static CharDriverState *qemu_chr_open_stdio(void)
2391
{
2392
    CharDriverState *chr;
2393

    
2394
    if (stdio_nb_clients >= STDIO_MAX_CLIENTS)
2395
        return NULL;
2396
    chr = qemu_chr_open_fd(0, 1);
2397
    chr->chr_close = qemu_chr_close_stdio;
2398
    qemu_set_fd_handler2(0, stdio_read_poll, stdio_read, NULL, chr);
2399
    stdio_nb_clients++;
2400
    term_init();
2401

    
2402
    return chr;
2403
}
2404

    
2405
#ifdef __sun__
2406
/* Once Solaris has openpty(), this is going to be removed. */
2407
int openpty(int *amaster, int *aslave, char *name,
2408
            struct termios *termp, struct winsize *winp)
2409
{
2410
        const char *slave;
2411
        int mfd = -1, sfd = -1;
2412

    
2413
        *amaster = *aslave = -1;
2414

    
2415
        mfd = open("/dev/ptmx", O_RDWR | O_NOCTTY);
2416
        if (mfd < 0)
2417
                goto err;
2418

    
2419
        if (grantpt(mfd) == -1 || unlockpt(mfd) == -1)
2420
                goto err;
2421

    
2422
        if ((slave = ptsname(mfd)) == NULL)
2423
                goto err;
2424

    
2425
        if ((sfd = open(slave, O_RDONLY | O_NOCTTY)) == -1)
2426
                goto err;
2427

    
2428
        if (ioctl(sfd, I_PUSH, "ptem") == -1 ||
2429
            (termp != NULL && tcgetattr(sfd, termp) < 0))
2430
                goto err;
2431

    
2432
        if (amaster)
2433
                *amaster = mfd;
2434
        if (aslave)
2435
                *aslave = sfd;
2436
        if (winp)
2437
                ioctl(sfd, TIOCSWINSZ, winp);
2438

    
2439
        return 0;
2440

    
2441
err:
2442
        if (sfd != -1)
2443
                close(sfd);
2444
        close(mfd);
2445
        return -1;
2446
}
2447

    
2448
void cfmakeraw (struct termios *termios_p)
2449
{
2450
        termios_p->c_iflag &=
2451
                ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);
2452
        termios_p->c_oflag &= ~OPOST;
2453
        termios_p->c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
2454
        termios_p->c_cflag &= ~(CSIZE|PARENB);
2455
        termios_p->c_cflag |= CS8;
2456

    
2457
        termios_p->c_cc[VMIN] = 0;
2458
        termios_p->c_cc[VTIME] = 0;
2459
}
2460
#endif
2461

    
2462
#if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \
2463
    || defined(__NetBSD__) || defined(__OpenBSD__)
2464

    
2465
typedef struct {
2466
    int fd;
2467
    int connected;
2468
    int polling;
2469
    int read_bytes;
2470
    QEMUTimer *timer;
2471
} PtyCharDriver;
2472

    
2473
static void pty_chr_update_read_handler(CharDriverState *chr);
2474
static void pty_chr_state(CharDriverState *chr, int connected);
2475

    
2476
static int pty_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
2477
{
2478
    PtyCharDriver *s = chr->opaque;
2479

    
2480
    if (!s->connected) {
2481
        /* guest sends data, check for (re-)connect */
2482
        pty_chr_update_read_handler(chr);
2483
        return 0;
2484
    }
2485
    return unix_write(s->fd, buf, len);
2486
}
2487

    
2488
static int pty_chr_read_poll(void *opaque)
2489
{
2490
    CharDriverState *chr = opaque;
2491
    PtyCharDriver *s = chr->opaque;
2492

    
2493
    s->read_bytes = qemu_chr_can_read(chr);
2494
    return s->read_bytes;
2495
}
2496

    
2497
static void pty_chr_read(void *opaque)
2498
{
2499
    CharDriverState *chr = opaque;
2500
    PtyCharDriver *s = chr->opaque;
2501
    int size, len;
2502
    uint8_t buf[1024];
2503

    
2504
    len = sizeof(buf);
2505
    if (len > s->read_bytes)
2506
        len = s->read_bytes;
2507
    if (len == 0)
2508
        return;
2509
    size = read(s->fd, buf, len);
2510
    if ((size == -1 && errno == EIO) ||
2511
        (size == 0)) {
2512
        pty_chr_state(chr, 0);
2513
        return;
2514
    }
2515
    if (size > 0) {
2516
        pty_chr_state(chr, 1);
2517
        qemu_chr_read(chr, buf, size);
2518
    }
2519
}
2520

    
2521
static void pty_chr_update_read_handler(CharDriverState *chr)
2522
{
2523
    PtyCharDriver *s = chr->opaque;
2524

    
2525
    qemu_set_fd_handler2(s->fd, pty_chr_read_poll,
2526
                         pty_chr_read, NULL, chr);
2527
    s->polling = 1;
2528
    /*
2529
     * Short timeout here: just need wait long enougth that qemu makes
2530
     * it through the poll loop once.  When reconnected we want a
2531
     * short timeout so we notice it almost instantly.  Otherwise
2532
     * read() gives us -EIO instantly, making pty_chr_state() reset the
2533
     * timeout to the normal (much longer) poll interval before the
2534
     * timer triggers.
2535
     */
2536
    qemu_mod_timer(s->timer, qemu_get_clock(rt_clock) + 10);
2537
}
2538

    
2539
static void pty_chr_state(CharDriverState *chr, int connected)
2540
{
2541
    PtyCharDriver *s = chr->opaque;
2542

    
2543
    if (!connected) {
2544
        qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
2545
        s->connected = 0;
2546
        s->polling = 0;
2547
        /* (re-)connect poll interval for idle guests: once per second.
2548
         * We check more frequently in case the guests sends data to
2549
         * the virtual device linked to our pty. */
2550
        qemu_mod_timer(s->timer, qemu_get_clock(rt_clock) + 1000);
2551
    } else {
2552
        if (!s->connected)
2553
            qemu_chr_reset(chr);
2554
        s->connected = 1;
2555
    }
2556
}
2557

    
2558
static void pty_chr_timer(void *opaque)
2559
{
2560
    struct CharDriverState *chr = opaque;
2561
    PtyCharDriver *s = chr->opaque;
2562

    
2563
    if (s->connected)
2564
        return;
2565
    if (s->polling) {
2566
        /* If we arrive here without polling being cleared due
2567
         * read returning -EIO, then we are (re-)connected */
2568
        pty_chr_state(chr, 1);
2569
        return;
2570
    }
2571

    
2572
    /* Next poll ... */
2573
    pty_chr_update_read_handler(chr);
2574
}
2575

    
2576
static void pty_chr_close(struct CharDriverState *chr)
2577
{
2578
    PtyCharDriver *s = chr->opaque;
2579

    
2580
    qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
2581
    close(s->fd);
2582
    qemu_free(s);
2583
}
2584

    
2585
static CharDriverState *qemu_chr_open_pty(void)
2586
{
2587
    CharDriverState *chr;
2588
    PtyCharDriver *s;
2589
    struct termios tty;
2590
    int slave_fd;
2591
#if defined(__OpenBSD__)
2592
    char pty_name[PATH_MAX];
2593
#define q_ptsname(x) pty_name
2594
#else
2595
    char *pty_name = NULL;
2596
#define q_ptsname(x) ptsname(x)
2597
#endif
2598

    
2599
    chr = qemu_mallocz(sizeof(CharDriverState));
2600
    if (!chr)
2601
        return NULL;
2602
    s = qemu_mallocz(sizeof(PtyCharDriver));
2603
    if (!s) {
2604
        qemu_free(chr);
2605
        return NULL;
2606
    }
2607

    
2608
    if (openpty(&s->fd, &slave_fd, pty_name, NULL, NULL) < 0) {
2609
        return NULL;
2610
    }
2611

    
2612
    /* Set raw attributes on the pty. */
2613
    cfmakeraw(&tty);
2614
    tcsetattr(slave_fd, TCSAFLUSH, &tty);
2615
    close(slave_fd);
2616

    
2617
    fprintf(stderr, "char device redirected to %s\n", q_ptsname(s->fd));
2618

    
2619
    chr->opaque = s;
2620
    chr->chr_write = pty_chr_write;
2621
    chr->chr_update_read_handler = pty_chr_update_read_handler;
2622
    chr->chr_close = pty_chr_close;
2623

    
2624
    s->timer = qemu_new_timer(rt_clock, pty_chr_timer, chr);
2625

    
2626
    return chr;
2627
}
2628

    
2629
static void tty_serial_init(int fd, int speed,
2630
                            int parity, int data_bits, int stop_bits)
2631
{
2632
    struct termios tty;
2633
    speed_t spd;
2634

    
2635
#if 0
2636
    printf("tty_serial_init: speed=%d parity=%c data=%d stop=%d\n",
2637
           speed, parity, data_bits, stop_bits);
2638
#endif
2639
    tcgetattr (fd, &tty);
2640

    
2641
#define MARGIN 1.1
2642
    if (speed <= 50 * MARGIN)
2643
        spd = B50;
2644
    else if (speed <= 75 * MARGIN)
2645
        spd = B75;
2646
    else if (speed <= 300 * MARGIN)
2647
        spd = B300;
2648
    else if (speed <= 600 * MARGIN)
2649
        spd = B600;
2650
    else if (speed <= 1200 * MARGIN)
2651
        spd = B1200;
2652
    else if (speed <= 2400 * MARGIN)
2653
        spd = B2400;
2654
    else if (speed <= 4800 * MARGIN)
2655
        spd = B4800;
2656
    else if (speed <= 9600 * MARGIN)
2657
        spd = B9600;
2658
    else if (speed <= 19200 * MARGIN)
2659
        spd = B19200;
2660
    else if (speed <= 38400 * MARGIN)
2661
        spd = B38400;
2662
    else if (speed <= 57600 * MARGIN)
2663
        spd = B57600;
2664
    else if (speed <= 115200 * MARGIN)
2665
        spd = B115200;
2666
    else
2667
        spd = B115200;
2668

    
2669
    cfsetispeed(&tty, spd);
2670
    cfsetospeed(&tty, spd);
2671

    
2672
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
2673
                          |INLCR|IGNCR|ICRNL|IXON);
2674
    tty.c_oflag |= OPOST;
2675
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN|ISIG);
2676
    tty.c_cflag &= ~(CSIZE|PARENB|PARODD|CRTSCTS|CSTOPB);
2677
    switch(data_bits) {
2678
    default:
2679
    case 8:
2680
        tty.c_cflag |= CS8;
2681
        break;
2682
    case 7:
2683
        tty.c_cflag |= CS7;
2684
        break;
2685
    case 6:
2686
        tty.c_cflag |= CS6;
2687
        break;
2688
    case 5:
2689
        tty.c_cflag |= CS5;
2690
        break;
2691
    }
2692
    switch(parity) {
2693
    default:
2694
    case 'N':
2695
        break;
2696
    case 'E':
2697
        tty.c_cflag |= PARENB;
2698
        break;
2699
    case 'O':
2700
        tty.c_cflag |= PARENB | PARODD;
2701
        break;
2702
    }
2703
    if (stop_bits == 2)
2704
        tty.c_cflag |= CSTOPB;
2705

    
2706
    tcsetattr (fd, TCSANOW, &tty);
2707
}
2708

    
2709
static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg)
2710
{
2711
    FDCharDriver *s = chr->opaque;
2712

    
2713
    switch(cmd) {
2714
    case CHR_IOCTL_SERIAL_SET_PARAMS:
2715
        {
2716
            QEMUSerialSetParams *ssp = arg;
2717
            tty_serial_init(s->fd_in, ssp->speed, ssp->parity,
2718
                            ssp->data_bits, ssp->stop_bits);
2719
        }
2720
        break;
2721
    case CHR_IOCTL_SERIAL_SET_BREAK:
2722
        {
2723
            int enable = *(int *)arg;
2724
            if (enable)
2725
                tcsendbreak(s->fd_in, 1);
2726
        }
2727
        break;
2728
    case CHR_IOCTL_SERIAL_GET_TIOCM:
2729
        {
2730
            int sarg = 0;
2731
            int *targ = (int *)arg;
2732
            ioctl(s->fd_in, TIOCMGET, &sarg);
2733
            *targ = 0;
2734
            if (sarg | TIOCM_CTS)
2735
                *targ |= CHR_TIOCM_CTS;
2736
            if (sarg | TIOCM_CAR)
2737
                *targ |= CHR_TIOCM_CAR;
2738
            if (sarg | TIOCM_DSR)
2739
                *targ |= CHR_TIOCM_DSR;
2740
            if (sarg | TIOCM_RI)
2741
                *targ |= CHR_TIOCM_RI;
2742
            if (sarg | TIOCM_DTR)
2743
                *targ |= CHR_TIOCM_DTR;
2744
            if (sarg | TIOCM_RTS)
2745
                *targ |= CHR_TIOCM_RTS;
2746
        }
2747
        break;
2748
    case CHR_IOCTL_SERIAL_SET_TIOCM:
2749
        {
2750
            int sarg = *(int *)arg;
2751
            int targ = 0;
2752
            if (sarg | CHR_TIOCM_DTR)
2753
                targ |= TIOCM_DTR;
2754
            if (sarg | CHR_TIOCM_RTS)
2755
                targ |= TIOCM_RTS;
2756
            ioctl(s->fd_in, TIOCMSET, &targ);
2757
        }
2758
        break;
2759
    default:
2760
        return -ENOTSUP;
2761
    }
2762
    return 0;
2763
}
2764

    
2765
static CharDriverState *qemu_chr_open_tty(const char *filename)
2766
{
2767
    CharDriverState *chr;
2768
    int fd;
2769

    
2770
    TFR(fd = open(filename, O_RDWR | O_NONBLOCK));
2771
    tty_serial_init(fd, 115200, 'N', 8, 1);
2772
    chr = qemu_chr_open_fd(fd, fd);
2773
    if (!chr) {
2774
        close(fd);
2775
        return NULL;
2776
    }
2777
    chr->chr_ioctl = tty_serial_ioctl;
2778
    qemu_chr_reset(chr);
2779
    return chr;
2780
}
2781
#else  /* ! __linux__ && ! __sun__ */
2782
static CharDriverState *qemu_chr_open_pty(void)
2783
{
2784
    return NULL;
2785
}
2786
#endif /* __linux__ || __sun__ */
2787

    
2788
#if defined(__linux__)
2789
typedef struct {
2790
    int fd;
2791
    int mode;
2792
} ParallelCharDriver;
2793

    
2794
static int pp_hw_mode(ParallelCharDriver *s, uint16_t mode)
2795
{
2796
    if (s->mode != mode) {
2797
        int m = mode;
2798
        if (ioctl(s->fd, PPSETMODE, &m) < 0)
2799
            return 0;
2800
        s->mode = mode;
2801
    }
2802
    return 1;
2803
}
2804

    
2805
static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
2806
{
2807
    ParallelCharDriver *drv = chr->opaque;
2808
    int fd = drv->fd;
2809
    uint8_t b;
2810

    
2811
    switch(cmd) {
2812
    case CHR_IOCTL_PP_READ_DATA:
2813
        if (ioctl(fd, PPRDATA, &b) < 0)
2814
            return -ENOTSUP;
2815
        *(uint8_t *)arg = b;
2816
        break;
2817
    case CHR_IOCTL_PP_WRITE_DATA:
2818
        b = *(uint8_t *)arg;
2819
        if (ioctl(fd, PPWDATA, &b) < 0)
2820
            return -ENOTSUP;
2821
        break;
2822
    case CHR_IOCTL_PP_READ_CONTROL:
2823
        if (ioctl(fd, PPRCONTROL, &b) < 0)
2824
            return -ENOTSUP;
2825
        /* Linux gives only the lowest bits, and no way to know data
2826
           direction! For better compatibility set the fixed upper
2827
           bits. */
2828
        *(uint8_t *)arg = b | 0xc0;
2829
        break;
2830
    case CHR_IOCTL_PP_WRITE_CONTROL:
2831
        b = *(uint8_t *)arg;
2832
        if (ioctl(fd, PPWCONTROL, &b) < 0)
2833
            return -ENOTSUP;
2834
        break;
2835
    case CHR_IOCTL_PP_READ_STATUS:
2836
        if (ioctl(fd, PPRSTATUS, &b) < 0)
2837
            return -ENOTSUP;
2838
        *(uint8_t *)arg = b;
2839
        break;
2840
    case CHR_IOCTL_PP_DATA_DIR:
2841
        if (ioctl(fd, PPDATADIR, (int *)arg) < 0)
2842
            return -ENOTSUP;
2843
        break;
2844
    case CHR_IOCTL_PP_EPP_READ_ADDR:
2845
        if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
2846
            struct ParallelIOArg *parg = arg;
2847
            int n = read(fd, parg->buffer, parg->count);
2848
            if (n != parg->count) {
2849
                return -EIO;
2850
            }
2851
        }
2852
        break;
2853
    case CHR_IOCTL_PP_EPP_READ:
2854
        if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
2855
            struct ParallelIOArg *parg = arg;
2856
            int n = read(fd, parg->buffer, parg->count);
2857
            if (n != parg->count) {
2858
                return -EIO;
2859
            }
2860
        }
2861
        break;
2862
    case CHR_IOCTL_PP_EPP_WRITE_ADDR:
2863
        if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
2864
            struct ParallelIOArg *parg = arg;
2865
            int n = write(fd, parg->buffer, parg->count);
2866
            if (n != parg->count) {
2867
                return -EIO;
2868
            }
2869
        }
2870
        break;
2871
    case CHR_IOCTL_PP_EPP_WRITE:
2872
        if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
2873
            struct ParallelIOArg *parg = arg;
2874
            int n = write(fd, parg->buffer, parg->count);
2875
            if (n != parg->count) {
2876
                return -EIO;
2877
            }
2878
        }
2879
        break;
2880
    default:
2881
        return -ENOTSUP;
2882
    }
2883
    return 0;
2884
}
2885

    
2886
static void pp_close(CharDriverState *chr)
2887
{
2888
    ParallelCharDriver *drv = chr->opaque;
2889
    int fd = drv->fd;
2890

    
2891
    pp_hw_mode(drv, IEEE1284_MODE_COMPAT);
2892
    ioctl(fd, PPRELEASE);
2893
    close(fd);
2894
    qemu_free(drv);
2895
}
2896

    
2897
static CharDriverState *qemu_chr_open_pp(const char *filename)
2898
{
2899
    CharDriverState *chr;
2900
    ParallelCharDriver *drv;
2901
    int fd;
2902

    
2903
    TFR(fd = open(filename, O_RDWR));
2904
    if (fd < 0)
2905
        return NULL;
2906

    
2907
    if (ioctl(fd, PPCLAIM) < 0) {
2908
        close(fd);
2909
        return NULL;
2910
    }
2911

    
2912
    drv = qemu_mallocz(sizeof(ParallelCharDriver));
2913
    if (!drv) {
2914
        close(fd);
2915
        return NULL;
2916
    }
2917
    drv->fd = fd;
2918
    drv->mode = IEEE1284_MODE_COMPAT;
2919

    
2920
    chr = qemu_mallocz(sizeof(CharDriverState));
2921
    if (!chr) {
2922
        qemu_free(drv);
2923
        close(fd);
2924
        return NULL;
2925
    }
2926
    chr->chr_write = null_chr_write;
2927
    chr->chr_ioctl = pp_ioctl;
2928
    chr->chr_close = pp_close;
2929
    chr->opaque = drv;
2930

    
2931
    qemu_chr_reset(chr);
2932

    
2933
    return chr;
2934
}
2935
#endif /* __linux__ */
2936

    
2937
#else /* _WIN32 */
2938

    
2939
typedef struct {
2940
    int max_size;
2941
    HANDLE hcom, hrecv, hsend;
2942
    OVERLAPPED orecv, osend;
2943
    BOOL fpipe;
2944
    DWORD len;
2945
} WinCharState;
2946

    
2947
#define NSENDBUF 2048
2948
#define NRECVBUF 2048
2949
#define MAXCONNECT 1
2950
#define NTIMEOUT 5000
2951

    
2952
static int win_chr_poll(void *opaque);
2953
static int win_chr_pipe_poll(void *opaque);
2954

    
2955
static void win_chr_close(CharDriverState *chr)
2956
{
2957
    WinCharState *s = chr->opaque;
2958

    
2959
    if (s->hsend) {
2960
        CloseHandle(s->hsend);
2961
        s->hsend = NULL;
2962
    }
2963
    if (s->hrecv) {
2964
        CloseHandle(s->hrecv);
2965
        s->hrecv = NULL;
2966
    }
2967
    if (s->hcom) {
2968
        CloseHandle(s->hcom);
2969
        s->hcom = NULL;
2970
    }
2971
    if (s->fpipe)
2972
        qemu_del_polling_cb(win_chr_pipe_poll, chr);
2973
    else
2974
        qemu_del_polling_cb(win_chr_poll, chr);
2975
}
2976

    
2977
static int win_chr_init(CharDriverState *chr, const char *filename)
2978
{
2979
    WinCharState *s = chr->opaque;
2980
    COMMCONFIG comcfg;
2981
    COMMTIMEOUTS cto = { 0, 0, 0, 0, 0};
2982
    COMSTAT comstat;
2983
    DWORD size;
2984
    DWORD err;
2985

    
2986
    s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
2987
    if (!s->hsend) {
2988
        fprintf(stderr, "Failed CreateEvent\n");
2989
        goto fail;
2990
    }
2991
    s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
2992
    if (!s->hrecv) {
2993
        fprintf(stderr, "Failed CreateEvent\n");
2994
        goto fail;
2995
    }
2996

    
2997
    s->hcom = CreateFile(filename, GENERIC_READ|GENERIC_WRITE, 0, NULL,
2998
                      OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
2999
    if (s->hcom == INVALID_HANDLE_VALUE) {
3000
        fprintf(stderr, "Failed CreateFile (%lu)\n", GetLastError());
3001
        s->hcom = NULL;
3002
        goto fail;
3003
    }
3004

    
3005
    if (!SetupComm(s->hcom, NRECVBUF, NSENDBUF)) {
3006
        fprintf(stderr, "Failed SetupComm\n");
3007
        goto fail;
3008
    }
3009

    
3010
    ZeroMemory(&comcfg, sizeof(COMMCONFIG));
3011
    size = sizeof(COMMCONFIG);
3012
    GetDefaultCommConfig(filename, &comcfg, &size);
3013
    comcfg.dcb.DCBlength = sizeof(DCB);
3014
    CommConfigDialog(filename, NULL, &comcfg);
3015

    
3016
    if (!SetCommState(s->hcom, &comcfg.dcb)) {
3017
        fprintf(stderr, "Failed SetCommState\n");
3018
        goto fail;
3019
    }
3020

    
3021
    if (!SetCommMask(s->hcom, EV_ERR)) {
3022
        fprintf(stderr, "Failed SetCommMask\n");
3023
        goto fail;
3024
    }
3025

    
3026
    cto.ReadIntervalTimeout = MAXDWORD;
3027
    if (!SetCommTimeouts(s->hcom, &cto)) {
3028
        fprintf(stderr, "Failed SetCommTimeouts\n");
3029
        goto fail;
3030
    }
3031

    
3032
    if (!ClearCommError(s->hcom, &err, &comstat)) {
3033
        fprintf(stderr, "Failed ClearCommError\n");
3034
        goto fail;
3035
    }
3036
    qemu_add_polling_cb(win_chr_poll, chr);
3037
    return 0;
3038

    
3039
 fail:
3040
    win_chr_close(chr);
3041
    return -1;
3042
}
3043

    
3044
static int win_chr_write(CharDriverState *chr, const uint8_t *buf, int len1)
3045
{
3046
    WinCharState *s = chr->opaque;
3047
    DWORD len, ret, size, err;
3048

    
3049
    len = len1;
3050
    ZeroMemory(&s->osend, sizeof(s->osend));
3051
    s->osend.hEvent = s->hsend;
3052
    while (len > 0) {
3053
        if (s->hsend)
3054
            ret = WriteFile(s->hcom, buf, len, &size, &s->osend);
3055
        else
3056
            ret = WriteFile(s->hcom, buf, len, &size, NULL);
3057
        if (!ret) {
3058
            err = GetLastError();
3059
            if (err == ERROR_IO_PENDING) {
3060
                ret = GetOverlappedResult(s->hcom, &s->osend, &size, TRUE);
3061
                if (ret) {
3062
                    buf += size;
3063
                    len -= size;
3064
                } else {
3065
                    break;
3066
                }
3067
            } else {
3068
                break;
3069
            }
3070
        } else {
3071
            buf += size;
3072
            len -= size;
3073
        }
3074
    }
3075
    return len1 - len;
3076
}
3077

    
3078
static int win_chr_read_poll(CharDriverState *chr)
3079
{
3080
    WinCharState *s = chr->opaque;
3081

    
3082
    s->max_size = qemu_chr_can_read(chr);
3083
    return s->max_size;
3084
}
3085

    
3086
static void win_chr_readfile(CharDriverState *chr)
3087
{
3088
    WinCharState *s = chr->opaque;
3089
    int ret, err;
3090
    uint8_t buf[1024];
3091
    DWORD size;
3092

    
3093
    ZeroMemory(&s->orecv, sizeof(s->orecv));
3094
    s->orecv.hEvent = s->hrecv;
3095
    ret = ReadFile(s->hcom, buf, s->len, &size, &s->orecv);
3096
    if (!ret) {
3097
        err = GetLastError();
3098
        if (err == ERROR_IO_PENDING) {
3099
            ret = GetOverlappedResult(s->hcom, &s->orecv, &size, TRUE);
3100
        }
3101
    }
3102

    
3103
    if (size > 0) {
3104
        qemu_chr_read(chr, buf, size);
3105
    }
3106
}
3107

    
3108
static void win_chr_read(CharDriverState *chr)
3109
{
3110
    WinCharState *s = chr->opaque;
3111

    
3112
    if (s->len > s->max_size)
3113
        s->len = s->max_size;
3114
    if (s->len == 0)
3115
        return;
3116

    
3117
    win_chr_readfile(chr);
3118
}
3119

    
3120
static int win_chr_poll(void *opaque)
3121
{
3122
    CharDriverState *chr = opaque;
3123
    WinCharState *s = chr->opaque;
3124
    COMSTAT status;
3125
    DWORD comerr;
3126

    
3127
    ClearCommError(s->hcom, &comerr, &status);
3128
    if (status.cbInQue > 0) {
3129
        s->len = status.cbInQue;
3130
        win_chr_read_poll(chr);
3131
        win_chr_read(chr);
3132
        return 1;
3133
    }
3134
    return 0;
3135
}
3136

    
3137
static CharDriverState *qemu_chr_open_win(const char *filename)
3138
{
3139
    CharDriverState *chr;
3140
    WinCharState *s;
3141

    
3142
    chr = qemu_mallocz(sizeof(CharDriverState));
3143
    if (!chr)
3144
        return NULL;
3145
    s = qemu_mallocz(sizeof(WinCharState));
3146
    if (!s) {
3147
        free(chr);
3148
        return NULL;
3149
    }
3150
    chr->opaque = s;
3151
    chr->chr_write = win_chr_write;
3152
    chr->chr_close = win_chr_close;
3153

    
3154
    if (win_chr_init(chr, filename) < 0) {
3155
        free(s);
3156
        free(chr);
3157
        return NULL;
3158
    }
3159
    qemu_chr_reset(chr);
3160
    return chr;
3161
}
3162

    
3163
static int win_chr_pipe_poll(void *opaque)
3164
{
3165
    CharDriverState *chr = opaque;
3166
    WinCharState *s = chr->opaque;
3167
    DWORD size;
3168

    
3169
    PeekNamedPipe(s->hcom, NULL, 0, NULL, &size, NULL);
3170
    if (size > 0) {
3171
        s->len = size;
3172
        win_chr_read_poll(chr);
3173
        win_chr_read(chr);
3174
        return 1;
3175
    }
3176
    return 0;
3177
}
3178

    
3179
static int win_chr_pipe_init(CharDriverState *chr, const char *filename)
3180
{
3181
    WinCharState *s = chr->opaque;
3182
    OVERLAPPED ov;
3183
    int ret;
3184
    DWORD size;
3185
    char openname[256];
3186

    
3187
    s->fpipe = TRUE;
3188

    
3189
    s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
3190
    if (!s->hsend) {
3191
        fprintf(stderr, "Failed CreateEvent\n");
3192
        goto fail;
3193
    }
3194
    s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
3195
    if (!s->hrecv) {
3196
        fprintf(stderr, "Failed CreateEvent\n");
3197
        goto fail;
3198
    }
3199

    
3200
    snprintf(openname, sizeof(openname), "\\\\.\\pipe\\%s", filename);
3201
    s->hcom = CreateNamedPipe(openname, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
3202
                              PIPE_TYPE_BYTE | PIPE_READMODE_BYTE |
3203
                              PIPE_WAIT,
3204
                              MAXCONNECT, NSENDBUF, NRECVBUF, NTIMEOUT, NULL);
3205
    if (s->hcom == INVALID_HANDLE_VALUE) {
3206
        fprintf(stderr, "Failed CreateNamedPipe (%lu)\n", GetLastError());
3207
        s->hcom = NULL;
3208
        goto fail;
3209
    }
3210

    
3211
    ZeroMemory(&ov, sizeof(ov));
3212
    ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
3213
    ret = ConnectNamedPipe(s->hcom, &ov);
3214
    if (ret) {
3215
        fprintf(stderr, "Failed ConnectNamedPipe\n");
3216
        goto fail;
3217
    }
3218

    
3219
    ret = GetOverlappedResult(s->hcom, &ov, &size, TRUE);
3220
    if (!ret) {
3221
        fprintf(stderr, "Failed GetOverlappedResult\n");
3222
        if (ov.hEvent) {
3223
            CloseHandle(ov.hEvent);
3224
            ov.hEvent = NULL;
3225
        }
3226
        goto fail;
3227
    }
3228

    
3229
    if (ov.hEvent) {
3230
        CloseHandle(ov.hEvent);
3231
        ov.hEvent = NULL;
3232
    }
3233
    qemu_add_polling_cb(win_chr_pipe_poll, chr);
3234
    return 0;
3235

    
3236
 fail:
3237
    win_chr_close(chr);
3238
    return -1;
3239
}
3240

    
3241

    
3242
static CharDriverState *qemu_chr_open_win_pipe(const char *filename)
3243
{
3244
    CharDriverState *chr;
3245
    WinCharState *s;
3246

    
3247
    chr = qemu_mallocz(sizeof(CharDriverState));
3248
    if (!chr)
3249
        return NULL;
3250
    s = qemu_mallocz(sizeof(WinCharState));
3251
    if (!s) {
3252
        free(chr);
3253
        return NULL;
3254
    }
3255
    chr->opaque = s;
3256
    chr->chr_write = win_chr_write;
3257
    chr->chr_close = win_chr_close;
3258

    
3259
    if (win_chr_pipe_init(chr, filename) < 0) {
3260
        free(s);
3261
        free(chr);
3262
        return NULL;
3263
    }
3264
    qemu_chr_reset(chr);
3265
    return chr;
3266
}
3267

    
3268
static CharDriverState *qemu_chr_open_win_file(HANDLE fd_out)
3269
{
3270
    CharDriverState *chr;
3271
    WinCharState *s;
3272

    
3273
    chr = qemu_mallocz(sizeof(CharDriverState));
3274
    if (!chr)
3275
        return NULL;
3276
    s = qemu_mallocz(sizeof(WinCharState));
3277
    if (!s) {
3278
        free(chr);
3279
        return NULL;
3280
    }
3281
    s->hcom = fd_out;
3282
    chr->opaque = s;
3283
    chr->chr_write = win_chr_write;
3284
    qemu_chr_reset(chr);
3285
    return chr;
3286
}
3287

    
3288
static CharDriverState *qemu_chr_open_win_con(const char *filename)
3289
{
3290
    return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE));
3291
}
3292

    
3293
static CharDriverState *qemu_chr_open_win_file_out(const char *file_out)
3294
{
3295
    HANDLE fd_out;
3296

    
3297
    fd_out = CreateFile(file_out, GENERIC_WRITE, FILE_SHARE_READ, NULL,
3298
                        OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
3299
    if (fd_out == INVALID_HANDLE_VALUE)
3300
        return NULL;
3301

    
3302
    return qemu_chr_open_win_file(fd_out);
3303
}
3304
#endif /* !_WIN32 */
3305

    
3306
/***********************************************************/
3307
/* UDP Net console */
3308

    
3309
typedef struct {
3310
    int fd;
3311
    struct sockaddr_in daddr;
3312
    uint8_t buf[1024];
3313
    int bufcnt;
3314
    int bufptr;
3315
    int max_size;
3316
} NetCharDriver;
3317

    
3318
static int udp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
3319
{
3320
    NetCharDriver *s = chr->opaque;
3321

    
3322
    return sendto(s->fd, buf, len, 0,
3323
                  (struct sockaddr *)&s->daddr, sizeof(struct sockaddr_in));
3324
}
3325

    
3326
static int udp_chr_read_poll(void *opaque)
3327
{
3328
    CharDriverState *chr = opaque;
3329
    NetCharDriver *s = chr->opaque;
3330

    
3331
    s->max_size = qemu_chr_can_read(chr);
3332

    
3333
    /* If there were any stray characters in the queue process them
3334
     * first
3335
     */
3336
    while (s->max_size > 0 && s->bufptr < s->bufcnt) {
3337
        qemu_chr_read(chr, &s->buf[s->bufptr], 1);
3338
        s->bufptr++;
3339
        s->max_size = qemu_chr_can_read(chr);
3340
    }
3341
    return s->max_size;
3342
}
3343

    
3344
static void udp_chr_read(void *opaque)
3345
{
3346
    CharDriverState *chr = opaque;
3347
    NetCharDriver *s = chr->opaque;
3348

    
3349
    if (s->max_size == 0)
3350
        return;
3351
    s->bufcnt = recv(s->fd, s->buf, sizeof(s->buf), 0);
3352
    s->bufptr = s->bufcnt;
3353
    if (s->bufcnt <= 0)
3354
        return;
3355

    
3356
    s->bufptr = 0;
3357
    while (s->max_size > 0 && s->bufptr < s->bufcnt) {
3358
        qemu_chr_read(chr, &s->buf[s->bufptr], 1);
3359
        s->bufptr++;
3360
        s->max_size = qemu_chr_can_read(chr);
3361
    }
3362
}
3363

    
3364
static void udp_chr_update_read_handler(CharDriverState *chr)
3365
{
3366
    NetCharDriver *s = chr->opaque;
3367

    
3368
    if (s->fd >= 0) {
3369
        qemu_set_fd_handler2(s->fd, udp_chr_read_poll,
3370
                             udp_chr_read, NULL, chr);
3371
    }
3372
}
3373

    
3374
int parse_host_port(struct sockaddr_in *saddr, const char *str);
3375
#ifndef _WIN32
3376
static int parse_unix_path(struct sockaddr_un *uaddr, const char *str);
3377
#endif
3378
int parse_host_src_port(struct sockaddr_in *haddr,
3379
                        struct sockaddr_in *saddr,
3380
                        const char *str);
3381

    
3382
static CharDriverState *qemu_chr_open_udp(const char *def)
3383
{
3384
    CharDriverState *chr = NULL;
3385
    NetCharDriver *s = NULL;
3386
    int fd = -1;
3387
    struct sockaddr_in saddr;
3388

    
3389
    chr = qemu_mallocz(sizeof(CharDriverState));
3390
    if (!chr)
3391
        goto return_err;
3392
    s = qemu_mallocz(sizeof(NetCharDriver));
3393
    if (!s)
3394
        goto return_err;
3395

    
3396
    fd = socket(PF_INET, SOCK_DGRAM, 0);
3397
    if (fd < 0) {
3398
        perror("socket(PF_INET, SOCK_DGRAM)");
3399
        goto return_err;
3400
    }
3401

    
3402
    if (parse_host_src_port(&s->daddr, &saddr, def) < 0) {
3403
        printf("Could not parse: %s\n", def);
3404
        goto return_err;
3405
    }
3406

    
3407
    if (bind(fd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
3408
    {
3409
        perror("bind");
3410
        goto return_err;
3411
    }
3412

    
3413
    s->fd = fd;
3414
    s->bufcnt = 0;
3415
    s->bufptr = 0;
3416
    chr->opaque = s;
3417
    chr->chr_write = udp_chr_write;
3418
    chr->chr_update_read_handler = udp_chr_update_read_handler;
3419
    return chr;
3420

    
3421
return_err:
3422
    if (chr)
3423
        free(chr);
3424
    if (s)
3425
        free(s);
3426
    if (fd >= 0)
3427
        closesocket(fd);
3428
    return NULL;
3429
}
3430

    
3431
/***********************************************************/
3432
/* TCP Net console */
3433

    
3434
typedef struct {
3435
    int fd, listen_fd;
3436
    int connected;
3437
    int max_size;
3438
    int do_telnetopt;
3439
    int do_nodelay;
3440
    int is_unix;
3441
} TCPCharDriver;
3442

    
3443
static void tcp_chr_accept(void *opaque);
3444

    
3445
static int tcp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
3446
{
3447
    TCPCharDriver *s = chr->opaque;
3448
    if (s->connected) {
3449
        return send_all(s->fd, buf, len);
3450
    } else {
3451
        /* XXX: indicate an error ? */
3452
        return len;
3453
    }
3454
}
3455

    
3456
static int tcp_chr_read_poll(void *opaque)
3457
{
3458
    CharDriverState *chr = opaque;
3459
    TCPCharDriver *s = chr->opaque;
3460
    if (!s->connected)
3461
        return 0;
3462
    s->max_size = qemu_chr_can_read(chr);
3463
    return s->max_size;
3464
}
3465

    
3466
#define IAC 255
3467
#define IAC_BREAK 243
3468
static void tcp_chr_process_IAC_bytes(CharDriverState *chr,
3469
                                      TCPCharDriver *s,
3470
                                      uint8_t *buf, int *size)
3471
{
3472
    /* Handle any telnet client's basic IAC options to satisfy char by
3473
     * char mode with no echo.  All IAC options will be removed from
3474
     * the buf and the do_telnetopt variable will be used to track the
3475
     * state of the width of the IAC information.
3476
     *
3477
     * IAC commands come in sets of 3 bytes with the exception of the
3478
     * "IAC BREAK" command and the double IAC.
3479
     */
3480

    
3481
    int i;
3482
    int j = 0;
3483

    
3484
    for (i = 0; i < *size; i++) {
3485
        if (s->do_telnetopt > 1) {
3486
            if ((unsigned char)buf[i] == IAC && s->do_telnetopt == 2) {
3487
                /* Double IAC means send an IAC */
3488
                if (j != i)
3489
                    buf[j] = buf[i];
3490
                j++;
3491
                s->do_telnetopt = 1;
3492
            } else {
3493
                if ((unsigned char)buf[i] == IAC_BREAK && s->do_telnetopt == 2) {
3494
                    /* Handle IAC break commands by sending a serial break */
3495
                    qemu_chr_event(chr, CHR_EVENT_BREAK);
3496
                    s->do_telnetopt++;
3497
                }
3498
                s->do_telnetopt++;
3499
            }
3500
            if (s->do_telnetopt >= 4) {
3501
                s->do_telnetopt = 1;
3502
            }
3503
        } else {
3504
            if ((unsigned char)buf[i] == IAC) {
3505
                s->do_telnetopt = 2;
3506
            } else {
3507
                if (j != i)
3508
                    buf[j] = buf[i];
3509
                j++;
3510
            }
3511
        }
3512
    }
3513
    *size = j;
3514
}
3515

    
3516
static void tcp_chr_read(void *opaque)
3517
{
3518
    CharDriverState *chr = opaque;
3519
    TCPCharDriver *s = chr->opaque;
3520
    uint8_t buf[1024];
3521
    int len, size;
3522

    
3523
    if (!s->connected || s->max_size <= 0)
3524
        return;
3525
    len = sizeof(buf);
3526
    if (len > s->max_size)
3527
        len = s->max_size;
3528
    size = recv(s->fd, buf, len, 0);
3529
    if (size == 0) {
3530
        /* connection closed */
3531
        s->connected = 0;
3532
        if (s->listen_fd >= 0) {
3533
            qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
3534
        }
3535
        qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
3536
        closesocket(s->fd);
3537
        s->fd = -1;
3538
    } else if (size > 0) {
3539
        if (s->do_telnetopt)
3540
            tcp_chr_process_IAC_bytes(chr, s, buf, &size);
3541
        if (size > 0)
3542
            qemu_chr_read(chr, buf, size);
3543
    }
3544
}
3545

    
3546
static void tcp_chr_connect(void *opaque)
3547
{
3548
    CharDriverState *chr = opaque;
3549
    TCPCharDriver *s = chr->opaque;
3550

    
3551
    s->connected = 1;
3552
    qemu_set_fd_handler2(s->fd, tcp_chr_read_poll,
3553
                         tcp_chr_read, NULL, chr);
3554
    qemu_chr_reset(chr);
3555
}
3556

    
3557
#define IACSET(x,a,b,c) x[0] = a; x[1] = b; x[2] = c;
3558
static void tcp_chr_telnet_init(int fd)
3559
{
3560
    char buf[3];
3561
    /* Send the telnet negotion to put telnet in binary, no echo, single char mode */
3562
    IACSET(buf, 0xff, 0xfb, 0x01);  /* IAC WILL ECHO */
3563
    send(fd, (char *)buf, 3, 0);
3564
    IACSET(buf, 0xff, 0xfb, 0x03);  /* IAC WILL Suppress go ahead */
3565
    send(fd, (char *)buf, 3, 0);
3566
    IACSET(buf, 0xff, 0xfb, 0x00);  /* IAC WILL Binary */
3567
    send(fd, (char *)buf, 3, 0);
3568
    IACSET(buf, 0xff, 0xfd, 0x00);  /* IAC DO Binary */
3569
    send(fd, (char *)buf, 3, 0);
3570
}
3571

    
3572
static void socket_set_nodelay(int fd)
3573
{
3574
    int val = 1;
3575
    setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val));
3576
}
3577

    
3578
static void tcp_chr_accept(void *opaque)
3579
{
3580
    CharDriverState *chr = opaque;
3581
    TCPCharDriver *s = chr->opaque;
3582
    struct sockaddr_in saddr;
3583
#ifndef _WIN32
3584
    struct sockaddr_un uaddr;
3585
#endif
3586
    struct sockaddr *addr;
3587
    socklen_t len;
3588
    int fd;
3589

    
3590
    for(;;) {
3591
#ifndef _WIN32
3592
        if (s->is_unix) {
3593
            len = sizeof(uaddr);
3594
            addr = (struct sockaddr *)&uaddr;
3595
        } else
3596
#endif
3597
        {
3598
            len = sizeof(saddr);
3599
            addr = (struct sockaddr *)&saddr;
3600
        }
3601
        fd = accept(s->listen_fd, addr, &len);
3602
        if (fd < 0 && errno != EINTR) {
3603
            return;
3604
        } else if (fd >= 0) {
3605
            if (s->do_telnetopt)
3606
                tcp_chr_telnet_init(fd);
3607
            break;
3608
        }
3609
    }
3610
    socket_set_nonblock(fd);
3611
    if (s->do_nodelay)
3612
        socket_set_nodelay(fd);
3613
    s->fd = fd;
3614
    qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);
3615
    tcp_chr_connect(chr);
3616
}
3617

    
3618
static void tcp_chr_close(CharDriverState *chr)
3619
{
3620
    TCPCharDriver *s = chr->opaque;
3621
    if (s->fd >= 0)
3622
        closesocket(s->fd);
3623
    if (s->listen_fd >= 0)
3624
        closesocket(s->listen_fd);
3625
    qemu_free(s);
3626
}
3627

    
3628
static CharDriverState *qemu_chr_open_tcp(const char *host_str,
3629
                                          int is_telnet,
3630
                                          int is_unix)
3631
{
3632
    CharDriverState *chr = NULL;
3633
    TCPCharDriver *s = NULL;
3634
    int fd = -1, ret, err, val;
3635
    int is_listen = 0;
3636
    int is_waitconnect = 1;
3637
    int do_nodelay = 0;
3638
    const char *ptr;
3639
    struct sockaddr_in saddr;
3640
#ifndef _WIN32
3641
    struct sockaddr_un uaddr;
3642
#endif
3643
    struct sockaddr *addr;
3644
    socklen_t addrlen;
3645

    
3646
#ifndef _WIN32
3647
    if (is_unix) {
3648
        addr = (struct sockaddr *)&uaddr;
3649
        addrlen = sizeof(uaddr);
3650
        if (parse_unix_path(&uaddr, host_str) < 0)
3651
            goto fail;
3652
    } else
3653
#endif
3654
    {
3655
        addr = (struct sockaddr *)&saddr;
3656
        addrlen = sizeof(saddr);
3657
        if (parse_host_port(&saddr, host_str) < 0)
3658
            goto fail;
3659
    }
3660

    
3661
    ptr = host_str;
3662
    while((ptr = strchr(ptr,','))) {
3663
        ptr++;
3664
        if (!strncmp(ptr,"server",6)) {
3665
            is_listen = 1;
3666
        } else if (!strncmp(ptr,"nowait",6)) {
3667
            is_waitconnect = 0;
3668
        } else if (!strncmp(ptr,"nodelay",6)) {
3669
            do_nodelay = 1;
3670
        } else {
3671
            printf("Unknown option: %s\n", ptr);
3672
            goto fail;
3673
        }
3674
    }
3675
    if (!is_listen)
3676
        is_waitconnect = 0;
3677

    
3678
    chr = qemu_mallocz(sizeof(CharDriverState));
3679
    if (!chr)
3680
        goto fail;
3681
    s = qemu_mallocz(sizeof(TCPCharDriver));
3682
    if (!s)
3683
        goto fail;
3684

    
3685
#ifndef _WIN32
3686
    if (is_unix)
3687
        fd = socket(PF_UNIX, SOCK_STREAM, 0);
3688
    else
3689
#endif
3690
        fd = socket(PF_INET, SOCK_STREAM, 0);
3691

    
3692
    if (fd < 0)
3693
        goto fail;
3694

    
3695
    if (!is_waitconnect)
3696
        socket_set_nonblock(fd);
3697

    
3698
    s->connected = 0;
3699
    s->fd = -1;
3700
    s->listen_fd = -1;
3701
    s->is_unix = is_unix;
3702
    s->do_nodelay = do_nodelay && !is_unix;
3703

    
3704
    chr->opaque = s;
3705
    chr->chr_write = tcp_chr_write;
3706
    chr->chr_close = tcp_chr_close;
3707

    
3708
    if (is_listen) {
3709
        /* allow fast reuse */
3710
#ifndef _WIN32
3711
        if (is_unix) {
3712
            char path[109];
3713
            pstrcpy(path, sizeof(path), uaddr.sun_path);
3714
            unlink(path);
3715
        } else
3716
#endif
3717
        {
3718
            val = 1;
3719
            setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
3720
        }
3721

    
3722
        ret = bind(fd, addr, addrlen);
3723
        if (ret < 0)
3724
            goto fail;
3725

    
3726
        ret = listen(fd, 0);
3727
        if (ret < 0)
3728
            goto fail;
3729

    
3730
        s->listen_fd = fd;
3731
        qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
3732
        if (is_telnet)
3733
            s->do_telnetopt = 1;
3734
    } else {
3735
        for(;;) {
3736
            ret = connect(fd, addr, addrlen);
3737
            if (ret < 0) {
3738
                err = socket_error();
3739
                if (err == EINTR || err == EWOULDBLOCK) {
3740
                } else if (err == EINPROGRESS) {
3741
                    break;
3742
#ifdef _WIN32
3743
                } else if (err == WSAEALREADY) {
3744
                    break;
3745
#endif
3746
                } else {
3747
                    goto fail;
3748
                }
3749
            } else {
3750
                s->connected = 1;
3751
                break;
3752
            }
3753
        }
3754
        s->fd = fd;
3755
        socket_set_nodelay(fd);
3756
        if (s->connected)
3757
            tcp_chr_connect(chr);
3758
        else
3759
            qemu_set_fd_handler(s->fd, NULL, tcp_chr_connect, chr);
3760
    }
3761

    
3762
    if (is_listen && is_waitconnect) {
3763
        printf("QEMU waiting for connection on: %s\n", host_str);
3764
        tcp_chr_accept(chr);
3765
        socket_set_nonblock(s->listen_fd);
3766
    }
3767

    
3768
    return chr;
3769
 fail:
3770
    if (fd >= 0)
3771
        closesocket(fd);
3772
    qemu_free(s);
3773
    qemu_free(chr);
3774
    return NULL;
3775
}
3776

    
3777
CharDriverState *qemu_chr_open(const char *filename)
3778
{
3779
    const char *p;
3780

    
3781
    if (!strcmp(filename, "vc")) {
3782
        return text_console_init(&display_state, 0);
3783
    } else if (strstart(filename, "vc:", &p)) {
3784
        return text_console_init(&display_state, p);
3785
    } else if (!strcmp(filename, "null")) {
3786
        return qemu_chr_open_null();
3787
    } else
3788
    if (strstart(filename, "tcp:", &p)) {
3789
        return qemu_chr_open_tcp(p, 0, 0);
3790
    } else
3791
    if (strstart(filename, "telnet:", &p)) {
3792
        return qemu_chr_open_tcp(p, 1, 0);
3793
    } else
3794
    if (strstart(filename, "udp:", &p)) {
3795
        return qemu_chr_open_udp(p);
3796
    } else
3797
    if (strstart(filename, "mon:", &p)) {
3798
        CharDriverState *drv = qemu_chr_open(p);
3799
        if (drv) {
3800
            drv = qemu_chr_open_mux(drv);
3801
            monitor_init(drv, !nographic);
3802
            return drv;
3803
        }
3804
        printf("Unable to open driver: %s\n", p);
3805
        return 0;
3806
    } else
3807
#ifndef _WIN32
3808
    if (strstart(filename, "unix:", &p)) {
3809
        return qemu_chr_open_tcp(p, 0, 1);
3810
    } else if (strstart(filename, "file:", &p)) {
3811
        return qemu_chr_open_file_out(p);
3812
    } else if (strstart(filename, "pipe:", &p)) {
3813
        return qemu_chr_open_pipe(p);
3814
    } else if (!strcmp(filename, "pty")) {
3815
        return qemu_chr_open_pty();
3816
    } else if (!strcmp(filename, "stdio")) {
3817
        return qemu_chr_open_stdio();
3818
    } else
3819
#if defined(__linux__)
3820
    if (strstart(filename, "/dev/parport", NULL)) {
3821
        return qemu_chr_open_pp(filename);
3822
    } else
3823
#endif
3824
#if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \
3825
    || defined(__NetBSD__) || defined(__OpenBSD__)
3826
    if (strstart(filename, "/dev/", NULL)) {
3827
        return qemu_chr_open_tty(filename);
3828
    } else
3829
#endif
3830
#else /* !_WIN32 */
3831
    if (strstart(filename, "COM", NULL)) {
3832
        return qemu_chr_open_win(filename);
3833
    } else
3834
    if (strstart(filename, "pipe:", &p)) {
3835
        return qemu_chr_open_win_pipe(p);
3836
    } else
3837
    if (strstart(filename, "con:", NULL)) {
3838
        return qemu_chr_open_win_con(filename);
3839
    } else
3840
    if (strstart(filename, "file:", &p)) {
3841
        return qemu_chr_open_win_file_out(p);
3842
    } else
3843
#endif
3844
#ifdef CONFIG_BRLAPI
3845
    if (!strcmp(filename, "braille")) {
3846
        return chr_baum_init();
3847
    } else
3848
#endif
3849
    {
3850
        return NULL;
3851
    }
3852
}
3853

    
3854
void qemu_chr_close(CharDriverState *chr)
3855
{
3856
    if (chr->chr_close)
3857
        chr->chr_close(chr);
3858
    qemu_free(chr);
3859
}
3860

    
3861
/***********************************************************/
3862
/* network device redirectors */
3863

    
3864
__attribute__ (( unused ))
3865
static void hex_dump(FILE *f, const uint8_t *buf, int size)
3866
{
3867
    int len, i, j, c;
3868

    
3869
    for(i=0;i<size;i+=16) {
3870
        len = size - i;
3871
        if (len > 16)
3872
            len = 16;
3873
        fprintf(f, "%08x ", i);
3874
        for(j=0;j<16;j++) {
3875
            if (j < len)
3876
                fprintf(f, " %02x", buf[i+j]);
3877
            else
3878
                fprintf(f, "   ");
3879
        }
3880
        fprintf(f, " ");
3881
        for(j=0;j<len;j++) {
3882
            c = buf[i+j];
3883
            if (c < ' ' || c > '~')
3884
                c = '.';
3885
            fprintf(f, "%c", c);
3886
        }
3887
        fprintf(f, "\n");
3888
    }
3889
}
3890

    
3891
static int parse_macaddr(uint8_t *macaddr, const char *p)
3892
{
3893
    int i;
3894
    char *last_char;
3895
    long int offset;
3896

    
3897
    errno = 0;
3898
    offset = strtol(p, &last_char, 0);    
3899
    if (0 == errno && '\0' == *last_char &&
3900
            offset >= 0 && offset <= 0xFFFFFF) {
3901
        macaddr[3] = (offset & 0xFF0000) >> 16;
3902
        macaddr[4] = (offset & 0xFF00) >> 8;
3903
        macaddr[5] = offset & 0xFF;
3904
        return 0;
3905
    } else {
3906
        for(i = 0; i < 6; i++) {
3907
            macaddr[i] = strtol(p, (char **)&p, 16);
3908
            if (i == 5) {
3909
                if (*p != '\0')
3910
                    return -1;
3911
            } else {
3912
                if (*p != ':' && *p != '-')
3913
                    return -1;
3914
                p++;
3915
            }
3916
        }
3917
        return 0;    
3918
    }
3919

    
3920
    return -1;
3921
}
3922

    
3923
static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
3924
{
3925
    const char *p, *p1;
3926
    int len;
3927
    p = *pp;
3928
    p1 = strchr(p, sep);
3929
    if (!p1)
3930
        return -1;
3931
    len = p1 - p;
3932
    p1++;
3933
    if (buf_size > 0) {
3934
        if (len > buf_size - 1)
3935
            len = buf_size - 1;
3936
        memcpy(buf, p, len);
3937
        buf[len] = '\0';
3938
    }
3939
    *pp = p1;
3940
    return 0;
3941
}
3942

    
3943
int parse_host_src_port(struct sockaddr_in *haddr,
3944
                        struct sockaddr_in *saddr,
3945
                        const char *input_str)
3946
{
3947
    char *str = strdup(input_str);
3948
    char *host_str = str;
3949
    char *src_str;
3950
    const char *src_str2;
3951
    char *ptr;
3952

    
3953
    /*
3954
     * Chop off any extra arguments at the end of the string which
3955
     * would start with a comma, then fill in the src port information
3956
     * if it was provided else use the "any address" and "any port".
3957
     */
3958
    if ((ptr = strchr(str,',')))
3959
        *ptr = '\0';
3960

    
3961
    if ((src_str = strchr(input_str,'@'))) {
3962
        *src_str = '\0';
3963
        src_str++;
3964
    }
3965

    
3966
    if (parse_host_port(haddr, host_str) < 0)
3967
        goto fail;
3968

    
3969
    src_str2 = src_str;
3970
    if (!src_str || *src_str == '\0')
3971
        src_str2 = ":0";
3972

    
3973
    if (parse_host_port(saddr, src_str2) < 0)
3974
        goto fail;
3975

    
3976
    free(str);
3977
    return(0);
3978

    
3979
fail:
3980
    free(str);
3981
    return -1;
3982
}
3983

    
3984
int parse_host_port(struct sockaddr_in *saddr, const char *str)
3985
{
3986
    char buf[512];
3987
    struct hostent *he;
3988
    const char *p, *r;
3989
    int port;
3990

    
3991
    p = str;
3992
    if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3993
        return -1;
3994
    saddr->sin_family = AF_INET;
3995
    if (buf[0] == '\0') {
3996
        saddr->sin_addr.s_addr = 0;
3997
    } else {
3998
        if (isdigit(buf[0])) {
3999
            if (!inet_aton(buf, &saddr->sin_addr))
4000
                return -1;
4001
        } else {
4002
            if ((he = gethostbyname(buf)) == NULL)
4003
                return - 1;
4004
            saddr->sin_addr = *(struct in_addr *)he->h_addr;
4005
        }
4006
    }
4007
    port = strtol(p, (char **)&r, 0);
4008
    if (r == p)
4009
        return -1;
4010
    saddr->sin_port = htons(port);
4011
    return 0;
4012
}
4013

    
4014
#ifndef _WIN32
4015
static int parse_unix_path(struct sockaddr_un *uaddr, const char *str)
4016
{
4017
    const char *p;
4018
    int len;
4019

    
4020
    len = MIN(108, strlen(str));
4021
    p = strchr(str, ',');
4022
    if (p)
4023
        len = MIN(len, p - str);
4024

    
4025
    memset(uaddr, 0, sizeof(*uaddr));
4026

    
4027
    uaddr->sun_family = AF_UNIX;
4028
    memcpy(uaddr->sun_path, str, len);
4029

    
4030
    return 0;
4031
}
4032
#endif
4033

    
4034
/* find or alloc a new VLAN */
4035
VLANState *qemu_find_vlan(int id)
4036
{
4037
    VLANState **pvlan, *vlan;
4038
    for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
4039
        if (vlan->id == id)
4040
            return vlan;
4041
    }
4042
    vlan = qemu_mallocz(sizeof(VLANState));
4043
    if (!vlan)
4044
        return NULL;
4045
    vlan->id = id;
4046
    vlan->next = NULL;
4047
    pvlan = &first_vlan;
4048
    while (*pvlan != NULL)
4049
        pvlan = &(*pvlan)->next;
4050
    *pvlan = vlan;
4051
    return vlan;
4052
}
4053

    
4054
VLANClientState *qemu_new_vlan_client(VLANState *vlan,
4055
                                      IOReadHandler *fd_read,
4056
                                      IOCanRWHandler *fd_can_read,
4057
                                      void *opaque)
4058
{
4059
    VLANClientState *vc, **pvc;
4060
    vc = qemu_mallocz(sizeof(VLANClientState));
4061
    if (!vc)
4062
        return NULL;
4063
    vc->fd_read = fd_read;
4064
    vc->fd_can_read = fd_can_read;
4065
    vc->opaque = opaque;
4066
    vc->vlan = vlan;
4067

    
4068
    vc->next = NULL;
4069
    pvc = &vlan->first_client;
4070
    while (*pvc != NULL)
4071
        pvc = &(*pvc)->next;
4072
    *pvc = vc;
4073
    return vc;
4074
}
4075

    
4076
void qemu_del_vlan_client(VLANClientState *vc)
4077
{
4078
    VLANClientState **pvc = &vc->vlan->first_client;
4079

    
4080
    while (*pvc != NULL)
4081
        if (*pvc == vc) {
4082
            *pvc = vc->next;
4083
            free(vc);
4084
            break;
4085
        } else
4086
            pvc = &(*pvc)->next;
4087
}
4088

    
4089
int qemu_can_send_packet(VLANClientState *vc1)
4090
{
4091
    VLANState *vlan = vc1->vlan;
4092
    VLANClientState *vc;
4093

    
4094
    for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
4095
        if (vc != vc1) {
4096
            if (vc->fd_can_read && vc->fd_can_read(vc->opaque))
4097
                return 1;
4098
        }
4099
    }
4100
    return 0;
4101
}
4102

    
4103
void qemu_send_packet(VLANClientState *vc1, const uint8_t *buf, int size)
4104
{
4105
    VLANState *vlan = vc1->vlan;
4106
    VLANClientState *vc;
4107

    
4108
#if 0
4109
    printf("vlan %d send:\n", vlan->id);
4110
    hex_dump(stdout, buf, size);
4111
#endif
4112
    for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
4113
        if (vc != vc1) {
4114
            vc->fd_read(vc->opaque, buf, size);
4115
        }
4116
    }
4117
}
4118

    
4119
#if defined(CONFIG_SLIRP)
4120

    
4121
/* slirp network adapter */
4122

    
4123
static int slirp_inited;
4124
static VLANClientState *slirp_vc;
4125

    
4126
int slirp_can_output(void)
4127
{
4128
    return !slirp_vc || qemu_can_send_packet(slirp_vc);
4129
}
4130

    
4131
void slirp_output(const uint8_t *pkt, int pkt_len)
4132
{
4133
#if 0
4134
    printf("slirp output:\n");
4135
    hex_dump(stdout, pkt, pkt_len);
4136
#endif
4137
    if (!slirp_vc)
4138
        return;
4139
    qemu_send_packet(slirp_vc, pkt, pkt_len);
4140
}
4141

    
4142
static void slirp_receive(void *opaque, const uint8_t *buf, int size)
4143
{
4144
#if 0
4145
    printf("slirp input:\n");
4146
    hex_dump(stdout, buf, size);
4147
#endif
4148
    slirp_input(buf, size);
4149
}
4150

    
4151
static int net_slirp_init(VLANState *vlan)
4152
{
4153
    if (!slirp_inited) {
4154
        slirp_inited = 1;
4155
        slirp_init();
4156
    }
4157
    slirp_vc = qemu_new_vlan_client(vlan,
4158
                                    slirp_receive, NULL, NULL);
4159
    snprintf(slirp_vc->info_str, sizeof(slirp_vc->info_str), "user redirector");
4160
    return 0;
4161
}
4162

    
4163
static void net_slirp_redir(const char *redir_str)
4164
{
4165
    int is_udp;
4166
    char buf[256], *r;
4167
    const char *p;
4168
    struct in_addr guest_addr;
4169
    int host_port, guest_port;
4170

    
4171
    if (!slirp_inited) {
4172
        slirp_inited = 1;
4173
        slirp_init();
4174
    }
4175

    
4176
    p = redir_str;
4177
    if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
4178
        goto fail;
4179
    if (!strcmp(buf, "tcp")) {
4180
        is_udp = 0;
4181
    } else if (!strcmp(buf, "udp")) {
4182
        is_udp = 1;
4183
    } else {
4184
        goto fail;
4185
    }
4186

    
4187
    if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
4188
        goto fail;
4189
    host_port = strtol(buf, &r, 0);
4190
    if (r == buf)
4191
        goto fail;
4192

    
4193
    if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
4194
        goto fail;
4195
    if (buf[0] == '\0') {
4196
        pstrcpy(buf, sizeof(buf), "10.0.2.15");
4197
    }
4198
    if (!inet_aton(buf, &guest_addr))
4199
        goto fail;
4200

    
4201
    guest_port = strtol(p, &r, 0);
4202
    if (r == p)
4203
        goto fail;
4204

    
4205
    if (slirp_redir(is_udp, host_port, guest_addr, guest_port) < 0) {
4206
        fprintf(stderr, "qemu: could not set up redirection\n");
4207
        exit(1);
4208
    }
4209
    return;
4210
 fail:
4211
    fprintf(stderr, "qemu: syntax: -redir [tcp|udp]:host-port:[guest-host]:guest-port\n");
4212
    exit(1);
4213
}
4214

    
4215
#ifndef _WIN32
4216

    
4217
char smb_dir[1024];
4218

    
4219
static void erase_dir(char *dir_name)
4220
{
4221
    DIR *d;
4222
    struct dirent *de;
4223
    char filename[1024];
4224

    
4225
    /* erase all the files in the directory */
4226
    if ((d = opendir(dir_name)) != 0) {
4227
        for(;;) {
4228
            de = readdir(d);
4229
            if (!de)
4230
                break;
4231
            if (strcmp(de->d_name, ".") != 0 &&
4232
                strcmp(de->d_name, "..") != 0) {
4233
                snprintf(filename, sizeof(filename), "%s/%s",
4234
                         smb_dir, de->d_name);
4235
                if (unlink(filename) != 0)  /* is it a directory? */
4236
                    erase_dir(filename);
4237
            }
4238
        }
4239
        closedir(d);
4240
        rmdir(dir_name);
4241
    }
4242
}
4243

    
4244
/* automatic user mode samba server configuration */
4245
static void smb_exit(void)
4246
{
4247
    erase_dir(smb_dir);
4248
}
4249

    
4250
/* automatic user mode samba server configuration */
4251
static void net_slirp_smb(const char *exported_dir)
4252
{
4253
    char smb_conf[1024];
4254
    char smb_cmdline[1024];
4255
    FILE *f;
4256

    
4257
    if (!slirp_inited) {
4258
        slirp_inited = 1;
4259
        slirp_init();
4260
    }
4261

    
4262
    /* XXX: better tmp dir construction */
4263
    snprintf(smb_dir, sizeof(smb_dir), "/tmp/qemu-smb.%d", getpid());
4264
    if (mkdir(smb_dir, 0700) < 0) {
4265
        fprintf(stderr, "qemu: could not create samba server dir '%s'\n", smb_dir);
4266
        exit(1);
4267
    }
4268
    snprintf(smb_conf, sizeof(smb_conf), "%s/%s", smb_dir, "smb.conf");
4269

    
4270
    f = fopen(smb_conf, "w");
4271
    if (!f) {
4272
        fprintf(stderr, "qemu: could not create samba server configuration file '%s'\n", smb_conf);
4273
        exit(1);
4274
    }
4275
    fprintf(f,
4276
            "[global]\n"
4277
            "private dir=%s\n"
4278
            "smb ports=0\n"
4279
            "socket address=127.0.0.1\n"
4280
            "pid directory=%s\n"
4281
            "lock directory=%s\n"
4282
            "log file=%s/log.smbd\n"
4283
            "smb passwd file=%s/smbpasswd\n"
4284
            "security = share\n"
4285
            "[qemu]\n"
4286
            "path=%s\n"
4287
            "read only=no\n"
4288
            "guest ok=yes\n",
4289
            smb_dir,
4290
            smb_dir,
4291
            smb_dir,
4292
            smb_dir,
4293
            smb_dir,
4294
            exported_dir
4295
            );
4296
    fclose(f);
4297
    atexit(smb_exit);
4298

    
4299
    snprintf(smb_cmdline, sizeof(smb_cmdline), "%s -s %s",
4300
             SMBD_COMMAND, smb_conf);
4301

    
4302
    slirp_add_exec(0, smb_cmdline, 4, 139);
4303
}
4304

    
4305
#endif /* !defined(_WIN32) */
4306
void do_info_slirp(void)
4307
{
4308
    slirp_stats();
4309
}
4310

    
4311
#endif /* CONFIG_SLIRP */
4312

    
4313
#if !defined(_WIN32)
4314

    
4315
typedef struct TAPState {
4316
    VLANClientState *vc;
4317
    int fd;
4318
    char down_script[1024];
4319
} TAPState;
4320

    
4321
static void tap_receive(void *opaque, const uint8_t *buf, int size)
4322
{
4323
    TAPState *s = opaque;
4324
    int ret;
4325
    for(;;) {
4326
        ret = write(s->fd, buf, size);
4327
        if (ret < 0 && (errno == EINTR || errno == EAGAIN)) {
4328
        } else {
4329
            break;
4330
        }
4331
    }
4332
}
4333

    
4334
static void tap_send(void *opaque)
4335
{
4336
    TAPState *s = opaque;
4337
    uint8_t buf[4096];
4338
    int size;
4339

    
4340
#ifdef __sun__
4341
    struct strbuf sbuf;
4342
    int f = 0;
4343
    sbuf.maxlen = sizeof(buf);
4344
    sbuf.buf = buf;
4345
    size = getmsg(s->fd, NULL, &sbuf, &f) >=0 ? sbuf.len : -1;
4346
#else
4347
    size = read(s->fd, buf, sizeof(buf));
4348
#endif
4349
    if (size > 0) {
4350
        qemu_send_packet(s->vc, buf, size);
4351
    }
4352
}
4353

    
4354
/* fd support */
4355

    
4356
static TAPState *net_tap_fd_init(VLANState *vlan, int fd)
4357
{
4358
    TAPState *s;
4359

    
4360
    s = qemu_mallocz(sizeof(TAPState));
4361
    if (!s)
4362
        return NULL;
4363
    s->fd = fd;
4364
    s->vc = qemu_new_vlan_client(vlan, tap_receive, NULL, s);
4365
    qemu_set_fd_handler(s->fd, tap_send, NULL, s);
4366
    snprintf(s->vc->info_str, sizeof(s->vc->info_str), "tap: fd=%d", fd);
4367
    return s;
4368
}
4369

    
4370
#if defined (_BSD) || defined (__FreeBSD_kernel__)
4371
static int tap_open(char *ifname, int ifname_size)
4372
{
4373
    int fd;
4374
    char *dev;
4375
    struct stat s;
4376

    
4377
    TFR(fd = open("/dev/tap", O_RDWR));
4378
    if (fd < 0) {
4379
        fprintf(stderr, "warning: could not open /dev/tap: no virtual network emulation\n");
4380
        return -1;
4381
    }
4382

    
4383
    fstat(fd, &s);
4384
    dev = devname(s.st_rdev, S_IFCHR);
4385
    pstrcpy(ifname, ifname_size, dev);
4386

    
4387
    fcntl(fd, F_SETFL, O_NONBLOCK);
4388
    return fd;
4389
}
4390
#elif defined(__sun__)
4391
#define TUNNEWPPA       (('T'<<16) | 0x0001)
4392
/*
4393
 * Allocate TAP device, returns opened fd.
4394
 * Stores dev name in the first arg(must be large enough).
4395
 */
4396
int tap_alloc(char *dev, size_t dev_size)
4397
{
4398
    int tap_fd, if_fd, ppa = -1;
4399
    static int ip_fd = 0;
4400
    char *ptr;
4401

    
4402
    static int arp_fd = 0;
4403
    int ip_muxid, arp_muxid;
4404
    struct strioctl  strioc_if, strioc_ppa;
4405
    int link_type = I_PLINK;;
4406
    struct lifreq ifr;
4407
    char actual_name[32] = "";
4408

    
4409
    memset(&ifr, 0x0, sizeof(ifr));
4410

    
4411
    if( *dev ){
4412
       ptr = dev;
4413
       while( *ptr && !isdigit((int)*ptr) ) ptr++;
4414
       ppa = atoi(ptr);
4415
    }
4416

    
4417
    /* Check if IP device was opened */
4418
    if( ip_fd )
4419
       close(ip_fd);
4420

    
4421
    TFR(ip_fd = open("/dev/udp", O_RDWR, 0));
4422
    if (ip_fd < 0) {
4423
       syslog(LOG_ERR, "Can't open /dev/ip (actually /dev/udp)");
4424
       return -1;
4425
    }
4426

    
4427
    TFR(tap_fd = open("/dev/tap", O_RDWR, 0));
4428
    if (tap_fd < 0) {
4429
       syslog(LOG_ERR, "Can't open /dev/tap");
4430
       return -1;
4431
    }
4432

    
4433
    /* Assign a new PPA and get its unit number. */
4434
    strioc_ppa.ic_cmd = TUNNEWPPA;
4435
    strioc_ppa.ic_timout = 0;
4436
    strioc_ppa.ic_len = sizeof(ppa);
4437
    strioc_ppa.ic_dp = (char *)&ppa;
4438
    if ((ppa = ioctl (tap_fd, I_STR, &strioc_ppa)) < 0)
4439
       syslog (LOG_ERR, "Can't assign new interface");
4440

    
4441
    TFR(if_fd = open("/dev/tap", O_RDWR, 0));
4442
    if (if_fd < 0) {
4443
       syslog(LOG_ERR, "Can't open /dev/tap (2)");
4444
       return -1;
4445
    }
4446
    if(ioctl(if_fd, I_PUSH, "ip") < 0){
4447
       syslog(LOG_ERR, "Can't push IP module");
4448
       return -1;
4449
    }
4450

    
4451
    if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) < 0)
4452
        syslog(LOG_ERR, "Can't get flags\n");
4453

    
4454
    snprintf (actual_name, 32, "tap%d", ppa);
4455
    strncpy (ifr.lifr_name, actual_name, sizeof (ifr.lifr_name));
4456

    
4457
    ifr.lifr_ppa = ppa;
4458
    /* Assign ppa according to the unit number returned by tun device */
4459

    
4460
    if (ioctl (if_fd, SIOCSLIFNAME, &ifr) < 0)
4461
        syslog (LOG_ERR, "Can't set PPA %d", ppa);
4462
    if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) <0)
4463
        syslog (LOG_ERR, "Can't get flags\n");
4464
    /* Push arp module to if_fd */
4465
    if (ioctl (if_fd, I_PUSH, "arp") < 0)
4466
        syslog (LOG_ERR, "Can't push ARP module (2)");
4467

    
4468
    /* Push arp module to ip_fd */
4469
    if (ioctl (ip_fd, I_POP, NULL) < 0)
4470
        syslog (LOG_ERR, "I_POP failed\n");
4471
    if (ioctl (ip_fd, I_PUSH, "arp") < 0)
4472
        syslog (LOG_ERR, "Can't push ARP module (3)\n");
4473
    /* Open arp_fd */
4474
    TFR(arp_fd = open ("/dev/tap", O_RDWR, 0));
4475
    if (arp_fd < 0)
4476
       syslog (LOG_ERR, "Can't open %s\n", "/dev/tap");
4477

    
4478
    /* Set ifname to arp */
4479
    strioc_if.ic_cmd = SIOCSLIFNAME;
4480
    strioc_if.ic_timout = 0;
4481
    strioc_if.ic_len = sizeof(ifr);
4482
    strioc_if.ic_dp = (char *)&ifr;
4483
    if (ioctl(arp_fd, I_STR, &strioc_if) < 0){
4484
        syslog (LOG_ERR, "Can't set ifname to arp\n");
4485
    }
4486

    
4487
    if((ip_muxid = ioctl(ip_fd, I_LINK, if_fd)) < 0){
4488
       syslog(LOG_ERR, "Can't link TAP device to IP");
4489
       return -1;
4490
    }
4491

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

    
4495
    close (if_fd);
4496

    
4497
    memset(&ifr, 0x0, sizeof(ifr));
4498
    strncpy (ifr.lifr_name, actual_name, sizeof (ifr.lifr_name));
4499
    ifr.lifr_ip_muxid  = ip_muxid;
4500
    ifr.lifr_arp_muxid = arp_muxid;
4501

    
4502
    if (ioctl (ip_fd, SIOCSLIFMUXID, &ifr) < 0)
4503
    {
4504
      ioctl (ip_fd, I_PUNLINK , arp_muxid);
4505
      ioctl (ip_fd, I_PUNLINK, ip_muxid);
4506
      syslog (LOG_ERR, "Can't set multiplexor id");
4507
    }
4508

    
4509
    snprintf(dev, dev_size, "tap%d", ppa);
4510
    return tap_fd;
4511
}
4512

    
4513
static int tap_open(char *ifname, int ifname_size)
4514
{
4515
    char  dev[10]="";
4516
    int fd;
4517
    if( (fd = tap_alloc(dev, sizeof(dev))) < 0 ){
4518
       fprintf(stderr, "Cannot allocate TAP device\n");
4519
       return -1;
4520
    }
4521
    pstrcpy(ifname, ifname_size, dev);
4522
    fcntl(fd, F_SETFL, O_NONBLOCK);
4523
    return fd;
4524
}
4525
#else
4526
static int tap_open(char *ifname, int ifname_size)
4527
{
4528
    struct ifreq ifr;
4529
    int fd, ret;
4530

    
4531
    TFR(fd = open("/dev/net/tun", O_RDWR));
4532
    if (fd < 0) {
4533
        fprintf(stderr, "warning: could not open /dev/net/tun: no virtual network emulation\n");
4534
        return -1;
4535
    }
4536
    memset(&ifr, 0, sizeof(ifr));
4537
    ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
4538
    if (ifname[0] != '\0')
4539
        pstrcpy(ifr.ifr_name, IFNAMSIZ, ifname);
4540
    else
4541
        pstrcpy(ifr.ifr_name, IFNAMSIZ, "tap%d");
4542
    ret = ioctl(fd, TUNSETIFF, (void *) &ifr);
4543
    if (ret != 0) {
4544
        fprintf(stderr, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
4545
        close(fd);
4546
        return -1;
4547
    }
4548
    pstrcpy(ifname, ifname_size, ifr.ifr_name);
4549
    fcntl(fd, F_SETFL, O_NONBLOCK);
4550
    return fd;
4551
}
4552
#endif
4553

    
4554
static int launch_script(const char *setup_script, const char *ifname, int fd)
4555
{
4556
    int pid, status;
4557
    char *args[3];
4558
    char **parg;
4559

    
4560
        /* try to launch network script */
4561
        pid = fork();
4562
        if (pid >= 0) {
4563
            if (pid == 0) {
4564
                int open_max = sysconf (_SC_OPEN_MAX), i;
4565
                for (i = 0; i < open_max; i++)
4566
                    if (i != STDIN_FILENO &&
4567
                        i != STDOUT_FILENO &&
4568
                        i != STDERR_FILENO &&
4569
                        i != fd)
4570
                        close(i);
4571

    
4572
                parg = args;
4573
                *parg++ = (char *)setup_script;
4574
                *parg++ = (char *)ifname;
4575
                *parg++ = NULL;
4576
                execv(setup_script, args);
4577
                _exit(1);
4578
            }
4579
            while (waitpid(pid, &status, 0) != pid);
4580
            if (!WIFEXITED(status) ||
4581
                WEXITSTATUS(status) != 0) {
4582
                fprintf(stderr, "%s: could not launch network script\n",
4583
                        setup_script);
4584
                return -1;
4585
            }
4586
        }
4587
    return 0;
4588
}
4589

    
4590
static int net_tap_init(VLANState *vlan, const char *ifname1,
4591
                        const char *setup_script, const char *down_script)
4592
{
4593
    TAPState *s;
4594
    int fd;
4595
    char ifname[128];
4596

    
4597
    if (ifname1 != NULL)
4598
        pstrcpy(ifname, sizeof(ifname), ifname1);
4599
    else
4600
        ifname[0] = '\0';
4601
    TFR(fd = tap_open(ifname, sizeof(ifname)));
4602
    if (fd < 0)
4603
        return -1;
4604

    
4605
    if (!setup_script || !strcmp(setup_script, "no"))
4606
        setup_script = "";
4607
    if (setup_script[0] != '\0') {
4608
        if (launch_script(setup_script, ifname, fd))
4609
            return -1;
4610
    }
4611
    s = net_tap_fd_init(vlan, fd);
4612
    if (!s)
4613
        return -1;
4614
    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4615
             "tap: ifname=%s setup_script=%s", ifname, setup_script);
4616
    if (down_script && strcmp(down_script, "no"))
4617
        snprintf(s->down_script, sizeof(s->down_script), "%s", down_script);
4618
    return 0;
4619
}
4620

    
4621
#endif /* !_WIN32 */
4622

    
4623
#if defined(CONFIG_VDE)
4624
typedef struct VDEState {
4625
    VLANClientState *vc;
4626
    VDECONN *vde;
4627
} VDEState;
4628

    
4629
static void vde_to_qemu(void *opaque)
4630
{
4631
    VDEState *s = opaque;
4632
    uint8_t buf[4096];
4633
    int size;
4634

    
4635
    size = vde_recv(s->vde, buf, sizeof(buf), 0);
4636
    if (size > 0) {
4637
        qemu_send_packet(s->vc, buf, size);
4638
    }
4639
}
4640

    
4641
static void vde_from_qemu(void *opaque, const uint8_t *buf, int size)
4642
{
4643
    VDEState *s = opaque;
4644
    int ret;
4645
    for(;;) {
4646
        ret = vde_send(s->vde, buf, size, 0);
4647
        if (ret < 0 && errno == EINTR) {
4648
        } else {
4649
            break;
4650
        }
4651
    }
4652
}
4653

    
4654
static int net_vde_init(VLANState *vlan, const char *sock, int port,
4655
                        const char *group, int mode)
4656
{
4657
    VDEState *s;
4658
    char *init_group = strlen(group) ? (char *)group : NULL;
4659
    char *init_sock = strlen(sock) ? (char *)sock : NULL;
4660

    
4661
    struct vde_open_args args = {
4662
        .port = port,
4663
        .group = init_group,
4664
        .mode = mode,
4665
    };
4666

    
4667
    s = qemu_mallocz(sizeof(VDEState));
4668
    if (!s)
4669
        return -1;
4670
    s->vde = vde_open(init_sock, "QEMU", &args);
4671
    if (!s->vde){
4672
        free(s);
4673
        return -1;
4674
    }
4675
    s->vc = qemu_new_vlan_client(vlan, vde_from_qemu, NULL, s);
4676
    qemu_set_fd_handler(vde_datafd(s->vde), vde_to_qemu, NULL, s);
4677
    snprintf(s->vc->info_str, sizeof(s->vc->info_str), "vde: sock=%s fd=%d",
4678
             sock, vde_datafd(s->vde));
4679
    return 0;
4680
}
4681
#endif
4682

    
4683
/* network connection */
4684
typedef struct NetSocketState {
4685
    VLANClientState *vc;
4686
    int fd;
4687
    int state; /* 0 = getting length, 1 = getting data */
4688
    int index;
4689
    int packet_len;
4690
    uint8_t buf[4096];
4691
    struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
4692
} NetSocketState;
4693

    
4694
typedef struct NetSocketListenState {
4695
    VLANState *vlan;
4696
    int fd;
4697
} NetSocketListenState;
4698

    
4699
/* XXX: we consider we can send the whole packet without blocking */
4700
static void net_socket_receive(void *opaque, const uint8_t *buf, int size)
4701
{
4702
    NetSocketState *s = opaque;
4703
    uint32_t len;
4704
    len = htonl(size);
4705

    
4706
    send_all(s->fd, (const uint8_t *)&len, sizeof(len));
4707
    send_all(s->fd, buf, size);
4708
}
4709

    
4710
static void net_socket_receive_dgram(void *opaque, const uint8_t *buf, int size)
4711
{
4712
    NetSocketState *s = opaque;
4713
    sendto(s->fd, buf, size, 0,
4714
           (struct sockaddr *)&s->dgram_dst, sizeof(s->dgram_dst));
4715
}
4716

    
4717
static void net_socket_send(void *opaque)
4718
{
4719
    NetSocketState *s = opaque;
4720
    int l, size, err;
4721
    uint8_t buf1[4096];
4722
    const uint8_t *buf;
4723

    
4724
    size = recv(s->fd, buf1, sizeof(buf1), 0);
4725
    if (size < 0) {
4726
        err = socket_error();
4727
        if (err != EWOULDBLOCK)
4728
            goto eoc;
4729
    } else if (size == 0) {
4730
        /* end of connection */
4731
    eoc:
4732
        qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
4733
        closesocket(s->fd);
4734
        return;
4735
    }
4736
    buf = buf1;
4737
    while (size > 0) {
4738
        /* reassemble a packet from the network */
4739
        switch(s->state) {
4740
        case 0:
4741
            l = 4 - s->index;
4742
            if (l > size)
4743
                l = size;
4744
            memcpy(s->buf + s->index, buf, l);
4745
            buf += l;
4746
            size -= l;
4747
            s->index += l;
4748
            if (s->index == 4) {
4749
                /* got length */
4750
                s->packet_len = ntohl(*(uint32_t *)s->buf);
4751
                s->index = 0;
4752
                s->state = 1;
4753
            }
4754
            break;
4755
        case 1:
4756
            l = s->packet_len - s->index;
4757
            if (l > size)
4758
                l = size;
4759
            memcpy(s->buf + s->index, buf, l);
4760
            s->index += l;
4761
            buf += l;
4762
            size -= l;
4763
            if (s->index >= s->packet_len) {
4764
                qemu_send_packet(s->vc, s->buf, s->packet_len);
4765
                s->index = 0;
4766
                s->state = 0;
4767
            }
4768
            break;
4769
        }
4770
    }
4771
}
4772

    
4773
static void net_socket_send_dgram(void *opaque)
4774
{
4775
    NetSocketState *s = opaque;
4776
    int size;
4777

    
4778
    size = recv(s->fd, s->buf, sizeof(s->buf), 0);
4779
    if (size < 0)
4780
        return;
4781
    if (size == 0) {
4782
        /* end of connection */
4783
        qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
4784
        return;
4785
    }
4786
    qemu_send_packet(s->vc, s->buf, size);
4787
}
4788

    
4789
static int net_socket_mcast_create(struct sockaddr_in *mcastaddr)
4790
{
4791
    struct ip_mreq imr;
4792
    int fd;
4793
    int val, ret;
4794
    if (!IN_MULTICAST(ntohl(mcastaddr->sin_addr.s_addr))) {
4795
        fprintf(stderr, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
4796
                inet_ntoa(mcastaddr->sin_addr),
4797
                (int)ntohl(mcastaddr->sin_addr.s_addr));
4798
        return -1;
4799

    
4800
    }
4801
    fd = socket(PF_INET, SOCK_DGRAM, 0);
4802
    if (fd < 0) {
4803
        perror("socket(PF_INET, SOCK_DGRAM)");
4804
        return -1;
4805
    }
4806

    
4807
    val = 1;
4808
    ret=setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
4809
                   (const char *)&val, sizeof(val));
4810
    if (ret < 0) {
4811
        perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
4812
        goto fail;
4813
    }
4814

    
4815
    ret = bind(fd, (struct sockaddr *)mcastaddr, sizeof(*mcastaddr));
4816
    if (ret < 0) {
4817
        perror("bind");
4818
        goto fail;
4819
    }
4820

    
4821
    /* Add host to multicast group */
4822
    imr.imr_multiaddr = mcastaddr->sin_addr;
4823
    imr.imr_interface.s_addr = htonl(INADDR_ANY);
4824

    
4825
    ret = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
4826
                     (const char *)&imr, sizeof(struct ip_mreq));
4827
    if (ret < 0) {
4828
        perror("setsockopt(IP_ADD_MEMBERSHIP)");
4829
        goto fail;
4830
    }
4831

    
4832
    /* Force mcast msgs to loopback (eg. several QEMUs in same host */
4833
    val = 1;
4834
    ret=setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
4835
                   (const char *)&val, sizeof(val));
4836
    if (ret < 0) {
4837
        perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
4838
        goto fail;
4839
    }
4840

    
4841
    socket_set_nonblock(fd);
4842
    return fd;
4843
fail:
4844
    if (fd >= 0)
4845
        closesocket(fd);
4846
    return -1;
4847
}
4848

    
4849
static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan, int fd,
4850
                                          int is_connected)
4851
{
4852
    struct sockaddr_in saddr;
4853
    int newfd;
4854
    socklen_t saddr_len;
4855
    NetSocketState *s;
4856

    
4857
    /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
4858
     * Because this may be "shared" socket from a "master" process, datagrams would be recv()
4859
     * by ONLY ONE process: we must "clone" this dgram socket --jjo
4860
     */
4861

    
4862
    if (is_connected) {
4863
        if (getsockname(fd, (struct sockaddr *) &saddr, &saddr_len) == 0) {
4864
            /* must be bound */
4865
            if (saddr.sin_addr.s_addr==0) {
4866
                fprintf(stderr, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
4867
                        fd);
4868
                return NULL;
4869
            }
4870
            /* clone dgram socket */
4871
            newfd = net_socket_mcast_create(&saddr);
4872
            if (newfd < 0) {
4873
                /* error already reported by net_socket_mcast_create() */
4874
                close(fd);
4875
                return NULL;
4876
            }
4877
            /* clone newfd to fd, close newfd */
4878
            dup2(newfd, fd);
4879
            close(newfd);
4880

    
4881
        } else {
4882
            fprintf(stderr, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
4883
                    fd, strerror(errno));
4884
            return NULL;
4885
        }
4886
    }
4887

    
4888
    s = qemu_mallocz(sizeof(NetSocketState));
4889
    if (!s)
4890
        return NULL;
4891
    s->fd = fd;
4892

    
4893
    s->vc = qemu_new_vlan_client(vlan, net_socket_receive_dgram, NULL, s);
4894
    qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s);
4895

    
4896
    /* mcast: save bound address as dst */
4897
    if (is_connected) s->dgram_dst=saddr;
4898

    
4899
    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4900
            "socket: fd=%d (%s mcast=%s:%d)",
4901
            fd, is_connected? "cloned" : "",
4902
            inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4903
    return s;
4904
}
4905

    
4906
static void net_socket_connect(void *opaque)
4907
{
4908
    NetSocketState *s = opaque;
4909
    qemu_set_fd_handler(s->fd, net_socket_send, NULL, s);
4910
}
4911

    
4912
static NetSocketState *net_socket_fd_init_stream(VLANState *vlan, int fd,
4913
                                          int is_connected)
4914
{
4915
    NetSocketState *s;
4916
    s = qemu_mallocz(sizeof(NetSocketState));
4917
    if (!s)
4918
        return NULL;
4919
    s->fd = fd;
4920
    s->vc = qemu_new_vlan_client(vlan,
4921
                                 net_socket_receive, NULL, s);
4922
    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4923
             "socket: fd=%d", fd);
4924
    if (is_connected) {
4925
        net_socket_connect(s);
4926
    } else {
4927
        qemu_set_fd_handler(s->fd, NULL, net_socket_connect, s);
4928
    }
4929
    return s;
4930
}
4931

    
4932
static NetSocketState *net_socket_fd_init(VLANState *vlan, int fd,
4933
                                          int is_connected)
4934
{
4935
    int so_type=-1, optlen=sizeof(so_type);
4936

    
4937
    if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type,
4938
        (socklen_t *)&optlen)< 0) {
4939
        fprintf(stderr, "qemu: error: getsockopt(SO_TYPE) for fd=%d failed\n", fd);
4940
        return NULL;
4941
    }
4942
    switch(so_type) {
4943
    case SOCK_DGRAM:
4944
        return net_socket_fd_init_dgram(vlan, fd, is_connected);
4945
    case SOCK_STREAM:
4946
        return net_socket_fd_init_stream(vlan, fd, is_connected);
4947
    default:
4948
        /* who knows ... this could be a eg. a pty, do warn and continue as stream */
4949
        fprintf(stderr, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type, fd);
4950
        return net_socket_fd_init_stream(vlan, fd, is_connected);
4951
    }
4952
    return NULL;
4953
}
4954

    
4955
static void net_socket_accept(void *opaque)
4956
{
4957
    NetSocketListenState *s = opaque;
4958
    NetSocketState *s1;
4959
    struct sockaddr_in saddr;
4960
    socklen_t len;
4961
    int fd;
4962

    
4963
    for(;;) {
4964
        len = sizeof(saddr);
4965
        fd = accept(s->fd, (struct sockaddr *)&saddr, &len);
4966
        if (fd < 0 && errno != EINTR) {
4967
            return;
4968
        } else if (fd >= 0) {
4969
            break;
4970
        }
4971
    }
4972
    s1 = net_socket_fd_init(s->vlan, fd, 1);
4973
    if (!s1) {
4974
        closesocket(fd);
4975
    } else {
4976
        snprintf(s1->vc->info_str, sizeof(s1->vc->info_str),
4977
                 "socket: connection from %s:%d",
4978
                 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4979
    }
4980
}
4981

    
4982
static int net_socket_listen_init(VLANState *vlan, const char *host_str)
4983
{
4984
    NetSocketListenState *s;
4985
    int fd, val, ret;
4986
    struct sockaddr_in saddr;
4987