Archipelago » qemu

        chr->init(chr);

}

{

    CharDriverState *chr;

    TextConsole *s;

    if (!s) {

        free(chr);

    }

    s->chr = chr;

    s->g_height = height;

    chr->opaque = s;

    chr->chr_set_echo = text_console_set_echo;

}

void text_consoles_set_display(DisplayState *ds)

int is_graphic_console(void);

int is_fixedsize_console(void);

void text_consoles_set_display(DisplayState *ds);

void console_select(unsigned int index);

void console_color_init(DisplayState *ds);

    qemu_free(baum);

}

{

    BaumDriverState *baum;

    CharDriverState *chr;

    qemu_chr_generic_open(chr);

fail:

    qemu_free_timer(baum->cellCount_timer);

    qemu_free(handle);

    qemu_free(chr);

    qemu_free(baum);

}

    qemu_free (chr);

}

{

    CharDriverState *chr;

    qemu_add_mouse_event_handler(msmouse_event, chr, 0, "QEMU Microsoft Mouse");

}

/* msmouse.c */

    return len;

}

{

    CharDriverState *chr;

    chr = qemu_mallocz(sizeof(CharDriverState));

    chr->chr_write = null_chr_write;

}

/* MUX driver for serial I/O splitting */

    return chr;

}

{

    int fd_out;

    TFR(fd_out = qemu_open(qemu_opt_get(opts, "path"),

                      O_WRONLY | O_TRUNC | O_CREAT | O_BINARY, 0666));

}

{

    int fd_in, fd_out;

    char filename_in[256], filename_out[256];

    if (filename == NULL) {

        fprintf(stderr, "chardev: pipe: no filename given\n");

    }

    snprintf(filename_in, 256, "%s.in", filename);

	    close(fd_in);

	if (fd_out >= 0)

	    close(fd_out);

    }

}

    fd_chr_close(chr);

}

{

    CharDriverState *chr;

    if (stdio_nb_clients == 0) {

        old_fd0_flags = fcntl(0, F_GETFL);

        tcgetattr (0, &oldtty);

                                           display_type != DT_NOGRAPHIC);

    qemu_chr_set_echo(chr, false);

}

#ifdef __sun__

    qemu_chr_event(chr, CHR_EVENT_CLOSED);

}

{

    CharDriverState *chr;

    PtyCharDriver *s;

    s = qemu_mallocz(sizeof(PtyCharDriver));

    if (openpty(&s->fd, &slave_fd, pty_name, NULL, NULL) < 0) {

    }

    /* Set raw attributes on the pty. */

    s->timer = qemu_new_timer_ms(rt_clock, pty_chr_timer, chr);

}

static void tty_serial_init(int fd, int speed,

    }

}

{

    const char *filename = qemu_opt_get(opts, "path");

    CharDriverState *chr;

    int fd;

    if (fd < 0) {

    }

    tty_serial_init(fd, 115200, 'N', 8, 1);

    chr = qemu_chr_open_fd(fd, fd);

    chr->chr_ioctl = tty_serial_ioctl;

    chr->chr_close = qemu_chr_close_tty;

}

#else  /* ! __linux__ && ! __sun__ */

{

}

#endif /* __linux__ || __sun__ */

    qemu_chr_event(chr, CHR_EVENT_CLOSED);

}

{

    const char *filename = qemu_opt_get(opts, "path");

    CharDriverState *chr;

    int fd;

    TFR(fd = open(filename, O_RDWR));

    if (ioctl(fd, PPCLAIM) < 0) {

        close(fd);

    }

    drv = qemu_mallocz(sizeof(ParallelCharDriver));

    qemu_chr_generic_open(chr);

}

#endif /* __linux__ */

    return 0;

}

{

    const char *filename = qemu_opt_get(opts, "path");

    CharDriverState *chr;

    int fd;

    chr = qemu_mallocz(sizeof(CharDriverState));

    chr->opaque = (void *)(intptr_t)fd;

    chr->chr_write = null_chr_write;

    chr->chr_ioctl = pp_ioctl;

}

#endif

    return 0;

}

{

    const char *filename = qemu_opt_get(opts, "path");

    CharDriverState *chr;

    if (win_chr_init(chr, filename) < 0) {

        free(s);

        free(chr);

    }

    qemu_chr_generic_open(chr);

}

static int win_chr_pipe_poll(void *opaque)

}

{

    const char *filename = qemu_opt_get(opts, "path");

    CharDriverState *chr;

    if (win_chr_pipe_init(chr, filename) < 0) {

        free(s);

        free(chr);

    }

    qemu_chr_generic_open(chr);

}

static CharDriverState *qemu_chr_open_win_file(HANDLE fd_out)

    return chr;

}

{

}

{

    const char *file_out = qemu_opt_get(opts, "path");

    HANDLE fd_out;

    fd_out = CreateFile(file_out, GENERIC_WRITE, FILE_SHARE_READ, NULL,

                        OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);

}

#endif /* !_WIN32 */

    qemu_chr_event(chr, CHR_EVENT_CLOSED);

}

{

    CharDriverState *chr = NULL;

    NetCharDriver *s = NULL;

    int fd = -1;

    chr = qemu_mallocz(sizeof(CharDriverState));

    s = qemu_mallocz(sizeof(NetCharDriver));

    fd = inet_dgram_opts(opts);

    if (fd < 0) {

        fprintf(stderr, "inet_dgram_opts failed\n");

        goto return_err;

    }

    chr->chr_write = udp_chr_write;

    chr->chr_update_read_handler = udp_chr_update_read_handler;

    chr->chr_close = udp_chr_close;

return_err:

        closesocket(fd);

}

/***********************************************************/

    qemu_chr_event(chr, CHR_EVENT_CLOSED);

}

{

    CharDriverState *chr = NULL;

    TCPCharDriver *s = NULL;

    int do_nodelay;

    int is_unix;

    int is_telnet;

    is_listen      = qemu_opt_get_bool(opts, "server", 0);

    is_waitconnect = qemu_opt_get_bool(opts, "wait", 1);

            fd = inet_connect_opts(opts);

        }

    }

        goto fail;

    if (!is_waitconnect)

        socket_set_nonblock(fd);

        tcp_chr_accept(chr);

        socket_set_nonblock(s->listen_fd);

    }

 fail:

    if (fd >= 0)

        closesocket(fd);

    qemu_free(s);

    qemu_free(chr);

}

/***********************************************************/

static const struct {

    const char *name;

} backend_table[] = {

    { .name = "null",      .open = qemu_chr_open_null },

    { .name = "socket",    .open = qemu_chr_open_socket },

{

    CharDriverState *chr;

    int i;

    if (qemu_opts_id(opts) == NULL) {

        fprintf(stderr, "chardev: no id specified\n");

        return NULL;

    }

        return NULL;

    }

    fprintf(stderr, "\n");

}

{

    CharDriverState *chr;

    SpiceCharDriver *s;

    if (name == NULL) {

        fprintf(stderr, "spice-qemu-char: missing name parameter\n");

        print_allowed_subtypes();

    }

    for(;*psubtype != NULL; ++psubtype) {

        if (strcmp(name, *psubtype) == 0) {

    if (subtype == NULL) {

        fprintf(stderr, "spice-qemu-char: unsupported name\n");

        print_allowed_subtypes();

    }

    chr = qemu_mallocz(sizeof(CharDriverState));

    qemu_chr_generic_open(chr);

}

void do_info_spice_print(Monitor *mon, const QObject *data);

void do_info_spice(Monitor *mon, QObject **ret_data);

#else  /* CONFIG_SPICE */