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