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