?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Apply some const
[Samba/gebeck_regimport.git] / source / libsmb / clirap.c
blob98066629d184c5be1ba57b8c37b97519610233e3
1 /*
2 Unix SMB/CIFS implementation.
3 client RAP calls
4 Copyright (C) Andrew Tridgell 1994-1998
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21 #define NO_SYSLOG
22
23 #include "includes.h"
24
25
26 /****************************************************************************
27 Call a remote api on an arbitrary pipe. takes param, data and setup buffers.
28 ****************************************************************************/
29 BOOL cli_api_pipe(struct cli_state *cli, const char *pipe_name,
30 uint16 *setup, uint32 setup_count, uint32 max_setup_count,
31 char *params, uint32 param_count, uint32 max_param_count,
32 char *data, uint32 data_count, uint32 max_data_count,
33 char **rparam, uint32 *rparam_count,
34 char **rdata, uint32 *rdata_count)
35 {
36 cli_send_trans(cli, SMBtrans,
37 pipe_name,
38 0,0, /* fid, flags */
39 setup, setup_count, max_setup_count,
40 params, param_count, max_param_count,
41 data, data_count, max_data_count);
42
43 return (cli_receive_trans(cli, SMBtrans,
44 rparam, (unsigned int *)rparam_count,
45 rdata, (unsigned int *)rdata_count));
46 }
47
48 /****************************************************************************
49 call a remote api
50 ****************************************************************************/
51 BOOL cli_api(struct cli_state *cli,
52 char *param, int prcnt, int mprcnt,
53 char *data, int drcnt, int mdrcnt,
54 char **rparam, unsigned int *rprcnt,
55 char **rdata, unsigned int *rdrcnt)
56 {
57 cli_send_trans(cli,SMBtrans,
58 PIPE_LANMAN, /* Name */
59 0,0, /* fid, flags */
60 NULL,0,0, /* Setup, length, max */
61 param, prcnt, mprcnt, /* Params, length, max */
62 data, drcnt, mdrcnt /* Data, length, max */
63 );
64
65 return (cli_receive_trans(cli,SMBtrans,
66 rparam, rprcnt,
67 rdata, rdrcnt));
68 }
69
70
71 /****************************************************************************
72 perform a NetWkstaUserLogon
73 ****************************************************************************/
74 BOOL cli_NetWkstaUserLogon(struct cli_state *cli,char *user, char *workstation)
75 {
76 char *rparam = NULL;
77 char *rdata = NULL;
78 char *p;
79 unsigned int rdrcnt,rprcnt;
80 pstring param;
81
82 memset(param, 0, sizeof(param));
83
84 /* send a SMBtrans command with api NetWkstaUserLogon */
85 p = param;
86 SSVAL(p,0,132); /* api number */
87 p += 2;
88 pstrcpy_base(p,"OOWb54WrLh",param);
89 p = skip_string(p,1);
90 pstrcpy_base(p,"WB21BWDWWDDDDDDDzzzD",param);
91 p = skip_string(p,1);
92 SSVAL(p,0,1);
93 p += 2;
94 pstrcpy_base(p,user,param);
95 strupper_m(p);
96 p += 21;
97 p++;
98 p += 15;
99 p++;
100 pstrcpy_base(p, workstation, param);
101 strupper_m(p);
102 p += 16;
103 SSVAL(p, 0, CLI_BUFFER_SIZE);
104 p += 2;
105 SSVAL(p, 0, CLI_BUFFER_SIZE);
106 p += 2;
107
108 if (cli_api(cli,
109 param, PTR_DIFF(p,param),1024, /* param, length, max */
110 NULL, 0, CLI_BUFFER_SIZE, /* data, length, max */
111 &rparam, &rprcnt, /* return params, return size */
112 &rdata, &rdrcnt /* return data, return size */
113 )) {
114 cli->rap_error = rparam? SVAL(rparam,0) : -1;
115 p = rdata;
116
117 if (cli->rap_error == 0) {
118 DEBUG(4,("NetWkstaUserLogon success\n"));
119 cli->privileges = SVAL(p, 24);
120 /* The cli->eff_name field used to be set here
121 but it wasn't used anywhere else. */
122 } else {
123 DEBUG(1,("NetwkstaUserLogon gave error %d\n", cli->rap_error));
124 }
125 }
126
127 SAFE_FREE(rparam);
128 SAFE_FREE(rdata);
129 return (cli->rap_error == 0);
130 }
131
132 /****************************************************************************
133 call a NetShareEnum - try and browse available connections on a host
134 ****************************************************************************/
135 int cli_RNetShareEnum(struct cli_state *cli, void (*fn)(const char *, uint32, const char *, void *), void *state)
136 {
137 char *rparam = NULL;
138 char *rdata = NULL;
139 char *p;
140 unsigned int rdrcnt,rprcnt;
141 pstring param;
142 int count = -1;
143
144 /* now send a SMBtrans command with api RNetShareEnum */
145 p = param;
146 SSVAL(p,0,0); /* api number */
147 p += 2;
148 pstrcpy_base(p,"WrLeh",param);
149 p = skip_string(p,1);
150 pstrcpy_base(p,"B13BWz",param);
151 p = skip_string(p,1);
152 SSVAL(p,0,1);
153 /*
154 * Win2k needs a *smaller* buffer than 0xFFFF here -
155 * it returns "out of server memory" with 0xFFFF !!! JRA.
156 */
157 SSVAL(p,2,0xFFE0);
158 p += 4;
159
160 if (cli_api(cli,
161 param, PTR_DIFF(p,param), 1024, /* Param, length, maxlen */
162 NULL, 0, 0xFFE0, /* data, length, maxlen - Win2k needs a small buffer here too ! */
163 &rparam, &rprcnt, /* return params, length */
164 &rdata, &rdrcnt)) /* return data, length */
165 {
166 int res = rparam? SVAL(rparam,0) : -1;
167
168 if (res == 0 || res == ERRmoredata) {
169 int converter=SVAL(rparam,2);
170 int i;
171
172 count=SVAL(rparam,4);
173 p = rdata;
174
175 for (i=0;i<count;i++,p+=20) {
176 char *sname = p;
177 int type = SVAL(p,14);
178 int comment_offset = IVAL(p,16) & 0xFFFF;
179 const char *cmnt = comment_offset?(rdata+comment_offset-converter):"";
180 pstring s1, s2;
181
182 pull_ascii_pstring(s1, sname);
183 pull_ascii_pstring(s2, cmnt);
184
185 fn(s1, type, s2, state);
186 }
187 } else {
188 DEBUG(4,("NetShareEnum res=%d\n", res));
189 }
190 } else {
191 DEBUG(4,("NetShareEnum failed\n"));
192 }
193
194 SAFE_FREE(rparam);
195 SAFE_FREE(rdata);
196
197 return count;
198 }
199
200
201 /****************************************************************************
202 call a NetServerEnum for the specified workgroup and servertype mask. This
203 function then calls the specified callback function for each name returned.
204
205 The callback function takes 4 arguments: the machine name, the server type,
206 the comment and a state pointer.
207 ****************************************************************************/
208 BOOL cli_NetServerEnum(struct cli_state *cli, char *workgroup, uint32 stype,
209 void (*fn)(const char *, uint32, const char *,
210 const void *),
211 const void *state)
212 {
213 char *rparam = NULL;
214 char *rdata = NULL;
215 unsigned int rdrcnt,rprcnt;
216 char *p;
217 pstring param;
218 int uLevel = 1;
219 int count = -1;
220
221 /* send a SMBtrans command with api NetServerEnum */
222 p = param;
223 SSVAL(p,0,0x68); /* api number */
224 p += 2;
225 pstrcpy_base(p,"WrLehDz", param);
226 p = skip_string(p,1);
227
228 pstrcpy_base(p,"B16BBDz", param);
229
230 p = skip_string(p,1);
231 SSVAL(p,0,uLevel);
232 SSVAL(p,2,CLI_BUFFER_SIZE);
233 p += 4;
234 SIVAL(p,0,stype);
235 p += 4;
236
237 p += push_ascii(p, workgroup, sizeof(pstring)-PTR_DIFF(p,param)-1, STR_TERMINATE|STR_UPPER);
238
239 if (cli_api(cli,
240 param, PTR_DIFF(p,param), 8, /* params, length, max */
241 NULL, 0, CLI_BUFFER_SIZE, /* data, length, max */
242 &rparam, &rprcnt, /* return params, return size */
243 &rdata, &rdrcnt /* return data, return size */
244 )) {
245 int res = rparam? SVAL(rparam,0) : -1;
246
247 if (res == 0 || res == ERRmoredata) {
248 int i;
249 int converter=SVAL(rparam,2);
250
251 count=SVAL(rparam,4);
252 p = rdata;
253
254 for (i = 0;i < count;i++, p += 26) {
255 char *sname = p;
256 int comment_offset = (IVAL(p,22) & 0xFFFF)-converter;
257 const char *cmnt = comment_offset?(rdata+comment_offset):"";
258 pstring s1, s2;
259
260 if (comment_offset < 0 || comment_offset > (int)rdrcnt) continue;
261
262 stype = IVAL(p,18) & ~SV_TYPE_LOCAL_LIST_ONLY;
263
264 pull_ascii_pstring(s1, sname);
265 pull_ascii_pstring(s2, cmnt);
266 fn(s1, stype, s2, state);
267 }
268 }
269 }
270
271 SAFE_FREE(rparam);
272 SAFE_FREE(rdata);
273
274 return(count > 0);
275 }
276
277
278
279 /****************************************************************************
280 Send a SamOEMChangePassword command
281 ****************************************************************************/
282 BOOL cli_oem_change_password(struct cli_state *cli, const char *user, const char *new_password,
283 const char *old_password)
284 {
285 pstring param;
286 char data[532];
287 char *p = param;
288 unsigned char old_pw_hash[16];
289 unsigned char new_pw_hash[16];
290 unsigned int data_len;
291 unsigned int param_len = 0;
292 char *rparam = NULL;
293 char *rdata = NULL;
294 unsigned int rprcnt, rdrcnt;
295
296 if (strlen(user) >= sizeof(fstring)-1) {
297 DEBUG(0,("cli_oem_change_password: user name %s is too long.\n", user));
298 return False;
299 }
300
301 SSVAL(p,0,214); /* SamOEMChangePassword command. */
302 p += 2;
303 pstrcpy_base(p, "zsT", param);
304 p = skip_string(p,1);
305 pstrcpy_base(p, "B516B16", param);
306 p = skip_string(p,1);
307 pstrcpy_base(p,user, param);
308 p = skip_string(p,1);
309 SSVAL(p,0,532);
310 p += 2;
311
312 param_len = PTR_DIFF(p,param);
313
314 /*
315 * Get the Lanman hash of the old password, we
316 * use this as the key to make_oem_passwd_hash().
317 */
318 E_deshash(old_password, old_pw_hash);
319
320 encode_pw_buffer(data, new_password, STR_ASCII);
321
322 #ifdef DEBUG_PASSWORD
323 DEBUG(100,("make_oem_passwd_hash\n"));
324 dump_data(100, data, 516);
325 #endif
326 SamOEMhash( (unsigned char *)data, (unsigned char *)old_pw_hash, 516);
327
328 /*
329 * Now place the old password hash in the data.
330 */
331 E_deshash(new_password, new_pw_hash);
332
333 E_old_pw_hash( new_pw_hash, old_pw_hash, (uchar *)&data[516]);
334
335 data_len = 532;
336
337 if (cli_send_trans(cli,SMBtrans,
338 PIPE_LANMAN, /* name */
339 0,0, /* fid, flags */
340 NULL,0,0, /* setup, length, max */
341 param,param_len,2, /* param, length, max */
342 data,data_len,0 /* data, length, max */
343 ) == False) {
344 DEBUG(0,("cli_oem_change_password: Failed to send password change for user %s\n",
345 user ));
346 return False;
347 }
348
349 if (!cli_receive_trans(cli,SMBtrans,
350 &rparam, &rprcnt,
351 &rdata, &rdrcnt)) {
352 DEBUG(0,("cli_oem_change_password: Failed to recieve reply to password change for user %s\n",
353 user ));
354 return False;
355 }
356
357 if (rparam)
358 cli->rap_error = SVAL(rparam,0);
359
360 SAFE_FREE(rparam);
361 SAFE_FREE(rdata);
362
363 return (cli->rap_error == 0);
364 }
365
366
367 /****************************************************************************
368 send a qpathinfo call
369 ****************************************************************************/
370 BOOL cli_qpathinfo(struct cli_state *cli, const char *fname,
371 time_t *c_time, time_t *a_time, time_t *m_time,
372 size_t *size, uint16 *mode)
373 {
374 unsigned int data_len = 0;
375 unsigned int param_len = 0;
376 unsigned int rparam_len, rdata_len;
377 uint16 setup = TRANSACT2_QPATHINFO;
378 pstring param;
379 char *rparam=NULL, *rdata=NULL;
380 int count=8;
381 BOOL ret;
382 time_t (*date_fn)(void *);
383 char *p;
384
385 p = param;
386 memset(p, 0, 6);
387 SSVAL(p, 0, SMB_INFO_STANDARD);
388 p += 6;
389 p += clistr_push(cli, p, fname, sizeof(pstring)-6, STR_TERMINATE);
390
391 param_len = PTR_DIFF(p, param);
392
393 do {
394 ret = (cli_send_trans(cli, SMBtrans2,
395 NULL, /* Name */
396 -1, 0, /* fid, flags */
397 &setup, 1, 0, /* setup, length, max */
398 param, param_len, 10, /* param, length, max */
399 NULL, data_len, cli->max_xmit /* data, length, max */
400 ) &&
401 cli_receive_trans(cli, SMBtrans2,
402 &rparam, &rparam_len,
403 &rdata, &rdata_len));
404 if (!cli_is_dos_error(cli)) break;
405 if (!ret) {
406 /* we need to work around a Win95 bug - sometimes
407 it gives ERRSRV/ERRerror temprarily */
408 uint8 eclass;
409 uint32 ecode;
410 cli_dos_error(cli, &eclass, &ecode);
411 if (eclass != ERRSRV || ecode != ERRerror) break;
412 smb_msleep(100);
413 }
414 } while (count-- && ret==False);
415
416 if (!ret || !rdata || rdata_len < 22) {
417 return False;
418 }
419
420 if (cli->win95) {
421 date_fn = make_unix_date;
422 } else {
423 date_fn = make_unix_date2;
424 }
425
426 if (c_time) {
427 *c_time = date_fn(rdata+0);
428 }
429 if (a_time) {
430 *a_time = date_fn(rdata+4);
431 }
432 if (m_time) {
433 *m_time = date_fn(rdata+8);
434 }
435 if (size) {
436 *size = IVAL(rdata, 12);
437 }
438 if (mode) {
439 *mode = SVAL(rdata,l1_attrFile);
440 }
441
442 SAFE_FREE(rdata);
443 SAFE_FREE(rparam);
444 return True;
445 }
446
447 /****************************************************************************
448 send a qpathinfo call with the SMB_QUERY_FILE_ALL_INFO info level
449 ****************************************************************************/
450 BOOL cli_qpathinfo2(struct cli_state *cli, const char *fname,
451 time_t *c_time, time_t *a_time, time_t *m_time,
452 time_t *w_time, size_t *size, uint16 *mode,
453 SMB_INO_T *ino)
454 {
455 unsigned int data_len = 0;
456 unsigned int param_len = 0;
457 uint16 setup = TRANSACT2_QPATHINFO;
458 pstring param;
459 char *rparam=NULL, *rdata=NULL;
460 char *p;
461
462 p = param;
463 memset(p, 0, 6);
464 SSVAL(p, 0, SMB_QUERY_FILE_ALL_INFO);
465 p += 6;
466 p += clistr_push(cli, p, fname, sizeof(pstring)-6, STR_TERMINATE);
467
468 param_len = PTR_DIFF(p, param);
469
470 if (!cli_send_trans(cli, SMBtrans2,
471 NULL, /* name */
472 -1, 0, /* fid, flags */
473 &setup, 1, 0, /* setup, length, max */
474 param, param_len, 10, /* param, length, max */
475 NULL, data_len, cli->max_xmit /* data, length, max */
476 )) {
477 return False;
478 }
479
480 if (!cli_receive_trans(cli, SMBtrans2,
481 &rparam, &param_len,
482 &rdata, &data_len)) {
483 return False;
484 }
485
486 if (!rdata || data_len < 22) {
487 return False;
488 }
489
490 if (c_time) {
491 *c_time = interpret_long_date(rdata+0) - cli->serverzone;
492 }
493 if (a_time) {
494 *a_time = interpret_long_date(rdata+8) - cli->serverzone;
495 }
496 if (m_time) {
497 *m_time = interpret_long_date(rdata+16) - cli->serverzone;
498 }
499 if (w_time) {
500 *w_time = interpret_long_date(rdata+24) - cli->serverzone;
501 }
502 if (mode) {
503 *mode = SVAL(rdata, 32);
504 }
505 if (size) {
506 *size = IVAL(rdata, 48);
507 }
508 if (ino) {
509 *ino = IVAL(rdata, 64);
510 }
511
512 SAFE_FREE(rdata);
513 SAFE_FREE(rparam);
514 return True;
515 }
516
517
518 /****************************************************************************
519 send a qfileinfo QUERY_FILE_NAME_INFO call
520 ****************************************************************************/
521 BOOL cli_qfilename(struct cli_state *cli, int fnum,
522 pstring name)
523 {
524 unsigned int data_len = 0;
525 unsigned int param_len = 0;
526 uint16 setup = TRANSACT2_QFILEINFO;
527 pstring param;
528 char *rparam=NULL, *rdata=NULL;
529
530 param_len = 4;
531 memset(param, 0, param_len);
532 SSVAL(param, 0, fnum);
533 SSVAL(param, 2, SMB_QUERY_FILE_NAME_INFO);
534
535 if (!cli_send_trans(cli, SMBtrans2,
536 NULL, /* name */
537 -1, 0, /* fid, flags */
538 &setup, 1, 0, /* setup, length, max */
539 param, param_len, 2, /* param, length, max */
540 NULL, data_len, cli->max_xmit /* data, length, max */
541 )) {
542 return False;
543 }
544
545 if (!cli_receive_trans(cli, SMBtrans2,
546 &rparam, &param_len,
547 &rdata, &data_len)) {
548 return False;
549 }
550
551 if (!rdata || data_len < 4) {
552 return False;
553 }
554
555 clistr_pull(cli, name, rdata+4, sizeof(pstring), IVAL(rdata, 0), STR_UNICODE);
556
557 return True;
558 }
559
560
561 /****************************************************************************
562 send a qfileinfo call
563 ****************************************************************************/
564 BOOL cli_qfileinfo(struct cli_state *cli, int fnum,
565 uint16 *mode, size_t *size,
566 time_t *c_time, time_t *a_time, time_t *m_time,
567 time_t *w_time, SMB_INO_T *ino)
568 {
569 unsigned int data_len = 0;
570 unsigned int param_len = 0;
571 uint16 setup = TRANSACT2_QFILEINFO;
572 pstring param;
573 char *rparam=NULL, *rdata=NULL;
574
575 /* if its a win95 server then fail this - win95 totally screws it
576 up */
577 if (cli->win95) return False;
578
579 param_len = 4;
580
581 memset(param, 0, param_len);
582 SSVAL(param, 0, fnum);
583 SSVAL(param, 2, SMB_QUERY_FILE_ALL_INFO);
584
585 if (!cli_send_trans(cli, SMBtrans2,
586 NULL, /* name */
587 -1, 0, /* fid, flags */
588 &setup, 1, 0, /* setup, length, max */
589 param, param_len, 2, /* param, length, max */
590 NULL, data_len, cli->max_xmit /* data, length, max */
591 )) {
592 return False;
593 }
594
595 if (!cli_receive_trans(cli, SMBtrans2,
596 &rparam, &param_len,
597 &rdata, &data_len)) {
598 return False;
599 }
600
601 if (!rdata || data_len < 68) {
602 return False;
603 }
604
605 if (c_time) {
606 *c_time = interpret_long_date(rdata+0) - cli->serverzone;
607 }
608 if (a_time) {
609 *a_time = interpret_long_date(rdata+8) - cli->serverzone;
610 }
611 if (m_time) {
612 *m_time = interpret_long_date(rdata+16) - cli->serverzone;
613 }
614 if (w_time) {
615 *w_time = interpret_long_date(rdata+24) - cli->serverzone;
616 }
617 if (mode) {
618 *mode = SVAL(rdata, 32);
619 }
620 if (size) {
621 *size = IVAL(rdata, 48);
622 }
623 if (ino) {
624 *ino = IVAL(rdata, 64);
625 }
626
627 SAFE_FREE(rdata);
628 SAFE_FREE(rparam);
629 return True;
630 }
631
632 /****************************************************************************
633 send a qfileinfo call
634 ****************************************************************************/
635 BOOL cli_qfileinfo_test(struct cli_state *cli, int fnum, int level, char **poutdata, uint32 *poutlen)
636 {
637 unsigned int data_len = 0;
638 unsigned int param_len = 0;
639 uint16 setup = TRANSACT2_QFILEINFO;
640 pstring param;
641 char *rparam=NULL, *rdata=NULL;
642
643 *poutdata = NULL;
644 *poutlen = 0;
645
646 /* if its a win95 server then fail this - win95 totally screws it
647 up */
648 if (cli->win95)
649 return False;
650
651 param_len = 4;
652
653 memset(param, 0, param_len);
654 SSVAL(param, 0, fnum);
655 SSVAL(param, 2, level);
656
657 if (!cli_send_trans(cli, SMBtrans2,
658 NULL, /* name */
659 -1, 0, /* fid, flags */
660 &setup, 1, 0, /* setup, length, max */
661 param, param_len, 2, /* param, length, max */
662 NULL, data_len, cli->max_xmit /* data, length, max */
663 )) {
664 return False;
665 }
666
667 if (!cli_receive_trans(cli, SMBtrans2,
668 &rparam, &param_len,
669 &rdata, &data_len)) {
670 return False;
671 }
672
673 *poutdata = memdup(rdata, data_len);
674 *poutlen = data_len;
675
676 SAFE_FREE(rdata);
677 SAFE_FREE(rparam);
678 return True;
679 }
680
681
682
683 /****************************************************************************
684 send a qpathinfo SMB_QUERY_FILE_ALT_NAME_INFO call
685 ****************************************************************************/
686 NTSTATUS cli_qpathinfo_alt_name(struct cli_state *cli, const char *fname, fstring alt_name)
687 {
688 unsigned int data_len = 0;
689 unsigned int param_len = 0;
690 uint16 setup = TRANSACT2_QPATHINFO;
691 pstring param;
692 char *rparam=NULL, *rdata=NULL;
693 int count=8;
694 char *p;
695 BOOL ret;
696 unsigned int len;
697
698 p = param;
699 memset(p, 0, 6);
700 SSVAL(p, 0, SMB_QUERY_FILE_ALT_NAME_INFO);
701 p += 6;
702 p += clistr_push(cli, p, fname, sizeof(pstring)-6, STR_TERMINATE);
703
704 param_len = PTR_DIFF(p, param);
705
706 do {
707 ret = (cli_send_trans(cli, SMBtrans2,
708 NULL, /* Name */
709 -1, 0, /* fid, flags */
710 &setup, 1, 0, /* setup, length, max */
711 param, param_len, 10, /* param, length, max */
712 NULL, data_len, cli->max_xmit /* data, length, max */
713 ) &&
714 cli_receive_trans(cli, SMBtrans2,
715 &rparam, &param_len,
716 &rdata, &data_len));
717 if (!ret && cli_is_dos_error(cli)) {
718 /* we need to work around a Win95 bug - sometimes
719 it gives ERRSRV/ERRerror temprarily */
720 uint8 eclass;
721 uint32 ecode;
722 cli_dos_error(cli, &eclass, &ecode);
723 if (eclass != ERRSRV || ecode != ERRerror) break;
724 smb_msleep(100);
725 }
726 } while (count-- && ret==False);
727
728 if (!ret || !rdata || data_len < 4) {
729 return NT_STATUS_UNSUCCESSFUL;
730 }
731
732 len = IVAL(rdata, 0);
733
734 if (len > data_len - 4) {
735 return NT_STATUS_INVALID_NETWORK_RESPONSE;
736 }
737
738 clistr_pull(cli, alt_name, rdata+4, sizeof(fstring), len, STR_UNICODE);
739
740 SAFE_FREE(rdata);
741 SAFE_FREE(rparam);
742
743 return NT_STATUS_OK;
744 }
reg import