← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/isc-dhcp/oneiric-security

« back to all changes in this revision

Viewing changes to dhcpctl/remote.c

  • Committer: Bazaar Package Importer
  • Author(s): Andrew Pollock
  • Date: 2009-09-02 22:34:25 UTC
  • Revision ID: james.westby@ubuntu.com-20090902223425-nypo7bkftxffq41m
Tags: upstream-4.1.0
Import upstream version 4.1.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
dhcpctl/remote.c
 
1
/* remote.c
 
2
 
 
3
   The dhcpctl remote object. */
 
4
 
 
5
/*
 
6
 * Copyright (c) 2004,2007 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 "dhcpd.h"
 
36
#include <omapip/omapip_p.h>
 
37
#include "dhcpctl.h"
 
38
 
 
39
/* dhcpctl_new_authenticator
 
40
 
 
41
   synchronous - creates an authenticator object.
 
42
   returns nonzero status code if the object couldn't be created
 
43
   stores handle to authenticator through h if successful, and returns zero.
 
44
   name is the authenticator name (NUL-terminated string).
 
45
   algorithm is the NUL-terminated string name of the algorithm to use
 
46
   (currently, only "hmac-md5" is supported).
 
47
   secret and secret_len is the key secret. */
 
48
 
 
49
dhcpctl_status dhcpctl_new_authenticator (dhcpctl_handle *h,
 
50
                                          const char *name,
 
51
                                          const char *algorithm,
 
52
                                          const unsigned char *secret,
 
53
                                          unsigned secret_len)
 
54
{
 
55
        struct auth_key *key = (struct auth_key *)0;
 
56
        isc_result_t status;
 
57
 
 
58
        status = omapi_auth_key_new (&key, MDL);
 
59
        if (status != ISC_R_SUCCESS)
 
60
                return status;
 
61
 
 
62
        key -> name = dmalloc (strlen (name) + 1, MDL);
 
63
        if (!key -> name) {
 
64
                omapi_auth_key_dereference (&key, MDL);
 
65
                return ISC_R_NOMEMORY;
 
66
        }
 
67
        strcpy (key -> name, name);
 
68
 
 
69
        /* If the algorithm name isn't an FQDN, tack on the
 
70
           .SIG-ALG.REG.NET. domain. */
 
71
        if (strchr (algorithm, '.') == 0) {
 
72
                static char add[] = ".SIG-ALG.REG.INT.";
 
73
                key -> algorithm = dmalloc (strlen (algorithm) +
 
74
                                            sizeof (add), MDL);
 
75
                if (!key -> algorithm) {
 
76
                        omapi_auth_key_dereference (&key, MDL);
 
77
                        return ISC_R_NOMEMORY;
 
78
                }
 
79
                strcpy (key -> algorithm, algorithm);
 
80
                strcat (key -> algorithm, add);
 
81
        } else {
 
82
                key -> algorithm = dmalloc (strlen (algorithm) + 1, MDL);
 
83
                if (!key -> algorithm) {
 
84
                        omapi_auth_key_dereference (&key, MDL);
 
85
                        return ISC_R_NOMEMORY;
 
86
                }
 
87
                strcpy (key -> algorithm, algorithm);
 
88
        }
 
89
 
 
90
        status = omapi_data_string_new (&key -> key, secret_len, MDL);
 
91
        if (status != ISC_R_SUCCESS) {
 
92
                omapi_auth_key_dereference (&key, MDL);
 
93
                return status;
 
94
        }
 
95
        memcpy (key -> key -> value, secret, secret_len);
 
96
        key -> key -> len = secret_len;
 
97
 
 
98
        *h = (dhcpctl_handle) key;
 
99
        return ISC_R_SUCCESS;
 
100
}
 
101
 
 
102
 
 
103
/* dhcpctl_new_object
 
104
 
 
105
   synchronous - creates a local handle for a host entry.
 
106
   returns nonzero status code if the local host entry couldn't
 
107
   be created
 
108
   stores handle to host through h if successful, and returns zero.
 
109
   object_type is a pointer to a NUL-terminated string containing
 
110
   the ascii name of the type of object being accessed - e.g., "host" */
 
111
 
 
112
dhcpctl_status dhcpctl_new_object (dhcpctl_handle *h,
 
113
                                   dhcpctl_handle connection,
 
114
                                   const char *object_type)
 
115
{
 
116
        dhcpctl_remote_object_t *m;
 
117
        omapi_object_t *g;
 
118
        isc_result_t status;
 
119
 
 
120
        m = (dhcpctl_remote_object_t *)0;
 
121
        status = omapi_object_allocate((omapi_object_t **)&m,
 
122
                                       dhcpctl_remote_type, 0, MDL);
 
123
        if (status != ISC_R_SUCCESS)
 
124
                return status;
 
125
 
 
126
        g = (omapi_object_t *)0;
 
127
        status = omapi_generic_new (&g, MDL);
 
128
        if (status != ISC_R_SUCCESS) {
 
129
                dfree (m, MDL);
 
130
                return status;
 
131
        }
 
132
        status = omapi_object_reference (&m -> inner, g, MDL);
 
133
        if (status != ISC_R_SUCCESS) {
 
134
                omapi_object_dereference ((omapi_object_t **)&m, MDL);
 
135
                omapi_object_dereference (&g, MDL);
 
136
                return status;
 
137
        }
 
138
        status = omapi_object_reference (&g -> outer,
 
139
                                         (omapi_object_t *)m, MDL);
 
140
 
 
141
        if (status != ISC_R_SUCCESS) {
 
142
                omapi_object_dereference ((omapi_object_t **)&m, MDL);
 
143
                omapi_object_dereference (&g, MDL);
 
144
                return status;
 
145
        }
 
146
 
 
147
        status = omapi_typed_data_new (MDL, &m -> rtype,
 
148
                                       omapi_datatype_string,
 
149
                                       object_type);
 
150
        if (status != ISC_R_SUCCESS) {
 
151
                omapi_object_dereference ((omapi_object_t **)&m, MDL);
 
152
                omapi_object_dereference (&g, MDL);
 
153
                return status;
 
154
        }
 
155
 
 
156
        status = omapi_object_reference (h, (omapi_object_t *)m, MDL);
 
157
        omapi_object_dereference ((omapi_object_t **)&m, MDL);
 
158
        omapi_object_dereference (&g, MDL);
 
159
        if (status != ISC_R_SUCCESS)
 
160
                return status;
 
161
 
 
162
        return status;
 
163
}
 
164
 
 
165
/* asynchronous - just queues the request
 
166
   returns nonzero status code if open couldn't be queued
 
167
   returns zero if open was queued
 
168
   h is a handle to an object created by dhcpctl_new_object
 
169
   connection is a connection to a DHCP server
 
170
   flags include:
 
171
     DHCPCTL_CREATE - if the object doesn't exist, create it
 
172
     DHCPCTL_UPDATE - update the object on the server using the
 
173
                      attached parameters 
 
174
     DHCPCTL_EXCL - error if the object exists and DHCPCTL_CREATE
 
175
                      was also specified */
 
176
 
 
177
dhcpctl_status dhcpctl_open_object (dhcpctl_handle h,
 
178
                                    dhcpctl_handle connection,
 
179
                                    int flags)
 
180
{
 
181
        isc_result_t status;
 
182
        omapi_object_t *message = (omapi_object_t *)0;
 
183
        dhcpctl_remote_object_t *remote;
 
184
 
 
185
        if (h -> type != dhcpctl_remote_type)
 
186
                return ISC_R_INVALIDARG;
 
187
        remote = (dhcpctl_remote_object_t *)h;
 
188
 
 
189
        status = omapi_message_new (&message, MDL);
 
190
        if (status != ISC_R_SUCCESS)
 
191
                return status;
 
192
        status = omapi_set_int_value (message, (omapi_object_t *)0,
 
193
                                      "op", OMAPI_OP_OPEN);
 
194
        if (status != ISC_R_SUCCESS) {
 
195
                omapi_object_dereference (&message, MDL);
 
196
                return status;
 
197
        }
 
198
        status = omapi_set_object_value (message, (omapi_object_t *)0,
 
199
                                         "object", h);
 
200
        if (status != ISC_R_SUCCESS) {
 
201
                omapi_object_dereference (&message, MDL);
 
202
                return status;
 
203
        }
 
204
        if (flags & DHCPCTL_CREATE) {
 
205
                status = omapi_set_boolean_value (message, (omapi_object_t *)0,
 
206
                                                  "create", 1);
 
207
                if (status != ISC_R_SUCCESS) {
 
208
                        omapi_object_dereference (&message, MDL);
 
209
                        return status;
 
210
                }
 
211
        }
 
212
        if (flags & DHCPCTL_UPDATE) {
 
213
                status = omapi_set_boolean_value (message, (omapi_object_t *)0,
 
214
                                                  "update", 1);
 
215
                if (status != ISC_R_SUCCESS) {
 
216
                        omapi_object_dereference (&message, MDL);
 
217
                        return status;
 
218
                }
 
219
        }
 
220
        if (flags & DHCPCTL_EXCL) {
 
221
                status = omapi_set_boolean_value (message, (omapi_object_t *)0,
 
222
                                                  "exclusive", 1);
 
223
                if (status != ISC_R_SUCCESS) {
 
224
                        omapi_object_dereference (&message, MDL);
 
225
                        return status;
 
226
                }
 
227
        }
 
228
 
 
229
        if (remote -> rtype) {
 
230
                status = omapi_set_value_str (message, (omapi_object_t *)0,
 
231
                                              "type", remote -> rtype);
 
232
                if (status != ISC_R_SUCCESS) {
 
233
                        omapi_object_dereference (&message, MDL);
 
234
                        return status;
 
235
                }
 
236
        }
 
237
 
 
238
        status = omapi_message_register (message);
 
239
        if (status != ISC_R_SUCCESS) {
 
240
                omapi_object_dereference (&message, MDL);
 
241
                return status;
 
242
        }
 
243
 
 
244
        status = omapi_protocol_send_message (connection -> outer,
 
245
                                            (omapi_object_t *)0,
 
246
                                            message, (omapi_object_t *)0);
 
247
 
 
248
        if (status != ISC_R_SUCCESS)
 
249
                omapi_message_unregister (message);
 
250
 
 
251
        omapi_object_dereference (&message, MDL);
 
252
        return status;
 
253
}
 
254
 
 
255
/* Callback methods (not meant to be called directly) */
 
256
 
 
257
isc_result_t dhcpctl_remote_set_value (omapi_object_t *h,
 
258
                                       omapi_object_t *id,
 
259
                                       omapi_data_string_t *name,
 
260
                                       omapi_typed_data_t *value)
 
261
{
 
262
        dhcpctl_remote_object_t *ro;
 
263
        unsigned long rh;
 
264
        isc_result_t status;
 
265
 
 
266
        if (h -> type != dhcpctl_remote_type)
 
267
                return ISC_R_INVALIDARG;
 
268
        ro = (dhcpctl_remote_object_t *)h;
 
269
 
 
270
        if (!omapi_ds_strcmp (name, "remote-handle")) {
 
271
                status = omapi_get_int_value (&rh, value);
 
272
                if (status == ISC_R_SUCCESS)
 
273
                        ro -> remote_handle = rh;
 
274
                return status;
 
275
        }
 
276
 
 
277
        if (h -> inner && h -> inner -> type -> set_value)
 
278
                return (*(h -> inner -> type -> set_value))
 
279
                        (h -> inner, id, name, value);
 
280
        return ISC_R_NOTFOUND;
 
281
}
 
282
 
 
283
isc_result_t dhcpctl_remote_get_value (omapi_object_t *h,
 
284
                                       omapi_object_t *id,
 
285
                                       omapi_data_string_t *name,
 
286
                                       omapi_value_t **value)
 
287
{
 
288
        if (h -> type != dhcpctl_remote_type)
 
289
                return ISC_R_INVALIDARG;
 
290
        
 
291
        if (h -> inner && h -> inner -> type -> get_value)
 
292
                return (*(h -> inner -> type -> get_value))
 
293
                        (h -> inner, id, name, value);
 
294
        return ISC_R_NOTFOUND;
 
295
}
 
296
 
 
297
isc_result_t dhcpctl_remote_signal_handler (omapi_object_t *o,
 
298
                                            const char *name, va_list ap)
 
299
{
 
300
        dhcpctl_remote_object_t *p;
 
301
        omapi_typed_data_t *tv;
 
302
 
 
303
        if (o -> type != dhcpctl_remote_type)
 
304
                return ISC_R_INVALIDARG;
 
305
        p = (dhcpctl_remote_object_t *)o;
 
306
 
 
307
        if (!strcmp (name, "updated")) {
 
308
                p -> waitstatus = ISC_R_SUCCESS;
 
309
                if (o -> inner -> type == omapi_type_generic)
 
310
                        omapi_generic_clear_flags (o -> inner);
 
311
                return omapi_signal_in (o -> inner, "ready");
 
312
        }
 
313
        if (!strcmp (name, "status")) {
 
314
                p -> waitstatus = va_arg (ap, isc_result_t);
 
315
                if (p -> message)
 
316
                        omapi_typed_data_dereference (&p -> message, MDL);
 
317
                tv = va_arg (ap, omapi_typed_data_t *);
 
318
                if (tv)
 
319
                        omapi_typed_data_reference (&p -> message, tv, MDL);
 
320
                return omapi_signal_in (o -> inner, "ready");
 
321
        }
 
322
 
 
323
        if (p -> inner && p -> inner -> type -> signal_handler)
 
324
                return (*(p -> inner -> type -> signal_handler))
 
325
                        (p -> inner, name, ap);
 
326
 
 
327
        return ISC_R_SUCCESS;
 
328
}
 
329
 
 
330
isc_result_t dhcpctl_remote_destroy (omapi_object_t *h,
 
331
                                     const char *file, int line)
 
332
{
 
333
        dhcpctl_remote_object_t *p;
 
334
        if (h -> type != dhcpctl_remote_type)
 
335
                return ISC_R_INVALIDARG;
 
336
        p = (dhcpctl_remote_object_t *)h;
 
337
        if (p -> handle)
 
338
                omapi_object_dereference ((omapi_object_t **)&p -> handle,
 
339
                                          file, line);
 
340
        if (p -> rtype)
 
341
                omapi_typed_data_dereference ((omapi_typed_data_t **)&p->rtype,
 
342
                                              file, line);
 
343
        return ISC_R_SUCCESS;
 
344
}
 
345
 
 
346
/* Write all the published values associated with the object through the
 
347
   specified connection. */
 
348
 
 
349
isc_result_t dhcpctl_remote_stuff_values (omapi_object_t *c,
 
350
                                          omapi_object_t *id,
 
351
                                          omapi_object_t *p)
 
352
{
 
353
        if (p -> type != dhcpctl_remote_type)
 
354
                return ISC_R_INVALIDARG;
 
355
 
 
356
        if (p -> inner && p -> inner -> type -> stuff_values)
 
357
                return (*(p -> inner -> type -> stuff_values)) (c, id,
 
358
                                                                p -> inner);
 
359
        return ISC_R_SUCCESS;
 
360
}
 
361