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