?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
smbd: Remove message_to_share_mode_entry and vice versa
[Samba.git] / source3 / libsmb / clirap.c
blob21ee346e0aa294fc405604df72947ad494005595
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/util/tevent_ntstatus.h"
26 #include "async_smb.h"
27 #include "libsmb/libsmb.h"
28 #include "libsmb/clirap.h"
29 #include "trans2.h"
30 #include "../libcli/smb/smbXcli_base.h"
31 #include "libcli/smb/reparse.h"
32 #include "cli_smb2_fnum.h"
33 #include "lib/util/string_wrappers.h"
34
35 #include <gnutls/gnutls.h>
36 #include <gnutls/crypto.h>
37
38 #define PIPE_LANMAN "\\PIPE\\LANMAN"
39
40 /****************************************************************************
41 Call a remote api
42 ****************************************************************************/
43
44 bool cli_api(struct cli_state *cli,
45 char *param, int prcnt, int mprcnt,
46 char *data, int drcnt, int mdrcnt,
47 char **rparam, unsigned int *rprcnt,
48 char **rdata, unsigned int *rdrcnt)
49 {
50 NTSTATUS status;
51
52 uint8_t *my_rparam, *my_rdata;
53 uint32_t num_my_rparam, num_my_rdata;
54
55 status = cli_trans(talloc_tos(), cli, SMBtrans,
56 PIPE_LANMAN, 0, /* name, fid */
57 0, 0, /* function, flags */
58 NULL, 0, 0, /* setup */
59 (uint8_t *)param, prcnt, mprcnt, /* Params, length, max */
60 (uint8_t *)data, drcnt, mdrcnt, /* Data, length, max */
61 NULL, /* recv_flags2 */
62 NULL, 0, NULL, /* rsetup */
63 &my_rparam, 0, &num_my_rparam,
64 &my_rdata, 0, &num_my_rdata);
65 if (!NT_STATUS_IS_OK(status)) {
66 return false;
67 }
68
69 /*
70 * I know this memcpy massively hurts, but there are just tons
71 * of callers of cli_api that eventually need changing to
72 * talloc
73 */
74
75 *rparam = (char *)smb_memdup(my_rparam, num_my_rparam);
76 if (*rparam == NULL) {
77 goto fail;
78 }
79 *rprcnt = num_my_rparam;
80 TALLOC_FREE(my_rparam);
81
82 *rdata = (char *)smb_memdup(my_rdata, num_my_rdata);
83 if (*rdata == NULL) {
84 goto fail;
85 }
86 *rdrcnt = num_my_rdata;
87 TALLOC_FREE(my_rdata);
88
89 return true;
90 fail:
91 TALLOC_FREE(my_rdata);
92 TALLOC_FREE(my_rparam);
93 *rparam = NULL;
94 *rprcnt = 0;
95 *rdata = NULL;
96 *rdrcnt = 0;
97 return false;
98 }
99
100 /****************************************************************************
101 Call a NetShareEnum - try and browse available connections on a host.
102 ****************************************************************************/
103
104 int cli_RNetShareEnum(struct cli_state *cli, void (*fn)(const char *, uint32_t, const char *, void *), void *state)
105 {
106 char *rparam = NULL;
107 char *rdata = NULL;
108 char *p;
109 unsigned int rdrcnt,rprcnt;
110 char param[1024];
111 int count = -1;
112 bool ok;
113 int res;
114
115 /* now send a SMBtrans command with api RNetShareEnum */
116 p = param;
117 SSVAL(p,0,0); /* api number */
118 p += 2;
119 strlcpy(p,"WrLeh",sizeof(param)-PTR_DIFF(p,param));
120 p = skip_string(param,sizeof(param),p);
121 strlcpy(p,"B13BWz",sizeof(param)-PTR_DIFF(p,param));
122 p = skip_string(param,sizeof(param),p);
123 SSVAL(p,0,1);
124 /*
125 * Win2k needs a *smaller* buffer than 0xFFFF here -
126 * it returns "out of server memory" with 0xFFFF !!! JRA.
127 */
128 SSVAL(p,2,0xFFE0);
129 p += 4;
130
131 ok = cli_api(
132 cli,
133 param, PTR_DIFF(p,param), 1024, /* Param, length, maxlen */
134 NULL, 0, 0xFFE0, /* data, length, maxlen - Win2k needs a small buffer here too ! */
135 &rparam, &rprcnt, /* return params, length */
136 &rdata, &rdrcnt); /* return data, length */
137 if (!ok) {
138 DEBUG(4,("NetShareEnum failed\n"));
139 goto done;
140 }
141
142 if (rprcnt < 6) {
143 DBG_ERR("Got invalid result: rprcnt=%u\n", rprcnt);
144 goto done;
145 }
146
147 res = rparam? SVAL(rparam,0) : -1;
148
149 if (res == 0 || res == ERRmoredata) {
150 int converter=SVAL(rparam,2);
151 int i;
152 char *rdata_end = rdata + rdrcnt;
153
154 count=SVAL(rparam,4);
155 p = rdata;
156
157 for (i=0;i<count;i++,p+=20) {
158 char *sname;
159 int type;
160 int comment_offset;
161 const char *cmnt;
162 const char *p1;
163 char *s1, *s2;
164 size_t len;
165 TALLOC_CTX *frame = talloc_stackframe();
166
167 if (p + 20 > rdata_end) {
168 TALLOC_FREE(frame);
169 break;
170 }
171
172 sname = p;
173 type = SVAL(p,14);
174 comment_offset = (IVAL(p,16) & 0xFFFF) - converter;
175 if (comment_offset < 0 ||
176 comment_offset > (int)rdrcnt) {
177 TALLOC_FREE(frame);
178 break;
179 }
180 cmnt = comment_offset?(rdata+comment_offset):"";
181
182 /* Work out the comment length. */
183 for (p1 = cmnt, len = 0; *p1 &&
184 p1 < rdata_end; len++)
185 p1++;
186 if (!*p1) {
187 len++;
188 }
189 pull_string_talloc(frame,rdata,0,
190 &s1,sname,14,STR_ASCII);
191 pull_string_talloc(frame,rdata,0,
192 &s2,cmnt,len,STR_ASCII);
193 if (!s1 || !s2) {
194 TALLOC_FREE(frame);
195 continue;
196 }
197
198 fn(s1, type, s2, state);
199
200 TALLOC_FREE(frame);
201 }
202 } else {
203 DEBUG(4,("NetShareEnum res=%d\n", res));
204 }
205
206 done:
207 SAFE_FREE(rparam);
208 SAFE_FREE(rdata);
209
210 return count;
211 }
212
213 /****************************************************************************
214 Call a NetServerEnum for the specified workgroup and servertype mask. This
215 function then calls the specified callback function for each name returned.
216
217 The callback function takes 4 arguments: the machine name, the server type,
218 the comment and a state pointer.
219 ****************************************************************************/
220
221 bool cli_NetServerEnum(struct cli_state *cli, char *workgroup, uint32_t stype,
222 void (*fn)(const char *, uint32_t, const char *, void *),
223 void *state)
224 {
225 char *rparam = NULL;
226 char *rdata = NULL;
227 char *rdata_end = NULL;
228 unsigned int rdrcnt,rprcnt;
229 char *p;
230 char param[1024];
231 int uLevel = 1;
232 size_t len;
233 uint32_t func = RAP_NetServerEnum2;
234 char *last_entry = NULL;
235 int total_cnt = 0;
236 int return_cnt = 0;
237 int res;
238
239 errno = 0; /* reset */
240
241 /*
242 * This may take more than one transaction, so we should loop until
243 * we no longer get a more data to process or we have all of the
244 * items.
245 */
246 do {
247 /* send a SMBtrans command with api NetServerEnum */
248 p = param;
249 SIVAL(p,0,func); /* api number */
250 p += 2;
251
252 if (func == RAP_NetServerEnum3) {
253 strlcpy(p,"WrLehDzz", sizeof(param)-PTR_DIFF(p,param));
254 } else {
255 strlcpy(p,"WrLehDz", sizeof(param)-PTR_DIFF(p,param));
256 }
257
258 p = skip_string(param, sizeof(param), p);
259 strlcpy(p,"B16BBDz", sizeof(param)-PTR_DIFF(p,param));
260
261 p = skip_string(param, sizeof(param), p);
262 SSVAL(p,0,uLevel);
263 SSVAL(p,2,CLI_BUFFER_SIZE);
264 p += 4;
265 SIVAL(p,0,stype);
266 p += 4;
267
268 /* If we have more data, tell the server where
269 * to continue from.
270 */
271 len = push_ascii(p,
272 workgroup,
273 sizeof(param) - PTR_DIFF(p,param) - 1,
274 STR_TERMINATE|STR_UPPER);
275
276 if (len == 0) {
277 SAFE_FREE(last_entry);
278 return false;
279 }
280 p += len;
281
282 if (func == RAP_NetServerEnum3) {
283 len = push_ascii(p,
284 last_entry ? last_entry : "",
285 sizeof(param) - PTR_DIFF(p,param) - 1,
286 STR_TERMINATE);
287
288 if (len == 0) {
289 SAFE_FREE(last_entry);
290 return false;
291 }
292 p += len;
293 }
294
295 /* Next time through we need to use the continue api */
296 func = RAP_NetServerEnum3;
297
298 if (!cli_api(cli,
299 param, PTR_DIFF(p,param), 8, /* params, length, max */
300 NULL, 0, CLI_BUFFER_SIZE, /* data, length, max */
301 &rparam, &rprcnt, /* return params, return size */
302 &rdata, &rdrcnt)) { /* return data, return size */
303
304 /* break out of the loop on error */
305 res = -1;
306 break;
307 }
308
309 rdata_end = rdata + rdrcnt;
310
311 if (rprcnt < 6) {
312 DBG_ERR("Got invalid result: rprcnt=%u\n", rprcnt);
313 res = -1;
314 break;
315 }
316
317 res = rparam ? SVAL(rparam,0) : -1;
318
319 if (res == 0 || res == ERRmoredata ||
320 (res != -1 && cli_errno(cli) == 0)) {
321 char *sname = NULL;
322 int i, count;
323 int converter=SVAL(rparam,2);
324
325 /* Get the number of items returned in this buffer */
326 count = SVAL(rparam, 4);
327
328 /* The next field contains the number of items left,
329 * including those returned in this buffer. So the
330 * first time through this should contain all of the
331 * entries.
332 */
333 if (total_cnt == 0) {
334 total_cnt = SVAL(rparam, 6);
335 }
336
337 /* Keep track of how many we have read */
338 return_cnt += count;
339 p = rdata;
340
341 /* The last name in the previous NetServerEnum reply is
342 * sent back to server in the NetServerEnum3 request
343 * (last_entry). The next reply should repeat this entry
344 * as the first element. We have no proof that this is
345 * always true, but from traces that seems to be the
346 * behavior from Window Servers. So first lets do a lot
347 * of checking, just being paranoid. If the string
348 * matches then we already saw this entry so skip it.
349 *
350 * NOTE: sv1_name field must be null terminated and has
351 * a max size of 16 (NetBIOS Name).
352 */
353 if (last_entry && count && p &&
354 (strncmp(last_entry, p, 16) == 0)) {
355 count -= 1; /* Skip this entry */
356 return_cnt = -1; /* Not part of total, so don't count. */
357 p = rdata + 26; /* Skip the whole record */
358 }
359
360 for (i = 0; i < count; i++, p += 26) {
361 int comment_offset;
362 const char *cmnt;
363 const char *p1;
364 char *s1, *s2;
365 TALLOC_CTX *frame = talloc_stackframe();
366 uint32_t entry_stype;
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 entry_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, entry_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 gnutls_cipher_hd_t cipher_hnd = NULL;
464 gnutls_datum_t old_pw_key = {
465 .data = old_pw_hash,
466 .size = sizeof(old_pw_hash),
467 };
468 int rc;
469
470 if (strlen(user) >= sizeof(fstring)-1) {
471 DEBUG(0,("cli_oem_change_password: user name %s is too long.\n", user));
472 return False;
473 }
474
475 SSVAL(p,0,214); /* SamOEMChangePassword command. */
476 p += 2;
477 strlcpy(p, "zsT", sizeof(param)-PTR_DIFF(p,param));
478 p = skip_string(param,sizeof(param),p);
479 strlcpy(p, "B516B16", sizeof(param)-PTR_DIFF(p,param));
480 p = skip_string(param,sizeof(param),p);
481 strlcpy(p,user, sizeof(param)-PTR_DIFF(p,param));
482 p = skip_string(param,sizeof(param),p);
483 SSVAL(p,0,532);
484 p += 2;
485
486 param_len = PTR_DIFF(p,param);
487
488 /*
489 * Get the Lanman hash of the old password, we
490 * use this as the key to make_oem_passwd_hash().
491 */
492 E_deshash(old_password, old_pw_hash);
493
494 encode_pw_buffer(data, new_password, STR_ASCII);
495
496 #ifdef DEBUG_PASSWORD
497 DEBUG(100,("make_oem_passwd_hash\n"));
498 dump_data(100, data, 516);
499 #endif
500 rc = gnutls_cipher_init(&cipher_hnd,
501 GNUTLS_CIPHER_ARCFOUR_128,
502 &old_pw_key,
503 NULL);
504 if (rc < 0) {
505 DBG_ERR("gnutls_cipher_init failed: %s\n",
506 gnutls_strerror(rc));
507 return false;
508 }
509 rc = gnutls_cipher_encrypt(cipher_hnd,
510 data,
511 516);
512 gnutls_cipher_deinit(cipher_hnd);
513 if (rc < 0) {
514 return false;
515 }
516
517 /*
518 * Now place the old password hash in the data.
519 */
520 E_deshash(new_password, new_pw_hash);
521
522 rc = E_old_pw_hash( new_pw_hash, old_pw_hash, (uchar *)&data[516]);
523 if (rc != 0) {
524 DBG_ERR("E_old_pw_hash failed: %s\n", gnutls_strerror(rc));
525 return false;
526 }
527
528 data_len = 532;
529
530 if (!cli_api(cli,
531 param, param_len, 4, /* param, length, max */
532 (char *)data, data_len, 0, /* data, length, max */
533 &rparam, &rprcnt,
534 &rdata, &rdrcnt)) {
535 DEBUG(0,("cli_oem_change_password: Failed to send password change for user %s\n",
536 user ));
537 return False;
538 }
539
540 if (rdrcnt < 2) {
541 cli->rap_error = ERRbadformat;
542 goto done;
543 }
544
545 if (rparam) {
546 cli->rap_error = SVAL(rparam,0);
547 }
548
549 done:
550 SAFE_FREE(rparam);
551 SAFE_FREE(rdata);
552
553 return (cli->rap_error == 0);
554 }
555
556 static void prep_basic_information_buf(
557 uint8_t buf[40],
558 struct timespec create_time,
559 struct timespec access_time,
560 struct timespec write_time,
561 struct timespec change_time,
562 uint32_t attr)
563 {
564 char *p = (char *)buf;
565 /*
566 * Add the create, last access, modification, and status change times
567 */
568 put_long_date_full_timespec(
569 TIMESTAMP_SET_NT_OR_BETTER, p, &create_time);
570 p += 8;
571
572 put_long_date_full_timespec(
573 TIMESTAMP_SET_NT_OR_BETTER, p, &access_time);
574 p += 8;
575
576 put_long_date_full_timespec(
577 TIMESTAMP_SET_NT_OR_BETTER, p, &write_time);
578 p += 8;
579
580 put_long_date_full_timespec(
581 TIMESTAMP_SET_NT_OR_BETTER, p, &change_time);
582 p += 8;
583
584 if (attr == (uint32_t)-1 || attr == FILE_ATTRIBUTE_NORMAL) {
585 /* No change. */
586 attr = 0;
587 } else if (attr == 0) {
588 /* Clear all existing attributes. */
589 attr = FILE_ATTRIBUTE_NORMAL;
590 }
591
592 /* Add attributes */
593 SIVAL(p, 0, attr);
594
595 p += 4;
596
597 /* Add padding */
598 SIVAL(p, 0, 0);
599 p += 4;
600
601 SMB_ASSERT(PTR_DIFF(p, buf) == 40);
602 }
603
604 NTSTATUS cli_setpathinfo_ext(struct cli_state *cli, const char *fname,
605 struct timespec create_time,
606 struct timespec access_time,
607 struct timespec write_time,
608 struct timespec change_time,
609 uint32_t attr)
610 {
611 uint8_t buf[40];
612
613 prep_basic_information_buf(
614 buf,
615 create_time,
616 access_time,
617 write_time,
618 change_time,
619 attr);
620
621 if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
622 DATA_BLOB in_data = data_blob_const(buf, sizeof(buf));
623 /*
624 * Split out SMB2 here as we need to select
625 * the correct info type and level.
626 */
627 return cli_smb2_setpathinfo(cli,
628 fname,
629 1, /* SMB2_SETINFO_FILE */
630 SMB_FILE_BASIC_INFORMATION - 1000,
631 &in_data);
632 }
633
634 return cli_setpathinfo(
635 cli, SMB_FILE_BASIC_INFORMATION, fname, buf, sizeof(buf));
636 }
637
638 struct cli_setfileinfo_ext_state {
639 uint8_t data[40];
640 DATA_BLOB in_data;
641 };
642
643 static void cli_setfileinfo_ext_done(struct tevent_req *subreq);
644 static void cli_setfileinfo_ext_done2(struct tevent_req *subreq);
645
646 struct tevent_req *cli_setfileinfo_ext_send(
647 TALLOC_CTX *mem_ctx,
648 struct tevent_context *ev,
649 struct cli_state *cli,
650 uint16_t fnum,
651 struct timespec create_time,
652 struct timespec access_time,
653 struct timespec write_time,
654 struct timespec change_time,
655 uint32_t attr)
656 {
657 struct tevent_req *req = NULL, *subreq = NULL;
658 struct cli_setfileinfo_ext_state *state = NULL;
659
660 req = tevent_req_create(
661 mem_ctx, &state, struct cli_setfileinfo_ext_state);
662 if (req == NULL) {
663 return NULL;
664 }
665 prep_basic_information_buf(
666 state->data,
667 create_time,
668 access_time,
669 write_time,
670 change_time,
671 attr);
672
673 if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
674 state->in_data = (DATA_BLOB) {
675 .data = state->data, .length = sizeof(state->data),
676 };
677
678 subreq = cli_smb2_set_info_fnum_send(
679 state,
680 ev,
681 cli,
682 fnum,
683 SMB2_0_INFO_FILE,
684 SMB_FILE_BASIC_INFORMATION - 1000,
685 &state->in_data,
686 0); /* in_additional_info */
687 if (tevent_req_nomem(subreq, req)) {
688 return tevent_req_post(req, ev);
689 }
690 tevent_req_set_callback(
691 subreq, cli_setfileinfo_ext_done2, req);
692 return req;
693 }
694
695 subreq = cli_setfileinfo_send(
696 state,
697 ev,
698 cli,
699 fnum,
700 SMB_FILE_BASIC_INFORMATION,
701 state->data,
702 sizeof(state->data));
703 if (tevent_req_nomem(subreq, req)) {
704 return tevent_req_post(req, ev);
705 }
706 tevent_req_set_callback(subreq, cli_setfileinfo_ext_done, req);
707 return req;
708 }
709
710 static void cli_setfileinfo_ext_done(struct tevent_req *subreq)
711 {
712 NTSTATUS status = cli_setfileinfo_recv(subreq);
713 tevent_req_simple_finish_ntstatus(subreq, status);
714 }
715
716 static void cli_setfileinfo_ext_done2(struct tevent_req *subreq)
717 {
718 NTSTATUS status = cli_smb2_set_info_fnum_recv(subreq);
719 tevent_req_simple_finish_ntstatus(subreq, status);
720 }
721
722 NTSTATUS cli_setfileinfo_ext_recv(struct tevent_req *req)
723 {
724 return tevent_req_simple_recv_ntstatus(req);
725 }
726
727 NTSTATUS cli_setfileinfo_ext(
728 struct cli_state *cli,
729 uint16_t fnum,
730 struct timespec create_time,
731 struct timespec access_time,
732 struct timespec write_time,
733 struct timespec change_time,
734 uint32_t attr)
735 {
736 TALLOC_CTX *frame = NULL;
737 struct tevent_context *ev = NULL;
738 struct tevent_req *req = NULL;
739 NTSTATUS status = NT_STATUS_NO_MEMORY;
740
741 if (smbXcli_conn_has_async_calls(cli->conn)) {
742 /*
743 * Can't use sync call while an async call is in flight
744 */
745 return NT_STATUS_INVALID_PARAMETER;
746 }
747
748 frame = talloc_stackframe();
749
750 ev = samba_tevent_context_init(frame);
751 if (ev == NULL) {
752 goto fail;
753 }
754 req = cli_setfileinfo_ext_send(
755 ev,
756 ev,
757 cli,
758 fnum,
759 create_time,
760 access_time,
761 write_time,
762 change_time,
763 attr);
764 if (req == NULL) {
765 goto fail;
766 }
767 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
768 goto fail;
769 }
770 status = cli_setfileinfo_ext_recv(req);
771 fail:
772 TALLOC_FREE(frame);
773 return status;
774 }
775
776 /****************************************************************************
777 Send a qpathinfo call with the SMB_QUERY_FILE_ALL_INFO info level.
778 ****************************************************************************/
779
780 struct cli_qpathinfo2_state {
781 struct tevent_context *ev;
782 struct cli_state *cli;
783 const char *fname;
784 struct timespec create_time;
785 struct timespec access_time;
786 struct timespec write_time;
787 struct timespec change_time;
788 off_t size;
789 uint32_t attr;
790 SMB_INO_T ino;
791 mode_t mode;
792 };
793
794 static void cli_qpathinfo2_done2(struct tevent_req *subreq);
795 static void cli_qpathinfo2_done(struct tevent_req *subreq);
796 static void cli_qpathinfo2_got_reparse(struct tevent_req *subreq);
797
798 struct tevent_req *cli_qpathinfo2_send(TALLOC_CTX *mem_ctx,
799 struct tevent_context *ev,
800 struct cli_state *cli,
801 const char *fname)
802 {
803 struct tevent_req *req = NULL, *subreq = NULL;
804 struct cli_qpathinfo2_state *state = NULL;
805
806 req = tevent_req_create(mem_ctx, &state, struct cli_qpathinfo2_state);
807 if (req == NULL) {
808 return NULL;
809 }
810 state->ev = ev;
811 state->cli = cli;
812 state->fname = fname;
813
814 state->mode = S_IFREG;
815
816 if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
817 subreq = cli_smb2_qpathinfo_send(state,
818 ev,
819 cli,
820 fname,
821 FSCC_FILE_ALL_INFORMATION,
822 0x60,
823 UINT16_MAX);
824 if (tevent_req_nomem(subreq, req)) {
825 return tevent_req_post(req, ev);
826 }
827 tevent_req_set_callback(subreq, cli_qpathinfo2_done2, req);
828 return req;
829 }
830 subreq = cli_qpathinfo_send(state, ev, cli, fname,
831 SMB_QUERY_FILE_ALL_INFO,
832 68, CLI_BUFFER_SIZE);
833 if (tevent_req_nomem(subreq, req)) {
834 return tevent_req_post(req, ev);
835 }
836 tevent_req_set_callback(subreq, cli_qpathinfo2_done, req);
837 return req;
838 }
839
840 static void cli_qpathinfo2_done2(struct tevent_req *subreq)
841 {
842 struct tevent_req *req =
843 tevent_req_callback_data(subreq, struct tevent_req);
844 struct cli_qpathinfo2_state *state =
845 tevent_req_data(req, struct cli_qpathinfo2_state);
846 uint8_t *rdata = NULL;
847 uint32_t num_rdata;
848 NTSTATUS status;
849
850 status = cli_smb2_qpathinfo_recv(subreq, state, &rdata, &num_rdata);
851 TALLOC_FREE(subreq);
852 if (tevent_req_nterror(req, status)) {
853 return;
854 }
855 state->create_time = interpret_long_date(BVAL(rdata, 0x0));
856 state->access_time = interpret_long_date(BVAL(rdata, 0x8));
857 state->write_time = interpret_long_date(BVAL(rdata, 0x10));
858 state->change_time = interpret_long_date(BVAL(rdata, 0x18));
859 state->attr = PULL_LE_U32(rdata, 0x20);
860 state->size = PULL_LE_U64(rdata, 0x30);
861 state->ino = PULL_LE_U64(rdata, 0x40);
862
863 if (state->attr & FILE_ATTRIBUTE_REPARSE_POINT) {
864 subreq = cli_get_reparse_data_send(state,
865 state->ev,
866 state->cli,
867 state->fname);
868 if (tevent_req_nomem(subreq, req)) {
869 return;
870 }
871 tevent_req_set_callback(subreq,
872 cli_qpathinfo2_got_reparse,
873 req);
874 return;
875 }
876
877 tevent_req_done(req);
878 }
879
880 static void cli_qpathinfo2_done(struct tevent_req *subreq)
881 {
882 struct tevent_req *req = tevent_req_callback_data(
883 subreq, struct tevent_req);
884 struct cli_qpathinfo2_state *state = tevent_req_data(
885 req, struct cli_qpathinfo2_state);
886 uint8_t *data = NULL;
887 uint32_t num_data;
888 NTSTATUS status;
889
890 status = cli_qpathinfo_recv(subreq, state, &data, &num_data);
891 TALLOC_FREE(subreq);
892 if (tevent_req_nterror(req, status)) {
893 return;
894 }
895
896 state->create_time = interpret_long_date(BVAL(data, 0));
897 state->access_time = interpret_long_date(BVAL(data, 8));
898 state->write_time = interpret_long_date(BVAL(data, 16));
899 state->change_time = interpret_long_date(BVAL(data, 24));
900 state->attr = PULL_LE_U32(data, 32);
901 state->size = PULL_LE_U64(data, 48);
902
903 /*
904 * SMB1 qpathinfo2 uses SMB_QUERY_FILE_ALL_INFO which doesn't
905 * return an inode number (fileid). We can't change this to
906 * one of the FILE_ID info levels as only Win2003 and above
907 * support these [MS-SMB: 2.2.2.3.1] and the SMB1 code needs
908 * to support older servers.
909 */
910 state->ino = 0;
911
912 TALLOC_FREE(data);
913
914 if (state->attr & FILE_ATTRIBUTE_REPARSE_POINT) {
915 subreq = cli_get_reparse_data_send(state,
916 state->ev,
917 state->cli,
918 state->fname);
919 if (tevent_req_nomem(subreq, req)) {
920 return;
921 }
922 tevent_req_set_callback(subreq,
923 cli_qpathinfo2_got_reparse,
924 req);
925 return;
926 }
927
928 tevent_req_done(req);
929 }
930
931 static void cli_qpathinfo2_got_reparse(struct tevent_req *subreq)
932 {
933 struct tevent_req *req =
934 tevent_req_callback_data(subreq, struct tevent_req);
935 struct cli_qpathinfo2_state *state =
936 tevent_req_data(req, struct cli_qpathinfo2_state);
937 uint8_t *data = NULL;
938 uint32_t num_data;
939 struct reparse_data_buffer reparse = {
940 .tag = 0,
941 };
942 NTSTATUS status;
943
944 status = cli_get_reparse_data_recv(subreq, state, &data, &num_data);
945 TALLOC_FREE(subreq);
946 if (tevent_req_nterror(req, status)) {
947 return;
948 }
949
950 status = reparse_data_buffer_parse(state, &reparse, data, num_data);
951 if (!NT_STATUS_IS_OK(status)) {
952 DBG_DEBUG("Ignoring unknown reparse data\n");
953 goto done;
954 }
955
956 switch (reparse.tag) {
957 case IO_REPARSE_TAG_SYMLINK:
958 state->mode = S_IFLNK;
959 break;
960 case IO_REPARSE_TAG_NFS:
961 switch (reparse.parsed.nfs.type) {
962 case NFS_SPECFILE_LNK:
963 state->mode = S_IFLNK;
964 break;
965 case NFS_SPECFILE_CHR:
966 state->mode = S_IFCHR;
967 break;
968 case NFS_SPECFILE_BLK:
969 state->mode = S_IFBLK;
970 break;
971 case NFS_SPECFILE_FIFO:
972 state->mode = S_IFIFO;
973 break;
974 case NFS_SPECFILE_SOCK:
975 state->mode = S_IFSOCK;
976 break;
977 }
978 break;
979 }
980 done:
981 tevent_req_done(req);
982 }
983
984 NTSTATUS cli_qpathinfo2_recv(struct tevent_req *req,
985 struct timespec *create_time,
986 struct timespec *access_time,
987 struct timespec *write_time,
988 struct timespec *change_time,
989 off_t *size,
990 uint32_t *pattr,
991 SMB_INO_T *ino,
992 mode_t *mode)
993 {
994 struct cli_qpathinfo2_state *state = tevent_req_data(
995 req, struct cli_qpathinfo2_state);
996 NTSTATUS status;
997
998 if (tevent_req_is_nterror(req, &status)) {
999 return status;
1000 }
1001
1002 if (create_time) {
1003 *create_time = state->create_time;
1004 }
1005 if (access_time) {
1006 *access_time = state->access_time;
1007 }
1008 if (write_time) {
1009 *write_time = state->write_time;
1010 }
1011 if (change_time) {
1012 *change_time = state->change_time;
1013 }
1014 if (pattr) {
1015 *pattr = state->attr;
1016 }
1017 if (size) {
1018 *size = state->size;
1019 }
1020 if (ino) {
1021 *ino = state->ino;
1022 }
1023 if (mode != NULL) {
1024 *mode = state->mode;
1025 }
1026 return NT_STATUS_OK;
1027 }
1028
1029 NTSTATUS cli_qpathinfo2(struct cli_state *cli,
1030 const char *fname,
1031 struct timespec *create_time,
1032 struct timespec *access_time,
1033 struct timespec *write_time,
1034 struct timespec *change_time,
1035 off_t *size,
1036 uint32_t *pattr,
1037 SMB_INO_T *ino,
1038 mode_t *mode)
1039 {
1040 TALLOC_CTX *frame = talloc_stackframe();
1041 struct tevent_context *ev = NULL;
1042 struct tevent_req *req = NULL;
1043 NTSTATUS status = NT_STATUS_NO_MEMORY;
1044
1045 if (smbXcli_conn_has_async_calls(cli->conn)) {
1046 /*
1047 * Can't use sync call while an async call is in flight
1048 */
1049 status = NT_STATUS_INVALID_PARAMETER;
1050 goto fail;
1051 }
1052 ev = samba_tevent_context_init(frame);
1053 if (ev == NULL) {
1054 goto fail;
1055 }
1056 req = cli_qpathinfo2_send(frame, ev, cli, fname);
1057 if (req == NULL) {
1058 goto fail;
1059 }
1060 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
1061 goto fail;
1062 }
1063 status = cli_qpathinfo2_recv(req,
1064 create_time,
1065 access_time,
1066 write_time,
1067 change_time,
1068 size,
1069 pattr,
1070 ino,
1071 mode);
1072 fail:
1073 TALLOC_FREE(frame);
1074 return status;
1075 }
1076
1077 /****************************************************************************
1078 Get the stream info
1079 ****************************************************************************/
1080
1081 struct cli_qpathinfo_streams_state {
1082 uint32_t num_data;
1083 uint8_t *data;
1084 };
1085
1086 static void cli_qpathinfo_streams_done(struct tevent_req *subreq);
1087 static void cli_qpathinfo_streams_done2(struct tevent_req *subreq);
1088
1089 struct tevent_req *cli_qpathinfo_streams_send(TALLOC_CTX *mem_ctx,
1090 struct tevent_context *ev,
1091 struct cli_state *cli,
1092 const char *fname)
1093 {
1094 struct tevent_req *req = NULL, *subreq = NULL;
1095 struct cli_qpathinfo_streams_state *state = NULL;
1096
1097 req = tevent_req_create(mem_ctx, &state,
1098 struct cli_qpathinfo_streams_state);
1099 if (req == NULL) {
1100 return NULL;
1101 }
1102 if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
1103 subreq = cli_smb2_qpathinfo_send(state,
1104 ev,
1105 cli,
1106 fname,
1107 FSCC_FILE_STREAM_INFORMATION,
1108 0,
1109 CLI_BUFFER_SIZE);
1110 if (tevent_req_nomem(subreq, req)) {
1111 return tevent_req_post(req, ev);
1112 }
1113 tevent_req_set_callback(subreq,
1114 cli_qpathinfo_streams_done2,
1115 req);
1116 return req;
1117 }
1118 subreq = cli_qpathinfo_send(state, ev, cli, fname,
1119 SMB_FILE_STREAM_INFORMATION,
1120 0, CLI_BUFFER_SIZE);
1121 if (tevent_req_nomem(subreq, req)) {
1122 return tevent_req_post(req, ev);
1123 }
1124 tevent_req_set_callback(subreq, cli_qpathinfo_streams_done, req);
1125 return req;
1126 }
1127
1128 static void cli_qpathinfo_streams_done(struct tevent_req *subreq)
1129 {
1130 struct tevent_req *req = tevent_req_callback_data(
1131 subreq, struct tevent_req);
1132 struct cli_qpathinfo_streams_state *state = tevent_req_data(
1133 req, struct cli_qpathinfo_streams_state);
1134 NTSTATUS status;
1135
1136 status = cli_qpathinfo_recv(subreq, state, &state->data,
1137 &state->num_data);
1138 tevent_req_simple_finish_ntstatus(subreq, status);
1139 }
1140
1141 static void cli_qpathinfo_streams_done2(struct tevent_req *subreq)
1142 {
1143 struct tevent_req *req =
1144 tevent_req_callback_data(subreq, struct tevent_req);
1145 struct cli_qpathinfo_streams_state *state =
1146 tevent_req_data(req, struct cli_qpathinfo_streams_state);
1147 NTSTATUS status;
1148
1149 status = cli_smb2_qpathinfo_recv(subreq,
1150 state,
1151 &state->data,
1152 &state->num_data);
1153 tevent_req_simple_finish_ntstatus(subreq, status);
1154 }
1155
1156 NTSTATUS cli_qpathinfo_streams_recv(struct tevent_req *req,
1157 TALLOC_CTX *mem_ctx,
1158 unsigned int *pnum_streams,
1159 struct stream_struct **pstreams)
1160 {
1161 struct cli_qpathinfo_streams_state *state = tevent_req_data(
1162 req, struct cli_qpathinfo_streams_state);
1163 NTSTATUS status;
1164
1165 if (tevent_req_is_nterror(req, &status)) {
1166 return status;
1167 }
1168 if (!parse_streams_blob(mem_ctx, state->data, state->num_data,
1169 pnum_streams, pstreams)) {
1170 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1171 }
1172 return NT_STATUS_OK;
1173 }
1174
1175 NTSTATUS cli_qpathinfo_streams(struct cli_state *cli, const char *fname,
1176 TALLOC_CTX *mem_ctx,
1177 unsigned int *pnum_streams,
1178 struct stream_struct **pstreams)
1179 {
1180 TALLOC_CTX *frame = NULL;
1181 struct tevent_context *ev;
1182 struct tevent_req *req;
1183 NTSTATUS status = NT_STATUS_NO_MEMORY;
1184
1185 frame = talloc_stackframe();
1186
1187 if (smbXcli_conn_has_async_calls(cli->conn)) {
1188 /*
1189 * Can't use sync call while an async call is in flight
1190 */
1191 status = NT_STATUS_INVALID_PARAMETER;
1192 goto fail;
1193 }
1194 ev = samba_tevent_context_init(frame);
1195 if (ev == NULL) {
1196 goto fail;
1197 }
1198 req = cli_qpathinfo_streams_send(frame, ev, cli, fname);
1199 if (req == NULL) {
1200 goto fail;
1201 }
1202 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
1203 goto fail;
1204 }
1205 status = cli_qpathinfo_streams_recv(req, mem_ctx, pnum_streams,
1206 pstreams);
1207 fail:
1208 TALLOC_FREE(frame);
1209 return status;
1210 }
1211
1212 bool parse_streams_blob(TALLOC_CTX *mem_ctx, const uint8_t *rdata,
1213 size_t data_len,
1214 unsigned int *pnum_streams,
1215 struct stream_struct **pstreams)
1216 {
1217 unsigned int num_streams;
1218 struct stream_struct *streams;
1219 unsigned int ofs;
1220
1221 num_streams = 0;
1222 streams = NULL;
1223 ofs = 0;
1224
1225 while ((data_len > ofs) && (data_len - ofs >= 24)) {
1226 uint32_t nlen, len;
1227 size_t size;
1228 void *vstr;
1229 struct stream_struct *tmp;
1230 uint8_t *tmp_buf;
1231
1232 tmp = talloc_realloc(mem_ctx, streams,
1233 struct stream_struct,
1234 num_streams+1);
1235
1236 if (tmp == NULL) {
1237 goto fail;
1238 }
1239 streams = tmp;
1240
1241 nlen = IVAL(rdata, ofs + 0x04);
1242
1243 streams[num_streams].size = IVAL_TO_SMB_OFF_T(
1244 rdata, ofs + 0x08);
1245 streams[num_streams].alloc_size = IVAL_TO_SMB_OFF_T(
1246 rdata, ofs + 0x10);
1247
1248 if (nlen > data_len - (ofs + 24)) {
1249 goto fail;
1250 }
1251
1252 /*
1253 * We need to null-terminate src, how do I do this with
1254 * convert_string_talloc??
1255 */
1256
1257 tmp_buf = talloc_array(streams, uint8_t, nlen+2);
1258 if (tmp_buf == NULL) {
1259 goto fail;
1260 }
1261
1262 memcpy(tmp_buf, rdata+ofs+24, nlen);
1263 tmp_buf[nlen] = 0;
1264 tmp_buf[nlen+1] = 0;
1265
1266 if (!convert_string_talloc(streams, CH_UTF16, CH_UNIX, tmp_buf,
1267 nlen+2, &vstr, &size))
1268 {
1269 TALLOC_FREE(tmp_buf);
1270 goto fail;
1271 }
1272
1273 TALLOC_FREE(tmp_buf);
1274 streams[num_streams].name = (char *)vstr;
1275 num_streams++;
1276
1277 len = IVAL(rdata, ofs);
1278 if (len > data_len - ofs) {
1279 goto fail;
1280 }
1281 if (len == 0) break;
1282 ofs += len;
1283 }
1284
1285 *pnum_streams = num_streams;
1286 *pstreams = streams;
1287 return true;
1288
1289 fail:
1290 TALLOC_FREE(streams);
1291 return false;
1292 }
1293
1294 /****************************************************************************
1295 Send a qfileinfo QUERY_FILE_NAME_INFO call.
1296 ****************************************************************************/
1297
1298 struct cli_qfileinfo_basic_state {
1299 uint32_t attr;
1300 off_t size;
1301 struct timespec create_time;
1302 struct timespec access_time;
1303 struct timespec write_time;
1304 struct timespec change_time;
1305 SMB_INO_T ino;
1306 };
1307
1308 static void cli_qfileinfo_basic_done(struct tevent_req *subreq);
1309 static void cli_qfileinfo_basic_doneE(struct tevent_req *subreq);
1310 static void cli_qfileinfo_basic_done2(struct tevent_req *subreq);
1311
1312 struct tevent_req *cli_qfileinfo_basic_send(
1313 TALLOC_CTX *mem_ctx,
1314 struct tevent_context *ev,
1315 struct cli_state *cli,
1316 uint16_t fnum)
1317 {
1318 struct tevent_req *req = NULL, *subreq = NULL;
1319 struct cli_qfileinfo_basic_state *state = NULL;
1320
1321 req = tevent_req_create(
1322 mem_ctx, &state, struct cli_qfileinfo_basic_state);
1323 if (req == NULL) {
1324 return NULL;
1325 }
1326
1327 if ((smbXcli_conn_protocol(cli->conn) < PROTOCOL_LANMAN2) ||
1328 cli->win95) {
1329 /*
1330 * According to
1331 * https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-cifs/3d9d8f3e-dc70-410d-a3fc-6f4a881e8cab
1332 * SMB_COM_TRANSACTION2 used in cli_qfileinfo_send()
1333 * further down was introduced with the LAN Manager
1334 * 1.2 dialect, which we encode as PROTOCOL_LANMAN2.
1335 *
1336 * The "win95" check was introduced with commit
1337 * 27e5850fd3e1c8 in 1998. Hard to check these days,
1338 * but leave it in.
1339 *
1340 * Use a lowerlevel fallback in both cases.
1341 */
1342
1343 subreq = cli_getattrE_send(state, ev, cli, fnum);
1344 if (tevent_req_nomem(subreq, req)) {
1345 return tevent_req_post(req, ev);
1346 }
1347 tevent_req_set_callback(
1348 subreq, cli_qfileinfo_basic_doneE, req);
1349 return req;
1350 }
1351
1352 if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
1353 subreq = cli_smb2_query_info_fnum_send(
1354 state, /* mem_ctx */
1355 ev, /* ev */
1356 cli, /* cli */
1357 fnum, /* fnum */
1358 1, /* in_info_type */
1359 (SMB_FILE_ALL_INFORMATION - 1000), /* in_file_info_class */
1360 0xFFFF, /* in_max_output_length */
1361 NULL, /* in_input_buffer */
1362 0, /* in_additional_info */
1363 0); /* in_flags */
1364 if (tevent_req_nomem(subreq, req)) {
1365 return tevent_req_post(req, ev);
1366 }
1367 tevent_req_set_callback(
1368 subreq, cli_qfileinfo_basic_done2, req);
1369 return req;
1370 }
1371
1372 subreq = cli_qfileinfo_send(
1373 state,
1374 ev,
1375 cli,
1376 fnum,
1377 SMB_QUERY_FILE_ALL_INFO, /* level */
1378 68, /* min_rdata */
1379 CLI_BUFFER_SIZE); /* max_rdata */
1380 if (tevent_req_nomem(subreq, req)) {
1381 return tevent_req_post(req, ev);
1382 }
1383 tevent_req_set_callback(subreq, cli_qfileinfo_basic_done, req);
1384 return req;
1385 }
1386
1387 static void cli_qfileinfo_basic_done(struct tevent_req *subreq)
1388 {
1389 struct tevent_req *req = tevent_req_callback_data(
1390 subreq, struct tevent_req);
1391 struct cli_qfileinfo_basic_state *state = tevent_req_data(
1392 req, struct cli_qfileinfo_basic_state);
1393 uint8_t *rdata;
1394 uint32_t num_rdata;
1395 NTSTATUS status;
1396
1397 status = cli_qfileinfo_recv(
1398 subreq, state, NULL, &rdata, &num_rdata);
1399 TALLOC_FREE(subreq);
1400 if (tevent_req_nterror(req, status)) {
1401 return;
1402 }
1403
1404 state->create_time = interpret_long_date(BVAL(rdata, 0));
1405 state->access_time = interpret_long_date(BVAL(rdata, 8));
1406 state->write_time = interpret_long_date(BVAL(rdata, 16));
1407 state->change_time = interpret_long_date(BVAL(rdata, 24));
1408 state->attr = PULL_LE_U32(rdata, 32);
1409 state->size = PULL_LE_U64(rdata,48);
1410 state->ino = PULL_LE_U32(rdata, 64);
1411 TALLOC_FREE(rdata);
1412
1413 tevent_req_done(req);
1414 }
1415
1416 static void cli_qfileinfo_basic_doneE(struct tevent_req *subreq)
1417 {
1418 struct tevent_req *req = tevent_req_callback_data(
1419 subreq, struct tevent_req);
1420 struct cli_qfileinfo_basic_state *state = tevent_req_data(
1421 req, struct cli_qfileinfo_basic_state);
1422 NTSTATUS status;
1423
1424 status = cli_getattrE_recv(
1425 subreq,
1426 &state->attr,
1427 &state->size,
1428 &state->change_time.tv_sec,
1429 &state->access_time.tv_sec,
1430 &state->write_time.tv_sec);
1431 TALLOC_FREE(subreq);
1432 if (tevent_req_nterror(req, status)) {
1433 return;
1434 }
1435 tevent_req_done(req);
1436 }
1437
1438 static void cli_qfileinfo_basic_done2(struct tevent_req *subreq)
1439 {
1440 struct tevent_req *req = tevent_req_callback_data(
1441 subreq, struct tevent_req);
1442 struct cli_qfileinfo_basic_state *state = tevent_req_data(
1443 req, struct cli_qfileinfo_basic_state);
1444 DATA_BLOB outbuf = {0};
1445 NTSTATUS status;
1446
1447 status = cli_smb2_query_info_fnum_recv(subreq, state, &outbuf);
1448 TALLOC_FREE(subreq);
1449 if (tevent_req_nterror(req, status)) {
1450 return;
1451 }
1452
1453 /* Parse the reply. */
1454 if (outbuf.length < 0x60) {
1455 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
1456 return;
1457 }
1458
1459 state->create_time = interpret_long_date(BVAL(outbuf.data, 0x0));
1460 state->access_time = interpret_long_date(BVAL(outbuf.data, 0x8));
1461 state->write_time = interpret_long_date(BVAL(outbuf.data, 0x10));
1462 state->change_time = interpret_long_date(BVAL(outbuf.data, 0x18));
1463 state->attr = IVAL(outbuf.data, 0x20);
1464 state->size = BVAL(outbuf.data, 0x30);
1465 state->ino = BVAL(outbuf.data, 0x40);
1466
1467 data_blob_free(&outbuf);
1468
1469 tevent_req_done(req);
1470 }
1471
1472 NTSTATUS cli_qfileinfo_basic_recv(
1473 struct tevent_req *req,
1474 uint32_t *attr,
1475 off_t *size,
1476 struct timespec *create_time,
1477 struct timespec *access_time,
1478 struct timespec *write_time,
1479 struct timespec *change_time,
1480 SMB_INO_T *ino)
1481 {
1482 struct cli_qfileinfo_basic_state *state = tevent_req_data(
1483 req, struct cli_qfileinfo_basic_state);
1484 NTSTATUS status;
1485
1486 if (tevent_req_is_nterror(req, &status)) {
1487 return status;
1488 }
1489
1490 if (create_time != NULL) {
1491 *create_time = state->create_time;
1492 }
1493 if (access_time != NULL) {
1494 *access_time = state->access_time;
1495 }
1496 if (write_time != NULL) {
1497 *write_time = state->write_time;
1498 }
1499 if (change_time != NULL) {
1500 *change_time = state->change_time;
1501 }
1502 if (attr != NULL) {
1503 *attr = state->attr;
1504 }
1505 if (size != NULL) {
1506 *size = state->size;
1507 }
1508 if (ino) {
1509 *ino = state->ino;
1510 }
1511
1512 return NT_STATUS_OK;
1513 }
1514 /****************************************************************************
1515 Send a qfileinfo call.
1516 ****************************************************************************/
1517
1518 NTSTATUS cli_qfileinfo_basic(
1519 struct cli_state *cli,
1520 uint16_t fnum,
1521 uint32_t *attr,
1522 off_t *size,
1523 struct timespec *create_time,
1524 struct timespec *access_time,
1525 struct timespec *write_time,
1526 struct timespec *change_time,
1527 SMB_INO_T *ino)
1528 {
1529 TALLOC_CTX *frame = NULL;
1530 struct tevent_context *ev = NULL;
1531 struct tevent_req *req = NULL;
1532 NTSTATUS status = NT_STATUS_NO_MEMORY;
1533
1534 frame = talloc_stackframe();
1535
1536 if (smbXcli_conn_has_async_calls(cli->conn)) {
1537 /*
1538 * Can't use sync call while an async call is in flight
1539 */
1540 status = NT_STATUS_INVALID_PARAMETER;
1541 goto fail;
1542 }
1543 ev = samba_tevent_context_init(frame);
1544 if (ev == NULL) {
1545 goto fail;
1546 }
1547 req = cli_qfileinfo_basic_send(frame, ev, cli, fnum);
1548 if (req == NULL) {
1549 goto fail;
1550 }
1551 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
1552 goto fail;
1553 }
1554
1555 status = cli_qfileinfo_basic_recv(
1556 req,
1557 attr,
1558 size,
1559 create_time,
1560 access_time,
1561 write_time,
1562 change_time,
1563 ino);
1564
1565 /* cli_smb2_query_info_fnum_recv doesn't set this */
1566 cli->raw_status = status;
1567 fail:
1568 TALLOC_FREE(frame);
1569 return status;
1570 }
1571
1572 /****************************************************************************
1573 Send a qpathinfo BASIC_INFO call.
1574 ****************************************************************************/
1575
1576 struct cli_qpathinfo_basic_state {
1577 uint32_t num_data;
1578 uint8_t *data;
1579 };
1580
1581 static void cli_qpathinfo_basic_done(struct tevent_req *subreq);
1582
1583 struct tevent_req *cli_qpathinfo_basic_send(TALLOC_CTX *mem_ctx,
1584 struct tevent_context *ev,
1585 struct cli_state *cli,
1586 const char *fname)
1587 {
1588 struct tevent_req *req = NULL, *subreq = NULL;
1589 struct cli_qpathinfo_basic_state *state = NULL;
1590
1591 req = tevent_req_create(mem_ctx, &state,
1592 struct cli_qpathinfo_basic_state);
1593 if (req == NULL) {
1594 return NULL;
1595 }
1596 subreq = cli_qpathinfo_send(state, ev, cli, fname,
1597 SMB_QUERY_FILE_BASIC_INFO,
1598 36, CLI_BUFFER_SIZE);
1599 if (tevent_req_nomem(subreq, req)) {
1600 return tevent_req_post(req, ev);
1601 }
1602 tevent_req_set_callback(subreq, cli_qpathinfo_basic_done, req);
1603 return req;
1604 }
1605
1606 static void cli_qpathinfo_basic_done(struct tevent_req *subreq)
1607 {
1608 struct tevent_req *req = tevent_req_callback_data(
1609 subreq, struct tevent_req);
1610 struct cli_qpathinfo_basic_state *state = tevent_req_data(
1611 req, struct cli_qpathinfo_basic_state);
1612 NTSTATUS status;
1613
1614 status = cli_qpathinfo_recv(subreq, state, &state->data,
1615 &state->num_data);
1616 TALLOC_FREE(subreq);
1617 if (tevent_req_nterror(req, status)) {
1618 return;
1619 }
1620 tevent_req_done(req);
1621 }
1622
1623 NTSTATUS cli_qpathinfo_basic_recv(struct tevent_req *req,
1624 SMB_STRUCT_STAT *sbuf, uint32_t *attributes)
1625 {
1626 struct cli_qpathinfo_basic_state *state = tevent_req_data(
1627 req, struct cli_qpathinfo_basic_state);
1628 NTSTATUS status;
1629
1630 if (tevent_req_is_nterror(req, &status)) {
1631 return status;
1632 }
1633
1634 sbuf->st_ex_btime = interpret_long_date(BVAL(state->data, 0));
1635 sbuf->st_ex_atime = interpret_long_date(BVAL(state->data, 8));
1636 sbuf->st_ex_mtime = interpret_long_date(BVAL(state->data, 16));
1637 sbuf->st_ex_ctime = interpret_long_date(BVAL(state->data, 24));
1638 *attributes = IVAL(state->data, 32);
1639 return NT_STATUS_OK;
1640 }
1641
1642 NTSTATUS cli_qpathinfo_basic(struct cli_state *cli, const char *name,
1643 SMB_STRUCT_STAT *sbuf, uint32_t *attributes)
1644 {
1645 TALLOC_CTX *frame = NULL;
1646 struct tevent_context *ev;
1647 struct tevent_req *req;
1648 NTSTATUS status = NT_STATUS_NO_MEMORY;
1649
1650 if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
1651 return cli_smb2_qpathinfo_basic(cli,
1652 name,
1653 sbuf,
1654 attributes);
1655 }
1656
1657 frame = talloc_stackframe();
1658
1659 if (smbXcli_conn_has_async_calls(cli->conn)) {
1660 /*
1661 * Can't use sync call while an async call is in flight
1662 */
1663 status = NT_STATUS_INVALID_PARAMETER;
1664 goto fail;
1665 }
1666 ev = samba_tevent_context_init(frame);
1667 if (ev == NULL) {
1668 goto fail;
1669 }
1670 req = cli_qpathinfo_basic_send(frame, ev, cli, name);
1671 if (req == NULL) {
1672 goto fail;
1673 }
1674 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
1675 goto fail;
1676 }
1677 status = cli_qpathinfo_basic_recv(req, sbuf, attributes);
1678 fail:
1679 TALLOC_FREE(frame);
1680 return status;
1681 }
1682
1683 /****************************************************************************
1684 Send a qpathinfo SMB_QUERY_FILE_ALT_NAME_INFO call.
1685 ****************************************************************************/
1686
1687 NTSTATUS cli_qpathinfo_alt_name(struct cli_state *cli, const char *fname, fstring alt_name)
1688 {
1689 uint8_t *rdata;
1690 uint32_t num_rdata;
1691 unsigned int len;
1692 char *converted = NULL;
1693 size_t converted_size = 0;
1694 NTSTATUS status;
1695
1696 status = cli_qpathinfo(talloc_tos(), cli, fname,
1697 SMB_QUERY_FILE_ALT_NAME_INFO,
1698 4, CLI_BUFFER_SIZE, &rdata, &num_rdata);
1699 if (!NT_STATUS_IS_OK(status)) {
1700 return status;
1701 }
1702
1703 len = IVAL(rdata, 0);
1704
1705 if (len > num_rdata - 4) {
1706 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1707 }
1708
1709 /* The returned data is a pushed string, not raw data. */
1710 if (!convert_string_talloc(talloc_tos(),
1711 smbXcli_conn_use_unicode(cli->conn) ? CH_UTF16LE : CH_DOS,
1712 CH_UNIX,
1713 rdata + 4,
1714 len,
1715 &converted,
1716 &converted_size)) {
1717 return NT_STATUS_NO_MEMORY;
1718 }
1719 fstrcpy(alt_name, converted);
1720
1721 TALLOC_FREE(converted);
1722 TALLOC_FREE(rdata);
1723
1724 return NT_STATUS_OK;
1725 }
1726
1727 /****************************************************************************
1728 Send a qpathinfo SMB_QUERY_FILE_STANDARD_INFO call.
1729 ****************************************************************************/
1730
1731 NTSTATUS cli_qpathinfo_standard(struct cli_state *cli, const char *fname,
1732 uint64_t *allocated, uint64_t *size,
1733 uint32_t *nlinks,
1734 bool *is_del_pending, bool *is_dir)
1735 {
1736 uint8_t *rdata;
1737 uint32_t num_rdata;
1738 NTSTATUS status;
1739
1740 if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
1741 return NT_STATUS_NOT_IMPLEMENTED;
1742 }
1743
1744 status = cli_qpathinfo(talloc_tos(), cli, fname,
1745 SMB_QUERY_FILE_STANDARD_INFO,
1746 24, CLI_BUFFER_SIZE, &rdata, &num_rdata);
1747 if (!NT_STATUS_IS_OK(status)) {
1748 return status;
1749 }
1750
1751 if (allocated) {
1752 *allocated = BVAL(rdata, 0);
1753 }
1754
1755 if (size) {
1756 *size = BVAL(rdata, 8);
1757 }
1758
1759 if (nlinks) {
1760 *nlinks = IVAL(rdata, 16);
1761 }
1762
1763 if (is_del_pending) {
1764 *is_del_pending = CVAL(rdata, 20);
1765 }
1766
1767 if (is_dir) {
1768 *is_dir = CVAL(rdata, 20);
1769 }
1770
1771 TALLOC_FREE(rdata);
1772
1773 return NT_STATUS_OK;
1774 }
1775
1776
1777 /* like cli_qpathinfo2 but do not use SMB_QUERY_FILE_ALL_INFO with smb1 */
1778 NTSTATUS cli_qpathinfo3(struct cli_state *cli, const char *fname,
1779 struct timespec *create_time,
1780 struct timespec *access_time,
1781 struct timespec *write_time,
1782 struct timespec *change_time,
1783 off_t *size, uint32_t *pattr,
1784 SMB_INO_T *ino)
1785 {
1786 NTSTATUS status = NT_STATUS_OK;
1787 SMB_STRUCT_STAT st = { 0 };
1788 uint32_t attr = 0;
1789 uint64_t pos;
1790
1791 if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
1792 /*
1793 * NB. cli_qpathinfo2() checks pattr is valid before
1794 * storing a value into it, so we don't need to use
1795 * an intermediate attr variable as below but can
1796 * pass pattr directly.
1797 */
1798 return cli_qpathinfo2(cli,
1799 fname,
1800 create_time,
1801 access_time,
1802 write_time,
1803 change_time,
1804 size,
1805 pattr,
1806 ino,
1807 NULL);
1808 }
1809
1810 if (create_time || access_time || write_time || change_time || pattr) {
1811 /*
1812 * cli_qpathinfo_basic() always indirects the passed
1813 * in pointers so we use intermediate variables to
1814 * collect all of them before assigning any requested
1815 * below.
1816 */
1817 status = cli_qpathinfo_basic(cli, fname, &st, &attr);
1818 if (!NT_STATUS_IS_OK(status)) {
1819 return status;
1820 }
1821 }
1822
1823 if (size) {
1824 status = cli_qpathinfo_standard(cli, fname,
1825 NULL, &pos, NULL, NULL, NULL);
1826 if (!NT_STATUS_IS_OK(status)) {
1827 return status;
1828 }
1829
1830 *size = pos;
1831 }
1832
1833 if (create_time) {
1834 *create_time = st.st_ex_btime;
1835 }
1836 if (access_time) {
1837 *access_time = st.st_ex_atime;
1838 }
1839 if (write_time) {
1840 *write_time = st.st_ex_mtime;
1841 }
1842 if (change_time) {
1843 *change_time = st.st_ex_ctime;
1844 }
1845 if (pattr) {
1846 *pattr = attr;
1847 }
1848 if (ino) {
1849 *ino = 0;
1850 }
1851
1852 return NT_STATUS_OK;
1853 }
Samba GIT mirror