ISC DHCP  4.4.1
A reference DHCPv4 and DHCPv6 implementation
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
buffer.c
Go to the documentation of this file.
1 /* buffer.c
2 
3  Buffer access functions for the object management protocol... */
4 
5 /*
6  * Copyright (c) 2004-2017 by Internet Systems Consortium, Inc. ("ISC")
7  * Copyright (c) 1999-2003 by Internet Software Consortium
8  *
9  * This Source Code Form is subject to the terms of the Mozilla Public
10  * License, v. 2.0. If a copy of the MPL was not distributed with this
11  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
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  * https://www.isc.org/
26  *
27  */
28 
29 #include "dhcpd.h"
30 
31 #include <omapip/omapip_p.h>
32 #include <errno.h>
33 
34 #if defined (TRACING)
35 static void trace_connection_input_input (trace_type_t *, unsigned, char *);
36 static void trace_connection_input_stop (trace_type_t *);
37 static void trace_connection_output_input (trace_type_t *, unsigned, char *);
38 static void trace_connection_output_stop (trace_type_t *);
39 static trace_type_t *trace_connection_input;
40 static trace_type_t *trace_connection_output;
41 static isc_result_t omapi_connection_reader_trace (omapi_object_t *,
42  unsigned, char *,
43  unsigned *);
44 extern omapi_array_t *omapi_connections;
45 
47 {
48  trace_connection_input =
49  trace_type_register ("connection-input",
50  (void *)0,
51  trace_connection_input_input,
52  trace_connection_input_stop, MDL);
53  trace_connection_output =
54  trace_type_register ("connection-output",
55  (void *)0,
56  trace_connection_output_input,
57  trace_connection_output_stop, MDL);
58 }
59 
60 static void trace_connection_input_input (trace_type_t *ttype,
61  unsigned length, char *buf)
62 {
63  unsigned left, taken, cc = 0;
64  char *s;
65  int32_t connect_index;
66  isc_result_t status;
68 
69  memcpy (&connect_index, buf, sizeof connect_index);
70  connect_index = ntohl (connect_index);
71 
72  omapi_array_foreach_begin (omapi_connections,
74  if (lp -> index == ntohl (connect_index)) {
75  omapi_connection_reference (&c, lp, MDL);
76  omapi_connection_dereference (&lp, MDL);
77  break;
78  }
79  } omapi_array_foreach_end (omapi_connections,
81 
82  if (!c) {
83  log_error ("trace connection input: no connection index %ld",
84  (long int)connect_index);
85  return;
86  }
87 
88  s = buf + sizeof connect_index;
89  left = length - sizeof connect_index;
90 
91  while (left) {
92  taken = 0;
93  status = omapi_connection_reader_trace ((omapi_object_t *)c,
94  left, s, &taken);
95  if (status != ISC_R_SUCCESS) {
96  log_error ("trace connection input: %s",
97  isc_result_totext (status));
98  break;
99  }
100  if (!taken) {
101  if (cc > 0) {
102  log_error ("trace connection_input: %s",
103  "input is not being consumed.");
104  break;
105  }
106  cc++;
107  } else {
108  cc = 0;
109  left -= taken;
110  }
111  }
112  omapi_connection_dereference (&c, MDL);
113 }
114 
115 static void trace_connection_input_stop (trace_type_t *ttype) { }
116 
117 static void trace_connection_output_input (trace_type_t *ttype,
118  unsigned length, char *buf)
119 {
120  /* We *could* check to see if the output is correct, but for now
121  we aren't going to do that. */
122 }
123 
124 static void trace_connection_output_stop (trace_type_t *ttype) { }
125 
126 #endif
127 
128 /* Make sure that at least len bytes are in the input buffer, and if not,
129  read enough bytes to make up the difference. */
130 
132 {
133 #if defined (TRACING)
134  return omapi_connection_reader_trace (h, 0, (char *)0, (unsigned *)0);
135 }
136 
137 static isc_result_t omapi_connection_reader_trace (omapi_object_t *h,
138  unsigned stuff_len,
139  char *stuff_buf,
140  unsigned *stuff_taken)
141 {
142 #endif
144  isc_result_t status;
145  unsigned read_len;
146  int read_status;
148  unsigned bytes_to_read;
149 
150  if (!h || h -> type != omapi_type_connection)
151  return DHCP_R_INVALIDARG;
152  c = (omapi_connection_object_t *)h;
153 
154  /* See if there are enough bytes. */
155  if (c -> in_bytes >= OMAPI_BUF_SIZE - 1 &&
156  c -> in_bytes > c -> bytes_needed)
157  return ISC_R_SUCCESS;
158 
159 
160  if (c -> inbufs) {
161  for (buffer = c -> inbufs; buffer -> next;
162  buffer = buffer -> next)
163  ;
164  if (!BUFFER_BYTES_FREE (buffer)) {
165  status = omapi_buffer_new (&buffer -> next, MDL);
166  if (status != ISC_R_SUCCESS)
167  return status;
168  buffer = buffer -> next;
169  }
170  } else {
171  status = omapi_buffer_new (&c -> inbufs, MDL);
172  if (status != ISC_R_SUCCESS)
173  return status;
174  buffer = c -> inbufs;
175  }
176 
177  bytes_to_read = BUFFER_BYTES_FREE (buffer);
178 
179  while (bytes_to_read) {
180  if (buffer -> tail > buffer -> head)
181  read_len = sizeof (buffer -> buf) - buffer -> tail;
182  else
183  read_len = buffer -> head - buffer -> tail;
184 
185 #if defined (TRACING)
186  if (trace_playback()) {
187  if (stuff_len) {
188  if (read_len > stuff_len)
189  read_len = stuff_len;
190  if (stuff_taken)
191  *stuff_taken += read_len;
192  memcpy (&buffer -> buf [buffer -> tail],
193  stuff_buf, read_len);
194  stuff_len -= read_len;
195  stuff_buf += read_len;
196  read_status = read_len;
197  } else {
198  break;
199  }
200  } else
201 #endif
202  {
203  read_status = read (c -> socket,
204  &buffer -> buf [buffer -> tail],
205  read_len);
206  }
207  if (read_status < 0) {
208  if (errno == EWOULDBLOCK)
209  break;
210  else if (errno == EIO)
211  return ISC_R_IOERROR;
212  else if (errno == EINVAL)
213  return DHCP_R_INVALIDARG;
214  else if (errno == ECONNRESET) {
215  omapi_disconnect (h, 1);
216  return ISC_R_SHUTTINGDOWN;
217  } else
218  return ISC_R_UNEXPECTED;
219  }
220 
221  /* If we got a zero-length read, as opposed to EWOULDBLOCK,
222  the remote end closed the connection. */
223  if (read_status == 0) {
224  omapi_disconnect (h, 0);
225  return ISC_R_SHUTTINGDOWN;
226  }
227 #if defined (TRACING)
228  if (trace_record ()) {
229  trace_iov_t iov [2];
230  int32_t connect_index;
231 
232  connect_index = htonl (c -> index);
233 
234  iov [0].buf = (char *)&connect_index;
235  iov [0].len = sizeof connect_index;
236  iov [1].buf = &buffer -> buf [buffer -> tail];
237  iov [1].len = read_status;
238 
239  status = (trace_write_packet_iov
240  (trace_connection_input, 2, iov, MDL));
241  if (status != ISC_R_SUCCESS) {
242  trace_stop ();
243  log_error ("trace connection input: %s",
244  isc_result_totext (status));
245  }
246  }
247 #endif
248  buffer -> tail += read_status;
249  c -> in_bytes += read_status;
250  if (buffer -> tail == sizeof buffer -> buf)
251  buffer -> tail = 0;
252  if (read_status < read_len)
253  break;
254  bytes_to_read -= read_status;
255  }
256 
257  if (c -> bytes_needed <= c -> in_bytes) {
258  omapi_signal (h, "ready", c);
259  }
260  return ISC_R_SUCCESS;
261 }
262 
263 /* Put some bytes into the output buffer for a connection. */
264 
266  const unsigned char *bufp,
267  unsigned len)
268 {
269  omapi_buffer_t *buffer;
270  isc_result_t status;
271  int bytes_copied = 0;
272  unsigned copy_len;
273  int sig_flags = SIG_MODE_UPDATE;
275 
276  /* no need to verify len as it's unsigned */
277  if (!h || h -> type != omapi_type_connection)
278  return DHCP_R_INVALIDARG;
279  c = (omapi_connection_object_t *)h;
280 
281  /* If the connection is closed, return an error if the caller
282  tries to copy in. */
283  if (c -> state == omapi_connection_disconnecting ||
284  c -> state == omapi_connection_closed)
285  return ISC_R_NOTCONNECTED;
286 
287  if (c -> outbufs) {
288  for (buffer = c -> outbufs;
289  buffer -> next; buffer = buffer -> next)
290  ;
291  } else {
292  status = omapi_buffer_new (&c -> outbufs, MDL);
293  if (status != ISC_R_SUCCESS)
294  goto leave;
295  buffer = c -> outbufs;
296  }
297 
298  while (bytes_copied < len) {
299  /* If there is no space available in this buffer,
300  allocate a new one. */
301  if (!BUFFER_BYTES_FREE (buffer)) {
302  status = (omapi_buffer_new (&buffer -> next, MDL));
303  if (status != ISC_R_SUCCESS)
304  goto leave;
305  buffer = buffer -> next;
306  }
307 
308  if (buffer -> tail > buffer -> head)
309  copy_len = sizeof (buffer -> buf) - buffer -> tail;
310  else
311  copy_len = buffer -> head - buffer -> tail;
312 
313  if (copy_len > (len - bytes_copied))
314  copy_len = len - bytes_copied;
315 
316  if (c -> out_key) {
317  if (!c -> out_context)
318  sig_flags |= SIG_MODE_INIT;
320  (sig_flags, c -> out_key, &c -> out_context,
321  &bufp [bytes_copied], copy_len,
322  (omapi_typed_data_t **)0);
323  if (status != ISC_R_SUCCESS)
324  goto leave;
325  }
326 
327  memcpy (&buffer -> buf [buffer -> tail],
328  &bufp [bytes_copied], copy_len);
329  buffer -> tail += copy_len;
330  c -> out_bytes += copy_len;
331  bytes_copied += copy_len;
332  if (buffer -> tail == sizeof buffer -> buf)
333  buffer -> tail = 0;
334  }
335 
336  status = ISC_R_SUCCESS;
337 
338  leave:
339  /*
340  * If we have any bytes to send and we have a proper io object
341  * inform the socket code that we would like to know when we
342  * can send more bytes.
343  */
344  if (c->out_bytes != 0) {
345  if ((c->outer != NULL) &&
346  (c->outer->type == omapi_type_io_object)) {
347  omapi_io_object_t *io = (omapi_io_object_t *)c->outer;
348  isc_socket_fdwatchpoke(io->fd,
349  ISC_SOCKFDWATCH_WRITE);
350  }
351  }
352 
353  return (status);
354 }
355 
356 /* Copy some bytes from the input buffer, and advance the input buffer
357  pointer beyond the bytes copied out. */
358 
359 isc_result_t omapi_connection_copyout (unsigned char *buf,
360  omapi_object_t *h,
361  unsigned size)
362 {
363  unsigned bytes_remaining;
364  unsigned bytes_this_copy;
365  unsigned first_byte;
366  omapi_buffer_t *buffer;
367  unsigned char *bufp;
368  int sig_flags = SIG_MODE_UPDATE;
370  isc_result_t status;
371 
372  if (!h || h -> type != omapi_type_connection)
373  return DHCP_R_INVALIDARG;
374  c = (omapi_connection_object_t *)h;
375 
376  if (size > c -> in_bytes)
377  return ISC_R_NOMORE;
378  bufp = buf;
379  bytes_remaining = size;
380  buffer = c -> inbufs;
381 
382  while (bytes_remaining) {
383  if (!buffer)
384  return ISC_R_UNEXPECTED;
385  if (BYTES_IN_BUFFER (buffer)) {
386  if (buffer -> head == (sizeof buffer -> buf) - 1)
387  first_byte = 0;
388  else
389  first_byte = buffer -> head + 1;
390 
391  if (first_byte > buffer -> tail) {
392  bytes_this_copy = (sizeof buffer -> buf -
393  first_byte);
394  } else {
395  bytes_this_copy =
396  buffer -> tail - first_byte;
397  }
398  if (bytes_this_copy > bytes_remaining)
399  bytes_this_copy = bytes_remaining;
400  if (bufp) {
401  if (c -> in_key) {
402  if (!c -> in_context)
403  sig_flags |= SIG_MODE_INIT;
405  (sig_flags,
406  c -> in_key,
407  &c -> in_context,
408  (unsigned char *)
409  &buffer -> buf [first_byte],
410  bytes_this_copy,
411  (omapi_typed_data_t **)0);
412  if (status != ISC_R_SUCCESS)
413  return status;
414  }
415 
416  memcpy (bufp, &buffer -> buf [first_byte],
417  bytes_this_copy);
418  bufp += bytes_this_copy;
419  }
420  bytes_remaining -= bytes_this_copy;
421  buffer -> head = first_byte + bytes_this_copy - 1;
422  c -> in_bytes -= bytes_this_copy;
423  }
424 
425  if (!BYTES_IN_BUFFER (buffer))
426  buffer = buffer -> next;
427  }
428 
429  /* Get rid of any input buffers that we emptied. */
430  buffer = (omapi_buffer_t *)0;
431  while (c -> inbufs &&
432  !BYTES_IN_BUFFER (c -> inbufs)) {
433  if (c -> inbufs -> next) {
434  omapi_buffer_reference (&buffer,
435  c -> inbufs -> next, MDL);
436  omapi_buffer_dereference (&c -> inbufs -> next, MDL);
437  }
438  omapi_buffer_dereference (&c -> inbufs, MDL);
439  if (buffer) {
441  (&c -> inbufs, buffer, MDL);
442  omapi_buffer_dereference (&buffer, MDL);
443  }
444  }
445  return ISC_R_SUCCESS;
446 }
447 
449 {
450  unsigned bytes_this_write;
451  int bytes_written;
452  unsigned first_byte;
453  omapi_buffer_t *buffer;
455 
456  if (!h || h -> type != omapi_type_connection)
457  return DHCP_R_INVALIDARG;
458  c = (omapi_connection_object_t *)h;
459 
460  /* Already flushed... */
461  if (!c -> out_bytes)
462  return ISC_R_SUCCESS;
463 
464  buffer = c -> outbufs;
465 
466  while (c -> out_bytes) {
467  if (!buffer)
468  return ISC_R_UNEXPECTED;
469  if (BYTES_IN_BUFFER (buffer)) {
470  if (buffer -> head == (sizeof buffer -> buf) - 1)
471  first_byte = 0;
472  else
473  first_byte = buffer -> head + 1;
474 
475  if (first_byte > buffer -> tail) {
476  bytes_this_write = (sizeof buffer -> buf -
477  first_byte);
478  } else {
479  bytes_this_write =
480  buffer -> tail - first_byte;
481  }
482  bytes_written = write (c -> socket,
483  &buffer -> buf [first_byte],
484  bytes_this_write);
485  /* If the write failed with EWOULDBLOCK or we wrote
486  zero bytes, a further write would block, so we have
487  flushed as much as we can for now. Other errors
488  are really errors. */
489  if (bytes_written < 0) {
490  if (errno == EWOULDBLOCK || errno == EAGAIN)
491  return ISC_R_INPROGRESS;
492  else if (errno == EPIPE)
493  return ISC_R_NOCONN;
494 #ifdef EDQUOT
495  else if (errno == EFBIG || errno == EDQUOT)
496 #else
497  else if (errno == EFBIG)
498 #endif
499  return ISC_R_NORESOURCES;
500  else if (errno == ENOSPC)
501  return ISC_R_NOSPACE;
502  else if (errno == EIO)
503  return ISC_R_IOERROR;
504  else if (errno == EINVAL)
505  return DHCP_R_INVALIDARG;
506  else if (errno == ECONNRESET)
507  return ISC_R_SHUTTINGDOWN;
508  else
509  return ISC_R_UNEXPECTED;
510  }
511  if (bytes_written == 0)
512  return ISC_R_INPROGRESS;
513 
514 #if defined (TRACING)
515  if (trace_record ()) {
516  isc_result_t status;
517  trace_iov_t iov [2];
518  int32_t connect_index;
519 
520  connect_index = htonl (c -> index);
521 
522  iov [0].buf = (char *)&connect_index;
523  iov [0].len = sizeof connect_index;
524  iov [1].buf = &buffer -> buf [buffer -> tail];
525  iov [1].len = bytes_written;
526 
527  status = (trace_write_packet_iov
528  (trace_connection_input, 2, iov,
529  MDL));
530  if (status != ISC_R_SUCCESS) {
531  trace_stop ();
532  log_error ("trace %s output: %s",
533  "connection",
534  isc_result_totext (status));
535  }
536  }
537 #endif
538 
539  buffer -> head = first_byte + bytes_written - 1;
540  c -> out_bytes -= bytes_written;
541 
542  /* If we didn't finish out the write, we filled the
543  O.S. output buffer and a further write would block,
544  so stop trying to flush now. */
545  if (bytes_written != bytes_this_write)
546  return ISC_R_INPROGRESS;
547  }
548 
549  if (!BYTES_IN_BUFFER (buffer))
550  buffer = buffer -> next;
551  }
552 
553  /* Get rid of any output buffers we emptied. */
554  buffer = (omapi_buffer_t *)0;
555  while (c -> outbufs &&
556  !BYTES_IN_BUFFER (c -> outbufs)) {
557  if (c -> outbufs -> next) {
558  omapi_buffer_reference (&buffer,
559  c -> outbufs -> next, MDL);
560  omapi_buffer_dereference (&c -> outbufs -> next, MDL);
561  }
562  omapi_buffer_dereference (&c -> outbufs, MDL);
563  if (buffer) {
564  omapi_buffer_reference (&c -> outbufs, buffer, MDL);
565  omapi_buffer_dereference (&buffer, MDL);
566  }
567  }
568 
569  /* If we had data left to write when we're told to disconnect,
570  * we need recall disconnect, now that we're done writing.
571  * See rt46767. */
572  if (c->out_bytes == 0 && c->state == omapi_connection_disconnecting) {
573  omapi_disconnect (h, 1);
574  return ISC_R_SHUTTINGDOWN;
575  }
576 
577  return ISC_R_SUCCESS;
578 }
579 
581  u_int32_t *result)
582 {
583  u_int32_t inbuf;
584  isc_result_t status;
585 
586  status = omapi_connection_copyout ((unsigned char *)&inbuf,
587  c, sizeof inbuf);
588  if (status != ISC_R_SUCCESS)
589  return status;
590 
591  *result = ntohl (inbuf);
592  return ISC_R_SUCCESS;
593 }
594 
596  u_int32_t value)
597 {
598  u_int32_t inbuf;
599 
600  inbuf = htonl (value);
601 
602  return omapi_connection_copyin (c, (unsigned char *)&inbuf,
603  sizeof inbuf);
604 }
605 
607  u_int16_t *result)
608 {
609  u_int16_t inbuf;
610  isc_result_t status;
611 
612  status = omapi_connection_copyout ((unsigned char *)&inbuf,
613  c, sizeof inbuf);
614  if (status != ISC_R_SUCCESS)
615  return status;
616 
617  *result = ntohs (inbuf);
618  return ISC_R_SUCCESS;
619 }
620 
622  u_int32_t value)
623 {
624  u_int16_t inbuf;
625 
626  inbuf = htons (value);
627 
628  return omapi_connection_copyin (c, (unsigned char *)&inbuf,
629  sizeof inbuf);
630 }
631 
633  omapi_typed_data_t *data)
634 {
635  isc_result_t status;
636  omapi_handle_t handle;
637 
638  /* Null data is valid. */
639  if (!data)
640  return omapi_connection_put_uint32 (c, 0);
641 
642  switch (data -> type) {
643  case omapi_datatype_int:
644  status = omapi_connection_put_uint32 (c, sizeof (u_int32_t));
645  if (status != ISC_R_SUCCESS)
646  return status;
647  return omapi_connection_put_uint32 (c, ((u_int32_t)
648  (data -> u.integer)));
649 
651  case omapi_datatype_data:
652  status = omapi_connection_put_uint32 (c, data -> u.buffer.len);
653  if (status != ISC_R_SUCCESS)
654  return status;
655  if (data -> u.buffer.len)
657  (c, data -> u.buffer.value,
658  data -> u.buffer.len);
659  return ISC_R_SUCCESS;
660 
662  if (data -> u.object) {
663  status = omapi_object_handle (&handle,
664  data -> u.object);
665  if (status != ISC_R_SUCCESS)
666  return status;
667  } else
668  handle = 0;
669  status = omapi_connection_put_uint32 (c, sizeof handle);
670  if (status != ISC_R_SUCCESS)
671  return status;
672  return omapi_connection_put_uint32 (c, handle);
673 
674  }
675  return DHCP_R_INVALIDARG;
676 }
677 
678 isc_result_t omapi_connection_put_name (omapi_object_t *c, const char *name)
679 {
680  isc_result_t status;
681  unsigned len = strlen (name);
682 
683  status = omapi_connection_put_uint16 (c, len);
684  if (status != ISC_R_SUCCESS)
685  return status;
686  return omapi_connection_copyin (c, (const unsigned char *)name, len);
687 }
688 
690  const char *string)
691 {
692  isc_result_t status;
693  unsigned len;
694 
695  if (string)
696  len = strlen (string);
697  else
698  len = 0;
699 
700  status = omapi_connection_put_uint32 (c, len);
701  if (status != ISC_R_SUCCESS)
702  return status;
703  if (len)
705  (c, (const unsigned char *)string, len);
706  return ISC_R_SUCCESS;
707 }
708 
710 {
711  isc_result_t status;
712  omapi_handle_t handle;
713 
714  if (h) {
715  status = omapi_object_handle (&handle, h);
716  if (status != ISC_R_SUCCESS)
717  return status;
718  } else
719  handle = 0; /* The null handle. */
720  status = omapi_connection_put_uint32 (c, sizeof handle);
721  if (status != ISC_R_SUCCESS)
722  return status;
723  return omapi_connection_put_uint32 (c, handle);
724 }
725 
727  const char *name,
728  u_int32_t value)
729 {
730  isc_result_t status;
731 
732  status = omapi_connection_put_name(c, name);
733  if (status != ISC_R_SUCCESS)
734  return (status);
735 
736  status = omapi_connection_put_uint32(c, sizeof(u_int32_t));
737  if (status != ISC_R_SUCCESS)
738  return (status);
739 
740  status = omapi_connection_put_uint32(c, value);
741  return (status);
742 }
743 
const char * buf
Definition: trace.h:75
const char * name
Definition: tree.h:302
return DHCP_R_INVALIDARG
Definition: parse.c:1222
isc_result_t omapi_connection_reader(omapi_object_t *)
Definition: buffer.c:131
omapi_object_type_t * omapi_type_connection
Definition: support.c:33
#define BUFFER_BYTES_FREE(x)
Definition: buffer.h:57
isc_result_t omapi_buffer_dereference(omapi_buffer_t **, const char *, int)
Definition: alloc.c:766
isc_result_t omapi_connection_put_handle(omapi_object_t *c, omapi_object_t *h)
Definition: buffer.c:709
#define SIG_MODE_INIT
Definition: omapip_p.h:70
isc_result_t omapi_connection_copyin(omapi_object_t *, const unsigned char *, unsigned)
Definition: buffer.c:265
#define MDL
Definition: omapip.h:567
isc_result_t omapi_connection_put_named_uint32(omapi_object_t *, const char *, u_int32_t)
Definition: buffer.c:726
omapi_connection_state_t state
Definition: omapip_p.h:181
return ISC_R_SUCCESS
Definition: parse.c:1341
int trace_playback(void)
int log_error(const char *,...) __attribute__((__format__(__printf__
omapi_object_t * object
Definition: omapip.h:62
struct omapi_typed_data_t::@3::@4 buffer
isc_result_t omapi_connection_put_uint32(omapi_object_t *, u_int32_t)
Definition: buffer.c:595
isc_result_t omapi_connection_write_typed_data(omapi_object_t *, omapi_typed_data_t *)
Definition: buffer.c:632
trace_type_t * trace_type_register(const char *, void *, void(*)(trace_type_t *, unsigned, char *), void(*)(trace_type_t *), const char *, int)
void trace_stop(void)
unsigned len
Definition: trace.h:76
isc_result_t omapi_connection_writer(omapi_object_t *)
Definition: buffer.c:448
isc_result_t omapi_signal(omapi_object_t *, const char *,...)
Definition: support.c:267
isc_result_t trace_write_packet_iov(trace_type_t *, int, trace_iov_t *, const char *, int)
int index
Definition: tree.h:339
isc_result_t omapi_connection_get_uint32(omapi_object_t *, u_int32_t *)
Definition: buffer.c:580
int trace_record(void)
isc_socket_t * fd
Definition: omapip_p.h:210
isc_result_t omapi_object_handle(omapi_handle_t *, omapi_object_t *)
Definition: handle.c:72
isc_result_t omapi_connection_put_string(omapi_object_t *, const char *)
Definition: buffer.c:689
unsigned int omapi_handle_t
Definition: omapip.h:36
isc_result_t omapi_buffer_reference(omapi_buffer_t **, omapi_buffer_t *, const char *, int)
Definition: alloc.c:744
isc_result_t omapi_connection_put_uint16(omapi_object_t *, u_int32_t)
Definition: buffer.c:621
omapi_object_type_t * omapi_type_io_object
Definition: support.c:35
void omapi_buffer_trace_setup(void)
Definition: tree.h:60
#define omapi_array_foreach_end(array, stype, var)
Definition: omapip.h:256
#define BYTES_IN_BUFFER(x)
Definition: buffer.h:62
omapi_type_protocol_listener omapi_type_listener omapi_type_waiter omapi_type_message isc_result_t omapi_connection_sign_data(int mode, dst_key_t *key, void **context, const unsigned char *data, const unsigned len, omapi_typed_data_t **result)
Definition: connection.c:828
isc_result_t omapi_connection_copyout(unsigned char *, omapi_object_t *, unsigned)
Definition: buffer.c:359
isc_result_t omapi_connection_get_uint16(omapi_object_t *, u_int16_t *)
Definition: buffer.c:606
isc_result_t omapi_connection_put_name(omapi_object_t *, const char *)
Definition: buffer.c:678
isc_result_t omapi_disconnect(omapi_object_t *, int)
Definition: connection.c:455
#define OMAPI_BUF_SIZE
Definition: buffer.h:48
#define omapi_array_foreach_begin(array, stype, var)
Definition: omapip.h:242
#define SIG_MODE_UPDATE
Definition: omapip_p.h:71
isc_result_t omapi_buffer_new(omapi_buffer_t **, const char *, int)
Definition: alloc.c:727