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 2010 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 *
25 * Copyright 2013 Nexenta Systems, Inc. All rights reserved.
26 */
27
28 /*
29 * Legacy encode/decode routines for door clients and servers.
30 */
31
32 #if !defined(_KERNEL) && !defined(_FAKE_KERNEL)
33 #include <errno.h>
34 #include <string.h>
35 #include <strings.h>
36 #else
37 #include <sys/types.h>
38 #include <sys/sunddi.h>
39 #include <sys/errno.h>
40 #endif
41
42 #include <smb/wintypes.h>
43 #include <smbsrv/smb_share.h>
44 #include <smbsrv/smb_door.h>
45 #include <smbsrv/alloc.h>
46 #include <smbsrv/smbinfo.h>
47
48 smb_dr_ctx_t *
49 smb_dr_decode_start(char *ptr, int size)
50 {
51 smb_dr_ctx_t *ctx = MEM_MALLOC("CommonDoor", sizeof (smb_dr_ctx_t));
52 if (ctx) {
53 ctx->start_ptr = ctx->ptr = ptr;
54 ctx->end_ptr = ptr + size;
55 ctx->status = 0;
56 }
57 return (ctx);
58 }
59
60 int
61 smb_dr_decode_finish(smb_dr_ctx_t *ctx)
62 {
63 int status = ctx->status;
64 if (status == 0 && ctx->ptr != ctx->end_ptr)
65 status = ENOTEMPTY;
66
67 MEM_FREE("CommonDoor", ctx);
68 return (status);
69 }
70
71 smb_dr_ctx_t *
72 smb_dr_encode_start(char *ptr, int size)
73 {
74 smb_dr_ctx_t *ctx = MEM_MALLOC("CommonDoor", sizeof (smb_dr_ctx_t));
75 if (ctx) {
76 ctx->start_ptr = ctx->ptr = ptr;
77 ctx->end_ptr = ptr + size;
78 ctx->status = 0;
79 }
80 return (ctx);
81 }
82
83 int
84 smb_dr_encode_finish(smb_dr_ctx_t *ctx, unsigned int *used)
85 {
86 int status = ctx->status;
87 if (status == 0) {
88 if (ctx->ptr < ctx->end_ptr) {
89 /*LINTED E_PTRDIFF_OVERFLOW*/
90 *used = ctx->ptr - ctx->start_ptr;
91 } else {
92 status = ENOSPC;
93 }
94 }
95
96 MEM_FREE("CommonDoor", ctx);
97 return (status);
98 }
99
100 DWORD
101 smb_dr_get_dword(smb_dr_ctx_t *ctx)
102 {
103 DWORD num = 0;
104 if (ctx->status == 0) {
105 if (ctx->ptr + sizeof (DWORD) <= ctx->end_ptr) {
106 (void) memcpy(&num, ctx->ptr, sizeof (DWORD));
107 ctx->ptr += sizeof (DWORD);
108 } else {
109 ctx->status = ENOSPC;
110 }
111 }
112 return (num);
113 }
114
115 int32_t
116 smb_dr_get_int32(smb_dr_ctx_t *ctx)
117 {
118 int32_t num = 0;
119 if (ctx->status == 0) {
120 if (ctx->ptr + sizeof (int32_t) <= ctx->end_ptr) {
121 (void) memcpy(&num, ctx->ptr, sizeof (int32_t));
122 ctx->ptr += sizeof (int32_t);
123 } else {
124 ctx->status = ENOSPC;
125 }
126 }
127 return (num);
128 }
129
130 uint32_t
131 smb_dr_get_uint32(smb_dr_ctx_t *ctx)
132 {
133 return ((uint32_t)smb_dr_get_int32(ctx));
134 }
135
136 char *
137 smb_dr_get_string(smb_dr_ctx_t *ctx)
138 {
139 char *buf = NULL;
140 int len = smb_dr_get_int32(ctx);
141
142 if (ctx->status == 0) {
143 if (len == -1)
144 return (buf);
145
146 if (ctx->ptr + len <= ctx->end_ptr) {
147 buf = MEM_MALLOC("CommonDoor", len +1);
148 if (buf) {
149 if (len == 0) {
150 (void) strcpy(buf, "");
151 } else {
152 (void) memcpy(buf, ctx->ptr, len);
153 ctx->ptr += len;
154 *(buf + len) = '\0';
155 }
156 } else {
157 #if !defined(_KERNEL) && !defined(_FAKE_KERNEL)
158 ctx->status = errno;
159 #else
160 ctx->status = ENOMEM;
161 #endif
162 }
163 } else {
164 ctx->status = ENOSPC;
165 }
166 }
167 return (buf);
168 }
169
170 void
171 smb_dr_put_dword(smb_dr_ctx_t *ctx, DWORD num)
172 {
173 if (ctx->status == 0) {
174 if (ctx->ptr + sizeof (DWORD) <= ctx->end_ptr) {
175 (void) memcpy(ctx->ptr, &num, sizeof (DWORD));
176 ctx->ptr += sizeof (DWORD);
177 } else {
178 ctx->status = ENOSPC;
179 }
180 }
181 }
182
183 void
184 smb_dr_put_int32(smb_dr_ctx_t *ctx, int32_t num)
185 {
186 if (ctx->status == 0) {
187 if (ctx->ptr + sizeof (int32_t) <= ctx->end_ptr) {
188 (void) memcpy(ctx->ptr, &num, sizeof (int32_t));
189 ctx->ptr += sizeof (int32_t);
190 } else {
191 ctx->status = ENOSPC;
192 }
193 }
194 }
195
196 void
197 smb_dr_put_uint32(smb_dr_ctx_t *ctx, uint32_t num)
198 {
199 smb_dr_put_int32(ctx, (int32_t)num);
200 }
201
202 void
203 smb_dr_put_string(smb_dr_ctx_t *ctx, const char *buf)
204 {
205 int len;
206
207 if (!buf)
208 len = -1;
209 else
210 len = strlen(buf);
211
212 if (ctx->status == 0) {
213 smb_dr_put_int32(ctx, len);
214 if (len <= 0)
215 return;
216
217 if (ctx->ptr + len <= ctx->end_ptr) {
218 (void) memcpy(ctx->ptr, buf, len);
219 ctx->ptr += len;
220 } else {
221 ctx->status = ENOSPC;
222 }
223 }
224 }
225
226 void
227 smb_dr_free_string(char *buf)
228 {
229 if (buf)
230 MEM_FREE("CommonDoor", buf);
231 }
232
233 int64_t
234 smb_dr_get_int64(smb_dr_ctx_t *ctx)
235 {
236 int64_t num = 0;
237 if (ctx->status == 0) {
238 if (ctx->ptr + sizeof (int64_t) <= ctx->end_ptr) {
239 (void) memcpy(&num, ctx->ptr, sizeof (int64_t));
240 ctx->ptr += sizeof (int64_t);
241 } else {
242 ctx->status = ENOSPC;
243 }
244 }
245 return (num);
246 }
247
248 uint64_t
249 smb_dr_get_uint64(smb_dr_ctx_t *ctx)
250 {
251 return ((uint64_t)smb_dr_get_int64(ctx));
252 }
253
254
255 void
256 smb_dr_put_int64(smb_dr_ctx_t *ctx, int64_t num)
257 {
258 if (ctx->status == 0) {
259 if (ctx->ptr + sizeof (int64_t) <= ctx->end_ptr) {
260 (void) memcpy(ctx->ptr, &num, sizeof (int64_t));
261 ctx->ptr += sizeof (int64_t);
262 } else {
263 ctx->status = ENOSPC;
264 }
265 }
266 }
267
268 void
269 smb_dr_put_uint64(smb_dr_ctx_t *ctx, uint64_t num)
270 {
271 smb_dr_put_int64(ctx, (int64_t)num);
272 }
273
274 void
275 smb_dr_put_short(smb_dr_ctx_t *ctx, short num)
276 {
277 if (ctx->status == 0) {
278 if (ctx->ptr + sizeof (short) <= ctx->end_ptr) {
279 (void) memcpy(ctx->ptr, &num, sizeof (short));
280 ctx->ptr += sizeof (short);
281 } else {
282 ctx->status = ENOSPC;
283 }
284 }
285 }
286
287 short
288 smb_dr_get_short(smb_dr_ctx_t *ctx)
289 {
290 short num = 0;
291 if (ctx->status == 0) {
292 if (ctx->ptr + sizeof (short) <= ctx->end_ptr) {
293 (void) memcpy(&num, ctx->ptr, sizeof (short));
294 ctx->ptr += sizeof (short);
295 } else {
296 ctx->status = ENOSPC;
297 }
298 }
299 return (num);
300 }
301
302 void
303 smb_dr_put_ushort(smb_dr_ctx_t *ctx, unsigned short num)
304 {
305 smb_dr_put_short(ctx, (short)num);
306 }
307
308 unsigned short
309 smb_dr_get_ushort(smb_dr_ctx_t *ctx)
310 {
311 return ((unsigned short)smb_dr_get_short(ctx));
312 }
313
314 void
315 smb_dr_put_word(smb_dr_ctx_t *ctx, WORD num)
316 {
317 smb_dr_put_ushort(ctx, num);
318 }
319
320 WORD
321 smb_dr_get_word(smb_dr_ctx_t *ctx)
322 {
323 return (smb_dr_get_ushort(ctx));
324 }
325
326 void
327 smb_dr_put_BYTE(smb_dr_ctx_t *ctx, BYTE byte)
328 {
329 if (ctx->status == 0) {
330 if (ctx->ptr + sizeof (BYTE) <= ctx->end_ptr) {
331 (void) memcpy(ctx->ptr, &byte, sizeof (BYTE));
332 ctx->ptr += sizeof (BYTE);
333 } else {
334 ctx->status = ENOSPC;
335 }
336 }
337 }
338
339 BYTE
340 smb_dr_get_BYTE(smb_dr_ctx_t *ctx)
341 {
342 BYTE byte = 0;
343 if (ctx->status == 0) {
344 if (ctx->ptr + sizeof (BYTE) <= ctx->end_ptr) {
345 (void) memcpy(&byte, ctx->ptr, sizeof (BYTE));
346 ctx->ptr += sizeof (BYTE);
347 } else {
348 ctx->status = ENOSPC;
349 }
350 }
351 return (byte);
352 }
353
354 void
355 smb_dr_put_buf(smb_dr_ctx_t *ctx, unsigned char *start, int len)
356 {
357 smb_dr_put_int32(ctx, len);
358 if (ctx->status == 0) {
359 if (ctx->ptr + len <= ctx->end_ptr) {
360 (void) memcpy(ctx->ptr, start, len);
361 ctx->ptr += len;
362 } else {
363 ctx->status = ENOSPC;
364 }
365 }
366 }
367
368 int
369 smb_dr_get_buf(smb_dr_ctx_t *ctx, unsigned char *buf, int bufsize)
370 {
371 int len = -1;
372
373 if (!buf)
374 return (-1);
375
376 len = smb_dr_get_int32(ctx);
377 if (ctx->status == 0) {
378 if (bufsize < len) {
379 ctx->status = ENOSPC;
380 return (-2);
381 }
382
383 if (ctx->ptr + len <= ctx->end_ptr) {
384 (void) memcpy(buf, ctx->ptr, len);
385 ctx->ptr += len;
386 } else {
387 ctx->status = ENOSPC;
388 return (-3);
389 }
390 }
391
392 return (len);
393 }
394
395 void
396 smb_dr_get_share(smb_dr_ctx_t *ctx, smb_share_t *si)
397 {
398 if (ctx->status == 0) {
399 if (smb_dr_get_int32(ctx)) {
400 (void) memcpy(si, ctx->ptr, sizeof (smb_share_t));
401 ctx->ptr += sizeof (smb_share_t);
402 } else {
403 bzero(si, sizeof (smb_share_t));
404 }
405 } else {
406 bzero(si, sizeof (smb_share_t));
407 }
408 }
409
410 void
411 smb_dr_put_share(smb_dr_ctx_t *ctx, smb_share_t *si)
412 {
413 if (si) {
414 smb_dr_put_int32(ctx, 1);
415 if (ctx->ptr + sizeof (smb_share_t) <= ctx->end_ptr) {
416 (void) memcpy(ctx->ptr, si, sizeof (smb_share_t));
417 ctx->ptr += sizeof (smb_share_t);
418 } else {
419 ctx->status = ENOSPC;
420 }
421 } else {
422 smb_dr_put_int32(ctx, 0);
423 }
424 }