source: roaraudio/libroar/vio.c @ 4708:c9d40761088a

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

updated copyright statements

File size: 17.3 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 int tmp;
370 int s_r = 0, s_w = 0;
371#if defined(ROAR_HAVE_GETSOCKNAME) || defined(ROAR_HAVE_GETPEERNAME)
372 union {
373  struct sockaddr     sa;
374#if defined(ROAR_HAVE_IPV4) || defined(ROAR_HAVE_IPV6)
375  struct sockaddr_in  in;
376#endif
377#ifdef ROAR_HAVE_UNIX
378  struct sockaddr_un  un;
379#endif
380#ifdef ROAR_HAVE_LIBDNET
381  struct sockaddr_dn  dn;
382#endif
383#ifdef ROAR_HAVE_IPV6
384  struct sockaddr_in6 in6;
385#endif
386#ifdef ROAR_HAVE_IPX
387  struct sockaddr_ipx ipx;
388#endif
389 } sockaddr;
390 socklen_t socklen;
391 struct roar_sockname * rsockname;
392#endif
393
394 if ( vio == NULL || cmd == -1 )
395  return -1;
396
397 ROAR_DBG("roar_vio_basic_ctl(vio=%p, cmd=0x%.8x, data=%p) = ?", vio, cmd, data);
398
399 switch (cmd) {
400  case ROAR_VIO_CTL_GET_NAME:
401    if ( data == NULL )
402     return -1;
403
404    *(char**)data = "basic";
405    return 0;
406   break;
407  case ROAR_VIO_CTL_GET_FH:
408  case ROAR_VIO_CTL_GET_READ_FH:
409  case ROAR_VIO_CTL_GET_WRITE_FH:
410  case ROAR_VIO_CTL_GET_SELECT_FH:
411  case ROAR_VIO_CTL_GET_SELECT_READ_FH:
412  case ROAR_VIO_CTL_GET_SELECT_WRITE_FH:
413    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));
414    *(int*)data = roar_vio_get_fh(vio);
415    return 0;
416   break;
417  case ROAR_VIO_CTL_SET_NOSYNC:
418    vio->sync = NULL;
419    return 0;
420   break;
421  case ROAR_VIO_CTL_ACCEPT:
422    tmp = ROAR_ACCEPT(roar_vio_get_fh(vio), NULL, 0);
423    if ( tmp == -1 )
424     return -1;
425
426    // most proably a socket.
427    if ( roar_vio_open_fh_socket(data, tmp) == -1 ) {
428#ifdef ROAR_TARGET_WIN32
429     closesocket(tmp);
430#else
431     close(tmp);
432#endif
433     return -1;
434    }
435
436    return 0;
437   break;
438  case ROAR_VIO_CTL_SHUTDOWN:
439    tmp = *(int*)data;
440
441    if ( tmp & ROAR_VIO_SHUTDOWN_READ ) {
442     s_r = 1;
443     tmp -= ROAR_VIO_SHUTDOWN_READ;
444    }
445
446    if ( tmp & ROAR_VIO_SHUTDOWN_WRITE ) {
447     s_w = 1;
448     tmp -= ROAR_VIO_SHUTDOWN_WRITE;
449    }
450
451    if ( tmp != 0 ) /* we currently only support R and W shutdowns */
452     return -1;
453
454    if ( s_r && s_w ) {
455     tmp = SHUT_RDWR;
456    } else if ( s_r ) {
457     tmp = SHUT_RD;
458    } else if ( s_w ) {
459     tmp = SHUT_WR;
460    } else {
461     return 0; // nothing to do.
462    }
463
464    return ROAR_SHUTDOWN(roar_vio_get_fh(vio), tmp);
465   break;
466#if defined(ROAR_HAVE_GETSOCKNAME) || defined(ROAR_HAVE_GETPEERNAME)
467  case ROAR_VIO_CTL_GET_SOCKNAME:
468  case ROAR_VIO_CTL_GET_PEERNAME:
469    if ( data == NULL )
470     return -1;
471
472    rsockname = data;
473
474    socklen = sizeof(sockaddr);
475
476    if ( cmd == ROAR_VIO_CTL_GET_SOCKNAME ) {
477#ifdef ROAR_HAVE_GETSOCKNAME
478     tmp = getsockname(roar_vio_get_fh(vio), &(sockaddr.sa), &socklen);
479#else
480     return -1;
481#endif
482    } else if ( cmd == ROAR_VIO_CTL_GET_PEERNAME ) {
483#ifdef ROAR_HAVE_GETPEERNAME
484     tmp = getpeername(roar_vio_get_fh(vio), &(sockaddr.sa), &socklen);
485#else
486     return -1;
487#endif
488    } else {
489     return -1;
490    }
491
492    if ( tmp == -1 )
493     return -1;
494
495    memset(rsockname, 0, sizeof(struct roar_sockname));
496
497    switch (sockaddr.sa.sa_family) {
498#ifdef AF_UNIX
499     case AF_UNIX:
500       rsockname->type = ROAR_SOCKET_TYPE_UNIX;
501       if ( sockaddr.un.sun_path[0] == 0 ) {
502        rsockname->addr = roar_mm_malloc(sizeof(sockaddr.un.sun_path));
503        if ( rsockname->addr == NULL )
504         return -1;
505        memcpy(rsockname->addr, sockaddr.un.sun_path, sizeof(sockaddr.un.sun_path));
506       } else {
507        rsockname->addr = roar_mm_strdup(sockaddr.un.sun_path);
508       }
509      break;
510#endif
511#ifdef AF_DECnet
512     case AF_DECnet:
513       rsockname->type = ROAR_SOCKET_TYPE_DECNET;
514
515       if ( sockaddr.dn.sdn_add.a_len != 2 )
516        return -1;
517
518       rsockname->addr = roar_mm_malloc(28);
519       if ( rsockname->addr == NULL )
520        return -1;
521
522       snprintf(rsockname->addr, 28, "%i.%i::",
523                 sockaddr.dn.sdn_add.a_addr[1] >> 2,
524                 sockaddr.dn.sdn_add.a_addr[0] + ((sockaddr.dn.sdn_add.a_addr[1] & 0x03) << 8));
525
526       rsockname->port = sockaddr.dn.sdn_objnum;
527       if ( sockaddr.dn.sdn_objnum == 0 ) {
528        tmp = strlen(rsockname->addr);
529        memcpy(rsockname->addr + tmp, sockaddr.dn.sdn_objname, sockaddr.dn.sdn_objnamel);
530        rsockname->addr[tmp + sockaddr.dn.sdn_objnamel] = 0;
531       }
532      break;
533#endif
534#ifdef AF_INET
535     case AF_INET:
536       rsockname->type = ROAR_SOCKET_TYPE_INET;
537       rsockname->port = ntohs(sockaddr.in.sin_port);
538       rsockname->addr = roar_mm_strdup(inet_ntoa(sockaddr.in.sin_addr));
539      break;
540#endif
541#ifdef AF_INET6
542     case AF_INET6:
543       rsockname->type = ROAR_SOCKET_TYPE_INET6;
544       rsockname->port = ntohs(sockaddr.in6.sin6_port);
545      break;
546#endif
547     default:
548       return -1;
549    }
550    return 0;
551#endif
552   break;
553#ifdef ROAR_HAVE_H_SYS_IOCTL
554  case ROAR_VIO_CTL_SYSIO_IOCTL:
555    sysioctl = data;
556    return ioctl(roar_vio_get_fh(vio), sysioctl->cmd, sysioctl->argp);
557   break;
558#endif
559 }
560
561 return -1;
562}
563
564int     roar_vio_basic_close    (struct roar_vio_calls * vio) {
565#ifdef _CAN_OPERATE
566 if ( roar_vio_get_fh(vio) != -1 )
567  return close(roar_vio_get_fh(vio));
568
569 return 0;
570#else
571 return -1;
572#endif
573}
574
575// null
576ssize_t roar_vio_null_rw    (struct roar_vio_calls * vio, void *buf, size_t count) {
577 if ( vio == NULL || buf == NULL )
578  return -1;
579
580 return 0;
581}
582
583int     roar_vio_null_sync    (struct roar_vio_calls * vio) {
584 return 0;
585}
586
587// pass
588int     roar_vio_open_pass    (struct roar_vio_calls * calls, struct roar_vio_calls * dst) {
589 if ( calls == NULL )
590  return -1;
591
592 memset((void*)calls, 0, sizeof(struct roar_vio_calls));
593
594 calls->read     = roar_vio_pass_read;
595 calls->write    = roar_vio_pass_write;
596 calls->lseek    = roar_vio_pass_lseek;
597 calls->nonblock = roar_vio_pass_nonblock;
598 calls->sync     = roar_vio_pass_sync;
599 calls->ctl      = roar_vio_pass_ctl;
600 calls->close    = roar_vio_pass_close;
601
602 calls->inst     = dst;
603
604 return 0;
605}
606
607ssize_t roar_vio_pass_read (struct roar_vio_calls * vio, void *buf, size_t count) {
608 return roar_vio_read((struct roar_vio_calls *) vio->inst, buf, count);
609}
610
611ssize_t roar_vio_pass_write(struct roar_vio_calls * vio, void *buf, size_t count) {
612 return roar_vio_write((struct roar_vio_calls *) vio->inst, buf, count);
613}
614
615off_t   roar_vio_pass_lseek(struct roar_vio_calls * vio, off_t offset, int whence) {
616 return roar_vio_lseek((struct roar_vio_calls *) vio->inst, offset, whence);
617}
618
619int     roar_vio_pass_nonblock(struct roar_vio_calls * vio, int state) {
620 return roar_vio_nonblock((struct roar_vio_calls *) vio->inst, state);
621}
622
623int     roar_vio_pass_sync    (struct roar_vio_calls * vio) {
624 return roar_vio_sync((struct roar_vio_calls *) vio->inst);
625}
626
627int     roar_vio_pass_ctl     (struct roar_vio_calls * vio, int cmd, void * data) {
628 if (vio == NULL || cmd == -1)
629  return -1;
630
631 ROAR_DBG("roar_vio_pass_ctl(vio=%p, cmd=0x%.8x, data=%p) = ?", vio, cmd, data);
632
633 switch (cmd) {
634  case ROAR_VIO_CTL_GET_NAME:
635    if ( data == NULL )
636     return -1;
637
638    *(char**)data = "pass";
639    return 0;
640   break;
641  case ROAR_VIO_CTL_GET_NEXT:
642    *(struct roar_vio_calls **)data = vio->inst;
643    return 0;
644   break;
645  case ROAR_VIO_CTL_SET_NEXT:
646    vio->inst = *(struct roar_vio_calls **)data;
647    return 0;
648   break;
649 }
650
651 return roar_vio_ctl((struct roar_vio_calls *) vio->inst, cmd, data);
652}
653
654int     roar_vio_pass_close   (struct roar_vio_calls * vio) {
655 return roar_vio_close((struct roar_vio_calls *) vio->inst);
656}
657
658
659// re
660int     roar_vio_open_re (struct roar_vio_calls * calls, struct roar_vio_calls * dst) {
661 if ( roar_vio_open_pass(calls, dst) == -1 )
662  return -1;
663
664 calls->read  = roar_vio_re_read;
665 calls->write = roar_vio_re_write;
666 calls->lseek = roar_vio_re_lseek;
667
668 return 0;
669}
670ssize_t roar_vio_re_read (struct roar_vio_calls * vio, void *buf, size_t count) {
671  size_t len =  0;
672 ssize_t r   = -1;
673
674 if ( vio == NULL )
675  return -1;
676
677 if ( vio->inst == NULL )
678  return -1;
679
680 errno = 0;
681
682 while ( (r = roar_vio_read((struct roar_vio_calls *) vio->inst, buf, count)) > 0 ) {
683  len   += r;
684  buf   += r;
685  count -= r;
686  if ( count == 0 )
687   break;
688 }
689
690 if ( len == 0 && r == -1 )
691  return -1;
692
693 return len;
694}
695
696ssize_t roar_vio_re_write(struct roar_vio_calls * vio, void *buf, size_t count) {
697  size_t len =  0;
698 ssize_t r   = -1;
699
700 if ( vio == NULL )
701  return -1;
702
703 if ( vio->inst == NULL )
704  return -1;
705
706 errno = 0;
707
708 while ( (r = roar_vio_write((struct roar_vio_calls *) vio->inst, buf, count)) > 0 ) {
709  len   += r;
710  buf   += r;
711  count -= r;
712  if ( count == 0 )
713   break;
714 }
715
716 if ( len == 0 && r == -1 )
717  return -1;
718
719 return len;
720}
721
722// TODO: we should do a some more intelgent thing here.
723off_t   roar_vio_re_lseek(struct roar_vio_calls * vio, off_t offset, int whence) {
724 return roar_vio_lseek((struct roar_vio_calls *) vio->inst, offset, whence);
725}
726
727//ll
Note: See TracBrowser for help on using the repository browser.