Statistics
| Branch: | Revision:

root / vl.c @ 7d294b61

History | View | Annotate | Download (217.9 kB)

1
/*
2
 * QEMU System Emulator
3
 *
4
 * Copyright (c) 2003-2007 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 "vl.h"
25

    
26
#include <unistd.h>
27
#include <fcntl.h>
28
#include <signal.h>
29
#include <time.h>
30
#include <errno.h>
31
#include <sys/time.h>
32
#include <zlib.h>
33

    
34
#ifndef _WIN32
35
#include <sys/times.h>
36
#include <sys/wait.h>
37
#include <termios.h>
38
#include <sys/poll.h>
39
#include <sys/mman.h>
40
#include <sys/ioctl.h>
41
#include <sys/socket.h>
42
#include <netinet/in.h>
43
#include <dirent.h>
44
#include <netdb.h>
45
#include <sys/select.h>
46
#include <arpa/inet.h>
47
#ifdef _BSD
48
#include <sys/stat.h>
49
#ifndef __APPLE__
50
#include <libutil.h>
51
#endif
52
#elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
53
#include <freebsd/stdlib.h>
54
#else
55
#ifndef __sun__
56
#include <linux/if.h>
57
#include <linux/if_tun.h>
58
#include <pty.h>
59
#include <malloc.h>
60
#include <linux/rtc.h>
61

    
62
/* For the benefit of older linux systems which don't supply it,
63
   we use a local copy of hpet.h. */
64
/* #include <linux/hpet.h> */
65
#include "hpet.h"
66

    
67
#include <linux/ppdev.h>
68
#include <linux/parport.h>
69
#else
70
#include <sys/stat.h>
71
#include <sys/ethernet.h>
72
#include <sys/sockio.h>
73
#include <netinet/arp.h>
74
#include <netinet/in.h>
75
#include <netinet/in_systm.h>
76
#include <netinet/ip.h>
77
#include <netinet/ip_icmp.h> // must come after ip.h
78
#include <netinet/udp.h>
79
#include <netinet/tcp.h>
80
#include <net/if.h>
81
#include <syslog.h>
82
#include <stropts.h>
83
#endif
84
#endif
85
#else
86
#include <winsock2.h>
87
int inet_aton(const char *cp, struct in_addr *ia);
88
#endif
89

    
90
#if defined(CONFIG_SLIRP)
91
#include "libslirp.h"
92
#endif
93

    
94
#ifdef _WIN32
95
#include <malloc.h>
96
#include <sys/timeb.h>
97
#include <windows.h>
98
#define getopt_long_only getopt_long
99
#define memalign(align, size) malloc(size)
100
#endif
101

    
102
#include "qemu_socket.h"
103

    
104
#ifdef CONFIG_SDL
105
#ifdef __APPLE__
106
#include <SDL/SDL.h>
107
#endif
108
#endif /* CONFIG_SDL */
109

    
110
#ifdef CONFIG_COCOA
111
#undef main
112
#define main qemu_main
113
#endif /* CONFIG_COCOA */
114

    
115
#include "disas.h"
116

    
117
#include "exec-all.h"
118

    
119
#define DEFAULT_NETWORK_SCRIPT "/etc/qemu-ifup"
120
#define DEFAULT_NETWORK_DOWN_SCRIPT "/etc/qemu-ifdown"
121
#ifdef __sun__
122
#define SMBD_COMMAND "/usr/sfw/sbin/smbd"
123
#else
124
#define SMBD_COMMAND "/usr/sbin/smbd"
125
#endif
126

    
127
//#define DEBUG_UNUSED_IOPORT
128
//#define DEBUG_IOPORT
129

    
130
#define PHYS_RAM_MAX_SIZE (2047 * 1024 * 1024)
131

    
132
#ifdef TARGET_PPC
133
#define DEFAULT_RAM_SIZE 144
134
#else
135
#define DEFAULT_RAM_SIZE 128
136
#endif
137
/* in ms */
138
#define GUI_REFRESH_INTERVAL 30
139

    
140
/* Max number of USB devices that can be specified on the commandline.  */
141
#define MAX_USB_CMDLINE 8
142

    
143
/* XXX: use a two level table to limit memory usage */
144
#define MAX_IOPORTS 65536
145

    
146
const char *bios_dir = CONFIG_QEMU_SHAREDIR;
147
const char *bios_name = NULL;
148
char phys_ram_file[1024];
149
void *ioport_opaque[MAX_IOPORTS];
150
IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS];
151
IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];
152
/* Note: bs_table[MAX_DISKS] is a dummy block driver if none available
153
   to store the VM snapshots */
154
BlockDriverState *bs_table[MAX_DISKS + 1], *fd_table[MAX_FD];
155
BlockDriverState *pflash_table[MAX_PFLASH];
156
BlockDriverState *sd_bdrv;
157
BlockDriverState *mtd_bdrv;
158
/* point to the block driver where the snapshots are managed */
159
BlockDriverState *bs_snapshots;
160
int vga_ram_size;
161
static DisplayState display_state;
162
int nographic;
163
const char* keyboard_layout = NULL;
164
int64_t ticks_per_sec;
165
int boot_device = 'c';
166
int ram_size;
167
int pit_min_timer_count = 0;
168
int nb_nics;
169
NICInfo nd_table[MAX_NICS];
170
int vm_running;
171
int rtc_utc = 1;
172
int cirrus_vga_enabled = 1;
173
int vmsvga_enabled = 0;
174
#ifdef TARGET_SPARC
175
int graphic_width = 1024;
176
int graphic_height = 768;
177
int graphic_depth = 8;
178
#else
179
int graphic_width = 800;
180
int graphic_height = 600;
181
int graphic_depth = 15;
182
#endif
183
int full_screen = 0;
184
int no_frame = 0;
185
int no_quit = 0;
186
CharDriverState *serial_hds[MAX_SERIAL_PORTS];
187
CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
188
#ifdef TARGET_I386
189
int win2k_install_hack = 0;
190
#endif
191
int usb_enabled = 0;
192
static VLANState *first_vlan;
193
int smp_cpus = 1;
194
const char *vnc_display;
195
#if defined(TARGET_SPARC)
196
#define MAX_CPUS 16
197
#elif defined(TARGET_I386)
198
#define MAX_CPUS 255
199
#else
200
#define MAX_CPUS 1
201
#endif
202
int acpi_enabled = 1;
203
int fd_bootchk = 1;
204
int no_reboot = 0;
205
int cursor_hide = 1;
206
int graphic_rotate = 0;
207
int daemonize = 0;
208
const char *option_rom[MAX_OPTION_ROMS];
209
int nb_option_roms;
210
int semihosting_enabled = 0;
211
int autostart = 1;
212
#ifdef TARGET_ARM
213
int old_param = 0;
214
#endif
215
const char *qemu_name;
216
int alt_grab = 0;
217
#ifdef TARGET_SPARC
218
unsigned int nb_prom_envs = 0;
219
const char *prom_envs[MAX_PROM_ENVS];
220
#endif
221

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

    
224
/***********************************************************/
225
/* x86 ISA bus support */
226

    
227
target_phys_addr_t isa_mem_base = 0;
228
PicState2 *isa_pic;
229

    
230
uint32_t default_ioport_readb(void *opaque, uint32_t address)
231
{
232
#ifdef DEBUG_UNUSED_IOPORT
233
    fprintf(stderr, "unused inb: port=0x%04x\n", address);
234
#endif
235
    return 0xff;
236
}
237

    
238
void default_ioport_writeb(void *opaque, uint32_t address, uint32_t data)
239
{
240
#ifdef DEBUG_UNUSED_IOPORT
241
    fprintf(stderr, "unused outb: port=0x%04x data=0x%02x\n", address, data);
242
#endif
243
}
244

    
245
/* default is to make two byte accesses */
246
uint32_t default_ioport_readw(void *opaque, uint32_t address)
247
{
248
    uint32_t data;
249
    data = ioport_read_table[0][address](ioport_opaque[address], address);
250
    address = (address + 1) & (MAX_IOPORTS - 1);
251
    data |= ioport_read_table[0][address](ioport_opaque[address], address) << 8;
252
    return data;
253
}
254

    
255
void default_ioport_writew(void *opaque, uint32_t address, uint32_t data)
256
{
257
    ioport_write_table[0][address](ioport_opaque[address], address, data & 0xff);
258
    address = (address + 1) & (MAX_IOPORTS - 1);
259
    ioport_write_table[0][address](ioport_opaque[address], address, (data >> 8) & 0xff);
260
}
261

    
262
uint32_t default_ioport_readl(void *opaque, uint32_t address)
263
{
264
#ifdef DEBUG_UNUSED_IOPORT
265
    fprintf(stderr, "unused inl: port=0x%04x\n", address);
266
#endif
267
    return 0xffffffff;
268
}
269

    
270
void default_ioport_writel(void *opaque, uint32_t address, uint32_t data)
271
{
272
#ifdef DEBUG_UNUSED_IOPORT
273
    fprintf(stderr, "unused outl: port=0x%04x data=0x%02x\n", address, data);
274
#endif
275
}
276

    
277
void init_ioports(void)
278
{
279
    int i;
280

    
281
    for(i = 0; i < MAX_IOPORTS; i++) {
282
        ioport_read_table[0][i] = default_ioport_readb;
283
        ioport_write_table[0][i] = default_ioport_writeb;
284
        ioport_read_table[1][i] = default_ioport_readw;
285
        ioport_write_table[1][i] = default_ioport_writew;
286
        ioport_read_table[2][i] = default_ioport_readl;
287
        ioport_write_table[2][i] = default_ioport_writel;
288
    }
289
}
290

    
291
/* size is the word size in byte */
292
int register_ioport_read(int start, int length, int size,
293
                         IOPortReadFunc *func, void *opaque)
294
{
295
    int i, bsize;
296

    
297
    if (size == 1) {
298
        bsize = 0;
299
    } else if (size == 2) {
300
        bsize = 1;
301
    } else if (size == 4) {
302
        bsize = 2;
303
    } else {
304
        hw_error("register_ioport_read: invalid size");
305
        return -1;
306
    }
307
    for(i = start; i < start + length; i += size) {
308
        ioport_read_table[bsize][i] = func;
309
        if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
310
            hw_error("register_ioport_read: invalid opaque");
311
        ioport_opaque[i] = opaque;
312
    }
313
    return 0;
314
}
315

    
316
/* size is the word size in byte */
317
int register_ioport_write(int start, int length, int size,
318
                          IOPortWriteFunc *func, void *opaque)
319
{
320
    int i, bsize;
321

    
322
    if (size == 1) {
323
        bsize = 0;
324
    } else if (size == 2) {
325
        bsize = 1;
326
    } else if (size == 4) {
327
        bsize = 2;
328
    } else {
329
        hw_error("register_ioport_write: invalid size");
330
        return -1;
331
    }
332
    for(i = start; i < start + length; i += size) {
333
        ioport_write_table[bsize][i] = func;
334
        if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
335
            hw_error("register_ioport_write: invalid opaque");
336
        ioport_opaque[i] = opaque;
337
    }
338
    return 0;
339
}
340

    
341
void isa_unassign_ioport(int start, int length)
342
{
343
    int i;
344

    
345
    for(i = start; i < start + length; i++) {
346
        ioport_read_table[0][i] = default_ioport_readb;
347
        ioport_read_table[1][i] = default_ioport_readw;
348
        ioport_read_table[2][i] = default_ioport_readl;
349

    
350
        ioport_write_table[0][i] = default_ioport_writeb;
351
        ioport_write_table[1][i] = default_ioport_writew;
352
        ioport_write_table[2][i] = default_ioport_writel;
353
    }
354
}
355

    
356
/***********************************************************/
357

    
358
void cpu_outb(CPUState *env, int addr, int val)
359
{
360
#ifdef DEBUG_IOPORT
361
    if (loglevel & CPU_LOG_IOPORT)
362
        fprintf(logfile, "outb: %04x %02x\n", addr, val);
363
#endif
364
    ioport_write_table[0][addr](ioport_opaque[addr], addr, val);
365
#ifdef USE_KQEMU
366
    if (env)
367
        env->last_io_time = cpu_get_time_fast();
368
#endif
369
}
370

    
371
void cpu_outw(CPUState *env, int addr, int val)
372
{
373
#ifdef DEBUG_IOPORT
374
    if (loglevel & CPU_LOG_IOPORT)
375
        fprintf(logfile, "outw: %04x %04x\n", addr, val);
376
#endif
377
    ioport_write_table[1][addr](ioport_opaque[addr], addr, val);
378
#ifdef USE_KQEMU
379
    if (env)
380
        env->last_io_time = cpu_get_time_fast();
381
#endif
382
}
383

    
384
void cpu_outl(CPUState *env, int addr, int val)
385
{
386
#ifdef DEBUG_IOPORT
387
    if (loglevel & CPU_LOG_IOPORT)
388
        fprintf(logfile, "outl: %04x %08x\n", addr, val);
389
#endif
390
    ioport_write_table[2][addr](ioport_opaque[addr], addr, val);
391
#ifdef USE_KQEMU
392
    if (env)
393
        env->last_io_time = cpu_get_time_fast();
394
#endif
395
}
396

    
397
int cpu_inb(CPUState *env, int addr)
398
{
399
    int val;
400
    val = ioport_read_table[0][addr](ioport_opaque[addr], addr);
401
#ifdef DEBUG_IOPORT
402
    if (loglevel & CPU_LOG_IOPORT)
403
        fprintf(logfile, "inb : %04x %02x\n", addr, val);
404
#endif
405
#ifdef USE_KQEMU
406
    if (env)
407
        env->last_io_time = cpu_get_time_fast();
408
#endif
409
    return val;
410
}
411

    
412
int cpu_inw(CPUState *env, int addr)
413
{
414
    int val;
415
    val = ioport_read_table[1][addr](ioport_opaque[addr], addr);
416
#ifdef DEBUG_IOPORT
417
    if (loglevel & CPU_LOG_IOPORT)
418
        fprintf(logfile, "inw : %04x %04x\n", addr, val);
419
#endif
420
#ifdef USE_KQEMU
421
    if (env)
422
        env->last_io_time = cpu_get_time_fast();
423
#endif
424
    return val;
425
}
426

    
427
int cpu_inl(CPUState *env, int addr)
428
{
429
    int val;
430
    val = ioport_read_table[2][addr](ioport_opaque[addr], addr);
431
#ifdef DEBUG_IOPORT
432
    if (loglevel & CPU_LOG_IOPORT)
433
        fprintf(logfile, "inl : %04x %08x\n", addr, val);
434
#endif
435
#ifdef USE_KQEMU
436
    if (env)
437
        env->last_io_time = cpu_get_time_fast();
438
#endif
439
    return val;
440
}
441

    
442
/***********************************************************/
443
void hw_error(const char *fmt, ...)
444
{
445
    va_list ap;
446
    CPUState *env;
447

    
448
    va_start(ap, fmt);
449
    fprintf(stderr, "qemu: hardware error: ");
450
    vfprintf(stderr, fmt, ap);
451
    fprintf(stderr, "\n");
452
    for(env = first_cpu; env != NULL; env = env->next_cpu) {
453
        fprintf(stderr, "CPU #%d:\n", env->cpu_index);
454
#ifdef TARGET_I386
455
        cpu_dump_state(env, stderr, fprintf, X86_DUMP_FPU);
456
#else
457
        cpu_dump_state(env, stderr, fprintf, 0);
458
#endif
459
    }
460
    va_end(ap);
461
    abort();
462
}
463

    
464
/***********************************************************/
465
/* keyboard/mouse */
466

    
467
static QEMUPutKBDEvent *qemu_put_kbd_event;
468
static void *qemu_put_kbd_event_opaque;
469
static QEMUPutMouseEntry *qemu_put_mouse_event_head;
470
static QEMUPutMouseEntry *qemu_put_mouse_event_current;
471

    
472
void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque)
473
{
474
    qemu_put_kbd_event_opaque = opaque;
475
    qemu_put_kbd_event = func;
476
}
477

    
478
QEMUPutMouseEntry *qemu_add_mouse_event_handler(QEMUPutMouseEvent *func,
479
                                                void *opaque, int absolute,
480
                                                const char *name)
481
{
482
    QEMUPutMouseEntry *s, *cursor;
483

    
484
    s = qemu_mallocz(sizeof(QEMUPutMouseEntry));
485
    if (!s)
486
        return NULL;
487

    
488
    s->qemu_put_mouse_event = func;
489
    s->qemu_put_mouse_event_opaque = opaque;
490
    s->qemu_put_mouse_event_absolute = absolute;
491
    s->qemu_put_mouse_event_name = qemu_strdup(name);
492
    s->next = NULL;
493

    
494
    if (!qemu_put_mouse_event_head) {
495
        qemu_put_mouse_event_head = qemu_put_mouse_event_current = s;
496
        return s;
497
    }
498

    
499
    cursor = qemu_put_mouse_event_head;
500
    while (cursor->next != NULL)
501
        cursor = cursor->next;
502

    
503
    cursor->next = s;
504
    qemu_put_mouse_event_current = s;
505

    
506
    return s;
507
}
508

    
509
void qemu_remove_mouse_event_handler(QEMUPutMouseEntry *entry)
510
{
511
    QEMUPutMouseEntry *prev = NULL, *cursor;
512

    
513
    if (!qemu_put_mouse_event_head || entry == NULL)
514
        return;
515

    
516
    cursor = qemu_put_mouse_event_head;
517
    while (cursor != NULL && cursor != entry) {
518
        prev = cursor;
519
        cursor = cursor->next;
520
    }
521

    
522
    if (cursor == NULL) // does not exist or list empty
523
        return;
524
    else if (prev == NULL) { // entry is head
525
        qemu_put_mouse_event_head = cursor->next;
526
        if (qemu_put_mouse_event_current == entry)
527
            qemu_put_mouse_event_current = cursor->next;
528
        qemu_free(entry->qemu_put_mouse_event_name);
529
        qemu_free(entry);
530
        return;
531
    }
532

    
533
    prev->next = entry->next;
534

    
535
    if (qemu_put_mouse_event_current == entry)
536
        qemu_put_mouse_event_current = prev;
537

    
538
    qemu_free(entry->qemu_put_mouse_event_name);
539
    qemu_free(entry);
540
}
541

    
542
void kbd_put_keycode(int keycode)
543
{
544
    if (qemu_put_kbd_event) {
545
        qemu_put_kbd_event(qemu_put_kbd_event_opaque, keycode);
546
    }
547
}
548

    
549
void kbd_mouse_event(int dx, int dy, int dz, int buttons_state)
550
{
551
    QEMUPutMouseEvent *mouse_event;
552
    void *mouse_event_opaque;
553
    int width;
554

    
555
    if (!qemu_put_mouse_event_current) {
556
        return;
557
    }
558

    
559
    mouse_event =
560
        qemu_put_mouse_event_current->qemu_put_mouse_event;
561
    mouse_event_opaque =
562
        qemu_put_mouse_event_current->qemu_put_mouse_event_opaque;
563

    
564
    if (mouse_event) {
565
        if (graphic_rotate) {
566
            if (qemu_put_mouse_event_current->qemu_put_mouse_event_absolute)
567
                width = 0x7fff;
568
            else
569
                width = graphic_width;
570
            mouse_event(mouse_event_opaque,
571
                                 width - dy, dx, dz, buttons_state);
572
        } else
573
            mouse_event(mouse_event_opaque,
574
                                 dx, dy, dz, buttons_state);
575
    }
576
}
577

    
578
int kbd_mouse_is_absolute(void)
579
{
580
    if (!qemu_put_mouse_event_current)
581
        return 0;
582

    
583
    return qemu_put_mouse_event_current->qemu_put_mouse_event_absolute;
584
}
585

    
586
void do_info_mice(void)
587
{
588
    QEMUPutMouseEntry *cursor;
589
    int index = 0;
590

    
591
    if (!qemu_put_mouse_event_head) {
592
        term_printf("No mouse devices connected\n");
593
        return;
594
    }
595

    
596
    term_printf("Mouse devices available:\n");
597
    cursor = qemu_put_mouse_event_head;
598
    while (cursor != NULL) {
599
        term_printf("%c Mouse #%d: %s\n",
600
                    (cursor == qemu_put_mouse_event_current ? '*' : ' '),
601
                    index, cursor->qemu_put_mouse_event_name);
602
        index++;
603
        cursor = cursor->next;
604
    }
605
}
606

    
607
void do_mouse_set(int index)
608
{
609
    QEMUPutMouseEntry *cursor;
610
    int i = 0;
611

    
612
    if (!qemu_put_mouse_event_head) {
613
        term_printf("No mouse devices connected\n");
614
        return;
615
    }
616

    
617
    cursor = qemu_put_mouse_event_head;
618
    while (cursor != NULL && index != i) {
619
        i++;
620
        cursor = cursor->next;
621
    }
622

    
623
    if (cursor != NULL)
624
        qemu_put_mouse_event_current = cursor;
625
    else
626
        term_printf("Mouse at given index not found\n");
627
}
628

    
629
/* compute with 96 bit intermediate result: (a*b)/c */
630
uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
631
{
632
    union {
633
        uint64_t ll;
634
        struct {
635
#ifdef WORDS_BIGENDIAN
636
            uint32_t high, low;
637
#else
638
            uint32_t low, high;
639
#endif
640
        } l;
641
    } u, res;
642
    uint64_t rl, rh;
643

    
644
    u.ll = a;
645
    rl = (uint64_t)u.l.low * (uint64_t)b;
646
    rh = (uint64_t)u.l.high * (uint64_t)b;
647
    rh += (rl >> 32);
648
    res.l.high = rh / c;
649
    res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
650
    return res.ll;
651
}
652

    
653
/***********************************************************/
654
/* real time host monotonic timer */
655

    
656
#define QEMU_TIMER_BASE 1000000000LL
657

    
658
#ifdef WIN32
659

    
660
static int64_t clock_freq;
661

    
662
static void init_get_clock(void)
663
{
664
    LARGE_INTEGER freq;
665
    int ret;
666
    ret = QueryPerformanceFrequency(&freq);
667
    if (ret == 0) {
668
        fprintf(stderr, "Could not calibrate ticks\n");
669
        exit(1);
670
    }
671
    clock_freq = freq.QuadPart;
672
}
673

    
674
static int64_t get_clock(void)
675
{
676
    LARGE_INTEGER ti;
677
    QueryPerformanceCounter(&ti);
678
    return muldiv64(ti.QuadPart, QEMU_TIMER_BASE, clock_freq);
679
}
680

    
681
#else
682

    
683
static int use_rt_clock;
684

    
685
static void init_get_clock(void)
686
{
687
    use_rt_clock = 0;
688
#if defined(__linux__)
689
    {
690
        struct timespec ts;
691
        if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
692
            use_rt_clock = 1;
693
        }
694
    }
695
#endif
696
}
697

    
698
static int64_t get_clock(void)
699
{
700
#if defined(__linux__)
701
    if (use_rt_clock) {
702
        struct timespec ts;
703
        clock_gettime(CLOCK_MONOTONIC, &ts);
704
        return ts.tv_sec * 1000000000LL + ts.tv_nsec;
705
    } else
706
#endif
707
    {
708
        /* XXX: using gettimeofday leads to problems if the date
709
           changes, so it should be avoided. */
710
        struct timeval tv;
711
        gettimeofday(&tv, NULL);
712
        return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
713
    }
714
}
715

    
716
#endif
717

    
718
/***********************************************************/
719
/* guest cycle counter */
720

    
721
static int64_t cpu_ticks_prev;
722
static int64_t cpu_ticks_offset;
723
static int64_t cpu_clock_offset;
724
static int cpu_ticks_enabled;
725

    
726
/* return the host CPU cycle counter and handle stop/restart */
727
int64_t cpu_get_ticks(void)
728
{
729
    if (!cpu_ticks_enabled) {
730
        return cpu_ticks_offset;
731
    } else {
732
        int64_t ticks;
733
        ticks = cpu_get_real_ticks();
734
        if (cpu_ticks_prev > ticks) {
735
            /* Note: non increasing ticks may happen if the host uses
736
               software suspend */
737
            cpu_ticks_offset += cpu_ticks_prev - ticks;
738
        }
739
        cpu_ticks_prev = ticks;
740
        return ticks + cpu_ticks_offset;
741
    }
742
}
743

    
744
/* return the host CPU monotonic timer and handle stop/restart */
745
static int64_t cpu_get_clock(void)
746
{
747
    int64_t ti;
748
    if (!cpu_ticks_enabled) {
749
        return cpu_clock_offset;
750
    } else {
751
        ti = get_clock();
752
        return ti + cpu_clock_offset;
753
    }
754
}
755

    
756
/* enable cpu_get_ticks() */
757
void cpu_enable_ticks(void)
758
{
759
    if (!cpu_ticks_enabled) {
760
        cpu_ticks_offset -= cpu_get_real_ticks();
761
        cpu_clock_offset -= get_clock();
762
        cpu_ticks_enabled = 1;
763
    }
764
}
765

    
766
/* disable cpu_get_ticks() : the clock is stopped. You must not call
767
   cpu_get_ticks() after that.  */
768
void cpu_disable_ticks(void)
769
{
770
    if (cpu_ticks_enabled) {
771
        cpu_ticks_offset = cpu_get_ticks();
772
        cpu_clock_offset = cpu_get_clock();
773
        cpu_ticks_enabled = 0;
774
    }
775
}
776

    
777
/***********************************************************/
778
/* timers */
779

    
780
#define QEMU_TIMER_REALTIME 0
781
#define QEMU_TIMER_VIRTUAL  1
782

    
783
struct QEMUClock {
784
    int type;
785
    /* XXX: add frequency */
786
};
787

    
788
struct QEMUTimer {
789
    QEMUClock *clock;
790
    int64_t expire_time;
791
    QEMUTimerCB *cb;
792
    void *opaque;
793
    struct QEMUTimer *next;
794
};
795

    
796
struct qemu_alarm_timer {
797
    char const *name;
798
    unsigned int flags;
799

    
800
    int (*start)(struct qemu_alarm_timer *t);
801
    void (*stop)(struct qemu_alarm_timer *t);
802
    void (*rearm)(struct qemu_alarm_timer *t);
803
    void *priv;
804
};
805

    
806
#define ALARM_FLAG_DYNTICKS  0x1
807

    
808
static inline int alarm_has_dynticks(struct qemu_alarm_timer *t)
809
{
810
    return t->flags & ALARM_FLAG_DYNTICKS;
811
}
812

    
813
static void qemu_rearm_alarm_timer(struct qemu_alarm_timer *t)
814
{
815
    if (!alarm_has_dynticks(t))
816
        return;
817

    
818
    t->rearm(t);
819
}
820

    
821
/* TODO: MIN_TIMER_REARM_US should be optimized */
822
#define MIN_TIMER_REARM_US 250
823

    
824
static struct qemu_alarm_timer *alarm_timer;
825

    
826
#ifdef _WIN32
827

    
828
struct qemu_alarm_win32 {
829
    MMRESULT timerId;
830
    HANDLE host_alarm;
831
    unsigned int period;
832
} alarm_win32_data = {0, NULL, -1};
833

    
834
static int win32_start_timer(struct qemu_alarm_timer *t);
835
static void win32_stop_timer(struct qemu_alarm_timer *t);
836
static void win32_rearm_timer(struct qemu_alarm_timer *t);
837

    
838
#else
839

    
840
static int unix_start_timer(struct qemu_alarm_timer *t);
841
static void unix_stop_timer(struct qemu_alarm_timer *t);
842

    
843
#ifdef __linux__
844

    
845
static int dynticks_start_timer(struct qemu_alarm_timer *t);
846
static void dynticks_stop_timer(struct qemu_alarm_timer *t);
847
static void dynticks_rearm_timer(struct qemu_alarm_timer *t);
848

    
849
static int hpet_start_timer(struct qemu_alarm_timer *t);
850
static void hpet_stop_timer(struct qemu_alarm_timer *t);
851

    
852
static int rtc_start_timer(struct qemu_alarm_timer *t);
853
static void rtc_stop_timer(struct qemu_alarm_timer *t);
854

    
855
#endif /* __linux__ */
856

    
857
#endif /* _WIN32 */
858

    
859
static struct qemu_alarm_timer alarm_timers[] = {
860
#ifndef _WIN32
861
#ifdef __linux__
862
    {"dynticks", ALARM_FLAG_DYNTICKS, dynticks_start_timer,
863
     dynticks_stop_timer, dynticks_rearm_timer, NULL},
864
    /* HPET - if available - is preferred */
865
    {"hpet", 0, hpet_start_timer, hpet_stop_timer, NULL, NULL},
866
    /* ...otherwise try RTC */
867
    {"rtc", 0, rtc_start_timer, rtc_stop_timer, NULL, NULL},
868
#endif
869
    {"unix", 0, unix_start_timer, unix_stop_timer, NULL, NULL},
870
#else
871
    {"dynticks", ALARM_FLAG_DYNTICKS, win32_start_timer,
872
     win32_stop_timer, win32_rearm_timer, &alarm_win32_data},
873
    {"win32", 0, win32_start_timer,
874
     win32_stop_timer, NULL, &alarm_win32_data},
875
#endif
876
    {NULL, }
877
};
878

    
879
static void show_available_alarms()
880
{
881
    int i;
882

    
883
    printf("Available alarm timers, in order of precedence:\n");
884
    for (i = 0; alarm_timers[i].name; i++)
885
        printf("%s\n", alarm_timers[i].name);
886
}
887

    
888
static void configure_alarms(char const *opt)
889
{
890
    int i;
891
    int cur = 0;
892
    int count = (sizeof(alarm_timers) / sizeof(*alarm_timers)) - 1;
893
    char *arg;
894
    char *name;
895

    
896
    if (!strcmp(opt, "help")) {
897
        show_available_alarms();
898
        exit(0);
899
    }
900

    
901
    arg = strdup(opt);
902

    
903
    /* Reorder the array */
904
    name = strtok(arg, ",");
905
    while (name) {
906
        struct qemu_alarm_timer tmp;
907

    
908
        for (i = 0; i < count && alarm_timers[i].name; i++) {
909
            if (!strcmp(alarm_timers[i].name, name))
910
                break;
911
        }
912

    
913
        if (i == count) {
914
            fprintf(stderr, "Unknown clock %s\n", name);
915
            goto next;
916
        }
917

    
918
        if (i < cur)
919
            /* Ignore */
920
            goto next;
921

    
922
        /* Swap */
923
        tmp = alarm_timers[i];
924
        alarm_timers[i] = alarm_timers[cur];
925
        alarm_timers[cur] = tmp;
926

    
927
        cur++;
928
next:
929
        name = strtok(NULL, ",");
930
    }
931

    
932
    free(arg);
933

    
934
    if (cur) {
935
        /* Disable remaining timers */
936
        for (i = cur; i < count; i++)
937
            alarm_timers[i].name = NULL;
938
    }
939

    
940
    /* debug */
941
    show_available_alarms();
942
}
943

    
944
QEMUClock *rt_clock;
945
QEMUClock *vm_clock;
946

    
947
static QEMUTimer *active_timers[2];
948

    
949
QEMUClock *qemu_new_clock(int type)
950
{
951
    QEMUClock *clock;
952
    clock = qemu_mallocz(sizeof(QEMUClock));
953
    if (!clock)
954
        return NULL;
955
    clock->type = type;
956
    return clock;
957
}
958

    
959
QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque)
960
{
961
    QEMUTimer *ts;
962

    
963
    ts = qemu_mallocz(sizeof(QEMUTimer));
964
    ts->clock = clock;
965
    ts->cb = cb;
966
    ts->opaque = opaque;
967
    return ts;
968
}
969

    
970
void qemu_free_timer(QEMUTimer *ts)
971
{
972
    qemu_free(ts);
973
}
974

    
975
/* stop a timer, but do not dealloc it */
976
void qemu_del_timer(QEMUTimer *ts)
977
{
978
    QEMUTimer **pt, *t;
979

    
980
    /* NOTE: this code must be signal safe because
981
       qemu_timer_expired() can be called from a signal. */
982
    pt = &active_timers[ts->clock->type];
983
    for(;;) {
984
        t = *pt;
985
        if (!t)
986
            break;
987
        if (t == ts) {
988
            *pt = t->next;
989
            break;
990
        }
991
        pt = &t->next;
992
    }
993
}
994

    
995
/* modify the current timer so that it will be fired when current_time
996
   >= expire_time. The corresponding callback will be called. */
997
void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
998
{
999
    QEMUTimer **pt, *t;
1000

    
1001
    qemu_del_timer(ts);
1002

    
1003
    /* add the timer in the sorted list */
1004
    /* NOTE: this code must be signal safe because
1005
       qemu_timer_expired() can be called from a signal. */
1006
    pt = &active_timers[ts->clock->type];
1007
    for(;;) {
1008
        t = *pt;
1009
        if (!t)
1010
            break;
1011
        if (t->expire_time > expire_time)
1012
            break;
1013
        pt = &t->next;
1014
    }
1015
    ts->expire_time = expire_time;
1016
    ts->next = *pt;
1017
    *pt = ts;
1018
}
1019

    
1020
int qemu_timer_pending(QEMUTimer *ts)
1021
{
1022
    QEMUTimer *t;
1023
    for(t = active_timers[ts->clock->type]; t != NULL; t = t->next) {
1024
        if (t == ts)
1025
            return 1;
1026
    }
1027
    return 0;
1028
}
1029

    
1030
static inline int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
1031
{
1032
    if (!timer_head)
1033
        return 0;
1034
    return (timer_head->expire_time <= current_time);
1035
}
1036

    
1037
static void qemu_run_timers(QEMUTimer **ptimer_head, int64_t current_time)
1038
{
1039
    QEMUTimer *ts;
1040

    
1041
    for(;;) {
1042
        ts = *ptimer_head;
1043
        if (!ts || ts->expire_time > current_time)
1044
            break;
1045
        /* remove timer from the list before calling the callback */
1046
        *ptimer_head = ts->next;
1047
        ts->next = NULL;
1048

    
1049
        /* run the callback (the timer list can be modified) */
1050
        ts->cb(ts->opaque);
1051
    }
1052
    qemu_rearm_alarm_timer(alarm_timer);
1053
}
1054

    
1055
int64_t qemu_get_clock(QEMUClock *clock)
1056
{
1057
    switch(clock->type) {
1058
    case QEMU_TIMER_REALTIME:
1059
        return get_clock() / 1000000;
1060
    default:
1061
    case QEMU_TIMER_VIRTUAL:
1062
        return cpu_get_clock();
1063
    }
1064
}
1065

    
1066
static void init_timers(void)
1067
{
1068
    init_get_clock();
1069
    ticks_per_sec = QEMU_TIMER_BASE;
1070
    rt_clock = qemu_new_clock(QEMU_TIMER_REALTIME);
1071
    vm_clock = qemu_new_clock(QEMU_TIMER_VIRTUAL);
1072
}
1073

    
1074
/* save a timer */
1075
void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
1076
{
1077
    uint64_t expire_time;
1078

    
1079
    if (qemu_timer_pending(ts)) {
1080
        expire_time = ts->expire_time;
1081
    } else {
1082
        expire_time = -1;
1083
    }
1084
    qemu_put_be64(f, expire_time);
1085
}
1086

    
1087
void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
1088
{
1089
    uint64_t expire_time;
1090

    
1091
    expire_time = qemu_get_be64(f);
1092
    if (expire_time != -1) {
1093
        qemu_mod_timer(ts, expire_time);
1094
    } else {
1095
        qemu_del_timer(ts);
1096
    }
1097
}
1098

    
1099
static void timer_save(QEMUFile *f, void *opaque)
1100
{
1101
    if (cpu_ticks_enabled) {
1102
        hw_error("cannot save state if virtual timers are running");
1103
    }
1104
    qemu_put_be64s(f, &cpu_ticks_offset);
1105
    qemu_put_be64s(f, &ticks_per_sec);
1106
    qemu_put_be64s(f, &cpu_clock_offset);
1107
}
1108

    
1109
static int timer_load(QEMUFile *f, void *opaque, int version_id)
1110
{
1111
    if (version_id != 1 && version_id != 2)
1112
        return -EINVAL;
1113
    if (cpu_ticks_enabled) {
1114
        return -EINVAL;
1115
    }
1116
    qemu_get_be64s(f, &cpu_ticks_offset);
1117
    qemu_get_be64s(f, &ticks_per_sec);
1118
    if (version_id == 2) {
1119
        qemu_get_be64s(f, &cpu_clock_offset);
1120
    }
1121
    return 0;
1122
}
1123

    
1124
#ifdef _WIN32
1125
void CALLBACK host_alarm_handler(UINT uTimerID, UINT uMsg,
1126
                                 DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2)
1127
#else
1128
static void host_alarm_handler(int host_signum)
1129
#endif
1130
{
1131
#if 0
1132
#define DISP_FREQ 1000
1133
    {
1134
        static int64_t delta_min = INT64_MAX;
1135
        static int64_t delta_max, delta_cum, last_clock, delta, ti;
1136
        static int count;
1137
        ti = qemu_get_clock(vm_clock);
1138
        if (last_clock != 0) {
1139
            delta = ti - last_clock;
1140
            if (delta < delta_min)
1141
                delta_min = delta;
1142
            if (delta > delta_max)
1143
                delta_max = delta;
1144
            delta_cum += delta;
1145
            if (++count == DISP_FREQ) {
1146
                printf("timer: min=%" PRId64 " us max=%" PRId64 " us avg=%" PRId64 " us avg_freq=%0.3f Hz\n",
1147
                       muldiv64(delta_min, 1000000, ticks_per_sec),
1148
                       muldiv64(delta_max, 1000000, ticks_per_sec),
1149
                       muldiv64(delta_cum, 1000000 / DISP_FREQ, ticks_per_sec),
1150
                       (double)ticks_per_sec / ((double)delta_cum / DISP_FREQ));
1151
                count = 0;
1152
                delta_min = INT64_MAX;
1153
                delta_max = 0;
1154
                delta_cum = 0;
1155
            }
1156
        }
1157
        last_clock = ti;
1158
    }
1159
#endif
1160
    if (alarm_has_dynticks(alarm_timer) ||
1161
        qemu_timer_expired(active_timers[QEMU_TIMER_VIRTUAL],
1162
                           qemu_get_clock(vm_clock)) ||
1163
        qemu_timer_expired(active_timers[QEMU_TIMER_REALTIME],
1164
                           qemu_get_clock(rt_clock))) {
1165
#ifdef _WIN32
1166
        struct qemu_alarm_win32 *data = ((struct qemu_alarm_timer*)dwUser)->priv;
1167
        SetEvent(data->host_alarm);
1168
#endif
1169
        CPUState *env = cpu_single_env;
1170
        if (env) {
1171
            /* stop the currently executing cpu because a timer occured */
1172
            cpu_interrupt(env, CPU_INTERRUPT_EXIT);
1173
#ifdef USE_KQEMU
1174
            if (env->kqemu_enabled) {
1175
                kqemu_cpu_interrupt(env);
1176
            }
1177
#endif
1178
        }
1179
    }
1180
}
1181

    
1182
static uint64_t qemu_next_deadline(void)
1183
{
1184
    int64_t nearest_delta_us = INT64_MAX;
1185
    int64_t vmdelta_us;
1186

    
1187
    if (active_timers[QEMU_TIMER_REALTIME])
1188
        nearest_delta_us = (active_timers[QEMU_TIMER_REALTIME]->expire_time -
1189
                            qemu_get_clock(rt_clock))*1000;
1190

    
1191
    if (active_timers[QEMU_TIMER_VIRTUAL]) {
1192
        /* round up */
1193
        vmdelta_us = (active_timers[QEMU_TIMER_VIRTUAL]->expire_time -
1194
                      qemu_get_clock(vm_clock)+999)/1000;
1195
        if (vmdelta_us < nearest_delta_us)
1196
            nearest_delta_us = vmdelta_us;
1197
    }
1198

    
1199
    /* Avoid arming the timer to negative, zero, or too low values */
1200
    if (nearest_delta_us <= MIN_TIMER_REARM_US)
1201
        nearest_delta_us = MIN_TIMER_REARM_US;
1202

    
1203
    return nearest_delta_us;
1204
}
1205

    
1206
#ifndef _WIN32
1207

    
1208
#if defined(__linux__)
1209

    
1210
#define RTC_FREQ 1024
1211

    
1212
static void enable_sigio_timer(int fd)
1213
{
1214
    struct sigaction act;
1215

    
1216
    /* timer signal */
1217
    sigfillset(&act.sa_mask);
1218
    act.sa_flags = 0;
1219
#if defined (TARGET_I386) && defined(USE_CODE_COPY)
1220
    act.sa_flags |= SA_ONSTACK;
1221
#endif
1222
    act.sa_handler = host_alarm_handler;
1223

    
1224
    sigaction(SIGIO, &act, NULL);
1225
    fcntl(fd, F_SETFL, O_ASYNC);
1226
    fcntl(fd, F_SETOWN, getpid());
1227
}
1228

    
1229
static int hpet_start_timer(struct qemu_alarm_timer *t)
1230
{
1231
    struct hpet_info info;
1232
    int r, fd;
1233

    
1234
    fd = open("/dev/hpet", O_RDONLY);
1235
    if (fd < 0)
1236
        return -1;
1237

    
1238
    /* Set frequency */
1239
    r = ioctl(fd, HPET_IRQFREQ, RTC_FREQ);
1240
    if (r < 0) {
1241
        fprintf(stderr, "Could not configure '/dev/hpet' to have a 1024Hz timer. This is not a fatal\n"
1242
                "error, but for better emulation accuracy type:\n"
1243
                "'echo 1024 > /proc/sys/dev/hpet/max-user-freq' as root.\n");
1244
        goto fail;
1245
    }
1246

    
1247
    /* Check capabilities */
1248
    r = ioctl(fd, HPET_INFO, &info);
1249
    if (r < 0)
1250
        goto fail;
1251

    
1252
    /* Enable periodic mode */
1253
    r = ioctl(fd, HPET_EPI, 0);
1254
    if (info.hi_flags && (r < 0))
1255
        goto fail;
1256

    
1257
    /* Enable interrupt */
1258
    r = ioctl(fd, HPET_IE_ON, 0);
1259
    if (r < 0)
1260
        goto fail;
1261

    
1262
    enable_sigio_timer(fd);
1263
    t->priv = (void *)(long)fd;
1264

    
1265
    return 0;
1266
fail:
1267
    close(fd);
1268
    return -1;
1269
}
1270

    
1271
static void hpet_stop_timer(struct qemu_alarm_timer *t)
1272
{
1273
    int fd = (long)t->priv;
1274

    
1275
    close(fd);
1276
}
1277

    
1278
static int rtc_start_timer(struct qemu_alarm_timer *t)
1279
{
1280
    int rtc_fd;
1281

    
1282
    TFR(rtc_fd = open("/dev/rtc", O_RDONLY));
1283
    if (rtc_fd < 0)
1284
        return -1;
1285
    if (ioctl(rtc_fd, RTC_IRQP_SET, RTC_FREQ) < 0) {
1286
        fprintf(stderr, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
1287
                "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
1288
                "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
1289
        goto fail;
1290
    }
1291
    if (ioctl(rtc_fd, RTC_PIE_ON, 0) < 0) {
1292
    fail:
1293
        close(rtc_fd);
1294
        return -1;
1295
    }
1296

    
1297
    enable_sigio_timer(rtc_fd);
1298

    
1299
    t->priv = (void *)(long)rtc_fd;
1300

    
1301
    return 0;
1302
}
1303

    
1304
static void rtc_stop_timer(struct qemu_alarm_timer *t)
1305
{
1306
    int rtc_fd = (long)t->priv;
1307

    
1308
    close(rtc_fd);
1309
}
1310

    
1311
static int dynticks_start_timer(struct qemu_alarm_timer *t)
1312
{
1313
    struct sigevent ev;
1314
    timer_t host_timer;
1315
    struct sigaction act;
1316

    
1317
    sigfillset(&act.sa_mask);
1318
    act.sa_flags = 0;
1319
#if defined(TARGET_I386) && defined(USE_CODE_COPY)
1320
    act.sa_flags |= SA_ONSTACK;
1321
#endif
1322
    act.sa_handler = host_alarm_handler;
1323

    
1324
    sigaction(SIGALRM, &act, NULL);
1325

    
1326
    ev.sigev_value.sival_int = 0;
1327
    ev.sigev_notify = SIGEV_SIGNAL;
1328
    ev.sigev_signo = SIGALRM;
1329

    
1330
    if (timer_create(CLOCK_REALTIME, &ev, &host_timer)) {
1331
        perror("timer_create");
1332

    
1333
        /* disable dynticks */
1334
        fprintf(stderr, "Dynamic Ticks disabled\n");
1335

    
1336
        return -1;
1337
    }
1338

    
1339
    t->priv = (void *)host_timer;
1340

    
1341
    return 0;
1342
}
1343

    
1344
static void dynticks_stop_timer(struct qemu_alarm_timer *t)
1345
{
1346
    timer_t host_timer = (timer_t)t->priv;
1347

    
1348
    timer_delete(host_timer);
1349
}
1350

    
1351
static void dynticks_rearm_timer(struct qemu_alarm_timer *t)
1352
{
1353
    timer_t host_timer = (timer_t)t->priv;
1354
    struct itimerspec timeout;
1355
    int64_t nearest_delta_us = INT64_MAX;
1356
    int64_t current_us;
1357

    
1358
    if (!active_timers[QEMU_TIMER_REALTIME] &&
1359
                !active_timers[QEMU_TIMER_VIRTUAL])
1360
            return;
1361

    
1362
    nearest_delta_us = qemu_next_deadline();
1363

    
1364
    /* check whether a timer is already running */
1365
    if (timer_gettime(host_timer, &timeout)) {
1366
        perror("gettime");
1367
        fprintf(stderr, "Internal timer error: aborting\n");
1368
        exit(1);
1369
    }
1370
    current_us = timeout.it_value.tv_sec * 1000000 + timeout.it_value.tv_nsec/1000;
1371
    if (current_us && current_us <= nearest_delta_us)
1372
        return;
1373

    
1374
    timeout.it_interval.tv_sec = 0;
1375
    timeout.it_interval.tv_nsec = 0; /* 0 for one-shot timer */
1376
    timeout.it_value.tv_sec =  nearest_delta_us / 1000000;
1377
    timeout.it_value.tv_nsec = (nearest_delta_us % 1000000) * 1000;
1378
    if (timer_settime(host_timer, 0 /* RELATIVE */, &timeout, NULL)) {
1379
        perror("settime");
1380
        fprintf(stderr, "Internal timer error: aborting\n");
1381
        exit(1);
1382
    }
1383
}
1384

    
1385
#endif /* defined(__linux__) */
1386

    
1387
static int unix_start_timer(struct qemu_alarm_timer *t)
1388
{
1389
    struct sigaction act;
1390
    struct itimerval itv;
1391
    int err;
1392

    
1393
    /* timer signal */
1394
    sigfillset(&act.sa_mask);
1395
    act.sa_flags = 0;
1396
#if defined(TARGET_I386) && defined(USE_CODE_COPY)
1397
    act.sa_flags |= SA_ONSTACK;
1398
#endif
1399
    act.sa_handler = host_alarm_handler;
1400

    
1401
    sigaction(SIGALRM, &act, NULL);
1402

    
1403
    itv.it_interval.tv_sec = 0;
1404
    /* for i386 kernel 2.6 to get 1 ms */
1405
    itv.it_interval.tv_usec = 999;
1406
    itv.it_value.tv_sec = 0;
1407
    itv.it_value.tv_usec = 10 * 1000;
1408

    
1409
    err = setitimer(ITIMER_REAL, &itv, NULL);
1410
    if (err)
1411
        return -1;
1412

    
1413
    return 0;
1414
}
1415

    
1416
static void unix_stop_timer(struct qemu_alarm_timer *t)
1417
{
1418
    struct itimerval itv;
1419

    
1420
    memset(&itv, 0, sizeof(itv));
1421
    setitimer(ITIMER_REAL, &itv, NULL);
1422
}
1423

    
1424
#endif /* !defined(_WIN32) */
1425

    
1426
#ifdef _WIN32
1427

    
1428
static int win32_start_timer(struct qemu_alarm_timer *t)
1429
{
1430
    TIMECAPS tc;
1431
    struct qemu_alarm_win32 *data = t->priv;
1432
    UINT flags;
1433

    
1434
    data->host_alarm = CreateEvent(NULL, FALSE, FALSE, NULL);
1435
    if (!data->host_alarm) {
1436
        perror("Failed CreateEvent");
1437
        return -1;
1438
    }
1439

    
1440
    memset(&tc, 0, sizeof(tc));
1441
    timeGetDevCaps(&tc, sizeof(tc));
1442

    
1443
    if (data->period < tc.wPeriodMin)
1444
        data->period = tc.wPeriodMin;
1445

    
1446
    timeBeginPeriod(data->period);
1447

    
1448
    flags = TIME_CALLBACK_FUNCTION;
1449
    if (alarm_has_dynticks(t))
1450
        flags |= TIME_ONESHOT;
1451
    else
1452
        flags |= TIME_PERIODIC;
1453

    
1454
    data->timerId = timeSetEvent(1,         // interval (ms)
1455
                        data->period,       // resolution
1456
                        host_alarm_handler, // function
1457
                        (DWORD)t,           // parameter
1458
                        flags);
1459

    
1460
    if (!data->timerId) {
1461
        perror("Failed to initialize win32 alarm timer");
1462

    
1463
        timeEndPeriod(data->period);
1464
        CloseHandle(data->host_alarm);
1465
        return -1;
1466
    }
1467

    
1468
    qemu_add_wait_object(data->host_alarm, NULL, NULL);
1469

    
1470
    return 0;
1471
}
1472

    
1473
static void win32_stop_timer(struct qemu_alarm_timer *t)
1474
{
1475
    struct qemu_alarm_win32 *data = t->priv;
1476

    
1477
    timeKillEvent(data->timerId);
1478
    timeEndPeriod(data->period);
1479

    
1480
    CloseHandle(data->host_alarm);
1481
}
1482

    
1483
static void win32_rearm_timer(struct qemu_alarm_timer *t)
1484
{
1485
    struct qemu_alarm_win32 *data = t->priv;
1486
    uint64_t nearest_delta_us;
1487

    
1488
    if (!active_timers[QEMU_TIMER_REALTIME] &&
1489
                !active_timers[QEMU_TIMER_VIRTUAL])
1490
            return;
1491

    
1492
    nearest_delta_us = qemu_next_deadline();
1493
    nearest_delta_us /= 1000;
1494

    
1495
    timeKillEvent(data->timerId);
1496

    
1497
    data->timerId = timeSetEvent(1,
1498
                        data->period,
1499
                        host_alarm_handler,
1500
                        (DWORD)t,
1501
                        TIME_ONESHOT | TIME_PERIODIC);
1502

    
1503
    if (!data->timerId) {
1504
        perror("Failed to re-arm win32 alarm timer");
1505

    
1506
        timeEndPeriod(data->period);
1507
        CloseHandle(data->host_alarm);
1508
        exit(1);
1509
    }
1510
}
1511

    
1512
#endif /* _WIN32 */
1513

    
1514
static void init_timer_alarm(void)
1515
{
1516
    struct qemu_alarm_timer *t;
1517
    int i, err = -1;
1518

    
1519
    for (i = 0; alarm_timers[i].name; i++) {
1520
        t = &alarm_timers[i];
1521

    
1522
        err = t->start(t);
1523
        if (!err)
1524
            break;
1525
    }
1526

    
1527
    if (err) {
1528
        fprintf(stderr, "Unable to find any suitable alarm timer.\n");
1529
        fprintf(stderr, "Terminating\n");
1530
        exit(1);
1531
    }
1532

    
1533
    alarm_timer = t;
1534
}
1535

    
1536
void quit_timers(void)
1537
{
1538
    alarm_timer->stop(alarm_timer);
1539
    alarm_timer = NULL;
1540
}
1541

    
1542
/***********************************************************/
1543
/* character device */
1544

    
1545
static void qemu_chr_event(CharDriverState *s, int event)
1546
{
1547
    if (!s->chr_event)
1548
        return;
1549
    s->chr_event(s->handler_opaque, event);
1550
}
1551

    
1552
static void qemu_chr_reset_bh(void *opaque)
1553
{
1554
    CharDriverState *s = opaque;
1555
    qemu_chr_event(s, CHR_EVENT_RESET);
1556
    qemu_bh_delete(s->bh);
1557
    s->bh = NULL;
1558
}
1559

    
1560
void qemu_chr_reset(CharDriverState *s)
1561
{
1562
    if (s->bh == NULL) {
1563
        s->bh = qemu_bh_new(qemu_chr_reset_bh, s);
1564
        qemu_bh_schedule(s->bh);
1565
    }
1566
}
1567

    
1568
int qemu_chr_write(CharDriverState *s, const uint8_t *buf, int len)
1569
{
1570
    return s->chr_write(s, buf, len);
1571
}
1572

    
1573
int qemu_chr_ioctl(CharDriverState *s, int cmd, void *arg)
1574
{
1575
    if (!s->chr_ioctl)
1576
        return -ENOTSUP;
1577
    return s->chr_ioctl(s, cmd, arg);
1578
}
1579

    
1580
int qemu_chr_can_read(CharDriverState *s)
1581
{
1582
    if (!s->chr_can_read)
1583
        return 0;
1584
    return s->chr_can_read(s->handler_opaque);
1585
}
1586

    
1587
void qemu_chr_read(CharDriverState *s, uint8_t *buf, int len)
1588
{
1589
    s->chr_read(s->handler_opaque, buf, len);
1590
}
1591

    
1592

    
1593
void qemu_chr_printf(CharDriverState *s, const char *fmt, ...)
1594
{
1595
    char buf[4096];
1596
    va_list ap;
1597
    va_start(ap, fmt);
1598
    vsnprintf(buf, sizeof(buf), fmt, ap);
1599
    qemu_chr_write(s, buf, strlen(buf));
1600
    va_end(ap);
1601
}
1602

    
1603
void qemu_chr_send_event(CharDriverState *s, int event)
1604
{
1605
    if (s->chr_send_event)
1606
        s->chr_send_event(s, event);
1607
}
1608

    
1609
void qemu_chr_add_handlers(CharDriverState *s,
1610
                           IOCanRWHandler *fd_can_read,
1611
                           IOReadHandler *fd_read,
1612
                           IOEventHandler *fd_event,
1613
                           void *opaque)
1614
{
1615
    s->chr_can_read = fd_can_read;
1616
    s->chr_read = fd_read;
1617
    s->chr_event = fd_event;
1618
    s->handler_opaque = opaque;
1619
    if (s->chr_update_read_handler)
1620
        s->chr_update_read_handler(s);
1621
}
1622

    
1623
static int null_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1624
{
1625
    return len;
1626
}
1627

    
1628
static CharDriverState *qemu_chr_open_null(void)
1629
{
1630
    CharDriverState *chr;
1631

    
1632
    chr = qemu_mallocz(sizeof(CharDriverState));
1633
    if (!chr)
1634
        return NULL;
1635
    chr->chr_write = null_chr_write;
1636
    return chr;
1637
}
1638

    
1639
/* MUX driver for serial I/O splitting */
1640
static int term_timestamps;
1641
static int64_t term_timestamps_start;
1642
#define MAX_MUX 4
1643
typedef struct {
1644
    IOCanRWHandler *chr_can_read[MAX_MUX];
1645
    IOReadHandler *chr_read[MAX_MUX];
1646
    IOEventHandler *chr_event[MAX_MUX];
1647
    void *ext_opaque[MAX_MUX];
1648
    CharDriverState *drv;
1649
    int mux_cnt;
1650
    int term_got_escape;
1651
    int max_size;
1652
} MuxDriver;
1653

    
1654

    
1655
static int mux_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1656
{
1657
    MuxDriver *d = chr->opaque;
1658
    int ret;
1659
    if (!term_timestamps) {
1660
        ret = d->drv->chr_write(d->drv, buf, len);
1661
    } else {
1662
        int i;
1663

    
1664
        ret = 0;
1665
        for(i = 0; i < len; i++) {
1666
            ret += d->drv->chr_write(d->drv, buf+i, 1);
1667
            if (buf[i] == '\n') {
1668
                char buf1[64];
1669
                int64_t ti;
1670
                int secs;
1671

    
1672
                ti = get_clock();
1673
                if (term_timestamps_start == -1)
1674
                    term_timestamps_start = ti;
1675
                ti -= term_timestamps_start;
1676
                secs = ti / 1000000000;
1677
                snprintf(buf1, sizeof(buf1),
1678
                         "[%02d:%02d:%02d.%03d] ",
1679
                         secs / 3600,
1680
                         (secs / 60) % 60,
1681
                         secs % 60,
1682
                         (int)((ti / 1000000) % 1000));
1683
                d->drv->chr_write(d->drv, buf1, strlen(buf1));
1684
            }
1685
        }
1686
    }
1687
    return ret;
1688
}
1689

    
1690
static char *mux_help[] = {
1691
    "% h    print this help\n\r",
1692
    "% x    exit emulator\n\r",
1693
    "% s    save disk data back to file (if -snapshot)\n\r",
1694
    "% t    toggle console timestamps\n\r"
1695
    "% b    send break (magic sysrq)\n\r",
1696
    "% c    switch between console and monitor\n\r",
1697
    "% %  sends %\n\r",
1698
    NULL
1699
};
1700

    
1701
static int term_escape_char = 0x01; /* ctrl-a is used for escape */
1702
static void mux_print_help(CharDriverState *chr)
1703
{
1704
    int i, j;
1705
    char ebuf[15] = "Escape-Char";
1706
    char cbuf[50] = "\n\r";
1707

    
1708
    if (term_escape_char > 0 && term_escape_char < 26) {
1709
        sprintf(cbuf,"\n\r");
1710
        sprintf(ebuf,"C-%c", term_escape_char - 1 + 'a');
1711
    } else {
1712
        sprintf(cbuf,"\n\rEscape-Char set to Ascii: 0x%02x\n\r\n\r", term_escape_char);
1713
    }
1714
    chr->chr_write(chr, cbuf, strlen(cbuf));
1715
    for (i = 0; mux_help[i] != NULL; i++) {
1716
        for (j=0; mux_help[i][j] != '\0'; j++) {
1717
            if (mux_help[i][j] == '%')
1718
                chr->chr_write(chr, ebuf, strlen(ebuf));
1719
            else
1720
                chr->chr_write(chr, &mux_help[i][j], 1);
1721
        }
1722
    }
1723
}
1724

    
1725
static int mux_proc_byte(CharDriverState *chr, MuxDriver *d, int ch)
1726
{
1727
    if (d->term_got_escape) {
1728
        d->term_got_escape = 0;
1729
        if (ch == term_escape_char)
1730
            goto send_char;
1731
        switch(ch) {
1732
        case '?':
1733
        case 'h':
1734
            mux_print_help(chr);
1735
            break;
1736
        case 'x':
1737
            {
1738
                 char *term =  "QEMU: Terminated\n\r";
1739
                 chr->chr_write(chr,term,strlen(term));
1740
                 exit(0);
1741
                 break;
1742
            }
1743
        case 's':
1744
            {
1745
                int i;
1746
                for (i = 0; i < MAX_DISKS; i++) {
1747
                    if (bs_table[i])
1748
                        bdrv_commit(bs_table[i]);
1749
                }
1750
                if (mtd_bdrv)
1751
                    bdrv_commit(mtd_bdrv);
1752
            }
1753
            break;
1754
        case 'b':
1755
            qemu_chr_event(chr, CHR_EVENT_BREAK);
1756
            break;
1757
        case 'c':
1758
            /* Switch to the next registered device */
1759
            chr->focus++;
1760
            if (chr->focus >= d->mux_cnt)
1761
                chr->focus = 0;
1762
            break;
1763
       case 't':
1764
           term_timestamps = !term_timestamps;
1765
           term_timestamps_start = -1;
1766
           break;
1767
        }
1768
    } else if (ch == term_escape_char) {
1769
        d->term_got_escape = 1;
1770
    } else {
1771
    send_char:
1772
        return 1;
1773
    }
1774
    return 0;
1775
}
1776

    
1777
static int mux_chr_can_read(void *opaque)
1778
{
1779
    CharDriverState *chr = opaque;
1780
    MuxDriver *d = chr->opaque;
1781
    if (d->chr_can_read[chr->focus])
1782
       return d->chr_can_read[chr->focus](d->ext_opaque[chr->focus]);
1783
    return 0;
1784
}
1785

    
1786
static void mux_chr_read(void *opaque, const uint8_t *buf, int size)
1787
{
1788
    CharDriverState *chr = opaque;
1789
    MuxDriver *d = chr->opaque;
1790
    int i;
1791
    for(i = 0; i < size; i++)
1792
        if (mux_proc_byte(chr, d, buf[i]))
1793
            d->chr_read[chr->focus](d->ext_opaque[chr->focus], &buf[i], 1);
1794
}
1795

    
1796
static void mux_chr_event(void *opaque, int event)
1797
{
1798
    CharDriverState *chr = opaque;
1799
    MuxDriver *d = chr->opaque;
1800
    int i;
1801

    
1802
    /* Send the event to all registered listeners */
1803
    for (i = 0; i < d->mux_cnt; i++)
1804
        if (d->chr_event[i])
1805
            d->chr_event[i](d->ext_opaque[i], event);
1806
}
1807

    
1808
static void mux_chr_update_read_handler(CharDriverState *chr)
1809
{
1810
    MuxDriver *d = chr->opaque;
1811

    
1812
    if (d->mux_cnt >= MAX_MUX) {
1813
        fprintf(stderr, "Cannot add I/O handlers, MUX array is full\n");
1814
        return;
1815
    }
1816
    d->ext_opaque[d->mux_cnt] = chr->handler_opaque;
1817
    d->chr_can_read[d->mux_cnt] = chr->chr_can_read;
1818
    d->chr_read[d->mux_cnt] = chr->chr_read;
1819
    d->chr_event[d->mux_cnt] = chr->chr_event;
1820
    /* Fix up the real driver with mux routines */
1821
    if (d->mux_cnt == 0) {
1822
        qemu_chr_add_handlers(d->drv, mux_chr_can_read, mux_chr_read,
1823
                              mux_chr_event, chr);
1824
    }
1825
    chr->focus = d->mux_cnt;
1826
    d->mux_cnt++;
1827
}
1828

    
1829
CharDriverState *qemu_chr_open_mux(CharDriverState *drv)
1830
{
1831
    CharDriverState *chr;
1832
    MuxDriver *d;
1833

    
1834
    chr = qemu_mallocz(sizeof(CharDriverState));
1835
    if (!chr)
1836
        return NULL;
1837
    d = qemu_mallocz(sizeof(MuxDriver));
1838
    if (!d) {
1839
        free(chr);
1840
        return NULL;
1841
    }
1842

    
1843
    chr->opaque = d;
1844
    d->drv = drv;
1845
    chr->focus = -1;
1846
    chr->chr_write = mux_chr_write;
1847
    chr->chr_update_read_handler = mux_chr_update_read_handler;
1848
    return chr;
1849
}
1850

    
1851

    
1852
#ifdef _WIN32
1853

    
1854
static void socket_cleanup(void)
1855
{
1856
    WSACleanup();
1857
}
1858

    
1859
static int socket_init(void)
1860
{
1861
    WSADATA Data;
1862
    int ret, err;
1863

    
1864
    ret = WSAStartup(MAKEWORD(2,2), &Data);
1865
    if (ret != 0) {
1866
        err = WSAGetLastError();
1867
        fprintf(stderr, "WSAStartup: %d\n", err);
1868
        return -1;
1869
    }
1870
    atexit(socket_cleanup);
1871
    return 0;
1872
}
1873

    
1874
static int send_all(int fd, const uint8_t *buf, int len1)
1875
{
1876
    int ret, len;
1877

    
1878
    len = len1;
1879
    while (len > 0) {
1880
        ret = send(fd, buf, len, 0);
1881
        if (ret < 0) {
1882
            int errno;
1883
            errno = WSAGetLastError();
1884
            if (errno != WSAEWOULDBLOCK) {
1885
                return -1;
1886
            }
1887
        } else if (ret == 0) {
1888
            break;
1889
        } else {
1890
            buf += ret;
1891
            len -= ret;
1892
        }
1893
    }
1894
    return len1 - len;
1895
}
1896

    
1897
void socket_set_nonblock(int fd)
1898
{
1899
    unsigned long opt = 1;
1900
    ioctlsocket(fd, FIONBIO, &opt);
1901
}
1902

    
1903
#else
1904

    
1905
static int unix_write(int fd, const uint8_t *buf, int len1)
1906
{
1907
    int ret, len;
1908

    
1909
    len = len1;
1910
    while (len > 0) {
1911
        ret = write(fd, buf, len);
1912
        if (ret < 0) {
1913
            if (errno != EINTR && errno != EAGAIN)
1914
                return -1;
1915
        } else if (ret == 0) {
1916
            break;
1917
        } else {
1918
            buf += ret;
1919
            len -= ret;
1920
        }
1921
    }
1922
    return len1 - len;
1923
}
1924

    
1925
static inline int send_all(int fd, const uint8_t *buf, int len1)
1926
{
1927
    return unix_write(fd, buf, len1);
1928
}
1929

    
1930
void socket_set_nonblock(int fd)
1931
{
1932
    fcntl(fd, F_SETFL, O_NONBLOCK);
1933
}
1934
#endif /* !_WIN32 */
1935

    
1936
#ifndef _WIN32
1937

    
1938
typedef struct {
1939
    int fd_in, fd_out;
1940
    int max_size;
1941
} FDCharDriver;
1942

    
1943
#define STDIO_MAX_CLIENTS 1
1944
static int stdio_nb_clients = 0;
1945

    
1946
static int fd_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1947
{
1948
    FDCharDriver *s = chr->opaque;
1949
    return unix_write(s->fd_out, buf, len);
1950
}
1951

    
1952
static int fd_chr_read_poll(void *opaque)
1953
{
1954
    CharDriverState *chr = opaque;
1955
    FDCharDriver *s = chr->opaque;
1956

    
1957
    s->max_size = qemu_chr_can_read(chr);
1958
    return s->max_size;
1959
}
1960

    
1961
static void fd_chr_read(void *opaque)
1962
{
1963
    CharDriverState *chr = opaque;
1964
    FDCharDriver *s = chr->opaque;
1965
    int size, len;
1966
    uint8_t buf[1024];
1967

    
1968
    len = sizeof(buf);
1969
    if (len > s->max_size)
1970
        len = s->max_size;
1971
    if (len == 0)
1972
        return;
1973
    size = read(s->fd_in, buf, len);
1974
    if (size == 0) {
1975
        /* FD has been closed. Remove it from the active list.  */
1976
        qemu_set_fd_handler2(s->fd_in, NULL, NULL, NULL, NULL);
1977
        return;
1978
    }
1979
    if (size > 0) {
1980
        qemu_chr_read(chr, buf, size);
1981
    }
1982
}
1983

    
1984
static void fd_chr_update_read_handler(CharDriverState *chr)
1985
{
1986
    FDCharDriver *s = chr->opaque;
1987

    
1988
    if (s->fd_in >= 0) {
1989
        if (nographic && s->fd_in == 0) {
1990
        } else {
1991
            qemu_set_fd_handler2(s->fd_in, fd_chr_read_poll,
1992
                                 fd_chr_read, NULL, chr);
1993
        }
1994
    }
1995
}
1996

    
1997
/* open a character device to a unix fd */
1998
static CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out)
1999
{
2000
    CharDriverState *chr;
2001
    FDCharDriver *s;
2002

    
2003
    chr = qemu_mallocz(sizeof(CharDriverState));
2004
    if (!chr)
2005
        return NULL;
2006
    s = qemu_mallocz(sizeof(FDCharDriver));
2007
    if (!s) {
2008
        free(chr);
2009
        return NULL;
2010
    }
2011
    s->fd_in = fd_in;
2012
    s->fd_out = fd_out;
2013
    chr->opaque = s;
2014
    chr->chr_write = fd_chr_write;
2015
    chr->chr_update_read_handler = fd_chr_update_read_handler;
2016

    
2017
    qemu_chr_reset(chr);
2018

    
2019
    return chr;
2020
}
2021

    
2022
static CharDriverState *qemu_chr_open_file_out(const char *file_out)
2023
{
2024
    int fd_out;
2025

    
2026
    TFR(fd_out = open(file_out, O_WRONLY | O_TRUNC | O_CREAT | O_BINARY, 0666));
2027
    if (fd_out < 0)
2028
        return NULL;
2029
    return qemu_chr_open_fd(-1, fd_out);
2030
}
2031

    
2032
static CharDriverState *qemu_chr_open_pipe(const char *filename)
2033
{
2034
    int fd_in, fd_out;
2035
    char filename_in[256], filename_out[256];
2036

    
2037
    snprintf(filename_in, 256, "%s.in", filename);
2038
    snprintf(filename_out, 256, "%s.out", filename);
2039
    TFR(fd_in = open(filename_in, O_RDWR | O_BINARY));
2040
    TFR(fd_out = open(filename_out, O_RDWR | O_BINARY));
2041
    if (fd_in < 0 || fd_out < 0) {
2042
        if (fd_in >= 0)
2043
            close(fd_in);
2044
        if (fd_out >= 0)
2045
            close(fd_out);
2046
        TFR(fd_in = fd_out = open(filename, O_RDWR | O_BINARY));
2047
        if (fd_in < 0)
2048
            return NULL;
2049
    }
2050
    return qemu_chr_open_fd(fd_in, fd_out);
2051
}
2052

    
2053

    
2054
/* for STDIO, we handle the case where several clients use it
2055
   (nographic mode) */
2056

    
2057
#define TERM_FIFO_MAX_SIZE 1
2058

    
2059
static uint8_t term_fifo[TERM_FIFO_MAX_SIZE];
2060
static int term_fifo_size;
2061

    
2062
static int stdio_read_poll(void *opaque)
2063
{
2064
    CharDriverState *chr = opaque;
2065

    
2066
    /* try to flush the queue if needed */
2067
    if (term_fifo_size != 0 && qemu_chr_can_read(chr) > 0) {
2068
        qemu_chr_read(chr, term_fifo, 1);
2069
        term_fifo_size = 0;
2070
    }
2071
    /* see if we can absorb more chars */
2072
    if (term_fifo_size == 0)
2073
        return 1;
2074
    else
2075
        return 0;
2076
}
2077

    
2078
static void stdio_read(void *opaque)
2079
{
2080
    int size;
2081
    uint8_t buf[1];
2082
    CharDriverState *chr = opaque;
2083

    
2084
    size = read(0, buf, 1);
2085
    if (size == 0) {
2086
        /* stdin has been closed. Remove it from the active list.  */
2087
        qemu_set_fd_handler2(0, NULL, NULL, NULL, NULL);
2088
        return;
2089
    }
2090
    if (size > 0) {
2091
        if (qemu_chr_can_read(chr) > 0) {
2092
            qemu_chr_read(chr, buf, 1);
2093
        } else if (term_fifo_size == 0) {
2094
            term_fifo[term_fifo_size++] = buf[0];
2095
        }
2096
    }
2097
}
2098

    
2099
/* init terminal so that we can grab keys */
2100
static struct termios oldtty;
2101
static int old_fd0_flags;
2102

    
2103
static void term_exit(void)
2104
{
2105
    tcsetattr (0, TCSANOW, &oldtty);
2106
    fcntl(0, F_SETFL, old_fd0_flags);
2107
}
2108

    
2109
static void term_init(void)
2110
{
2111
    struct termios tty;
2112

    
2113
    tcgetattr (0, &tty);
2114
    oldtty = tty;
2115
    old_fd0_flags = fcntl(0, F_GETFL);
2116

    
2117
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
2118
                          |INLCR|IGNCR|ICRNL|IXON);
2119
    tty.c_oflag |= OPOST;
2120
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
2121
    /* if graphical mode, we allow Ctrl-C handling */
2122
    if (nographic)
2123
        tty.c_lflag &= ~ISIG;
2124
    tty.c_cflag &= ~(CSIZE|PARENB);
2125
    tty.c_cflag |= CS8;
2126
    tty.c_cc[VMIN] = 1;
2127
    tty.c_cc[VTIME] = 0;
2128

    
2129
    tcsetattr (0, TCSANOW, &tty);
2130

    
2131
    atexit(term_exit);
2132

    
2133
    fcntl(0, F_SETFL, O_NONBLOCK);
2134
}
2135

    
2136
static CharDriverState *qemu_chr_open_stdio(void)
2137
{
2138
    CharDriverState *chr;
2139

    
2140
    if (stdio_nb_clients >= STDIO_MAX_CLIENTS)
2141
        return NULL;
2142
    chr = qemu_chr_open_fd(0, 1);
2143
    qemu_set_fd_handler2(0, stdio_read_poll, stdio_read, NULL, chr);
2144
    stdio_nb_clients++;
2145
    term_init();
2146

    
2147
    return chr;
2148
}
2149

    
2150
#if defined(__linux__) || defined(__sun__)
2151
static CharDriverState *qemu_chr_open_pty(void)
2152
{
2153
    struct termios tty;
2154
    char slave_name[1024];
2155
    int master_fd, slave_fd;
2156

    
2157
#if defined(__linux__)
2158
    /* Not satisfying */
2159
    if (openpty(&master_fd, &slave_fd, slave_name, NULL, NULL) < 0) {
2160
        return NULL;
2161
    }
2162
#endif
2163

    
2164
    /* Disabling local echo and line-buffered output */
2165
    tcgetattr (master_fd, &tty);
2166
    tty.c_lflag &= ~(ECHO|ICANON|ISIG);
2167
    tty.c_cc[VMIN] = 1;
2168
    tty.c_cc[VTIME] = 0;
2169
    tcsetattr (master_fd, TCSAFLUSH, &tty);
2170

    
2171
    fprintf(stderr, "char device redirected to %s\n", slave_name);
2172
    return qemu_chr_open_fd(master_fd, master_fd);
2173
}
2174

    
2175
static void tty_serial_init(int fd, int speed,
2176
                            int parity, int data_bits, int stop_bits)
2177
{
2178
    struct termios tty;
2179
    speed_t spd;
2180

    
2181
#if 0
2182
    printf("tty_serial_init: speed=%d parity=%c data=%d stop=%d\n",
2183
           speed, parity, data_bits, stop_bits);
2184
#endif
2185
    tcgetattr (fd, &tty);
2186

    
2187
    switch(speed) {
2188
    case 50:
2189
        spd = B50;
2190
        break;
2191
    case 75:
2192
        spd = B75;
2193
        break;
2194
    case 300:
2195
        spd = B300;
2196
        break;
2197
    case 600:
2198
        spd = B600;
2199
        break;
2200
    case 1200:
2201
        spd = B1200;
2202
        break;
2203
    case 2400:
2204
        spd = B2400;
2205
        break;
2206
    case 4800:
2207
        spd = B4800;
2208
        break;
2209
    case 9600:
2210
        spd = B9600;
2211
        break;
2212
    case 19200:
2213
        spd = B19200;
2214
        break;
2215
    case 38400:
2216
        spd = B38400;
2217
        break;
2218
    case 57600:
2219
        spd = B57600;
2220
        break;
2221
    default:
2222
    case 115200:
2223
        spd = B115200;
2224
        break;
2225
    }
2226

    
2227
    cfsetispeed(&tty, spd);
2228
    cfsetospeed(&tty, spd);
2229

    
2230
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
2231
                          |INLCR|IGNCR|ICRNL|IXON);
2232
    tty.c_oflag |= OPOST;
2233
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN|ISIG);
2234
    tty.c_cflag &= ~(CSIZE|PARENB|PARODD|CRTSCTS|CSTOPB);
2235
    switch(data_bits) {
2236
    default:
2237
    case 8:
2238
        tty.c_cflag |= CS8;
2239
        break;
2240
    case 7:
2241
        tty.c_cflag |= CS7;
2242
        break;
2243
    case 6:
2244
        tty.c_cflag |= CS6;
2245
        break;
2246
    case 5:
2247
        tty.c_cflag |= CS5;
2248
        break;
2249
    }
2250
    switch(parity) {
2251
    default:
2252
    case 'N':
2253
        break;
2254
    case 'E':
2255
        tty.c_cflag |= PARENB;
2256
        break;
2257
    case 'O':
2258
        tty.c_cflag |= PARENB | PARODD;
2259
        break;
2260
    }
2261
    if (stop_bits == 2)
2262
        tty.c_cflag |= CSTOPB;
2263

    
2264
    tcsetattr (fd, TCSANOW, &tty);
2265
}
2266

    
2267
static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg)
2268
{
2269
    FDCharDriver *s = chr->opaque;
2270

    
2271
    switch(cmd) {
2272
    case CHR_IOCTL_SERIAL_SET_PARAMS:
2273
        {
2274
            QEMUSerialSetParams *ssp = arg;
2275
            tty_serial_init(s->fd_in, ssp->speed, ssp->parity,
2276
                            ssp->data_bits, ssp->stop_bits);
2277
        }
2278
        break;
2279
    case CHR_IOCTL_SERIAL_SET_BREAK:
2280
        {
2281
            int enable = *(int *)arg;
2282
            if (enable)
2283
                tcsendbreak(s->fd_in, 1);
2284
        }
2285
        break;
2286
    default:
2287
        return -ENOTSUP;
2288
    }
2289
    return 0;
2290
}
2291

    
2292
static CharDriverState *qemu_chr_open_tty(const char *filename)
2293
{
2294
    CharDriverState *chr;
2295
    int fd;
2296

    
2297
    TFR(fd = open(filename, O_RDWR | O_NONBLOCK));
2298
    fcntl(fd, F_SETFL, O_NONBLOCK);
2299
    tty_serial_init(fd, 115200, 'N', 8, 1);
2300
    chr = qemu_chr_open_fd(fd, fd);
2301
    if (!chr) {
2302
        close(fd);
2303
        return NULL;
2304
    }
2305
    chr->chr_ioctl = tty_serial_ioctl;
2306
    qemu_chr_reset(chr);
2307
    return chr;
2308
}
2309
#else  /* ! __linux__ && ! __sun__ */
2310
static CharDriverState *qemu_chr_open_pty(void)
2311
{
2312
    return NULL;
2313
}
2314
#endif /* __linux__ || __sun__ */
2315

    
2316
#if defined(__linux__)
2317
typedef struct {
2318
    int fd;
2319
    int mode;
2320
} ParallelCharDriver;
2321

    
2322
static int pp_hw_mode(ParallelCharDriver *s, uint16_t mode)
2323
{
2324
    if (s->mode != mode) {
2325
        int m = mode;
2326
        if (ioctl(s->fd, PPSETMODE, &m) < 0)
2327
            return 0;
2328
        s->mode = mode;
2329
    }
2330
    return 1;
2331
}
2332

    
2333
static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
2334
{
2335
    ParallelCharDriver *drv = chr->opaque;
2336
    int fd = drv->fd;
2337
    uint8_t b;
2338

    
2339
    switch(cmd) {
2340
    case CHR_IOCTL_PP_READ_DATA:
2341
        if (ioctl(fd, PPRDATA, &b) < 0)
2342
            return -ENOTSUP;
2343
        *(uint8_t *)arg = b;
2344
        break;
2345
    case CHR_IOCTL_PP_WRITE_DATA:
2346
        b = *(uint8_t *)arg;
2347
        if (ioctl(fd, PPWDATA, &b) < 0)
2348
            return -ENOTSUP;
2349
        break;
2350
    case CHR_IOCTL_PP_READ_CONTROL:
2351
        if (ioctl(fd, PPRCONTROL, &b) < 0)
2352
            return -ENOTSUP;
2353
        /* Linux gives only the lowest bits, and no way to know data
2354
           direction! For better compatibility set the fixed upper
2355
           bits. */
2356
        *(uint8_t *)arg = b | 0xc0;
2357
        break;
2358
    case CHR_IOCTL_PP_WRITE_CONTROL:
2359
        b = *(uint8_t *)arg;
2360
        if (ioctl(fd, PPWCONTROL, &b) < 0)
2361
            return -ENOTSUP;
2362
        break;
2363
    case CHR_IOCTL_PP_READ_STATUS:
2364
        if (ioctl(fd, PPRSTATUS, &b) < 0)
2365
            return -ENOTSUP;
2366
        *(uint8_t *)arg = b;
2367
        break;
2368
    case CHR_IOCTL_PP_EPP_READ_ADDR:
2369
        if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
2370
            struct ParallelIOArg *parg = arg;
2371
            int n = read(fd, parg->buffer, parg->count);
2372
            if (n != parg->count) {
2373
                return -EIO;
2374
            }
2375
        }
2376
        break;
2377
    case CHR_IOCTL_PP_EPP_READ:
2378
        if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
2379
            struct ParallelIOArg *parg = arg;
2380
            int n = read(fd, parg->buffer, parg->count);
2381
            if (n != parg->count) {
2382
                return -EIO;
2383
            }
2384
        }
2385
        break;
2386
    case CHR_IOCTL_PP_EPP_WRITE_ADDR:
2387
        if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
2388
            struct ParallelIOArg *parg = arg;
2389
            int n = write(fd, parg->buffer, parg->count);
2390
            if (n != parg->count) {
2391
                return -EIO;
2392
            }
2393
        }
2394
        break;
2395
    case CHR_IOCTL_PP_EPP_WRITE:
2396
        if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
2397
            struct ParallelIOArg *parg = arg;
2398
            int n = write(fd, parg->buffer, parg->count);
2399
            if (n != parg->count) {
2400
                return -EIO;
2401
            }
2402
        }
2403
        break;
2404
    default:
2405
        return -ENOTSUP;
2406
    }
2407
    return 0;
2408
}
2409

    
2410
static void pp_close(CharDriverState *chr)
2411
{
2412
    ParallelCharDriver *drv = chr->opaque;
2413
    int fd = drv->fd;
2414

    
2415
    pp_hw_mode(drv, IEEE1284_MODE_COMPAT);
2416
    ioctl(fd, PPRELEASE);
2417
    close(fd);
2418
    qemu_free(drv);
2419
}
2420

    
2421
static CharDriverState *qemu_chr_open_pp(const char *filename)
2422
{
2423
    CharDriverState *chr;
2424
    ParallelCharDriver *drv;
2425
    int fd;
2426

    
2427
    TFR(fd = open(filename, O_RDWR));
2428
    if (fd < 0)
2429
        return NULL;
2430

    
2431
    if (ioctl(fd, PPCLAIM) < 0) {
2432
        close(fd);
2433
        return NULL;
2434
    }
2435

    
2436
    drv = qemu_mallocz(sizeof(ParallelCharDriver));
2437
    if (!drv) {
2438
        close(fd);
2439
        return NULL;
2440
    }
2441
    drv->fd = fd;
2442
    drv->mode = IEEE1284_MODE_COMPAT;
2443

    
2444
    chr = qemu_mallocz(sizeof(CharDriverState));
2445
    if (!chr) {
2446
        qemu_free(drv);
2447
        close(fd);
2448
        return NULL;
2449
    }
2450
    chr->chr_write = null_chr_write;
2451
    chr->chr_ioctl = pp_ioctl;
2452
    chr->chr_close = pp_close;
2453
    chr->opaque = drv;
2454

    
2455
    qemu_chr_reset(chr);
2456

    
2457
    return chr;
2458
}
2459
#endif /* __linux__ */
2460

    
2461
#else /* _WIN32 */
2462

    
2463
typedef struct {
2464
    int max_size;
2465
    HANDLE hcom, hrecv, hsend;
2466
    OVERLAPPED orecv, osend;
2467
    BOOL fpipe;
2468
    DWORD len;
2469
} WinCharState;
2470

    
2471
#define NSENDBUF 2048
2472
#define NRECVBUF 2048
2473
#define MAXCONNECT 1
2474
#define NTIMEOUT 5000
2475

    
2476
static int win_chr_poll(void *opaque);
2477
static int win_chr_pipe_poll(void *opaque);
2478

    
2479
static void win_chr_close(CharDriverState *chr)
2480
{
2481
    WinCharState *s = chr->opaque;
2482

    
2483
    if (s->hsend) {
2484
        CloseHandle(s->hsend);
2485
        s->hsend = NULL;
2486
    }
2487
    if (s->hrecv) {
2488
        CloseHandle(s->hrecv);
2489
        s->hrecv = NULL;
2490
    }
2491
    if (s->hcom) {
2492
        CloseHandle(s->hcom);
2493
        s->hcom = NULL;
2494
    }
2495
    if (s->fpipe)
2496
        qemu_del_polling_cb(win_chr_pipe_poll, chr);
2497
    else
2498
        qemu_del_polling_cb(win_chr_poll, chr);
2499
}
2500

    
2501
static int win_chr_init(CharDriverState *chr, const char *filename)
2502
{
2503
    WinCharState *s = chr->opaque;
2504
    COMMCONFIG comcfg;
2505
    COMMTIMEOUTS cto = { 0, 0, 0, 0, 0};
2506
    COMSTAT comstat;
2507
    DWORD size;
2508
    DWORD err;
2509

    
2510
    s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
2511
    if (!s->hsend) {
2512
        fprintf(stderr, "Failed CreateEvent\n");
2513
        goto fail;
2514
    }
2515
    s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
2516
    if (!s->hrecv) {
2517
        fprintf(stderr, "Failed CreateEvent\n");
2518
        goto fail;
2519
    }
2520

    
2521
    s->hcom = CreateFile(filename, GENERIC_READ|GENERIC_WRITE, 0, NULL,
2522
                      OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
2523
    if (s->hcom == INVALID_HANDLE_VALUE) {
2524
        fprintf(stderr, "Failed CreateFile (%lu)\n", GetLastError());
2525
        s->hcom = NULL;
2526
        goto fail;
2527
    }
2528

    
2529
    if (!SetupComm(s->hcom, NRECVBUF, NSENDBUF)) {
2530
        fprintf(stderr, "Failed SetupComm\n");
2531
        goto fail;
2532
    }
2533

    
2534
    ZeroMemory(&comcfg, sizeof(COMMCONFIG));
2535
    size = sizeof(COMMCONFIG);
2536
    GetDefaultCommConfig(filename, &comcfg, &size);
2537
    comcfg.dcb.DCBlength = sizeof(DCB);
2538
    CommConfigDialog(filename, NULL, &comcfg);
2539

    
2540
    if (!SetCommState(s->hcom, &comcfg.dcb)) {
2541
        fprintf(stderr, "Failed SetCommState\n");
2542
        goto fail;
2543
    }
2544

    
2545
    if (!SetCommMask(s->hcom, EV_ERR)) {
2546
        fprintf(stderr, "Failed SetCommMask\n");
2547
        goto fail;
2548
    }
2549

    
2550
    cto.ReadIntervalTimeout = MAXDWORD;
2551
    if (!SetCommTimeouts(s->hcom, &cto)) {
2552
        fprintf(stderr, "Failed SetCommTimeouts\n");
2553
        goto fail;
2554
    }
2555

    
2556
    if (!ClearCommError(s->hcom, &err, &comstat)) {
2557
        fprintf(stderr, "Failed ClearCommError\n");
2558
        goto fail;
2559
    }
2560
    qemu_add_polling_cb(win_chr_poll, chr);
2561
    return 0;
2562

    
2563
 fail:
2564
    win_chr_close(chr);
2565
    return -1;
2566
}
2567

    
2568
static int win_chr_write(CharDriverState *chr, const uint8_t *buf, int len1)
2569
{
2570
    WinCharState *s = chr->opaque;
2571
    DWORD len, ret, size, err;
2572

    
2573
    len = len1;
2574
    ZeroMemory(&s->osend, sizeof(s->osend));
2575
    s->osend.hEvent = s->hsend;
2576
    while (len > 0) {
2577
        if (s->hsend)
2578
            ret = WriteFile(s->hcom, buf, len, &size, &s->osend);
2579
        else
2580
            ret = WriteFile(s->hcom, buf, len, &size, NULL);
2581
        if (!ret) {
2582
            err = GetLastError();
2583
            if (err == ERROR_IO_PENDING) {
2584
                ret = GetOverlappedResult(s->hcom, &s->osend, &size, TRUE);
2585
                if (ret) {
2586
                    buf += size;
2587
                    len -= size;
2588
                } else {
2589
                    break;
2590
                }
2591
            } else {
2592
                break;
2593
            }
2594
        } else {
2595
            buf += size;
2596
            len -= size;
2597
        }
2598
    }
2599
    return len1 - len;
2600
}
2601

    
2602
static int win_chr_read_poll(CharDriverState *chr)
2603
{
2604
    WinCharState *s = chr->opaque;
2605

    
2606
    s->max_size = qemu_chr_can_read(chr);
2607
    return s->max_size;
2608
}
2609

    
2610
static void win_chr_readfile(CharDriverState *chr)
2611
{
2612
    WinCharState *s = chr->opaque;
2613
    int ret, err;
2614
    uint8_t buf[1024];
2615
    DWORD size;
2616

    
2617
    ZeroMemory(&s->orecv, sizeof(s->orecv));
2618
    s->orecv.hEvent = s->hrecv;
2619
    ret = ReadFile(s->hcom, buf, s->len, &size, &s->orecv);
2620
    if (!ret) {
2621
        err = GetLastError();
2622
        if (err == ERROR_IO_PENDING) {
2623
            ret = GetOverlappedResult(s->hcom, &s->orecv, &size, TRUE);
2624
        }
2625
    }
2626

    
2627
    if (size > 0) {
2628
        qemu_chr_read(chr, buf, size);
2629
    }
2630
}
2631

    
2632
static void win_chr_read(CharDriverState *chr)
2633
{
2634
    WinCharState *s = chr->opaque;
2635

    
2636
    if (s->len > s->max_size)
2637
        s->len = s->max_size;
2638
    if (s->len == 0)
2639
        return;
2640

    
2641
    win_chr_readfile(chr);
2642
}
2643

    
2644
static int win_chr_poll(void *opaque)
2645
{
2646
    CharDriverState *chr = opaque;
2647
    WinCharState *s = chr->opaque;
2648
    COMSTAT status;
2649
    DWORD comerr;
2650

    
2651
    ClearCommError(s->hcom, &comerr, &status);
2652
    if (status.cbInQue > 0) {
2653
        s->len = status.cbInQue;
2654
        win_chr_read_poll(chr);
2655
        win_chr_read(chr);
2656
        return 1;
2657
    }
2658
    return 0;
2659
}
2660

    
2661
static CharDriverState *qemu_chr_open_win(const char *filename)
2662
{
2663
    CharDriverState *chr;
2664
    WinCharState *s;
2665

    
2666
    chr = qemu_mallocz(sizeof(CharDriverState));
2667
    if (!chr)
2668
        return NULL;
2669
    s = qemu_mallocz(sizeof(WinCharState));
2670
    if (!s) {
2671
        free(chr);
2672
        return NULL;
2673
    }
2674
    chr->opaque = s;
2675
    chr->chr_write = win_chr_write;
2676
    chr->chr_close = win_chr_close;
2677

    
2678
    if (win_chr_init(chr, filename) < 0) {
2679
        free(s);
2680
        free(chr);
2681
        return NULL;
2682
    }
2683
    qemu_chr_reset(chr);
2684
    return chr;
2685
}
2686

    
2687
static int win_chr_pipe_poll(void *opaque)
2688
{
2689
    CharDriverState *chr = opaque;
2690
    WinCharState *s = chr->opaque;
2691
    DWORD size;
2692

    
2693
    PeekNamedPipe(s->hcom, NULL, 0, NULL, &size, NULL);
2694
    if (size > 0) {
2695
        s->len = size;
2696
        win_chr_read_poll(chr);
2697
        win_chr_read(chr);
2698
        return 1;
2699
    }
2700
    return 0;
2701
}
2702

    
2703
static int win_chr_pipe_init(CharDriverState *chr, const char *filename)
2704
{
2705
    WinCharState *s = chr->opaque;
2706
    OVERLAPPED ov;
2707
    int ret;
2708
    DWORD size;
2709
    char openname[256];
2710

    
2711
    s->fpipe = TRUE;
2712

    
2713
    s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
2714
    if (!s->hsend) {
2715
        fprintf(stderr, "Failed CreateEvent\n");
2716
        goto fail;
2717
    }
2718
    s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
2719
    if (!s->hrecv) {
2720
        fprintf(stderr, "Failed CreateEvent\n");
2721
        goto fail;
2722
    }
2723

    
2724
    snprintf(openname, sizeof(openname), "\\\\.\\pipe\\%s", filename);
2725
    s->hcom = CreateNamedPipe(openname, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
2726
                              PIPE_TYPE_BYTE | PIPE_READMODE_BYTE |
2727
                              PIPE_WAIT,
2728
                              MAXCONNECT, NSENDBUF, NRECVBUF, NTIMEOUT, NULL);
2729
    if (s->hcom == INVALID_HANDLE_VALUE) {
2730
        fprintf(stderr, "Failed CreateNamedPipe (%lu)\n", GetLastError());
2731
        s->hcom = NULL;
2732
        goto fail;
2733
    }
2734

    
2735
    ZeroMemory(&ov, sizeof(ov));
2736
    ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
2737
    ret = ConnectNamedPipe(s->hcom, &ov);
2738
    if (ret) {
2739
        fprintf(stderr, "Failed ConnectNamedPipe\n");
2740
        goto fail;
2741
    }
2742

    
2743
    ret = GetOverlappedResult(s->hcom, &ov, &size, TRUE);
2744
    if (!ret) {
2745
        fprintf(stderr, "Failed GetOverlappedResult\n");
2746
        if (ov.hEvent) {
2747
            CloseHandle(ov.hEvent);
2748
            ov.hEvent = NULL;
2749
        }
2750
        goto fail;
2751
    }
2752

    
2753
    if (ov.hEvent) {
2754
        CloseHandle(ov.hEvent);
2755
        ov.hEvent = NULL;
2756
    }
2757
    qemu_add_polling_cb(win_chr_pipe_poll, chr);
2758
    return 0;
2759

    
2760
 fail:
2761
    win_chr_close(chr);
2762
    return -1;
2763
}
2764

    
2765

    
2766
static CharDriverState *qemu_chr_open_win_pipe(const char *filename)
2767
{
2768
    CharDriverState *chr;
2769
    WinCharState *s;
2770

    
2771
    chr = qemu_mallocz(sizeof(CharDriverState));
2772
    if (!chr)
2773
        return NULL;
2774
    s = qemu_mallocz(sizeof(WinCharState));
2775
    if (!s) {
2776
        free(chr);
2777
        return NULL;
2778
    }
2779
    chr->opaque = s;
2780
    chr->chr_write = win_chr_write;
2781
    chr->chr_close = win_chr_close;
2782

    
2783
    if (win_chr_pipe_init(chr, filename) < 0) {
2784
        free(s);
2785
        free(chr);
2786
        return NULL;
2787
    }
2788
    qemu_chr_reset(chr);
2789
    return chr;
2790
}
2791

    
2792
static CharDriverState *qemu_chr_open_win_file(HANDLE fd_out)
2793
{
2794
    CharDriverState *chr;
2795
    WinCharState *s;
2796

    
2797
    chr = qemu_mallocz(sizeof(CharDriverState));
2798
    if (!chr)
2799
        return NULL;
2800
    s = qemu_mallocz(sizeof(WinCharState));
2801
    if (!s) {
2802
        free(chr);
2803
        return NULL;
2804
    }
2805
    s->hcom = fd_out;
2806
    chr->opaque = s;
2807
    chr->chr_write = win_chr_write;
2808
    qemu_chr_reset(chr);
2809
    return chr;
2810
}
2811

    
2812
static CharDriverState *qemu_chr_open_win_con(const char *filename)
2813
{
2814
    return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE));
2815
}
2816

    
2817
static CharDriverState *qemu_chr_open_win_file_out(const char *file_out)
2818
{
2819
    HANDLE fd_out;
2820

    
2821
    fd_out = CreateFile(file_out, GENERIC_WRITE, FILE_SHARE_READ, NULL,
2822
                        OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
2823
    if (fd_out == INVALID_HANDLE_VALUE)
2824
        return NULL;
2825

    
2826
    return qemu_chr_open_win_file(fd_out);
2827
}
2828
#endif /* !_WIN32 */
2829

    
2830
/***********************************************************/
2831
/* UDP Net console */
2832

    
2833
typedef struct {
2834
    int fd;
2835
    struct sockaddr_in daddr;
2836
    char buf[1024];
2837
    int bufcnt;
2838
    int bufptr;
2839
    int max_size;
2840
} NetCharDriver;
2841

    
2842
static int udp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
2843
{
2844
    NetCharDriver *s = chr->opaque;
2845

    
2846
    return sendto(s->fd, buf, len, 0,
2847
                  (struct sockaddr *)&s->daddr, sizeof(struct sockaddr_in));
2848
}
2849

    
2850
static int udp_chr_read_poll(void *opaque)
2851
{
2852
    CharDriverState *chr = opaque;
2853
    NetCharDriver *s = chr->opaque;
2854

    
2855
    s->max_size = qemu_chr_can_read(chr);
2856

    
2857
    /* If there were any stray characters in the queue process them
2858
     * first
2859
     */
2860
    while (s->max_size > 0 && s->bufptr < s->bufcnt) {
2861
        qemu_chr_read(chr, &s->buf[s->bufptr], 1);
2862
        s->bufptr++;
2863
        s->max_size = qemu_chr_can_read(chr);
2864
    }
2865
    return s->max_size;
2866
}
2867

    
2868
static void udp_chr_read(void *opaque)
2869
{
2870
    CharDriverState *chr = opaque;
2871
    NetCharDriver *s = chr->opaque;
2872

    
2873
    if (s->max_size == 0)
2874
        return;
2875
    s->bufcnt = recv(s->fd, s->buf, sizeof(s->buf), 0);
2876
    s->bufptr = s->bufcnt;
2877
    if (s->bufcnt <= 0)
2878
        return;
2879

    
2880
    s->bufptr = 0;
2881
    while (s->max_size > 0 && s->bufptr < s->bufcnt) {
2882
        qemu_chr_read(chr, &s->buf[s->bufptr], 1);
2883
        s->bufptr++;
2884
        s->max_size = qemu_chr_can_read(chr);
2885
    }
2886
}
2887

    
2888
static void udp_chr_update_read_handler(CharDriverState *chr)
2889
{
2890
    NetCharDriver *s = chr->opaque;
2891

    
2892
    if (s->fd >= 0) {
2893
        qemu_set_fd_handler2(s->fd, udp_chr_read_poll,
2894
                             udp_chr_read, NULL, chr);
2895
    }
2896
}
2897

    
2898
int parse_host_port(struct sockaddr_in *saddr, const char *str);
2899
#ifndef _WIN32
2900
static int parse_unix_path(struct sockaddr_un *uaddr, const char *str);
2901
#endif
2902
int parse_host_src_port(struct sockaddr_in *haddr,
2903
                        struct sockaddr_in *saddr,
2904
                        const char *str);
2905

    
2906
static CharDriverState *qemu_chr_open_udp(const char *def)
2907
{
2908
    CharDriverState *chr = NULL;
2909
    NetCharDriver *s = NULL;
2910
    int fd = -1;
2911
    struct sockaddr_in saddr;
2912

    
2913
    chr = qemu_mallocz(sizeof(CharDriverState));
2914
    if (!chr)
2915
        goto return_err;
2916
    s = qemu_mallocz(sizeof(NetCharDriver));
2917
    if (!s)
2918
        goto return_err;
2919

    
2920
    fd = socket(PF_INET, SOCK_DGRAM, 0);
2921
    if (fd < 0) {
2922
        perror("socket(PF_INET, SOCK_DGRAM)");
2923
        goto return_err;
2924
    }
2925

    
2926
    if (parse_host_src_port(&s->daddr, &saddr, def) < 0) {
2927
        printf("Could not parse: %s\n", def);
2928
        goto return_err;
2929
    }
2930

    
2931
    if (bind(fd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
2932
    {
2933
        perror("bind");
2934
        goto return_err;
2935
    }
2936

    
2937
    s->fd = fd;
2938
    s->bufcnt = 0;
2939
    s->bufptr = 0;
2940
    chr->opaque = s;
2941
    chr->chr_write = udp_chr_write;
2942
    chr->chr_update_read_handler = udp_chr_update_read_handler;
2943
    return chr;
2944

    
2945
return_err:
2946
    if (chr)
2947
        free(chr);
2948
    if (s)
2949
        free(s);
2950
    if (fd >= 0)
2951
        closesocket(fd);
2952
    return NULL;
2953
}
2954

    
2955
/***********************************************************/
2956
/* TCP Net console */
2957

    
2958
typedef struct {
2959
    int fd, listen_fd;
2960
    int connected;
2961
    int max_size;
2962
    int do_telnetopt;
2963
    int do_nodelay;
2964
    int is_unix;
2965
} TCPCharDriver;
2966

    
2967
static void tcp_chr_accept(void *opaque);
2968

    
2969
static int tcp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
2970
{
2971
    TCPCharDriver *s = chr->opaque;
2972
    if (s->connected) {
2973
        return send_all(s->fd, buf, len);
2974
    } else {
2975
        /* XXX: indicate an error ? */
2976
        return len;
2977
    }
2978
}
2979

    
2980
static int tcp_chr_read_poll(void *opaque)
2981
{
2982
    CharDriverState *chr = opaque;
2983
    TCPCharDriver *s = chr->opaque;
2984
    if (!s->connected)
2985
        return 0;
2986
    s->max_size = qemu_chr_can_read(chr);
2987
    return s->max_size;
2988
}
2989

    
2990
#define IAC 255
2991
#define IAC_BREAK 243
2992
static void tcp_chr_process_IAC_bytes(CharDriverState *chr,
2993
                                      TCPCharDriver *s,
2994
                                      char *buf, int *size)
2995
{
2996
    /* Handle any telnet client's basic IAC options to satisfy char by
2997
     * char mode with no echo.  All IAC options will be removed from
2998
     * the buf and the do_telnetopt variable will be used to track the
2999
     * state of the width of the IAC information.
3000
     *
3001
     * IAC commands come in sets of 3 bytes with the exception of the
3002
     * "IAC BREAK" command and the double IAC.
3003
     */
3004

    
3005
    int i;
3006
    int j = 0;
3007

    
3008
    for (i = 0; i < *size; i++) {
3009
        if (s->do_telnetopt > 1) {
3010
            if ((unsigned char)buf[i] == IAC && s->do_telnetopt == 2) {
3011
                /* Double IAC means send an IAC */
3012
                if (j != i)
3013
                    buf[j] = buf[i];
3014
                j++;
3015
                s->do_telnetopt = 1;
3016
            } else {
3017
                if ((unsigned char)buf[i] == IAC_BREAK && s->do_telnetopt == 2) {
3018
                    /* Handle IAC break commands by sending a serial break */
3019
                    qemu_chr_event(chr, CHR_EVENT_BREAK);
3020
                    s->do_telnetopt++;
3021
                }
3022
                s->do_telnetopt++;
3023
            }
3024
            if (s->do_telnetopt >= 4) {
3025
                s->do_telnetopt = 1;
3026
            }
3027
        } else {
3028
            if ((unsigned char)buf[i] == IAC) {
3029
                s->do_telnetopt = 2;
3030
            } else {
3031
                if (j != i)
3032
                    buf[j] = buf[i];
3033
                j++;
3034
            }
3035
        }
3036
    }
3037
    *size = j;
3038
}
3039

    
3040
static void tcp_chr_read(void *opaque)
3041
{
3042
    CharDriverState *chr = opaque;
3043
    TCPCharDriver *s = chr->opaque;
3044
    uint8_t buf[1024];
3045
    int len, size;
3046

    
3047
    if (!s->connected || s->max_size <= 0)
3048
        return;
3049
    len = sizeof(buf);
3050
    if (len > s->max_size)
3051
        len = s->max_size;
3052
    size = recv(s->fd, buf, len, 0);
3053
    if (size == 0) {
3054
        /* connection closed */
3055
        s->connected = 0;
3056
        if (s->listen_fd >= 0) {
3057
            qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
3058
        }
3059
        qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
3060
        closesocket(s->fd);
3061
        s->fd = -1;
3062
    } else if (size > 0) {
3063
        if (s->do_telnetopt)
3064
            tcp_chr_process_IAC_bytes(chr, s, buf, &size);
3065
        if (size > 0)
3066
            qemu_chr_read(chr, buf, size);
3067
    }
3068
}
3069

    
3070
static void tcp_chr_connect(void *opaque)
3071
{
3072
    CharDriverState *chr = opaque;
3073
    TCPCharDriver *s = chr->opaque;
3074

    
3075
    s->connected = 1;
3076
    qemu_set_fd_handler2(s->fd, tcp_chr_read_poll,
3077
                         tcp_chr_read, NULL, chr);
3078
    qemu_chr_reset(chr);
3079
}
3080

    
3081
#define IACSET(x,a,b,c) x[0] = a; x[1] = b; x[2] = c;
3082
static void tcp_chr_telnet_init(int fd)
3083
{
3084
    char buf[3];
3085
    /* Send the telnet negotion to put telnet in binary, no echo, single char mode */
3086
    IACSET(buf, 0xff, 0xfb, 0x01);  /* IAC WILL ECHO */
3087
    send(fd, (char *)buf, 3, 0);
3088
    IACSET(buf, 0xff, 0xfb, 0x03);  /* IAC WILL Suppress go ahead */
3089
    send(fd, (char *)buf, 3, 0);
3090
    IACSET(buf, 0xff, 0xfb, 0x00);  /* IAC WILL Binary */
3091
    send(fd, (char *)buf, 3, 0);
3092
    IACSET(buf, 0xff, 0xfd, 0x00);  /* IAC DO Binary */
3093
    send(fd, (char *)buf, 3, 0);
3094
}
3095

    
3096
static void socket_set_nodelay(int fd)
3097
{
3098
    int val = 1;
3099
    setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val));
3100
}
3101

    
3102
static void tcp_chr_accept(void *opaque)
3103
{
3104
    CharDriverState *chr = opaque;
3105
    TCPCharDriver *s = chr->opaque;
3106
    struct sockaddr_in saddr;
3107
#ifndef _WIN32
3108
    struct sockaddr_un uaddr;
3109
#endif
3110
    struct sockaddr *addr;
3111
    socklen_t len;
3112
    int fd;
3113

    
3114
    for(;;) {
3115
#ifndef _WIN32
3116
        if (s->is_unix) {
3117
            len = sizeof(uaddr);
3118
            addr = (struct sockaddr *)&uaddr;
3119
        } else
3120
#endif
3121
        {
3122
            len = sizeof(saddr);
3123
            addr = (struct sockaddr *)&saddr;
3124
        }
3125
        fd = accept(s->listen_fd, addr, &len);
3126
        if (fd < 0 && errno != EINTR) {
3127
            return;
3128
        } else if (fd >= 0) {
3129
            if (s->do_telnetopt)
3130
                tcp_chr_telnet_init(fd);
3131
            break;
3132
        }
3133
    }
3134
    socket_set_nonblock(fd);
3135
    if (s->do_nodelay)
3136
        socket_set_nodelay(fd);
3137
    s->fd = fd;
3138
    qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);
3139
    tcp_chr_connect(chr);
3140
}
3141

    
3142
static void tcp_chr_close(CharDriverState *chr)
3143
{
3144
    TCPCharDriver *s = chr->opaque;
3145
    if (s->fd >= 0)
3146
        closesocket(s->fd);
3147
    if (s->listen_fd >= 0)
3148
        closesocket(s->listen_fd);
3149
    qemu_free(s);
3150
}
3151

    
3152
static CharDriverState *qemu_chr_open_tcp(const char *host_str,
3153
                                          int is_telnet,
3154
                                          int is_unix)
3155
{
3156
    CharDriverState *chr = NULL;
3157
    TCPCharDriver *s = NULL;
3158
    int fd = -1, ret, err, val;
3159
    int is_listen = 0;
3160
    int is_waitconnect = 1;
3161
    int do_nodelay = 0;
3162
    const char *ptr;
3163
    struct sockaddr_in saddr;
3164
#ifndef _WIN32
3165
    struct sockaddr_un uaddr;
3166
#endif
3167
    struct sockaddr *addr;
3168
    socklen_t addrlen;
3169

    
3170
#ifndef _WIN32
3171
    if (is_unix) {
3172
        addr = (struct sockaddr *)&uaddr;
3173
        addrlen = sizeof(uaddr);
3174
        if (parse_unix_path(&uaddr, host_str) < 0)
3175
            goto fail;
3176
    } else
3177
#endif
3178
    {
3179
        addr = (struct sockaddr *)&saddr;
3180
        addrlen = sizeof(saddr);
3181
        if (parse_host_port(&saddr, host_str) < 0)
3182
            goto fail;
3183
    }
3184

    
3185
    ptr = host_str;
3186
    while((ptr = strchr(ptr,','))) {
3187
        ptr++;
3188
        if (!strncmp(ptr,"server",6)) {
3189
            is_listen = 1;
3190
        } else if (!strncmp(ptr,"nowait",6)) {
3191
            is_waitconnect = 0;
3192
        } else if (!strncmp(ptr,"nodelay",6)) {
3193
            do_nodelay = 1;
3194
        } else {
3195
            printf("Unknown option: %s\n", ptr);
3196
            goto fail;
3197
        }
3198
    }
3199
    if (!is_listen)
3200
        is_waitconnect = 0;
3201

    
3202
    chr = qemu_mallocz(sizeof(CharDriverState));
3203
    if (!chr)
3204
        goto fail;
3205
    s = qemu_mallocz(sizeof(TCPCharDriver));
3206
    if (!s)
3207
        goto fail;
3208

    
3209
#ifndef _WIN32
3210
    if (is_unix)
3211
        fd = socket(PF_UNIX, SOCK_STREAM, 0);
3212
    else
3213
#endif
3214
        fd = socket(PF_INET, SOCK_STREAM, 0);
3215

    
3216
    if (fd < 0)
3217
        goto fail;
3218

    
3219
    if (!is_waitconnect)
3220
        socket_set_nonblock(fd);
3221

    
3222
    s->connected = 0;
3223
    s->fd = -1;
3224
    s->listen_fd = -1;
3225
    s->is_unix = is_unix;
3226
    s->do_nodelay = do_nodelay && !is_unix;
3227

    
3228
    chr->opaque = s;
3229
    chr->chr_write = tcp_chr_write;
3230
    chr->chr_close = tcp_chr_close;
3231

    
3232
    if (is_listen) {
3233
        /* allow fast reuse */
3234
#ifndef _WIN32
3235
        if (is_unix) {
3236
            char path[109];
3237
            strncpy(path, uaddr.sun_path, 108);
3238
            path[108] = 0;
3239
            unlink(path);
3240
        } else
3241
#endif
3242
        {
3243
            val = 1;
3244
            setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
3245
        }
3246

    
3247
        ret = bind(fd, addr, addrlen);
3248
        if (ret < 0)
3249
            goto fail;
3250

    
3251
        ret = listen(fd, 0);
3252
        if (ret < 0)
3253
            goto fail;
3254

    
3255
        s->listen_fd = fd;
3256
        qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
3257
        if (is_telnet)
3258
            s->do_telnetopt = 1;
3259
    } else {
3260
        for(;;) {
3261
            ret = connect(fd, addr, addrlen);
3262
            if (ret < 0) {
3263
                err = socket_error();
3264
                if (err == EINTR || err == EWOULDBLOCK) {
3265
                } else if (err == EINPROGRESS) {
3266
                    break;
3267
#ifdef _WIN32
3268
                } else if (err == WSAEALREADY) {
3269
                    break;
3270
#endif
3271
                } else {
3272
                    goto fail;
3273
                }
3274
            } else {
3275
                s->connected = 1;
3276
                break;
3277
            }
3278
        }
3279
        s->fd = fd;
3280
        socket_set_nodelay(fd);
3281
        if (s->connected)
3282
            tcp_chr_connect(chr);
3283
        else
3284
            qemu_set_fd_handler(s->fd, NULL, tcp_chr_connect, chr);
3285
    }
3286

    
3287
    if (is_listen && is_waitconnect) {
3288
        printf("QEMU waiting for connection on: %s\n", host_str);
3289
        tcp_chr_accept(chr);
3290
        socket_set_nonblock(s->listen_fd);
3291
    }
3292

    
3293
    return chr;
3294
 fail:
3295
    if (fd >= 0)
3296
        closesocket(fd);
3297
    qemu_free(s);
3298
    qemu_free(chr);
3299
    return NULL;
3300
}
3301

    
3302
CharDriverState *qemu_chr_open(const char *filename)
3303
{
3304
    const char *p;
3305

    
3306
    if (!strcmp(filename, "vc")) {
3307
        return text_console_init(&display_state, 0);
3308
    } else if (strstart(filename, "vc:", &p)) {
3309
        return text_console_init(&display_state, p);
3310
    } else if (!strcmp(filename, "null")) {
3311
        return qemu_chr_open_null();
3312
    } else
3313
    if (strstart(filename, "tcp:", &p)) {
3314
        return qemu_chr_open_tcp(p, 0, 0);
3315
    } else
3316
    if (strstart(filename, "telnet:", &p)) {
3317
        return qemu_chr_open_tcp(p, 1, 0);
3318
    } else
3319
    if (strstart(filename, "udp:", &p)) {
3320
        return qemu_chr_open_udp(p);
3321
    } else
3322
    if (strstart(filename, "mon:", &p)) {
3323
        CharDriverState *drv = qemu_chr_open(p);
3324
        if (drv) {
3325
            drv = qemu_chr_open_mux(drv);
3326
            monitor_init(drv, !nographic);
3327
            return drv;
3328
        }
3329
        printf("Unable to open driver: %s\n", p);
3330
        return 0;
3331
    } else
3332
#ifndef _WIN32
3333
    if (strstart(filename, "unix:", &p)) {
3334
        return qemu_chr_open_tcp(p, 0, 1);
3335
    } else if (strstart(filename, "file:", &p)) {
3336
        return qemu_chr_open_file_out(p);
3337
    } else if (strstart(filename, "pipe:", &p)) {
3338
        return qemu_chr_open_pipe(p);
3339
    } else if (!strcmp(filename, "pty")) {
3340
        return qemu_chr_open_pty();
3341
    } else if (!strcmp(filename, "stdio")) {
3342
        return qemu_chr_open_stdio();
3343
    } else
3344
#if defined(__linux__)
3345
    if (strstart(filename, "/dev/parport", NULL)) {
3346
        return qemu_chr_open_pp(filename);
3347
    } else
3348
#endif
3349
#if defined(__linux__) || defined(__sun__)
3350
    if (strstart(filename, "/dev/", NULL)) {
3351
        return qemu_chr_open_tty(filename);
3352
    } else
3353
#endif
3354
#else /* !_WIN32 */
3355
    if (strstart(filename, "COM", NULL)) {
3356
        return qemu_chr_open_win(filename);
3357
    } else
3358
    if (strstart(filename, "pipe:", &p)) {
3359
        return qemu_chr_open_win_pipe(p);
3360
    } else
3361
    if (strstart(filename, "con:", NULL)) {
3362
        return qemu_chr_open_win_con(filename);
3363
    } else
3364
    if (strstart(filename, "file:", &p)) {
3365
        return qemu_chr_open_win_file_out(p);
3366
    }
3367
#endif
3368
    {
3369
        return NULL;
3370
    }
3371
}
3372

    
3373
void qemu_chr_close(CharDriverState *chr)
3374
{
3375
    if (chr->chr_close)
3376
        chr->chr_close(chr);
3377
}
3378

    
3379
/***********************************************************/
3380
/* network device redirectors */
3381

    
3382
void hex_dump(FILE *f, const uint8_t *buf, int size)
3383
{
3384
    int len, i, j, c;
3385

    
3386
    for(i=0;i<size;i+=16) {
3387
        len = size - i;
3388
        if (len > 16)
3389
            len = 16;
3390
        fprintf(f, "%08x ", i);
3391
        for(j=0;j<16;j++) {
3392
            if (j < len)
3393
                fprintf(f, " %02x", buf[i+j]);
3394
            else
3395
                fprintf(f, "   ");
3396
        }
3397
        fprintf(f, " ");
3398
        for(j=0;j<len;j++) {
3399
            c = buf[i+j];
3400
            if (c < ' ' || c > '~')
3401
                c = '.';
3402
            fprintf(f, "%c", c);
3403
        }
3404
        fprintf(f, "\n");
3405
    }
3406
}
3407

    
3408
static int parse_macaddr(uint8_t *macaddr, const char *p)
3409
{
3410
    int i;
3411
    for(i = 0; i < 6; i++) {
3412
        macaddr[i] = strtol(p, (char **)&p, 16);
3413
        if (i == 5) {
3414
            if (*p != '\0')
3415
                return -1;
3416
        } else {
3417
            if (*p != ':')
3418
                return -1;
3419
            p++;
3420
        }
3421
    }
3422
    return 0;
3423
}
3424

    
3425
static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
3426
{
3427
    const char *p, *p1;
3428
    int len;
3429
    p = *pp;
3430
    p1 = strchr(p, sep);
3431
    if (!p1)
3432
        return -1;
3433
    len = p1 - p;
3434
    p1++;
3435
    if (buf_size > 0) {
3436
        if (len > buf_size - 1)
3437
            len = buf_size - 1;
3438
        memcpy(buf, p, len);
3439
        buf[len] = '\0';
3440
    }
3441
    *pp = p1;
3442
    return 0;
3443
}
3444

    
3445
int parse_host_src_port(struct sockaddr_in *haddr,
3446
                        struct sockaddr_in *saddr,
3447
                        const char *input_str)
3448
{
3449
    char *str = strdup(input_str);
3450
    char *host_str = str;
3451
    char *src_str;
3452
    char *ptr;
3453

    
3454
    /*
3455
     * Chop off any extra arguments at the end of the string which
3456
     * would start with a comma, then fill in the src port information
3457
     * if it was provided else use the "any address" and "any port".
3458
     */
3459
    if ((ptr = strchr(str,',')))
3460
        *ptr = '\0';
3461

    
3462
    if ((src_str = strchr(input_str,'@'))) {
3463
        *src_str = '\0';
3464
        src_str++;
3465
    }
3466

    
3467
    if (parse_host_port(haddr, host_str) < 0)
3468
        goto fail;
3469

    
3470
    if (!src_str || *src_str == '\0')
3471
        src_str = ":0";
3472

    
3473
    if (parse_host_port(saddr, src_str) < 0)
3474
        goto fail;
3475

    
3476
    free(str);
3477
    return(0);
3478

    
3479
fail:
3480
    free(str);
3481
    return -1;
3482
}
3483

    
3484
int parse_host_port(struct sockaddr_in *saddr, const char *str)
3485
{
3486
    char buf[512];
3487
    struct hostent *he;
3488
    const char *p, *r;
3489
    int port;
3490

    
3491
    p = str;
3492
    if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3493
        return -1;
3494
    saddr->sin_family = AF_INET;
3495
    if (buf[0] == '\0') {
3496
        saddr->sin_addr.s_addr = 0;
3497
    } else {
3498
        if (isdigit(buf[0])) {
3499
            if (!inet_aton(buf, &saddr->sin_addr))
3500
                return -1;
3501
        } else {
3502
            if ((he = gethostbyname(buf)) == NULL)
3503
                return - 1;
3504
            saddr->sin_addr = *(struct in_addr *)he->h_addr;
3505
        }
3506
    }
3507
    port = strtol(p, (char **)&r, 0);
3508
    if (r == p)
3509
        return -1;
3510
    saddr->sin_port = htons(port);
3511
    return 0;
3512
}
3513

    
3514
#ifndef _WIN32
3515
static int parse_unix_path(struct sockaddr_un *uaddr, const char *str)
3516
{
3517
    const char *p;
3518
    int len;
3519

    
3520
    len = MIN(108, strlen(str));
3521
    p = strchr(str, ',');
3522
    if (p)
3523
        len = MIN(len, p - str);
3524

    
3525
    memset(uaddr, 0, sizeof(*uaddr));
3526

    
3527
    uaddr->sun_family = AF_UNIX;
3528
    memcpy(uaddr->sun_path, str, len);
3529

    
3530
    return 0;
3531
}
3532
#endif
3533

    
3534
/* find or alloc a new VLAN */
3535
VLANState *qemu_find_vlan(int id)
3536
{
3537
    VLANState **pvlan, *vlan;
3538
    for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
3539
        if (vlan->id == id)
3540
            return vlan;
3541
    }
3542
    vlan = qemu_mallocz(sizeof(VLANState));
3543
    if (!vlan)
3544
        return NULL;
3545
    vlan->id = id;
3546
    vlan->next = NULL;
3547
    pvlan = &first_vlan;
3548
    while (*pvlan != NULL)
3549
        pvlan = &(*pvlan)->next;
3550
    *pvlan = vlan;
3551
    return vlan;
3552
}
3553

    
3554
VLANClientState *qemu_new_vlan_client(VLANState *vlan,
3555
                                      IOReadHandler *fd_read,
3556
                                      IOCanRWHandler *fd_can_read,
3557
                                      void *opaque)
3558
{
3559
    VLANClientState *vc, **pvc;
3560
    vc = qemu_mallocz(sizeof(VLANClientState));
3561
    if (!vc)
3562
        return NULL;
3563
    vc->fd_read = fd_read;
3564
    vc->fd_can_read = fd_can_read;
3565
    vc->opaque = opaque;
3566
    vc->vlan = vlan;
3567

    
3568
    vc->next = NULL;
3569
    pvc = &vlan->first_client;
3570
    while (*pvc != NULL)
3571
        pvc = &(*pvc)->next;
3572
    *pvc = vc;
3573
    return vc;
3574
}
3575

    
3576
int qemu_can_send_packet(VLANClientState *vc1)
3577
{
3578
    VLANState *vlan = vc1->vlan;
3579
    VLANClientState *vc;
3580

    
3581
    for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
3582
        if (vc != vc1) {
3583
            if (vc->fd_can_read && vc->fd_can_read(vc->opaque))
3584
                return 1;
3585
        }
3586
    }
3587
    return 0;
3588
}
3589

    
3590
void qemu_send_packet(VLANClientState *vc1, const uint8_t *buf, int size)
3591
{
3592
    VLANState *vlan = vc1->vlan;
3593
    VLANClientState *vc;
3594

    
3595
#if 0
3596
    printf("vlan %d send:\n", vlan->id);
3597
    hex_dump(stdout, buf, size);
3598
#endif
3599
    for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
3600
        if (vc != vc1) {
3601
            vc->fd_read(vc->opaque, buf, size);
3602
        }
3603
    }
3604
}
3605

    
3606
#if defined(CONFIG_SLIRP)
3607

    
3608
/* slirp network adapter */
3609

    
3610
static int slirp_inited;
3611
static VLANClientState *slirp_vc;
3612

    
3613
int slirp_can_output(void)
3614
{
3615
    return !slirp_vc || qemu_can_send_packet(slirp_vc);
3616
}
3617

    
3618
void slirp_output(const uint8_t *pkt, int pkt_len)
3619
{
3620
#if 0
3621
    printf("slirp output:\n");
3622
    hex_dump(stdout, pkt, pkt_len);
3623
#endif
3624
    if (!slirp_vc)
3625
        return;
3626
    qemu_send_packet(slirp_vc, pkt, pkt_len);
3627
}
3628

    
3629
static void slirp_receive(void *opaque, const uint8_t *buf, int size)
3630
{
3631
#if 0
3632
    printf("slirp input:\n");
3633
    hex_dump(stdout, buf, size);
3634
#endif
3635
    slirp_input(buf, size);
3636
}
3637

    
3638
static int net_slirp_init(VLANState *vlan)
3639
{
3640
    if (!slirp_inited) {
3641
        slirp_inited = 1;
3642
        slirp_init();
3643
    }
3644
    slirp_vc = qemu_new_vlan_client(vlan,
3645
                                    slirp_receive, NULL, NULL);
3646
    snprintf(slirp_vc->info_str, sizeof(slirp_vc->info_str), "user redirector");
3647
    return 0;
3648
}
3649

    
3650
static void net_slirp_redir(const char *redir_str)
3651
{
3652
    int is_udp;
3653
    char buf[256], *r;
3654
    const char *p;
3655
    struct in_addr guest_addr;
3656
    int host_port, guest_port;
3657

    
3658
    if (!slirp_inited) {
3659
        slirp_inited = 1;
3660
        slirp_init();
3661
    }
3662

    
3663
    p = redir_str;
3664
    if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3665
        goto fail;
3666
    if (!strcmp(buf, "tcp")) {
3667
        is_udp = 0;
3668
    } else if (!strcmp(buf, "udp")) {
3669
        is_udp = 1;
3670
    } else {
3671
        goto fail;
3672
    }
3673

    
3674
    if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3675
        goto fail;
3676
    host_port = strtol(buf, &r, 0);
3677
    if (r == buf)
3678
        goto fail;
3679

    
3680
    if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3681
        goto fail;
3682
    if (buf[0] == '\0') {
3683
        pstrcpy(buf, sizeof(buf), "10.0.2.15");
3684
    }
3685
    if (!inet_aton(buf, &guest_addr))
3686
        goto fail;
3687

    
3688
    guest_port = strtol(p, &r, 0);
3689
    if (r == p)
3690
        goto fail;
3691

    
3692
    if (slirp_redir(is_udp, host_port, guest_addr, guest_port) < 0) {
3693
        fprintf(stderr, "qemu: could not set up redirection\n");
3694
        exit(1);
3695
    }
3696
    return;
3697
 fail:
3698
    fprintf(stderr, "qemu: syntax: -redir [tcp|udp]:host-port:[guest-host]:guest-port\n");
3699
    exit(1);
3700
}
3701

    
3702
#ifndef _WIN32
3703

    
3704
char smb_dir[1024];
3705

    
3706
static void smb_exit(void)
3707
{
3708
    DIR *d;
3709
    struct dirent *de;
3710
    char filename[1024];
3711

    
3712
    /* erase all the files in the directory */
3713
    d = opendir(smb_dir);
3714
    for(;;) {
3715
        de = readdir(d);
3716
        if (!de)
3717
            break;
3718
        if (strcmp(de->d_name, ".") != 0 &&
3719
            strcmp(de->d_name, "..") != 0) {
3720
            snprintf(filename, sizeof(filename), "%s/%s",
3721
                     smb_dir, de->d_name);
3722
            unlink(filename);
3723
        }
3724
    }
3725
    closedir(d);
3726
    rmdir(smb_dir);
3727
}
3728

    
3729
/* automatic user mode samba server configuration */
3730
void net_slirp_smb(const char *exported_dir)
3731
{
3732
    char smb_conf[1024];
3733
    char smb_cmdline[1024];
3734
    FILE *f;
3735

    
3736
    if (!slirp_inited) {
3737
        slirp_inited = 1;
3738
        slirp_init();
3739
    }
3740

    
3741
    /* XXX: better tmp dir construction */
3742
    snprintf(smb_dir, sizeof(smb_dir), "/tmp/qemu-smb.%d", getpid());
3743
    if (mkdir(smb_dir, 0700) < 0) {
3744
        fprintf(stderr, "qemu: could not create samba server dir '%s'\n", smb_dir);
3745
        exit(1);
3746
    }
3747
    snprintf(smb_conf, sizeof(smb_conf), "%s/%s", smb_dir, "smb.conf");
3748

    
3749
    f = fopen(smb_conf, "w");
3750
    if (!f) {
3751
        fprintf(stderr, "qemu: could not create samba server configuration file '%s'\n", smb_conf);
3752
        exit(1);
3753
    }
3754
    fprintf(f,
3755
            "[global]\n"
3756
            "private dir=%s\n"
3757
            "smb ports=0\n"
3758
            "socket address=127.0.0.1\n"
3759
            "pid directory=%s\n"
3760
            "lock directory=%s\n"
3761
            "log file=%s/log.smbd\n"
3762
            "smb passwd file=%s/smbpasswd\n"
3763
            "security = share\n"
3764
            "[qemu]\n"
3765
            "path=%s\n"
3766
            "read only=no\n"
3767
            "guest ok=yes\n",
3768
            smb_dir,
3769
            smb_dir,
3770
            smb_dir,
3771
            smb_dir,
3772
            smb_dir,
3773
            exported_dir
3774
            );
3775
    fclose(f);
3776
    atexit(smb_exit);
3777

    
3778
    snprintf(smb_cmdline, sizeof(smb_cmdline), "%s -s %s",
3779
             SMBD_COMMAND, smb_conf);
3780

    
3781
    slirp_add_exec(0, smb_cmdline, 4, 139);
3782
}
3783

    
3784
#endif /* !defined(_WIN32) */
3785

    
3786
#endif /* CONFIG_SLIRP */
3787

    
3788
#if !defined(_WIN32)
3789

    
3790
typedef struct TAPState {
3791
    VLANClientState *vc;
3792
    int fd;
3793
    char down_script[1024];
3794
} TAPState;
3795

    
3796
static void tap_receive(void *opaque, const uint8_t *buf, int size)
3797
{
3798
    TAPState *s = opaque;
3799
    int ret;
3800
    for(;;) {
3801
        ret = write(s->fd, buf, size);
3802
        if (ret < 0 && (errno == EINTR || errno == EAGAIN)) {
3803
        } else {
3804
            break;
3805
        }
3806
    }
3807
}
3808

    
3809
static void tap_send(void *opaque)
3810
{
3811
    TAPState *s = opaque;
3812
    uint8_t buf[4096];
3813
    int size;
3814

    
3815
#ifdef __sun__
3816
    struct strbuf sbuf;
3817
    int f = 0;
3818
    sbuf.maxlen = sizeof(buf);
3819
    sbuf.buf = buf;
3820
    size = getmsg(s->fd, NULL, &sbuf, &f) >=0 ? sbuf.len : -1;
3821
#else
3822
    size = read(s->fd, buf, sizeof(buf));
3823
#endif
3824
    if (size > 0) {
3825
        qemu_send_packet(s->vc, buf, size);
3826
    }
3827
}
3828

    
3829
/* fd support */
3830

    
3831
static TAPState *net_tap_fd_init(VLANState *vlan, int fd)
3832
{
3833
    TAPState *s;
3834

    
3835
    s = qemu_mallocz(sizeof(TAPState));
3836
    if (!s)
3837
        return NULL;
3838
    s->fd = fd;
3839
    s->vc = qemu_new_vlan_client(vlan, tap_receive, NULL, s);
3840
    qemu_set_fd_handler(s->fd, tap_send, NULL, s);
3841
    snprintf(s->vc->info_str, sizeof(s->vc->info_str), "tap: fd=%d", fd);
3842
    return s;
3843
}
3844

    
3845
#if defined (_BSD) || defined (__FreeBSD_kernel__)
3846
static int tap_open(char *ifname, int ifname_size)
3847
{
3848
    int fd;
3849
    char *dev;
3850
    struct stat s;
3851

    
3852
    TFR(fd = open("/dev/tap", O_RDWR));
3853
    if (fd < 0) {
3854
        fprintf(stderr, "warning: could not open /dev/tap: no virtual network emulation\n");
3855
        return -1;
3856
    }
3857

    
3858
    fstat(fd, &s);
3859
    dev = devname(s.st_rdev, S_IFCHR);
3860
    pstrcpy(ifname, ifname_size, dev);
3861

    
3862
    fcntl(fd, F_SETFL, O_NONBLOCK);
3863
    return fd;
3864
}
3865
#elif defined(__sun__)
3866
#define TUNNEWPPA       (('T'<<16) | 0x0001)
3867
/*
3868
 * Allocate TAP device, returns opened fd.
3869
 * Stores dev name in the first arg(must be large enough).
3870
 */
3871
int tap_alloc(char *dev)
3872
{
3873
    int tap_fd, if_fd, ppa = -1;
3874
    static int ip_fd = 0;
3875
    char *ptr;
3876

    
3877
    static int arp_fd = 0;
3878
    int ip_muxid, arp_muxid;
3879
    struct strioctl  strioc_if, strioc_ppa;
3880
    int link_type = I_PLINK;;
3881
    struct lifreq ifr;
3882
    char actual_name[32] = "";
3883

    
3884
    memset(&ifr, 0x0, sizeof(ifr));
3885

    
3886
    if( *dev ){
3887
       ptr = dev;
3888
       while( *ptr && !isdigit((int)*ptr) ) ptr++;
3889
       ppa = atoi(ptr);
3890
    }
3891

    
3892
    /* Check if IP device was opened */
3893
    if( ip_fd )
3894
       close(ip_fd);
3895

    
3896
    TFR(ip_fd = open("/dev/udp", O_RDWR, 0));
3897
    if (ip_fd < 0) {
3898
       syslog(LOG_ERR, "Can't open /dev/ip (actually /dev/udp)");
3899
       return -1;
3900
    }
3901

    
3902
    TFR(tap_fd = open("/dev/tap", O_RDWR, 0));
3903
    if (tap_fd < 0) {
3904
       syslog(LOG_ERR, "Can't open /dev/tap");
3905
       return -1;
3906
    }
3907

    
3908
    /* Assign a new PPA and get its unit number. */
3909
    strioc_ppa.ic_cmd = TUNNEWPPA;
3910
    strioc_ppa.ic_timout = 0;
3911
    strioc_ppa.ic_len = sizeof(ppa);
3912
    strioc_ppa.ic_dp = (char *)&ppa;
3913
    if ((ppa = ioctl (tap_fd, I_STR, &strioc_ppa)) < 0)
3914
       syslog (LOG_ERR, "Can't assign new interface");
3915

    
3916
    TFR(if_fd = open("/dev/tap", O_RDWR, 0));
3917
    if (if_fd < 0) {
3918
       syslog(LOG_ERR, "Can't open /dev/tap (2)");
3919
       return -1;
3920
    }
3921
    if(ioctl(if_fd, I_PUSH, "ip") < 0){
3922
       syslog(LOG_ERR, "Can't push IP module");
3923
       return -1;
3924
    }
3925

    
3926
    if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) < 0)
3927
        syslog(LOG_ERR, "Can't get flags\n");
3928

    
3929
    snprintf (actual_name, 32, "tap%d", ppa);
3930
    strncpy (ifr.lifr_name, actual_name, sizeof (ifr.lifr_name));
3931

    
3932
    ifr.lifr_ppa = ppa;
3933
    /* Assign ppa according to the unit number returned by tun device */
3934

    
3935
    if (ioctl (if_fd, SIOCSLIFNAME, &ifr) < 0)
3936
        syslog (LOG_ERR, "Can't set PPA %d", ppa);
3937
    if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) <0)
3938
        syslog (LOG_ERR, "Can't get flags\n");
3939
    /* Push arp module to if_fd */
3940
    if (ioctl (if_fd, I_PUSH, "arp") < 0)
3941
        syslog (LOG_ERR, "Can't push ARP module (2)");
3942

    
3943
    /* Push arp module to ip_fd */
3944
    if (ioctl (ip_fd, I_POP, NULL) < 0)
3945
        syslog (LOG_ERR, "I_POP failed\n");
3946
    if (ioctl (ip_fd, I_PUSH, "arp") < 0)
3947
        syslog (LOG_ERR, "Can't push ARP module (3)\n");
3948
    /* Open arp_fd */
3949
    TFR(arp_fd = open ("/dev/tap", O_RDWR, 0));
3950
    if (arp_fd < 0)
3951
       syslog (LOG_ERR, "Can't open %s\n", "/dev/tap");
3952

    
3953
    /* Set ifname to arp */
3954
    strioc_if.ic_cmd = SIOCSLIFNAME;
3955
    strioc_if.ic_timout = 0;
3956
    strioc_if.ic_len = sizeof(ifr);
3957
    strioc_if.ic_dp = (char *)&ifr;
3958
    if (ioctl(arp_fd, I_STR, &strioc_if) < 0){
3959
        syslog (LOG_ERR, "Can't set ifname to arp\n");
3960
    }
3961

    
3962
    if((ip_muxid = ioctl(ip_fd, I_LINK, if_fd)) < 0){
3963
       syslog(LOG_ERR, "Can't link TAP device to IP");
3964
       return -1;
3965
    }
3966

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

    
3970
    close (if_fd);
3971

    
3972
    memset(&ifr, 0x0, sizeof(ifr));
3973
    strncpy (ifr.lifr_name, actual_name, sizeof (ifr.lifr_name));
3974
    ifr.lifr_ip_muxid  = ip_muxid;
3975
    ifr.lifr_arp_muxid = arp_muxid;
3976

    
3977
    if (ioctl (ip_fd, SIOCSLIFMUXID, &ifr) < 0)
3978
    {
3979
      ioctl (ip_fd, I_PUNLINK , arp_muxid);
3980
      ioctl (ip_fd, I_PUNLINK, ip_muxid);
3981
      syslog (LOG_ERR, "Can't set multiplexor id");
3982
    }
3983

    
3984
    sprintf(dev, "tap%d", ppa);
3985
    return tap_fd;
3986
}
3987

    
3988
static int tap_open(char *ifname, int ifname_size)
3989
{
3990
    char  dev[10]="";
3991
    int fd;
3992
    if( (fd = tap_alloc(dev)) < 0 ){
3993
       fprintf(stderr, "Cannot allocate TAP device\n");
3994
       return -1;
3995
    }
3996
    pstrcpy(ifname, ifname_size, dev);
3997
    fcntl(fd, F_SETFL, O_NONBLOCK);
3998
    return fd;
3999
}
4000
#else
4001
static int tap_open(char *ifname, int ifname_size)
4002
{
4003
    struct ifreq ifr;
4004
    int fd, ret;
4005

    
4006
    TFR(fd = open("/dev/net/tun", O_RDWR));
4007
    if (fd < 0) {
4008
        fprintf(stderr, "warning: could not open /dev/net/tun: no virtual network emulation\n");
4009
        return -1;
4010
    }
4011
    memset(&ifr, 0, sizeof(ifr));
4012
    ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
4013
    if (ifname[0] != '\0')
4014
        pstrcpy(ifr.ifr_name, IFNAMSIZ, ifname);
4015
    else
4016
        pstrcpy(ifr.ifr_name, IFNAMSIZ, "tap%d");
4017
    ret = ioctl(fd, TUNSETIFF, (void *) &ifr);
4018
    if (ret != 0) {
4019
        fprintf(stderr, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
4020
        close(fd);
4021
        return -1;
4022
    }
4023
    pstrcpy(ifname, ifname_size, ifr.ifr_name);
4024
    fcntl(fd, F_SETFL, O_NONBLOCK);
4025
    return fd;
4026
}
4027
#endif
4028

    
4029
static int launch_script(const char *setup_script, const char *ifname, int fd)
4030
{
4031
    int pid, status;
4032
    char *args[3];
4033
    char **parg;
4034

    
4035
        /* try to launch network script */
4036
        pid = fork();
4037
        if (pid >= 0) {
4038
            if (pid == 0) {
4039
                int open_max = sysconf (_SC_OPEN_MAX), i;
4040
                for (i = 0; i < open_max; i++)
4041
                    if (i != STDIN_FILENO &&
4042
                        i != STDOUT_FILENO &&
4043
                        i != STDERR_FILENO &&
4044
                        i != fd)
4045
                        close(i);
4046

    
4047
                parg = args;
4048
                *parg++ = (char *)setup_script;
4049
                *parg++ = (char *)ifname;
4050
                *parg++ = NULL;
4051
                execv(setup_script, args);
4052
                _exit(1);
4053
            }
4054
            while (waitpid(pid, &status, 0) != pid);
4055
            if (!WIFEXITED(status) ||
4056
                WEXITSTATUS(status) != 0) {
4057
                fprintf(stderr, "%s: could not launch network script\n",
4058
                        setup_script);
4059
                return -1;
4060
            }
4061
        }
4062
    return 0;
4063
}
4064

    
4065
static int net_tap_init(VLANState *vlan, const char *ifname1,
4066
                        const char *setup_script, const char *down_script)
4067
{
4068
    TAPState *s;
4069
    int fd;
4070
    char ifname[128];
4071

    
4072
    if (ifname1 != NULL)
4073
        pstrcpy(ifname, sizeof(ifname), ifname1);
4074
    else
4075
        ifname[0] = '\0';
4076
    TFR(fd = tap_open(ifname, sizeof(ifname)));
4077
    if (fd < 0)
4078
        return -1;
4079

    
4080
    if (!setup_script || !strcmp(setup_script, "no"))
4081
        setup_script = "";
4082
    if (setup_script[0] != '\0') {
4083
        if (launch_script(setup_script, ifname, fd))
4084
            return -1;
4085
    }
4086
    s = net_tap_fd_init(vlan, fd);
4087
    if (!s)
4088
        return -1;
4089
    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4090
             "tap: ifname=%s setup_script=%s", ifname, setup_script);
4091
    if (down_script && strcmp(down_script, "no"))
4092
        snprintf(s->down_script, sizeof(s->down_script), "%s", down_script);
4093
    return 0;
4094
}
4095

    
4096
#endif /* !_WIN32 */
4097

    
4098
/* network connection */
4099
typedef struct NetSocketState {
4100
    VLANClientState *vc;
4101
    int fd;
4102
    int state; /* 0 = getting length, 1 = getting data */
4103
    int index;
4104
    int packet_len;
4105
    uint8_t buf[4096];
4106
    struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
4107
} NetSocketState;
4108

    
4109
typedef struct NetSocketListenState {
4110
    VLANState *vlan;
4111
    int fd;
4112
} NetSocketListenState;
4113

    
4114
/* XXX: we consider we can send the whole packet without blocking */
4115
static void net_socket_receive(void *opaque, const uint8_t *buf, int size)
4116
{
4117
    NetSocketState *s = opaque;
4118
    uint32_t len;
4119
    len = htonl(size);
4120

    
4121
    send_all(s->fd, (const uint8_t *)&len, sizeof(len));
4122
    send_all(s->fd, buf, size);
4123
}
4124

    
4125
static void net_socket_receive_dgram(void *opaque, const uint8_t *buf, int size)
4126
{
4127
    NetSocketState *s = opaque;
4128
    sendto(s->fd, buf, size, 0,
4129
           (struct sockaddr *)&s->dgram_dst, sizeof(s->dgram_dst));
4130
}
4131

    
4132
static void net_socket_send(void *opaque)
4133
{
4134
    NetSocketState *s = opaque;
4135
    int l, size, err;
4136
    uint8_t buf1[4096];
4137
    const uint8_t *buf;
4138

    
4139
    size = recv(s->fd, buf1, sizeof(buf1), 0);
4140
    if (size < 0) {
4141
        err = socket_error();
4142
        if (err != EWOULDBLOCK)
4143
            goto eoc;
4144
    } else if (size == 0) {
4145
        /* end of connection */
4146
    eoc:
4147
        qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
4148
        closesocket(s->fd);
4149
        return;
4150
    }
4151
    buf = buf1;
4152
    while (size > 0) {
4153
        /* reassemble a packet from the network */
4154
        switch(s->state) {
4155
        case 0:
4156
            l = 4 - s->index;
4157
            if (l > size)
4158
                l = size;
4159
            memcpy(s->buf + s->index, buf, l);
4160
            buf += l;
4161
            size -= l;
4162
            s->index += l;
4163
            if (s->index == 4) {
4164
                /* got length */
4165
                s->packet_len = ntohl(*(uint32_t *)s->buf);
4166
                s->index = 0;
4167
                s->state = 1;
4168
            }
4169
            break;
4170
        case 1:
4171
            l = s->packet_len - s->index;
4172
            if (l > size)
4173
                l = size;
4174
            memcpy(s->buf + s->index, buf, l);
4175
            s->index += l;
4176
            buf += l;
4177
            size -= l;
4178
            if (s->index >= s->packet_len) {
4179
                qemu_send_packet(s->vc, s->buf, s->packet_len);
4180
                s->index = 0;
4181
                s->state = 0;
4182
            }
4183
            break;
4184
        }
4185
    }
4186
}
4187

    
4188
static void net_socket_send_dgram(void *opaque)
4189
{
4190
    NetSocketState *s = opaque;
4191
    int size;
4192

    
4193
    size = recv(s->fd, s->buf, sizeof(s->buf), 0);
4194
    if (size < 0)
4195
        return;
4196
    if (size == 0) {
4197
        /* end of connection */
4198
        qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
4199
        return;
4200
    }
4201
    qemu_send_packet(s->vc, s->buf, size);
4202
}
4203

    
4204
static int net_socket_mcast_create(struct sockaddr_in *mcastaddr)
4205
{
4206
    struct ip_mreq imr;
4207
    int fd;
4208
    int val, ret;
4209
    if (!IN_MULTICAST(ntohl(mcastaddr->sin_addr.s_addr))) {
4210
        fprintf(stderr, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
4211
                inet_ntoa(mcastaddr->sin_addr),
4212
                (int)ntohl(mcastaddr->sin_addr.s_addr));
4213
        return -1;
4214

    
4215
    }
4216
    fd = socket(PF_INET, SOCK_DGRAM, 0);
4217
    if (fd < 0) {
4218
        perror("socket(PF_INET, SOCK_DGRAM)");
4219
        return -1;
4220
    }
4221

    
4222
    val = 1;
4223
    ret=setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
4224
                   (const char *)&val, sizeof(val));
4225
    if (ret < 0) {
4226
        perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
4227
        goto fail;
4228
    }
4229

    
4230
    ret = bind(fd, (struct sockaddr *)mcastaddr, sizeof(*mcastaddr));
4231
    if (ret < 0) {
4232
        perror("bind");
4233
        goto fail;
4234
    }
4235

    
4236
    /* Add host to multicast group */
4237
    imr.imr_multiaddr = mcastaddr->sin_addr;
4238
    imr.imr_interface.s_addr = htonl(INADDR_ANY);
4239

    
4240
    ret = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
4241
                     (const char *)&imr, sizeof(struct ip_mreq));
4242
    if (ret < 0) {
4243
        perror("setsockopt(IP_ADD_MEMBERSHIP)");
4244
        goto fail;
4245
    }
4246

    
4247
    /* Force mcast msgs to loopback (eg. several QEMUs in same host */
4248
    val = 1;
4249
    ret=setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
4250
                   (const char *)&val, sizeof(val));
4251
    if (ret < 0) {
4252
        perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
4253
        goto fail;
4254
    }
4255

    
4256
    socket_set_nonblock(fd);
4257
    return fd;
4258
fail:
4259
    if (fd >= 0)
4260
        closesocket(fd);
4261
    return -1;
4262
}
4263

    
4264
static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan, int fd,
4265
                                          int is_connected)
4266
{
4267
    struct sockaddr_in saddr;
4268
    int newfd;
4269
    socklen_t saddr_len;
4270
    NetSocketState *s;
4271

    
4272
    /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
4273
     * Because this may be "shared" socket from a "master" process, datagrams would be recv()
4274
     * by ONLY ONE process: we must "clone" this dgram socket --jjo
4275
     */
4276

    
4277
    if (is_connected) {
4278
        if (getsockname(fd, (struct sockaddr *) &saddr, &saddr_len) == 0) {
4279
            /* must be bound */
4280
            if (saddr.sin_addr.s_addr==0) {
4281
                fprintf(stderr, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
4282
                        fd);
4283
                return NULL;
4284
            }
4285
            /* clone dgram socket */
4286
            newfd = net_socket_mcast_create(&saddr);
4287
            if (newfd < 0) {
4288
                /* error already reported by net_socket_mcast_create() */
4289
                close(fd);
4290
                return NULL;
4291
            }
4292
            /* clone newfd to fd, close newfd */
4293
            dup2(newfd, fd);
4294
            close(newfd);
4295

    
4296
        } else {
4297
            fprintf(stderr, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
4298
                    fd, strerror(errno));
4299
            return NULL;
4300
        }
4301
    }
4302

    
4303
    s = qemu_mallocz(sizeof(NetSocketState));
4304
    if (!s)
4305
        return NULL;
4306
    s->fd = fd;
4307

    
4308
    s->vc = qemu_new_vlan_client(vlan, net_socket_receive_dgram, NULL, s);
4309
    qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s);
4310

    
4311
    /* mcast: save bound address as dst */
4312
    if (is_connected) s->dgram_dst=saddr;
4313

    
4314
    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4315
            "socket: fd=%d (%s mcast=%s:%d)",
4316
            fd, is_connected? "cloned" : "",
4317
            inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4318
    return s;
4319
}
4320

    
4321
static void net_socket_connect(void *opaque)
4322
{
4323
    NetSocketState *s = opaque;
4324
    qemu_set_fd_handler(s->fd, net_socket_send, NULL, s);
4325
}
4326

    
4327
static NetSocketState *net_socket_fd_init_stream(VLANState *vlan, int fd,
4328
                                          int is_connected)
4329
{
4330
    NetSocketState *s;
4331
    s = qemu_mallocz(sizeof(NetSocketState));
4332
    if (!s)
4333
        return NULL;
4334
    s->fd = fd;
4335
    s->vc = qemu_new_vlan_client(vlan,
4336
                                 net_socket_receive, NULL, s);
4337
    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4338
             "socket: fd=%d", fd);
4339
    if (is_connected) {
4340
        net_socket_connect(s);
4341
    } else {
4342
        qemu_set_fd_handler(s->fd, NULL, net_socket_connect, s);
4343
    }
4344
    return s;
4345
}
4346

    
4347
static NetSocketState *net_socket_fd_init(VLANState *vlan, int fd,
4348
                                          int is_connected)
4349
{
4350
    int so_type=-1, optlen=sizeof(so_type);
4351

    
4352
    if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type, &optlen)< 0) {
4353
        fprintf(stderr, "qemu: error: getsockopt(SO_TYPE) for fd=%d failed\n", fd);
4354
        return NULL;
4355
    }
4356
    switch(so_type) {
4357
    case SOCK_DGRAM:
4358
        return net_socket_fd_init_dgram(vlan, fd, is_connected);
4359
    case SOCK_STREAM:
4360
        return net_socket_fd_init_stream(vlan, fd, is_connected);
4361
    default:
4362
        /* who knows ... this could be a eg. a pty, do warn and continue as stream */
4363
        fprintf(stderr, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type, fd);
4364
        return net_socket_fd_init_stream(vlan, fd, is_connected);
4365
    }
4366
    return NULL;
4367
}
4368

    
4369
static void net_socket_accept(void *opaque)
4370
{
4371
    NetSocketListenState *s = opaque;
4372
    NetSocketState *s1;
4373
    struct sockaddr_in saddr;
4374
    socklen_t len;
4375
    int fd;
4376

    
4377
    for(;;) {
4378
        len = sizeof(saddr);
4379
        fd = accept(s->fd, (struct sockaddr *)&saddr, &len);
4380
        if (fd < 0 && errno != EINTR) {
4381
            return;
4382
        } else if (fd >= 0) {
4383
            break;
4384
        }
4385
    }
4386
    s1 = net_socket_fd_init(s->vlan, fd, 1);
4387
    if (!s1) {
4388
        closesocket(fd);
4389
    } else {
4390
        snprintf(s1->vc->info_str, sizeof(s1->vc->info_str),
4391
                 "socket: connection from %s:%d",
4392
                 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4393
    }
4394
}
4395

    
4396
static int net_socket_listen_init(VLANState *vlan, const char *host_str)
4397
{
4398
    NetSocketListenState *s;
4399
    int fd, val, ret;
4400
    struct sockaddr_in saddr;
4401

    
4402
    if (parse_host_port(&saddr, host_str) < 0)
4403
        return -1;
4404

    
4405
    s = qemu_mallocz(sizeof(NetSocketListenState));
4406
    if (!s)
4407
        return -1;
4408

    
4409
    fd = socket(PF_INET, SOCK_STREAM, 0);
4410
    if (fd < 0) {
4411
        perror("socket");
4412
        return -1;
4413
    }
4414
    socket_set_nonblock(fd);
4415

    
4416
    /* allow fast reuse */
4417
    val = 1;
4418
    setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
4419

    
4420
    ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
4421
    if (ret < 0) {
4422
        perror("bind");
4423
        return -1;
4424
    }
4425
    ret = listen(fd, 0);
4426
    if (ret < 0) {
4427
        perror("listen");
4428
        return -1;
4429
    }
4430
    s->vlan = vlan;
4431
    s->fd = fd;
4432
    qemu_set_fd_handler(fd, net_socket_accept, NULL, s);
4433
    return 0;
4434
}
4435

    
4436
static int net_socket_connect_init(VLANState *vlan, const char *host_str)
4437
{
4438
    NetSocketState *s;
4439
    int fd, connected, ret, err;
4440
    struct sockaddr_in saddr;
4441

    
4442
    if (parse_host_port(&saddr, host_str) < 0)
4443
        return -1;
4444

    
4445
    fd = socket(PF_INET, SOCK_STREAM, 0);
4446
    if (fd < 0) {
4447
        perror("socket");
4448
        return -1;
4449
    }
4450
    socket_set_nonblock(fd);
4451

    
4452
    connected = 0;
4453
    for(;;) {
4454
        ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
4455
        if (ret < 0) {
4456
            err = socket_error();
4457
            if (err == EINTR || err == EWOULDBLOCK) {
4458
            } else if (err == EINPROGRESS) {
4459
                break;
4460
#ifdef _WIN32
4461
            } else if (err == WSAEALREADY) {
4462
                break;
4463
#endif
4464
            } else {
4465
                perror("connect");
4466
                closesocket(fd);
4467
                return -1;
4468
            }
4469
        } else {
4470
            connected = 1;
4471
            break;
4472
        }
4473
    }
4474
    s = net_socket_fd_init(vlan, fd, connected);
4475
    if (!s)
4476
        return -1;
4477
    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4478
             "socket: connect to %s:%d",
4479
             inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4480
    return 0;
4481
}
4482

    
4483
static int net_socket_mcast_init(VLANState *vlan, const char *host_str)
4484
{
4485
    NetSocketState *s;
4486
    int fd;
4487
    struct sockaddr_in saddr;
4488

    
4489
    if (parse_host_port(&saddr, host_str) < 0)
4490
        return -1;
4491

    
4492

    
4493
    fd = net_socket_mcast_create(&saddr);
4494
    if (fd < 0)
4495
        return -1;
4496

    
4497
    s = net_socket_fd_init(vlan, fd, 0);
4498
    if (!s)
4499
        return -1;
4500

    
4501
    s->dgram_dst = saddr;
4502

    
4503
    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4504
             "socket: mcast=%s:%d",
4505
             inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4506
    return 0;
4507

    
4508
}
4509

    
4510
static int get_param_value(char *buf, int buf_size,
4511
                           const char *tag, const char *str)
4512
{
4513
    const char *p;
4514
    char *q;
4515
    char option[128];
4516

    
4517
    p = str;
4518
    for(;;) {
4519
        q = option;
4520
        while (*p != '\0' && *p != '=') {
4521
            if ((q - option) < sizeof(option) - 1)
4522
                *q++ = *p;
4523
            p++;
4524
        }
4525
        *q = '\0';
4526
        if (*p != '=')
4527
            break;
4528
        p++;
4529
        if (!strcmp(tag, option)) {
4530
            q = buf;
4531
            while (*p != '\0' && *p != ',') {
4532
                if ((q - buf) < buf_size - 1)
4533
                    *q++ = *p;
4534
                p++;
4535
            }
4536
            *q = '\0';
4537
            return q - buf;
4538
        } else {
4539
            while (*p != '\0' && *p != ',') {
4540
                p++;
4541
            }
4542
        }
4543
        if (*p != ',')
4544
            break;
4545
        p++;
4546
    }
4547
    return 0;
4548
}
4549

    
4550
static int net_client_init(const char *str)
4551
{
4552
    const char *p;
4553
    char *q;
4554
    char device[64];
4555
    char buf[1024];
4556
    int vlan_id, ret;
4557
    VLANState *vlan;
4558

    
4559
    p = str;
4560
    q = device;
4561
    while (*p != '\0' && *p != ',') {
4562
        if ((q - device) < sizeof(device) - 1)
4563
            *q++ = *p;
4564
        p++;
4565
    }
4566
    *q = '\0';
4567
    if (*p == ',')
4568
        p++;
4569
    vlan_id = 0;
4570
    if (get_param_value(buf, sizeof(buf), "vlan", p)) {
4571
        vlan_id = strtol(buf, NULL, 0);
4572
    }
4573
    vlan = qemu_find_vlan(vlan_id);
4574
    if (!vlan) {
4575
        fprintf(stderr, "Could not create vlan %d\n", vlan_id);
4576
        return -1;
4577
    }
4578
    if (!strcmp(device, "nic")) {
4579
        NICInfo *nd;
4580
        uint8_t *macaddr;
4581

    
4582
        if (nb_nics >= MAX_NICS) {
4583
            fprintf(stderr, "Too Many NICs\n");
4584
            return -1;
4585
        }
4586
        nd = &nd_table[nb_nics];
4587
        macaddr = nd->macaddr;
4588
        macaddr[0] = 0x52;
4589
        macaddr[1] = 0x54;
4590
        macaddr[2] = 0x00;
4591
        macaddr[3] = 0x12;
4592
        macaddr[4] = 0x34;
4593
        macaddr[5] = 0x56 + nb_nics;
4594

    
4595
        if (get_param_value(buf, sizeof(buf), "macaddr", p)) {
4596
            if (parse_macaddr(macaddr, buf) < 0) {
4597
                fprintf(stderr, "invalid syntax for ethernet address\n");
4598
                return -1;
4599
            }
4600
        }
4601
        if (get_param_value(buf, sizeof(buf), "model", p)) {
4602
            nd->model = strdup(buf);
4603
        }
4604
        nd->vlan = vlan;
4605
        nb_nics++;
4606
        vlan->nb_guest_devs++;
4607
        ret = 0;
4608
    } else
4609
    if (!strcmp(device, "none")) {
4610
        /* does nothing. It is needed to signal that no network cards
4611
           are wanted */
4612
        ret = 0;
4613
    } else
4614
#ifdef CONFIG_SLIRP
4615
    if (!strcmp(device, "user")) {
4616
        if (get_param_value(buf, sizeof(buf), "hostname", p)) {
4617
            pstrcpy(slirp_hostname, sizeof(slirp_hostname), buf);
4618
        }
4619
        vlan->nb_host_devs++;
4620
        ret = net_slirp_init(vlan);
4621
    } else
4622
#endif
4623
#ifdef _WIN32
4624
    if (!strcmp(device, "tap")) {
4625
        char ifname[64];
4626
        if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
4627
            fprintf(stderr, "tap: no interface name\n");
4628
            return -1;
4629
        }
4630
        vlan->nb_host_devs++;
4631
        ret = tap_win32_init(vlan, ifname);
4632
    } else
4633
#else
4634
    if (!strcmp(device, "tap")) {
4635
        char ifname[64];
4636
        char setup_script[1024], down_script[1024];
4637
        int fd;
4638
        vlan->nb_host_devs++;
4639
        if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
4640
            fd = strtol(buf, NULL, 0);
4641
            ret = -1;
4642
            if (net_tap_fd_init(vlan, fd))
4643
                ret = 0;
4644
        } else {
4645
            if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
4646
                ifname[0] = '\0';
4647
            }
4648
            if (get_param_value(setup_script, sizeof(setup_script), "script", p) == 0) {
4649
                pstrcpy(setup_script, sizeof(setup_script), DEFAULT_NETWORK_SCRIPT);
4650
            }
4651
            if (get_param_value(down_script, sizeof(down_script), "downscript", p) == 0) {
4652
                pstrcpy(down_script, sizeof(down_script), DEFAULT_NETWORK_DOWN_SCRIPT);
4653
            }
4654
            ret = net_tap_init(vlan, ifname, setup_script, down_script);
4655
        }
4656
    } else
4657
#endif
4658
    if (!strcmp(device, "socket")) {
4659
        if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
4660
            int fd;
4661
            fd = strtol(buf, NULL, 0);
4662
            ret = -1;
4663
            if (net_socket_fd_init(vlan, fd, 1))
4664
                ret = 0;
4665
        } else if (get_param_value(buf, sizeof(buf), "listen", p) > 0) {
4666
            ret = net_socket_listen_init(vlan, buf);
4667
        } else if (get_param_value(buf, sizeof(buf), "connect", p) > 0) {
4668
            ret = net_socket_connect_init(vlan, buf);
4669
        } else if (get_param_value(buf, sizeof(buf), "mcast", p) > 0) {
4670
            ret = net_socket_mcast_init(vlan, buf);
4671
        } else {
4672
            fprintf(stderr, "Unknown socket options: %s\n", p);
4673
            return -1;
4674
        }
4675
        vlan->nb_host_devs++;
4676
    } else
4677
    {
4678
        fprintf(stderr, "Unknown network device: %s\n", device);
4679
        return -1;
4680
    }
4681
    if (ret < 0) {
4682
        fprintf(stderr, "Could not initialize device '%s'\n", device);
4683
    }
4684

    
4685
    return ret;
4686
}
4687

    
4688
void do_info_network(void)
4689
{
4690
    VLANState *vlan;
4691
    VLANClientState *vc;
4692

    
4693
    for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
4694
        term_printf("VLAN %d devices:\n", vlan->id);
4695
        for(vc = vlan->first_client; vc != NULL; vc = vc->next)
4696
            term_printf("  %s\n", vc->info_str);
4697
    }
4698
}
4699

    
4700
/***********************************************************/
4701
/* USB devices */
4702

    
4703
static USBPort *used_usb_ports;
4704
static USBPort *free_usb_ports;
4705

    
4706
/* ??? Maybe change this to register a hub to keep track of the topology.  */
4707
void qemu_register_usb_port(USBPort *port, void *opaque, int index,
4708
                            usb_attachfn attach)
4709
{
4710
    port->opaque = opaque;
4711
    port->index = index;
4712
    port->attach = attach;
4713
    port->next = free_usb_ports;
4714
    free_usb_ports = port;
4715
}
4716

    
4717
static int usb_device_add(const char *devname)
4718
{
4719
    const char *p;
4720
    USBDevice *dev;
4721
    USBPort *port;
4722

    
4723
    if (!free_usb_ports)
4724
        return -1;
4725

    
4726
    if (strstart(devname, "host:", &p)) {
4727
        dev = usb_host_device_open(p);
4728
    } else if (!strcmp(devname, "mouse")) {
4729
        dev = usb_mouse_init();
4730
    } else if (!strcmp(devname, "tablet")) {
4731
        dev = usb_tablet_init();
4732
    } else if (!strcmp(devname, "keyboard")) {
4733
        dev = usb_keyboard_init();
4734
    } else if (strstart(devname, "disk:", &p)) {
4735
        dev = usb_msd_init(p);
4736
    } else if (!strcmp(devname, "wacom-tablet")) {
4737
        dev = usb_wacom_init();
4738
    } else {
4739
        return -1;
4740
    }
4741
    if (!dev)
4742
        return -1;
4743

    
4744
    /* Find a USB port to add the device to.  */
4745
    port = free_usb_ports;
4746
    if (!port->next) {
4747
        USBDevice *hub;
4748

    
4749
        /* Create a new hub and chain it on.  */
4750
        free_usb_ports = NULL;
4751
        port->next = used_usb_ports;
4752
        used_usb_ports = port;
4753

    
4754
        hub = usb_hub_init(VM_USB_HUB_SIZE);
4755
        usb_attach(port, hub);
4756
        port = free_usb_ports;
4757
    }
4758

    
4759
    free_usb_ports = port->next;
4760
    port->next = used_usb_ports;
4761
    used_usb_ports = port;
4762
    usb_attach(port, dev);
4763
    return 0;
4764
}
4765

    
4766
static int usb_device_del(const char *devname)
4767
{
4768
    USBPort *port;
4769
    USBPort **lastp;
4770
    USBDevice *dev;
4771
    int bus_num, addr;
4772
    const char *p;
4773

    
4774
    if (!used_usb_ports)
4775
        return -1;
4776

    
4777
    p = strchr(devname, '.');
4778
    if (!p)
4779
        return -1;
4780
    bus_num = strtoul(devname, NULL, 0);
4781
    addr = strtoul(p + 1, NULL, 0);
4782
    if (bus_num != 0)
4783
        return -1;
4784

    
4785
    lastp = &used_usb_ports;
4786
    port = used_usb_ports;
4787
    while (port && port->dev->addr != addr) {
4788
        lastp = &port->next;
4789
        port = port->next;
4790
    }
4791

    
4792
    if (!port)
4793
        return -1;
4794

    
4795
    dev = port->dev;
4796
    *lastp = port->next;
4797
    usb_attach(port, NULL);
4798
    dev->handle_destroy(dev);
4799
    port->next = free_usb_ports;
4800
    free_usb_ports = port;
4801
    return 0;
4802
}
4803

    
4804
void do_usb_add(const char *devname)
4805
{
4806
    int ret;
4807
    ret = usb_device_add(devname);
4808
    if (ret < 0)
4809
        term_printf("Could not add USB device '%s'\n", devname);
4810
}
4811

    
4812
void do_usb_del(const char *devname)
4813
{
4814
    int ret;
4815
    ret = usb_device_del(devname);
4816
    if (ret < 0)
4817
        term_printf("Could not remove USB device '%s'\n", devname);
4818
}
4819

    
4820
void usb_info(void)
4821
{
4822
    USBDevice *dev;
4823
    USBPort *port;
4824
    const char *speed_str;
4825

    
4826
    if (!usb_enabled) {
4827
        term_printf("USB support not enabled\n");
4828
        return;
4829
    }
4830

    
4831
    for (port = used_usb_ports; port; port = port->next) {
4832
        dev = port->dev;
4833
        if (!dev)
4834
            continue;
4835
        switch(dev->speed) {
4836
        case USB_SPEED_LOW:
4837
            speed_str = "1.5";
4838
            break;
4839
        case USB_SPEED_FULL:
4840
            speed_str = "12";
4841
            break;
4842
        case USB_SPEED_HIGH:
4843
            speed_str = "480";
4844
            break;
4845
        default:
4846
            speed_str = "?";
4847
            break;
4848
        }
4849
        term_printf("  Device %d.%d, Speed %s Mb/s, Product %s\n",
4850
                    0, dev->addr, speed_str, dev->devname);
4851
    }
4852
}
4853

    
4854
/***********************************************************/
4855
/* PCMCIA/Cardbus */
4856

    
4857
static struct pcmcia_socket_entry_s {
4858
    struct pcmcia_socket_s *socket;
4859
    struct pcmcia_socket_entry_s *next;
4860
} *pcmcia_sockets = 0;
4861

    
4862
void pcmcia_socket_register(struct pcmcia_socket_s *socket)
4863
{
4864
    struct pcmcia_socket_entry_s *entry;
4865

    
4866
    entry = qemu_malloc(sizeof(struct pcmcia_socket_entry_s));
4867
    entry->socket = socket;
4868
    entry->next = pcmcia_sockets;
4869
    pcmcia_sockets = entry;
4870
}
4871

    
4872
void pcmcia_socket_unregister(struct pcmcia_socket_s *socket)
4873
{
4874
    struct pcmcia_socket_entry_s *entry, **ptr;
4875

    
4876
    ptr = &pcmcia_sockets;
4877
    for (entry = *ptr; entry; ptr = &entry->next, entry = *ptr)
4878
        if (entry->socket == socket) {
4879
            *ptr = entry->next;
4880
            qemu_free(entry);
4881
        }
4882
}
4883

    
4884
void pcmcia_info(void)
4885
{
4886
    struct pcmcia_socket_entry_s *iter;
4887
    if (!pcmcia_sockets)
4888
        term_printf("No PCMCIA sockets\n");
4889

    
4890
    for (iter = pcmcia_sockets; iter; iter = iter->next)
4891
        term_printf("%s: %s\n", iter->socket->slot_string,
4892
                    iter->socket->attached ? iter->socket->card_string :
4893
                    "Empty");
4894
}
4895

    
4896
/***********************************************************/
4897
/* dumb display */
4898

    
4899
static void dumb_update(DisplayState *ds, int x, int y, int w, int h)
4900
{
4901
}
4902

    
4903
static void dumb_resize(DisplayState *ds, int w, int h)
4904
{
4905
}
4906

    
4907
static void dumb_refresh(DisplayState *ds)
4908
{
4909
#if defined(CONFIG_SDL)
4910
    vga_hw_update();
4911
#endif
4912
}
4913

    
4914
static void dumb_display_init(DisplayState *ds)
4915
{
4916
    ds->data = NULL;
4917
    ds->linesize = 0;
4918
    ds->depth = 0;
4919
    ds->dpy_update = dumb_update;
4920
    ds->dpy_resize = dumb_resize;
4921
    ds->dpy_refresh = dumb_refresh;
4922
}
4923

    
4924
/***********************************************************/
4925
/* I/O handling */
4926

    
4927
#define MAX_IO_HANDLERS 64
4928

    
4929
typedef struct IOHandlerRecord {
4930
    int fd;
4931
    IOCanRWHandler *fd_read_poll;
4932
    IOHandler *fd_read;
4933
    IOHandler *fd_write;
4934
    int deleted;
4935
    void *opaque;
4936
    /* temporary data */
4937
    struct pollfd *ufd;
4938
    struct IOHandlerRecord *next;
4939
} IOHandlerRecord;
4940

    
4941
static IOHandlerRecord *first_io_handler;
4942

    
4943
/* XXX: fd_read_poll should be suppressed, but an API change is
4944
   necessary in the character devices to suppress fd_can_read(). */
4945
int qemu_set_fd_handler2(int fd,
4946
                         IOCanRWHandler *fd_read_poll,
4947
                         IOHandler *fd_read,
4948
                         IOHandler *fd_write,
4949
                         void *opaque)
4950
{
4951
    IOHandlerRecord **pioh, *ioh;
4952

    
4953
    if (!fd_read && !fd_write) {
4954
        pioh = &first_io_handler;
4955
        for(;;) {
4956
            ioh = *pioh;
4957
            if (ioh == NULL)
4958
                break;
4959
            if (ioh->fd == fd) {
4960
                ioh->deleted = 1;
4961
                break;
4962
            }
4963
            pioh = &ioh->next;
4964
        }
4965
    } else {