1 /*
2 * Copyright (c) 2000, Boris Popov
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by Boris Popov.
16 * 4. Neither the name of the author nor the names of any co-contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * SUCH DAMAGE.
31 *
32 * $Id: mbuf.c,v 1.3 2004/12/13 00:25:22 lindak Exp $
33 */
34
35 /*
36 * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
37 */
38
39 #include <sys/types.h>
40 #include <ctype.h>
41 #include <errno.h>
42 #include <stdio.h>
43 #include <stdlib.h>
44 #include <string.h>
45 #include <strings.h>
46 #include <libintl.h>
47 #include <assert.h>
48
49 #include <netsmb/smb_lib.h>
50 #include <netsmb/mchain.h>
51
52 #include "private.h"
53 #include "charsets.h"
54
55 /*
56 * Note: Leaving a little space (8 bytes) between the
57 * mbuf header and the start of the data so we can
58 * prepend a NetBIOS header in that space.
59 */
60 #define M_ALIGNFACTOR (sizeof (long))
61 #define M_ALIGN(len) (((len) + M_ALIGNFACTOR - 1) & ~(M_ALIGNFACTOR - 1))
62 #define M_BASESIZE (sizeof (struct mbuf) + 8)
63 #define M_MINSIZE (1024 - M_BASESIZE)
64 #define M_TOP(m) ((char *)(m) + M_BASESIZE)
65 #define M_TRAILINGSPACE(m) ((m)->m_maxlen - (m)->m_len)
66
67 int
m_get(int len,struct mbuf ** mpp)68 m_get(int len, struct mbuf **mpp)
69 {
70 struct mbuf *m;
71
72 assert(len < 0x100000); /* sanity */
73
74 len = M_ALIGN(len);
75 if (len < M_MINSIZE)
76 len = M_MINSIZE;
77 m = malloc(M_BASESIZE + len);
78 if (m == NULL)
79 return (ENOMEM);
80 bzero(m, M_BASESIZE + len);
81 m->m_maxlen = len;
82 m->m_data = M_TOP(m);
83 *mpp = m;
84 return (0);
85 }
86
87 static void
m_free(struct mbuf * m)88 m_free(struct mbuf *m)
89 {
90 free(m);
91 }
92
93 void
m_freem(struct mbuf * m0)94 m_freem(struct mbuf *m0)
95 {
96 struct mbuf *m;
97
98 while (m0) {
99 m = m0->m_next;
100 m_free(m0);
101 m0 = m;
102 }
103 }
104
105 size_t
m_totlen(struct mbuf * m0)106 m_totlen(struct mbuf *m0)
107 {
108 struct mbuf *m = m0;
109 int len = 0;
110
111 while (m) {
112 len += m->m_len;
113 m = m->m_next;
114 }
115 return (len);
116 }
117
118 int
m_lineup(struct mbuf * m0,struct mbuf ** mpp)119 m_lineup(struct mbuf *m0, struct mbuf **mpp)
120 {
121 struct mbuf *nm, *m;
122 char *dp;
123 size_t len, totlen;
124 int error;
125
126 if (m0->m_next == NULL) {
127 *mpp = m0;
128 return (0);
129 }
130 totlen = m_totlen(m0);
131 if ((error = m_get(totlen, &nm)) != 0)
132 return (error);
133 dp = mtod(nm, char *);
134 while (m0) {
135 len = m0->m_len;
136 bcopy(m0->m_data, dp, len);
137 dp += len;
138 m = m0->m_next;
139 m_free(m0);
140 m0 = m;
141 }
142 nm->m_len = totlen;
143 *mpp = nm;
144 return (0);
145 }
146
147 int
mb_init(struct mbdata * mbp)148 mb_init(struct mbdata *mbp)
149 {
150 return (mb_init_sz(mbp, M_MINSIZE));
151 }
152
153 int
mb_init_sz(struct mbdata * mbp,int size)154 mb_init_sz(struct mbdata *mbp, int size)
155 {
156 struct mbuf *m;
157 int error;
158
159 if ((error = m_get(size, &m)) != 0)
160 return (error);
161 mb_initm(mbp, m);
162 return (0);
163 }
164
165 void
mb_initm(struct mbdata * mbp,struct mbuf * m)166 mb_initm(struct mbdata *mbp, struct mbuf *m)
167 {
168 bzero(mbp, sizeof (*mbp));
169 mbp->mb_top = mbp->mb_cur = m;
170 mbp->mb_pos = mtod(m, char *);
171 }
172
173 void
mb_done(struct mbdata * mbp)174 mb_done(struct mbdata *mbp)
175 {
176 if (mbp->mb_top) {
177 m_freem(mbp->mb_top);
178 mbp->mb_top = NULL;
179 }
180 }
181
182 int
m_getm(struct mbuf * top,int len,struct mbuf ** mpp)183 m_getm(struct mbuf *top, int len, struct mbuf **mpp)
184 {
185 struct mbuf *m, *mp;
186 int error, ts;
187
188 for (mp = top; ; mp = mp->m_next) {
189 ts = M_TRAILINGSPACE(mp);
190 if (len <= ts)
191 goto out;
192 len -= ts;
193 if (mp->m_next == NULL)
194 break;
195
196 }
197 if (len > 0) {
198 if ((error = m_get(len, &m)) != 0)
199 return (error);
200 mp->m_next = m;
201 }
202 out:
203 *mpp = top;
204 return (0);
205 }
206
207 /*
208 * Routines to put data in a buffer
209 */
210
211 void *
mb_reserve(mbchain_t * mbp,int size)212 mb_reserve(mbchain_t *mbp, int size)
213 {
214 char *p;
215
216 if (mb_fit(mbp, size, &p) != 0)
217 return (NULL);
218
219 return (p);
220 }
221
222 /*
223 * Check if object of size 'size' fit to the current position and
224 * allocate new mbuf if not. Advance pointers and increase length of mbuf(s).
225 * Return pointer to the object placeholder or NULL if any error occured.
226 */
227 int
mb_fit(mbchain_t * mbp,int size,char ** pp)228 mb_fit(mbchain_t *mbp, int size, char **pp)
229 {
230 struct mbuf *m, *mn;
231 int error;
232
233 m = mbp->mb_cur;
234 if (M_TRAILINGSPACE(m) < (int)size) {
235 if ((error = m_get(size, &mn)) != 0)
236 return (error);
237 mbp->mb_pos = mtod(mn, char *);
238 mbp->mb_cur = m->m_next = mn;
239 m = mn;
240 }
241 m->m_len += size;
242 *pp = mbp->mb_pos;
243 mbp->mb_pos += size;
244 mbp->mb_count += size;
245 return (0);
246 }
247
248 int
mb_put_uint8(mbchain_t * mbp,uint8_t x)249 mb_put_uint8(mbchain_t *mbp, uint8_t x)
250 {
251 uint8_t y = x;
252 return (mb_put_mem(mbp, &y, sizeof (y), MB_MINLINE));
253 }
254
255 int
mb_put_uint16be(mbchain_t * mbp,uint16_t x)256 mb_put_uint16be(mbchain_t *mbp, uint16_t x)
257 {
258 uint16_t y = htobes(x);
259 return (mb_put_mem(mbp, &y, sizeof (y), MB_MINLINE));
260 }
261
262 int
mb_put_uint16le(mbchain_t * mbp,uint16_t x)263 mb_put_uint16le(mbchain_t *mbp, uint16_t x)
264 {
265 uint16_t y = htoles(x);
266 return (mb_put_mem(mbp, &y, sizeof (y), MB_MINLINE));
267 }
268
269 int
mb_put_uint32be(mbchain_t * mbp,uint32_t x)270 mb_put_uint32be(mbchain_t *mbp, uint32_t x)
271 {
272 uint32_t y = htobel(x);
273 return (mb_put_mem(mbp, &y, sizeof (y), MB_MINLINE));
274 }
275
276 int
mb_put_uint32le(mbchain_t * mbp,uint32_t x)277 mb_put_uint32le(mbchain_t *mbp, uint32_t x)
278 {
279 uint32_t y = htolel(x);
280 return (mb_put_mem(mbp, &y, sizeof (y), MB_MINLINE));
281 }
282
283 int
mb_put_uint64be(mbchain_t * mbp,uint64_t x)284 mb_put_uint64be(mbchain_t *mbp, uint64_t x)
285 {
286 uint64_t y = htobeq(x);
287 return (mb_put_mem(mbp, &y, sizeof (y), MB_MINLINE));
288 }
289
290 int
mb_put_uint64le(mbchain_t * mbp,uint64_t x)291 mb_put_uint64le(mbchain_t *mbp, uint64_t x)
292 {
293 uint64_t y = htoleq(x);
294 return (mb_put_mem(mbp, &y, sizeof (y), MB_MINLINE));
295 }
296
297 /* ARGSUSED */
298 int
mb_put_mem(mbchain_t * mbp,const void * vmem,int size,int type)299 mb_put_mem(mbchain_t *mbp, const void *vmem, int size, int type)
300 {
301 struct mbuf *m;
302 const char *src;
303 char *dst;
304 size_t cplen;
305 int error;
306
307 if (size == 0)
308 return (0);
309
310 src = vmem;
311 m = mbp->mb_cur;
312 if ((error = m_getm(m, size, &m)) != 0)
313 return (error);
314 while (size > 0) {
315 cplen = M_TRAILINGSPACE(m);
316 if (cplen == 0) {
317 m = m->m_next;
318 continue;
319 }
320 if (cplen > size)
321 cplen = size;
322 dst = mtod(m, char *) + m->m_len;
323 if (src) {
324 bcopy(src, dst, cplen);
325 src += cplen;
326 } else
327 bzero(dst, cplen);
328 size -= cplen;
329 m->m_len += cplen;
330 mbp->mb_count += cplen;
331 }
332 mbp->mb_pos = mtod(m, char *) + m->m_len;
333 mbp->mb_cur = m;
334 return (0);
335 }
336
337 /*
338 * Append another mbuf to the mbuf chain.
339 * If what we're appending is smaller than
340 * the current trailing space, just copy.
341 * This always consumes the passed mbuf.
342 */
343 int
mb_put_mbuf(mbchain_t * mbp,struct mbuf * m)344 mb_put_mbuf(mbchain_t *mbp, struct mbuf *m)
345 {
346 struct mbuf *cm = mbp->mb_cur;
347 int ts = M_TRAILINGSPACE(cm);
348
349 if (m->m_next == NULL && m->m_len <= ts) {
350 /* just copy */
351 mb_put_mem(mbp, m->m_data, m->m_len, MB_MSYSTEM);
352 m_freem(m);
353 return (0);
354 }
355
356 cm->m_next = m;
357 while (m) {
358 mbp->mb_count += m->m_len;
359 if (m->m_next == NULL)
360 break;
361 m = m->m_next;
362 }
363 mbp->mb_pos = mtod(m, char *) + m->m_len;
364 mbp->mb_cur = m;
365 return (0);
366 }
367
368 /*
369 * Convenience function to put an OEM or Unicode string,
370 * null terminated, and aligned if necessary.
371 */
372 int
mb_put_string(mbchain_t * mbp,const char * s,int uc)373 mb_put_string(mbchain_t *mbp, const char *s, int uc)
374 {
375 int err;
376
377 if (uc) {
378 /* Put Unicode. align(2) first. */
379 if (mbp->mb_count & 1)
380 mb_put_uint8(mbp, 0);
381 err = mb_put_ustring(mbp, s);
382 } else {
383 /* Put ASCII (really OEM) */
384 err = mb_put_astring(mbp, s);
385 }
386
387 return (err);
388 }
389
390 /*
391 * Put an ASCII string (really OEM), given a UTF-8 string.
392 */
393 int
mb_put_astring(mbchain_t * mbp,const char * s)394 mb_put_astring(mbchain_t *mbp, const char *s)
395 {
396 char *abuf;
397 int err, len;
398
399 abuf = convert_utf8_to_wincs(s);
400 if (abuf == NULL)
401 return (ENOMEM);
402 len = strlen(abuf) + 1;
403 err = mb_put_mem(mbp, abuf, len, MB_MSYSTEM);
404 free(abuf);
405 return (err);
406 }
407
408 /*
409 * Put UCS-2LE, given a UTF-8 string.
410 */
411 int
mb_put_ustring(mbchain_t * mbp,const char * s)412 mb_put_ustring(mbchain_t *mbp, const char *s)
413 {
414 uint16_t *ubuf;
415 int err, len;
416
417 ubuf = convert_utf8_to_leunicode(s);
418 if (ubuf == NULL)
419 return (ENOMEM);
420 len = 2 * (unicode_strlen(ubuf) + 1);
421 err = mb_put_mem(mbp, ubuf, len, MB_MSYSTEM);
422 free(ubuf);
423 return (err);
424 }
425
426 /*
427 * Routines for fetching data from an mbuf chain
428 */
429 #define mb_left(m, p) (mtod(m, char *) + (m)->m_len - (p))
430
431 int
md_get_uint8(mdchain_t * mbp,uint8_t * x)432 md_get_uint8(mdchain_t *mbp, uint8_t *x)
433 {
434 return (md_get_mem(mbp, x, 1, MB_MINLINE));
435 }
436
437 int
md_get_uint16le(mdchain_t * mbp,uint16_t * x)438 md_get_uint16le(mdchain_t *mbp, uint16_t *x)
439 {
440 uint16_t v;
441 int err;
442
443 if ((err = md_get_mem(mbp, &v, sizeof (v), MB_MINLINE)) != 0)
444 return (err);
445 if (x != NULL)
446 *x = letohs(v);
447 return (0);
448 }
449
450 int
md_get_uint16be(mdchain_t * mbp,uint16_t * x)451 md_get_uint16be(mdchain_t *mbp, uint16_t *x) {
452 uint16_t v;
453 int err;
454
455 if ((err = md_get_mem(mbp, &v, sizeof (v), MB_MINLINE)) != 0)
456 return (err);
457 if (x != NULL)
458 *x = betohs(v);
459 return (0);
460 }
461
462 int
md_get_uint32be(mdchain_t * mbp,uint32_t * x)463 md_get_uint32be(mdchain_t *mbp, uint32_t *x)
464 {
465 uint32_t v;
466 int err;
467
468 if ((err = md_get_mem(mbp, &v, sizeof (v), MB_MINLINE)) != 0)
469 return (err);
470 if (x != NULL)
471 *x = betohl(v);
472 return (0);
473 }
474
475 int
md_get_uint32le(mdchain_t * mbp,uint32_t * x)476 md_get_uint32le(mdchain_t *mbp, uint32_t *x)
477 {
478 uint32_t v;
479 int err;
480
481 if ((err = md_get_mem(mbp, &v, sizeof (v), MB_MINLINE)) != 0)
482 return (err);
483 if (x != NULL)
484 *x = letohl(v);
485 return (0);
486 }
487
488 int
md_get_uint64be(mdchain_t * mbp,uint64_t * x)489 md_get_uint64be(mdchain_t *mbp, uint64_t *x)
490 {
491 uint64_t v;
492 int err;
493
494 if ((err = md_get_mem(mbp, &v, sizeof (v), MB_MINLINE)) != 0)
495 return (err);
496 if (x != NULL)
497 *x = betohq(v);
498 return (0);
499 }
500
501 int
md_get_uint64le(mdchain_t * mbp,uint64_t * x)502 md_get_uint64le(mdchain_t *mbp, uint64_t *x)
503 {
504 uint64_t v;
505 int err;
506
507 if ((err = md_get_mem(mbp, &v, sizeof (v), MB_MINLINE)) != 0)
508 return (err);
509 if (x != NULL)
510 *x = letohq(v);
511 return (0);
512 }
513
514 /* ARGSUSED */
515 int
md_get_mem(mdchain_t * mbp,void * vmem,int size,int type)516 md_get_mem(mdchain_t *mbp, void *vmem, int size, int type)
517 {
518 struct mbuf *m = mbp->mb_cur;
519 char *dst = vmem;
520 uint_t count;
521
522 while (size > 0) {
523 if (m == NULL) {
524 /* DPRINT("incomplete copy"); */
525 return (EBADRPC);
526 }
527 count = mb_left(m, mbp->mb_pos);
528 if (count == 0) {
529 mbp->mb_cur = m = m->m_next;
530 if (m)
531 mbp->mb_pos = mtod(m, char *);
532 continue;
533 }
534 if (count > size)
535 count = size;
536 size -= count;
537 if (dst) {
538 if (count == 1) {
539 *dst++ = *mbp->mb_pos;
540 } else {
541 bcopy(mbp->mb_pos, dst, count);
542 dst += count;
543 }
544 }
545 mbp->mb_pos += count;
546 }
547 return (0);
548 }
549
550 /*
551 * Get the next SIZE bytes as a separate mblk.
552 * Nothing fancy here - just copy.
553 */
554 int
md_get_mbuf(mdchain_t * mbp,int size,mbuf_t ** ret)555 md_get_mbuf(mdchain_t *mbp, int size, mbuf_t **ret)
556 {
557 mbuf_t *m;
558 int err;
559
560 err = m_get(size, &m);
561 if (err)
562 return (err);
563
564 err = md_get_mem(mbp, m->m_data, size, MB_MSYSTEM);
565 if (err) {
566 m_freem(m);
567 return (err);
568 }
569 m->m_len = size;
570 *ret = m;
571
572 return (0);
573 }
574
575 /*
576 * Get a string from the mbuf chain,
577 * either Unicode or OEM chars.
578 */
579 int
md_get_string(mdchain_t * mbp,char ** str_pp,int uc)580 md_get_string(mdchain_t *mbp, char **str_pp, int uc)
581 {
582 int err;
583
584 if (uc)
585 err = md_get_ustring(mbp, str_pp);
586 else
587 err = md_get_astring(mbp, str_pp);
588 return (err);
589 }
590
591 /*
592 * Get an ASCII (really OEM) string from the mbuf chain
593 * and convert it to UTF-8
594 *
595 * Similar to md_get_ustring below.
596 */
597 int
md_get_astring(mdchain_t * real_mbp,char ** str_pp)598 md_get_astring(mdchain_t *real_mbp, char **str_pp)
599 {
600 mdchain_t tmp_mb, *mbp;
601 char *tstr, *ostr;
602 int err, i, slen;
603 uint8_t ch;
604
605 /*
606 * First, figure out the string length.
607 * Use a copy of the real_mbp so we don't
608 * actually consume it here, then search for
609 * the null (or end of data).
610 */
611 bcopy(real_mbp, &tmp_mb, sizeof (tmp_mb));
612 mbp = &tmp_mb;
613 slen = 0;
614 for (;;) {
615 err = md_get_uint8(mbp, &ch);
616 if (err)
617 break;
618 if (ch == 0)
619 break;
620 slen++;
621 }
622
623 /*
624 * Now read the (OEM) string for real.
625 * No need to re-check errors.
626 */
627 tstr = malloc(slen + 1);
628 if (tstr == NULL)
629 return (ENOMEM);
630 mbp = real_mbp;
631 for (i = 0; i < slen; i++) {
632 md_get_uint8(mbp, &ch);
633 tstr[i] = ch;
634 }
635 tstr[i] = 0;
636 md_get_uint8(mbp, NULL);
637
638 /*
639 * Convert OEM to UTF-8
640 */
641 ostr = convert_wincs_to_utf8(tstr);
642 free(tstr);
643 if (ostr == NULL)
644 return (ENOMEM);
645
646 *str_pp = ostr;
647 return (0);
648 }
649
650 /*
651 * Get a UCS-2LE string from the mbuf chain, and
652 * convert it to UTF-8.
653 *
654 * Similar to md_get_astring above.
655 */
656 int
md_get_ustring(mdchain_t * real_mbp,char ** str_pp)657 md_get_ustring(mdchain_t *real_mbp, char **str_pp)
658 {
659 mdchain_t tmp_mb, *mbp;
660 uint16_t *tstr;
661 char *ostr;
662 int err, i, slen;
663 uint16_t ch;
664
665 /*
666 * First, align(2) on the real_mbp
667 */
668 if (((uintptr_t)real_mbp->mb_pos) & 1)
669 md_get_uint8(real_mbp, NULL);
670
671 /*
672 * Next, figure out the string length.
673 * Use a copy of the real_mbp so we don't
674 * actually consume it here, then search for
675 * the null (or end of data).
676 */
677 bcopy(real_mbp, &tmp_mb, sizeof (tmp_mb));
678 mbp = &tmp_mb;
679 slen = 0;
680 for (;;) {
681 err = md_get_uint16le(mbp, &ch);
682 if (err)
683 break;
684 if (ch == 0)
685 break;
686 slen++;
687 }
688
689 /*
690 * Now read the (UCS-2) string for real.
691 * No need to re-check errors. Note:
692 * This puts the UCS-2 in NATIVE order!
693 */
694 tstr = calloc(slen + 1, 2);
695 if (tstr == NULL)
696 return (ENOMEM);
697 mbp = real_mbp;
698 for (i = 0; i < slen; i++) {
699 md_get_uint16le(mbp, &ch);
700 tstr[i] = ch;
701 }
702 tstr[i] = 0;
703 md_get_uint16le(mbp, NULL);
704
705 /*
706 * Convert UCS-2 (native!) to UTF-8
707 */
708 ostr = convert_unicode_to_utf8(tstr);
709 free(tstr);
710 if (ostr == NULL)
711 return (ENOMEM);
712
713 *str_pp = ostr;
714 return (0);
715 }
716