r588: Some fixes from coolo ...
[tprouty/samba.git] / source3 / libsmb / clirap.c
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 *, void *),
210                        void *state)
211 {
212         char *rparam = NULL;
213         char *rdata = NULL;
214         unsigned int rdrcnt,rprcnt;
215         char *p;
216         pstring param;
217         int uLevel = 1;
218         int count = -1;
219
220         errno = 0; /* reset */
221
222         /* send a SMBtrans command with api NetServerEnum */
223         p = param;
224         SSVAL(p,0,0x68); /* api number */
225         p += 2;
226         pstrcpy_base(p,"WrLehDz", param);
227         p = skip_string(p,1);
228   
229         pstrcpy_base(p,"B16BBDz", param);
230
231         p = skip_string(p,1);
232         SSVAL(p,0,uLevel);
233         SSVAL(p,2,CLI_BUFFER_SIZE);
234         p += 4;
235         SIVAL(p,0,stype);
236         p += 4;
237
238         p += push_ascii(p, workgroup, sizeof(pstring)-PTR_DIFF(p,param)-1, STR_TERMINATE|STR_UPPER);
239         
240         if (cli_api(cli, 
241                     param, PTR_DIFF(p,param), 8,        /* params, length, max */
242                     NULL, 0, CLI_BUFFER_SIZE,               /* data, length, max */
243                     &rparam, &rprcnt,                   /* return params, return size */
244                     &rdata, &rdrcnt                     /* return data, return size */
245                    )) {
246                 int res = rparam? SVAL(rparam,0) : -1;
247                         
248                 if (res == 0 || res == ERRmoredata) {
249                         int i;
250                         int converter=SVAL(rparam,2);
251
252                         count=SVAL(rparam,4);
253                         p = rdata;
254                                         
255                         for (i = 0;i < count;i++, p += 26) {
256                                 char *sname = p;
257                                 int comment_offset = (IVAL(p,22) & 0xFFFF)-converter;
258                                 const char *cmnt = comment_offset?(rdata+comment_offset):"";
259                                 pstring s1, s2;
260
261                                 if (comment_offset < 0 || comment_offset > (int)rdrcnt) continue;
262
263                                 stype = IVAL(p,18) & ~SV_TYPE_LOCAL_LIST_ONLY;
264
265                                 pull_ascii_pstring(s1, sname);
266                                 pull_ascii_pstring(s2, cmnt);
267                                 fn(s1, stype, s2, state);
268                         }
269                 }
270         }
271   
272         SAFE_FREE(rparam);
273         SAFE_FREE(rdata);
274
275         if (count < 0) {
276             errno = cli_errno(cli);
277         } else {
278             if (!count) {
279                 /* this is a very special case, when the domain master for the 
280                    work group isn't part of the work group itself, there is something
281                    wild going on */
282                 errno = ENOENT;
283             }
284         }
285                         
286         return(count > 0);
287 }
288
289
290
291 /****************************************************************************
292 Send a SamOEMChangePassword command
293 ****************************************************************************/
294 BOOL cli_oem_change_password(struct cli_state *cli, const char *user, const char *new_password,
295                              const char *old_password)
296 {
297   pstring param;
298   char data[532];
299   char *p = param;
300   unsigned char old_pw_hash[16];
301   unsigned char new_pw_hash[16];
302   unsigned int data_len;
303   unsigned int param_len = 0;
304   char *rparam = NULL;
305   char *rdata = NULL;
306   unsigned int rprcnt, rdrcnt;
307
308   if (strlen(user) >= sizeof(fstring)-1) {
309     DEBUG(0,("cli_oem_change_password: user name %s is too long.\n", user));
310     return False;
311   }
312
313   SSVAL(p,0,214); /* SamOEMChangePassword command. */
314   p += 2;
315   pstrcpy_base(p, "zsT", param);
316   p = skip_string(p,1);
317   pstrcpy_base(p, "B516B16", param);
318   p = skip_string(p,1);
319   pstrcpy_base(p,user, param);
320   p = skip_string(p,1);
321   SSVAL(p,0,532);
322   p += 2;
323
324   param_len = PTR_DIFF(p,param);
325
326   /*
327    * Get the Lanman hash of the old password, we
328    * use this as the key to make_oem_passwd_hash().
329    */
330   E_deshash(old_password, old_pw_hash);
331
332   encode_pw_buffer(data, new_password, STR_ASCII);
333   
334 #ifdef DEBUG_PASSWORD
335   DEBUG(100,("make_oem_passwd_hash\n"));
336   dump_data(100, data, 516);
337 #endif
338   SamOEMhash( (unsigned char *)data, (unsigned char *)old_pw_hash, 516);
339
340   /* 
341    * Now place the old password hash in the data.
342    */
343   E_deshash(new_password, new_pw_hash);
344
345   E_old_pw_hash( new_pw_hash, old_pw_hash, (uchar *)&data[516]);
346
347   data_len = 532;
348     
349   if (cli_send_trans(cli,SMBtrans,
350                     PIPE_LANMAN,                          /* name */
351                     0,0,                                  /* fid, flags */
352                     NULL,0,0,                             /* setup, length, max */
353                     param,param_len,2,                    /* param, length, max */
354                     data,data_len,0                       /* data, length, max */
355                    ) == False) {
356     DEBUG(0,("cli_oem_change_password: Failed to send password change for user %s\n",
357               user ));
358     return False;
359   }
360
361   if (!cli_receive_trans(cli,SMBtrans,
362                        &rparam, &rprcnt,
363                        &rdata, &rdrcnt)) {
364           DEBUG(0,("cli_oem_change_password: Failed to recieve reply to password change for user %s\n",
365                    user ));
366           return False;
367   }
368   
369   if (rparam)
370           cli->rap_error = SVAL(rparam,0);
371   
372   SAFE_FREE(rparam);
373   SAFE_FREE(rdata);
374
375   return (cli->rap_error == 0);
376 }
377
378
379 /****************************************************************************
380 send a qpathinfo call
381 ****************************************************************************/
382 BOOL cli_qpathinfo(struct cli_state *cli, const char *fname, 
383                    time_t *c_time, time_t *a_time, time_t *m_time, 
384                    size_t *size, uint16 *mode)
385 {
386         unsigned int data_len = 0;
387         unsigned int param_len = 0;
388         unsigned int rparam_len, rdata_len;
389         uint16 setup = TRANSACT2_QPATHINFO;
390         pstring param;
391         char *rparam=NULL, *rdata=NULL;
392         int count=8;
393         BOOL ret;
394         time_t (*date_fn)(void *);
395         char *p;
396
397         p = param;
398         memset(p, 0, 6);
399         SSVAL(p, 0, SMB_INFO_STANDARD);
400         p += 6;
401         p += clistr_push(cli, p, fname, sizeof(pstring)-6, STR_TERMINATE);
402
403         param_len = PTR_DIFF(p, param);
404
405         do {
406                 ret = (cli_send_trans(cli, SMBtrans2, 
407                                       NULL,           /* Name */
408                                       -1, 0,          /* fid, flags */
409                                       &setup, 1, 0,   /* setup, length, max */
410                                       param, param_len, 10, /* param, length, max */
411                                       NULL, data_len, cli->max_xmit /* data, length, max */
412                                       ) &&
413                        cli_receive_trans(cli, SMBtrans2, 
414                                          &rparam, &rparam_len,
415                                          &rdata, &rdata_len));
416                 if (!cli_is_dos_error(cli)) break;
417                 if (!ret) {
418                         /* we need to work around a Win95 bug - sometimes
419                            it gives ERRSRV/ERRerror temprarily */
420                         uint8 eclass;
421                         uint32 ecode;
422                         cli_dos_error(cli, &eclass, &ecode);
423                         if (eclass != ERRSRV || ecode != ERRerror) break;
424                         smb_msleep(100);
425                 }
426         } while (count-- && ret==False);
427
428         if (!ret || !rdata || rdata_len < 22) {
429                 return False;
430         }
431
432         if (cli->win95) {
433                 date_fn = make_unix_date;
434         } else {
435                 date_fn = make_unix_date2;
436         }
437
438         if (c_time) {
439                 *c_time = date_fn(rdata+0);
440         }
441         if (a_time) {
442                 *a_time = date_fn(rdata+4);
443         }
444         if (m_time) {
445                 *m_time = date_fn(rdata+8);
446         }
447         if (size) {
448                 *size = IVAL(rdata, 12);
449         }
450         if (mode) {
451                 *mode = SVAL(rdata,l1_attrFile);
452         }
453
454         SAFE_FREE(rdata);
455         SAFE_FREE(rparam);
456         return True;
457 }
458
459 /****************************************************************************
460 send a qpathinfo call with the SMB_QUERY_FILE_ALL_INFO info level
461 ****************************************************************************/
462 BOOL cli_qpathinfo2(struct cli_state *cli, const char *fname, 
463                     time_t *c_time, time_t *a_time, time_t *m_time, 
464                     time_t *w_time, size_t *size, uint16 *mode,
465                     SMB_INO_T *ino)
466 {
467         unsigned int data_len = 0;
468         unsigned int param_len = 0;
469         uint16 setup = TRANSACT2_QPATHINFO;
470         pstring param;
471         char *rparam=NULL, *rdata=NULL;
472         char *p;
473
474         p = param;
475         memset(p, 0, 6);
476         SSVAL(p, 0, SMB_QUERY_FILE_ALL_INFO);
477         p += 6;
478         p += clistr_push(cli, p, fname, sizeof(pstring)-6, STR_TERMINATE);
479
480         param_len = PTR_DIFF(p, param);
481
482         if (!cli_send_trans(cli, SMBtrans2, 
483                             NULL,                         /* name */
484                             -1, 0,                        /* fid, flags */
485                             &setup, 1, 0,                 /* setup, length, max */
486                             param, param_len, 10,         /* param, length, max */
487                             NULL, data_len, cli->max_xmit /* data, length, max */
488                            )) {
489                 return False;
490         }
491
492         if (!cli_receive_trans(cli, SMBtrans2,
493                                &rparam, &param_len,
494                                &rdata, &data_len)) {
495                 return False;
496         }
497
498         if (!rdata || data_len < 22) {
499                 return False;
500         }
501
502         if (c_time) {
503                 *c_time = interpret_long_date(rdata+0) - cli->serverzone;
504         }
505         if (a_time) {
506                 *a_time = interpret_long_date(rdata+8) - cli->serverzone;
507         }
508         if (m_time) {
509                 *m_time = interpret_long_date(rdata+16) - cli->serverzone;
510         }
511         if (w_time) {
512                 *w_time = interpret_long_date(rdata+24) - cli->serverzone;
513         }
514         if (mode) {
515                 *mode = SVAL(rdata, 32);
516         }
517         if (size) {
518                 *size = IVAL(rdata, 48);
519         }
520         if (ino) {
521                 *ino = IVAL(rdata, 64);
522         }
523
524         SAFE_FREE(rdata);
525         SAFE_FREE(rparam);
526         return True;
527 }
528
529
530 /****************************************************************************
531 send a qfileinfo QUERY_FILE_NAME_INFO call
532 ****************************************************************************/
533 BOOL cli_qfilename(struct cli_state *cli, int fnum, 
534                    pstring name)
535 {
536         unsigned int data_len = 0;
537         unsigned int param_len = 0;
538         uint16 setup = TRANSACT2_QFILEINFO;
539         pstring param;
540         char *rparam=NULL, *rdata=NULL;
541
542         param_len = 4;
543         memset(param, 0, param_len);
544         SSVAL(param, 0, fnum);
545         SSVAL(param, 2, SMB_QUERY_FILE_NAME_INFO);
546
547         if (!cli_send_trans(cli, SMBtrans2, 
548                             NULL,                           /* name */
549                             -1, 0,                          /* fid, flags */
550                             &setup, 1, 0,                   /* setup, length, max */
551                             param, param_len, 2,            /* param, length, max */
552                             NULL, data_len, cli->max_xmit   /* data, length, max */
553                            )) {
554                 return False;
555         }
556
557         if (!cli_receive_trans(cli, SMBtrans2,
558                                &rparam, &param_len,
559                                &rdata, &data_len)) {
560                 return False;
561         }
562
563         if (!rdata || data_len < 4) {
564                 return False;
565         }
566
567         clistr_pull(cli, name, rdata+4, sizeof(pstring), IVAL(rdata, 0), STR_UNICODE);
568
569         return True;
570 }
571
572
573 /****************************************************************************
574 send a qfileinfo call
575 ****************************************************************************/
576 BOOL cli_qfileinfo(struct cli_state *cli, int fnum, 
577                    uint16 *mode, size_t *size,
578                    time_t *c_time, time_t *a_time, time_t *m_time, 
579                    time_t *w_time, SMB_INO_T *ino)
580 {
581         unsigned int data_len = 0;
582         unsigned int param_len = 0;
583         uint16 setup = TRANSACT2_QFILEINFO;
584         pstring param;
585         char *rparam=NULL, *rdata=NULL;
586
587         /* if its a win95 server then fail this - win95 totally screws it
588            up */
589         if (cli->win95) return False;
590
591         param_len = 4;
592
593         memset(param, 0, param_len);
594         SSVAL(param, 0, fnum);
595         SSVAL(param, 2, SMB_QUERY_FILE_ALL_INFO);
596
597         if (!cli_send_trans(cli, SMBtrans2, 
598                             NULL,                           /* name */
599                             -1, 0,                          /* fid, flags */
600                             &setup, 1, 0,                   /* setup, length, max */
601                             param, param_len, 2,            /* param, length, max */
602                             NULL, data_len, cli->max_xmit   /* data, length, max */
603                            )) {
604                 return False;
605         }
606
607         if (!cli_receive_trans(cli, SMBtrans2,
608                                &rparam, &param_len,
609                                &rdata, &data_len)) {
610                 return False;
611         }
612
613         if (!rdata || data_len < 68) {
614                 return False;
615         }
616
617         if (c_time) {
618                 *c_time = interpret_long_date(rdata+0) - cli->serverzone;
619         }
620         if (a_time) {
621                 *a_time = interpret_long_date(rdata+8) - cli->serverzone;
622         }
623         if (m_time) {
624                 *m_time = interpret_long_date(rdata+16) - cli->serverzone;
625         }
626         if (w_time) {
627                 *w_time = interpret_long_date(rdata+24) - cli->serverzone;
628         }
629         if (mode) {
630                 *mode = SVAL(rdata, 32);
631         }
632         if (size) {
633                 *size = IVAL(rdata, 48);
634         }
635         if (ino) {
636                 *ino = IVAL(rdata, 64);
637         }
638
639         SAFE_FREE(rdata);
640         SAFE_FREE(rparam);
641         return True;
642 }
643
644 /****************************************************************************
645 send a qfileinfo call
646 ****************************************************************************/
647 BOOL cli_qfileinfo_test(struct cli_state *cli, int fnum, int level, char **poutdata, uint32 *poutlen)
648 {
649         unsigned int data_len = 0;
650         unsigned int param_len = 0;
651         uint16 setup = TRANSACT2_QFILEINFO;
652         pstring param;
653         char *rparam=NULL, *rdata=NULL;
654
655         *poutdata = NULL;
656         *poutlen = 0;
657
658         /* if its a win95 server then fail this - win95 totally screws it
659            up */
660         if (cli->win95)
661                 return False;
662
663         param_len = 4;
664
665         memset(param, 0, param_len);
666         SSVAL(param, 0, fnum);
667         SSVAL(param, 2, level);
668
669         if (!cli_send_trans(cli, SMBtrans2, 
670                             NULL,                           /* name */
671                             -1, 0,                          /* fid, flags */
672                             &setup, 1, 0,                   /* setup, length, max */
673                             param, param_len, 2,            /* param, length, max */
674                             NULL, data_len, cli->max_xmit   /* data, length, max */
675                            )) {
676                 return False;
677         }
678
679         if (!cli_receive_trans(cli, SMBtrans2,
680                                &rparam, &param_len,
681                                &rdata, &data_len)) {
682                 return False;
683         }
684
685         *poutdata = memdup(rdata, data_len);
686         *poutlen = data_len;
687
688         SAFE_FREE(rdata);
689         SAFE_FREE(rparam);
690         return True;
691 }
692
693
694
695 /****************************************************************************
696 send a qpathinfo SMB_QUERY_FILE_ALT_NAME_INFO call
697 ****************************************************************************/
698 NTSTATUS cli_qpathinfo_alt_name(struct cli_state *cli, const char *fname, fstring alt_name)
699 {
700         unsigned int data_len = 0;
701         unsigned int param_len = 0;
702         uint16 setup = TRANSACT2_QPATHINFO;
703         pstring param;
704         char *rparam=NULL, *rdata=NULL;
705         int count=8;
706         char *p;
707         BOOL ret;
708         unsigned int len;
709
710         p = param;
711         memset(p, 0, 6);
712         SSVAL(p, 0, SMB_QUERY_FILE_ALT_NAME_INFO);
713         p += 6;
714         p += clistr_push(cli, p, fname, sizeof(pstring)-6, STR_TERMINATE);
715
716         param_len = PTR_DIFF(p, param);
717
718         do {
719                 ret = (cli_send_trans(cli, SMBtrans2, 
720                                       NULL,           /* Name */
721                                       -1, 0,          /* fid, flags */
722                                       &setup, 1, 0,   /* setup, length, max */
723                                       param, param_len, 10, /* param, length, max */
724                                       NULL, data_len, cli->max_xmit /* data, length, max */
725                                       ) &&
726                        cli_receive_trans(cli, SMBtrans2, 
727                                          &rparam, &param_len,
728                                          &rdata, &data_len));
729                 if (!ret && cli_is_dos_error(cli)) {
730                         /* we need to work around a Win95 bug - sometimes
731                            it gives ERRSRV/ERRerror temprarily */
732                         uint8 eclass;
733                         uint32 ecode;
734                         cli_dos_error(cli, &eclass, &ecode);
735                         if (eclass != ERRSRV || ecode != ERRerror) break;
736                         smb_msleep(100);
737                 }
738         } while (count-- && ret==False);
739
740         if (!ret || !rdata || data_len < 4) {
741                 return NT_STATUS_UNSUCCESSFUL;
742         }
743
744         len = IVAL(rdata, 0);
745
746         if (len > data_len - 4) {
747                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
748         }
749
750         clistr_pull(cli, alt_name, rdata+4, sizeof(fstring), len, STR_UNICODE);
751
752         SAFE_FREE(rdata);
753         SAFE_FREE(rparam);
754
755         return NT_STATUS_OK;
756 }