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