1: /* buffer.c
2:
3: Buffer access functions for the object management protocol... */
4:
5: /*
6: * Copyright (c) 2004,2005,2007,2009
7: * by Internet Systems Consortium, Inc. ("ISC")
8: * Copyright (c) 1999-2003 by Internet Software Consortium
9: *
10: * Permission to use, copy, modify, and distribute this software for any
11: * purpose with or without fee is hereby granted, provided that the above
12: * copyright notice and this permission notice appear in all copies.
13: *
14: * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
15: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
16: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR
17: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
18: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
19: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
20: * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
21: *
22: * Internet Systems Consortium, Inc.
23: * 950 Charter Street
24: * Redwood City, CA 94063
25: * <info@isc.org>
26: * https://www.isc.org/
27: *
28: * This software has been written for Internet Systems Consortium
29: * by Ted Lemon in cooperation with Vixie Enterprises and Nominum, Inc.
30: * To learn more about Internet Systems Consortium, see
31: * ``https://www.isc.org/''. To learn more about Vixie Enterprises,
32: * see ``http://www.vix.com''. To learn more about Nominum, Inc., see
33: * ``http://www.nominum.com''.
34: */
35:
36: #include "dhcpd.h"
37:
38: #include <omapip/omapip_p.h>
39: #include <errno.h>
40:
41: #if defined (TRACING)
42: static void trace_connection_input_input (trace_type_t *, unsigned, char *);
43: static void trace_connection_input_stop (trace_type_t *);
44: static void trace_connection_output_input (trace_type_t *, unsigned, char *);
45: static void trace_connection_output_stop (trace_type_t *);
46: static trace_type_t *trace_connection_input;
47: static trace_type_t *trace_connection_output;
48: static isc_result_t omapi_connection_reader_trace (omapi_object_t *,
49: unsigned, char *,
50: unsigned *);
51: extern omapi_array_t *omapi_connections;
52:
53: void omapi_buffer_trace_setup ()
54: {
55: trace_connection_input =
56: trace_type_register ("connection-input",
57: (void *)0,
58: trace_connection_input_input,
59: trace_connection_input_stop, MDL);
60: trace_connection_output =
61: trace_type_register ("connection-output",
62: (void *)0,
63: trace_connection_output_input,
64: trace_connection_output_stop, MDL);
65: }
66:
67: static void trace_connection_input_input (trace_type_t *ttype,
68: unsigned length, char *buf)
69: {
70: unsigned left, taken, cc = 0;
71: char *s;
72: int32_t connect_index;
73: isc_result_t status;
74: omapi_connection_object_t *c = (omapi_connection_object_t *)0;
75:
76: memcpy (&connect_index, buf, sizeof connect_index);
77: connect_index = ntohl (connect_index);
78:
79: omapi_array_foreach_begin (omapi_connections,
80: omapi_connection_object_t, lp) {
81: if (lp -> index == ntohl (connect_index)) {
82: omapi_connection_reference (&c, lp, MDL);
83: omapi_connection_dereference (&lp, MDL);
84: break;
85: }
86: } omapi_array_foreach_end (omapi_connections,
87: omapi_connection_object_t, lp);
88:
89: if (!c) {
90: log_error ("trace connection input: no connection index %ld",
91: (long int)connect_index);
92: return;
93: }
94:
95: s = buf + sizeof connect_index;
96: left = length - sizeof connect_index;
97:
98: while (left) {
99: taken = 0;
100: status = omapi_connection_reader_trace ((omapi_object_t *)c,
101: left, s, &taken);
102: if (status != ISC_R_SUCCESS) {
103: log_error ("trace connection input: %s",
104: isc_result_totext (status));
105: break;
106: }
107: if (!taken) {
108: if (cc > 0) {
109: log_error ("trace connection_input: %s",
110: "input is not being consumed.");
111: break;
112: }
113: cc++;
114: } else {
115: cc = 0;
116: left -= taken;
117: }
118: }
119: omapi_connection_dereference (&c, MDL);
120: }
121:
122: static void trace_connection_input_stop (trace_type_t *ttype) { }
123:
124: static void trace_connection_output_input (trace_type_t *ttype,
125: unsigned length, char *buf)
126: {
127: /* We *could* check to see if the output is correct, but for now
128: we aren't going to do that. */
129: }
130:
131: static void trace_connection_output_stop (trace_type_t *ttype) { }
132:
133: #endif
134:
135: /* Make sure that at least len bytes are in the input buffer, and if not,
136: read enough bytes to make up the difference. */
137:
138: isc_result_t omapi_connection_reader (omapi_object_t *h)
139: {
140: #if defined (TRACING)
141: return omapi_connection_reader_trace (h, 0, (char *)0, (unsigned *)0);
142: }
143:
144: static isc_result_t omapi_connection_reader_trace (omapi_object_t *h,
145: unsigned stuff_len,
146: char *stuff_buf,
147: unsigned *stuff_taken)
148: {
149: #endif
150: omapi_buffer_t *buffer;
151: isc_result_t status;
152: unsigned read_len;
153: int read_status;
154: omapi_connection_object_t *c;
155: unsigned bytes_to_read;
156:
157: if (!h || h -> type != omapi_type_connection)
158: return ISC_R_INVALIDARG;
159: c = (omapi_connection_object_t *)h;
160:
161: /* See if there are enough bytes. */
162: if (c -> in_bytes >= OMAPI_BUF_SIZE - 1 &&
163: c -> in_bytes > c -> bytes_needed)
164: return ISC_R_SUCCESS;
165:
166:
167: if (c -> inbufs) {
168: for (buffer = c -> inbufs; buffer -> next;
169: buffer = buffer -> next)
170: ;
171: if (!BUFFER_BYTES_FREE (buffer)) {
172: status = omapi_buffer_new (&buffer -> next, MDL);
173: if (status != ISC_R_SUCCESS)
174: return status;
175: buffer = buffer -> next;
176: }
177: } else {
178: status = omapi_buffer_new (&c -> inbufs, MDL);
179: if (status != ISC_R_SUCCESS)
180: return status;
181: buffer = c -> inbufs;
182: }
183:
184: bytes_to_read = BUFFER_BYTES_FREE (buffer);
185:
186: while (bytes_to_read) {
187: if (buffer -> tail > buffer -> head)
188: read_len = sizeof (buffer -> buf) - buffer -> tail;
189: else
190: read_len = buffer -> head - buffer -> tail;
191:
192: #if defined (TRACING)
193: if (trace_playback()) {
194: if (stuff_len) {
195: if (read_len > stuff_len)
196: read_len = stuff_len;
197: if (stuff_taken)
198: *stuff_taken += read_len;
199: memcpy (&buffer -> buf [buffer -> tail],
200: stuff_buf, read_len);
201: stuff_len -= read_len;
202: stuff_buf += read_len;
203: read_status = read_len;
204: } else {
205: break;
206: }
207: } else
208: #endif
209: {
210: read_status = read (c -> socket,
211: &buffer -> buf [buffer -> tail],
212: read_len);
213: }
214: if (read_status < 0) {
215: if (errno == EWOULDBLOCK)
216: break;
217: else if (errno == EIO)
218: return ISC_R_IOERROR;
219: else if (errno == EINVAL)
220: return ISC_R_INVALIDARG;
221: else if (errno == ECONNRESET) {
222: omapi_disconnect (h, 1);
223: return ISC_R_SHUTTINGDOWN;
224: } else
225: return ISC_R_UNEXPECTED;
226: }
227:
228: /* If we got a zero-length read, as opposed to EWOULDBLOCK,
229: the remote end closed the connection. */
230: if (read_status == 0) {
231: omapi_disconnect (h, 0);
232: return ISC_R_SHUTTINGDOWN;
233: }
234: #if defined (TRACING)
235: if (trace_record ()) {
236: trace_iov_t iov [2];
237: int32_t connect_index;
238:
239: connect_index = htonl (c -> index);
240:
241: iov [0].buf = (char *)&connect_index;
242: iov [0].len = sizeof connect_index;
243: iov [1].buf = &buffer -> buf [buffer -> tail];
244: iov [1].len = read_status;
245:
246: status = (trace_write_packet_iov
247: (trace_connection_input, 2, iov, MDL));
248: if (status != ISC_R_SUCCESS) {
249: trace_stop ();
250: log_error ("trace connection input: %s",
251: isc_result_totext (status));
252: }
253: }
254: #endif
255: buffer -> tail += read_status;
256: c -> in_bytes += read_status;
257: if (buffer -> tail == sizeof buffer -> buf)
258: buffer -> tail = 0;
259: if (read_status < read_len)
260: break;
261: bytes_to_read -= read_status;
262: }
263:
264: if (c -> bytes_needed <= c -> in_bytes) {
265: omapi_signal (h, "ready", c);
266: }
267: return ISC_R_SUCCESS;
268: }
269:
270: /* Put some bytes into the output buffer for a connection. */
271:
272: isc_result_t omapi_connection_copyin (omapi_object_t *h,
273: const unsigned char *bufp,
274: unsigned len)
275: {
276: omapi_buffer_t *buffer;
277: isc_result_t status;
278: int bytes_copied = 0;
279: unsigned copy_len;
280: int sig_flags = SIG_MODE_UPDATE;
281: omapi_connection_object_t *c;
282:
283: /* Make sure len is valid. */
284: if (len < 0)
285: return ISC_R_INVALIDARG;
286: if (!h || h -> type != omapi_type_connection)
287: return ISC_R_INVALIDARG;
288: c = (omapi_connection_object_t *)h;
289:
290: /* If the connection is closed, return an error if the caller
291: tries to copy in. */
292: if (c -> state == omapi_connection_disconnecting ||
293: c -> state == omapi_connection_closed)
294: return ISC_R_NOTCONNECTED;
295:
296: if (c -> outbufs) {
297: for (buffer = c -> outbufs;
298: buffer -> next; buffer = buffer -> next)
299: ;
300: } else {
301: status = omapi_buffer_new (&c -> outbufs, MDL);
302: if (status != ISC_R_SUCCESS)
303: return status;
304: buffer = c -> outbufs;
305: }
306:
307: while (bytes_copied < len) {
308: /* If there is no space available in this buffer,
309: allocate a new one. */
310: if (!BUFFER_BYTES_FREE (buffer)) {
311: status = (omapi_buffer_new (&buffer -> next, MDL));
312: if (status != ISC_R_SUCCESS)
313: return status;
314: buffer = buffer -> next;
315: }
316:
317: if (buffer -> tail > buffer -> head)
318: copy_len = sizeof (buffer -> buf) - buffer -> tail;
319: else
320: copy_len = buffer -> head - buffer -> tail;
321:
322: if (copy_len > (len - bytes_copied))
323: copy_len = len - bytes_copied;
324:
325: if (c -> out_key) {
326: if (!c -> out_context)
327: sig_flags |= SIG_MODE_INIT;
328: status = omapi_connection_sign_data
329: (sig_flags, c -> out_key, &c -> out_context,
330: &bufp [bytes_copied], copy_len,
331: (omapi_typed_data_t **)0);
332: if (status != ISC_R_SUCCESS)
333: return status;
334: }
335:
336: memcpy (&buffer -> buf [buffer -> tail],
337: &bufp [bytes_copied], copy_len);
338: buffer -> tail += copy_len;
339: c -> out_bytes += copy_len;
340: bytes_copied += copy_len;
341: if (buffer -> tail == sizeof buffer -> buf)
342: buffer -> tail = 0;
343: }
344: return ISC_R_SUCCESS;
345: }
346:
347: /* Copy some bytes from the input buffer, and advance the input buffer
348: pointer beyond the bytes copied out. */
349:
350: isc_result_t omapi_connection_copyout (unsigned char *buf,
351: omapi_object_t *h,
352: unsigned size)
353: {
354: unsigned bytes_remaining;
355: unsigned bytes_this_copy;
356: unsigned first_byte;
357: omapi_buffer_t *buffer;
358: unsigned char *bufp;
359: int sig_flags = SIG_MODE_UPDATE;
360: omapi_connection_object_t *c;
361: isc_result_t status;
362:
363: if (!h || h -> type != omapi_type_connection)
364: return ISC_R_INVALIDARG;
365: c = (omapi_connection_object_t *)h;
366:
367: if (size > c -> in_bytes)
368: return ISC_R_NOMORE;
369: bufp = buf;
370: bytes_remaining = size;
371: buffer = c -> inbufs;
372:
373: while (bytes_remaining) {
374: if (!buffer)
375: return ISC_R_UNEXPECTED;
376: if (BYTES_IN_BUFFER (buffer)) {
377: if (buffer -> head == (sizeof buffer -> buf) - 1)
378: first_byte = 0;
379: else
380: first_byte = buffer -> head + 1;
381:
382: if (first_byte > buffer -> tail) {
383: bytes_this_copy = (sizeof buffer -> buf -
384: first_byte);
385: } else {
386: bytes_this_copy =
387: buffer -> tail - first_byte;
388: }
389: if (bytes_this_copy > bytes_remaining)
390: bytes_this_copy = bytes_remaining;
391: if (bufp) {
392: if (c -> in_key) {
393: if (!c -> in_context)
394: sig_flags |= SIG_MODE_INIT;
395: status = omapi_connection_sign_data
396: (sig_flags,
397: c -> in_key,
398: &c -> in_context,
399: (unsigned char *)
400: &buffer -> buf [first_byte],
401: bytes_this_copy,
402: (omapi_typed_data_t **)0);
403: if (status != ISC_R_SUCCESS)
404: return status;
405: }
406:
407: memcpy (bufp, &buffer -> buf [first_byte],
408: bytes_this_copy);
409: bufp += bytes_this_copy;
410: }
411: bytes_remaining -= bytes_this_copy;
412: buffer -> head = first_byte + bytes_this_copy - 1;
413: c -> in_bytes -= bytes_this_copy;
414: }
415:
416: if (!BYTES_IN_BUFFER (buffer))
417: buffer = buffer -> next;
418: }
419:
420: /* Get rid of any input buffers that we emptied. */
421: buffer = (omapi_buffer_t *)0;
422: while (c -> inbufs &&
423: !BYTES_IN_BUFFER (c -> inbufs)) {
424: if (c -> inbufs -> next) {
425: omapi_buffer_reference (&buffer,
426: c -> inbufs -> next, MDL);
427: omapi_buffer_dereference (&c -> inbufs -> next, MDL);
428: }
429: omapi_buffer_dereference (&c -> inbufs, MDL);
430: if (buffer) {
431: omapi_buffer_reference
432: (&c -> inbufs, buffer, MDL);
433: omapi_buffer_dereference (&buffer, MDL);
434: }
435: }
436: return ISC_R_SUCCESS;
437: }
438:
439: isc_result_t omapi_connection_writer (omapi_object_t *h)
440: {
441: unsigned bytes_this_write;
442: int bytes_written;
443: unsigned first_byte;
444: omapi_buffer_t *buffer;
445: omapi_connection_object_t *c;
446:
447: if (!h || h -> type != omapi_type_connection)
448: return ISC_R_INVALIDARG;
449: c = (omapi_connection_object_t *)h;
450:
451: /* Already flushed... */
452: if (!c -> out_bytes)
453: return ISC_R_SUCCESS;
454:
455: buffer = c -> outbufs;
456:
457: while (c -> out_bytes) {
458: if (!buffer)
459: return ISC_R_UNEXPECTED;
460: if (BYTES_IN_BUFFER (buffer)) {
461: if (buffer -> head == (sizeof buffer -> buf) - 1)
462: first_byte = 0;
463: else
464: first_byte = buffer -> head + 1;
465:
466: if (first_byte > buffer -> tail) {
467: bytes_this_write = (sizeof buffer -> buf -
468: first_byte);
469: } else {
470: bytes_this_write =
471: buffer -> tail - first_byte;
472: }
473: bytes_written = write (c -> socket,
474: &buffer -> buf [first_byte],
475: bytes_this_write);
476: /* If the write failed with EWOULDBLOCK or we wrote
477: zero bytes, a further write would block, so we have
478: flushed as much as we can for now. Other errors
479: are really errors. */
480: if (bytes_written < 0) {
481: if (errno == EWOULDBLOCK || errno == EAGAIN)
482: return ISC_R_SUCCESS;
483: else if (errno == EPIPE)
484: return ISC_R_NOCONN;
485: #ifdef EDQUOT
486: else if (errno == EFBIG || errno == EDQUOT)
487: #else
488: else if (errno == EFBIG)
489: #endif
490: return ISC_R_NORESOURCES;
491: else if (errno == ENOSPC)
492: return ISC_R_NOSPACE;
493: else if (errno == EIO)
494: return ISC_R_IOERROR;
495: else if (errno == EINVAL)
496: return ISC_R_INVALIDARG;
497: else if (errno == ECONNRESET)
498: return ISC_R_SHUTTINGDOWN;
499: else
500: return ISC_R_UNEXPECTED;
501: }
502: if (bytes_written == 0)
503: return ISC_R_SUCCESS;
504:
505: #if defined (TRACING)
506: if (trace_record ()) {
507: isc_result_t status;
508: trace_iov_t iov [2];
509: int32_t connect_index;
510:
511: connect_index = htonl (c -> index);
512:
513: iov [0].buf = (char *)&connect_index;
514: iov [0].len = sizeof connect_index;
515: iov [1].buf = &buffer -> buf [buffer -> tail];
516: iov [1].len = bytes_written;
517:
518: status = (trace_write_packet_iov
519: (trace_connection_input, 2, iov,
520: MDL));
521: if (status != ISC_R_SUCCESS) {
522: trace_stop ();
523: log_error ("trace %s output: %s",
524: "connection",
525: isc_result_totext (status));
526: }
527: }
528: #endif
529:
530: buffer -> head = first_byte + bytes_written - 1;
531: c -> out_bytes -= bytes_written;
532:
533: /* If we didn't finish out the write, we filled the
534: O.S. output buffer and a further write would block,
535: so stop trying to flush now. */
536: if (bytes_written != bytes_this_write)
537: return ISC_R_SUCCESS;
538: }
539:
540: if (!BYTES_IN_BUFFER (buffer))
541: buffer = buffer -> next;
542: }
543:
544: /* Get rid of any output buffers we emptied. */
545: buffer = (omapi_buffer_t *)0;
546: while (c -> outbufs &&
547: !BYTES_IN_BUFFER (c -> outbufs)) {
548: if (c -> outbufs -> next) {
549: omapi_buffer_reference (&buffer,
550: c -> outbufs -> next, MDL);
551: omapi_buffer_dereference (&c -> outbufs -> next, MDL);
552: }
553: omapi_buffer_dereference (&c -> outbufs, MDL);
554: if (buffer) {
555: omapi_buffer_reference (&c -> outbufs, buffer, MDL);
556: omapi_buffer_dereference (&buffer, MDL);
557: }
558: }
559: return ISC_R_SUCCESS;
560: }
561:
562: isc_result_t omapi_connection_get_uint32 (omapi_object_t *c,
563: u_int32_t *result)
564: {
565: u_int32_t inbuf;
566: isc_result_t status;
567:
568: status = omapi_connection_copyout ((unsigned char *)&inbuf,
569: c, sizeof inbuf);
570: if (status != ISC_R_SUCCESS)
571: return status;
572:
573: *result = ntohl (inbuf);
574: return ISC_R_SUCCESS;
575: }
576:
577: isc_result_t omapi_connection_put_uint32 (omapi_object_t *c,
578: u_int32_t value)
579: {
580: u_int32_t inbuf;
581:
582: inbuf = htonl (value);
583:
584: return omapi_connection_copyin (c, (unsigned char *)&inbuf,
585: sizeof inbuf);
586: }
587:
588: isc_result_t omapi_connection_get_uint16 (omapi_object_t *c,
589: u_int16_t *result)
590: {
591: u_int16_t inbuf;
592: isc_result_t status;
593:
594: status = omapi_connection_copyout ((unsigned char *)&inbuf,
595: c, sizeof inbuf);
596: if (status != ISC_R_SUCCESS)
597: return status;
598:
599: *result = ntohs (inbuf);
600: return ISC_R_SUCCESS;
601: }
602:
603: isc_result_t omapi_connection_put_uint16 (omapi_object_t *c,
604: u_int32_t value)
605: {
606: u_int16_t inbuf;
607:
608: inbuf = htons (value);
609:
610: return omapi_connection_copyin (c, (unsigned char *)&inbuf,
611: sizeof inbuf);
612: }
613:
614: isc_result_t omapi_connection_write_typed_data (omapi_object_t *c,
615: omapi_typed_data_t *data)
616: {
617: isc_result_t status;
618: omapi_handle_t handle;
619:
620: /* Null data is valid. */
621: if (!data)
622: return omapi_connection_put_uint32 (c, 0);
623:
624: switch (data -> type) {
625: case omapi_datatype_int:
626: status = omapi_connection_put_uint32 (c, sizeof (u_int32_t));
627: if (status != ISC_R_SUCCESS)
628: return status;
629: return omapi_connection_put_uint32 (c, ((u_int32_t)
630: (data -> u.integer)));
631:
632: case omapi_datatype_string:
633: case omapi_datatype_data:
634: status = omapi_connection_put_uint32 (c, data -> u.buffer.len);
635: if (status != ISC_R_SUCCESS)
636: return status;
637: if (data -> u.buffer.len)
638: return omapi_connection_copyin
639: (c, data -> u.buffer.value,
640: data -> u.buffer.len);
641: return ISC_R_SUCCESS;
642:
643: case omapi_datatype_object:
644: if (data -> u.object) {
645: status = omapi_object_handle (&handle,
646: data -> u.object);
647: if (status != ISC_R_SUCCESS)
648: return status;
649: } else
650: handle = 0;
651: status = omapi_connection_put_uint32 (c, sizeof handle);
652: if (status != ISC_R_SUCCESS)
653: return status;
654: return omapi_connection_put_uint32 (c, handle);
655:
656: }
657: return ISC_R_INVALIDARG;
658: }
659:
660: isc_result_t omapi_connection_put_name (omapi_object_t *c, const char *name)
661: {
662: isc_result_t status;
663: unsigned len = strlen (name);
664:
665: status = omapi_connection_put_uint16 (c, len);
666: if (status != ISC_R_SUCCESS)
667: return status;
668: return omapi_connection_copyin (c, (const unsigned char *)name, len);
669: }
670:
671: isc_result_t omapi_connection_put_string (omapi_object_t *c,
672: const char *string)
673: {
674: isc_result_t status;
675: unsigned len;
676:
677: if (string)
678: len = strlen (string);
679: else
680: len = 0;
681:
682: status = omapi_connection_put_uint32 (c, len);
683: if (status != ISC_R_SUCCESS)
684: return status;
685: if (len)
686: return omapi_connection_copyin
687: (c, (const unsigned char *)string, len);
688: return ISC_R_SUCCESS;
689: }
690:
691: isc_result_t omapi_connection_put_handle (omapi_object_t *c, omapi_object_t *h)
692: {
693: isc_result_t status;
694: omapi_handle_t handle;
695:
696: if (h) {
697: status = omapi_object_handle (&handle, h);
698: if (status != ISC_R_SUCCESS)
699: return status;
700: } else
701: handle = 0; /* The null handle. */
702: status = omapi_connection_put_uint32 (c, sizeof handle);
703: if (status != ISC_R_SUCCESS)
704: return status;
705: return omapi_connection_put_uint32 (c, handle);
706: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to buffer.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / dhcp / omapip