2 Unix SMB/CIFS implementation.
4 Copyright (C) Andrew Tridgell 1994-1998
5 Copyright (C) Gerald (Jerry) Carter 2004
6 Copyright (C) James Peach 2007
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.
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.
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/>.
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"
32 #define PIPE_LANMAN "\\PIPE\\LANMAN"
34 /****************************************************************************
36 ****************************************************************************/
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
)
46 uint8_t *my_rparam
, *my_rdata
;
47 uint32_t num_my_rparam
, num_my_rdata
;
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
)) {
64 * I know this memcpy massively hurts, but there are just tons
65 * of callers of cli_api that eventually need changing to
69 *rparam
= (char *)memdup(my_rparam
, num_my_rparam
);
70 if (*rparam
== NULL
) {
73 *rprcnt
= num_my_rparam
;
74 TALLOC_FREE(my_rparam
);
76 *rdata
= (char *)memdup(my_rdata
, num_my_rdata
);
80 *rdrcnt
= num_my_rdata
;
81 TALLOC_FREE(my_rdata
);
85 TALLOC_FREE(my_rdata
);
86 TALLOC_FREE(my_rparam
);
94 /****************************************************************************
95 Perform a NetWkstaUserLogon.
96 ****************************************************************************/
98 bool cli_NetWkstaUserLogon(struct cli_state
*cli
,char *user
, char *workstation
)
103 unsigned int rdrcnt
,rprcnt
;
106 memset(param
, 0, sizeof(param
));
108 /* send a SMBtrans command with api NetWkstaUserLogon */
110 SSVAL(p
,0,132); /* api number */
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
);
118 strlcpy(p
,user
,sizeof(param
)-PTR_DIFF(p
,param
));
124 strlcpy(p
, workstation
,sizeof(param
)-PTR_DIFF(p
,param
));
127 SSVAL(p
, 0, CLI_BUFFER_SIZE
);
129 SSVAL(p
, 0, CLI_BUFFER_SIZE
);
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 */
138 cli
->rap_error
= rparam
? SVAL(rparam
,0) : -1;
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. */
147 DEBUG(1,("NetwkstaUserLogon gave error %d\n", cli
->rap_error
));
153 return (cli
->rap_error
== 0);
156 /****************************************************************************
157 Call a NetShareEnum - try and browse available connections on a host.
158 ****************************************************************************/
160 int cli_RNetShareEnum(struct cli_state
*cli
, void (*fn
)(const char *, uint32
, const char *, void *), void *state
)
165 unsigned int rdrcnt
,rprcnt
;
169 /* now send a SMBtrans command with api RNetShareEnum */
171 SSVAL(p
,0,0); /* api number */
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
);
179 * Win2k needs a *smaller* buffer than 0xFFFF here -
180 * it returns "out of server memory" with 0xFFFF !!! JRA.
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 */
191 int res
= rparam
? SVAL(rparam
,0) : -1;
193 if (res
== 0 || res
== ERRmoredata
) {
194 int converter
=SVAL(rparam
,2);
196 char *rdata_end
= rdata
+ rdrcnt
;
198 count
=SVAL(rparam
,4);
201 for (i
=0;i
<count
;i
++,p
+=20) {
209 TALLOC_CTX
*frame
= talloc_stackframe();
211 if (p
+ 20 > rdata_end
) {
218 comment_offset
= (IVAL(p
,16) & 0xFFFF) - converter
;
219 if (comment_offset
< 0 ||
220 comment_offset
> (int)rdrcnt
) {
224 cmnt
= comment_offset
?(rdata
+comment_offset
):"";
226 /* Work out the comment length. */
227 for (p1
= cmnt
, len
= 0; *p1
&&
228 p1
< rdata_end
; len
++)
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
);
242 fn(s1
, type
, s2
, state
);
247 DEBUG(4,("NetShareEnum res=%d\n", res
));
250 DEBUG(4,("NetShareEnum failed\n"));
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.
263 The callback function takes 4 arguments: the machine name, the server type,
264 the comment and a state pointer.
265 ****************************************************************************/
267 bool cli_NetServerEnum(struct cli_state
*cli
, char *workgroup
, uint32 stype
,
268 void (*fn
)(const char *, uint32
, const char *, void *),
273 char *rdata_end
= NULL
;
274 unsigned int rdrcnt
,rprcnt
;
279 uint32 func
= RAP_NetServerEnum2
;
280 char *last_entry
= NULL
;
285 errno
= 0; /* reset */
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
293 /* send a SMBtrans command with api NetServerEnum */
295 SIVAL(p
,0,func
); /* api number */
298 if (func
== RAP_NetServerEnum3
) {
299 strlcpy(p
,"WrLehDzz", sizeof(param
)-PTR_DIFF(p
,param
));
301 strlcpy(p
,"WrLehDz", sizeof(param
)-PTR_DIFF(p
,param
));
304 p
= skip_string(param
, sizeof(param
), p
);
305 strlcpy(p
,"B16BBDz", sizeof(param
)-PTR_DIFF(p
,param
));
307 p
= skip_string(param
, sizeof(param
), p
);
309 SSVAL(p
,2,CLI_BUFFER_SIZE
);
314 /* If we have more data, tell the server where
319 sizeof(param
) - PTR_DIFF(p
,param
) - 1,
320 STR_TERMINATE
|STR_UPPER
);
322 if (len
== (size_t)-1) {
323 SAFE_FREE(last_entry
);
328 if (func
== RAP_NetServerEnum3
) {
330 last_entry
? last_entry
: "",
331 sizeof(param
) - PTR_DIFF(p
,param
) - 1,
334 if (len
== (size_t)-1) {
335 SAFE_FREE(last_entry
);
341 /* Next time through we need to use the continue api */
342 func
= RAP_NetServerEnum3
;
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 */
350 /* break out of the loop on error */
355 rdata_end
= rdata
+ rdrcnt
;
356 res
= rparam
? SVAL(rparam
,0) : -1;
358 if (res
== 0 || res
== ERRmoredata
||
359 (res
!= -1 && cli_errno(cli
) == 0)) {
362 int converter
=SVAL(rparam
,2);
364 /* Get the number of items returned in this buffer */
365 count
= SVAL(rparam
, 4);
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
372 if (total_cnt
== 0) {
373 total_cnt
= SVAL(rparam
, 6);
376 /* Keep track of how many we have read */
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.
389 * NOTE: sv1_name field must be null terminated and has
390 * a max size of 16 (NetBIOS Name).
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 */
399 for (i
= 0; i
< count
; i
++, p
+= 26) {
404 TALLOC_CTX
*frame
= talloc_stackframe();
405 uint32_t entry_stype
;
407 if (p
+ 26 > rdata_end
) {
413 comment_offset
= (IVAL(p
,22) & 0xFFFF)-converter
;
414 cmnt
= comment_offset
?(rdata
+comment_offset
):"";
416 if (comment_offset
< 0 || comment_offset
>= (int)rdrcnt
) {
421 /* Work out the comment length. */
422 for (p1
= cmnt
, len
= 0; *p1
&&
423 p1
< rdata_end
; len
++)
429 entry_stype
= IVAL(p
,18) & ~SV_TYPE_LOCAL_LIST_ONLY
;
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
);
441 fn(s1
, entry_stype
, s2
, state
);
445 /* We are done with the old last entry, so now we can free it */
447 SAFE_FREE(last_entry
); /* This will set it to null */
450 /* We always make a copy of the last entry if we have one */
452 last_entry
= smb_xstrdup(sname
);
455 /* If we have more data, but no last entry then error out */
456 if (!last_entry
&& (res
== ERRmoredata
)) {
465 } while ((res
== ERRmoredata
) && (total_cnt
> return_cnt
));
469 SAFE_FREE(last_entry
);
472 errno
= cli_errno(cli
);
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
482 return(return_cnt
> 0);
485 /****************************************************************************
486 Send a SamOEMChangePassword command.
487 ****************************************************************************/
489 bool cli_oem_change_password(struct cli_state
*cli
, const char *user
, const char *new_password
,
490 const char *old_password
)
493 unsigned char data
[532];
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;
501 unsigned int rprcnt
, rdrcnt
;
503 if (strlen(user
) >= sizeof(fstring
)-1) {
504 DEBUG(0,("cli_oem_change_password: user name %s is too long.\n", user
));
508 SSVAL(p
,0,214); /* SamOEMChangePassword command. */
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
);
519 param_len
= PTR_DIFF(p
,param
);
522 * Get the Lanman hash of the old password, we
523 * use this as the key to make_oem_passwd_hash().
525 E_deshash(old_password
, old_pw_hash
);
527 encode_pw_buffer(data
, new_password
, STR_ASCII
);
529 #ifdef DEBUG_PASSWORD
530 DEBUG(100,("make_oem_passwd_hash\n"));
531 dump_data(100, data
, 516);
533 arcfour_crypt( (unsigned char *)data
, (unsigned char *)old_pw_hash
, 516);
536 * Now place the old password hash in the data.
538 E_deshash(new_password
, new_pw_hash
);
540 E_old_pw_hash( new_pw_hash
, old_pw_hash
, (uchar
*)&data
[516]);
545 param
, param_len
, 4, /* param, length, max */
546 (char *)data
, data_len
, 0, /* data, length, max */
549 DEBUG(0,("cli_oem_change_password: Failed to send password change for user %s\n",
555 cli
->rap_error
= SVAL(rparam
,0);
561 return (cli
->rap_error
== 0);
564 /****************************************************************************
565 Send a qpathinfo call.
566 ****************************************************************************/
568 struct cli_qpathinfo1_state
{
569 struct cli_state
*cli
;
574 static void cli_qpathinfo1_done(struct tevent_req
*subreq
);
576 struct tevent_req
*cli_qpathinfo1_send(TALLOC_CTX
*mem_ctx
,
577 struct event_context
*ev
,
578 struct cli_state
*cli
,
581 struct tevent_req
*req
= NULL
, *subreq
= NULL
;
582 struct cli_qpathinfo1_state
*state
= NULL
;
584 req
= tevent_req_create(mem_ctx
, &state
, struct cli_qpathinfo1_state
);
589 subreq
= cli_qpathinfo_send(state
, ev
, cli
, fname
, SMB_INFO_STANDARD
,
591 if (tevent_req_nomem(subreq
, req
)) {
592 return tevent_req_post(req
, ev
);
594 tevent_req_set_callback(subreq
, cli_qpathinfo1_done
, req
);
598 static void cli_qpathinfo1_done(struct tevent_req
*subreq
)
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
);
606 status
= cli_qpathinfo_recv(subreq
, state
, &state
->data
,
609 if (!NT_STATUS_IS_OK(status
)) {
610 tevent_req_nterror(req
, status
);
613 tevent_req_done(req
);
616 NTSTATUS
cli_qpathinfo1_recv(struct tevent_req
*req
,
623 struct cli_qpathinfo1_state
*state
= tevent_req_data(
624 req
, struct cli_qpathinfo1_state
);
627 time_t (*date_fn
)(const void *buf
, int serverzone
);
629 if (tevent_req_is_nterror(req
, &status
)) {
633 if (state
->cli
->win95
) {
634 date_fn
= make_unix_date
;
636 date_fn
= make_unix_date2
;
640 *change_time
= date_fn(state
->data
+0, state
->cli
->serverzone
);
643 *access_time
= date_fn(state
->data
+4, state
->cli
->serverzone
);
646 *write_time
= date_fn(state
->data
+8, state
->cli
->serverzone
);
649 *size
= IVAL(state
->data
, 12);
652 *mode
= SVAL(state
->data
, l1_attrFile
);
657 NTSTATUS
cli_qpathinfo1(struct cli_state
*cli
,
665 TALLOC_CTX
*frame
= talloc_stackframe();
666 struct event_context
*ev
;
667 struct tevent_req
*req
;
668 NTSTATUS status
= NT_STATUS_NO_MEMORY
;
670 if (cli_has_async_calls(cli
)) {
672 * Can't use sync call while an async call is in flight
674 status
= NT_STATUS_INVALID_PARAMETER
;
677 ev
= event_context_init(frame
);
681 req
= cli_qpathinfo1_send(frame
, ev
, cli
, fname
);
685 if (!tevent_req_poll_ntstatus(req
, ev
, &status
)) {
688 status
= cli_qpathinfo1_recv(req
, change_time
, access_time
,
689 write_time
, size
, mode
);
695 /****************************************************************************
696 Send a setpathinfo call.
697 ****************************************************************************/
699 NTSTATUS
cli_setpathinfo_basic(struct cli_state
*cli
, const char *fname
,
706 unsigned int data_len
= 0;
713 * Add the create, last access, modification, and status change times
715 put_long_date(p
, create_time
);
718 put_long_date(p
, access_time
);
721 put_long_date(p
, write_time
);
724 put_long_date(p
, change_time
);
735 data_len
= PTR_DIFF(p
, data
);
737 return cli_setpathinfo(cli
, SMB_FILE_BASIC_INFORMATION
, fname
,
738 (uint8_t *)data
, data_len
);
741 /****************************************************************************
742 Send a qpathinfo call with the SMB_QUERY_FILE_ALL_INFO info level.
743 ****************************************************************************/
745 struct cli_qpathinfo2_state
{
750 static void cli_qpathinfo2_done(struct tevent_req
*subreq
);
752 struct tevent_req
*cli_qpathinfo2_send(TALLOC_CTX
*mem_ctx
,
753 struct event_context
*ev
,
754 struct cli_state
*cli
,
757 struct tevent_req
*req
= NULL
, *subreq
= NULL
;
758 struct cli_qpathinfo2_state
*state
= NULL
;
760 req
= tevent_req_create(mem_ctx
, &state
, struct cli_qpathinfo2_state
);
764 subreq
= cli_qpathinfo_send(state
, ev
, cli
, fname
,
765 SMB_QUERY_FILE_ALL_INFO
,
767 if (tevent_req_nomem(subreq
, req
)) {
768 return tevent_req_post(req
, ev
);
770 tevent_req_set_callback(subreq
, cli_qpathinfo2_done
, req
);
774 static void cli_qpathinfo2_done(struct tevent_req
*subreq
)
776 struct tevent_req
*req
= tevent_req_callback_data(
777 subreq
, struct tevent_req
);
778 struct cli_qpathinfo2_state
*state
= tevent_req_data(
779 req
, struct cli_qpathinfo2_state
);
782 status
= cli_qpathinfo_recv(subreq
, state
, &state
->data
,
785 if (!NT_STATUS_IS_OK(status
)) {
786 tevent_req_nterror(req
, status
);
789 tevent_req_done(req
);
792 NTSTATUS
cli_qpathinfo2_recv(struct tevent_req
*req
,
793 struct timespec
*create_time
,
794 struct timespec
*access_time
,
795 struct timespec
*write_time
,
796 struct timespec
*change_time
,
797 SMB_OFF_T
*size
, uint16
*mode
,
800 struct cli_qpathinfo2_state
*state
= tevent_req_data(
801 req
, struct cli_qpathinfo2_state
);
804 if (tevent_req_is_nterror(req
, &status
)) {
809 *create_time
= interpret_long_date((char *)state
->data
+0);
812 *access_time
= interpret_long_date((char *)state
->data
+8);
815 *write_time
= interpret_long_date((char *)state
->data
+16);
818 *change_time
= interpret_long_date((char *)state
->data
+24);
821 *mode
= SVAL(state
->data
, 32);
824 *size
= IVAL2_TO_SMB_BIG_UINT(state
->data
,48);
827 *ino
= IVAL(state
->data
, 64);
832 NTSTATUS
cli_qpathinfo2(struct cli_state
*cli
, const char *fname
,
833 struct timespec
*create_time
,
834 struct timespec
*access_time
,
835 struct timespec
*write_time
,
836 struct timespec
*change_time
,
837 SMB_OFF_T
*size
, uint16
*mode
,
840 TALLOC_CTX
*frame
= talloc_stackframe();
841 struct event_context
*ev
;
842 struct tevent_req
*req
;
843 NTSTATUS status
= NT_STATUS_NO_MEMORY
;
845 if (cli_has_async_calls(cli
)) {
847 * Can't use sync call while an async call is in flight
849 status
= NT_STATUS_INVALID_PARAMETER
;
852 ev
= event_context_init(frame
);
856 req
= cli_qpathinfo2_send(frame
, ev
, cli
, fname
);
860 if (!tevent_req_poll_ntstatus(req
, ev
, &status
)) {
863 status
= cli_qpathinfo2_recv(req
, create_time
, access_time
,
864 write_time
, change_time
, size
, mode
, ino
);
870 /****************************************************************************
872 ****************************************************************************/
874 static bool parse_streams_blob(TALLOC_CTX
*mem_ctx
, const uint8_t *data
,
876 unsigned int *pnum_streams
,
877 struct stream_struct
**pstreams
);
879 struct cli_qpathinfo_streams_state
{
884 static void cli_qpathinfo_streams_done(struct tevent_req
*subreq
);
886 struct tevent_req
*cli_qpathinfo_streams_send(TALLOC_CTX
*mem_ctx
,
887 struct tevent_context
*ev
,
888 struct cli_state
*cli
,
891 struct tevent_req
*req
= NULL
, *subreq
= NULL
;
892 struct cli_qpathinfo_streams_state
*state
= NULL
;
894 req
= tevent_req_create(mem_ctx
, &state
,
895 struct cli_qpathinfo_streams_state
);
899 subreq
= cli_qpathinfo_send(state
, ev
, cli
, fname
,
900 SMB_FILE_STREAM_INFORMATION
,
902 if (tevent_req_nomem(subreq
, req
)) {
903 return tevent_req_post(req
, ev
);
905 tevent_req_set_callback(subreq
, cli_qpathinfo_streams_done
, req
);
909 static void cli_qpathinfo_streams_done(struct tevent_req
*subreq
)
911 struct tevent_req
*req
= tevent_req_callback_data(
912 subreq
, struct tevent_req
);
913 struct cli_qpathinfo_streams_state
*state
= tevent_req_data(
914 req
, struct cli_qpathinfo_streams_state
);
917 status
= cli_qpathinfo_recv(subreq
, state
, &state
->data
,
920 if (!NT_STATUS_IS_OK(status
)) {
921 tevent_req_nterror(req
, status
);
924 tevent_req_done(req
);
927 NTSTATUS
cli_qpathinfo_streams_recv(struct tevent_req
*req
,
929 unsigned int *pnum_streams
,
930 struct stream_struct
**pstreams
)
932 struct cli_qpathinfo_streams_state
*state
= tevent_req_data(
933 req
, struct cli_qpathinfo_streams_state
);
936 if (tevent_req_is_nterror(req
, &status
)) {
939 if (!parse_streams_blob(mem_ctx
, state
->data
, state
->num_data
,
940 pnum_streams
, pstreams
)) {
941 return NT_STATUS_INVALID_NETWORK_RESPONSE
;
946 NTSTATUS
cli_qpathinfo_streams(struct cli_state
*cli
, const char *fname
,
948 unsigned int *pnum_streams
,
949 struct stream_struct
**pstreams
)
951 TALLOC_CTX
*frame
= talloc_stackframe();
952 struct event_context
*ev
;
953 struct tevent_req
*req
;
954 NTSTATUS status
= NT_STATUS_NO_MEMORY
;
956 if (cli_has_async_calls(cli
)) {
958 * Can't use sync call while an async call is in flight
960 status
= NT_STATUS_INVALID_PARAMETER
;
963 ev
= event_context_init(frame
);
967 req
= cli_qpathinfo_streams_send(frame
, ev
, cli
, fname
);
971 if (!tevent_req_poll_ntstatus(req
, ev
, &status
)) {
974 status
= cli_qpathinfo_streams_recv(req
, mem_ctx
, pnum_streams
,
981 static bool parse_streams_blob(TALLOC_CTX
*mem_ctx
, const uint8_t *rdata
,
983 unsigned int *pnum_streams
,
984 struct stream_struct
**pstreams
)
986 unsigned int num_streams
;
987 struct stream_struct
*streams
;
994 while ((data_len
> ofs
) && (data_len
- ofs
>= 24)) {
998 struct stream_struct
*tmp
;
1001 tmp
= TALLOC_REALLOC_ARRAY(mem_ctx
, streams
,
1002 struct stream_struct
,
1010 nlen
= IVAL(rdata
, ofs
+ 0x04);
1012 streams
[num_streams
].size
= IVAL_TO_SMB_OFF_T(
1014 streams
[num_streams
].alloc_size
= IVAL_TO_SMB_OFF_T(
1017 if (nlen
> data_len
- (ofs
+ 24)) {
1022 * We need to null-terminate src, how do I do this with
1023 * convert_string_talloc??
1026 tmp_buf
= TALLOC_ARRAY(streams
, uint8_t, nlen
+2);
1027 if (tmp_buf
== NULL
) {
1031 memcpy(tmp_buf
, rdata
+ofs
+24, nlen
);
1033 tmp_buf
[nlen
+1] = 0;
1035 if (!convert_string_talloc(streams
, CH_UTF16
, CH_UNIX
, tmp_buf
,
1036 nlen
+2, &vstr
, &size
, false))
1038 TALLOC_FREE(tmp_buf
);
1042 TALLOC_FREE(tmp_buf
);
1043 streams
[num_streams
].name
= (char *)vstr
;
1046 len
= IVAL(rdata
, ofs
);
1047 if (len
> data_len
- ofs
) {
1050 if (len
== 0) break;
1054 *pnum_streams
= num_streams
;
1055 *pstreams
= streams
;
1059 TALLOC_FREE(streams
);
1063 /****************************************************************************
1064 Send a qfileinfo QUERY_FILE_NAME_INFO call.
1065 ****************************************************************************/
1067 NTSTATUS
cli_qfilename(struct cli_state
*cli
, uint16_t fnum
, char *name
,
1074 status
= cli_qfileinfo(talloc_tos(), cli
, fnum
,
1075 SMB_QUERY_FILE_NAME_INFO
,
1077 &rdata
, &num_rdata
);
1078 if (!NT_STATUS_IS_OK(status
)) {
1082 clistr_pull(cli
->inbuf
, name
, rdata
+4, namelen
, IVAL(rdata
, 0),
1085 return NT_STATUS_OK
;
1088 /****************************************************************************
1089 Send a qfileinfo call.
1090 ****************************************************************************/
1092 NTSTATUS
cli_qfileinfo_basic(struct cli_state
*cli
, uint16_t fnum
,
1093 uint16
*mode
, SMB_OFF_T
*size
,
1094 struct timespec
*create_time
,
1095 struct timespec
*access_time
,
1096 struct timespec
*write_time
,
1097 struct timespec
*change_time
,
1104 /* if its a win95 server then fail this - win95 totally screws it
1107 return NT_STATUS_NOT_SUPPORTED
;
1110 status
= cli_qfileinfo(talloc_tos(), cli
, fnum
,
1111 SMB_QUERY_FILE_ALL_INFO
,
1112 68, MIN(cli
->max_xmit
, 0xffff),
1113 &rdata
, &num_rdata
);
1114 if (!NT_STATUS_IS_OK(status
)) {
1119 *create_time
= interpret_long_date((char *)rdata
+0);
1122 *access_time
= interpret_long_date((char *)rdata
+8);
1125 *write_time
= interpret_long_date((char *)rdata
+16);
1128 *change_time
= interpret_long_date((char *)rdata
+24);
1131 *mode
= SVAL(rdata
, 32);
1134 *size
= IVAL2_TO_SMB_BIG_UINT(rdata
,48);
1137 *ino
= IVAL(rdata
, 64);
1141 return NT_STATUS_OK
;
1144 /****************************************************************************
1145 Send a qpathinfo BASIC_INFO call.
1146 ****************************************************************************/
1148 struct cli_qpathinfo_basic_state
{
1153 static void cli_qpathinfo_basic_done(struct tevent_req
*subreq
);
1155 struct tevent_req
*cli_qpathinfo_basic_send(TALLOC_CTX
*mem_ctx
,
1156 struct event_context
*ev
,
1157 struct cli_state
*cli
,
1160 struct tevent_req
*req
= NULL
, *subreq
= NULL
;
1161 struct cli_qpathinfo_basic_state
*state
= NULL
;
1163 req
= tevent_req_create(mem_ctx
, &state
,
1164 struct cli_qpathinfo_basic_state
);
1168 subreq
= cli_qpathinfo_send(state
, ev
, cli
, fname
,
1169 SMB_QUERY_FILE_BASIC_INFO
,
1171 if (tevent_req_nomem(subreq
, req
)) {
1172 return tevent_req_post(req
, ev
);
1174 tevent_req_set_callback(subreq
, cli_qpathinfo_basic_done
, req
);
1178 static void cli_qpathinfo_basic_done(struct tevent_req
*subreq
)
1180 struct tevent_req
*req
= tevent_req_callback_data(
1181 subreq
, struct tevent_req
);
1182 struct cli_qpathinfo_basic_state
*state
= tevent_req_data(
1183 req
, struct cli_qpathinfo_basic_state
);
1186 status
= cli_qpathinfo_recv(subreq
, state
, &state
->data
,
1188 TALLOC_FREE(subreq
);
1189 if (!NT_STATUS_IS_OK(status
)) {
1190 tevent_req_nterror(req
, status
);
1193 tevent_req_done(req
);
1196 NTSTATUS
cli_qpathinfo_basic_recv(struct tevent_req
*req
,
1197 SMB_STRUCT_STAT
*sbuf
, uint32
*attributes
)
1199 struct cli_qpathinfo_basic_state
*state
= tevent_req_data(
1200 req
, struct cli_qpathinfo_basic_state
);
1203 if (tevent_req_is_nterror(req
, &status
)) {
1207 sbuf
->st_ex_atime
= interpret_long_date((char *)state
->data
+8);
1208 sbuf
->st_ex_mtime
= interpret_long_date((char *)state
->data
+16);
1209 sbuf
->st_ex_ctime
= interpret_long_date((char *)state
->data
+24);
1210 *attributes
= IVAL(state
->data
, 32);
1211 return NT_STATUS_OK
;
1214 NTSTATUS
cli_qpathinfo_basic(struct cli_state
*cli
, const char *name
,
1215 SMB_STRUCT_STAT
*sbuf
, uint32
*attributes
)
1217 TALLOC_CTX
*frame
= talloc_stackframe();
1218 struct event_context
*ev
;
1219 struct tevent_req
*req
;
1220 NTSTATUS status
= NT_STATUS_NO_MEMORY
;
1222 if (cli_has_async_calls(cli
)) {
1224 * Can't use sync call while an async call is in flight
1226 status
= NT_STATUS_INVALID_PARAMETER
;
1229 ev
= event_context_init(frame
);
1233 req
= cli_qpathinfo_basic_send(frame
, ev
, cli
, name
);
1237 if (!tevent_req_poll_ntstatus(req
, ev
, &status
)) {
1240 status
= cli_qpathinfo_basic_recv(req
, sbuf
, attributes
);
1246 /****************************************************************************
1247 Send a qpathinfo SMB_QUERY_FILE_ALT_NAME_INFO call.
1248 ****************************************************************************/
1250 NTSTATUS
cli_qpathinfo_alt_name(struct cli_state
*cli
, const char *fname
, fstring alt_name
)
1255 char *converted
= NULL
;
1256 size_t converted_size
= 0;
1259 status
= cli_qpathinfo(talloc_tos(), cli
, fname
,
1260 SMB_QUERY_FILE_ALT_NAME_INFO
,
1261 4, cli
->max_xmit
, &rdata
, &num_rdata
);
1262 if (!NT_STATUS_IS_OK(status
)) {
1266 len
= IVAL(rdata
, 0);
1268 if (len
> num_rdata
- 4) {
1269 return NT_STATUS_INVALID_NETWORK_RESPONSE
;
1272 /* The returned data is a pushed string, not raw data. */
1273 if (!convert_string_talloc(talloc_tos(),
1274 cli_ucs2(cli
) ? CH_UTF16LE
: CH_DOS
,
1281 return NT_STATUS_NO_MEMORY
;
1283 fstrcpy(alt_name
, converted
);
1285 TALLOC_FREE(converted
);
1288 return NT_STATUS_OK
;