source3/libsmb/clirap.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    client RAP calls
   4    Copyright (C) Andrew Tridgell         1994-1998
   5    Copyright (C) Gerald (Jerry) Carter   2004
   6    Copyright (C) James Peach             2007
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "includes.h"
  23 #include "../libcli/auth/libcli_auth.h"
  24 #include "../librpc/gen_ndr/rap.h"
  25 #include "../lib/crypto/arcfour.h"
  26 #include "../lib/util/tevent_ntstatus.h"
  27 #include "async_smb.h"
  28 #include "libsmb/libsmb.h"
  29 #include "libsmb/clirap.h"
  30 #include "trans2.h"
  31 #include "../libcli/smb/smbXcli_base.h"
  32
  33 #define PIPE_LANMAN   "\\PIPE\\LANMAN"
  34
  35 /****************************************************************************
  36  Call a remote api
  37 ****************************************************************************/
  38
  39 bool cli_api(struct cli_state *cli,
  40              char *param, int prcnt, int mprcnt,
  41              char *data, int drcnt, int mdrcnt,
  42              char **rparam, unsigned int *rprcnt,
  43              char **rdata, unsigned int *rdrcnt)
  44 {
  45         NTSTATUS status;
  46
  47         uint8_t *my_rparam, *my_rdata;
  48         uint32_t num_my_rparam, num_my_rdata;
  49
  50         status = cli_trans(talloc_tos(), cli, SMBtrans,
  51                            PIPE_LANMAN, 0, /* name, fid */
  52                            0, 0,           /* function, flags */
  53                            NULL, 0, 0,     /* setup */
  54                            (uint8_t *)param, prcnt, mprcnt, /* Params, length, max */
  55                            (uint8_t *)data, drcnt, mdrcnt,  /* Data, length, max */
  56                            NULL,                 /* recv_flags2 */
  57                            NULL, 0, NULL,        /* rsetup */
  58                            &my_rparam, 0, &num_my_rparam,
  59                            &my_rdata, 0, &num_my_rdata);
  60         if (!NT_STATUS_IS_OK(status)) {
  61                 return false;
  62         }
  63
  64         /*
  65          * I know this memcpy massively hurts, but there are just tons
  66          * of callers of cli_api that eventually need changing to
  67          * talloc
  68          */
  69
  70         *rparam = (char *)smb_memdup(my_rparam, num_my_rparam);
  71         if (*rparam == NULL) {
  72                 goto fail;
  73         }
  74         *rprcnt = num_my_rparam;
  75         TALLOC_FREE(my_rparam);
  76
  77         *rdata = (char *)smb_memdup(my_rdata, num_my_rdata);
  78         if (*rdata == NULL) {
  79                 goto fail;
  80         }
  81         *rdrcnt = num_my_rdata;
  82         TALLOC_FREE(my_rdata);
  83
  84         return true;
  85 fail:
  86         TALLOC_FREE(my_rdata);
  87         TALLOC_FREE(my_rparam);
  88         *rparam = NULL;
  89         *rprcnt = 0;
  90         *rdata = NULL;
  91         *rdrcnt = 0;
  92         return false;
  93 }
  94
  95 /****************************************************************************
  96  Perform a NetWkstaUserLogon.
  97 ****************************************************************************/
  98
  99 bool cli_NetWkstaUserLogon(struct cli_state *cli,char *user, char *workstation)
 100 {
 101         char *rparam = NULL;
 102         char *rdata = NULL;
 103         char *p;
 104         unsigned int rdrcnt,rprcnt;
 105         char param[1024];
 106
 107         memset(param, 0, sizeof(param));
 108
 109         /* send a SMBtrans command with api NetWkstaUserLogon */
 110         p = param;
 111         SSVAL(p,0,132); /* api number */
 112         p += 2;
 113         strlcpy(p,"OOWb54WrLh",sizeof(param)-PTR_DIFF(p,param));
 114         p = skip_string(param,sizeof(param),p);
 115         strlcpy(p,"WB21BWDWWDDDDDDDzzzD",sizeof(param)-PTR_DIFF(p,param));
 116         p = skip_string(param,sizeof(param),p);
 117         SSVAL(p,0,1);
 118         p += 2;
 119         strlcpy(p,user,sizeof(param)-PTR_DIFF(p,param));
 120         if (!strupper_m(p)) {
 121                 return false;
 122         }
 123         p += 21;
 124         p++;
 125         p += 15;
 126         p++;
 127         strlcpy(p, workstation,sizeof(param)-PTR_DIFF(p,param));
 128         if (!strupper_m(p)) {
 129                 return false;
 130         }
 131         p += 16;
 132         SSVAL(p, 0, CLI_BUFFER_SIZE);
 133         p += 2;
 134         SSVAL(p, 0, CLI_BUFFER_SIZE);
 135         p += 2;
 136
 137         if (cli_api(cli,
 138                     param, PTR_DIFF(p,param),1024,  /* param, length, max */
 139                     NULL, 0, CLI_BUFFER_SIZE,           /* data, length, max */
 140                     &rparam, &rprcnt,               /* return params, return size */
 141                     &rdata, &rdrcnt                 /* return data, return size */
 142                    )) {
 143                 cli->rap_error = rparam? SVAL(rparam,0) : -1;
 144                 p = rdata;
 145
 146                 if (cli->rap_error == 0) {
 147                         DEBUG(4,("NetWkstaUserLogon success\n"));
 148                         /*
 149                          * The cli->privileges = SVAL(p, 24); field was set here
 150                          * but it was not use anywhere else.
 151                          */
 152                         /* The cli->eff_name field used to be set here
 153                            but it wasn't used anywhere else. */
 154                 } else {
 155                         DEBUG(1,("NetwkstaUserLogon gave error %d\n", cli->rap_error));
 156                 }
 157         }
 158
 159         SAFE_FREE(rparam);
 160         SAFE_FREE(rdata);
 161         return (cli->rap_error == 0);
 162 }
 163
 164 /****************************************************************************
 165  Call a NetShareEnum - try and browse available connections on a host.
 166 ****************************************************************************/
 167
 168 int cli_RNetShareEnum(struct cli_state *cli, void (*fn)(const char *, uint32_t, const char *, void *), void *state)
 169 {
 170         char *rparam = NULL;
 171         char *rdata = NULL;
 172         char *p;
 173         unsigned int rdrcnt,rprcnt;
 174         char param[1024];
 175         int count = -1;
 176
 177         /* now send a SMBtrans command with api RNetShareEnum */
 178         p = param;
 179         SSVAL(p,0,0); /* api number */
 180         p += 2;
 181         strlcpy(p,"WrLeh",sizeof(param)-PTR_DIFF(p,param));
 182         p = skip_string(param,sizeof(param),p);
 183         strlcpy(p,"B13BWz",sizeof(param)-PTR_DIFF(p,param));
 184         p = skip_string(param,sizeof(param),p);
 185         SSVAL(p,0,1);
 186         /*
 187          * Win2k needs a *smaller* buffer than 0xFFFF here -
 188          * it returns "out of server memory" with 0xFFFF !!! JRA.
 189          */
 190         SSVAL(p,2,0xFFE0);
 191         p += 4;
 192
 193         if (cli_api(cli,
 194                     param, PTR_DIFF(p,param), 1024,  /* Param, length, maxlen */
 195                     NULL, 0, 0xFFE0,            /* data, length, maxlen - Win2k needs a small buffer here too ! */
 196                     &rparam, &rprcnt,                /* return params, length */
 197                     &rdata, &rdrcnt))                /* return data, length */
 198                 {
 199                         int res = rparam? SVAL(rparam,0) : -1;
 200
 201                         if (res == 0 || res == ERRmoredata) {
 202                                 int converter=SVAL(rparam,2);
 203                                 int i;
 204                                 char *rdata_end = rdata + rdrcnt;
 205
 206                                 count=SVAL(rparam,4);
 207                                 p = rdata;
 208
 209                                 for (i=0;i<count;i++,p+=20) {
 210                                         char *sname;
 211                                         int type;
 212                                         int comment_offset;
 213                                         const char *cmnt;
 214                                         const char *p1;
 215                                         char *s1, *s2;
 216                                         size_t len;
 217                                         TALLOC_CTX *frame = talloc_stackframe();
 218
 219                                         if (p + 20 > rdata_end) {
 220                                                 TALLOC_FREE(frame);
 221                                                 break;
 222                                         }
 223
 224                                         sname = p;
 225                                         type = SVAL(p,14);
 226                                         comment_offset = (IVAL(p,16) & 0xFFFF) - converter;
 227                                         if (comment_offset < 0 ||
 228                                                         comment_offset > (int)rdrcnt) {
 229                                                 TALLOC_FREE(frame);
 230                                                 break;
 231                                         }
 232                                         cmnt = comment_offset?(rdata+comment_offset):"";
 233
 234                                         /* Work out the comment length. */
 235                                         for (p1 = cmnt, len = 0; *p1 &&
 236                                                         p1 < rdata_end; len++)
 237                                                 p1++;
 238                                         if (!*p1) {
 239                                                 len++;
 240                                         }
 241                                         pull_string_talloc(frame,rdata,0,
 242                                                 &s1,sname,14,STR_ASCII);
 243                                         pull_string_talloc(frame,rdata,0,
 244                                                 &s2,cmnt,len,STR_ASCII);
 245                                         if (!s1 || !s2) {
 246                                                 TALLOC_FREE(frame);
 247                                                 continue;
 248                                         }
 249
 250                                         fn(s1, type, s2, state);
 251
 252                                         TALLOC_FREE(frame);
 253                                 }
 254                         } else {
 255                                 DEBUG(4,("NetShareEnum res=%d\n", res));
 256                         }
 257                 } else {
 258                         DEBUG(4,("NetShareEnum failed\n"));
 259                 }
 260
 261         SAFE_FREE(rparam);
 262         SAFE_FREE(rdata);
 263
 264         return count;
 265 }
 266
 267 /****************************************************************************
 268  Call a NetServerEnum for the specified workgroup and servertype mask.  This
 269  function then calls the specified callback function for each name returned.
 270
 271  The callback function takes 4 arguments: the machine name, the server type,
 272  the comment and a state pointer.
 273 ****************************************************************************/
 274
 275 bool cli_NetServerEnum(struct cli_state *cli, char *workgroup, uint32_t stype,
 276                        void (*fn)(const char *, uint32_t, const char *, void *),
 277                        void *state)
 278 {
 279         char *rparam = NULL;
 280         char *rdata = NULL;
 281         char *rdata_end = NULL;
 282         unsigned int rdrcnt,rprcnt;
 283         char *p;
 284         char param[1024];
 285         int uLevel = 1;
 286         size_t len;
 287         uint32_t func = RAP_NetServerEnum2;
 288         char *last_entry = NULL;
 289         int total_cnt = 0;
 290         int return_cnt = 0;
 291         int res;
 292
 293         errno = 0; /* reset */
 294
 295         /*
 296          * This may take more than one transaction, so we should loop until
 297          * we no longer get a more data to process or we have all of the
 298          * items.
 299          */
 300         do {
 301                 /* send a SMBtrans command with api NetServerEnum */
 302                 p = param;
 303                 SIVAL(p,0,func); /* api number */
 304                 p += 2;
 305
 306                 if (func == RAP_NetServerEnum3) {
 307                         strlcpy(p,"WrLehDzz", sizeof(param)-PTR_DIFF(p,param));
 308                 } else {
 309                         strlcpy(p,"WrLehDz", sizeof(param)-PTR_DIFF(p,param));
 310                 }
 311
 312                 p = skip_string(param, sizeof(param), p);
 313                 strlcpy(p,"B16BBDz", sizeof(param)-PTR_DIFF(p,param));
 314
 315                 p = skip_string(param, sizeof(param), p);
 316                 SSVAL(p,0,uLevel);
 317                 SSVAL(p,2,CLI_BUFFER_SIZE);
 318                 p += 4;
 319                 SIVAL(p,0,stype);
 320                 p += 4;
 321
 322                 /* If we have more data, tell the server where
 323                  * to continue from.
 324                  */
 325                 len = push_ascii(p,
 326                                 workgroup,
 327                                 sizeof(param) - PTR_DIFF(p,param) - 1,
 328                                 STR_TERMINATE|STR_UPPER);
 329
 330                 if (len == 0) {
 331                         SAFE_FREE(last_entry);
 332                         return false;
 333                 }
 334                 p += len;
 335
 336                 if (func == RAP_NetServerEnum3) {
 337                         len = push_ascii(p,
 338                                         last_entry ? last_entry : "",
 339                                         sizeof(param) - PTR_DIFF(p,param) - 1,
 340                                         STR_TERMINATE);
 341
 342                         if (len == 0) {
 343                                 SAFE_FREE(last_entry);
 344                                 return false;
 345                         }
 346                         p += len;
 347                 }
 348
 349                 /* Next time through we need to use the continue api */
 350                 func = RAP_NetServerEnum3;
 351
 352                 if (!cli_api(cli,
 353                         param, PTR_DIFF(p,param), 8, /* params, length, max */
 354                         NULL, 0, CLI_BUFFER_SIZE, /* data, length, max */
 355                             &rparam, &rprcnt, /* return params, return size */
 356                             &rdata, &rdrcnt)) { /* return data, return size */
 357
 358                         /* break out of the loop on error */
 359                         res = -1;
 360                         break;
 361                 }
 362
 363                 rdata_end = rdata + rdrcnt;
 364                 res = rparam ? SVAL(rparam,0) : -1;
 365
 366                 if (res == 0 || res == ERRmoredata ||
 367                     (res != -1 && cli_errno(cli) == 0)) {
 368                         char *sname = NULL;
 369                         int i, count;
 370                         int converter=SVAL(rparam,2);
 371
 372                         /* Get the number of items returned in this buffer */
 373                         count = SVAL(rparam, 4);
 374
 375                         /* The next field contains the number of items left,
 376                          * including those returned in this buffer. So the
 377                          * first time through this should contain all of the
 378                          * entries.
 379                          */
 380                         if (total_cnt == 0) {
 381                                 total_cnt = SVAL(rparam, 6);
 382                         }
 383
 384                         /* Keep track of how many we have read */
 385                         return_cnt += count;
 386                         p = rdata;
 387
 388                         /* The last name in the previous NetServerEnum reply is
 389                          * sent back to server in the NetServerEnum3 request
 390                          * (last_entry). The next reply should repeat this entry
 391                          * as the first element. We have no proof that this is
 392                          * always true, but from traces that seems to be the
 393                          * behavior from Window Servers. So first lets do a lot
 394                          * of checking, just being paranoid. If the string
 395                          * matches then we already saw this entry so skip it.
 396                          *
 397                          * NOTE: sv1_name field must be null terminated and has
 398                          * a max size of 16 (NetBIOS Name).
 399                          */
 400                         if (last_entry && count && p &&
 401                                 (strncmp(last_entry, p, 16) == 0)) {
 402                             count -= 1; /* Skip this entry */
 403                             return_cnt = -1; /* Not part of total, so don't count. */
 404                             p = rdata + 26; /* Skip the whole record */
 405                         }
 406
 407                         for (i = 0; i < count; i++, p += 26) {
 408                                 int comment_offset;
 409                                 const char *cmnt;
 410                                 const char *p1;
 411                                 char *s1, *s2;
 412                                 TALLOC_CTX *frame = talloc_stackframe();
 413                                 uint32_t entry_stype;
 414
 415                                 if (p + 26 > rdata_end) {
 416                                         TALLOC_FREE(frame);
 417                                         break;
 418                                 }
 419
 420                                 sname = p;
 421                                 comment_offset = (IVAL(p,22) & 0xFFFF)-converter;
 422                                 cmnt = comment_offset?(rdata+comment_offset):"";
 423
 424                                 if (comment_offset < 0 || comment_offset >= (int)rdrcnt) {
 425                                         TALLOC_FREE(frame);
 426                                         continue;
 427                                 }
 428
 429                                 /* Work out the comment length. */
 430                                 for (p1 = cmnt, len = 0; *p1 &&
 431                                                 p1 < rdata_end; len++)
 432                                         p1++;
 433                                 if (!*p1) {
 434                                         len++;
 435                                 }
 436
 437                                 entry_stype = IVAL(p,18) & ~SV_TYPE_LOCAL_LIST_ONLY;
 438
 439                                 pull_string_talloc(frame,rdata,0,
 440                                         &s1,sname,16,STR_ASCII);
 441                                 pull_string_talloc(frame,rdata,0,
 442                                         &s2,cmnt,len,STR_ASCII);
 443
 444                                 if (!s1 || !s2) {
 445                                         TALLOC_FREE(frame);
 446                                         continue;
 447                                 }
 448
 449                                 fn(s1, entry_stype, s2, state);
 450                                 TALLOC_FREE(frame);
 451                         }
 452
 453                         /* We are done with the old last entry, so now we can free it */
 454                         if (last_entry) {
 455                                 SAFE_FREE(last_entry); /* This will set it to null */
 456                         }
 457
 458                         /* We always make a copy of  the last entry if we have one */
 459                         if (sname) {
 460                                 last_entry = smb_xstrdup(sname);
 461                         }
 462
 463                         /* If we have more data, but no last entry then error out */
 464                         if (!last_entry && (res == ERRmoredata)) {
 465                                 errno = EINVAL;
 466                                 res = 0;
 467                         }
 468
 469                 }
 470
 471                 SAFE_FREE(rparam);
 472                 SAFE_FREE(rdata);
 473         } while ((res == ERRmoredata) && (total_cnt > return_cnt));
 474
 475         SAFE_FREE(rparam);
 476         SAFE_FREE(rdata);
 477         SAFE_FREE(last_entry);
 478
 479         if (res == -1) {
 480                 errno = cli_errno(cli);
 481         } else {
 482                 if (!return_cnt) {
 483                         /* this is a very special case, when the domain master for the
 484                            work group isn't part of the work group itself, there is something
 485                            wild going on */
 486                         errno = ENOENT;
 487                 }
 488             }
 489
 490         return(return_cnt > 0);
 491 }
 492
 493 /****************************************************************************
 494  Send a SamOEMChangePassword command.
 495 ****************************************************************************/
 496
 497 bool cli_oem_change_password(struct cli_state *cli, const char *user, const char *new_password,
 498                              const char *old_password)
 499 {
 500         char param[1024];
 501         unsigned char data[532];
 502         char *p = param;
 503         unsigned char old_pw_hash[16];
 504         unsigned char new_pw_hash[16];
 505         unsigned int data_len;
 506         unsigned int param_len = 0;
 507         char *rparam = NULL;
 508         char *rdata = NULL;
 509         unsigned int rprcnt, rdrcnt;
 510
 511         if (strlen(user) >= sizeof(fstring)-1) {
 512                 DEBUG(0,("cli_oem_change_password: user name %s is too long.\n", user));
 513                 return False;
 514         }
 515
 516         SSVAL(p,0,214); /* SamOEMChangePassword command. */
 517         p += 2;
 518         strlcpy(p, "zsT", sizeof(param)-PTR_DIFF(p,param));
 519         p = skip_string(param,sizeof(param),p);
 520         strlcpy(p, "B516B16", sizeof(param)-PTR_DIFF(p,param));
 521         p = skip_string(param,sizeof(param),p);
 522         strlcpy(p,user, sizeof(param)-PTR_DIFF(p,param));
 523         p = skip_string(param,sizeof(param),p);
 524         SSVAL(p,0,532);
 525         p += 2;
 526
 527         param_len = PTR_DIFF(p,param);
 528
 529         /*
 530          * Get the Lanman hash of the old password, we
 531          * use this as the key to make_oem_passwd_hash().
 532          */
 533         E_deshash(old_password, old_pw_hash);
 534
 535         encode_pw_buffer(data, new_password, STR_ASCII);
 536
 537 #ifdef DEBUG_PASSWORD
 538         DEBUG(100,("make_oem_passwd_hash\n"));
 539         dump_data(100, data, 516);
 540 #endif
 541         arcfour_crypt( (unsigned char *)data, (unsigned char *)old_pw_hash, 516);
 542
 543         /*
 544          * Now place the old password hash in the data.
 545          */
 546         E_deshash(new_password, new_pw_hash);
 547
 548         E_old_pw_hash( new_pw_hash, old_pw_hash, (uchar *)&data[516]);
 549
 550         data_len = 532;
 551
 552         if (!cli_api(cli,
 553                      param, param_len, 4,               /* param, length, max */
 554                      (char *)data, data_len, 0,         /* data, length, max */
 555                      &rparam, &rprcnt,
 556                      &rdata, &rdrcnt)) {
 557                 DEBUG(0,("cli_oem_change_password: Failed to send password change for user %s\n",
 558                         user ));
 559                 return False;
 560         }
 561
 562         if (rparam) {
 563                 cli->rap_error = SVAL(rparam,0);
 564         }
 565
 566         SAFE_FREE(rparam);
 567         SAFE_FREE(rdata);
 568
 569         return (cli->rap_error == 0);
 570 }
 571
 572 /****************************************************************************
 573  Send a qpathinfo call.
 574 ****************************************************************************/
 575
 576 struct cli_qpathinfo1_state {
 577         struct cli_state *cli;
 578         uint32_t num_data;
 579         uint8_t *data;
 580 };
 581
 582 static void cli_qpathinfo1_done(struct tevent_req *subreq);
 583
 584 struct tevent_req *cli_qpathinfo1_send(TALLOC_CTX *mem_ctx,
 585                                        struct tevent_context *ev,
 586                                        struct cli_state *cli,
 587                                        const char *fname)
 588 {
 589         struct tevent_req *req = NULL, *subreq = NULL;
 590         struct cli_qpathinfo1_state *state = NULL;
 591
 592         req = tevent_req_create(mem_ctx, &state, struct cli_qpathinfo1_state);
 593         if (req == NULL) {
 594                 return NULL;
 595         }
 596         state->cli = cli;
 597         subreq = cli_qpathinfo_send(state, ev, cli, fname, SMB_INFO_STANDARD,
 598                                     22, CLI_BUFFER_SIZE);
 599         if (tevent_req_nomem(subreq, req)) {
 600                 return tevent_req_post(req, ev);
 601         }
 602         tevent_req_set_callback(subreq, cli_qpathinfo1_done, req);
 603         return req;
 604 }
 605
 606 static void cli_qpathinfo1_done(struct tevent_req *subreq)
 607 {
 608         struct tevent_req *req = tevent_req_callback_data(
 609                 subreq, struct tevent_req);
 610         struct cli_qpathinfo1_state *state = tevent_req_data(
 611                 req, struct cli_qpathinfo1_state);
 612         NTSTATUS status;
 613
 614         status = cli_qpathinfo_recv(subreq, state, &state->data,
 615                                     &state->num_data);
 616         TALLOC_FREE(subreq);
 617         if (!NT_STATUS_IS_OK(status)) {
 618                 tevent_req_nterror(req, status);
 619                 return;
 620         }
 621         tevent_req_done(req);
 622 }
 623
 624 NTSTATUS cli_qpathinfo1_recv(struct tevent_req *req,
 625                              time_t *change_time,
 626                              time_t *access_time,
 627                              time_t *write_time,
 628                              off_t *size,
 629                              uint16_t *mode)
 630 {
 631         struct cli_qpathinfo1_state *state = tevent_req_data(
 632                 req, struct cli_qpathinfo1_state);
 633         NTSTATUS status;
 634
 635         time_t (*date_fn)(const void *buf, int serverzone);
 636
 637         if (tevent_req_is_nterror(req, &status)) {
 638                 return status;
 639         }
 640
 641         if (state->cli->win95) {
 642                 date_fn = make_unix_date;
 643         } else {
 644                 date_fn = make_unix_date2;
 645         }
 646
 647         if (change_time) {
 648                 *change_time = date_fn(state->data+0, smb1cli_conn_server_time_zone(state->cli->conn));
 649         }
 650         if (access_time) {
 651                 *access_time = date_fn(state->data+4, smb1cli_conn_server_time_zone(state->cli->conn));
 652         }
 653         if (write_time) {
 654                 *write_time = date_fn(state->data+8, smb1cli_conn_server_time_zone(state->cli->conn));
 655         }
 656         if (size) {
 657                 *size = IVAL(state->data, 12);
 658         }
 659         if (mode) {
 660                 *mode = SVAL(state->data, l1_attrFile);
 661         }
 662         return NT_STATUS_OK;
 663 }
 664
 665 NTSTATUS cli_qpathinfo1(struct cli_state *cli,
 666                         const char *fname,
 667                         time_t *change_time,
 668                         time_t *access_time,
 669                         time_t *write_time,
 670                         off_t *size,
 671                         uint16_t *mode)
 672 {
 673         TALLOC_CTX *frame = talloc_stackframe();
 674         struct tevent_context *ev;
 675         struct tevent_req *req;
 676         NTSTATUS status = NT_STATUS_NO_MEMORY;
 677
 678         if (smbXcli_conn_has_async_calls(cli->conn)) {
 679                 /*
 680                  * Can't use sync call while an async call is in flight
 681                  */
 682                 status = NT_STATUS_INVALID_PARAMETER;
 683                 goto fail;
 684         }
 685         ev = samba_tevent_context_init(frame);
 686         if (ev == NULL) {
 687                 goto fail;
 688         }
 689         req = cli_qpathinfo1_send(frame, ev, cli, fname);
 690         if (req == NULL) {
 691                 goto fail;
 692         }
 693         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
 694                 goto fail;
 695         }
 696         status = cli_qpathinfo1_recv(req, change_time, access_time,
 697                                      write_time, size, mode);
 698  fail:
 699         TALLOC_FREE(frame);
 700         return status;
 701 }
 702
 703 /****************************************************************************
 704  Send a setpathinfo call.
 705 ****************************************************************************/
 706
 707 NTSTATUS cli_setpathinfo_basic(struct cli_state *cli, const char *fname,
 708                                time_t create_time,
 709                                time_t access_time,
 710                                time_t write_time,
 711                                time_t change_time,
 712                                uint16_t mode)
 713 {
 714         unsigned int data_len = 0;
 715         char data[40];
 716         char *p;
 717
 718         p = data;
 719
 720         /*
 721          * Add the create, last access, modification, and status change times
 722          */
 723         put_long_date(p, create_time);
 724         p += 8;
 725
 726         put_long_date(p, access_time);
 727         p += 8;
 728
 729         put_long_date(p, write_time);
 730         p += 8;
 731
 732         put_long_date(p, change_time);
 733         p += 8;
 734
 735         /* Add attributes */
 736         SIVAL(p, 0, mode);
 737         p += 4;
 738
 739         /* Add padding */
 740         SIVAL(p, 0, 0);
 741         p += 4;
 742
 743         data_len = PTR_DIFF(p, data);
 744
 745         return cli_setpathinfo(cli, SMB_FILE_BASIC_INFORMATION, fname,
 746                                (uint8_t *)data, data_len);
 747 }
 748
 749 /****************************************************************************
 750  Send a qpathinfo call with the SMB_QUERY_FILE_ALL_INFO info level.
 751 ****************************************************************************/
 752
 753 struct cli_qpathinfo2_state {
 754         uint32_t num_data;
 755         uint8_t *data;
 756 };
 757
 758 static void cli_qpathinfo2_done(struct tevent_req *subreq);
 759
 760 struct tevent_req *cli_qpathinfo2_send(TALLOC_CTX *mem_ctx,
 761                                        struct tevent_context *ev,
 762                                        struct cli_state *cli,
 763                                        const char *fname)
 764 {
 765         struct tevent_req *req = NULL, *subreq = NULL;
 766         struct cli_qpathinfo2_state *state = NULL;
 767
 768         req = tevent_req_create(mem_ctx, &state, struct cli_qpathinfo2_state);
 769         if (req == NULL) {
 770                 return NULL;
 771         }
 772         subreq = cli_qpathinfo_send(state, ev, cli, fname,
 773                                     SMB_QUERY_FILE_ALL_INFO,
 774                                     68, CLI_BUFFER_SIZE);
 775         if (tevent_req_nomem(subreq, req)) {
 776                 return tevent_req_post(req, ev);
 777         }
 778         tevent_req_set_callback(subreq, cli_qpathinfo2_done, req);
 779         return req;
 780 }
 781
 782 static void cli_qpathinfo2_done(struct tevent_req *subreq)
 783 {
 784         struct tevent_req *req = tevent_req_callback_data(
 785                 subreq, struct tevent_req);
 786         struct cli_qpathinfo2_state *state = tevent_req_data(
 787                 req, struct cli_qpathinfo2_state);
 788         NTSTATUS status;
 789
 790         status = cli_qpathinfo_recv(subreq, state, &state->data,
 791                                     &state->num_data);
 792         TALLOC_FREE(subreq);
 793         if (!NT_STATUS_IS_OK(status)) {
 794                 tevent_req_nterror(req, status);
 795                 return;
 796         }
 797         tevent_req_done(req);
 798 }
 799
 800 NTSTATUS cli_qpathinfo2_recv(struct tevent_req *req,
 801                              struct timespec *create_time,
 802                              struct timespec *access_time,
 803                              struct timespec *write_time,
 804                              struct timespec *change_time,
 805                              off_t *size, uint16_t *mode,
 806                              SMB_INO_T *ino)
 807 {
 808         struct cli_qpathinfo2_state *state = tevent_req_data(
 809                 req, struct cli_qpathinfo2_state);
 810         NTSTATUS status;
 811
 812         if (tevent_req_is_nterror(req, &status)) {
 813                 return status;
 814         }
 815
 816         if (create_time) {
 817                 *create_time = interpret_long_date((char *)state->data+0);
 818         }
 819         if (access_time) {
 820                 *access_time = interpret_long_date((char *)state->data+8);
 821         }
 822         if (write_time) {
 823                 *write_time = interpret_long_date((char *)state->data+16);
 824         }
 825         if (change_time) {
 826                 *change_time = interpret_long_date((char *)state->data+24);
 827         }
 828         if (mode) {
 829                 *mode = SVAL(state->data, 32);
 830         }
 831         if (size) {
 832                 *size = IVAL2_TO_SMB_BIG_UINT(state->data,48);
 833         }
 834         if (ino) {
 835                 *ino = IVAL(state->data, 64);
 836         }
 837         return NT_STATUS_OK;
 838 }
 839
 840 NTSTATUS cli_qpathinfo2(struct cli_state *cli, const char *fname,
 841                         struct timespec *create_time,
 842                         struct timespec *access_time,
 843                         struct timespec *write_time,
 844                         struct timespec *change_time,
 845                         off_t *size, uint16_t *mode,
 846                         SMB_INO_T *ino)
 847 {
 848         TALLOC_CTX *frame = NULL;
 849         struct tevent_context *ev;
 850         struct tevent_req *req;
 851         NTSTATUS status = NT_STATUS_NO_MEMORY;
 852
 853         if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
 854                 return cli_smb2_qpathinfo2(cli,
 855                                         fname,
 856                                         create_time,
 857                                         access_time,
 858                                         write_time,
 859                                         change_time,
 860                                         size,
 861                                         mode,
 862                                         ino);
 863         }
 864
 865         frame = talloc_stackframe();
 866
 867         if (smbXcli_conn_has_async_calls(cli->conn)) {
 868                 /*
 869                  * Can't use sync call while an async call is in flight
 870                  */
 871                 status = NT_STATUS_INVALID_PARAMETER;
 872                 goto fail;
 873         }
 874         ev = samba_tevent_context_init(frame);
 875         if (ev == NULL) {
 876                 goto fail;
 877         }
 878         req = cli_qpathinfo2_send(frame, ev, cli, fname);
 879         if (req == NULL) {
 880                 goto fail;
 881         }
 882         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
 883                 goto fail;
 884         }
 885         status = cli_qpathinfo2_recv(req, create_time, access_time,
 886                                      write_time, change_time, size, mode, ino);
 887  fail:
 888         TALLOC_FREE(frame);
 889         return status;
 890 }
 891
 892 /****************************************************************************
 893  Get the stream info
 894 ****************************************************************************/
 895
 896 struct cli_qpathinfo_streams_state {
 897         uint32_t num_data;
 898         uint8_t *data;
 899 };
 900
 901 static void cli_qpathinfo_streams_done(struct tevent_req *subreq);
 902
 903 struct tevent_req *cli_qpathinfo_streams_send(TALLOC_CTX *mem_ctx,
 904                                               struct tevent_context *ev,
 905                                               struct cli_state *cli,
 906                                               const char *fname)
 907 {
 908         struct tevent_req *req = NULL, *subreq = NULL;
 909         struct cli_qpathinfo_streams_state *state = NULL;
 910
 911         req = tevent_req_create(mem_ctx, &state,
 912                                 struct cli_qpathinfo_streams_state);
 913         if (req == NULL) {
 914                 return NULL;
 915         }
 916         subreq = cli_qpathinfo_send(state, ev, cli, fname,
 917                                     SMB_FILE_STREAM_INFORMATION,
 918                                     0, CLI_BUFFER_SIZE);
 919         if (tevent_req_nomem(subreq, req)) {
 920                 return tevent_req_post(req, ev);
 921         }
 922         tevent_req_set_callback(subreq, cli_qpathinfo_streams_done, req);
 923         return req;
 924 }
 925
 926 static void cli_qpathinfo_streams_done(struct tevent_req *subreq)
 927 {
 928         struct tevent_req *req = tevent_req_callback_data(
 929                 subreq, struct tevent_req);
 930         struct cli_qpathinfo_streams_state *state = tevent_req_data(
 931                 req, struct cli_qpathinfo_streams_state);
 932         NTSTATUS status;
 933
 934         status = cli_qpathinfo_recv(subreq, state, &state->data,
 935                                     &state->num_data);
 936         TALLOC_FREE(subreq);
 937         if (!NT_STATUS_IS_OK(status)) {
 938                 tevent_req_nterror(req, status);
 939                 return;
 940         }
 941         tevent_req_done(req);
 942 }
 943
 944 NTSTATUS cli_qpathinfo_streams_recv(struct tevent_req *req,
 945                                     TALLOC_CTX *mem_ctx,
 946                                     unsigned int *pnum_streams,
 947                                     struct stream_struct **pstreams)
 948 {
 949         struct cli_qpathinfo_streams_state *state = tevent_req_data(
 950                 req, struct cli_qpathinfo_streams_state);
 951         NTSTATUS status;
 952
 953         if (tevent_req_is_nterror(req, &status)) {
 954                 return status;
 955         }
 956         if (!parse_streams_blob(mem_ctx, state->data, state->num_data,
 957                                 pnum_streams, pstreams)) {
 958                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 959         }
 960         return NT_STATUS_OK;
 961 }
 962
 963 NTSTATUS cli_qpathinfo_streams(struct cli_state *cli, const char *fname,
 964                                TALLOC_CTX *mem_ctx,
 965                                unsigned int *pnum_streams,
 966                                struct stream_struct **pstreams)
 967 {
 968         TALLOC_CTX *frame = NULL;
 969         struct tevent_context *ev;
 970         struct tevent_req *req;
 971         NTSTATUS status = NT_STATUS_NO_MEMORY;
 972
 973         if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
 974                 return cli_smb2_qpathinfo_streams(cli,
 975                                         fname,
 976                                         mem_ctx,
 977                                         pnum_streams,
 978                                         pstreams);
 979         }
 980
 981         frame = talloc_stackframe();
 982
 983         if (smbXcli_conn_has_async_calls(cli->conn)) {
 984                 /*
 985                  * Can't use sync call while an async call is in flight
 986                  */
 987                 status = NT_STATUS_INVALID_PARAMETER;
 988                 goto fail;
 989         }
 990         ev = samba_tevent_context_init(frame);
 991         if (ev == NULL) {
 992                 goto fail;
 993         }
 994         req = cli_qpathinfo_streams_send(frame, ev, cli, fname);
 995         if (req == NULL) {
 996                 goto fail;
 997         }
 998         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
 999                 goto fail;
1000         }
1001         status = cli_qpathinfo_streams_recv(req, mem_ctx, pnum_streams,
1002                                             pstreams);
1003  fail:
1004         TALLOC_FREE(frame);
1005         return status;
1006 }
1007
1008 bool parse_streams_blob(TALLOC_CTX *mem_ctx, const uint8_t *rdata,
1009                                size_t data_len,
1010                                unsigned int *pnum_streams,
1011                                struct stream_struct **pstreams)
1012 {
1013         unsigned int num_streams;
1014         struct stream_struct *streams;
1015         unsigned int ofs;
1016
1017         num_streams = 0;
1018         streams = NULL;
1019         ofs = 0;
1020
1021         while ((data_len > ofs) && (data_len - ofs >= 24)) {
1022                 uint32_t nlen, len;
1023                 size_t size;
1024                 void *vstr;
1025                 struct stream_struct *tmp;
1026                 uint8_t *tmp_buf;
1027
1028                 tmp = talloc_realloc(mem_ctx, streams,
1029                                            struct stream_struct,
1030                                            num_streams+1);
1031
1032                 if (tmp == NULL) {
1033                         goto fail;
1034                 }
1035                 streams = tmp;
1036
1037                 nlen                      = IVAL(rdata, ofs + 0x04);
1038
1039                 streams[num_streams].size = IVAL_TO_SMB_OFF_T(
1040                         rdata, ofs + 0x08);
1041                 streams[num_streams].alloc_size = IVAL_TO_SMB_OFF_T(
1042                         rdata, ofs + 0x10);
1043
1044                 if (nlen > data_len - (ofs + 24)) {
1045                         goto fail;
1046                 }
1047
1048                 /*
1049                  * We need to null-terminate src, how do I do this with
1050                  * convert_string_talloc??
1051                  */
1052
1053                 tmp_buf = talloc_array(streams, uint8_t, nlen+2);
1054                 if (tmp_buf == NULL) {
1055                         goto fail;
1056                 }
1057
1058                 memcpy(tmp_buf, rdata+ofs+24, nlen);
1059                 tmp_buf[nlen] = 0;
1060                 tmp_buf[nlen+1] = 0;
1061
1062                 if (!convert_string_talloc(streams, CH_UTF16, CH_UNIX, tmp_buf,
1063                                            nlen+2, &vstr, &size))
1064                 {
1065                         TALLOC_FREE(tmp_buf);
1066                         goto fail;
1067                 }
1068
1069                 TALLOC_FREE(tmp_buf);
1070                 streams[num_streams].name = (char *)vstr;
1071                 num_streams++;
1072
1073                 len = IVAL(rdata, ofs);
1074                 if (len > data_len - ofs) {
1075                         goto fail;
1076                 }
1077                 if (len == 0) break;
1078                 ofs += len;
1079         }
1080
1081         *pnum_streams = num_streams;
1082         *pstreams = streams;
1083         return true;
1084
1085  fail:
1086         TALLOC_FREE(streams);
1087         return false;
1088 }
1089
1090 /****************************************************************************
1091  Send a qfileinfo QUERY_FILE_NAME_INFO call.
1092 ****************************************************************************/
1093
1094 NTSTATUS cli_qfilename(struct cli_state *cli, uint16_t fnum,
1095                        TALLOC_CTX *mem_ctx, char **_name)
1096 {
1097         uint16_t recv_flags2;
1098         uint8_t *rdata;
1099         uint32_t num_rdata;
1100         NTSTATUS status;
1101         char *name = NULL;
1102         uint32_t namelen;
1103
1104         status = cli_qfileinfo(talloc_tos(), cli, fnum,
1105                                SMB_QUERY_FILE_NAME_INFO,
1106                                4, CLI_BUFFER_SIZE, &recv_flags2,
1107                                &rdata, &num_rdata);
1108         if (!NT_STATUS_IS_OK(status)) {
1109                 return status;
1110         }
1111
1112         namelen = IVAL(rdata, 0);
1113         if (namelen > (num_rdata - 4)) {
1114                 TALLOC_FREE(rdata);
1115                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1116         }
1117
1118         clistr_pull_talloc(mem_ctx,
1119                            (const char *)rdata,
1120                            recv_flags2,
1121                            &name,
1122                            rdata + 4,
1123                            namelen,
1124                            STR_UNICODE);
1125         if (name == NULL) {
1126                 status = map_nt_error_from_unix(errno);
1127                 TALLOC_FREE(rdata);
1128                 return status;
1129         }
1130
1131         *_name = name;
1132         TALLOC_FREE(rdata);
1133         return NT_STATUS_OK;
1134 }
1135
1136 /****************************************************************************
1137  Send a qfileinfo call.
1138 ****************************************************************************/
1139
1140 NTSTATUS cli_qfileinfo_basic(struct cli_state *cli, uint16_t fnum,
1141                              uint16_t *mode, off_t *size,
1142                              struct timespec *create_time,
1143                              struct timespec *access_time,
1144                              struct timespec *write_time,
1145                              struct timespec *change_time,
1146                              SMB_INO_T *ino)
1147 {
1148         uint8_t *rdata;
1149         uint32_t num_rdata;
1150         NTSTATUS status;
1151
1152         if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
1153                 return cli_smb2_qfileinfo_basic(cli,
1154                                                 fnum,
1155                                                 mode,
1156                                                 size,
1157                                                 create_time,
1158                                                 access_time,
1159                                                 write_time,
1160                                                 change_time,
1161                                                 ino);
1162         }
1163
1164         /* if its a win95 server then fail this - win95 totally screws it
1165            up */
1166         if (cli->win95) {
1167                 return NT_STATUS_NOT_SUPPORTED;
1168         }
1169
1170         status = cli_qfileinfo(talloc_tos(), cli, fnum,
1171                                SMB_QUERY_FILE_ALL_INFO,
1172                                68, CLI_BUFFER_SIZE,
1173                                NULL,
1174                                &rdata, &num_rdata);
1175         if (!NT_STATUS_IS_OK(status)) {
1176                 return status;
1177         }
1178
1179         if (create_time) {
1180                 *create_time = interpret_long_date((char *)rdata+0);
1181         }
1182         if (access_time) {
1183                 *access_time = interpret_long_date((char *)rdata+8);
1184         }
1185         if (write_time) {
1186                 *write_time = interpret_long_date((char *)rdata+16);
1187         }
1188         if (change_time) {
1189                 *change_time = interpret_long_date((char *)rdata+24);
1190         }
1191         if (mode) {
1192                 *mode = SVAL(rdata, 32);
1193         }
1194         if (size) {
1195                 *size = IVAL2_TO_SMB_BIG_UINT(rdata,48);
1196         }
1197         if (ino) {
1198                 *ino = IVAL(rdata, 64);
1199         }
1200
1201         TALLOC_FREE(rdata);
1202         return NT_STATUS_OK;
1203 }
1204
1205 /****************************************************************************
1206  Send a qpathinfo BASIC_INFO call.
1207 ****************************************************************************/
1208
1209 struct cli_qpathinfo_basic_state {
1210         uint32_t num_data;
1211         uint8_t *data;
1212 };
1213
1214 static void cli_qpathinfo_basic_done(struct tevent_req *subreq);
1215
1216 struct tevent_req *cli_qpathinfo_basic_send(TALLOC_CTX *mem_ctx,
1217                                             struct tevent_context *ev,
1218                                             struct cli_state *cli,
1219                                             const char *fname)
1220 {
1221         struct tevent_req *req = NULL, *subreq = NULL;
1222         struct cli_qpathinfo_basic_state *state = NULL;
1223
1224         req = tevent_req_create(mem_ctx, &state,
1225                                 struct cli_qpathinfo_basic_state);
1226         if (req == NULL) {
1227                 return NULL;
1228         }
1229         subreq = cli_qpathinfo_send(state, ev, cli, fname,
1230                                     SMB_QUERY_FILE_BASIC_INFO,
1231                                     36, CLI_BUFFER_SIZE);
1232         if (tevent_req_nomem(subreq, req)) {
1233                 return tevent_req_post(req, ev);
1234         }
1235         tevent_req_set_callback(subreq, cli_qpathinfo_basic_done, req);
1236         return req;
1237 }
1238
1239 static void cli_qpathinfo_basic_done(struct tevent_req *subreq)
1240 {
1241         struct tevent_req *req = tevent_req_callback_data(
1242                 subreq, struct tevent_req);
1243         struct cli_qpathinfo_basic_state *state = tevent_req_data(
1244                 req, struct cli_qpathinfo_basic_state);
1245         NTSTATUS status;
1246
1247         status = cli_qpathinfo_recv(subreq, state, &state->data,
1248                                     &state->num_data);
1249         TALLOC_FREE(subreq);
1250         if (!NT_STATUS_IS_OK(status)) {
1251                 tevent_req_nterror(req, status);
1252                 return;
1253         }
1254         tevent_req_done(req);
1255 }
1256
1257 NTSTATUS cli_qpathinfo_basic_recv(struct tevent_req *req,
1258                                   SMB_STRUCT_STAT *sbuf, uint32_t *attributes)
1259 {
1260         struct cli_qpathinfo_basic_state *state = tevent_req_data(
1261                 req, struct cli_qpathinfo_basic_state);
1262         NTSTATUS status;
1263
1264         if (tevent_req_is_nterror(req, &status)) {
1265                 return status;
1266         }
1267
1268         sbuf->st_ex_btime = interpret_long_date((char *)state->data);
1269         sbuf->st_ex_atime = interpret_long_date((char *)state->data+8);
1270         sbuf->st_ex_mtime = interpret_long_date((char *)state->data+16);
1271         sbuf->st_ex_ctime = interpret_long_date((char *)state->data+24);
1272         *attributes = IVAL(state->data, 32);
1273         return NT_STATUS_OK;
1274 }
1275
1276 NTSTATUS cli_qpathinfo_basic(struct cli_state *cli, const char *name,
1277                              SMB_STRUCT_STAT *sbuf, uint32_t *attributes)
1278 {
1279         TALLOC_CTX *frame = NULL;
1280         struct tevent_context *ev;
1281         struct tevent_req *req;
1282         NTSTATUS status = NT_STATUS_NO_MEMORY;
1283
1284         if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
1285                 return cli_smb2_qpathinfo_basic(cli,
1286                                                 name,
1287                                                 sbuf,
1288                                                 attributes);
1289         }
1290
1291         frame = talloc_stackframe();
1292
1293         if (smbXcli_conn_has_async_calls(cli->conn)) {
1294                 /*
1295                  * Can't use sync call while an async call is in flight
1296                  */
1297                 status = NT_STATUS_INVALID_PARAMETER;
1298                 goto fail;
1299         }
1300         ev = samba_tevent_context_init(frame);
1301         if (ev == NULL) {
1302                 goto fail;
1303         }
1304         req = cli_qpathinfo_basic_send(frame, ev, cli, name);
1305         if (req == NULL) {
1306                 goto fail;
1307         }
1308         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
1309                 goto fail;
1310         }
1311         status = cli_qpathinfo_basic_recv(req, sbuf, attributes);
1312  fail:
1313         TALLOC_FREE(frame);
1314         return status;
1315 }
1316
1317 /****************************************************************************
1318  Send a qpathinfo SMB_QUERY_FILE_ALT_NAME_INFO call.
1319 ****************************************************************************/
1320
1321 NTSTATUS cli_qpathinfo_alt_name(struct cli_state *cli, const char *fname, fstring alt_name)
1322 {
1323         uint8_t *rdata;
1324         uint32_t num_rdata;
1325         unsigned int len;
1326         char *converted = NULL;
1327         size_t converted_size = 0;
1328         NTSTATUS status;
1329
1330         if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
1331                 return cli_smb2_qpathinfo_alt_name(cli,
1332                                                 fname,
1333                                                 alt_name);
1334         }
1335
1336         status = cli_qpathinfo(talloc_tos(), cli, fname,
1337                                SMB_QUERY_FILE_ALT_NAME_INFO,
1338                                4, CLI_BUFFER_SIZE, &rdata, &num_rdata);
1339         if (!NT_STATUS_IS_OK(status)) {
1340                 return status;
1341         }
1342
1343         len = IVAL(rdata, 0);
1344
1345         if (len > num_rdata - 4) {
1346                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1347         }
1348
1349         /* The returned data is a pushed string, not raw data. */
1350         if (!convert_string_talloc(talloc_tos(),
1351                                    smbXcli_conn_use_unicode(cli->conn) ? CH_UTF16LE : CH_DOS,
1352                                    CH_UNIX,
1353                                    rdata + 4,
1354                                    len,
1355                                    &converted,
1356                                    &converted_size)) {
1357                 return NT_STATUS_NO_MEMORY;
1358         }
1359         fstrcpy(alt_name, converted);
1360
1361         TALLOC_FREE(converted);
1362         TALLOC_FREE(rdata);
1363
1364         return NT_STATUS_OK;
1365 }
1366
1367 /****************************************************************************
1368  Send a qpathinfo SMB_QUERY_FILE_STADNDARD_INFO call.
1369 ****************************************************************************/
1370
1371 NTSTATUS cli_qpathinfo_standard(struct cli_state *cli, const char *fname,
1372                                 uint64_t *allocated, uint64_t *size,
1373                                 uint32_t *nlinks,
1374                                 bool *is_del_pending, bool *is_dir)
1375 {
1376         uint8_t *rdata;
1377         uint32_t num_rdata;
1378         NTSTATUS status;
1379
1380         if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
1381                 return NT_STATUS_NOT_IMPLEMENTED;
1382         }
1383
1384         status = cli_qpathinfo(talloc_tos(), cli, fname,
1385                                SMB_QUERY_FILE_STANDARD_INFO,
1386                                24, CLI_BUFFER_SIZE, &rdata, &num_rdata);
1387         if (!NT_STATUS_IS_OK(status)) {
1388                 return status;
1389         }
1390
1391         if (allocated) {
1392                 *allocated = BVAL(rdata, 0);
1393         }
1394
1395         if (size) {
1396                 *size = BVAL(rdata, 8);
1397         }
1398
1399         if (nlinks) {
1400                 *nlinks = IVAL(rdata, 16);
1401         }
1402
1403         if (is_del_pending) {
1404                 *is_del_pending = CVAL(rdata, 20);
1405         }
1406
1407         if (is_dir) {
1408                 *is_dir = CVAL(rdata, 20);
1409         }
1410
1411         TALLOC_FREE(rdata);
1412
1413         return NT_STATUS_OK;
1414 }
1415
1416
1417 /* like cli_qpathinfo2 but do not use SMB_QUERY_FILE_ALL_INFO with smb1 */
1418 NTSTATUS cli_qpathinfo3(struct cli_state *cli, const char *fname,
1419                         struct timespec *create_time,
1420                         struct timespec *access_time,
1421                         struct timespec *write_time,
1422                         struct timespec *change_time,
1423                         off_t *size, uint16_t *mode,
1424                         SMB_INO_T *ino)
1425 {
1426         NTSTATUS status = NT_STATUS_OK;
1427         SMB_STRUCT_STAT st = { 0 };
1428         uint32_t attr;
1429         uint64_t pos;
1430
1431         if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
1432                 return cli_qpathinfo2(cli, fname,
1433                                       create_time, access_time, write_time, change_time,
1434                                       size, mode, ino);
1435         }
1436
1437         if (create_time || access_time || write_time || change_time || mode) {
1438                 status = cli_qpathinfo_basic(cli, fname, &st, &attr);
1439                 if (!NT_STATUS_IS_OK(status)) {
1440                         return status;
1441                 }
1442         }
1443
1444         if (size) {
1445                 status = cli_qpathinfo_standard(cli, fname,
1446                                                 NULL, &pos, NULL, NULL, NULL);
1447                 if (!NT_STATUS_IS_OK(status)) {
1448                         return status;
1449                 }
1450
1451                 *size = pos;
1452         }
1453
1454         if (create_time) {
1455                 *create_time = st.st_ex_btime;
1456         }
1457         if (access_time) {
1458                 *access_time = st.st_ex_atime;
1459         }
1460         if (write_time) {
1461                 *write_time = st.st_ex_mtime;
1462         }
1463         if (change_time) {
1464                 *change_time = st.st_ex_ctime;
1465         }
1466         if (mode) {
1467                 *mode = attr;
1468         }
1469         if (ino) {
1470                 *ino = 0;
1471         }
1472
1473         return NT_STATUS_OK;
1474 }