?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Expand PMF_FN_* macros.
[netbsd-mini2440.git] / dist / dhcp / omapip / buffer.c
blob6b436a7ce89b43bd77ca3a87eba07642de568d06
1 /* buffer.c
2
3 Buffer access functions for the object management protocol... */
4
5 /*
6 * Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC")
7 * Copyright (c) 1999-2003 by Internet Software Consortium
8 *
9 * Permission to use, copy, modify, and distribute this software for any
10 * purpose with or without fee is hereby granted, provided that the above
11 * copyright notice and this permission notice appear in all copies.
12 *
13 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
14 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
15 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR
16 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
17 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
18 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
19 * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
20 *
21 * Internet Systems Consortium, Inc.
22 * 950 Charter Street
23 * Redwood City, CA 94063
24 * <info@isc.org>
25 * http://www.isc.org/
26 *
27 * This software has been written for Internet Systems Consortium
28 * by Ted Lemon in cooperation with Vixie Enterprises and Nominum, Inc.
29 * To learn more about Internet Systems Consortium, see
30 * ``http://www.isc.org/''. To learn more about Vixie Enterprises,
31 * see ``http://www.vix.com''. To learn more about Nominum, Inc., see
32 * ``http://www.nominum.com''.
33 */
34
35 #include <omapip/omapip_p.h>
36
37 #if defined (TRACING)
38 static void trace_connection_input_input (trace_type_t *, unsigned, char *);
39 static void trace_connection_input_stop (trace_type_t *);
40 static void trace_connection_output_input (trace_type_t *, unsigned, char *);
41 static void trace_connection_output_stop (trace_type_t *);
42 static trace_type_t *trace_connection_input;
43 static trace_type_t *trace_connection_output;
44 static isc_result_t omapi_connection_reader_trace (omapi_object_t *,
45 unsigned, char *,
46 unsigned *);
47 extern omapi_array_t *omapi_connections;
48
49 void omapi_buffer_trace_setup ()
50 {
51 trace_connection_input =
52 trace_type_register ("connection-input",
53 (void *)0,
54 trace_connection_input_input,
55 trace_connection_input_stop, MDL);
56 trace_connection_output =
57 trace_type_register ("connection-output",
58 (void *)0,
59 trace_connection_output_input,
60 trace_connection_output_stop, MDL);
61 }
62
63 static void trace_connection_input_input (trace_type_t *ttype,
64 unsigned length, char *buf)
65 {
66 unsigned left, taken, cc = 0;
67 char *s;
68 int32_t connect_index;
69 isc_result_t status;
70 omapi_connection_object_t *c = (omapi_connection_object_t *)0;
71
72 memcpy (&connect_index, buf, sizeof connect_index);
73 connect_index = ntohl (connect_index);
74
75 omapi_array_foreach_begin (omapi_connections,
76 omapi_connection_object_t, lp) {
77 if (lp -> index == ntohl (connect_index)) {
78 omapi_connection_reference (&c, lp, MDL);
79 omapi_connection_dereference (&lp, MDL);
80 break;
81 }
82 } omapi_array_foreach_end (omapi_connections,
83 omapi_connection_object_t, lp);
84
85 if (!c) {
86 log_error ("trace connection input: no connection index %ld",
87 (long int)connect_index);
88 return;
89 }
90
91 s = buf + sizeof connect_index;
92 left = length - sizeof connect_index;
93
94 while (left) {
95 taken = 0;
96 status = omapi_connection_reader_trace ((omapi_object_t *)c,
97 left, s, &taken);
98 if (status != ISC_R_SUCCESS) {
99 log_error ("trace connection input: %s",
100 isc_result_totext (status));
101 break;
102 }
103 if (!taken) {
104 if (cc > 0) {
105 log_error ("trace connection_input: %s",
106 "input is not being consumed.");
107 break;
108 }
109 cc++;
110 } else {
111 cc = 0;
112 left -= taken;
113 }
114 }
115 omapi_connection_dereference (&c, MDL);
116 }
117
118 static void trace_connection_input_stop (trace_type_t *ttype) { }
119
120 static void trace_connection_output_input (trace_type_t *ttype,
121 unsigned length, char *buf)
122 {
123 /* We *could* check to see if the output is correct, but for now
124 we aren't going to do that. */
125 }
126
127 static void trace_connection_output_stop (trace_type_t *ttype) { }
128
129 #endif
130
131 /* Make sure that at least len bytes are in the input buffer, and if not,
132 read enough bytes to make up the difference. */
133
134 isc_result_t omapi_connection_reader (omapi_object_t *h)
135 {
136 #if defined (TRACING)
137 return omapi_connection_reader_trace (h, 0, (char *)0, (unsigned *)0);
138 }
139
140 static isc_result_t omapi_connection_reader_trace (omapi_object_t *h,
141 unsigned stuff_len,
142 char *stuff_buf,
143 unsigned *stuff_taken)
144 {
145 #endif
146 omapi_buffer_t *buffer;
147 isc_result_t status;
148 unsigned read_len;
149 int read_status;
150 omapi_connection_object_t *c;
151 unsigned bytes_to_read;
152
153 if (!h || h -> type != omapi_type_connection)
154 return ISC_R_INVALIDARG;
155 c = (omapi_connection_object_t *)h;
156
157 /* Make sure c -> bytes_needed is valid. */
158 if (c -> bytes_needed < 0)
159 return ISC_R_INVALIDARG;
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 isc_result_t status;
447
448 if (!h || h -> type != omapi_type_connection)
449 return ISC_R_INVALIDARG;
450 c = (omapi_connection_object_t *)h;
451
452 /* Already flushed... */
453 if (!c -> out_bytes)
454 return ISC_R_SUCCESS;
455
456 buffer = c -> outbufs;
457
458 while (c -> out_bytes) {
459 if (!buffer)
460 return ISC_R_UNEXPECTED;
461 if (BYTES_IN_BUFFER (buffer)) {
462 if (buffer -> head == (sizeof buffer -> buf) - 1)
463 first_byte = 0;
464 else
465 first_byte = buffer -> head + 1;
466
467 if (first_byte > buffer -> tail) {
468 bytes_this_write = (sizeof buffer -> buf -
469 first_byte);
470 } else {
471 bytes_this_write =
472 buffer -> tail - first_byte;
473 }
474 bytes_written = write (c -> socket,
475 &buffer -> buf [first_byte],
476 bytes_this_write);
477 /* If the write failed with EWOULDBLOCK or we wrote
478 zero bytes, a further write would block, so we have
479 flushed as much as we can for now. Other errors
480 are really errors. */
481 if (bytes_written < 0) {
482 if (errno == EWOULDBLOCK || errno == EAGAIN)
483 return ISC_R_SUCCESS;
484 else if (errno == EPIPE)
485 return ISC_R_NOCONN;
486 #ifdef EDQUOT
487 else if (errno == EFBIG || errno == EDQUOT)
488 #else
489 else if (errno == EFBIG)
490 #endif
491 return ISC_R_NORESOURCES;
492 else if (errno == ENOSPC)
493 return ISC_R_NOSPACE;
494 else if (errno == EIO)
495 return ISC_R_IOERROR;
496 else if (errno == EINVAL)
497 return ISC_R_INVALIDARG;
498 else if (errno == ECONNRESET)
499 return ISC_R_SHUTTINGDOWN;
500 else
501 return ISC_R_UNEXPECTED;
502 }
503 if (bytes_written == 0)
504 return ISC_R_SUCCESS;
505
506 #if defined (TRACING)
507 if (trace_record ()) {
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 }
NetBSD on the FriendlyARM MINI2440