d16e5a471fcf95f90eb70f9c8a334450b4863d75
[kai/samba.git] / source3 / client / clientutil.c
1 /* 
2    Unix SMB/Netbios implementation.
3    Version 1.9.
4    SMB client
5    Copyright (C) Andrew Tridgell 1994-1997
6    
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11    
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16    
17    You should have received a copy of the GNU General Public License
18    along with this program; if not, write to the Free Software
19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 */
21
22 #ifdef SYSLOG
23 #undef SYSLOG
24 #endif
25
26 #include "includes.h"
27
28 #ifndef REGISTER
29 #define REGISTER 0
30 #endif
31
32 pstring service="";
33 pstring desthost="";
34 extern pstring myname;
35 pstring password = "";
36 pstring username="";
37 pstring workgroup=WORKGROUP;
38 BOOL got_pass = False;
39 BOOL connect_as_printer = False;
40 BOOL connect_as_ipc = False;
41
42 char cryptkey[8];
43 BOOL doencrypt=False;
44
45 extern pstring user_socket_options;
46
47 /* 30 second timeout on most commands */
48 #define CLIENT_TIMEOUT (30*1000)
49 #define SHORT_TIMEOUT (5*1000)
50
51 int name_type = 0x20;
52
53 int max_protocol = PROTOCOL_NT1;
54
55 BOOL readbraw_supported = False;
56 BOOL writebraw_supported = False;
57
58 extern int DEBUGLEVEL;
59
60 int cnum = 0;
61 int pid = 0;
62 int gid = 0;
63 int uid = 0;
64 int mid = 0;
65
66 int max_xmit = BUFFER_SIZE;
67
68 BOOL have_ip = False;
69
70 struct in_addr dest_ip;
71
72 extern int Protocol;
73
74 extern int Client;
75
76
77 /****************************************************************************
78 setup basics in a outgoing packet
79 ****************************************************************************/
80 void cli_setup_pkt(char *outbuf)
81 {
82   SSVAL(outbuf,smb_pid,pid);
83   SSVAL(outbuf,smb_uid,uid);
84   SSVAL(outbuf,smb_mid,mid);
85   if (Protocol > PROTOCOL_CORE)
86     {
87       SCVAL(outbuf,smb_flg,0x8);
88       SSVAL(outbuf,smb_flg2,0x1);
89     }
90 }
91
92 /****************************************************************************
93   receive a SMB trans or trans2 response allocating the necessary memory
94   ****************************************************************************/
95 BOOL cli_receive_trans_response(char *inbuf,int trans,int *data_len,
96                                 int *param_len, char **data,char **param)
97 {
98   int total_data=0;
99   int total_param=0;
100   int this_data,this_param;
101
102   *data_len = *param_len = 0;
103
104   receive_smb(Client,inbuf,CLIENT_TIMEOUT);
105   show_msg(inbuf);
106
107   /* sanity check */
108   if (CVAL(inbuf,smb_com) != trans)
109     {
110       DEBUG(0,("Expected %s response, got command 0x%02x\n",
111                trans==SMBtrans?"SMBtrans":"SMBtrans2", CVAL(inbuf,smb_com)));
112       return(False);
113     }
114   if (CVAL(inbuf,smb_rcls) != 0)
115     return(False);
116
117   /* parse out the lengths */
118   total_data = SVAL(inbuf,smb_tdrcnt);
119   total_param = SVAL(inbuf,smb_tprcnt);
120
121   /* allocate it */
122   *data = Realloc(*data,total_data);
123   *param = Realloc(*param,total_param);
124
125   while (1)
126     {
127       this_data = SVAL(inbuf,smb_drcnt);
128       this_param = SVAL(inbuf,smb_prcnt);
129       if (this_data)
130         memcpy(*data + SVAL(inbuf,smb_drdisp),
131                smb_base(inbuf) + SVAL(inbuf,smb_droff),
132                this_data);
133       if (this_param)
134         memcpy(*param + SVAL(inbuf,smb_prdisp),
135                smb_base(inbuf) + SVAL(inbuf,smb_proff),
136                this_param);
137       *data_len += this_data;
138       *param_len += this_param;
139
140       /* parse out the total lengths again - they can shrink! */
141       total_data = SVAL(inbuf,smb_tdrcnt);
142       total_param = SVAL(inbuf,smb_tprcnt);
143
144       if (total_data <= *data_len && total_param <= *param_len)
145         break;
146
147       receive_smb(Client,inbuf,CLIENT_TIMEOUT);
148       show_msg(inbuf);
149
150       /* sanity check */
151       if (CVAL(inbuf,smb_com) != trans)
152         {
153           DEBUG(0,("Expected %s response, got command 0x%02x\n",
154                    trans==SMBtrans?"SMBtrans":"SMBtrans2", CVAL(inbuf,smb_com)));
155           return(False);
156         }
157       if (CVAL(inbuf,smb_rcls) != 0)
158           return(False);
159     }
160   
161   return(True);
162 }
163
164 /****************************************************************************
165 send a session request
166 ****************************************************************************/
167 BOOL cli_send_session_request(char *inbuf, char *outbuf)
168 {
169   fstring dest;
170   char *p;
171   int len = 4;
172   /* send a session request (RFC 8002) */
173
174   fstrcpy(dest,desthost);
175   
176   p = strchr(dest,'.');
177   if (p) *p = 0;
178
179   /* put in the destination name */
180   p = outbuf+len;
181   name_mangle(dest,p,name_type);
182   len += name_len(p);
183
184   /* and my name */
185   p = outbuf+len;
186   name_mangle(myname,p,0);
187   len += name_len(p);
188
189   /* setup the packet length */
190   _smb_setlen(outbuf,len);
191   CVAL(outbuf,0) = 0x81;
192
193   send_smb(Client,outbuf);
194   DEBUG(5,("Sent session request\n"));
195
196   receive_smb(Client,inbuf,CLIENT_TIMEOUT);
197
198   if (CVAL(inbuf,0) == 0x84) /* C. Hoch  9/14/95 Start */
199     {
200       /* For information, here is the response structure.
201        * We do the byte-twiddling to for portability.
202        struct RetargetResponse{
203        unsigned char type;
204        unsigned char flags;
205        int16 length;
206        int32 ip_addr;
207        int16 port;
208        };
209        */
210       extern int Client;
211       int port = (CVAL(inbuf,8)<<8)+CVAL(inbuf,9);
212       /* SESSION RETARGET */
213       putip((char *)&dest_ip,inbuf+4);
214
215       close_sockets();
216       Client = open_socket_out(SOCK_STREAM, &dest_ip, port, SHORT_CONNECT_TIMEOUT);
217       if (Client == -1)
218         return False;
219
220       DEBUG(5,("Retargeted\n"));
221
222       set_socket_options(Client,user_socket_options);
223
224       /* Try again */
225       return cli_send_session_request(inbuf,outbuf);
226     } /* C. Hoch 9/14/95 End */
227
228
229   if (CVAL(inbuf,0) != 0x82)
230     {
231       int ecode = CVAL(inbuf,4);
232       DEBUG(0,("Session request failed (%d,%d) with myname=%s destname=%s\n",
233                CVAL(inbuf,0),ecode,myname,desthost));
234       switch (ecode)
235         {
236         case 0x80: 
237           DEBUG(0,("Not listening on called name\n")); 
238           DEBUG(0,("Try to connect to another name (instead of %s)\n",desthost));
239           DEBUG(0,("You may find the -I option useful for this\n"));
240           break;
241         case 0x81: 
242           DEBUG(0,("Not listening for calling name\n")); 
243           DEBUG(0,("Try to connect as another name (instead of %s)\n",myname));
244           DEBUG(0,("You may find the -n option useful for this\n"));
245           break;
246         case 0x82: 
247           DEBUG(0,("Called name not present\n")); 
248           DEBUG(0,("Try to connect to another name (instead of %s)\n",desthost));
249           DEBUG(0,("You may find the -I option useful for this\n"));
250           break;
251         case 0x83: 
252           DEBUG(0,("Called name present, but insufficient resources\n")); 
253           DEBUG(0,("Perhaps you should try again later?\n")); 
254           break;
255         default:
256           DEBUG(0,("Unspecified error 0x%X\n",ecode)); 
257           DEBUG(0,("Your server software is being unfriendly\n"));
258           break;          
259         }
260       return(False);
261     }
262   return(True);
263 }
264
265
266 static  struct {
267     int prot;
268     char *name;
269   }
270 prots[] = 
271     {
272       {PROTOCOL_CORE,"PC NETWORK PROGRAM 1.0"},
273       {PROTOCOL_COREPLUS,"MICROSOFT NETWORKS 1.03"},
274       {PROTOCOL_LANMAN1,"MICROSOFT NETWORKS 3.0"},
275       {PROTOCOL_LANMAN1,"LANMAN1.0"},
276       {PROTOCOL_LANMAN2,"LM1.2X002"},
277       {PROTOCOL_LANMAN2,"Samba"},
278       {PROTOCOL_NT1,"NT LM 0.12"},
279       {PROTOCOL_NT1,"NT LANMAN 1.0"},
280       {-1,NULL}
281     };
282
283 /****************************************************************************
284 send a login command
285 ****************************************************************************/
286 BOOL cli_send_login(char *inbuf, char *outbuf, BOOL start_session, BOOL use_setup)
287 {
288   BOOL was_null = (!inbuf && !outbuf);
289   int sesskey=0;
290   time_t servertime = 0;
291   extern int serverzone;
292   int sec_mode=0;
293   int crypt_len;
294   int max_vcs=0;
295   char *pass = NULL;  
296   pstring dev;
297   char *p;
298   int numprots;
299
300   if (was_null)
301     {
302       inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
303       outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
304     }
305
306   pstrcpy(dev,"A:");
307   if (connect_as_printer)
308     pstrcpy(dev,"LPT1:");
309   if (connect_as_ipc)
310     pstrcpy(dev,"IPC");
311
312
313   if (start_session && !cli_send_session_request(inbuf,outbuf))
314     {
315       if (was_null)
316         {
317           free(inbuf);
318           free(outbuf);
319         }      
320       return(False);
321     }
322
323   bzero(outbuf,smb_size);
324
325   /* setup the protocol strings */
326   {
327     int plength;
328
329     for (plength=0,numprots=0;
330          prots[numprots].name && prots[numprots].prot<=max_protocol;
331          numprots++)
332       plength += strlen(prots[numprots].name)+2;
333     
334     set_message(outbuf,0,plength,True);
335
336     p = smb_buf(outbuf);
337     for (numprots=0;
338          prots[numprots].name && prots[numprots].prot<=max_protocol;
339          numprots++)
340       {
341         *p++ = 2;
342         strcpy(p,prots[numprots].name);
343         p += strlen(p) + 1;
344       }
345   }
346
347   CVAL(outbuf,smb_com) = SMBnegprot;
348   cli_setup_pkt(outbuf);
349
350   CVAL(smb_buf(outbuf),0) = 2;
351
352   send_smb(Client,outbuf);
353   receive_smb(Client,inbuf,CLIENT_TIMEOUT);
354
355   show_msg(inbuf);
356
357   if (CVAL(inbuf,smb_rcls) != 0 || ((int)SVAL(inbuf,smb_vwv0) >= numprots))
358     {
359       DEBUG(0,("SMBnegprot failed. myname=%s destname=%s - %s \n",
360             myname,desthost,smb_errstr(inbuf)));
361       if (was_null)
362         {
363           free(inbuf);
364           free(outbuf);
365         }
366       return(False);
367     }
368
369   Protocol = prots[SVAL(inbuf,smb_vwv0)].prot;
370
371
372   if (Protocol < PROTOCOL_NT1) {    
373     sec_mode = SVAL(inbuf,smb_vwv1);
374     max_xmit = SVAL(inbuf,smb_vwv2);
375     sesskey = IVAL(inbuf,smb_vwv6);
376     serverzone = SVALS(inbuf,smb_vwv10)*60;
377     /* this time is converted to GMT by make_unix_date */
378     servertime = make_unix_date(inbuf+smb_vwv8);
379     if (Protocol >= PROTOCOL_COREPLUS) {
380       readbraw_supported = ((SVAL(inbuf,smb_vwv5) & 0x1) != 0);
381       writebraw_supported = ((SVAL(inbuf,smb_vwv5) & 0x2) != 0);
382     }
383     crypt_len = smb_buflen(inbuf);
384     memcpy(cryptkey,smb_buf(inbuf),8);
385     DEBUG(5,("max mux %d\n",SVAL(inbuf,smb_vwv3)));
386     max_vcs = SVAL(inbuf,smb_vwv4); 
387     DEBUG(5,("max vcs %d\n",max_vcs)); 
388     DEBUG(5,("max blk %d\n",SVAL(inbuf,smb_vwv5)));
389   } else {
390     /* NT protocol */
391     sec_mode = CVAL(inbuf,smb_vwv1);
392     max_xmit = IVAL(inbuf,smb_vwv3+1);
393     sesskey = IVAL(inbuf,smb_vwv7+1);
394     serverzone = SVALS(inbuf,smb_vwv15+1)*60;
395     /* this time arrives in real GMT */
396     servertime = interpret_long_date(inbuf+smb_vwv11+1);
397     crypt_len = CVAL(inbuf,smb_vwv16+1);
398     memcpy(cryptkey,smb_buf(inbuf),8);
399     if (IVAL(inbuf,smb_vwv9+1) & 1)
400       readbraw_supported = writebraw_supported = True;      
401     DEBUG(5,("max mux %d\n",SVAL(inbuf,smb_vwv1+1)));
402     max_vcs = SVAL(inbuf,smb_vwv2+1); 
403     DEBUG(5,("max vcs %d\n",max_vcs));
404     DEBUG(5,("max raw %d\n",IVAL(inbuf,smb_vwv5+1)));
405     DEBUG(5,("capabilities 0x%x\n",IVAL(inbuf,smb_vwv9+1)));
406   }
407
408   DEBUG(5,("Sec mode %d\n",SVAL(inbuf,smb_vwv1)));
409   DEBUG(5,("max xmt %d\n",max_xmit));
410   DEBUG(5,("Got %d byte crypt key\n",crypt_len));
411   DEBUG(5,("Chose protocol [%s]\n",prots[SVAL(inbuf,smb_vwv0)].name));
412
413   doencrypt = ((sec_mode & 2) != 0);
414
415   if (servertime) {
416     static BOOL done_time = False;
417     if (!done_time) {
418       DEBUG(1,("Server time is %sTimezone is UTC%+02.1f\n",
419                asctime(LocalTime(&servertime)),
420                -(double)(serverzone/3600.0)));
421       done_time = True;
422     }
423   }
424
425  get_pass:
426
427   if (got_pass)
428     pass = password;
429   else
430     pass = (char *)getpass("Password: ");
431
432   if(pass == NULL)
433   {
434     DEBUG(0, ("cli_send_login : no password available - logon failed.\n"));
435     return False;
436   }
437
438   if (Protocol >= PROTOCOL_LANMAN1 && use_setup)
439     {
440       fstring pword;
441       int passlen = strlen(pass)+1;
442       fstrcpy(pword,pass);      
443
444       if (doencrypt && *pass) {
445         DEBUG(5,("Using encrypted passwords\n"));
446         passlen = 24;
447         SMBencrypt((uchar *)pass,(uchar *)cryptkey,(uchar *)pword);
448       }
449
450       /* if in share level security then don't send a password now */
451       if (!(sec_mode & 1)) {fstrcpy(pword, "");passlen=1;} 
452
453       /* send a session setup command */
454       bzero(outbuf,smb_size);
455
456       if (Protocol < PROTOCOL_NT1) {
457         set_message(outbuf,10,1 + strlen(username) + passlen,True);
458         CVAL(outbuf,smb_com) = SMBsesssetupX;
459         cli_setup_pkt(outbuf);
460
461         CVAL(outbuf,smb_vwv0) = 0xFF;
462         SSVAL(outbuf,smb_vwv2,max_xmit);
463         SSVAL(outbuf,smb_vwv3,2);
464         SSVAL(outbuf,smb_vwv4,max_vcs-1);
465         SIVAL(outbuf,smb_vwv5,sesskey);
466         SSVAL(outbuf,smb_vwv7,passlen);
467         p = smb_buf(outbuf);
468         memcpy(p,pword,passlen);
469         p += passlen;
470         strcpy(p,username);
471       } else {
472         if (!doencrypt) passlen--;
473         /* for Win95 */
474         set_message(outbuf,13,0,True);
475         CVAL(outbuf,smb_com) = SMBsesssetupX;
476         cli_setup_pkt(outbuf);
477
478         CVAL(outbuf,smb_vwv0) = 0xFF;
479         SSVAL(outbuf,smb_vwv2,BUFFER_SIZE);
480         SSVAL(outbuf,smb_vwv3,2);
481         SSVAL(outbuf,smb_vwv4,getpid());
482         SIVAL(outbuf,smb_vwv5,sesskey);
483         SSVAL(outbuf,smb_vwv7,passlen);
484         SSVAL(outbuf,smb_vwv8,0);
485         p = smb_buf(outbuf);
486         memcpy(p,pword,passlen); p += SVAL(outbuf,smb_vwv7);
487         strcpy(p,username);p = skip_string(p,1);
488         strcpy(p,workgroup);p = skip_string(p,1);
489         strcpy(p,"Unix");p = skip_string(p,1);
490         strcpy(p,"Samba");p = skip_string(p,1);
491         set_message(outbuf,13,PTR_DIFF(p,smb_buf(outbuf)),False);
492       }
493
494       send_smb(Client,outbuf);
495       receive_smb(Client,inbuf,CLIENT_TIMEOUT);
496
497       show_msg(inbuf);
498
499       if (CVAL(inbuf,smb_rcls) != 0)
500         {
501           if (! *pass &&
502               ((CVAL(inbuf,smb_rcls) == ERRDOS && 
503                 SVAL(inbuf,smb_err) == ERRnoaccess) ||
504                (CVAL(inbuf,smb_rcls) == ERRSRV && 
505                 SVAL(inbuf,smb_err) == ERRbadpw)))
506             {
507               got_pass = False;
508               DEBUG(5,("resending login\n"));
509               goto get_pass;
510             }
511               
512           DEBUG(0,("Session setup failed for username=%s myname=%s destname=%s   %s\n",
513                 username,myname,desthost,smb_errstr(inbuf)));
514           DEBUG(0,("You might find the -U or -n options useful\n"));
515           DEBUG(0,("Sometimes you have to use `-n USERNAME' (particularly with OS/2)\n"));
516           DEBUG(0,("Some servers also insist on uppercase-only passwords\n"));
517           if (was_null)
518             {
519               free(inbuf);
520               free(outbuf);
521             }
522           return(False);
523         }
524
525       if (Protocol >= PROTOCOL_NT1) {
526         char *domain,*os,*lanman;
527         p = smb_buf(inbuf);
528         os = p;
529         lanman = skip_string(os,1);
530         domain = skip_string(lanman,1);
531         if (*domain || *os || *lanman)
532           DEBUG(1,("Domain=[%s] OS=[%s] Server=[%s]\n",domain,os,lanman));
533       }
534
535       /* use the returned uid from now on */
536       if (SVAL(inbuf,smb_uid) != uid)
537         DEBUG(5,("Server gave us a UID of %d. We gave %d\n",
538               SVAL(inbuf,smb_uid),uid));
539       uid = SVAL(inbuf,smb_uid);
540     }
541
542   /* now we've got a connection - send a tcon message */
543   bzero(outbuf,smb_size);
544
545   if (strncmp(service,"\\\\",2) != 0)
546     {
547       DEBUG(0,("\nWarning: Your service name doesn't start with \\\\. This is probably incorrect.\n"));
548       DEBUG(0,("Perhaps try replacing each \\ with \\\\ on the command line?\n\n"));
549     }
550
551
552  again2:
553
554   {
555     int passlen = strlen(pass)+1;
556     fstring pword;
557     fstrcpy(pword,pass);
558
559     if (doencrypt && *pass) {
560       passlen=24;
561       SMBencrypt((uchar *)pass,(uchar *)cryptkey,(uchar *)pword);      
562     }
563
564     /* if in user level security then don't send a password now */
565     if ((sec_mode & 1)) {
566       fstrcpy(pword, ""); passlen=1; 
567     }
568
569     set_message(outbuf,4,2 + strlen(service) + passlen + strlen(dev),True);
570     CVAL(outbuf,smb_com) = SMBtconX;
571     cli_setup_pkt(outbuf);
572
573     SSVAL(outbuf,smb_vwv0,0xFF);
574     SSVAL(outbuf,smb_vwv3,passlen);
575
576     p = smb_buf(outbuf);
577     memcpy(p,pword,passlen);
578     p += passlen;
579     strcpy(p,service);
580     p = skip_string(p,1);
581     strcpy(p,dev);
582   }
583
584   send_smb(Client,outbuf);
585   receive_smb(Client,inbuf,CLIENT_TIMEOUT);
586
587   /* trying again with a blank password */
588   if (CVAL(inbuf,smb_rcls) != 0 && 
589       (int)strlen(pass) > 0 && 
590       !doencrypt &&
591       Protocol >= PROTOCOL_LANMAN1)
592     {
593       DEBUG(2,("first SMBtconX failed, trying again. %s\n",smb_errstr(inbuf)));
594       strcpy(pass,"");
595       goto again2;
596     }  
597
598   if (CVAL(inbuf,smb_rcls) != 0)
599     {
600       DEBUG(0,("SMBtconX failed. %s\n",smb_errstr(inbuf)));
601       DEBUG(0,("Perhaps you are using the wrong sharename, username or password?\n"));
602       DEBUG(0,("Some servers insist that these be in uppercase\n"));
603       if (was_null)
604         {
605           free(inbuf);
606           free(outbuf);
607         }
608       return(False);
609     }
610   
611
612   max_xmit = MIN(max_xmit,BUFFER_SIZE-4);
613   if (max_xmit <= 0)
614     max_xmit = BUFFER_SIZE - 4;
615
616   cnum = SVAL(inbuf,smb_tid);
617
618   DEBUG(5,("Connected with cnum=%d max_xmit=%d\n",cnum,max_xmit));
619
620   if (was_null)
621     {
622       free(inbuf);
623       free(outbuf);
624     }
625   return True;
626 }
627
628
629 /****************************************************************************
630 send a logout command
631 ****************************************************************************/
632 void cli_send_logout(void)
633 {
634   pstring inbuf,outbuf;
635
636   bzero(outbuf,smb_size);
637   set_message(outbuf,0,0,True);
638   CVAL(outbuf,smb_com) = SMBtdis;
639   SSVAL(outbuf,smb_tid,cnum);
640   cli_setup_pkt(outbuf);
641
642   send_smb(Client,outbuf);
643   receive_smb(Client,inbuf,SHORT_TIMEOUT);
644
645   if (CVAL(inbuf,smb_rcls) != 0)
646     {
647       DEBUG(0,("SMBtdis failed %s\n",smb_errstr(inbuf)));
648     }
649
650   
651 #ifdef STATS
652   stats_report();
653 #endif
654   exit(0);
655 }
656
657
658
659 /****************************************************************************
660 call a remote api
661 ****************************************************************************/
662 BOOL cli_call_api(int prcnt,int drcnt,int mprcnt,int mdrcnt,int *rprcnt,
663               int *rdrcnt, char *param,char *data, char **rparam,char **rdata)
664 {
665   static char *inbuf=NULL;
666   static char *outbuf=NULL;
667
668   if (!inbuf) inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
669   if (!outbuf) outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
670
671   cli_send_trans_request(outbuf,SMBtrans,"\\PIPE\\LANMAN",0,0,
672                          data,param,NULL,
673                          drcnt,prcnt,0,
674                          mdrcnt,mprcnt,0);
675
676   return (cli_receive_trans_response(inbuf,SMBtrans,
677                                      rdrcnt,rprcnt,
678                                      rdata,rparam));
679 }
680
681 /****************************************************************************
682   send a SMB trans or trans2 request
683   ****************************************************************************/
684 BOOL cli_send_trans_request(char *outbuf, int trans, char *name, int fid, int flags,
685                         char *data,char *param,uint16 *setup, int ldata,int lparam,
686                         int lsetup,int mdata,int mparam,int msetup)
687 {
688   int i;
689   int this_ldata,this_lparam;
690   int tot_data=0,tot_param=0;
691   char *outdata,*outparam;
692   pstring inbuf;
693   char *p;
694
695   this_lparam = MIN(lparam,max_xmit - (500+lsetup*SIZEOFWORD)); /* hack */
696   this_ldata = MIN(ldata,max_xmit - (500+lsetup*SIZEOFWORD+this_lparam));
697
698   bzero(outbuf,smb_size);
699   set_message(outbuf,14+lsetup,0,True);
700   CVAL(outbuf,smb_com) = trans;
701   SSVAL(outbuf,smb_tid,cnum);
702   cli_setup_pkt(outbuf);
703
704   outparam = smb_buf(outbuf)+(trans==SMBtrans ? strlen(name)+1 : 3);
705   outdata = outparam+this_lparam;
706
707   /* primary request */
708   SSVAL(outbuf,smb_tpscnt,lparam);      /* tpscnt */
709   SSVAL(outbuf,smb_tdscnt,ldata);       /* tdscnt */
710   SSVAL(outbuf,smb_mprcnt,mparam);      /* mprcnt */
711   SSVAL(outbuf,smb_mdrcnt,mdata);       /* mdrcnt */
712   SCVAL(outbuf,smb_msrcnt,msetup);      /* msrcnt */
713   SSVAL(outbuf,smb_flags,flags);        /* flags */
714   SIVAL(outbuf,smb_timeout,0);          /* timeout */
715   SSVAL(outbuf,smb_pscnt,this_lparam);  /* pscnt */
716   SSVAL(outbuf,smb_psoff,smb_offset(outparam,outbuf)); /* psoff */
717   SSVAL(outbuf,smb_dscnt,this_ldata);   /* dscnt */
718   SSVAL(outbuf,smb_dsoff,smb_offset(outdata,outbuf)); /* dsoff */
719   SCVAL(outbuf,smb_suwcnt,lsetup);      /* suwcnt */
720   for (i=0;i<lsetup;i++)                /* setup[] */
721     SSVAL(outbuf,smb_setup+i*SIZEOFWORD,setup[i]);
722   p = smb_buf(outbuf);
723   if (trans==SMBtrans)
724     strcpy(p,name);                     /* name[] */
725   else
726     {
727       *p++ = 0;                         /* put in a null smb_name */
728       *p++ = 'D'; *p++ = ' ';           /* this was added because OS/2 does it */
729     }
730   if (this_lparam)                      /* param[] */
731     memcpy(outparam,param,this_lparam);
732   if (this_ldata)                       /* data[] */
733     memcpy(outdata,data,this_ldata);
734   set_message(outbuf,14+lsetup,         /* wcnt, bcc */
735               PTR_DIFF(outdata+this_ldata,smb_buf(outbuf)),False);
736
737   show_msg(outbuf);
738   send_smb(Client,outbuf);
739
740   if (this_ldata < ldata || this_lparam < lparam)
741     {
742       /* receive interim response */
743       if (!receive_smb(Client,inbuf,SHORT_TIMEOUT) || CVAL(inbuf,smb_rcls) != 0)
744         {
745           DEBUG(0,("%s request failed (%s)\n",
746                    trans==SMBtrans?"SMBtrans":"SMBtrans2", smb_errstr(inbuf)));
747           return(False);
748         }      
749
750       tot_data = this_ldata;
751       tot_param = this_lparam;
752
753       while (tot_data < ldata || tot_param < lparam)
754     {
755           this_lparam = MIN(lparam-tot_param,max_xmit - 500); /* hack */
756           this_ldata = MIN(ldata-tot_data,max_xmit - (500+this_lparam));
757
758           set_message(outbuf,trans==SMBtrans?8:9,0,True);
759           CVAL(outbuf,smb_com) = trans==SMBtrans ? SMBtranss : SMBtranss2;
760
761           outparam = smb_buf(outbuf);
762           outdata = outparam+this_lparam;
763
764           /* secondary request */
765           SSVAL(outbuf,smb_tpscnt,lparam);      /* tpscnt */
766           SSVAL(outbuf,smb_tdscnt,ldata);       /* tdscnt */
767           SSVAL(outbuf,smb_spscnt,this_lparam); /* pscnt */
768           SSVAL(outbuf,smb_spsoff,smb_offset(outparam,outbuf)); /* psoff */
769           SSVAL(outbuf,smb_spsdisp,tot_param);  /* psdisp */
770           SSVAL(outbuf,smb_sdscnt,this_ldata);  /* dscnt */
771           SSVAL(outbuf,smb_sdsoff,smb_offset(outdata,outbuf)); /* dsoff */
772           SSVAL(outbuf,smb_sdsdisp,tot_data);   /* dsdisp */
773           if (trans==SMBtrans2)
774             SSVAL(outbuf,smb_sfid,fid);         /* fid */
775           if (this_lparam)                      /* param[] */
776             memcpy(outparam,param,this_lparam);
777           if (this_ldata)                       /* data[] */
778             memcpy(outdata,data,this_ldata);
779           set_message(outbuf,trans==SMBtrans?8:9, /* wcnt, bcc */
780                       PTR_DIFF(outdata+this_ldata,smb_buf(outbuf)),False);
781
782           show_msg(outbuf);
783           send_smb(Client,outbuf);
784
785           tot_data += this_ldata;
786           tot_param += this_lparam;
787         }
788     }
789
790     return(True);
791 }
792
793
794 /****************************************************************************
795 open the client sockets
796 ****************************************************************************/
797 BOOL cli_open_sockets(int port)
798 {
799   static int last_port;
800   char *host;
801   pstring service2;
802   extern int Client;
803
804   if (port == 0) port=last_port;
805   last_port=port;
806
807   strupper(service);
808
809   if (*desthost)
810     {
811       host = desthost;
812     }
813   else
814     {
815       pstrcpy(service2,service);
816       host = strtok(service2,"\\/");
817       pstrcpy(desthost,host);
818     }
819
820   DEBUG(5,("Opening sockets\n"));
821
822   if (*myname == 0)
823     get_myname(myname,NULL);
824   strupper(myname);
825
826   if (!have_ip)
827     {
828       struct hostent *hp;
829
830       if ((hp = Get_Hostbyname(host)) == 0) 
831         {
832           DEBUG(0,("Get_Hostbyname: Unknown host %s.\n",host));
833           return False;
834         }
835
836       putip((char *)&dest_ip,(char *)hp->h_addr);
837     }
838
839   Client = open_socket_out(SOCK_STREAM, &dest_ip, port, SHORT_CONNECT_TIMEOUT);
840   if (Client == -1)
841     return False;
842
843   DEBUG(5,("Connected\n"));
844
845   set_socket_options(Client,user_socket_options);  
846
847   return True;
848 }
849
850 /****************************************************************************
851 close and open the connection again
852 ****************************************************************************/
853 BOOL cli_reopen_connection(char *inbuf,char *outbuf)
854 {
855   static int open_count=0;
856
857   open_count++;
858
859   if (open_count>5) return(False);
860
861   DEBUG(1,("Trying to re-open connection\n"));
862
863   set_message(outbuf,0,0,True);
864   SCVAL(outbuf,smb_com,SMBtdis);
865   SSVAL(outbuf,smb_tid,cnum);
866   cli_setup_pkt(outbuf);
867
868   send_smb(Client,outbuf);
869   receive_smb(Client,inbuf,SHORT_TIMEOUT);
870
871   close_sockets();
872   if (!cli_open_sockets(0)) return(False);
873
874   return(cli_send_login(inbuf,outbuf,True,True));
875 }
876
877 /* error code stuff - put together by Merik Karman
878    merik@blackadder.dsh.oz.au */
879
880 typedef struct
881 {
882   char *name;
883   int code;
884   char *message;
885 } err_code_struct;
886
887 /* Dos Error Messages */
888 err_code_struct dos_msgs[] = {
889   {"ERRbadfunc",1,"Invalid function."},
890   {"ERRbadfile",2,"File not found."},
891   {"ERRbadpath",3,"Directory invalid."},
892   {"ERRnofids",4,"No file descriptors available"},
893   {"ERRnoaccess",5,"Access denied."},
894   {"ERRbadfid",6,"Invalid file handle."},
895   {"ERRbadmcb",7,"Memory control blocks destroyed."},
896   {"ERRnomem",8,"Insufficient server memory to perform the requested function."},
897   {"ERRbadmem",9,"Invalid memory block address."},
898   {"ERRbadenv",10,"Invalid environment."},
899   {"ERRbadformat",11,"Invalid format."},
900   {"ERRbadaccess",12,"Invalid open mode."},
901   {"ERRbaddata",13,"Invalid data."},
902   {"ERR",14,"reserved."},
903   {"ERRbaddrive",15,"Invalid drive specified."},
904   {"ERRremcd",16,"A Delete Directory request attempted  to  remove  the  server's  current directory."},
905   {"ERRdiffdevice",17,"Not same device."},
906   {"ERRnofiles",18,"A File Search command can find no more files matching the specified criteria."},
907   {"ERRbadshare",32,"The sharing mode specified for an Open conflicts with existing  FIDs  on the file."},
908   {"ERRlock",33,"A Lock request conflicted with an existing lock or specified an  invalid mode,  or an Unlock requested attempted to remove a lock held by another process."},
909   {"ERRfilexists",80,"The file named in a Create Directory, Make  New  File  or  Link  request already exists."},
910   {"ERRbadpipe",230,"Pipe invalid."},
911   {"ERRpipebusy",231,"All instances of the requested pipe are busy."},
912   {"ERRpipeclosing",232,"Pipe close in progress."},
913   {"ERRnotconnected",233,"No process on other end of pipe."},
914   {"ERRmoredata",234,"There is more data to be returned."},
915   {NULL,-1,NULL}};
916
917 /* Server Error Messages */
918 err_code_struct server_msgs[] = {
919   {"ERRerror",1,"Non-specific error code."},
920   {"ERRbadpw",2,"Bad password - name/password pair in a Tree Connect or Session Setup are invalid."},
921   {"ERRbadtype",3,"reserved."},
922   {"ERRaccess",4,"The requester does not have  the  necessary  access  rights  within  the specified  context for the requested function. The context is defined by the TID or the UID."},
923   {"ERRinvnid",5,"The tree ID (TID) specified in a command was invalid."},
924   {"ERRinvnetname",6,"Invalid network name in tree connect."},
925   {"ERRinvdevice",7,"Invalid device - printer request made to non-printer connection or  non-printer request made to printer connection."},
926   {"ERRqfull",49,"Print queue full (files) -- returned by open print file."},
927   {"ERRqtoobig",50,"Print queue full -- no space."},
928   {"ERRqeof",51,"EOF on print queue dump."},
929   {"ERRinvpfid",52,"Invalid print file FID."},
930   {"ERRsmbcmd",64,"The server did not recognize the command received."},
931   {"ERRsrverror",65,"The server encountered an internal error, e.g., system file unavailable."},
932   {"ERRfilespecs",67,"The file handle (FID) and pathname parameters contained an invalid  combination of values."},
933   {"ERRreserved",68,"reserved."},
934   {"ERRbadpermits",69,"The access permissions specified for a file or directory are not a valid combination.  The server cannot set the requested attribute."},
935   {"ERRreserved",70,"reserved."},
936   {"ERRsetattrmode",71,"The attribute mode in the Set File Attribute request is invalid."},
937   {"ERRpaused",81,"Server is paused."},
938   {"ERRmsgoff",82,"Not receiving messages."},
939   {"ERRnoroom",83,"No room to buffer message."},
940   {"ERRrmuns",87,"Too many remote user names."},
941   {"ERRtimeout",88,"Operation timed out."},
942   {"ERRnoresource",89,"No resources currently available for request."},
943   {"ERRtoomanyuids",90,"Too many UIDs active on this session."},
944   {"ERRbaduid",91,"The UID is not known as a valid ID on this session."},
945   {"ERRusempx",250,"Temp unable to support Raw, use MPX mode."},
946   {"ERRusestd",251,"Temp unable to support Raw, use standard read/write."},
947   {"ERRcontmpx",252,"Continue in MPX mode."},
948   {"ERRreserved",253,"reserved."},
949   {"ERRreserved",254,"reserved."},
950   {"ERRnosupport",0xFFFF,"Function not supported."},
951   {NULL,-1,NULL}};
952
953 /* Hard Error Messages */
954 err_code_struct hard_msgs[] = {
955   {"ERRnowrite",19,"Attempt to write on write-protected diskette."},
956   {"ERRbadunit",20,"Unknown unit."},
957   {"ERRnotready",21,"Drive not ready."},
958   {"ERRbadcmd",22,"Unknown command."},
959   {"ERRdata",23,"Data error (CRC)."},
960   {"ERRbadreq",24,"Bad request structure length."},
961   {"ERRseek",25 ,"Seek error."},
962   {"ERRbadmedia",26,"Unknown media type."},
963   {"ERRbadsector",27,"Sector not found."},
964   {"ERRnopaper",28,"Printer out of paper."},
965   {"ERRwrite",29,"Write fault."},
966   {"ERRread",30,"Read fault."},
967   {"ERRgeneral",31,"General failure."},
968   {"ERRbadshare",32,"A open conflicts with an existing open."},
969   {"ERRlock",33,"A Lock request conflicted with an existing lock or specified an invalid mode, or an Unlock requested attempted to remove a lock held by another process."},
970   {"ERRwrongdisk",34,"The wrong disk was found in a drive."},
971   {"ERRFCBUnavail",35,"No FCBs are available to process request."},
972   {"ERRsharebufexc",36,"A sharing buffer has been exceeded."},
973   {NULL,-1,NULL}};
974
975
976 struct
977 {
978   int code;
979   char *class;
980   err_code_struct *err_msgs;
981 } err_classes[] = { 
982   {0,"SUCCESS",NULL},
983   {0x01,"ERRDOS",dos_msgs},
984   {0x02,"ERRSRV",server_msgs},
985   {0x03,"ERRHRD",hard_msgs},
986   {0x04,"ERRXOS",NULL},
987   {0xE1,"ERRRMX1",NULL},
988   {0xE2,"ERRRMX2",NULL},
989   {0xE3,"ERRRMX3",NULL},
990   {0xFF,"ERRCMD",NULL},
991   {-1,NULL,NULL}};
992
993
994 /****************************************************************************
995 return a SMB error string from a SMB buffer
996 ****************************************************************************/
997 char *smb_errstr(char *inbuf)
998 {
999   static pstring ret;
1000   int class = CVAL(inbuf,smb_rcls);
1001   int num = SVAL(inbuf,smb_err);
1002   int i,j;
1003
1004   for (i=0;err_classes[i].class;i++)
1005     if (err_classes[i].code == class)
1006       {
1007         if (err_classes[i].err_msgs)
1008           {
1009             err_code_struct *err = err_classes[i].err_msgs;
1010             for (j=0;err[j].name;j++)
1011               if (num == err[j].code)
1012                 {
1013                   if (DEBUGLEVEL > 0)
1014                     sprintf(ret,"%s - %s (%s)",err_classes[i].class,
1015                             err[j].name,err[j].message);
1016                   else
1017                     sprintf(ret,"%s - %s",err_classes[i].class,err[j].name);
1018                   return ret;
1019                 }
1020           }
1021
1022         sprintf(ret,"%s - %d",err_classes[i].class,num);
1023         return ret;
1024       }
1025   
1026   sprintf(ret,"ERROR: Unknown error (%d,%d)",class,num);
1027   return(ret);
1028 }