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