sys/sys/mount.h: Add fsidcmp()
[dragonfly.git] / lib / libcam / scsi_cmdparse.c
1 /*
2  * Taken from the original FreeBSD user SCSI library.
3  */
4 /* Copyright (c) 1994 HD Associates
5  * (contact: dufault@hda.com)
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. All advertising materials mentioning features or use of this software
17  *    must display the following acknowledgement:
18  * This product includes software developed by HD Associates
19  * 4. Neither the name of the HD Associaates nor the names of its contributors
20  *    may be used to endorse or promote products derived from this software
21  *    without specific prior written permission.
22  *
23  * THIS SOFTWARE IS PROVIDED BY HD ASSOCIATES``AS IS'' AND
24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26  * ARE DISCLAIMED.  IN NO EVENT SHALL HD ASSOCIATES OR CONTRIBUTORS BE LIABLE
27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33  * SUCH DAMAGE.
34  * From: scsi.c,v 1.8 1997/02/22 15:07:54 peter Exp $
35  * $FreeBSD: src/lib/libcam/scsi_cmdparse.c,v 1.3.2.1 2000/08/14 05:42:30 kbyanc Exp $
36  */
37 #include <stdlib.h>
38 #include <stdio.h>
39 #include <ctype.h>
40 #include <string.h>
41 #include <sys/errno.h>
42 #include <stdarg.h>
43 #include <fcntl.h>
44
45 #include <bus/cam/cam.h>
46 #include <bus/cam/cam_ccb.h>
47 #include <bus/cam/scsi/scsi_message.h>
48 #include "camlib.h"
49
50 /*
51  * Decode: Decode the data section of a scsireq.  This decodes
52  * trivial grammar:
53  *
54  * fields : field fields
55  *        ;
56  *
57  * field : field_specifier
58  *       | control
59  *       ;
60  *
61  * control : 's' seek_value
62  *       | 's' '+' seek_value
63  *       ;
64  *
65  * seek_value : DECIMAL_NUMBER
66  *       | 'v'                          // For indirect seek, i.e., value from the arg list
67  *       ;
68  *
69  * field_specifier : type_specifier field_width
70  *       | '{' NAME '}' type_specifier field_width
71  *       ;
72  *
73  * field_width : DECIMAL_NUMBER
74  *       ;
75  *
76  * type_specifier : 'i' // Integral types (i1, i2, i3, i4)
77  *       | 'b'                          // Bits
78  *       | 't'                          // Bits
79  *       | 'c'                          // Character arrays
80  *       | 'z'                          // Character arrays with zeroed trailing spaces
81  *       ;
82  *
83  * Notes:
84  * 1. Integral types are swapped into host order.
85  * 2. Bit fields are allocated MSB to LSB to match the SCSI spec documentation.
86  * 3. 's' permits "seeking" in the string.  "s+DECIMAL" seeks relative to
87  *    DECIMAL; "sDECIMAL" seeks absolute to decimal.
88  * 4. 's' permits an indirect reference.  "sv" or "s+v" will get the
89  *    next integer value from the arg array.
90  * 5. Field names can be anything between the braces
91  *
92  * BUGS:
93  * i and b types are promoted to ints.
94  *
95  */
96
97 static int
98 do_buff_decode(u_int8_t *databuf, size_t len,
99                void (*arg_put)(void *, int , void *, int, char *),
100                void *puthook, const char *fmt, va_list ap)
101 {
102         int assigned = 0;
103         int width;
104         int suppress;
105         int plus;
106         int done = 0;
107         static u_char mask[] = {0, 0x01, 0x03, 0x07, 0x0f,
108                                    0x1f, 0x3f, 0x7f, 0xff};
109         int value;
110         u_char *base = databuf;
111         char *intendp;
112         char letter;
113         char field_name[80];
114
115 #       define ARG_PUT(ARG) \
116         do \
117         { \
118                 if (!suppress) \
119                 { \
120                         if (arg_put) \
121                                 (*arg_put)(puthook, (letter == 't' ? \
122                                         'b' : letter), \
123                                         (void *)((long)(ARG)), width, \
124                                         field_name); \
125                         else \
126                                 *(va_arg(ap, int *)) = (ARG); \
127                         assigned++; \
128                 } \
129                 field_name[0] = 0; \
130                 suppress = 0; \
131         } while (0)
132
133         u_char bits = 0;        /* For bit fields */
134         int shift = 0;          /* Bits already shifted out */
135         suppress = 0;
136         field_name[0] = 0;
137
138         while (!done) {
139                 switch(letter = *fmt) {
140                 case ' ':       /* White space */
141                 case '\t':
142                 case '\r':
143                 case '\n':
144                 case '\f':
145                         fmt++;
146                         break;
147
148                 case '#':       /* Comment */
149                         while (*fmt && (*fmt != '\n'))
150                                 fmt++;
151                         if (fmt)
152                                 fmt++;  /* Skip '\n' */
153                         break;
154
155                 case '*':       /* Suppress assignment */
156                         fmt++;
157                         suppress = 1;
158                         break;
159
160                 case '{':       /* Field Name */
161                 {
162                         int i = 0;
163                         fmt++;  /* Skip '{' */
164                         while (*fmt && (*fmt != '}')) {
165                                 if (i < sizeof(field_name))
166                                         field_name[i++] = *fmt;
167
168                                 fmt++;
169                         }
170                         if (fmt)
171                                 fmt++;  /* Skip '}' */
172                         field_name[i] = 0;
173                         break;
174                 }
175
176                 case 't':       /* Bit (field) */
177                 case 'b':       /* Bits */
178                         fmt++;
179                         width = strtol(fmt, &intendp, 10);
180                         fmt = intendp;
181                         if (width > 8)
182                                 done = 1;
183                         else {
184                                 if (shift <= 0) {
185                                         bits = *databuf++;
186                                         shift = 8;
187                                 }
188                                 value = (bits >> (shift - width)) &
189                                          mask[width];
190
191 #if 0
192                                 printf("shift %2d bits %02x value %02x width %2d mask %02x\n",
193                                 shift, bits, value, width, mask[width]);
194 #endif
195
196                                 ARG_PUT(value);
197
198                                 shift -= width;
199                         }
200                         break;
201
202                 case 'i':       /* Integral values */
203                         shift = 0;
204                         fmt++;
205                         width = strtol(fmt, &intendp, 10);
206                         fmt = intendp;
207                         switch(width) {
208                         case 1:
209                                 ARG_PUT(*databuf);
210                                 databuf++;
211                                 break;
212
213                         case 2:
214                                 ARG_PUT((*databuf) << 8 | *(databuf + 1));
215                                 databuf += 2;
216                                 break;
217
218                         case 3:
219                                 ARG_PUT((*databuf) << 16 |
220                                         (*(databuf + 1)) << 8 | *(databuf + 2));
221                                 databuf += 3;
222                                 break;
223
224                         case 4:
225                                 ARG_PUT((*databuf) << 24 |
226                                         (*(databuf + 1)) << 16 |
227                                         (*(databuf + 2)) << 8 |
228                                         *(databuf + 3));
229                                 databuf += 4;
230                                 break;
231
232                         default:
233                                 done = 1;
234                                 break;
235                         }
236
237                         break;
238
239                 case 'c':       /* Characters (i.e., not swapped) */
240                 case 'z':       /* Characters with zeroed trailing
241                                            spaces  */
242                         shift = 0;
243                         fmt++;
244                         width = strtol(fmt, &intendp, 10);
245                         fmt = intendp;
246                         if (!suppress) {
247                                 if (arg_put)
248                                         (*arg_put)(puthook,
249                                                 (letter == 't' ? 'b' : letter),
250                                                 databuf, width, field_name);
251                                 else {
252                                         char *dest;
253                                         dest = va_arg(ap, char *);
254                                         bcopy(databuf, dest, width);
255                                         if (letter == 'z') {
256                                                 char *p;
257                                                 for (p = dest + width - 1;
258                                                      (p >= (char *)dest)
259                                                      && (*p == ' '); p--)
260                                                         *p = 0;
261                                         }
262                                 }
263                                 assigned++;
264                         }
265                         databuf += width;
266                         field_name[0] = 0;
267                         suppress = 0;
268                         break;
269
270                 case 's':       /* Seek */
271                         shift = 0;
272                         fmt++;
273                         if (*fmt == '+') {
274                                 plus = 1;
275                                 fmt++;
276                         } else
277                                 plus = 0;
278
279                         if (tolower(*fmt) == 'v') {
280                                 /*
281                                  * You can't suppress a seek value.  You also
282                                  * can't have a variable seek when you are using
283                                  * "arg_put".
284                                  */
285                                 width = (arg_put) ? 0 : va_arg(ap, int);
286                                 fmt++;
287                         } else {
288                                 width = strtol(fmt, &intendp, 10);
289                                 fmt = intendp;
290                         }
291
292                         if (plus)
293                                 databuf += width;       /* Relative seek */
294                         else
295                                 databuf = base + width; /* Absolute seek */
296
297                         break;
298
299                 case 0:
300                         done = 1;
301                         break;
302
303                 default:
304                         fprintf(stderr, "Unknown letter in format: %c\n",
305                                 letter);
306                         fmt++;
307                         break;
308                 }
309         }
310
311         return (assigned);
312 }
313
314 /* next_field: Return the next field in a command specifier.  This
315  * builds up a SCSI command using this trivial grammar:
316  *
317  * fields : field fields
318  *        ;
319  *
320  * field : value
321  *       | value ':' field_width
322  *       ;
323  *
324  * field_width : digit
325  *       | 'i' digit            // i2 = 2 byte integer, i3 = 3 byte integer etc.
326  *       ;
327  *
328  * value : HEX_NUMBER
329  *       | 'v'                          // For indirection.
330  *       ;
331  *
332  * Notes:
333  *  Bit fields are specified MSB first to match the SCSI spec.
334  *
335  * Examples:
336  *  TUR: "0 0 0 0 0 0"
337  *  WRITE BUFFER: "38 v:3 0:2 0:3 v v:i3 v:i3 0", mode, buffer_id, list_length
338  *
339  * The function returns the value:
340  *  0: For reached end, with error_p set if an error was found
341  *  1: For valid stuff setup
342  *  2: For "v" was entered as the value (implies use varargs)
343  *
344  */
345
346 static int
347 next_field(const char **pp, char *fmt, int *width_p, int *value_p, char *name,
348            int n_name, int *error_p, int *suppress_p)
349 {
350         const char *p = *pp;
351         char *intendp;
352
353         int something = 0;
354
355         enum {
356                 BETWEEN_FIELDS,
357                 START_FIELD,
358                 GET_FIELD,
359                 DONE,
360         } state;
361
362         int value = 0;
363         int field_size;         /* Default to byte field type... */
364         int field_width;        /* 1 byte wide */
365         int is_error = 0;
366         int suppress = 0;
367
368         field_size = 8;         /* Default to byte field type... */
369         *fmt = 'i';
370         field_width = 1;        /* 1 byte wide */
371         if (name)
372                 *name = 0;
373
374         state = BETWEEN_FIELDS;
375
376         while (state != DONE) {
377                 switch(state) {
378                 case BETWEEN_FIELDS:
379                         if (*p == 0)
380                                 state = DONE;
381                         else if (isspace(*p))
382                                 p++;
383                         else if (*p == '#') {
384                                 while (*p && *p != '\n')
385                                         p++;
386                                 if (p)
387                                         p++;
388                         } else if (*p == '{') {
389                                 int i = 0;
390
391                                 p++;
392
393                                 while (*p && *p != '}') {
394                                         if(name && i < n_name) {
395                                                 name[i] = *p;
396                                                 i++;
397                                         }
398                                         p++;
399                                 }
400
401                                 if(name && i < n_name)
402                                         name[i] = 0;
403
404                                 if (*p == '}')
405                                         p++;
406                         } else if (*p == '*') {
407                                 p++;
408                                 suppress = 1;
409                         } else if (isxdigit(*p)) {
410                                 something = 1;
411                                 value = strtol(p, &intendp, 16);
412                                 p = intendp;
413                                 state = START_FIELD;
414                         } else if (tolower(*p) == 'v') {
415                                 p++;
416                                 something = 2;
417                                 value = *value_p;
418                                 state = START_FIELD;
419                         } else if (tolower(*p) == 'i') {
420                                 /*
421                                  * Try to work without the "v".
422                                  */
423                                 something = 2;
424                                 value = *value_p;
425                                 p++;
426
427                                 *fmt = 'i';
428                                 field_size = 8;
429                                 field_width = strtol(p, &intendp, 10);
430                                 p = intendp;
431                                 state = DONE;
432
433                         } else if (tolower(*p) == 't') {
434                                 /*
435                                  * XXX: B can't work: Sees the 'b' as a
436                                  * hex digit in "isxdigit".  try "t" for
437                                  * bit field.
438                                  */
439                                 something = 2;
440                                 value = *value_p;
441                                 p++;
442
443                                 *fmt = 'b';
444                                 field_size = 1;
445                                 field_width = strtol(p, &intendp, 10);
446                                 p = intendp;
447                                 state = DONE;
448                         } else if (tolower(*p) == 's') {
449                                 /* Seek */
450                                 *fmt = 's';
451                                 p++;
452                                 if (tolower(*p) == 'v') {
453                                         p++;
454                                         something = 2;
455                                         value = *value_p;
456                                 } else {
457                                         something = 1;
458                                         value = strtol(p, &intendp, 0);
459                                         p = intendp;
460                                 }
461                                 state = DONE;
462                         } else {
463                                 fprintf(stderr, "Invalid starting "
464                                         "character: %c\n", *p);
465                                 is_error = 1;
466                                 state = DONE;
467                         }
468                         break;
469
470                 case START_FIELD:
471                         if (*p == ':') {
472                                 p++;
473                                 field_size = 1;         /* Default to bits
474                                                            when specified */
475                                 state = GET_FIELD;
476                         } else
477                                 state = DONE;
478                         break;
479
480                 case GET_FIELD:
481                         if (isdigit(*p)) {
482                                 *fmt = 'b';
483                                 field_size = 1;
484                                 field_width = strtol(p, &intendp, 10);
485                                 p = intendp;
486                                 state = DONE;
487                         } else if (*p == 'i') {
488
489                                 /* Integral (bytes) */
490                                 p++;
491
492                                 *fmt = 'i';
493                                 field_size = 8;
494                                 field_width = strtol(p, &intendp, 10);
495                                 p = intendp;
496                                 state = DONE;
497                         } else if (*p == 'b') {
498
499                                 /* Bits */
500                                 p++;
501
502                                 *fmt = 'b';
503                                 field_size = 1;
504                                 field_width = strtol(p, &intendp, 10);
505                                 p = intendp;
506                                 state = DONE;
507                         } else {
508                                 fprintf(stderr, "Invalid startfield %c "
509                                         "(%02x)\n", *p, *p);
510                                 is_error = 1;
511                                 state = DONE;
512                         }
513                         break;
514
515                 case DONE:
516                         break;
517                 }
518         }
519
520         if (is_error) {
521                 *error_p = 1;
522                 return 0;
523         }
524
525         *error_p = 0;
526         *pp = p;
527         *width_p = field_width * field_size;
528         *value_p = value;
529         *suppress_p = suppress;
530
531         return (something);
532 }
533
534 static int
535 do_encode(u_char *buff, size_t vec_max, size_t *used,
536           int (*arg_get)(void *, char *), void *gethook, const char *fmt,
537           va_list ap)
538 {
539         int ind;
540         int shift;
541         u_char val;
542         int ret;
543         int width, value, error, suppress;
544         char c;
545         int encoded = 0;
546         char field_name[80];
547
548         ind = 0;
549         shift = 0;
550         val = 0;
551
552         while ((ret = next_field(&fmt, &c, &width, &value, field_name,
553                                  sizeof(field_name), &error, &suppress))) {
554                 encoded++;
555
556                 if (ret == 2) {
557                         if (suppress)
558                                 value = 0;
559                         else
560                                 value = arg_get ?
561                                         (*arg_get)(gethook, field_name) :
562                                         va_arg(ap, int);
563                 }
564
565 #if 0
566                 printf(
567 "do_encode: ret %d fmt %c width %d value %d name \"%s\" error %d suppress %d\n",
568                 ret, c, width, value, field_name, error, suppress);
569 #endif
570                 /* Absolute seek */
571                 if (c == 's') {
572                         ind = value;
573                         continue;
574                 }
575
576                 /* A width of < 8 is a bit field. */
577                 if (width < 8) {
578
579                         /* This is a bit field.  We start with the high bits
580                          * so it reads the same as the SCSI spec.
581                          */
582
583                         shift += width;
584
585                         val |= (value << (8 - shift));
586
587                         if (shift == 8) {
588                                 if (ind < vec_max) {
589                                         buff[ind++] = val;
590                                         val = 0;
591                                 }
592                                 shift = 0;
593                         }
594                 } else {
595                         if (shift) {
596                                 if (ind < vec_max) {
597                                         buff[ind++] = val;
598                                         val = 0;
599                                 }
600                                 shift = 0;
601                         }
602                         switch(width) {
603                         case 8:         /* 1 byte integer */
604                                 if (ind < vec_max)
605                                         buff[ind++] = value;
606                                 break;
607
608                         case 16:        /* 2 byte integer */
609                                 if (ind < vec_max - 2 + 1) {
610                                         buff[ind++] = value >> 8;
611                                         buff[ind++] = value;
612                                 }
613                                 break;
614
615                         case 24:        /* 3 byte integer */
616                                 if (ind < vec_max - 3 + 1) {
617                                         buff[ind++] = value >> 16;
618                                         buff[ind++] = value >> 8;
619                                         buff[ind++] = value;
620                                 }
621                                 break;
622
623                         case 32:        /* 4 byte integer */
624                                 if (ind < vec_max - 4 + 1) {
625                                         buff[ind++] = value >> 24;
626                                         buff[ind++] = value >> 16;
627                                         buff[ind++] = value >> 8;
628                                         buff[ind++] = value;
629                                 }
630                                 break;
631
632                         default:
633                                 fprintf(stderr, "do_encode: Illegal width\n");
634                                 break;
635                         }
636                 }
637         }
638
639         /* Flush out any remaining bits
640          */
641         if (shift && ind < vec_max)
642                 buff[ind++] = val;
643
644         if (used)
645                 *used = ind;
646
647         if (error)
648                 return -1;
649
650         return encoded;
651 }
652
653 int
654 csio_decode(struct ccb_scsiio *csio, const char *fmt, ...)
655 {
656         va_list ap;
657
658         va_start(ap, fmt);
659
660         return(do_buff_decode(csio->data_ptr, (size_t)csio->dxfer_len,
661                               0, 0, fmt, ap));
662 }
663
664 int
665 csio_decode_visit(struct ccb_scsiio *csio, const char *fmt,
666                   void (*arg_put)(void *, int, void *, int, char *),
667                   void *puthook)
668 {
669         va_list ap;
670
671         /*
672          * We need some way to output things; we can't do it without
673          * the arg_put function.
674          */
675         if (arg_put == NULL)
676                 return(-1);
677
678         bzero(&ap, sizeof(ap));
679
680         return(do_buff_decode(csio->data_ptr, (size_t)csio->dxfer_len,
681                               arg_put, puthook, fmt, ap));
682 }
683
684 int
685 buff_decode(u_int8_t *buff, size_t len, const char *fmt, ...)
686 {
687         va_list ap;
688
689         va_start(ap, fmt);
690
691         return(do_buff_decode(buff, len, 0, 0, fmt, ap));
692 }
693
694 int
695 buff_decode_visit(u_int8_t *buff, size_t len, const char *fmt,
696                   void (*arg_put)(void *, int, void *, int, char *),
697                   void *puthook)
698 {
699         va_list ap;
700
701         /*
702          * We need some way to output things; we can't do it without
703          * the arg_put function.
704          */
705         if (arg_put == NULL)
706                 return(-1);
707
708         bzero(&ap, sizeof(ap));
709
710         return(do_buff_decode(buff, len, arg_put, puthook, fmt, ap));
711 }
712
713 /*
714  * Build a SCSI CCB, given the command and data pointers and a format
715  * string describing the 
716  */
717 int
718 csio_build(struct ccb_scsiio *csio, u_int8_t *data_ptr, u_int32_t dxfer_len,
719            u_int32_t flags, int retry_count, int timeout, const char *cmd_spec,
720            ...)
721 {
722         size_t cmdlen;
723         int retval;
724         va_list ap;
725
726         if (csio == NULL)
727                 return(0);
728
729         bzero(csio, sizeof(struct ccb_scsiio));
730
731         va_start(ap, cmd_spec);
732
733         if ((retval = do_encode(csio->cdb_io.cdb_bytes, SCSI_MAX_CDBLEN,
734                                 &cmdlen, NULL, NULL, cmd_spec, ap)) == -1)
735                 return(retval);
736
737         cam_fill_csio(csio,
738                       /* retries */ retry_count,
739                       /* cbfcnp */ NULL,
740                       /* flags */ flags,
741                       /* tag_action */ MSG_SIMPLE_Q_TAG,
742                       /* data_ptr */ data_ptr,
743                       /* dxfer_len */ dxfer_len,
744                       /* sense_len */ SSD_FULL_SIZE,
745                       /* cdb_len */ cmdlen,
746                       /* timeout */ timeout ? timeout : 5000);
747
748         return(retval);
749 }
750
751 int
752 csio_build_visit(struct ccb_scsiio *csio, u_int8_t *data_ptr,
753                  u_int32_t dxfer_len, u_int32_t flags, int retry_count,
754                  int timeout, const char *cmd_spec,
755                  int (*arg_get)(void *hook, char *field_name), void *gethook)
756 {
757         va_list ap;
758         size_t cmdlen;
759         int retval;
760
761         if (csio == NULL)
762                 return(0);
763
764         /*
765          * We need something to encode, but we can't get it without the
766          * arg_get function.
767          */
768         if (arg_get == NULL)
769                 return(-1);
770
771         bzero(&ap, sizeof(ap));
772
773         bzero(csio, sizeof(struct ccb_scsiio));
774
775         if ((retval = do_encode(csio->cdb_io.cdb_bytes, SCSI_MAX_CDBLEN,
776                                 &cmdlen, arg_get, gethook, cmd_spec, ap)) == -1)
777                 return(retval);
778
779         cam_fill_csio(csio,
780                       /* retries */ retry_count,
781                       /* cbfcnp */ NULL,
782                       /* flags */ flags,
783                       /* tag_action */ MSG_SIMPLE_Q_TAG,
784                       /* data_ptr */ data_ptr,
785                       /* dxfer_len */ dxfer_len,
786                       /* sense_len */ SSD_FULL_SIZE,
787                       /* cdb_len */ cmdlen,
788                       /* timeout */ timeout ? timeout : 5000);
789
790         return(retval);
791 }
792
793 int
794 csio_encode(struct ccb_scsiio *csio, const char *fmt, ...)
795 {
796         va_list ap;
797
798         if (csio == NULL)
799                 return(0);
800
801         va_start(ap, fmt);
802
803         return(do_encode(csio->data_ptr, csio->dxfer_len, 0, 0, 0, fmt, ap));
804 }
805
806 int
807 buff_encode_visit(u_int8_t *buff, size_t len, const char *fmt,
808                   int (*arg_get)(void *hook, char *field_name), void *gethook)
809 {
810         va_list ap;
811
812         /*
813          * We need something to encode, but we can't get it without the
814          * arg_get function.
815          */
816         if (arg_get == NULL)
817                 return(-1);
818
819         bzero(&ap, sizeof(ap));
820
821         return(do_encode(buff, len, 0, arg_get, gethook, fmt, ap));
822 }
823
824 int
825 csio_encode_visit(struct ccb_scsiio *csio, const char *fmt,
826                   int (*arg_get)(void *hook, char *field_name), void *gethook)
827 {
828         va_list ap;
829
830         /*
831          * We need something to encode, but we can't get it without the
832          * arg_get function.
833          */
834         if (arg_get == NULL)
835                 return(-1);
836
837         bzero(&ap, sizeof(ap));
838
839         return(do_encode(csio->data_ptr, csio->dxfer_len, 0, arg_get,
840                          gethook, fmt, ap));
841 }