#include <unistd.h>
#include <fcntl.h>
-#include <signal.h>
#include <time.h>
#include <errno.h>
#include <sys/time.h>
return s->get_msgfd ? s->get_msgfd(s) : -1;
}
+int qemu_chr_add_client(CharDriverState *s, int fd)
+{
+ return s->chr_add_client ? s->chr_add_client(s, fd) : -1;
+}
+
void qemu_chr_accept_input(CharDriverState *s)
{
if (s->chr_accept_input)
return len;
}
-static CharDriverState *qemu_chr_open_null(QemuOpts *opts)
+static int qemu_chr_open_null(QemuOpts *opts, CharDriverState **_chr)
{
CharDriverState *chr;
- chr = qemu_mallocz(sizeof(CharDriverState));
+ chr = g_malloc0(sizeof(CharDriverState));
chr->chr_write = null_chr_write;
- return chr;
+
+ *_chr= chr;
+ return 0;
}
/* MUX driver for serial I/O splitting */
CharDriverState *chr;
MuxDriver *d;
- chr = qemu_mallocz(sizeof(CharDriverState));
- d = qemu_mallocz(sizeof(MuxDriver));
+ chr = g_malloc0(sizeof(CharDriverState));
+ d = g_malloc0(sizeof(MuxDriver));
chr->opaque = d;
d->drv = drv;
}
}
- qemu_free(s);
+ g_free(s);
qemu_chr_event(chr, CHR_EVENT_CLOSED);
}
CharDriverState *chr;
FDCharDriver *s;
- chr = qemu_mallocz(sizeof(CharDriverState));
- s = qemu_mallocz(sizeof(FDCharDriver));
+ chr = g_malloc0(sizeof(CharDriverState));
+ s = g_malloc0(sizeof(FDCharDriver));
s->fd_in = fd_in;
s->fd_out = fd_out;
chr->opaque = s;
return chr;
}
-static CharDriverState *qemu_chr_open_file_out(QemuOpts *opts)
+static int qemu_chr_open_file_out(QemuOpts *opts, CharDriverState **_chr)
{
int fd_out;
TFR(fd_out = qemu_open(qemu_opt_get(opts, "path"),
O_WRONLY | O_TRUNC | O_CREAT | O_BINARY, 0666));
- if (fd_out < 0)
- return NULL;
- return qemu_chr_open_fd(-1, fd_out);
+ if (fd_out < 0) {
+ return -errno;
+ }
+
+ *_chr = qemu_chr_open_fd(-1, fd_out);
+ return 0;
}
-static CharDriverState *qemu_chr_open_pipe(QemuOpts *opts)
+static int qemu_chr_open_pipe(QemuOpts *opts, CharDriverState **_chr)
{
int fd_in, fd_out;
char filename_in[256], filename_out[256];
if (filename == NULL) {
fprintf(stderr, "chardev: pipe: no filename given\n");
- return NULL;
+ return -EINVAL;
}
snprintf(filename_in, 256, "%s.in", filename);
close(fd_in);
if (fd_out >= 0)
close(fd_out);
- TFR(fd_in = fd_out = open(filename, O_RDWR | O_BINARY));
- if (fd_in < 0)
- return NULL;
+ TFR(fd_in = fd_out = qemu_open(filename, O_RDWR | O_BINARY));
+ if (fd_in < 0) {
+ return -errno;
+ }
}
- return qemu_chr_open_fd(fd_in, fd_out);
+
+ *_chr = qemu_chr_open_fd(fd_in, fd_out);
+ return 0;
}
fd_chr_close(chr);
}
-static CharDriverState *qemu_chr_open_stdio(QemuOpts *opts)
+static int qemu_chr_open_stdio(QemuOpts *opts, CharDriverState **_chr)
{
CharDriverState *chr;
- if (stdio_nb_clients >= STDIO_MAX_CLIENTS)
- return NULL;
+ if (stdio_nb_clients >= STDIO_MAX_CLIENTS) {
+ return -EBUSY;
+ }
+
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);
- return chr;
+ *_chr = chr;
+ return 0;
}
#ifdef __sun__
close(s->fd);
qemu_del_timer(s->timer);
qemu_free_timer(s->timer);
- qemu_free(s);
+ g_free(s);
qemu_chr_event(chr, CHR_EVENT_CLOSED);
}
-static CharDriverState *qemu_chr_open_pty(QemuOpts *opts)
+static int qemu_chr_open_pty(QemuOpts *opts, CharDriverState **_chr)
{
CharDriverState *chr;
PtyCharDriver *s;
#define q_ptsname(x) ptsname(x)
#endif
- chr = qemu_mallocz(sizeof(CharDriverState));
- s = qemu_mallocz(sizeof(PtyCharDriver));
+ chr = g_malloc0(sizeof(CharDriverState));
+ s = g_malloc0(sizeof(PtyCharDriver));
if (openpty(&s->fd, &slave_fd, pty_name, NULL, NULL) < 0) {
- return NULL;
+ return -errno;
}
/* Set raw attributes on the pty. */
close(slave_fd);
len = strlen(q_ptsname(s->fd)) + 5;
- chr->filename = qemu_malloc(len);
+ chr->filename = g_malloc(len);
snprintf(chr->filename, len, "pty:%s", q_ptsname(s->fd));
qemu_opt_set(opts, "path", q_ptsname(s->fd));
fprintf(stderr, "char device redirected to %s\n", q_ptsname(s->fd));
s->timer = qemu_new_timer_ms(rt_clock, pty_chr_timer, chr);
- return chr;
+ *_chr = chr;
+ return 0;
}
static void tty_serial_init(int fd, int speed,
}
}
-static CharDriverState *qemu_chr_open_tty(QemuOpts *opts)
+static int qemu_chr_open_tty(QemuOpts *opts, CharDriverState **_chr)
{
const char *filename = qemu_opt_get(opts, "path");
CharDriverState *chr;
int fd;
- TFR(fd = open(filename, O_RDWR | O_NONBLOCK));
+ TFR(fd = qemu_open(filename, O_RDWR | O_NONBLOCK));
if (fd < 0) {
- return NULL;
+ return -errno;
}
tty_serial_init(fd, 115200, 'N', 8, 1);
chr = qemu_chr_open_fd(fd, fd);
- if (!chr) {
- close(fd);
- return NULL;
- }
chr->chr_ioctl = tty_serial_ioctl;
chr->chr_close = qemu_chr_close_tty;
- return chr;
+
+ *_chr = chr;
+ return 0;
}
#else /* ! __linux__ && ! __sun__ */
-static CharDriverState *qemu_chr_open_pty(QemuOpts *opts)
+static int qemu_chr_open_pty(QemuOpts *opts, CharDriverState **_chr)
{
- return NULL;
+ return -ENOTSUP;
}
#endif /* __linux__ || __sun__ */
pp_hw_mode(drv, IEEE1284_MODE_COMPAT);
ioctl(fd, PPRELEASE);
close(fd);
- qemu_free(drv);
+ g_free(drv);
qemu_chr_event(chr, CHR_EVENT_CLOSED);
}
-static CharDriverState *qemu_chr_open_pp(QemuOpts *opts)
+static int qemu_chr_open_pp(QemuOpts *opts, CharDriverState **_chr)
{
const char *filename = qemu_opt_get(opts, "path");
CharDriverState *chr;
int fd;
TFR(fd = open(filename, O_RDWR));
- if (fd < 0)
- return NULL;
+ if (fd < 0) {
+ return -errno;
+ }
if (ioctl(fd, PPCLAIM) < 0) {
close(fd);
- return NULL;
+ return -errno;
}
- drv = qemu_mallocz(sizeof(ParallelCharDriver));
+ drv = g_malloc0(sizeof(ParallelCharDriver));
drv->fd = fd;
drv->mode = IEEE1284_MODE_COMPAT;
- chr = qemu_mallocz(sizeof(CharDriverState));
+ chr = g_malloc0(sizeof(CharDriverState));
chr->chr_write = null_chr_write;
chr->chr_ioctl = pp_ioctl;
chr->chr_close = pp_close;
qemu_chr_generic_open(chr);
- return chr;
+ *_chr = chr;
+ return 0;
}
#endif /* __linux__ */
return 0;
}
-static CharDriverState *qemu_chr_open_pp(QemuOpts *opts)
+static int qemu_chr_open_pp(QemuOpts *opts, CharDriverState **_chr)
{
const char *filename = qemu_opt_get(opts, "path");
CharDriverState *chr;
int fd;
- fd = open(filename, O_RDWR);
- if (fd < 0)
- return NULL;
+ fd = qemu_open(filename, O_RDWR);
+ if (fd < 0) {
+ return -errno;
+ }
- chr = qemu_mallocz(sizeof(CharDriverState));
+ chr = g_malloc0(sizeof(CharDriverState));
chr->opaque = (void *)(intptr_t)fd;
chr->chr_write = null_chr_write;
chr->chr_ioctl = pp_ioctl;
- return chr;
+
+ *_chr = chr;
+ return 0;
}
#endif
return 0;
}
-static CharDriverState *qemu_chr_open_win(QemuOpts *opts)
+static int qemu_chr_open_win(QemuOpts *opts, CharDriverState **_chr)
{
const char *filename = qemu_opt_get(opts, "path");
CharDriverState *chr;
WinCharState *s;
- chr = qemu_mallocz(sizeof(CharDriverState));
- s = qemu_mallocz(sizeof(WinCharState));
+ chr = g_malloc0(sizeof(CharDriverState));
+ s = g_malloc0(sizeof(WinCharState));
chr->opaque = s;
chr->chr_write = win_chr_write;
chr->chr_close = win_chr_close;
if (win_chr_init(chr, filename) < 0) {
free(s);
free(chr);
- return NULL;
+ return -EIO;
}
qemu_chr_generic_open(chr);
- return chr;
+
+ *_chr = chr;
+ return 0;
}
static int win_chr_pipe_poll(void *opaque)
}
-static CharDriverState *qemu_chr_open_win_pipe(QemuOpts *opts)
+static int qemu_chr_open_win_pipe(QemuOpts *opts, CharDriverState **_chr)
{
const char *filename = qemu_opt_get(opts, "path");
CharDriverState *chr;
WinCharState *s;
- chr = qemu_mallocz(sizeof(CharDriverState));
- s = qemu_mallocz(sizeof(WinCharState));
+ chr = g_malloc0(sizeof(CharDriverState));
+ s = g_malloc0(sizeof(WinCharState));
chr->opaque = s;
chr->chr_write = win_chr_write;
chr->chr_close = win_chr_close;
if (win_chr_pipe_init(chr, filename) < 0) {
free(s);
free(chr);
- return NULL;
+ return -EIO;
}
qemu_chr_generic_open(chr);
- return chr;
+
+ *_chr = chr;
+ return 0;
}
-static CharDriverState *qemu_chr_open_win_file(HANDLE fd_out)
+static int qemu_chr_open_win_file(HANDLE fd_out, CharDriverState **pchr)
{
CharDriverState *chr;
WinCharState *s;
- chr = qemu_mallocz(sizeof(CharDriverState));
- s = qemu_mallocz(sizeof(WinCharState));
+ chr = g_malloc0(sizeof(CharDriverState));
+ s = g_malloc0(sizeof(WinCharState));
s->hcom = fd_out;
chr->opaque = s;
chr->chr_write = win_chr_write;
qemu_chr_generic_open(chr);
- return chr;
+ *pchr = chr;
+ return 0;
}
-static CharDriverState *qemu_chr_open_win_con(QemuOpts *opts)
+static int qemu_chr_open_win_con(QemuOpts *opts, CharDriverState **chr)
{
- return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE));
+ return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE), chr);
}
-static CharDriverState *qemu_chr_open_win_file_out(QemuOpts *opts)
+static int qemu_chr_open_win_file_out(QemuOpts *opts, CharDriverState **_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);
- if (fd_out == INVALID_HANDLE_VALUE)
- return NULL;
+ if (fd_out == INVALID_HANDLE_VALUE) {
+ return -EIO;
+ }
- return qemu_chr_open_win_file(fd_out);
+ return qemu_chr_open_win_file(fd_out, _chr);
}
#endif /* !_WIN32 */
if (s->max_size == 0)
return;
- s->bufcnt = recv(s->fd, (void *)s->buf, sizeof(s->buf), 0);
+ s->bufcnt = qemu_recv(s->fd, s->buf, sizeof(s->buf), 0);
s->bufptr = s->bufcnt;
if (s->bufcnt <= 0)
return;
qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
closesocket(s->fd);
}
- qemu_free(s);
+ g_free(s);
qemu_chr_event(chr, CHR_EVENT_CLOSED);
}
-static CharDriverState *qemu_chr_open_udp(QemuOpts *opts)
+static int qemu_chr_open_udp(QemuOpts *opts, CharDriverState **_chr)
{
CharDriverState *chr = NULL;
NetCharDriver *s = NULL;
int fd = -1;
+ int ret;
- chr = qemu_mallocz(sizeof(CharDriverState));
- s = qemu_mallocz(sizeof(NetCharDriver));
+ chr = g_malloc0(sizeof(CharDriverState));
+ s = g_malloc0(sizeof(NetCharDriver));
fd = inet_dgram_opts(opts);
if (fd < 0) {
fprintf(stderr, "inet_dgram_opts failed\n");
+ ret = -errno;
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 chr;
+
+ *_chr = chr;
+ return 0;
return_err:
- if (chr)
- free(chr);
- if (s)
- free(s);
- if (fd >= 0)
+ g_free(chr);
+ g_free(s);
+ if (fd >= 0) {
closesocket(fd);
- return NULL;
+ }
+ return ret;
}
/***********************************************************/
static ssize_t tcp_chr_recv(CharDriverState *chr, char *buf, size_t len)
{
TCPCharDriver *s = chr->opaque;
- return recv(s->fd, buf, len, 0);
+ return qemu_recv(s->fd, buf, len, 0);
}
#endif
setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val));
}
+static int tcp_chr_add_client(CharDriverState *chr, int fd)
+{
+ TCPCharDriver *s = chr->opaque;
+ if (s->fd != -1)
+ return -1;
+
+ socket_set_nonblock(fd);
+ if (s->do_nodelay)
+ socket_set_nodelay(fd);
+ s->fd = fd;
+ qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);
+ tcp_chr_connect(chr);
+
+ return 0;
+}
+
static void tcp_chr_accept(void *opaque)
{
CharDriverState *chr = opaque;
break;
}
}
- socket_set_nonblock(fd);
- if (s->do_nodelay)
- socket_set_nodelay(fd);
- s->fd = fd;
- qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);
- tcp_chr_connect(chr);
+ if (tcp_chr_add_client(chr, fd) < 0)
+ close(fd);
}
static void tcp_chr_close(CharDriverState *chr)
qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);
closesocket(s->listen_fd);
}
- qemu_free(s);
+ g_free(s);
qemu_chr_event(chr, CHR_EVENT_CLOSED);
}
-static CharDriverState *qemu_chr_open_socket(QemuOpts *opts)
+static int qemu_chr_open_socket(QemuOpts *opts, CharDriverState **_chr)
{
CharDriverState *chr = NULL;
TCPCharDriver *s = NULL;
int do_nodelay;
int is_unix;
int is_telnet;
+ int ret;
is_listen = qemu_opt_get_bool(opts, "server", 0);
is_waitconnect = qemu_opt_get_bool(opts, "wait", 1);
if (!is_listen)
is_waitconnect = 0;
- chr = qemu_mallocz(sizeof(CharDriverState));
- s = qemu_mallocz(sizeof(TCPCharDriver));
+ chr = g_malloc0(sizeof(CharDriverState));
+ s = g_malloc0(sizeof(TCPCharDriver));
if (is_unix) {
if (is_listen) {
fd = inet_connect_opts(opts);
}
}
- if (fd < 0)
+ if (fd < 0) {
+ ret = -errno;
goto fail;
+ }
if (!is_waitconnect)
socket_set_nonblock(fd);
chr->chr_write = tcp_chr_write;
chr->chr_close = tcp_chr_close;
chr->get_msgfd = tcp_get_msgfd;
+ chr->chr_add_client = tcp_chr_add_client;
if (is_listen) {
s->listen_fd = fd;
}
/* for "info chardev" monitor command */
- chr->filename = qemu_malloc(256);
+ chr->filename = g_malloc(256);
if (is_unix) {
snprintf(chr->filename, 256, "unix:%s%s",
qemu_opt_get(opts, "path"),
tcp_chr_accept(chr);
socket_set_nonblock(s->listen_fd);
}
- return chr;
+
+ *_chr = chr;
+ return 0;
fail:
if (fd >= 0)
closesocket(fd);
- qemu_free(s);
- qemu_free(chr);
- return NULL;
+ g_free(s);
+ g_free(chr);
+ return ret;
}
/***********************************************************/
/* grow outbuf */
d->outbuf_capacity += len;
d->outbuf_capacity *= 2;
- d->outbuf = qemu_realloc(d->outbuf, d->outbuf_capacity);
+ d->outbuf = g_realloc(d->outbuf, d->outbuf_capacity);
}
memcpy(d->outbuf + d->outbuf_size, buf, len);
{
MemoryDriver *d;
- d = qemu_malloc(sizeof(*d));
+ d = g_malloc(sizeof(*d));
d->outbuf_size = 0;
d->outbuf_capacity = 4096;
- d->outbuf = qemu_mallocz(d->outbuf_capacity);
+ d->outbuf = g_malloc0(d->outbuf_capacity);
memset(chr, 0, sizeof(*chr));
chr->opaque = d;
{
MemoryDriver *d = chr->opaque;
- qemu_free(d->outbuf);
- qemu_free(chr->opaque);
+ g_free(d->outbuf);
+ g_free(chr->opaque);
chr->opaque = NULL;
chr->chr_write = NULL;
}
static const struct {
const char *name;
- CharDriverState *(*open)(QemuOpts *opts);
+ int (*open)(QemuOpts *opts, CharDriverState **chr);
} backend_table[] = {
{ .name = "null", .open = qemu_chr_open_null },
{ .name = "socket", .open = qemu_chr_open_socket },
{
CharDriverState *chr;
int i;
+ int ret;
if (qemu_opts_id(opts) == NULL) {
fprintf(stderr, "chardev: no id specified\n");
return NULL;
}
- chr = backend_table[i].open(opts);
- if (!chr) {
- fprintf(stderr, "chardev: opening backend \"%s\" failed\n",
- qemu_opt_get(opts, "backend"));
+ ret = backend_table[i].open(opts, &chr);
+ if (ret < 0) {
+ fprintf(stderr, "chardev: opening backend \"%s\" failed: %s\n",
+ qemu_opt_get(opts, "backend"), strerror(-ret));
return NULL;
}
if (!chr->filename)
- chr->filename = qemu_strdup(qemu_opt_get(opts, "backend"));
+ chr->filename = g_strdup(qemu_opt_get(opts, "backend"));
chr->init = init;
QTAILQ_INSERT_TAIL(&chardevs, chr, next);
if (qemu_opt_get_bool(opts, "mux", 0)) {
CharDriverState *base = chr;
int len = strlen(qemu_opts_id(opts)) + 6;
- base->label = qemu_malloc(len);
+ base->label = g_malloc(len);
snprintf(base->label, len, "%s-base", qemu_opts_id(opts));
chr = qemu_chr_open_mux(base);
chr->filename = base->filename;
} else {
chr->avail_connections = 1;
}
- chr->label = qemu_strdup(qemu_opts_id(opts));
+ chr->label = g_strdup(qemu_opts_id(opts));
return chr;
}
QTAILQ_REMOVE(&chardevs, chr, next);
if (chr->chr_close)
chr->chr_close(chr);
- qemu_free(chr->filename);
- qemu_free(chr->label);
- qemu_free(chr);
+ g_free(chr->filename);
+ g_free(chr->label);
+ g_free(chr);
}
static void qemu_chr_qlist_iter(QObject *obj, void *opaque)