r898: - remove some unused macros
[gd/samba-autobuild/.git] / source4 / smb_server / request.c
1 /* 
2    Unix SMB/CIFS implementation.
3    
4    Copyright (C) Andrew Tridgell              2003
5    
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 2 of the License, or
9    (at your option) any later version.
10    
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15    
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21 /*
22   this file implements functions for manipulating the 'struct request_context' structure in smbd
23 */
24
25 #include "includes.h"
26
27 /* we over allocate the data buffer to prevent too many realloc calls */
28 #define REQ_OVER_ALLOCATION 256
29
30 /* destroy a request structure */
31 void req_destroy(struct request_context *req)
32 {
33         /* the request might be marked protected. This is done by the
34          * SMBecho code for example */
35         if (req->control_flags & REQ_CONTROL_PROTECTED) {
36                 return;
37         }
38
39         /* ahh, its so nice to destroy a complex structure in such a
40          * simple way! */
41         talloc_destroy(req->mem_ctx);
42 }
43
44 /****************************************************************************
45 construct a basic request packet, mostly used to construct async packets
46 such as change notify and oplock break requests
47 ****************************************************************************/
48 struct request_context *init_smb_request(struct server_context *smb)
49 {
50         struct request_context *req;
51         TALLOC_CTX *mem_ctx;
52
53         /* each request gets its own talloc context. The request
54            structure itself is also allocated inside this context, so
55            we need to allocate it before we construct the request
56         */
57         mem_ctx = talloc_init("request_context[%d]", smb->socket.pkt_count);
58         if (!mem_ctx) {
59                 return NULL;
60         }
61
62         smb->socket.pkt_count++;
63
64         req = talloc(mem_ctx, sizeof(*req));
65         if (!req) {
66                 return NULL;
67         }
68
69         ZERO_STRUCTP(req);
70
71         /* setup the request context */
72         req->smb = smb;
73         req->mem_ctx = mem_ctx;
74         
75         return req;
76 }
77
78
79 /*
80   setup a chained reply in req->out with the given word count and initial data buffer size. 
81 */
82 static void req_setup_chain_reply(struct request_context *req, unsigned wct, unsigned buflen)
83 {
84         uint32_t chain_base_size = req->out.size;
85
86         /* we need room for the wct value, the words, the buffer length and the buffer */
87         req->out.size += 1 + VWV(wct) + 2 + buflen;
88
89         /* over allocate by a small amount */
90         req->out.allocated = req->out.size + REQ_OVER_ALLOCATION; 
91
92         req->out.buffer = talloc_realloc(req->mem_ctx, req->out.buffer, req->out.allocated);
93         if (!req->out.buffer) {
94                 exit_server(req->smb, "allocation failed");
95         }
96
97         req->out.hdr = req->out.buffer + NBT_HDR_SIZE;
98         req->out.vwv = req->out.buffer + chain_base_size + 1;
99         req->out.wct = wct;
100         req->out.data = req->out.vwv + VWV(wct) + 2;
101         req->out.data_size = buflen;
102         req->out.ptr = req->out.data;
103
104         SCVAL(req->out.buffer, chain_base_size, wct);
105         SSVAL(req->out.vwv, VWV(wct), buflen);
106 }
107
108
109 /*
110   setup a reply in req->out with the given word count and initial data buffer size. 
111   the caller will then fill in the command words and data before calling req_send_reply() to 
112   send the reply on its way
113 */
114 void req_setup_reply(struct request_context *req, unsigned wct, unsigned buflen)
115 {
116         if (req->chain_count != 0) {
117                 req_setup_chain_reply(req, wct, buflen);
118                 return;
119         }
120
121         req->out.size = NBT_HDR_SIZE + MIN_SMB_SIZE + wct*2 + buflen;
122
123         /* over allocate by a small amount */
124         req->out.allocated = req->out.size + REQ_OVER_ALLOCATION; 
125
126         req->out.buffer = talloc(req->mem_ctx, req->out.allocated);
127         if (!req->out.buffer) {
128                 exit_server(req->smb, "allocation failed");
129         }
130
131         req->out.hdr = req->out.buffer + NBT_HDR_SIZE;
132         req->out.vwv = req->out.hdr + HDR_VWV;
133         req->out.wct = wct;
134         req->out.data = req->out.vwv + VWV(wct) + 2;
135         req->out.data_size = buflen;
136         req->out.ptr = req->out.data;
137
138         SIVAL(req->out.hdr, HDR_RCLS, 0);
139
140         SCVAL(req->out.hdr, HDR_WCT, wct);
141         SSVAL(req->out.vwv, VWV(wct), buflen);
142
143
144         memcpy(req->out.hdr, "\377SMB", 4);
145         SCVAL(req->out.hdr,HDR_FLG, FLAG_REPLY | FLAG_CASELESS_PATHNAMES); 
146         SSVAL(req->out.hdr,HDR_FLG2, 
147               (req->flags2 & FLAGS2_UNICODE_STRINGS) |
148               FLAGS2_LONG_PATH_COMPONENTS | FLAGS2_32_BIT_ERROR_CODES | FLAGS2_EXTENDED_SECURITY);
149
150         SSVAL(req->out.hdr,HDR_PIDHIGH,0);
151         memset(req->out.hdr + HDR_SS_FIELD, 0, 10);
152
153         if (req->in.hdr) {
154                 /* copy the cmd, tid, pid, uid and mid from the request */
155                 SCVAL(req->out.hdr,HDR_COM,CVAL(req->in.hdr,HDR_COM));  
156                 SSVAL(req->out.hdr,HDR_TID,SVAL(req->in.hdr,HDR_TID));
157                 SSVAL(req->out.hdr,HDR_PID,SVAL(req->in.hdr,HDR_PID));
158                 SSVAL(req->out.hdr,HDR_UID,SVAL(req->in.hdr,HDR_UID));
159                 SSVAL(req->out.hdr,HDR_MID,SVAL(req->in.hdr,HDR_MID));
160         } else {
161                 SSVAL(req->out.hdr,HDR_TID,0);
162                 SSVAL(req->out.hdr,HDR_PID,0);
163                 SSVAL(req->out.hdr,HDR_UID,0);
164                 SSVAL(req->out.hdr,HDR_MID,0);
165         }
166 }
167
168 /*
169   work out the maximum data size we will allow for this reply, given
170   the negotiated max_xmit. The basic reply packet must be setup before
171   this call
172
173   note that this is deliberately a signed integer reply
174 */
175 int req_max_data(struct request_context *req)
176 {
177         int ret;
178         ret = req->smb->negotiate.max_send;
179         ret -= PTR_DIFF(req->out.data, req->out.hdr);
180         if (ret < 0) ret = 0;
181         return ret;
182 }
183
184
185 /*
186   grow the allocation of the data buffer portion of a reply
187   packet. Note that as this can reallocate the packet buffer this
188   invalidates any local pointers into the packet.
189
190   To cope with this req->out.ptr is supplied. This will be updated to
191   point at the same offset into the packet as before this call
192 */
193 static void req_grow_allocation(struct request_context *req, unsigned new_size)
194 {
195         int delta;
196         char *buf2;
197
198         delta = new_size - req->out.data_size;
199         if (delta + req->out.size <= req->out.allocated) {
200                 /* it fits in the preallocation */
201                 return;
202         }
203
204         /* we need to realloc */
205         req->out.allocated = req->out.size + delta + REQ_OVER_ALLOCATION;
206         buf2 = talloc_realloc(req->mem_ctx, req->out.buffer, req->out.allocated);
207         if (buf2 == NULL) {
208                 smb_panic("out of memory in req_grow_allocation");
209         }
210
211         if (buf2 == req->out.buffer) {
212                 /* the malloc library gave us the same pointer */
213                 return;
214         }
215         
216         /* update the pointers into the packet */
217         req->out.data = buf2 + PTR_DIFF(req->out.data, req->out.buffer);
218         req->out.ptr  = buf2 + PTR_DIFF(req->out.ptr,  req->out.buffer);
219         req->out.vwv  = buf2 + PTR_DIFF(req->out.vwv,  req->out.buffer);
220         req->out.hdr  = buf2 + PTR_DIFF(req->out.hdr,  req->out.buffer);
221
222         req->out.buffer = buf2;
223 }
224
225
226 /*
227   grow the data buffer portion of a reply packet. Note that as this
228   can reallocate the packet buffer this invalidates any local pointers
229   into the packet. 
230
231   To cope with this req->out.ptr is supplied. This will be updated to
232   point at the same offset into the packet as before this call
233 */
234 void req_grow_data(struct request_context *req, unsigned new_size)
235 {
236         int delta;
237
238         if (!(req->control_flags & REQ_CONTROL_LARGE) && new_size > req_max_data(req)) {
239                 smb_panic("reply buffer too large!");
240         }
241
242         req_grow_allocation(req, new_size);
243
244         delta = new_size - req->out.data_size;
245
246         req->out.size += delta;
247         req->out.data_size += delta;
248
249         /* set the BCC to the new data size */
250         SSVAL(req->out.vwv, VWV(req->out.wct), new_size);
251 }
252
253 /*
254   send a reply and destroy the request buffer
255
256   note that this only looks at req->out.buffer and req->out.size, allowing manually 
257   constructed packets to be sent
258 */
259 void req_send_reply_nosign(struct request_context *req)
260 {
261         if (req->out.size > NBT_HDR_SIZE) {
262                 _smb_setlen(req->out.buffer, req->out.size - NBT_HDR_SIZE);
263         }
264
265         if (write_data(req->smb->socket.fd, req->out.buffer, req->out.size) != req->out.size) {
266                 smb_panic("failed to send reply\n");
267         }
268
269         req_destroy(req);
270 }
271
272 /*
273   possibly sign a message then send a reply and destroy the request buffer
274
275   note that this only looks at req->out.buffer and req->out.size, allowing manually 
276   constructed packets to be sent
277 */
278 void req_send_reply(struct request_context *req)
279 {
280         req_sign_packet(req);
281
282         req_send_reply_nosign(req);
283 }
284
285
286
287 /* 
288    construct and send an error packet with a forced DOS error code
289    this is needed to match win2000 behaviour for some parts of the protocol
290 */
291 void req_reply_dos_error(struct request_context *req, uint8_t eclass, uint16_t ecode)
292 {
293         /* if the basic packet hasn't been setup yet then do it now */
294         if (req->out.buffer == NULL) {
295                 req_setup_reply(req, 0, 0);
296         }
297
298         SCVAL(req->out.hdr, HDR_RCLS, eclass);
299         SSVAL(req->out.hdr, HDR_ERR, ecode);
300
301         SSVAL(req->out.hdr, HDR_FLG2, SVAL(req->out.hdr, HDR_FLG2) & ~FLAGS2_32_BIT_ERROR_CODES);
302         
303         req_send_reply(req);
304 }
305
306 /* 
307    construct and send an error packet, then destroy the request 
308    auto-converts to DOS error format when appropriate
309 */
310 void req_reply_error(struct request_context *req, NTSTATUS status)
311 {
312         req_setup_reply(req, 0, 0);
313
314         /* error returns never have any data */
315         req_grow_data(req, 0);
316
317         if (!lp_nt_status_support() || !(req->smb->negotiate.client_caps & CAP_STATUS32)) {
318                 /* convert to DOS error codes */
319                 uint8_t eclass;
320                 uint32_t ecode;
321                 ntstatus_to_dos(status, &eclass, &ecode);
322                 req_reply_dos_error(req, eclass, ecode);
323                 return;
324         }
325
326         if (NT_STATUS_IS_DOS(status)) {
327                 /* its a encoded DOS error, using the reserved range */
328                 SSVAL(req->out.hdr, HDR_RCLS, NT_STATUS_DOS_CLASS(status));
329                 SSVAL(req->out.hdr, HDR_ERR,  NT_STATUS_DOS_CODE(status));
330                 SSVAL(req->out.hdr, HDR_FLG2, SVAL(req->out.hdr, HDR_FLG2) & ~FLAGS2_32_BIT_ERROR_CODES);
331         } else {
332                 SIVAL(req->out.hdr, HDR_RCLS, NT_STATUS_V(status));
333                 SSVAL(req->out.hdr, HDR_FLG2, SVAL(req->out.hdr, HDR_FLG2) | FLAGS2_32_BIT_ERROR_CODES);
334         }
335         
336         req_send_reply(req);
337 }
338
339
340 /*
341   push a string into the data portion of the request packet, growing it if necessary
342   this gets quite tricky - please be very careful to cover all cases when modifying this
343
344   if dest is NULL, then put the string at the end of the data portion of the packet
345
346   if dest_len is -1 then no limit applies
347 */
348 size_t req_push_str(struct request_context *req, char *dest, const char *str, int dest_len, unsigned flags)
349 {
350         size_t len;
351         unsigned grow_size;
352         char *buf0;
353         const int max_bytes_per_char = 3;
354
355         if (!(flags & (STR_ASCII|STR_UNICODE))) {
356                 flags |= (req->flags2 & FLAGS2_UNICODE_STRINGS) ? STR_UNICODE : STR_ASCII;
357         }
358
359         if (dest == NULL) {
360                 dest = req->out.data + req->out.data_size;
361         }
362
363         if (dest_len != -1) {
364                 len = dest_len;
365         } else {
366                 len = (strlen(str)+2) * max_bytes_per_char;
367         }
368
369         grow_size = len + PTR_DIFF(dest, req->out.data);
370         buf0 = req->out.buffer;
371
372         req_grow_allocation(req, grow_size);
373
374         if (buf0 != req->out.buffer) {
375                 dest = req->out.buffer + PTR_DIFF(dest, buf0);
376         }
377
378         len = push_string(req->out.hdr, dest, str, len, flags);
379
380         grow_size = len + PTR_DIFF(dest, req->out.data);
381
382         if (grow_size > req->out.data_size) {
383                 req_grow_data(req, grow_size);
384         }
385
386         return len;
387 }
388
389 /*
390   append raw bytes into the data portion of the request packet
391   return the number of bytes added
392 */
393 size_t req_append_bytes(struct request_context *req, 
394                 const uint8_t *bytes, size_t byte_len)
395 {
396         req_grow_allocation(req, byte_len + req->out.data_size);
397         memcpy(req->out.data + req->out.data_size, bytes, byte_len);
398         req_grow_data(req, byte_len + req->out.data_size);
399         return byte_len;
400 }
401 /*
402   append variable block (type 5 buffer) into the data portion of the request packet
403   return the number of bytes added
404 */
405 size_t req_append_var_block(struct request_context *req, 
406                 const uint8_t *bytes, uint16_t byte_len)
407 {
408         req_grow_allocation(req, byte_len + 3 + req->out.data_size);
409         SCVAL(req->out.data + req->out.data_size, 0, 5);
410         SSVAL(req->out.data + req->out.data_size, 1, byte_len);         /* add field length */
411         if (byte_len > 0) {
412                 memcpy(req->out.data + req->out.data_size + 3, bytes, byte_len);
413         }
414         req_grow_data(req, byte_len + 3 + req->out.data_size);
415         return byte_len + 3;
416 }
417 /*
418   pull a UCS2 string from a request packet, returning a talloced unix string
419
420   the string length is limited by the 3 things:
421    - the data size in the request (end of packet)
422    - the passed 'byte_len' if it is not -1
423    - the end of string (null termination)
424
425   Note that 'byte_len' is the number of bytes in the packet
426
427   on failure zero is returned and *dest is set to NULL, otherwise the number
428   of bytes consumed in the packet is returned
429 */
430 static size_t req_pull_ucs2(struct request_context *req, const char **dest, const char *src, int byte_len, unsigned flags)
431 {
432         int src_len, src_len2, alignment=0;
433         ssize_t ret;
434
435         if (!(flags & STR_NOALIGN) && ucs2_align(req->in.buffer, src, flags)) {
436                 src++;
437                 alignment=1;
438                 if (byte_len != -1) {
439                         byte_len--;
440                 }
441         }
442
443         if (flags & STR_NO_RANGE_CHECK) {
444                 src_len = byte_len;
445         } else {
446                 src_len = req->in.data_size - PTR_DIFF(src, req->in.data);
447                 if (src_len < 0) {
448                         *dest = NULL;
449                         return 0;
450                 }
451
452                 if (byte_len != -1 && src_len > byte_len) {
453                         src_len = byte_len;
454                 }
455         }
456
457         src_len2 = strnlen_w((const smb_ucs2_t *)src, src_len/2) * 2;
458
459         if (src_len2 <= src_len - 2) {
460                 /* include the termination if we didn't reach the end of the packet */
461                 src_len2 += 2;
462         }
463
464         ret = convert_string_talloc(req->mem_ctx, CH_UCS2, CH_UNIX, src, src_len2, (const void **)dest);
465
466         if (ret == -1) {
467                 *dest = NULL;
468                 return 0;
469         }
470
471         return src_len2 + alignment;
472 }
473
474 /*
475   pull a ascii string from a request packet, returning a talloced string
476
477   the string length is limited by the 3 things:
478    - the data size in the request (end of packet)
479    - the passed 'byte_len' if it is not -1
480    - the end of string (null termination)
481
482   Note that 'byte_len' is the number of bytes in the packet
483
484   on failure zero is returned and *dest is set to NULL, otherwise the number
485   of bytes consumed in the packet is returned
486 */
487 static size_t req_pull_ascii(struct request_context *req, const char **dest, const char *src, int byte_len, unsigned flags)
488 {
489         int src_len, src_len2;
490         ssize_t ret;
491
492         if (flags & STR_NO_RANGE_CHECK) {
493                 src_len = byte_len;
494         } else {
495                 src_len = req->in.data_size - PTR_DIFF(src, req->in.data);
496                 if (src_len < 0) {
497                         *dest = NULL;
498                         return 0;
499                 }
500                 if (byte_len != -1 && src_len > byte_len) {
501                         src_len = byte_len;
502                 }
503         }
504
505         src_len2 = strnlen(src, src_len);
506         if (src_len2 <= src_len - 1) {
507                 /* include the termination if we didn't reach the end of the packet */
508                 src_len2++;
509         }
510
511         ret = convert_string_talloc(req->mem_ctx, CH_DOS, CH_UNIX, src, src_len2, (const void **)dest);
512
513         if (ret == -1) {
514                 *dest = NULL;
515                 return 0;
516         }
517
518         return src_len2;
519 }
520
521 /*
522   pull a string from a request packet, returning a talloced string
523
524   the string length is limited by the 3 things:
525    - the data size in the request (end of packet)
526    - the passed 'byte_len' if it is not -1
527    - the end of string (null termination)
528
529   Note that 'byte_len' is the number of bytes in the packet
530
531   on failure zero is returned and *dest is set to NULL, otherwise the number
532   of bytes consumed in the packet is returned
533 */
534 size_t req_pull_string(struct request_context *req, const char **dest, const char *src, int byte_len, unsigned flags)
535 {
536         if (!(flags & STR_ASCII) && 
537             (((flags & STR_UNICODE) || (req->flags2 & FLAGS2_UNICODE_STRINGS)))) {
538                 return req_pull_ucs2(req, dest, src, byte_len, flags);
539         }
540
541         return req_pull_ascii(req, dest, src, byte_len, flags);
542 }
543
544
545 /*
546   pull a ASCII4 string buffer from a request packet, returning a talloced string
547   
548   an ASCII4 buffer is a null terminated string that has a prefix
549   of the character 0x4. It tends to be used in older parts of the protocol.
550
551   on failure *dest is set to the zero length string. This seems to
552   match win2000 behaviour
553 */
554 size_t req_pull_ascii4(struct request_context *req, const char **dest, const char *src, unsigned flags)
555 {
556         ssize_t ret;
557
558         if (PTR_DIFF(src, req->in.data) + 1 > req->in.data_size) {
559                 /* win2000 treats this as the NULL string! */
560                 (*dest) = talloc_strdup(req->mem_ctx, "");
561                 return 0;
562         }
563
564         /* this consumes the 0x4 byte. We don't check whether the byte
565            is actually 0x4 or not. This matches win2000 server
566            behaviour */
567         src++;
568
569         ret = req_pull_string(req, dest, src, -1, flags);
570         if (ret == -1) {
571                 (*dest) = talloc_strdup(req->mem_ctx, "");
572                 return 1;
573         }
574         
575         return ret + 1;
576 }
577
578 /*
579   pull a DATA_BLOB from a request packet, returning a talloced blob
580
581   return False if any part is outside the data portion of the packet
582 */
583 BOOL req_pull_blob(struct request_context *req, const char *src, int len, DATA_BLOB *blob)
584 {
585         if (len != 0 && req_data_oob(req, src, len)) {
586                 return False;
587         }
588
589         (*blob) = data_blob_talloc(req->mem_ctx, src, len);
590
591         return True;
592 }
593
594 /* check that a lump of data in a request is within the bounds of the data section of
595    the packet */
596 BOOL req_data_oob(struct request_context *req, const char *ptr, uint32_t count)
597 {
598         if (count == 0) {
599                 return False;
600         }
601         
602         /* be careful with wraparound! */
603         if (ptr < req->in.data ||
604             ptr >= req->in.data + req->in.data_size ||
605             count > req->in.data_size ||
606             ptr + count > req->in.data + req->in.data_size) {
607                 return True;
608         }
609         return False;
610 }
611
612
613 /* 
614    pull an open file handle from a packet, taking account of the chained_fnum
615 */
616 uint16_t req_fnum(struct request_context *req, const char *base, unsigned offset)
617 {
618         if (req->chained_fnum != -1) {
619                 return req->chained_fnum;
620         }
621         return SVAL(base, offset);
622 }