![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to channel-posix.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / qga|
Return to channel-posix.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / qga |
1.1 root 1: #include <glib.h>
2: #include <termios.h>
3: #include "qemu_socket.h"
4: #include "qga/channel.h"
5:
6: #ifdef CONFIG_SOLARIS
7: #include <stropts.h>
8: #endif
9:
10: #define GA_CHANNEL_BAUDRATE_DEFAULT B38400 /* for isa-serial channels */
11:
12: struct GAChannel {
13: GIOChannel *listen_channel;
14: GIOChannel *client_channel;
15: GAChannelMethod method;
16: GAChannelCallback event_cb;
17: gpointer user_data;
18: };
19:
20: static int ga_channel_client_add(GAChannel *c, int fd);
21:
22: static gboolean ga_channel_listen_accept(GIOChannel *channel,
23: GIOCondition condition, gpointer data)
24: {
25: GAChannel *c = data;
26: int ret, client_fd;
27: bool accepted = false;
28: struct sockaddr_un addr;
29: socklen_t addrlen = sizeof(addr);
30:
31: g_assert(channel != NULL);
32:
33: client_fd = qemu_accept(g_io_channel_unix_get_fd(channel),
34: (struct sockaddr *)&addr, &addrlen);
35: if (client_fd == -1) {
36: g_warning("error converting fd to gsocket: %s", strerror(errno));
37: goto out;
38: }
39: fcntl(client_fd, F_SETFL, O_NONBLOCK);
40: ret = ga_channel_client_add(c, client_fd);
41: if (ret) {
42: g_warning("error setting up connection");
43: goto out;
44: }
45: accepted = true;
46:
47: out:
48: /* only accept 1 connection at a time */
49: return !accepted;
50: }
51:
52: /* start polling for readable events on listen fd, new==true
53: * indicates we should use the existing s->listen_channel
54: */
55: static void ga_channel_listen_add(GAChannel *c, int listen_fd, bool create)
56: {
57: if (create) {
58: c->listen_channel = g_io_channel_unix_new(listen_fd);
59: }
60: g_io_add_watch(c->listen_channel, G_IO_IN, ga_channel_listen_accept, c);
61: }
62:
63: static void ga_channel_listen_close(GAChannel *c)
64: {
65: g_assert(c->method == GA_CHANNEL_UNIX_LISTEN);
66: g_assert(c->listen_channel);
67: g_io_channel_shutdown(c->listen_channel, true, NULL);
68: g_io_channel_unref(c->listen_channel);
69: c->listen_channel = NULL;
70: }
71:
72: /* cleanup state for closed connection/session, start accepting new
73: * connections if we're in listening mode
74: */
75: static void ga_channel_client_close(GAChannel *c)
76: {
77: g_assert(c->client_channel);
78: g_io_channel_shutdown(c->client_channel, true, NULL);
79: g_io_channel_unref(c->client_channel);
80: c->client_channel = NULL;
81: if (c->method == GA_CHANNEL_UNIX_LISTEN && c->listen_channel) {
82: ga_channel_listen_add(c, 0, false);
83: }
84: }
85:
86: static gboolean ga_channel_client_event(GIOChannel *channel,
87: GIOCondition condition, gpointer data)
88: {
89: GAChannel *c = data;
90: gboolean client_cont;
91:
92: g_assert(c);
93: if (c->event_cb) {
94: client_cont = c->event_cb(condition, c->user_data);
95: if (!client_cont) {
96: ga_channel_client_close(c);
97: return false;
98: }
99: }
100: return true;
101: }
102:
103: static int ga_channel_client_add(GAChannel *c, int fd)
104: {
105: GIOChannel *client_channel;
106: GError *err = NULL;
107:
108: g_assert(c && !c->client_channel);
109: client_channel = g_io_channel_unix_new(fd);
110: g_assert(client_channel);
111: g_io_channel_set_encoding(client_channel, NULL, &err);
112: if (err != NULL) {
113: g_warning("error setting channel encoding to binary");
114: g_error_free(err);
115: return -1;
116: }
117: g_io_add_watch(client_channel, G_IO_IN | G_IO_HUP,
118: ga_channel_client_event, c);
119: c->client_channel = client_channel;
120: return 0;
121: }
122:
123: static gboolean ga_channel_open(GAChannel *c, const gchar *path, GAChannelMethod method)
124: {
125: int ret;
126: c->method = method;
127:
128: switch (c->method) {
129: case GA_CHANNEL_VIRTIO_SERIAL: {
130: int fd = qemu_open(path, O_RDWR | O_NONBLOCK
131: #ifndef CONFIG_SOLARIS
132: | O_ASYNC
133: #endif
134: );
135: if (fd == -1) {
136: g_critical("error opening channel: %s", strerror(errno));
137: exit(EXIT_FAILURE);
138: }
139: #ifdef CONFIG_SOLARIS
140: ret = ioctl(fd, I_SETSIG, S_OUTPUT | S_INPUT | S_HIPRI);
141: if (ret == -1) {
142: g_critical("error setting event mask for channel: %s",
143: strerror(errno));
144: exit(EXIT_FAILURE);
145: }
146: #endif
147: ret = ga_channel_client_add(c, fd);
148: if (ret) {
149: g_critical("error adding channel to main loop");
150: return false;
151: }
152: break;
153: }
154: case GA_CHANNEL_ISA_SERIAL: {
155: struct termios tio;
156: int fd = qemu_open(path, O_RDWR | O_NOCTTY | O_NONBLOCK);
157: if (fd == -1) {
158: g_critical("error opening channel: %s", strerror(errno));
159: exit(EXIT_FAILURE);
160: }
161: tcgetattr(fd, &tio);
162: /* set up serial port for non-canonical, dumb byte streaming */
163: tio.c_iflag &= ~(IGNBRK | BRKINT | IGNPAR | PARMRK | INPCK | ISTRIP |
164: INLCR | IGNCR | ICRNL | IXON | IXOFF | IXANY |
165: IMAXBEL);
166: tio.c_oflag = 0;
167: tio.c_lflag = 0;
168: tio.c_cflag |= GA_CHANNEL_BAUDRATE_DEFAULT;
169: /* 1 available byte min or reads will block (we'll set non-blocking
170: * elsewhere, else we have to deal with read()=0 instead)
171: */
172: tio.c_cc[VMIN] = 1;
173: tio.c_cc[VTIME] = 0;
174: /* flush everything waiting for read/xmit, it's garbage at this point */
175: tcflush(fd, TCIFLUSH);
176: tcsetattr(fd, TCSANOW, &tio);
177: ret = ga_channel_client_add(c, fd);
178: if (ret) {
179: g_error("error adding channel to main loop");
180: }
181: break;
182: }
183: case GA_CHANNEL_UNIX_LISTEN: {
184: int fd = unix_listen(path, NULL, strlen(path));
185: if (fd == -1) {
186: g_critical("error opening path: %s", strerror(errno));
187: return false;
188: }
189: ga_channel_listen_add(c, fd, true);
190: break;
191: }
192: default:
193: g_critical("error binding/listening to specified socket");
194: return false;
195: }
196:
197: return true;
198: }
199:
200: GIOStatus ga_channel_write_all(GAChannel *c, const gchar *buf, gsize size)
201: {
202: GError *err = NULL;
203: gsize written = 0;
204: GIOStatus status = G_IO_STATUS_NORMAL;
205:
206: while (size) {
207: status = g_io_channel_write_chars(c->client_channel, buf, size,
208: &written, &err);
209: g_debug("sending data, count: %d", (int)size);
210: if (err != NULL) {
211: g_warning("error writing to channel: %s", err->message);
212: return G_IO_STATUS_ERROR;
213: }
214: if (status != G_IO_STATUS_NORMAL) {
215: break;
216: }
217: size -= written;
218: }
219:
220: if (status == G_IO_STATUS_NORMAL) {
221: status = g_io_channel_flush(c->client_channel, &err);
222: if (err != NULL) {
223: g_warning("error flushing channel: %s", err->message);
224: return G_IO_STATUS_ERROR;
225: }
226: }
227:
228: return status;
229: }
230:
231: GIOStatus ga_channel_read(GAChannel *c, gchar *buf, gsize size, gsize *count)
232: {
233: return g_io_channel_read_chars(c->client_channel, buf, size, count, NULL);
234: }
235:
236: GAChannel *ga_channel_new(GAChannelMethod method, const gchar *path,
237: GAChannelCallback cb, gpointer opaque)
238: {
239: GAChannel *c = g_malloc0(sizeof(GAChannel));
240: c->event_cb = cb;
241: c->user_data = opaque;
242:
243: if (!ga_channel_open(c, path, method)) {
244: g_critical("error opening channel");
245: ga_channel_free(c);
246: return NULL;
247: }
248:
249: return c;
250: }
251:
252: void ga_channel_free(GAChannel *c)
253: {
254: if (c->method == GA_CHANNEL_UNIX_LISTEN
255: && c->listen_channel) {
256: ga_channel_listen_close(c);
257: }
258: if (c->client_channel) {
259: ga_channel_client_close(c);
260: }
261: g_free(c);
262: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.