xref: /illumos-gate/usr/src/cmd/smbsrv/test-msgbuf/test_mbmarshal.c (revision 897907ce12f040adf70d35697d537c9d72b35285)
1 /*
2  * This file and its contents are supplied under the terms of the
3  * Common Development and Distribution License ("CDDL"), version 1.0.
4  * You may only use this file in accordance with the terms of version
5  * 1.0 of the CDDL.
6  *
7  * A full copy of the text of the CDDL should have accompanied this
8  * source.  A copy of the CDDL is also available via the Internet at
9  * http://www.illumos.org/license/CDDL.
10  */
11 
12 /*
13  * Copyright 2018-2021 Tintri by DDN, Inc. All rights reserved.
14  */
15 
16 /*
17  * Test putting/getting unicode strings in mbchains.
18  */
19 
20 #include <sys/types.h>
21 #include <sys/debug.h>
22 #include <sys/varargs.h>
23 #include <smbsrv/smb_kproto.h>
24 #include <stdio.h>
25 #include <string.h>
26 #include <strings.h>
27 
28 #include "test_defs.h"
29 
30 static char mbsa[] = "A\xef\xbc\xa1.";		// A fwA . (5)
31 static char mbsp[] = "P\xf0\x9f\x92\xa9.";	// P poop . (6)
32 static smb_wchar_t wcsa[] = { 'A', 0xff21, '.', 0 };	// (3)
33 static smb_wchar_t wcsp[] = { 'P', 0xd83d, 0xdca9, '.', 0 }; // (4)
34 
35 smb_session_t test_ssn;
36 smb_request_t test_sr;
37 
38 /*
39  * Put ASCII string with NULL
40  */
41 static void
mbm_put_a0()42 mbm_put_a0()
43 {
44 	uint8_t wire[] = { 'o', 'n', 'e', 0, 42, 0 };
45 	mbuf_chain_t *mbc;
46 	int rc;
47 
48 	mbc = smb_mbc_alloc(100);
49 
50 	rc = smb_mbc_encodef(mbc, "sw", "one", 42);
51 	if (rc != 0) {
52 		printf("Fail: mbm_put_a0 encode\n");
53 		goto out;
54 	}
55 	if (mbc->chain->m_len != 6) {
56 		printf("Fail: mbm_put_a0 len=%d\n",
57 		    mbc->chain->m_len);
58 		return;
59 	}
60 
61 	if (memcmp(mbc->chain->m_data, wire, 6)) {
62 		printf("Fail: mbm_put_a0 cmp:\n");
63 		hexdump((uchar_t *)mbc->chain->m_data, 6);
64 		return;
65 	}
66 
67 	printf("Pass: mbm_put_a0\n");
68 
69 out:
70 	smb_mbc_free(mbc);
71 }
72 
73 /*
74  * Put ASCII string, no NULL
75  */
76 static void
mbm_put_a1()77 mbm_put_a1()
78 {
79 	uint8_t wire[] = { 'o', 'n', 'e', '.', 42, 0 };
80 	mbuf_chain_t *mbc;
81 	int rc;
82 
83 	mbc = smb_mbc_alloc(100);
84 
85 	rc = smb_mbc_encodef(mbc, "4sw", "one.", 42);
86 	if (rc != 0) {
87 		printf("Fail: mbm_put_a1 encode\n");
88 		goto out;
89 	}
90 	if (mbc->chain->m_len != 6) {
91 		printf("Fail: mbm_put_a1 len=%d\n",
92 		    mbc->chain->m_len);
93 		return;
94 	}
95 
96 	if (memcmp(mbc->chain->m_data, wire, 6)) {
97 		printf("Fail: mbm_put_a1 cmp:\n");
98 		hexdump((uchar_t *)mbc->chain->m_data, 6);
99 		return;
100 	}
101 
102 	printf("Pass: mbm_put_a1\n");
103 
104 out:
105 	smb_mbc_free(mbc);
106 }
107 
108 static void
mbm_put_apad()109 mbm_put_apad()
110 {
111 	uint8_t wire[] = { 'o', 'n', 'e', 0, 0 };
112 	mbuf_chain_t *mbc;
113 	int rc;
114 
115 	mbc = smb_mbc_alloc(100);
116 
117 	/* Encode with wire length > strlen */
118 	rc = smb_mbc_encodef(mbc, "5s", "one");
119 	if (rc != 0) {
120 		printf("Fail: mbm_put_apad encode\n");
121 		goto out;
122 	}
123 	if (mbc->chain->m_len != 5) {
124 		printf("Fail: mbm_put_apad len=%d\n",
125 		    mbc->chain->m_len);
126 		return;
127 	}
128 
129 	if (memcmp(mbc->chain->m_data, wire, 5)) {
130 		printf("Fail: mbm_put_apad cmp:\n");
131 		hexdump((uchar_t *)mbc->chain->m_data, 5);
132 		return;
133 	}
134 
135 	printf("Pass: mbm_put_apad\n");
136 
137 out:
138 	smb_mbc_free(mbc);
139 }
140 
141 static void
mbm_put_atrunc1()142 mbm_put_atrunc1()
143 {
144 	uint8_t wire[] = { 'o', 'n', 'e', 't', };
145 	mbuf_chain_t *mbc;
146 	int rc;
147 
148 	mbc = smb_mbc_alloc(100);
149 
150 	/* Encode with wire length < strlen */
151 	rc = smb_mbc_encodef(mbc, "4s", "onetwo");
152 	if (rc != 0) {
153 		printf("Fail: mbm_put_atrunc1 encode\n");
154 		goto out;
155 	}
156 	/* Trunc should put exactly 4 */
157 	if (mbc->chain->m_len != 4) {
158 		printf("Fail: mbm_put_atrunc1 len=%d\n",
159 		    mbc->chain->m_len);
160 		return;
161 	}
162 
163 	if (memcmp(mbc->chain->m_data, wire, 4)) {
164 		printf("Fail: mbm_put_atrunc1 cmp:\n");
165 		hexdump((uchar_t *)mbc->chain->m_data, 4);
166 		return;
167 	}
168 
169 	printf("Pass: mbm_put_atrunc1\n");
170 
171 out:
172 	smb_mbc_free(mbc);
173 }
174 
175 static void
mbm_put_atrunc2()176 mbm_put_atrunc2()
177 {
178 	uint8_t wire[] = { 'o', 'n', 'e', 't', 0 };
179 	mbuf_chain_t *mbc;
180 	int rc;
181 
182 	mbc = smb_mbc_alloc(4);
183 
184 	/* Encode with wire length < strlen */
185 	rc = smb_mbc_encodef(mbc, "s", "onetwo");
186 	if (rc != 1) {
187 		printf("Fail: mbm_put_atrunc2 encode rc=%d\n", rc);
188 		goto out;
189 	}
190 	/* Trunc should put exactly 4 */
191 	if (mbc->chain->m_len != 4) {
192 		printf("Fail: mbm_put_atrunc2 len=%d\n",
193 		    mbc->chain->m_len);
194 		return;
195 	}
196 
197 	if (memcmp(mbc->chain->m_data, wire, 5)) {
198 		printf("Fail: mbm_put_atrunc2 cmp:\n");
199 		hexdump((uchar_t *)mbc->chain->m_data, 4);
200 		return;
201 	}
202 
203 	printf("Pass: mbm_put_atrunc2\n");
204 
205 out:
206 	smb_mbc_free(mbc);
207 }
208 
209 /*
210  * Put unicode string with NULL
211  */
212 static void
mbm_put_u0()213 mbm_put_u0()
214 {
215 	uint16_t wire[] = { 'o', 'n', 'e', 0, 42, 0 };
216 	mbuf_chain_t *mbc;
217 	int rc;
218 
219 	mbc = smb_mbc_alloc(100);
220 
221 	rc = smb_mbc_encodef(mbc, "Uw", "one", 42);
222 	if (rc != 0) {
223 		printf("Fail: mbm_put_u0 encode\n");
224 		goto out;
225 	}
226 	if (mbc->chain->m_len != 10) {
227 		printf("Fail: mbm_put_u0 len=%d\n",
228 		    mbc->chain->m_len);
229 		return;
230 	}
231 
232 	if (memcmp(mbc->chain->m_data, wire, 10)) {
233 		printf("Fail: mbm_put_u0 cmp:\n");
234 		hexdump((uchar_t *)mbc->chain->m_data, 10);
235 		return;
236 	}
237 
238 	printf("Pass: mbm_put_u0\n");
239 
240 out:
241 	smb_mbc_free(mbc);
242 }
243 
244 /*
245  * Put unicode string, no NULL
246  */
247 static void
mbm_put_u1()248 mbm_put_u1()
249 {
250 	uint16_t wire[] = { 'o', 'n', 'e', '.', 42, 0 };
251 	mbuf_chain_t *mbc;
252 	int rc;
253 
254 	mbc = smb_mbc_alloc(100);
255 
256 	rc = smb_mbc_encodef(mbc, "8Uw", "one.", 42);
257 	if (rc != 0) {
258 		printf("Fail: mbm_put_u1 encode\n");
259 		goto out;
260 	}
261 	if (mbc->chain->m_len != 10) {
262 		printf("Fail: mbm_put_u1 len=%d\n",
263 		    mbc->chain->m_len);
264 		return;
265 	}
266 
267 	if (memcmp(mbc->chain->m_data, wire, 10)) {
268 		printf("Fail: mbm_put_u1 cmp:\n");
269 		hexdump((uchar_t *)mbc->chain->m_data, 10);
270 		return;
271 	}
272 
273 	printf("Pass: mbm_put_u1\n");
274 
275 out:
276 	smb_mbc_free(mbc);
277 }
278 
279 static void
mbm_put_u3()280 mbm_put_u3()
281 {
282 	mbuf_chain_t *mbc;
283 	int rc;
284 
285 	mbc = smb_mbc_alloc(100);
286 
287 	rc = smb_mbc_encodef(mbc, "U", mbsa);
288 	if (rc != 0) {
289 		printf("Fail: mbm_put_u3 encode\n");
290 		goto out;
291 	}
292 	if (mbc->chain->m_len != 8) {
293 		printf("Fail: mbm_put_u3 len=%d\n",
294 		    mbc->chain->m_len);
295 		return;
296 	}
297 
298 	if (memcmp(mbc->chain->m_data, wcsa, 8)) {
299 		printf("Fail: mbm_put_u3 cmp:\n");
300 		hexdump((uchar_t *)mbc->chain->m_data, 8);
301 		return;
302 	}
303 
304 	printf("Pass: mbm_put_u3\n");
305 
306 out:
307 	smb_mbc_free(mbc);
308 }
309 
310 static void
mbm_put_u4()311 mbm_put_u4()
312 {
313 	mbuf_chain_t *mbc;
314 	int rc;
315 
316 	mbc = smb_mbc_alloc(100);
317 
318 	rc = smb_mbc_encodef(mbc, "U", mbsp);
319 	if (rc != 0) {
320 		printf("Fail: mbm_put_u4 encode\n");
321 		goto out;
322 	}
323 	if (mbc->chain->m_len != 10) {
324 		printf("Fail: mbm_put_u4 len=%d\n",
325 		    mbc->chain->m_len);
326 		return;
327 	}
328 
329 	if (memcmp(mbc->chain->m_data, wcsp, 10)) {
330 		printf("Fail: mbm_put_u4 cmp:\n");
331 		hexdump((uchar_t *)mbc->chain->m_data, 10);
332 		return;
333 	}
334 
335 	printf("Pass: mbm_put_u4\n");
336 
337 out:
338 	smb_mbc_free(mbc);
339 }
340 
341 static void
mbm_put_upad()342 mbm_put_upad()
343 {
344 	uint16_t wire[] = { 'o', 'n', 'e', 0, 0 };
345 	mbuf_chain_t *mbc;
346 	int rc;
347 
348 	mbc = smb_mbc_alloc(100);
349 
350 	/* Encode with wire length > strlen */
351 	rc = smb_mbc_encodef(mbc, "10U", "one");
352 	if (rc != 0) {
353 		printf("Fail: mbm_put_upad encode\n");
354 		goto out;
355 	}
356 	if (mbc->chain->m_len != 10) {
357 		printf("Fail: mbm_put_upad len=%d\n",
358 		    mbc->chain->m_len);
359 		return;
360 	}
361 
362 	if (memcmp(mbc->chain->m_data, wire, 10)) {
363 		printf("Fail: mbm_put_upad cmp:\n");
364 		hexdump((uchar_t *)mbc->chain->m_data, 10);
365 		return;
366 	}
367 
368 	printf("Pass: mbm_put_upad\n");
369 
370 out:
371 	smb_mbc_free(mbc);
372 }
373 
374 static void
mbm_put_utrunc1()375 mbm_put_utrunc1()
376 {
377 	uint16_t wire[] = { 'o', 'n', 'e', 't' };
378 	mbuf_chain_t *mbc;
379 	int rc;
380 
381 	mbc = smb_mbc_alloc(100);
382 
383 	/* Encode with wire length < strlen */
384 	rc = smb_mbc_encodef(mbc, "8U", "onetwo");
385 	if (rc != 0) {
386 		printf("Fail: mbm_put_utrunc1 encode\n");
387 		goto out;
388 	}
389 	/* Trunc should put exactly 8 */
390 	if (mbc->chain->m_len != 8) {
391 		printf("Fail: mbm_put_utrunc1 len=%d\n",
392 		    mbc->chain->m_len);
393 		return;
394 	}
395 
396 	if (memcmp(mbc->chain->m_data, wire, 8)) {
397 		printf("Fail: mbm_put_utrunc1 cmp:\n");
398 		hexdump((uchar_t *)mbc->chain->m_data, 8);
399 		return;
400 	}
401 
402 	printf("Pass: mbm_put_utrunc1\n");
403 
404 out:
405 	smb_mbc_free(mbc);
406 }
407 
408 static void
mbm_put_utrunc2()409 mbm_put_utrunc2()
410 {
411 	uint16_t wire[] = { 'o', 'n', 'e', 't', 0 };
412 	mbuf_chain_t *mbc;
413 	int rc;
414 
415 	mbc = smb_mbc_alloc(8);
416 
417 	/* Encode with wire length < strlen */
418 	rc = smb_mbc_encodef(mbc, "U", "onetwo");
419 	if (rc != 1) {
420 		printf("Fail: mbm_put_utrunc2 encode rc=%d\n", rc);
421 		goto out;
422 	}
423 	/* Trunc should put exactly 8 */
424 	if (mbc->chain->m_len != 8) {
425 		printf("Fail: mbm_put_utrunc2 len=%d\n",
426 		    mbc->chain->m_len);
427 		return;
428 	}
429 
430 	if (memcmp(mbc->chain->m_data, wire, 10)) {
431 		printf("Fail: mbm_put_utrunc2 cmp:\n");
432 		hexdump((uchar_t *)mbc->chain->m_data, 8);
433 		return;
434 	}
435 
436 	printf("Pass: mbm_put_utrunc2\n");
437 
438 out:
439 	smb_mbc_free(mbc);
440 }
441 
442 static void
mbm_put_mbuf1()443 mbm_put_mbuf1()
444 {
445 	uint8_t wire[] = "onetwo";
446 	mbuf_chain_t mbc, mbc2;
447 	int rc;
448 
449 	MBC_INIT(&mbc, 16);
450 	MBC_INIT(&mbc2, 8);
451 
452 	rc = smb_mbc_encodef(&mbc, "3s", "one");
453 	if (rc != 0) {
454 		printf("Fail: mbm_put_mbuf1 encode 1 rc=%d\n", rc);
455 		goto out;
456 	}
457 	if (mbc.chain_offset != 3) {
458 		printf("Fail: mbm_put_mbuf1 encode 1 len=%d\n",
459 		    mbc.chain_offset);
460 		goto out;
461 	}
462 
463 	rc = smb_mbc_encodef(&mbc2, "s", "two");
464 	if (rc != 0) {
465 		printf("Fail: mbm_put_mbuf1 encode 2 rc=%d\n", rc);
466 		goto out;
467 	}
468 	if (mbc2.chain_offset != 4) {
469 		printf("Fail: mbm_put_mbuf1 encode 2 len=%d\n",
470 		    mbc.chain_offset);
471 		goto out;
472 	}
473 
474 	/* Append */
475 	rc = smb_mbc_encodef(&mbc, "m", mbc2.chain);
476 	mbc2.chain = NULL;
477 	if (rc != 0) {
478 		printf("Fail: mbm_put_mbuf1 encode 3 rc=%d\n", rc);
479 		goto out;
480 	}
481 	if (mbc.chain_offset != 7) {
482 		printf("Fail: mbm_put_mbuf1 encode 3 len=%d\n",
483 		    mbc.chain_offset);
484 		goto out;
485 	}
486 
487 	if (memcmp(mbc.chain->m_data, wire, 7)) {
488 		printf("Fail: mbm_put_mbuf1 cmp:\n");
489 		hexdump((uchar_t *)mbc.chain->m_data, 7);
490 		goto out;
491 	}
492 
493 	printf("Pass: mbm_put_mbuf1\n");
494 
495 out:
496 	MBC_FLUSH(&mbc);
497 	MBC_FLUSH(&mbc2);
498 }
499 
500 /*
501  * Verify m_prepend works
502  */
503 static void
mbm_put_mbuf2()504 mbm_put_mbuf2()
505 {
506 	uint8_t wire[] = "one.two";
507 	mbuf_chain_t mbc;
508 	mbuf_t *m;
509 	int len, rc;
510 
511 	MBC_INIT(&mbc, 512);
512 
513 	rc = smb_mbc_encodef(&mbc, "s", "two");
514 	if (rc != 0) {
515 		printf("Fail: mbm_put_mbuf2 encode 1 rc=%d\n", rc);
516 		goto out;
517 	}
518 	if (mbc.chain_offset != 4) {
519 		printf("Fail: mbm_put_mbuf2 encode 1 len=%d\n",
520 		    mbc.chain_offset);
521 		goto out;
522 	}
523 
524 	/* Prepend.  Should use prepend space, not allocate. */
525 	m = m_prepend(mbc.chain, 4, M_WAIT);
526 	if (m != mbc.chain) {
527 		(void) m_free(m);
528 		printf("Fail: mbm_put_mbuf2 m_prepend error\n", rc);
529 		goto out;
530 	}
531 
532 	/* Now write into the prepend space. */
533 	bcopy("one.", m->m_data, 4);
534 
535 	/* Verify length and content */
536 	len = MBC_LENGTH(&mbc);
537 	if (len != 8) {
538 		printf("Fail: mbm_put_mbuf2 encode 2 len=%d\n",
539 		    mbc.chain_offset);
540 		goto out;
541 	}
542 
543 	if (memcmp(mbc.chain->m_data, wire, 7)) {
544 		printf("Fail: mbm_put_mbuf2 cmp:\n");
545 		hexdump((uchar_t *)mbc.chain->m_data, 7);
546 		goto out;
547 	}
548 
549 	printf("Pass: mbm_put_mbuf2\n");
550 
551 out:
552 	MBC_FLUSH(&mbc);
553 }
554 
555 /*
556  * Check how mbc_marshal_make_room crosses a message boundary
557  */
558 static void
mbm_put_mbuf3()559 mbm_put_mbuf3()
560 {
561 	mbuf_chain_t mbc;
562 	mbuf_t *m;
563 	char *p;
564 	int rc;
565 
566 	MBC_INIT(&mbc, 16384);
567 
568 	/*
569 	 * Encode near the end of the first mbuf
570 	 * running over into the second.
571 	 */
572 	m = mbc.chain;
573 	mbc.chain_offset = M_TRAILINGSPACE(m) - 4;
574 	rc = smb_mbc_encodef(&mbc, "s", "one.two");
575 	if (rc != 0) {
576 		printf("Fail: mbm_put_mbuf3 encode 1 rc=%d\n", rc);
577 		goto out;
578 	}
579 
580 	/* Verify first segment */
581 	p = m->m_data + m->m_len - 4;
582 	if (memcmp(p, "one.", 4)) {
583 		printf("Fail: mbm_put_mbuf3 cmp1:\n");
584 		hexdump((uchar_t *)p, 4);
585 		goto out;
586 	}
587 
588 	/* Verify second segment */
589 	p = m->m_next->m_data;
590 	if (memcmp(p, "two", 4)) {
591 		printf("Fail: mbm_put_mbuf3 cmp2:\n");
592 		hexdump((uchar_t *)p, 4);
593 		goto out;
594 	}
595 
596 	printf("Pass: mbm_put_mbuf3\n");
597 
598 out:
599 	MBC_FLUSH(&mbc);
600 }
601 
602 /*
603  * Parse an ascii string.
604  */
605 static void
mbm_get_a0()606 mbm_get_a0()
607 {
608 	uint8_t wire[] = { 'o', 'n', 'e', 0, 42, 0 };
609 	mbuf_chain_t mbc;
610 	char *s;
611 	int rc;
612 	uint16_t w;
613 
614 	bzero(&mbc, sizeof (mbc));
615 	MBC_ATTACH_BUF(&mbc, (uchar_t *)wire, sizeof (wire));
616 
617 	rc = smb_mbc_decodef(&mbc, "%sw", &test_sr, &s, &w);
618 	if (rc != 0) {
619 		printf("Fail: mbm_get_a0 decode\n");
620 		goto out;
621 	}
622 	/*
623 	 * Decode a word after the string to make sure we
624 	 * end up positioned correctly after the string.
625 	 */
626 	if (w != 42) {
627 		printf("Fail: mbm_get_a0 w=%d\n", w);
628 		return;
629 	}
630 	if (strcmp(s, "one") != 0) {
631 		printf("Fail: mbm_get_a0 cmp: <%s>\n", s);
632 		return;
633 	}
634 
635 	printf("Pass: mbm_get_a0\n");
636 
637 out:
638 	MBC_FLUSH(&mbc);
639 }
640 
641 /*
642  * Parse an ascii string, no NULL
643  */
644 static void
mbm_get_a1()645 mbm_get_a1()
646 {
647 	uint8_t wire[] = { 'o', 'n', 'e', '.', 42, 0 };
648 	mbuf_chain_t mbc;
649 	char *s;
650 	int rc;
651 	uint16_t w;
652 
653 	bzero(&mbc, sizeof (mbc));
654 	MBC_ATTACH_BUF(&mbc, (uchar_t *)wire, sizeof (wire));
655 
656 	rc = smb_mbc_decodef(&mbc, "%3s.w", &test_sr, &s, &w);
657 	if (rc != 0) {
658 		printf("Fail: mbm_get_a1 decode\n");
659 		goto out;
660 	}
661 	/*
662 	 * Decode a word after the string to make sure we
663 	 * end up positioned correctly after the string.
664 	 */
665 	if (w != 42) {
666 		printf("Fail: mbm_get_a1 w=%d\n", w);
667 		return;
668 	}
669 	if (strcmp(s, "one") != 0) {
670 		printf("Fail: mbm_get_a1 cmp: <%s>\n", s);
671 		return;
672 	}
673 
674 	printf("Pass: mbm_get_a1\n");
675 
676 out:
677 	MBC_FLUSH(&mbc);
678 }
679 
680 /* parse exactly to end of data */
681 static void
mbm_get_a2()682 mbm_get_a2()
683 {
684 	uint8_t wire[] = { 'o', 'n', 'e' };
685 	mbuf_chain_t mbc;
686 	char *s;
687 	int rc;
688 
689 	bzero(&mbc, sizeof (mbc));
690 	MBC_ATTACH_BUF(&mbc, (uchar_t *)wire, sizeof (wire));
691 
692 	rc = smb_mbc_decodef(&mbc, "%3s", &test_sr, &s);
693 	if (rc != 0) {
694 		printf("Fail: mbm_get_a2 decode\n");
695 		goto out;
696 	}
697 	if (mbc.chain_offset != 3) {
698 		printf("Fail: mbm_get_a2 wrong pos\n");
699 		return;
700 	}
701 	if (strcmp(s, "one") != 0) {
702 		printf("Fail: mbm_get_a2 cmp: <%s>\n", s);
703 		return;
704 	}
705 
706 	printf("Pass: mbm_get_a2\n");
707 
708 out:
709 	MBC_FLUSH(&mbc);
710 }
711 
712 /*
713  * Parse a unicode string.
714  */
715 static void
mbm_get_u0()716 mbm_get_u0()
717 {
718 	uint16_t wire[] = { 'o', 'n', 'e', 0, 42, 0 };
719 	mbuf_chain_t mbc;
720 	char *s;
721 	int rc;
722 	uint16_t w;
723 
724 	bzero(&mbc, sizeof (mbc));
725 	MBC_ATTACH_BUF(&mbc, (uchar_t *)wire, sizeof (wire));
726 
727 	rc = smb_mbc_decodef(&mbc, "%Uw", &test_sr, &s, &w);
728 	if (rc != 0) {
729 		printf("Fail: mbm_get_u0 decode\n");
730 		goto out;
731 	}
732 	/*
733 	 * Decode a word after the string to make sure we
734 	 * end up positioned correctly after the string.
735 	 */
736 	if (w != 42) {
737 		printf("Fail: mbm_get_u0 w=%d\n", w);
738 		return;
739 	}
740 	if (strcmp(s, "one") != 0) {
741 		printf("Fail: mbm_get_u0 cmp: <%s>\n", s);
742 		return;
743 	}
744 
745 	printf("Pass: mbm_get_u0\n");
746 
747 out:
748 	MBC_FLUSH(&mbc);
749 }
750 
751 /*
752  * Parse a string that's NOT null terminated.
753  */
754 static void
mbm_get_u1()755 mbm_get_u1()
756 {
757 	uint16_t wire[] = { 'o', 'n', 'e', '.', 42, 0 };
758 	mbuf_chain_t mbc;
759 	char *s;
760 	int rc;
761 	uint16_t w;
762 
763 	bzero(&mbc, sizeof (mbc));
764 	MBC_ATTACH_BUF(&mbc, (uchar_t *)wire, sizeof (wire));
765 
766 	rc = smb_mbc_decodef(&mbc, "%6U..w", &test_sr, &s, &w);
767 	if (rc != 0) {
768 		printf("Fail: mbm_get_u1 decode\n");
769 		goto out;
770 	}
771 	/*
772 	 * Decode a word after the string to make sure we
773 	 * end up positioned correctly after the string.
774 	 */
775 	if (w != 42) {
776 		printf("Fail: mbm_get_u1 w=%d\n", w);
777 		return;
778 	}
779 	if (strcmp(s, "one") != 0) {
780 		printf("Fail: mbm_get_u1 cmp: <%s>\n", s);
781 		return;
782 	}
783 
784 	printf("Pass: mbm_get_u1\n");
785 
786 out:
787 	MBC_FLUSH(&mbc);
788 }
789 
790 /* parse exactly to end of data */
791 static void
mbm_get_u2()792 mbm_get_u2()
793 {
794 	uint16_t wire[] = { 't', 'w', 'o' };
795 	mbuf_chain_t mbc;
796 	char *s;
797 	int rc;
798 
799 	bzero(&mbc, sizeof (mbc));
800 	MBC_ATTACH_BUF(&mbc, (uchar_t *)wire, sizeof (wire));
801 
802 	rc = smb_mbc_decodef(&mbc, "%6U", &test_sr, &s);
803 	if (rc != 0) {
804 		printf("Fail: mbm_get_u2 decode\n");
805 		goto out;
806 	}
807 	if (mbc.chain_offset != 6) {
808 		printf("Fail: mbm_get_u2 wrong pos\n");
809 		return;
810 	}
811 	if (strcmp(s, "two") != 0) {
812 		printf("Fail: mbm_get_u2 cmp: <%s>\n", s);
813 		return;
814 	}
815 
816 	printf("Pass: mbm_get_a2\n");
817 
818 out:
819 	MBC_FLUSH(&mbc);
820 }
821 
822 static void
mbm_get_u3()823 mbm_get_u3()
824 {
825 	mbuf_chain_t mbc;
826 	char *s;
827 	int rc;
828 
829 	bzero(&mbc, sizeof (mbc));
830 	MBC_ATTACH_BUF(&mbc, (uchar_t *)wcsa, sizeof (wcsa));
831 
832 	rc = smb_mbc_decodef(&mbc, "%#U", &test_sr, sizeof (wcsa), &s);
833 	if (rc != 0) {
834 		printf("Fail: mbm_get_u3 decode\n");
835 		goto out;
836 	}
837 	if (strcmp(s, mbsa) != 0) {
838 		printf("Fail: mbm_get_u3 cmp: <%s>\n", s);
839 		return;
840 	}
841 
842 	printf("Pass: mbm_get_u3\n");
843 
844 out:
845 	MBC_FLUSH(&mbc);
846 }
847 
848 static void
mbm_get_u4()849 mbm_get_u4()
850 {
851 	mbuf_chain_t mbc;
852 	char *s;
853 	int rc;
854 
855 	bzero(&mbc, sizeof (mbc));
856 	MBC_ATTACH_BUF(&mbc, (uchar_t *)wcsp, sizeof (wcsp));
857 
858 	rc = smb_mbc_decodef(&mbc, "%#U", &test_sr, sizeof (wcsp), &s);
859 	if (rc != 0) {
860 		printf("Fail: mbm_get_u4 decode\n");
861 		goto out;
862 	}
863 	if (strcmp(s, mbsp) != 0) {
864 		printf("Fail: mbm_get_u4 cmp: <%s>\n", s);
865 		return;
866 	}
867 
868 	printf("Pass: mbm_get_u4\n");
869 
870 out:
871 	MBC_FLUSH(&mbc);
872 }
873 
874 void
test_mbmarshal()875 test_mbmarshal()
876 {
877 
878 	smb_mbc_init();
879 
880 	test_ssn.dialect = 0x210;	// SMB 2.1
881 	test_sr.session = &test_ssn;
882 	test_sr.sr_magic = SMB_REQ_MAGIC;
883 	smb_srm_init(&test_sr);
884 
885 	mbm_put_a0();
886 	mbm_put_a1();
887 	mbm_put_apad();
888 	mbm_put_atrunc1();
889 	mbm_put_atrunc2();
890 
891 	mbm_put_u0();
892 	mbm_put_u1();
893 	mbm_put_u3();
894 	mbm_put_u4();
895 	mbm_put_upad();
896 	mbm_put_utrunc1();
897 	mbm_put_utrunc2();
898 
899 	mbm_put_mbuf1();
900 	mbm_put_mbuf2();
901 	mbm_put_mbuf3();
902 
903 	mbm_get_a0();
904 	mbm_get_a1();
905 	mbm_get_a2();
906 	mbm_get_u0();
907 	mbm_get_u1();
908 	mbm_get_u2();
909 	mbm_get_u3();
910 	mbm_get_u4();
911 
912 	smb_srm_fini(&test_sr);
913 	smb_mbc_fini();
914 }
915