source/libsmb/clientgen.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    SMB client generic functions
   5    Copyright (C) Andrew Tridgell 1994-1998
   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 #include "trans2.h"
  28
  29
  30 extern int DEBUGLEVEL;
  31
  32 /*****************************************************
  33  RAP error codes - a small start but will be extended.
  34 *******************************************************/
  35
  36 struct
  37 {
  38   int err;
  39   char *message;
  40 } rap_errmap[] =
  41 {
  42   {5,    "User has insufficient privilege" },
  43   {86,   "The specified password is invalid" },
  44   {2226, "Operation only permitted on a Primary Domain Controller"  },
  45   {2242, "The password of this user has expired." },
  46   {2243, "The password of this user cannot change." },
  47   {2244, "This password cannot be used now (password history conflict)." },
  48   {2245, "The password is shorter than required." },
  49   {2246, "The password of this user is too recent to change."},
  50   {0, NULL}
  51 };
  52
  53 /****************************************************************************
  54   return a description of an SMB error
  55 ****************************************************************************/
  56 char *cli_smb_errstr(struct cli_state *cli)
  57 {
  58         return smb_errstr(cli->inbuf);
  59 }
  60
  61 /******************************************************
  62  Return an error message - either an SMB error or a RAP
  63  error.
  64 *******************************************************/
  65
  66 char *cli_errstr(struct cli_state *cli)
  67 {
  68   static fstring error_message;
  69   int errclass;
  70   int errnum;
  71   int i;
  72
  73   /*
  74    * Errors are of three kinds - smb errors,
  75    * dealt with by cli_smb_errstr, NT errors,
  76    * whose code is in cli.nt_error, and rap
  77    * errors, whose error code is in cli.rap_error.
  78    */
  79
  80   cli_error(cli, &errclass, &errnum);
  81   if(errclass != 0)
  82     return cli_smb_errstr(cli);
  83
  84   /*
  85    * Was it an NT error ?
  86    */
  87
  88   if(cli->nt_error) {
  89     char *nt_msg = get_nt_error_msg(cli->nt_error);
  90
  91     if(nt_msg == NULL)
  92       sprintf(error_message, "NT code %d", cli->nt_error);
  93     else
  94       fstrcpy(error_message, nt_msg);
  95
  96     return error_message;
  97   }
  98
  99   /*
 100    * Must have been a rap error.
 101    */
 102
 103   sprintf(error_message, "code %d", cli->rap_error);
 104
 105   for(i = 0; rap_errmap[i].message != NULL; i++) {
 106     if (rap_errmap[i].err == cli->rap_error) {
 107       fstrcpy( error_message, rap_errmap[i].message);
 108       break;
 109     }
 110   }
 111
 112   return error_message;
 113 }
 114
 115 /****************************************************************************
 116 setup basics in a outgoing packet
 117 ****************************************************************************/
 118 static void cli_setup_packet(struct cli_state *cli)
 119 {
 120         cli->rap_error = 0;
 121         cli->nt_error = 0;
 122         SSVAL(cli->outbuf,smb_pid,cli->pid);
 123         SSVAL(cli->outbuf,smb_uid,cli->uid);
 124         SSVAL(cli->outbuf,smb_mid,cli->mid);
 125         if (cli->protocol > PROTOCOL_CORE) {
 126                 SCVAL(cli->outbuf,smb_flg,0x8);
 127                 SSVAL(cli->outbuf,smb_flg2,0x1);
 128         }
 129 }
 130
 131
 132 /****************************************************************************
 133   send a SMB trans or trans2 request
 134   ****************************************************************************/
 135 static BOOL cli_send_trans(struct cli_state *cli, int trans,
 136                            char *name, int pipe_name_len,
 137                            int fid, int flags,
 138                            uint16 *setup, int lsetup, int msetup,
 139                            char *param, int lparam, int mparam,
 140                            char *data, int ldata, int mdata)
 141 {
 142         int i;
 143         int this_ldata,this_lparam;
 144         int tot_data=0,tot_param=0;
 145         char *outdata,*outparam;
 146         char *p;
 147
 148         this_lparam = MIN(lparam,cli->max_xmit - (500+lsetup*2)); /* hack */
 149         this_ldata = MIN(ldata,cli->max_xmit - (500+lsetup*2+this_lparam));
 150
 151         bzero(cli->outbuf,smb_size);
 152         set_message(cli->outbuf,14+lsetup,0,True);
 153         CVAL(cli->outbuf,smb_com) = trans;
 154         SSVAL(cli->outbuf,smb_tid, cli->cnum);
 155         cli_setup_packet(cli);
 156
 157         outparam = smb_buf(cli->outbuf)+(trans==SMBtrans ? pipe_name_len+1 : 3);
 158         outdata = outparam+this_lparam;
 159
 160         /* primary request */
 161         SSVAL(cli->outbuf,smb_tpscnt,lparam);   /* tpscnt */
 162         SSVAL(cli->outbuf,smb_tdscnt,ldata);    /* tdscnt */
 163         SSVAL(cli->outbuf,smb_mprcnt,mparam);   /* mprcnt */
 164         SSVAL(cli->outbuf,smb_mdrcnt,mdata);    /* mdrcnt */
 165         SCVAL(cli->outbuf,smb_msrcnt,msetup);   /* msrcnt */
 166         SSVAL(cli->outbuf,smb_flags,flags);     /* flags */
 167         SIVAL(cli->outbuf,smb_timeout,0);               /* timeout */
 168         SSVAL(cli->outbuf,smb_pscnt,this_lparam);       /* pscnt */
 169         SSVAL(cli->outbuf,smb_psoff,smb_offset(outparam,cli->outbuf)); /* psoff */
 170         SSVAL(cli->outbuf,smb_dscnt,this_ldata);        /* dscnt */
 171         SSVAL(cli->outbuf,smb_dsoff,smb_offset(outdata,cli->outbuf)); /* dsoff */
 172         SCVAL(cli->outbuf,smb_suwcnt,lsetup);   /* suwcnt */
 173         for (i=0;i<lsetup;i++)          /* setup[] */
 174                 SSVAL(cli->outbuf,smb_setup+i*2,setup[i]);
 175         p = smb_buf(cli->outbuf);
 176         if (trans==SMBtrans) {
 177                 memcpy(p,name, pipe_name_len + 1);  /* name[] */
 178         } else {
 179                 *p++ = 0;  /* put in a null smb_name */
 180                 *p++ = 'D'; *p++ = ' '; /* observed in OS/2 */
 181         }
 182         if (this_lparam)                        /* param[] */
 183                 memcpy(outparam,param,this_lparam);
 184         if (this_ldata)                 /* data[] */
 185                 memcpy(outdata,data,this_ldata);
 186         set_message(cli->outbuf,14+lsetup,              /* wcnt, bcc */
 187                     PTR_DIFF(outdata+this_ldata,smb_buf(cli->outbuf)),False);
 188
 189         show_msg(cli->outbuf);
 190         send_smb(cli->fd,cli->outbuf);
 191
 192         if (this_ldata < ldata || this_lparam < lparam) {
 193                 /* receive interim response */
 194                 if (!client_receive_smb(cli->fd,cli->inbuf,cli->timeout) ||
 195                     CVAL(cli->inbuf,smb_rcls) != 0) {
 196                         return(False);
 197                 }
 198
 199                 tot_data = this_ldata;
 200                 tot_param = this_lparam;
 201
 202                 while (tot_data < ldata || tot_param < lparam)  {
 203                         this_lparam = MIN(lparam-tot_param,cli->max_xmit - 500); /* hack */
 204                         this_ldata = MIN(ldata-tot_data,cli->max_xmit - (500+this_lparam));
 205
 206                         set_message(cli->outbuf,trans==SMBtrans?8:9,0,True);
 207                         CVAL(cli->outbuf,smb_com) = trans==SMBtrans ? SMBtranss : SMBtranss2;
 208
 209                         outparam = smb_buf(cli->outbuf);
 210                         outdata = outparam+this_lparam;
 211
 212                         /* secondary request */
 213                         SSVAL(cli->outbuf,smb_tpscnt,lparam);   /* tpscnt */
 214                         SSVAL(cli->outbuf,smb_tdscnt,ldata);    /* tdscnt */
 215                         SSVAL(cli->outbuf,smb_spscnt,this_lparam);      /* pscnt */
 216                         SSVAL(cli->outbuf,smb_spsoff,smb_offset(outparam,cli->outbuf)); /* psoff */
 217                         SSVAL(cli->outbuf,smb_spsdisp,tot_param);       /* psdisp */
 218                         SSVAL(cli->outbuf,smb_sdscnt,this_ldata);       /* dscnt */
 219                         SSVAL(cli->outbuf,smb_sdsoff,smb_offset(outdata,cli->outbuf)); /* dsoff */
 220                         SSVAL(cli->outbuf,smb_sdsdisp,tot_data);        /* dsdisp */
 221                         if (trans==SMBtrans2)
 222                                 SSVALS(cli->outbuf,smb_sfid,fid);               /* fid */
 223                         if (this_lparam)                        /* param[] */
 224                                 memcpy(outparam,param,this_lparam);
 225                         if (this_ldata)                 /* data[] */
 226                                 memcpy(outdata,data,this_ldata);
 227                         set_message(cli->outbuf,trans==SMBtrans?8:9, /* wcnt, bcc */
 228                                     PTR_DIFF(outdata+this_ldata,smb_buf(cli->outbuf)),False);
 229
 230                         show_msg(cli->outbuf);
 231                         send_smb(cli->fd,cli->outbuf);
 232
 233                         tot_data += this_ldata;
 234                         tot_param += this_lparam;
 235                 }
 236         }
 237
 238         return(True);
 239 }
 240
 241
 242 /****************************************************************************
 243   receive a SMB trans or trans2 response allocating the necessary memory
 244   ****************************************************************************/
 245 static BOOL cli_receive_trans(struct cli_state *cli,int trans,
 246                               char **param, int *param_len,
 247                               char **data, int *data_len)
 248 {
 249         int total_data=0;
 250         int total_param=0;
 251         int this_data,this_param;
 252
 253         *data_len = *param_len = 0;
 254
 255         if (!client_receive_smb(cli->fd,cli->inbuf,cli->timeout))
 256                 return False;
 257
 258         show_msg(cli->inbuf);
 259
 260         /* sanity check */
 261         if (CVAL(cli->inbuf,smb_com) != trans) {
 262                 DEBUG(0,("Expected %s response, got command 0x%02x\n",
 263                          trans==SMBtrans?"SMBtrans":"SMBtrans2",
 264                          CVAL(cli->inbuf,smb_com)));
 265                 return(False);
 266         }
 267         if (CVAL(cli->inbuf,smb_rcls) != 0)
 268                 return(False);
 269
 270         /* parse out the lengths */
 271         total_data = SVAL(cli->inbuf,smb_tdrcnt);
 272         total_param = SVAL(cli->inbuf,smb_tprcnt);
 273
 274         /* allocate it */
 275         *data = Realloc(*data,total_data);
 276         *param = Realloc(*param,total_param);
 277
 278         while (1)  {
 279                 this_data = SVAL(cli->inbuf,smb_drcnt);
 280                 this_param = SVAL(cli->inbuf,smb_prcnt);
 281
 282                 if (this_data + *data_len > total_data ||
 283                     this_param + *param_len > total_param) {
 284                         DEBUG(1,("Data overflow in cli_receive_trans\n"));
 285                         return False;
 286                 }
 287
 288                 if (this_data)
 289                         memcpy(*data + SVAL(cli->inbuf,smb_drdisp),
 290                                smb_base(cli->inbuf) + SVAL(cli->inbuf,smb_droff),
 291                                this_data);
 292                 if (this_param)
 293                         memcpy(*param + SVAL(cli->inbuf,smb_prdisp),
 294                                smb_base(cli->inbuf) + SVAL(cli->inbuf,smb_proff),
 295                                this_param);
 296                 *data_len += this_data;
 297                 *param_len += this_param;
 298
 299                 /* parse out the total lengths again - they can shrink! */
 300                 total_data = SVAL(cli->inbuf,smb_tdrcnt);
 301                 total_param = SVAL(cli->inbuf,smb_tprcnt);
 302
 303                 if (total_data <= *data_len && total_param <= *param_len)
 304                         break;
 305
 306                 if (!client_receive_smb(cli->fd,cli->inbuf,cli->timeout))
 307                         return False;
 308
 309                 show_msg(cli->inbuf);
 310
 311                 /* sanity check */
 312                 if (CVAL(cli->inbuf,smb_com) != trans) {
 313                         DEBUG(0,("Expected %s response, got command 0x%02x\n",
 314                                  trans==SMBtrans?"SMBtrans":"SMBtrans2",
 315                                  CVAL(cli->inbuf,smb_com)));
 316                         return(False);
 317                 }
 318                 if (CVAL(cli->inbuf,smb_rcls) != 0)
 319                         return(False);
 320         }
 321
 322         return(True);
 323 }
 324
 325 /****************************************************************************
 326 Call a remote api on an arbitrary pipe.  takes param, data and setup buffers.
 327 ****************************************************************************/
 328 BOOL cli_api_pipe(struct cli_state *cli, char *pipe_name, int pipe_name_len,
 329                   uint16 *setup, uint32 setup_count, uint32 max_setup_count,
 330                   char *params, uint32 param_count, uint32 max_param_count,
 331                   char *data, uint32 data_count, uint32 max_data_count,
 332                   char **rparam, uint32 *rparam_count,
 333                   char **rdata, uint32 *rdata_count)
 334 {
 335   if(pipe_name_len == 0)
 336     pipe_name_len = strlen(pipe_name);
 337
 338   cli_send_trans(cli, SMBtrans,
 339                  pipe_name, pipe_name_len,
 340                  0,0,                         /* fid, flags */
 341                  setup, setup_count, max_setup_count,
 342                  params, param_count, max_param_count,
 343                  data, data_count, max_data_count);
 344
 345   return (cli_receive_trans(cli, SMBtrans,
 346                             rparam, rparam_count,
 347                             rdata, rdata_count));
 348 }
 349
 350 /****************************************************************************
 351 call a remote api
 352 ****************************************************************************/
 353 static BOOL cli_api(struct cli_state *cli,
 354                     char *param, int prcnt, int mprcnt,
 355                     char *data, int drcnt, int mdrcnt,
 356                     char **rparam, int *rprcnt,
 357                     char **rdata, int *rdrcnt)
 358 {
 359   cli_send_trans(cli,SMBtrans,
 360                  PIPE_LANMAN,strlen(PIPE_LANMAN), /* Name, length */
 361                  0,0,                             /* fid, flags */
 362                  NULL,0,0,                /* Setup, length, max */
 363                  param, prcnt, mprcnt,    /* Params, length, max */
 364                  data, drcnt, mdrcnt      /* Data, length, max */
 365                 );
 366
 367   return (cli_receive_trans(cli,SMBtrans,
 368                             rparam, rprcnt,
 369                             rdata, rdrcnt));
 370 }
 371
 372
 373 /****************************************************************************
 374 perform a NetWkstaUserLogon
 375 ****************************************************************************/
 376 BOOL cli_NetWkstaUserLogon(struct cli_state *cli,char *user, char *workstation)
 377 {
 378         char *rparam = NULL;
 379         char *rdata = NULL;
 380         char *p;
 381         int rdrcnt,rprcnt;
 382         pstring param;
 383
 384         memset(param, 0, sizeof(param));
 385
 386         /* send a SMBtrans command with api NetWkstaUserLogon */
 387         p = param;
 388         SSVAL(p,0,132); /* api number */
 389         p += 2;
 390         strcpy(p,"OOWb54WrLh");
 391         p = skip_string(p,1);
 392         strcpy(p,"WB21BWDWWDDDDDDDzzzD");
 393         p = skip_string(p,1);
 394         SSVAL(p,0,1);
 395         p += 2;
 396         strcpy(p,user);
 397         strupper(p);
 398         p += 21; p++; p += 15; p++;
 399         strcpy(p, workstation);
 400         strupper(p);
 401         p += 16;
 402         SSVAL(p, 0, BUFFER_SIZE);
 403         p += 2;
 404         SSVAL(p, 0, BUFFER_SIZE);
 405         p += 2;
 406
 407         if (cli_api(cli,
 408                     param, PTR_DIFF(p,param),1024,  /* param, length, max */
 409                     NULL, 0, BUFFER_SIZE,           /* data, length, max */
 410                     &rparam, &rprcnt,               /* return params, return size */
 411                     &rdata, &rdrcnt                 /* return data, return size */
 412                    )) {
 413                 cli->rap_error = SVAL(rparam,0);
 414                 p = rdata;
 415
 416                 if (cli->rap_error == 0) {
 417                         DEBUG(4,("NetWkstaUserLogon success\n"));
 418                         cli->privilages = SVAL(p, 24);
 419                         fstrcpy(cli->eff_name,p+2);
 420                 } else {
 421                         DEBUG(1,("NetwkstaUserLogon gave error %d\n", cli->rap_error));
 422                 }
 423         }
 424
 425         if (rparam) free(rparam);
 426         if (rdata) free(rdata);
 427         return (cli->rap_error == 0);
 428 }
 429
 430 /****************************************************************************
 431 call a NetShareEnum - try and browse available connections on a host
 432 ****************************************************************************/
 433 BOOL cli_RNetShareEnum(struct cli_state *cli, void (*fn)(char *, uint32, char *))
 434 {
 435   char *rparam = NULL;
 436   char *rdata = NULL;
 437   char *p;
 438   int rdrcnt,rprcnt;
 439   pstring param;
 440   int count = -1;
 441
 442   /* now send a SMBtrans command with api RNetShareEnum */
 443   p = param;
 444   SSVAL(p,0,0); /* api number */
 445   p += 2;
 446   strcpy(p,"WrLeh");
 447   p = skip_string(p,1);
 448   strcpy(p,"B13BWz");
 449   p = skip_string(p,1);
 450   SSVAL(p,0,1);
 451   SSVAL(p,2,BUFFER_SIZE);
 452   p += 4;
 453
 454   if (cli_api(cli,
 455               PTR_DIFF(p,param),
 456               0, /* data count */
 457               1024, /* mprcount */
 458               BUFFER_SIZE, /* mdrcount */
 459               &rprcnt, &rdrcnt,
 460               param,NULL,
 461               &rparam,&rdata))
 462     {
 463       int res = SVAL(rparam,0);
 464       int converter=SVAL(rparam,2);
 465       int i;
 466       BOOL long_share_name=False;
 467
 468       if (res == 0)
 469         {
 470           count=SVAL(rparam,4);
 471           p = rdata;
 472
 473           for (i=0;i<count;i++,p+=20)
 474             {
 475               char *sname = p;
 476               int type = SVAL(p,14);
 477               int comment_offset = IVAL(p,16) & 0xFFFF;
 478               char *cmnt = comment_offset?(rdata+comment_offset-converter):"";
 479               fn(sname, type, cmnt);
 480             }
 481         }
 482     }
 483
 484   if (rparam) free(rparam);
 485   if (rdata) free(rdata);
 486
 487   return(count>0);
 488 }
 489
 490 /****************************************************************************
 491 call a NetServerEnum for the specified workgroup and servertype mask.
 492 This function then calls the specified callback function for each name returned.
 493
 494 The callback function takes 3 arguments: the machine name, the server type and
 495 the comment.
 496 ****************************************************************************/
 497 BOOL cli_NetServerEnum(struct cli_state *cli, char *workgroup, uint32 stype,
 498                        void (*fn)(char *, uint32, char *))
 499 {
 500         char *rparam = NULL;
 501         char *rdata = NULL;
 502         int rdrcnt,rprcnt;
 503         char *p;
 504         pstring param;
 505         int uLevel = 1;
 506         int count = -1;
 507
 508         /* send a SMBtrans command with api NetServerEnum */
 509         p = param;
 510         SSVAL(p,0,0x68); /* api number */
 511         p += 2;
 512         strcpy(p,"WrLehDz");
 513         p = skip_string(p,1);
 514
 515         strcpy(p,"B16BBDz");
 516
 517         p = skip_string(p,1);
 518         SSVAL(p,0,uLevel);
 519         SSVAL(p,2,BUFFER_SIZE);
 520         p += 4;
 521         SIVAL(p,0,stype);
 522         p += 4;
 523
 524         pstrcpy(p, workgroup);
 525         p = skip_string(p,1);
 526
 527         if (cli_api(cli,
 528                     param, PTR_DIFF(p,param), 8,        /* params, length, max */
 529                     NULL, 0, BUFFER_SIZE,               /* data, length, max */
 530                     &rparam, &rprcnt,                   /* return params, return size */
 531                     &rdata, &rdrcnt                     /* return data, return size */
 532                    )) {
 533                 int res = SVAL(rparam,0);
 534                 int converter=SVAL(rparam,2);
 535                 int i;
 536
 537                 if (res == 0) {
 538                         count=SVAL(rparam,4);
 539                         p = rdata;
 540
 541                         for (i = 0;i < count;i++, p += 26) {
 542                                 char *sname = p;
 543                                 int comment_offset = (IVAL(p,22) & 0xFFFF)-converter;
 544                                 char *cmnt = comment_offset?(rdata+comment_offset):"";
 545                                 if (comment_offset < 0 || comment_offset > rdrcnt) continue;
 546
 547                                 stype = IVAL(p,18) & ~SV_TYPE_LOCAL_LIST_ONLY;
 548
 549                                 fn(sname, stype, cmnt);
 550                         }
 551                 }
 552         }
 553
 554         if (rparam) free(rparam);
 555         if (rdata) free(rdata);
 556
 557         return(count > 0);
 558 }
 559
 560
 561
 562
 563 static  struct {
 564     int prot;
 565     char *name;
 566   }
 567 prots[] =
 568     {
 569       {PROTOCOL_CORE,"PC NETWORK PROGRAM 1.0"},
 570       {PROTOCOL_COREPLUS,"MICROSOFT NETWORKS 1.03"},
 571       {PROTOCOL_LANMAN1,"MICROSOFT NETWORKS 3.0"},
 572       {PROTOCOL_LANMAN1,"LANMAN1.0"},
 573       {PROTOCOL_LANMAN2,"LM1.2X002"},
 574       {PROTOCOL_LANMAN2,"Samba"},
 575       {PROTOCOL_NT1,"NT LM 0.12"},
 576       {PROTOCOL_NT1,"NT LANMAN 1.0"},
 577       {-1,NULL}
 578     };
 579
 580
 581 /****************************************************************************
 582 send a session setup
 583 ****************************************************************************/
 584 BOOL cli_session_setup(struct cli_state *cli,
 585                        char *user,
 586                        char *pass, int passlen,
 587                        char *ntpass, int ntpasslen,
 588                        char *workgroup)
 589 {
 590         char *p;
 591         fstring pword;
 592
 593         if (cli->protocol < PROTOCOL_LANMAN1)
 594                 return True;
 595
 596         if (passlen > sizeof(pword)-1) {
 597                 return False;
 598         }
 599
 600         if ((cli->sec_mode & 2) && passlen != 24) {
 601                 passlen = 24;
 602                 SMBencrypt((uchar *)pass,(uchar *)cli->cryptkey,(uchar *)pword);
 603         } else {
 604                 memcpy(pword, pass, passlen);
 605         }
 606
 607         /* if in share level security then don't send a password now */
 608         if (!(cli->sec_mode & 1)) {fstrcpy(pword, "");passlen=1;}
 609
 610         /* send a session setup command */
 611         bzero(cli->outbuf,smb_size);
 612
 613         if (cli->protocol < PROTOCOL_NT1) {
 614                 set_message(cli->outbuf,10,1 + strlen(user) + passlen,True);
 615                 CVAL(cli->outbuf,smb_com) = SMBsesssetupX;
 616                 cli_setup_packet(cli);
 617
 618                 CVAL(cli->outbuf,smb_vwv0) = 0xFF;
 619                 SSVAL(cli->outbuf,smb_vwv2,cli->max_xmit);
 620                 SSVAL(cli->outbuf,smb_vwv3,2);
 621                 SSVAL(cli->outbuf,smb_vwv4,1);
 622                 SIVAL(cli->outbuf,smb_vwv5,cli->sesskey);
 623                 SSVAL(cli->outbuf,smb_vwv7,passlen);
 624                 p = smb_buf(cli->outbuf);
 625                 memcpy(p,pword,passlen);
 626                 p += passlen;
 627                 strcpy(p,user);
 628                 strupper(p);
 629         } else {
 630                 set_message(cli->outbuf,13,0,True);
 631                 CVAL(cli->outbuf,smb_com) = SMBsesssetupX;
 632                 cli_setup_packet(cli);
 633
 634                 CVAL(cli->outbuf,smb_vwv0) = 0xFF;
 635                 SSVAL(cli->outbuf,smb_vwv2,BUFFER_SIZE);
 636                 SSVAL(cli->outbuf,smb_vwv3,2);
 637                 SSVAL(cli->outbuf,smb_vwv4,cli->pid);
 638                 SIVAL(cli->outbuf,smb_vwv5,cli->sesskey);
 639                 SSVAL(cli->outbuf,smb_vwv7,passlen);
 640                 SSVAL(cli->outbuf,smb_vwv8,ntpasslen);
 641                 p = smb_buf(cli->outbuf);
 642                 memcpy(p,pword,passlen);
 643                 p += SVAL(cli->outbuf,smb_vwv7);
 644                 memcpy(p,ntpass,ntpasslen);
 645                 p += SVAL(cli->outbuf,smb_vwv8);
 646                 strcpy(p,user);
 647                 strupper(p);
 648                 p = skip_string(p,1);
 649                 strcpy(p,workgroup);
 650                 strupper(p);
 651                 p = skip_string(p,1);
 652                 strcpy(p,"Unix");p = skip_string(p,1);
 653                 strcpy(p,"Samba");p = skip_string(p,1);
 654                 set_message(cli->outbuf,13,PTR_DIFF(p,smb_buf(cli->outbuf)),False);
 655         }
 656
 657       send_smb(cli->fd,cli->outbuf);
 658       if (!client_receive_smb(cli->fd,cli->inbuf,cli->timeout))
 659               return False;
 660
 661       show_msg(cli->inbuf);
 662
 663       if (CVAL(cli->inbuf,smb_rcls) != 0) {
 664               return False;
 665       }
 666
 667       /* use the returned uid from now on */
 668       cli->uid = SVAL(cli->inbuf,smb_uid);
 669
 670       return True;
 671 }
 672
 673 /****************************************************************************
 674  Send a uloggoff.
 675 *****************************************************************************/
 676
 677 BOOL cli_ulogoff(struct cli_state *cli)
 678 {
 679         bzero(cli->outbuf,smb_size);
 680         set_message(cli->outbuf,2,0,True);
 681         CVAL(cli->outbuf,smb_com) = SMBulogoffX;
 682         cli_setup_packet(cli);
 683         SSVAL(cli->outbuf,smb_vwv0,0xFF);
 684         SSVAL(cli->outbuf,smb_vwv2,0);  /* no additional info */
 685
 686         send_smb(cli->fd,cli->outbuf);
 687         if (!client_receive_smb(cli->fd,cli->inbuf,cli->timeout))
 688                 return False;
 689
 690         return CVAL(cli->inbuf,smb_rcls) == 0;
 691 }
 692
 693 /****************************************************************************
 694 send a tconX
 695 ****************************************************************************/
 696 BOOL cli_send_tconX(struct cli_state *cli,
 697                     char *share, char *dev, char *pass, int passlen)
 698 {
 699         fstring fullshare, pword;
 700         char *p;
 701         bzero(cli->outbuf,smb_size);
 702         bzero(cli->inbuf,smb_size);
 703
 704         if (cli->sec_mode & 1) {
 705                 passlen = 1;
 706                 pass = "";
 707         }
 708
 709         if ((cli->sec_mode & 2) && *pass && passlen != 24) {
 710                 passlen = 24;
 711                 SMBencrypt((uchar *)pass,(uchar *)cli->cryptkey,(uchar *)pword);
 712         } else {
 713                 memcpy(pword, pass, passlen);
 714         }
 715
 716         sprintf(fullshare, "\\\\%s\\%s", cli->desthost, share);
 717
 718         set_message(cli->outbuf,4,
 719                     2 + strlen(fullshare) + passlen + strlen(dev),True);
 720         CVAL(cli->outbuf,smb_com) = SMBtconX;
 721         cli_setup_packet(cli);
 722
 723         SSVAL(cli->outbuf,smb_vwv0,0xFF);
 724         SSVAL(cli->outbuf,smb_vwv3,passlen);
 725
 726         p = smb_buf(cli->outbuf);
 727         memcpy(p,pword,passlen);
 728         p += passlen;
 729         strcpy(p,fullshare);
 730         p = skip_string(p,1);
 731         strcpy(p,dev);
 732
 733         SCVAL(cli->inbuf,smb_rcls, 1);
 734
 735         send_smb(cli->fd,cli->outbuf);
 736         if (!client_receive_smb(cli->fd,cli->inbuf,cli->timeout))
 737                 return False;
 738
 739         if (CVAL(cli->inbuf,smb_rcls) != 0) {
 740                 return False;
 741         }
 742
 743         cli->cnum = SVAL(cli->inbuf,smb_tid);
 744         return True;
 745 }
 746
 747
 748 /****************************************************************************
 749 send a tree disconnect
 750 ****************************************************************************/
 751 BOOL cli_tdis(struct cli_state *cli)
 752 {
 753         bzero(cli->outbuf,smb_size);
 754         set_message(cli->outbuf,0,0,True);
 755         CVAL(cli->outbuf,smb_com) = SMBtdis;
 756         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 757         cli_setup_packet(cli);
 758
 759         send_smb(cli->fd,cli->outbuf);
 760         if (!client_receive_smb(cli->fd,cli->inbuf,cli->timeout))
 761                 return False;
 762
 763         return CVAL(cli->inbuf,smb_rcls) == 0;
 764 }
 765
 766 /****************************************************************************
 767 rename a file
 768 ****************************************************************************/
 769 BOOL cli_mv(struct cli_state *cli, char *fname_src, char *fname_dst)
 770 {
 771         char *p;
 772
 773         bzero(cli->outbuf,smb_size);
 774         bzero(cli->inbuf,smb_size);
 775
 776         set_message(cli->outbuf,1, 4 + strlen(fname_src) + strlen(fname_dst), True);
 777
 778         CVAL(cli->outbuf,smb_com) = SMBmv;
 779         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 780         cli_setup_packet(cli);
 781
 782         SSVAL(cli->outbuf,smb_vwv0,aSYSTEM | aHIDDEN);
 783
 784         p = smb_buf(cli->outbuf);
 785         *p++ = 4;
 786         strcpy(p,fname_src);
 787         p = skip_string(p,1);
 788         *p++ = 4;
 789         strcpy(p,fname_dst);
 790
 791         send_smb(cli->fd,cli->outbuf);
 792         if (!client_receive_smb(cli->fd,cli->inbuf,cli->timeout)) {
 793                 return False;
 794         }
 795
 796         if (CVAL(cli->inbuf,smb_rcls) != 0) {
 797                 return False;
 798         }
 799
 800         return True;
 801 }
 802
 803 /****************************************************************************
 804 delete a file
 805 ****************************************************************************/
 806 BOOL cli_unlink(struct cli_state *cli, char *fname)
 807 {
 808         char *p;
 809
 810         bzero(cli->outbuf,smb_size);
 811         bzero(cli->inbuf,smb_size);
 812
 813         set_message(cli->outbuf,1, 2 + strlen(fname),True);
 814
 815         CVAL(cli->outbuf,smb_com) = SMBunlink;
 816         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 817         cli_setup_packet(cli);
 818
 819         SSVAL(cli->outbuf,smb_vwv0,aSYSTEM | aHIDDEN);
 820
 821         p = smb_buf(cli->outbuf);
 822         *p++ = 4;
 823         strcpy(p,fname);
 824
 825         send_smb(cli->fd,cli->outbuf);
 826         if (!client_receive_smb(cli->fd,cli->inbuf,cli->timeout)) {
 827                 return False;
 828         }
 829
 830         if (CVAL(cli->inbuf,smb_rcls) != 0) {
 831                 return False;
 832         }
 833
 834         return True;
 835 }
 836
 837
 838 /****************************************************************************
 839 create a directory
 840 ****************************************************************************/
 841 BOOL cli_mkdir(struct cli_state *cli, char *dname)
 842 {
 843         char *p;
 844
 845         bzero(cli->outbuf,smb_size);
 846         bzero(cli->inbuf,smb_size);
 847
 848         set_message(cli->outbuf,0, 2 + strlen(dname),True);
 849
 850         CVAL(cli->outbuf,smb_com) = SMBmkdir;
 851         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 852         cli_setup_packet(cli);
 853
 854         p = smb_buf(cli->outbuf);
 855         *p++ = 4;
 856         strcpy(p,dname);
 857
 858         send_smb(cli->fd,cli->outbuf);
 859         if (!client_receive_smb(cli->fd,cli->inbuf,cli->timeout)) {
 860                 return False;
 861         }
 862
 863         if (CVAL(cli->inbuf,smb_rcls) != 0) {
 864                 return False;
 865         }
 866
 867         return True;
 868 }
 869
 870 /****************************************************************************
 871 remove a directory
 872 ****************************************************************************/
 873 BOOL cli_rmdir(struct cli_state *cli, char *dname)
 874 {
 875         char *p;
 876
 877         bzero(cli->outbuf,smb_size);
 878         bzero(cli->inbuf,smb_size);
 879
 880         set_message(cli->outbuf,0, 2 + strlen(dname),True);
 881
 882         CVAL(cli->outbuf,smb_com) = SMBrmdir;
 883         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 884         cli_setup_packet(cli);
 885
 886         p = smb_buf(cli->outbuf);
 887         *p++ = 4;
 888         strcpy(p,dname);
 889
 890         send_smb(cli->fd,cli->outbuf);
 891         if (!client_receive_smb(cli->fd,cli->inbuf,cli->timeout)) {
 892                 return False;
 893         }
 894
 895         if (CVAL(cli->inbuf,smb_rcls) != 0) {
 896                 return False;
 897         }
 898
 899         return True;
 900 }
 901
 902
 903
 904 /****************************************************************************
 905 open a file
 906 ****************************************************************************/
 907 int cli_open(struct cli_state *cli, char *fname, int flags, int share_mode)
 908 {
 909         char *p;
 910         unsigned openfn=0;
 911         unsigned accessmode=0;
 912
 913         if (flags & O_CREAT)
 914                 openfn |= (1<<4);
 915         if (!(flags & O_EXCL)) {
 916                 if (flags & O_TRUNC)
 917                         openfn |= (1<<1);
 918                 else
 919                         openfn |= (1<<0);
 920         }
 921
 922         accessmode = (share_mode<<4);
 923
 924         if ((flags & O_RDWR) == O_RDWR) {
 925                 accessmode |= 2;
 926         } else if ((flags & O_WRONLY) == O_WRONLY) {
 927                 accessmode |= 1;
 928         }
 929
 930 #if defined(O_SYNC)
 931         if ((flags & O_SYNC) == O_SYNC) {
 932                 accessmode |= (1<<14);
 933         }
 934 #endif /* O_SYNC */
 935
 936         bzero(cli->outbuf,smb_size);
 937         bzero(cli->inbuf,smb_size);
 938
 939         set_message(cli->outbuf,15,1 + strlen(fname),True);
 940
 941         CVAL(cli->outbuf,smb_com) = SMBopenX;
 942         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 943         cli_setup_packet(cli);
 944
 945         SSVAL(cli->outbuf,smb_vwv0,0xFF);
 946         SSVAL(cli->outbuf,smb_vwv2,0);  /* no additional info */
 947         SSVAL(cli->outbuf,smb_vwv3,accessmode);
 948         SSVAL(cli->outbuf,smb_vwv4,aSYSTEM | aHIDDEN);
 949         SSVAL(cli->outbuf,smb_vwv5,0);
 950         SSVAL(cli->outbuf,smb_vwv8,openfn);
 951
 952         p = smb_buf(cli->outbuf);
 953         strcpy(p,fname);
 954         p = skip_string(p,1);
 955
 956         send_smb(cli->fd,cli->outbuf);
 957         if (!client_receive_smb(cli->fd,cli->inbuf,cli->timeout)) {
 958                 return -1;
 959         }
 960
 961         if (CVAL(cli->inbuf,smb_rcls) != 0) {
 962                 return -1;
 963         }
 964
 965         return SVAL(cli->inbuf,smb_vwv2);
 966 }
 967
 968
 969
 970
 971 /****************************************************************************
 972   close a file
 973 ****************************************************************************/
 974 BOOL cli_close(struct cli_state *cli, int fnum)
 975 {
 976         bzero(cli->outbuf,smb_size);
 977         bzero(cli->inbuf,smb_size);
 978
 979         set_message(cli->outbuf,3,0,True);
 980
 981         CVAL(cli->outbuf,smb_com) = SMBclose;
 982         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 983         cli_setup_packet(cli);
 984
 985         SSVAL(cli->outbuf,smb_vwv0,fnum);
 986         SIVALS(cli->outbuf,smb_vwv1,-1);
 987
 988         send_smb(cli->fd,cli->outbuf);
 989         if (!client_receive_smb(cli->fd,cli->inbuf,cli->timeout)) {
 990                 return False;
 991         }
 992
 993         if (CVAL(cli->inbuf,smb_rcls) != 0) {
 994                 return False;
 995         }
 996
 997         return True;
 998 }
 999
1000
1001 /****************************************************************************
1002   lock a file
1003 ****************************************************************************/
1004 BOOL cli_lock(struct cli_state *cli, int fnum, uint32 offset, uint32 len, int timeout)
1005 {
1006         char *p;
1007
1008         bzero(cli->outbuf,smb_size);
1009         bzero(cli->inbuf,smb_size);
1010
1011         set_message(cli->outbuf,8,10,True);
1012
1013         CVAL(cli->outbuf,smb_com) = SMBlockingX;
1014         SSVAL(cli->outbuf,smb_tid,cli->cnum);
1015         cli_setup_packet(cli);
1016
1017         CVAL(cli->outbuf,smb_vwv0) = 0xFF;
1018         SSVAL(cli->outbuf,smb_vwv2,fnum);
1019         CVAL(cli->outbuf,smb_vwv3) = 0;
1020         SIVALS(cli->outbuf, smb_vwv4, timeout);
1021         SSVAL(cli->outbuf,smb_vwv6,0);
1022         SSVAL(cli->outbuf,smb_vwv7,1);
1023
1024         p = smb_buf(cli->outbuf);
1025         SSVAL(p, 0, cli->pid);
1026         SIVAL(p, 2, offset);
1027         SIVAL(p, 6, len);
1028
1029         send_smb(cli->fd,cli->outbuf);
1030         if (!client_receive_smb(cli->fd,cli->inbuf,cli->timeout)) {
1031                 return False;
1032         }
1033
1034         if (CVAL(cli->inbuf,smb_rcls) != 0) {
1035                 return False;
1036         }
1037
1038         return True;
1039 }
1040
1041 /****************************************************************************
1042   unlock a file
1043 ****************************************************************************/
1044 BOOL cli_unlock(struct cli_state *cli, int fnum, uint32 offset, uint32 len, int timeout)
1045 {
1046         char *p;
1047
1048         bzero(cli->outbuf,smb_size);
1049         bzero(cli->inbuf,smb_size);
1050
1051         set_message(cli->outbuf,8,10,True);
1052
1053         CVAL(cli->outbuf,smb_com) = SMBlockingX;
1054         SSVAL(cli->outbuf,smb_tid,cli->cnum);
1055         cli_setup_packet(cli);
1056
1057         CVAL(cli->outbuf,smb_vwv0) = 0xFF;
1058         SSVAL(cli->outbuf,smb_vwv2,fnum);
1059         CVAL(cli->outbuf,smb_vwv3) = 0;
1060         SIVALS(cli->outbuf, smb_vwv4, timeout);
1061         SSVAL(cli->outbuf,smb_vwv6,1);
1062         SSVAL(cli->outbuf,smb_vwv7,0);
1063
1064         p = smb_buf(cli->outbuf);
1065         SSVAL(p, 0, cli->pid);
1066         SIVAL(p, 2, offset);
1067         SIVAL(p, 6, len);
1068
1069         send_smb(cli->fd,cli->outbuf);
1070         if (!client_receive_smb(cli->fd,cli->inbuf,cli->timeout)) {
1071                 return False;
1072         }
1073
1074         if (CVAL(cli->inbuf,smb_rcls) != 0) {
1075                 return False;
1076         }
1077
1078         return True;
1079 }
1080
1081
1082 /****************************************************************************
1083   read from a file
1084 ****************************************************************************/
1085 int cli_read(struct cli_state *cli, int fnum, char *buf, uint32 offset, uint16 size)
1086 {
1087         char *p;
1088
1089         bzero(cli->outbuf,smb_size);
1090         bzero(cli->inbuf,smb_size);
1091
1092         set_message(cli->outbuf,10,0,True);
1093
1094         CVAL(cli->outbuf,smb_com) = SMBreadX;
1095         SSVAL(cli->outbuf,smb_tid,cli->cnum);
1096         cli_setup_packet(cli);
1097
1098         CVAL(cli->outbuf,smb_vwv0) = 0xFF;
1099         SSVAL(cli->outbuf,smb_vwv2,fnum);
1100         SIVAL(cli->outbuf,smb_vwv3,offset);
1101         SSVAL(cli->outbuf,smb_vwv5,size);
1102         SSVAL(cli->outbuf,smb_vwv6,size);
1103
1104         send_smb(cli->fd,cli->outbuf);
1105         if (!client_receive_smb(cli->fd,cli->inbuf,cli->timeout)) {
1106                 return -1;
1107         }
1108
1109         if (CVAL(cli->inbuf,smb_rcls) != 0) {
1110                 return -1;
1111         }
1112
1113         size = SVAL(cli->inbuf, smb_vwv5);
1114         p = smb_base(cli->inbuf) + SVAL(cli->inbuf,smb_vwv6);
1115
1116         memcpy(buf, p, size);
1117
1118         return size;
1119 }
1120
1121
1122 /****************************************************************************
1123   write to a file
1124 ****************************************************************************/
1125 int cli_write(struct cli_state *cli, int fnum, char *buf, uint32 offset, uint16 size)
1126 {
1127         char *p;
1128
1129         bzero(cli->outbuf,smb_size);
1130         bzero(cli->inbuf,smb_size);
1131
1132         set_message(cli->outbuf,12,size,True);
1133
1134         CVAL(cli->outbuf,smb_com) = SMBwriteX;
1135         SSVAL(cli->outbuf,smb_tid,cli->cnum);
1136         cli_setup_packet(cli);
1137
1138         CVAL(cli->outbuf,smb_vwv0) = 0xFF;
1139         SSVAL(cli->outbuf,smb_vwv2,fnum);
1140         SIVAL(cli->outbuf,smb_vwv3,offset);
1141
1142         SSVAL(cli->outbuf,smb_vwv10,size);
1143         SSVAL(cli->outbuf,smb_vwv11,smb_buf(cli->outbuf) - smb_base(cli->outbuf));
1144
1145         p = smb_base(cli->outbuf) + SVAL(cli->outbuf,smb_vwv11);
1146         memcpy(p, buf, size);
1147
1148         send_smb(cli->fd,cli->outbuf);
1149         if (!client_receive_smb(cli->fd,cli->inbuf,cli->timeout)) {
1150                 return -1;
1151         }
1152
1153         if (CVAL(cli->inbuf,smb_rcls) != 0) {
1154                 return -1;
1155         }
1156
1157         return SVAL(cli->inbuf, smb_vwv2);
1158 }
1159
1160
1161 /****************************************************************************
1162 do a SMBgetatr call
1163 ****************************************************************************/
1164 BOOL cli_getatr(struct cli_state *cli, char *fname,
1165                 int *attr, uint32 *size, time_t *t)
1166 {
1167         char *p;
1168
1169         bzero(cli->outbuf,smb_size);
1170         bzero(cli->inbuf,smb_size);
1171
1172         set_message(cli->outbuf,0,strlen(fname)+2,True);
1173
1174         CVAL(cli->outbuf,smb_com) = SMBgetatr;
1175         SSVAL(cli->outbuf,smb_tid,cli->cnum);
1176         cli_setup_packet(cli);
1177
1178         p = smb_buf(cli->outbuf);
1179         *p = 4;
1180         strcpy(p+1, fname);
1181
1182         send_smb(cli->fd,cli->outbuf);
1183         if (!client_receive_smb(cli->fd,cli->inbuf,cli->timeout)) {
1184                 return False;
1185         }
1186
1187         if (CVAL(cli->inbuf,smb_rcls) != 0) {
1188                 return False;
1189         }
1190
1191         if (size) {
1192                 *size = IVAL(cli->inbuf, smb_vwv3);
1193         }
1194
1195         if (t) {
1196                 *t = make_unix_date3(cli->inbuf+smb_vwv1);
1197         }
1198
1199         if (attr) {
1200                 *attr = SVAL(cli->inbuf,smb_vwv0);
1201         }
1202
1203
1204         return True;
1205 }
1206
1207
1208 /****************************************************************************
1209 do a SMBsetatr call
1210 ****************************************************************************/
1211 BOOL cli_setatr(struct cli_state *cli, char *fname, int attr, time_t t)
1212 {
1213         char *p;
1214
1215         bzero(cli->outbuf,smb_size);
1216         bzero(cli->inbuf,smb_size);
1217
1218         set_message(cli->outbuf,8,strlen(fname)+4,True);
1219
1220         CVAL(cli->outbuf,smb_com) = SMBsetatr;
1221         SSVAL(cli->outbuf,smb_tid,cli->cnum);
1222         cli_setup_packet(cli);
1223
1224         SSVAL(cli->outbuf,smb_vwv0, attr);
1225         put_dos_date3(cli->outbuf,smb_vwv1, t);
1226
1227         p = smb_buf(cli->outbuf);
1228         *p = 4;
1229         strcpy(p+1, fname);
1230         p = skip_string(p,1);
1231         *p = 4;
1232
1233         send_smb(cli->fd,cli->outbuf);
1234         if (!client_receive_smb(cli->fd,cli->inbuf,cli->timeout)) {
1235                 return False;
1236         }
1237
1238         if (CVAL(cli->inbuf,smb_rcls) != 0) {
1239                 return False;
1240         }
1241
1242         return True;
1243 }
1244
1245 /****************************************************************************
1246 send a qpathinfo call
1247 ****************************************************************************/
1248 BOOL cli_qpathinfo(struct cli_state *cli, char *fname,
1249                    time_t *c_time, time_t *a_time, time_t *m_time, uint32 *size)
1250 {
1251         int data_len = 0;
1252         int param_len = 0;
1253         uint16 setup = TRANSACT2_QPATHINFO;
1254         pstring param;
1255         char *rparam=NULL, *rdata=NULL;
1256
1257         param_len = strlen(fname) + 7;
1258
1259         memset(param, 0, param_len);
1260         SSVAL(param, 0, SMB_INFO_STANDARD);
1261         pstrcpy(&param[6], fname);
1262
1263         if (!cli_send_trans(cli, SMBtrans2,
1264                             NULL, 0,                      /* Name, length */
1265                             -1, 0,                        /* fid, flags */
1266                             &setup, 1, 0,                 /* setup, length, max */
1267                             param, param_len, 10,         /* param, length, max */
1268                             NULL, data_len, cli->max_xmit /* data, length, max */
1269                            )) {
1270                 return False;
1271         }
1272
1273         if (!cli_receive_trans(cli, SMBtrans2,
1274                                &rparam, &param_len,
1275                                &rdata, &data_len)) {
1276                 return False;
1277         }
1278
1279         if (!rdata || data_len < 22) {
1280                 return False;
1281         }
1282
1283         if (c_time) {
1284                 *c_time = make_unix_date2(rdata+0);
1285         }
1286         if (a_time) {
1287                 *a_time = make_unix_date2(rdata+4);
1288         }
1289         if (m_time) {
1290                 *m_time = make_unix_date2(rdata+8);
1291         }
1292         if (size) {
1293                 *size = IVAL(rdata, 12);
1294         }
1295
1296         if (rdata) free(rdata);
1297         if (rparam) free(rparam);
1298         return True;
1299 }
1300
1301 /****************************************************************************
1302 send a qpathinfo call with the SMB_QUERY_FILE_ALL_INFO info level
1303 ****************************************************************************/
1304 BOOL cli_qpathinfo2(struct cli_state *cli, char *fname,
1305                     time_t *c_time, time_t *a_time, time_t *m_time,
1306                     time_t *w_time, uint32 *size)
1307 {
1308         int data_len = 0;
1309         int param_len = 0;
1310         uint16 setup = TRANSACT2_QPATHINFO;
1311         pstring param;
1312         char *rparam=NULL, *rdata=NULL;
1313
1314         param_len = strlen(fname) + 7;
1315
1316         memset(param, 0, param_len);
1317         SSVAL(param, 0, SMB_QUERY_FILE_ALL_INFO);
1318         pstrcpy(&param[6], fname);
1319
1320         if (!cli_send_trans(cli, SMBtrans2,
1321                             NULL, 0,                      /* name, length */
1322                             -1, 0,                        /* fid, flags */
1323                             &setup, 1, 0,                 /* setup, length, max */
1324                             param, param_len, 10,         /* param, length, max */
1325                             NULL, data_len, cli->max_xmit /* data, length, max */
1326                            )) {
1327                 return False;
1328         }
1329
1330         if (!cli_receive_trans(cli, SMBtrans2,
1331                                &rparam, &param_len,
1332                                &rdata, &data_len)) {
1333                 return False;
1334         }
1335
1336         if (!rdata || data_len < 22) {
1337                 return False;
1338         }
1339
1340         if (c_time) {
1341                 *c_time = interpret_long_date(rdata+0) - cli->serverzone;
1342         }
1343         if (a_time) {
1344                 *a_time = interpret_long_date(rdata+8) - cli->serverzone;
1345         }
1346         if (m_time) {
1347                 *m_time = interpret_long_date(rdata+16) - cli->serverzone;
1348         }
1349         if (w_time) {
1350                 *w_time = interpret_long_date(rdata+24) - cli->serverzone;
1351         }
1352         if (size) {
1353                 *size = IVAL(rdata, 40);
1354         }
1355
1356         if (rdata) free(rdata);
1357         if (rparam) free(rparam);
1358         return True;
1359 }
1360
1361
1362 /****************************************************************************
1363 send a qfileinfo call
1364 ****************************************************************************/
1365 BOOL cli_qfileinfo(struct cli_state *cli, int fnum,
1366                    time_t *c_time, time_t *a_time, time_t *m_time, uint32 *size)
1367 {
1368         int data_len = 0;
1369         int param_len = 0;
1370         uint16 setup = TRANSACT2_QFILEINFO;
1371         pstring param;
1372         char *rparam=NULL, *rdata=NULL;
1373
1374         param_len = 4;
1375
1376         memset(param, 0, param_len);
1377         SSVAL(param, 0, fnum);
1378         SSVAL(param, 2, SMB_INFO_STANDARD);
1379
1380         if (!cli_send_trans(cli, SMBtrans2,
1381                             NULL, 0,                        /* name, length */
1382                             -1, 0,                          /* fid, flags */
1383                             &setup, 1, 0,                   /* setup, length, max */
1384                             param, param_len, 2,            /* param, length, max */
1385                             NULL, data_len, cli->max_xmit   /* data, length, max */
1386                            )) {
1387                 return False;
1388         }
1389
1390         if (!cli_receive_trans(cli, SMBtrans2,
1391                                &rparam, &param_len,
1392                                &rdata, &data_len)) {
1393                 return False;
1394         }
1395
1396         if (!rdata || data_len < 22) {
1397                 return False;
1398         }
1399
1400         if (c_time) {
1401                 *c_time = make_unix_date2(rdata+0);
1402         }
1403         if (a_time) {
1404                 *a_time = make_unix_date2(rdata+4);
1405         }
1406         if (m_time) {
1407                 *m_time = make_unix_date2(rdata+8);
1408         }
1409         if (size) {
1410                 *size = IVAL(rdata, 12);
1411         }
1412
1413         if (rdata) free(rdata);
1414         if (rparam) free(rparam);
1415         return True;
1416 }
1417
1418 /****************************************************************************
1419 Send a SamOEMChangePassword command
1420 ****************************************************************************/
1421
1422 BOOL cli_oem_change_password(struct cli_state *cli, char *user, char *new_password,
1423                              char *old_password)
1424 {
1425   char param[16+sizeof(fstring)];
1426   char data[532];
1427   char *p = param;
1428   fstring upper_case_old_pw;
1429   fstring upper_case_new_pw;
1430   unsigned char old_pw_hash[16];
1431   unsigned char new_pw_hash[16];
1432   int data_len;
1433   int param_len = 0;
1434   int new_pw_len = strlen(new_password);
1435   char *rparam = NULL;
1436   char *rdata = NULL;
1437   int rprcnt, rdrcnt;
1438
1439   if(strlen(user) >= sizeof(fstring)-1) {
1440     DEBUG(0,("cli_oem_change_password: user name %s is too long.\n", user));
1441     return False;
1442   }
1443
1444   if(new_pw_len > 512) {
1445     DEBUG(0,("cli_oem_change_password: new password for user %s is too long.\n", user));
1446     return False;
1447   }
1448
1449   SSVAL(p,0,214); /* SamOEMChangePassword command. */
1450   p += 2;
1451   strcpy(p, "zsT");
1452   p = skip_string(p,1);
1453   strcpy(p, "B516B16");
1454   p = skip_string(p,1);
1455   fstrcpy(p,user);
1456   p = skip_string(p,1);
1457   SSVAL(p,0,532);
1458   p += 2;
1459
1460   param_len = PTR_DIFF(p,param);
1461
1462   /*
1463    * Now setup the data area.
1464    * We need to generate a random fill
1465    * for this area to make it harder to
1466    * decrypt. JRA.
1467    */
1468   generate_random_buffer(data, sizeof(data), False);
1469   fstrcpy( &data[512 - new_pw_len], new_password);
1470   SIVAL(data, 512, new_pw_len);
1471
1472   /*
1473    * Get the Lanman hash of the old password, we
1474    * use this as the key to SamOEMHash().
1475    */
1476   memset(upper_case_old_pw, '\0', sizeof(upper_case_old_pw));
1477   fstrcpy(upper_case_old_pw, old_password);
1478   strupper(upper_case_old_pw);
1479   E_P16((uchar *)upper_case_old_pw, old_pw_hash);
1480
1481   SamOEMhash( (unsigned char *)data, (unsigned char *)old_pw_hash, True);
1482
1483   /*
1484    * Now place the old password hash in the data.
1485    */
1486   memset(upper_case_new_pw, '\0', sizeof(upper_case_new_pw));
1487   fstrcpy(upper_case_new_pw, new_password);
1488   strupper(upper_case_new_pw);
1489
1490   E_P16((uchar *)upper_case_new_pw, new_pw_hash);
1491
1492   E_old_pw_hash( new_pw_hash, old_pw_hash, (uchar *)&data[516]);
1493
1494   data_len = 532;
1495
1496   if(cli_send_trans(cli,SMBtrans,
1497                     PIPE_LANMAN,strlen(PIPE_LANMAN),      /* name, length */
1498                     0,0,                                  /* fid, flags */
1499                     NULL,0,0,                             /* setup, length, max */
1500                     param,param_len,2,                    /* param, length, max */
1501                     data,data_len,0                       /* data, length, max */
1502                    ) == False) {
1503     DEBUG(0,("cli_oem_change_password: Failed to send password change for user %s\n",
1504               user ));
1505     return False;
1506   }
1507
1508   if(cli_receive_trans(cli,SMBtrans,
1509                        &rparam, &rprcnt,
1510                        &rdata, &rdrcnt)) {
1511     if(rparam)
1512       cli->rap_error = SVAL(rparam,0);
1513   }
1514
1515   if (rparam)
1516     free(rparam);
1517   if (rdata)
1518     free(rdata);
1519
1520   return (cli->rap_error == 0);
1521 }
1522
1523 /****************************************************************************
1524 send a negprot command
1525 ****************************************************************************/
1526 BOOL cli_negprot(struct cli_state *cli)
1527 {
1528         char *p;
1529         int numprots;
1530         int plength;
1531
1532         bzero(cli->outbuf,smb_size);
1533
1534         /* setup the protocol strings */
1535         for (plength=0,numprots=0;
1536              prots[numprots].name && prots[numprots].prot<=cli->protocol;
1537              numprots++)
1538                 plength += strlen(prots[numprots].name)+2;
1539
1540         set_message(cli->outbuf,0,plength,True);
1541
1542         p = smb_buf(cli->outbuf);
1543         for (numprots=0;
1544              prots[numprots].name && prots[numprots].prot<=cli->protocol;
1545              numprots++) {
1546                 *p++ = 2;
1547                 strcpy(p,prots[numprots].name);
1548                 p += strlen(p) + 1;
1549         }
1550
1551         CVAL(cli->outbuf,smb_com) = SMBnegprot;
1552         cli_setup_packet(cli);
1553
1554         CVAL(smb_buf(cli->outbuf),0) = 2;
1555
1556         send_smb(cli->fd,cli->outbuf);
1557         if (!client_receive_smb(cli->fd,cli->inbuf,cli->timeout))
1558                 return False;
1559
1560         show_msg(cli->inbuf);
1561
1562         if (CVAL(cli->inbuf,smb_rcls) != 0 ||
1563             ((int)SVAL(cli->inbuf,smb_vwv0) >= numprots)) {
1564                 return(False);
1565         }
1566
1567         cli->protocol = prots[SVAL(cli->inbuf,smb_vwv0)].prot;
1568
1569
1570         if (cli->protocol >= PROTOCOL_NT1) {
1571                 /* NT protocol */
1572                 cli->sec_mode = CVAL(cli->inbuf,smb_vwv1);
1573                 cli->max_xmit = IVAL(cli->inbuf,smb_vwv3+1);
1574                 cli->sesskey = IVAL(cli->inbuf,smb_vwv7+1);
1575                 cli->serverzone = SVALS(cli->inbuf,smb_vwv15+1)*60;
1576                 /* this time arrives in real GMT */
1577                 cli->servertime = interpret_long_date(cli->inbuf+smb_vwv11+1);
1578                 memcpy(cli->cryptkey,smb_buf(cli->inbuf),8);
1579                 if (IVAL(cli->inbuf,smb_vwv9+1) & 1)
1580                         cli->readbraw_supported =
1581                                 cli->writebraw_supported = True;
1582         } else if (cli->protocol >= PROTOCOL_LANMAN1) {
1583                 cli->sec_mode = SVAL(cli->inbuf,smb_vwv1);
1584                 cli->max_xmit = SVAL(cli->inbuf,smb_vwv2);
1585                 cli->sesskey = IVAL(cli->inbuf,smb_vwv6);
1586                 cli->serverzone = SVALS(cli->inbuf,smb_vwv10)*60;
1587                 /* this time is converted to GMT by make_unix_date */
1588                 cli->servertime = make_unix_date(cli->inbuf+smb_vwv8);
1589                 cli->readbraw_supported = ((SVAL(cli->inbuf,smb_vwv5) & 0x1) != 0);
1590                 cli->writebraw_supported = ((SVAL(cli->inbuf,smb_vwv5) & 0x2) != 0);
1591                 memcpy(cli->cryptkey,smb_buf(cli->inbuf),8);
1592         } else {
1593                 /* the old core protocol */
1594                 cli->sec_mode = 0;
1595                 cli->serverzone = TimeDiff(time(NULL));
1596         }
1597
1598         return True;
1599 }
1600
1601
1602 /****************************************************************************
1603   send a session request
1604 ****************************************************************************/
1605 BOOL cli_session_request(struct cli_state *cli, char *host, int name_type,
1606                          char *myname)
1607 {
1608         fstring dest;
1609         char *p;
1610         int len = 4;
1611         /* send a session request (RFC 1002) */
1612
1613         fstrcpy(dest,host);
1614
1615         p = strchr(dest,'.');
1616         if (p) *p = 0;
1617
1618         fstrcpy(cli->desthost, dest);
1619
1620         /* put in the destination name */
1621         p = cli->outbuf+len;
1622         name_mangle(dest,p,name_type);
1623         len += name_len(p);
1624
1625         /* and my name */
1626         p = cli->outbuf+len;
1627         name_mangle(myname,p,0);
1628         len += name_len(p);
1629
1630         /* setup the packet length */
1631         _smb_setlen(cli->outbuf,len);
1632         CVAL(cli->outbuf,0) = 0x81;
1633
1634         send_smb(cli->fd,cli->outbuf);
1635         DEBUG(5,("Sent session request\n"));
1636
1637         if (!client_receive_smb(cli->fd,cli->inbuf,cli->timeout))
1638                 return False;
1639
1640         if (CVAL(cli->inbuf,0) != 0x82) {
1641                 /* This is the wrong place to put the error... JRA. */
1642                 cli->rap_error = CVAL(cli->inbuf,0);
1643                 return False;
1644         }
1645         return(True);
1646 }
1647
1648
1649 /****************************************************************************
1650 open the client sockets
1651 ****************************************************************************/
1652 BOOL cli_connect(struct cli_state *cli, char *host, struct in_addr *ip)
1653 {
1654         struct in_addr dest_ip;
1655
1656         fstrcpy(cli->desthost, host);
1657
1658         if (!ip) {
1659                 if(!resolve_name( cli->desthost, &dest_ip)) {
1660                         return False;
1661                 }
1662         } else {
1663                 dest_ip = *ip;
1664         }
1665
1666
1667         cli->fd = open_socket_out(SOCK_STREAM, &dest_ip, 139, cli->timeout);
1668         if (cli->fd == -1)
1669                 return False;
1670
1671         return True;
1672 }
1673
1674
1675 /****************************************************************************
1676 initialise a client structure
1677 ****************************************************************************/
1678 BOOL cli_initialise(struct cli_state *cli)
1679 {
1680         if (cli->initialised) cli_shutdown(cli);
1681
1682         memset(cli, 0, sizeof(*cli));
1683         cli->fd = -1;
1684         cli->cnum = -1;
1685         cli->pid = getpid();
1686         cli->mid = 1;
1687         cli->uid = getuid();
1688         cli->protocol = PROTOCOL_NT1;
1689         cli->timeout = 20000;
1690         cli->bufsize = 0x10000;
1691         cli->max_xmit = cli->bufsize - 4;
1692         cli->outbuf = (char *)malloc(cli->bufsize);
1693         cli->inbuf = (char *)malloc(cli->bufsize);
1694         if (!cli->outbuf || !cli->inbuf) return False;
1695         cli->initialised = 1;
1696         return True;
1697 }
1698
1699 /****************************************************************************
1700 shutdown a client structure
1701 ****************************************************************************/
1702 void cli_shutdown(struct cli_state *cli)
1703 {
1704         if (cli->outbuf) free(cli->outbuf);
1705         if (cli->inbuf) free(cli->inbuf);
1706         if (cli->fd != -1) close(cli->fd);
1707         memset(cli, 0, sizeof(*cli));
1708 }
1709
1710 /****************************************************************************
1711   return error codes for the last packet
1712 ****************************************************************************/
1713 void cli_error(struct cli_state *cli, int *eclass, int *num)
1714 {
1715         *eclass = CVAL(cli->inbuf,smb_rcls);
1716         *num = SVAL(cli->inbuf,smb_err);
1717 }
1718
1719 /****************************************************************************
1720 set socket options on a open connection
1721 ****************************************************************************/
1722 void cli_sockopt(struct cli_state *cli, char *options)
1723 {
1724         set_socket_options(cli->fd, options);
1725 }
1726
1727 /****************************************************************************
1728 set the PID to use for smb messages. Return the old pid.
1729 ****************************************************************************/
1730 int cli_setpid(struct cli_state *cli, int pid)
1731 {
1732         int ret = cli->pid;
1733         cli->pid = pid;
1734         return ret;
1735 }