Statistics
| Branch: | Revision:

root / vl.c @ 5fafdf24

History | View | Annotate | Download (216.8 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
#ifdef __sun__
121
#define SMBD_COMMAND "/usr/sfw/sbin/smbd"
122
#else
123
#define SMBD_COMMAND "/usr/sbin/smbd"
124
#endif
125

    
126
//#define DEBUG_UNUSED_IOPORT
127
//#define DEBUG_IOPORT
128

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

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

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

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

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

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

    
222
/***********************************************************/
223
/* x86 ISA bus support */
224

    
225
target_phys_addr_t isa_mem_base = 0;
226
PicState2 *isa_pic;
227

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

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

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

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

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

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

    
275
void init_ioports(void)
276
{
277
    int i;
278

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

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

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

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

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

    
339
void isa_unassign_ioport(int start, int length)
340
{
341
    int i;
342

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

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

    
354
/***********************************************************/
355

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

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

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

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

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

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

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

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

    
462
/***********************************************************/
463
/* keyboard/mouse */
464

    
465
static QEMUPutKBDEvent *qemu_put_kbd_event;
466
static void *qemu_put_kbd_event_opaque;
467
static QEMUPutMouseEntry *qemu_put_mouse_event_head;
468
static QEMUPutMouseEntry *qemu_put_mouse_event_current;
469

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

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

    
482
    s = qemu_mallocz(sizeof(QEMUPutMouseEntry));
483
    if (!s)
484
        return NULL;
485

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

    
492
    if (!qemu_put_mouse_event_head) {
493
        qemu_put_mouse_event_head = qemu_put_mouse_event_current = s;
494
        return s;
495
    }
496

    
497
    cursor = qemu_put_mouse_event_head;
498
    while (cursor->next != NULL)
499
        cursor = cursor->next;
500

    
501
    cursor->next = s;
502
    qemu_put_mouse_event_current = s;
503

    
504
    return s;
505
}
506

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

    
511
    if (!qemu_put_mouse_event_head || entry == NULL)
512
        return;
513

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

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

    
531
    prev->next = entry->next;
532

    
533
    if (qemu_put_mouse_event_current == entry)
534
        qemu_put_mouse_event_current = prev;
535

    
536
    qemu_free(entry->qemu_put_mouse_event_name);
537
    qemu_free(entry);
538
}
539

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

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

    
553
    if (!qemu_put_mouse_event_current) {
554
        return;
555
    }
556

    
557
    mouse_event =
558
        qemu_put_mouse_event_current->qemu_put_mouse_event;
559
    mouse_event_opaque =
560
        qemu_put_mouse_event_current->qemu_put_mouse_event_opaque;
561

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

    
576
int kbd_mouse_is_absolute(void)
577
{
578
    if (!qemu_put_mouse_event_current)
579
        return 0;
580

    
581
    return qemu_put_mouse_event_current->qemu_put_mouse_event_absolute;
582
}
583

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

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

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

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

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

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

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

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

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

    
651
/***********************************************************/
652
/* real time host monotonic timer */
653

    
654
#define QEMU_TIMER_BASE 1000000000LL
655

    
656
#ifdef WIN32
657

    
658
static int64_t clock_freq;
659

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

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

    
679
#else
680

    
681
static int use_rt_clock;
682

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

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

    
714
#endif
715

    
716
/***********************************************************/
717
/* guest cycle counter */
718

    
719
static int64_t cpu_ticks_prev;
720
static int64_t cpu_ticks_offset;
721
static int64_t cpu_clock_offset;
722
static int cpu_ticks_enabled;
723

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

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

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

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

    
775
/***********************************************************/
776
/* timers */
777

    
778
#define QEMU_TIMER_REALTIME 0
779
#define QEMU_TIMER_VIRTUAL  1
780

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

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

    
794
struct qemu_alarm_timer {
795
    char const *name;
796
    unsigned int flags;
797

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

    
804
#define ALARM_FLAG_DYNTICKS  0x1
805

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

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

    
816
    t->rearm(t);
817
}
818

    
819
/* TODO: MIN_TIMER_REARM_US should be optimized */
820
#define MIN_TIMER_REARM_US 250
821

    
822
static struct qemu_alarm_timer *alarm_timer;
823

    
824
#ifdef _WIN32
825

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

    
832
static int win32_start_timer(struct qemu_alarm_timer *t);
833
static void win32_stop_timer(struct qemu_alarm_timer *t);
834
static void win32_rearm_timer(struct qemu_alarm_timer *t);
835

    
836
#else
837

    
838
static int unix_start_timer(struct qemu_alarm_timer *t);
839
static void unix_stop_timer(struct qemu_alarm_timer *t);
840

    
841
#ifdef __linux__
842

    
843
static int dynticks_start_timer(struct qemu_alarm_timer *t);
844
static void dynticks_stop_timer(struct qemu_alarm_timer *t);
845
static void dynticks_rearm_timer(struct qemu_alarm_timer *t);
846

    
847
static int hpet_start_timer(struct qemu_alarm_timer *t);
848
static void hpet_stop_timer(struct qemu_alarm_timer *t);
849

    
850
static int rtc_start_timer(struct qemu_alarm_timer *t);
851
static void rtc_stop_timer(struct qemu_alarm_timer *t);
852

    
853
#endif /* __linux__ */
854

    
855
#endif /* _WIN32 */
856

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

    
877
static void show_available_alarms()
878
{
879
    int i;
880

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

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

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

    
899
    arg = strdup(opt);
900

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

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

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

    
916
        if (i < cur)
917
            /* Ignore */
918
            goto next;
919

    
920
        /* Swap */
921
        tmp = alarm_timers[i];
922
        alarm_timers[i] = alarm_timers[cur];
923
        alarm_timers[cur] = tmp;
924

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

    
930
    free(arg);
931

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

    
938
    /* debug */
939
    show_available_alarms();
940
}
941

    
942
QEMUClock *rt_clock;
943
QEMUClock *vm_clock;
944

    
945
static QEMUTimer *active_timers[2];
946

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

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

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

    
968
void qemu_free_timer(QEMUTimer *ts)
969
{
970
    qemu_free(ts);
971
}
972

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

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

    
992
    qemu_rearm_alarm_timer(alarm_timer);
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 = UINT64_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
} TAPState;
3794

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

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

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

    
3828
/* fd support */
3829

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3969
    close (if_fd);
3970

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

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

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

    
3987
static int tap_open(char *ifname, int ifname_size)
3988
{
3989
    char  dev[10]="";
3990
    int fd;
3991
    if( (fd = tap_alloc(dev)) < 0 ){
3992
       fprintf(stderr, "Cannot allocate TAP device\n");
3993
       return -1;
3994
    }
3995
    pstrcpy(ifname, ifname_size, dev);
3996
    fcntl(fd, F_SETFL, O_NONBLOCK);
3997
    return fd;
3998
}
3999
#else
4000
static int tap_open(char *ifname, int ifname_size)
4001
{
4002
    struct ifreq ifr;
4003
    int fd, ret;
4004
   
4005
    TFR(fd = open("/dev/net/tun", O_RDWR));
4006
    if (fd < 0) {
4007
        fprintf(stderr, "warning: could not open /dev/net/tun: no virtual network emulation\n");
4008
        return -1;
4009
    }
4010
    memset(&ifr, 0, sizeof(ifr));
4011
    ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
4012
    if (ifname[0] != '\0')
4013
        pstrcpy(ifr.ifr_name, IFNAMSIZ, ifname);
4014
    else
4015
        pstrcpy(ifr.ifr_name, IFNAMSIZ, "tap%d");
4016
    ret = ioctl(fd, TUNSETIFF, (void *) &ifr);
4017
    if (ret != 0) {
4018
        fprintf(stderr, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
4019
        close(fd);
4020
        return -1;
4021
    }
4022
    pstrcpy(ifname, ifname_size, ifr.ifr_name);
4023
    fcntl(fd, F_SETFL, O_NONBLOCK);
4024
    return fd;
4025
}
4026
#endif
4027

    
4028
static int net_tap_init(VLANState *vlan, const char *ifname1,
4029
                        const char *setup_script)
4030
{
4031
    TAPState *s;
4032
    int pid, status, fd;
4033
    char *args[3];
4034
    char **parg;
4035
    char ifname[128];
4036

    
4037
    if (ifname1 != NULL)
4038
        pstrcpy(ifname, sizeof(ifname), ifname1);
4039
    else
4040
        ifname[0] = '\0';
4041
    TFR(fd = tap_open(ifname, sizeof(ifname)));
4042
    if (fd < 0)
4043
        return -1;
4044

    
4045
    if (!setup_script || !strcmp(setup_script, "no"))
4046
        setup_script = "";
4047
    if (setup_script[0] != '\0') {
4048
        /* try to launch network init script */
4049
        pid = fork();
4050
        if (pid >= 0) {
4051
            if (pid == 0) {
4052
                int open_max = sysconf (_SC_OPEN_MAX), i;
4053
                for (i = 0; i < open_max; i++)
4054
                    if (i != STDIN_FILENO &&
4055
                        i != STDOUT_FILENO &&
4056
                        i != STDERR_FILENO &&
4057
                        i != fd)
4058
                        close(i);
4059

    
4060
                parg = args;
4061
                *parg++ = (char *)setup_script;
4062
                *parg++ = ifname;
4063
                *parg++ = NULL;
4064
                execv(setup_script, args);
4065
                _exit(1);
4066
            }
4067
            while (waitpid(pid, &status, 0) != pid);
4068
            if (!WIFEXITED(status) ||
4069
                WEXITSTATUS(status) != 0) {
4070
                fprintf(stderr, "%s: could not launch network script\n",
4071
                        setup_script);
4072
                return -1;
4073
            }
4074
        }
4075
    }
4076
    s = net_tap_fd_init(vlan, fd);
4077
    if (!s)
4078
        return -1;
4079
    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4080
             "tap: ifname=%s setup_script=%s", ifname, setup_script);
4081
    return 0;
4082
}
4083

    
4084
#endif /* !_WIN32 */
4085

    
4086
/* network connection */
4087
typedef struct NetSocketState {
4088
    VLANClientState *vc;
4089
    int fd;
4090
    int state; /* 0 = getting length, 1 = getting data */
4091
    int index;
4092
    int packet_len;
4093
    uint8_t buf[4096];
4094
    struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
4095
} NetSocketState;
4096

    
4097
typedef struct NetSocketListenState {
4098
    VLANState *vlan;
4099
    int fd;
4100
} NetSocketListenState;
4101

    
4102
/* XXX: we consider we can send the whole packet without blocking */
4103
static void net_socket_receive(void *opaque, const uint8_t *buf, int size)
4104
{
4105
    NetSocketState *s = opaque;
4106
    uint32_t len;
4107
    len = htonl(size);
4108

    
4109
    send_all(s->fd, (const uint8_t *)&len, sizeof(len));
4110
    send_all(s->fd, buf, size);
4111
}
4112

    
4113
static void net_socket_receive_dgram(void *opaque, const uint8_t *buf, int size)
4114
{
4115
    NetSocketState *s = opaque;
4116
    sendto(s->fd, buf, size, 0,
4117
           (struct sockaddr *)&s->dgram_dst, sizeof(s->dgram_dst));
4118
}
4119

    
4120
static void net_socket_send(void *opaque)
4121
{
4122
    NetSocketState *s = opaque;
4123
    int l, size, err;
4124
    uint8_t buf1[4096];
4125
    const uint8_t *buf;
4126

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

    
4176
static void net_socket_send_dgram(void *opaque)
4177
{
4178
    NetSocketState *s = opaque;
4179
    int size;
4180

    
4181
    size = recv(s->fd, s->buf, sizeof(s->buf), 0);
4182
    if (size < 0)
4183
        return;
4184
    if (size == 0) {
4185
        /* end of connection */
4186
        qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
4187
        return;
4188
    }
4189
    qemu_send_packet(s->vc, s->buf, size);
4190
}
4191

    
4192
static int net_socket_mcast_create(struct sockaddr_in *mcastaddr)
4193
{
4194
    struct ip_mreq imr;
4195
    int fd;
4196
    int val, ret;
4197
    if (!IN_MULTICAST(ntohl(mcastaddr->sin_addr.s_addr))) {
4198
        fprintf(stderr, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
4199
                inet_ntoa(mcastaddr->sin_addr),
4200
                (int)ntohl(mcastaddr->sin_addr.s_addr));
4201
        return -1;
4202

    
4203
    }
4204
    fd = socket(PF_INET, SOCK_DGRAM, 0);
4205
    if (fd < 0) {
4206
        perror("socket(PF_INET, SOCK_DGRAM)");
4207
        return -1;
4208
    }
4209

    
4210
    val = 1;
4211
    ret=setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
4212
                   (const char *)&val, sizeof(val));
4213
    if (ret < 0) {
4214
        perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
4215
        goto fail;
4216
    }
4217

    
4218
    ret = bind(fd, (struct sockaddr *)mcastaddr, sizeof(*mcastaddr));
4219
    if (ret < 0) {
4220
        perror("bind");
4221
        goto fail;
4222
    }
4223
   
4224
    /* Add host to multicast group */
4225
    imr.imr_multiaddr = mcastaddr->sin_addr;
4226
    imr.imr_interface.s_addr = htonl(INADDR_ANY);
4227

    
4228
    ret = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
4229
                     (const char *)&imr, sizeof(struct ip_mreq));
4230
    if (ret < 0) {
4231
        perror("setsockopt(IP_ADD_MEMBERSHIP)");
4232
        goto fail;
4233
    }
4234

    
4235
    /* Force mcast msgs to loopback (eg. several QEMUs in same host */
4236
    val = 1;
4237
    ret=setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
4238
                   (const char *)&val, sizeof(val));
4239
    if (ret < 0) {
4240
        perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
4241
        goto fail;
4242
    }
4243

    
4244
    socket_set_nonblock(fd);
4245
    return fd;
4246
fail:
4247
    if (fd >= 0)
4248
        closesocket(fd);
4249
    return -1;
4250
}
4251

    
4252
static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan, int fd,
4253
                                          int is_connected)
4254
{
4255
    struct sockaddr_in saddr;
4256
    int newfd;
4257
    socklen_t saddr_len;
4258
    NetSocketState *s;
4259

    
4260
    /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
4261
     * Because this may be "shared" socket from a "master" process, datagrams would be recv()
4262
     * by ONLY ONE process: we must "clone" this dgram socket --jjo
4263
     */
4264

    
4265
    if (is_connected) {
4266
        if (getsockname(fd, (struct sockaddr *) &saddr, &saddr_len) == 0) {
4267
            /* must be bound */
4268
            if (saddr.sin_addr.s_addr==0) {
4269
                fprintf(stderr, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
4270
                        fd);
4271
                return NULL;
4272
            }
4273
            /* clone dgram socket */
4274
            newfd = net_socket_mcast_create(&saddr);
4275
            if (newfd < 0) {
4276
                /* error already reported by net_socket_mcast_create() */
4277
                close(fd);
4278
                return NULL;
4279
            }
4280
            /* clone newfd to fd, close newfd */
4281
            dup2(newfd, fd);
4282
            close(newfd);
4283

    
4284
        } else {
4285
            fprintf(stderr, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
4286
                    fd, strerror(errno));
4287
            return NULL;
4288
        }
4289
    }
4290

    
4291
    s = qemu_mallocz(sizeof(NetSocketState));
4292
    if (!s)
4293
        return NULL;
4294
    s->fd = fd;
4295

    
4296
    s->vc = qemu_new_vlan_client(vlan, net_socket_receive_dgram, NULL, s);
4297
    qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s);
4298

    
4299
    /* mcast: save bound address as dst */
4300
    if (is_connected) s->dgram_dst=saddr;
4301

    
4302
    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4303
            "socket: fd=%d (%s mcast=%s:%d)",
4304
            fd, is_connected? "cloned" : "",
4305
            inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4306
    return s;
4307
}
4308

    
4309
static void net_socket_connect(void *opaque)
4310
{
4311
    NetSocketState *s = opaque;
4312
    qemu_set_fd_handler(s->fd, net_socket_send, NULL, s);
4313
}
4314

    
4315
static NetSocketState *net_socket_fd_init_stream(VLANState *vlan, int fd,
4316
                                          int is_connected)
4317
{
4318
    NetSocketState *s;
4319
    s = qemu_mallocz(sizeof(NetSocketState));
4320
    if (!s)
4321
        return NULL;
4322
    s->fd = fd;
4323
    s->vc = qemu_new_vlan_client(vlan,
4324
                                 net_socket_receive, NULL, s);
4325
    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4326
             "socket: fd=%d", fd);
4327
    if (is_connected) {
4328
        net_socket_connect(s);
4329
    } else {
4330
        qemu_set_fd_handler(s->fd, NULL, net_socket_connect, s);
4331
    }
4332
    return s;
4333
}
4334

    
4335
static NetSocketState *net_socket_fd_init(VLANState *vlan, int fd,
4336
                                          int is_connected)
4337
{
4338
    int so_type=-1, optlen=sizeof(so_type);
4339

    
4340
    if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type, &optlen)< 0) {
4341
        fprintf(stderr, "qemu: error: getsockopt(SO_TYPE) for fd=%d failed\n", fd);
4342
        return NULL;
4343
    }
4344
    switch(so_type) {
4345
    case SOCK_DGRAM:
4346
        return net_socket_fd_init_dgram(vlan, fd, is_connected);
4347
    case SOCK_STREAM:
4348
        return net_socket_fd_init_stream(vlan, fd, is_connected);
4349
    default:
4350
        /* who knows ... this could be a eg. a pty, do warn and continue as stream */
4351
        fprintf(stderr, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type, fd);
4352
        return net_socket_fd_init_stream(vlan, fd, is_connected);
4353
    }
4354
    return NULL;
4355
}
4356

    
4357
static void net_socket_accept(void *opaque)
4358
{
4359
    NetSocketListenState *s = opaque;   
4360
    NetSocketState *s1;
4361
    struct sockaddr_in saddr;
4362
    socklen_t len;
4363
    int fd;
4364

    
4365
    for(;;) {
4366
        len = sizeof(saddr);
4367
        fd = accept(s->fd, (struct sockaddr *)&saddr, &len);
4368
        if (fd < 0 && errno != EINTR) {
4369
            return;
4370
        } else if (fd >= 0) {
4371
            break;
4372
        }
4373
    }
4374
    s1 = net_socket_fd_init(s->vlan, fd, 1);
4375
    if (!s1) {
4376
        closesocket(fd);
4377
    } else {
4378
        snprintf(s1->vc->info_str, sizeof(s1->vc->info_str),
4379
                 "socket: connection from %s:%d",
4380
                 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4381
    }
4382
}
4383

    
4384
static int net_socket_listen_init(VLANState *vlan, const char *host_str)
4385
{
4386
    NetSocketListenState *s;
4387
    int fd, val, ret;
4388
    struct sockaddr_in saddr;
4389

    
4390
    if (parse_host_port(&saddr, host_str) < 0)
4391
        return -1;
4392
   
4393
    s = qemu_mallocz(sizeof(NetSocketListenState));
4394
    if (!s)
4395
        return -1;
4396

    
4397
    fd = socket(PF_INET, SOCK_STREAM, 0);
4398
    if (fd < 0) {
4399
        perror("socket");
4400
        return -1;
4401
    }
4402
    socket_set_nonblock(fd);
4403

    
4404
    /* allow fast reuse */
4405
    val = 1;
4406
    setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
4407
   
4408
    ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
4409
    if (ret < 0) {
4410
        perror("bind");
4411
        return -1;
4412
    }
4413
    ret = listen(fd, 0);
4414
    if (ret < 0) {
4415
        perror("listen");
4416
        return -1;
4417
    }
4418
    s->vlan = vlan;
4419
    s->fd = fd;
4420
    qemu_set_fd_handler(fd, net_socket_accept, NULL, s);
4421
    return 0;
4422
}
4423

    
4424
static int net_socket_connect_init(VLANState *vlan, const char *host_str)
4425
{
4426
    NetSocketState *s;
4427
    int fd, connected, ret, err;
4428
    struct sockaddr_in saddr;
4429

    
4430
    if (parse_host_port(&saddr, host_str) < 0)
4431
        return -1;
4432

    
4433
    fd = socket(PF_INET, SOCK_STREAM, 0);
4434
    if (fd < 0) {
4435
        perror("socket");
4436
        return -1;
4437
    }
4438
    socket_set_nonblock(fd);
4439

    
4440
    connected = 0;
4441
    for(;;) {
4442
        ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
4443
        if (ret < 0) {
4444
            err = socket_error();
4445
            if (err == EINTR || err == EWOULDBLOCK) {
4446
            } else if (err == EINPROGRESS) {
4447
                break;
4448
#ifdef _WIN32
4449
            } else if (err == WSAEALREADY) {
4450
                break;
4451
#endif
4452
            } else {
4453
                perror("connect");
4454
                closesocket(fd);
4455
                return -1;
4456
            }
4457
        } else {
4458
            connected = 1;
4459
            break;
4460
        }
4461
    }
4462
    s = net_socket_fd_init(vlan, fd, connected);
4463
    if (!s)
4464
        return -1;
4465
    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4466
             "socket: connect to %s:%d",
4467
             inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4468
    return 0;
4469
}
4470

    
4471
static int net_socket_mcast_init(VLANState *vlan, const char *host_str)
4472
{
4473
    NetSocketState *s;
4474
    int fd;
4475
    struct sockaddr_in saddr;
4476

    
4477
    if (parse_host_port(&saddr, host_str) < 0)
4478
        return -1;
4479

    
4480

    
4481
    fd = net_socket_mcast_create(&saddr);
4482
    if (fd < 0)
4483
        return -1;
4484

    
4485
    s = net_socket_fd_init(vlan, fd, 0);
4486
    if (!s)
4487
        return -1;
4488

    
4489
    s->dgram_dst = saddr;
4490
   
4491
    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4492
             "socket: mcast=%s:%d",
4493
             inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4494
    return 0;
4495

    
4496
}
4497

    
4498
static int get_param_value(char *buf, int buf_size,
4499
                           const char *tag, const char *str)
4500
{
4501
    const char *p;
4502
    char *q;
4503
    char option[128];
4504

    
4505
    p = str;
4506
    for(;;) {
4507
        q = option;
4508
        while (*p != '\0' && *p != '=') {
4509
            if ((q - option) < sizeof(option) - 1)
4510
                *q++ = *p;
4511
            p++;
4512
        }
4513
        *q = '\0';
4514
        if (*p != '=')
4515
            break;
4516
        p++;
4517
        if (!strcmp(tag, option)) {
4518
            q = buf;
4519
            while (*p != '\0' && *p != ',') {
4520
                if ((q - buf) < buf_size - 1)
4521
                    *q++ = *p;
4522
                p++;
4523
            }
4524
            *q = '\0';
4525
            return q - buf;
4526
        } else {
4527
            while (*p != '\0' && *p != ',') {
4528
                p++;
4529
            }
4530
        }
4531
        if (*p != ',')
4532
            break;
4533
        p++;
4534
    }
4535
    return 0;
4536
}
4537

    
4538
static int net_client_init(const char *str)
4539
{
4540
    const char *p;
4541
    char *q;
4542
    char device[64];
4543
    char buf[1024];
4544
    int vlan_id, ret;
4545
    VLANState *vlan;
4546

    
4547
    p = str;
4548
    q = device;
4549
    while (*p != '\0' && *p != ',') {
4550
        if ((q - device) < sizeof(device) - 1)
4551
            *q++ = *p;
4552
        p++;
4553
    }
4554
    *q = '\0';
4555
    if (*p == ',')
4556
        p++;
4557
    vlan_id = 0;
4558
    if (get_param_value(buf, sizeof(buf), "vlan", p)) {
4559
        vlan_id = strtol(buf, NULL, 0);
4560
    }
4561
    vlan = qemu_find_vlan(vlan_id);
4562
    if (!vlan) {
4563
        fprintf(stderr, "Could not create vlan %d\n", vlan_id);
4564
        return -1;
4565
    }
4566
    if (!strcmp(device, "nic")) {
4567
        NICInfo *nd;
4568
        uint8_t *macaddr;
4569

    
4570
        if (nb_nics >= MAX_NICS) {
4571
            fprintf(stderr, "Too Many NICs\n");
4572
            return -1;
4573
        }
4574
        nd = &nd_table[nb_nics];
4575
        macaddr = nd->macaddr;
4576
        macaddr[0] = 0x52;
4577
        macaddr[1] = 0x54;
4578
        macaddr[2] = 0x00;
4579
        macaddr[3] = 0x12;
4580
        macaddr[4] = 0x34;
4581
        macaddr[5] = 0x56 + nb_nics;
4582

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

    
4673
void do_info_network(void)
4674
{
4675
    VLANState *vlan;
4676
    VLANClientState *vc;
4677

    
4678
    for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
4679
        term_printf("VLAN %d devices:\n", vlan->id);
4680
        for(vc = vlan->first_client; vc != NULL; vc = vc->next)
4681
            term_printf("  %s\n", vc->info_str);
4682
    }
4683
}
4684

    
4685
/***********************************************************/
4686
/* USB devices */
4687

    
4688
static USBPort *used_usb_ports;
4689
static USBPort *free_usb_ports;
4690

    
4691
/* ??? Maybe change this to register a hub to keep track of the topology.  */
4692
void qemu_register_usb_port(USBPort *port, void *opaque, int index,
4693
                            usb_attachfn attach)
4694
{
4695
    port->opaque = opaque;
4696
    port->index = index;
4697
    port->attach = attach;
4698
    port->next = free_usb_ports;
4699
    free_usb_ports = port;
4700
}
4701

    
4702
static int usb_device_add(const char *devname)
4703
{
4704
    const char *p;
4705
    USBDevice *dev;
4706
    USBPort *port;
4707

    
4708
    if (!free_usb_ports)
4709
        return -1;
4710

    
4711
    if (strstart(devname, "host:", &p)) {
4712
        dev = usb_host_device_open(p);
4713
    } else if (!strcmp(devname, "mouse")) {
4714
        dev = usb_mouse_init();
4715
    } else if (!strcmp(devname, "tablet")) {
4716
        dev = usb_tablet_init();
4717
    } else if (!strcmp(devname, "keyboard")) {
4718
        dev = usb_keyboard_init();
4719
    } else if (strstart(devname, "disk:", &p)) {
4720
        dev = usb_msd_init(p);
4721
    } else if (!strcmp(devname, "wacom-tablet")) {
4722
        dev = usb_wacom_init();
4723
    } else {
4724
        return -1;
4725
    }
4726
    if (!dev)
4727
        return -1;
4728

    
4729
    /* Find a USB port to add the device to.  */
4730
    port = free_usb_ports;
4731
    if (!port->next) {
4732
        USBDevice *hub;
4733

    
4734
        /* Create a new hub and chain it on.  */
4735
        free_usb_ports = NULL;
4736
        port->next = used_usb_ports;
4737
        used_usb_ports = port;
4738

    
4739
        hub = usb_hub_init(VM_USB_HUB_SIZE);
4740
        usb_attach(port, hub);
4741
        port = free_usb_ports;
4742
    }
4743

    
4744
    free_usb_ports = port->next;
4745
    port->next = used_usb_ports;
4746
    used_usb_ports = port;
4747
    usb_attach(port, dev);
4748
    return 0;
4749
}
4750

    
4751
static int usb_device_del(const char *devname)
4752
{
4753
    USBPort *port;
4754
    USBPort **lastp;
4755
    USBDevice *dev;
4756
    int bus_num, addr;
4757
    const char *p;
4758

    
4759
    if (!used_usb_ports)
4760
        return -1;
4761

    
4762
    p = strchr(devname, '.');
4763
    if (!p)
4764
        return -1;
4765
    bus_num = strtoul(devname, NULL, 0);
4766
    addr = strtoul(p + 1, NULL, 0);
4767
    if (bus_num != 0)
4768
        return -1;
4769

    
4770
    lastp = &used_usb_ports;
4771
    port = used_usb_ports;
4772
    while (port && port->dev->addr != addr) {
4773
        lastp = &port->next;
4774
        port = port->next;
4775
    }
4776

    
4777
    if (!port)
4778
        return -1;
4779

    
4780
    dev = port->dev;
4781
    *lastp = port->next;
4782
    usb_attach(port, NULL);
4783
    dev->handle_destroy(dev);
4784
    port->next = free_usb_ports;
4785
    free_usb_ports = port;
4786
    return 0;
4787
}
4788

    
4789
void do_usb_add(const char *devname)
4790
{
4791
    int ret;
4792
    ret = usb_device_add(devname);
4793
    if (ret < 0)
4794
        term_printf("Could not add USB device '%s'\n", devname);
4795
}
4796

    
4797
void do_usb_del(const char *devname)
4798
{
4799
    int ret;
4800
    ret = usb_device_del(devname);
4801
    if (ret < 0)
4802
        term_printf("Could not remove USB device '%s'\n", devname);
4803
}
4804

    
4805
void usb_info(void)
4806
{
4807
    USBDevice *dev;
4808
    USBPort *port;
4809
    const char *speed_str;
4810

    
4811
    if (!usb_enabled) {
4812
        term_printf("USB support not enabled\n");
4813
        return;
4814
    }
4815

    
4816
    for (port = used_usb_ports; port; port = port->next) {
4817
        dev = port->dev;
4818
        if (!dev)
4819
            continue;
4820
        switch(dev->speed) {
4821
        case USB_SPEED_LOW:
4822
            speed_str = "1.5";
4823
            break;
4824
        case USB_SPEED_FULL:
4825
            speed_str = "12";
4826
            break;
4827
        case USB_SPEED_HIGH:
4828
            speed_str = "480";
4829
            break;
4830
        default:
4831
            speed_str = "?";
4832
            break;
4833
        }
4834
        term_printf("  Device %d.%d, Speed %s Mb/s, Product %s\n",
4835
                    0, dev->addr, speed_str, dev->devname);
4836
    }
4837
}
4838

    
4839
/***********************************************************/
4840
/* PCMCIA/Cardbus */
4841

    
4842
static struct pcmcia_socket_entry_s {
4843
    struct pcmcia_socket_s *socket;
4844
    struct pcmcia_socket_entry_s *next;
4845
} *pcmcia_sockets = 0;
4846

    
4847
void pcmcia_socket_register(struct pcmcia_socket_s *socket)
4848
{
4849
    struct pcmcia_socket_entry_s *entry;
4850

    
4851
    entry = qemu_malloc(sizeof(struct pcmcia_socket_entry_s));
4852
    entry->socket = socket;
4853
    entry->next = pcmcia_sockets;
4854
    pcmcia_sockets = entry;
4855
}
4856

    
4857
void pcmcia_socket_unregister(struct pcmcia_socket_s *socket)
4858
{
4859
    struct pcmcia_socket_entry_s *entry, **ptr;
4860

    
4861
    ptr = &pcmcia_sockets;
4862
    for (entry = *ptr; entry; ptr = &entry->next, entry = *ptr)
4863
        if (entry->socket == socket) {
4864
            *ptr = entry->next;
4865
            qemu_free(entry);
4866
        }
4867
}
4868

    
4869
void pcmcia_info(void)
4870
{
4871
    struct pcmcia_socket_entry_s *iter;
4872
    if (!pcmcia_sockets)
4873
        term_printf("No PCMCIA sockets\n");
4874

    
4875
    for (iter = pcmcia_sockets; iter; iter = iter->next)
4876
        term_printf("%s: %s\n", iter->socket->slot_string,
4877
                    iter->socket->attached ? iter->socket->card_string :
4878
                    "Empty");
4879
}
4880

    
4881
/***********************************************************/
4882
/* dumb display */
4883

    
4884
static void dumb_update(DisplayState *ds, int x, int y, int w, int h)
4885
{
4886
}
4887

    
4888
static void dumb_resize(DisplayState *ds, int w, int h)
4889
{
4890
}
4891

    
4892
static void dumb_refresh(DisplayState *ds)
4893
{
4894
#if defined(CONFIG_SDL)
4895
    vga_hw_update();
4896
#endif
4897
}
4898

    
4899
static void dumb_display_init(DisplayState *ds)
4900
{
4901
    ds->data = NULL;
4902
    ds->linesize = 0;
4903
    ds->depth = 0;
4904
    ds->dpy_update = dumb_update;
4905
    ds->dpy_resize = dumb_resize;
4906
    ds->dpy_refresh = dumb_refresh;
4907
}
4908

    
4909
/***********************************************************/
4910
/* I/O handling */
4911

    
4912
#define MAX_IO_HANDLERS 64
4913

    
4914
typedef struct IOHandlerRecord {
4915
    int fd;
4916
    IOCanRWHandler *fd_read_poll;
4917
    IOHandler *fd_read;
4918
    IOHandler *fd_write;
4919
    int deleted;
4920
    void *opaque;
4921
    /* temporary data */
4922
    struct pollfd *ufd;
4923
    struct IOHandlerRecord *next;
4924
} IOHandlerRecord;
4925

    
4926
static IOHandlerRecord *first_io_handler;
4927

    
4928
/* XXX: fd_read_poll should be suppressed, but an API change is
4929
   necessary in the character devices to suppress fd_can_read(). */
4930
int qemu_set_fd_handler2(int fd,
4931
                         IOCanRWHandler *fd_read_poll,
4932
                         IOHandler *fd_read,
4933
                         IOHandler *fd_write,
4934
                         void *opaque)
4935
{
4936
    IOHandlerRecord **pioh, *ioh;
4937

    
4938
    if (!fd_read && !fd_write) {
4939
        pioh = &first_io_handler;
4940
        for(;;) {
4941
            ioh = *pioh;
4942
            if (ioh == NULL)
4943
                break;
4944
            if (ioh->fd == fd) {
4945
                ioh->deleted = 1;
4946
                break;
4947
            }
4948
            pioh = &ioh->next;
4949
        }
4950
    } else {
4951
        for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
4952
            if (ioh->fd == fd)
4953
                goto found;
4954
        }
4955
        ioh = qemu_mallocz(sizeof(IOHandlerRecord));
4956
        if (!ioh)
4957
            return -1;
4958
        ioh->next = first_io_handler;
4959
        first_io_handler = ioh;
4960
    found:
4961
        ioh->fd = fd;
4962
        ioh->fd_read_poll = fd_read_poll;
4963
        ioh->fd_read = fd_read;
4964
        ioh->fd_write = fd_write;
4965
        ioh->opaque = opaque;
4966
        ioh->deleted = 0;
4967
    }
4968
    return 0;
4969
}
4970

    
4971
int qemu_set_fd_handler(int fd,