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