1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2001-2002 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #pragma ident "%Z%%M% %I% %E% SMI"
28
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <sys/types.h>
32 #include <sys/stat.h>
33 #include <unistd.h>
34 #include <errno.h>
35 #include <strings.h>
36 #include <string.h>
37 #include <fcntl.h>
38 #include <assert.h>
39 #include <libipp.h>
40 #include <libnvpair.h>
41 #include <ipp/ippctl.h>
42
43 /*
44 * Debug macros
45 */
46
47 #if defined(DEBUG) && !defined(lint)
48 uint32_t ipp_debug_flags =
49 /*
50 * DBG_IO |
51 */
52 DBG_ERR |
53 0;
54
55 #define DBG0(flags, fmt) \
56 do { \
57 if (flags & ipp_debug_flags) \
58 fprintf(stderr, "libipp: " __FN__ ": " fmt); \
59 } while (0)
60
61 #define DBG1(flags, fmt, a) \
62 do { \
63 if (flags & ipp_debug_flags) \
64 fprintf(stderr, "libipp: " __FN__ ": " fmt, a); \
65 } while (0)
66
67 #define DBG2(flags, fmt, a, b) \
68 do { \
69 if (flags & ipp_debug_flags) \
70 fprintf(stderr, "libipp: " __FN__ ": " fmt, a, \
71 b); \
72 } while (0)
73
74 #define DBG3(flags, fmt, a, b, c) \
75 do { \
76 if (flags & ipp_debug_flags) \
77 fprintf(stderr, "libipp: " __FN__ ": " fmt, a, \
78 b, c); \
79 } while (0)
80
81 #else /* defined(DEBUG) && !defined(lint) */
82 #define DBG0(flags, fmt)
83 #define DBG1(flags, fmt, a)
84 #define DBG2(flags, fmt, a, b)
85 #define DBG3(flags, fmt, a, b, c)
86 #endif /* defined(DEBUG) && !defined(lint) */
87
88 /*
89 * Control device node
90 */
91
92 #define IPPCTL_DEVICE "/devices/pseudo/ippctl@0:ctl"
93
94 /*
95 * Structures.
96 */
97
98 typedef struct array_desc_t {
99 char *name;
100 char **array;
101 int nelt;
102 } array_desc_t;
103
104 /*
105 * Prototypes
106 */
107
108 static int nvlist_callback(nvlist_t *, void *);
109 static int string_callback(nvlist_t *, void *);
110 static int string_array_callback(nvlist_t *, void *);
111 static int dispatch(nvlist_t **, int (*)(nvlist_t *, void *), void *);
112
113 /*
114 * API functions
115 */
116 #define __FN__ "ipp_action_create"
117 int
118 ipp_action_create(
119 const char *modname,
120 const char *aname,
121 nvlist_t **nvlpp,
122 ipp_flags_t flags)
123 {
124 nvlist_t *nvlp;
125 int rc;
126
127 /*
128 * Sanity check the arguments.
129 */
130
131 if (nvlpp == NULL || modname == NULL || aname == NULL) {
132 DBG0(DBG_ERR, "bad argument\n");
133 errno = EINVAL;
134 return (-1);
135 }
136
137 /*
138 * Add our data to the nvlist. (This information will be removed for
139 * use by ippctl).
140 */
141
142 nvlp = *nvlpp;
143 if ((rc = nvlist_add_byte(nvlp, IPPCTL_OP,
144 IPPCTL_OP_ACTION_CREATE)) != 0) {
145 DBG1(DBG_ERR, "failed to add '%s' to nvlist\n", IPPCTL_OP);
146 goto failed;
147 }
148
149 if ((rc = nvlist_add_string(nvlp, IPPCTL_MODNAME,
150 (char *)modname)) != 0) {
151 DBG1(DBG_ERR, "failed to add '%s' to nvlist\n",
152 IPPCTL_MODNAME);
153 goto failed;
154 }
155
156 if ((rc = nvlist_add_string(nvlp, IPPCTL_ANAME, (char *)aname)) != 0) {
157 DBG1(DBG_ERR, "failed to add '%s' to nvlist\n", IPPCTL_ANAME);
158 goto failed;
159 }
160
161 if ((rc = nvlist_add_uint32(nvlp, IPPCTL_FLAGS, flags)) != 0) {
162 DBG1(DBG_ERR, "failed to add '%s' to nvlist\n", IPPCTL_FLAGS);
163 goto failed;
164 }
165
166 /*
167 * Talk to the kernel.
168 */
169
170 return (dispatch(nvlpp, nvlist_callback, (void *)nvlpp));
171 failed:
172 errno = rc;
173 return (-1);
174 }
175 #undef __FN__
176
177 #define __FN__ "ipp_action_destroy"
178 int
179 ipp_action_destroy(
180 const char *aname,
181 ipp_flags_t flags)
182 {
183 nvlist_t *nvlp;
184 int rc;
185
186 /*
187 * Sanity check the arguments.
188 */
189
190 if (aname == NULL) {
191 DBG0(DBG_ERR, "bad argument\n");
192 errno = EINVAL;
193 return (-1);
194 }
195
196 /*
197 * Create an nvlist for our data as none is passed into the function.
198 */
199
200 if ((rc = nvlist_alloc(&nvlp, NV_UNIQUE_NAME, 0)) != 0) {
201 DBG0(DBG_ERR, "failed to allocate nvlist\n");
202 nvlp = NULL;
203 goto failed;
204 }
205
206 if ((rc = nvlist_add_byte(nvlp, IPPCTL_OP,
207 IPPCTL_OP_ACTION_DESTROY)) != 0) {
208 DBG1(DBG_ERR, "failed to add '%s' to nvlist\n", IPPCTL_OP);
209 goto failed;
210 }
211
212 if ((rc = nvlist_add_string(nvlp, IPPCTL_ANAME, (char *)aname)) != 0) {
213 DBG1(DBG_ERR, "failed to add '%s' to nvlist\n", IPPCTL_ANAME);
214 goto failed;
215 }
216
217 if ((rc = nvlist_add_uint32(nvlp, IPPCTL_FLAGS, flags)) != 0) {
218 DBG1(DBG_ERR, "failed to add '%s' to nvlist\n", IPPCTL_FLAGS);
219 goto failed;
220 }
221
222 /*
223 * Talk to the kernel.
224 */
225
226 return (dispatch(&nvlp, NULL, NULL));
227 failed:
228 if (nvlp != NULL)
229 nvlist_free(nvlp);
230 errno = rc;
231 return (-1);
232 }
233 #undef __FN__
234
235 #define __FN__ "ipp_action_modify"
236 int
237 ipp_action_modify(
238 const char *aname,
239 nvlist_t **nvlpp,
240 ipp_flags_t flags)
241 {
242 nvlist_t *nvlp;
243 int rc;
244
245 /*
246 * Sanity check the arguments.
247 */
248
249 if (nvlpp == NULL || aname == NULL) {
250 DBG0(DBG_ERR, "bad argument\n");
251 errno = EINVAL;
252 return (-1);
253 }
254
255 /*
256 * Add our data to the nvlist.
257 */
258
259 nvlp = *nvlpp;
260 if ((rc = nvlist_add_byte(nvlp, IPPCTL_OP,
261 IPPCTL_OP_ACTION_MODIFY)) != 0) {
262 DBG1(DBG_ERR, "failed to add '%s' to nvlist\n", IPPCTL_OP);
263 goto failed;
264 }
265
266 if ((rc = nvlist_add_string(nvlp, IPPCTL_ANAME, (char *)aname)) != 0) {
267 DBG1(DBG_ERR, "failed to add '%s' to nvlist\n", IPPCTL_ANAME);
268 goto failed;
269 }
270
271 if ((rc = nvlist_add_uint32(nvlp, IPPCTL_FLAGS, flags)) != 0) {
272 DBG1(DBG_ERR, "failed to add '%s' to nvlist\n", IPPCTL_FLAGS);
273 goto failed;
274 }
275
276 /*
277 * Talk to the kernel.
278 */
279
280 return (dispatch(nvlpp, nvlist_callback, (void *)nvlpp));
281 failed:
282 errno = rc;
283 return (-1);
284 }
285 #undef __FN__
286
287 #define __FN__ "ipp_action_info"
288 int
289 ipp_action_info(
290 const char *aname,
291 int (*fn)(nvlist_t *, void *),
292 void *arg,
293 ipp_flags_t flags)
294 {
295 nvlist_t *nvlp;
296 int rc;
297
298 /*
299 * Sanity check the arguments.
300 */
301
302 if (aname == NULL || fn == NULL) {
303 DBG0(DBG_ERR, "bad argument\n");
304 errno = EINVAL;
305 return (-1);
306 }
307
308 /*
309 * Create an nvlist for our data.
310 */
311
312 if ((rc = nvlist_alloc(&nvlp, NV_UNIQUE_NAME, 0)) != 0) {
313 DBG0(DBG_ERR, "failed to allocate nvlist\n");
314 nvlp = NULL;
315 }
316
317 if ((rc = nvlist_add_byte(nvlp, IPPCTL_OP,
318 IPPCTL_OP_ACTION_INFO)) != 0) {
319 DBG1(DBG_ERR, "failed to add '%s' to nvlist\n", IPPCTL_OP);
320 goto failed;
321 }
322
323 if ((rc = nvlist_add_string(nvlp, IPPCTL_ANAME, (char *)aname)) != 0) {
324 DBG1(DBG_ERR, "failed to add '%s' to nvlist\n", IPPCTL_ANAME);
325 goto failed;
326 }
327
328 if ((rc = nvlist_add_uint32(nvlp, IPPCTL_FLAGS, flags)) != 0) {
329 DBG1(DBG_ERR, "failed to add '%s' to nvlist\n", IPPCTL_FLAGS);
330 goto failed;
331 }
332
333 /*
334 * Talk to the kernel.
335 */
336
337 return (dispatch(&nvlp, fn, arg));
338 failed:
339 if (nvlp != NULL)
340 nvlist_free(nvlp);
341 errno = rc;
342 return (-1);
343 }
344 #undef __FN__
345
346 #define __FN__ "ipp_action_mod"
347 int
348 ipp_action_mod(
349 const char *aname,
350 char **modnamep)
351 {
352 nvlist_t *nvlp;
353 int rc;
354
355 /*
356 * Sanity check the arguments.
357 */
358
359 if (aname == NULL || modnamep == NULL) {
360 DBG0(DBG_ERR, "bad argument\n");
361 errno = EINVAL;
362 return (-1);
363 }
364
365 /*
366 * Create an nvlist for our data.
367 */
368
369 if ((rc = nvlist_alloc(&nvlp, NV_UNIQUE_NAME, 0)) != 0) {
370 DBG0(DBG_ERR, "failed to allocate nvlist\n");
371 nvlp = NULL;
372 goto failed;
373 }
374
375 if ((rc = nvlist_add_byte(nvlp, IPPCTL_OP,
376 IPPCTL_OP_ACTION_MOD)) != 0) {
377 DBG1(DBG_ERR, "failed to add '%s' to nvlist\n", IPPCTL_OP);
378 goto failed;
379 }
380
381 if ((rc = nvlist_add_string(nvlp, IPPCTL_ANAME, (char *)aname)) != 0) {
382 DBG1(DBG_ERR, "failed to add '%s' to nvlist\n", IPPCTL_ANAME);
383 goto failed;
384 }
385
386 /*
387 * Talk to the kernel.
388 */
389
390 return (dispatch(&nvlp, string_callback, (void *)modnamep));
391 failed:
392 if (nvlp != NULL)
393 nvlist_free(nvlp);
394 errno = rc;
395 return (-1);
396 }
397 #undef __FN__
398
399 #define __FN__ "ipp_list_mods"
400 int
401 ipp_list_mods(
402 char ***modname_arrayp,
403 int *neltp)
404 {
405 nvlist_t *nvlp;
406 array_desc_t ad;
407 int rc;
408
409 /*
410 * Sanity check the arguments.
411 */
412
413 if (modname_arrayp == NULL || neltp == NULL) {
414 DBG0(DBG_ERR, "bad argument");
415 errno = EINVAL;
416 return (-1);
417 }
418
419 /*
420 * Create an nvlist for our data.
421 */
422
423 if ((rc = nvlist_alloc(&nvlp, NV_UNIQUE_NAME, 0)) != 0) {
424 DBG0(DBG_ERR, "failed to allocate nvlist\n");
425 nvlp = NULL;
426 }
427
428 if ((rc = nvlist_add_byte(nvlp, IPPCTL_OP,
429 IPPCTL_OP_LIST_MODS)) != 0) {
430 DBG1(DBG_ERR, "failed to add '%s' to nvlist\n", IPPCTL_OP);
431 goto failed;
432 }
433
434 /*
435 * Talk to the kernel.
436 */
437
438 ad.name = IPPCTL_MODNAME_ARRAY;
439 ad.array = NULL;
440 ad.nelt = 0;
441
442 if ((rc = dispatch(&nvlp, string_array_callback, (void *)&ad)) == 0) {
443 *modname_arrayp = ad.array;
444 *neltp = ad.nelt;
445 }
446
447 return (rc);
448 failed:
449 if (nvlp != NULL)
450 nvlist_free(nvlp);
451 errno = rc;
452 return (-1);
453 }
454 #undef __FN__
455
456 #define __FN__ "ipp_mod_list_actions"
457 int
458 ipp_mod_list_actions(
459 const char *modname,
460 char ***aname_arrayp,
461 int *neltp)
462 {
463 nvlist_t *nvlp;
464 array_desc_t ad;
465 int rc;
466
467 /*
468 * Sanity check the arguments.
469 */
470
471 if (modname == NULL || aname_arrayp == NULL || neltp == NULL) {
472 DBG0(DBG_ERR, "bad argument");
473 errno = EINVAL;
474 return (-1);
475 }
476
477 /*
478 * Create an nvlist for our data.
479 */
480
481 if ((rc = nvlist_alloc(&nvlp, NV_UNIQUE_NAME, 0)) != 0) {
482 DBG0(DBG_ERR, "failed to allocate nvlist\n");
483 nvlp = NULL;
484 }
485
486 if ((rc = nvlist_add_byte(nvlp, IPPCTL_OP,
487 IPPCTL_OP_MOD_LIST_ACTIONS)) != 0) {
488 DBG1(DBG_ERR, "failed to add '%s' to nvlist\n", IPPCTL_OP);
489 goto failed;
490 }
491
492 if ((rc = nvlist_add_string(nvlp, IPPCTL_MODNAME,
493 (char *)modname)) != 0) {
494 DBG1(DBG_ERR, "failed to add '%s' to nvlist\n", IPPCTL_MODNAME);
495 goto failed;
496 }
497
498 /*
499 * Talk to the kernel.
500 */
501
502 ad.name = IPPCTL_ANAME_ARRAY;
503 ad.array = NULL;
504 ad.nelt = 0;
505
506 if ((rc = dispatch(&nvlp, string_array_callback, (void *)&ad)) == 0) {
507 *aname_arrayp = ad.array;
508 *neltp = ad.nelt;
509 }
510
511 return (rc);
512 failed:
513 if (nvlp != NULL)
514 nvlist_free(nvlp);
515 errno = rc;
516 return (-1);
517 }
518 #undef __FN__
519
520 #define __FN__ "ipp_free"
521 void
522 ipp_free(
523 char *buf)
524 {
525 free(buf);
526 }
527 #undef __FN__
528
529 #define __FN__ "ipp_free_array"
530 void
531 ipp_free_array(
532 char **array,
533 int nelt)
534 {
535 int i;
536
537 assert(array[nelt] == NULL);
538
539 for (i = 0; i < nelt; i++)
540 free(array[i]);
541
542 free(array);
543 }
544 #undef __FN__
545
546 #define __FN__ "nvlist_callback"
547 static int
548 nvlist_callback(
549 nvlist_t *nvlp,
550 void *arg)
551 {
552 nvlist_t **nvlpp = (nvlist_t **)arg;
553 int rc;
554
555 /*
556 * Callback function used by ipp_action_create() and
557 * ipp_action_modify()
558 */
559
560 DBG0(DBG_IO, "called\n");
561
562 assert(nvlpp != NULL);
563 assert(*nvlpp == NULL);
564
565 /*
566 * Duplicate the nvlist and set the given pointer to point at the new
567 * copy.
568 */
569
570 if ((rc = nvlist_dup(nvlp, nvlpp, 0)) != 0) {
571 DBG0(DBG_ERR, "failed to dup nvlist\n");
572 errno = rc;
573 return (-1);
574 }
575
576 return (0);
577 }
578 #undef __FN__
579
580 #define __FN__ "string_callback"
581 static int
582 string_callback(
583 nvlist_t *nvlp,
584 void *arg)
585 {
586 char **namep = (char **)arg;
587 char *name;
588 char *ptr;
589 int rc;
590
591 /*
592 * Callback function used by ipp_action_mod()
593 */
594
595 DBG0(DBG_IO, "called\n");
596
597 assert(namep != NULL);
598
599 /*
600 * Look up the module name from the nvlist.
601 */
602
603 if ((rc = nvlist_lookup_string(nvlp, IPPCTL_MODNAME, &ptr)) != 0) {
604 DBG0(DBG_ERR, "failed to find string\n");
605 errno = rc;
606 return (-1);
607 }
608
609 /*
610 * Allocate a duplicate string.
611 */
612
613 if ((name = strdup(ptr)) == NULL) {
614 DBG0(DBG_ERR, "failed to duplicate string\n");
615 return (-1);
616 }
617
618 /*
619 * Set the given pointer to point at the string.
620 */
621
622 *namep = name;
623 return (0);
624 }
625 #undef __FN__
626
627 #define __FN__ "string_array_callback"
628 static int
629 string_array_callback(
630 nvlist_t *nvlp,
631 void *arg)
632 {
633 array_desc_t *adp = (array_desc_t *)arg;
634 char **dst;
635 char **src;
636 uint_t nelt;
637 int i;
638 int rc;
639
640 /*
641 * Callback function used by ipp_list_mods()
642 */
643
644 DBG0(DBG_IO, "called\n");
645
646 assert(adp != NULL);
647
648 /*
649 * Look up the module name from the nvlist.
650 */
651
652 if ((rc = nvlist_lookup_string_array(nvlp, adp->name, &src,
653 &nelt)) != 0) {
654 DBG0(DBG_ERR, "failed to find array\n");
655 errno = rc;
656 return (-1);
657 }
658
659 /*
660 * Allocate an array.
661 */
662
663 if ((dst = malloc((nelt + 1) * sizeof (char *))) == NULL) {
664 DBG0(DBG_ERR, "failed to allocate new array\n");
665 return (-1);
666 }
667
668 /*
669 * For each string in the array, allocate a new buffer and copy
670 * the string into it.
671 */
672
673 for (i = 0; i < nelt; i++) {
674 if ((dst[i] = strdup(src[i])) == NULL) {
675 while (--i >= 0) {
676 free(dst[i]);
677 }
678 free(dst);
679 DBG0(DBG_ERR, "failed to duplicate array\n");
680 return (-1);
681 }
682 }
683 dst[nelt] = NULL;
684
685 /*
686 * Set the information to be passed back.
687 */
688
689 adp->array = dst;
690 adp->nelt = nelt;
691
692 return (0);
693 }
694 #undef __FN__
695
696 #define __FN__ "dispatch"
697 static int
698 dispatch(
699 nvlist_t **nvlpp,
700 int (*fn)(nvlist_t *, void *),
701 void *arg)
702 {
703 char *cbuf = NULL;
704 char *dbuf = NULL;
705 size_t cbuflen = 0;
706 size_t dbuflen = 0;
707 size_t thisbuflen = 0;
708 size_t nextbuflen = 0;
709 int rc;
710 ippctl_ioctl_t iioc;
711 int fd;
712 nvlist_t *cnvlp;
713 nvlist_t *dnvlp = NULL;
714 int count;
715 int rval;
716
717 /*
718 * Sanity check the 'command' nvlist.
719 */
720
721 cnvlp = *nvlpp;
722 if (cnvlp == NULL) {
723 rc = EINVAL;
724 return (-1);
725 }
726
727 /*
728 * Pack the nvlist and then free the original.
729 */
730
731 if ((rc = nvlist_pack(cnvlp, &cbuf, &cbuflen, NV_ENCODE_NATIVE,
732 0)) != 0) {
733 DBG0(DBG_ERR, "failed to pack nvlist\n");
734 nvlist_free(cnvlp);
735 errno = rc;
736 return (-1);
737 }
738 nvlist_free(cnvlp);
739 *nvlpp = NULL;
740
741 /*
742 * Open the control device node.
743 */
744
745 DBG1(DBG_IO, "opening %s\n", IPPCTL_DEVICE);
746 if ((fd = open(IPPCTL_DEVICE, O_RDWR | O_NOCTTY)) == -1) {
747 DBG1(DBG_ERR, "failed to open %s\n", IPPCTL_DEVICE);
748 goto command_failed;
749 }
750
751 /*
752 * Set up an ioctl structure to point at the packed nvlist.
753 */
754
755 iioc.ii_buf = cbuf;
756 iioc.ii_buflen = cbuflen;
757
758 /*
759 * Issue a command ioctl, passing the ioctl structure.
760 */
761
762 DBG0(DBG_IO, "command\n");
763 if ((rc = ioctl(fd, IPPCTL_CMD, &iioc)) < 0) {
764 DBG0(DBG_ERR, "command ioctl failed\n");
765 goto command_failed;
766 }
767
768 /*
769 * Get back the length of the first data buffer.
770 */
771
772 if ((nextbuflen = (size_t)rc) == 0) {
773 DBG0(DBG_ERR, "no data buffer\n");
774 errno = EPROTO;
775 goto command_failed;
776 }
777
778 /*
779 * Try to re-use the command buffer as the first data buffer.
780 */
781
782 dbuf = cbuf;
783 thisbuflen = cbuflen;
784
785 count = 0;
786 while (nextbuflen != 0) {
787 dbuflen = nextbuflen;
788
789 /*
790 * Check whether the buffer we have is long enough for the
791 * next lot of data. If it isn't, allocate a new one of
792 * the appropriate length.
793 */
794
795 if (nextbuflen > thisbuflen) {
796 if ((dbuf = realloc(dbuf, nextbuflen)) == NULL) {
797 DBG0(DBG_ERR,
798 "failed to allocate data buffer\n");
799 goto data_failed;
800 }
801 thisbuflen = nextbuflen;
802 }
803
804 /*
805 * Set up an ioctl structure to point at the data buffer.
806 */
807
808 iioc.ii_buf = dbuf;
809 iioc.ii_buflen = dbuflen;
810
811 /*
812 * Issue a data ioctl, passing the ioctl structure.
813 */
814
815 DBG2(DBG_IO, "data[%d]: length = %d\n", count, dbuflen);
816 if ((rc = ioctl(fd, IPPCTL_DATA, &iioc)) < 0) {
817 DBG0(DBG_ERR, "data ioctl failed\n");
818 goto data_failed;
819 }
820
821 /*
822 * Get the length of the *next* data buffer, if there is
823 * one.
824 */
825
826 nextbuflen = (size_t)rc;
827 DBG1(DBG_IO, "nextbuflen = %d\n", nextbuflen);
828
829 /*
830 * Unpack the nvlist that the current data buffer should
831 * now contain.
832 */
833
834 if ((rc = nvlist_unpack(dbuf, dbuflen, &dnvlp, 0)) != 0) {
835 DBG0(DBG_ERR, "failed to unpack nvlist\n");
836 errno = rc;
837 goto data_failed;
838 }
839
840 /*
841 * The first data buffer should contain the kernel function's
842 * return code. Subsequent buffers contain nvlists which
843 * should be passed to the given callback function.
844 */
845
846 if (count == 0) {
847 if ((rc = nvlist_lookup_int32(dnvlp, IPPCTL_RC,
848 &rval)) != 0) {
849 DBG0(DBG_ERR, "failed to find return code\n");
850 nvlist_free(dnvlp);
851 errno = rc;
852 goto data_failed;
853 }
854 } else {
855 if (fn != NULL)
856 if (fn(dnvlp, arg) != 0) {
857
858 /*
859 * The callback function returned
860 * a non-zero value. Abort any further
861 * data collection.
862 */
863
864 nvlist_free(dnvlp);
865 free(dbuf);
866 }
867 }
868
869 /*
870 * Free the nvlist now that we have extracted the return
871 * code or called the callback function.
872 */
873
874 nvlist_free(dnvlp);
875 dnvlp = NULL;
876
877 count++;
878 }
879
880 /*
881 * Free the data buffer as data collection is now complete.
882 */
883
884 free(dbuf);
885
886 /*
887 * Close the control device.
888 */
889
890 (void) close(fd);
891
892 /*
893 * If the kernel returned an error, we should return an error.
894 * and set errno.
895 */
896
897 if (rval != 0) {
898 DBG1(DBG_IO, "kernel return code = %d\n", rval);
899 errno = rval;
900 return (-1);
901 }
902
903 return (0);
904
905 command_failed:
906 free(cbuf);
907 if (fd != -1)
908 (void) close(fd);
909 return (-1);
910
911 data_failed:
912 if (dbuf != NULL)
913 free(dbuf);
914 (void) close(fd);
915 return (-1);
916 }
917 #undef __FN__