]>
Commit | Line | Data |
---|---|---|
718e3744 | 1 | /* |
d62a17ae | 2 | * Buffering of output and input. |
718e3744 | 3 | * Copyright (C) 1998 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 | |
8 | * it under the terms of the GNU General Public License as published | |
9 | * by the Free Software Foundation; either version 2, or (at your | |
10 | * option) any later version. | |
896014f4 | 11 | * |
718e3744 | 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 | * | |
896014f4 DL |
17 | * You should have received a copy of the GNU General Public License along |
18 | * with this program; see the file COPYING; if not, write to the Free Software | |
19 | * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | |
718e3744 | 20 | */ |
21 | ||
22 | #include <zebra.h> | |
23 | ||
24 | #include "memory.h" | |
25 | #include "buffer.h" | |
2265d20c | 26 | #include "log.h" |
9fc7ebf1 | 27 | #include "network.h" |
481bc15f DS |
28 | #include "lib_errors.h" |
29 | ||
49ff6d9d | 30 | #include <stddef.h> |
718e3744 | 31 | |
bf8d3d6a DL |
32 | DEFINE_MTYPE_STATIC(LIB, BUFFER, "Buffer"); |
33 | DEFINE_MTYPE_STATIC(LIB, BUFFER_DATA, "Buffer data"); | |
718e3744 | 34 | |
9fc7ebf1 | 35 | /* Buffer master. */ |
d62a17ae | 36 | struct buffer { |
37 | /* Data list. */ | |
38 | struct buffer_data *head; | |
39 | struct buffer_data *tail; | |
40 | ||
41 | /* Size of each buffer_data chunk. */ | |
42 | size_t size; | |
9fc7ebf1 | 43 | }; |
44 | ||
45 | /* Data container. */ | |
d62a17ae | 46 | struct buffer_data { |
47 | struct buffer_data *next; | |
9fc7ebf1 | 48 | |
d62a17ae | 49 | /* Location to add new data. */ |
50 | size_t cp; | |
9fc7ebf1 | 51 | |
d62a17ae | 52 | /* Pointer to data not yet flushed. */ |
53 | size_t sp; | |
9fc7ebf1 | 54 | |
d62a17ae | 55 | /* Actual data stream (variable length). */ |
56 | unsigned char data[]; /* real dimension is buffer->size */ | |
9fc7ebf1 | 57 | }; |
58 | ||
59 | /* It should always be true that: 0 <= sp <= cp <= size */ | |
60 | ||
61 | /* Default buffer size (used if none specified). It is rounded up to the | |
214d8a60 | 62 | next page boundary. */ |
9fc7ebf1 | 63 | #define BUFFER_SIZE_DEFAULT 4096 |
64 | ||
9fc7ebf1 | 65 | #define BUFFER_DATA_FREE(D) XFREE(MTYPE_BUFFER_DATA, (D)) |
718e3744 | 66 | |
67 | /* Make new buffer. */ | |
d62a17ae | 68 | struct buffer *buffer_new(size_t size) |
718e3744 | 69 | { |
d62a17ae | 70 | struct buffer *b; |
71 | ||
72 | b = XCALLOC(MTYPE_BUFFER, sizeof(struct buffer)); | |
73 | ||
74 | if (size) | |
75 | b->size = size; | |
76 | else { | |
77 | static size_t default_size; | |
78 | if (!default_size) { | |
79 | long pgsz = sysconf(_SC_PAGESIZE); | |
80 | default_size = ((((BUFFER_SIZE_DEFAULT - 1) / pgsz) + 1) | |
81 | * pgsz); | |
82 | } | |
83 | b->size = default_size; | |
9fc7ebf1 | 84 | } |
718e3744 | 85 | |
d62a17ae | 86 | return b; |
718e3744 | 87 | } |
88 | ||
89 | /* Free buffer. */ | |
d62a17ae | 90 | void buffer_free(struct buffer *b) |
718e3744 | 91 | { |
d62a17ae | 92 | buffer_reset(b); |
93 | XFREE(MTYPE_BUFFER, b); | |
718e3744 | 94 | } |
95 | ||
96 | /* Make string clone. */ | |
d62a17ae | 97 | char *buffer_getstr(struct buffer *b) |
718e3744 | 98 | { |
d62a17ae | 99 | size_t totlen = 0; |
100 | struct buffer_data *data; | |
101 | char *s; | |
102 | char *p; | |
103 | ||
104 | for (data = b->head; data; data = data->next) | |
105 | totlen += data->cp - data->sp; | |
106 | if (!(s = XMALLOC(MTYPE_TMP, totlen + 1))) | |
107 | return NULL; | |
108 | p = s; | |
109 | for (data = b->head; data; data = data->next) { | |
110 | memcpy(p, data->data + data->sp, data->cp - data->sp); | |
111 | p += data->cp - data->sp; | |
112 | } | |
113 | *p = '\0'; | |
114 | return s; | |
718e3744 | 115 | } |
116 | ||
718e3744 | 117 | /* Clear and free all allocated data. */ |
d62a17ae | 118 | void buffer_reset(struct buffer *b) |
718e3744 | 119 | { |
d62a17ae | 120 | struct buffer_data *data; |
121 | struct buffer_data *next; | |
122 | ||
123 | for (data = b->head; data; data = next) { | |
124 | next = data->next; | |
125 | BUFFER_DATA_FREE(data); | |
126 | } | |
127 | b->head = b->tail = NULL; | |
718e3744 | 128 | } |
129 | ||
130 | /* Add buffer_data to the end of buffer. */ | |
d62a17ae | 131 | static struct buffer_data *buffer_add(struct buffer *b) |
718e3744 | 132 | { |
d62a17ae | 133 | struct buffer_data *d; |
718e3744 | 134 | |
d62a17ae | 135 | d = XMALLOC(MTYPE_BUFFER_DATA, |
136 | offsetof(struct buffer_data, data) + b->size); | |
137 | d->cp = d->sp = 0; | |
138 | d->next = NULL; | |
718e3744 | 139 | |
d62a17ae | 140 | if (b->tail) |
141 | b->tail->next = d; | |
142 | else | |
143 | b->head = d; | |
144 | b->tail = d; | |
718e3744 | 145 | |
d62a17ae | 146 | return d; |
718e3744 | 147 | } |
148 | ||
149 | /* Write data to buffer. */ | |
d62a17ae | 150 | void buffer_put(struct buffer *b, const void *p, size_t size) |
718e3744 | 151 | { |
d62a17ae | 152 | struct buffer_data *data = b->tail; |
153 | const char *ptr = p; | |
154 | ||
155 | /* We use even last one byte of data buffer. */ | |
156 | while (size) { | |
157 | size_t chunk; | |
158 | ||
159 | /* If there is no data buffer add it. */ | |
160 | if (data == NULL || data->cp == b->size) | |
161 | data = buffer_add(b); | |
162 | ||
163 | chunk = ((size <= (b->size - data->cp)) ? size | |
164 | : (b->size - data->cp)); | |
165 | memcpy((data->data + data->cp), ptr, chunk); | |
166 | size -= chunk; | |
167 | ptr += chunk; | |
168 | data->cp += chunk; | |
169 | } | |
718e3744 | 170 | } |
171 | ||
172 | /* Insert character into the buffer. */ | |
d7c0a89a | 173 | void buffer_putc(struct buffer *b, uint8_t c) |
718e3744 | 174 | { |
d62a17ae | 175 | buffer_put(b, &c, 1); |
718e3744 | 176 | } |
177 | ||
178 | /* Put string to the buffer. */ | |
d62a17ae | 179 | void buffer_putstr(struct buffer *b, const char *c) |
718e3744 | 180 | { |
d62a17ae | 181 | buffer_put(b, c, strlen(c)); |
718e3744 | 182 | } |
183 | ||
83eba583 | 184 | /* Expand \n to \r\n */ |
d62a17ae | 185 | void buffer_put_crlf(struct buffer *b, const void *origp, size_t origsize) |
83eba583 | 186 | { |
d62a17ae | 187 | struct buffer_data *data = b->tail; |
188 | const char *p = origp, *end = p + origsize, *lf; | |
189 | size_t size; | |
190 | ||
191 | lf = memchr(p, '\n', end - p); | |
192 | ||
193 | /* We use even last one byte of data buffer. */ | |
194 | while (p < end) { | |
195 | size_t avail, chunk; | |
196 | ||
197 | /* If there is no data buffer add it. */ | |
198 | if (data == NULL || data->cp == b->size) | |
199 | data = buffer_add(b); | |
200 | ||
201 | size = (lf ? lf : end) - p; | |
202 | avail = b->size - data->cp; | |
203 | ||
204 | chunk = (size <= avail) ? size : avail; | |
205 | memcpy(data->data + data->cp, p, chunk); | |
206 | ||
207 | p += chunk; | |
208 | data->cp += chunk; | |
209 | ||
210 | if (lf && size <= avail) { | |
211 | /* we just copied up to (including) a '\n' */ | |
212 | if (data->cp == b->size) | |
213 | data = buffer_add(b); | |
214 | data->data[data->cp++] = '\r'; | |
215 | if (data->cp == b->size) | |
216 | data = buffer_add(b); | |
217 | data->data[data->cp++] = '\n'; | |
218 | ||
219 | p++; | |
220 | lf = memchr(p, '\n', end - p); | |
221 | } | |
222 | } | |
83eba583 DL |
223 | } |
224 | ||
9fc7ebf1 | 225 | /* Keep flushing data to the fd until the buffer is empty or an error is |
226 | encountered or the operation would block. */ | |
d62a17ae | 227 | buffer_status_t buffer_flush_all(struct buffer *b, int fd) |
718e3744 | 228 | { |
d62a17ae | 229 | buffer_status_t ret; |
230 | struct buffer_data *head; | |
231 | size_t head_sp; | |
232 | ||
233 | if (!b->head) | |
234 | return BUFFER_EMPTY; | |
235 | head_sp = (head = b->head)->sp; | |
236 | /* Flush all data. */ | |
237 | while ((ret = buffer_flush_available(b, fd)) == BUFFER_PENDING) { | |
238 | if ((b->head == head) && (head_sp == head->sp) | |
239 | && (errno != EINTR)) | |
240 | /* No data was flushed, so kernel buffer must be full. | |
241 | */ | |
242 | return ret; | |
243 | head_sp = (head = b->head)->sp; | |
244 | } | |
718e3744 | 245 | |
d62a17ae | 246 | return ret; |
718e3744 | 247 | } |
248 | ||
9fc7ebf1 | 249 | /* Flush enough data to fill a terminal window of the given scene (used only |
250 | by vty telnet interface). */ | |
d62a17ae | 251 | buffer_status_t buffer_flush_window(struct buffer *b, int fd, int width, |
252 | int height, int erase_flag, | |
253 | int no_more_flag) | |
718e3744 | 254 | { |
d62a17ae | 255 | int nbytes; |
256 | int iov_alloc; | |
257 | int iov_index; | |
258 | struct iovec *iov; | |
259 | struct iovec small_iov[3]; | |
260 | char more[] = " --More-- "; | |
261 | char erase[] = {0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, | |
262 | 0x08, 0x08, ' ', ' ', ' ', ' ', ' ', ' ', | |
263 | ' ', ' ', ' ', ' ', 0x08, 0x08, 0x08, 0x08, | |
264 | 0x08, 0x08, 0x08, 0x08, 0x08, 0x08}; | |
265 | struct buffer_data *data; | |
266 | int column; | |
267 | ||
268 | if (!b->head) | |
269 | return BUFFER_EMPTY; | |
270 | ||
07436e2a | 271 | if (height < 1) |
d62a17ae | 272 | height = 1; |
07436e2a | 273 | else if (height >= 2) |
d62a17ae | 274 | height--; |
07436e2a | 275 | if (width < 1) |
d62a17ae | 276 | width = 1; |
718e3744 | 277 | |
d62a17ae | 278 | /* For erase and more data add two to b's buffer_data count.*/ |
279 | if (b->head->next == NULL) { | |
280 | iov_alloc = array_size(small_iov); | |
281 | iov = small_iov; | |
282 | } else { | |
283 | iov_alloc = ((height * (width + 2)) / b->size) + 10; | |
284 | iov = XMALLOC(MTYPE_TMP, iov_alloc * sizeof(*iov)); | |
285 | } | |
286 | iov_index = 0; | |
287 | ||
288 | /* Previously print out is performed. */ | |
289 | if (erase_flag) { | |
290 | iov[iov_index].iov_base = erase; | |
0d6f7fd6 | 291 | iov[iov_index].iov_len = sizeof(erase); |
d62a17ae | 292 | iov_index++; |
293 | } | |
294 | ||
295 | /* Output data. */ | |
296 | column = 1; /* Column position of next character displayed. */ | |
297 | for (data = b->head; data && (height > 0); data = data->next) { | |
298 | size_t cp; | |
299 | ||
300 | cp = data->sp; | |
301 | while ((cp < data->cp) && (height > 0)) { | |
302 | /* Calculate lines remaining and column position after | |
303 | displaying | |
304 | this character. */ | |
305 | if (data->data[cp] == '\r') | |
306 | column = 1; | |
307 | else if ((data->data[cp] == '\n') | |
308 | || (column == width)) { | |
309 | column = 1; | |
310 | height--; | |
311 | } else | |
312 | column++; | |
313 | cp++; | |
314 | } | |
315 | iov[iov_index].iov_base = (char *)(data->data + data->sp); | |
316 | iov[iov_index++].iov_len = cp - data->sp; | |
317 | data->sp = cp; | |
318 | ||
319 | if (iov_index == iov_alloc) | |
320 | /* This should not ordinarily happen. */ | |
321 | { | |
322 | iov_alloc *= 2; | |
323 | if (iov != small_iov) { | |
d62a17ae | 324 | iov = XREALLOC(MTYPE_TMP, iov, |
325 | iov_alloc * sizeof(*iov)); | |
326 | } else { | |
327 | /* This should absolutely never occur. */ | |
09c866e3 | 328 | flog_err_sys( |
450971aa | 329 | EC_LIB_SYSTEM_CALL, |
3efd0893 | 330 | "%s: corruption detected: iov_small overflowed; head %p, tail %p, head->next %p", |
09c866e3 QY |
331 | __func__, (void *)b->head, |
332 | (void *)b->tail, (void *)b->head->next); | |
d62a17ae | 333 | iov = XMALLOC(MTYPE_TMP, |
334 | iov_alloc * sizeof(*iov)); | |
335 | memcpy(iov, small_iov, sizeof(small_iov)); | |
336 | } | |
337 | } | |
338 | } | |
339 | ||
340 | /* In case of `more' display need. */ | |
341 | if (b->tail && (b->tail->sp < b->tail->cp) && !no_more_flag) { | |
342 | iov[iov_index].iov_base = more; | |
0d6f7fd6 | 343 | iov[iov_index].iov_len = sizeof(more); |
d62a17ae | 344 | iov_index++; |
345 | } | |
718e3744 | 346 | |
718e3744 | 347 | |
348 | #ifdef IOV_MAX | |
d62a17ae | 349 | /* IOV_MAX are normally defined in <sys/uio.h> , Posix.1g. |
350 | example: Solaris2.6 are defined IOV_MAX size at 16. */ | |
351 | { | |
352 | struct iovec *c_iov = iov; | |
353 | nbytes = 0; /* Make sure it's initialized. */ | |
354 | ||
355 | while (iov_index > 0) { | |
356 | int iov_size; | |
357 | ||
358 | iov_size = | |
359 | ((iov_index > IOV_MAX) ? IOV_MAX : iov_index); | |
0e2d7076 DA |
360 | nbytes = writev(fd, c_iov, iov_size); |
361 | if (nbytes < 0) { | |
450971aa | 362 | flog_err(EC_LIB_SOCKET, |
29c7044c DS |
363 | "%s: writev to fd %d failed: %s", |
364 | __func__, fd, safe_strerror(errno)); | |
d62a17ae | 365 | break; |
366 | } | |
367 | ||
368 | /* move pointer io-vector */ | |
369 | c_iov += iov_size; | |
370 | iov_index -= iov_size; | |
371 | } | |
372 | } | |
718e3744 | 373 | #else /* IOV_MAX */ |
0e2d7076 DA |
374 | nbytes = writev(fd, iov, iov_index); |
375 | if (nbytes < 0) | |
450971aa | 376 | flog_err(EC_LIB_SOCKET, "%s: writev to fd %d failed: %s", |
ade6974d | 377 | __func__, fd, safe_strerror(errno)); |
718e3744 | 378 | #endif /* IOV_MAX */ |
379 | ||
d62a17ae | 380 | /* Free printed buffer data. */ |
381 | while (b->head && (b->head->sp == b->head->cp)) { | |
382 | struct buffer_data *del; | |
383 | if (!(b->head = (del = b->head)->next)) | |
384 | b->tail = NULL; | |
385 | BUFFER_DATA_FREE(del); | |
386 | } | |
718e3744 | 387 | |
d62a17ae | 388 | if (iov != small_iov) |
389 | XFREE(MTYPE_TMP, iov); | |
718e3744 | 390 | |
d62a17ae | 391 | return (nbytes < 0) ? BUFFER_ERROR |
392 | : (b->head ? BUFFER_PENDING : BUFFER_EMPTY); | |
718e3744 | 393 | } |
49ff6d9d | 394 | |
395 | /* This function (unlike other buffer_flush* functions above) is designed | |
396 | to work with non-blocking sockets. It does not attempt to write out | |
397 | all of the queued data, just a "big" chunk. It returns 0 if it was | |
9fc7ebf1 | 398 | able to empty out the buffers completely, 1 if more flushing is |
399 | required later, or -1 on a fatal write error. */ | |
d62a17ae | 400 | buffer_status_t buffer_flush_available(struct buffer *b, int fd) |
49ff6d9d | 401 | { |
402 | ||
403 | /* These are just reasonable values to make sure a significant amount of | |
404 | data is written. There's no need to go crazy and try to write it all | |
405 | in one shot. */ | |
406 | #ifdef IOV_MAX | |
407 | #define MAX_CHUNKS ((IOV_MAX >= 16) ? 16 : IOV_MAX) | |
408 | #else | |
409 | #define MAX_CHUNKS 16 | |
410 | #endif | |
411 | #define MAX_FLUSH 131072 | |
412 | ||
d62a17ae | 413 | struct buffer_data *d; |
414 | size_t written; | |
415 | struct iovec iov[MAX_CHUNKS]; | |
416 | size_t iovcnt = 0; | |
417 | size_t nbyte = 0; | |
418 | ||
6451e846 QY |
419 | if (fd < 0) |
420 | return BUFFER_ERROR; | |
421 | ||
d62a17ae | 422 | for (d = b->head; d && (iovcnt < MAX_CHUNKS) && (nbyte < MAX_FLUSH); |
423 | d = d->next, iovcnt++) { | |
424 | iov[iovcnt].iov_base = d->data + d->sp; | |
425 | nbyte += (iov[iovcnt].iov_len = d->cp - d->sp); | |
49ff6d9d | 426 | } |
427 | ||
d62a17ae | 428 | if (!nbyte) |
429 | /* No data to flush: should we issue a warning message? */ | |
430 | return BUFFER_EMPTY; | |
431 | ||
432 | /* only place where written should be sign compared */ | |
433 | if ((ssize_t)(written = writev(fd, iov, iovcnt)) < 0) { | |
434 | if (ERRNO_IO_RETRY(errno)) | |
435 | /* Calling code should try again later. */ | |
436 | return BUFFER_PENDING; | |
450971aa | 437 | flog_err(EC_LIB_SOCKET, "%s: write error on fd %d: %s", |
ade6974d | 438 | __func__, fd, safe_strerror(errno)); |
d62a17ae | 439 | return BUFFER_ERROR; |
440 | } | |
441 | ||
442 | /* Free printed buffer data. */ | |
443 | while (written > 0) { | |
d62a17ae | 444 | if (!(d = b->head)) { |
af4c2728 | 445 | flog_err( |
450971aa | 446 | EC_LIB_DEVELOPMENT, |
472878dc | 447 | "%s: corruption detected: buffer queue empty, but written is %lu", |
d7c0a89a | 448 | __func__, (unsigned long)written); |
d62a17ae | 449 | break; |
450 | } | |
451 | if (written < d->cp - d->sp) { | |
452 | d->sp += written; | |
453 | return BUFFER_PENDING; | |
454 | } | |
455 | ||
456 | written -= (d->cp - d->sp); | |
457 | if (!(b->head = d->next)) | |
458 | b->tail = NULL; | |
459 | BUFFER_DATA_FREE(d); | |
460 | } | |
49ff6d9d | 461 | |
d62a17ae | 462 | return b->head ? BUFFER_PENDING : BUFFER_EMPTY; |
49ff6d9d | 463 | |
464 | #undef MAX_CHUNKS | |
465 | #undef MAX_FLUSH | |
466 | } | |
9fc7ebf1 | 467 | |
d62a17ae | 468 | buffer_status_t buffer_write(struct buffer *b, int fd, const void *p, |
469 | size_t size) | |
9fc7ebf1 | 470 | { |
d62a17ae | 471 | ssize_t nbytes; |
9fc7ebf1 | 472 | |
d62a17ae | 473 | if (b->head) |
474 | /* Buffer is not empty, so do not attempt to write the new data. | |
475 | */ | |
476 | nbytes = 0; | |
0e2d7076 DA |
477 | else { |
478 | nbytes = write(fd, p, size); | |
479 | if (nbytes < 0) { | |
480 | if (ERRNO_IO_RETRY(errno)) | |
481 | nbytes = 0; | |
482 | else { | |
483 | flog_err(EC_LIB_SOCKET, | |
484 | "%s: write error on fd %d: %s", | |
485 | __func__, fd, safe_strerror(errno)); | |
486 | return BUFFER_ERROR; | |
487 | } | |
d62a17ae | 488 | } |
489 | } | |
490 | /* Add any remaining data to the buffer. */ | |
491 | { | |
492 | size_t written = nbytes; | |
493 | if (written < size) | |
494 | buffer_put(b, ((const char *)p) + written, | |
495 | size - written); | |
9fc7ebf1 | 496 | } |
d62a17ae | 497 | return b->head ? BUFFER_PENDING : BUFFER_EMPTY; |
9fc7ebf1 | 498 | } |