2476270d49a2e151254fe922a4071cd2c85eb8b5
[kai/samba-autobuild/.git] / source4 / libcli / smb2 / request.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    SMB2 client request handling
5
6    Copyright (C) Andrew Tridgell        2005
7    Copyright (C) Stefan Metzmacher      2005
8    
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 2 of the License, or
12    (at your option) any later version.
13    
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18    
19    You should have received a copy of the GNU General Public License
20    along with this program; if not, write to the Free Software
21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 */
23
24 #include "includes.h"
25 #include "libcli/raw/libcliraw.h"
26 #include "libcli/smb2/smb2.h"
27 #include "include/dlinklist.h"
28 #include "lib/events/events.h"
29
30 /*
31   initialise a smb2 request
32 */
33 struct smb2_request *smb2_request_init(struct smb2_transport *transport, uint16_t opcode,
34                                        uint16_t body_fixed_size, uint32_t body_dynamic_size)
35 {
36         struct smb2_request *req;
37
38         req = talloc(transport, struct smb2_request);
39         if (req == NULL) return NULL;
40
41         req->state     = SMB2_REQUEST_INIT;
42         req->transport = transport;
43         req->session   = NULL;
44         req->tree      = NULL;
45         req->seqnum    = transport->seqnum++;
46         req->status    = NT_STATUS_OK;
47         req->async.fn  = NULL;
48         req->next = req->prev = NULL;
49
50         ZERO_STRUCT(req->in);
51         
52         req->out.size      = SMB2_HDR_BODY+NBT_HDR_SIZE+body_fixed_size;
53
54         req->out.allocated = req->out.size + body_dynamic_size;
55         req->out.buffer    = talloc_size(req, req->out.allocated);
56         if (req->out.buffer == NULL) {
57                 talloc_free(req);
58                 return NULL;
59         }
60
61         req->out.hdr       = req->out.buffer + NBT_HDR_SIZE;
62         req->out.body      = req->out.hdr + SMB2_HDR_BODY;
63         req->out.body_size = body_fixed_size;
64         req->out.dynamic   = (body_dynamic_size ? req->out.body + body_fixed_size : NULL);
65
66         SIVAL(req->out.hdr, 0,                SMB2_MAGIC);
67         SSVAL(req->out.hdr, SMB2_HDR_LENGTH,  SMB2_HDR_BODY);
68         SSVAL(req->out.hdr, SMB2_HDR_PAD1,    0);
69         SIVAL(req->out.hdr, SMB2_HDR_STATUS,  0);
70         SSVAL(req->out.hdr, SMB2_HDR_OPCODE,  opcode);
71         SSVAL(req->out.hdr, SMB2_HDR_PAD2,    0);
72         SIVAL(req->out.hdr, SMB2_HDR_FLAGS,   0);
73         SIVAL(req->out.hdr, SMB2_HDR_UNKNOWN, 0);
74         SBVAL(req->out.hdr, SMB2_HDR_SEQNUM,  req->seqnum);
75         SIVAL(req->out.hdr, SMB2_HDR_PID,     0);
76         SIVAL(req->out.hdr, SMB2_HDR_TID,     0);
77         SBVAL(req->out.hdr, SMB2_HDR_UID,     0);
78         memset(req->out.hdr+SMB2_HDR_SIG, 0, 16);
79
80         /* set the length of the fixed body part and +1 if there's a dynamic part also */
81         SSVAL(req->out.body, 0, body_fixed_size + (body_dynamic_size?1:0));
82
83         /* 
84          * if we have a dynamic part, make sure the first byte
85          * which is always be part of the packet is initialized
86          */
87         if (body_dynamic_size) {
88                 SCVAL(req->out.dynamic, 0, 0);
89         }
90
91         return req;
92 }
93
94 /*
95     initialise a smb2 request for tree operations
96 */
97 struct smb2_request *smb2_request_init_tree(struct smb2_tree *tree, uint16_t opcode,
98                                             uint16_t body_fixed_size, uint32_t body_dynamic_size)
99 {
100         struct smb2_request *req = smb2_request_init(tree->session->transport, opcode, 
101                                                      body_fixed_size, body_dynamic_size);
102         if (req == NULL) return NULL;
103
104         SBVAL(req->out.hdr,  SMB2_HDR_UID, tree->session->uid);
105         SIVAL(req->out.hdr,  SMB2_HDR_TID, tree->tid);
106         req->session = tree->session;
107         req->tree = tree;
108
109         return req;     
110 }
111
112 /* destroy a request structure and return final status */
113 NTSTATUS smb2_request_destroy(struct smb2_request *req)
114 {
115         NTSTATUS status;
116
117         /* this is the error code we give the application for when a
118            _send() call fails completely */
119         if (!req) return NT_STATUS_UNSUCCESSFUL;
120
121         if (req->transport) {
122                 /* remove it from the list of pending requests (a null op if
123                    its not in the list) */
124                 DLIST_REMOVE(req->transport->pending_recv, req);
125         }
126
127         if (req->state == SMB2_REQUEST_ERROR &&
128             NT_STATUS_IS_OK(req->status)) {
129                 req->status = NT_STATUS_INTERNAL_ERROR;
130         }
131
132         status = req->status;
133         talloc_free(req);
134         return status;
135 }
136
137 /*
138   receive a response to a packet
139 */
140 BOOL smb2_request_receive(struct smb2_request *req)
141 {
142         /* req can be NULL when a send has failed. This eliminates lots of NULL
143            checks in each module */
144         if (!req) return False;
145
146         /* keep receiving packets until this one is replied to */
147         while (req->state <= SMB2_REQUEST_RECV) {
148                 if (event_loop_once(req->transport->socket->event.ctx) != 0) {
149                         return False;
150                 }
151         }
152
153         return req->state == SMB2_REQUEST_DONE;
154 }
155
156 /* Return true if the last packet was in error */
157 BOOL smb2_request_is_error(struct smb2_request *req)
158 {
159         return NT_STATUS_IS_ERR(req->status);
160 }
161
162 /* Return true if the last packet was OK */
163 BOOL smb2_request_is_ok(struct smb2_request *req)
164 {
165         return NT_STATUS_IS_OK(req->status);
166 }
167
168 /*
169   check if a range in the reply body is out of bounds
170 */
171 BOOL smb2_oob(struct smb2_request_buffer *buf, const uint8_t *ptr, size_t size)
172 {
173         /* be careful with wraparound! */
174         if (ptr < buf->body ||
175             ptr >= buf->body + buf->body_size ||
176             size > buf->body_size ||
177             ptr + size > buf->body + buf->body_size) {
178                 return True;
179         }
180         return False;
181 }
182
183 size_t smb2_padding_size(uint32_t offset, size_t n)
184 {
185         if ((offset & (n-1)) == 0) return 0;
186         return n - (offset & (n-1));
187 }
188
189 /*
190   grow a SMB2 buffer by the specified amount
191 */
192 static NTSTATUS smb2_grow_buffer(struct smb2_request_buffer *buf, size_t increase)
193 {
194         size_t dynamic_ofs;
195         uint8_t *buffer_ptr;
196         uint32_t newsize = buf->size + increase;
197
198         /* a packet size should be limited a bit */
199         if (newsize >= 0x00FFFFFF) return NT_STATUS_MARSHALL_OVERFLOW;
200
201         if (newsize <= buf->allocated) return NT_STATUS_OK;
202
203         dynamic_ofs = buf->dynamic - buf->buffer;
204
205         buffer_ptr = talloc_realloc_size(buf, buf->buffer, newsize);
206         NT_STATUS_HAVE_NO_MEMORY(buffer_ptr);
207
208         buf->buffer     = buffer_ptr;
209         buf->hdr        = buf->buffer + NBT_HDR_SIZE;
210         buf->body       = buf->hdr    + SMB2_HDR_BODY;
211         buf->dynamic    = buf->buffer + dynamic_ofs;
212         buf->allocated  = newsize;
213
214         return NT_STATUS_OK;
215 }
216
217 /*
218   pull a uint16_t ofs/ uint16_t length/blob triple from a data blob
219   the ptr points to the start of the offset/length pair
220 */
221 NTSTATUS smb2_pull_o16s16_blob(struct smb2_request_buffer *buf, TALLOC_CTX *mem_ctx, uint8_t *ptr, DATA_BLOB *blob)
222 {
223         uint16_t ofs, size;
224         if (smb2_oob(buf, ptr, 4)) {
225                 return NT_STATUS_BUFFER_TOO_SMALL;
226         }
227         ofs  = SVAL(ptr, 0);
228         size = SVAL(ptr, 2);
229         if (ofs == 0 || size == 0) {
230                 *blob = data_blob(NULL, 0);
231                 return NT_STATUS_OK;
232         }
233         if (smb2_oob(buf, buf->hdr + ofs, size)) {
234                 return NT_STATUS_BUFFER_TOO_SMALL;
235         }
236         *blob = data_blob_talloc(mem_ctx, buf->hdr + ofs, size);
237         NT_STATUS_HAVE_NO_MEMORY(blob->data);
238         return NT_STATUS_OK;
239 }
240
241 /*
242   push a uint16_t ofs/ uint16_t length/blob triple into a data blob
243   the ofs points to the start of the offset/length pair, and is relative
244   to the body start
245 */
246 NTSTATUS smb2_push_o16s16_blob(struct smb2_request_buffer *buf, 
247                                uint16_t ofs, DATA_BLOB blob)
248 {
249         NTSTATUS status;
250         size_t offset;
251         size_t padding_length;
252         uint8_t *ptr = buf->body+ofs;
253
254         if (buf->dynamic == NULL) {
255                 return NT_STATUS_INVALID_PARAMETER;
256         }
257
258         /* we have only 16 bit for the size */
259         if (blob.length > 0xFFFF) {
260                 return NT_STATUS_BUFFER_TOO_SMALL;
261         }
262
263         /* check if there're enough room for ofs and size */
264         if (smb2_oob(buf, ptr, 4)) {
265                 return NT_STATUS_BUFFER_TOO_SMALL;
266         }
267
268         if (blob.length == 0) {
269                 SSVAL(ptr, 0, 0);
270                 SSVAL(ptr, 2, 0);
271                 return NT_STATUS_OK;
272         }
273
274         offset = buf->dynamic - buf->hdr;
275         padding_length = smb2_padding_size(offset, 2);
276         offset += padding_length;
277
278         SSVAL(ptr, 0, offset);
279         SSVAL(ptr, 2, blob.length);
280
281         status = smb2_grow_buffer(buf, padding_length + blob.length);
282         NT_STATUS_NOT_OK_RETURN(status);
283
284         memset(buf->dynamic, 0, padding_length);
285         buf->dynamic += padding_length;
286
287         memcpy(buf->dynamic, blob.data, blob.length);
288         buf->dynamic += blob.length;
289
290         buf->size += blob.length + padding_length;
291         buf->body_size += blob.length + padding_length;
292
293         return NT_STATUS_OK;
294 }
295
296
297 /*
298   push a uint16_t ofs/ uint32_t length/blob triple into a data blob
299   the ofs points to the start of the offset/length pair, and is relative
300   to the body start
301 */
302 NTSTATUS smb2_push_o16s32_blob(struct smb2_request_buffer *buf, 
303                                uint16_t ofs, DATA_BLOB blob)
304 {
305         NTSTATUS status;
306         size_t offset;
307         size_t padding_length;
308         uint8_t *ptr = buf->body+ofs;
309
310         if (buf->dynamic == NULL) {
311                 return NT_STATUS_INVALID_PARAMETER;
312         }
313
314         /* check if there're enough room for ofs and size */
315         if (smb2_oob(buf, ptr, 6)) {
316                 return NT_STATUS_BUFFER_TOO_SMALL;
317         }
318
319         if (blob.length == 0) {
320                 SSVAL(ptr, 0, 0);
321                 SIVAL(ptr, 2, 0);
322                 return NT_STATUS_OK;
323         }
324
325         offset = buf->dynamic - buf->hdr;
326         padding_length = smb2_padding_size(offset, 2);
327         offset += padding_length;
328
329         SSVAL(ptr, 0, offset);
330         SIVAL(ptr, 2, blob.length);
331
332         status = smb2_grow_buffer(buf, padding_length + blob.length);
333         NT_STATUS_NOT_OK_RETURN(status);
334
335         memset(buf->dynamic, 0, padding_length);
336         buf->dynamic += padding_length;
337
338         memcpy(buf->dynamic, blob.data, blob.length);
339         buf->dynamic += blob.length;
340
341         buf->size += blob.length + padding_length;
342         buf->body_size += blob.length + padding_length;
343
344         return NT_STATUS_OK;
345 }
346
347
348 /*
349   push a uint32_t ofs/ uint32_t length/blob triple into a data blob
350   the ofs points to the start of the offset/length pair, and is relative
351   to the body start
352 */
353 NTSTATUS smb2_push_o32s32_blob(struct smb2_request_buffer *buf, 
354                                uint32_t ofs, DATA_BLOB blob)
355 {
356         NTSTATUS status;
357         size_t offset;
358         size_t padding_length;
359         uint8_t *ptr = buf->body+ofs;
360
361         if (buf->dynamic == NULL) {
362                 return NT_STATUS_INVALID_PARAMETER;
363         }
364
365         /* check if there're enough room for ofs and size */
366         if (smb2_oob(buf, ptr, 8)) {
367                 return NT_STATUS_BUFFER_TOO_SMALL;
368         }
369
370         if (blob.length == 0) {
371                 SIVAL(ptr, 0, 0);
372                 SIVAL(ptr, 4, 0);
373                 return NT_STATUS_OK;
374         }
375
376         offset = buf->dynamic - buf->hdr;
377         padding_length = smb2_padding_size(offset, 8);
378         offset += padding_length;
379
380         SIVAL(ptr, 0, offset);
381         SIVAL(ptr, 4, blob.length);
382
383         status = smb2_grow_buffer(buf, padding_length + blob.length);
384         NT_STATUS_NOT_OK_RETURN(status);
385
386         memset(buf->dynamic, 0, padding_length);
387         buf->dynamic += padding_length;
388
389         memcpy(buf->dynamic, blob.data, blob.length);
390         buf->dynamic += blob.length;
391
392         buf->size += blob.length + padding_length;
393         buf->body_size += blob.length + padding_length;
394
395         return NT_STATUS_OK;
396 }
397
398
399 /*
400   push a uint32_t length/ uint32_t ofs/blob triple into a data blob
401   the ofs points to the start of the length/offset pair, and is relative
402   to the body start
403 */
404 NTSTATUS smb2_push_s32o32_blob(struct smb2_request_buffer *buf, 
405                                uint32_t ofs, DATA_BLOB blob)
406 {
407         NTSTATUS status;
408         size_t offset;
409         size_t padding_length;
410         uint8_t *ptr = buf->body+ofs;
411
412         if (buf->dynamic == NULL) {
413                 return NT_STATUS_INVALID_PARAMETER;
414         }
415
416         /* check if there're enough room for ofs and size */
417         if (smb2_oob(buf, ptr, 8)) {
418                 return NT_STATUS_BUFFER_TOO_SMALL;
419         }
420
421         if (blob.length == 0) {
422                 SIVAL(ptr, 0, 0);
423                 SIVAL(ptr, 4, 0);
424                 return NT_STATUS_OK;
425         }
426
427         offset = buf->dynamic - buf->hdr;
428         padding_length = smb2_padding_size(offset, 8);
429         offset += padding_length;
430
431         SIVAL(ptr, 0, blob.length);
432         SIVAL(ptr, 4, offset);
433
434         status = smb2_grow_buffer(buf, padding_length + blob.length);
435         NT_STATUS_NOT_OK_RETURN(status);
436
437         memset(buf->dynamic, 0, padding_length);
438         buf->dynamic += padding_length;
439
440         memcpy(buf->dynamic, blob.data, blob.length);
441         buf->dynamic += blob.length;
442
443         buf->size += blob.length + padding_length;
444         buf->body_size += blob.length + padding_length;
445
446         return NT_STATUS_OK;
447 }
448
449 /*
450   pull a uint16_t ofs/ uint32_t length/blob triple from a data blob
451   the ptr points to the start of the offset/length pair
452 */
453 NTSTATUS smb2_pull_o16s32_blob(struct smb2_request_buffer *buf, TALLOC_CTX *mem_ctx, uint8_t *ptr, DATA_BLOB *blob)
454 {
455         uint16_t ofs;
456         uint32_t size;
457
458         if (smb2_oob(buf, ptr, 6)) {
459                 return NT_STATUS_BUFFER_TOO_SMALL;
460         }
461         ofs  = SVAL(ptr, 0);
462         size = IVAL(ptr, 2);
463         if (ofs == 0 || size == 0) {
464                 *blob = data_blob(NULL, 0);
465                 return NT_STATUS_OK;
466         }
467         if (smb2_oob(buf, buf->hdr + ofs, size)) {
468                 return NT_STATUS_BUFFER_TOO_SMALL;
469         }
470         *blob = data_blob_talloc(mem_ctx, buf->hdr + ofs, size);
471         NT_STATUS_HAVE_NO_MEMORY(blob->data);
472         return NT_STATUS_OK;
473 }
474
475 /*
476   pull a uint32_t ofs/ uint32_t length/blob triple from a data blob
477   the ptr points to the start of the offset/length pair
478 */
479 NTSTATUS smb2_pull_o32s32_blob(struct smb2_request_buffer *buf, TALLOC_CTX *mem_ctx, uint8_t *ptr, DATA_BLOB *blob)
480 {
481         uint32_t ofs, size;
482         if (smb2_oob(buf, ptr, 8)) {
483                 return NT_STATUS_BUFFER_TOO_SMALL;
484         }
485         ofs  = IVAL(ptr, 0);
486         size = IVAL(ptr, 4);
487         if (ofs == 0 || size == 0) {
488                 *blob = data_blob(NULL, 0);
489                 return NT_STATUS_OK;
490         }
491         if (smb2_oob(buf, buf->hdr + ofs, size)) {
492                 return NT_STATUS_BUFFER_TOO_SMALL;
493         }
494         *blob = data_blob_talloc(mem_ctx, buf->hdr + ofs, size);
495         NT_STATUS_HAVE_NO_MEMORY(blob->data);
496         return NT_STATUS_OK;
497 }
498
499 /*
500   pull a string in a uint16_t ofs/ uint16_t length/blob format
501   UTF-16 without termination
502 */
503 NTSTATUS smb2_pull_o16s16_string(struct smb2_request_buffer *buf, TALLOC_CTX *mem_ctx,
504                                  uint8_t *ptr, const char **str)
505 {
506         DATA_BLOB blob;
507         NTSTATUS status;
508         ssize_t size;
509         void *vstr;
510
511         status = smb2_pull_o16s16_blob(buf, mem_ctx, ptr, &blob);
512         NT_STATUS_NOT_OK_RETURN(status);
513
514         size = convert_string_talloc(mem_ctx, CH_UTF16, CH_UNIX, 
515                                      blob.data, blob.length, &vstr);
516         data_blob_free(&blob);
517         (*str) = vstr;
518         if (size == -1) {
519                 return NT_STATUS_ILLEGAL_CHARACTER;
520         }
521         return NT_STATUS_OK;
522 }
523
524 /*
525   push a string in a uint16_t ofs/ uint16_t length/blob format
526   UTF-16 without termination
527 */
528 NTSTATUS smb2_push_o16s16_string(struct smb2_request_buffer *buf,
529                                  uint16_t ofs, const char *str)
530 {
531         DATA_BLOB blob;
532         NTSTATUS status;
533         ssize_t size;
534
535         if (strcmp("", str) == 0) {
536                 return smb2_push_o16s16_blob(buf, ofs, data_blob(NULL, 0));
537         }
538
539         size = convert_string_talloc(buf->buffer, CH_UNIX, CH_UTF16, 
540                                      str, strlen(str), (void **)&blob.data);
541         if (size == -1) {
542                 return NT_STATUS_ILLEGAL_CHARACTER;
543         }
544         blob.length = size;
545
546         status = smb2_push_o16s16_blob(buf, ofs, blob);
547         data_blob_free(&blob);
548         return status;
549 }
550
551 /*
552   push a file handle into a buffer
553 */
554 void smb2_push_handle(uint8_t *data, struct smb2_handle *h)
555 {
556         SBVAL(data, 0, h->data[0]);
557         SBVAL(data, 8, h->data[1]);
558 }
559
560 /*
561   pull a file handle from a buffer
562 */
563 void smb2_pull_handle(uint8_t *ptr, struct smb2_handle *h)
564 {
565         h->data[0] = BVAL(ptr, 0);
566         h->data[1] = BVAL(ptr, 8);
567 }