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