Annotation of embedaddon/quagga/lib/stream.c, revision 1.1.1.1
1.1 misho 1: /*
2: * Packet interface
3: * Copyright (C) 1999 Kunihiro Ishiguro
4: *
5: * This file is part of GNU Zebra.
6: *
7: * GNU Zebra is free software; you can redistribute it and/or modify it
8: * under the terms of the GNU General Public License as published by the
9: * Free Software Foundation; either version 2, or (at your option) any
10: * later version.
11: *
12: * GNU Zebra is distributed in the hope that it will be useful, but
13: * WITHOUT ANY WARRANTY; without even the implied warranty of
14: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15: * General Public License for more details.
16: *
17: * You should have received a copy of the GNU General Public License
18: * along with GNU Zebra; see the file COPYING. If not, write to the Free
19: * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
20: * 02111-1307, USA.
21: */
22:
23: #include <stddef.h>
24: #include <zebra.h>
25:
26: #include "stream.h"
27: #include "memory.h"
28: #include "network.h"
29: #include "prefix.h"
30: #include "log.h"
31:
32: /* Tests whether a position is valid */
33: #define GETP_VALID(S,G) \
34: ((G) <= (S)->endp)
35: #define PUT_AT_VALID(S,G) GETP_VALID(S,G)
36: #define ENDP_VALID(S,E) \
37: ((E) <= (S)->size)
38:
39: /* asserting sanity checks. Following must be true before
40: * stream functions are called:
41: *
42: * Following must always be true of stream elements
43: * before and after calls to stream functions:
44: *
45: * getp <= endp <= size
46: *
47: * Note that after a stream function is called following may be true:
48: * if (getp == endp) then stream is no longer readable
49: * if (endp == size) then stream is no longer writeable
50: *
51: * It is valid to put to anywhere within the size of the stream, but only
52: * using stream_put..._at() functions.
53: */
54: #define STREAM_WARN_OFFSETS(S) \
55: zlog_warn ("&(struct stream): %p, size: %lu, endp: %lu, getp: %lu\n", \
56: (S), \
57: (unsigned long) (S)->size, \
58: (unsigned long) (S)->getp, \
59: (unsigned long) (S)->endp)\
60:
61: #define STREAM_VERIFY_SANE(S) \
62: do { \
63: if ( !(GETP_VALID(S, (S)->getp)) && ENDP_VALID(S, (S)->endp) ) \
64: STREAM_WARN_OFFSETS(S); \
65: assert ( GETP_VALID(S, (S)->getp) ); \
66: assert ( ENDP_VALID(S, (S)->endp) ); \
67: } while (0)
68:
69: #define STREAM_BOUND_WARN(S, WHAT) \
70: do { \
71: zlog_warn ("%s: Attempt to %s out of bounds", __func__, (WHAT)); \
72: STREAM_WARN_OFFSETS(S); \
73: assert (0); \
74: } while (0)
75:
76: /* XXX: Deprecated macro: do not use */
77: #define CHECK_SIZE(S, Z) \
78: do { \
79: if (((S)->endp + (Z)) > (S)->size) \
80: { \
81: zlog_warn ("CHECK_SIZE: truncating requested size %lu\n", \
82: (unsigned long) (Z)); \
83: STREAM_WARN_OFFSETS(S); \
84: (Z) = (S)->size - (S)->endp; \
85: } \
86: } while (0);
87:
88: /* Make stream buffer. */
89: struct stream *
90: stream_new (size_t size)
91: {
92: struct stream *s;
93:
94: assert (size > 0);
95:
96: if (size == 0)
97: {
98: zlog_warn ("stream_new(): called with 0 size!");
99: return NULL;
100: }
101:
102: s = XCALLOC (MTYPE_STREAM, sizeof (struct stream));
103:
104: if (s == NULL)
105: return s;
106:
107: if ( (s->data = XMALLOC (MTYPE_STREAM_DATA, size)) == NULL)
108: {
109: XFREE (MTYPE_STREAM, s);
110: return NULL;
111: }
112:
113: s->size = size;
114: return s;
115: }
116:
117: /* Free it now. */
118: void
119: stream_free (struct stream *s)
120: {
121: if (!s)
122: return;
123:
124: XFREE (MTYPE_STREAM_DATA, s->data);
125: XFREE (MTYPE_STREAM, s);
126: }
127:
128: struct stream *
129: stream_copy (struct stream *new, struct stream *src)
130: {
131: STREAM_VERIFY_SANE (src);
132:
133: assert (new != NULL);
134: assert (STREAM_SIZE(new) >= src->endp);
135:
136: new->endp = src->endp;
137: new->getp = src->getp;
138:
139: memcpy (new->data, src->data, src->endp);
140:
141: return new;
142: }
143:
144: struct stream *
145: stream_dup (struct stream *s)
146: {
147: struct stream *new;
148:
149: STREAM_VERIFY_SANE (s);
150:
151: if ( (new = stream_new (s->endp)) == NULL)
152: return NULL;
153:
154: return (stream_copy (new, s));
155: }
156:
157: size_t
158: stream_resize (struct stream *s, size_t newsize)
159: {
160: u_char *newdata;
161: STREAM_VERIFY_SANE (s);
162:
163: newdata = XREALLOC (MTYPE_STREAM_DATA, s->data, newsize);
164:
165: if (newdata == NULL)
166: return s->size;
167:
168: s->data = newdata;
169: s->size = newsize;
170:
171: if (s->endp > s->size)
172: s->endp = s->size;
173: if (s->getp > s->endp)
174: s->getp = s->endp;
175:
176: STREAM_VERIFY_SANE (s);
177:
178: return s->size;
179: }
180:
181: size_t
182: stream_get_getp (struct stream *s)
183: {
184: STREAM_VERIFY_SANE(s);
185: return s->getp;
186: }
187:
188: size_t
189: stream_get_endp (struct stream *s)
190: {
191: STREAM_VERIFY_SANE(s);
192: return s->endp;
193: }
194:
195: size_t
196: stream_get_size (struct stream *s)
197: {
198: STREAM_VERIFY_SANE(s);
199: return s->size;
200: }
201:
202: /* Stream structre' stream pointer related functions. */
203: void
204: stream_set_getp (struct stream *s, size_t pos)
205: {
206: STREAM_VERIFY_SANE(s);
207:
208: if (!GETP_VALID (s, pos))
209: {
210: STREAM_BOUND_WARN (s, "set getp");
211: pos = s->endp;
212: }
213:
214: s->getp = pos;
215: }
216:
217: /* Forward pointer. */
218: void
219: stream_forward_getp (struct stream *s, size_t size)
220: {
221: STREAM_VERIFY_SANE(s);
222:
223: if (!GETP_VALID (s, s->getp + size))
224: {
225: STREAM_BOUND_WARN (s, "seek getp");
226: return;
227: }
228:
229: s->getp += size;
230: }
231:
232: void
233: stream_forward_endp (struct stream *s, size_t size)
234: {
235: STREAM_VERIFY_SANE(s);
236:
237: if (!ENDP_VALID (s, s->endp + size))
238: {
239: STREAM_BOUND_WARN (s, "seek endp");
240: return;
241: }
242:
243: s->endp += size;
244: }
245:
246: /* Copy from stream to destination. */
247: void
248: stream_get (void *dst, struct stream *s, size_t size)
249: {
250: STREAM_VERIFY_SANE(s);
251:
252: if (STREAM_READABLE(s) < size)
253: {
254: STREAM_BOUND_WARN (s, "get");
255: return;
256: }
257:
258: memcpy (dst, s->data + s->getp, size);
259: s->getp += size;
260: }
261:
262: /* Get next character from the stream. */
263: u_char
264: stream_getc (struct stream *s)
265: {
266: u_char c;
267:
268: STREAM_VERIFY_SANE (s);
269:
270: if (STREAM_READABLE(s) < sizeof (u_char))
271: {
272: STREAM_BOUND_WARN (s, "get char");
273: return 0;
274: }
275: c = s->data[s->getp++];
276:
277: return c;
278: }
279:
280: /* Get next character from the stream. */
281: u_char
282: stream_getc_from (struct stream *s, size_t from)
283: {
284: u_char c;
285:
286: STREAM_VERIFY_SANE(s);
287:
288: if (!GETP_VALID (s, from + sizeof (u_char)))
289: {
290: STREAM_BOUND_WARN (s, "get char");
291: return 0;
292: }
293:
294: c = s->data[from];
295:
296: return c;
297: }
298:
299: /* Get next word from the stream. */
300: u_int16_t
301: stream_getw (struct stream *s)
302: {
303: u_int16_t w;
304:
305: STREAM_VERIFY_SANE (s);
306:
307: if (STREAM_READABLE (s) < sizeof (u_int16_t))
308: {
309: STREAM_BOUND_WARN (s, "get ");
310: return 0;
311: }
312:
313: w = s->data[s->getp++] << 8;
314: w |= s->data[s->getp++];
315:
316: return w;
317: }
318:
319: /* Get next word from the stream. */
320: u_int16_t
321: stream_getw_from (struct stream *s, size_t from)
322: {
323: u_int16_t w;
324:
325: STREAM_VERIFY_SANE(s);
326:
327: if (!GETP_VALID (s, from + sizeof (u_int16_t)))
328: {
329: STREAM_BOUND_WARN (s, "get ");
330: return 0;
331: }
332:
333: w = s->data[from++] << 8;
334: w |= s->data[from];
335:
336: return w;
337: }
338:
339: /* Get next long word from the stream. */
340: u_int32_t
341: stream_getl_from (struct stream *s, size_t from)
342: {
343: u_int32_t l;
344:
345: STREAM_VERIFY_SANE(s);
346:
347: if (!GETP_VALID (s, from + sizeof (u_int32_t)))
348: {
349: STREAM_BOUND_WARN (s, "get long");
350: return 0;
351: }
352:
353: l = s->data[from++] << 24;
354: l |= s->data[from++] << 16;
355: l |= s->data[from++] << 8;
356: l |= s->data[from];
357:
358: return l;
359: }
360:
361: u_int32_t
362: stream_getl (struct stream *s)
363: {
364: u_int32_t l;
365:
366: STREAM_VERIFY_SANE(s);
367:
368: if (STREAM_READABLE (s) < sizeof (u_int32_t))
369: {
370: STREAM_BOUND_WARN (s, "get long");
371: return 0;
372: }
373:
374: l = s->data[s->getp++] << 24;
375: l |= s->data[s->getp++] << 16;
376: l |= s->data[s->getp++] << 8;
377: l |= s->data[s->getp++];
378:
379: return l;
380: }
381:
382: /* Get next quad word from the stream. */
383: uint64_t
384: stream_getq_from (struct stream *s, size_t from)
385: {
386: uint64_t q;
387:
388: STREAM_VERIFY_SANE(s);
389:
390: if (!GETP_VALID (s, from + sizeof (uint64_t)))
391: {
392: STREAM_BOUND_WARN (s, "get quad");
393: return 0;
394: }
395:
396: q = ((uint64_t) s->data[from++]) << 56;
397: q |= ((uint64_t) s->data[from++]) << 48;
398: q |= ((uint64_t) s->data[from++]) << 40;
399: q |= ((uint64_t) s->data[from++]) << 32;
400: q |= ((uint64_t) s->data[from++]) << 24;
401: q |= ((uint64_t) s->data[from++]) << 16;
402: q |= ((uint64_t) s->data[from++]) << 8;
403: q |= ((uint64_t) s->data[from++]);
404:
405: return q;
406: }
407:
408: uint64_t
409: stream_getq (struct stream *s)
410: {
411: uint64_t q;
412:
413: STREAM_VERIFY_SANE(s);
414:
415: if (STREAM_READABLE (s) < sizeof (uint64_t))
416: {
417: STREAM_BOUND_WARN (s, "get quad");
418: return 0;
419: }
420:
421: q = ((uint64_t) s->data[s->getp++]) << 56;
422: q |= ((uint64_t) s->data[s->getp++]) << 48;
423: q |= ((uint64_t) s->data[s->getp++]) << 40;
424: q |= ((uint64_t) s->data[s->getp++]) << 32;
425: q |= ((uint64_t) s->data[s->getp++]) << 24;
426: q |= ((uint64_t) s->data[s->getp++]) << 16;
427: q |= ((uint64_t) s->data[s->getp++]) << 8;
428: q |= ((uint64_t) s->data[s->getp++]);
429:
430: return q;
431: }
432:
433: /* Get next long word from the stream. */
434: u_int32_t
435: stream_get_ipv4 (struct stream *s)
436: {
437: u_int32_t l;
438:
439: STREAM_VERIFY_SANE(s);
440:
441: if (STREAM_READABLE (s) < sizeof(u_int32_t))
442: {
443: STREAM_BOUND_WARN (s, "get ipv4");
444: return 0;
445: }
446:
447: memcpy (&l, s->data + s->getp, sizeof(u_int32_t));
448: s->getp += sizeof(u_int32_t);
449:
450: return l;
451: }
452:
453: /* Copy to source to stream.
454: *
455: * XXX: This uses CHECK_SIZE and hence has funny semantics -> Size will wrap
456: * around. This should be fixed once the stream updates are working.
457: *
458: * stream_write() is saner
459: */
460: void
461: stream_put (struct stream *s, const void *src, size_t size)
462: {
463:
464: /* XXX: CHECK_SIZE has strange semantics. It should be deprecated */
465: CHECK_SIZE(s, size);
466:
467: STREAM_VERIFY_SANE(s);
468:
469: if (STREAM_WRITEABLE (s) < size)
470: {
471: STREAM_BOUND_WARN (s, "put");
472: return;
473: }
474:
475: if (src)
476: memcpy (s->data + s->endp, src, size);
477: else
478: memset (s->data + s->endp, 0, size);
479:
480: s->endp += size;
481: }
482:
483: /* Put character to the stream. */
484: int
485: stream_putc (struct stream *s, u_char c)
486: {
487: STREAM_VERIFY_SANE(s);
488:
489: if (STREAM_WRITEABLE (s) < sizeof(u_char))
490: {
491: STREAM_BOUND_WARN (s, "put");
492: return 0;
493: }
494:
495: s->data[s->endp++] = c;
496: return sizeof (u_char);
497: }
498:
499: /* Put word to the stream. */
500: int
501: stream_putw (struct stream *s, u_int16_t w)
502: {
503: STREAM_VERIFY_SANE (s);
504:
505: if (STREAM_WRITEABLE (s) < sizeof (u_int16_t))
506: {
507: STREAM_BOUND_WARN (s, "put");
508: return 0;
509: }
510:
511: s->data[s->endp++] = (u_char)(w >> 8);
512: s->data[s->endp++] = (u_char) w;
513:
514: return 2;
515: }
516:
517: /* Put long word to the stream. */
518: int
519: stream_putl (struct stream *s, u_int32_t l)
520: {
521: STREAM_VERIFY_SANE (s);
522:
523: if (STREAM_WRITEABLE (s) < sizeof (u_int32_t))
524: {
525: STREAM_BOUND_WARN (s, "put");
526: return 0;
527: }
528:
529: s->data[s->endp++] = (u_char)(l >> 24);
530: s->data[s->endp++] = (u_char)(l >> 16);
531: s->data[s->endp++] = (u_char)(l >> 8);
532: s->data[s->endp++] = (u_char)l;
533:
534: return 4;
535: }
536:
537: /* Put quad word to the stream. */
538: int
539: stream_putq (struct stream *s, uint64_t q)
540: {
541: STREAM_VERIFY_SANE (s);
542:
543: if (STREAM_WRITEABLE (s) < sizeof (uint64_t))
544: {
545: STREAM_BOUND_WARN (s, "put quad");
546: return 0;
547: }
548:
549: s->data[s->endp++] = (u_char)(q >> 56);
550: s->data[s->endp++] = (u_char)(q >> 48);
551: s->data[s->endp++] = (u_char)(q >> 40);
552: s->data[s->endp++] = (u_char)(q >> 32);
553: s->data[s->endp++] = (u_char)(q >> 24);
554: s->data[s->endp++] = (u_char)(q >> 16);
555: s->data[s->endp++] = (u_char)(q >> 8);
556: s->data[s->endp++] = (u_char)q;
557:
558: return 8;
559: }
560:
561: int
562: stream_putc_at (struct stream *s, size_t putp, u_char c)
563: {
564: STREAM_VERIFY_SANE(s);
565:
566: if (!PUT_AT_VALID (s, putp + sizeof (u_char)))
567: {
568: STREAM_BOUND_WARN (s, "put");
569: return 0;
570: }
571:
572: s->data[putp] = c;
573:
574: return 1;
575: }
576:
577: int
578: stream_putw_at (struct stream *s, size_t putp, u_int16_t w)
579: {
580: STREAM_VERIFY_SANE(s);
581:
582: if (!PUT_AT_VALID (s, putp + sizeof (u_int16_t)))
583: {
584: STREAM_BOUND_WARN (s, "put");
585: return 0;
586: }
587:
588: s->data[putp] = (u_char)(w >> 8);
589: s->data[putp + 1] = (u_char) w;
590:
591: return 2;
592: }
593:
594: int
595: stream_putl_at (struct stream *s, size_t putp, u_int32_t l)
596: {
597: STREAM_VERIFY_SANE(s);
598:
599: if (!PUT_AT_VALID (s, putp + sizeof (u_int32_t)))
600: {
601: STREAM_BOUND_WARN (s, "put");
602: return 0;
603: }
604: s->data[putp] = (u_char)(l >> 24);
605: s->data[putp + 1] = (u_char)(l >> 16);
606: s->data[putp + 2] = (u_char)(l >> 8);
607: s->data[putp + 3] = (u_char)l;
608:
609: return 4;
610: }
611:
612: int
613: stream_putq_at (struct stream *s, size_t putp, uint64_t q)
614: {
615: STREAM_VERIFY_SANE(s);
616:
617: if (!PUT_AT_VALID (s, putp + sizeof (uint64_t)))
618: {
619: STREAM_BOUND_WARN (s, "put");
620: return 0;
621: }
622: s->data[putp] = (u_char)(q >> 56);
623: s->data[putp + 1] = (u_char)(q >> 48);
624: s->data[putp + 2] = (u_char)(q >> 40);
625: s->data[putp + 3] = (u_char)(q >> 32);
626: s->data[putp + 4] = (u_char)(q >> 24);
627: s->data[putp + 5] = (u_char)(q >> 16);
628: s->data[putp + 6] = (u_char)(q >> 8);
629: s->data[putp + 7] = (u_char)q;
630:
631: return 8;
632: }
633:
634: /* Put long word to the stream. */
635: int
636: stream_put_ipv4 (struct stream *s, u_int32_t l)
637: {
638: STREAM_VERIFY_SANE(s);
639:
640: if (STREAM_WRITEABLE (s) < sizeof (u_int32_t))
641: {
642: STREAM_BOUND_WARN (s, "put");
643: return 0;
644: }
645: memcpy (s->data + s->endp, &l, sizeof (u_int32_t));
646: s->endp += sizeof (u_int32_t);
647:
648: return sizeof (u_int32_t);
649: }
650:
651: /* Put long word to the stream. */
652: int
653: stream_put_in_addr (struct stream *s, struct in_addr *addr)
654: {
655: STREAM_VERIFY_SANE(s);
656:
657: if (STREAM_WRITEABLE (s) < sizeof (u_int32_t))
658: {
659: STREAM_BOUND_WARN (s, "put");
660: return 0;
661: }
662:
663: memcpy (s->data + s->endp, addr, sizeof (u_int32_t));
664: s->endp += sizeof (u_int32_t);
665:
666: return sizeof (u_int32_t);
667: }
668:
669: /* Put prefix by nlri type format. */
670: int
671: stream_put_prefix (struct stream *s, struct prefix *p)
672: {
673: size_t psize;
674:
675: STREAM_VERIFY_SANE(s);
676:
677: psize = PSIZE (p->prefixlen);
678:
679: if (STREAM_WRITEABLE (s) < psize)
680: {
681: STREAM_BOUND_WARN (s, "put");
682: return 0;
683: }
684:
685: stream_putc (s, p->prefixlen);
686: memcpy (s->data + s->endp, &p->u.prefix, psize);
687: s->endp += psize;
688:
689: return psize;
690: }
691:
692: /* Read size from fd. */
693: int
694: stream_read (struct stream *s, int fd, size_t size)
695: {
696: int nbytes;
697:
698: STREAM_VERIFY_SANE(s);
699:
700: if (STREAM_WRITEABLE (s) < size)
701: {
702: STREAM_BOUND_WARN (s, "put");
703: return 0;
704: }
705:
706: nbytes = readn (fd, s->data + s->endp, size);
707:
708: if (nbytes > 0)
709: s->endp += nbytes;
710:
711: return nbytes;
712: }
713:
714: /* Read size from fd. */
715: int
716: stream_read_unblock (struct stream *s, int fd, size_t size)
717: {
718: int nbytes;
719: int val;
720:
721: STREAM_VERIFY_SANE(s);
722:
723: if (STREAM_WRITEABLE (s) < size)
724: {
725: STREAM_BOUND_WARN (s, "put");
726: return 0;
727: }
728:
729: val = fcntl (fd, F_GETFL, 0);
730: fcntl (fd, F_SETFL, val|O_NONBLOCK);
731: nbytes = read (fd, s->data + s->endp, size);
732: fcntl (fd, F_SETFL, val);
733:
734: if (nbytes > 0)
735: s->endp += nbytes;
736:
737: return nbytes;
738: }
739:
740: ssize_t
741: stream_read_try(struct stream *s, int fd, size_t size)
742: {
743: ssize_t nbytes;
744:
745: STREAM_VERIFY_SANE(s);
746:
747: if (STREAM_WRITEABLE(s) < size)
748: {
749: STREAM_BOUND_WARN (s, "put");
750: /* Fatal (not transient) error, since retrying will not help
751: (stream is too small to contain the desired data). */
752: return -1;
753: }
754:
755: if ((nbytes = read(fd, s->data + s->endp, size)) >= 0)
756: {
757: s->endp += nbytes;
758: return nbytes;
759: }
760: /* Error: was it transient (return -2) or fatal (return -1)? */
761: if (ERRNO_IO_RETRY(errno))
762: return -2;
763: zlog_warn("%s: read failed on fd %d: %s", __func__, fd, safe_strerror(errno));
764: return -1;
765: }
766:
767: /* Read up to size bytes into the stream from the fd, using recvmsgfrom
768: * whose arguments match the remaining arguments to this function
769: */
770: ssize_t
771: stream_recvfrom (struct stream *s, int fd, size_t size, int flags,
772: struct sockaddr *from, socklen_t *fromlen)
773: {
774: ssize_t nbytes;
775:
776: STREAM_VERIFY_SANE(s);
777:
778: if (STREAM_WRITEABLE(s) < size)
779: {
780: STREAM_BOUND_WARN (s, "put");
781: /* Fatal (not transient) error, since retrying will not help
782: (stream is too small to contain the desired data). */
783: return -1;
784: }
785:
786: if ((nbytes = recvfrom (fd, s->data + s->endp, size,
787: flags, from, fromlen)) >= 0)
788: {
789: s->endp += nbytes;
790: return nbytes;
791: }
792: /* Error: was it transient (return -2) or fatal (return -1)? */
793: if (ERRNO_IO_RETRY(errno))
794: return -2;
795: zlog_warn("%s: read failed on fd %d: %s", __func__, fd, safe_strerror(errno));
796: return -1;
797: }
798:
799: /* Read up to smaller of size or SIZE_REMAIN() bytes to the stream, starting
800: * from endp.
801: * First iovec will be used to receive the data.
802: * Stream need not be empty.
803: */
804: ssize_t
805: stream_recvmsg (struct stream *s, int fd, struct msghdr *msgh, int flags,
806: size_t size)
807: {
808: int nbytes;
809: struct iovec *iov;
810:
811: STREAM_VERIFY_SANE(s);
812: assert (msgh->msg_iovlen > 0);
813:
814: if (STREAM_WRITEABLE (s) < size)
815: {
816: STREAM_BOUND_WARN (s, "put");
817: /* This is a logic error in the calling code: the stream is too small
818: to hold the desired data! */
819: return -1;
820: }
821:
822: iov = &(msgh->msg_iov[0]);
823: iov->iov_base = (s->data + s->endp);
824: iov->iov_len = size;
825:
826: nbytes = recvmsg (fd, msgh, flags);
827:
828: if (nbytes > 0)
829: s->endp += nbytes;
830:
831: return nbytes;
832: }
833:
834: /* Write data to buffer. */
835: size_t
836: stream_write (struct stream *s, const void *ptr, size_t size)
837: {
838:
839: CHECK_SIZE(s, size);
840:
841: STREAM_VERIFY_SANE(s);
842:
843: if (STREAM_WRITEABLE (s) < size)
844: {
845: STREAM_BOUND_WARN (s, "put");
846: return 0;
847: }
848:
849: memcpy (s->data + s->endp, ptr, size);
850: s->endp += size;
851:
852: return size;
853: }
854:
855: /* Return current read pointer.
856: * DEPRECATED!
857: * Use stream_get_pnt_to if you must, but decoding streams properly
858: * is preferred
859: */
860: u_char *
861: stream_pnt (struct stream *s)
862: {
863: STREAM_VERIFY_SANE(s);
864: return s->data + s->getp;
865: }
866:
867: /* Check does this stream empty? */
868: int
869: stream_empty (struct stream *s)
870: {
871: STREAM_VERIFY_SANE(s);
872:
873: return (s->endp == 0);
874: }
875:
876: /* Reset stream. */
877: void
878: stream_reset (struct stream *s)
879: {
880: STREAM_VERIFY_SANE (s);
881:
882: s->getp = s->endp = 0;
883: }
884:
885: /* Write stream contens to the file discriptor. */
886: int
887: stream_flush (struct stream *s, int fd)
888: {
889: int nbytes;
890:
891: STREAM_VERIFY_SANE(s);
892:
893: nbytes = write (fd, s->data + s->getp, s->endp - s->getp);
894:
895: return nbytes;
896: }
897:
898: /* Stream first in first out queue. */
899:
900: struct stream_fifo *
901: stream_fifo_new (void)
902: {
903: struct stream_fifo *new;
904:
905: new = XCALLOC (MTYPE_STREAM_FIFO, sizeof (struct stream_fifo));
906: return new;
907: }
908:
909: /* Add new stream to fifo. */
910: void
911: stream_fifo_push (struct stream_fifo *fifo, struct stream *s)
912: {
913: if (fifo->tail)
914: fifo->tail->next = s;
915: else
916: fifo->head = s;
917:
918: fifo->tail = s;
919:
920: fifo->count++;
921: }
922:
923: /* Delete first stream from fifo. */
924: struct stream *
925: stream_fifo_pop (struct stream_fifo *fifo)
926: {
927: struct stream *s;
928:
929: s = fifo->head;
930:
931: if (s)
932: {
933: fifo->head = s->next;
934:
935: if (fifo->head == NULL)
936: fifo->tail = NULL;
937: }
938:
939: fifo->count--;
940:
941: return s;
942: }
943:
944: /* Return first fifo entry. */
945: struct stream *
946: stream_fifo_head (struct stream_fifo *fifo)
947: {
948: return fifo->head;
949: }
950:
951: void
952: stream_fifo_clean (struct stream_fifo *fifo)
953: {
954: struct stream *s;
955: struct stream *next;
956:
957: for (s = fifo->head; s; s = next)
958: {
959: next = s->next;
960: stream_free (s);
961: }
962: fifo->head = fifo->tail = NULL;
963: fifo->count = 0;
964: }
965:
966: void
967: stream_fifo_free (struct stream_fifo *fifo)
968: {
969: stream_fifo_clean (fifo);
970: XFREE (MTYPE_STREAM_FIFO, fifo);
971: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to stream.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / lib