source: roaraudio/libroar/vio.c @ 4718:eff5b46526d0

Last change on this file since 4718:eff5b46526d0 was 4718:eff5b46526d0, checked in by phi, 13 years ago

added VIO based direct access to SYSIO [gs]etsockopt()

File size: 17.8 KB
Line 
1//vio.c:
2
3/*
4 *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008-2011
5 *
6 *  This file is part of libroar a part of RoarAudio,
7 *  a cross-platform sound system for both, home and professional use.
8 *  See README for details.
9 *
10 *  This file is free software; you can redistribute it and/or modify
11 *  it under the terms of the GNU General Public License version 3
12 *  as published by the Free Software Foundation.
13 *
14 *  libroar is distributed in the hope that it will be useful,
15 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 *  GNU General Public License for more details.
18 *
19 *  You should have received a copy of the GNU General Public License
20 *  along with this software; see the file COPYING.  If not, write to
21 *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
22 *  Boston, MA 02110-1301, USA.
23 *
24 *  NOTE for everyone want's to change something and send patches:
25 *  read README and HACKING! There a addition information on
26 *  the license of this document you need to read before you send
27 *  any patches.
28 *
29 *  NOTE for uses of non-GPL (LGPL,...) software using libesd, libartsc
30 *  or libpulse*:
31 *  The libs libroaresd, libroararts and libroarpulse link this lib
32 *  and are therefore GPL. Because of this it may be illigal to use
33 *  them with any software that uses libesd, libartsc or libpulse*.
34 */
35
36#include "libroar.h"
37
38#ifdef ROAR_HAVE_H_SYS_IOCTL
39#include <sys/ioctl.h>
40#endif
41
42#ifdef ROAR_HAVE_IO_POSIX
43#define _CAN_OPERATE
44#endif
45
46int roar_vio_init_calls (struct roar_vio_calls * calls) {
47#ifdef _CAN_OPERATE
48 if ( calls == NULL )
49  return -1;
50
51 memset((void*)calls, 0, sizeof(struct roar_vio_calls));
52
53/*
54 calls->read  = (ssize_t (*)(int fd, void *buf, size_t count,      void * inst))read;
55 calls->write = (ssize_t (*)(int fd, void *buf, size_t count,      void * inst))write;
56 calls->lseek = (off_t   (*)(int fildes, off_t offset, int whence, void * inst))lseek;
57*/
58
59 calls->read     = roar_vio_basic_read;
60 calls->write    = roar_vio_basic_write;
61 calls->lseek    = roar_vio_basic_lseek;
62 calls->nonblock = roar_vio_basic_nonblock;
63 calls->sync     = roar_vio_basic_sync;
64 calls->ctl      = roar_vio_basic_ctl;
65 calls->close    = roar_vio_basic_close;
66
67 return 0;
68#else
69 return -1;
70#endif
71}
72
73int roar_vio_set_inst (struct roar_vio_calls * vio, void * inst) {
74 if ( vio == NULL )
75  return -1;
76
77 vio->inst = inst;
78
79 return 0;
80}
81
82int roar_vio_set_fh   (struct roar_vio_calls * vio, int fh) {
83 return roar_vio_set_inst(vio, (void*)(ROAR_INSTINT)(fh + 1));
84}
85
86int roar_vio_get_fh   (struct roar_vio_calls * vio) {
87 if ( vio == NULL )
88  return -1;
89
90 return ((int)(ROAR_INSTINT)vio->inst) - 1;
91}
92
93
94ssize_t roar_vio_read (struct roar_vio_calls * vio, void *buf, size_t count) {
95 ROAR_DBG("roar_vio_read(vio=%p, buf=%p, count=%u) = ?", vio, buf, (unsigned int)count);
96
97 if ( vio == NULL )
98  return -1;
99
100 if ( vio->read == NULL )
101  return -1;
102
103 return vio->read(vio, buf, count);
104}
105
106ssize_t roar_vio_write(struct roar_vio_calls * vio, void *buf, size_t count) {
107 ROAR_DBG("roar_vio_write(vio=%p, buf=%p, count=%u) = ?", vio, buf, (unsigned int)count);
108
109 if ( vio == NULL )
110  return -1;
111
112 if ( vio->write == NULL )
113  return -1;
114
115 return vio->write(vio, buf, count);
116}
117
118off_t   roar_vio_lseek(struct roar_vio_calls * vio, off_t offset, int whence) {
119 ROAR_DBG("roar_vio_lseek(vio=%p, offset=%u, whence=%i) = ?", vio, (unsigned int)offset, whence);
120
121 if ( vio == NULL )
122  return -1;
123
124 if ( vio->lseek == NULL )
125  return -1;
126
127 return vio->lseek(vio, offset, whence);
128}
129
130int     roar_vio_nonblock(struct roar_vio_calls * vio, int state) {
131 ROAR_DBG("roar_vio_nonblock(vio=%p, state=%i) = ?", vio, state);
132
133 if ( vio == NULL )
134  return -1;
135
136 if ( vio->nonblock == NULL )
137  return -1;
138
139 return vio->nonblock(vio, state);
140}
141
142int     roar_vio_sync    (struct roar_vio_calls * vio) {
143 ROAR_DBG("roar_vio_sync(vio=%p) = ?", vio);
144
145 if ( vio == NULL )
146  return -1;
147
148 if ( vio->sync == NULL )
149  return -1;
150
151 return vio->sync(vio);
152}
153
154int     roar_vio_ctl     (struct roar_vio_calls * vio, int cmd, void * data) {
155 ROAR_DBG("roar_vio_ctl(vio=%p, cmd=%i, data=%p) = ?", vio, cmd, data);
156
157 if ( vio == NULL )
158  return -1;
159
160 ROAR_DBG("roar_vio_ctl(vio=%p, cmd=0x%.8x, data=%p): vio->ctl=%p", vio, cmd, data, vio->ctl);
161
162 if ( vio->ctl == NULL )
163  return -1;
164
165 return vio->ctl(vio, cmd, data);
166}
167
168int     roar_vio_close    (struct roar_vio_calls * vio) {
169 ROAR_DBG("roar_vio_close(vio=%p) = ?", vio);
170
171 if ( vio == NULL )
172  return -1;
173
174 if ( vio->close == NULL )
175  return -1;
176
177 return vio->close(vio);
178}
179
180// specal commands:
181int     roar_vio_accept  (struct roar_vio_calls * calls, struct roar_vio_calls * dst) {
182 if (dst == NULL || calls == NULL)
183  return -1;
184
185 return roar_vio_ctl(dst, ROAR_VIO_CTL_ACCEPT, calls);
186}
187
188int     roar_vio_shutdown(struct roar_vio_calls * vio,   int how) {
189 return roar_vio_ctl(vio, ROAR_VIO_CTL_SHUTDOWN, &how);
190}
191
192// converters:
193int     roar_vio_open_file     (struct roar_vio_calls * calls, char * filename, int flags, mode_t mode) {
194#ifdef _CAN_OPERATE
195 int fh;
196
197 if ( calls == NULL || filename == NULL )
198  return -1;
199
200#ifdef ROAR_TARGET_WIN32
201 flags |= O_BINARY;
202#endif
203
204 if ( (fh = open(filename, flags, mode)) == -1 )
205  return -1;
206
207 if ( roar_vio_open_fh(calls, fh) == -1 ) {
208  close(fh);
209  return -1;
210 }
211
212 return 0;
213#else
214 return -1;
215#endif
216}
217
218int     roar_vio_open_fh       (struct roar_vio_calls * calls, int fh) {
219 if ( calls == NULL )
220  return -1;
221
222 if ( roar_vio_init_calls(calls) == -1 )
223  return -1;
224
225 return roar_vio_set_fh(calls, fh);
226}
227
228int     roar_vio_open_fh_socket(struct roar_vio_calls * calls, int fh) {
229 if ( calls == NULL )
230  return -1;
231
232 if ( roar_vio_open_fh(calls, fh) == -1 )
233  return -1;
234
235#ifdef ROAR_TARGET_WIN32
236 calls->read     = roar_vio_winsock_read;
237 calls->write    = roar_vio_winsock_write;
238 calls->nonblock = roar_vio_winsock_nonblock;
239 calls->sync     = roar_vio_winsock_sync;
240 calls->ctl      = roar_vio_winsock_ctl;
241 calls->close    = roar_vio_winsock_close;
242#else
243 calls->sync     = roar_vio_null_sync;
244#endif
245
246 return 0;
247}
248
249int     roar_vio_open_socket   (struct roar_vio_calls * calls, char * host, int port) {
250 int fh;
251
252 if ( calls == NULL )
253  return -1;
254
255 if ( (fh = roar_socket_connect(host, port)) == -1 )
256  return -1;
257
258 return roar_vio_open_fh_socket(calls, fh);
259}
260
261int     roar_vio_open_socket_listen(struct roar_vio_calls * calls, int type, char * host, int port) {
262 int fh;
263
264 if ( calls == NULL )
265  return -1;
266
267 if ( (fh = roar_socket_listen(type, host, port)) == -1 )
268  return -1;
269
270 return roar_vio_open_fh_socket(calls, fh);
271}
272
273int     roar_vio_simple_stream (struct roar_vio_calls * calls, int rate, int channels, int bits, int codec,
274                                                               char * server, int dir, char * name) {
275 int fh;
276
277 if ( calls == NULL )
278  return -1;
279
280 roar_libroar_nowarn();
281 if ( (fh = roar_simple_stream(rate, channels, bits, codec, server, dir, name)) == -1 ) {
282  roar_libroar_warn();
283  return -1;
284 }
285 roar_libroar_warn();
286
287 return roar_vio_open_fh_socket(calls, fh);
288}
289
290int     roar_vio_simple_new_stream_obj (struct roar_vio_calls * calls,
291                                        struct roar_connection * con,
292                                        struct roar_stream * s,
293                                        int rate, int channels, int bits, int codec, int dir) {
294 struct roar_stream stream;
295 int fh;
296
297 ROAR_DBG("roar_vio_simple_new_stream_obj(*) = ?");
298
299 if ( calls == NULL )
300  return -1;
301
302 if ( s == NULL )
303  s = &stream;
304
305 roar_libroar_nowarn();
306 if ( (fh = roar_simple_new_stream_obj(con, s, rate, channels, bits, codec, dir)) == -1 ) {
307  roar_libroar_warn();
308  ROAR_DBG("roar_vio_simple_new_stream_obj(*) = -1");
309  return -1;
310 }
311 roar_libroar_warn();
312
313 ROAR_DBG("roar_vio_simple_new_stream_obj(*): fh=%i", fh);
314
315 return roar_vio_open_fh_socket(calls, fh);
316}
317
318// VIOs:
319
320// basic
321ssize_t roar_vio_basic_read (struct roar_vio_calls * vio, void *buf, size_t count) {
322#ifdef _CAN_OPERATE
323 return read(roar_vio_get_fh(vio), buf, count);
324#else
325 return -1;
326#endif
327}
328
329ssize_t roar_vio_basic_write(struct roar_vio_calls * vio, void *buf, size_t count) {
330#ifdef _CAN_OPERATE
331 return write(roar_vio_get_fh(vio), buf, count);
332#else
333 return -1;
334#endif
335}
336
337off_t   roar_vio_basic_lseek(struct roar_vio_calls * vio, off_t offset, int whence) {
338#ifdef _CAN_OPERATE
339 return lseek(roar_vio_get_fh(vio), offset, whence);
340#else
341 return -1;
342#endif
343}
344
345int     roar_vio_basic_nonblock(struct roar_vio_calls * vio, int state) {
346 if ( roar_socket_nonblock(roar_vio_get_fh(vio), state) == -1 )
347  return -1;
348
349 if ( state == ROAR_SOCKET_NONBLOCK )
350  return 0;
351
352 roar_vio_sync(vio);
353
354 return 0;
355}
356
357int     roar_vio_basic_sync    (struct roar_vio_calls * vio) {
358#ifdef ROAR_FDATASYNC
359 return ROAR_FDATASYNC(roar_vio_get_fh(vio));
360#else
361 return 0;
362#endif
363}
364
365int     roar_vio_basic_ctl     (struct roar_vio_calls * vio, int cmd, void * data) {
366#ifdef ROAR_HAVE_H_SYS_IOCTL
367 struct roar_vio_sysio_ioctl * sysioctl;
368#endif
369#if defined(ROAR_HAVE_GETSOCKOPT) || defined(ROAR_HAVE_SETSOCKOPT)
370 struct roar_vio_sysio_sockopt  * syssockopt;
371#endif
372 int tmp;
373 int s_r = 0, s_w = 0;
374#if defined(ROAR_HAVE_GETSOCKNAME) || defined(ROAR_HAVE_GETPEERNAME)
375 union {
376  struct sockaddr     sa;
377#if defined(ROAR_HAVE_IPV4) || defined(ROAR_HAVE_IPV6)
378  struct sockaddr_in  in;
379#endif
380#ifdef ROAR_HAVE_UNIX
381  struct sockaddr_un  un;
382#endif
383#ifdef ROAR_HAVE_LIBDNET
384  struct sockaddr_dn  dn;
385#endif
386#ifdef ROAR_HAVE_IPV6
387  struct sockaddr_in6 in6;
388#endif
389#ifdef ROAR_HAVE_IPX
390  struct sockaddr_ipx ipx;
391#endif
392 } sockaddr;
393 socklen_t socklen;
394 struct roar_sockname * rsockname;
395#endif
396
397 if ( vio == NULL || cmd == -1 )
398  return -1;
399
400 ROAR_DBG("roar_vio_basic_ctl(vio=%p, cmd=0x%.8x, data=%p) = ?", vio, cmd, data);
401
402 switch (cmd) {
403  case ROAR_VIO_CTL_GET_NAME:
404    if ( data == NULL )
405     return -1;
406
407    *(char**)data = "basic";
408    return 0;
409   break;
410  case ROAR_VIO_CTL_GET_FH:
411  case ROAR_VIO_CTL_GET_READ_FH:
412  case ROAR_VIO_CTL_GET_WRITE_FH:
413  case ROAR_VIO_CTL_GET_SELECT_FH:
414  case ROAR_VIO_CTL_GET_SELECT_READ_FH:
415  case ROAR_VIO_CTL_GET_SELECT_WRITE_FH:
416    ROAR_DBG("roar_vio_basic_ctl(vio=%p, cmd=ROAR_VIO_CTL_GET_*FH(0x%.8x), data=%p) = 0 // fh=%i", vio, cmd, data, roar_vio_get_fh(vio));
417    *(int*)data = roar_vio_get_fh(vio);
418    return 0;
419   break;
420  case ROAR_VIO_CTL_SET_NOSYNC:
421    vio->sync = NULL;
422    return 0;
423   break;
424  case ROAR_VIO_CTL_ACCEPT:
425    tmp = ROAR_ACCEPT(roar_vio_get_fh(vio), NULL, 0);
426    if ( tmp == -1 )
427     return -1;
428
429    // most proably a socket.
430    if ( roar_vio_open_fh_socket(data, tmp) == -1 ) {
431#ifdef ROAR_TARGET_WIN32
432     closesocket(tmp);
433#else
434     close(tmp);
435#endif
436     return -1;
437    }
438
439    return 0;
440   break;
441  case ROAR_VIO_CTL_SHUTDOWN:
442    tmp = *(int*)data;
443
444    if ( tmp & ROAR_VIO_SHUTDOWN_READ ) {
445     s_r = 1;
446     tmp -= ROAR_VIO_SHUTDOWN_READ;
447    }
448
449    if ( tmp & ROAR_VIO_SHUTDOWN_WRITE ) {
450     s_w = 1;
451     tmp -= ROAR_VIO_SHUTDOWN_WRITE;
452    }
453
454    if ( tmp != 0 ) /* we currently only support R and W shutdowns */
455     return -1;
456
457    if ( s_r && s_w ) {
458     tmp = SHUT_RDWR;
459    } else if ( s_r ) {
460     tmp = SHUT_RD;
461    } else if ( s_w ) {
462     tmp = SHUT_WR;
463    } else {
464     return 0; // nothing to do.
465    }
466
467    return ROAR_SHUTDOWN(roar_vio_get_fh(vio), tmp);
468   break;
469#if defined(ROAR_HAVE_GETSOCKNAME) || defined(ROAR_HAVE_GETPEERNAME)
470  case ROAR_VIO_CTL_GET_SOCKNAME:
471  case ROAR_VIO_CTL_GET_PEERNAME:
472    if ( data == NULL )
473     return -1;
474
475    rsockname = data;
476
477    socklen = sizeof(sockaddr);
478
479    if ( cmd == ROAR_VIO_CTL_GET_SOCKNAME ) {
480#ifdef ROAR_HAVE_GETSOCKNAME
481     tmp = getsockname(roar_vio_get_fh(vio), &(sockaddr.sa), &socklen);
482#else
483     return -1;
484#endif
485    } else if ( cmd == ROAR_VIO_CTL_GET_PEERNAME ) {
486#ifdef ROAR_HAVE_GETPEERNAME
487     tmp = getpeername(roar_vio_get_fh(vio), &(sockaddr.sa), &socklen);
488#else
489     return -1;
490#endif
491    } else {
492     return -1;
493    }
494
495    if ( tmp == -1 )
496     return -1;
497
498    memset(rsockname, 0, sizeof(struct roar_sockname));
499
500    switch (sockaddr.sa.sa_family) {
501#ifdef AF_UNIX
502     case AF_UNIX:
503       rsockname->type = ROAR_SOCKET_TYPE_UNIX;
504       if ( sockaddr.un.sun_path[0] == 0 ) {
505        rsockname->addr = roar_mm_malloc(sizeof(sockaddr.un.sun_path));
506        if ( rsockname->addr == NULL )
507         return -1;
508        memcpy(rsockname->addr, sockaddr.un.sun_path, sizeof(sockaddr.un.sun_path));
509       } else {
510        rsockname->addr = roar_mm_strdup(sockaddr.un.sun_path);
511       }
512      break;
513#endif
514#ifdef AF_DECnet
515     case AF_DECnet:
516       rsockname->type = ROAR_SOCKET_TYPE_DECNET;
517
518       if ( sockaddr.dn.sdn_add.a_len != 2 )
519        return -1;
520
521       rsockname->addr = roar_mm_malloc(28);
522       if ( rsockname->addr == NULL )
523        return -1;
524
525       snprintf(rsockname->addr, 28, "%i.%i::",
526                 sockaddr.dn.sdn_add.a_addr[1] >> 2,
527                 sockaddr.dn.sdn_add.a_addr[0] + ((sockaddr.dn.sdn_add.a_addr[1] & 0x03) << 8));
528
529       rsockname->port = sockaddr.dn.sdn_objnum;
530       if ( sockaddr.dn.sdn_objnum == 0 ) {
531        tmp = strlen(rsockname->addr);
532        memcpy(rsockname->addr + tmp, sockaddr.dn.sdn_objname, sockaddr.dn.sdn_objnamel);
533        rsockname->addr[tmp + sockaddr.dn.sdn_objnamel] = 0;
534       }
535      break;
536#endif
537#ifdef AF_INET
538     case AF_INET:
539       rsockname->type = ROAR_SOCKET_TYPE_INET;
540       rsockname->port = ntohs(sockaddr.in.sin_port);
541       rsockname->addr = roar_mm_strdup(inet_ntoa(sockaddr.in.sin_addr));
542      break;
543#endif
544#ifdef AF_INET6
545     case AF_INET6:
546       rsockname->type = ROAR_SOCKET_TYPE_INET6;
547       rsockname->port = ntohs(sockaddr.in6.sin6_port);
548      break;
549#endif
550     default:
551       return -1;
552    }
553    return 0;
554#endif
555   break;
556#ifdef ROAR_HAVE_H_SYS_IOCTL
557  case ROAR_VIO_CTL_SYSIO_IOCTL:
558    sysioctl = data;
559    return ioctl(roar_vio_get_fh(vio), sysioctl->cmd, sysioctl->argp);
560   break;
561#endif
562#ifdef ROAR_HAVE_GETSOCKOPT
563  case ROAR_VIO_CTL_GET_SYSIO_SOCKOPT:
564    syssockopt = data;
565    return getsockopt(roar_vio_get_fh(vio), syssockopt->level, syssockopt->optname, syssockopt->optval, &(syssockopt->optlen));
566   break;
567#endif
568#ifdef ROAR_HAVE_SETSOCKOPT
569  case ROAR_VIO_CTL_SET_SYSIO_SOCKOPT:
570    syssockopt = data;
571    return setsockopt(roar_vio_get_fh(vio), syssockopt->level, syssockopt->optname, syssockopt->optval, syssockopt->optlen);
572   break;
573#endif
574 }
575
576 return -1;
577}
578
579int     roar_vio_basic_close    (struct roar_vio_calls * vio) {
580#ifdef _CAN_OPERATE
581 if ( roar_vio_get_fh(vio) != -1 )
582  return close(roar_vio_get_fh(vio));
583
584 return 0;
585#else
586 return -1;
587#endif
588}
589
590// null
591ssize_t roar_vio_null_rw    (struct roar_vio_calls * vio, void *buf, size_t count) {
592 if ( vio == NULL || buf == NULL )
593  return -1;
594
595 return 0;
596}
597
598int     roar_vio_null_sync    (struct roar_vio_calls * vio) {
599 return 0;
600}
601
602// pass
603int     roar_vio_open_pass    (struct roar_vio_calls * calls, struct roar_vio_calls * dst) {
604 if ( calls == NULL )
605  return -1;
606
607 memset((void*)calls, 0, sizeof(struct roar_vio_calls));
608
609 calls->read     = roar_vio_pass_read;
610 calls->write    = roar_vio_pass_write;
611 calls->lseek    = roar_vio_pass_lseek;
612 calls->nonblock = roar_vio_pass_nonblock;
613 calls->sync     = roar_vio_pass_sync;
614 calls->ctl      = roar_vio_pass_ctl;
615 calls->close    = roar_vio_pass_close;
616
617 calls->inst     = dst;
618
619 return 0;
620}
621
622ssize_t roar_vio_pass_read (struct roar_vio_calls * vio, void *buf, size_t count) {
623 return roar_vio_read((struct roar_vio_calls *) vio->inst, buf, count);
624}
625
626ssize_t roar_vio_pass_write(struct roar_vio_calls * vio, void *buf, size_t count) {
627 return roar_vio_write((struct roar_vio_calls *) vio->inst, buf, count);
628}
629
630off_t   roar_vio_pass_lseek(struct roar_vio_calls * vio, off_t offset, int whence) {
631 return roar_vio_lseek((struct roar_vio_calls *) vio->inst, offset, whence);
632}
633
634int     roar_vio_pass_nonblock(struct roar_vio_calls * vio, int state) {
635 return roar_vio_nonblock((struct roar_vio_calls *) vio->inst, state);
636}
637
638int     roar_vio_pass_sync    (struct roar_vio_calls * vio) {
639 return roar_vio_sync((struct roar_vio_calls *) vio->inst);
640}
641
642int     roar_vio_pass_ctl     (struct roar_vio_calls * vio, int cmd, void * data) {
643 if (vio == NULL || cmd == -1)
644  return -1;
645
646 ROAR_DBG("roar_vio_pass_ctl(vio=%p, cmd=0x%.8x, data=%p) = ?", vio, cmd, data);
647
648 switch (cmd) {
649  case ROAR_VIO_CTL_GET_NAME:
650    if ( data == NULL )
651     return -1;
652
653    *(char**)data = "pass";
654    return 0;
655   break;
656  case ROAR_VIO_CTL_GET_NEXT:
657    *(struct roar_vio_calls **)data = vio->inst;
658    return 0;
659   break;
660  case ROAR_VIO_CTL_SET_NEXT:
661    vio->inst = *(struct roar_vio_calls **)data;
662    return 0;
663   break;
664 }
665
666 return roar_vio_ctl((struct roar_vio_calls *) vio->inst, cmd, data);
667}
668
669int     roar_vio_pass_close   (struct roar_vio_calls * vio) {
670 return roar_vio_close((struct roar_vio_calls *) vio->inst);
671}
672
673
674// re
675int     roar_vio_open_re (struct roar_vio_calls * calls, struct roar_vio_calls * dst) {
676 if ( roar_vio_open_pass(calls, dst) == -1 )
677  return -1;
678
679 calls->read  = roar_vio_re_read;
680 calls->write = roar_vio_re_write;
681 calls->lseek = roar_vio_re_lseek;
682
683 return 0;
684}
685ssize_t roar_vio_re_read (struct roar_vio_calls * vio, void *buf, size_t count) {
686  size_t len =  0;
687 ssize_t r   = -1;
688
689 if ( vio == NULL )
690  return -1;
691
692 if ( vio->inst == NULL )
693  return -1;
694
695 errno = 0;
696
697 while ( (r = roar_vio_read((struct roar_vio_calls *) vio->inst, buf, count)) > 0 ) {
698  len   += r;
699  buf   += r;
700  count -= r;
701  if ( count == 0 )
702   break;
703 }
704
705 if ( len == 0 && r == -1 )
706  return -1;
707
708 return len;
709}
710
711ssize_t roar_vio_re_write(struct roar_vio_calls * vio, void *buf, size_t count) {
712  size_t len =  0;
713 ssize_t r   = -1;
714
715 if ( vio == NULL )
716  return -1;
717
718 if ( vio->inst == NULL )
719  return -1;
720
721 errno = 0;
722
723 while ( (r = roar_vio_write((struct roar_vio_calls *) vio->inst, buf, count)) > 0 ) {
724  len   += r;
725  buf   += r;
726  count -= r;
727  if ( count == 0 )
728   break;
729 }
730
731 if ( len == 0 && r == -1 )
732  return -1;
733
734 return len;
735}
736
737// TODO: we should do a some more intelgent thing here.
738off_t   roar_vio_re_lseek(struct roar_vio_calls * vio, off_t offset, int whence) {
739 return roar_vio_lseek((struct roar_vio_calls *) vio->inst, offset, whence);
740}
741
742//ll
Note: See TracBrowser for help on using the repository browser.