fixed a problem with the smb client code spinning when the connection
[samba.git] / source4 / libcli / raw / rawrequest.c
1 /* 
2    Unix SMB/CIFS implementation.
3    
4    Copyright (C) Andrew Tridgell  2003
5    Copyright (C) James Myers 2003 <myersjj@samba.org>
6    
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11    
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16    
17    You should have received a copy of the GNU General Public License
18    along with this program; if not, write to the Free Software
19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 */
21
22 /*
23   this file implements functions for manipulating the 'struct cli_request' structure in libsmb
24 */
25
26 #include "includes.h"
27
28 /* we over allocate the data buffer to prevent too many realloc calls */
29 #define REQ_OVER_ALLOCATION 256
30
31 /* assume that a character will not consume more than 3 bytes per char */
32 #define MAX_BYTES_PER_CHAR 3
33
34 /* destroy a request structure and return final status */
35 NTSTATUS cli_request_destroy(struct cli_request *req)
36 {
37         NTSTATUS status;
38
39         /* this is the error code we give the application for when a
40            _send() call fails completely */
41         if (!req) return NT_STATUS_UNSUCCESSFUL;
42
43         /* remove it from the list of pending requests (a null op if
44            its not in the list) */
45         DLIST_REMOVE(req->transport->pending_requests, req);
46
47         /* ahh, its so nice to destroy a complex structure in such a
48            simple way! */
49         status = req->status;
50         talloc_destroy(req->mem_ctx);
51         return status;
52 }
53
54
55 /*
56   low-level function to setup a request buffer for a non-SMB packet 
57   at the transport level
58 */
59 struct cli_request *cli_request_setup_nonsmb(struct cli_transport *transport, uint_t size)
60 {
61         struct cli_request *req;
62         TALLOC_CTX *mem_ctx;
63         
64         /* each request gets its own talloc context. The request
65            structure itself is also allocated inside this context,
66            so we need to allocate it before we construct the request
67         */
68         mem_ctx = talloc_init("cli_request");
69         if (!mem_ctx) {
70                 return NULL;
71         }
72
73         req = talloc(mem_ctx, sizeof(struct cli_request));
74         if (!req) {
75                 return NULL;
76         }
77         ZERO_STRUCTP(req);
78
79         /* setup the request context */
80         req->mem_ctx = mem_ctx;
81         req->transport = transport;
82         req->session = NULL;
83         req->tree = NULL;
84         req->out.size = size;
85
86         /* over allocate by a small amount */
87         req->out.allocated = req->out.size + REQ_OVER_ALLOCATION; 
88
89         req->out.buffer = talloc(req->mem_ctx, req->out.allocated);
90         if (!req->out.buffer) {
91                 return NULL;
92         }
93
94         SIVAL(req->out.buffer, 0, 0);
95
96         return req;
97 }
98
99
100 /*
101   setup a SMB packet at transport level
102 */
103 struct cli_request *cli_request_setup_transport(struct cli_transport *transport,
104                                                 uint8 command, unsigned wct, unsigned buflen)
105 {
106         struct cli_request *req;
107
108         req = cli_request_setup_nonsmb(transport, NBT_HDR_SIZE + MIN_SMB_SIZE + wct*2 + buflen);
109
110         if (!req) return NULL;
111         
112         req->out.hdr = req->out.buffer + NBT_HDR_SIZE;
113         req->out.vwv = req->out.hdr + HDR_VWV;
114         req->out.wct = wct;
115         req->out.data = req->out.vwv + VWV(wct) + 2;
116         req->out.data_size = buflen;
117         req->out.ptr = req->out.data;
118
119         SCVAL(req->out.hdr, HDR_WCT, wct);
120         SSVAL(req->out.vwv, VWV(wct), buflen);
121
122         memcpy(req->out.hdr, "\377SMB", 4);
123         SCVAL(req->out.hdr,HDR_COM,command);
124
125         SCVAL(req->out.hdr,HDR_FLG, FLAG_CASELESS_PATHNAMES);
126         SSVAL(req->out.hdr,HDR_FLG2, 0);
127
128         /* assign a mid */
129         req->mid = cli_transport_next_mid(transport);
130
131         /* copy the pid, uid and mid to the request */
132         SSVAL(req->out.hdr, HDR_PID, 0);
133         SSVAL(req->out.hdr, HDR_UID, 0);
134         SSVAL(req->out.hdr, HDR_MID, req->mid);
135         SSVAL(req->out.hdr, HDR_TID,0);
136         SSVAL(req->out.hdr, HDR_PIDHIGH,0);
137         SIVAL(req->out.hdr, HDR_RCLS, 0);
138         memset(req->out.hdr+HDR_SS_FIELD, 0, 10);
139         
140         return req;
141 }
142
143 /*
144   setup a reply in req->out with the given word count and initial data
145   buffer size.  the caller will then fill in the command words and
146   data before calling cli_request_send() to send the reply on its
147   way. This interface is used before a session is setup.
148 */
149 struct cli_request *cli_request_setup_session(struct cli_session *session,
150                                               uint8 command, unsigned wct, unsigned buflen)
151 {
152         struct cli_request *req;
153         uint16 flags2;
154         uint32 capabilities;
155
156         req = cli_request_setup_transport(session->transport, command, wct, buflen);
157
158         if (!req) return NULL;
159
160         req->session = session;
161         
162         flags2 = FLAGS2_LONG_PATH_COMPONENTS;
163         capabilities = session->transport->negotiate.capabilities;
164
165         if (capabilities & CAP_UNICODE) {
166                 flags2 |= FLAGS2_UNICODE_STRINGS;
167         }
168         if (capabilities & CAP_STATUS32) {
169                 flags2 |= FLAGS2_32_BIT_ERROR_CODES;
170         }
171         if (capabilities & CAP_EXTENDED_SECURITY) {
172                 flags2 |= FLAGS2_EXTENDED_SECURITY;
173         }
174         if (session->transport->negotiate.sign_info.doing_signing) {
175                 flags2 |= FLAGS2_SMB_SECURITY_SIGNATURES;
176         }
177
178         SSVAL(req->out.hdr, HDR_FLG2, flags2);
179         SSVAL(req->out.hdr, HDR_PID, session->pid & 0xFFFF);
180         SSVAL(req->out.hdr, HDR_PIDHIGH, session->pid >> 16);
181         SSVAL(req->out.hdr, HDR_UID, session->vuid);
182         
183         return req;
184 }
185
186 /*
187   setup a request for tree based commands
188 */
189 struct cli_request *cli_request_setup(struct cli_tree *tree,
190                                       uint8 command, 
191                                       unsigned wct, unsigned buflen)
192 {
193         struct cli_request *req;
194
195         req = cli_request_setup_session(tree->session, command, wct, buflen);
196         if (req) {
197                 req->tree = tree;
198                 SSVAL(req->out.hdr,HDR_TID,tree->tid);
199         }
200         return req;
201 }
202
203 /*
204   grow the allocation of the data buffer portion of a reply
205   packet. Note that as this can reallocate the packet buffer this
206   invalidates any local pointers into the packet.
207
208   To cope with this req->out.ptr is supplied. This will be updated to
209   point at the same offset into the packet as before this call
210 */
211 static void cli_req_grow_allocation(struct cli_request *req, unsigned new_size)
212 {
213         int delta;
214         char *buf2;
215
216         delta = new_size - req->out.data_size;
217         if (delta + req->out.size <= req->out.allocated) {
218                 /* it fits in the preallocation */
219                 return;
220         }
221
222         /* we need to realloc */
223         req->out.allocated = req->out.size + delta + REQ_OVER_ALLOCATION;
224         buf2 = talloc_realloc(req->mem_ctx, req->out.buffer, req->out.allocated);
225         if (buf2 == NULL) {
226                 smb_panic("out of memory in req_grow_allocation");
227         }
228
229         if (buf2 == req->out.buffer) {
230                 /* the malloc library gave us the same pointer */
231                 return;
232         }
233         
234         /* update the pointers into the packet */
235         req->out.data = buf2 + PTR_DIFF(req->out.data, req->out.buffer);
236         req->out.ptr  = buf2 + PTR_DIFF(req->out.ptr,  req->out.buffer);
237         req->out.vwv  = buf2 + PTR_DIFF(req->out.vwv,  req->out.buffer);
238         req->out.hdr  = buf2 + PTR_DIFF(req->out.hdr,  req->out.buffer);
239
240         req->out.buffer = buf2;
241 }
242
243
244 /*
245   grow the data buffer portion of a reply packet. Note that as this
246   can reallocate the packet buffer this invalidates any local pointers
247   into the packet. 
248
249   To cope with this req->out.ptr is supplied. This will be updated to
250   point at the same offset into the packet as before this call
251 */
252 static void cli_req_grow_data(struct cli_request *req, unsigned new_size)
253 {
254         int delta;
255
256         cli_req_grow_allocation(req, new_size);
257
258         delta = new_size - req->out.data_size;
259
260         req->out.size += delta;
261         req->out.data_size += delta;
262
263         /* set the BCC to the new data size */
264         SSVAL(req->out.vwv, VWV(req->out.wct), new_size);
265 }
266
267 /*
268   send a message
269 */
270 BOOL cli_request_send(struct cli_request *req)
271 {
272         uint_t ret;
273
274         if (IVAL(req->out.buffer, 0) == 0) {
275                 _smb_setlen(req->out.buffer, req->out.size - NBT_HDR_SIZE);
276         }
277
278         cli_request_calculate_sign_mac(req);
279
280         ret = cli_sock_write(req->transport->socket, req->out.buffer, req->out.size);
281
282         if (req->out.size != ret) {
283                 req->transport->error.etype = ETYPE_SOCKET;
284                 req->transport->error.e.socket_error = SOCKET_WRITE_ERROR;
285                 DEBUG(0,("Error writing %d bytes to server - %s\n",
286                          (int)req->out.size, strerror(errno)));
287                 return False;
288         }
289
290         /* add it to the list of pending requests */
291         DLIST_ADD(req->transport->pending_requests, req);
292         
293         return True;
294 }
295
296
297 /*
298   receive a response to a packet
299 */
300 BOOL cli_request_receive(struct cli_request *req)
301 {
302         /* req can be NULL when a send has failed. This eliminates lots of NULL
303            checks in each module */
304         if (!req) return False;
305
306         /* keep receiving packets until this one is replied to */
307         while (!req->in.buffer) {
308                 if (!cli_transport_select(req->transport)) {
309                         return False;
310                 }
311
312                 if (!cli_request_receive_next(req->transport)) {
313                         cli_transport_close(req->transport);
314                         req->status = NT_STATUS_UNEXPECTED_NETWORK_ERROR;
315                         return False;
316                 }
317         }
318
319         return True;
320 }
321
322
323 /*
324   handle oplock break requests from the server - return True if the request was
325   an oplock break
326 */
327 static BOOL handle_oplock_break(struct cli_transport *transport, uint_t len, const char *hdr, const char *vwv)
328 {
329         /* we must be very fussy about what we consider an oplock break to avoid
330            matching readbraw replies */
331         if (len != MIN_SMB_SIZE + VWV(8) ||
332             (CVAL(hdr, HDR_FLG) & FLAG_REPLY) ||
333             CVAL(hdr,HDR_COM) != SMBlockingX ||
334             SVAL(hdr, HDR_MID) != 0xFFFF ||
335             SVAL(vwv,VWV(6)) != 0 ||
336             SVAL(vwv,VWV(7)) != 0) {
337                 return False;
338         }
339
340         if (transport->oplock.handler) {
341                 uint16 tid = SVAL(hdr, HDR_TID);
342                 uint16 fnum = SVAL(vwv,VWV(2));
343                 uint8 level = CVAL(vwv,VWV(3));
344                 transport->oplock.handler(transport, tid, fnum, level, transport->oplock.private);
345         }
346
347         return True;
348 }
349
350
351 /*
352   receive an async message from the server
353   this function assumes that the caller already knows that the socket is readable
354   and that there is a packet waiting
355
356   The packet is not actually returned by this function, instead any
357   registered async message handlers are called
358
359   return True if a packet was successfully received and processed
360   return False if the socket appears to be dead
361 */
362 BOOL cli_request_receive_next(struct cli_transport *transport)
363 {
364         BOOL ret;
365         int len;
366         char header[NBT_HDR_SIZE];
367         char *buffer, *hdr, *vwv;
368         TALLOC_CTX *mem_ctx;
369         struct cli_request *req;
370         uint16 wct, mid = 0;
371
372         len = cli_sock_read(transport->socket, header, 4);
373         if (len != 4) {
374                 return False;
375         }
376         
377         len = smb_len(header);
378
379         mem_ctx = talloc_init("cli_request_receive_next");
380         
381         /* allocate the incoming buffer at the right size */
382         buffer = talloc(mem_ctx, len+NBT_HDR_SIZE);
383         if (!buffer) {
384                 talloc_destroy(mem_ctx);
385                 return False;
386         }
387
388         /* fill in the already received header */
389         memcpy(buffer, header, NBT_HDR_SIZE);
390
391         ret = cli_sock_read(transport->socket, buffer + NBT_HDR_SIZE, len);
392         /* If the server is not responding, note that now */
393         if (ret != len) {
394                 return False;
395         }
396
397         hdr = buffer+NBT_HDR_SIZE;
398         vwv = hdr + HDR_VWV;
399
400         /* see if it could be an oplock break request */
401         if (handle_oplock_break(transport, len, hdr, vwv)) {
402                 goto done;
403         }
404
405         /* at this point we need to check for a readbraw reply, as these can be any length */
406         if (transport->readbraw_pending) {
407                 transport->readbraw_pending = 0;
408
409                 /* it must match the first entry in the pending queue as the client is not allowed
410                    to have outstanding readbraw requests */
411                 req = transport->pending_requests;
412                 if (!req) goto done;
413
414                 req->in.buffer = buffer;
415                 talloc_steal(mem_ctx, req->mem_ctx, buffer);
416                 req->in.size = len + NBT_HDR_SIZE;
417                 req->in.allocated = req->in.size;
418                 goto async;
419         }
420
421         if (len >= MIN_SMB_SIZE) {
422                 /* extract the mid for matching to pending requests */
423                 mid = SVAL(hdr, HDR_MID);
424                 wct = CVAL(hdr, HDR_WCT);
425         }
426
427         /* match the incoming request against the list of pending requests */
428         for (req=transport->pending_requests; req; req=req->next) {
429                 if (req->mid == mid) break;
430         }
431
432         if (!req) {
433                 DEBUG(3,("Discarding unmatched reply with mid %d\n", mid));
434                 goto done;
435         }
436
437         /* fill in the 'in' portion of the matching request */
438         req->in.buffer = buffer;
439         talloc_steal(mem_ctx, req->mem_ctx, buffer);
440         req->in.size = len + NBT_HDR_SIZE;
441         req->in.allocated = req->in.size;
442
443         /* handle non-SMB replies */
444         if (req->in.size < NBT_HDR_SIZE + MIN_SMB_SIZE) {
445                 goto done;
446         }
447
448         if (req->in.size < NBT_HDR_SIZE + MIN_SMB_SIZE + VWV(wct)) {
449                 DEBUG(2,("bad reply size for mid %d\n", mid));
450                 req->status = NT_STATUS_UNSUCCESSFUL;
451                 goto done;
452         }
453
454         req->in.hdr = hdr;
455         req->in.vwv = vwv;
456         req->in.wct = wct;
457         if (req->in.size >= NBT_HDR_SIZE + MIN_SMB_SIZE + VWV(wct)) {
458                 req->in.data = req->in.vwv + VWV(wct) + 2;
459                 req->in.data_size = SVAL(req->in.vwv, VWV(wct));
460                 if (req->in.size < NBT_HDR_SIZE + MIN_SMB_SIZE + VWV(wct) + req->in.data_size) {
461                         DEBUG(3,("bad data size for mid %d\n", mid));
462                         /* blergh - w2k3 gives a bogus data size values in some
463                            openX replies */
464                         req->in.data_size = req->in.size - (NBT_HDR_SIZE + MIN_SMB_SIZE + VWV(wct));
465                 }
466         }
467         req->in.ptr = req->in.data;
468         req->flags2 = SVAL(req->in.hdr, HDR_FLG2);
469
470         if (!(req->flags2 & FLAGS2_32_BIT_ERROR_CODES)) {
471                 transport->error.etype = ETYPE_DOS;
472                 transport->error.e.dos.eclass = CVAL(req->in.hdr,HDR_RCLS);
473                 transport->error.e.dos.ecode = SVAL(req->in.hdr,HDR_ERR);
474                 req->status = dos_to_ntstatus(transport->error.e.dos.eclass, 
475                                               transport->error.e.dos.ecode);
476         } else {
477                 transport->error.etype = ETYPE_NT;
478                 transport->error.e.nt_status = NT_STATUS(IVAL(req->in.hdr, HDR_RCLS));
479                 req->status = transport->error.e.nt_status;
480         }
481
482         if (!cli_request_check_sign_mac(req)) {
483                 transport->error.etype = ETYPE_SOCKET;
484                 transport->error.e.socket_error = SOCKET_READ_BAD_SIG;
485                 return False;
486         };
487
488 async:
489         /* if this request has an async handler then call that to
490            notify that the reply has been received. This might destroy
491            the request so it must happen last */
492         if (req->async.fn) {
493                 req->async.fn(req);
494         }
495
496 done:
497         talloc_destroy(mem_ctx);
498         return True;
499 }
500
501
502 /*
503   wait for a reply to be received for a packet that just returns an error
504   code and nothing more
505 */
506 NTSTATUS cli_request_simple_recv(struct cli_request *req)
507 {
508         cli_request_receive(req);
509         return cli_request_destroy(req);
510 }
511
512
513 /* Return true if the last packet was in error */
514 BOOL cli_request_is_error(struct cli_request *req)
515 {
516         return NT_STATUS_IS_ERR(req->status);
517 }
518
519 /*
520   append a string into the data portion of the request packet
521
522   return the number of bytes added to the packet
523 */
524 size_t cli_req_append_string(struct cli_request *req, const char *str, unsigned flags)
525 {
526         size_t len;
527
528         /* determine string type to use */
529         if (!(flags & (STR_ASCII|STR_UNICODE))) {
530                 flags |= (req->transport->negotiate.capabilities & CAP_UNICODE) ? STR_UNICODE : STR_ASCII;
531         }
532
533         len = (strlen(str)+2) * MAX_BYTES_PER_CHAR;             
534
535         cli_req_grow_allocation(req, len + req->out.data_size);
536
537         len = push_string(NULL, req->out.data + req->out.data_size, str, len, flags);
538
539         cli_req_grow_data(req, len + req->out.data_size);
540
541         return len;
542 }
543
544 /*
545   this is like cli_req_append_string but it also return the
546   non-terminated string byte length, which can be less than the number
547   of bytes consumed in the packet for 2 reasons:
548
549    1) the string in the packet may be null terminated
550    2) the string in the packet may need a 1 byte UCS2 alignment
551
552  this is used in places where the non-terminated string byte length is
553  placed in the packet as a separate field  
554 */
555 size_t cli_req_append_string_len(struct cli_request *req, const char *str, unsigned flags, int *len)
556 {
557         int diff = 0;
558         size_t ret;
559
560         /* determine string type to use */
561         if (!(flags & (STR_ASCII|STR_UNICODE))) {
562                 flags |= (req->transport->negotiate.capabilities & CAP_UNICODE) ? STR_UNICODE : STR_ASCII;
563         }
564
565         /* see if an alignment byte will be used */
566         if ((flags & STR_UNICODE) && !(flags & STR_NOALIGN)) {
567                 diff = ucs2_align(NULL, req->out.data + req->out.data_size, flags);
568         }
569
570         /* do the hard work */
571         ret = cli_req_append_string(req, str, flags);
572
573         /* see if we need to subtract the termination */
574         if (flags & STR_TERMINATE) {
575                 diff += (flags & STR_UNICODE) ? 2 : 1;
576         }
577
578         if (ret >= diff) {
579                 (*len) = ret - diff;
580         } else {
581                 (*len) = ret;
582         }
583
584         return ret;
585 }
586
587
588 /*
589   push a string into the data portion of the request packet, growing it if necessary
590   this gets quite tricky - please be very careful to cover all cases when modifying this
591
592   if dest is NULL, then put the string at the end of the data portion of the packet
593
594   if dest_len is -1 then no limit applies
595 */
596 size_t cli_req_append_ascii4(struct cli_request *req, const char *str, unsigned flags)
597 {
598         size_t size;
599         cli_req_append_bytes(req, (const uint8 *)"\4", 1);
600         size = cli_req_append_string(req, str, flags);
601         return size + 1;
602 }
603
604
605 /*
606   push a blob into the data portion of the request packet, growing it if necessary
607   this gets quite tricky - please be very careful to cover all cases when modifying this
608
609   if dest is NULL, then put the blob at the end of the data portion of the packet
610 */
611 size_t cli_req_append_blob(struct cli_request *req, const DATA_BLOB *blob)
612 {
613         cli_req_grow_allocation(req, req->out.data_size + blob->length);
614         memcpy(req->out.data + req->out.data_size, blob->data, blob->length);
615         cli_req_grow_data(req, req->out.data_size + blob->length);
616         return blob->length;
617 }
618
619 /*
620   append raw bytes into the data portion of the request packet
621   return the number of bytes added
622 */
623 size_t cli_req_append_bytes(struct cli_request *req, const uint8 *bytes, size_t byte_len)
624 {
625         cli_req_grow_allocation(req, byte_len + req->out.data_size);
626         memcpy(req->out.data + req->out.data_size, bytes, byte_len);
627         cli_req_grow_data(req, byte_len + req->out.data_size);
628         return byte_len;
629 }
630
631 /*
632   append variable block (type 5 buffer) into the data portion of the request packet
633   return the number of bytes added
634 */
635 size_t cli_req_append_var_block(struct cli_request *req, const uint8 *bytes, uint16 byte_len)
636 {
637         cli_req_grow_allocation(req, byte_len + 3 + req->out.data_size);
638         SCVAL(req->out.data + req->out.data_size, 0, 5);
639         SSVAL(req->out.data + req->out.data_size, 1, byte_len);         /* add field length */
640         if (byte_len > 0) {
641                 memcpy(req->out.data + req->out.data_size + 3, bytes, byte_len);
642         }
643         cli_req_grow_data(req, byte_len + 3 + req->out.data_size);
644         return byte_len + 3;
645 }
646
647
648 /*
649   pull a UCS2 string from a request packet, returning a talloced unix string
650
651   the string length is limited by the 3 things:
652    - the data size in the request (end of packet)
653    - the passed 'byte_len' if it is not -1
654    - the end of string (null termination)
655
656   Note that 'byte_len' is the number of bytes in the packet
657
658   on failure zero is returned and *dest is set to NULL, otherwise the number
659   of bytes consumed in the packet is returned
660 */
661 static size_t cli_req_pull_ucs2(struct cli_request *req, TALLOC_CTX *mem_ctx,
662                                 char **dest, const char *src, int byte_len, unsigned flags)
663 {
664         int src_len, src_len2, alignment=0;
665         ssize_t ret;
666
667         if (!(flags & STR_NOALIGN) && ucs2_align(req->in.buffer, src, flags)) {
668                 src++;
669                 alignment=1;
670                 if (byte_len != -1) {
671                         byte_len--;
672                 }
673         }
674
675         src_len = req->in.data_size - PTR_DIFF(src, req->in.data);
676         if (src_len < 0) {
677                 *dest = NULL;
678                 return 0;
679         }
680         if (byte_len != -1 && src_len > byte_len) {
681                 src_len = byte_len;
682         }
683
684         src_len2 = strnlen_w((const smb_ucs2_t *)src, src_len/2) * 2;
685         if (src_len2 < src_len - 2) {
686                 /* include the termination if we didn't reach the end of the packet */
687                 src_len2 += 2;
688         }
689
690         /* ucs2 strings must be at least 2 bytes long */
691         if (src_len2 < 2) {
692                 *dest = NULL;
693                 return 0;
694         }
695
696         ret = convert_string_talloc(mem_ctx, CH_UCS2, CH_UNIX, src, src_len2, (const void **)dest);
697         if (ret == -1) {
698                 *dest = NULL;
699                 return 0;
700         }
701
702         return src_len2 + alignment;
703 }
704
705 /*
706   pull a ascii string from a request packet, returning a talloced string
707
708   the string length is limited by the 3 things:
709    - the data size in the request (end of packet)
710    - the passed 'byte_len' if it is not -1
711    - the end of string (null termination)
712
713   Note that 'byte_len' is the number of bytes in the packet
714
715   on failure zero is returned and *dest is set to NULL, otherwise the number
716   of bytes consumed in the packet is returned
717 */
718 size_t cli_req_pull_ascii(struct cli_request *req, TALLOC_CTX *mem_ctx,
719                           char **dest, const char *src, int byte_len, unsigned flags)
720 {
721         int src_len, src_len2;
722         ssize_t ret;
723
724         src_len = req->in.data_size - PTR_DIFF(src, req->in.data);
725         if (src_len < 0) {
726                 *dest = NULL;
727                 return 0;
728         }
729         if (byte_len != -1 && src_len > byte_len) {
730                 src_len = byte_len;
731         }
732         src_len2 = strnlen(src, src_len);
733         if (src_len2 < src_len - 1) {
734                 /* include the termination if we didn't reach the end of the packet */
735                 src_len2++;
736         }
737
738         ret = convert_string_talloc(mem_ctx, CH_DOS, CH_UNIX, src, src_len2, (const void **)dest);
739
740         if (ret == -1) {
741                 *dest = NULL;
742                 return 0;
743         }
744
745         return ret;
746 }
747
748 /*
749   pull a string from a request packet, returning a talloced string
750
751   the string length is limited by the 3 things:
752    - the data size in the request (end of packet)
753    - the passed 'byte_len' if it is not -1
754    - the end of string (null termination)
755
756   Note that 'byte_len' is the number of bytes in the packet
757
758   on failure zero is returned and *dest is set to NULL, otherwise the number
759   of bytes consumed in the packet is returned
760 */
761 size_t cli_req_pull_string(struct cli_request *req, TALLOC_CTX *mem_ctx, 
762                            char **dest, const char *src, int byte_len, unsigned flags)
763 {
764         if (!(flags & STR_ASCII) && 
765             (((flags & STR_UNICODE) || (req->flags2 & FLAGS2_UNICODE_STRINGS)))) {
766                 return cli_req_pull_ucs2(req, mem_ctx, dest, src, byte_len, flags);
767         }
768
769         return cli_req_pull_ascii(req, mem_ctx, dest, src, byte_len, flags);
770 }
771
772
773 /*
774   pull a DATA_BLOB from a reply packet, returning a talloced blob
775   make sure we don't go past end of packet
776
777   if byte_len is -1 then limit the blob only by packet size
778 */
779 DATA_BLOB cli_req_pull_blob(struct cli_request *req, TALLOC_CTX *mem_ctx, const char *src, int byte_len)
780 {
781         int src_len;
782
783         src_len = req->in.data_size - PTR_DIFF(src, req->in.data);
784
785         if (src_len < 0) {
786                 return data_blob(NULL, 0);
787         }
788
789         if (byte_len != -1 && src_len > byte_len) {
790                 src_len = byte_len;
791         }
792
793         return data_blob_talloc(mem_ctx, src, src_len);
794 }
795
796 /* check that a lump of data in a request is within the bounds of the data section of
797    the packet */
798 static BOOL cli_req_data_oob(struct cli_request *req, const char *ptr, uint32 count)
799 {
800         /* be careful with wraparound! */
801         if (ptr < req->in.data ||
802             ptr >= req->in.data + req->in.data_size ||
803             count > req->in.data_size ||
804             ptr + count > req->in.data + req->in.data_size) {
805                 return True;
806         }
807         return False;
808 }
809
810 /*
811   pull a lump of data from a request packet
812
813   return False if any part is outside the data portion of the packet
814 */
815 BOOL cli_raw_pull_data(struct cli_request *req, const char *src, int len, char *dest)
816 {
817         if (len == 0) return True;
818
819         if (cli_req_data_oob(req, src, len)) {
820                 return False;
821         }
822
823         memcpy(dest, src, len);
824         return True;
825 }
826
827
828 /*
829   put a NTTIME into a packet
830 */
831
832 void cli_push_nttime(void *base, uint16 offset, NTTIME *t)
833 {
834         SIVAL(base, offset,   t->low);
835         SIVAL(base, offset+4, t->high);
836 }
837
838 /*
839   pull a NTTIME from a packet
840 */
841 NTTIME cli_pull_nttime(void *base, uint16 offset)
842 {
843         NTTIME ret;
844         ret.low = IVAL(base, offset);
845         ret.high = IVAL(base, offset+4);
846         return ret;
847 }
848
849 /*
850   pull a UCS2 string from a blob, returning a talloced unix string
851
852   the string length is limited by the 3 things:
853    - the data size in the blob
854    - the passed 'byte_len' if it is not -1
855    - the end of string (null termination)
856
857   Note that 'byte_len' is the number of bytes in the packet
858
859   on failure zero is returned and *dest is set to NULL, otherwise the number
860   of bytes consumed in the blob is returned
861 */
862 static size_t cli_blob_pull_ucs2(TALLOC_CTX* mem_ctx,
863                                  DATA_BLOB *blob, const char **dest, 
864                                  const char *src, int byte_len, unsigned flags)
865 {
866         int src_len, src_len2, alignment=0;
867         ssize_t ret;
868
869         if (src < (const char *)blob->data ||
870             src >= (const char *)(blob->data + blob->length)) {
871                 *dest = NULL;
872                 return 0;
873         }
874
875         src_len = blob->length - PTR_DIFF(src, blob->data);
876
877         if (byte_len != -1 && src_len > byte_len) {
878                 src_len = byte_len;
879         }
880
881         if (!(flags & STR_NOALIGN) && ucs2_align(blob->data, src, flags)) {
882                 src++;
883                 alignment=1;
884                 src_len--;
885         }
886
887         if (src_len < 2) {
888                 *dest = NULL;
889                 return 0;
890         }
891
892         src_len2 = strnlen_w((const smb_ucs2_t *)src, src_len/2) * 2;
893
894         if (src_len2 < src_len - 2) {
895                 /* include the termination if we didn't reach the end of the packet */
896                 src_len2 += 2;
897         }
898
899         ret = convert_string_talloc(mem_ctx, CH_UCS2, CH_UNIX, src, src_len2, (const void **)dest);
900         if (ret == -1) {
901                 *dest = NULL;
902                 return 0;
903         }
904
905         return src_len2 + alignment;
906 }
907
908 /*
909   pull a ascii string from a blob, returning a talloced string
910
911   the string length is limited by the 3 things:
912    - the data size in the blob
913    - the passed 'byte_len' if it is not -1
914    - the end of string (null termination)
915
916   Note that 'byte_len' is the number of bytes in the blob
917
918   on failure zero is returned and *dest is set to NULL, otherwise the number
919   of bytes consumed in the blob is returned
920 */
921 static size_t cli_blob_pull_ascii(TALLOC_CTX *mem_ctx,
922                                   DATA_BLOB *blob, const char **dest, 
923                                   const char *src, int byte_len, unsigned flags)
924 {
925         int src_len, src_len2;
926         ssize_t ret;
927
928         src_len = blob->length - PTR_DIFF(src, blob->data);
929         if (src_len < 0) {
930                 *dest = NULL;
931                 return 0;
932         }
933         if (byte_len != -1 && src_len > byte_len) {
934                 src_len = byte_len;
935         }
936         src_len2 = strnlen(src, src_len);
937
938         if (src_len2 < src_len - 1) {
939                 /* include the termination if we didn't reach the end of the packet */
940                 src_len2++;
941         }
942
943         ret = convert_string_talloc(mem_ctx, CH_DOS, CH_UNIX, src, src_len2, (const void **)dest);
944
945         if (ret == -1) {
946                 *dest = NULL;
947                 return 0;
948         }
949
950         return ret;
951 }
952
953 /*
954   pull a string from a blob, returning a talloced WIRE_STRING
955
956   the string length is limited by the 3 things:
957    - the data size in the blob
958    - length field on the wire
959    - the end of string (null termination)
960
961    if STR_LEN8BIT is set in the flags then assume the length field is
962    8 bits, instead of 32
963
964   on failure zero is returned and dest->s is set to NULL, otherwise the number
965   of bytes consumed in the blob is returned
966 */
967 size_t cli_blob_pull_string(struct cli_session *session,
968                             TALLOC_CTX *mem_ctx,
969                             DATA_BLOB *blob, 
970                             WIRE_STRING *dest, 
971                             uint16 len_offset, uint16 str_offset, 
972                             unsigned flags)
973 {
974         int extra;
975         dest->s = NULL;
976         
977         if (len_offset > blob->length-4) {
978                 return 0;
979         }
980         if (flags & STR_LEN8BIT) {
981                 dest->private_length = CVAL(blob->data, len_offset);
982         } else {
983                 dest->private_length = IVAL(blob->data, len_offset);
984         }
985         extra = 0;
986         dest->s = NULL;
987         if (!(flags & STR_ASCII) && 
988             ((flags & STR_UNICODE) || 
989              (session->transport->negotiate.capabilities & CAP_UNICODE))) {
990                 int align = 0;
991                 if ((str_offset&1) && !(flags & STR_NOALIGN)) {
992                         align = 1;
993                 }
994                 if (flags & STR_LEN_NOTERM) {
995                         extra = 2;
996                 }
997                 return align + extra + cli_blob_pull_ucs2(mem_ctx, blob, &dest->s, 
998                                                           blob->data+str_offset+align, 
999                                                           dest->private_length, flags);
1000         }
1001
1002         if (flags & STR_LEN_NOTERM) {
1003                 extra = 1;
1004         }
1005
1006         return extra + cli_blob_pull_ascii(mem_ctx, blob, &dest->s, 
1007                                            blob->data+str_offset, dest->private_length, flags);
1008 }
1009
1010 /*
1011   append a string into a blob
1012 */
1013 size_t cli_blob_append_string(struct cli_session *session,
1014                               TALLOC_CTX *mem_ctx, DATA_BLOB *blob, 
1015                               const char *str, unsigned flags)
1016 {
1017         size_t max_len;
1018         int len;
1019
1020         if (!str) return 0;
1021
1022         /* determine string type to use */
1023         if (!(flags & (STR_ASCII|STR_UNICODE))) {
1024                 flags |= (session->transport->negotiate.capabilities & CAP_UNICODE) ? STR_UNICODE : STR_ASCII;
1025         }
1026
1027         max_len = (strlen(str)+2) * MAX_BYTES_PER_CHAR;         
1028
1029         blob->data = talloc_realloc(mem_ctx, blob->data, blob->length + max_len);
1030         if (!blob->data) {
1031                 return 0;
1032         }
1033
1034         len = push_string(NULL, blob->data + blob->length, str, max_len, flags);
1035
1036         blob->length += len;
1037
1038         return len;
1039 }