?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s4-smbtorture: use struct torture_context in RPC-LSA.
[Samba.git] / source3 / libsmb / clirap.c
blob3f95e77aeec31a0ff227f15321de17ddb9945241
1 /*
2 Unix SMB/CIFS implementation.
3 client RAP calls
4 Copyright (C) Andrew Tridgell 1994-1998
5 Copyright (C) Gerald (Jerry) Carter 2004
6 Copyright (C) James Peach 2007
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23
24 /****************************************************************************
25 Call a remote api
26 ****************************************************************************/
27
28 bool cli_api(struct cli_state *cli,
29 char *param, int prcnt, int mprcnt,
30 char *data, int drcnt, int mdrcnt,
31 char **rparam, unsigned int *rprcnt,
32 char **rdata, unsigned int *rdrcnt)
33 {
34 cli_send_trans(cli,SMBtrans,
35 PIPE_LANMAN, /* Name */
36 0,0, /* fid, flags */
37 NULL,0,0, /* Setup, length, max */
38 param, prcnt, mprcnt, /* Params, length, max */
39 data, drcnt, mdrcnt /* Data, length, max */
40 );
41
42 return (cli_receive_trans(cli,SMBtrans,
43 rparam, rprcnt,
44 rdata, rdrcnt));
45 }
46
47 /****************************************************************************
48 Perform a NetWkstaUserLogon.
49 ****************************************************************************/
50
51 bool cli_NetWkstaUserLogon(struct cli_state *cli,char *user, char *workstation)
52 {
53 char *rparam = NULL;
54 char *rdata = NULL;
55 char *p;
56 unsigned int rdrcnt,rprcnt;
57 char param[1024];
58
59 memset(param, 0, sizeof(param));
60
61 /* send a SMBtrans command with api NetWkstaUserLogon */
62 p = param;
63 SSVAL(p,0,132); /* api number */
64 p += 2;
65 strlcpy(p,"OOWb54WrLh",sizeof(param)-PTR_DIFF(p,param));
66 p = skip_string(param,sizeof(param),p);
67 strlcpy(p,"WB21BWDWWDDDDDDDzzzD",sizeof(param)-PTR_DIFF(p,param));
68 p = skip_string(param,sizeof(param),p);
69 SSVAL(p,0,1);
70 p += 2;
71 strlcpy(p,user,sizeof(param)-PTR_DIFF(p,param));
72 strupper_m(p);
73 p += 21;
74 p++;
75 p += 15;
76 p++;
77 strlcpy(p, workstation,sizeof(param)-PTR_DIFF(p,param));
78 strupper_m(p);
79 p += 16;
80 SSVAL(p, 0, CLI_BUFFER_SIZE);
81 p += 2;
82 SSVAL(p, 0, CLI_BUFFER_SIZE);
83 p += 2;
84
85 if (cli_api(cli,
86 param, PTR_DIFF(p,param),1024, /* param, length, max */
87 NULL, 0, CLI_BUFFER_SIZE, /* data, length, max */
88 &rparam, &rprcnt, /* return params, return size */
89 &rdata, &rdrcnt /* return data, return size */
90 )) {
91 cli->rap_error = rparam? SVAL(rparam,0) : -1;
92 p = rdata;
93
94 if (cli->rap_error == 0) {
95 DEBUG(4,("NetWkstaUserLogon success\n"));
96 cli->privileges = SVAL(p, 24);
97 /* The cli->eff_name field used to be set here
98 but it wasn't used anywhere else. */
99 } else {
100 DEBUG(1,("NetwkstaUserLogon gave error %d\n", cli->rap_error));
101 }
102 }
103
104 SAFE_FREE(rparam);
105 SAFE_FREE(rdata);
106 return (cli->rap_error == 0);
107 }
108
109 /****************************************************************************
110 Call a NetShareEnum - try and browse available connections on a host.
111 ****************************************************************************/
112
113 int cli_RNetShareEnum(struct cli_state *cli, void (*fn)(const char *, uint32, const char *, void *), void *state)
114 {
115 char *rparam = NULL;
116 char *rdata = NULL;
117 char *p;
118 unsigned int rdrcnt,rprcnt;
119 char param[1024];
120 int count = -1;
121
122 /* now send a SMBtrans command with api RNetShareEnum */
123 p = param;
124 SSVAL(p,0,0); /* api number */
125 p += 2;
126 strlcpy(p,"WrLeh",sizeof(param)-PTR_DIFF(p,param));
127 p = skip_string(param,sizeof(param),p);
128 strlcpy(p,"B13BWz",sizeof(param)-PTR_DIFF(p,param));
129 p = skip_string(param,sizeof(param),p);
130 SSVAL(p,0,1);
131 /*
132 * Win2k needs a *smaller* buffer than 0xFFFF here -
133 * it returns "out of server memory" with 0xFFFF !!! JRA.
134 */
135 SSVAL(p,2,0xFFE0);
136 p += 4;
137
138 if (cli_api(cli,
139 param, PTR_DIFF(p,param), 1024, /* Param, length, maxlen */
140 NULL, 0, 0xFFE0, /* data, length, maxlen - Win2k needs a small buffer here too ! */
141 &rparam, &rprcnt, /* return params, length */
142 &rdata, &rdrcnt)) /* return data, length */
143 {
144 int res = rparam? SVAL(rparam,0) : -1;
145
146 if (res == 0 || res == ERRmoredata) {
147 int converter=SVAL(rparam,2);
148 int i;
149 char *rdata_end = rdata + rdrcnt;
150
151 count=SVAL(rparam,4);
152 p = rdata;
153
154 for (i=0;i<count;i++,p+=20) {
155 char *sname;
156 int type;
157 int comment_offset;
158 const char *cmnt;
159 const char *p1;
160 char *s1, *s2;
161 size_t len;
162 TALLOC_CTX *frame = talloc_stackframe();
163
164 if (p + 20 > rdata_end) {
165 TALLOC_FREE(frame);
166 break;
167 }
168
169 sname = p;
170 type = SVAL(p,14);
171 comment_offset = (IVAL(p,16) & 0xFFFF) - converter;
172 if (comment_offset < 0 ||
173 comment_offset > (int)rdrcnt) {
174 TALLOC_FREE(frame);
175 break;
176 }
177 cmnt = comment_offset?(rdata+comment_offset):"";
178
179 /* Work out the comment length. */
180 for (p1 = cmnt, len = 0; *p1 &&
181 p1 < rdata_end; len++)
182 p1++;
183 if (!*p1) {
184 len++;
185 }
186 pull_string_talloc(frame,rdata,0,
187 &s1,sname,14,STR_ASCII);
188 pull_string_talloc(frame,rdata,0,
189 &s2,cmnt,len,STR_ASCII);
190 if (!s1 || !s2) {
191 TALLOC_FREE(frame);
192 continue;
193 }
194
195 fn(s1, type, s2, state);
196
197 TALLOC_FREE(frame);
198 }
199 } else {
200 DEBUG(4,("NetShareEnum res=%d\n", res));
201 }
202 } else {
203 DEBUG(4,("NetShareEnum failed\n"));
204 }
205
206 SAFE_FREE(rparam);
207 SAFE_FREE(rdata);
208
209 return count;
210 }
211
212 /****************************************************************************
213 Call a NetServerEnum for the specified workgroup and servertype mask. This
214 function then calls the specified callback function for each name returned.
215
216 The callback function takes 4 arguments: the machine name, the server type,
217 the comment and a state pointer.
218 ****************************************************************************/
219
220 bool cli_NetServerEnum(struct cli_state *cli, char *workgroup, uint32 stype,
221 void (*fn)(const char *, uint32, const char *, void *),
222 void *state)
223 {
224 char *rparam = NULL;
225 char *rdata = NULL;
226 char *rdata_end = NULL;
227 unsigned int rdrcnt,rprcnt;
228 char *p;
229 char param[1024];
230 int uLevel = 1;
231 size_t len;
232 uint32 func = RAP_NetServerEnum2;
233 char *last_entry = NULL;
234 int total_cnt = 0;
235 int return_cnt = 0;
236 int res;
237
238 errno = 0; /* reset */
239
240 /*
241 * This may take more than one transaction, so we should loop until
242 * we no longer get a more data to process or we have all of the
243 * items.
244 */
245 do {
246 /* send a SMBtrans command with api NetServerEnum */
247 p = param;
248 SIVAL(p,0,func); /* api number */
249 p += 2;
250 /* Next time through we need to use the continue api */
251 func = RAP_NetServerEnum3;
252
253 if (last_entry) {
254 strlcpy(p,"WrLehDOz", sizeof(param)-PTR_DIFF(p,param));
255 } else {
256 strlcpy(p,"WrLehDz", sizeof(param)-PTR_DIFF(p,param));
257 }
258
259 p = skip_string(param, sizeof(param), p);
260 strlcpy(p,"B16BBDz", sizeof(param)-PTR_DIFF(p,param));
261
262 p = skip_string(param, sizeof(param), p);
263 SSVAL(p,0,uLevel);
264 SSVAL(p,2,CLI_BUFFER_SIZE);
265 p += 4;
266 SIVAL(p,0,stype);
267 p += 4;
268
269 /* If we have more data, tell the server where
270 * to continue from.
271 */
272 len = push_ascii(p,
273 last_entry ? last_entry : workgroup,
274 sizeof(param) - PTR_DIFF(p,param) - 1,
275 STR_TERMINATE|STR_UPPER);
276
277 if (len == (size_t)-1) {
278 SAFE_FREE(last_entry);
279 return false;
280 }
281 p += len;
282
283 if (!cli_api(cli,
284 param, PTR_DIFF(p,param), 8, /* params, length, max */
285 NULL, 0, CLI_BUFFER_SIZE, /* data, length, max */
286 &rparam, &rprcnt, /* return params, return size */
287 &rdata, &rdrcnt)) { /* return data, return size */
288
289 /* break out of the loop on error */
290 res = -1;
291 break;
292 }
293
294 rdata_end = rdata + rdrcnt;
295 res = rparam ? SVAL(rparam,0) : -1;
296
297 if (res == 0 || res == ERRmoredata ||
298 (res != -1 && cli_errno(cli) == 0)) {
299 char *sname = NULL;
300 int i, count;
301 int converter=SVAL(rparam,2);
302
303 /* Get the number of items returned in this buffer */
304 count = SVAL(rparam, 4);
305
306 /* The next field contains the number of items left,
307 * including those returned in this buffer. So the
308 * first time through this should contain all of the
309 * entries.
310 */
311 if (total_cnt == 0) {
312 total_cnt = SVAL(rparam, 6);
313 }
314
315 /* Keep track of how many we have read */
316 return_cnt += count;
317 p = rdata;
318
319 /* The last name in the previous NetServerEnum reply is
320 * sent back to server in the NetServerEnum3 request
321 * (last_entry). The next reply should repeat this entry
322 * as the first element. We have no proof that this is
323 * always true, but from traces that seems to be the
324 * behavior from Window Servers. So first lets do a lot
325 * of checking, just being paranoid. If the string
326 * matches then we already saw this entry so skip it.
327 *
328 * NOTE: sv1_name field must be null terminated and has
329 * a max size of 16 (NetBIOS Name).
330 */
331 if (last_entry && count && p &&
332 (strncmp(last_entry, p, 16) == 0)) {
333 count -= 1; /* Skip this entry */
334 return_cnt = -1; /* Not part of total, so don't count. */
335 p = rdata + 26; /* Skip the whole record */
336 }
337
338 for (i = 0; i < count; i++, p += 26) {
339 int comment_offset;
340 const char *cmnt;
341 const char *p1;
342 char *s1, *s2;
343 TALLOC_CTX *frame = talloc_stackframe();
344
345 if (p + 26 > rdata_end) {
346 TALLOC_FREE(frame);
347 break;
348 }
349
350 sname = p;
351 comment_offset = (IVAL(p,22) & 0xFFFF)-converter;
352 cmnt = comment_offset?(rdata+comment_offset):"";
353
354 if (comment_offset < 0 || comment_offset > (int)rdrcnt) {
355 TALLOC_FREE(frame);
356 continue;
357 }
358
359 /* Work out the comment length. */
360 for (p1 = cmnt, len = 0; *p1 &&
361 p1 < rdata_end; len++)
362 p1++;
363 if (!*p1) {
364 len++;
365 }
366
367 stype = IVAL(p,18) & ~SV_TYPE_LOCAL_LIST_ONLY;
368
369 pull_string_talloc(frame,rdata,0,
370 &s1,sname,16,STR_ASCII);
371 pull_string_talloc(frame,rdata,0,
372 &s2,cmnt,len,STR_ASCII);
373
374 if (!s1 || !s2) {
375 TALLOC_FREE(frame);
376 continue;
377 }
378
379 fn(s1, stype, s2, state);
380 TALLOC_FREE(frame);
381 }
382
383 /* We are done with the old last entry, so now we can free it */
384 if (last_entry) {
385 SAFE_FREE(last_entry); /* This will set it to null */
386 }
387
388 /* We always make a copy of the last entry if we have one */
389 if (sname) {
390 last_entry = smb_xstrdup(sname);
391 }
392
393 /* If we have more data, but no last entry then error out */
394 if (!last_entry && (res == ERRmoredata)) {
395 errno = EINVAL;
396 res = 0;
397 }
398
399 }
400
401 SAFE_FREE(rparam);
402 SAFE_FREE(rdata);
403 } while ((res == ERRmoredata) && (total_cnt > return_cnt));
404
405 SAFE_FREE(rparam);
406 SAFE_FREE(rdata);
407 SAFE_FREE(last_entry);
408
409 if (res == -1) {
410 errno = cli_errno(cli);
411 } else {
412 if (!return_cnt) {
413 /* this is a very special case, when the domain master for the
414 work group isn't part of the work group itself, there is something
415 wild going on */
416 errno = ENOENT;
417 }
418 }
419
420 return(return_cnt > 0);
421 }
422
423 /****************************************************************************
424 Send a SamOEMChangePassword command.
425 ****************************************************************************/
426
427 bool cli_oem_change_password(struct cli_state *cli, const char *user, const char *new_password,
428 const char *old_password)
429 {
430 char param[1024];
431 unsigned char data[532];
432 char *p = param;
433 unsigned char old_pw_hash[16];
434 unsigned char new_pw_hash[16];
435 unsigned int data_len;
436 unsigned int param_len = 0;
437 char *rparam = NULL;
438 char *rdata = NULL;
439 unsigned int rprcnt, rdrcnt;
440
441 if (strlen(user) >= sizeof(fstring)-1) {
442 DEBUG(0,("cli_oem_change_password: user name %s is too long.\n", user));
443 return False;
444 }
445
446 SSVAL(p,0,214); /* SamOEMChangePassword command. */
447 p += 2;
448 strlcpy(p, "zsT", sizeof(param)-PTR_DIFF(p,param));
449 p = skip_string(param,sizeof(param),p);
450 strlcpy(p, "B516B16", sizeof(param)-PTR_DIFF(p,param));
451 p = skip_string(param,sizeof(param),p);
452 strlcpy(p,user, sizeof(param)-PTR_DIFF(p,param));
453 p = skip_string(param,sizeof(param),p);
454 SSVAL(p,0,532);
455 p += 2;
456
457 param_len = PTR_DIFF(p,param);
458
459 /*
460 * Get the Lanman hash of the old password, we
461 * use this as the key to make_oem_passwd_hash().
462 */
463 E_deshash(old_password, old_pw_hash);
464
465 encode_pw_buffer(data, new_password, STR_ASCII);
466
467 #ifdef DEBUG_PASSWORD
468 DEBUG(100,("make_oem_passwd_hash\n"));
469 dump_data(100, data, 516);
470 #endif
471 SamOEMhash( (unsigned char *)data, (unsigned char *)old_pw_hash, 516);
472
473 /*
474 * Now place the old password hash in the data.
475 */
476 E_deshash(new_password, new_pw_hash);
477
478 E_old_pw_hash( new_pw_hash, old_pw_hash, (uchar *)&data[516]);
479
480 data_len = 532;
481
482 if (cli_send_trans(cli,SMBtrans,
483 PIPE_LANMAN, /* name */
484 0,0, /* fid, flags */
485 NULL,0,0, /* setup, length, max */
486 param,param_len,2, /* param, length, max */
487 (char *)data,data_len,0 /* data, length, max */
488 ) == False) {
489 DEBUG(0,("cli_oem_change_password: Failed to send password change for user %s\n",
490 user ));
491 return False;
492 }
493
494 if (!cli_receive_trans(cli,SMBtrans,
495 &rparam, &rprcnt,
496 &rdata, &rdrcnt)) {
497 DEBUG(0,("cli_oem_change_password: Failed to recieve reply to password change for user %s\n",
498 user ));
499 return False;
500 }
501
502 if (rparam) {
503 cli->rap_error = SVAL(rparam,0);
504 }
505
506 SAFE_FREE(rparam);
507 SAFE_FREE(rdata);
508
509 return (cli->rap_error == 0);
510 }
511
512 /****************************************************************************
513 Send a qpathinfo call.
514 ****************************************************************************/
515
516 bool cli_qpathinfo(struct cli_state *cli,
517 const char *fname,
518 time_t *change_time,
519 time_t *access_time,
520 time_t *write_time,
521 SMB_OFF_T *size,
522 uint16 *mode)
523 {
524 unsigned int data_len = 0;
525 unsigned int param_len = 0;
526 unsigned int rparam_len, rdata_len;
527 uint16 setup = TRANSACT2_QPATHINFO;
528 char *param;
529 char *rparam=NULL, *rdata=NULL;
530 int count=8;
531 bool ret;
532 time_t (*date_fn)(struct cli_state *, const void *);
533 char *p;
534 size_t nlen = 2*(strlen(fname)+1);
535
536 param = SMB_MALLOC_ARRAY(char, 6+nlen+2);
537 if (!param) {
538 return false;
539 }
540 p = param;
541 memset(p, '\0', 6);
542 SSVAL(p, 0, SMB_INFO_STANDARD);
543 p += 6;
544 p += clistr_push(cli, p, fname, nlen, STR_TERMINATE);
545 param_len = PTR_DIFF(p, param);
546
547 do {
548 ret = (cli_send_trans(cli, SMBtrans2,
549 NULL, /* Name */
550 -1, 0, /* fid, flags */
551 &setup, 1, 0, /* setup, length, max */
552 param, param_len, 10, /* param, length, max */
553 NULL, data_len, cli->max_xmit /* data, length, max */
554 ) &&
555 cli_receive_trans(cli, SMBtrans2,
556 &rparam, &rparam_len,
557 &rdata, &rdata_len));
558 if (!cli_is_dos_error(cli)) break;
559 if (!ret) {
560 /* we need to work around a Win95 bug - sometimes
561 it gives ERRSRV/ERRerror temprarily */
562 uint8 eclass;
563 uint32 ecode;
564 cli_dos_error(cli, &eclass, &ecode);
565 if (eclass != ERRSRV || ecode != ERRerror) break;
566 smb_msleep(100);
567 }
568 } while (count-- && ret==False);
569
570 SAFE_FREE(param);
571 if (!ret || !rdata || rdata_len < 22) {
572 return False;
573 }
574
575 if (cli->win95) {
576 date_fn = cli_make_unix_date;
577 } else {
578 date_fn = cli_make_unix_date2;
579 }
580
581 if (change_time) {
582 *change_time = date_fn(cli, rdata+0);
583 }
584 if (access_time) {
585 *access_time = date_fn(cli, rdata+4);
586 }
587 if (write_time) {
588 *write_time = date_fn(cli, rdata+8);
589 }
590 if (size) {
591 *size = IVAL(rdata, 12);
592 }
593 if (mode) {
594 *mode = SVAL(rdata,l1_attrFile);
595 }
596
597 SAFE_FREE(rdata);
598 SAFE_FREE(rparam);
599 return True;
600 }
601
602 /****************************************************************************
603 Send a setpathinfo call.
604 ****************************************************************************/
605
606 bool cli_setpathinfo(struct cli_state *cli, const char *fname,
607 time_t create_time,
608 time_t access_time,
609 time_t write_time,
610 time_t change_time,
611 uint16 mode)
612 {
613 unsigned int data_len = 0;
614 unsigned int param_len = 0;
615 unsigned int rparam_len, rdata_len;
616 uint16 setup = TRANSACT2_SETPATHINFO;
617 char *param;
618 char data[40];
619 char *rparam=NULL, *rdata=NULL;
620 int count=8;
621 bool ret;
622 char *p;
623 size_t nlen = 2*(strlen(fname)+1);
624
625 param = SMB_MALLOC_ARRAY(char, 6+nlen+2);
626 if (!param) {
627 return false;
628 }
629 memset(param, '\0', 6);
630 memset(data, 0, sizeof(data));
631
632 p = param;
633
634 /* Add the information level */
635 SSVAL(p, 0, SMB_FILE_BASIC_INFORMATION);
636
637 /* Skip reserved */
638 p += 6;
639
640 /* Add the file name */
641 p += clistr_push(cli, p, fname, nlen, STR_TERMINATE);
642
643 param_len = PTR_DIFF(p, param);
644
645 p = data;
646
647 /*
648 * Add the create, last access, modification, and status change times
649 */
650 put_long_date(p, create_time);
651 p += 8;
652
653 put_long_date(p, access_time);
654 p += 8;
655
656 put_long_date(p, write_time);
657 p += 8;
658
659 put_long_date(p, change_time);
660 p += 8;
661
662 /* Add attributes */
663 SIVAL(p, 0, mode);
664 p += 4;
665
666 /* Add padding */
667 SIVAL(p, 0, 0);
668 p += 4;
669
670 data_len = PTR_DIFF(p, data);
671
672 do {
673 ret = (cli_send_trans(cli, SMBtrans2,
674 NULL, /* Name */
675 -1, 0, /* fid, flags */
676 &setup, 1, 0, /* setup, length, max */
677 param, param_len, 10, /* param, length, max */
678 data, data_len, cli->max_xmit /* data, length, max */
679 ) &&
680 cli_receive_trans(cli, SMBtrans2,
681 &rparam, &rparam_len,
682 &rdata, &rdata_len));
683 if (!cli_is_dos_error(cli)) break;
684 if (!ret) {
685 /* we need to work around a Win95 bug - sometimes
686 it gives ERRSRV/ERRerror temprarily */
687 uint8 eclass;
688 uint32 ecode;
689 cli_dos_error(cli, &eclass, &ecode);
690 if (eclass != ERRSRV || ecode != ERRerror) break;
691 smb_msleep(100);
692 }
693 } while (count-- && ret==False);
694
695 SAFE_FREE(param);
696 if (!ret) {
697 return False;
698 }
699
700 SAFE_FREE(rdata);
701 SAFE_FREE(rparam);
702 return True;
703 }
704
705 /****************************************************************************
706 Send a qpathinfo call with the SMB_QUERY_FILE_ALL_INFO info level.
707 ****************************************************************************/
708
709 bool cli_qpathinfo2(struct cli_state *cli, const char *fname,
710 struct timespec *create_time,
711 struct timespec *access_time,
712 struct timespec *write_time,
713 struct timespec *change_time,
714 SMB_OFF_T *size, uint16 *mode,
715 SMB_INO_T *ino)
716 {
717 unsigned int data_len = 0;
718 unsigned int param_len = 0;
719 uint16 setup = TRANSACT2_QPATHINFO;
720 char *param;
721 char *rparam=NULL, *rdata=NULL;
722 char *p;
723 size_t nlen = 2*(strlen(fname)+1);
724
725 param = SMB_MALLOC_ARRAY(char, 6+nlen+2);
726 if (!param) {
727 return false;
728 }
729 p = param;
730 memset(param, '\0', 6);
731 SSVAL(p, 0, SMB_QUERY_FILE_ALL_INFO);
732 p += 6;
733 p += clistr_push(cli, p, fname, nlen, STR_TERMINATE);
734
735 param_len = PTR_DIFF(p, param);
736
737 if (!cli_send_trans(cli, SMBtrans2,
738 NULL, /* name */
739 -1, 0, /* fid, flags */
740 &setup, 1, 0, /* setup, length, max */
741 param, param_len, 10, /* param, length, max */
742 NULL, data_len, cli->max_xmit /* data, length, max */
743 )) {
744 SAFE_FREE(param);
745 return False;
746 }
747
748 SAFE_FREE(param);
749 if (!cli_receive_trans(cli, SMBtrans2,
750 &rparam, &param_len,
751 &rdata, &data_len)) {
752 return False;
753 }
754
755 if (!rdata || data_len < 22) {
756 return False;
757 }
758
759 if (create_time) {
760 *create_time = interpret_long_date(rdata+0);
761 }
762 if (access_time) {
763 *access_time = interpret_long_date(rdata+8);
764 }
765 if (write_time) {
766 *write_time = interpret_long_date(rdata+16);
767 }
768 if (change_time) {
769 *change_time = interpret_long_date(rdata+24);
770 }
771 if (mode) {
772 *mode = SVAL(rdata, 32);
773 }
774 if (size) {
775 *size = IVAL2_TO_SMB_BIG_UINT(rdata,48);
776 }
777 if (ino) {
778 *ino = IVAL(rdata, 64);
779 }
780
781 SAFE_FREE(rdata);
782 SAFE_FREE(rparam);
783 return True;
784 }
785
786 /****************************************************************************
787 Get the stream info
788 ****************************************************************************/
789
790 bool cli_qpathinfo_streams(struct cli_state *cli, const char *fname,
791 TALLOC_CTX *mem_ctx,
792 unsigned int *pnum_streams,
793 struct stream_struct **pstreams)
794 {
795 unsigned int data_len = 0;
796 unsigned int param_len = 0;
797 uint16 setup = TRANSACT2_QPATHINFO;
798 char *param;
799 char *rparam=NULL, *rdata=NULL;
800 char *p;
801 unsigned int num_streams;
802 struct stream_struct *streams;
803 unsigned int ofs;
804 size_t namelen = 2*(strlen(fname)+1);
805
806 param = SMB_MALLOC_ARRAY(char, 6+namelen+2);
807 if (param == NULL) {
808 return false;
809 }
810 p = param;
811 memset(p, 0, 6);
812 SSVAL(p, 0, SMB_FILE_STREAM_INFORMATION);
813 p += 6;
814 p += clistr_push(cli, p, fname, namelen, STR_TERMINATE);
815
816 param_len = PTR_DIFF(p, param);
817
818 if (!cli_send_trans(cli, SMBtrans2,
819 NULL, /* name */
820 -1, 0, /* fid, flags */
821 &setup, 1, 0, /* setup, len, max */
822 param, param_len, 10, /* param, len, max */
823 NULL, data_len, cli->max_xmit /* data, len, max */
824 )) {
825 return false;
826 }
827
828 if (!cli_receive_trans(cli, SMBtrans2,
829 &rparam, &param_len,
830 &rdata, &data_len)) {
831 return false;
832 }
833
834 if (!rdata) {
835 SAFE_FREE(rparam);
836 return false;
837 }
838
839 num_streams = 0;
840 streams = NULL;
841 ofs = 0;
842
843 while ((data_len > ofs) && (data_len - ofs >= 24)) {
844 uint32_t nlen, len;
845 size_t size;
846 void *vstr;
847 struct stream_struct *tmp;
848 uint8_t *tmp_buf;
849
850 tmp = TALLOC_REALLOC_ARRAY(mem_ctx, streams,
851 struct stream_struct,
852 num_streams+1);
853
854 if (tmp == NULL) {
855 goto fail;
856 }
857 streams = tmp;
858
859 nlen = IVAL(rdata, ofs + 0x04);
860
861 streams[num_streams].size = IVAL_TO_SMB_OFF_T(
862 rdata, ofs + 0x08);
863 streams[num_streams].alloc_size = IVAL_TO_SMB_OFF_T(
864 rdata, ofs + 0x10);
865
866 if (nlen > data_len - (ofs + 24)) {
867 goto fail;
868 }
869
870 /*
871 * We need to null-terminate src, how do I do this with
872 * convert_string_talloc??
873 */
874
875 tmp_buf = TALLOC_ARRAY(streams, uint8_t, nlen+2);
876 if (tmp_buf == NULL) {
877 goto fail;
878 }
879
880 memcpy(tmp_buf, rdata+ofs+24, nlen);
881 tmp_buf[nlen] = 0;
882 tmp_buf[nlen+1] = 0;
883
884 if (!convert_string_talloc(streams, CH_UTF16, CH_UNIX, tmp_buf,
885 nlen+2, &vstr, &size, false))
886 {
887 TALLOC_FREE(tmp_buf);
888 goto fail;
889 }
890
891 TALLOC_FREE(tmp_buf);
892 streams[num_streams].name = (char *)vstr;
893 num_streams++;
894
895 len = IVAL(rdata, ofs);
896 if (len > data_len - ofs) {
897 goto fail;
898 }
899 if (len == 0) break;
900 ofs += len;
901 }
902
903 SAFE_FREE(rdata);
904 SAFE_FREE(rparam);
905
906 *pnum_streams = num_streams;
907 *pstreams = streams;
908 return true;
909
910 fail:
911 TALLOC_FREE(streams);
912 SAFE_FREE(rdata);
913 SAFE_FREE(rparam);
914 return false;
915 }
916
917 /****************************************************************************
918 Send a qfileinfo QUERY_FILE_NAME_INFO call.
919 ****************************************************************************/
920
921 bool cli_qfilename(struct cli_state *cli, int fnum, char *name, size_t namelen)
922 {
923 unsigned int data_len = 0;
924 unsigned int param_len = 0;
925 uint16 setup = TRANSACT2_QFILEINFO;
926 char param[4];
927 char *rparam=NULL, *rdata=NULL;
928
929 param_len = 4;
930 SSVAL(param, 0, fnum);
931 SSVAL(param, 2, SMB_QUERY_FILE_NAME_INFO);
932
933 if (!cli_send_trans(cli, SMBtrans2,
934 NULL, /* name */
935 -1, 0, /* fid, flags */
936 &setup, 1, 0, /* setup, length, max */
937 param, param_len, 2, /* param, length, max */
938 NULL, data_len, cli->max_xmit /* data, length, max */
939 )) {
940 return False;
941 }
942
943 if (!cli_receive_trans(cli, SMBtrans2,
944 &rparam, &param_len,
945 &rdata, &data_len)) {
946 return False;
947 }
948
949 if (!rdata || data_len < 4) {
950 SAFE_FREE(rparam);
951 SAFE_FREE(rdata);
952 return False;
953 }
954
955 clistr_pull(cli->inbuf, name, rdata+4, namelen, IVAL(rdata, 0),
956 STR_UNICODE);
957
958 SAFE_FREE(rparam);
959 SAFE_FREE(rdata);
960
961 return True;
962 }
963
964 /****************************************************************************
965 Send a qfileinfo call.
966 ****************************************************************************/
967
968 bool cli_qfileinfo(struct cli_state *cli, int fnum,
969 uint16 *mode, SMB_OFF_T *size,
970 struct timespec *create_time,
971 struct timespec *access_time,
972 struct timespec *write_time,
973 struct timespec *change_time,
974 SMB_INO_T *ino)
975 {
976 unsigned int data_len = 0;
977 unsigned int param_len = 0;
978 uint16 setup;
979 uint8_t param[4];
980 uint8_t *rparam=NULL, *rdata=NULL;
981 NTSTATUS status;
982
983 /* if its a win95 server then fail this - win95 totally screws it
984 up */
985 if (cli->win95) return False;
986
987 param_len = 4;
988
989 SSVAL(param, 0, fnum);
990 SSVAL(param, 2, SMB_QUERY_FILE_ALL_INFO);
991
992 SSVAL(&setup, 0, TRANSACT2_QFILEINFO);
993
994 status = cli_trans(talloc_tos(), cli, SMBtrans2,
995 NULL, -1, 0, 0, /* name, fid, function, flags */
996 &setup, 1, 0, /* setup, length, max */
997 param, param_len, 2, /* param, length, max */
998 NULL, 0, MIN(cli->max_xmit, 0xffff), /* data, length, max */
999 NULL, NULL, /* rsetup, length */
1000 &rparam, &param_len, /* rparam, length */
1001 &rdata, &data_len);
1002
1003 if (!NT_STATUS_IS_OK(status)) {
1004 return false;
1005 }
1006
1007 if (!rdata || data_len < 68) {
1008 return False;
1009 }
1010
1011 if (create_time) {
1012 *create_time = interpret_long_date((char *)rdata+0);
1013 }
1014 if (access_time) {
1015 *access_time = interpret_long_date((char *)rdata+8);
1016 }
1017 if (write_time) {
1018 *write_time = interpret_long_date((char *)rdata+16);
1019 }
1020 if (change_time) {
1021 *change_time = interpret_long_date((char *)rdata+24);
1022 }
1023 if (mode) {
1024 *mode = SVAL(rdata, 32);
1025 }
1026 if (size) {
1027 *size = IVAL2_TO_SMB_BIG_UINT(rdata,48);
1028 }
1029 if (ino) {
1030 *ino = IVAL(rdata, 64);
1031 }
1032
1033 TALLOC_FREE(rdata);
1034 TALLOC_FREE(rparam);
1035 return True;
1036 }
1037
1038 /****************************************************************************
1039 Send a qpathinfo BASIC_INFO call.
1040 ****************************************************************************/
1041
1042 bool cli_qpathinfo_basic( struct cli_state *cli, const char *name,
1043 SMB_STRUCT_STAT *sbuf, uint32 *attributes )
1044 {
1045 unsigned int param_len = 0;
1046 unsigned int data_len = 0;
1047 uint16 setup = TRANSACT2_QPATHINFO;
1048 char *param;
1049 char *rparam=NULL, *rdata=NULL;
1050 char *p;
1051 char *path;
1052 int len;
1053 size_t nlen;
1054 TALLOC_CTX *frame = talloc_stackframe();
1055
1056 path = talloc_strdup(frame, name);
1057 if (!path) {
1058 TALLOC_FREE(frame);
1059 return false;
1060 }
1061 /* cleanup */
1062
1063 len = strlen(path);
1064 if ( path[len-1] == '\\' || path[len-1] == '/') {
1065 path[len-1] = '\0';
1066 }
1067 nlen = 2*(strlen(path)+1);
1068
1069 param = TALLOC_ARRAY(frame,char,6+nlen+2);
1070 if (!param) {
1071 return false;
1072 }
1073 p = param;
1074 memset(param, '\0', 6);
1075
1076 SSVAL(p, 0, SMB_QUERY_FILE_BASIC_INFO);
1077 p += 6;
1078 p += clistr_push(cli, p, path, nlen, STR_TERMINATE);
1079 param_len = PTR_DIFF(p, param);
1080
1081
1082 if (!cli_send_trans(cli, SMBtrans2,
1083 NULL, /* name */
1084 -1, 0, /* fid, flags */
1085 &setup, 1, 0, /* setup, length, max */
1086 param, param_len, 2, /* param, length, max */
1087 NULL, 0, cli->max_xmit /* data, length, max */
1088 )) {
1089 TALLOC_FREE(frame);
1090 return False;
1091 }
1092
1093 TALLOC_FREE(frame);
1094
1095 if (!cli_receive_trans(cli, SMBtrans2,
1096 &rparam, &param_len,
1097 &rdata, &data_len)) {
1098 return False;
1099 }
1100
1101 if (data_len < 36) {
1102 SAFE_FREE(rdata);
1103 SAFE_FREE(rparam);
1104 return False;
1105 }
1106
1107 set_atimespec(sbuf, interpret_long_date( rdata+8 )); /* Access time. */
1108 set_mtimespec(sbuf, interpret_long_date( rdata+16 )); /* Write time. */
1109 set_ctimespec(sbuf, interpret_long_date( rdata+24 )); /* Change time. */
1110
1111 *attributes = IVAL( rdata, 32 );
1112
1113 SAFE_FREE(rparam);
1114 SAFE_FREE(rdata);
1115
1116 return True;
1117 }
1118
1119 /****************************************************************************
1120 Send a qfileinfo call.
1121 ****************************************************************************/
1122
1123 bool cli_qfileinfo_test(struct cli_state *cli, int fnum, int level, char **poutdata, uint32 *poutlen)
1124 {
1125 unsigned int data_len = 0;
1126 unsigned int param_len = 0;
1127 uint16 setup = TRANSACT2_QFILEINFO;
1128 char param[4];
1129 char *rparam=NULL, *rdata=NULL;
1130
1131 *poutdata = NULL;
1132 *poutlen = 0;
1133
1134 /* if its a win95 server then fail this - win95 totally screws it
1135 up */
1136 if (cli->win95)
1137 return False;
1138
1139 param_len = 4;
1140
1141 SSVAL(param, 0, fnum);
1142 SSVAL(param, 2, level);
1143
1144 if (!cli_send_trans(cli, SMBtrans2,
1145 NULL, /* name */
1146 -1, 0, /* fid, flags */
1147 &setup, 1, 0, /* setup, length, max */
1148 param, param_len, 2, /* param, length, max */
1149 NULL, data_len, cli->max_xmit /* data, length, max */
1150 )) {
1151 return False;
1152 }
1153
1154 if (!cli_receive_trans(cli, SMBtrans2,
1155 &rparam, &param_len,
1156 &rdata, &data_len)) {
1157 return False;
1158 }
1159
1160 *poutdata = (char *)memdup(rdata, data_len);
1161 if (!*poutdata) {
1162 SAFE_FREE(rdata);
1163 SAFE_FREE(rparam);
1164 return False;
1165 }
1166
1167 *poutlen = data_len;
1168
1169 SAFE_FREE(rdata);
1170 SAFE_FREE(rparam);
1171 return True;
1172 }
1173
1174 /****************************************************************************
1175 Send a qpathinfo SMB_QUERY_FILE_ALT_NAME_INFO call.
1176 ****************************************************************************/
1177
1178 NTSTATUS cli_qpathinfo_alt_name(struct cli_state *cli, const char *fname, fstring alt_name)
1179 {
1180 unsigned int data_len = 0;
1181 unsigned int param_len = 0;
1182 uint16 setup = TRANSACT2_QPATHINFO;
1183 char *param;
1184 char *rparam=NULL, *rdata=NULL;
1185 int count=8;
1186 char *p;
1187 bool ret;
1188 unsigned int len;
1189 size_t nlen = 2*(strlen(fname)+1);
1190
1191 param = SMB_MALLOC_ARRAY(char, 6+nlen+2);
1192 if (!param) {
1193 return NT_STATUS_NO_MEMORY;
1194 }
1195 p = param;
1196 memset(param, '\0', 6);
1197 SSVAL(p, 0, SMB_QUERY_FILE_ALT_NAME_INFO);
1198 p += 6;
1199 p += clistr_push(cli, p, fname, nlen, STR_TERMINATE);
1200 param_len = PTR_DIFF(p, param);
1201
1202 do {
1203 ret = (cli_send_trans(cli, SMBtrans2,
1204 NULL, /* Name */
1205 -1, 0, /* fid, flags */
1206 &setup, 1, 0, /* setup, length, max */
1207 param, param_len, 10, /* param, length, max */
1208 NULL, data_len, cli->max_xmit /* data, length, max */
1209 ) &&
1210 cli_receive_trans(cli, SMBtrans2,
1211 &rparam, &param_len,
1212 &rdata, &data_len));
1213 if (!ret && cli_is_dos_error(cli)) {
1214 /* we need to work around a Win95 bug - sometimes
1215 it gives ERRSRV/ERRerror temprarily */
1216 uint8 eclass;
1217 uint32 ecode;
1218 cli_dos_error(cli, &eclass, &ecode);
1219 if (eclass != ERRSRV || ecode != ERRerror) break;
1220 smb_msleep(100);
1221 }
1222 } while (count-- && ret==False);
1223
1224 SAFE_FREE(param);
1225
1226 if (!ret || !rdata || data_len < 4) {
1227 return NT_STATUS_UNSUCCESSFUL;
1228 }
1229
1230 len = IVAL(rdata, 0);
1231
1232 if (len > data_len - 4) {
1233 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1234 }
1235
1236 clistr_pull(cli->inbuf, alt_name, rdata+4, sizeof(fstring), len,
1237 STR_UNICODE);
1238
1239 SAFE_FREE(rdata);
1240 SAFE_FREE(rparam);
1241
1242 return NT_STATUS_OK;
1243 }
Samba GIT mirror