- Hide the following characters '(', ')', '{', '}' inside of #defines
[dragonfly.git] / contrib / dhcp-3.0 / dhcpctl / dhcpctl.c
1 /* dhcpctl.c
2
3    Subroutines providing general support for objects. */
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 #ifndef lint
36 static char copyright[] =
37 "$Id: dhcpctl.c,v 1.22.2.7 2004/06/10 17:59:24 dhankins Exp $ Copyright (c) 2004 Internet Systems Consortium.  All rights reserved.\n";
38 #endif /* not lint */
39
40 #include <omapip/omapip_p.h>
41 #include "dhcpctl.h"
42
43 omapi_object_type_t *dhcpctl_callback_type;
44 omapi_object_type_t *dhcpctl_remote_type;
45
46 /* dhcpctl_initialize ()
47
48    Must be called before any other dhcpctl function. */
49
50 dhcpctl_status dhcpctl_initialize ()
51 {
52         isc_result_t status;
53
54         status = omapi_init();
55         if (status != ISC_R_SUCCESS)
56                 return status;
57
58         status = omapi_object_type_register (&dhcpctl_callback_type,
59                                              "dhcpctl-callback",
60                                              dhcpctl_callback_set_value,
61                                              dhcpctl_callback_get_value,
62                                              dhcpctl_callback_destroy,
63                                              dhcpctl_callback_signal_handler,
64                                              dhcpctl_callback_stuff_values,
65                                              0, 0, 0, 0, 0, 0,
66                                              sizeof
67                                              (dhcpctl_callback_object_t), 0,
68                                              RC_MISC);
69         if (status != ISC_R_SUCCESS)
70                 return status;
71
72         status = omapi_object_type_register (&dhcpctl_remote_type,
73                                              "dhcpctl-remote",
74                                              dhcpctl_remote_set_value,
75                                              dhcpctl_remote_get_value,
76                                              dhcpctl_remote_destroy,
77                                              dhcpctl_remote_signal_handler,
78                                              dhcpctl_remote_stuff_values,
79                                              0, 0, 0, 0, 0, 0,
80                                              sizeof (dhcpctl_remote_object_t),
81                                              0, RC_MISC);
82         if (status != ISC_R_SUCCESS)
83                 return status;
84
85         return ISC_R_SUCCESS;
86 }
87
88 /* dhcpctl_connect
89
90    synchronous
91    returns nonzero status code if it didn't connect, zero otherwise
92    stores connection handle through connection, which can be used
93    for subsequent access to the specified server. 
94    server_name is the name of the server, and port is the TCP
95    port on which it is listening.
96    authinfo is the handle to an object containing authentication
97    information. */
98
99 dhcpctl_status dhcpctl_connect (dhcpctl_handle *connection,
100                                 const char *server_name, int port,
101                                 dhcpctl_handle authinfo)
102 {
103         isc_result_t status;
104         dhcpctl_status waitstatus;
105
106         status = omapi_generic_new (connection, MDL);
107         if (status != ISC_R_SUCCESS) {
108                 return status;
109         }
110
111         status = omapi_protocol_connect (*connection, server_name,
112                                          (unsigned)port, authinfo);
113         if (status == ISC_R_SUCCESS)
114                 return status;
115         if (status != ISC_R_INCOMPLETE) {
116                 omapi_object_dereference (connection, MDL);
117                 return status;
118         }
119
120         status = omapi_wait_for_completion (*connection, 0);
121         if (status != ISC_R_SUCCESS) {
122                 omapi_object_dereference (connection, MDL);
123                 return status;
124         }
125
126         return status;
127 }
128
129 /* dhcpctl_wait_for_completion
130
131    synchronous
132    returns zero if the callback completes, a nonzero status if
133    there was some problem relating to the wait operation.   The
134    status of the queued request will be stored through s, and
135    will also be either zero for success or nonzero for some kind
136    of failure.    Never returns until completion or until the
137    connection to the server is lost.   This performs the same
138    function as dhcpctl_set_callback and the subsequent callback,
139    for programs that want to do inline execution instead of using
140    callbacks. */
141
142 dhcpctl_status dhcpctl_wait_for_completion (dhcpctl_handle h,
143                                             dhcpctl_status *s)
144 {
145         isc_result_t status;
146         status = omapi_wait_for_completion (h, 0);
147         if (status != ISC_R_SUCCESS)
148                 return status;
149         if (h -> type == dhcpctl_remote_type)
150                 *s = ((dhcpctl_remote_object_t *)h) -> waitstatus;
151         return ISC_R_SUCCESS;
152 }
153
154 /* dhcpctl_get_value
155
156    synchronous
157    returns zero if the call succeeded, a nonzero status code if
158    it didn't. 
159    result is the address of an empty data string (initialized
160    with bzero or cleared with data_string_forget).   On
161    successful completion, the addressed data string will contain
162    the value that was fetched.
163    dhcpctl_handle refers to some dhcpctl item
164    value_name refers to some value related to that item - e.g.,
165    for a handle associated with a completed host lookup, value
166    could be one of "hardware-address", "dhcp-client-identifier",
167    "known" or "client-hostname". */
168
169 dhcpctl_status dhcpctl_get_value (dhcpctl_data_string *result,
170                                   dhcpctl_handle h, const char *value_name)
171 {
172         isc_result_t status;
173         omapi_value_t *tv = (omapi_value_t *)0;
174         omapi_data_string_t *value = (omapi_data_string_t *)0;
175         unsigned len;
176         int ip;
177
178         status = omapi_get_value_str (h, (omapi_object_t *)0, value_name, &tv);
179         if (status != ISC_R_SUCCESS)
180                 return status;
181
182         switch (tv -> value -> type) {
183               case omapi_datatype_int:
184                 len = sizeof (int);
185                 break;
186
187               case omapi_datatype_string:
188               case omapi_datatype_data:
189                 len = tv -> value -> u.buffer.len;
190                 break;
191
192               case omapi_datatype_object:
193                 len = sizeof (omapi_handle_t);
194                 break;
195
196               default:
197                 omapi_typed_data_dereference (&tv -> value, MDL);
198                 return ISC_R_UNEXPECTED;
199         }
200
201         status = omapi_data_string_new (result, len, MDL);
202         if (status != ISC_R_SUCCESS) {
203                 omapi_typed_data_dereference (&tv -> value, MDL);
204                 return status;
205         }
206
207         switch (tv -> value -> type) {
208               case omapi_datatype_int:
209                 ip = htonl (tv -> value -> u.integer);
210                 memcpy ((*result) -> value, &ip, sizeof ip);
211                 break;
212
213               case omapi_datatype_string:
214               case omapi_datatype_data:
215                 memcpy ((*result) -> value,
216                         tv -> value -> u.buffer.value,
217                         tv -> value -> u.buffer.len);
218                 break;
219
220               case omapi_datatype_object:
221                 ip = htonl (tv -> value -> u.object -> handle);
222                 memcpy ((*result) -> value, &ip, sizeof ip);
223                 break;
224         }
225
226         omapi_value_dereference (&tv, MDL);
227         return ISC_R_SUCCESS;
228 }
229
230 /* dhcpctl_get_boolean
231
232    like dhcpctl_get_value, but more convenient for boolean
233    values, since no data_string needs to be dealt with. */
234
235 dhcpctl_status dhcpctl_get_boolean (int *result,
236                                     dhcpctl_handle h, const char *value_name)
237 {
238         isc_result_t status;
239         dhcpctl_data_string data = (dhcpctl_data_string)0;
240         int rv;
241         
242         status = dhcpctl_get_value (&data, h, value_name);
243         if (status != ISC_R_SUCCESS)
244                 return status;
245         if (data -> len != sizeof rv) {
246                 omapi_data_string_dereference (&data, MDL);
247                 return ISC_R_UNEXPECTED;
248         }
249         memcpy (&rv, data -> value, sizeof rv);
250         *result = ntohl (rv);
251         return ISC_R_SUCCESS;
252 }
253
254 /* dhcpctl_set_value
255
256    Sets a value on an object referred to by a dhcpctl_handle.
257    The opposite of dhcpctl_get_value.   Does not update the
258    server - just sets the value on the handle. */
259
260 dhcpctl_status dhcpctl_set_value (dhcpctl_handle h, dhcpctl_data_string value,
261                                   const char *value_name)
262 {
263         isc_result_t status;
264         omapi_typed_data_t *tv = (omapi_typed_data_t *)0;
265         omapi_data_string_t *name = (omapi_data_string_t *)0;
266         int len;
267
268         status = omapi_data_string_new (&name, strlen (value_name), MDL);
269         if (status != ISC_R_SUCCESS)
270                 return status;
271         memcpy (name -> value, value_name, strlen (value_name));
272
273         status = omapi_typed_data_new (MDL, &tv, omapi_datatype_data,
274                                        value -> len);
275         if (status != ISC_R_SUCCESS) {
276                 omapi_data_string_dereference (&name, MDL);
277                 return status;
278         }
279         memcpy (tv -> u.buffer.value, value -> value, value -> len);
280
281         status = omapi_set_value (h, (omapi_object_t *)0, name, tv);
282         omapi_data_string_dereference (&name, MDL);
283         omapi_typed_data_dereference (&tv, MDL);
284         return status;
285 }
286
287 /* dhcpctl_set_string_value
288
289    Sets a NUL-terminated ASCII value on an object referred to by
290    a dhcpctl_handle.   like dhcpctl_set_value, but saves the
291    trouble of creating a data_string for a NUL-terminated string.
292    Does not update the server - just sets the value on the handle. */
293
294 dhcpctl_status dhcpctl_set_string_value (dhcpctl_handle h, const char *value,
295                                          const char *value_name)
296 {
297         isc_result_t status;
298         omapi_typed_data_t *tv = (omapi_typed_data_t *)0;
299         omapi_data_string_t *name = (omapi_data_string_t *)0;
300         int len;
301
302         status = omapi_data_string_new (&name, strlen (value_name), MDL);
303         if (status != ISC_R_SUCCESS)
304                 return status;
305         memcpy (name -> value, value_name, strlen (value_name));
306
307         status = omapi_typed_data_new (MDL, &tv, omapi_datatype_string, value);
308         if (status != ISC_R_SUCCESS) {
309                 omapi_data_string_dereference (&name, MDL);
310                 return status;
311         }
312
313         status = omapi_set_value (h, (omapi_object_t *)0, name, tv);
314         omapi_data_string_dereference (&name, MDL);
315         omapi_typed_data_dereference (&tv, MDL);
316         return status;
317 }
318
319 /* dhcpctl_set_buffer_value
320
321    Sets a value on an object referred to by a dhcpctl_handle.  like
322    dhcpctl_set_value, but saves the trouble of creating a data_string
323    for string for which we have a buffer and length.  Does not update
324    the server - just sets the value on the handle. */
325
326 dhcpctl_status dhcpctl_set_data_value (dhcpctl_handle h,
327                                        const char *value, unsigned len,
328                                        const char *value_name)
329 {
330         isc_result_t status;
331         omapi_typed_data_t *tv = (omapi_typed_data_t *)0;
332         omapi_data_string_t *name = (omapi_data_string_t *)0;
333         unsigned ll;
334
335         ll = strlen (value_name);
336         status = omapi_data_string_new (&name, ll, MDL);
337         if (status != ISC_R_SUCCESS)
338                 return status;
339         memcpy (name -> value, value_name, ll);
340
341         status = omapi_typed_data_new (MDL, &tv,
342                                        omapi_datatype_data, len, value);
343         if (status != ISC_R_SUCCESS) {
344                 omapi_data_string_dereference (&name, MDL);
345                 return status;
346         }
347         memcpy (tv -> u.buffer.value, value, len);
348
349         status = omapi_set_value (h, (omapi_object_t *)0, name, tv);
350         omapi_data_string_dereference (&name, MDL);
351         omapi_typed_data_dereference (&tv, MDL);
352         return status;
353 }
354
355 /* dhcpctl_set_null_value
356
357    Sets a null value on an object referred to by a dhcpctl_handle. */
358
359 dhcpctl_status dhcpctl_set_null_value (dhcpctl_handle h,
360                                        const char *value_name)
361 {
362         isc_result_t status;
363         omapi_data_string_t *name = (omapi_data_string_t *)0;
364         unsigned ll;
365
366         ll = strlen (value_name);
367         status = omapi_data_string_new (&name, ll, MDL);
368         if (status != ISC_R_SUCCESS)
369                 return status;
370         memcpy (name -> value, value_name, ll);
371
372         status = omapi_set_value (h, (omapi_object_t *)0, name,
373                                   (omapi_typed_data_t *)0);
374         omapi_data_string_dereference (&name, MDL);
375         return status;
376 }
377
378 /* dhcpctl_set_boolean_value
379
380    Sets a boolean value on an object - like dhcpctl_set_value,
381    only more convenient for booleans. */
382
383 dhcpctl_status dhcpctl_set_boolean_value (dhcpctl_handle h, int value,
384                                           const char *value_name)
385 {
386         isc_result_t status;
387         omapi_typed_data_t *tv = (omapi_typed_data_t *)0;
388         omapi_data_string_t *name = (omapi_data_string_t *)0;
389         int len;
390
391         status = omapi_data_string_new (&name, strlen (value_name), MDL);
392         if (status != ISC_R_SUCCESS)
393                 return status;
394         memcpy (name -> value, value_name, strlen (value_name));
395
396         status = omapi_typed_data_new (MDL, &tv, omapi_datatype_int, value);
397         if (status != ISC_R_SUCCESS) {
398                 omapi_data_string_dereference (&name, MDL);
399                 return status;
400         }
401
402         status = omapi_set_value (h, (omapi_object_t *)0, name, tv);
403         omapi_data_string_dereference (&name, MDL);
404         omapi_typed_data_dereference (&tv, MDL);
405         return status;
406 }
407
408 /* dhcpctl_set_int_value
409
410    Sets a boolean value on an object - like dhcpctl_set_value,
411    only more convenient for booleans. */
412
413 dhcpctl_status dhcpctl_set_int_value (dhcpctl_handle h, int value,
414                                       const char *value_name)
415 {
416         isc_result_t status;
417         omapi_typed_data_t *tv = (omapi_typed_data_t *)0;
418         omapi_data_string_t *name = (omapi_data_string_t *)0;
419         int len;
420
421         status = omapi_data_string_new (&name, strlen (value_name), MDL);
422         if (status != ISC_R_SUCCESS)
423                 return status;
424         memcpy (name -> value, value_name, strlen (value_name));
425
426         status = omapi_typed_data_new (MDL, &tv, omapi_datatype_int, value);
427         if (status != ISC_R_SUCCESS) {
428                 omapi_data_string_dereference (&name, MDL);
429                 return status;
430         }
431
432         status = omapi_set_value (h, (omapi_object_t *)0, name, tv);
433         omapi_data_string_dereference (&name, MDL);
434         omapi_typed_data_dereference (&tv, MDL);
435         return status;
436 }
437
438 /* dhcpctl_object_update
439
440    Queues an update on the object referenced by the handle (there
441    can't be any other work in progress on the handle).   An
442    update means local parameters will be sent to the server. */
443
444 dhcpctl_status dhcpctl_object_update (dhcpctl_handle connection,
445                                       dhcpctl_handle h)
446 {
447         isc_result_t status;
448         omapi_object_t *message = (omapi_object_t *)0;
449         dhcpctl_remote_object_t *ro;
450
451         if (h -> type != dhcpctl_remote_type)
452                 return ISC_R_INVALIDARG;
453         ro = (dhcpctl_remote_object_t *)h;
454
455         status = omapi_message_new (&message, MDL);
456         if (status != ISC_R_SUCCESS) {
457                 omapi_object_dereference (&message, MDL);
458                 return status;
459         }
460         status = omapi_set_int_value (message, (omapi_object_t *)0,
461                                       "op", OMAPI_OP_UPDATE);
462         if (status != ISC_R_SUCCESS) {
463                 omapi_object_dereference (&message, MDL);
464                 return status;
465         }
466
467         status = omapi_set_object_value (message, (omapi_object_t *)0,
468                                          "object", h);
469         if (status != ISC_R_SUCCESS) {
470                 omapi_object_dereference (&message, MDL);
471                 return status;
472         }
473
474         status = omapi_set_int_value (message, (omapi_object_t *)0, "handle",
475                                       (int)(ro -> remote_handle));
476         if (status != ISC_R_SUCCESS) {
477                 omapi_object_dereference (&message, MDL);
478                 return status;
479         }
480
481         omapi_message_register (message);
482         status = omapi_protocol_send_message (connection -> outer,
483                                               (omapi_object_t *)0,
484                                               message, (omapi_object_t *)0);
485         omapi_object_dereference (&message, MDL);
486         return status;
487 }
488
489 /* Requests a refresh on the object referenced by the handle (there
490    can't be any other work in progress on the handle).   A
491    refresh means local parameters are updated from the server. */
492
493 dhcpctl_status dhcpctl_object_refresh (dhcpctl_handle connection,
494                                        dhcpctl_handle h)
495 {
496         isc_result_t status;
497         omapi_object_t *message = (omapi_object_t *)0;
498         dhcpctl_remote_object_t *ro;
499
500         if (h -> type != dhcpctl_remote_type)
501                 return ISC_R_INVALIDARG;
502         ro = (dhcpctl_remote_object_t *)h;
503
504         status = omapi_message_new (&message, MDL);
505         if (status != ISC_R_SUCCESS) {
506                 omapi_object_dereference (&message, MDL);
507                 return status;
508         }
509         status = omapi_set_int_value (message, (omapi_object_t *)0,
510                                       "op", OMAPI_OP_REFRESH);
511         if (status != ISC_R_SUCCESS) {
512                 omapi_object_dereference (&message, MDL);
513                 return status;
514         }
515         status = omapi_set_int_value (message, (omapi_object_t *)0,
516                                       "handle", (int)(ro -> remote_handle));
517         if (status != ISC_R_SUCCESS) {
518                 omapi_object_dereference (&message, MDL);
519                 return status;
520         }
521
522         omapi_message_register (message);
523         status = omapi_protocol_send_message (connection -> outer,
524                                               (omapi_object_t *)0,
525                                               message, (omapi_object_t *)0);
526
527         /* We don't want to send the contents of the object down the
528            wire, but we do need to reference it so that we know what
529            to do with the update. */
530         status = omapi_set_object_value (message, (omapi_object_t *)0,
531                                          "object", h);
532         if (status != ISC_R_SUCCESS) {
533                 omapi_object_dereference (&message, MDL);
534                 return status;
535         }
536
537         omapi_object_dereference (&message, MDL);
538         return status;
539 }
540
541 /* Requests the removal of the object referenced by the handle (there
542    can't be any other work in progress on the handle).   A
543    removal means that all searchable references to the object on the
544    server are deleted. */
545
546 dhcpctl_status dhcpctl_object_remove (dhcpctl_handle connection,
547                                       dhcpctl_handle h)
548 {
549         isc_result_t status;
550         omapi_object_t *message = (omapi_object_t *)0;
551         dhcpctl_remote_object_t *ro;
552
553         if (h -> type != dhcpctl_remote_type)
554                 return ISC_R_INVALIDARG;
555         ro = (dhcpctl_remote_object_t *)h;
556
557         status = omapi_message_new (&message, MDL);
558         if (status != ISC_R_SUCCESS) {
559                 omapi_object_dereference (&message, MDL);
560                 return status;
561         }
562         status = omapi_set_int_value (message, (omapi_object_t *)0,
563                                       "op", OMAPI_OP_DELETE);
564         if (status != ISC_R_SUCCESS) {
565                 omapi_object_dereference (&message, MDL);
566                 return status;
567         }
568
569         status = omapi_set_int_value (message, (omapi_object_t *)0, "handle",
570                                       (int)(ro -> remote_handle));
571         if (status != ISC_R_SUCCESS) {
572                 omapi_object_dereference (&message, MDL);
573                 return status;
574         }
575
576         status = omapi_set_object_value (message, (omapi_object_t *)0,
577                                          "notify-object", h);
578         if (status != ISC_R_SUCCESS) {
579                 omapi_object_dereference (&message, MDL);
580                 return status;
581         }
582
583         omapi_message_register (message);
584         status = omapi_protocol_send_message (connection -> outer,
585                                               (omapi_object_t *)0,
586                                               message, (omapi_object_t *)0);
587         omapi_object_dereference (&message, MDL);
588         return status;
589 }
590
591 isc_result_t dhcpctl_data_string_dereference (dhcpctl_data_string *vp,
592                                               const char *file, int line)
593 {
594         return omapi_data_string_dereference (vp, file, line);
595 }