1 /* 2 * ustream - library for stream buffer management 3 * 4 * Copyright (C) 2012 Felix Fietkau <nbd@openwrt.org> 5 * 6 * Permission to use, copy, modify, and/or distribute this software for any 7 * purpose with or without fee is hereby granted, provided that the above 8 * copyright notice and this permission notice appear in all copies. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 17 */ 18 19 #ifndef __USTREAM_H 20 #define __USTREAM_H 21 22 #include <stdarg.h> 23 #include "uloop.h" 24 25 struct ustream; 26 struct ustream_buf; 27 28 enum read_blocked_reason { 29 READ_BLOCKED_USER = (1 << 0), 30 READ_BLOCKED_FULL = (1 << 1), 31 }; 32 33 struct ustream_buf_list { 34 struct ustream_buf *head; 35 struct ustream_buf *data_tail; 36 struct ustream_buf *tail; 37 38 int (*alloc)(struct ustream *s, struct ustream_buf_list *l); 39 40 int data_bytes; 41 42 int min_buffers; 43 int max_buffers; 44 int buffer_len; 45 46 int buffers; 47 }; 48 49 struct ustream { 50 struct ustream_buf_list r, w; 51 struct uloop_timeout state_change; 52 struct ustream *next; 53 54 /* 55 * notify_read: (optional) 56 * called by the ustream core to notify that new data is available 57 * for reading. 58 * freeing the ustream from this callback is allowed 59 */ 60 void (*notify_read)(struct ustream *s, int bytes_new); 61 62 /* 63 * notify_write: (optional) 64 * called by the ustream core to notify that some buffered data has 65 * been written to the stream. 66 * freeing the ustream from this callback is allowed 67 */ 68 void (*notify_write)(struct ustream *s, int bytes); 69 70 /* 71 * notify_state: (optional) 72 * called by the ustream implementation to notify that the read 73 * side of the stream is closed (eof is set) or there was a write 74 * error (write_error is set). 75 * will be called again after the write buffer has been emptied when 76 * the read side has hit EOF. 77 */ 78 void (*notify_state)(struct ustream *s); 79 80 /* 81 * write: 82 * must be defined by ustream implementation, accepts new write data. 83 * 'more' is used to indicate that a subsequent call will provide more 84 * data (useful for aggregating writes) 85 * returns the number of bytes accepted, or -1 if no more writes can 86 * be accepted (link error) 87 */ 88 int (*write)(struct ustream *s, const char *buf, int len, bool more); 89 90 /* 91 * free: (optional) 92 * defined by ustream implementation, tears down the ustream and frees data 93 */ 94 void (*free)(struct ustream *s); 95 96 /* 97 * set_read_blocked: (optional) 98 * defined by ustream implementation, called when the read_blocked flag 99 * changes 100 */ 101 void (*set_read_blocked)(struct ustream *s); 102 103 /* 104 * poll: (optional) 105 * defined by the upstream implementation, called to request polling for 106 * available data. 107 * returns true if data was fetched. 108 */ 109 bool (*poll)(struct ustream *s); 110 111 /* 112 * ustream user should set this if the input stream is expected 113 * to contain string data. the core will keep all data 0-terminated. 114 */ 115 bool string_data; 116 bool write_error; 117 bool eof; 118 uint8_t pending_cb; 119 bool *free_flag; 120 121 enum read_blocked_reason read_blocked; 122 }; 123 124 struct ustream_fd { 125 struct ustream stream; 126 struct uloop_fd fd; 127 }; 128 129 struct ustream_buf { 130 struct ustream_buf *next; 131 132 char *data; 133 char *tail; 134 char *end; 135 136 char head[]; 137 }; 138 139 /* ustream_fd_init: create a file descriptor ustream (uses uloop) */ 140 void ustream_fd_init(struct ustream_fd *s, int fd); 141 142 /* ustream_free: free all buffers and data associated with a ustream */ 143 void ustream_free(struct ustream *s); 144 145 /* ustream_consume: remove data from the head of the read buffer */ 146 void ustream_consume(struct ustream *s, int len); 147 148 /* 149 * ustream_read: read and consume data in read buffer into caller-specified 150 * area. Return length of data read. 151 */ 152 int ustream_read(struct ustream *s, char *buf, int buflen); 153 /* ustream_write: add data to the write buffer */ 154 int ustream_write(struct ustream *s, const char *buf, int len, bool more); 155 int ustream_printf(struct ustream *s, const char *format, ...) 156 __attribute__ ((format (printf, 2, 3))); 157 int ustream_vprintf(struct ustream *s, const char *format, va_list arg) 158 __attribute__ ((format (printf, 2, 0))); 159 160 /* ustream_get_read_buf: get a pointer to the next read buffer data */ 161 char *ustream_get_read_buf(struct ustream *s, int *buflen); 162 163 /* 164 * ustream_set_read_blocked: set read blocked state 165 * 166 * if set, the ustream will no longer fetch pending data. 167 */ 168 void ustream_set_read_blocked(struct ustream *s, bool set); 169 170 static inline bool ustream_read_blocked(struct ustream *s) 171 { 172 return !!(s->read_blocked & READ_BLOCKED_USER); 173 } 174 175 static inline int ustream_pending_data(struct ustream *s, bool write) 176 { 177 struct ustream_buf_list *b = write ? &s->w : &s->r; 178 return b->data_bytes; 179 } 180 181 static inline bool ustream_read_buf_full(struct ustream *s) 182 { 183 struct ustream_buf *buf = s->r.data_tail; 184 return buf && buf->data == buf->head && buf->tail == buf->end && 185 s->r.buffers == s->r.max_buffers; 186 } 187 188 /*** --- functions only used by ustream implementations --- ***/ 189 190 /* 191 * Guard for invoking notify callbacks that may call ustream_free(). 192 * ustream_free() signals the innermost active guard; a triggered guard 193 * forwards the signal to the next outer one, so every nested call site 194 * can bail out without touching the freed stream. 195 */ 196 struct ustream_free_guard { 197 bool freed; 198 bool *prev; 199 }; 200 201 void ustream_free_guard_set(struct ustream *s, struct ustream_free_guard *g); 202 bool ustream_free_guard_check(struct ustream *s, struct ustream_free_guard *g); 203 204 /* ustream_init_defaults: fill default callbacks and options */ 205 void ustream_init_defaults(struct ustream *s); 206 207 /* 208 * ustream_reserve: allocate rx buffer space 209 * 210 * len: hint for how much space is needed (not guaranteed to be met) 211 * maxlen: pointer to where the actual buffer size is going to be stored 212 */ 213 char *ustream_reserve(struct ustream *s, int len, int *maxlen); 214 215 /* ustream_fill_read: mark rx buffer space as filled */ 216 void ustream_fill_read(struct ustream *s, int len); 217 218 /* 219 * ustream_write_pending: attempt to write more data from write buffers 220 * returns true if all write buffers have been emptied. 221 */ 222 bool ustream_write_pending(struct ustream *s); 223 224 static inline void ustream_state_change(struct ustream *s) 225 { 226 uloop_timeout_set(&s->state_change, 0); 227 } 228 229 static inline bool ustream_poll(struct ustream *s) 230 { 231 if (!s->poll) 232 return false; 233 234 return s->poll(s); 235 } 236 237 #endif 238
This page was automatically generated by LXR 0.3.1. • OpenWrt