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 (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 *
25 * Copyright 2014 Nexenta Systems, Inc. All rights reserved.
26 */
27
28 /*
29 * Msgbuf buffer management implementation. The smb_msgbuf interface is
30 * typically used to encode or decode SMB data using sprintf/scanf
31 * style operations. It contains special handling for the SMB header.
32 * It can also be used for general purpose encoding and decoding.
33 */
34
35 #include <sys/types.h>
36 #include <sys/varargs.h>
37 #include <sys/byteorder.h>
38 #if !defined(_KERNEL) && !defined(_FAKE_KERNEL)
39 #include <stdlib.h>
40 #include <syslog.h>
41 #include <string.h>
42 #include <strings.h>
43 #else
44 #include <sys/sunddi.h>
45 #include <sys/kmem.h>
46 #endif
47 #include <smbsrv/string.h>
48 #include <smbsrv/msgbuf.h>
49 #include <smbsrv/smb.h>
50
51 static int buf_decode(smb_msgbuf_t *, char *, va_list ap);
52 static int buf_encode(smb_msgbuf_t *, char *, va_list ap);
53 static void *smb_msgbuf_malloc(smb_msgbuf_t *, size_t);
54 static int smb_msgbuf_chkerc(char *text, int erc);
55
56 /*
57 * Returns the offset or number of bytes used within the buffer.
58 */
59 size_t
60 smb_msgbuf_used(smb_msgbuf_t *mb)
61 {
62 /*LINTED E_PTRDIFF_OVERFLOW*/
63 return (mb->scan - mb->base);
64 }
65
66 /*
67 * Returns the actual buffer size.
68 */
69 size_t
70 smb_msgbuf_size(smb_msgbuf_t *mb)
71 {
72 return (mb->max);
73 }
74
75 uint8_t *
76 smb_msgbuf_base(smb_msgbuf_t *mb)
77 {
78 return (mb->base);
79 }
80
81 /*
82 * Ensure that the scan is aligned on a word (16-bit) boundary.
83 */
84 void
85 smb_msgbuf_word_align(smb_msgbuf_t *mb)
86 {
87 mb->scan = (uint8_t *)((uintptr_t)(mb->scan + 1) & ~1);
88 }
89
90 /*
91 * Ensure that the scan is aligned on a dword (32-bit) boundary.
92 */
93 void
94 smb_msgbuf_dword_align(smb_msgbuf_t *mb)
95 {
96 mb->scan = (uint8_t *)((uintptr_t)(mb->scan + 3) & ~3);
97 }
98
99 /*
100 * Checks whether or not the buffer has space for the amount of data
101 * specified. Returns 1 if there is space, otherwise returns 0.
102 */
103 int
104 smb_msgbuf_has_space(smb_msgbuf_t *mb, size_t size)
105 {
106 if (size > mb->max || (mb->scan + size) > mb->end)
107 return (0);
108
109 return (1);
110 }
111
112 /*
113 * Set flags the smb_msgbuf.
114 */
115 void
116 smb_msgbuf_fset(smb_msgbuf_t *mb, uint32_t flags)
117 {
118 mb->flags |= flags;
119 }
120
121 /*
122 * Clear flags the smb_msgbuf.
123 */
124 void
125 smb_msgbuf_fclear(smb_msgbuf_t *mb, uint32_t flags)
126 {
127 mb->flags &= ~flags;
128 }
129
130 /*
131 * smb_msgbuf_init
132 *
133 * Initialize a smb_msgbuf_t structure based on the buffer and size
134 * specified. Both scan and base initially point to the beginning
135 * of the buffer and end points to the limit of the buffer. As
136 * data is added scan should be incremented to point to the next
137 * offset at which data will be written. Max and count are set
138 * to the actual buffer size.
139 */
140 void
141 smb_msgbuf_init(smb_msgbuf_t *mb, uint8_t *buf, size_t size, uint32_t flags)
142 {
143 mb->scan = mb->base = buf;
144 mb->max = mb->count = size;
145 mb->end = &buf[size];
146 mb->flags = flags;
147 mb->mlist.next = 0;
148 }
149
150
151 /*
152 * smb_msgbuf_term
153 *
154 * Destruct a smb_msgbuf_t. Free any memory hanging off the mlist.
155 */
156 void
157 smb_msgbuf_term(smb_msgbuf_t *mb)
158 {
159 smb_msgbuf_mlist_t *item = mb->mlist.next;
160 smb_msgbuf_mlist_t *tmp;
161
162 while (item) {
163 tmp = item;
164 item = item->next;
165 #if !defined(_KERNEL) && !defined(_FAKE_KERNEL)
166 free(tmp);
167 #else
168 kmem_free(tmp, tmp->size);
169 #endif
170 }
171 }
172
173
174 /*
175 * smb_msgbuf_decode
176 *
177 * Decode a smb_msgbuf buffer as indicated by the format string into
178 * the variable arg list. This is similar to a scanf operation.
179 *
180 * On success, returns the number of bytes encoded. Otherwise
181 * returns a -ve error code.
182 */
183 int
184 smb_msgbuf_decode(smb_msgbuf_t *mb, char *fmt, ...)
185 {
186 int rc;
187 uint8_t *orig_scan;
188 va_list ap;
189
190 va_start(ap, fmt);
191 orig_scan = mb->scan;
192 rc = buf_decode(mb, fmt, ap);
193 va_end(ap);
194
195 if (rc != SMB_MSGBUF_SUCCESS) {
196 (void) smb_msgbuf_chkerc("smb_msgbuf_decode", rc);
197 mb->scan = orig_scan;
198 return (rc);
199 }
200
201 /*LINTED E_PTRDIFF_OVERFLOW*/
202 return (mb->scan - orig_scan);
203 }
204
205
206 /*
207 * buf_decode
208 *
209 * Private decode function, where the real work of decoding the smb_msgbuf
210 * is done. This function should only be called via smb_msgbuf_decode to
211 * ensure correct behaviour and error handling.
212 */
213 static int
214 buf_decode(smb_msgbuf_t *mb, char *fmt, va_list ap)
215 {
216 uint32_t ival;
217 uint8_t c;
218 uint8_t *bvalp;
219 uint16_t *wvalp;
220 uint32_t *lvalp;
221 uint64_t *llvalp;
222 char *cvalp;
223 char **cvalpp;
224 smb_wchar_t wchar;
225 boolean_t repc_specified;
226 int repc;
227 int rc;
228
229 while ((c = *fmt++) != 0) {
230 repc_specified = B_FALSE;
231 repc = 1;
232
233 if (c == ' ' || c == '\t')
234 continue;
235
236 if (c == '(') {
237 while (((c = *fmt++) != 0) && c != ')')
238 ;
239
240 if (!c)
241 return (SMB_MSGBUF_SUCCESS);
242
243 continue;
244 }
245
246 if ('0' <= c && c <= '9') {
247 repc = 0;
248 do {
249 repc = repc * 10 + c - '0';
250 c = *fmt++;
251 } while ('0' <= c && c <= '9');
252 repc_specified = B_TRUE;
253 } else if (c == '#') {
254 repc = va_arg(ap, int);
255 c = *fmt++;
256 repc_specified = B_TRUE;
257 }
258
259 switch (c) {
260 case '.':
261 if (smb_msgbuf_has_space(mb, repc) == 0)
262 return (SMB_MSGBUF_UNDERFLOW);
263
264 mb->scan += repc;
265 break;
266
267 case 'c': /* get char */
268 if (smb_msgbuf_has_space(mb, repc) == 0)
269 return (SMB_MSGBUF_UNDERFLOW);
270
271 bvalp = va_arg(ap, uint8_t *);
272 bcopy(mb->scan, bvalp, repc);
273 mb->scan += repc;
274 break;
275
276 case 'b': /* get byte */
277 if (smb_msgbuf_has_space(mb, repc) == 0)
278 return (SMB_MSGBUF_UNDERFLOW);
279
280 bvalp = va_arg(ap, uint8_t *);
281 while (repc-- > 0) {
282 *bvalp++ = *mb->scan++;
283 }
284 break;
285
286 case 'w': /* get word */
287 rc = smb_msgbuf_has_space(mb, repc * sizeof (uint16_t));
288 if (rc == 0)
289 return (SMB_MSGBUF_UNDERFLOW);
290
291 wvalp = va_arg(ap, uint16_t *);
292 while (repc-- > 0) {
293 *wvalp++ = LE_IN16(mb->scan);
294 mb->scan += sizeof (uint16_t);
295 }
296 break;
297
298 case 'l': /* get long */
299 rc = smb_msgbuf_has_space(mb, repc * sizeof (int32_t));
300 if (rc == 0)
301 return (SMB_MSGBUF_UNDERFLOW);
302
303 lvalp = va_arg(ap, uint32_t *);
304 while (repc-- > 0) {
305 *lvalp++ = LE_IN32(mb->scan);
306 mb->scan += sizeof (int32_t);
307 }
308 break;
309
310 case 'q': /* get quad */
311 rc = smb_msgbuf_has_space(mb, repc * sizeof (int64_t));
312 if (rc == 0)
313 return (SMB_MSGBUF_UNDERFLOW);
314
315 llvalp = va_arg(ap, uint64_t *);
316 while (repc-- > 0) {
317 *llvalp++ = LE_IN64(mb->scan);
318 mb->scan += sizeof (int64_t);
319 }
320 break;
321
322 case 'u': /* Convert from unicode if flags are set */
323 if (mb->flags & SMB_MSGBUF_UNICODE)
324 goto unicode_translation;
325 /*FALLTHROUGH*/
326
327 case 's': /* get string */
328 if (!repc_specified)
329 repc = strlen((const char *)mb->scan) + 1;
330 if (smb_msgbuf_has_space(mb, repc) == 0)
331 return (SMB_MSGBUF_UNDERFLOW);
332 if ((cvalp = smb_msgbuf_malloc(mb, repc * 2)) == 0)
333 return (SMB_MSGBUF_UNDERFLOW);
334 cvalpp = va_arg(ap, char **);
335 *cvalpp = cvalp;
336 /* Translate OEM to mbs */
337 while (repc > 0) {
338 wchar = *mb->scan++;
339 repc--;
340 if (wchar == 0)
341 break;
342 ival = smb_wctomb(cvalp, wchar);
343 cvalp += ival;
344 }
345 *cvalp = '\0';
346 if (repc > 0)
347 mb->scan += repc;
348 break;
349
350 case 'U': /* get unicode string */
351 unicode_translation:
352 /*
353 * Unicode strings are always word aligned.
354 * The malloc'd area is larger than the
355 * original string because the UTF-8 chars
356 * may be longer than the wide-chars.
357 */
358 smb_msgbuf_word_align(mb);
359 if (!repc_specified) {
360 /*
361 * Count bytes, including the null.
362 */
363 uint8_t *tmp_scan = mb->scan;
364 repc = 2; /* the null */
365 while ((wchar = LE_IN16(tmp_scan)) != 0) {
366 tmp_scan += 2;
367 repc += 2;
368 }
369 }
370 if (smb_msgbuf_has_space(mb, repc) == 0)
371 return (SMB_MSGBUF_UNDERFLOW);
372 /*
373 * Get space for translated string
374 * Allocates worst-case size.
375 */
376 if ((cvalp = smb_msgbuf_malloc(mb, repc * 2)) == 0)
377 return (SMB_MSGBUF_UNDERFLOW);
378 cvalpp = va_arg(ap, char **);
379 *cvalpp = cvalp;
380 /*
381 * Translate unicode to mbs, stopping after
382 * null or repc limit.
383 */
384 while (repc >= 2) {
385 wchar = LE_IN16(mb->scan);
386 mb->scan += 2;
387 repc -= 2;
388 if (wchar == 0)
389 break;
390 ival = smb_wctomb(cvalp, wchar);
391 cvalp += ival;
392 }
393 *cvalp = '\0';
394 if (repc > 0)
395 mb->scan += repc;
396 break;
397
398 case 'M':
399 if (smb_msgbuf_has_space(mb, 4) == 0)
400 return (SMB_MSGBUF_UNDERFLOW);
401
402 if (mb->scan[0] != 0xFF ||
403 mb->scan[1] != 'S' ||
404 mb->scan[2] != 'M' ||
405 mb->scan[3] != 'B') {
406 return (SMB_MSGBUF_INVALID_HEADER);
407 }
408 mb->scan += 4;
409 break;
410
411 default:
412 return (SMB_MSGBUF_INVALID_FORMAT);
413 }
414 }
415
416 return (SMB_MSGBUF_SUCCESS);
417 }
418
419
420 /*
421 * smb_msgbuf_encode
422 *
423 * Encode a smb_msgbuf buffer as indicated by the format string using
424 * the variable arg list. This is similar to a sprintf operation.
425 *
426 * On success, returns the number of bytes encoded. Otherwise
427 * returns a -ve error code.
428 */
429 int
430 smb_msgbuf_encode(smb_msgbuf_t *mb, char *fmt, ...)
431 {
432 int rc;
433 uint8_t *orig_scan;
434 va_list ap;
435
436 va_start(ap, fmt);
437 orig_scan = mb->scan;
438 rc = buf_encode(mb, fmt, ap);
439 va_end(ap);
440
441 if (rc != SMB_MSGBUF_SUCCESS) {
442 (void) smb_msgbuf_chkerc("smb_msgbuf_encode", rc);
443 mb->scan = orig_scan;
444 return (rc);
445 }
446
447 /*LINTED E_PTRDIFF_OVERFLOW*/
448 return (mb->scan - orig_scan);
449 }
450
451
452 /*
453 * buf_encode
454 *
455 * Private encode function, where the real work of encoding the smb_msgbuf
456 * is done. This function should only be called via smb_msgbuf_encode to
457 * ensure correct behaviour and error handling.
458 */
459 static int
460 buf_encode(smb_msgbuf_t *mb, char *fmt, va_list ap)
461 {
462 uint8_t cval;
463 uint16_t wval;
464 uint32_t lval;
465 uint64_t llval;
466 uint8_t *bvalp;
467 char *cvalp;
468 uint8_t c;
469 smb_wchar_t wchar;
470 int count;
471 boolean_t repc_specified;
472 int repc;
473 int rc;
474
475 while ((c = *fmt++) != 0) {
476 repc_specified = B_FALSE;
477 repc = 1;
478
479 if (c == ' ' || c == '\t')
480 continue;
481
482 if (c == '(') {
483 while (((c = *fmt++) != 0) && c != ')')
484 ;
485
486 if (!c)
487 return (SMB_MSGBUF_SUCCESS);
488
489 continue;
490 }
491
492 if ('0' <= c && c <= '9') {
493 repc = 0;
494 do {
495 repc = repc * 10 + c - '0';
496 c = *fmt++;
497 } while ('0' <= c && c <= '9');
498 repc_specified = B_TRUE;
499 } else if (c == '#') {
500 repc = va_arg(ap, int);
501 c = *fmt++;
502 repc_specified = B_TRUE;
503 }
504
505 switch (c) {
506 case '.':
507 if (smb_msgbuf_has_space(mb, repc) == 0)
508 return (SMB_MSGBUF_OVERFLOW);
509
510 while (repc-- > 0)
511 *mb->scan++ = 0;
512 break;
513
514 case 'c': /* put char */
515 if (smb_msgbuf_has_space(mb, repc) == 0)
516 return (SMB_MSGBUF_OVERFLOW);
517
518 bvalp = va_arg(ap, uint8_t *);
519 bcopy(bvalp, mb->scan, repc);
520 mb->scan += repc;
521 break;
522
523 case 'b': /* put byte */
524 if (smb_msgbuf_has_space(mb, repc) == 0)
525 return (SMB_MSGBUF_OVERFLOW);
526
527 while (repc-- > 0) {
528 cval = va_arg(ap, int);
529 *mb->scan++ = cval;
530 }
531 break;
532
533 case 'w': /* put word */
534 rc = smb_msgbuf_has_space(mb, repc * sizeof (uint16_t));
535 if (rc == 0)
536 return (SMB_MSGBUF_OVERFLOW);
537
538 while (repc-- > 0) {
539 wval = va_arg(ap, int);
540 LE_OUT16(mb->scan, wval);
541 mb->scan += sizeof (uint16_t);
542 }
543 break;
544
545 case 'l': /* put long */
546 rc = smb_msgbuf_has_space(mb, repc * sizeof (int32_t));
547 if (rc == 0)
548 return (SMB_MSGBUF_OVERFLOW);
549
550 while (repc-- > 0) {
551 lval = va_arg(ap, uint32_t);
552 LE_OUT32(mb->scan, lval);
553 mb->scan += sizeof (int32_t);
554 }
555 break;
556
557 case 'q': /* put quad */
558 rc = smb_msgbuf_has_space(mb, repc * sizeof (int64_t));
559 if (rc == 0)
560 return (SMB_MSGBUF_OVERFLOW);
561
562 while (repc-- > 0) {
563 llval = va_arg(ap, uint64_t);
564 LE_OUT64(mb->scan, llval);
565 mb->scan += sizeof (uint64_t);
566 }
567 break;
568
569 case 'u': /* conditional unicode */
570 if (mb->flags & SMB_MSGBUF_UNICODE)
571 goto unicode_translation;
572 /* FALLTHROUGH */
573
574 case 's': /* put string */
575 cvalp = va_arg(ap, char *);
576 if (!repc_specified) {
577 repc = smb_sbequiv_strlen(cvalp);
578 if (repc == -1)
579 return (SMB_MSGBUF_OVERFLOW);
580 if (!(mb->flags & SMB_MSGBUF_NOTERM))
581 repc++;
582 }
583 if (smb_msgbuf_has_space(mb, repc) == 0)
584 return (SMB_MSGBUF_OVERFLOW);
585 while (repc > 0) {
586 count = smb_mbtowc(&wchar, cvalp,
587 MTS_MB_CHAR_MAX);
588 if (count < 0)
589 return (SMB_MSGBUF_DATA_ERROR);
590 cvalp += count;
591 if (wchar == 0)
592 break;
593 *mb->scan++ = (uint8_t)wchar;
594 repc--;
595 if (wchar & 0xff00) {
596 *mb->scan++ = wchar >> 8;
597 repc--;
598 }
599 }
600 if (*cvalp == '\0' && repc > 0 &&
601 (mb->flags & SMB_MSGBUF_NOTERM) == 0) {
602 *mb->scan++ = 0;
603 repc--;
604 }
605 while (repc > 0) {
606 *mb->scan++ = 0;
607 repc--;
608 }
609 break;
610
611 case 'U': /* put unicode string */
612 unicode_translation:
613 /*
614 * Unicode strings are always word aligned.
615 */
616 smb_msgbuf_word_align(mb);
617 cvalp = va_arg(ap, char *);
618 if (!repc_specified) {
619 repc = smb_wcequiv_strlen(cvalp);
620 if (!(mb->flags & SMB_MSGBUF_NOTERM))
621 repc += 2;
622 }
623 if (!smb_msgbuf_has_space(mb, repc))
624 return (SMB_MSGBUF_OVERFLOW);
625 while (repc >= 2) {
626 count = smb_mbtowc(&wchar, cvalp,
627 MTS_MB_CHAR_MAX);
628 if (count < 0)
629 return (SMB_MSGBUF_DATA_ERROR);
630 cvalp += count;
631 if (wchar == 0)
632 break;
633
634 LE_OUT16(mb->scan, wchar);
635 mb->scan += 2;
636 repc -= 2;
637 }
638 if (*cvalp == '\0' && repc >= 2 &&
639 (mb->flags & SMB_MSGBUF_NOTERM) == 0) {
640 LE_OUT16(mb->scan, 0);
641 mb->scan += 2;
642 repc -= 2;
643 }
644 while (repc > 0) {
645 *mb->scan++ = 0;
646 repc--;
647 }
648 break;
649
650 case 'M':
651 if (smb_msgbuf_has_space(mb, 4) == 0)
652 return (SMB_MSGBUF_OVERFLOW);
653
654 *mb->scan++ = 0xFF;
655 *mb->scan++ = 'S';
656 *mb->scan++ = 'M';
657 *mb->scan++ = 'B';
658 break;
659
660 default:
661 return (SMB_MSGBUF_INVALID_FORMAT);
662 }
663 }
664
665 return (SMB_MSGBUF_SUCCESS);
666 }
667
668
669 /*
670 * smb_msgbuf_malloc
671 *
672 * Allocate some memory for use with this smb_msgbuf. We increase the
673 * requested size to hold the list pointer and return a pointer
674 * to the area for use by the caller.
675 */
676 static void *
677 smb_msgbuf_malloc(smb_msgbuf_t *mb, size_t size)
678 {
679 smb_msgbuf_mlist_t *item;
680
681 size += sizeof (smb_msgbuf_mlist_t);
682
683 #if !defined(_KERNEL) && !defined(_FAKE_KERNEL)
684 if ((item = malloc(size)) == NULL)
685 return (NULL);
686 #else
687 item = kmem_alloc(size, KM_SLEEP);
688 #endif
689 item->next = mb->mlist.next;
690 item->size = size;
691 mb->mlist.next = item;
692
693 /*
694 * The caller gets a pointer to the address
695 * immediately after the smb_msgbuf_mlist_t.
696 */
697 return ((void *)(item + 1));
698 }
699
700
701 /*
702 * smb_msgbuf_chkerc
703 *
704 * Diagnostic function to write an appropriate message to the system log.
705 */
706 static int
707 smb_msgbuf_chkerc(char *text, int erc)
708 {
709 static struct {
710 int erc;
711 char *name;
712 } etable[] = {
713 { SMB_MSGBUF_SUCCESS, "success" },
714 { SMB_MSGBUF_UNDERFLOW, "overflow/underflow" },
715 { SMB_MSGBUF_INVALID_FORMAT, "invalid format" },
716 { SMB_MSGBUF_INVALID_HEADER, "invalid header" },
717 { SMB_MSGBUF_DATA_ERROR, "data error" }
718 };
719
720 int i;
721
722 for (i = 0; i < sizeof (etable)/sizeof (etable[0]); ++i) {
723 if (etable[i].erc == erc) {
724 if (text == 0)
725 text = "smb_msgbuf_chkerc";
726 break;
727 }
728 }
729 return (erc);
730 }