?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Flesh out BUF_CMD_FLUSH support.
[dragonfly.git] / contrib / dhcp-3.0 / omapip / message.c
blob53fac626c684ec46ba46639d3da9ec3951c4e682
1 /* message.c
2
3 Subroutines for dealing with message 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 #include <omapip/omapip_p.h>
36
37 OMAPI_OBJECT_ALLOC (omapi_message,
38 omapi_message_object_t, omapi_type_message)
39
40 omapi_message_object_t *omapi_registered_messages;
41
42 isc_result_t omapi_message_new (omapi_object_t **o, const char *file, int line)
43 {
44 omapi_message_object_t *m;
45 omapi_object_t *g;
46 isc_result_t status;
47
48 m = (omapi_message_object_t *)0;
49 status = omapi_message_allocate (&m, file, line);
50 if (status != ISC_R_SUCCESS)
51 return status;
52
53 g = (omapi_object_t *)0;
54 status = omapi_generic_new (&g, file, line);
55 if (status != ISC_R_SUCCESS) {
56 dfree (m, file, line);
57 return status;
58 }
59 status = omapi_object_reference (&m -> inner, g, file, line);
60 if (status != ISC_R_SUCCESS) {
61 omapi_object_dereference ((omapi_object_t **)&m, file, line);
62 omapi_object_dereference (&g, file, line);
63 return status;
64 }
65 status = omapi_object_reference (&g -> outer,
66 (omapi_object_t *)m, file, line);
67
68 if (status != ISC_R_SUCCESS) {
69 omapi_object_dereference ((omapi_object_t **)&m, file, line);
70 omapi_object_dereference (&g, file, line);
71 return status;
72 }
73
74 status = omapi_object_reference (o, (omapi_object_t *)m, file, line);
75 omapi_message_dereference (&m, file, line);
76 omapi_object_dereference (&g, file, line);
77 if (status != ISC_R_SUCCESS)
78 return status;
79
80 return status;
81 }
82
83 isc_result_t omapi_message_set_value (omapi_object_t *h,
84 omapi_object_t *id,
85 omapi_data_string_t *name,
86 omapi_typed_data_t *value)
87 {
88 omapi_message_object_t *m;
89 isc_result_t status;
90
91 if (h -> type != omapi_type_message)
92 return ISC_R_INVALIDARG;
93 m = (omapi_message_object_t *)h;
94
95 /* Can't set authlen. */
96
97 /* Can set authenticator, but the value must be typed data. */
98 if (!omapi_ds_strcmp (name, "authenticator")) {
99 if (m -> authenticator)
100 omapi_typed_data_dereference (&m -> authenticator,
101 MDL);
102 omapi_typed_data_reference (&m -> authenticator, value, MDL);
103 return ISC_R_SUCCESS;
104
105 } else if (!omapi_ds_strcmp (name, "object")) {
106 if (value -> type != omapi_datatype_object)
107 return ISC_R_INVALIDARG;
108 if (m -> object)
109 omapi_object_dereference (&m -> object, MDL);
110 omapi_object_reference (&m -> object, value -> u.object, MDL);
111 return ISC_R_SUCCESS;
112
113 } else if (!omapi_ds_strcmp (name, "notify-object")) {
114 if (value -> type != omapi_datatype_object)
115 return ISC_R_INVALIDARG;
116 if (m -> notify_object)
117 omapi_object_dereference (&m -> notify_object, MDL);
118 omapi_object_reference (&m -> notify_object,
119 value -> u.object, MDL);
120 return ISC_R_SUCCESS;
121
122 /* Can set authid, but it has to be an integer. */
123 } else if (!omapi_ds_strcmp (name, "authid")) {
124 if (value -> type != omapi_datatype_int)
125 return ISC_R_INVALIDARG;
126 m -> authid = value -> u.integer;
127 return ISC_R_SUCCESS;
128
129 /* Can set op, but it has to be an integer. */
130 } else if (!omapi_ds_strcmp (name, "op")) {
131 if (value -> type != omapi_datatype_int)
132 return ISC_R_INVALIDARG;
133 m -> op = value -> u.integer;
134 return ISC_R_SUCCESS;
135
136 /* Handle also has to be an integer. */
137 } else if (!omapi_ds_strcmp (name, "handle")) {
138 if (value -> type != omapi_datatype_int)
139 return ISC_R_INVALIDARG;
140 m -> h = value -> u.integer;
141 return ISC_R_SUCCESS;
142
143 /* Transaction ID has to be an integer. */
144 } else if (!omapi_ds_strcmp (name, "id")) {
145 if (value -> type != omapi_datatype_int)
146 return ISC_R_INVALIDARG;
147 m -> id = value -> u.integer;
148 return ISC_R_SUCCESS;
149
150 /* Remote transaction ID has to be an integer. */
151 } else if (!omapi_ds_strcmp (name, "rid")) {
152 if (value -> type != omapi_datatype_int)
153 return ISC_R_INVALIDARG;
154 m -> rid = value -> u.integer;
155 return ISC_R_SUCCESS;
156 }
157
158 /* Try to find some inner object that can take the value. */
159 if (h -> inner && h -> inner -> type -> set_value) {
160 status = ((*(h -> inner -> type -> set_value))
161 (h -> inner, id, name, value));
162 if (status == ISC_R_SUCCESS)
163 return status;
164 }
165
166 return ISC_R_NOTFOUND;
167 }
168
169 isc_result_t omapi_message_get_value (omapi_object_t *h,
170 omapi_object_t *id,
171 omapi_data_string_t *name,
172 omapi_value_t **value)
173 {
174 omapi_message_object_t *m;
175 if (h -> type != omapi_type_message)
176 return ISC_R_INVALIDARG;
177 m = (omapi_message_object_t *)h;
178
179 /* Look for values that are in the message data structure. */
180 if (!omapi_ds_strcmp (name, "authlen"))
181 return omapi_make_int_value (value, name, (int)m -> authlen,
182 MDL);
183 else if (!omapi_ds_strcmp (name, "authenticator")) {
184 if (m -> authenticator)
185 return omapi_make_value (value, name,
186 m -> authenticator, MDL);
187 else
188 return ISC_R_NOTFOUND;
189 } else if (!omapi_ds_strcmp (name, "authid")) {
190 return omapi_make_int_value (value,
191 name, (int)m -> authid, MDL);
192 } else if (!omapi_ds_strcmp (name, "op")) {
193 return omapi_make_int_value (value, name, (int)m -> op, MDL);
194 } else if (!omapi_ds_strcmp (name, "handle")) {
195 return omapi_make_int_value (value, name, (int)m -> h, MDL);
196 } else if (!omapi_ds_strcmp (name, "id")) {
197 return omapi_make_int_value (value, name, (int)m -> id, MDL);
198 } else if (!omapi_ds_strcmp (name, "rid")) {
199 return omapi_make_int_value (value, name, (int)m -> rid, MDL);
200 }
201
202 /* See if there's an inner object that has the value. */
203 if (h -> inner && h -> inner -> type -> get_value)
204 return (*(h -> inner -> type -> get_value))
205 (h -> inner, id, name, value);
206 return ISC_R_NOTFOUND;
207 }
208
209 isc_result_t omapi_message_destroy (omapi_object_t *h,
210 const char *file, int line)
211 {
212 int i;
213
214 omapi_message_object_t *m;
215 if (h -> type != omapi_type_message)
216 return ISC_R_INVALIDARG;
217 m = (omapi_message_object_t *)h;
218 if (m -> authenticator) {
219 omapi_typed_data_dereference (&m -> authenticator, file, line);
220 }
221 if (!m -> prev && omapi_registered_messages != m)
222 omapi_message_unregister (h);
223 if (m -> id_object)
224 omapi_object_dereference (&m -> id_object, file, line);
225 if (m -> object)
226 omapi_object_dereference (&m -> object, file, line);
227 if (m -> notify_object)
228 omapi_object_dereference (&m -> notify_object, file, line);
229 if (m -> protocol_object)
230 omapi_protocol_dereference (&m -> protocol_object, file, line);
231 return ISC_R_SUCCESS;
232 }
233
234 isc_result_t omapi_message_signal_handler (omapi_object_t *h,
235 const char *name, va_list ap)
236 {
237 omapi_message_object_t *m;
238 if (h -> type != omapi_type_message)
239 return ISC_R_INVALIDARG;
240 m = (omapi_message_object_t *)h;
241
242 if (!strcmp (name, "status")) {
243 if (m -> notify_object &&
244 m -> notify_object -> type -> signal_handler)
245 return ((m -> notify_object -> type -> signal_handler))
246 (m -> notify_object, name, ap);
247 else if (m -> object && m -> object -> type -> signal_handler)
248 return ((m -> object -> type -> signal_handler))
249 (m -> object, name, ap);
250 }
251 if (h -> inner && h -> inner -> type -> signal_handler)
252 return (*(h -> inner -> type -> signal_handler)) (h -> inner,
253 name, ap);
254 return ISC_R_NOTFOUND;
255 }
256
257 /* Write all the published values associated with the object through the
258 specified connection. */
259
260 isc_result_t omapi_message_stuff_values (omapi_object_t *c,
261 omapi_object_t *id,
262 omapi_object_t *m)
263 {
264 int i;
265
266 if (m -> type != omapi_type_message)
267 return ISC_R_INVALIDARG;
268
269 if (m -> inner && m -> inner -> type -> stuff_values)
270 return (*(m -> inner -> type -> stuff_values)) (c, id,
271 m -> inner);
272 return ISC_R_SUCCESS;
273 }
274
275 isc_result_t omapi_message_register (omapi_object_t *mo)
276 {
277 omapi_message_object_t *m;
278
279 if (mo -> type != omapi_type_message)
280 return ISC_R_INVALIDARG;
281 m = (omapi_message_object_t *)mo;
282
283 /* Already registered? */
284 if (m -> prev || m -> next || omapi_registered_messages == m)
285 return ISC_R_INVALIDARG;
286
287 if (omapi_registered_messages) {
288 omapi_object_reference
289 ((omapi_object_t **)&m -> next,
290 (omapi_object_t *)omapi_registered_messages, MDL);
291 omapi_object_reference
292 ((omapi_object_t **)&omapi_registered_messages -> prev,
293 (omapi_object_t *)m, MDL);
294 omapi_object_dereference
295 ((omapi_object_t **)&omapi_registered_messages, MDL);
296 }
297 omapi_object_reference
298 ((omapi_object_t **)&omapi_registered_messages,
299 (omapi_object_t *)m, MDL);
300 return ISC_R_SUCCESS;;
301 }
302
303 isc_result_t omapi_message_unregister (omapi_object_t *mo)
304 {
305 omapi_message_object_t *m;
306 omapi_message_object_t *n;
307
308 if (mo -> type != omapi_type_message)
309 return ISC_R_INVALIDARG;
310 m = (omapi_message_object_t *)mo;
311
312 /* Not registered? */
313 if (!m -> prev && omapi_registered_messages != m)
314 return ISC_R_INVALIDARG;
315
316 n = (omapi_message_object_t *)0;
317 if (m -> next) {
318 omapi_object_reference ((omapi_object_t **)&n,
319 (omapi_object_t *)m -> next, MDL);
320 omapi_object_dereference ((omapi_object_t **)&m -> next, MDL);
321 omapi_object_dereference ((omapi_object_t **)&n -> prev, MDL);
322 }
323 if (m -> prev) {
324 omapi_message_object_t *tmp = (omapi_message_object_t *)0;
325 omapi_object_reference ((omapi_object_t **)&tmp,
326 (omapi_object_t *)m -> prev, MDL);
327 omapi_object_dereference ((omapi_object_t **)&m -> prev, MDL);
328 if (tmp -> next)
329 omapi_object_dereference
330 ((omapi_object_t **)&tmp -> next, MDL);
331 if (n)
332 omapi_object_reference
333 ((omapi_object_t **)&tmp -> next,
334 (omapi_object_t *)n, MDL);
335 omapi_object_dereference ((omapi_object_t **)&tmp, MDL);
336 } else {
337 omapi_object_dereference
338 ((omapi_object_t **)&omapi_registered_messages, MDL);
339 if (n)
340 omapi_object_reference
341 ((omapi_object_t **)&omapi_registered_messages,
342 (omapi_object_t *)n, MDL);
343 }
344 if (n)
345 omapi_object_dereference ((omapi_object_t **)&n, MDL);
346 return ISC_R_SUCCESS;
347 }
348
349 #ifdef DEBUG_PROTOCOL
350 static const char *omapi_message_op_name(int op) {
351 switch (op) {
352 case OMAPI_OP_OPEN: return "OMAPI_OP_OPEN";
353 case OMAPI_OP_REFRESH: return "OMAPI_OP_REFRESH";
354 case OMAPI_OP_UPDATE: return "OMAPI_OP_UPDATE";
355 case OMAPI_OP_STATUS: return "OMAPI_OP_STATUS";
356 case OMAPI_OP_DELETE: return "OMAPI_OP_DELETE";
357 case OMAPI_OP_NOTIFY: return "OMAPI_OP_NOTIFY";
358 default: return "(unknown op)";
359 }
360 }
361 #endif
362
363 static isc_result_t
364 omapi_message_process_internal (omapi_object_t *, omapi_object_t *);
365
366 isc_result_t omapi_message_process (omapi_object_t *mo, omapi_object_t *po)
367 {
368 isc_result_t status;
369 #if defined (DEBUG_MEMORY_LEAKAGE)
370 unsigned long previous_outstanding = dmalloc_outstanding;
371 #endif
372
373 status = omapi_message_process_internal (mo, po);
374
375 #if defined (DEBUG_MEMORY_LEAKAGE) && 0
376 log_info ("generation %ld: %ld new, %ld outstanding, %ld long-term",
377 dmalloc_generation,
378 dmalloc_outstanding - previous_outstanding,
379 dmalloc_outstanding, dmalloc_longterm);
380 #endif
381 #if defined (DEBUG_MEMORY_LEAKAGE) && 0
382 dmalloc_dump_outstanding ();
383 #endif
384 #if defined (DEBUG_RC_HISTORY_EXHAUSTIVELY) && 0
385 dump_rc_history ();
386 #endif
387
388 return status;
389 }
390
391 static isc_result_t
392 omapi_message_process_internal (omapi_object_t *mo, omapi_object_t *po)
393 {
394 omapi_message_object_t *message, *m;
395 omapi_object_t *object = (omapi_object_t *)0;
396 omapi_value_t *tv = (omapi_value_t *)0;
397 unsigned long create, update, exclusive;
398 unsigned long wsi;
399 isc_result_t status, waitstatus;
400 omapi_object_type_t *type;
401
402 if (mo -> type != omapi_type_message)
403 return ISC_R_INVALIDARG;
404 message = (omapi_message_object_t *)mo;
405
406 #ifdef DEBUG_PROTOCOL
407 log_debug ("omapi_message_process(): "
408 "op=%s handle=%#x id=%#x rid=%#x",
409 omapi_message_op_name (message -> op),
410 message -> h, message -> id, message -> rid);
411 #endif
412
413 if (message -> rid) {
414 for (m = omapi_registered_messages; m; m = m -> next)
415 if (m -> id == message -> rid)
416 break;
417 /* If we don't have a real message corresponding to
418 the message ID to which this message claims it is a
419 response, something's fishy. */
420 if (!m)
421 return ISC_R_NOTFOUND;
422 /* The authenticator on responses must match the initial
423 message. */
424 if (message -> authid != m -> authid)
425 return ISC_R_NOTFOUND;
426 } else {
427 m = (omapi_message_object_t *)0;
428
429 /* All messages must have an authenticator, with the exception
430 of messages that are opening a new authenticator. */
431 if (omapi_protocol_authenticated (po) &&
432 !message -> id_object &&
433 message -> op != OMAPI_OP_OPEN) {
434 return omapi_protocol_send_status
435 (po, message -> id_object, ISC_R_NOKEYS,
436 message -> id, "No authenticator on message");
437 }
438 }
439
440 switch (message -> op) {
441 case OMAPI_OP_OPEN:
442 if (m) {
443 return omapi_protocol_send_status
444 (po, message -> id_object, ISC_R_INVALIDARG,
445 message -> id, "OPEN can't be a response");
446 }
447
448 /* Get the type of the requested object, if one was
449 specified. */
450 status = omapi_get_value_str (mo, message -> id_object,
451 "type", &tv);
452 if (status == ISC_R_SUCCESS &&
453 (tv -> value -> type == omapi_datatype_data ||
454 tv -> value -> type == omapi_datatype_string)) {
455 for (type = omapi_object_types;
456 type; type = type -> next)
457 if (!omapi_td_strcmp (tv -> value,
458 type -> name))
459 break;
460 } else
461 type = (omapi_object_type_t *)0;
462 if (tv)
463 omapi_value_dereference (&tv, MDL);
464
465 /* If this object had no authenticator, the requested object
466 must be an authenticator object. */
467 if (omapi_protocol_authenticated (po) &&
468 !message -> id_object &&
469 type != omapi_type_auth_key) {
470 return omapi_protocol_send_status
471 (po, message -> id_object, ISC_R_NOKEYS,
472 message -> id, "No authenticator on message");
473 }
474
475 /* Get the create flag. */
476 status = omapi_get_value_str (mo, message -> id_object,
477 "create", &tv);
478 if (status == ISC_R_SUCCESS) {
479 status = omapi_get_int_value (&create, tv -> value);
480 omapi_value_dereference (&tv, MDL);
481 if (status != ISC_R_SUCCESS) {
482 return omapi_protocol_send_status
483 (po, message -> id_object,
484 status, message -> id,
485 "invalid create flag value");
486 }
487 } else
488 create = 0;
489
490 /* Get the update flag. */
491 status = omapi_get_value_str (mo, message -> id_object,
492 "update", &tv);
493 if (status == ISC_R_SUCCESS) {
494 status = omapi_get_int_value (&update, tv -> value);
495 omapi_value_dereference (&tv, MDL);
496 if (status != ISC_R_SUCCESS) {
497 return omapi_protocol_send_status
498 (po, message -> id_object,
499 status, message -> id,
500 "invalid update flag value");
501 }
502 } else
503 update = 0;
504
505 /* Get the exclusive flag. */
506 status = omapi_get_value_str (mo, message -> id_object,
507 "exclusive", &tv);
508 if (status == ISC_R_SUCCESS) {
509 status = omapi_get_int_value (&exclusive, tv -> value);
510 omapi_value_dereference (&tv, MDL);
511 if (status != ISC_R_SUCCESS) {
512 return omapi_protocol_send_status
513 (po, message -> id_object,
514 status, message -> id,
515 "invalid exclusive flag value");
516 }
517 } else
518 exclusive = 0;
519
520 /* If we weren't given a type, look the object up with
521 the handle. */
522 if (!type) {
523 if (create) {
524 return omapi_protocol_send_status
525 (po, message -> id_object,
526 ISC_R_INVALIDARG,
527 message -> id,
528 "type required on create");
529 }
530 goto refresh;
531 }
532
533 /* If the type doesn't provide a lookup method, we can't
534 look up the object. */
535 if (!type -> lookup) {
536 return omapi_protocol_send_status
537 (po, message -> id_object,
538 ISC_R_NOTIMPLEMENTED, message -> id,
539 "unsearchable object type");
540 }
541
542 status = (*(type -> lookup)) (&object, message -> id_object,
543 message -> object);
544
545 if (status != ISC_R_SUCCESS &&
546 status != ISC_R_NOTFOUND &&
547 status != ISC_R_NOKEYS) {
548 return omapi_protocol_send_status
549 (po, message -> id_object,
550 status, message -> id,
551 "object lookup failed");
552 }
553
554 /* If we didn't find the object and we aren't supposed to
555 create it, return an error. */
556 if (status == ISC_R_NOTFOUND && !create) {
557 return omapi_protocol_send_status
558 (po, message -> id_object,
559 ISC_R_NOTFOUND, message -> id,
560 "no object matches specification");
561 }
562
563 /* If we found an object, we're supposed to be creating an
564 object, and we're not supposed to have found an object,
565 return an error. */
566 if (status == ISC_R_SUCCESS && create && exclusive) {
567 omapi_object_dereference (&object, MDL);
568 return omapi_protocol_send_status
569 (po, message -> id_object,
570 ISC_R_EXISTS, message -> id,
571 "specified object already exists");
572 }
573
574 /* If we're creating the object, do it now. */
575 if (!object) {
576 status = omapi_object_create (&object,
577 message -> id_object,
578 type);
579 if (status != ISC_R_SUCCESS) {
580 return omapi_protocol_send_status
581 (po, message -> id_object,
582 status, message -> id,
583 "can't create new object");
584 }
585 }
586
587 /* If we're updating it, do so now. */
588 if (create || update) {
589 /* This check does not belong here. */
590 if (object -> type == omapi_type_auth_key) {
591 omapi_object_dereference (&object, MDL);
592 return omapi_protocol_send_status
593 (po, message -> id_object,
594 status, message -> id,
595 "can't update object");
596 }
597
598 status = omapi_object_update (object,
599 message -> id_object,
600 message -> object,
601 message -> h);
602 if (status != ISC_R_SUCCESS) {
603 omapi_object_dereference (&object, MDL);
604 return omapi_protocol_send_status
605 (po, message -> id_object,
606 status, message -> id,
607 "can't update object");
608 }
609 }
610
611 /* If this is an authenticator object, add it to the active
612 set for the connection. */
613 if (object -> type == omapi_type_auth_key) {
614 omapi_handle_t handle;
615 status = omapi_object_handle (&handle, object);
616 if (status != ISC_R_SUCCESS) {
617 omapi_object_dereference (&object, MDL);
618 return omapi_protocol_send_status
619 (po, message -> id_object,
620 status, message -> id,
621 "can't select authenticator");
622 }
623
624 status = omapi_protocol_add_auth (po, object, handle);
625 if (status != ISC_R_SUCCESS) {
626 omapi_object_dereference (&object, MDL);
627 return omapi_protocol_send_status
628 (po, message -> id_object,
629 status, message -> id,
630 "can't select authenticator");
631 }
632 }
633
634 /* Now send the new contents of the object back in
635 response. */
636 goto send;
637
638 case OMAPI_OP_REFRESH:
639 refresh:
640 status = omapi_handle_lookup (&object, message -> h);
641 if (status != ISC_R_SUCCESS) {
642 return omapi_protocol_send_status
643 (po, message -> id_object,
644 status, message -> id,
645 "no matching handle");
646 }
647 send:
648 status = omapi_protocol_send_update (po, message -> id_object,
649 message -> id, object);
650 omapi_object_dereference (&object, MDL);
651 return status;
652
653 case OMAPI_OP_UPDATE:
654 if (m && m -> object) {
655 status = omapi_object_reference (&object, m -> object,
656 MDL);
657 } else {
658 status = omapi_handle_lookup (&object, message -> h);
659 if (status != ISC_R_SUCCESS) {
660 return omapi_protocol_send_status
661 (po, message -> id_object,
662 status, message -> id,
663 "no matching handle");
664 }
665 }
666
667 if (object -> type == omapi_type_auth_key ||
668 (object -> inner &&
669 object -> inner -> type == omapi_type_auth_key)) {
670 if (!m) {
671 omapi_object_dereference (&object, MDL);
672 return omapi_protocol_send_status
673 (po, message -> id_object,
674 status, message -> id,
675 "cannot update authenticator");
676 }
677
678 status = omapi_protocol_add_auth (po, object,
679 message -> h);
680 } else {
681 status = omapi_object_update (object,
682 message -> id_object,
683 message -> object,
684 message -> h);
685 }
686 if (status != ISC_R_SUCCESS) {
687 omapi_object_dereference (&object, MDL);
688 if (!message -> rid)
689 return omapi_protocol_send_status
690 (po, message -> id_object,
691 status, message -> id,
692 "can't update object");
693 if (m)
694 omapi_signal ((omapi_object_t *)m,
695 "status", status,
696 (omapi_typed_data_t *)0);
697 return ISC_R_SUCCESS;
698 }
699 if (!message -> rid)
700 status = omapi_protocol_send_status
701 (po, message -> id_object, ISC_R_SUCCESS,
702 message -> id, (char *)0);
703 if (m) {
704 omapi_signal ((omapi_object_t *)m,
705 "status", ISC_R_SUCCESS,
706 (omapi_typed_data_t *)0);
707 omapi_message_unregister ((omapi_object_t *)m);
708 }
709
710 omapi_object_dereference (&object, MDL);
711
712 return status;
713
714 case OMAPI_OP_NOTIFY:
715 return omapi_protocol_send_status
716 (po, message -> id_object, ISC_R_NOTIMPLEMENTED,
717 message -> id, "notify not implemented yet");
718
719 case OMAPI_OP_STATUS:
720 /* The return status of a request. */
721 if (!m)
722 return ISC_R_UNEXPECTED;
723
724 /* Get the wait status. */
725 status = omapi_get_value_str (mo, message -> id_object,
726 "result", &tv);
727 if (status == ISC_R_SUCCESS) {
728 status = omapi_get_int_value (&wsi, tv -> value);
729 waitstatus = wsi;
730 omapi_value_dereference (&tv, MDL);
731 if (status != ISC_R_SUCCESS)
732 waitstatus = ISC_R_UNEXPECTED;
733 } else
734 waitstatus = ISC_R_UNEXPECTED;
735
736 status = omapi_get_value_str (mo, message -> id_object,
737 "message", &tv);
738 omapi_signal ((omapi_object_t *)m, "status", waitstatus, tv);
739 if (status == ISC_R_SUCCESS)
740 omapi_value_dereference (&tv, MDL);
741
742 omapi_message_unregister((omapi_object_t *)m);
743
744 return ISC_R_SUCCESS;
745
746 case OMAPI_OP_DELETE:
747 status = omapi_handle_lookup (&object, message -> h);
748 if (status != ISC_R_SUCCESS) {
749 return omapi_protocol_send_status
750 (po, message -> id_object,
751 status, message -> id,
752 "no matching handle");
753 }
754
755 if (!object -> type -> remove)
756 return omapi_protocol_send_status
757 (po, message -> id_object,
758 ISC_R_NOTIMPLEMENTED, message -> id,
759 "no remove method for object");
760
761 status = (*(object -> type -> remove)) (object,
762 message -> id_object);
763 omapi_object_dereference (&object, MDL);
764
765 return omapi_protocol_send_status (po, message -> id_object,
766 status, message -> id,
767 (char *)0);
768 }
769 return ISC_R_NOTIMPLEMENTED;
770 }
DragonFly BSD