more pa_boolization
[pulseaudio.git] / src / pulsecore / ioline.c
blob5fd2189b32969abc765c798396bd67a4fa7b476e
1 /* $Id$ */
3 /***
4 This file is part of PulseAudio.
6 Copyright 2004-2006 Lennart Poettering
8 PulseAudio is free software; you can redistribute it and/or modify
9 it under the terms of the GNU Lesser General Public License as published
10 by the Free Software Foundation; either version 2 of the License,
11 or (at your option) any later version.
13 PulseAudio is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with PulseAudio; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
21 USA.
22 ***/
24 #ifdef HAVE_CONFIG_H
25 #include <config.h>
26 #endif
28 #include <errno.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
33 #include <pulse/xmalloc.h>
35 #include <pulsecore/winsock.h>
36 #include <pulsecore/core-error.h>
37 #include <pulsecore/log.h>
38 #include <pulsecore/macro.h>
39 #include <pulsecore/refcnt.h>
41 #include "ioline.h"
43 #define BUFFER_LIMIT (64*1024)
44 #define READ_SIZE (1024)
46 struct pa_ioline {
47 PA_REFCNT_DECLARE;
49 pa_iochannel *io;
50 pa_defer_event *defer_event;
51 pa_mainloop_api *mainloop;
52 int dead;
54 char *wbuf;
55 size_t wbuf_length, wbuf_index, wbuf_valid_length;
57 char *rbuf;
58 size_t rbuf_length, rbuf_index, rbuf_valid_length;
60 void (*callback)(pa_ioline*io, const char *s, void *userdata);
61 void *userdata;
63 int defer_close;
66 static void io_callback(pa_iochannel*io, void *userdata);
67 static void defer_callback(pa_mainloop_api*m, pa_defer_event*e, void *userdata);
69 pa_ioline* pa_ioline_new(pa_iochannel *io) {
70 pa_ioline *l;
71 pa_assert(io);
73 l = pa_xnew(pa_ioline, 1);
74 PA_REFCNT_INIT(l);
75 l->io = io;
76 l->dead = 0;
78 l->wbuf = NULL;
79 l->wbuf_length = l->wbuf_index = l->wbuf_valid_length = 0;
81 l->rbuf = NULL;
82 l->rbuf_length = l->rbuf_index = l->rbuf_valid_length = 0;
84 l->callback = NULL;
85 l->userdata = NULL;
87 l->mainloop = pa_iochannel_get_mainloop_api(io);
89 l->defer_event = l->mainloop->defer_new(l->mainloop, defer_callback, l);
90 l->mainloop->defer_enable(l->defer_event, 0);
92 l->defer_close = 0;
94 pa_iochannel_set_callback(io, io_callback, l);
96 return l;
99 static void ioline_free(pa_ioline *l) {
100 pa_assert(l);
102 if (l->io)
103 pa_iochannel_free(l->io);
105 if (l->defer_event)
106 l->mainloop->defer_free(l->defer_event);
108 pa_xfree(l->wbuf);
109 pa_xfree(l->rbuf);
110 pa_xfree(l);
113 void pa_ioline_unref(pa_ioline *l) {
114 pa_assert(l);
115 pa_assert(PA_REFCNT_VALUE(l) >= 1);
117 if (PA_REFCNT_DEC(l) <= 0)
118 ioline_free(l);
121 pa_ioline* pa_ioline_ref(pa_ioline *l) {
122 pa_assert(l);
123 pa_assert(PA_REFCNT_VALUE(l) >= 1);
125 PA_REFCNT_INC(l);
126 return l;
129 void pa_ioline_close(pa_ioline *l) {
130 pa_assert(l);
131 pa_assert(PA_REFCNT_VALUE(l) >= 1);
133 l->dead = 1;
135 if (l->io) {
136 pa_iochannel_free(l->io);
137 l->io = NULL;
140 if (l->defer_event) {
141 l->mainloop->defer_free(l->defer_event);
142 l->defer_event = NULL;
145 if (l->callback)
146 l->callback = NULL;
149 void pa_ioline_puts(pa_ioline *l, const char *c) {
150 size_t len;
152 pa_assert(l);
153 pa_assert(PA_REFCNT_VALUE(l) >= 1);
154 pa_assert(c);
156 if (l->dead)
157 return;
159 len = strlen(c);
160 if (len > BUFFER_LIMIT - l->wbuf_valid_length)
161 len = BUFFER_LIMIT - l->wbuf_valid_length;
163 if (len) {
164 pa_assert(l->wbuf_length >= l->wbuf_valid_length);
166 /* In case the allocated buffer is too small, enlarge it. */
167 if (l->wbuf_valid_length + len > l->wbuf_length) {
168 size_t n = l->wbuf_valid_length+len;
169 char *new = pa_xmalloc(n);
170 if (l->wbuf) {
171 memcpy(new, l->wbuf+l->wbuf_index, l->wbuf_valid_length);
172 pa_xfree(l->wbuf);
174 l->wbuf = new;
175 l->wbuf_length = n;
176 l->wbuf_index = 0;
177 } else if (l->wbuf_index + l->wbuf_valid_length + len > l->wbuf_length) {
179 /* In case the allocated buffer fits, but the current index is too far from the start, move it to the front. */
180 memmove(l->wbuf, l->wbuf+l->wbuf_index, l->wbuf_valid_length);
181 l->wbuf_index = 0;
184 pa_assert(l->wbuf_index + l->wbuf_valid_length + len <= l->wbuf_length);
186 /* Append the new string */
187 memcpy(l->wbuf + l->wbuf_index + l->wbuf_valid_length, c, len);
188 l->wbuf_valid_length += len;
190 l->mainloop->defer_enable(l->defer_event, 1);
194 void pa_ioline_set_callback(pa_ioline*l, void (*callback)(pa_ioline*io, const char *s, void *userdata), void *userdata) {
195 pa_assert(l);
196 pa_assert(PA_REFCNT_VALUE(l) >= 1);
198 l->callback = callback;
199 l->userdata = userdata;
202 static void failure(pa_ioline *l, int process_leftover) {
203 pa_assert(l);
204 pa_assert(PA_REFCNT_VALUE(l) >= 1);
205 pa_assert(!l->dead);
207 if (process_leftover && l->rbuf_valid_length > 0) {
208 /* Pass the last missing bit to the client */
210 if (l->callback) {
211 char *p = pa_xstrndup(l->rbuf+l->rbuf_index, l->rbuf_valid_length);
212 l->callback(l, p, l->userdata);
213 pa_xfree(p);
217 if (l->callback) {
218 l->callback(l, NULL, l->userdata);
219 l->callback = NULL;
222 pa_ioline_close(l);
225 static void scan_for_lines(pa_ioline *l, size_t skip) {
226 pa_assert(l);
227 pa_assert(PA_REFCNT_VALUE(l) >= 1);
228 pa_assert(skip < l->rbuf_valid_length);
230 while (!l->dead && l->rbuf_valid_length > skip) {
231 char *e, *p;
232 size_t m;
234 if (!(e = memchr(l->rbuf + l->rbuf_index + skip, '\n', l->rbuf_valid_length - skip)))
235 break;
237 *e = 0;
239 p = l->rbuf + l->rbuf_index;
240 m = strlen(p);
242 l->rbuf_index += m+1;
243 l->rbuf_valid_length -= m+1;
245 /* A shortcut for the next time */
246 if (l->rbuf_valid_length == 0)
247 l->rbuf_index = 0;
249 if (l->callback)
250 l->callback(l, p, l->userdata);
252 skip = 0;
255 /* If the buffer became too large and still no newline was found, drop it. */
256 if (l->rbuf_valid_length >= BUFFER_LIMIT)
257 l->rbuf_index = l->rbuf_valid_length = 0;
260 static int do_write(pa_ioline *l);
262 static int do_read(pa_ioline *l) {
263 pa_assert(l);
264 pa_assert(PA_REFCNT_VALUE(l) >= 1);
266 while (!l->dead && pa_iochannel_is_readable(l->io)) {
267 ssize_t r;
268 size_t len;
270 len = l->rbuf_length - l->rbuf_index - l->rbuf_valid_length;
272 /* Check if we have to enlarge the read buffer */
273 if (len < READ_SIZE) {
274 size_t n = l->rbuf_valid_length+READ_SIZE;
276 if (n >= BUFFER_LIMIT)
277 n = BUFFER_LIMIT;
279 if (l->rbuf_length >= n) {
280 /* The current buffer is large enough, let's just move the data to the front */
281 if (l->rbuf_valid_length)
282 memmove(l->rbuf, l->rbuf+l->rbuf_index, l->rbuf_valid_length);
283 } else {
284 /* Enlarge the buffer */
285 char *new = pa_xmalloc(n);
286 if (l->rbuf_valid_length)
287 memcpy(new, l->rbuf+l->rbuf_index, l->rbuf_valid_length);
288 pa_xfree(l->rbuf);
289 l->rbuf = new;
290 l->rbuf_length = n;
293 l->rbuf_index = 0;
296 len = l->rbuf_length - l->rbuf_index - l->rbuf_valid_length;
298 pa_assert(len >= READ_SIZE);
300 /* Read some data */
301 if ((r = pa_iochannel_read(l->io, l->rbuf+l->rbuf_index+l->rbuf_valid_length, len)) <= 0) {
302 if (r < 0 && errno != ECONNRESET) {
303 pa_log("read(): %s", pa_cstrerror(errno));
304 failure(l, 0);
305 } else
306 failure(l, 1);
308 return -1;
311 l->rbuf_valid_length += r;
313 /* Look if a line has been terminated in the newly read data */
314 scan_for_lines(l, l->rbuf_valid_length - r);
317 return 0;
320 /* Try to flush the buffer */
321 static int do_write(pa_ioline *l) {
322 ssize_t r;
324 pa_assert(l);
325 pa_assert(PA_REFCNT_VALUE(l) >= 1);
327 while (!l->dead && pa_iochannel_is_writable(l->io) && l->wbuf_valid_length) {
329 if ((r = pa_iochannel_write(l->io, l->wbuf+l->wbuf_index, l->wbuf_valid_length)) <= 0) {
331 if (r < 0 && errno != EPIPE)
332 pa_log("write(): %s", pa_cstrerror(errno));
334 failure(l, 0);
336 return -1;
339 l->wbuf_index += r;
340 l->wbuf_valid_length -= r;
342 /* A shortcut for the next time */
343 if (l->wbuf_valid_length == 0)
344 l->wbuf_index = 0;
347 return 0;
350 /* Try to flush read/write data */
351 static void do_work(pa_ioline *l) {
352 pa_assert(l);
353 pa_assert(PA_REFCNT_VALUE(l) >= 1);
355 pa_ioline_ref(l);
357 l->mainloop->defer_enable(l->defer_event, 0);
359 if (!l->dead)
360 do_read(l);
362 if (!l->dead)
363 do_write(l);
365 if (l->defer_close && !l->wbuf_valid_length)
366 failure(l, 1);
368 pa_ioline_unref(l);
371 static void io_callback(pa_iochannel*io, void *userdata) {
372 pa_ioline *l = userdata;
374 pa_assert(io);
375 pa_assert(l);
376 pa_assert(PA_REFCNT_VALUE(l) >= 1);
378 do_work(l);
381 static void defer_callback(pa_mainloop_api*m, pa_defer_event*e, void *userdata) {
382 pa_ioline *l = userdata;
384 pa_assert(l);
385 pa_assert(PA_REFCNT_VALUE(l) >= 1);
386 pa_assert(l->mainloop == m);
387 pa_assert(l->defer_event == e);
389 do_work(l);
392 void pa_ioline_defer_close(pa_ioline *l) {
393 pa_assert(l);
394 pa_assert(PA_REFCNT_VALUE(l) >= 1);
396 l->defer_close = 1;
398 if (!l->wbuf_valid_length)
399 l->mainloop->defer_enable(l->defer_event, 1);
402 void pa_ioline_printf(pa_ioline *l, const char *format, ...) {
403 char *t;
404 va_list ap;
406 pa_assert(l);
407 pa_assert(PA_REFCNT_VALUE(l) >= 1);
409 va_start(ap, format);
410 t = pa_vsprintf_malloc(format, ap);
411 va_end(ap);
413 pa_ioline_puts(l, t);
414 pa_xfree(t);