vl.c

   1 /*
   2  * QEMU System Emulator
   3  *
   4  * Copyright (c) 2003-2008 Fabrice Bellard
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24 #include "hw/hw.h"
  25 #include "hw/boards.h"
  26 #include "hw/usb.h"
  27 #include "hw/pcmcia.h"
  28 #include "hw/pc.h"
  29 #include "hw/audiodev.h"
  30 #include "hw/isa.h"
  31 #include "hw/baum.h"
  32 #include "hw/bt.h"
  33 #include "net.h"
  34 #include "console.h"
  35 #include "sysemu.h"
  36 #include "gdbstub.h"
  37 #include "qemu-timer.h"
  38 #include "qemu-char.h"
  39 #include "block.h"
  40 #include "audio/audio.h"
  41
  42 #include <unistd.h>
  43 #include <fcntl.h>
  44 #include <signal.h>
  45 #include <time.h>
  46 #include <errno.h>
  47 #include <sys/time.h>
  48 #include <zlib.h>
  49
  50 #ifndef _WIN32
  51 #include <sys/times.h>
  52 #include <sys/wait.h>
  53 #include <termios.h>
  54 #include <sys/poll.h>
  55 #include <sys/mman.h>
  56 #include <sys/ioctl.h>
  57 #include <sys/socket.h>
  58 #include <netinet/in.h>
  59 #include <dirent.h>
  60 #include <netdb.h>
  61 #include <sys/select.h>
  62 #include <arpa/inet.h>
  63 #ifdef _BSD
  64 #include <sys/stat.h>
  65 #if !defined(__APPLE__) && !defined(__OpenBSD__)
  66 #include <libutil.h>
  67 #endif
  68 #ifdef __OpenBSD__
  69 #include <net/if.h>
  70 #endif
  71 #elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
  72 #include <freebsd/stdlib.h>
  73 #else
  74 #ifdef __linux__
  75 #include <linux/if.h>
  76 #include <linux/if_tun.h>
  77 #include <pty.h>
  78 #include <malloc.h>
  79 #include <linux/rtc.h>
  80
  81 /* For the benefit of older linux systems which don't supply it,
  82    we use a local copy of hpet.h. */
  83 /* #include <linux/hpet.h> */
  84 #include "hpet.h"
  85
  86 #include <linux/ppdev.h>
  87 #include <linux/parport.h>
  88 #endif
  89 #ifdef __sun__
  90 #include <sys/stat.h>
  91 #include <sys/ethernet.h>
  92 #include <sys/sockio.h>
  93 #include <netinet/arp.h>
  94 #include <netinet/in.h>
  95 #include <netinet/in_systm.h>
  96 #include <netinet/ip.h>
  97 #include <netinet/ip_icmp.h> // must come after ip.h
  98 #include <netinet/udp.h>
  99 #include <netinet/tcp.h>
 100 #include <net/if.h>
 101 #include <syslog.h>
 102 #include <stropts.h>
 103 #endif
 104 #endif
 105 #endif
 106
 107 #include "qemu_socket.h"
 108
 109 #if defined(CONFIG_SLIRP)
 110 #include "libslirp.h"
 111 #endif
 112
 113 #if defined(__OpenBSD__)
 114 #include <util.h>
 115 #endif
 116
 117 #if defined(CONFIG_VDE)
 118 #include <libvdeplug.h>
 119 #endif
 120
 121 #ifdef _WIN32
 122 #include <malloc.h>
 123 #include <sys/timeb.h>
 124 #include <mmsystem.h>
 125 #define getopt_long_only getopt_long
 126 #define memalign(align, size) malloc(size)
 127 #endif
 128
 129 #ifdef CONFIG_SDL
 130 #ifdef __APPLE__
 131 #include <SDL/SDL.h>
 132 #endif
 133 #endif /* CONFIG_SDL */
 134
 135 #ifdef CONFIG_COCOA
 136 #undef main
 137 #define main qemu_main
 138 #endif /* CONFIG_COCOA */
 139
 140 #include "disas.h"
 141
 142 #include "exec-all.h"
 143
 144 #define DEFAULT_NETWORK_SCRIPT "/etc/qemu-ifup"
 145 #define DEFAULT_NETWORK_DOWN_SCRIPT "/etc/qemu-ifdown"
 146 #ifdef __sun__
 147 #define SMBD_COMMAND "/usr/sfw/sbin/smbd"
 148 #else
 149 #define SMBD_COMMAND "/usr/sbin/smbd"
 150 #endif
 151
 152 //#define DEBUG_UNUSED_IOPORT
 153 //#define DEBUG_IOPORT
 154 //#define DEBUG_NET
 155 //#define DEBUG_SLIRP
 156
 157 #ifdef TARGET_PPC
 158 #define DEFAULT_RAM_SIZE 144
 159 #else
 160 #define DEFAULT_RAM_SIZE 128
 161 #endif
 162
 163 /* Max number of USB devices that can be specified on the commandline.  */
 164 #define MAX_USB_CMDLINE 8
 165
 166 /* XXX: use a two level table to limit memory usage */
 167 #define MAX_IOPORTS 65536
 168
 169 const char *bios_dir = CONFIG_QEMU_SHAREDIR;
 170 const char *bios_name = NULL;
 171 static void *ioport_opaque[MAX_IOPORTS];
 172 static IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS];
 173 static IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];
 174 /* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available
 175    to store the VM snapshots */
 176 DriveInfo drives_table[MAX_DRIVES+1];
 177 int nb_drives;
 178 /* point to the block driver where the snapshots are managed */
 179 static BlockDriverState *bs_snapshots;
 180 static int vga_ram_size;
 181 enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB;
 182 static DisplayState display_state;
 183 int nographic;
 184 static int curses;
 185 const char* keyboard_layout = NULL;
 186 int64_t ticks_per_sec;
 187 ram_addr_t ram_size;
 188 int nb_nics;
 189 NICInfo nd_table[MAX_NICS];
 190 int vm_running;
 191 static int rtc_utc = 1;
 192 static int rtc_date_offset = -1; /* -1 means no change */
 193 int cirrus_vga_enabled = 1;
 194 int vmsvga_enabled = 0;
 195 #ifdef TARGET_SPARC
 196 int graphic_width = 1024;
 197 int graphic_height = 768;
 198 int graphic_depth = 8;
 199 #else
 200 int graphic_width = 800;
 201 int graphic_height = 600;
 202 int graphic_depth = 15;
 203 #endif
 204 static int full_screen = 0;
 205 static int no_frame = 0;
 206 int no_quit = 0;
 207 CharDriverState *serial_hds[MAX_SERIAL_PORTS];
 208 CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
 209 #ifdef TARGET_I386
 210 int win2k_install_hack = 0;
 211 #endif
 212 int usb_enabled = 0;
 213 static VLANState *first_vlan;
 214 int smp_cpus = 1;
 215 const char *vnc_display;
 216 #if defined(TARGET_SPARC)
 217 #define MAX_CPUS 16
 218 #elif defined(TARGET_I386)
 219 #define MAX_CPUS 255
 220 #else
 221 #define MAX_CPUS 1
 222 #endif
 223 int acpi_enabled = 1;
 224 int fd_bootchk = 1;
 225 int no_reboot = 0;
 226 int no_shutdown = 0;
 227 int cursor_hide = 1;
 228 int graphic_rotate = 0;
 229 int daemonize = 0;
 230 const char *option_rom[MAX_OPTION_ROMS];
 231 int nb_option_roms;
 232 int semihosting_enabled = 0;
 233 #ifdef TARGET_ARM
 234 int old_param = 0;
 235 #endif
 236 const char *qemu_name;
 237 int alt_grab = 0;
 238 #ifdef TARGET_SPARC
 239 unsigned int nb_prom_envs = 0;
 240 const char *prom_envs[MAX_PROM_ENVS];
 241 #endif
 242 static int nb_drives_opt;
 243 static struct drive_opt {
 244     const char *file;
 245     char opt[1024];
 246 } drives_opt[MAX_DRIVES];
 247
 248 static CPUState *cur_cpu;
 249 static CPUState *next_cpu;
 250 static int event_pending = 1;
 251 /* Conversion factor from emulated instructions to virtual clock ticks.  */
 252 static int icount_time_shift;
 253 /* Arbitrarily pick 1MIPS as the minimum allowable speed.  */
 254 #define MAX_ICOUNT_SHIFT 10
 255 /* Compensate for varying guest execution speed.  */
 256 static int64_t qemu_icount_bias;
 257 static QEMUTimer *icount_rt_timer;
 258 static QEMUTimer *icount_vm_timer;
 259
 260 uint8_t qemu_uuid[16];
 261
 262 #define TFR(expr) do { if ((expr) != -1) break; } while (errno == EINTR)
 263
 264 /***********************************************************/
 265 /* x86 ISA bus support */
 266
 267 target_phys_addr_t isa_mem_base = 0;
 268 PicState2 *isa_pic;
 269
 270 static IOPortReadFunc default_ioport_readb, default_ioport_readw, default_ioport_readl;
 271 static IOPortWriteFunc default_ioport_writeb, default_ioport_writew, default_ioport_writel;
 272
 273 static uint32_t ioport_read(int index, uint32_t address)
 274 {
 275     static IOPortReadFunc *default_func[3] = {
 276         default_ioport_readb,
 277         default_ioport_readw,
 278         default_ioport_readl
 279     };
 280     IOPortReadFunc *func = ioport_read_table[index][address];
 281     if (!func)
 282         func = default_func[index];
 283     return func(ioport_opaque[address], address);
 284 }
 285
 286 static void ioport_write(int index, uint32_t address, uint32_t data)
 287 {
 288     static IOPortWriteFunc *default_func[3] = {
 289         default_ioport_writeb,
 290         default_ioport_writew,
 291         default_ioport_writel
 292     };
 293     IOPortWriteFunc *func = ioport_write_table[index][address];
 294     if (!func)
 295         func = default_func[index];
 296     func(ioport_opaque[address], address, data);
 297 }
 298
 299 static uint32_t default_ioport_readb(void *opaque, uint32_t address)
 300 {
 301 #ifdef DEBUG_UNUSED_IOPORT
 302     fprintf(stderr, "unused inb: port=0x%04x\n", address);
 303 #endif
 304     return 0xff;
 305 }
 306
 307 static void default_ioport_writeb(void *opaque, uint32_t address, uint32_t data)
 308 {
 309 #ifdef DEBUG_UNUSED_IOPORT
 310     fprintf(stderr, "unused outb: port=0x%04x data=0x%02x\n", address, data);
 311 #endif
 312 }
 313
 314 /* default is to make two byte accesses */
 315 static uint32_t default_ioport_readw(void *opaque, uint32_t address)
 316 {
 317     uint32_t data;
 318     data = ioport_read(0, address);
 319     address = (address + 1) & (MAX_IOPORTS - 1);
 320     data |= ioport_read(0, address) << 8;
 321     return data;
 322 }
 323
 324 static void default_ioport_writew(void *opaque, uint32_t address, uint32_t data)
 325 {
 326     ioport_write(0, address, data & 0xff);
 327     address = (address + 1) & (MAX_IOPORTS - 1);
 328     ioport_write(0, address, (data >> 8) & 0xff);
 329 }
 330
 331 static uint32_t default_ioport_readl(void *opaque, uint32_t address)
 332 {
 333 #ifdef DEBUG_UNUSED_IOPORT
 334     fprintf(stderr, "unused inl: port=0x%04x\n", address);
 335 #endif
 336     return 0xffffffff;
 337 }
 338
 339 static void default_ioport_writel(void *opaque, uint32_t address, uint32_t data)
 340 {
 341 #ifdef DEBUG_UNUSED_IOPORT
 342     fprintf(stderr, "unused outl: port=0x%04x data=0x%02x\n", address, data);
 343 #endif
 344 }
 345
 346 /* size is the word size in byte */
 347 int register_ioport_read(int start, int length, int size,
 348                          IOPortReadFunc *func, void *opaque)
 349 {
 350     int i, bsize;
 351
 352     if (size == 1) {
 353         bsize = 0;
 354     } else if (size == 2) {
 355         bsize = 1;
 356     } else if (size == 4) {
 357         bsize = 2;
 358     } else {
 359         hw_error("register_ioport_read: invalid size");
 360         return -1;
 361     }
 362     for(i = start; i < start + length; i += size) {
 363         ioport_read_table[bsize][i] = func;
 364         if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
 365             hw_error("register_ioport_read: invalid opaque");
 366         ioport_opaque[i] = opaque;
 367     }
 368     return 0;
 369 }
 370
 371 /* size is the word size in byte */
 372 int register_ioport_write(int start, int length, int size,
 373                           IOPortWriteFunc *func, void *opaque)
 374 {
 375     int i, bsize;
 376
 377     if (size == 1) {
 378         bsize = 0;
 379     } else if (size == 2) {
 380         bsize = 1;
 381     } else if (size == 4) {
 382         bsize = 2;
 383     } else {
 384         hw_error("register_ioport_write: invalid size");
 385         return -1;
 386     }
 387     for(i = start; i < start + length; i += size) {
 388         ioport_write_table[bsize][i] = func;
 389         if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
 390             hw_error("register_ioport_write: invalid opaque");
 391         ioport_opaque[i] = opaque;
 392     }
 393     return 0;
 394 }
 395
 396 void isa_unassign_ioport(int start, int length)
 397 {
 398     int i;
 399
 400     for(i = start; i < start + length; i++) {
 401         ioport_read_table[0][i] = default_ioport_readb;
 402         ioport_read_table[1][i] = default_ioport_readw;
 403         ioport_read_table[2][i] = default_ioport_readl;
 404
 405         ioport_write_table[0][i] = default_ioport_writeb;
 406         ioport_write_table[1][i] = default_ioport_writew;
 407         ioport_write_table[2][i] = default_ioport_writel;
 408     }
 409 }
 410
 411 /***********************************************************/
 412
 413 void cpu_outb(CPUState *env, int addr, int val)
 414 {
 415 #ifdef DEBUG_IOPORT
 416     if (loglevel & CPU_LOG_IOPORT)
 417         fprintf(logfile, "outb: %04x %02x\n", addr, val);
 418 #endif
 419     ioport_write(0, addr, val);
 420 #ifdef USE_KQEMU
 421     if (env)
 422         env->last_io_time = cpu_get_time_fast();
 423 #endif
 424 }
 425
 426 void cpu_outw(CPUState *env, int addr, int val)
 427 {
 428 #ifdef DEBUG_IOPORT
 429     if (loglevel & CPU_LOG_IOPORT)
 430         fprintf(logfile, "outw: %04x %04x\n", addr, val);
 431 #endif
 432     ioport_write(1, addr, val);
 433 #ifdef USE_KQEMU
 434     if (env)
 435         env->last_io_time = cpu_get_time_fast();
 436 #endif
 437 }
 438
 439 void cpu_outl(CPUState *env, int addr, int val)
 440 {
 441 #ifdef DEBUG_IOPORT
 442     if (loglevel & CPU_LOG_IOPORT)
 443         fprintf(logfile, "outl: %04x %08x\n", addr, val);
 444 #endif
 445     ioport_write(2, addr, val);
 446 #ifdef USE_KQEMU
 447     if (env)
 448         env->last_io_time = cpu_get_time_fast();
 449 #endif
 450 }
 451
 452 int cpu_inb(CPUState *env, int addr)
 453 {
 454     int val;
 455     val = ioport_read(0, addr);
 456 #ifdef DEBUG_IOPORT
 457     if (loglevel & CPU_LOG_IOPORT)
 458         fprintf(logfile, "inb : %04x %02x\n", addr, val);
 459 #endif
 460 #ifdef USE_KQEMU
 461     if (env)
 462         env->last_io_time = cpu_get_time_fast();
 463 #endif
 464     return val;
 465 }
 466
 467 int cpu_inw(CPUState *env, int addr)
 468 {
 469     int val;
 470     val = ioport_read(1, addr);
 471 #ifdef DEBUG_IOPORT
 472     if (loglevel & CPU_LOG_IOPORT)
 473         fprintf(logfile, "inw : %04x %04x\n", addr, val);
 474 #endif
 475 #ifdef USE_KQEMU
 476     if (env)
 477         env->last_io_time = cpu_get_time_fast();
 478 #endif
 479     return val;
 480 }
 481
 482 int cpu_inl(CPUState *env, int addr)
 483 {
 484     int val;
 485     val = ioport_read(2, addr);
 486 #ifdef DEBUG_IOPORT
 487     if (loglevel & CPU_LOG_IOPORT)
 488         fprintf(logfile, "inl : %04x %08x\n", addr, val);
 489 #endif
 490 #ifdef USE_KQEMU
 491     if (env)
 492         env->last_io_time = cpu_get_time_fast();
 493 #endif
 494     return val;
 495 }
 496
 497 /***********************************************************/
 498 void hw_error(const char *fmt, ...)
 499 {
 500     va_list ap;
 501     CPUState *env;
 502
 503     va_start(ap, fmt);
 504     fprintf(stderr, "qemu: hardware error: ");
 505     vfprintf(stderr, fmt, ap);
 506     fprintf(stderr, "\n");
 507     for(env = first_cpu; env != NULL; env = env->next_cpu) {
 508         fprintf(stderr, "CPU #%d:\n", env->cpu_index);
 509 #ifdef TARGET_I386
 510         cpu_dump_state(env, stderr, fprintf, X86_DUMP_FPU);
 511 #else
 512         cpu_dump_state(env, stderr, fprintf, 0);
 513 #endif
 514     }
 515     va_end(ap);
 516     abort();
 517 }
 518
 519 /***********************************************************/
 520 /* keyboard/mouse */
 521
 522 static QEMUPutKBDEvent *qemu_put_kbd_event;
 523 static void *qemu_put_kbd_event_opaque;
 524 static QEMUPutMouseEntry *qemu_put_mouse_event_head;
 525 static QEMUPutMouseEntry *qemu_put_mouse_event_current;
 526
 527 void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque)
 528 {
 529     qemu_put_kbd_event_opaque = opaque;
 530     qemu_put_kbd_event = func;
 531 }
 532
 533 QEMUPutMouseEntry *qemu_add_mouse_event_handler(QEMUPutMouseEvent *func,
 534                                                 void *opaque, int absolute,
 535                                                 const char *name)
 536 {
 537     QEMUPutMouseEntry *s, *cursor;
 538
 539     s = qemu_mallocz(sizeof(QEMUPutMouseEntry));
 540     if (!s)
 541         return NULL;
 542
 543     s->qemu_put_mouse_event = func;
 544     s->qemu_put_mouse_event_opaque = opaque;
 545     s->qemu_put_mouse_event_absolute = absolute;
 546     s->qemu_put_mouse_event_name = qemu_strdup(name);
 547     s->next = NULL;
 548
 549     if (!qemu_put_mouse_event_head) {
 550         qemu_put_mouse_event_head = qemu_put_mouse_event_current = s;
 551         return s;
 552     }
 553
 554     cursor = qemu_put_mouse_event_head;
 555     while (cursor->next != NULL)
 556         cursor = cursor->next;
 557
 558     cursor->next = s;
 559     qemu_put_mouse_event_current = s;
 560
 561     return s;
 562 }
 563
 564 void qemu_remove_mouse_event_handler(QEMUPutMouseEntry *entry)
 565 {
 566     QEMUPutMouseEntry *prev = NULL, *cursor;
 567
 568     if (!qemu_put_mouse_event_head || entry == NULL)
 569         return;
 570
 571     cursor = qemu_put_mouse_event_head;
 572     while (cursor != NULL && cursor != entry) {
 573         prev = cursor;
 574         cursor = cursor->next;
 575     }
 576
 577     if (cursor == NULL) // does not exist or list empty
 578         return;
 579     else if (prev == NULL) { // entry is head
 580         qemu_put_mouse_event_head = cursor->next;
 581         if (qemu_put_mouse_event_current == entry)
 582             qemu_put_mouse_event_current = cursor->next;
 583         qemu_free(entry->qemu_put_mouse_event_name);
 584         qemu_free(entry);
 585         return;
 586     }
 587
 588     prev->next = entry->next;
 589
 590     if (qemu_put_mouse_event_current == entry)
 591         qemu_put_mouse_event_current = prev;
 592
 593     qemu_free(entry->qemu_put_mouse_event_name);
 594     qemu_free(entry);
 595 }
 596
 597 void kbd_put_keycode(int keycode)
 598 {
 599     if (qemu_put_kbd_event) {
 600         qemu_put_kbd_event(qemu_put_kbd_event_opaque, keycode);
 601     }
 602 }
 603
 604 void kbd_mouse_event(int dx, int dy, int dz, int buttons_state)
 605 {
 606     QEMUPutMouseEvent *mouse_event;
 607     void *mouse_event_opaque;
 608     int width;
 609
 610     if (!qemu_put_mouse_event_current) {
 611         return;
 612     }
 613
 614     mouse_event =
 615         qemu_put_mouse_event_current->qemu_put_mouse_event;
 616     mouse_event_opaque =
 617         qemu_put_mouse_event_current->qemu_put_mouse_event_opaque;
 618
 619     if (mouse_event) {
 620         if (graphic_rotate) {
 621             if (qemu_put_mouse_event_current->qemu_put_mouse_event_absolute)
 622                 width = 0x7fff;
 623             else
 624                 width = graphic_width - 1;
 625             mouse_event(mouse_event_opaque,
 626                                  width - dy, dx, dz, buttons_state);
 627         } else
 628             mouse_event(mouse_event_opaque,
 629                                  dx, dy, dz, buttons_state);
 630     }
 631 }
 632
 633 int kbd_mouse_is_absolute(void)
 634 {
 635     if (!qemu_put_mouse_event_current)
 636         return 0;
 637
 638     return qemu_put_mouse_event_current->qemu_put_mouse_event_absolute;
 639 }
 640
 641 void do_info_mice(void)
 642 {
 643     QEMUPutMouseEntry *cursor;
 644     int index = 0;
 645
 646     if (!qemu_put_mouse_event_head) {
 647         term_printf("No mouse devices connected\n");
 648         return;
 649     }
 650
 651     term_printf("Mouse devices available:\n");
 652     cursor = qemu_put_mouse_event_head;
 653     while (cursor != NULL) {
 654         term_printf("%c Mouse #%d: %s\n",
 655                     (cursor == qemu_put_mouse_event_current ? '*' : ' '),
 656                     index, cursor->qemu_put_mouse_event_name);
 657         index++;
 658         cursor = cursor->next;
 659     }
 660 }
 661
 662 void do_mouse_set(int index)
 663 {
 664     QEMUPutMouseEntry *cursor;
 665     int i = 0;
 666
 667     if (!qemu_put_mouse_event_head) {
 668         term_printf("No mouse devices connected\n");
 669         return;
 670     }
 671
 672     cursor = qemu_put_mouse_event_head;
 673     while (cursor != NULL && index != i) {
 674         i++;
 675         cursor = cursor->next;
 676     }
 677
 678     if (cursor != NULL)
 679         qemu_put_mouse_event_current = cursor;
 680     else
 681         term_printf("Mouse at given index not found\n");
 682 }
 683
 684 /* compute with 96 bit intermediate result: (a*b)/c */
 685 uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
 686 {
 687     union {
 688         uint64_t ll;
 689         struct {
 690 #ifdef WORDS_BIGENDIAN
 691             uint32_t high, low;
 692 #else
 693             uint32_t low, high;
 694 #endif
 695         } l;
 696     } u, res;
 697     uint64_t rl, rh;
 698
 699     u.ll = a;
 700     rl = (uint64_t)u.l.low * (uint64_t)b;
 701     rh = (uint64_t)u.l.high * (uint64_t)b;
 702     rh += (rl >> 32);
 703     res.l.high = rh / c;
 704     res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
 705     return res.ll;
 706 }
 707
 708 /***********************************************************/
 709 /* real time host monotonic timer */
 710
 711 #define QEMU_TIMER_BASE 1000000000LL
 712
 713 #ifdef WIN32
 714
 715 static int64_t clock_freq;
 716
 717 static void init_get_clock(void)
 718 {
 719     LARGE_INTEGER freq;
 720     int ret;
 721     ret = QueryPerformanceFrequency(&freq);
 722     if (ret == 0) {
 723         fprintf(stderr, "Could not calibrate ticks\n");
 724         exit(1);
 725     }
 726     clock_freq = freq.QuadPart;
 727 }
 728
 729 static int64_t get_clock(void)
 730 {
 731     LARGE_INTEGER ti;
 732     QueryPerformanceCounter(&ti);
 733     return muldiv64(ti.QuadPart, QEMU_TIMER_BASE, clock_freq);
 734 }
 735
 736 #else
 737
 738 static int use_rt_clock;
 739
 740 static void init_get_clock(void)
 741 {
 742     use_rt_clock = 0;
 743 #if defined(__linux__)
 744     {
 745         struct timespec ts;
 746         if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
 747             use_rt_clock = 1;
 748         }
 749     }
 750 #endif
 751 }
 752
 753 static int64_t get_clock(void)
 754 {
 755 #if defined(__linux__)
 756     if (use_rt_clock) {
 757         struct timespec ts;
 758         clock_gettime(CLOCK_MONOTONIC, &ts);
 759         return ts.tv_sec * 1000000000LL + ts.tv_nsec;
 760     } else
 761 #endif
 762     {
 763         /* XXX: using gettimeofday leads to problems if the date
 764            changes, so it should be avoided. */
 765         struct timeval tv;
 766         gettimeofday(&tv, NULL);
 767         return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
 768     }
 769 }
 770 #endif
 771
 772 /* Return the virtual CPU time, based on the instruction counter.  */
 773 static int64_t cpu_get_icount(void)
 774 {
 775     int64_t icount;
 776     CPUState *env = cpu_single_env;;
 777     icount = qemu_icount;
 778     if (env) {
 779         if (!can_do_io(env))
 780             fprintf(stderr, "Bad clock read\n");
 781         icount -= (env->icount_decr.u16.low + env->icount_extra);
 782     }
 783     return qemu_icount_bias + (icount << icount_time_shift);
 784 }
 785
 786 /***********************************************************/
 787 /* guest cycle counter */
 788
 789 static int64_t cpu_ticks_prev;
 790 static int64_t cpu_ticks_offset;
 791 static int64_t cpu_clock_offset;
 792 static int cpu_ticks_enabled;
 793
 794 /* return the host CPU cycle counter and handle stop/restart */
 795 int64_t cpu_get_ticks(void)
 796 {
 797     if (use_icount) {
 798         return cpu_get_icount();
 799     }
 800     if (!cpu_ticks_enabled) {
 801         return cpu_ticks_offset;
 802     } else {
 803         int64_t ticks;
 804         ticks = cpu_get_real_ticks();
 805         if (cpu_ticks_prev > ticks) {
 806             /* Note: non increasing ticks may happen if the host uses
 807                software suspend */
 808             cpu_ticks_offset += cpu_ticks_prev - ticks;
 809         }
 810         cpu_ticks_prev = ticks;
 811         return ticks + cpu_ticks_offset;
 812     }
 813 }
 814
 815 /* return the host CPU monotonic timer and handle stop/restart */
 816 static int64_t cpu_get_clock(void)
 817 {
 818     int64_t ti;
 819     if (!cpu_ticks_enabled) {
 820         return cpu_clock_offset;
 821     } else {
 822         ti = get_clock();
 823         return ti + cpu_clock_offset;
 824     }
 825 }
 826
 827 /* enable cpu_get_ticks() */
 828 void cpu_enable_ticks(void)
 829 {
 830     if (!cpu_ticks_enabled) {
 831         cpu_ticks_offset -= cpu_get_real_ticks();
 832         cpu_clock_offset -= get_clock();
 833         cpu_ticks_enabled = 1;
 834     }
 835 }
 836
 837 /* disable cpu_get_ticks() : the clock is stopped. You must not call
 838    cpu_get_ticks() after that.  */
 839 void cpu_disable_ticks(void)
 840 {
 841     if (cpu_ticks_enabled) {
 842         cpu_ticks_offset = cpu_get_ticks();
 843         cpu_clock_offset = cpu_get_clock();
 844         cpu_ticks_enabled = 0;
 845     }
 846 }
 847
 848 /***********************************************************/
 849 /* timers */
 850
 851 #define QEMU_TIMER_REALTIME 0
 852 #define QEMU_TIMER_VIRTUAL  1
 853
 854 struct QEMUClock {
 855     int type;
 856     /* XXX: add frequency */
 857 };
 858
 859 struct QEMUTimer {
 860     QEMUClock *clock;
 861     int64_t expire_time;
 862     QEMUTimerCB *cb;
 863     void *opaque;
 864     struct QEMUTimer *next;
 865 };
 866
 867 struct qemu_alarm_timer {
 868     char const *name;
 869     unsigned int flags;
 870
 871     int (*start)(struct qemu_alarm_timer *t);
 872     void (*stop)(struct qemu_alarm_timer *t);
 873     void (*rearm)(struct qemu_alarm_timer *t);
 874     void *priv;
 875 };
 876
 877 #define ALARM_FLAG_DYNTICKS  0x1
 878 #define ALARM_FLAG_EXPIRED   0x2
 879
 880 static inline int alarm_has_dynticks(struct qemu_alarm_timer *t)
 881 {
 882     return t->flags & ALARM_FLAG_DYNTICKS;
 883 }
 884
 885 static void qemu_rearm_alarm_timer(struct qemu_alarm_timer *t)
 886 {
 887     if (!alarm_has_dynticks(t))
 888         return;
 889
 890     t->rearm(t);
 891 }
 892
 893 /* TODO: MIN_TIMER_REARM_US should be optimized */
 894 #define MIN_TIMER_REARM_US 250
 895
 896 static struct qemu_alarm_timer *alarm_timer;
 897
 898 #ifdef _WIN32
 899
 900 struct qemu_alarm_win32 {
 901     MMRESULT timerId;
 902     HANDLE host_alarm;
 903     unsigned int period;
 904 } alarm_win32_data = {0, NULL, -1};
 905
 906 static int win32_start_timer(struct qemu_alarm_timer *t);
 907 static void win32_stop_timer(struct qemu_alarm_timer *t);
 908 static void win32_rearm_timer(struct qemu_alarm_timer *t);
 909
 910 #else
 911
 912 static int unix_start_timer(struct qemu_alarm_timer *t);
 913 static void unix_stop_timer(struct qemu_alarm_timer *t);
 914
 915 #ifdef __linux__
 916
 917 static int dynticks_start_timer(struct qemu_alarm_timer *t);
 918 static void dynticks_stop_timer(struct qemu_alarm_timer *t);
 919 static void dynticks_rearm_timer(struct qemu_alarm_timer *t);
 920
 921 static int hpet_start_timer(struct qemu_alarm_timer *t);
 922 static void hpet_stop_timer(struct qemu_alarm_timer *t);
 923
 924 static int rtc_start_timer(struct qemu_alarm_timer *t);
 925 static void rtc_stop_timer(struct qemu_alarm_timer *t);
 926
 927 #endif /* __linux__ */
 928
 929 #endif /* _WIN32 */
 930
 931 /* Correlation between real and virtual time is always going to be
 932    fairly approximate, so ignore small variation.
 933    When the guest is idle real and virtual time will be aligned in
 934    the IO wait loop.  */
 935 #define ICOUNT_WOBBLE (QEMU_TIMER_BASE / 10)
 936
 937 static void icount_adjust(void)
 938 {
 939     int64_t cur_time;
 940     int64_t cur_icount;
 941     int64_t delta;
 942     static int64_t last_delta;
 943     /* If the VM is not running, then do nothing.  */
 944     if (!vm_running)
 945         return;
 946
 947     cur_time = cpu_get_clock();
 948     cur_icount = qemu_get_clock(vm_clock);
 949     delta = cur_icount - cur_time;
 950     /* FIXME: This is a very crude algorithm, somewhat prone to oscillation.  */
 951     if (delta > 0
 952         && last_delta + ICOUNT_WOBBLE < delta * 2
 953         && icount_time_shift > 0) {
 954         /* The guest is getting too far ahead.  Slow time down.  */
 955         icount_time_shift--;
 956     }
 957     if (delta < 0
 958         && last_delta - ICOUNT_WOBBLE > delta * 2
 959         && icount_time_shift < MAX_ICOUNT_SHIFT) {
 960         /* The guest is getting too far behind.  Speed time up.  */
 961         icount_time_shift++;
 962     }
 963     last_delta = delta;
 964     qemu_icount_bias = cur_icount - (qemu_icount << icount_time_shift);
 965 }
 966
 967 static void icount_adjust_rt(void * opaque)
 968 {
 969     qemu_mod_timer(icount_rt_timer,
 970                    qemu_get_clock(rt_clock) + 1000);
 971     icount_adjust();
 972 }
 973
 974 static void icount_adjust_vm(void * opaque)
 975 {
 976     qemu_mod_timer(icount_vm_timer,
 977                    qemu_get_clock(vm_clock) + QEMU_TIMER_BASE / 10);
 978     icount_adjust();
 979 }
 980
 981 static void init_icount_adjust(void)
 982 {
 983     /* Have both realtime and virtual time triggers for speed adjustment.
 984        The realtime trigger catches emulated time passing too slowly,
 985        the virtual time trigger catches emulated time passing too fast.
 986        Realtime triggers occur even when idle, so use them less frequently
 987        than VM triggers.  */
 988     icount_rt_timer = qemu_new_timer(rt_clock, icount_adjust_rt, NULL);
 989     qemu_mod_timer(icount_rt_timer,
 990                    qemu_get_clock(rt_clock) + 1000);
 991     icount_vm_timer = qemu_new_timer(vm_clock, icount_adjust_vm, NULL);
 992     qemu_mod_timer(icount_vm_timer,
 993                    qemu_get_clock(vm_clock) + QEMU_TIMER_BASE / 10);
 994 }
 995
 996 static struct qemu_alarm_timer alarm_timers[] = {
 997 #ifndef _WIN32
 998 #ifdef __linux__
 999     {"dynticks", ALARM_FLAG_DYNTICKS, dynticks_start_timer,
1000      dynticks_stop_timer, dynticks_rearm_timer, NULL},
1001     /* HPET - if available - is preferred */
1002     {"hpet", 0, hpet_start_timer, hpet_stop_timer, NULL, NULL},
1003     /* ...otherwise try RTC */
1004     {"rtc", 0, rtc_start_timer, rtc_stop_timer, NULL, NULL},
1005 #endif
1006     {"unix", 0, unix_start_timer, unix_stop_timer, NULL, NULL},
1007 #else
1008     {"dynticks", ALARM_FLAG_DYNTICKS, win32_start_timer,
1009      win32_stop_timer, win32_rearm_timer, &alarm_win32_data},
1010     {"win32", 0, win32_start_timer,
1011      win32_stop_timer, NULL, &alarm_win32_data},
1012 #endif
1013     {NULL, }
1014 };
1015
1016 static void show_available_alarms(void)
1017 {
1018     int i;
1019
1020     printf("Available alarm timers, in order of precedence:\n");
1021     for (i = 0; alarm_timers[i].name; i++)
1022         printf("%s\n", alarm_timers[i].name);
1023 }
1024
1025 static void configure_alarms(char const *opt)
1026 {
1027     int i;
1028     int cur = 0;
1029     int count = (sizeof(alarm_timers) / sizeof(*alarm_timers)) - 1;
1030     char *arg;
1031     char *name;
1032     struct qemu_alarm_timer tmp;
1033
1034     if (!strcmp(opt, "?")) {
1035         show_available_alarms();
1036         exit(0);
1037     }
1038
1039     arg = strdup(opt);
1040
1041     /* Reorder the array */
1042     name = strtok(arg, ",");
1043     while (name) {
1044         for (i = 0; i < count && alarm_timers[i].name; i++) {
1045             if (!strcmp(alarm_timers[i].name, name))
1046                 break;
1047         }
1048
1049         if (i == count) {
1050             fprintf(stderr, "Unknown clock %s\n", name);
1051             goto next;
1052         }
1053
1054         if (i < cur)
1055             /* Ignore */
1056             goto next;
1057
1058         /* Swap */
1059         tmp = alarm_timers[i];
1060         alarm_timers[i] = alarm_timers[cur];
1061         alarm_timers[cur] = tmp;
1062
1063         cur++;
1064 next:
1065         name = strtok(NULL, ",");
1066     }
1067
1068     free(arg);
1069
1070     if (cur) {
1071         /* Disable remaining timers */
1072         for (i = cur; i < count; i++)
1073             alarm_timers[i].name = NULL;
1074     } else {
1075         show_available_alarms();
1076         exit(1);
1077     }
1078 }
1079
1080 QEMUClock *rt_clock;
1081 QEMUClock *vm_clock;
1082
1083 static QEMUTimer *active_timers[2];
1084
1085 static QEMUClock *qemu_new_clock(int type)
1086 {
1087     QEMUClock *clock;
1088     clock = qemu_mallocz(sizeof(QEMUClock));
1089     if (!clock)
1090         return NULL;
1091     clock->type = type;
1092     return clock;
1093 }
1094
1095 QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque)
1096 {
1097     QEMUTimer *ts;
1098
1099     ts = qemu_mallocz(sizeof(QEMUTimer));
1100     ts->clock = clock;
1101     ts->cb = cb;
1102     ts->opaque = opaque;
1103     return ts;
1104 }
1105
1106 void qemu_free_timer(QEMUTimer *ts)
1107 {
1108     qemu_free(ts);
1109 }
1110
1111 /* stop a timer, but do not dealloc it */
1112 void qemu_del_timer(QEMUTimer *ts)
1113 {
1114     QEMUTimer **pt, *t;
1115
1116     /* NOTE: this code must be signal safe because
1117        qemu_timer_expired() can be called from a signal. */
1118     pt = &active_timers[ts->clock->type];
1119     for(;;) {
1120         t = *pt;
1121         if (!t)
1122             break;
1123         if (t == ts) {
1124             *pt = t->next;
1125             break;
1126         }
1127         pt = &t->next;
1128     }
1129 }
1130
1131 /* modify the current timer so that it will be fired when current_time
1132    >= expire_time. The corresponding callback will be called. */
1133 void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
1134 {
1135     QEMUTimer **pt, *t;
1136
1137     qemu_del_timer(ts);
1138
1139     /* add the timer in the sorted list */
1140     /* NOTE: this code must be signal safe because
1141        qemu_timer_expired() can be called from a signal. */
1142     pt = &active_timers[ts->clock->type];
1143     for(;;) {
1144         t = *pt;
1145         if (!t)
1146             break;
1147         if (t->expire_time > expire_time)
1148             break;
1149         pt = &t->next;
1150     }
1151     ts->expire_time = expire_time;
1152     ts->next = *pt;
1153     *pt = ts;
1154
1155     /* Rearm if necessary  */
1156     if (pt == &active_timers[ts->clock->type]) {
1157         if ((alarm_timer->flags & ALARM_FLAG_EXPIRED) == 0) {
1158             qemu_rearm_alarm_timer(alarm_timer);
1159         }
1160         /* Interrupt execution to force deadline recalculation.  */
1161         if (use_icount && cpu_single_env) {
1162             cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
1163         }
1164     }
1165 }
1166
1167 int qemu_timer_pending(QEMUTimer *ts)
1168 {
1169     QEMUTimer *t;
1170     for(t = active_timers[ts->clock->type]; t != NULL; t = t->next) {
1171         if (t == ts)
1172             return 1;
1173     }
1174     return 0;
1175 }
1176
1177 static inline int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
1178 {
1179     if (!timer_head)
1180         return 0;
1181     return (timer_head->expire_time <= current_time);
1182 }
1183
1184 static void qemu_run_timers(QEMUTimer **ptimer_head, int64_t current_time)
1185 {
1186     QEMUTimer *ts;
1187
1188     for(;;) {
1189         ts = *ptimer_head;
1190         if (!ts || ts->expire_time > current_time)
1191             break;
1192         /* remove timer from the list before calling the callback */
1193         *ptimer_head = ts->next;
1194         ts->next = NULL;
1195
1196         /* run the callback (the timer list can be modified) */
1197         ts->cb(ts->opaque);
1198     }
1199 }
1200
1201 int64_t qemu_get_clock(QEMUClock *clock)
1202 {
1203     switch(clock->type) {
1204     case QEMU_TIMER_REALTIME:
1205         return get_clock() / 1000000;
1206     default:
1207     case QEMU_TIMER_VIRTUAL:
1208         if (use_icount) {
1209             return cpu_get_icount();
1210         } else {
1211             return cpu_get_clock();
1212         }
1213     }
1214 }
1215
1216 static void init_timers(void)
1217 {
1218     init_get_clock();
1219     ticks_per_sec = QEMU_TIMER_BASE;
1220     rt_clock = qemu_new_clock(QEMU_TIMER_REALTIME);
1221     vm_clock = qemu_new_clock(QEMU_TIMER_VIRTUAL);
1222 }
1223
1224 /* save a timer */
1225 void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
1226 {
1227     uint64_t expire_time;
1228
1229     if (qemu_timer_pending(ts)) {
1230         expire_time = ts->expire_time;
1231     } else {
1232         expire_time = -1;
1233     }
1234     qemu_put_be64(f, expire_time);
1235 }
1236
1237 void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
1238 {
1239     uint64_t expire_time;
1240
1241     expire_time = qemu_get_be64(f);
1242     if (expire_time != -1) {
1243         qemu_mod_timer(ts, expire_time);
1244     } else {
1245         qemu_del_timer(ts);
1246     }
1247 }
1248
1249 static void timer_save(QEMUFile *f, void *opaque)
1250 {
1251     if (cpu_ticks_enabled) {
1252         hw_error("cannot save state if virtual timers are running");
1253     }
1254     qemu_put_be64(f, cpu_ticks_offset);
1255     qemu_put_be64(f, ticks_per_sec);
1256     qemu_put_be64(f, cpu_clock_offset);
1257 }
1258
1259 static int timer_load(QEMUFile *f, void *opaque, int version_id)
1260 {
1261     if (version_id != 1 && version_id != 2)
1262         return -EINVAL;
1263     if (cpu_ticks_enabled) {
1264         return -EINVAL;
1265     }
1266     cpu_ticks_offset=qemu_get_be64(f);
1267     ticks_per_sec=qemu_get_be64(f);
1268     if (version_id == 2) {
1269         cpu_clock_offset=qemu_get_be64(f);
1270     }
1271     return 0;
1272 }
1273
1274 #ifdef _WIN32
1275 void CALLBACK host_alarm_handler(UINT uTimerID, UINT uMsg,
1276                                  DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2)
1277 #else
1278 static void host_alarm_handler(int host_signum)
1279 #endif
1280 {
1281 #if 0
1282 #define DISP_FREQ 1000
1283     {
1284         static int64_t delta_min = INT64_MAX;
1285         static int64_t delta_max, delta_cum, last_clock, delta, ti;
1286         static int count;
1287         ti = qemu_get_clock(vm_clock);
1288         if (last_clock != 0) {
1289             delta = ti - last_clock;
1290             if (delta < delta_min)
1291                 delta_min = delta;
1292             if (delta > delta_max)
1293                 delta_max = delta;
1294             delta_cum += delta;
1295             if (++count == DISP_FREQ) {
1296                 printf("timer: min=%" PRId64 " us max=%" PRId64 " us avg=%" PRId64 " us avg_freq=%0.3f Hz\n",
1297                        muldiv64(delta_min, 1000000, ticks_per_sec),
1298                        muldiv64(delta_max, 1000000, ticks_per_sec),
1299                        muldiv64(delta_cum, 1000000 / DISP_FREQ, ticks_per_sec),
1300                        (double)ticks_per_sec / ((double)delta_cum / DISP_FREQ));
1301                 count = 0;
1302                 delta_min = INT64_MAX;
1303                 delta_max = 0;
1304                 delta_cum = 0;
1305             }
1306         }
1307         last_clock = ti;
1308     }
1309 #endif
1310     if (alarm_has_dynticks(alarm_timer) ||
1311         (!use_icount &&
1312             qemu_timer_expired(active_timers[QEMU_TIMER_VIRTUAL],
1313                                qemu_get_clock(vm_clock))) ||
1314         qemu_timer_expired(active_timers[QEMU_TIMER_REALTIME],
1315                            qemu_get_clock(rt_clock))) {
1316 #ifdef _WIN32
1317         struct qemu_alarm_win32 *data = ((struct qemu_alarm_timer*)dwUser)->priv;
1318         SetEvent(data->host_alarm);
1319 #endif
1320         CPUState *env = next_cpu;
1321
1322         alarm_timer->flags |= ALARM_FLAG_EXPIRED;
1323
1324         if (env) {
1325             /* stop the currently executing cpu because a timer occured */
1326             cpu_interrupt(env, CPU_INTERRUPT_EXIT);
1327 #ifdef USE_KQEMU
1328             if (env->kqemu_enabled) {
1329                 kqemu_cpu_interrupt(env);
1330             }
1331 #endif
1332         }
1333         event_pending = 1;
1334     }
1335 }
1336
1337 static int64_t qemu_next_deadline(void)
1338 {
1339     int64_t delta;
1340
1341     if (active_timers[QEMU_TIMER_VIRTUAL]) {
1342         delta = active_timers[QEMU_TIMER_VIRTUAL]->expire_time -
1343                      qemu_get_clock(vm_clock);
1344     } else {
1345         /* To avoid problems with overflow limit this to 2^32.  */
1346         delta = INT32_MAX;
1347     }
1348
1349     if (delta < 0)
1350         delta = 0;
1351
1352     return delta;
1353 }
1354
1355 #if defined(__linux__) || defined(_WIN32)
1356 static uint64_t qemu_next_deadline_dyntick(void)
1357 {
1358     int64_t delta;
1359     int64_t rtdelta;
1360
1361     if (use_icount)
1362         delta = INT32_MAX;
1363     else
1364         delta = (qemu_next_deadline() + 999) / 1000;
1365
1366     if (active_timers[QEMU_TIMER_REALTIME]) {
1367         rtdelta = (active_timers[QEMU_TIMER_REALTIME]->expire_time -
1368                  qemu_get_clock(rt_clock))*1000;
1369         if (rtdelta < delta)
1370             delta = rtdelta;
1371     }
1372
1373     if (delta < MIN_TIMER_REARM_US)
1374         delta = MIN_TIMER_REARM_US;
1375
1376     return delta;
1377 }
1378 #endif
1379
1380 #ifndef _WIN32
1381
1382 #if defined(__linux__)
1383
1384 #define RTC_FREQ 1024
1385
1386 static void enable_sigio_timer(int fd)
1387 {
1388     struct sigaction act;
1389
1390     /* timer signal */
1391     sigfillset(&act.sa_mask);
1392     act.sa_flags = 0;
1393     act.sa_handler = host_alarm_handler;
1394
1395     sigaction(SIGIO, &act, NULL);
1396     fcntl(fd, F_SETFL, O_ASYNC);
1397     fcntl(fd, F_SETOWN, getpid());
1398 }
1399
1400 static int hpet_start_timer(struct qemu_alarm_timer *t)
1401 {
1402     struct hpet_info info;
1403     int r, fd;
1404
1405     fd = open("/dev/hpet", O_RDONLY);
1406     if (fd < 0)
1407         return -1;
1408
1409     /* Set frequency */
1410     r = ioctl(fd, HPET_IRQFREQ, RTC_FREQ);
1411     if (r < 0) {
1412         fprintf(stderr, "Could not configure '/dev/hpet' to have a 1024Hz timer. This is not a fatal\n"
1413                 "error, but for better emulation accuracy type:\n"
1414                 "'echo 1024 > /proc/sys/dev/hpet/max-user-freq' as root.\n");
1415         goto fail;
1416     }
1417
1418     /* Check capabilities */
1419     r = ioctl(fd, HPET_INFO, &info);
1420     if (r < 0)
1421         goto fail;
1422
1423     /* Enable periodic mode */
1424     r = ioctl(fd, HPET_EPI, 0);
1425     if (info.hi_flags && (r < 0))
1426         goto fail;
1427
1428     /* Enable interrupt */
1429     r = ioctl(fd, HPET_IE_ON, 0);
1430     if (r < 0)
1431         goto fail;
1432
1433     enable_sigio_timer(fd);
1434     t->priv = (void *)(long)fd;
1435
1436     return 0;
1437 fail:
1438     close(fd);
1439     return -1;
1440 }
1441
1442 static void hpet_stop_timer(struct qemu_alarm_timer *t)
1443 {
1444     int fd = (long)t->priv;
1445
1446     close(fd);
1447 }
1448
1449 static int rtc_start_timer(struct qemu_alarm_timer *t)
1450 {
1451     int rtc_fd;
1452     unsigned long current_rtc_freq = 0;
1453
1454     TFR(rtc_fd = open("/dev/rtc", O_RDONLY));
1455     if (rtc_fd < 0)
1456         return -1;
1457     ioctl(rtc_fd, RTC_IRQP_READ, &current_rtc_freq);
1458     if (current_rtc_freq != RTC_FREQ &&
1459         ioctl(rtc_fd, RTC_IRQP_SET, RTC_FREQ) < 0) {
1460         fprintf(stderr, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
1461                 "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
1462                 "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
1463         goto fail;
1464     }
1465     if (ioctl(rtc_fd, RTC_PIE_ON, 0) < 0) {
1466     fail:
1467         close(rtc_fd);
1468         return -1;
1469     }
1470
1471     enable_sigio_timer(rtc_fd);
1472
1473     t->priv = (void *)(long)rtc_fd;
1474
1475     return 0;
1476 }
1477
1478 static void rtc_stop_timer(struct qemu_alarm_timer *t)
1479 {
1480     int rtc_fd = (long)t->priv;
1481
1482     close(rtc_fd);
1483 }
1484
1485 static int dynticks_start_timer(struct qemu_alarm_timer *t)
1486 {
1487     struct sigevent ev;
1488     timer_t host_timer;
1489     struct sigaction act;
1490
1491     sigfillset(&act.sa_mask);
1492     act.sa_flags = 0;
1493     act.sa_handler = host_alarm_handler;
1494
1495     sigaction(SIGALRM, &act, NULL);
1496
1497     ev.sigev_value.sival_int = 0;
1498     ev.sigev_notify = SIGEV_SIGNAL;
1499     ev.sigev_signo = SIGALRM;
1500
1501     if (timer_create(CLOCK_REALTIME, &ev, &host_timer)) {
1502         perror("timer_create");
1503
1504         /* disable dynticks */
1505         fprintf(stderr, "Dynamic Ticks disabled\n");
1506
1507         return -1;
1508     }
1509
1510     t->priv = (void *)host_timer;
1511
1512     return 0;
1513 }
1514
1515 static void dynticks_stop_timer(struct qemu_alarm_timer *t)
1516 {
1517     timer_t host_timer = (timer_t)t->priv;
1518
1519     timer_delete(host_timer);
1520 }
1521
1522 static void dynticks_rearm_timer(struct qemu_alarm_timer *t)
1523 {
1524     timer_t host_timer = (timer_t)t->priv;
1525     struct itimerspec timeout;
1526     int64_t nearest_delta_us = INT64_MAX;
1527     int64_t current_us;
1528
1529     if (!active_timers[QEMU_TIMER_REALTIME] &&
1530                 !active_timers[QEMU_TIMER_VIRTUAL])
1531         return;
1532
1533     nearest_delta_us = qemu_next_deadline_dyntick();
1534
1535     /* check whether a timer is already running */
1536     if (timer_gettime(host_timer, &timeout)) {
1537         perror("gettime");
1538         fprintf(stderr, "Internal timer error: aborting\n");
1539         exit(1);
1540     }
1541     current_us = timeout.it_value.tv_sec * 1000000 + timeout.it_value.tv_nsec/1000;
1542     if (current_us && current_us <= nearest_delta_us)
1543         return;
1544
1545     timeout.it_interval.tv_sec = 0;
1546     timeout.it_interval.tv_nsec = 0; /* 0 for one-shot timer */
1547     timeout.it_value.tv_sec =  nearest_delta_us / 1000000;
1548     timeout.it_value.tv_nsec = (nearest_delta_us % 1000000) * 1000;
1549     if (timer_settime(host_timer, 0 /* RELATIVE */, &timeout, NULL)) {
1550         perror("settime");
1551         fprintf(stderr, "Internal timer error: aborting\n");
1552         exit(1);
1553     }
1554 }
1555
1556 #endif /* defined(__linux__) */
1557
1558 static int unix_start_timer(struct qemu_alarm_timer *t)
1559 {
1560     struct sigaction act;
1561     struct itimerval itv;
1562     int err;
1563
1564     /* timer signal */
1565     sigfillset(&act.sa_mask);
1566     act.sa_flags = 0;
1567     act.sa_handler = host_alarm_handler;
1568
1569     sigaction(SIGALRM, &act, NULL);
1570
1571     itv.it_interval.tv_sec = 0;
1572     /* for i386 kernel 2.6 to get 1 ms */
1573     itv.it_interval.tv_usec = 999;
1574     itv.it_value.tv_sec = 0;
1575     itv.it_value.tv_usec = 10 * 1000;
1576
1577     err = setitimer(ITIMER_REAL, &itv, NULL);
1578     if (err)
1579         return -1;
1580
1581     return 0;
1582 }
1583
1584 static void unix_stop_timer(struct qemu_alarm_timer *t)
1585 {
1586     struct itimerval itv;
1587
1588     memset(&itv, 0, sizeof(itv));
1589     setitimer(ITIMER_REAL, &itv, NULL);
1590 }
1591
1592 #endif /* !defined(_WIN32) */
1593
1594 #ifdef _WIN32
1595
1596 static int win32_start_timer(struct qemu_alarm_timer *t)
1597 {
1598     TIMECAPS tc;
1599     struct qemu_alarm_win32 *data = t->priv;
1600     UINT flags;
1601
1602     data->host_alarm = CreateEvent(NULL, FALSE, FALSE, NULL);
1603     if (!data->host_alarm) {
1604         perror("Failed CreateEvent");
1605         return -1;
1606     }
1607
1608     memset(&tc, 0, sizeof(tc));
1609     timeGetDevCaps(&tc, sizeof(tc));
1610
1611     if (data->period < tc.wPeriodMin)
1612         data->period = tc.wPeriodMin;
1613
1614     timeBeginPeriod(data->period);
1615
1616     flags = TIME_CALLBACK_FUNCTION;
1617     if (alarm_has_dynticks(t))
1618         flags |= TIME_ONESHOT;
1619     else
1620         flags |= TIME_PERIODIC;
1621
1622     data->timerId = timeSetEvent(1,         // interval (ms)
1623                         data->period,       // resolution
1624                         host_alarm_handler, // function
1625                         (DWORD)t,           // parameter
1626                         flags);
1627
1628     if (!data->timerId) {
1629         perror("Failed to initialize win32 alarm timer");
1630
1631         timeEndPeriod(data->period);
1632         CloseHandle(data->host_alarm);
1633         return -1;
1634     }
1635
1636     qemu_add_wait_object(data->host_alarm, NULL, NULL);
1637
1638     return 0;
1639 }
1640
1641 static void win32_stop_timer(struct qemu_alarm_timer *t)
1642 {
1643     struct qemu_alarm_win32 *data = t->priv;
1644
1645     timeKillEvent(data->timerId);
1646     timeEndPeriod(data->period);
1647
1648     CloseHandle(data->host_alarm);
1649 }
1650
1651 static void win32_rearm_timer(struct qemu_alarm_timer *t)
1652 {
1653     struct qemu_alarm_win32 *data = t->priv;
1654     uint64_t nearest_delta_us;
1655
1656     if (!active_timers[QEMU_TIMER_REALTIME] &&
1657                 !active_timers[QEMU_TIMER_VIRTUAL])
1658         return;
1659
1660     nearest_delta_us = qemu_next_deadline_dyntick();
1661     nearest_delta_us /= 1000;
1662
1663     timeKillEvent(data->timerId);
1664
1665     data->timerId = timeSetEvent(1,
1666                         data->period,
1667                         host_alarm_handler,
1668                         (DWORD)t,
1669                         TIME_ONESHOT | TIME_PERIODIC);
1670
1671     if (!data->timerId) {
1672         perror("Failed to re-arm win32 alarm timer");
1673
1674         timeEndPeriod(data->period);
1675         CloseHandle(data->host_alarm);
1676         exit(1);
1677     }
1678 }
1679
1680 #endif /* _WIN32 */
1681
1682 static void init_timer_alarm(void)
1683 {
1684     struct qemu_alarm_timer *t = NULL;
1685     int i, err = -1;
1686
1687     for (i = 0; alarm_timers[i].name; i++) {
1688         t = &alarm_timers[i];
1689
1690         err = t->start(t);
1691         if (!err)
1692             break;
1693     }
1694
1695     if (err) {
1696         fprintf(stderr, "Unable to find any suitable alarm timer.\n");
1697         fprintf(stderr, "Terminating\n");
1698         exit(1);
1699     }
1700
1701     alarm_timer = t;
1702 }
1703
1704 static void quit_timers(void)
1705 {
1706     alarm_timer->stop(alarm_timer);
1707     alarm_timer = NULL;
1708 }
1709
1710 /***********************************************************/
1711 /* host time/date access */
1712 void qemu_get_timedate(struct tm *tm, int offset)
1713 {
1714     time_t ti;
1715     struct tm *ret;
1716
1717     time(&ti);
1718     ti += offset;
1719     if (rtc_date_offset == -1) {
1720         if (rtc_utc)
1721             ret = gmtime(&ti);
1722         else
1723             ret = localtime(&ti);
1724     } else {
1725         ti -= rtc_date_offset;
1726         ret = gmtime(&ti);
1727     }
1728
1729     memcpy(tm, ret, sizeof(struct tm));
1730 }
1731
1732 int qemu_timedate_diff(struct tm *tm)
1733 {
1734     time_t seconds;
1735
1736     if (rtc_date_offset == -1)
1737         if (rtc_utc)
1738             seconds = mktimegm(tm);
1739         else
1740             seconds = mktime(tm);
1741     else
1742         seconds = mktimegm(tm) + rtc_date_offset;
1743
1744     return seconds - time(NULL);
1745 }
1746
1747 /***********************************************************/
1748 /* character device */
1749
1750 static void qemu_chr_event(CharDriverState *s, int event)
1751 {
1752     if (!s->chr_event)
1753         return;
1754     s->chr_event(s->handler_opaque, event);
1755 }
1756
1757 static void qemu_chr_reset_bh(void *opaque)
1758 {
1759     CharDriverState *s = opaque;
1760     qemu_chr_event(s, CHR_EVENT_RESET);
1761     qemu_bh_delete(s->bh);
1762     s->bh = NULL;
1763 }
1764
1765 void qemu_chr_reset(CharDriverState *s)
1766 {
1767     if (s->bh == NULL) {
1768         s->bh = qemu_bh_new(qemu_chr_reset_bh, s);
1769         qemu_bh_schedule(s->bh);
1770     }
1771 }
1772
1773 int qemu_chr_write(CharDriverState *s, const uint8_t *buf, int len)
1774 {
1775     return s->chr_write(s, buf, len);
1776 }
1777
1778 int qemu_chr_ioctl(CharDriverState *s, int cmd, void *arg)
1779 {
1780     if (!s->chr_ioctl)
1781         return -ENOTSUP;
1782     return s->chr_ioctl(s, cmd, arg);
1783 }
1784
1785 int qemu_chr_can_read(CharDriverState *s)
1786 {
1787     if (!s->chr_can_read)
1788         return 0;
1789     return s->chr_can_read(s->handler_opaque);
1790 }
1791
1792 void qemu_chr_read(CharDriverState *s, uint8_t *buf, int len)
1793 {
1794     s->chr_read(s->handler_opaque, buf, len);
1795 }
1796
1797 void qemu_chr_accept_input(CharDriverState *s)
1798 {
1799     if (s->chr_accept_input)
1800         s->chr_accept_input(s);
1801 }
1802
1803 void qemu_chr_printf(CharDriverState *s, const char *fmt, ...)
1804 {
1805     char buf[4096];
1806     va_list ap;
1807     va_start(ap, fmt);
1808     vsnprintf(buf, sizeof(buf), fmt, ap);
1809     qemu_chr_write(s, (uint8_t *)buf, strlen(buf));
1810     va_end(ap);
1811 }
1812
1813 void qemu_chr_send_event(CharDriverState *s, int event)
1814 {
1815     if (s->chr_send_event)
1816         s->chr_send_event(s, event);
1817 }
1818
1819 void qemu_chr_add_handlers(CharDriverState *s,
1820                            IOCanRWHandler *fd_can_read,
1821                            IOReadHandler *fd_read,
1822                            IOEventHandler *fd_event,
1823                            void *opaque)
1824 {
1825     s->chr_can_read = fd_can_read;
1826     s->chr_read = fd_read;
1827     s->chr_event = fd_event;
1828     s->handler_opaque = opaque;
1829     if (s->chr_update_read_handler)
1830         s->chr_update_read_handler(s);
1831 }
1832
1833 static int null_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1834 {
1835     return len;
1836 }
1837
1838 static CharDriverState *qemu_chr_open_null(void)
1839 {
1840     CharDriverState *chr;
1841
1842     chr = qemu_mallocz(sizeof(CharDriverState));
1843     if (!chr)
1844         return NULL;
1845     chr->chr_write = null_chr_write;
1846     return chr;
1847 }
1848
1849 /* MUX driver for serial I/O splitting */
1850 static int term_timestamps;
1851 static int64_t term_timestamps_start;
1852 #define MAX_MUX 4
1853 #define MUX_BUFFER_SIZE 32      /* Must be a power of 2.  */
1854 #define MUX_BUFFER_MASK (MUX_BUFFER_SIZE - 1)
1855 typedef struct {
1856     IOCanRWHandler *chr_can_read[MAX_MUX];
1857     IOReadHandler *chr_read[MAX_MUX];
1858     IOEventHandler *chr_event[MAX_MUX];
1859     void *ext_opaque[MAX_MUX];
1860     CharDriverState *drv;
1861     unsigned char buffer[MUX_BUFFER_SIZE];
1862     int prod;
1863     int cons;
1864     int mux_cnt;
1865     int term_got_escape;
1866     int max_size;
1867 } MuxDriver;
1868
1869
1870 static int mux_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1871 {
1872     MuxDriver *d = chr->opaque;
1873     int ret;
1874     if (!term_timestamps) {
1875         ret = d->drv->chr_write(d->drv, buf, len);
1876     } else {
1877         int i;
1878
1879         ret = 0;
1880         for(i = 0; i < len; i++) {
1881             ret += d->drv->chr_write(d->drv, buf+i, 1);
1882             if (buf[i] == '\n') {
1883                 char buf1[64];
1884                 int64_t ti;
1885                 int secs;
1886
1887                 ti = get_clock();
1888                 if (term_timestamps_start == -1)
1889                     term_timestamps_start = ti;
1890                 ti -= term_timestamps_start;
1891                 secs = ti / 1000000000;
1892                 snprintf(buf1, sizeof(buf1),
1893                          "[%02d:%02d:%02d.%03d] ",
1894                          secs / 3600,
1895                          (secs / 60) % 60,
1896                          secs % 60,
1897                          (int)((ti / 1000000) % 1000));
1898                 d->drv->chr_write(d->drv, (uint8_t *)buf1, strlen(buf1));
1899             }
1900         }
1901     }
1902     return ret;
1903 }
1904
1905 static const char * const mux_help[] = {
1906     "% h    print this help\n\r",
1907     "% x    exit emulator\n\r",
1908     "% s    save disk data back to file (if -snapshot)\n\r",
1909     "% t    toggle console timestamps\n\r"
1910     "% b    send break (magic sysrq)\n\r",
1911     "% c    switch between console and monitor\n\r",
1912     "% %  sends %\n\r",
1913     NULL
1914 };
1915
1916 static int term_escape_char = 0x01; /* ctrl-a is used for escape */
1917 static void mux_print_help(CharDriverState *chr)
1918 {
1919     int i, j;
1920     char ebuf[15] = "Escape-Char";
1921     char cbuf[50] = "\n\r";
1922
1923     if (term_escape_char > 0 && term_escape_char < 26) {
1924         snprintf(cbuf, sizeof(cbuf), "\n\r");
1925         snprintf(ebuf, sizeof(ebuf), "C-%c", term_escape_char - 1 + 'a');
1926     } else {
1927         snprintf(cbuf, sizeof(cbuf),
1928                  "\n\rEscape-Char set to Ascii: 0x%02x\n\r\n\r",
1929                  term_escape_char);
1930     }
1931     chr->chr_write(chr, (uint8_t *)cbuf, strlen(cbuf));
1932     for (i = 0; mux_help[i] != NULL; i++) {
1933         for (j=0; mux_help[i][j] != '\0'; j++) {
1934             if (mux_help[i][j] == '%')
1935                 chr->chr_write(chr, (uint8_t *)ebuf, strlen(ebuf));
1936             else
1937                 chr->chr_write(chr, (uint8_t *)&mux_help[i][j], 1);
1938         }
1939     }
1940 }
1941
1942 static int mux_proc_byte(CharDriverState *chr, MuxDriver *d, int ch)
1943 {
1944     if (d->term_got_escape) {
1945         d->term_got_escape = 0;
1946         if (ch == term_escape_char)
1947             goto send_char;
1948         switch(ch) {
1949         case '?':
1950         case 'h':
1951             mux_print_help(chr);
1952             break;
1953         case 'x':
1954             {
1955                  const char *term =  "QEMU: Terminated\n\r";
1956                  chr->chr_write(chr,(uint8_t *)term,strlen(term));
1957                  exit(0);
1958                  break;
1959             }
1960         case 's':
1961             {
1962                 int i;
1963                 for (i = 0; i < nb_drives; i++) {
1964                         bdrv_commit(drives_table[i].bdrv);
1965                 }
1966             }
1967             break;
1968         case 'b':
1969             qemu_chr_event(chr, CHR_EVENT_BREAK);
1970             break;
1971         case 'c':
1972             /* Switch to the next registered device */
1973             chr->focus++;
1974             if (chr->focus >= d->mux_cnt)
1975                 chr->focus = 0;
1976             break;
1977        case 't':
1978            term_timestamps = !term_timestamps;
1979            term_timestamps_start = -1;
1980            break;
1981         }
1982     } else if (ch == term_escape_char) {
1983         d->term_got_escape = 1;
1984     } else {
1985     send_char:
1986         return 1;
1987     }
1988     return 0;
1989 }
1990
1991 static void mux_chr_accept_input(CharDriverState *chr)
1992 {
1993     int m = chr->focus;
1994     MuxDriver *d = chr->opaque;
1995
1996     while (d->prod != d->cons &&
1997            d->chr_can_read[m] &&
1998            d->chr_can_read[m](d->ext_opaque[m])) {
1999         d->chr_read[m](d->ext_opaque[m],
2000                        &d->buffer[d->cons++ & MUX_BUFFER_MASK], 1);
2001     }
2002 }
2003
2004 static int mux_chr_can_read(void *opaque)
2005 {
2006     CharDriverState *chr = opaque;
2007     MuxDriver *d = chr->opaque;
2008
2009     if ((d->prod - d->cons) < MUX_BUFFER_SIZE)
2010         return 1;
2011     if (d->chr_can_read[chr->focus])
2012         return d->chr_can_read[chr->focus](d->ext_opaque[chr->focus]);
2013     return 0;
2014 }
2015
2016 static void mux_chr_read(void *opaque, const uint8_t *buf, int size)
2017 {
2018     CharDriverState *chr = opaque;
2019     MuxDriver *d = chr->opaque;
2020     int m = chr->focus;
2021     int i;
2022
2023     mux_chr_accept_input (opaque);
2024
2025     for(i = 0; i < size; i++)
2026         if (mux_proc_byte(chr, d, buf[i])) {
2027             if (d->prod == d->cons &&
2028                 d->chr_can_read[m] &&
2029                 d->chr_can_read[m](d->ext_opaque[m]))
2030                 d->chr_read[m](d->ext_opaque[m], &buf[i], 1);
2031             else
2032                 d->buffer[d->prod++ & MUX_BUFFER_MASK] = buf[i];
2033         }
2034 }
2035
2036 static void mux_chr_event(void *opaque, int event)
2037 {
2038     CharDriverState *chr = opaque;
2039     MuxDriver *d = chr->opaque;
2040     int i;
2041
2042     /* Send the event to all registered listeners */
2043     for (i = 0; i < d->mux_cnt; i++)
2044         if (d->chr_event[i])
2045             d->chr_event[i](d->ext_opaque[i], event);
2046 }
2047
2048 static void mux_chr_update_read_handler(CharDriverState *chr)
2049 {
2050     MuxDriver *d = chr->opaque;
2051
2052     if (d->mux_cnt >= MAX_MUX) {
2053         fprintf(stderr, "Cannot add I/O handlers, MUX array is full\n");
2054         return;
2055     }
2056     d->ext_opaque[d->mux_cnt] = chr->handler_opaque;
2057     d->chr_can_read[d->mux_cnt] = chr->chr_can_read;
2058     d->chr_read[d->mux_cnt] = chr->chr_read;
2059     d->chr_event[d->mux_cnt] = chr->chr_event;
2060     /* Fix up the real driver with mux routines */
2061     if (d->mux_cnt == 0) {
2062         qemu_chr_add_handlers(d->drv, mux_chr_can_read, mux_chr_read,
2063                               mux_chr_event, chr);
2064     }
2065     chr->focus = d->mux_cnt;
2066     d->mux_cnt++;
2067 }
2068
2069 static CharDriverState *qemu_chr_open_mux(CharDriverState *drv)
2070 {
2071     CharDriverState *chr;
2072     MuxDriver *d;
2073
2074     chr = qemu_mallocz(sizeof(CharDriverState));
2075     if (!chr)
2076         return NULL;
2077     d = qemu_mallocz(sizeof(MuxDriver));
2078     if (!d) {
2079         free(chr);
2080         return NULL;
2081     }
2082
2083     chr->opaque = d;
2084     d->drv = drv;
2085     chr->focus = -1;
2086     chr->chr_write = mux_chr_write;
2087     chr->chr_update_read_handler = mux_chr_update_read_handler;
2088     chr->chr_accept_input = mux_chr_accept_input;
2089     return chr;
2090 }
2091
2092
2093 #ifdef _WIN32
2094
2095 static void socket_cleanup(void)
2096 {
2097     WSACleanup();
2098 }
2099
2100 static int socket_init(void)
2101 {
2102     WSADATA Data;
2103     int ret, err;
2104
2105     ret = WSAStartup(MAKEWORD(2,2), &Data);
2106     if (ret != 0) {
2107         err = WSAGetLastError();
2108         fprintf(stderr, "WSAStartup: %d\n", err);
2109         return -1;
2110     }
2111     atexit(socket_cleanup);
2112     return 0;
2113 }
2114
2115 static int send_all(int fd, const uint8_t *buf, int len1)
2116 {
2117     int ret, len;
2118
2119     len = len1;
2120     while (len > 0) {
2121         ret = send(fd, buf, len, 0);
2122         if (ret < 0) {
2123             int errno;
2124             errno = WSAGetLastError();
2125             if (errno != WSAEWOULDBLOCK) {
2126                 return -1;
2127             }
2128         } else if (ret == 0) {
2129             break;
2130         } else {
2131             buf += ret;
2132             len -= ret;
2133         }
2134     }
2135     return len1 - len;
2136 }
2137
2138 #else
2139
2140 static int unix_write(int fd, const uint8_t *buf, int len1)
2141 {
2142     int ret, len;
2143
2144     len = len1;
2145     while (len > 0) {
2146         ret = write(fd, buf, len);
2147         if (ret < 0) {
2148             if (errno != EINTR && errno != EAGAIN)
2149                 return -1;
2150         } else if (ret == 0) {
2151             break;
2152         } else {
2153             buf += ret;
2154             len -= ret;
2155         }
2156     }
2157     return len1 - len;
2158 }
2159
2160 static inline int send_all(int fd, const uint8_t *buf, int len1)
2161 {
2162     return unix_write(fd, buf, len1);
2163 }
2164 #endif /* !_WIN32 */
2165
2166 #ifndef _WIN32
2167
2168 typedef struct {
2169     int fd_in, fd_out;
2170     int max_size;
2171 } FDCharDriver;
2172
2173 #define STDIO_MAX_CLIENTS 1
2174 static int stdio_nb_clients = 0;
2175
2176 static int fd_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
2177 {
2178     FDCharDriver *s = chr->opaque;
2179     return unix_write(s->fd_out, buf, len);
2180 }
2181
2182 static int fd_chr_read_poll(void *opaque)
2183 {
2184     CharDriverState *chr = opaque;
2185     FDCharDriver *s = chr->opaque;
2186
2187     s->max_size = qemu_chr_can_read(chr);
2188     return s->max_size;
2189 }
2190
2191 static void fd_chr_read(void *opaque)
2192 {
2193     CharDriverState *chr = opaque;
2194     FDCharDriver *s = chr->opaque;
2195     int size, len;
2196     uint8_t buf[1024];
2197
2198     len = sizeof(buf);
2199     if (len > s->max_size)
2200         len = s->max_size;
2201     if (len == 0)
2202         return;
2203     size = read(s->fd_in, buf, len);
2204     if (size == 0) {
2205         /* FD has been closed. Remove it from the active list.  */
2206         qemu_set_fd_handler2(s->fd_in, NULL, NULL, NULL, NULL);
2207         return;
2208     }
2209     if (size > 0) {
2210         qemu_chr_read(chr, buf, size);
2211     }
2212 }
2213
2214 static void fd_chr_update_read_handler(CharDriverState *chr)
2215 {
2216     FDCharDriver *s = chr->opaque;
2217
2218     if (s->fd_in >= 0) {
2219         if (nographic && s->fd_in == 0) {
2220         } else {
2221             qemu_set_fd_handler2(s->fd_in, fd_chr_read_poll,
2222                                  fd_chr_read, NULL, chr);
2223         }
2224     }
2225 }
2226
2227 static void fd_chr_close(struct CharDriverState *chr)
2228 {
2229     FDCharDriver *s = chr->opaque;
2230
2231     if (s->fd_in >= 0) {
2232         if (nographic && s->fd_in == 0) {
2233         } else {
2234             qemu_set_fd_handler2(s->fd_in, NULL, NULL, NULL, NULL);
2235         }
2236     }
2237
2238     qemu_free(s);
2239 }
2240
2241 /* open a character device to a unix fd */
2242 static CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out)
2243 {
2244     CharDriverState *chr;
2245     FDCharDriver *s;
2246
2247     chr = qemu_mallocz(sizeof(CharDriverState));
2248     if (!chr)
2249         return NULL;
2250     s = qemu_mallocz(sizeof(FDCharDriver));
2251     if (!s) {
2252         free(chr);
2253         return NULL;
2254     }
2255     s->fd_in = fd_in;
2256     s->fd_out = fd_out;
2257     chr->opaque = s;
2258     chr->chr_write = fd_chr_write;
2259     chr->chr_update_read_handler = fd_chr_update_read_handler;
2260     chr->chr_close = fd_chr_close;
2261
2262     qemu_chr_reset(chr);
2263
2264     return chr;
2265 }
2266
2267 static CharDriverState *qemu_chr_open_file_out(const char *file_out)
2268 {
2269     int fd_out;
2270
2271     TFR(fd_out = open(file_out, O_WRONLY | O_TRUNC | O_CREAT | O_BINARY, 0666));
2272     if (fd_out < 0)
2273         return NULL;
2274     return qemu_chr_open_fd(-1, fd_out);
2275 }
2276
2277 static CharDriverState *qemu_chr_open_pipe(const char *filename)
2278 {
2279     int fd_in, fd_out;
2280     char filename_in[256], filename_out[256];
2281
2282     snprintf(filename_in, 256, "%s.in", filename);
2283     snprintf(filename_out, 256, "%s.out", filename);
2284     TFR(fd_in = open(filename_in, O_RDWR | O_BINARY));
2285     TFR(fd_out = open(filename_out, O_RDWR | O_BINARY));
2286     if (fd_in < 0 || fd_out < 0) {
2287         if (fd_in >= 0)
2288             close(fd_in);
2289         if (fd_out >= 0)
2290             close(fd_out);
2291         TFR(fd_in = fd_out = open(filename, O_RDWR | O_BINARY));
2292         if (fd_in < 0)
2293             return NULL;
2294     }
2295     return qemu_chr_open_fd(fd_in, fd_out);
2296 }
2297
2298
2299 /* for STDIO, we handle the case where several clients use it
2300    (nographic mode) */
2301
2302 #define TERM_FIFO_MAX_SIZE 1
2303
2304 static uint8_t term_fifo[TERM_FIFO_MAX_SIZE];
2305 static int term_fifo_size;
2306
2307 static int stdio_read_poll(void *opaque)
2308 {
2309     CharDriverState *chr = opaque;
2310
2311     /* try to flush the queue if needed */
2312     if (term_fifo_size != 0 && qemu_chr_can_read(chr) > 0) {
2313         qemu_chr_read(chr, term_fifo, 1);
2314         term_fifo_size = 0;
2315     }
2316     /* see if we can absorb more chars */
2317     if (term_fifo_size == 0)
2318         return 1;
2319     else
2320         return 0;
2321 }
2322
2323 static void stdio_read(void *opaque)
2324 {
2325     int size;
2326     uint8_t buf[1];
2327     CharDriverState *chr = opaque;
2328
2329     size = read(0, buf, 1);
2330     if (size == 0) {
2331         /* stdin has been closed. Remove it from the active list.  */
2332         qemu_set_fd_handler2(0, NULL, NULL, NULL, NULL);
2333         return;
2334     }
2335     if (size > 0) {
2336         if (qemu_chr_can_read(chr) > 0) {
2337             qemu_chr_read(chr, buf, 1);
2338         } else if (term_fifo_size == 0) {
2339             term_fifo[term_fifo_size++] = buf[0];
2340         }
2341     }
2342 }
2343
2344 /* init terminal so that we can grab keys */
2345 static struct termios oldtty;
2346 static int old_fd0_flags;
2347 static int term_atexit_done;
2348
2349 static void term_exit(void)
2350 {
2351     tcsetattr (0, TCSANOW, &oldtty);
2352     fcntl(0, F_SETFL, old_fd0_flags);
2353 }
2354
2355 static void term_init(void)
2356 {
2357     struct termios tty;
2358
2359     tcgetattr (0, &tty);
2360     oldtty = tty;
2361     old_fd0_flags = fcntl(0, F_GETFL);
2362
2363     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
2364                           |INLCR|IGNCR|ICRNL|IXON);
2365     tty.c_oflag |= OPOST;
2366     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
2367     /* if graphical mode, we allow Ctrl-C handling */
2368     if (nographic)
2369         tty.c_lflag &= ~ISIG;
2370     tty.c_cflag &= ~(CSIZE|PARENB);
2371     tty.c_cflag |= CS8;
2372     tty.c_cc[VMIN] = 1;
2373     tty.c_cc[VTIME] = 0;
2374
2375     tcsetattr (0, TCSANOW, &tty);
2376
2377     if (!term_atexit_done++)
2378         atexit(term_exit);
2379
2380     fcntl(0, F_SETFL, O_NONBLOCK);
2381 }
2382
2383 static void qemu_chr_close_stdio(struct CharDriverState *chr)
2384 {
2385     term_exit();
2386     stdio_nb_clients--;
2387     qemu_set_fd_handler2(0, NULL, NULL, NULL, NULL);
2388     fd_chr_close(chr);
2389 }
2390
2391 static CharDriverState *qemu_chr_open_stdio(void)
2392 {
2393     CharDriverState *chr;
2394
2395     if (stdio_nb_clients >= STDIO_MAX_CLIENTS)
2396         return NULL;
2397     chr = qemu_chr_open_fd(0, 1);
2398     chr->chr_close = qemu_chr_close_stdio;
2399     qemu_set_fd_handler2(0, stdio_read_poll, stdio_read, NULL, chr);
2400     stdio_nb_clients++;
2401     term_init();
2402
2403     return chr;
2404 }
2405
2406 #ifdef __sun__
2407 /* Once Solaris has openpty(), this is going to be removed. */
2408 int openpty(int *amaster, int *aslave, char *name,
2409             struct termios *termp, struct winsize *winp)
2410 {
2411         const char *slave;
2412         int mfd = -1, sfd = -1;
2413
2414         *amaster = *aslave = -1;
2415
2416         mfd = open("/dev/ptmx", O_RDWR | O_NOCTTY);
2417         if (mfd < 0)
2418                 goto err;
2419
2420         if (grantpt(mfd) == -1 || unlockpt(mfd) == -1)
2421                 goto err;
2422
2423         if ((slave = ptsname(mfd)) == NULL)
2424                 goto err;
2425
2426         if ((sfd = open(slave, O_RDONLY | O_NOCTTY)) == -1)
2427                 goto err;
2428
2429         if (ioctl(sfd, I_PUSH, "ptem") == -1 ||
2430             (termp != NULL && tcgetattr(sfd, termp) < 0))
2431                 goto err;
2432
2433         if (amaster)
2434                 *amaster = mfd;
2435         if (aslave)
2436                 *aslave = sfd;
2437         if (winp)
2438                 ioctl(sfd, TIOCSWINSZ, winp);
2439
2440         return 0;
2441
2442 err:
2443         if (sfd != -1)
2444                 close(sfd);
2445         close(mfd);
2446         return -1;
2447 }
2448
2449 void cfmakeraw (struct termios *termios_p)
2450 {
2451         termios_p->c_iflag &=
2452                 ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);
2453         termios_p->c_oflag &= ~OPOST;
2454         termios_p->c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
2455         termios_p->c_cflag &= ~(CSIZE|PARENB);
2456         termios_p->c_cflag |= CS8;
2457
2458         termios_p->c_cc[VMIN] = 0;
2459         termios_p->c_cc[VTIME] = 0;
2460 }
2461 #endif
2462
2463 #if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \
2464     || defined(__NetBSD__) || defined(__OpenBSD__)
2465
2466 typedef struct {
2467     int fd;
2468     int connected;
2469     int polling;
2470     int read_bytes;
2471     QEMUTimer *timer;
2472 } PtyCharDriver;
2473
2474 static void pty_chr_update_read_handler(CharDriverState *chr);
2475 static void pty_chr_state(CharDriverState *chr, int connected);
2476
2477 static int pty_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
2478 {
2479     PtyCharDriver *s = chr->opaque;
2480
2481     if (!s->connected) {
2482         /* guest sends data, check for (re-)connect */
2483         pty_chr_update_read_handler(chr);
2484         return 0;
2485     }
2486     return unix_write(s->fd, buf, len);
2487 }
2488
2489 static int pty_chr_read_poll(void *opaque)
2490 {
2491     CharDriverState *chr = opaque;
2492     PtyCharDriver *s = chr->opaque;
2493
2494     s->read_bytes = qemu_chr_can_read(chr);
2495     return s->read_bytes;
2496 }
2497
2498 static void pty_chr_read(void *opaque)
2499 {
2500     CharDriverState *chr = opaque;
2501     PtyCharDriver *s = chr->opaque;
2502     int size, len;
2503     uint8_t buf[1024];
2504
2505     len = sizeof(buf);
2506     if (len > s->read_bytes)
2507         len = s->read_bytes;
2508     if (len == 0)
2509         return;
2510     size = read(s->fd, buf, len);
2511     if ((size == -1 && errno == EIO) ||
2512         (size == 0)) {
2513         pty_chr_state(chr, 0);
2514         return;
2515     }
2516     if (size > 0) {
2517         pty_chr_state(chr, 1);
2518         qemu_chr_read(chr, buf, size);
2519     }
2520 }
2521
2522 static void pty_chr_update_read_handler(CharDriverState *chr)
2523 {
2524     PtyCharDriver *s = chr->opaque;
2525
2526     qemu_set_fd_handler2(s->fd, pty_chr_read_poll,
2527                          pty_chr_read, NULL, chr);
2528     s->polling = 1;
2529     /*
2530      * Short timeout here: just need wait long enougth that qemu makes
2531      * it through the poll loop once.  When reconnected we want a
2532      * short timeout so we notice it almost instantly.  Otherwise
2533      * read() gives us -EIO instantly, making pty_chr_state() reset the
2534      * timeout to the normal (much longer) poll interval before the
2535      * timer triggers.
2536      */
2537     qemu_mod_timer(s->timer, qemu_get_clock(rt_clock) + 10);
2538 }
2539
2540 static void pty_chr_state(CharDriverState *chr, int connected)
2541 {
2542     PtyCharDriver *s = chr->opaque;
2543
2544     if (!connected) {
2545         qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
2546         s->connected = 0;
2547         s->polling = 0;
2548         /* (re-)connect poll interval for idle guests: once per second.
2549          * We check more frequently in case the guests sends data to
2550          * the virtual device linked to our pty. */
2551         qemu_mod_timer(s->timer, qemu_get_clock(rt_clock) + 1000);
2552     } else {
2553         if (!s->connected)
2554             qemu_chr_reset(chr);
2555         s->connected = 1;
2556     }
2557 }
2558
2559 static void pty_chr_timer(void *opaque)
2560 {
2561     struct CharDriverState *chr = opaque;
2562     PtyCharDriver *s = chr->opaque;
2563
2564     if (s->connected)
2565         return;
2566     if (s->polling) {
2567         /* If we arrive here without polling being cleared due
2568          * read returning -EIO, then we are (re-)connected */
2569         pty_chr_state(chr, 1);
2570         return;
2571     }
2572
2573     /* Next poll ... */
2574     pty_chr_update_read_handler(chr);
2575 }
2576
2577 static void pty_chr_close(struct CharDriverState *chr)
2578 {
2579     PtyCharDriver *s = chr->opaque;
2580
2581     qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
2582     close(s->fd);
2583     qemu_free(s);
2584 }
2585
2586 static CharDriverState *qemu_chr_open_pty(void)
2587 {
2588     CharDriverState *chr;
2589     PtyCharDriver *s;
2590     struct termios tty;
2591     int slave_fd;
2592 #if defined(__OpenBSD__)
2593     char pty_name[PATH_MAX];
2594 #define q_ptsname(x) pty_name
2595 #else
2596     char *pty_name = NULL;
2597 #define q_ptsname(x) ptsname(x)
2598 #endif
2599
2600     chr = qemu_mallocz(sizeof(CharDriverState));
2601     if (!chr)
2602         return NULL;
2603     s = qemu_mallocz(sizeof(PtyCharDriver));
2604     if (!s) {
2605         qemu_free(chr);
2606         return NULL;
2607     }
2608
2609     if (openpty(&s->fd, &slave_fd, pty_name, NULL, NULL) < 0) {
2610         return NULL;
2611     }
2612
2613     /* Set raw attributes on the pty. */
2614     cfmakeraw(&tty);
2615     tcsetattr(slave_fd, TCSAFLUSH, &tty);
2616     close(slave_fd);
2617
2618     fprintf(stderr, "char device redirected to %s\n", q_ptsname(s->fd));
2619
2620     chr->opaque = s;
2621     chr->chr_write = pty_chr_write;
2622     chr->chr_update_read_handler = pty_chr_update_read_handler;
2623     chr->chr_close = pty_chr_close;
2624
2625     s->timer = qemu_new_timer(rt_clock, pty_chr_timer, chr);
2626
2627     return chr;
2628 }
2629
2630 static void tty_serial_init(int fd, int speed,
2631                             int parity, int data_bits, int stop_bits)
2632 {
2633     struct termios tty;
2634     speed_t spd;
2635
2636 #if 0
2637     printf("tty_serial_init: speed=%d parity=%c data=%d stop=%d\n",
2638            speed, parity, data_bits, stop_bits);
2639 #endif
2640     tcgetattr (fd, &tty);
2641
2642 #define MARGIN 1.1
2643     if (speed <= 50 * MARGIN)
2644         spd = B50;
2645     else if (speed <= 75 * MARGIN)
2646         spd = B75;
2647     else if (speed <= 300 * MARGIN)
2648         spd = B300;
2649     else if (speed <= 600 * MARGIN)
2650         spd = B600;
2651     else if (speed <= 1200 * MARGIN)
2652         spd = B1200;
2653     else if (speed <= 2400 * MARGIN)
2654         spd = B2400;
2655     else if (speed <= 4800 * MARGIN)
2656         spd = B4800;
2657     else if (speed <= 9600 * MARGIN)
2658         spd = B9600;
2659     else if (speed <= 19200 * MARGIN)
2660         spd = B19200;
2661     else if (speed <= 38400 * MARGIN)
2662         spd = B38400;
2663     else if (speed <= 57600 * MARGIN)
2664         spd = B57600;
2665     else if (speed <= 115200 * MARGIN)
2666         spd = B115200;
2667     else
2668         spd = B115200;
2669
2670     cfsetispeed(&tty, spd);
2671     cfsetospeed(&tty, spd);
2672
2673     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
2674                           |INLCR|IGNCR|ICRNL|IXON);
2675     tty.c_oflag |= OPOST;
2676     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN|ISIG);
2677     tty.c_cflag &= ~(CSIZE|PARENB|PARODD|CRTSCTS|CSTOPB);
2678     switch(data_bits) {
2679     default:
2680     case 8:
2681         tty.c_cflag |= CS8;
2682         break;
2683     case 7:
2684         tty.c_cflag |= CS7;
2685         break;
2686     case 6:
2687         tty.c_cflag |= CS6;
2688         break;
2689     case 5:
2690         tty.c_cflag |= CS5;
2691         break;
2692     }
2693     switch(parity) {
2694     default:
2695     case 'N':
2696         break;
2697     case 'E':
2698         tty.c_cflag |= PARENB;
2699         break;
2700     case 'O':
2701         tty.c_cflag |= PARENB | PARODD;
2702         break;
2703     }
2704     if (stop_bits == 2)
2705         tty.c_cflag |= CSTOPB;
2706
2707     tcsetattr (fd, TCSANOW, &tty);
2708 }
2709
2710 static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg)
2711 {
2712     FDCharDriver *s = chr->opaque;
2713
2714     switch(cmd) {
2715     case CHR_IOCTL_SERIAL_SET_PARAMS:
2716         {
2717             QEMUSerialSetParams *ssp = arg;
2718             tty_serial_init(s->fd_in, ssp->speed, ssp->parity,
2719                             ssp->data_bits, ssp->stop_bits);
2720         }
2721         break;
2722     case CHR_IOCTL_SERIAL_SET_BREAK:
2723         {
2724             int enable = *(int *)arg;
2725             if (enable)
2726                 tcsendbreak(s->fd_in, 1);
2727         }
2728         break;
2729     case CHR_IOCTL_SERIAL_GET_TIOCM:
2730         {
2731             int sarg = 0;
2732             int *targ = (int *)arg;
2733             ioctl(s->fd_in, TIOCMGET, &sarg);
2734             *targ = 0;
2735             if (sarg | TIOCM_CTS)
2736                 *targ |= CHR_TIOCM_CTS;
2737             if (sarg | TIOCM_CAR)
2738                 *targ |= CHR_TIOCM_CAR;
2739             if (sarg | TIOCM_DSR)
2740                 *targ |= CHR_TIOCM_DSR;
2741             if (sarg | TIOCM_RI)
2742                 *targ |= CHR_TIOCM_RI;
2743             if (sarg | TIOCM_DTR)
2744                 *targ |= CHR_TIOCM_DTR;
2745             if (sarg | TIOCM_RTS)
2746                 *targ |= CHR_TIOCM_RTS;
2747         }
2748         break;
2749     case CHR_IOCTL_SERIAL_SET_TIOCM:
2750         {
2751             int sarg = *(int *)arg;
2752             int targ = 0;
2753             if (sarg | CHR_TIOCM_DTR)
2754                 targ |= TIOCM_DTR;
2755             if (sarg | CHR_TIOCM_RTS)
2756                 targ |= TIOCM_RTS;
2757             ioctl(s->fd_in, TIOCMSET, &targ);
2758         }
2759         break;
2760     default:
2761         return -ENOTSUP;
2762     }
2763     return 0;
2764 }
2765
2766 static CharDriverState *qemu_chr_open_tty(const char *filename)
2767 {
2768     CharDriverState *chr;
2769     int fd;
2770
2771     TFR(fd = open(filename, O_RDWR | O_NONBLOCK));
2772     tty_serial_init(fd, 115200, 'N', 8, 1);
2773     chr = qemu_chr_open_fd(fd, fd);
2774     if (!chr) {
2775         close(fd);
2776         return NULL;
2777     }
2778     chr->chr_ioctl = tty_serial_ioctl;
2779     qemu_chr_reset(chr);
2780     return chr;
2781 }
2782 #else  /* ! __linux__ && ! __sun__ */
2783 static CharDriverState *qemu_chr_open_pty(void)
2784 {
2785     return NULL;
2786 }
2787 #endif /* __linux__ || __sun__ */
2788
2789 #if defined(__linux__)
2790 typedef struct {
2791     int fd;
2792     int mode;
2793 } ParallelCharDriver;
2794
2795 static int pp_hw_mode(ParallelCharDriver *s, uint16_t mode)
2796 {
2797     if (s->mode != mode) {
2798         int m = mode;
2799         if (ioctl(s->fd, PPSETMODE, &m) < 0)
2800             return 0;
2801         s->mode = mode;
2802     }
2803     return 1;
2804 }
2805
2806 static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
2807 {
2808     ParallelCharDriver *drv = chr->opaque;
2809     int fd = drv->fd;
2810     uint8_t b;
2811
2812     switch(cmd) {
2813     case CHR_IOCTL_PP_READ_DATA:
2814         if (ioctl(fd, PPRDATA, &b) < 0)
2815             return -ENOTSUP;
2816         *(uint8_t *)arg = b;
2817         break;
2818     case CHR_IOCTL_PP_WRITE_DATA:
2819         b = *(uint8_t *)arg;
2820         if (ioctl(fd, PPWDATA, &b) < 0)
2821             return -ENOTSUP;
2822         break;
2823     case CHR_IOCTL_PP_READ_CONTROL:
2824         if (ioctl(fd, PPRCONTROL, &b) < 0)
2825             return -ENOTSUP;
2826         /* Linux gives only the lowest bits, and no way to know data
2827            direction! For better compatibility set the fixed upper
2828            bits. */
2829         *(uint8_t *)arg = b | 0xc0;
2830         break;
2831     case CHR_IOCTL_PP_WRITE_CONTROL:
2832         b = *(uint8_t *)arg;
2833         if (ioctl(fd, PPWCONTROL, &b) < 0)
2834             return -ENOTSUP;
2835         break;
2836     case CHR_IOCTL_PP_READ_STATUS:
2837         if (ioctl(fd, PPRSTATUS, &b) < 0)
2838             return -ENOTSUP;
2839         *(uint8_t *)arg = b;
2840         break;
2841     case CHR_IOCTL_PP_DATA_DIR:
2842         if (ioctl(fd, PPDATADIR, (int *)arg) < 0)
2843             return -ENOTSUP;
2844         break;
2845     case CHR_IOCTL_PP_EPP_READ_ADDR:
2846         if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
2847             struct ParallelIOArg *parg = arg;
2848             int n = read(fd, parg->buffer, parg->count);
2849             if (n != parg->count) {
2850                 return -EIO;
2851             }
2852         }
2853         break;
2854     case CHR_IOCTL_PP_EPP_READ:
2855         if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
2856             struct ParallelIOArg *parg = arg;
2857             int n = read(fd, parg->buffer, parg->count);
2858             if (n != parg->count) {
2859                 return -EIO;
2860             }
2861         }
2862         break;
2863     case CHR_IOCTL_PP_EPP_WRITE_ADDR:
2864         if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
2865             struct ParallelIOArg *parg = arg;
2866             int n = write(fd, parg->buffer, parg->count);
2867             if (n != parg->count) {
2868                 return -EIO;
2869             }
2870         }
2871         break;
2872     case CHR_IOCTL_PP_EPP_WRITE:
2873         if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
2874             struct ParallelIOArg *parg = arg;
2875             int n = write(fd, parg->buffer, parg->count);
2876             if (n != parg->count) {
2877                 return -EIO;
2878             }
2879         }
2880         break;
2881     default:
2882         return -ENOTSUP;
2883     }
2884     return 0;
2885 }
2886
2887 static void pp_close(CharDriverState *chr)
2888 {
2889     ParallelCharDriver *drv = chr->opaque;
2890     int fd = drv->fd;
2891
2892     pp_hw_mode(drv, IEEE1284_MODE_COMPAT);
2893     ioctl(fd, PPRELEASE);
2894     close(fd);
2895     qemu_free(drv);
2896 }
2897
2898 static CharDriverState *qemu_chr_open_pp(const char *filename)
2899 {
2900     CharDriverState *chr;
2901     ParallelCharDriver *drv;
2902     int fd;
2903
2904     TFR(fd = open(filename, O_RDWR));
2905     if (fd < 0)
2906         return NULL;
2907
2908     if (ioctl(fd, PPCLAIM) < 0) {
2909         close(fd);
2910         return NULL;
2911     }
2912
2913     drv = qemu_mallocz(sizeof(ParallelCharDriver));
2914     if (!drv) {
2915         close(fd);
2916         return NULL;
2917     }
2918     drv->fd = fd;
2919     drv->mode = IEEE1284_MODE_COMPAT;
2920
2921     chr = qemu_mallocz(sizeof(CharDriverState));
2922     if (!chr) {
2923         qemu_free(drv);
2924         close(fd);
2925         return NULL;
2926     }
2927     chr->chr_write = null_chr_write;
2928     chr->chr_ioctl = pp_ioctl;
2929     chr->chr_close = pp_close;
2930     chr->opaque = drv;
2931
2932     qemu_chr_reset(chr);
2933
2934     return chr;
2935 }
2936 #endif /* __linux__ */
2937
2938 #else /* _WIN32 */
2939
2940 typedef struct {
2941     int max_size;
2942     HANDLE hcom, hrecv, hsend;
2943     OVERLAPPED orecv, osend;
2944     BOOL fpipe;
2945     DWORD len;
2946 } WinCharState;
2947
2948 #define NSENDBUF 2048
2949 #define NRECVBUF 2048
2950 #define MAXCONNECT 1
2951 #define NTIMEOUT 5000
2952
2953 static int win_chr_poll(void *opaque);
2954 static int win_chr_pipe_poll(void *opaque);
2955
2956 static void win_chr_close(CharDriverState *chr)
2957 {
2958     WinCharState *s = chr->opaque;
2959
2960     if (s->hsend) {
2961         CloseHandle(s->hsend);
2962         s->hsend = NULL;
2963     }
2964     if (s->hrecv) {
2965         CloseHandle(s->hrecv);
2966         s->hrecv = NULL;
2967     }
2968     if (s->hcom) {
2969         CloseHandle(s->hcom);
2970         s->hcom = NULL;
2971     }
2972     if (s->fpipe)
2973         qemu_del_polling_cb(win_chr_pipe_poll, chr);
2974     else
2975         qemu_del_polling_cb(win_chr_poll, chr);
2976 }
2977
2978 static int win_chr_init(CharDriverState *chr, const char *filename)
2979 {
2980     WinCharState *s = chr->opaque;
2981     COMMCONFIG comcfg;
2982     COMMTIMEOUTS cto = { 0, 0, 0, 0, 0};
2983     COMSTAT comstat;
2984     DWORD size;
2985     DWORD err;
2986
2987     s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
2988     if (!s->hsend) {
2989         fprintf(stderr, "Failed CreateEvent\n");
2990         goto fail;
2991     }
2992     s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
2993     if (!s->hrecv) {
2994         fprintf(stderr, "Failed CreateEvent\n");
2995         goto fail;
2996     }
2997
2998     s->hcom = CreateFile(filename, GENERIC_READ|GENERIC_WRITE, 0, NULL,
2999                       OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
3000     if (s->hcom == INVALID_HANDLE_VALUE) {
3001         fprintf(stderr, "Failed CreateFile (%lu)\n", GetLastError());
3002         s->hcom = NULL;
3003         goto fail;
3004     }
3005
3006     if (!SetupComm(s->hcom, NRECVBUF, NSENDBUF)) {
3007         fprintf(stderr, "Failed SetupComm\n");
3008         goto fail;
3009     }
3010
3011     ZeroMemory(&comcfg, sizeof(COMMCONFIG));
3012     size = sizeof(COMMCONFIG);
3013     GetDefaultCommConfig(filename, &comcfg, &size);
3014     comcfg.dcb.DCBlength = sizeof(DCB);
3015     CommConfigDialog(filename, NULL, &comcfg);
3016
3017     if (!SetCommState(s->hcom, &comcfg.dcb)) {
3018         fprintf(stderr, "Failed SetCommState\n");
3019         goto fail;
3020     }
3021
3022     if (!SetCommMask(s->hcom, EV_ERR)) {
3023         fprintf(stderr, "Failed SetCommMask\n");
3024         goto fail;
3025     }
3026
3027     cto.ReadIntervalTimeout = MAXDWORD;
3028     if (!SetCommTimeouts(s->hcom, &cto)) {
3029         fprintf(stderr, "Failed SetCommTimeouts\n");
3030         goto fail;
3031     }
3032
3033     if (!ClearCommError(s->hcom, &err, &comstat)) {
3034         fprintf(stderr, "Failed ClearCommError\n");
3035         goto fail;
3036     }
3037     qemu_add_polling_cb(win_chr_poll, chr);
3038     return 0;
3039
3040  fail:
3041     win_chr_close(chr);
3042     return -1;
3043 }
3044
3045 static int win_chr_write(CharDriverState *chr, const uint8_t *buf, int len1)
3046 {
3047     WinCharState *s = chr->opaque;
3048     DWORD len, ret, size, err;
3049
3050     len = len1;
3051     ZeroMemory(&s->osend, sizeof(s->osend));
3052     s->osend.hEvent = s->hsend;
3053     while (len > 0) {
3054         if (s->hsend)
3055             ret = WriteFile(s->hcom, buf, len, &size, &s->osend);
3056         else
3057             ret = WriteFile(s->hcom, buf, len, &size, NULL);
3058         if (!ret) {
3059             err = GetLastError();
3060             if (err == ERROR_IO_PENDING) {
3061                 ret = GetOverlappedResult(s->hcom, &s->osend, &size, TRUE);
3062                 if (ret) {
3063                     buf += size;
3064                     len -= size;
3065                 } else {
3066                     break;
3067                 }
3068             } else {
3069                 break;
3070             }
3071         } else {
3072             buf += size;
3073             len -= size;
3074         }
3075     }
3076     return len1 - len;
3077 }
3078
3079 static int win_chr_read_poll(CharDriverState *chr)
3080 {
3081     WinCharState *s = chr->opaque;
3082
3083     s->max_size = qemu_chr_can_read(chr);
3084     return s->max_size;
3085 }
3086
3087 static void win_chr_readfile(CharDriverState *chr)
3088 {
3089     WinCharState *s = chr->opaque;
3090     int ret, err;
3091     uint8_t buf[1024];
3092     DWORD size;
3093
3094     ZeroMemory(&s->orecv, sizeof(s->orecv));
3095     s->orecv.hEvent = s->hrecv;
3096     ret = ReadFile(s->hcom, buf, s->len, &size, &s->orecv);
3097     if (!ret) {
3098         err = GetLastError();
3099         if (err == ERROR_IO_PENDING) {
3100             ret = GetOverlappedResult(s->hcom, &s->orecv, &size, TRUE);
3101         }
3102     }
3103
3104     if (size > 0) {
3105         qemu_chr_read(chr, buf, size);
3106     }
3107 }
3108
3109 static void win_chr_read(CharDriverState *chr)
3110 {
3111     WinCharState *s = chr->opaque;
3112
3113     if (s->len > s->max_size)
3114         s->len = s->max_size;
3115     if (s->len == 0)
3116         return;
3117
3118     win_chr_readfile(chr);
3119 }
3120
3121 static int win_chr_poll(void *opaque)
3122 {
3123     CharDriverState *chr = opaque;
3124     WinCharState *s = chr->opaque;
3125     COMSTAT status;
3126     DWORD comerr;
3127
3128     ClearCommError(s->hcom, &comerr, &status);
3129     if (status.cbInQue > 0) {
3130         s->len = status.cbInQue;
3131         win_chr_read_poll(chr);
3132         win_chr_read(chr);
3133         return 1;
3134     }
3135     return 0;
3136 }
3137
3138 static CharDriverState *qemu_chr_open_win(const char *filename)
3139 {
3140     CharDriverState *chr;
3141     WinCharState *s;
3142
3143     chr = qemu_mallocz(sizeof(CharDriverState));
3144     if (!chr)
3145         return NULL;
3146     s = qemu_mallocz(sizeof(WinCharState));
3147     if (!s) {
3148         free(chr);
3149         return NULL;
3150     }
3151     chr->opaque = s;
3152     chr->chr_write = win_chr_write;
3153     chr->chr_close = win_chr_close;
3154
3155     if (win_chr_init(chr, filename) < 0) {
3156         free(s);
3157         free(chr);
3158         return NULL;
3159     }
3160     qemu_chr_reset(chr);
3161     return chr;
3162 }
3163
3164 static int win_chr_pipe_poll(void *opaque)
3165 {
3166     CharDriverState *chr = opaque;
3167     WinCharState *s = chr->opaque;
3168     DWORD size;
3169
3170     PeekNamedPipe(s->hcom, NULL, 0, NULL, &size, NULL);
3171     if (size > 0) {
3172         s->len = size;
3173         win_chr_read_poll(chr);
3174         win_chr_read(chr);
3175         return 1;
3176     }
3177     return 0;
3178 }
3179
3180 static int win_chr_pipe_init(CharDriverState *chr, const char *filename)
3181 {
3182     WinCharState *s = chr->opaque;
3183     OVERLAPPED ov;
3184     int ret;
3185     DWORD size;
3186     char openname[256];
3187
3188     s->fpipe = TRUE;
3189
3190     s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
3191     if (!s->hsend) {
3192         fprintf(stderr, "Failed CreateEvent\n");
3193         goto fail;
3194     }
3195     s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
3196     if (!s->hrecv) {
3197         fprintf(stderr, "Failed CreateEvent\n");
3198         goto fail;
3199     }
3200
3201     snprintf(openname, sizeof(openname), "\\\\.\\pipe\\%s", filename);
3202     s->hcom = CreateNamedPipe(openname, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
3203                               PIPE_TYPE_BYTE | PIPE_READMODE_BYTE |
3204                               PIPE_WAIT,
3205                               MAXCONNECT, NSENDBUF, NRECVBUF, NTIMEOUT, NULL);
3206     if (s->hcom == INVALID_HANDLE_VALUE) {
3207         fprintf(stderr, "Failed CreateNamedPipe (%lu)\n", GetLastError());
3208         s->hcom = NULL;
3209         goto fail;
3210     }
3211
3212     ZeroMemory(&ov, sizeof(ov));
3213     ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
3214     ret = ConnectNamedPipe(s->hcom, &ov);
3215     if (ret) {
3216         fprintf(stderr, "Failed ConnectNamedPipe\n");
3217         goto fail;
3218     }
3219
3220     ret = GetOverlappedResult(s->hcom, &ov, &size, TRUE);
3221     if (!ret) {
3222         fprintf(stderr, "Failed GetOverlappedResult\n");
3223         if (ov.hEvent) {
3224             CloseHandle(ov.hEvent);
3225             ov.hEvent = NULL;
3226         }
3227         goto fail;
3228     }
3229
3230     if (ov.hEvent) {
3231         CloseHandle(ov.hEvent);
3232         ov.hEvent = NULL;
3233     }
3234     qemu_add_polling_cb(win_chr_pipe_poll, chr);
3235     return 0;
3236
3237  fail:
3238     win_chr_close(chr);
3239     return -1;
3240 }
3241
3242
3243 static CharDriverState *qemu_chr_open_win_pipe(const char *filename)
3244 {
3245     CharDriverState *chr;
3246     WinCharState *s;
3247
3248     chr = qemu_mallocz(sizeof(CharDriverState));
3249     if (!chr)
3250         return NULL;
3251     s = qemu_mallocz(sizeof(WinCharState));
3252     if (!s) {
3253         free(chr);
3254         return NULL;
3255     }
3256     chr->opaque = s;
3257     chr->chr_write = win_chr_write;
3258     chr->chr_close = win_chr_close;
3259
3260     if (win_chr_pipe_init(chr, filename) < 0) {
3261         free(s);
3262         free(chr);
3263         return NULL;
3264     }
3265     qemu_chr_reset(chr);
3266     return chr;
3267 }
3268
3269 static CharDriverState *qemu_chr_open_win_file(HANDLE fd_out)
3270 {
3271     CharDriverState *chr;
3272     WinCharState *s;
3273
3274     chr = qemu_mallocz(sizeof(CharDriverState));
3275     if (!chr)
3276         return NULL;
3277     s = qemu_mallocz(sizeof(WinCharState));
3278     if (!s) {
3279         free(chr);
3280         return NULL;
3281     }
3282     s->hcom = fd_out;
3283     chr->opaque = s;
3284     chr->chr_write = win_chr_write;
3285     qemu_chr_reset(chr);
3286     return chr;
3287 }
3288
3289 static CharDriverState *qemu_chr_open_win_con(const char *filename)
3290 {
3291     return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE));
3292 }
3293
3294 static CharDriverState *qemu_chr_open_win_file_out(const char *file_out)
3295 {
3296     HANDLE fd_out;
3297
3298     fd_out = CreateFile(file_out, GENERIC_WRITE, FILE_SHARE_READ, NULL,
3299                         OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
3300     if (fd_out == INVALID_HANDLE_VALUE)
3301         return NULL;
3302
3303     return qemu_chr_open_win_file(fd_out);
3304 }
3305 #endif /* !_WIN32 */
3306
3307 /***********************************************************/
3308 /* UDP Net console */
3309
3310 typedef struct {
3311     int fd;
3312     struct sockaddr_in daddr;
3313     uint8_t buf[1024];
3314     int bufcnt;
3315     int bufptr;
3316     int max_size;
3317 } NetCharDriver;
3318
3319 static int udp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
3320 {
3321     NetCharDriver *s = chr->opaque;
3322
3323     return sendto(s->fd, buf, len, 0,
3324                   (struct sockaddr *)&s->daddr, sizeof(struct sockaddr_in));
3325 }
3326
3327 static int udp_chr_read_poll(void *opaque)
3328 {
3329     CharDriverState *chr = opaque;
3330     NetCharDriver *s = chr->opaque;
3331
3332     s->max_size = qemu_chr_can_read(chr);
3333
3334     /* If there were any stray characters in the queue process them
3335      * first
3336      */
3337     while (s->max_size > 0 && s->bufptr < s->bufcnt) {
3338         qemu_chr_read(chr, &s->buf[s->bufptr], 1);
3339         s->bufptr++;
3340         s->max_size = qemu_chr_can_read(chr);
3341     }
3342     return s->max_size;
3343 }
3344
3345 static void udp_chr_read(void *opaque)
3346 {
3347     CharDriverState *chr = opaque;
3348     NetCharDriver *s = chr->opaque;
3349
3350     if (s->max_size == 0)
3351         return;
3352     s->bufcnt = recv(s->fd, s->buf, sizeof(s->buf), 0);
3353     s->bufptr = s->bufcnt;
3354     if (s->bufcnt <= 0)
3355         return;
3356
3357     s->bufptr = 0;
3358     while (s->max_size > 0 && s->bufptr < s->bufcnt) {
3359         qemu_chr_read(chr, &s->buf[s->bufptr], 1);
3360         s->bufptr++;
3361         s->max_size = qemu_chr_can_read(chr);
3362     }
3363 }
3364
3365 static void udp_chr_update_read_handler(CharDriverState *chr)
3366 {
3367     NetCharDriver *s = chr->opaque;
3368
3369     if (s->fd >= 0) {
3370         qemu_set_fd_handler2(s->fd, udp_chr_read_poll,
3371                              udp_chr_read, NULL, chr);
3372     }
3373 }
3374
3375 int parse_host_port(struct sockaddr_in *saddr, const char *str);
3376 #ifndef _WIN32
3377 static int parse_unix_path(struct sockaddr_un *uaddr, const char *str);
3378 #endif
3379 int parse_host_src_port(struct sockaddr_in *haddr,
3380                         struct sockaddr_in *saddr,
3381                         const char *str);
3382
3383 static CharDriverState *qemu_chr_open_udp(const char *def)
3384 {
3385     CharDriverState *chr = NULL;
3386     NetCharDriver *s = NULL;
3387     int fd = -1;
3388     struct sockaddr_in saddr;
3389
3390     chr = qemu_mallocz(sizeof(CharDriverState));
3391     if (!chr)
3392         goto return_err;
3393     s = qemu_mallocz(sizeof(NetCharDriver));
3394     if (!s)
3395         goto return_err;
3396
3397     fd = socket(PF_INET, SOCK_DGRAM, 0);
3398     if (fd < 0) {
3399         perror("socket(PF_INET, SOCK_DGRAM)");
3400         goto return_err;
3401     }
3402
3403     if (parse_host_src_port(&s->daddr, &saddr, def) < 0) {
3404         printf("Could not parse: %s\n", def);
3405         goto return_err;
3406     }
3407
3408     if (bind(fd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
3409     {
3410         perror("bind");
3411         goto return_err;
3412     }
3413
3414     s->fd = fd;
3415     s->bufcnt = 0;
3416     s->bufptr = 0;
3417     chr->opaque = s;
3418     chr->chr_write = udp_chr_write;
3419     chr->chr_update_read_handler = udp_chr_update_read_handler;
3420     return chr;
3421
3422 return_err:
3423     if (chr)
3424         free(chr);
3425     if (s)
3426         free(s);
3427     if (fd >= 0)
3428         closesocket(fd);
3429     return NULL;
3430 }
3431
3432 /***********************************************************/
3433 /* TCP Net console */
3434
3435 typedef struct {
3436     int fd, listen_fd;
3437     int connected;
3438     int max_size;
3439     int do_telnetopt;
3440     int do_nodelay;
3441     int is_unix;
3442 } TCPCharDriver;
3443
3444 static void tcp_chr_accept(void *opaque);
3445
3446 static int tcp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
3447 {
3448     TCPCharDriver *s = chr->opaque;
3449     if (s->connected) {
3450         return send_all(s->fd, buf, len);
3451     } else {
3452         /* XXX: indicate an error ? */
3453         return len;
3454     }
3455 }
3456
3457 static int tcp_chr_read_poll(void *opaque)
3458 {
3459     CharDriverState *chr = opaque;
3460     TCPCharDriver *s = chr->opaque;
3461     if (!s->connected)
3462         return 0;
3463     s->max_size = qemu_chr_can_read(chr);
3464     return s->max_size;
3465 }
3466
3467 #define IAC 255
3468 #define IAC_BREAK 243
3469 static void tcp_chr_process_IAC_bytes(CharDriverState *chr,
3470                                       TCPCharDriver *s,
3471                                       uint8_t *buf, int *size)
3472 {
3473     /* Handle any telnet client's basic IAC options to satisfy char by
3474      * char mode with no echo.  All IAC options will be removed from
3475      * the buf and the do_telnetopt variable will be used to track the
3476      * state of the width of the IAC information.
3477      *
3478      * IAC commands come in sets of 3 bytes with the exception of the
3479      * "IAC BREAK" command and the double IAC.
3480      */
3481
3482     int i;
3483     int j = 0;
3484
3485     for (i = 0; i < *size; i++) {
3486         if (s->do_telnetopt > 1) {
3487             if ((unsigned char)buf[i] == IAC && s->do_telnetopt == 2) {
3488                 /* Double IAC means send an IAC */
3489                 if (j != i)
3490                     buf[j] = buf[i];
3491                 j++;
3492                 s->do_telnetopt = 1;
3493             } else {
3494                 if ((unsigned char)buf[i] == IAC_BREAK && s->do_telnetopt == 2) {
3495                     /* Handle IAC break commands by sending a serial break */
3496                     qemu_chr_event(chr, CHR_EVENT_BREAK);
3497                     s->do_telnetopt++;
3498                 }
3499                 s->do_telnetopt++;
3500             }
3501             if (s->do_telnetopt >= 4) {
3502                 s->do_telnetopt = 1;
3503             }
3504         } else {
3505             if ((unsigned char)buf[i] == IAC) {
3506                 s->do_telnetopt = 2;
3507             } else {
3508                 if (j != i)
3509                     buf[j] = buf[i];
3510                 j++;
3511             }
3512         }
3513     }
3514     *size = j;
3515 }
3516
3517 static void tcp_chr_read(void *opaque)
3518 {
3519     CharDriverState *chr = opaque;
3520     TCPCharDriver *s = chr->opaque;
3521     uint8_t buf[1024];
3522     int len, size;
3523
3524     if (!s->connected || s->max_size <= 0)
3525         return;
3526     len = sizeof(buf);
3527     if (len > s->max_size)
3528         len = s->max_size;
3529     size = recv(s->fd, buf, len, 0);
3530     if (size == 0) {
3531         /* connection closed */
3532         s->connected = 0;
3533         if (s->listen_fd >= 0) {
3534             qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
3535         }
3536         qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
3537         closesocket(s->fd);
3538         s->fd = -1;
3539     } else if (size > 0) {
3540         if (s->do_telnetopt)
3541             tcp_chr_process_IAC_bytes(chr, s, buf, &size);
3542         if (size > 0)
3543             qemu_chr_read(chr, buf, size);
3544     }
3545 }
3546
3547 static void tcp_chr_connect(void *opaque)
3548 {
3549     CharDriverState *chr = opaque;
3550     TCPCharDriver *s = chr->opaque;
3551
3552     s->connected = 1;
3553     qemu_set_fd_handler2(s->fd, tcp_chr_read_poll,
3554                          tcp_chr_read, NULL, chr);
3555     qemu_chr_reset(chr);
3556 }
3557
3558 #define IACSET(x,a,b,c) x[0] = a; x[1] = b; x[2] = c;
3559 static void tcp_chr_telnet_init(int fd)
3560 {
3561     char buf[3];
3562     /* Send the telnet negotion to put telnet in binary, no echo, single char mode */
3563     IACSET(buf, 0xff, 0xfb, 0x01);  /* IAC WILL ECHO */
3564     send(fd, (char *)buf, 3, 0);
3565     IACSET(buf, 0xff, 0xfb, 0x03);  /* IAC WILL Suppress go ahead */
3566     send(fd, (char *)buf, 3, 0);
3567     IACSET(buf, 0xff, 0xfb, 0x00);  /* IAC WILL Binary */
3568     send(fd, (char *)buf, 3, 0);
3569     IACSET(buf, 0xff, 0xfd, 0x00);  /* IAC DO Binary */
3570     send(fd, (char *)buf, 3, 0);
3571 }
3572
3573 static void socket_set_nodelay(int fd)
3574 {
3575     int val = 1;
3576     setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val));
3577 }
3578
3579 static void tcp_chr_accept(void *opaque)
3580 {
3581     CharDriverState *chr = opaque;
3582     TCPCharDriver *s = chr->opaque;
3583     struct sockaddr_in saddr;
3584 #ifndef _WIN32
3585     struct sockaddr_un uaddr;
3586 #endif
3587     struct sockaddr *addr;
3588     socklen_t len;
3589     int fd;
3590
3591     for(;;) {
3592 #ifndef _WIN32
3593         if (s->is_unix) {
3594             len = sizeof(uaddr);
3595             addr = (struct sockaddr *)&uaddr;
3596         } else
3597 #endif
3598         {
3599             len = sizeof(saddr);
3600             addr = (struct sockaddr *)&saddr;
3601         }
3602         fd = accept(s->listen_fd, addr, &len);
3603         if (fd < 0 && errno != EINTR) {
3604             return;
3605         } else if (fd >= 0) {
3606             if (s->do_telnetopt)
3607                 tcp_chr_telnet_init(fd);
3608             break;
3609         }
3610     }
3611     socket_set_nonblock(fd);
3612     if (s->do_nodelay)
3613         socket_set_nodelay(fd);
3614     s->fd = fd;
3615     qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);
3616     tcp_chr_connect(chr);
3617 }
3618
3619 static void tcp_chr_close(CharDriverState *chr)
3620 {
3621     TCPCharDriver *s = chr->opaque;
3622     if (s->fd >= 0)
3623         closesocket(s->fd);
3624     if (s->listen_fd >= 0)
3625         closesocket(s->listen_fd);
3626     qemu_free(s);
3627 }
3628
3629 static CharDriverState *qemu_chr_open_tcp(const char *host_str,
3630                                           int is_telnet,
3631                                           int is_unix)
3632 {
3633     CharDriverState *chr = NULL;
3634     TCPCharDriver *s = NULL;
3635     int fd = -1, ret, err, val;
3636     int is_listen = 0;
3637     int is_waitconnect = 1;
3638     int do_nodelay = 0;
3639     const char *ptr;
3640     struct sockaddr_in saddr;
3641 #ifndef _WIN32
3642     struct sockaddr_un uaddr;
3643 #endif
3644     struct sockaddr *addr;
3645     socklen_t addrlen;
3646
3647 #ifndef _WIN32
3648     if (is_unix) {
3649         addr = (struct sockaddr *)&uaddr;
3650         addrlen = sizeof(uaddr);
3651         if (parse_unix_path(&uaddr, host_str) < 0)
3652             goto fail;
3653     } else
3654 #endif
3655     {
3656         addr = (struct sockaddr *)&saddr;
3657         addrlen = sizeof(saddr);
3658         if (parse_host_port(&saddr, host_str) < 0)
3659             goto fail;
3660     }
3661
3662     ptr = host_str;
3663     while((ptr = strchr(ptr,','))) {
3664         ptr++;
3665         if (!strncmp(ptr,"server",6)) {
3666             is_listen = 1;
3667         } else if (!strncmp(ptr,"nowait",6)) {
3668             is_waitconnect = 0;
3669         } else if (!strncmp(ptr,"nodelay",6)) {
3670             do_nodelay = 1;
3671         } else {
3672             printf("Unknown option: %s\n", ptr);
3673             goto fail;
3674         }
3675     }
3676     if (!is_listen)
3677         is_waitconnect = 0;
3678
3679     chr = qemu_mallocz(sizeof(CharDriverState));
3680     if (!chr)
3681         goto fail;
3682     s = qemu_mallocz(sizeof(TCPCharDriver));
3683     if (!s)
3684         goto fail;
3685
3686 #ifndef _WIN32
3687     if (is_unix)
3688         fd = socket(PF_UNIX, SOCK_STREAM, 0);
3689     else
3690 #endif
3691         fd = socket(PF_INET, SOCK_STREAM, 0);
3692
3693     if (fd < 0)
3694         goto fail;
3695
3696     if (!is_waitconnect)
3697         socket_set_nonblock(fd);
3698
3699     s->connected = 0;
3700     s->fd = -1;
3701     s->listen_fd = -1;
3702     s->is_unix = is_unix;
3703     s->do_nodelay = do_nodelay && !is_unix;
3704
3705     chr->opaque = s;
3706     chr->chr_write = tcp_chr_write;
3707     chr->chr_close = tcp_chr_close;
3708
3709     if (is_listen) {
3710         /* allow fast reuse */
3711 #ifndef _WIN32
3712         if (is_unix) {
3713             char path[109];
3714             pstrcpy(path, sizeof(path), uaddr.sun_path);
3715             unlink(path);
3716         } else
3717 #endif
3718         {
3719             val = 1;
3720             setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
3721         }
3722
3723         ret = bind(fd, addr, addrlen);
3724         if (ret < 0)
3725             goto fail;
3726
3727         ret = listen(fd, 0);
3728         if (ret < 0)
3729             goto fail;
3730
3731         s->listen_fd = fd;
3732         qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
3733         if (is_telnet)
3734             s->do_telnetopt = 1;
3735     } else {
3736         for(;;) {
3737             ret = connect(fd, addr, addrlen);
3738             if (ret < 0) {
3739                 err = socket_error();
3740                 if (err == EINTR || err == EWOULDBLOCK) {
3741                 } else if (err == EINPROGRESS) {
3742                     break;
3743 #ifdef _WIN32
3744                 } else if (err == WSAEALREADY) {
3745                     break;
3746 #endif
3747                 } else {
3748                     goto fail;
3749                 }
3750             } else {
3751                 s->connected = 1;
3752                 break;
3753             }
3754         }
3755         s->fd = fd;
3756         socket_set_nodelay(fd);
3757         if (s->connected)
3758             tcp_chr_connect(chr);
3759         else
3760             qemu_set_fd_handler(s->fd, NULL, tcp_chr_connect, chr);
3761     }
3762
3763     if (is_listen && is_waitconnect) {
3764         printf("QEMU waiting for connection on: %s\n", host_str);
3765         tcp_chr_accept(chr);
3766         socket_set_nonblock(s->listen_fd);
3767     }
3768
3769     return chr;
3770  fail:
3771     if (fd >= 0)
3772         closesocket(fd);
3773     qemu_free(s);
3774     qemu_free(chr);
3775     return NULL;
3776 }
3777
3778 CharDriverState *qemu_chr_open(const char *filename)
3779 {
3780     const char *p;
3781
3782     if (!strcmp(filename, "vc")) {
3783         return text_console_init(&display_state, 0);
3784     } else if (strstart(filename, "vc:", &p)) {
3785         return text_console_init(&display_state, p);
3786     } else if (!strcmp(filename, "null")) {
3787         return qemu_chr_open_null();
3788     } else
3789     if (strstart(filename, "tcp:", &p)) {
3790         return qemu_chr_open_tcp(p, 0, 0);
3791     } else
3792     if (strstart(filename, "telnet:", &p)) {
3793         return qemu_chr_open_tcp(p, 1, 0);
3794     } else
3795     if (strstart(filename, "udp:", &p)) {
3796         return qemu_chr_open_udp(p);
3797     } else
3798     if (strstart(filename, "mon:", &p)) {
3799         CharDriverState *drv = qemu_chr_open(p);
3800         if (drv) {
3801             drv = qemu_chr_open_mux(drv);
3802             monitor_init(drv, !nographic);
3803             return drv;
3804         }
3805         printf("Unable to open driver: %s\n", p);
3806         return 0;
3807     } else
3808 #ifndef _WIN32
3809     if (strstart(filename, "unix:", &p)) {
3810         return qemu_chr_open_tcp(p, 0, 1);
3811     } else if (strstart(filename, "file:", &p)) {
3812         return qemu_chr_open_file_out(p);
3813     } else if (strstart(filename, "pipe:", &p)) {
3814         return qemu_chr_open_pipe(p);
3815     } else if (!strcmp(filename, "pty")) {
3816         return qemu_chr_open_pty();
3817     } else if (!strcmp(filename, "stdio")) {
3818         return qemu_chr_open_stdio();
3819     } else
3820 #if defined(__linux__)
3821     if (strstart(filename, "/dev/parport", NULL)) {
3822         return qemu_chr_open_pp(filename);
3823     } else
3824 #endif
3825 #if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \
3826     || defined(__NetBSD__) || defined(__OpenBSD__)
3827     if (strstart(filename, "/dev/", NULL)) {
3828         return qemu_chr_open_tty(filename);
3829     } else
3830 #endif
3831 #else /* !_WIN32 */
3832     if (strstart(filename, "COM", NULL)) {
3833         return qemu_chr_open_win(filename);
3834     } else
3835     if (strstart(filename, "pipe:", &p)) {
3836         return qemu_chr_open_win_pipe(p);
3837     } else
3838     if (strstart(filename, "con:", NULL)) {
3839         return qemu_chr_open_win_con(filename);
3840     } else
3841     if (strstart(filename, "file:", &p)) {
3842         return qemu_chr_open_win_file_out(p);
3843     } else
3844 #endif
3845 #ifdef CONFIG_BRLAPI
3846     if (!strcmp(filename, "braille")) {
3847         return chr_baum_init();
3848     } else
3849 #endif
3850     {
3851         return NULL;
3852     }
3853 }
3854
3855 void qemu_chr_close(CharDriverState *chr)
3856 {
3857     if (chr->chr_close)
3858         chr->chr_close(chr);
3859     qemu_free(chr);
3860 }
3861
3862 /***********************************************************/
3863 /* network device redirectors */
3864
3865 #if defined(DEBUG_NET) || defined(DEBUG_SLIRP)
3866 static void hex_dump(FILE *f, const uint8_t *buf, int size)
3867 {
3868     int len, i, j, c;
3869
3870     for(i=0;i<size;i+=16) {
3871         len = size - i;
3872         if (len > 16)
3873             len = 16;
3874         fprintf(f, "%08x ", i);
3875         for(j=0;j<16;j++) {
3876             if (j < len)
3877                 fprintf(f, " %02x", buf[i+j]);
3878             else
3879                 fprintf(f, "   ");
3880         }
3881         fprintf(f, " ");
3882         for(j=0;j<len;j++) {
3883             c = buf[i+j];
3884             if (c < ' ' || c > '~')
3885                 c = '.';
3886             fprintf(f, "%c", c);
3887         }
3888         fprintf(f, "\n");
3889     }
3890 }
3891 #endif
3892
3893 static int parse_macaddr(uint8_t *macaddr, const char *p)
3894 {
3895     int i;
3896     char *last_char;
3897     long int offset;
3898
3899     errno = 0;
3900     offset = strtol(p, &last_char, 0);
3901     if (0 == errno && '\0' == *last_char &&
3902             offset >= 0 && offset <= 0xFFFFFF) {
3903         macaddr[3] = (offset & 0xFF0000) >> 16;
3904         macaddr[4] = (offset & 0xFF00) >> 8;
3905         macaddr[5] = offset & 0xFF;
3906         return 0;
3907     } else {
3908         for(i = 0; i < 6; i++) {
3909             macaddr[i] = strtol(p, (char **)&p, 16);
3910             if (i == 5) {
3911                 if (*p != '\0')
3912                     return -1;
3913             } else {
3914                 if (*p != ':' && *p != '-')
3915                     return -1;
3916                 p++;
3917             }
3918         }
3919         return 0;
3920     }
3921
3922     return -1;
3923 }
3924
3925 static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
3926 {
3927     const char *p, *p1;
3928     int len;
3929     p = *pp;
3930     p1 = strchr(p, sep);
3931     if (!p1)
3932         return -1;
3933     len = p1 - p;
3934     p1++;
3935     if (buf_size > 0) {
3936         if (len > buf_size - 1)
3937             len = buf_size - 1;
3938         memcpy(buf, p, len);
3939         buf[len] = '\0';
3940     }
3941     *pp = p1;
3942     return 0;
3943 }
3944
3945 int parse_host_src_port(struct sockaddr_in *haddr,
3946                         struct sockaddr_in *saddr,
3947                         const char *input_str)
3948 {
3949     char *str = strdup(input_str);
3950     char *host_str = str;
3951     char *src_str;
3952     const char *src_str2;
3953     char *ptr;
3954
3955     /*
3956      * Chop off any extra arguments at the end of the string which
3957      * would start with a comma, then fill in the src port information
3958      * if it was provided else use the "any address" and "any port".
3959      */
3960     if ((ptr = strchr(str,',')))
3961         *ptr = '\0';
3962
3963     if ((src_str = strchr(input_str,'@'))) {
3964         *src_str = '\0';
3965         src_str++;
3966     }
3967
3968     if (parse_host_port(haddr, host_str) < 0)
3969         goto fail;
3970
3971     src_str2 = src_str;
3972     if (!src_str || *src_str == '\0')
3973         src_str2 = ":0";
3974
3975     if (parse_host_port(saddr, src_str2) < 0)
3976         goto fail;
3977
3978     free(str);
3979     return(0);
3980
3981 fail:
3982     free(str);
3983     return -1;
3984 }
3985
3986 int parse_host_port(struct sockaddr_in *saddr, const char *str)
3987 {
3988     char buf[512];
3989     struct hostent *he;
3990     const char *p, *r;
3991     int port;
3992
3993     p = str;
3994     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3995         return -1;
3996     saddr->sin_family = AF_INET;
3997     if (buf[0] == '\0') {
3998         saddr->sin_addr.s_addr = 0;
3999     } else {
4000         if (isdigit(buf[0])) {
4001             if (!inet_aton(buf, &saddr->sin_addr))
4002                 return -1;
4003         } else {
4004             if ((he = gethostbyname(buf)) == NULL)
4005                 return - 1;
4006             saddr->sin_addr = *(struct in_addr *)he->h_addr;
4007         }
4008     }
4009     port = strtol(p, (char **)&r, 0);
4010     if (r == p)
4011         return -1;
4012     saddr->sin_port = htons(port);
4013     return 0;
4014 }
4015
4016 #ifndef _WIN32
4017 static int parse_unix_path(struct sockaddr_un *uaddr, const char *str)
4018 {
4019     const char *p;
4020     int len;
4021
4022     len = MIN(108, strlen(str));
4023     p = strchr(str, ',');
4024     if (p)
4025         len = MIN(len, p - str);
4026
4027     memset(uaddr, 0, sizeof(*uaddr));
4028
4029     uaddr->sun_family = AF_UNIX;
4030     memcpy(uaddr->sun_path, str, len);
4031
4032     return 0;
4033 }
4034 #endif
4035
4036 /* find or alloc a new VLAN */
4037 VLANState *qemu_find_vlan(int id)
4038 {
4039     VLANState **pvlan, *vlan;
4040     for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
4041         if (vlan->id == id)
4042             return vlan;
4043     }
4044     vlan = qemu_mallocz(sizeof(VLANState));
4045     if (!vlan)
4046         return NULL;
4047     vlan->id = id;
4048     vlan->next = NULL;
4049     pvlan = &first_vlan;
4050     while (*pvlan != NULL)
4051         pvlan = &(*pvlan)->next;
4052     *pvlan = vlan;
4053     return vlan;
4054 }
4055
4056 VLANClientState *qemu_new_vlan_client(VLANState *vlan,
4057                                       IOReadHandler *fd_read,
4058                                       IOCanRWHandler *fd_can_read,
4059                                       void *opaque)
4060 {
4061     VLANClientState *vc, **pvc;
4062     vc = qemu_mallocz(sizeof(VLANClientState));
4063     if (!vc)
4064         return NULL;
4065     vc->fd_read = fd_read;
4066     vc->fd_can_read = fd_can_read;
4067     vc->opaque = opaque;
4068     vc->vlan = vlan;
4069
4070     vc->next = NULL;
4071     pvc = &vlan->first_client;
4072     while (*pvc != NULL)
4073         pvc = &(*pvc)->next;
4074     *pvc = vc;
4075     return vc;
4076 }
4077
4078 void qemu_del_vlan_client(VLANClientState *vc)
4079 {
4080     VLANClientState **pvc = &vc->vlan->first_client;
4081
4082     while (*pvc != NULL)
4083         if (*pvc == vc) {
4084             *pvc = vc->next;
4085             free(vc);
4086             break;
4087         } else
4088             pvc = &(*pvc)->next;
4089 }
4090
4091 int qemu_can_send_packet(VLANClientState *vc1)
4092 {
4093     VLANState *vlan = vc1->vlan;
4094     VLANClientState *vc;
4095
4096     for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
4097         if (vc != vc1) {
4098             if (vc->fd_can_read && vc->fd_can_read(vc->opaque))
4099                 return 1;
4100         }
4101     }
4102     return 0;
4103 }
4104
4105 void qemu_send_packet(VLANClientState *vc1, const uint8_t *buf, int size)
4106 {
4107     VLANState *vlan = vc1->vlan;
4108     VLANClientState *vc;
4109
4110 #ifdef DEBUG_NET
4111     printf("vlan %d send:\n", vlan->id);
4112     hex_dump(stdout, buf, size);
4113 #endif
4114     for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
4115         if (vc != vc1) {
4116             vc->fd_read(vc->opaque, buf, size);
4117         }
4118     }
4119 }
4120
4121 #if defined(CONFIG_SLIRP)
4122
4123 /* slirp network adapter */
4124
4125 static int slirp_inited;
4126 static VLANClientState *slirp_vc;
4127
4128 int slirp_can_output(void)
4129 {
4130     return !slirp_vc || qemu_can_send_packet(slirp_vc);
4131 }
4132
4133 void slirp_output(const uint8_t *pkt, int pkt_len)
4134 {
4135 #ifdef DEBUG_SLIRP
4136     printf("slirp output:\n");
4137     hex_dump(stdout, pkt, pkt_len);
4138 #endif
4139     if (!slirp_vc)
4140         return;
4141     qemu_send_packet(slirp_vc, pkt, pkt_len);
4142 }
4143
4144 static void slirp_receive(void *opaque, const uint8_t *buf, int size)
4145 {
4146 #ifdef DEBUG_SLIRP
4147     printf("slirp input:\n");
4148     hex_dump(stdout, buf, size);
4149 #endif
4150     slirp_input(buf, size);
4151 }
4152
4153 static int net_slirp_init(VLANState *vlan)
4154 {
4155     if (!slirp_inited) {
4156         slirp_inited = 1;
4157         slirp_init();
4158     }
4159     slirp_vc = qemu_new_vlan_client(vlan,
4160                                     slirp_receive, NULL, NULL);
4161     snprintf(slirp_vc->info_str, sizeof(slirp_vc->info_str), "user redirector");
4162     return 0;
4163 }
4164
4165 static void net_slirp_redir(const char *redir_str)
4166 {
4167     int is_udp;
4168     char buf[256], *r;
4169     const char *p;
4170     struct in_addr guest_addr;
4171     int host_port, guest_port;
4172
4173     if (!slirp_inited) {
4174         slirp_inited = 1;
4175         slirp_init();
4176     }
4177
4178     p = redir_str;
4179     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
4180         goto fail;
4181     if (!strcmp(buf, "tcp")) {
4182         is_udp = 0;
4183     } else if (!strcmp(buf, "udp")) {
4184         is_udp = 1;
4185     } else {
4186         goto fail;
4187     }
4188
4189     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
4190         goto fail;
4191     host_port = strtol(buf, &r, 0);
4192     if (r == buf)
4193         goto fail;
4194
4195     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
4196         goto fail;
4197     if (buf[0] == '\0') {
4198         pstrcpy(buf, sizeof(buf), "10.0.2.15");
4199     }
4200     if (!inet_aton(buf, &guest_addr))
4201         goto fail;
4202
4203     guest_port = strtol(p, &r, 0);
4204     if (r == p)
4205         goto fail;
4206
4207     if (slirp_redir(is_udp, host_port, guest_addr, guest_port) < 0) {
4208         fprintf(stderr, "qemu: could not set up redirection\n");
4209         exit(1);
4210     }
4211     return;
4212  fail:
4213     fprintf(stderr, "qemu: syntax: -redir [tcp|udp]:host-port:[guest-host]:guest-port\n");
4214     exit(1);
4215 }
4216
4217 #ifndef _WIN32
4218
4219 static char smb_dir[1024];
4220
4221 static void erase_dir(char *dir_name)
4222 {
4223     DIR *d;
4224     struct dirent *de;
4225     char filename[1024];
4226
4227     /* erase all the files in the directory */
4228     if ((d = opendir(dir_name)) != 0) {
4229         for(;;) {
4230             de = readdir(d);
4231             if (!de)
4232                 break;
4233             if (strcmp(de->d_name, ".") != 0 &&
4234                 strcmp(de->d_name, "..") != 0) {
4235                 snprintf(filename, sizeof(filename), "%s/%s",
4236                          smb_dir, de->d_name);
4237                 if (unlink(filename) != 0)  /* is it a directory? */
4238                     erase_dir(filename);
4239             }
4240         }
4241         closedir(d);
4242         rmdir(dir_name);
4243     }
4244 }
4245
4246 /* automatic user mode samba server configuration */
4247 static void smb_exit(void)
4248 {
4249     erase_dir(smb_dir);
4250 }
4251
4252 /* automatic user mode samba server configuration */
4253 static void net_slirp_smb(const char *exported_dir)
4254 {
4255     char smb_conf[1024];
4256     char smb_cmdline[1024];
4257     FILE *f;
4258
4259     if (!slirp_inited) {
4260         slirp_inited = 1;
4261         slirp_init();
4262     }
4263
4264     /* XXX: better tmp dir construction */
4265     snprintf(smb_dir, sizeof(smb_dir), "/tmp/qemu-smb.%d", getpid());
4266     if (mkdir(smb_dir, 0700) < 0) {
4267         fprintf(stderr, "qemu: could not create samba server dir '%s'\n", smb_dir);
4268         exit(1);
4269     }
4270     snprintf(smb_conf, sizeof(smb_conf), "%s/%s", smb_dir, "smb.conf");
4271
4272     f = fopen(smb_conf, "w");
4273     if (!f) {
4274         fprintf(stderr, "qemu: could not create samba server configuration file '%s'\n", smb_conf);
4275         exit(1);
4276     }
4277     fprintf(f,
4278             "[global]\n"
4279             "private dir=%s\n"
4280             "smb ports=0\n"
4281             "socket address=127.0.0.1\n"
4282             "pid directory=%s\n"
4283             "lock directory=%s\n"
4284             "log file=%s/log.smbd\n"
4285             "smb passwd file=%s/smbpasswd\n"
4286             "security = share\n"
4287             "[qemu]\n"
4288             "path=%s\n"
4289             "read only=no\n"
4290             "guest ok=yes\n",
4291             smb_dir,
4292             smb_dir,
4293             smb_dir,
4294             smb_dir,
4295             smb_dir,
4296             exported_dir
4297             );
4298     fclose(f);
4299     atexit(smb_exit);
4300
4301     snprintf(smb_cmdline, sizeof(smb_cmdline), "%s -s %s",
4302              SMBD_COMMAND, smb_conf);
4303
4304     slirp_add_exec(0, smb_cmdline, 4, 139);
4305 }
4306
4307 #endif /* !defined(_WIN32) */
4308 void do_info_slirp(void)
4309 {
4310     slirp_stats();
4311 }
4312
4313 #endif /* CONFIG_SLIRP */
4314
4315 #if !defined(_WIN32)
4316
4317 typedef struct TAPState {
4318     VLANClientState *vc;
4319     int fd;
4320     char down_script[1024];
4321 } TAPState;
4322
4323 static void tap_receive(void *opaque, const uint8_t *buf, int size)
4324 {
4325     TAPState *s = opaque;
4326     int ret;
4327     for(;;) {
4328         ret = write(s->fd, buf, size);
4329         if (ret < 0 && (errno == EINTR || errno == EAGAIN)) {
4330         } else {
4331             break;
4332         }
4333     }
4334 }
4335
4336 static void tap_send(void *opaque)
4337 {
4338     TAPState *s = opaque;
4339     uint8_t buf[4096];
4340     int size;
4341
4342 #ifdef __sun__
4343     struct strbuf sbuf;
4344     int f = 0;
4345     sbuf.maxlen = sizeof(buf);
4346     sbuf.buf = buf;
4347     size = getmsg(s->fd, NULL, &sbuf, &f) >=0 ? sbuf.len : -1;
4348 #else
4349     size = read(s->fd, buf, sizeof(buf));
4350 #endif
4351     if (size > 0) {
4352         qemu_send_packet(s->vc, buf, size);
4353     }
4354 }
4355
4356 /* fd support */
4357
4358 static TAPState *net_tap_fd_init(VLANState *vlan, int fd)
4359 {
4360     TAPState *s;
4361
4362     s = qemu_mallocz(sizeof(TAPState));
4363     if (!s)
4364         return NULL;
4365     s->fd = fd;
4366     s->vc = qemu_new_vlan_client(vlan, tap_receive, NULL, s);
4367     qemu_set_fd_handler(s->fd, tap_send, NULL, s);
4368     snprintf(s->vc->info_str, sizeof(s->vc->info_str), "tap: fd=%d", fd);
4369     return s;
4370 }
4371
4372 #if defined (_BSD) || defined (__FreeBSD_kernel__)
4373 static int tap_open(char *ifname, int ifname_size)
4374 {
4375     int fd;
4376     char *dev;
4377     struct stat s;
4378
4379     TFR(fd = open("/dev/tap", O_RDWR));
4380     if (fd < 0) {
4381         fprintf(stderr, "warning: could not open /dev/tap: no virtual network emulation\n");
4382         return -1;
4383     }
4384
4385     fstat(fd, &s);
4386     dev = devname(s.st_rdev, S_IFCHR);
4387     pstrcpy(ifname, ifname_size, dev);
4388
4389     fcntl(fd, F_SETFL, O_NONBLOCK);
4390     return fd;
4391 }
4392 #elif defined(__sun__)
4393 #define TUNNEWPPA       (('T'<<16) | 0x0001)
4394 /*
4395  * Allocate TAP device, returns opened fd.
4396  * Stores dev name in the first arg(must be large enough).
4397  */
4398 int tap_alloc(char *dev, size_t dev_size)
4399 {
4400     int tap_fd, if_fd, ppa = -1;
4401     static int ip_fd = 0;
4402     char *ptr;
4403
4404     static int arp_fd = 0;
4405     int ip_muxid, arp_muxid;
4406     struct strioctl  strioc_if, strioc_ppa;
4407     int link_type = I_PLINK;;
4408     struct lifreq ifr;
4409     char actual_name[32] = "";
4410
4411     memset(&ifr, 0x0, sizeof(ifr));
4412
4413     if( *dev ){
4414        ptr = dev;
4415        while( *ptr && !isdigit((int)*ptr) ) ptr++;
4416        ppa = atoi(ptr);
4417     }
4418
4419     /* Check if IP device was opened */
4420     if( ip_fd )
4421        close(ip_fd);
4422
4423     TFR(ip_fd = open("/dev/udp", O_RDWR, 0));
4424     if (ip_fd < 0) {
4425        syslog(LOG_ERR, "Can't open /dev/ip (actually /dev/udp)");
4426        return -1;
4427     }
4428
4429     TFR(tap_fd = open("/dev/tap", O_RDWR, 0));
4430     if (tap_fd < 0) {
4431        syslog(LOG_ERR, "Can't open /dev/tap");
4432        return -1;
4433     }
4434
4435     /* Assign a new PPA and get its unit number. */
4436     strioc_ppa.ic_cmd = TUNNEWPPA;
4437     strioc_ppa.ic_timout = 0;
4438     strioc_ppa.ic_len = sizeof(ppa);
4439     strioc_ppa.ic_dp = (char *)&ppa;
4440     if ((ppa = ioctl (tap_fd, I_STR, &strioc_ppa)) < 0)
4441        syslog (LOG_ERR, "Can't assign new interface");
4442
4443     TFR(if_fd = open("/dev/tap", O_RDWR, 0));
4444     if (if_fd < 0) {
4445        syslog(LOG_ERR, "Can't open /dev/tap (2)");
4446        return -1;
4447     }
4448     if(ioctl(if_fd, I_PUSH, "ip") < 0){
4449        syslog(LOG_ERR, "Can't push IP module");
4450        return -1;
4451     }
4452
4453     if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) < 0)
4454         syslog(LOG_ERR, "Can't get flags\n");
4455
4456     snprintf (actual_name, 32, "tap%d", ppa);
4457     strncpy (ifr.lifr_name, actual_name, sizeof (ifr.lifr_name));
4458
4459     ifr.lifr_ppa = ppa;
4460     /* Assign ppa according to the unit number returned by tun device */
4461
4462     if (ioctl (if_fd, SIOCSLIFNAME, &ifr) < 0)
4463         syslog (LOG_ERR, "Can't set PPA %d", ppa);
4464     if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) <0)
4465         syslog (LOG_ERR, "Can't get flags\n");
4466     /* Push arp module to if_fd */
4467     if (ioctl (if_fd, I_PUSH, "arp") < 0)
4468         syslog (LOG_ERR, "Can't push ARP module (2)");
4469
4470     /* Push arp module to ip_fd */
4471     if (ioctl (ip_fd, I_POP, NULL) < 0)
4472         syslog (LOG_ERR, "I_POP failed\n");
4473     if (ioctl (ip_fd, I_PUSH, "arp") < 0)
4474         syslog (LOG_ERR, "Can't push ARP module (3)\n");
4475     /* Open arp_fd */
4476     TFR(arp_fd = open ("/dev/tap", O_RDWR, 0));
4477     if (arp_fd < 0)
4478        syslog (LOG_ERR, "Can't open %s\n", "/dev/tap");
4479
4480     /* Set ifname to arp */
4481     strioc_if.ic_cmd = SIOCSLIFNAME;
4482     strioc_if.ic_timout = 0;
4483     strioc_if.ic_len = sizeof(ifr);
4484     strioc_if.ic_dp = (char *)&ifr;
4485     if (ioctl(arp_fd, I_STR, &strioc_if) < 0){
4486         syslog (LOG_ERR, "Can't set ifname to arp\n");
4487     }
4488
4489     if((ip_muxid = ioctl(ip_fd, I_LINK, if_fd)) < 0){
4490        syslog(LOG_ERR, "Can't link TAP device to IP");
4491        return -1;
4492     }
4493
4494     if ((arp_muxid = ioctl (ip_fd, link_type, arp_fd)) < 0)
4495         syslog (LOG_ERR, "Can't link TAP device to ARP");
4496
4497     close (if_fd);
4498
4499     memset(&ifr, 0x0, sizeof(ifr));
4500     strncpy (ifr.lifr_name, actual_name, sizeof (ifr.lifr_name));
4501     ifr.lifr_ip_muxid  = ip_muxid;
4502     ifr.lifr_arp_muxid = arp_muxid;
4503
4504     if (ioctl (ip_fd, SIOCSLIFMUXID, &ifr) < 0)
4505     {
4506       ioctl (ip_fd, I_PUNLINK , arp_muxid);
4507       ioctl (ip_fd, I_PUNLINK, ip_muxid);
4508       syslog (LOG_ERR, "Can't set multiplexor id");
4509     }
4510
4511     snprintf(dev, dev_size, "tap%d", ppa);
4512     return tap_fd;
4513 }
4514
4515 static int tap_open(char *ifname, int ifname_size)
4516 {
4517     char  dev[10]="";
4518     int fd;
4519     if( (fd = tap_alloc(dev, sizeof(dev))) < 0 ){
4520        fprintf(stderr, "Cannot allocate TAP device\n");
4521        return -1;
4522     }
4523     pstrcpy(ifname, ifname_size, dev);
4524     fcntl(fd, F_SETFL, O_NONBLOCK);
4525     return fd;
4526 }
4527 #else
4528 static int tap_open(char *ifname, int ifname_size)
4529 {
4530     struct ifreq ifr;
4531     int fd, ret;
4532
4533     TFR(fd = open("/dev/net/tun", O_RDWR));
4534     if (fd < 0) {
4535         fprintf(stderr, "warning: could not open /dev/net/tun: no virtual network emulation\n");
4536         return -1;
4537     }
4538     memset(&ifr, 0, sizeof(ifr));
4539     ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
4540     if (ifname[0] != '\0')
4541         pstrcpy(ifr.ifr_name, IFNAMSIZ, ifname);
4542     else
4543         pstrcpy(ifr.ifr_name, IFNAMSIZ, "tap%d");
4544     ret = ioctl(fd, TUNSETIFF, (void *) &ifr);
4545     if (ret != 0) {
4546         fprintf(stderr, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
4547         close(fd);
4548         return -1;
4549     }
4550     pstrcpy(ifname, ifname_size, ifr.ifr_name);
4551     fcntl(fd, F_SETFL, O_NONBLOCK);
4552     return fd;
4553 }
4554 #endif
4555
4556 static int launch_script(const char *setup_script, const char *ifname, int fd)
4557 {
4558     int pid, status;
4559     char *args[3];
4560     char **parg;
4561
4562         /* try to launch network script */
4563         pid = fork();
4564         if (pid >= 0) {
4565             if (pid == 0) {
4566                 int open_max = sysconf (_SC_OPEN_MAX), i;
4567                 for (i = 0; i < open_max; i++)
4568                     if (i != STDIN_FILENO &&
4569                         i != STDOUT_FILENO &&
4570                         i != STDERR_FILENO &&
4571                         i != fd)
4572                         close(i);
4573
4574                 parg = args;
4575                 *parg++ = (char *)setup_script;
4576                 *parg++ = (char *)ifname;
4577                 *parg++ = NULL;
4578                 execv(setup_script, args);
4579                 _exit(1);
4580             }
4581             while (waitpid(pid, &status, 0) != pid);
4582             if (!WIFEXITED(status) ||
4583                 WEXITSTATUS(status) != 0) {
4584                 fprintf(stderr, "%s: could not launch network script\n",
4585                         setup_script);
4586                 return -1;
4587             }
4588         }
4589     return 0;
4590 }
4591
4592 static int net_tap_init(VLANState *vlan, const char *ifname1,
4593                         const char *setup_script, const char *down_script)
4594 {
4595     TAPState *s;
4596     int fd;
4597     char ifname[128];
4598
4599     if (ifname1 != NULL)
4600         pstrcpy(ifname, sizeof(ifname), ifname1);
4601     else
4602         ifname[0] = '\0';
4603     TFR(fd = tap_open(ifname, sizeof(ifname)));
4604     if (fd < 0)
4605         return -1;
4606
4607     if (!setup_script || !strcmp(setup_script, "no"))
4608         setup_script = "";
4609     if (setup_script[0] != '\0') {
4610         if (launch_script(setup_script, ifname, fd))
4611             return -1;
4612     }
4613     s = net_tap_fd_init(vlan, fd);
4614     if (!s)
4615         return -1;
4616     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4617              "tap: ifname=%s setup_script=%s", ifname, setup_script);
4618     if (down_script && strcmp(down_script, "no"))
4619         snprintf(s->down_script, sizeof(s->down_script), "%s", down_script);
4620     return 0;
4621 }
4622
4623 #endif /* !_WIN32 */
4624
4625 #if defined(CONFIG_VDE)
4626 typedef struct VDEState {
4627     VLANClientState *vc;
4628     VDECONN *vde;
4629 } VDEState;
4630
4631 static void vde_to_qemu(void *opaque)
4632 {
4633     VDEState *s = opaque;
4634     uint8_t buf[4096];
4635     int size;
4636
4637     size = vde_recv(s->vde, buf, sizeof(buf), 0);
4638     if (size > 0) {
4639         qemu_send_packet(s->vc, buf, size);
4640     }
4641 }
4642
4643 static void vde_from_qemu(void *opaque, const uint8_t *buf, int size)
4644 {
4645     VDEState *s = opaque;
4646     int ret;
4647     for(;;) {
4648         ret = vde_send(s->vde, buf, size, 0);
4649         if (ret < 0 && errno == EINTR) {
4650         } else {
4651             break;
4652         }
4653     }
4654 }
4655
4656 static int net_vde_init(VLANState *vlan, const char *sock, int port,
4657                         const char *group, int mode)
4658 {
4659     VDEState *s;
4660     char *init_group = strlen(group) ? (char *)group : NULL;
4661     char *init_sock = strlen(sock) ? (char *)sock : NULL;
4662
4663     struct vde_open_args args = {
4664         .port = port,
4665         .group = init_group,
4666         .mode = mode,
4667     };
4668
4669     s = qemu_mallocz(sizeof(VDEState));
4670     if (!s)
4671         return -1;
4672     s->vde = vde_open(init_sock, "QEMU", &args);
4673     if (!s->vde){
4674         free(s);
4675         return -1;
4676     }
4677     s->vc = qemu_new_vlan_client(vlan, vde_from_qemu, NULL, s);
4678     qemu_set_fd_handler(vde_datafd(s->vde), vde_to_qemu, NULL, s);
4679     snprintf(s->vc->info_str, sizeof(s->vc->info_str), "vde: sock=%s fd=%d",
4680              sock, vde_datafd(s->vde));
4681     return 0;
4682 }
4683 #endif
4684
4685 /* network connection */
4686 typedef struct NetSocketState {
4687     VLANClientState *vc;
4688     int fd;
4689     int state; /* 0 = getting length, 1 = getting data */
4690     int index;
4691     int packet_len;
4692     uint8_t buf[4096];
4693     struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
4694 } NetSocketState;
4695
4696 typedef struct NetSocketListenState {
4697     VLANState *vlan;
4698     int fd;
4699 } NetSocketListenState;
4700
4701 /* XXX: we consider we can send the whole packet without blocking */
4702 static void net_socket_receive(void *opaque, const uint8_t *buf, int size)
4703 {
4704     NetSocketState *s = opaque;
4705     uint32_t len;
4706     len = htonl(size);
4707
4708     send_all(s->fd, (const uint8_t *)&len, sizeof(len));
4709     send_all(s->fd, buf, size);
4710 }
4711
4712 static void net_socket_receive_dgram(void *opaque, const uint8_t *buf, int size)
4713 {
4714     NetSocketState *s = opaque;
4715     sendto(s->fd, buf, size, 0,
4716            (struct sockaddr *)&s->dgram_dst, sizeof(s->dgram_dst));
4717 }
4718
4719 static void net_socket_send(void *opaque)
4720 {
4721     NetSocketState *s = opaque;
4722     int l, size, err;
4723     uint8_t buf1[4096];
4724     const uint8_t *buf;
4725
4726     size = recv(s->fd, buf1, sizeof(buf1), 0);
4727     if (size < 0) {
4728         err = socket_error();
4729         if (err != EWOULDBLOCK)
4730             goto eoc;
4731     } else if (size == 0) {
4732         /* end of connection */
4733     eoc:
4734         qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
4735         closesocket(s->fd);
4736         return;
4737     }
4738     buf = buf1;
4739     while (size > 0) {
4740         /* reassemble a packet from the network */
4741         switch(s->state) {
4742         case 0:
4743             l = 4 - s->index;
4744             if (l > size)
4745                 l = size;
4746             memcpy(s->buf + s->index, buf, l);
4747             buf += l;
4748             size -= l;
4749             s->index += l;
4750             if (s->index == 4) {
4751                 /* got length */
4752                 s->packet_len = ntohl(*(uint32_t *)s->buf);
4753                 s->index = 0;
4754                 s->state = 1;
4755             }
4756             break;
4757         case 1:
4758             l = s->packet_len - s->index;
4759             if (l > size)
4760                 l = size;
4761             memcpy(s->buf + s->index, buf, l);
4762             s->index += l;
4763             buf += l;
4764             size -= l;
4765             if (s->index >= s->packet_len) {
4766                 qemu_send_packet(s->vc, s->buf, s->packet_len);
4767                 s->index = 0;
4768                 s->state = 0;
4769             }
4770             break;
4771         }
4772     }
4773 }
4774
4775 static void net_socket_send_dgram(void *opaque)
4776 {
4777     NetSocketState *s = opaque;
4778     int size;
4779
4780     size = recv(s->fd, s->buf, sizeof(s->buf), 0);
4781     if (size < 0)
4782         return;
4783     if (size == 0) {
4784         /* end of connection */
4785         qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
4786         return;
4787     }
4788     qemu_send_packet(s->vc, s->buf, size);
4789 }
4790
4791 static int net_socket_mcast_create(struct sockaddr_in *mcastaddr)
4792 {
4793     struct ip_mreq imr;
4794     int fd;
4795     int val, ret;
4796     if (!IN_MULTICAST(ntohl(mcastaddr->sin_addr.s_addr))) {
4797         fprintf(stderr, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
4798                 inet_ntoa(mcastaddr->sin_addr),
4799                 (int)ntohl(mcastaddr->sin_addr.s_addr));
4800         return -1;
4801
4802     }
4803     fd = socket(PF_INET, SOCK_DGRAM, 0);
4804     if (fd < 0) {
4805         perror("socket(PF_INET, SOCK_DGRAM)");
4806         return -1;
4807     }
4808
4809     val = 1;
4810     ret=setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
4811                    (const char *)&val, sizeof(val));
4812     if (ret < 0) {
4813         perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
4814         goto fail;
4815     }
4816
4817     ret = bind(fd, (struct sockaddr *)mcastaddr, sizeof(*mcastaddr));
4818     if (ret < 0) {
4819         perror("bind");
4820         goto fail;
4821     }
4822
4823     /* Add host to multicast group */
4824     imr.imr_multiaddr = mcastaddr->sin_addr;
4825     imr.imr_interface.s_addr = htonl(INADDR_ANY);
4826
4827     ret = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
4828                      (const char *)&imr, sizeof(struct ip_mreq));
4829     if (ret < 0) {
4830         perror("setsockopt(IP_ADD_MEMBERSHIP)");
4831         goto fail;
4832     }
4833
4834     /* Force mcast msgs to loopback (eg. several QEMUs in same host */
4835     val = 1;
4836     ret=setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
4837                    (const char *)&val, sizeof(val));
4838     if (ret < 0) {
4839         perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
4840         goto fail;
4841     }
4842
4843     socket_set_nonblock(fd);
4844     return fd;
4845 fail:
4846     if (fd >= 0)
4847         closesocket(fd);
4848     return -1;
4849 }
4850
4851 static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan, int fd,
4852                                           int is_connected)
4853 {
4854     struct sockaddr_in saddr;
4855     int newfd;
4856     socklen_t saddr_len;
4857     NetSocketState *s;
4858
4859     /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
4860      * Because this may be "shared" socket from a "master" process, datagrams would be recv()
4861      * by ONLY ONE process: we must "clone" this dgram socket --jjo
4862      */
4863
4864     if (is_connected) {
4865         if (getsockname(fd, (struct sockaddr *) &saddr, &saddr_len) == 0) {
4866             /* must be bound */
4867             if (saddr.sin_addr.s_addr==0) {
4868                 fprintf(stderr, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
4869                         fd);
4870                 return NULL;
4871             }
4872             /* clone dgram socket */
4873             newfd = net_socket_mcast_create(&saddr);
4874             if (newfd < 0) {
4875                 /* error already reported by net_socket_mcast_create() */
4876                 close(fd);
4877                 return NULL;
4878             }
4879             /* clone newfd to fd, close newfd */
4880             dup2(newfd, fd);
4881             close(newfd);
4882
4883         } else {
4884             fprintf(stderr, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
4885                     fd, strerror(errno));
4886             return NULL;
4887         }
4888     }
4889
4890     s = qemu_mallocz(sizeof(NetSocketState));
4891     if (!s)
4892         return NULL;
4893     s->fd = fd;
4894
4895     s->vc = qemu_new_vlan_client(vlan, net_socket_receive_dgram, NULL, s);
4896     qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s);
4897
4898     /* mcast: save bound address as dst */
4899     if (is_connected) s->dgram_dst=saddr;
4900
4901     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4902             "socket: fd=%d (%s mcast=%s:%d)",
4903             fd, is_connected? "cloned" : "",
4904             inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4905     return s;
4906 }
4907
4908 static void net_socket_connect(void *opaque)
4909 {
4910     NetSocketState *s = opaque;
4911     qemu_set_fd_handler(s->fd, net_socket_send, NULL, s);
4912 }
4913
4914 static NetSocketState *net_socket_fd_init_stream(VLANState *vlan, int fd,
4915                                           int is_connected)
4916 {
4917     NetSocketState *s;
4918     s = qemu_mallocz(sizeof(NetSocketState));
4919     if (!s)
4920         return NULL;
4921     s->fd = fd;
4922     s->vc = qemu_new_vlan_client(vlan,
4923                                  net_socket_receive, NULL, s);
4924     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4925              "socket: fd=%d", fd);
4926     if (is_connected) {
4927         net_socket_connect(s);
4928     } else {
4929         qemu_set_fd_handler(s->fd, NULL, net_socket_connect, s);
4930     }
4931     return s;
4932 }
4933
4934 static NetSocketState *net_socket_fd_init(VLANState *vlan, int fd,
4935                                           int is_connected)
4936 {
4937     int so_type=-1, optlen=sizeof(so_type);
4938
4939     if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type,
4940         (socklen_t *)&optlen)< 0) {
4941         fprintf(stderr, "qemu: error: getsockopt(SO_TYPE) for fd=%d failed\n", fd);
4942         return NULL;
4943     }
4944     switch(so_type) {
4945     case SOCK_DGRAM:
4946         return net_socket_fd_init_dgram(vlan, fd, is_connected);
4947     case SOCK_STREAM:
4948         return net_socket_fd_init_stream(vlan, fd, is_connected);
4949     default:
4950         /* who knows ... this could be a eg. a pty, do warn and continue as stream */
4951         fprintf(stderr, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type, fd);
4952         return net_socket_fd_init_stream(vlan, fd, is_connected);
4953     }
4954     return NULL;
4955 }
4956
4957 static void net_socket_accept(void *opaque)
4958 {
4959     NetSocketListenState *s = opaque;
4960     NetSocketState *s1;
4961     struct sockaddr_in saddr;
4962     socklen_t len;
4963     int fd;
4964
4965     for(;;) {
4966         len = sizeof(saddr);
4967         fd = accept(s->fd, (struct sockaddr *)&saddr, &len);
4968         if (fd < 0 && errno != EINTR) {
4969             return;
4970         } else if (fd >= 0) {
4971             break;
4972         }
4973     }
4974     s1 = net_socket_fd_init(s->vlan, fd, 1);
4975     if (!s1) {
4976         closesocket(fd);
4977     } else {
4978         snprintf(s1->vc->info_str, sizeof(s1->vc->info_str),
4979                  "socket: connection from %s:%d",
4980                  inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4981     }
4982 }
4983
4984 static int net_socket_listen_init(VLANState *vlan, const char *host_str)
4985 {
4986     NetSocketListenState *s;
4987     int fd, val, ret;
4988     struct sockaddr_in saddr;
4989
4990     if (parse_host_port(&saddr, host_str) < 0)
4991         return -1;
4992
4993     s = qemu_mallocz(sizeof(NetSocketListenState));
4994     if (!s)
4995         return -1;
4996
4997     fd = socket(PF_INET, SOCK_STREAM, 0);
4998     if (fd < 0) {
4999         perror("socket");
5000         return -1;
5001     }
5002     socket_set_nonblock(fd);
5003
5004     /* allow fast reuse */
5005     val = 1;
5006     setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
5007
5008     ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
5009     if (ret < 0) {
5010         perror("bind");
5011         return -1;
5012     }
5013     ret = listen(fd, 0);
5014     if (ret < 0) {
5015         perror("listen");
5016         return -1;
5017     }
5018     s->vlan = vlan;
5019     s->fd = fd;
5020     qemu_set_fd_handler(fd, net_socket_accept, NULL, s);
5021     return 0;
5022 }
5023
5024 static int net_socket_connect_init(VLANState *vlan, const char *host_str)
5025 {
5026     NetSocketState *s;
5027     int fd, connected, ret, err;
5028     struct sockaddr_in saddr;
5029
5030     if (parse_host_port(&saddr, host_str) < 0)
5031         return -1;
5032
5033     fd = socket(PF_INET, SOCK_STREAM, 0);
5034     if (fd < 0) {
5035         perror("socket");
5036         return -1;
5037     }
5038     socket_set_nonblock(fd);
5039
5040     connected = 0;
5041     for(;;) {
5042         ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
5043         if (ret < 0) {
5044             err = socket_error();
5045             if (err == EINTR || err == EWOULDBLOCK) {
5046             } else if (err == EINPROGRESS) {
5047                 break;
5048 #ifdef _WIN32
5049             } else if (err == WSAEALREADY) {
5050                 break;
5051 #endif
5052             } else {
5053                 perror("connect");
5054                 closesocket(fd);
5055                 return -1;
5056             }
5057         } else {
5058             connected = 1;
5059             break;
5060         }
5061     }
5062     s = net_socket_fd_init(vlan, fd, connected);
5063     if (!s)
5064         return -1;
5065     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
5066              "socket: connect to %s:%d",
5067              inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
5068     return 0;
5069 }
5070
5071 static int net_socket_mcast_init(VLANState *vlan, const char *host_str)
5072 {
5073     NetSocketState *s;
5074     int fd;
5075     struct sockaddr_in saddr;
5076
5077     if (parse_host_port(&saddr, host_str) < 0)
5078         return -1;
5079
5080
5081     fd = net_socket_mcast_create(&saddr);
5082     if (fd < 0)
5083         return -1;
5084
5085     s = net_socket_fd_init(vlan, fd, 0);
5086     if (!s)
5087         return -1;
5088
5089     s->dgram_dst = saddr;
5090
5091     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
5092              "socket: mcast=%s:%d",
5093              inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
5094     return 0;
5095
5096 }
5097
5098 static const char *get_opt_name(char *buf, int buf_size, const char *p)
5099 {
5100     char *q;
5101
5102     q = buf;
5103     while (*p != '\0' && *p != '=') {
5104         if (q && (q - buf) < buf_size - 1)
5105             *q++ = *p;
5106         p++;
5107     }
5108     if (q)
5109         *q = '\0';
5110
5111     return p;
5112 }
5113
5114 static const char *get_opt_value(char *buf, int buf_size, const char *p)
5115 {
5116     char *q;
5117
5118     q = buf;
5119     while (*p != '\0') {
5120         if (*p == ',') {
5121             if (*(p + 1) != ',')
5122                 break;
5123             p++;
5124         }
5125         if (q && (q - buf) < buf_size - 1)
5126             *q++ = *p;
5127         p++;
5128     }
5129     if (q)
5130         *q = '\0';
5131
5132     return p;
5133 }
5134
5135 static int get_param_value(char *buf, int buf_size,
5136                            const char *tag, const char *str)
5137 {
5138     const char *p;
5139     char option[128];
5140
5141     p = str;
5142     for(;;) {
5143         p = get_opt_name(option, sizeof(option), p);
5144         if (*p != '=')
5145             break;
5146         p++;
5147         if (!strcmp(tag, option)) {
5148             (void)get_opt_value(buf, buf_size, p);
5149             return strlen(buf);
5150         } else {
5151             p = get_opt_value(NULL, 0, p);
5152         }
5153         if (*p != ',')
5154             break;
5155         p++;
5156     }
5157     return 0;
5158 }
5159
5160 static int check_params(char *buf, int buf_size,
5161                         const char * const *params, const char *str)
5162 {
5163     const char *p;
5164     int i;
5165
5166     p = str;
5167     for(;;) {
5168         p = get_opt_name(buf, buf_size, p);
5169         if (*p != '=')
5170             return -1;
5171         p++;
5172         for(i = 0; params[i] != NULL; i++)
5173             if (!strcmp(params[i], buf))
5174                 break;
5175         if (params[i] == NULL)
5176             return -1;
5177         p = get_opt_value(NULL, 0, p);
5178         if (*p != ',')
5179             break;
5180         p++;
5181     }
5182     return 0;
5183 }
5184
5185 static int net_client_init(const char *device, const char *p)
5186 {
5187     char buf[1024];
5188     int vlan_id, ret;
5189     VLANState *vlan;
5190
5191     vlan_id = 0;
5192     if (get_param_value(buf, sizeof(buf), "vlan", p)) {
5193         vlan_id = strtol(buf, NULL, 0);
5194     }
5195     vlan = qemu_find_vlan(vlan_id);
5196     if (!vlan) {
5197         fprintf(stderr, "Could not create vlan %d\n", vlan_id);
5198         return -1;
5199     }
5200     if (!strcmp(device, "nic")) {
5201         NICInfo *nd;
5202         uint8_t *macaddr;
5203
5204         if (nb_nics >= MAX_NICS) {
5205             fprintf(stderr, "Too Many NICs\n");
5206             return -1;
5207         }
5208         nd = &nd_table[nb_nics];
5209         macaddr = nd->macaddr;
5210         macaddr[0] = 0x52;
5211         macaddr[1] = 0x54;
5212         macaddr[2] = 0x00;
5213         macaddr[3] = 0x12;
5214         macaddr[4] = 0x34;
5215         macaddr[5] = 0x56 + nb_nics;
5216
5217         if (get_param_value(buf, sizeof(buf), "macaddr", p)) {
5218             if (parse_macaddr(macaddr, buf) < 0) {
5219                 fprintf(stderr, "invalid syntax for ethernet address\n");
5220                 return -1;
5221             }
5222         }
5223         if (get_param_value(buf, sizeof(buf), "model", p)) {
5224             nd->model = strdup(buf);
5225         }
5226         nd->vlan = vlan;
5227         nb_nics++;
5228         vlan->nb_guest_devs++;
5229         ret = 0;
5230     } else
5231     if (!strcmp(device, "none")) {
5232         /* does nothing. It is needed to signal that no network cards
5233            are wanted */
5234         ret = 0;
5235     } else
5236 #ifdef CONFIG_SLIRP
5237     if (!strcmp(device, "user")) {
5238         if (get_param_value(buf, sizeof(buf), "hostname", p)) {
5239             pstrcpy(slirp_hostname, sizeof(slirp_hostname), buf);
5240         }
5241         vlan->nb_host_devs++;
5242         ret = net_slirp_init(vlan);
5243     } else
5244 #endif
5245 #ifdef _WIN32
5246     if (!strcmp(device, "tap")) {
5247         char ifname[64];
5248         if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
5249             fprintf(stderr, "tap: no interface name\n");
5250             return -1;
5251         }
5252         vlan->nb_host_devs++;
5253         ret = tap_win32_init(vlan, ifname);
5254     } else
5255 #else
5256     if (!strcmp(device, "tap")) {
5257         char ifname[64];
5258         char setup_script[1024], down_script[1024];
5259         int fd;
5260         vlan->nb_host_devs++;
5261         if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
5262             fd = strtol(buf, NULL, 0);
5263             fcntl(fd, F_SETFL, O_NONBLOCK);
5264             ret = -1;
5265             if (net_tap_fd_init(vlan, fd))
5266                 ret = 0;
5267         } else {
5268             if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
5269                 ifname[0] = '\0';
5270             }
5271             if (get_param_value(setup_script, sizeof(setup_script), "script", p) == 0) {
5272                 pstrcpy(setup_script, sizeof(setup_script), DEFAULT_NETWORK_SCRIPT);
5273             }
5274             if (get_param_value(down_script, sizeof(down_script), "downscript", p) == 0) {
5275                 pstrcpy(down_script, sizeof(down_script), DEFAULT_NETWORK_DOWN_SCRIPT);
5276             }
5277             ret = net_tap_init(vlan, ifname, setup_script, down_script);
5278         }
5279     } else
5280 #endif
5281     if (!strcmp(device, "socket")) {
5282         if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
5283             int fd;
5284             fd = strtol(buf, NULL, 0);
5285             ret = -1;
5286             if (net_socket_fd_init(vlan, fd, 1))
5287                 ret = 0;
5288         } else if (get_param_value(buf, sizeof(buf), "listen", p) > 0) {
5289             ret = net_socket_listen_init(vlan, buf);
5290         } else if (get_param_value(buf, sizeof(buf), "connect", p) > 0) {
5291             ret = net_socket_connect_init(vlan, buf);
5292         } else if (get_param_value(buf, sizeof(buf), "mcast", p) > 0) {
5293             ret = net_socket_mcast_init(vlan, buf);
5294         } else {
5295             fprintf(stderr, "Unknown socket options: %s\n", p);
5296             return -1;
5297         }
5298         vlan->nb_host_devs++;
5299     } else
5300 #ifdef CONFIG_VDE
5301     if (!strcmp(device, "vde")) {
5302         char vde_sock[1024], vde_group[512];
5303         int vde_port, vde_mode;
5304         vlan->nb_host_devs++;
5305         if (get_param_value(vde_sock, sizeof(vde_sock), "sock", p) <= 0) {
5306             vde_sock[0] = '\0';
5307         }
5308         if (get_param_value(buf, sizeof(buf), "port", p) > 0) {
5309             vde_port = strtol(buf, NULL, 10);
5310         } else {
5311             vde_port = 0;
5312         }
5313         if (get_param_value(vde_group, sizeof(vde_group), "group", p) <= 0) {
5314             vde_group[0] = '\0';
5315         }
5316         if (get_param_value(buf, sizeof(buf), "mode", p) > 0) {
5317             vde_mode = strtol(buf, NULL, 8);
5318         } else {
5319             vde_mode = 0700;
5320         }
5321         ret = net_vde_init(vlan, vde_sock, vde_port, vde_group, vde_mode);
5322     } else
5323 #endif
5324     {
5325         fprintf(stderr, "Unknown network device: %s\n", device);
5326         return -1;
5327     }
5328     if (ret < 0) {
5329         fprintf(stderr, "Could not initialize device '%s'\n", device);
5330     }
5331
5332     return ret;
5333 }
5334
5335 static int net_client_parse(const char *str)
5336 {
5337     const char *p;
5338     char *q;
5339     char device[64];
5340
5341     p = str;
5342     q = device;
5343     while (*p != '\0' && *p != ',') {
5344         if ((q - device) < sizeof(device) - 1)
5345             *q++ = *p;
5346         p++;
5347     }
5348     *q = '\0';
5349     if (*p == ',')
5350         p++;
5351
5352     return net_client_init(device, p);
5353 }
5354
5355 void do_info_network(void)
5356 {
5357     VLANState *vlan;
5358     VLANClientState *vc;
5359
5360     for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
5361         term_printf("VLAN %d devices:\n", vlan->id);
5362         for(vc = vlan->first_client; vc != NULL; vc = vc->next)
5363             term_printf("  %s\n", vc->info_str);
5364     }
5365 }
5366
5367 /***********************************************************/
5368 /* Bluetooth support */
5369 static int nb_hcis;
5370 static int cur_hci;
5371 static struct HCIInfo *hci_table[MAX_NICS];
5372 static struct bt_vlan_s {
5373     struct bt_scatternet_s net;
5374     int id;
5375     struct bt_vlan_s *next;
5376 } *first_bt_vlan;
5377
5378 /* find or alloc a new bluetooth "VLAN" */
5379 static struct bt_scatternet_s *qemu_find_bt_vlan(int id)
5380 {
5381     struct bt_vlan_s **pvlan, *vlan;
5382     for (vlan = first_bt_vlan; vlan != NULL; vlan = vlan->next) {
5383         if (vlan->id == id)
5384             return &vlan->net;
5385     }
5386     vlan = qemu_mallocz(sizeof(struct bt_vlan_s));
5387     vlan->id = id;
5388     pvlan = &first_bt_vlan;
5389     while (*pvlan != NULL)
5390         pvlan = &(*pvlan)->next;
5391     *pvlan = vlan;
5392     return &vlan->net;
5393 }
5394
5395 static void null_hci_send(struct HCIInfo *hci, const uint8_t *data, int len)
5396 {
5397 }
5398
5399 static int null_hci_addr_set(struct HCIInfo *hci, const uint8_t *bd_addr)
5400 {
5401     return -ENOTSUP;
5402 }
5403
5404 static struct HCIInfo null_hci = {
5405     .cmd_send = null_hci_send,
5406     .sco_send = null_hci_send,
5407     .acl_send = null_hci_send,
5408     .bdaddr_set = null_hci_addr_set,
5409 };
5410
5411 struct HCIInfo *qemu_next_hci(void)
5412 {
5413     if (cur_hci == nb_hcis)
5414         return &null_hci;
5415
5416     return hci_table[cur_hci++];
5417 }
5418
5419 /***********************************************************/
5420 /* QEMU Block devices */
5421
5422 #define HD_ALIAS "index=%d,media=disk"
5423 #ifdef TARGET_PPC
5424 #define CDROM_ALIAS "index=1,media=cdrom"
5425 #else
5426 #define CDROM_ALIAS "index=2,media=cdrom"
5427 #endif
5428 #define FD_ALIAS "index=%d,if=floppy"
5429 #define PFLASH_ALIAS "if=pflash"
5430 #define MTD_ALIAS "if=mtd"
5431 #define SD_ALIAS "index=0,if=sd"
5432
5433 static int drive_add(const char *file, const char *fmt, ...)
5434 {
5435     va_list ap;
5436
5437     if (nb_drives_opt >= MAX_DRIVES) {
5438         fprintf(stderr, "qemu: too many drives\n");
5439         exit(1);
5440     }
5441
5442     drives_opt[nb_drives_opt].file = file;
5443     va_start(ap, fmt);
5444     vsnprintf(drives_opt[nb_drives_opt].opt,
5445               sizeof(drives_opt[0].opt), fmt, ap);
5446     va_end(ap);
5447
5448     return nb_drives_opt++;
5449 }
5450
5451 int drive_get_index(BlockInterfaceType type, int bus, int unit)
5452 {
5453     int index;
5454
5455     /* seek interface, bus and unit */
5456
5457     for (index = 0; index < nb_drives; index++)
5458         if (drives_table[index].type == type &&
5459             drives_table[index].bus == bus &&
5460             drives_table[index].unit == unit)
5461         return index;
5462
5463     return -1;
5464 }
5465
5466 int drive_get_max_bus(BlockInterfaceType type)
5467 {
5468     int max_bus;
5469     int index;
5470
5471     max_bus = -1;
5472     for (index = 0; index < nb_drives; index++) {
5473         if(drives_table[index].type == type &&
5474            drives_table[index].bus > max_bus)
5475             max_bus = drives_table[index].bus;
5476     }
5477     return max_bus;
5478 }
5479
5480 static void bdrv_format_print(void *opaque, const char *name)
5481 {
5482     fprintf(stderr, " %s", name);
5483 }
5484
5485 static int drive_init(struct drive_opt *arg, int snapshot,
5486                       QEMUMachine *machine)
5487 {
5488     char buf[128];
5489     char file[1024];
5490     char devname[128];
5491     const char *mediastr = "";
5492     BlockInterfaceType type;
5493     enum { MEDIA_DISK, MEDIA_CDROM } media;
5494     int bus_id, unit_id;
5495     int cyls, heads, secs, translation;
5496     BlockDriverState *bdrv;
5497     BlockDriver *drv = NULL;
5498     int max_devs;
5499     int index;
5500     int cache;
5501     int bdrv_flags;
5502     char *str = arg->opt;
5503     static const char * const params[] = { "bus", "unit", "if", "index",
5504                                            "cyls", "heads", "secs", "trans",
5505                                            "media", "snapshot", "file",
5506                                            "cache", "format", NULL };
5507
5508     if (check_params(buf, sizeof(buf), params, str) < 0) {
5509          fprintf(stderr, "qemu: unknown parameter '%s' in '%s'\n",
5510                          buf, str);
5511          return -1;
5512     }
5513
5514     file[0] = 0;
5515     cyls = heads = secs = 0;
5516     bus_id = 0;
5517     unit_id = -1;
5518     translation = BIOS_ATA_TRANSLATION_AUTO;
5519     index = -1;
5520     cache = 1;
5521
5522     if (machine->use_scsi) {
5523         type = IF_SCSI;
5524         max_devs = MAX_SCSI_DEVS;
5525         pstrcpy(devname, sizeof(devname), "scsi");
5526     } else {
5527         type = IF_IDE;
5528         max_devs = MAX_IDE_DEVS;
5529         pstrcpy(devname, sizeof(devname), "ide");
5530     }
5531     media = MEDIA_DISK;
5532
5533     /* extract parameters */
5534
5535     if (get_param_value(buf, sizeof(buf), "bus", str)) {
5536         bus_id = strtol(buf, NULL, 0);
5537         if (bus_id < 0) {
5538             fprintf(stderr, "qemu: '%s' invalid bus id\n", str);
5539             return -1;
5540         }
5541     }
5542
5543     if (get_param_value(buf, sizeof(buf), "unit", str)) {
5544         unit_id = strtol(buf, NULL, 0);
5545         if (unit_id < 0) {
5546             fprintf(stderr, "qemu: '%s' invalid unit id\n", str);
5547             return -1;
5548         }
5549     }
5550
5551     if (get_param_value(buf, sizeof(buf), "if", str)) {
5552         pstrcpy(devname, sizeof(devname), buf);
5553         if (!strcmp(buf, "ide")) {
5554             type = IF_IDE;
5555             max_devs = MAX_IDE_DEVS;
5556         } else if (!strcmp(buf, "scsi")) {
5557             type = IF_SCSI;
5558             max_devs = MAX_SCSI_DEVS;
5559         } else if (!strcmp(buf, "floppy")) {
5560             type = IF_FLOPPY;
5561             max_devs = 0;
5562         } else if (!strcmp(buf, "pflash")) {
5563             type = IF_PFLASH;
5564             max_devs = 0;
5565         } else if (!strcmp(buf, "mtd")) {
5566             type = IF_MTD;
5567             max_devs = 0;
5568         } else if (!strcmp(buf, "sd")) {
5569             type = IF_SD;
5570             max_devs = 0;
5571         } else {
5572             fprintf(stderr, "qemu: '%s' unsupported bus type '%s'\n", str, buf);
5573             return -1;
5574         }
5575     }
5576
5577     if (get_param_value(buf, sizeof(buf), "index", str)) {
5578         index = strtol(buf, NULL, 0);
5579         if (index < 0) {
5580             fprintf(stderr, "qemu: '%s' invalid index\n", str);
5581             return -1;
5582         }
5583     }
5584
5585     if (get_param_value(buf, sizeof(buf), "cyls", str)) {
5586         cyls = strtol(buf, NULL, 0);
5587     }
5588
5589     if (get_param_value(buf, sizeof(buf), "heads", str)) {
5590         heads = strtol(buf, NULL, 0);
5591     }
5592
5593     if (get_param_value(buf, sizeof(buf), "secs", str)) {
5594         secs = strtol(buf, NULL, 0);
5595     }
5596
5597     if (cyls || heads || secs) {
5598         if (cyls < 1 || cyls > 16383) {
5599             fprintf(stderr, "qemu: '%s' invalid physical cyls number\n", str);
5600             return -1;
5601         }
5602         if (heads < 1 || heads > 16) {
5603             fprintf(stderr, "qemu: '%s' invalid physical heads number\n", str);
5604             return -1;
5605         }
5606         if (secs < 1 || secs > 63) {
5607             fprintf(stderr, "qemu: '%s' invalid physical secs number\n", str);
5608             return -1;
5609         }
5610     }
5611
5612     if (get_param_value(buf, sizeof(buf), "trans", str)) {
5613         if (!cyls) {
5614             fprintf(stderr,
5615                     "qemu: '%s' trans must be used with cyls,heads and secs\n",
5616                     str);
5617             return -1;
5618         }
5619         if (!strcmp(buf, "none"))
5620             translation = BIOS_ATA_TRANSLATION_NONE;
5621         else if (!strcmp(buf, "lba"))
5622             translation = BIOS_ATA_TRANSLATION_LBA;
5623         else if (!strcmp(buf, "auto"))
5624             translation = BIOS_ATA_TRANSLATION_AUTO;
5625         else {
5626             fprintf(stderr, "qemu: '%s' invalid translation type\n", str);
5627             return -1;
5628         }
5629     }
5630
5631     if (get_param_value(buf, sizeof(buf), "media", str)) {
5632         if (!strcmp(buf, "disk")) {
5633             media = MEDIA_DISK;
5634         } else if (!strcmp(buf, "cdrom")) {
5635             if (cyls || secs || heads) {
5636                 fprintf(stderr,
5637                         "qemu: '%s' invalid physical CHS format\n", str);
5638                 return -1;
5639             }
5640             media = MEDIA_CDROM;
5641         } else {
5642             fprintf(stderr, "qemu: '%s' invalid media\n", str);
5643             return -1;
5644         }
5645     }
5646
5647     if (get_param_value(buf, sizeof(buf), "snapshot", str)) {
5648         if (!strcmp(buf, "on"))
5649             snapshot = 1;
5650         else if (!strcmp(buf, "off"))
5651             snapshot = 0;
5652         else {
5653             fprintf(stderr, "qemu: '%s' invalid snapshot option\n", str);
5654             return -1;
5655         }
5656     }
5657
5658     if (get_param_value(buf, sizeof(buf), "cache", str)) {
5659         if (!strcmp(buf, "off"))
5660             cache = 0;
5661         else if (!strcmp(buf, "on"))
5662             cache = 1;
5663         else {
5664            fprintf(stderr, "qemu: invalid cache option\n");
5665            return -1;
5666         }
5667     }
5668
5669     if (get_param_value(buf, sizeof(buf), "format", str)) {
5670        if (strcmp(buf, "?") == 0) {
5671             fprintf(stderr, "qemu: Supported formats:");
5672             bdrv_iterate_format(bdrv_format_print, NULL);
5673             fprintf(stderr, "\n");
5674             return -1;
5675         }
5676         drv = bdrv_find_format(buf);
5677         if (!drv) {
5678             fprintf(stderr, "qemu: '%s' invalid format\n", buf);
5679             return -1;
5680         }
5681     }
5682
5683     if (arg->file == NULL)
5684         get_param_value(file, sizeof(file), "file", str);
5685     else
5686         pstrcpy(file, sizeof(file), arg->file);
5687
5688     /* compute bus and unit according index */
5689
5690     if (index != -1) {
5691         if (bus_id != 0 || unit_id != -1) {
5692             fprintf(stderr,
5693                     "qemu: '%s' index cannot be used with bus and unit\n", str);
5694             return -1;
5695         }
5696         if (max_devs == 0)
5697         {
5698             unit_id = index;
5699             bus_id = 0;
5700         } else {
5701             unit_id = index % max_devs;
5702             bus_id = index / max_devs;
5703         }
5704     }
5705
5706     /* if user doesn't specify a unit_id,
5707      * try to find the first free
5708      */
5709
5710     if (unit_id == -1) {
5711        unit_id = 0;
5712        while (drive_get_index(type, bus_id, unit_id) != -1) {
5713            unit_id++;
5714            if (max_devs && unit_id >= max_devs) {
5715                unit_id -= max_devs;
5716                bus_id++;
5717            }
5718        }
5719     }
5720
5721     /* check unit id */
5722
5723     if (max_devs && unit_id >= max_devs) {
5724         fprintf(stderr, "qemu: '%s' unit %d too big (max is %d)\n",
5725                         str, unit_id, max_devs - 1);
5726         return -1;
5727     }
5728
5729     /*
5730      * ignore multiple definitions
5731      */
5732
5733     if (drive_get_index(type, bus_id, unit_id) != -1)
5734         return 0;
5735
5736     /* init */
5737
5738     if (type == IF_IDE || type == IF_SCSI)
5739         mediastr = (media == MEDIA_CDROM) ? "-cd" : "-hd";
5740     if (max_devs)
5741         snprintf(buf, sizeof(buf), "%s%i%s%i",
5742                  devname, bus_id, mediastr, unit_id);
5743     else
5744         snprintf(buf, sizeof(buf), "%s%s%i",
5745                  devname, mediastr, unit_id);
5746     bdrv = bdrv_new(buf);
5747     drives_table[nb_drives].bdrv = bdrv;
5748     drives_table[nb_drives].type = type;
5749     drives_table[nb_drives].bus = bus_id;
5750     drives_table[nb_drives].unit = unit_id;
5751     nb_drives++;
5752
5753     switch(type) {
5754     case IF_IDE:
5755     case IF_SCSI:
5756         switch(media) {
5757         case MEDIA_DISK:
5758             if (cyls != 0) {
5759                 bdrv_set_geometry_hint(bdrv, cyls, heads, secs);
5760                 bdrv_set_translation_hint(bdrv, translation);
5761             }
5762             break;
5763         case MEDIA_CDROM:
5764             bdrv_set_type_hint(bdrv, BDRV_TYPE_CDROM);
5765             break;
5766         }
5767         break;
5768     case IF_SD:
5769         /* FIXME: This isn't really a floppy, but it's a reasonable
5770            approximation.  */
5771     case IF_FLOPPY:
5772         bdrv_set_type_hint(bdrv, BDRV_TYPE_FLOPPY);
5773         break;
5774     case IF_PFLASH:
5775     case IF_MTD:
5776         break;
5777     }
5778     if (!file[0])
5779         return 0;
5780     bdrv_flags = 0;
5781     if (snapshot)
5782         bdrv_flags |= BDRV_O_SNAPSHOT;
5783     if (!cache)
5784         bdrv_flags |= BDRV_O_DIRECT;
5785     if (bdrv_open2(bdrv, file, bdrv_flags, drv) < 0 || qemu_key_check(bdrv, file)) {
5786         fprintf(stderr, "qemu: could not open disk image %s\n",
5787                         file);
5788         return -1;
5789     }
5790     return 0;
5791 }
5792
5793 /***********************************************************/
5794 /* USB devices */
5795
5796 static USBPort *used_usb_ports;
5797 static USBPort *free_usb_ports;
5798
5799 /* ??? Maybe change this to register a hub to keep track of the topology.  */
5800 void qemu_register_usb_port(USBPort *port, void *opaque, int index,
5801                             usb_attachfn attach)
5802 {
5803     port->opaque = opaque;
5804     port->index = index;
5805     port->attach = attach;
5806     port->next = free_usb_ports;
5807     free_usb_ports = port;
5808 }
5809
5810 int usb_device_add_dev(USBDevice *dev)
5811 {
5812     USBPort *port;
5813
5814     /* Find a USB port to add the device to.  */
5815     port = free_usb_ports;
5816     if (!port->next) {
5817         USBDevice *hub;
5818
5819         /* Create a new hub and chain it on.  */
5820         free_usb_ports = NULL;
5821         port->next = used_usb_ports;
5822         used_usb_ports = port;
5823
5824         hub = usb_hub_init(VM_USB_HUB_SIZE);
5825         usb_attach(port, hub);
5826         port = free_usb_ports;
5827     }
5828
5829     free_usb_ports = port->next;
5830     port->next = used_usb_ports;
5831     used_usb_ports = port;
5832     usb_attach(port, dev);
5833     return 0;
5834 }
5835
5836 static int usb_device_add(const char *devname)
5837 {
5838     const char *p;
5839     USBDevice *dev;
5840
5841     if (!free_usb_ports)
5842         return -1;
5843
5844     if (strstart(devname, "host:", &p)) {
5845         dev = usb_host_device_open(p);
5846     } else if (!strcmp(devname, "mouse")) {
5847         dev = usb_mouse_init();
5848     } else if (!strcmp(devname, "tablet")) {
5849         dev = usb_tablet_init();
5850     } else if (!strcmp(devname, "keyboard")) {
5851         dev = usb_keyboard_init();
5852     } else if (strstart(devname, "disk:", &p)) {
5853         dev = usb_msd_init(p);
5854     } else if (!strcmp(devname, "wacom-tablet")) {
5855         dev = usb_wacom_init();
5856     } else if (strstart(devname, "serial:", &p)) {
5857         dev = usb_serial_init(p);
5858 #ifdef CONFIG_BRLAPI
5859     } else if (!strcmp(devname, "braille")) {
5860         dev = usb_baum_init();
5861 #endif
5862     } else if (strstart(devname, "net:", &p)) {
5863         int nic = nb_nics;
5864
5865         if (net_client_init("nic", p) < 0)
5866             return -1;
5867         nd_table[nic].model = "usb";
5868         dev = usb_net_init(&nd_table[nic]);
5869     } else {
5870         return -1;
5871     }
5872     if (!dev)
5873         return -1;
5874
5875     return usb_device_add_dev(dev);
5876 }
5877
5878 int usb_device_del_addr(int bus_num, int addr)
5879 {
5880     USBPort *port;
5881     USBPort **lastp;
5882     USBDevice *dev;
5883
5884     if (!used_usb_ports)
5885         return -1;
5886
5887     if (bus_num != 0)
5888         return -1;
5889
5890     lastp = &used_usb_ports;
5891     port = used_usb_ports;
5892     while (port && port->dev->addr != addr) {
5893         lastp = &port->next;
5894         port = port->next;
5895     }
5896
5897     if (!port)
5898         return -1;
5899
5900     dev = port->dev;
5901     *lastp = port->next;
5902     usb_attach(port, NULL);
5903     dev->handle_destroy(dev);
5904     port->next = free_usb_ports;
5905     free_usb_ports = port;
5906     return 0;
5907 }
5908
5909 static int usb_device_del(const char *devname)
5910 {
5911     int bus_num, addr;
5912     const char *p;
5913
5914     if (strstart(devname, "host:", &p))
5915         return usb_host_device_close(p);
5916
5917     if (!used_usb_ports)
5918         return -1;
5919
5920     p = strchr(devname, '.');
5921     if (!p)
5922         return -1;
5923     bus_num = strtoul(devname, NULL, 0);
5924     addr = strtoul(p + 1, NULL, 0);
5925
5926     return usb_device_del_addr(bus_num, addr);
5927 }
5928
5929 void do_usb_add(const char *devname)
5930 {
5931     usb_device_add(devname);
5932 }
5933
5934 void do_usb_del(const char *devname)
5935 {
5936     usb_device_del(devname);
5937 }
5938
5939 void usb_info(void)
5940 {
5941     USBDevice *dev;
5942     USBPort *port;
5943     const char *speed_str;
5944
5945     if (!usb_enabled) {
5946         term_printf("USB support not enabled\n");
5947         return;
5948     }
5949
5950     for (port = used_usb_ports; port; port = port->next) {
5951         dev = port->dev;
5952         if (!dev)
5953             continue;
5954         switch(dev->speed) {
5955         case USB_SPEED_LOW:
5956             speed_str = "1.5";
5957             break;
5958         case USB_SPEED_FULL:
5959             speed_str = "12";
5960             break;
5961         case USB_SPEED_HIGH:
5962             speed_str = "480";
5963             break;
5964         default:
5965             speed_str = "?";
5966             break;
5967         }
5968         term_printf("  Device %d.%d, Speed %s Mb/s, Product %s\n",
5969                     0, dev->addr, speed_str, dev->devname);
5970     }
5971 }
5972
5973 /***********************************************************/
5974 /* PCMCIA/Cardbus */
5975
5976 static struct pcmcia_socket_entry_s {
5977     struct pcmcia_socket_s *socket;
5978     struct pcmcia_socket_entry_s *next;
5979 } *pcmcia_sockets = 0;
5980
5981 void pcmcia_socket_register(struct pcmcia_socket_s *socket)
5982 {
5983     struct pcmcia_socket_entry_s *entry;
5984
5985     entry = qemu_malloc(sizeof(struct pcmcia_socket_entry_s));
5986     entry->socket = socket;
5987     entry->next = pcmcia_sockets;
5988     pcmcia_sockets = entry;
5989 }
5990
5991 void pcmcia_socket_unregister(struct pcmcia_socket_s *socket)
5992 {
5993     struct pcmcia_socket_entry_s *entry, **ptr;
5994
5995     ptr = &pcmcia_sockets;
5996     for (entry = *ptr; entry; ptr = &entry->next, entry = *ptr)
5997         if (entry->socket == socket) {
5998             *ptr = entry->next;
5999             qemu_free(entry);
6000         }
6001 }
6002
6003 void pcmcia_info(void)
6004 {
6005     struct pcmcia_socket_entry_s *iter;
6006     if (!pcmcia_sockets)
6007         term_printf("No PCMCIA sockets\n");
6008
6009     for (iter = pcmcia_sockets; iter; iter = iter->next)
6010         term_printf("%s: %s\n", iter->socket->slot_string,
6011                     iter->socket->attached ? iter->socket->card_string :
6012                     "Empty");
6013 }
6014
6015 /***********************************************************/
6016 /* dumb display */
6017
6018 static void dumb_update(DisplayState *ds, int x, int y, int w, int h)
6019 {
6020 }
6021
6022 static void dumb_resize(DisplayState *ds, int w, int h)
6023 {
6024 }
6025
6026 static void dumb_refresh(DisplayState *ds)
6027 {
6028 #if defined(CONFIG_SDL)
6029     vga_hw_update();
6030 #endif
6031 }
6032
6033 static void dumb_display_init(DisplayState *ds)
6034 {
6035     ds->data = NULL;
6036     ds->linesize = 0;
6037     ds->depth = 0;
6038     ds->dpy_update = dumb_update;
6039     ds->dpy_resize = dumb_resize;
6040     ds->dpy_refresh = dumb_refresh;
6041     ds->gui_timer_interval = 500;
6042     ds->idle = 1;
6043 }
6044
6045 /***********************************************************/
6046 /* I/O handling */
6047
6048 #define MAX_IO_HANDLERS 64
6049
6050 typedef struct IOHandlerRecord {
6051     int fd;
6052     IOCanRWHandler *fd_read_poll;
6053     IOHandler *fd_read;
6054     IOHandler *fd_write;
6055     int deleted;
6056     void *opaque;
6057     /* temporary data */
6058     struct pollfd *ufd;
6059     struct IOHandlerRecord *next;
6060 } IOHandlerRecord;
6061
6062 static IOHandlerRecord *first_io_handler;
6063
6064 /* XXX: fd_read_poll should be suppressed, but an API change is
6065    necessary in the character devices to suppress fd_can_read(). */
6066 int qemu_set_fd_handler2(int fd,
6067                          IOCanRWHandler *fd_read_poll,
6068                          IOHandler *fd_read,
6069                          IOHandler *fd_write,
6070                          void *opaque)
6071 {
6072     IOHandlerRecord **pioh, *ioh;
6073
6074     if (!fd_read && !fd_write) {
6075         pioh = &first_io_handler;
6076         for(;;) {
6077             ioh = *pioh;
6078             if (ioh == NULL)
6079                 break;
6080             if (ioh->fd == fd) {
6081                 ioh->deleted = 1;
6082                 break;
6083             }
6084             pioh = &ioh->next;
6085         }
6086     } else {
6087         for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
6088             if (ioh->fd == fd)
6089                 goto found;
6090         }
6091         ioh = qemu_mallocz(sizeof(IOHandlerRecord));
6092         if (!ioh)
6093             return -1;
6094         ioh->next = first_io_handler;
6095         first_io_handler = ioh;
6096     found:
6097         ioh->fd = fd;
6098         ioh->fd_read_poll = fd_read_poll;
6099         ioh->fd_read = fd_read;
6100         ioh->fd_write = fd_write;
6101         ioh->opaque = opaque;
6102         ioh->deleted = 0;
6103     }
6104     return 0;
6105 }
6106
6107 int qemu_set_fd_handler(int fd,
6108                         IOHandler *fd_read,
6109                         IOHandler *fd_write,
6110                         void *opaque)
6111 {
6112     return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);
6113 }
6114
6115 /***********************************************************/
6116 /* Polling handling */
6117
6118 typedef struct PollingEntry {
6119     PollingFunc *func;
6120     void *opaque;
6121     struct PollingEntry *next;
6122 } PollingEntry;
6123
6124 static PollingEntry *first_polling_entry;
6125
6126 int qemu_add_polling_cb(PollingFunc *func, void *opaque)
6127 {
6128     PollingEntry **ppe, *pe;
6129     pe = qemu_mallocz(sizeof(PollingEntry));
6130     if (!pe)
6131         return -1;
6132     pe->func = func;
6133     pe->opaque = opaque;
6134     for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next);
6135     *ppe = pe;
6136     return 0;
6137 }
6138
6139 void qemu_del_polling_cb(PollingFunc *func, void *opaque)
6140 {
6141     PollingEntry **ppe, *pe;
6142     for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next) {
6143         pe = *ppe;
6144         if (pe->func == func && pe->opaque == opaque) {
6145             *ppe = pe->next;
6146             qemu_free(pe);
6147             break;
6148         }
6149     }
6150 }
6151
6152 #ifdef _WIN32
6153 /***********************************************************/
6154 /* Wait objects support */
6155 typedef struct WaitObjects {
6156     int num;
6157     HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
6158     WaitObjectFunc *func[MAXIMUM_WAIT_OBJECTS + 1];
6159     void *opaque[MAXIMUM_WAIT_OBJECTS + 1];
6160 } WaitObjects;
6161
6162 static WaitObjects wait_objects = {0};
6163
6164 int qemu_add_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
6165 {
6166     WaitObjects *w = &wait_objects;
6167
6168     if (w->num >= MAXIMUM_WAIT_OBJECTS)
6169         return -1;
6170     w->events[w->num] = handle;
6171     w->func[w->num] = func;
6172     w->opaque[w->num] = opaque;
6173     w->num++;
6174     return 0;
6175 }
6176
6177 void qemu_del_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
6178 {
6179     int i, found;
6180     WaitObjects *w = &wait_objects;
6181
6182     found = 0;
6183     for (i = 0; i < w->num; i++) {
6184         if (w->events[i] == handle)
6185             found = 1;
6186         if (found) {
6187             w->events[i] = w->events[i + 1];
6188             w->func[i] = w->func[i + 1];
6189             w->opaque[i] = w->opaque[i + 1];
6190         }
6191     }
6192     if (found)
6193         w->num--;
6194 }
6195 #endif
6196
6197 /***********************************************************/
6198 /* savevm/loadvm support */
6199
6200 #define IO_BUF_SIZE 32768
6201
6202 struct QEMUFile {
6203     QEMUFilePutBufferFunc *put_buffer;
6204     QEMUFileGetBufferFunc *get_buffer;
6205     QEMUFileCloseFunc *close;
6206     QEMUFileRateLimit *rate_limit;
6207     void *opaque;
6208
6209     int64_t buf_offset; /* start of buffer when writing, end of buffer
6210                            when reading */
6211     int buf_index;
6212     int buf_size; /* 0 when writing */
6213     uint8_t buf[IO_BUF_SIZE];
6214 };
6215
6216 typedef struct QEMUFileFD
6217 {
6218     int fd;
6219     QEMUFile *file;
6220 } QEMUFileFD;
6221
6222 static void fd_put_notify(void *opaque)
6223 {
6224     QEMUFileFD *s = opaque;
6225
6226     /* Remove writable callback and do a put notify */
6227     qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
6228     qemu_file_put_notify(s->file);
6229 }
6230
6231 static void fd_put_buffer(void *opaque, const uint8_t *buf,
6232                           int64_t pos, int size)
6233 {
6234     QEMUFileFD *s = opaque;
6235     ssize_t len;
6236
6237     do {
6238         len = write(s->fd, buf, size);
6239     } while (len == -1 && errno == EINTR);
6240
6241     if (len == -1)
6242         len = -errno;
6243
6244     /* When the fd becomes writable again, register a callback to do
6245      * a put notify */
6246     if (len == -EAGAIN)
6247         qemu_set_fd_handler2(s->fd, NULL, NULL, fd_put_notify, s);
6248 }
6249
6250 static int fd_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
6251 {
6252     QEMUFileFD *s = opaque;
6253     ssize_t len;
6254
6255     do {
6256         len = read(s->fd, buf, size);
6257     } while (len == -1 && errno == EINTR);
6258
6259     if (len == -1)
6260         len = -errno;
6261
6262     return len;
6263 }
6264
6265 static int fd_close(void *opaque)
6266 {
6267     QEMUFileFD *s = opaque;
6268     qemu_free(s);
6269     return 0;
6270 }
6271
6272 QEMUFile *qemu_fopen_fd(int fd)
6273 {
6274     QEMUFileFD *s = qemu_mallocz(sizeof(QEMUFileFD));
6275
6276     if (s == NULL)
6277         return NULL;
6278
6279     s->fd = fd;
6280     s->file = qemu_fopen_ops(s, fd_put_buffer, fd_get_buffer, fd_close, NULL);
6281     return s->file;
6282 }
6283
6284 typedef struct QEMUFileStdio
6285 {
6286     FILE *outfile;
6287 } QEMUFileStdio;
6288
6289 static void file_put_buffer(void *opaque, const uint8_t *buf,
6290                             int64_t pos, int size)
6291 {
6292     QEMUFileStdio *s = opaque;
6293     fseek(s->outfile, pos, SEEK_SET);
6294     fwrite(buf, 1, size, s->outfile);
6295 }
6296
6297 static int file_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
6298 {
6299     QEMUFileStdio *s = opaque;
6300     fseek(s->outfile, pos, SEEK_SET);
6301     return fread(buf, 1, size, s->outfile);
6302 }
6303
6304 static int file_close(void *opaque)
6305 {
6306     QEMUFileStdio *s = opaque;
6307     fclose(s->outfile);
6308     qemu_free(s);
6309     return 0;
6310 }
6311
6312 QEMUFile *qemu_fopen(const char *filename, const char *mode)
6313 {
6314     QEMUFileStdio *s;
6315
6316     s = qemu_mallocz(sizeof(QEMUFileStdio));
6317     if (!s)
6318         return NULL;
6319
6320     s->outfile = fopen(filename, mode);
6321     if (!s->outfile)
6322         goto fail;
6323
6324     if (!strcmp(mode, "wb"))
6325         return qemu_fopen_ops(s, file_put_buffer, NULL, file_close, NULL);
6326     else if (!strcmp(mode, "rb"))
6327         return qemu_fopen_ops(s, NULL, file_get_buffer, file_close, NULL);
6328
6329 fail:
6330     if (s->outfile)
6331         fclose(s->outfile);
6332     qemu_free(s);
6333     return NULL;
6334 }
6335
6336 typedef struct QEMUFileBdrv
6337 {
6338     BlockDriverState *bs;
6339     int64_t base_offset;
6340 } QEMUFileBdrv;
6341
6342 static void bdrv_put_buffer(void *opaque, const uint8_t *buf,
6343                             int64_t pos, int size)
6344 {
6345     QEMUFileBdrv *s = opaque;
6346     bdrv_pwrite(s->bs, s->base_offset + pos, buf, size);
6347 }
6348
6349 static int bdrv_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
6350 {
6351     QEMUFileBdrv *s = opaque;
6352     return bdrv_pread(s->bs, s->base_offset + pos, buf, size);
6353 }
6354
6355 static int bdrv_fclose(void *opaque)
6356 {
6357     QEMUFileBdrv *s = opaque;
6358     qemu_free(s);
6359     return 0;
6360 }
6361
6362 static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int64_t offset, int is_writable)
6363 {
6364     QEMUFileBdrv *s;
6365
6366     s = qemu_mallocz(sizeof(QEMUFileBdrv));
6367     if (!s)
6368         return NULL;
6369
6370     s->bs = bs;
6371     s->base_offset = offset;
6372
6373     if (is_writable)
6374         return qemu_fopen_ops(s, bdrv_put_buffer, NULL, bdrv_fclose, NULL);
6375
6376     return qemu_fopen_ops(s, NULL, bdrv_get_buffer, bdrv_fclose, NULL);
6377 }
6378
6379 QEMUFile *qemu_fopen_ops(void *opaque, QEMUFilePutBufferFunc *put_buffer,
6380                          QEMUFileGetBufferFunc *get_buffer,
6381                          QEMUFileCloseFunc *close,
6382                          QEMUFileRateLimit *rate_limit)
6383 {
6384     QEMUFile *f;
6385
6386     f = qemu_mallocz(sizeof(QEMUFile));
6387     if (!f)
6388         return NULL;
6389
6390     f->opaque = opaque;
6391     f->put_buffer = put_buffer;
6392     f->get_buffer = get_buffer;
6393     f->close = close;
6394     f->rate_limit = rate_limit;
6395
6396     return f;
6397 }
6398
6399 void qemu_fflush(QEMUFile *f)
6400 {
6401     if (!f->put_buffer)
6402         return;
6403
6404     if (f->buf_index > 0) {
6405         f->put_buffer(f->opaque, f->buf, f->buf_offset, f->buf_index);
6406         f->buf_offset += f->buf_index;
6407         f->buf_index = 0;
6408     }
6409 }
6410
6411 static void qemu_fill_buffer(QEMUFile *f)
6412 {
6413     int len;
6414
6415     if (!f->get_buffer)
6416         return;
6417
6418     len = f->get_buffer(f->opaque, f->buf, f->buf_offset, IO_BUF_SIZE);
6419     if (len < 0)
6420         len = 0;
6421
6422     f->buf_index = 0;
6423     f->buf_size = len;
6424     f->buf_offset += len;
6425 }
6426
6427 int qemu_fclose(QEMUFile *f)
6428 {
6429     int ret = 0;
6430     qemu_fflush(f);
6431     if (f->close)
6432         ret = f->close(f->opaque);
6433     qemu_free(f);
6434     return ret;
6435 }
6436
6437 void qemu_file_put_notify(QEMUFile *f)
6438 {
6439     f->put_buffer(f->opaque, NULL, 0, 0);
6440 }
6441
6442 void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
6443 {
6444     int l;
6445     while (size > 0) {
6446         l = IO_BUF_SIZE - f->buf_index;
6447         if (l > size)
6448             l = size;
6449         memcpy(f->buf + f->buf_index, buf, l);
6450         f->buf_index += l;
6451         buf += l;
6452         size -= l;
6453         if (f->buf_index >= IO_BUF_SIZE)
6454             qemu_fflush(f);
6455     }
6456 }
6457
6458 void qemu_put_byte(QEMUFile *f, int v)
6459 {
6460     f->buf[f->buf_index++] = v;
6461     if (f->buf_index >= IO_BUF_SIZE)
6462         qemu_fflush(f);
6463 }
6464
6465 int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size1)
6466 {
6467     int size, l;
6468
6469     size = size1;
6470     while (size > 0) {
6471         l = f->buf_size - f->buf_index;
6472         if (l == 0) {
6473             qemu_fill_buffer(f);
6474             l = f->buf_size - f->buf_index;
6475             if (l == 0)
6476                 break;
6477         }
6478         if (l > size)
6479             l = size;
6480         memcpy(buf, f->buf + f->buf_index, l);
6481         f->buf_index += l;
6482         buf += l;
6483         size -= l;
6484     }
6485     return size1 - size;
6486 }
6487
6488 int qemu_get_byte(QEMUFile *f)
6489 {
6490     if (f->buf_index >= f->buf_size) {
6491         qemu_fill_buffer(f);
6492         if (f->buf_index >= f->buf_size)
6493             return 0;
6494     }
6495     return f->buf[f->buf_index++];
6496 }
6497
6498 int64_t qemu_ftell(QEMUFile *f)
6499 {
6500     return f->buf_offset - f->buf_size + f->buf_index;
6501 }
6502
6503 int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence)
6504 {
6505     if (whence == SEEK_SET) {
6506         /* nothing to do */
6507     } else if (whence == SEEK_CUR) {
6508         pos += qemu_ftell(f);
6509     } else {
6510         /* SEEK_END not supported */
6511         return -1;
6512     }
6513     if (f->put_buffer) {
6514         qemu_fflush(f);
6515         f->buf_offset = pos;
6516     } else {
6517         f->buf_offset = pos;
6518         f->buf_index = 0;
6519         f->buf_size = 0;
6520     }
6521     return pos;
6522 }
6523
6524 int qemu_file_rate_limit(QEMUFile *f)
6525 {
6526     if (f->rate_limit)
6527         return f->rate_limit(f->opaque);
6528
6529     return 0;
6530 }
6531
6532 void qemu_put_be16(QEMUFile *f, unsigned int v)
6533 {
6534     qemu_put_byte(f, v >> 8);
6535     qemu_put_byte(f, v);
6536 }
6537
6538 void qemu_put_be32(QEMUFile *f, unsigned int v)
6539 {
6540     qemu_put_byte(f, v >> 24);
6541     qemu_put_byte(f, v >> 16);
6542     qemu_put_byte(f, v >> 8);
6543     qemu_put_byte(f, v);
6544 }
6545
6546 void qemu_put_be64(QEMUFile *f, uint64_t v)
6547 {
6548     qemu_put_be32(f, v >> 32);
6549     qemu_put_be32(f, v);
6550 }
6551
6552 unsigned int qemu_get_be16(QEMUFile *f)
6553 {
6554     unsigned int v;
6555     v = qemu_get_byte(f) << 8;
6556     v |= qemu_get_byte(f);
6557     return v;
6558 }
6559
6560 unsigned int qemu_get_be32(QEMUFile *f)
6561 {
6562     unsigned int v;
6563     v = qemu_get_byte(f) << 24;
6564     v |= qemu_get_byte(f) << 16;
6565     v |= qemu_get_byte(f) << 8;
6566     v |= qemu_get_byte(f);
6567     return v;
6568 }
6569
6570 uint64_t qemu_get_be64(QEMUFile *f)
6571 {
6572     uint64_t v;
6573     v = (uint64_t)qemu_get_be32(f) << 32;
6574     v |= qemu_get_be32(f);
6575     return v;
6576 }
6577
6578 typedef struct SaveStateEntry {
6579     char idstr[256];
6580     int instance_id;
6581     int version_id;
6582     SaveStateHandler *save_state;
6583     LoadStateHandler *load_state;
6584     void *opaque;
6585     struct SaveStateEntry *next;
6586 } SaveStateEntry;
6587
6588 static SaveStateEntry *first_se;
6589
6590 /* TODO: Individual devices generally have very little idea about the rest
6591    of the system, so instance_id should be removed/replaced.
6592    Meanwhile pass -1 as instance_id if you do not already have a clearly
6593    distinguishing id for all instances of your device class. */
6594 int register_savevm(const char *idstr,
6595                     int instance_id,
6596                     int version_id,
6597                     SaveStateHandler *save_state,
6598                     LoadStateHandler *load_state,
6599                     void *opaque)
6600 {
6601     SaveStateEntry *se, **pse;
6602
6603     se = qemu_malloc(sizeof(SaveStateEntry));
6604     if (!se)
6605         return -1;
6606     pstrcpy(se->idstr, sizeof(se->idstr), idstr);
6607     se->instance_id = (instance_id == -1) ? 0 : instance_id;
6608     se->version_id = version_id;
6609     se->save_state = save_state;
6610     se->load_state = load_state;
6611     se->opaque = opaque;
6612     se->next = NULL;
6613
6614     /* add at the end of list */
6615     pse = &first_se;
6616     while (*pse != NULL) {
6617         if (instance_id == -1
6618                 && strcmp(se->idstr, (*pse)->idstr) == 0
6619                 && se->instance_id <= (*pse)->instance_id)
6620             se->instance_id = (*pse)->instance_id + 1;
6621         pse = &(*pse)->next;
6622     }
6623     *pse = se;
6624     return 0;
6625 }
6626
6627 #define QEMU_VM_FILE_MAGIC   0x5145564d
6628 #define QEMU_VM_FILE_VERSION 0x00000002
6629
6630 static int qemu_savevm_state(QEMUFile *f)
6631 {
6632     SaveStateEntry *se;
6633     int len, ret;
6634     int64_t cur_pos, len_pos, total_len_pos;
6635
6636     qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
6637     qemu_put_be32(f, QEMU_VM_FILE_VERSION);
6638     total_len_pos = qemu_ftell(f);
6639     qemu_put_be64(f, 0); /* total size */
6640
6641     for(se = first_se; se != NULL; se = se->next) {
6642         if (se->save_state == NULL)
6643             /* this one has a loader only, for backwards compatibility */
6644             continue;
6645
6646         /* ID string */
6647         len = strlen(se->idstr);
6648         qemu_put_byte(f, len);
6649         qemu_put_buffer(f, (uint8_t *)se->idstr, len);
6650
6651         qemu_put_be32(f, se->instance_id);
6652         qemu_put_be32(f, se->version_id);
6653
6654         /* record size: filled later */
6655         len_pos = qemu_ftell(f);
6656         qemu_put_be32(f, 0);
6657         se->save_state(f, se->opaque);
6658
6659         /* fill record size */
6660         cur_pos = qemu_ftell(f);
6661         len = cur_pos - len_pos - 4;
6662         qemu_fseek(f, len_pos, SEEK_SET);
6663         qemu_put_be32(f, len);
6664         qemu_fseek(f, cur_pos, SEEK_SET);
6665     }
6666     cur_pos = qemu_ftell(f);
6667     qemu_fseek(f, total_len_pos, SEEK_SET);
6668     qemu_put_be64(f, cur_pos - total_len_pos - 8);
6669     qemu_fseek(f, cur_pos, SEEK_SET);
6670
6671     ret = 0;
6672     return ret;
6673 }
6674
6675 static SaveStateEntry *find_se(const char *idstr, int instance_id)
6676 {
6677     SaveStateEntry *se;
6678
6679     for(se = first_se; se != NULL; se = se->next) {
6680         if (!strcmp(se->idstr, idstr) &&
6681             instance_id == se->instance_id)
6682             return se;
6683     }
6684     return NULL;
6685 }
6686
6687 static int qemu_loadvm_state(QEMUFile *f)
6688 {
6689     SaveStateEntry *se;
6690     int len, ret, instance_id, record_len, version_id;
6691     int64_t total_len, end_pos, cur_pos;
6692     unsigned int v;
6693     char idstr[256];
6694
6695     v = qemu_get_be32(f);
6696     if (v != QEMU_VM_FILE_MAGIC)
6697         goto fail;
6698     v = qemu_get_be32(f);
6699     if (v != QEMU_VM_FILE_VERSION) {
6700     fail:
6701         ret = -1;
6702         goto the_end;
6703     }
6704     total_len = qemu_get_be64(f);
6705     end_pos = total_len + qemu_ftell(f);
6706     for(;;) {
6707         if (qemu_ftell(f) >= end_pos)
6708             break;
6709         len = qemu_get_byte(f);
6710         qemu_get_buffer(f, (uint8_t *)idstr, len);
6711         idstr[len] = '\0';
6712         instance_id = qemu_get_be32(f);
6713         version_id = qemu_get_be32(f);
6714         record_len = qemu_get_be32(f);
6715 #if 0
6716         printf("idstr=%s instance=0x%x version=%d len=%d\n",
6717                idstr, instance_id, version_id, record_len);
6718 #endif
6719         cur_pos = qemu_ftell(f);
6720         se = find_se(idstr, instance_id);
6721         if (!se) {
6722             fprintf(stderr, "qemu: warning: instance 0x%x of device '%s' not present in current VM\n",
6723                     instance_id, idstr);
6724         } else {
6725             ret = se->load_state(f, se->opaque, version_id);
6726             if (ret < 0) {
6727                 fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
6728                         instance_id, idstr);
6729             }
6730         }
6731         /* always seek to exact end of record */
6732         qemu_fseek(f, cur_pos + record_len, SEEK_SET);
6733     }
6734     ret = 0;
6735  the_end:
6736     return ret;
6737 }
6738
6739 /* device can contain snapshots */
6740 static int bdrv_can_snapshot(BlockDriverState *bs)
6741 {
6742     return (bs &&
6743             !bdrv_is_removable(bs) &&
6744             !bdrv_is_read_only(bs));
6745 }
6746
6747 /* device must be snapshots in order to have a reliable snapshot */
6748 static int bdrv_has_snapshot(BlockDriverState *bs)
6749 {
6750     return (bs &&
6751             !bdrv_is_removable(bs) &&
6752             !bdrv_is_read_only(bs));
6753 }
6754
6755 static BlockDriverState *get_bs_snapshots(void)
6756 {
6757     BlockDriverState *bs;
6758     int i;
6759
6760     if (bs_snapshots)
6761         return bs_snapshots;
6762     for(i = 0; i <= nb_drives; i++) {
6763         bs = drives_table[i].bdrv;
6764         if (bdrv_can_snapshot(bs))
6765             goto ok;
6766     }
6767     return NULL;
6768  ok:
6769     bs_snapshots = bs;
6770     return bs;
6771 }
6772
6773 static int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,
6774                               const char *name)
6775 {
6776     QEMUSnapshotInfo *sn_tab, *sn;
6777     int nb_sns, i, ret;
6778
6779     ret = -ENOENT;
6780     nb_sns = bdrv_snapshot_list(bs, &sn_tab);
6781     if (nb_sns < 0)
6782         return ret;
6783     for(i = 0; i < nb_sns; i++) {
6784         sn = &sn_tab[i];
6785         if (!strcmp(sn->id_str, name) || !strcmp(sn->name, name)) {
6786             *sn_info = *sn;
6787             ret = 0;
6788             break;
6789         }
6790     }
6791     qemu_free(sn_tab);
6792     return ret;
6793 }
6794
6795 void do_savevm(const char *name)
6796 {
6797     BlockDriverState *bs, *bs1;
6798     QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
6799     int must_delete, ret, i;
6800     BlockDriverInfo bdi1, *bdi = &bdi1;
6801     QEMUFile *f;
6802     int saved_vm_running;
6803 #ifdef _WIN32
6804     struct _timeb tb;
6805 #else
6806     struct timeval tv;
6807 #endif
6808
6809     bs = get_bs_snapshots();
6810     if (!bs) {
6811         term_printf("No block device can accept snapshots\n");
6812         return;
6813     }
6814
6815     /* ??? Should this occur after vm_stop?  */
6816     qemu_aio_flush();
6817
6818     saved_vm_running = vm_running;
6819     vm_stop(0);
6820
6821     must_delete = 0;
6822     if (name) {
6823         ret = bdrv_snapshot_find(bs, old_sn, name);
6824         if (ret >= 0) {
6825             must_delete = 1;
6826         }
6827     }
6828     memset(sn, 0, sizeof(*sn));
6829     if (must_delete) {
6830         pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
6831         pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
6832     } else {
6833         if (name)
6834             pstrcpy(sn->name, sizeof(sn->name), name);
6835     }
6836
6837     /* fill auxiliary fields */
6838 #ifdef _WIN32
6839     _ftime(&tb);
6840     sn->date_sec = tb.time;
6841     sn->date_nsec = tb.millitm * 1000000;
6842 #else
6843     gettimeofday(&tv, NULL);
6844     sn->date_sec = tv.tv_sec;
6845     sn->date_nsec = tv.tv_usec * 1000;
6846 #endif
6847     sn->vm_clock_nsec = qemu_get_clock(vm_clock);
6848
6849     if (bdrv_get_info(bs, bdi) < 0 || bdi->vm_state_offset <= 0) {
6850         term_printf("Device %s does not support VM state snapshots\n",
6851                     bdrv_get_device_name(bs));
6852         goto the_end;
6853     }
6854
6855     /* save the VM state */
6856     f = qemu_fopen_bdrv(bs, bdi->vm_state_offset, 1);
6857     if (!f) {
6858         term_printf("Could not open VM state file\n");
6859         goto the_end;
6860     }
6861     ret = qemu_savevm_state(f);
6862     sn->vm_state_size = qemu_ftell(f);
6863     qemu_fclose(f);
6864     if (ret < 0) {
6865         term_printf("Error %d while writing VM\n", ret);
6866         goto the_end;
6867     }
6868
6869     /* create the snapshots */
6870
6871     for(i = 0; i < nb_drives; i++) {
6872         bs1 = drives_table[i].bdrv;
6873         if (bdrv_has_snapshot(bs1)) {
6874             if (must_delete) {
6875                 ret = bdrv_snapshot_delete(bs1, old_sn->id_str);
6876                 if (ret < 0) {
6877                     term_printf("Error while deleting snapshot on '%s'\n",
6878                                 bdrv_get_device_name(bs1));
6879                 }
6880             }
6881             ret = bdrv_snapshot_create(bs1, sn);
6882             if (ret < 0) {
6883                 term_printf("Error while creating snapshot on '%s'\n",
6884                             bdrv_get_device_name(bs1));
6885             }
6886         }
6887     }
6888
6889  the_end:
6890     if (saved_vm_running)
6891         vm_start();
6892 }
6893
6894 void do_loadvm(const char *name)
6895 {
6896     BlockDriverState *bs, *bs1;
6897     BlockDriverInfo bdi1, *bdi = &bdi1;
6898     QEMUFile *f;
6899     int i, ret;
6900     int saved_vm_running;
6901
6902     bs = get_bs_snapshots();
6903     if (!bs) {
6904         term_printf("No block device supports snapshots\n");
6905         return;
6906     }
6907
6908     /* Flush all IO requests so they don't interfere with the new state.  */
6909     qemu_aio_flush();
6910
6911     saved_vm_running = vm_running;
6912     vm_stop(0);
6913
6914     for(i = 0; i <= nb_drives; i++) {
6915         bs1 = drives_table[i].bdrv;
6916         if (bdrv_has_snapshot(bs1)) {
6917             ret = bdrv_snapshot_goto(bs1, name);
6918             if (ret < 0) {
6919                 if (bs != bs1)
6920                     term_printf("Warning: ");
6921                 switch(ret) {
6922                 case -ENOTSUP:
6923                     term_printf("Snapshots not supported on device '%s'\n",
6924                                 bdrv_get_device_name(bs1));
6925                     break;
6926                 case -ENOENT:
6927                     term_printf("Could not find snapshot '%s' on device '%s'\n",
6928                                 name, bdrv_get_device_name(bs1));
6929                     break;
6930                 default:
6931                     term_printf("Error %d while activating snapshot on '%s'\n",
6932                                 ret, bdrv_get_device_name(bs1));
6933                     break;
6934                 }
6935                 /* fatal on snapshot block device */
6936                 if (bs == bs1)
6937                     goto the_end;
6938             }
6939         }
6940     }
6941
6942     if (bdrv_get_info(bs, bdi) < 0 || bdi->vm_state_offset <= 0) {
6943         term_printf("Device %s does not support VM state snapshots\n",
6944                     bdrv_get_device_name(bs));
6945         return;
6946     }
6947
6948     /* restore the VM state */
6949     f = qemu_fopen_bdrv(bs, bdi->vm_state_offset, 0);
6950     if (!f) {
6951         term_printf("Could not open VM state file\n");
6952         goto the_end;
6953     }
6954     ret = qemu_loadvm_state(f);
6955     qemu_fclose(f);
6956     if (ret < 0) {
6957         term_printf("Error %d while loading VM state\n", ret);
6958     }
6959  the_end:
6960     if (saved_vm_running)
6961         vm_start();
6962 }
6963
6964 void do_delvm(const char *name)
6965 {
6966     BlockDriverState *bs, *bs1;
6967     int i, ret;
6968
6969     bs = get_bs_snapshots();
6970     if (!bs) {
6971         term_printf("No block device supports snapshots\n");
6972         return;
6973     }
6974
6975     for(i = 0; i <= nb_drives; i++) {
6976         bs1 = drives_table[i].bdrv;
6977         if (bdrv_has_snapshot(bs1)) {
6978             ret = bdrv_snapshot_delete(bs1, name);
6979             if (ret < 0) {
6980                 if (ret == -ENOTSUP)
6981                     term_printf("Snapshots not supported on device '%s'\n",
6982                                 bdrv_get_device_name(bs1));
6983                 else
6984                     term_printf("Error %d while deleting snapshot on '%s'\n",
6985                                 ret, bdrv_get_device_name(bs1));
6986             }
6987         }
6988     }
6989 }
6990
6991 void do_info_snapshots(void)
6992 {
6993     BlockDriverState *bs, *bs1;
6994     QEMUSnapshotInfo *sn_tab, *sn;
6995     int nb_sns, i;
6996     char buf[256];
6997
6998     bs = get_bs_snapshots();
6999     if (!bs) {
7000         term_printf("No available block device supports snapshots\n");
7001         return;
7002     }
7003     term_printf("Snapshot devices:");
7004     for(i = 0; i <= nb_drives; i++) {
7005         bs1 = drives_table[i].bdrv;
7006         if (bdrv_has_snapshot(bs1)) {
7007             if (bs == bs1)
7008                 term_printf(" %s", bdrv_get_device_name(bs1));
7009         }
7010     }
7011     term_printf("\n");
7012
7013     nb_sns = bdrv_snapshot_list(bs, &sn_tab);
7014     if (nb_sns < 0) {
7015         term_printf("bdrv_snapshot_list: error %d\n", nb_sns);
7016         return;
7017     }
7018     term_printf("Snapshot list (from %s):\n", bdrv_get_device_name(bs));
7019     term_printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
7020     for(i = 0; i < nb_sns; i++) {
7021         sn = &sn_tab[i];
7022         term_printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
7023     }
7024     qemu_free(sn_tab);
7025 }
7026
7027 /***********************************************************/
7028 /* ram save/restore */
7029
7030 static int ram_get_page(QEMUFile *f, uint8_t *buf, int len)
7031 {
7032     int v;
7033
7034     v = qemu_get_byte(f);
7035     switch(v) {
7036     case 0:
7037         if (qemu_get_buffer(f, buf, len) != len)
7038             return -EIO;
7039         break;
7040     case 1:
7041         v = qemu_get_byte(f);
7042         memset(buf, v, len);
7043         break;
7044     default:
7045         return -EINVAL;
7046     }
7047     return 0;
7048 }
7049
7050 static int ram_load_v1(QEMUFile *f, void *opaque)
7051 {
7052     int ret;
7053     ram_addr_t i;
7054
7055     if (qemu_get_be32(f) != phys_ram_size)
7056         return -EINVAL;
7057     for(i = 0; i < phys_ram_size; i+= TARGET_PAGE_SIZE) {
7058         ret = ram_get_page(f, phys_ram_base + i, TARGET_PAGE_SIZE);
7059         if (ret)
7060             return ret;
7061     }
7062     return 0;
7063 }
7064
7065 #define BDRV_HASH_BLOCK_SIZE 1024
7066 #define IOBUF_SIZE 4096
7067 #define RAM_CBLOCK_MAGIC 0xfabe
7068
7069 typedef struct RamCompressState {
7070     z_stream zstream;
7071     QEMUFile *f;
7072     uint8_t buf[IOBUF_SIZE];
7073 } RamCompressState;
7074
7075 static int ram_compress_open(RamCompressState *s, QEMUFile *f)
7076 {
7077     int ret;
7078     memset(s, 0, sizeof(*s));
7079     s->f = f;
7080     ret = deflateInit2(&s->zstream, 1,
7081                        Z_DEFLATED, 15,
7082                        9, Z_DEFAULT_STRATEGY);
7083     if (ret != Z_OK)
7084         return -1;
7085     s->zstream.avail_out = IOBUF_SIZE;
7086     s->zstream.next_out = s->buf;
7087     return 0;
7088 }
7089
7090 static void ram_put_cblock(RamCompressState *s, const uint8_t *buf, int len)
7091 {
7092     qemu_put_be16(s->f, RAM_CBLOCK_MAGIC);
7093     qemu_put_be16(s->f, len);
7094     qemu_put_buffer(s->f, buf, len);
7095 }
7096
7097 static int ram_compress_buf(RamCompressState *s, const uint8_t *buf, int len)
7098 {
7099     int ret;
7100
7101     s->zstream.avail_in = len;
7102     s->zstream.next_in = (uint8_t *)buf;
7103     while (s->zstream.avail_in > 0) {
7104         ret = deflate(&s->zstream, Z_NO_FLUSH);
7105         if (ret != Z_OK)
7106             return -1;
7107         if (s->zstream.avail_out == 0) {
7108             ram_put_cblock(s, s->buf, IOBUF_SIZE);
7109             s->zstream.avail_out = IOBUF_SIZE;
7110             s->zstream.next_out = s->buf;
7111         }
7112     }
7113     return 0;
7114 }
7115
7116 static void ram_compress_close(RamCompressState *s)
7117 {
7118     int len, ret;
7119
7120     /* compress last bytes */
7121     for(;;) {
7122         ret = deflate(&s->zstream, Z_FINISH);
7123         if (ret == Z_OK || ret == Z_STREAM_END) {
7124             len = IOBUF_SIZE - s->zstream.avail_out;
7125             if (len > 0) {
7126                 ram_put_cblock(s, s->buf, len);
7127             }
7128             s->zstream.avail_out = IOBUF_SIZE;
7129             s->zstream.next_out = s->buf;
7130             if (ret == Z_STREAM_END)
7131                 break;
7132         } else {
7133             goto fail;
7134         }
7135     }
7136 fail:
7137     deflateEnd(&s->zstream);
7138 }
7139
7140 typedef struct RamDecompressState {
7141     z_stream zstream;
7142     QEMUFile *f;
7143     uint8_t buf[IOBUF_SIZE];
7144 } RamDecompressState;
7145
7146 static int ram_decompress_open(RamDecompressState *s, QEMUFile *f)
7147 {
7148     int ret;
7149     memset(s, 0, sizeof(*s));
7150     s->f = f;
7151     ret = inflateInit(&s->zstream);
7152     if (ret != Z_OK)
7153         return -1;
7154     return 0;
7155 }
7156
7157 static int ram_decompress_buf(RamDecompressState *s, uint8_t *buf, int len)
7158 {
7159     int ret, clen;
7160
7161     s->zstream.avail_out = len;
7162     s->zstream.next_out = buf;
7163     while (s->zstream.avail_out > 0) {
7164         if (s->zstream.avail_in == 0) {
7165             if (qemu_get_be16(s->f) != RAM_CBLOCK_MAGIC)
7166                 return -1;
7167             clen = qemu_get_be16(s->f);
7168             if (clen > IOBUF_SIZE)
7169                 return -1;
7170             qemu_get_buffer(s->f, s->buf, clen);
7171             s->zstream.avail_in = clen;
7172             s->zstream.next_in = s->buf;
7173         }
7174         ret = inflate(&s->zstream, Z_PARTIAL_FLUSH);
7175         if (ret != Z_OK && ret != Z_STREAM_END) {
7176             return -1;
7177         }
7178     }
7179     return 0;
7180 }
7181
7182 static void ram_decompress_close(RamDecompressState *s)
7183 {
7184     inflateEnd(&s->zstream);
7185 }
7186
7187 static void ram_save(QEMUFile *f, void *opaque)
7188 {
7189     ram_addr_t i;
7190     RamCompressState s1, *s = &s1;
7191     uint8_t buf[10];
7192
7193     qemu_put_be32(f, phys_ram_size);
7194     if (ram_compress_open(s, f) < 0)
7195         return;
7196     for(i = 0; i < phys_ram_size; i+= BDRV_HASH_BLOCK_SIZE) {
7197 #if 0
7198         if (tight_savevm_enabled) {
7199             int64_t sector_num;
7200             int j;
7201
7202             /* find if the memory block is available on a virtual
7203                block device */
7204             sector_num = -1;
7205             for(j = 0; j < nb_drives; j++) {
7206                 sector_num = bdrv_hash_find(drives_table[j].bdrv,
7207                                             phys_ram_base + i,
7208                                             BDRV_HASH_BLOCK_SIZE);
7209                 if (sector_num >= 0)
7210                     break;
7211             }
7212             if (j == nb_drives)
7213                 goto normal_compress;
7214             buf[0] = 1;
7215             buf[1] = j;
7216             cpu_to_be64wu((uint64_t *)(buf + 2), sector_num);
7217             ram_compress_buf(s, buf, 10);
7218         } else
7219 #endif
7220         {
7221             //        normal_compress:
7222             buf[0] = 0;
7223             ram_compress_buf(s, buf, 1);
7224             ram_compress_buf(s, phys_ram_base + i, BDRV_HASH_BLOCK_SIZE);
7225         }
7226     }
7227     ram_compress_close(s);
7228 }
7229
7230 static int ram_load(QEMUFile *f, void *opaque, int version_id)
7231 {
7232     RamDecompressState s1, *s = &s1;
7233     uint8_t buf[10];
7234     ram_addr_t i;
7235
7236     if (version_id == 1)
7237         return ram_load_v1(f, opaque);
7238     if (version_id != 2)
7239         return -EINVAL;
7240     if (qemu_get_be32(f) != phys_ram_size)
7241         return -EINVAL;
7242     if (ram_decompress_open(s, f) < 0)
7243         return -EINVAL;
7244     for(i = 0; i < phys_ram_size; i+= BDRV_HASH_BLOCK_SIZE) {
7245         if (ram_decompress_buf(s, buf, 1) < 0) {
7246             fprintf(stderr, "Error while reading ram block header\n");
7247             goto error;
7248         }
7249         if (buf[0] == 0) {
7250             if (ram_decompress_buf(s, phys_ram_base + i, BDRV_HASH_BLOCK_SIZE) < 0) {
7251                 fprintf(stderr, "Error while reading ram block address=0x%08" PRIx64, (uint64_t)i);
7252                 goto error;
7253             }
7254         } else
7255 #if 0
7256         if (buf[0] == 1) {
7257             int bs_index;
7258             int64_t sector_num;
7259
7260             ram_decompress_buf(s, buf + 1, 9);
7261             bs_index = buf[1];
7262             sector_num = be64_to_cpupu((const uint64_t *)(buf + 2));
7263             if (bs_index >= nb_drives) {
7264                 fprintf(stderr, "Invalid block device index %d\n", bs_index);
7265                 goto error;
7266             }
7267             if (bdrv_read(drives_table[bs_index].bdrv, sector_num,
7268                           phys_ram_base + i,
7269                           BDRV_HASH_BLOCK_SIZE / 512) < 0) {
7270                 fprintf(stderr, "Error while reading sector %d:%" PRId64 "\n",
7271                         bs_index, sector_num);
7272                 goto error;
7273             }
7274         } else
7275 #endif
7276         {
7277         error:
7278             printf("Error block header\n");
7279             return -EINVAL;
7280         }
7281     }
7282     ram_decompress_close(s);
7283     return 0;
7284 }
7285
7286 /***********************************************************/
7287 /* bottom halves (can be seen as timers which expire ASAP) */
7288
7289 struct QEMUBH {
7290     QEMUBHFunc *cb;
7291     void *opaque;
7292     int scheduled;
7293     QEMUBH *next;
7294 };
7295
7296 static QEMUBH *first_bh = NULL;
7297
7298 QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
7299 {
7300     QEMUBH *bh;
7301     bh = qemu_mallocz(sizeof(QEMUBH));
7302     if (!bh)
7303         return NULL;
7304     bh->cb = cb;
7305     bh->opaque = opaque;
7306     return bh;
7307 }
7308
7309 int qemu_bh_poll(void)
7310 {
7311     QEMUBH *bh, **pbh;
7312     int ret;
7313
7314     ret = 0;
7315     for(;;) {
7316         pbh = &first_bh;
7317         bh = *pbh;
7318         if (!bh)
7319             break;
7320         ret = 1;
7321         *pbh = bh->next;
7322         bh->scheduled = 0;
7323         bh->cb(bh->opaque);
7324     }
7325     return ret;
7326 }
7327
7328 void qemu_bh_schedule(QEMUBH *bh)
7329 {
7330     CPUState *env = cpu_single_env;
7331     if (bh->scheduled)
7332         return;
7333     bh->scheduled = 1;
7334     bh->next = first_bh;
7335     first_bh = bh;
7336
7337     /* stop the currently executing CPU to execute the BH ASAP */
7338     if (env) {
7339         cpu_interrupt(env, CPU_INTERRUPT_EXIT);
7340     }
7341 }
7342
7343 void qemu_bh_cancel(QEMUBH *bh)
7344 {
7345     QEMUBH **pbh;
7346     if (bh->scheduled) {
7347         pbh = &first_bh;
7348         while (*pbh != bh)
7349             pbh = &(*pbh)->next;
7350         *pbh = bh->next;
7351         bh->scheduled = 0;
7352     }
7353 }
7354
7355 void qemu_bh_delete(QEMUBH *bh)
7356 {
7357     qemu_bh_cancel(bh);
7358     qemu_free(bh);
7359 }
7360
7361 /***********************************************************/
7362 /* machine registration */
7363
7364 static QEMUMachine *first_machine = NULL;
7365
7366 int qemu_register_machine(QEMUMachine *m)
7367 {
7368     QEMUMachine **pm;
7369     pm = &first_machine;
7370     while (*pm != NULL)
7371         pm = &(*pm)->next;
7372     m->next = NULL;
7373     *pm = m;
7374     return 0;
7375 }
7376
7377 static QEMUMachine *find_machine(const char *name)
7378 {
7379     QEMUMachine *m;
7380
7381     for(m = first_machine; m != NULL; m = m->next) {
7382         if (!strcmp(m->name, name))
7383             return m;
7384     }
7385     return NULL;
7386 }
7387
7388 /***********************************************************/
7389 /* main execution loop */
7390
7391 static void gui_update(void *opaque)
7392 {
7393     DisplayState *ds = opaque;
7394     ds->dpy_refresh(ds);
7395     qemu_mod_timer(ds->gui_timer,
7396         (ds->gui_timer_interval ?
7397             ds->gui_timer_interval :
7398             GUI_REFRESH_INTERVAL)
7399         + qemu_get_clock(rt_clock));
7400 }
7401
7402 struct vm_change_state_entry {
7403     VMChangeStateHandler *cb;
7404     void *opaque;
7405     LIST_ENTRY (vm_change_state_entry) entries;
7406 };
7407
7408 static LIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
7409
7410 VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
7411                                                      void *opaque)
7412 {
7413     VMChangeStateEntry *e;
7414
7415     e = qemu_mallocz(sizeof (*e));
7416     if (!e)
7417         return NULL;
7418
7419     e->cb = cb;
7420     e->opaque = opaque;
7421     LIST_INSERT_HEAD(&vm_change_state_head, e, entries);
7422     return e;
7423 }
7424
7425 void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
7426 {
7427     LIST_REMOVE (e, entries);
7428     qemu_free (e);
7429 }
7430
7431 static void vm_state_notify(int running)
7432 {
7433     VMChangeStateEntry *e;
7434
7435     for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
7436         e->cb(e->opaque, running);
7437     }
7438 }
7439
7440 /* XXX: support several handlers */
7441 static VMStopHandler *vm_stop_cb;
7442 static void *vm_stop_opaque;
7443
7444 int qemu_add_vm_stop_handler(VMStopHandler *cb, void *opaque)
7445 {
7446     vm_stop_cb = cb;
7447     vm_stop_opaque = opaque;
7448     return 0;
7449 }
7450
7451 void qemu_del_vm_stop_handler(VMStopHandler *cb, void *opaque)
7452 {
7453     vm_stop_cb = NULL;
7454 }
7455
7456 void vm_start(void)
7457 {
7458     if (!vm_running) {
7459         cpu_enable_ticks();
7460         vm_running = 1;
7461         vm_state_notify(1);
7462         qemu_rearm_alarm_timer(alarm_timer);
7463     }
7464 }
7465
7466 void vm_stop(int reason)
7467 {
7468     if (vm_running) {
7469         cpu_disable_ticks();
7470         vm_running = 0;
7471         if (reason != 0) {
7472             if (vm_stop_cb) {
7473                 vm_stop_cb(vm_stop_opaque, reason);
7474             }
7475         }
7476         vm_state_notify(0);
7477     }
7478 }
7479
7480 /* reset/shutdown handler */
7481
7482 typedef struct QEMUResetEntry {
7483     QEMUResetHandler *func;
7484     void *opaque;
7485     struct QEMUResetEntry *next;
7486 } QEMUResetEntry;
7487
7488 static QEMUResetEntry *first_reset_entry;
7489 static int reset_requested;
7490 static int shutdown_requested;
7491 static int powerdown_requested;
7492
7493 int qemu_shutdown_requested(void)
7494 {
7495     int r = shutdown_requested;
7496     shutdown_requested = 0;
7497     return r;
7498 }
7499
7500 int qemu_reset_requested(void)
7501 {
7502     int r = reset_requested;
7503     reset_requested = 0;
7504     return r;
7505 }
7506
7507 int qemu_powerdown_requested(void)
7508 {
7509     int r = powerdown_requested;
7510     powerdown_requested = 0;
7511     return r;
7512 }
7513
7514 void qemu_register_reset(QEMUResetHandler *func, void *opaque)
7515 {
7516     QEMUResetEntry **pre, *re;
7517
7518     pre = &first_reset_entry;
7519     while (*pre != NULL)
7520         pre = &(*pre)->next;
7521     re = qemu_mallocz(sizeof(QEMUResetEntry));
7522     re->func = func;
7523     re->opaque = opaque;
7524     re->next = NULL;
7525     *pre = re;
7526 }
7527
7528 void qemu_system_reset(void)
7529 {
7530     QEMUResetEntry *re;
7531
7532     /* reset all devices */
7533     for(re = first_reset_entry; re != NULL; re = re->next) {
7534         re->func(re->opaque);
7535     }
7536 }
7537
7538 void qemu_system_reset_request(void)
7539 {
7540     if (no_reboot) {
7541         shutdown_requested = 1;
7542     } else {
7543         reset_requested = 1;
7544     }
7545     if (cpu_single_env)
7546         cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
7547 }
7548
7549 void qemu_system_shutdown_request(void)
7550 {
7551     shutdown_requested = 1;
7552     if (cpu_single_env)
7553         cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
7554 }
7555
7556 void qemu_system_powerdown_request(void)
7557 {
7558     powerdown_requested = 1;
7559     if (cpu_single_env)
7560         cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
7561 }
7562
7563 void main_loop_wait(int timeout)
7564 {
7565     IOHandlerRecord *ioh;
7566     fd_set rfds, wfds, xfds;
7567     int ret, nfds;
7568 #ifdef _WIN32
7569     int ret2, i;
7570 #endif
7571     struct timeval tv;
7572     PollingEntry *pe;
7573
7574
7575     /* XXX: need to suppress polling by better using win32 events */
7576     ret = 0;
7577     for(pe = first_polling_entry; pe != NULL; pe = pe->next) {
7578         ret |= pe->func(pe->opaque);
7579     }
7580 #ifdef _WIN32
7581     if (ret == 0) {
7582         int err;
7583         WaitObjects *w = &wait_objects;
7584
7585         ret = WaitForMultipleObjects(w->num, w->events, FALSE, timeout);
7586         if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
7587             if (w->func[ret - WAIT_OBJECT_0])
7588                 w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
7589
7590             /* Check for additional signaled events */
7591             for(i = (ret - WAIT_OBJECT_0 + 1); i < w->num; i++) {
7592
7593                 /* Check if event is signaled */
7594                 ret2 = WaitForSingleObject(w->events[i], 0);
7595                 if(ret2 == WAIT_OBJECT_0) {
7596                     if (w->func[i])
7597                         w->func[i](w->opaque[i]);
7598                 } else if (ret2 == WAIT_TIMEOUT) {
7599                 } else {
7600                     err = GetLastError();
7601                     fprintf(stderr, "WaitForSingleObject error %d %d\n", i, err);
7602                 }
7603             }
7604         } else if (ret == WAIT_TIMEOUT) {
7605         } else {
7606             err = GetLastError();
7607             fprintf(stderr, "WaitForMultipleObjects error %d %d\n", ret, err);
7608         }
7609     }
7610 #endif
7611     /* poll any events */
7612     /* XXX: separate device handlers from system ones */
7613     nfds = -1;
7614     FD_ZERO(&rfds);
7615     FD_ZERO(&wfds);
7616     FD_ZERO(&xfds);
7617     for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
7618         if (ioh->deleted)
7619             continue;
7620         if (ioh->fd_read &&
7621             (!ioh->fd_read_poll ||
7622              ioh->fd_read_poll(ioh->opaque) != 0)) {
7623             FD_SET(ioh->fd, &rfds);
7624             if (ioh->fd > nfds)
7625                 nfds = ioh->fd;
7626         }
7627         if (ioh->fd_write) {
7628             FD_SET(ioh->fd, &wfds);
7629             if (ioh->fd > nfds)
7630                 nfds = ioh->fd;
7631         }
7632     }
7633
7634     tv.tv_sec = 0;
7635 #ifdef _WIN32
7636     tv.tv_usec = 0;
7637 #else
7638     tv.tv_usec = timeout * 1000;
7639 #endif
7640 #if defined(CONFIG_SLIRP)
7641     if (slirp_inited) {
7642         slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
7643     }
7644 #endif
7645     ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
7646     if (ret > 0) {
7647         IOHandlerRecord **pioh;
7648
7649         for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
7650             if (!ioh->deleted && ioh->fd_read && FD_ISSET(ioh->fd, &rfds)) {
7651                 ioh->fd_read(ioh->opaque);
7652             }
7653             if (!ioh->deleted && ioh->fd_write && FD_ISSET(ioh->fd, &wfds)) {
7654                 ioh->fd_write(ioh->opaque);
7655             }
7656         }
7657
7658         /* remove deleted IO handlers */
7659         pioh = &first_io_handler;
7660         while (*pioh) {
7661             ioh = *pioh;
7662             if (ioh->deleted) {
7663                 *pioh = ioh->next;
7664                 qemu_free(ioh);
7665             } else
7666                 pioh = &ioh->next;
7667         }
7668     }
7669 #if defined(CONFIG_SLIRP)
7670     if (slirp_inited) {
7671         if (ret < 0) {
7672             FD_ZERO(&rfds);
7673             FD_ZERO(&wfds);
7674             FD_ZERO(&xfds);
7675         }
7676         slirp_select_poll(&rfds, &wfds, &xfds);
7677     }
7678 #endif
7679
7680     if (vm_running) {
7681         if (likely(!(cur_cpu->singlestep_enabled & SSTEP_NOTIMER)))
7682         qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL],
7683                         qemu_get_clock(vm_clock));
7684         /* run dma transfers, if any */
7685         DMA_run();
7686     }
7687
7688     /* real time timers */
7689     qemu_run_timers(&active_timers[QEMU_TIMER_REALTIME],
7690                     qemu_get_clock(rt_clock));
7691
7692     if (alarm_timer->flags & ALARM_FLAG_EXPIRED) {
7693         alarm_timer->flags &= ~(ALARM_FLAG_EXPIRED);
7694         qemu_rearm_alarm_timer(alarm_timer);
7695     }
7696
7697     /* Check bottom-halves last in case any of the earlier events triggered
7698        them.  */
7699     qemu_bh_poll();
7700
7701 }
7702
7703 static int main_loop(void)
7704 {
7705     int ret, timeout;
7706 #ifdef CONFIG_PROFILER
7707     int64_t ti;
7708 #endif
7709     CPUState *env;
7710
7711     cur_cpu = first_cpu;
7712     next_cpu = cur_cpu->next_cpu ?: first_cpu;
7713     for(;;) {
7714         if (vm_running) {
7715
7716             for(;;) {
7717                 /* get next cpu */
7718                 env = next_cpu;
7719 #ifdef CONFIG_PROFILER
7720                 ti = profile_getclock();
7721 #endif
7722                 if (use_icount) {
7723                     int64_t count;
7724                     int decr;
7725                     qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
7726                     env->icount_decr.u16.low = 0;
7727                     env->icount_extra = 0;
7728                     count = qemu_next_deadline();
7729                     count = (count + (1 << icount_time_shift) - 1)
7730                             >> icount_time_shift;
7731                     qemu_icount += count;
7732                     decr = (count > 0xffff) ? 0xffff : count;
7733                     count -= decr;
7734                     env->icount_decr.u16.low = decr;
7735                     env->icount_extra = count;
7736                 }
7737                 ret = cpu_exec(env);
7738 #ifdef CONFIG_PROFILER
7739                 qemu_time += profile_getclock() - ti;
7740 #endif
7741                 if (use_icount) {
7742                     /* Fold pending instructions back into the
7743                        instruction counter, and clear the interrupt flag.  */
7744                     qemu_icount -= (env->icount_decr.u16.low
7745                                     + env->icount_extra);
7746                     env->icount_decr.u32 = 0;
7747                     env->icount_extra = 0;
7748                 }
7749                 next_cpu = env->next_cpu ?: first_cpu;
7750                 if (event_pending && likely(ret != EXCP_DEBUG)) {
7751                     ret = EXCP_INTERRUPT;
7752                     event_pending = 0;
7753                     break;
7754                 }
7755                 if (ret == EXCP_HLT) {
7756                     /* Give the next CPU a chance to run.  */
7757                     cur_cpu = env;
7758                     continue;
7759                 }
7760                 if (ret != EXCP_HALTED)
7761                     break;
7762                 /* all CPUs are halted ? */
7763                 if (env == cur_cpu)
7764                     break;
7765             }
7766             cur_cpu = env;
7767
7768             if (shutdown_requested) {
7769                 ret = EXCP_INTERRUPT;
7770                 if (no_shutdown) {
7771                     vm_stop(0);
7772                     no_shutdown = 0;
7773                 }
7774                 else
7775                     break;
7776             }
7777             if (reset_requested) {
7778                 reset_requested = 0;
7779                 qemu_system_reset();
7780                 ret = EXCP_INTERRUPT;
7781             }
7782             if (powerdown_requested) {
7783                 powerdown_requested = 0;
7784                 qemu_system_powerdown();
7785                 ret = EXCP_INTERRUPT;
7786             }
7787             if (unlikely(ret == EXCP_DEBUG)) {
7788                 vm_stop(EXCP_DEBUG);
7789             }
7790             /* If all cpus are halted then wait until the next IRQ */
7791             /* XXX: use timeout computed from timers */
7792             if (ret == EXCP_HALTED) {
7793                 if (use_icount) {
7794                     int64_t add;
7795                     int64_t delta;
7796                     /* Advance virtual time to the next event.  */
7797                     if (use_icount == 1) {
7798                         /* When not using an adaptive execution frequency
7799                            we tend to get badly out of sync with real time,
7800                            so just delay for a reasonable amount of time.  */
7801                         delta = 0;
7802                     } else {
7803                         delta = cpu_get_icount() - cpu_get_clock();
7804                     }
7805                     if (delta > 0) {
7806                         /* If virtual time is ahead of real time then just
7807                            wait for IO.  */
7808                         timeout = (delta / 1000000) + 1;
7809                     } else {
7810                         /* Wait for either IO to occur or the next
7811                            timer event.  */
7812                         add = qemu_next_deadline();
7813                         /* We advance the timer before checking for IO.
7814                            Limit the amount we advance so that early IO
7815                            activity won't get the guest too far ahead.  */
7816                         if (add > 10000000)
7817                             add = 10000000;
7818                         delta += add;
7819                         add = (add + (1 << icount_time_shift) - 1)
7820                               >> icount_time_shift;
7821                         qemu_icount += add;
7822                         timeout = delta / 1000000;
7823                         if (timeout < 0)
7824                             timeout = 0;
7825                     }
7826                 } else {
7827                     timeout = 10;
7828                 }
7829             } else {
7830                 timeout = 0;
7831             }
7832         } else {
7833             if (shutdown_requested) {
7834                 ret = EXCP_INTERRUPT;
7835                 break;
7836             }
7837             timeout = 10;
7838         }
7839 #ifdef CONFIG_PROFILER
7840         ti = profile_getclock();
7841 #endif
7842         main_loop_wait(timeout);
7843 #ifdef CONFIG_PROFILER
7844         dev_time += profile_getclock() - ti;
7845 #endif
7846     }
7847     cpu_disable_ticks();
7848     return ret;
7849 }
7850
7851 static void help(int exitcode)
7852 {
7853     printf("QEMU PC emulator version " QEMU_VERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n"
7854            "usage: %s [options] [disk_image]\n"
7855            "\n"
7856            "'disk_image' is a raw hard image image for IDE hard disk 0\n"
7857            "\n"
7858            "Standard options:\n"
7859            "-M machine      select emulated machine (-M ? for list)\n"
7860            "-cpu cpu        select CPU (-cpu ? for list)\n"
7861            "-fda/-fdb file  use 'file' as floppy disk 0/1 image\n"
7862            "-hda/-hdb file  use 'file' as IDE hard disk 0/1 image\n"
7863            "-hdc/-hdd file  use 'file' as IDE hard disk 2/3 image\n"
7864            "-cdrom file     use 'file' as IDE cdrom image (cdrom is ide1 master)\n"
7865            "-drive [file=file][,if=type][,bus=n][,unit=m][,media=d][,index=i]\n"
7866            "       [,cyls=c,heads=h,secs=s[,trans=t]][,snapshot=on|off]\n"
7867            "       [,cache=on|off][,format=f]\n"
7868            "                use 'file' as a drive image\n"
7869            "-mtdblock file  use 'file' as on-board Flash memory image\n"
7870            "-sd file        use 'file' as SecureDigital card image\n"
7871            "-pflash file    use 'file' as a parallel flash image\n"
7872            "-boot [a|c|d|n] boot on floppy (a), hard disk (c), CD-ROM (d), or network (n)\n"
7873            "-snapshot       write to temporary files instead of disk image files\n"
7874 #ifdef CONFIG_SDL
7875            "-no-frame       open SDL window without a frame and window decorations\n"
7876            "-alt-grab       use Ctrl-Alt-Shift to grab mouse (instead of Ctrl-Alt)\n"
7877            "-no-quit        disable SDL window close capability\n"
7878 #endif
7879 #ifdef TARGET_I386
7880            "-no-fd-bootchk  disable boot signature checking for floppy disks\n"
7881 #endif
7882            "-m megs         set virtual RAM size to megs MB [default=%d]\n"
7883            "-smp n          set the number of CPUs to 'n' [default=1]\n"
7884            "-nographic      disable graphical output and redirect serial I/Os to console\n"
7885            "-portrait       rotate graphical output 90 deg left (only PXA LCD)\n"
7886 #ifndef _WIN32
7887            "-k language     use keyboard layout (for example \"fr\" for French)\n"
7888 #endif
7889 #ifdef HAS_AUDIO
7890            "-audio-help     print list of audio drivers and their options\n"
7891            "-soundhw c1,... enable audio support\n"
7892            "                and only specified sound cards (comma separated list)\n"
7893            "                use -soundhw ? to get the list of supported cards\n"
7894            "                use -soundhw all to enable all of them\n"
7895 #endif
7896            "-vga [std|cirrus|vmware]\n"
7897            "                select video card type\n"
7898            "-localtime      set the real time clock to local time [default=utc]\n"
7899            "-full-screen    start in full screen\n"
7900 #ifdef TARGET_I386
7901            "-win2k-hack     use it when installing Windows 2000 to avoid a disk full bug\n"
7902 #endif
7903            "-usb            enable the USB driver (will be the default soon)\n"
7904            "-usbdevice name add the host or guest USB device 'name'\n"
7905 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
7906            "-g WxH[xDEPTH]  Set the initial graphical resolution and depth\n"
7907 #endif
7908            "-name string    set the name of the guest\n"
7909            "-uuid %%08x-%%04x-%%04x-%%04x-%%012x specify machine UUID\n"
7910            "\n"
7911            "Network options:\n"
7912            "-net nic[,vlan=n][,macaddr=addr][,model=type]\n"
7913            "                create a new Network Interface Card and connect it to VLAN 'n'\n"
7914 #ifdef CONFIG_SLIRP
7915            "-net user[,vlan=n][,hostname=host]\n"
7916            "                connect the user mode network stack to VLAN 'n' and send\n"
7917            "                hostname 'host' to DHCP clients\n"
7918 #endif
7919 #ifdef _WIN32
7920            "-net tap[,vlan=n],ifname=name\n"
7921            "                connect the host TAP network interface to VLAN 'n'\n"
7922 #else
7923            "-net tap[,vlan=n][,fd=h][,ifname=name][,script=file][,downscript=dfile]\n"
7924            "                connect the host TAP network interface to VLAN 'n' and use the\n"
7925            "                network scripts 'file' (default=%s)\n"
7926            "                and 'dfile' (default=%s);\n"
7927            "                use '[down]script=no' to disable script execution;\n"
7928            "                use 'fd=h' to connect to an already opened TAP interface\n"
7929 #endif
7930            "-net socket[,vlan=n][,fd=h][,listen=[host]:port][,connect=host:port]\n"
7931            "                connect the vlan 'n' to another VLAN using a socket connection\n"
7932            "-net socket[,vlan=n][,fd=h][,mcast=maddr:port]\n"
7933            "                connect the vlan 'n' to multicast maddr and port\n"
7934 #ifdef CONFIG_VDE
7935            "-net vde[,vlan=n][,sock=socketpath][,port=n][,group=groupname][,mode=octalmode]\n"
7936            "                connect the vlan 'n' to port 'n' of a vde switch running\n"
7937            "                on host and listening for incoming connections on 'socketpath'.\n"
7938            "                Use group 'groupname' and mode 'octalmode' to change default\n"
7939            "                ownership and permissions for communication port.\n"
7940 #endif
7941            "-net none       use it alone to have zero network devices; if no -net option\n"
7942            "                is provided, the default is '-net nic -net user'\n"
7943            "\n"
7944 #ifdef CONFIG_SLIRP
7945            "-tftp dir       allow tftp access to files in dir [-net user]\n"
7946            "-bootp file     advertise file in BOOTP replies\n"
7947 #ifndef _WIN32
7948            "-smb dir        allow SMB access to files in 'dir' [-net user]\n"
7949 #endif
7950            "-redir [tcp|udp]:host-port:[guest-host]:guest-port\n"
7951            "                redirect TCP or UDP connections from host to guest [-net user]\n"
7952 #endif
7953            "\n"
7954            "Linux boot specific:\n"
7955            "-kernel bzImage use 'bzImage' as kernel image\n"
7956            "-append cmdline use 'cmdline' as kernel command line\n"
7957            "-initrd file    use 'file' as initial ram disk\n"
7958            "\n"
7959            "Debug/Expert options:\n"
7960            "-monitor dev    redirect the monitor to char device 'dev'\n"
7961            "-serial dev     redirect the serial port to char device 'dev'\n"
7962            "-parallel dev   redirect the parallel port to char device 'dev'\n"
7963            "-pidfile file   Write PID to 'file'\n"
7964            "-S              freeze CPU at startup (use 'c' to start execution)\n"
7965            "-s              wait gdb connection to port\n"
7966            "-p port         set gdb connection port [default=%s]\n"
7967            "-d item1,...    output log to %s (use -d ? for a list of log items)\n"
7968            "-hdachs c,h,s[,t]  force hard disk 0 physical geometry and the optional BIOS\n"
7969            "                translation (t=none or lba) (usually qemu can guess them)\n"
7970            "-L path         set the directory for the BIOS, VGA BIOS and keymaps\n"
7971 #ifdef USE_KQEMU
7972            "-kernel-kqemu   enable KQEMU full virtualization (default is user mode only)\n"
7973            "-no-kqemu       disable KQEMU kernel module usage\n"
7974 #endif
7975 #ifdef TARGET_I386
7976            "-no-acpi        disable ACPI\n"
7977 #endif
7978 #ifdef CONFIG_CURSES
7979            "-curses         use a curses/ncurses interface instead of SDL\n"
7980 #endif
7981            "-no-reboot      exit instead of rebooting\n"
7982            "-no-shutdown    stop before shutdown\n"
7983            "-loadvm [tag|id]  start right away with a saved state (loadvm in monitor)\n"
7984            "-vnc display    start a VNC server on display\n"
7985 #ifndef _WIN32
7986            "-daemonize      daemonize QEMU after initializing\n"
7987 #endif
7988            "-option-rom rom load a file, rom, into the option ROM space\n"
7989 #ifdef TARGET_SPARC
7990            "-prom-env variable=value  set OpenBIOS nvram variables\n"
7991 #endif
7992            "-clock          force the use of the given methods for timer alarm.\n"
7993            "                To see what timers are available use -clock ?\n"
7994            "-startdate      select initial date of the clock\n"
7995            "-icount [N|auto]\n"
7996            "                Enable virtual instruction counter with 2^N clock ticks per instruction\n"
7997            "\n"
7998            "During emulation, the following keys are useful:\n"
7999            "ctrl-alt-f      toggle full screen\n"
8000            "ctrl-alt-n      switch to virtual console 'n'\n"
8001            "ctrl-alt        toggle mouse and keyboard grab\n"
8002            "\n"
8003            "When using -nographic, press 'ctrl-a h' to get some help.\n"
8004            ,
8005            "qemu",
8006            DEFAULT_RAM_SIZE,
8007 #ifndef _WIN32
8008            DEFAULT_NETWORK_SCRIPT,
8009            DEFAULT_NETWORK_DOWN_SCRIPT,
8010 #endif
8011            DEFAULT_GDBSTUB_PORT,
8012            "/tmp/qemu.log");
8013     exit(exitcode);
8014 }
8015
8016 #define HAS_ARG 0x0001
8017
8018 enum {
8019     QEMU_OPTION_h,
8020
8021     QEMU_OPTION_M,
8022     QEMU_OPTION_cpu,
8023     QEMU_OPTION_fda,
8024     QEMU_OPTION_fdb,
8025     QEMU_OPTION_hda,
8026     QEMU_OPTION_hdb,
8027     QEMU_OPTION_hdc,
8028     QEMU_OPTION_hdd,
8029     QEMU_OPTION_drive,
8030     QEMU_OPTION_cdrom,
8031     QEMU_OPTION_mtdblock,
8032     QEMU_OPTION_sd,
8033     QEMU_OPTION_pflash,
8034     QEMU_OPTION_boot,
8035     QEMU_OPTION_snapshot,
8036 #ifdef TARGET_I386
8037     QEMU_OPTION_no_fd_bootchk,
8038 #endif
8039     QEMU_OPTION_m,
8040     QEMU_OPTION_nographic,
8041     QEMU_OPTION_portrait,
8042 #ifdef HAS_AUDIO
8043     QEMU_OPTION_audio_help,
8044     QEMU_OPTION_soundhw,
8045 #endif
8046
8047     QEMU_OPTION_net,
8048     QEMU_OPTION_tftp,
8049     QEMU_OPTION_bootp,
8050     QEMU_OPTION_smb,
8051     QEMU_OPTION_redir,
8052
8053     QEMU_OPTION_kernel,
8054     QEMU_OPTION_append,
8055     QEMU_OPTION_initrd,
8056
8057     QEMU_OPTION_S,
8058     QEMU_OPTION_s,
8059     QEMU_OPTION_p,
8060     QEMU_OPTION_d,
8061     QEMU_OPTION_hdachs,
8062     QEMU_OPTION_L,
8063     QEMU_OPTION_bios,
8064     QEMU_OPTION_k,
8065     QEMU_OPTION_localtime,
8066     QEMU_OPTION_g,
8067     QEMU_OPTION_vga,
8068     QEMU_OPTION_echr,
8069     QEMU_OPTION_monitor,
8070     QEMU_OPTION_serial,
8071     QEMU_OPTION_parallel,
8072     QEMU_OPTION_loadvm,
8073     QEMU_OPTION_full_screen,
8074     QEMU_OPTION_no_frame,
8075     QEMU_OPTION_alt_grab,
8076     QEMU_OPTION_no_quit,
8077     QEMU_OPTION_pidfile,
8078     QEMU_OPTION_no_kqemu,
8079     QEMU_OPTION_kernel_kqemu,
8080     QEMU_OPTION_win2k_hack,
8081     QEMU_OPTION_usb,
8082     QEMU_OPTION_usbdevice,
8083     QEMU_OPTION_smp,
8084     QEMU_OPTION_vnc,
8085     QEMU_OPTION_no_acpi,
8086     QEMU_OPTION_curses,
8087     QEMU_OPTION_no_reboot,
8088     QEMU_OPTION_no_shutdown,
8089     QEMU_OPTION_show_cursor,
8090     QEMU_OPTION_daemonize,
8091     QEMU_OPTION_option_rom,
8092     QEMU_OPTION_semihosting,
8093     QEMU_OPTION_name,
8094     QEMU_OPTION_prom_env,
8095     QEMU_OPTION_old_param,
8096     QEMU_OPTION_clock,
8097     QEMU_OPTION_startdate,
8098     QEMU_OPTION_tb_size,
8099     QEMU_OPTION_icount,
8100     QEMU_OPTION_uuid,
8101 };
8102
8103 typedef struct QEMUOption {
8104     const char *name;
8105     int flags;
8106     int index;
8107 } QEMUOption;
8108
8109 static const QEMUOption qemu_options[] = {
8110     { "h", 0, QEMU_OPTION_h },
8111     { "help", 0, QEMU_OPTION_h },
8112
8113     { "M", HAS_ARG, QEMU_OPTION_M },
8114     { "cpu", HAS_ARG, QEMU_OPTION_cpu },
8115     { "fda", HAS_ARG, QEMU_OPTION_fda },
8116     { "fdb", HAS_ARG, QEMU_OPTION_fdb },
8117     { "hda", HAS_ARG, QEMU_OPTION_hda },
8118     { "hdb", HAS_ARG, QEMU_OPTION_hdb },
8119     { "hdc", HAS_ARG, QEMU_OPTION_hdc },
8120     { "hdd", HAS_ARG, QEMU_OPTION_hdd },
8121     { "drive", HAS_ARG, QEMU_OPTION_drive },
8122     { "cdrom", HAS_ARG, QEMU_OPTION_cdrom },
8123     { "mtdblock", HAS_ARG, QEMU_OPTION_mtdblock },
8124     { "sd", HAS_ARG, QEMU_OPTION_sd },
8125     { "pflash", HAS_ARG, QEMU_OPTION_pflash },
8126     { "boot", HAS_ARG, QEMU_OPTION_boot },
8127     { "snapshot", 0, QEMU_OPTION_snapshot },
8128 #ifdef TARGET_I386
8129     { "no-fd-bootchk", 0, QEMU_OPTION_no_fd_bootchk },
8130 #endif
8131     { "m", HAS_ARG, QEMU_OPTION_m },
8132     { "nographic", 0, QEMU_OPTION_nographic },
8133     { "portrait", 0, QEMU_OPTION_portrait },
8134     { "k", HAS_ARG, QEMU_OPTION_k },
8135 #ifdef HAS_AUDIO
8136     { "audio-help", 0, QEMU_OPTION_audio_help },
8137     { "soundhw", HAS_ARG, QEMU_OPTION_soundhw },
8138 #endif
8139
8140     { "net", HAS_ARG, QEMU_OPTION_net},
8141 #ifdef CONFIG_SLIRP
8142     { "tftp", HAS_ARG, QEMU_OPTION_tftp },
8143     { "bootp", HAS_ARG, QEMU_OPTION_bootp },
8144 #ifndef _WIN32
8145     { "smb", HAS_ARG, QEMU_OPTION_smb },
8146 #endif
8147     { "redir", HAS_ARG, QEMU_OPTION_redir },
8148 #endif
8149
8150     { "kernel", HAS_ARG, QEMU_OPTION_kernel },
8151     { "append", HAS_ARG, QEMU_OPTION_append },
8152     { "initrd", HAS_ARG, QEMU_OPTION_initrd },
8153
8154     { "S", 0, QEMU_OPTION_S },
8155     { "s", 0, QEMU_OPTION_s },
8156     { "p", HAS_ARG, QEMU_OPTION_p },
8157     { "d", HAS_ARG, QEMU_OPTION_d },
8158     { "hdachs", HAS_ARG, QEMU_OPTION_hdachs },
8159     { "L", HAS_ARG, QEMU_OPTION_L },
8160     { "bios", HAS_ARG, QEMU_OPTION_bios },
8161 #ifdef USE_KQEMU
8162     { "no-kqemu", 0, QEMU_OPTION_no_kqemu },
8163     { "kernel-kqemu", 0, QEMU_OPTION_kernel_kqemu },
8164 #endif
8165 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
8166     { "g", 1, QEMU_OPTION_g },
8167 #endif
8168     { "localtime", 0, QEMU_OPTION_localtime },
8169     { "vga", HAS_ARG, QEMU_OPTION_vga },
8170     { "echr", HAS_ARG, QEMU_OPTION_echr },
8171     { "monitor", HAS_ARG, QEMU_OPTION_monitor },
8172     { "serial", HAS_ARG, QEMU_OPTION_serial },
8173     { "parallel", HAS_ARG, QEMU_OPTION_parallel },
8174     { "loadvm", HAS_ARG, QEMU_OPTION_loadvm },
8175     { "full-screen", 0, QEMU_OPTION_full_screen },
8176 #ifdef CONFIG_SDL
8177     { "no-frame", 0, QEMU_OPTION_no_frame },
8178     { "alt-grab", 0, QEMU_OPTION_alt_grab },
8179     { "no-quit", 0, QEMU_OPTION_no_quit },
8180 #endif
8181     { "pidfile", HAS_ARG, QEMU_OPTION_pidfile },
8182     { "win2k-hack", 0, QEMU_OPTION_win2k_hack },
8183     { "usbdevice", HAS_ARG, QEMU_OPTION_usbdevice },
8184     { "smp", HAS_ARG, QEMU_OPTION_smp },
8185     { "vnc", HAS_ARG, QEMU_OPTION_vnc },
8186 #ifdef CONFIG_CURSES
8187     { "curses", 0, QEMU_OPTION_curses },
8188 #endif
8189     { "uuid", HAS_ARG, QEMU_OPTION_uuid },
8190
8191     /* temporary options */
8192     { "usb", 0, QEMU_OPTION_usb },
8193     { "no-acpi", 0, QEMU_OPTION_no_acpi },
8194     { "no-reboot", 0, QEMU_OPTION_no_reboot },
8195     { "no-shutdown", 0, QEMU_OPTION_no_shutdown },
8196     { "show-cursor", 0, QEMU_OPTION_show_cursor },
8197     { "daemonize", 0, QEMU_OPTION_daemonize },
8198     { "option-rom", HAS_ARG, QEMU_OPTION_option_rom },
8199 #if defined(TARGET_ARM) || defined(TARGET_M68K)
8200     { "semihosting", 0, QEMU_OPTION_semihosting },
8201 #endif
8202     { "name", HAS_ARG, QEMU_OPTION_name },
8203 #if defined(TARGET_SPARC)
8204     { "prom-env", HAS_ARG, QEMU_OPTION_prom_env },
8205 #endif
8206 #if defined(TARGET_ARM)
8207     { "old-param", 0, QEMU_OPTION_old_param },
8208 #endif
8209     { "clock", HAS_ARG, QEMU_OPTION_clock },
8210     { "startdate", HAS_ARG, QEMU_OPTION_startdate },
8211     { "tb-size", HAS_ARG, QEMU_OPTION_tb_size },
8212     { "icount", HAS_ARG, QEMU_OPTION_icount },
8213     { NULL },
8214 };
8215
8216 /* password input */
8217
8218 int qemu_key_check(BlockDriverState *bs, const char *name)
8219 {
8220     char password[256];
8221     int i;
8222
8223     if (!bdrv_is_encrypted(bs))
8224         return 0;
8225
8226     term_printf("%s is encrypted.\n", name);
8227     for(i = 0; i < 3; i++) {
8228         monitor_readline("Password: ", 1, password, sizeof(password));
8229         if (bdrv_set_key(bs, password) == 0)
8230             return 0;
8231         term_printf("invalid password\n");
8232     }
8233     return -EPERM;
8234 }
8235
8236 static BlockDriverState *get_bdrv(int index)
8237 {
8238     if (index > nb_drives)
8239         return NULL;
8240     return drives_table[index].bdrv;
8241 }
8242
8243 static void read_passwords(void)
8244 {
8245     BlockDriverState *bs;
8246     int i;
8247
8248     for(i = 0; i < 6; i++) {
8249         bs = get_bdrv(i);
8250         if (bs)
8251             qemu_key_check(bs, bdrv_get_device_name(bs));
8252     }
8253 }
8254
8255 #ifdef HAS_AUDIO
8256 struct soundhw soundhw[] = {
8257 #ifdef HAS_AUDIO_CHOICE
8258 #if defined(TARGET_I386) || defined(TARGET_MIPS)
8259     {
8260         "pcspk",
8261         "PC speaker",
8262         0,
8263         1,
8264         { .init_isa = pcspk_audio_init }
8265     },
8266 #endif
8267     {
8268         "sb16",
8269         "Creative Sound Blaster 16",
8270         0,
8271         1,
8272         { .init_isa = SB16_init }
8273     },
8274
8275 #ifdef CONFIG_CS4231A
8276     {
8277         "cs4231a",
8278         "CS4231A",
8279         0,
8280         1,
8281         { .init_isa = cs4231a_init }
8282     },
8283 #endif
8284
8285 #ifdef CONFIG_ADLIB
8286     {
8287         "adlib",
8288 #ifdef HAS_YMF262
8289         "Yamaha YMF262 (OPL3)",
8290 #else
8291         "Yamaha YM3812 (OPL2)",
8292 #endif
8293         0,
8294         1,
8295         { .init_isa = Adlib_init }
8296     },
8297 #endif
8298
8299 #ifdef CONFIG_GUS
8300     {
8301         "gus",
8302         "Gravis Ultrasound GF1",
8303         0,
8304         1,
8305         { .init_isa = GUS_init }
8306     },
8307 #endif
8308
8309 #ifdef CONFIG_AC97
8310     {
8311         "ac97",
8312         "Intel 82801AA AC97 Audio",
8313         0,
8314         0,
8315         { .init_pci = ac97_init }
8316     },
8317 #endif
8318
8319     {
8320         "es1370",
8321         "ENSONIQ AudioPCI ES1370",
8322         0,
8323         0,
8324         { .init_pci = es1370_init }
8325     },
8326 #endif
8327
8328     { NULL, NULL, 0, 0, { NULL } }
8329 };
8330
8331 static void select_soundhw (const char *optarg)
8332 {
8333     struct soundhw *c;
8334
8335     if (*optarg == '?') {
8336     show_valid_cards:
8337
8338         printf ("Valid sound card names (comma separated):\n");
8339         for (c = soundhw; c->name; ++c) {
8340             printf ("%-11s %s\n", c->name, c->descr);
8341         }
8342         printf ("\n-soundhw all will enable all of the above\n");
8343         exit (*optarg != '?');
8344     }
8345     else {
8346         size_t l;
8347         const char *p;
8348         char *e;
8349         int bad_card = 0;
8350
8351         if (!strcmp (optarg, "all")) {
8352             for (c = soundhw; c->name; ++c) {
8353                 c->enabled = 1;
8354             }
8355             return;
8356         }
8357
8358         p = optarg;
8359         while (*p) {
8360             e = strchr (p, ',');
8361             l = !e ? strlen (p) : (size_t) (e - p);
8362
8363             for (c = soundhw; c->name; ++c) {
8364                 if (!strncmp (c->name, p, l)) {
8365                     c->enabled = 1;
8366                     break;
8367                 }
8368             }
8369
8370             if (!c->name) {
8371                 if (l > 80) {
8372                     fprintf (stderr,
8373                              "Unknown sound card name (too big to show)\n");
8374                 }
8375                 else {
8376                     fprintf (stderr, "Unknown sound card name `%.*s'\n",
8377                              (int) l, p);
8378                 }
8379                 bad_card = 1;
8380             }
8381             p += l + (e != NULL);
8382         }
8383
8384         if (bad_card)
8385             goto show_valid_cards;
8386     }
8387 }
8388 #endif
8389
8390 static void select_vgahw (const char *p)
8391 {
8392     const char *opts;
8393
8394     if (strstart(p, "std", &opts)) {
8395         cirrus_vga_enabled = 0;
8396         vmsvga_enabled = 0;
8397     } else if (strstart(p, "cirrus", &opts)) {
8398         cirrus_vga_enabled = 1;
8399         vmsvga_enabled = 0;
8400     } else if (strstart(p, "vmware", &opts)) {
8401         cirrus_vga_enabled = 0;
8402         vmsvga_enabled = 1;
8403     } else {
8404     invalid_vga:
8405         fprintf(stderr, "Unknown vga type: %s\n", p);
8406         exit(1);
8407     }
8408     while (*opts) {
8409         const char *nextopt;
8410
8411         if (strstart(opts, ",retrace=", &nextopt)) {
8412             opts = nextopt;
8413             if (strstart(opts, "dumb", &nextopt))
8414                 vga_retrace_method = VGA_RETRACE_DUMB;
8415             else if (strstart(opts, "precise", &nextopt))
8416                 vga_retrace_method = VGA_RETRACE_PRECISE;
8417             else goto invalid_vga;
8418         } else goto invalid_vga;
8419         opts = nextopt;
8420     }
8421 }
8422
8423 #ifdef _WIN32
8424 static BOOL WINAPI qemu_ctrl_handler(DWORD type)
8425 {
8426     exit(STATUS_CONTROL_C_EXIT);
8427     return TRUE;
8428 }
8429 #endif
8430
8431 static int qemu_uuid_parse(const char *str, uint8_t *uuid)
8432 {
8433     int ret;
8434
8435     if(strlen(str) != 36)
8436         return -1;
8437
8438     ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],
8439             &uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],
8440             &uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14], &uuid[15]);
8441
8442     if(ret != 16)
8443         return -1;
8444
8445     return 0;
8446 }
8447
8448 #define MAX_NET_CLIENTS 32
8449
8450 #ifndef _WIN32
8451
8452 static void termsig_handler(int signal)
8453 {
8454     qemu_system_shutdown_request();
8455 }
8456
8457 static void termsig_setup(void)
8458 {
8459     struct sigaction act;
8460
8461     memset(&act, 0, sizeof(act));
8462     act.sa_handler = termsig_handler;
8463     sigaction(SIGINT,  &act, NULL);
8464     sigaction(SIGHUP,  &act, NULL);
8465     sigaction(SIGTERM, &act, NULL);
8466 }
8467
8468 #endif
8469
8470 int main(int argc, char **argv)
8471 {
8472 #ifdef CONFIG_GDBSTUB
8473     int use_gdbstub;
8474     const char *gdbstub_port;
8475 #endif
8476     uint32_t boot_devices_bitmap = 0;
8477     int i;
8478     int snapshot, linux_boot, net_boot;
8479     const char *initrd_filename;
8480     const char *kernel_filename, *kernel_cmdline;
8481     const char *boot_devices = "";
8482     DisplayState *ds = &display_state;
8483     int cyls, heads, secs, translation;
8484     const char *net_clients[MAX_NET_CLIENTS];
8485     int nb_net_clients;
8486     int hda_index;
8487     int optind;
8488     const char *r, *optarg;
8489     CharDriverState *monitor_hd;
8490     const char *monitor_device;
8491     const char *serial_devices[MAX_SERIAL_PORTS];
8492     int serial_device_index;
8493     const char *parallel_devices[MAX_PARALLEL_PORTS];
8494     int parallel_device_index;
8495     const char *loadvm = NULL;
8496     QEMUMachine *machine;
8497     const char *cpu_model;
8498     const char *usb_devices[MAX_USB_CMDLINE];
8499     int usb_devices_index;
8500     int fds[2];
8501     int tb_size;
8502     const char *pid_file = NULL;
8503     VLANState *vlan;
8504     int autostart;
8505
8506     LIST_INIT (&vm_change_state_head);
8507 #ifndef _WIN32
8508     {
8509         struct sigaction act;
8510         sigfillset(&act.sa_mask);
8511         act.sa_flags = 0;
8512         act.sa_handler = SIG_IGN;
8513         sigaction(SIGPIPE, &act, NULL);
8514     }
8515 #else
8516     SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
8517     /* Note: cpu_interrupt() is currently not SMP safe, so we force
8518        QEMU to run on a single CPU */
8519     {
8520         HANDLE h;
8521         DWORD mask, smask;
8522         int i;
8523         h = GetCurrentProcess();
8524         if (GetProcessAffinityMask(h, &mask, &smask)) {
8525             for(i = 0; i < 32; i++) {
8526                 if (mask & (1 << i))
8527                     break;
8528             }
8529             if (i != 32) {
8530                 mask = 1 << i;
8531                 SetProcessAffinityMask(h, mask);
8532             }
8533         }
8534     }
8535 #endif
8536
8537     register_machines();
8538     machine = first_machine;
8539     cpu_model = NULL;
8540     initrd_filename = NULL;
8541     ram_size = 0;
8542     vga_ram_size = VGA_RAM_SIZE;
8543 #ifdef CONFIG_GDBSTUB
8544     use_gdbstub = 0;
8545     gdbstub_port = DEFAULT_GDBSTUB_PORT;
8546 #endif
8547     snapshot = 0;
8548     nographic = 0;
8549     curses = 0;
8550     kernel_filename = NULL;
8551     kernel_cmdline = "";
8552     cyls = heads = secs = 0;
8553     translation = BIOS_ATA_TRANSLATION_AUTO;
8554     monitor_device = "vc";
8555
8556     serial_devices[0] = "vc:80Cx24C";
8557     for(i = 1; i < MAX_SERIAL_PORTS; i++)
8558         serial_devices[i] = NULL;
8559     serial_device_index = 0;
8560
8561     parallel_devices[0] = "vc:640x480";
8562     for(i = 1; i < MAX_PARALLEL_PORTS; i++)
8563         parallel_devices[i] = NULL;
8564     parallel_device_index = 0;
8565
8566     usb_devices_index = 0;
8567
8568     nb_net_clients = 0;
8569     nb_drives = 0;
8570     nb_drives_opt = 0;
8571     hda_index = -1;
8572
8573     nb_nics = 0;
8574
8575     tb_size = 0;
8576     autostart= 1;
8577
8578     optind = 1;
8579     for(;;) {
8580         if (optind >= argc)
8581             break;
8582         r = argv[optind];
8583         if (r[0] != '-') {
8584             hda_index = drive_add(argv[optind++], HD_ALIAS, 0);
8585         } else {
8586             const QEMUOption *popt;
8587
8588             optind++;
8589             /* Treat --foo the same as -foo.  */
8590             if (r[1] == '-')
8591                 r++;
8592             popt = qemu_options;
8593             for(;;) {
8594                 if (!popt->name) {
8595                     fprintf(stderr, "%s: invalid option -- '%s'\n",
8596                             argv[0], r);
8597                     exit(1);
8598                 }
8599                 if (!strcmp(popt->name, r + 1))
8600                     break;
8601                 popt++;
8602             }
8603             if (popt->flags & HAS_ARG) {
8604                 if (optind >= argc) {
8605                     fprintf(stderr, "%s: option '%s' requires an argument\n",
8606                             argv[0], r);
8607                     exit(1);
8608                 }
8609                 optarg = argv[optind++];
8610             } else {
8611                 optarg = NULL;
8612             }
8613
8614             switch(popt->index) {
8615             case QEMU_OPTION_M:
8616                 machine = find_machine(optarg);
8617                 if (!machine) {
8618                     QEMUMachine *m;
8619                     printf("Supported machines are:\n");
8620                     for(m = first_machine; m != NULL; m = m->next) {
8621                         printf("%-10s %s%s\n",
8622                                m->name, m->desc,
8623                                m == first_machine ? " (default)" : "");
8624                     }
8625                     exit(*optarg != '?');
8626                 }
8627                 break;
8628             case QEMU_OPTION_cpu:
8629                 /* hw initialization will check this */
8630                 if (*optarg == '?') {
8631 /* XXX: implement xxx_cpu_list for targets that still miss it */
8632 #if defined(cpu_list)
8633                     cpu_list(stdout, &fprintf);
8634 #endif
8635                     exit(0);
8636                 } else {
8637                     cpu_model = optarg;
8638                 }
8639                 break;
8640             case QEMU_OPTION_initrd:
8641                 initrd_filename = optarg;
8642                 break;
8643             case QEMU_OPTION_hda:
8644                 if (cyls == 0)
8645                     hda_index = drive_add(optarg, HD_ALIAS, 0);
8646                 else
8647                     hda_index = drive_add(optarg, HD_ALIAS
8648                              ",cyls=%d,heads=%d,secs=%d%s",
8649                              0, cyls, heads, secs,
8650                              translation == BIOS_ATA_TRANSLATION_LBA ?
8651                                  ",trans=lba" :
8652                              translation == BIOS_ATA_TRANSLATION_NONE ?
8653                                  ",trans=none" : "");
8654                  break;
8655             case QEMU_OPTION_hdb:
8656             case QEMU_OPTION_hdc:
8657             case QEMU_OPTION_hdd:
8658                 drive_add(optarg, HD_ALIAS, popt->index - QEMU_OPTION_hda);
8659                 break;
8660             case QEMU_OPTION_drive:
8661                 drive_add(NULL, "%s", optarg);
8662                 break;
8663             case QEMU_OPTION_mtdblock:
8664                 drive_add(optarg, MTD_ALIAS);
8665                 break;
8666             case QEMU_OPTION_sd:
8667                 drive_add(optarg, SD_ALIAS);
8668                 break;
8669             case QEMU_OPTION_pflash:
8670                 drive_add(optarg, PFLASH_ALIAS);
8671                 break;
8672             case QEMU_OPTION_snapshot:
8673                 snapshot = 1;
8674                 break;
8675             case QEMU_OPTION_hdachs:
8676                 {
8677                     const char *p;
8678                     p = optarg;
8679                     cyls = strtol(p, (char **)&p, 0);
8680                     if (cyls < 1 || cyls > 16383)
8681                         goto chs_fail;
8682                     if (*p != ',')
8683                         goto chs_fail;
8684                     p++;
8685                     heads = strtol(p, (char **)&p, 0);
8686                     if (heads < 1 || heads > 16)
8687                         goto chs_fail;
8688                     if (*p != ',')
8689                         goto chs_fail;
8690                     p++;
8691                     secs = strtol(p, (char **)&p, 0);
8692                     if (secs < 1 || secs > 63)
8693                         goto chs_fail;
8694                     if (*p == ',') {
8695                         p++;
8696                         if (!strcmp(p, "none"))
8697                             translation = BIOS_ATA_TRANSLATION_NONE;
8698                         else if (!strcmp(p, "lba"))
8699                             translation = BIOS_ATA_TRANSLATION_LBA;
8700                         else if (!strcmp(p, "auto"))
8701                             translation = BIOS_ATA_TRANSLATION_AUTO;
8702                         else
8703                             goto chs_fail;
8704                     } else if (*p != '\0') {
8705                     chs_fail:
8706                         fprintf(stderr, "qemu: invalid physical CHS format\n");
8707                         exit(1);
8708                     }
8709                     if (hda_index != -1)
8710                         snprintf(drives_opt[hda_index].opt,
8711                                  sizeof(drives_opt[hda_index].opt),
8712                                  HD_ALIAS ",cyls=%d,heads=%d,secs=%d%s",
8713                                  0, cyls, heads, secs,
8714                                  translation == BIOS_ATA_TRANSLATION_LBA ?
8715                                     ",trans=lba" :
8716                                  translation == BIOS_ATA_TRANSLATION_NONE ?
8717                                      ",trans=none" : "");
8718                 }
8719                 break;
8720             case QEMU_OPTION_nographic:
8721                 nographic = 1;
8722                 break;
8723 #ifdef CONFIG_CURSES
8724             case QEMU_OPTION_curses:
8725                 curses = 1;
8726                 break;
8727 #endif
8728             case QEMU_OPTION_portrait:
8729                 graphic_rotate = 1;
8730                 break;
8731             case QEMU_OPTION_kernel:
8732                 kernel_filename = optarg;
8733                 break;
8734             case QEMU_OPTION_append:
8735                 kernel_cmdline = optarg;
8736                 break;
8737             case QEMU_OPTION_cdrom:
8738                 drive_add(optarg, CDROM_ALIAS);
8739                 break;
8740             case QEMU_OPTION_boot:
8741                 boot_devices = optarg;
8742                 /* We just do some generic consistency checks */
8743                 {
8744                     /* Could easily be extended to 64 devices if needed */
8745                     const char *p;
8746
8747                     boot_devices_bitmap = 0;
8748                     for (p = boot_devices; *p != '\0'; p++) {
8749                         /* Allowed boot devices are:
8750                          * a b     : floppy disk drives
8751                          * c ... f : IDE disk drives
8752                          * g ... m : machine implementation dependant drives
8753                          * n ... p : network devices
8754                          * It's up to each machine implementation to check
8755                          * if the given boot devices match the actual hardware
8756                          * implementation and firmware features.
8757                          */
8758                         if (*p < 'a' || *p > 'q') {
8759                             fprintf(stderr, "Invalid boot device '%c'\n", *p);
8760                             exit(1);
8761                         }
8762                         if (boot_devices_bitmap & (1 << (*p - 'a'))) {
8763                             fprintf(stderr,
8764                                     "Boot device '%c' was given twice\n",*p);
8765                             exit(1);
8766                         }
8767                         boot_devices_bitmap |= 1 << (*p - 'a');
8768                     }
8769                 }
8770                 break;
8771             case QEMU_OPTION_fda:
8772             case QEMU_OPTION_fdb:
8773                 drive_add(optarg, FD_ALIAS, popt->index - QEMU_OPTION_fda);
8774                 break;
8775 #ifdef TARGET_I386
8776             case QEMU_OPTION_no_fd_bootchk:
8777                 fd_bootchk = 0;
8778                 break;
8779 #endif
8780             case QEMU_OPTION_net:
8781                 if (nb_net_clients >= MAX_NET_CLIENTS) {
8782                     fprintf(stderr, "qemu: too many network clients\n");
8783                     exit(1);
8784                 }
8785                 net_clients[nb_net_clients] = optarg;
8786                 nb_net_clients++;
8787                 break;
8788 #ifdef CONFIG_SLIRP
8789             case QEMU_OPTION_tftp:
8790                 tftp_prefix = optarg;
8791                 break;
8792             case QEMU_OPTION_bootp:
8793                 bootp_filename = optarg;
8794                 break;
8795 #ifndef _WIN32
8796             case QEMU_OPTION_smb:
8797                 net_slirp_smb(optarg);
8798                 break;
8799 #endif
8800             case QEMU_OPTION_redir:
8801                 net_slirp_redir(optarg);
8802                 break;
8803 #endif
8804 #ifdef HAS_AUDIO
8805             case QEMU_OPTION_audio_help:
8806                 AUD_help ();
8807                 exit (0);
8808                 break;
8809             case QEMU_OPTION_soundhw:
8810                 select_soundhw (optarg);
8811                 break;
8812 #endif
8813             case QEMU_OPTION_h:
8814                 help(0);
8815                 break;
8816             case QEMU_OPTION_m: {
8817                 uint64_t value;
8818                 char *ptr;
8819
8820                 value = strtoul(optarg, &ptr, 10);
8821                 switch (*ptr) {
8822                 case 0: case 'M': case 'm':
8823                     value <<= 20;
8824                     break;
8825                 case 'G': case 'g':
8826                     value <<= 30;
8827                     break;
8828                 default:
8829                     fprintf(stderr, "qemu: invalid ram size: %s\n", optarg);
8830                     exit(1);
8831                 }
8832
8833                 /* On 32-bit hosts, QEMU is limited by virtual address space */
8834                 if (value > (2047 << 20)
8835 #ifndef USE_KQEMU
8836                     && HOST_LONG_BITS == 32
8837 #endif
8838                     ) {
8839                     fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n");
8840                     exit(1);
8841                 }
8842                 if (value != (uint64_t)(ram_addr_t)value) {
8843                     fprintf(stderr, "qemu: ram size too large\n");
8844                     exit(1);
8845                 }
8846                 ram_size = value;
8847                 break;
8848             }
8849             case QEMU_OPTION_d:
8850                 {
8851                     int mask;
8852                     const CPULogItem *item;
8853
8854                     mask = cpu_str_to_log_mask(optarg);
8855                     if (!mask) {
8856                         printf("Log items (comma separated):\n");
8857                     for(item = cpu_log_items; item->mask != 0; item++) {
8858                         printf("%-10s %s\n", item->name, item->help);
8859                     }
8860                     exit(1);
8861                     }
8862                     cpu_set_log(mask);
8863                 }
8864                 break;
8865 #ifdef CONFIG_GDBSTUB
8866             case QEMU_OPTION_s:
8867                 use_gdbstub = 1;
8868                 break;
8869             case QEMU_OPTION_p:
8870                 gdbstub_port = optarg;
8871                 break;
8872 #endif
8873             case QEMU_OPTION_L:
8874                 bios_dir = optarg;
8875                 break;
8876             case QEMU_OPTION_bios:
8877                 bios_name = optarg;
8878                 break;
8879             case QEMU_OPTION_S:
8880                 autostart = 0;
8881                 break;
8882             case QEMU_OPTION_k:
8883                 keyboard_layout = optarg;
8884                 break;
8885             case QEMU_OPTION_localtime:
8886                 rtc_utc = 0;
8887                 break;
8888             case QEMU_OPTION_vga:
8889                 select_vgahw (optarg);
8890                 break;
8891             case QEMU_OPTION_g:
8892                 {
8893                     const char *p;
8894                     int w, h, depth;
8895                     p = optarg;
8896                     w = strtol(p, (char **)&p, 10);
8897                     if (w <= 0) {
8898                     graphic_error:
8899                         fprintf(stderr, "qemu: invalid resolution or depth\n");
8900                         exit(1);
8901                     }
8902                     if (*p != 'x')
8903                         goto graphic_error;
8904                     p++;
8905                     h = strtol(p, (char **)&p, 10);
8906                     if (h <= 0)
8907                         goto graphic_error;
8908                     if (*p == 'x') {
8909                         p++;
8910                         depth = strtol(p, (char **)&p, 10);
8911                         if (depth != 8 && depth != 15 && depth != 16 &&
8912                             depth != 24 && depth != 32)
8913                             goto graphic_error;
8914                     } else if (*p == '\0') {
8915                         depth = graphic_depth;
8916                     } else {
8917                         goto graphic_error;
8918                     }
8919
8920                     graphic_width = w;
8921                     graphic_height = h;
8922                     graphic_depth = depth;
8923                 }
8924                 break;
8925             case QEMU_OPTION_echr:
8926                 {
8927                     char *r;
8928                     term_escape_char = strtol(optarg, &r, 0);
8929                     if (r == optarg)
8930                         printf("Bad argument to echr\n");
8931                     break;
8932                 }
8933             case QEMU_OPTION_monitor:
8934                 monitor_device = optarg;
8935                 break;
8936             case QEMU_OPTION_serial:
8937                 if (serial_device_index >= MAX_SERIAL_PORTS) {
8938                     fprintf(stderr, "qemu: too many serial ports\n");
8939                     exit(1);
8940                 }
8941                 serial_devices[serial_device_index] = optarg;
8942                 serial_device_index++;
8943                 break;
8944             case QEMU_OPTION_parallel:
8945                 if (parallel_device_index >= MAX_PARALLEL_PORTS) {
8946                     fprintf(stderr, "qemu: too many parallel ports\n");
8947                     exit(1);
8948                 }
8949                 parallel_devices[parallel_device_index] = optarg;
8950                 parallel_device_index++;
8951                 break;
8952             case QEMU_OPTION_loadvm:
8953                 loadvm = optarg;
8954                 break;
8955             case QEMU_OPTION_full_screen:
8956                 full_screen = 1;
8957                 break;
8958 #ifdef CONFIG_SDL
8959             case QEMU_OPTION_no_frame:
8960                 no_frame = 1;
8961                 break;
8962             case QEMU_OPTION_alt_grab:
8963                 alt_grab = 1;
8964                 break;
8965             case QEMU_OPTION_no_quit:
8966                 no_quit = 1;
8967                 break;
8968 #endif
8969             case QEMU_OPTION_pidfile:
8970                 pid_file = optarg;
8971                 break;
8972 #ifdef TARGET_I386
8973             case QEMU_OPTION_win2k_hack:
8974                 win2k_install_hack = 1;
8975                 break;
8976 #endif
8977 #ifdef USE_KQEMU
8978             case QEMU_OPTION_no_kqemu:
8979                 kqemu_allowed = 0;
8980                 break;
8981             case QEMU_OPTION_kernel_kqemu:
8982                 kqemu_allowed = 2;
8983                 break;
8984 #endif
8985             case QEMU_OPTION_usb:
8986                 usb_enabled = 1;
8987                 break;
8988             case QEMU_OPTION_usbdevice:
8989                 usb_enabled = 1;
8990                 if (usb_devices_index >= MAX_USB_CMDLINE) {
8991                     fprintf(stderr, "Too many USB devices\n");
8992                     exit(1);
8993                 }
8994                 usb_devices[usb_devices_index] = optarg;
8995                 usb_devices_index++;
8996                 break;
8997             case QEMU_OPTION_smp:
8998                 smp_cpus = atoi(optarg);
8999                 if (smp_cpus < 1 || smp_cpus > MAX_CPUS) {
9000                     fprintf(stderr, "Invalid number of CPUs\n");
9001                     exit(1);
9002                 }
9003                 break;
9004             case QEMU_OPTION_vnc:
9005                 vnc_display = optarg;
9006                 break;
9007             case QEMU_OPTION_no_acpi:
9008                 acpi_enabled = 0;
9009                 break;
9010             case QEMU_OPTION_no_reboot:
9011                 no_reboot = 1;
9012                 break;
9013             case QEMU_OPTION_no_shutdown:
9014                 no_shutdown = 1;
9015                 break;
9016             case QEMU_OPTION_show_cursor:
9017                 cursor_hide = 0;
9018                 break;
9019             case QEMU_OPTION_uuid:
9020                 if(qemu_uuid_parse(optarg, qemu_uuid) < 0) {
9021                     fprintf(stderr, "Fail to parse UUID string."
9022                             " Wrong format.\n");
9023                     exit(1);
9024                 }
9025                 break;
9026             case QEMU_OPTION_daemonize:
9027                 daemonize = 1;
9028                 break;
9029             case QEMU_OPTION_option_rom:
9030                 if (nb_option_roms >= MAX_OPTION_ROMS) {
9031                     fprintf(stderr, "Too many option ROMs\n");
9032                     exit(1);
9033                 }
9034                 option_rom[nb_option_roms] = optarg;
9035                 nb_option_roms++;
9036                 break;
9037             case QEMU_OPTION_semihosting:
9038                 semihosting_enabled = 1;
9039                 break;
9040             case QEMU_OPTION_name:
9041                 qemu_name = optarg;
9042                 break;
9043 #ifdef TARGET_SPARC
9044             case QEMU_OPTION_prom_env:
9045                 if (nb_prom_envs >= MAX_PROM_ENVS) {
9046                     fprintf(stderr, "Too many prom variables\n");
9047                     exit(1);
9048                 }
9049                 prom_envs[nb_prom_envs] = optarg;
9050                 nb_prom_envs++;
9051                 break;
9052 #endif
9053 #ifdef TARGET_ARM
9054             case QEMU_OPTION_old_param:
9055                 old_param = 1;
9056                 break;
9057 #endif
9058             case QEMU_OPTION_clock:
9059                 configure_alarms(optarg);
9060                 break;
9061             case QEMU_OPTION_startdate:
9062                 {
9063                     struct tm tm;
9064                     time_t rtc_start_date;
9065                     if (!strcmp(optarg, "now")) {
9066                         rtc_date_offset = -1;
9067                     } else {
9068                         if (sscanf(optarg, "%d-%d-%dT%d:%d:%d",
9069                                &tm.tm_year,
9070                                &tm.tm_mon,
9071                                &tm.tm_mday,
9072                                &tm.tm_hour,
9073                                &tm.tm_min,
9074                                &tm.tm_sec) == 6) {
9075                             /* OK */
9076                         } else if (sscanf(optarg, "%d-%d-%d",
9077                                           &tm.tm_year,
9078                                           &tm.tm_mon,
9079                                           &tm.tm_mday) == 3) {
9080                             tm.tm_hour = 0;
9081                             tm.tm_min = 0;
9082                             tm.tm_sec = 0;
9083                         } else {
9084                             goto date_fail;
9085                         }
9086                         tm.tm_year -= 1900;
9087                         tm.tm_mon--;
9088                         rtc_start_date = mktimegm(&tm);
9089                         if (rtc_start_date == -1) {
9090                         date_fail:
9091                             fprintf(stderr, "Invalid date format. Valid format are:\n"
9092                                     "'now' or '2006-06-17T16:01:21' or '2006-06-17'\n");
9093                             exit(1);
9094                         }
9095                         rtc_date_offset = time(NULL) - rtc_start_date;
9096                     }
9097                 }
9098                 break;
9099             case QEMU_OPTION_tb_size:
9100                 tb_size = strtol(optarg, NULL, 0);
9101                 if (tb_size < 0)
9102                     tb_size = 0;
9103                 break;
9104             case QEMU_OPTION_icount:
9105                 use_icount = 1;
9106                 if (strcmp(optarg, "auto") == 0) {
9107                     icount_time_shift = -1;
9108                 } else {
9109                     icount_time_shift = strtol(optarg, NULL, 0);
9110                 }
9111                 break;
9112             }
9113         }
9114     }
9115
9116     if (nographic) {
9117        if (serial_device_index == 0)
9118            serial_devices[0] = "stdio";
9119        if (parallel_device_index == 0)
9120            parallel_devices[0] = "null";
9121        if (strncmp(monitor_device, "vc", 2) == 0)
9122            monitor_device = "stdio";
9123     }
9124
9125 #ifndef _WIN32
9126     if (daemonize) {
9127         pid_t pid;
9128
9129         if (pipe(fds) == -1)
9130             exit(1);
9131
9132         pid = fork();
9133         if (pid > 0) {
9134             uint8_t status;
9135             ssize_t len;
9136
9137             close(fds[1]);
9138
9139         again:
9140             len = read(fds[0], &status, 1);
9141             if (len == -1 && (errno == EINTR))
9142                 goto again;
9143
9144             if (len != 1)
9145                 exit(1);
9146             else if (status == 1) {
9147                 fprintf(stderr, "Could not acquire pidfile\n");
9148                 exit(1);
9149             } else
9150                 exit(0);
9151         } else if (pid < 0)
9152             exit(1);
9153
9154         setsid();
9155
9156         pid = fork();
9157         if (pid > 0)
9158             exit(0);
9159         else if (pid < 0)
9160             exit(1);
9161
9162         umask(027);
9163
9164         signal(SIGTSTP, SIG_IGN);
9165         signal(SIGTTOU, SIG_IGN);
9166         signal(SIGTTIN, SIG_IGN);
9167     }
9168 #endif
9169
9170     if (pid_file && qemu_create_pidfile(pid_file) != 0) {
9171         if (daemonize) {
9172             uint8_t status = 1;
9173             write(fds[1], &status, 1);
9174         } else
9175             fprintf(stderr, "Could not acquire pid file\n");
9176         exit(1);
9177     }
9178
9179 #ifdef USE_KQEMU
9180     if (smp_cpus > 1)
9181         kqemu_allowed = 0;
9182 #endif
9183     linux_boot = (kernel_filename != NULL);
9184     net_boot = (boot_devices_bitmap >> ('n' - 'a')) & 0xF;
9185
9186     if (!linux_boot && net_boot == 0 &&
9187         !machine->nodisk_ok && nb_drives_opt == 0)
9188         help(1);
9189
9190     if (!linux_boot && *kernel_cmdline != '\0') {
9191         fprintf(stderr, "-append only allowed with -kernel option\n");
9192         exit(1);
9193     }
9194
9195     if (!linux_boot && initrd_filename != NULL) {
9196         fprintf(stderr, "-initrd only allowed with -kernel option\n");
9197         exit(1);
9198     }
9199
9200     /* boot to floppy or the default cd if no hard disk defined yet */
9201     if (!boot_devices[0]) {
9202         boot_devices = "cad";
9203     }
9204     setvbuf(stdout, NULL, _IOLBF, 0);
9205
9206     init_timers();
9207     init_timer_alarm();
9208     if (use_icount && icount_time_shift < 0) {
9209         use_icount = 2;
9210         /* 125MIPS seems a reasonable initial guess at the guest speed.
9211            It will be corrected fairly quickly anyway.  */
9212         icount_time_shift = 3;
9213         init_icount_adjust();
9214     }
9215
9216 #ifdef _WIN32
9217     socket_init();
9218 #endif
9219
9220     /* init network clients */
9221     if (nb_net_clients == 0) {
9222         /* if no clients, we use a default config */
9223         net_clients[nb_net_clients++] = "nic";
9224 #ifdef CONFIG_SLIRP
9225         net_clients[nb_net_clients++] = "user";
9226 #endif
9227     }
9228
9229     for(i = 0;i < nb_net_clients; i++) {
9230         if (net_client_parse(net_clients[i]) < 0)
9231             exit(1);
9232     }
9233     for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
9234         if (vlan->nb_guest_devs == 0 && vlan->nb_host_devs == 0)
9235             continue;
9236         if (vlan->nb_guest_devs == 0)
9237             fprintf(stderr, "Warning: vlan %d with no nics\n", vlan->id);
9238         if (vlan->nb_host_devs == 0)
9239             fprintf(stderr,
9240                     "Warning: vlan %d is not connected to host network\n",
9241                     vlan->id);
9242     }
9243
9244 #ifdef TARGET_I386
9245     /* XXX: this should be moved in the PC machine instantiation code */
9246     if (net_boot != 0) {
9247         int netroms = 0;
9248         for (i = 0; i < nb_nics && i < 4; i++) {
9249             const char *model = nd_table[i].model;
9250             char buf[1024];
9251             if (net_boot & (1 << i)) {
9252                 if (model == NULL)
9253                     model = "ne2k_pci";
9254                 snprintf(buf, sizeof(buf), "%s/pxe-%s.bin", bios_dir, model);
9255                 if (get_image_size(buf) > 0) {
9256                     if (nb_option_roms >= MAX_OPTION_ROMS) {
9257                         fprintf(stderr, "Too many option ROMs\n");
9258                         exit(1);
9259                     }
9260                     option_rom[nb_option_roms] = strdup(buf);
9261                     nb_option_roms++;
9262                     netroms++;
9263                 }
9264             }
9265         }
9266         if (netroms == 0) {
9267             fprintf(stderr, "No valid PXE rom found for network device\n");
9268             exit(1);
9269         }
9270     }
9271 #endif
9272
9273     /* init the memory */
9274     phys_ram_size = machine->ram_require & ~RAMSIZE_FIXED;
9275
9276     if (machine->ram_require & RAMSIZE_FIXED) {
9277         if (ram_size > 0) {
9278             if (ram_size < phys_ram_size) {
9279                 fprintf(stderr, "Machine `%s' requires %llu bytes of memory\n",
9280                                 machine->name, (unsigned long long) phys_ram_size);
9281                 exit(-1);
9282             }
9283
9284             phys_ram_size = ram_size;
9285         } else
9286             ram_size = phys_ram_size;
9287     } else {
9288         if (ram_size == 0)
9289             ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
9290
9291         phys_ram_size += ram_size;
9292     }
9293
9294     phys_ram_base = qemu_vmalloc(phys_ram_size);
9295     if (!phys_ram_base) {
9296         fprintf(stderr, "Could not allocate physical memory\n");
9297         exit(1);
9298     }
9299
9300     /* init the dynamic translator */
9301     cpu_exec_init_all(tb_size * 1024 * 1024);
9302
9303     bdrv_init();
9304
9305     /* we always create the cdrom drive, even if no disk is there */
9306
9307     if (nb_drives_opt < MAX_DRIVES)
9308         drive_add(NULL, CDROM_ALIAS);
9309
9310     /* we always create at least one floppy */
9311
9312     if (nb_drives_opt < MAX_DRIVES)
9313         drive_add(NULL, FD_ALIAS, 0);
9314
9315     /* we always create one sd slot, even if no card is in it */
9316
9317     if (nb_drives_opt < MAX_DRIVES)
9318         drive_add(NULL, SD_ALIAS);
9319
9320     /* open the virtual block devices */
9321
9322     for(i = 0; i < nb_drives_opt; i++)
9323         if (drive_init(&drives_opt[i], snapshot, machine) == -1)
9324             exit(1);
9325
9326     register_savevm("timer", 0, 2, timer_save, timer_load, NULL);
9327     register_savevm("ram", 0, 2, ram_save, ram_load, NULL);
9328
9329     /* terminal init */
9330     memset(&display_state, 0, sizeof(display_state));
9331     if (nographic) {
9332         if (curses) {
9333             fprintf(stderr, "fatal: -nographic can't be used with -curses\n");
9334             exit(1);
9335         }
9336         /* nearly nothing to do */
9337         dumb_display_init(ds);
9338     } else if (vnc_display != NULL) {
9339         vnc_display_init(ds);
9340         if (vnc_display_open(ds, vnc_display) < 0)
9341             exit(1);
9342     } else
9343 #if defined(CONFIG_CURSES)
9344     if (curses) {
9345         curses_display_init(ds, full_screen);
9346     } else
9347 #endif
9348     {
9349 #if defined(CONFIG_SDL)
9350         sdl_display_init(ds, full_screen, no_frame);
9351 #elif defined(CONFIG_COCOA)
9352         cocoa_display_init(ds, full_screen);
9353 #else
9354         dumb_display_init(ds);
9355 #endif
9356     }
9357
9358 #ifndef _WIN32
9359     /* must be after terminal init, SDL library changes signal handlers */
9360     termsig_setup();
9361 #endif
9362
9363     /* Maintain compatibility with multiple stdio monitors */
9364     if (!strcmp(monitor_device,"stdio")) {
9365         for (i = 0; i < MAX_SERIAL_PORTS; i++) {
9366             const char *devname = serial_devices[i];
9367             if (devname && !strcmp(devname,"mon:stdio")) {
9368                 monitor_device = NULL;
9369                 break;
9370             } else if (devname && !strcmp(devname,"stdio")) {
9371                 monitor_device = NULL;
9372                 serial_devices[i] = "mon:stdio";
9373                 break;
9374             }
9375         }
9376     }
9377     if (monitor_device) {
9378         monitor_hd = qemu_chr_open(monitor_device);
9379         if (!monitor_hd) {
9380             fprintf(stderr, "qemu: could not open monitor device '%s'\n", monitor_device);
9381             exit(1);
9382         }
9383         monitor_init(monitor_hd, !nographic);
9384     }
9385
9386     for(i = 0; i < MAX_SERIAL_PORTS; i++) {
9387         const char *devname = serial_devices[i];
9388         if (devname && strcmp(devname, "none")) {
9389             serial_hds[i] = qemu_chr_open(devname);
9390             if (!serial_hds[i]) {
9391                 fprintf(stderr, "qemu: could not open serial device '%s'\n",
9392                         devname);
9393                 exit(1);
9394             }
9395             if (strstart(devname, "vc", 0))
9396                 qemu_chr_printf(serial_hds[i], "serial%d console\r\n", i);
9397         }
9398     }
9399
9400     for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
9401         const char *devname = parallel_devices[i];
9402         if (devname && strcmp(devname, "none")) {
9403             parallel_hds[i] = qemu_chr_open(devname);
9404             if (!parallel_hds[i]) {
9405                 fprintf(stderr, "qemu: could not open parallel device '%s'\n",
9406                         devname);
9407                 exit(1);
9408             }
9409             if (strstart(devname, "vc", 0))
9410                 qemu_chr_printf(parallel_hds[i], "parallel%d console\r\n", i);
9411         }
9412     }
9413
9414     machine->init(ram_size, vga_ram_size, boot_devices, ds,
9415                   kernel_filename, kernel_cmdline, initrd_filename, cpu_model);
9416
9417     /* init USB devices */
9418     if (usb_enabled) {
9419         for(i = 0; i < usb_devices_index; i++) {
9420             if (usb_device_add(usb_devices[i]) < 0) {
9421                 fprintf(stderr, "Warning: could not add USB device %s\n",
9422                         usb_devices[i]);
9423             }
9424         }
9425     }
9426
9427     if (display_state.dpy_refresh) {
9428         display_state.gui_timer = qemu_new_timer(rt_clock, gui_update, &display_state);
9429         qemu_mod_timer(display_state.gui_timer, qemu_get_clock(rt_clock));
9430     }
9431
9432 #ifdef CONFIG_GDBSTUB
9433     if (use_gdbstub) {
9434         /* XXX: use standard host:port notation and modify options
9435            accordingly. */
9436         if (gdbserver_start(gdbstub_port) < 0) {
9437             fprintf(stderr, "qemu: could not open gdbstub device on port '%s'\n",
9438                     gdbstub_port);
9439             exit(1);
9440         }
9441     }
9442 #endif
9443
9444     if (loadvm)
9445         do_loadvm(loadvm);
9446
9447     {
9448         /* XXX: simplify init */
9449         read_passwords();
9450         if (autostart) {
9451             vm_start();
9452         }
9453     }
9454
9455     if (daemonize) {
9456         uint8_t status = 0;
9457         ssize_t len;
9458         int fd;
9459
9460     again1:
9461         len = write(fds[1], &status, 1);
9462         if (len == -1 && (errno == EINTR))
9463             goto again1;
9464
9465         if (len != 1)
9466             exit(1);
9467
9468         chdir("/");
9469         TFR(fd = open("/dev/null", O_RDWR));
9470         if (fd == -1)
9471             exit(1);
9472
9473         dup2(fd, 0);
9474         dup2(fd, 1);
9475         dup2(fd, 2);
9476
9477         close(fd);
9478     }
9479
9480     main_loop();
9481     quit_timers();
9482
9483 #if !defined(_WIN32)
9484     /* close network clients */
9485     for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
9486         VLANClientState *vc;
9487
9488         for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
9489             if (vc->fd_read == tap_receive) {
9490                 char ifname[64];
9491                 TAPState *s = vc->opaque;
9492
9493                 if (sscanf(vc->info_str, "tap: ifname=%63s ", ifname) == 1 &&
9494                     s->down_script[0])
9495                     launch_script(s->down_script, ifname, s->fd);
9496             }
9497 #if defined(CONFIG_VDE)
9498             if (vc->fd_read == vde_from_qemu) {
9499                 VDEState *s = vc->opaque;
9500                 vde_close(s->vde);
9501             }
9502 #endif
9503         }
9504     }
9505 #endif
9506     return 0;
9507 }