source3/libsmb/libsmb_file.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    SMB client library implementation
   4    Copyright (C) Andrew Tridgell 1998
   5    Copyright (C) Richard Sharpe 2000, 2002
   6    Copyright (C) John Terpstra 2000
   7    Copyright (C) Tom Jansen (Ninja ISD) 2002
   8    Copyright (C) Derrell Lipman 2003-2008
   9    Copyright (C) Jeremy Allison 2007, 2008
  10
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 3 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  23 */
  24
  25 #include "includes.h"
  26 #include "libsmbclient.h"
  27 #include "libsmb_internal.h"
  28
  29
  30 /*
  31  * Routine to open() a file ...
  32  */
  33
  34 SMBCFILE *
  35 SMBC_open_ctx(SMBCCTX *context,
  36               const char *fname,
  37               int flags,
  38               mode_t mode)
  39 {
  40         char *server = NULL;
  41         char *share = NULL;
  42         char *user = NULL;
  43         char *password = NULL;
  44         char *workgroup = NULL;
  45         char *path = NULL;
  46         char *targetpath = NULL;
  47         struct cli_state *targetcli = NULL;
  48         SMBCSRV *srv   = NULL;
  49         SMBCFILE *file = NULL;
  50         uint16_t fd;
  51         NTSTATUS status = NT_STATUS_OBJECT_PATH_INVALID;
  52         TALLOC_CTX *frame = talloc_stackframe();
  53
  54         if (!context || !context->internal->initialized) {
  55
  56                 errno = EINVAL;  /* Best I can think of ... */
  57                 TALLOC_FREE(frame);
  58                 return NULL;
  59
  60         }
  61
  62         if (!fname) {
  63
  64                 errno = EINVAL;
  65                 TALLOC_FREE(frame);
  66                 return NULL;
  67
  68         }
  69
  70         if (SMBC_parse_path(frame,
  71                             context,
  72                             fname,
  73                             &workgroup,
  74                             &server,
  75                             &share,
  76                             &path,
  77                             &user,
  78                             &password,
  79                             NULL)) {
  80                 errno = EINVAL;
  81                 TALLOC_FREE(frame);
  82                 return NULL;
  83         }
  84
  85         if (!user || user[0] == (char)0) {
  86                 user = talloc_strdup(frame, smbc_getUser(context));
  87                 if (!user) {
  88                         errno = ENOMEM;
  89                         TALLOC_FREE(frame);
  90                         return NULL;
  91                 }
  92         }
  93
  94         srv = SMBC_server(frame, context, True,
  95                           server, share, &workgroup, &user, &password);
  96
  97         if (!srv) {
  98                 if (errno == EPERM) errno = EACCES;
  99                 TALLOC_FREE(frame);
 100                 return NULL;  /* SMBC_server sets errno */
 101         }
 102
 103         /* Hmmm, the test for a directory is suspect here ... FIXME */
 104
 105         if (strlen(path) > 0 && path[strlen(path) - 1] == '\\') {
 106                 status = NT_STATUS_OBJECT_PATH_INVALID;
 107         } else {
 108                 file = SMB_MALLOC_P(SMBCFILE);
 109
 110                 if (!file) {
 111                         errno = ENOMEM;
 112                         TALLOC_FREE(frame);
 113                         return NULL;
 114                 }
 115
 116                 ZERO_STRUCTP(file);
 117
 118                 /*d_printf(">>>open: resolving %s\n", path);*/
 119                 if (!cli_resolve_path(frame, "", context->internal->auth_info,
 120                                 srv->cli, path,
 121                                 &targetcli, &targetpath)) {
 122                         d_printf("Could not resolve %s\n", path);
 123                         errno = ENOENT;
 124                         SAFE_FREE(file);
 125                         TALLOC_FREE(frame);
 126                         return NULL;
 127                 }
 128                 /*d_printf(">>>open: resolved %s as %s\n", path, targetpath);*/
 129
 130                 status = cli_open(targetcli, targetpath, flags,
 131                                    context->internal->share_mode, &fd);
 132                 if (!NT_STATUS_IS_OK(status)) {
 133
 134                         /* Handle the error ... */
 135
 136                         SAFE_FREE(file);
 137                         errno = SMBC_errno(context, targetcli);
 138                         TALLOC_FREE(frame);
 139                         return NULL;
 140
 141                 }
 142
 143                 /* Fill in file struct */
 144
 145                 file->cli_fd  = fd;
 146                 file->fname   = SMB_STRDUP(fname);
 147                 file->srv     = srv;
 148                 file->offset  = 0;
 149                 file->file    = True;
 150
 151                 DLIST_ADD(context->internal->files, file);
 152
 153                 /*
 154                  * If the file was opened in O_APPEND mode, all write
 155                  * operations should be appended to the file.  To do that,
 156                  * though, using this protocol, would require a getattrE()
 157                  * call for each and every write, to determine where the end
 158                  * of the file is. (There does not appear to be an append flag
 159                  * in the protocol.)  Rather than add all of that overhead of
 160                  * retrieving the current end-of-file offset prior to each
 161                  * write operation, we'll assume that most append operations
 162                  * will continuously write, so we'll just set the offset to
 163                  * the end of the file now and hope that's adequate.
 164                  *
 165                  * Note to self: If this proves inadequate, and O_APPEND
 166                  * should, in some cases, be forced for each write, add a
 167                  * field in the context options structure, for
 168                  * "strict_append_mode" which would select between the current
 169                  * behavior (if FALSE) or issuing a getattrE() prior to each
 170                  * write and forcing the write to the end of the file (if
 171                  * TRUE).  Adding that capability will likely require adding
 172                  * an "append" flag into the _SMBCFILE structure to track
 173                  * whether a file was opened in O_APPEND mode.  -- djl
 174                  */
 175                 if (flags & O_APPEND) {
 176                         if (SMBC_lseek_ctx(context, file, 0, SEEK_END) < 0) {
 177                                 (void) SMBC_close_ctx(context, file);
 178                                 errno = ENXIO;
 179                                 TALLOC_FREE(frame);
 180                                 return NULL;
 181                         }
 182                 }
 183
 184                 TALLOC_FREE(frame);
 185                 return file;
 186
 187         }
 188
 189         /* Check if opendir needed ... */
 190
 191         if (!NT_STATUS_IS_OK(status)) {
 192                 int eno = 0;
 193
 194                 eno = SMBC_errno(context, srv->cli);
 195                 file = smbc_getFunctionOpendir(context)(context, fname);
 196                 if (!file) errno = eno;
 197                 TALLOC_FREE(frame);
 198                 return file;
 199
 200         }
 201
 202         errno = EINVAL; /* FIXME, correct errno ? */
 203         TALLOC_FREE(frame);
 204         return NULL;
 205
 206 }
 207
 208 /*
 209  * Routine to create a file
 210  */
 211
 212 SMBCFILE *
 213 SMBC_creat_ctx(SMBCCTX *context,
 214                const char *path,
 215                mode_t mode)
 216 {
 217
 218         if (!context || !context->internal->initialized) {
 219
 220                 errno = EINVAL;
 221                 return NULL;
 222
 223         }
 224
 225         return SMBC_open_ctx(context, path,
 226                              O_WRONLY | O_CREAT | O_TRUNC, mode);
 227 }
 228
 229 /*
 230  * Routine to read() a file ...
 231  */
 232
 233 ssize_t
 234 SMBC_read_ctx(SMBCCTX *context,
 235               SMBCFILE *file,
 236               void *buf,
 237               size_t count)
 238 {
 239         int ret;
 240         char *server = NULL, *share = NULL, *user = NULL, *password = NULL;
 241         char *path = NULL;
 242         char *targetpath = NULL;
 243         struct cli_state *targetcli = NULL;
 244         TALLOC_CTX *frame = talloc_stackframe();
 245
 246         /*
 247          * offset:
 248          *
 249          * Compiler bug (possibly) -- gcc (GCC) 3.3.5 (Debian 1:3.3.5-2) --
 250          * appears to pass file->offset (which is type off_t) differently than
 251          * a local variable of type off_t.  Using local variable "offset" in
 252          * the call to cli_read() instead of file->offset fixes a problem
 253          * retrieving data at an offset greater than 4GB.
 254          */
 255         off_t offset;
 256
 257         if (!context || !context->internal->initialized) {
 258
 259                 errno = EINVAL;
 260                 TALLOC_FREE(frame);
 261                 return -1;
 262
 263         }
 264
 265         DEBUG(4, ("smbc_read(%p, %d)\n", file, (int)count));
 266
 267         if (!file || !SMBC_dlist_contains(context->internal->files, file)) {
 268                 errno = EBADF;
 269                 TALLOC_FREE(frame);
 270                 return -1;
 271
 272         }
 273
 274         offset = file->offset;
 275
 276         /* Check that the buffer exists ... */
 277
 278         if (buf == NULL) {
 279                 errno = EINVAL;
 280                 TALLOC_FREE(frame);
 281                 return -1;
 282
 283         }
 284
 285         /*d_printf(">>>read: parsing %s\n", file->fname);*/
 286         if (SMBC_parse_path(frame,
 287                             context,
 288                             file->fname,
 289                             NULL,
 290                             &server,
 291                             &share,
 292                             &path,
 293                             &user,
 294                             &password,
 295                             NULL)) {
 296                 errno = EINVAL;
 297                 TALLOC_FREE(frame);
 298                 return -1;
 299         }
 300
 301         /*d_printf(">>>read: resolving %s\n", path);*/
 302         if (!cli_resolve_path(frame, "", context->internal->auth_info,
 303                         file->srv->cli, path,
 304                         &targetcli, &targetpath)) {
 305                 d_printf("Could not resolve %s\n", path);
 306                 errno = ENOENT;
 307                 TALLOC_FREE(frame);
 308                 return -1;
 309         }
 310         /*d_printf(">>>fstat: resolved path as %s\n", targetpath);*/
 311
 312         ret = cli_read(targetcli, file->cli_fd, (char *)buf, offset, count);
 313
 314         if (ret < 0) {
 315
 316                 errno = SMBC_errno(context, targetcli);
 317                 TALLOC_FREE(frame);
 318                 return -1;
 319
 320         }
 321
 322         file->offset += ret;
 323
 324         DEBUG(4, ("  --> %d\n", ret));
 325
 326         TALLOC_FREE(frame);
 327         return ret;  /* Success, ret bytes of data ... */
 328
 329 }
 330
 331 /*
 332  * Routine to write() a file ...
 333  */
 334
 335 ssize_t
 336 SMBC_write_ctx(SMBCCTX *context,
 337                SMBCFILE *file,
 338                const void *buf,
 339                size_t count)
 340 {
 341         int ret;
 342         off_t offset;
 343         char *server = NULL, *share = NULL, *user = NULL, *password = NULL;
 344         char *path = NULL;
 345         char *targetpath = NULL;
 346         struct cli_state *targetcli = NULL;
 347         TALLOC_CTX *frame = talloc_stackframe();
 348
 349         /* First check all pointers before dereferencing them */
 350
 351         if (!context || !context->internal->initialized) {
 352
 353                 errno = EINVAL;
 354                 TALLOC_FREE(frame);
 355                 return -1;
 356
 357         }
 358
 359         if (!file || !SMBC_dlist_contains(context->internal->files, file)) {
 360                 errno = EBADF;
 361                 TALLOC_FREE(frame);
 362                 return -1;
 363         }
 364
 365         /* Check that the buffer exists ... */
 366
 367         if (buf == NULL) {
 368                 errno = EINVAL;
 369                 TALLOC_FREE(frame);
 370                 return -1;
 371
 372         }
 373
 374         offset = file->offset; /* See "offset" comment in SMBC_read_ctx() */
 375
 376         /*d_printf(">>>write: parsing %s\n", file->fname);*/
 377         if (SMBC_parse_path(frame,
 378                             context,
 379                             file->fname,
 380                             NULL,
 381                             &server,
 382                             &share,
 383                             &path,
 384                             &user,
 385                             &password,
 386                             NULL)) {
 387                 errno = EINVAL;
 388                 TALLOC_FREE(frame);
 389                 return -1;
 390         }
 391
 392         /*d_printf(">>>write: resolving %s\n", path);*/
 393         if (!cli_resolve_path(frame, "", context->internal->auth_info,
 394                         file->srv->cli, path,
 395                         &targetcli, &targetpath)) {
 396                 d_printf("Could not resolve %s\n", path);
 397                 errno = ENOENT;
 398                 TALLOC_FREE(frame);
 399                 return -1;
 400         }
 401         /*d_printf(">>>write: resolved path as %s\n", targetpath);*/
 402
 403         ret = cli_write(targetcli, file->cli_fd,
 404                         0, (char *)buf, offset, count);
 405
 406         if (ret <= 0) {
 407                 errno = SMBC_errno(context, targetcli);
 408                 TALLOC_FREE(frame);
 409                 return -1;
 410
 411         }
 412
 413         file->offset += ret;
 414
 415         TALLOC_FREE(frame);
 416         return ret;  /* Success, 0 bytes of data ... */
 417 }
 418
 419 /*
 420  * Routine to close() a file ...
 421  */
 422
 423 int
 424 SMBC_close_ctx(SMBCCTX *context,
 425                SMBCFILE *file)
 426 {
 427         SMBCSRV *srv;
 428         char *server = NULL, *share = NULL, *user = NULL, *password = NULL;
 429         char *path = NULL;
 430         char *targetpath = NULL;
 431         struct cli_state *targetcli = NULL;
 432         TALLOC_CTX *frame = talloc_stackframe();
 433
 434         if (!context || !context->internal->initialized) {
 435
 436                 errno = EINVAL;
 437                 TALLOC_FREE(frame);
 438                 return -1;
 439         }
 440
 441         if (!file || !SMBC_dlist_contains(context->internal->files, file)) {
 442                 errno = EBADF;
 443                 TALLOC_FREE(frame);
 444                 return -1;
 445         }
 446
 447         /* IS a dir ... */
 448         if (!file->file) {
 449                 TALLOC_FREE(frame);
 450                 return smbc_getFunctionClosedir(context)(context, file);
 451         }
 452
 453         /*d_printf(">>>close: parsing %s\n", file->fname);*/
 454         if (SMBC_parse_path(frame,
 455                             context,
 456                             file->fname,
 457                             NULL,
 458                             &server,
 459                             &share,
 460                             &path,
 461                             &user,
 462                             &password,
 463                             NULL)) {
 464                 errno = EINVAL;
 465                 TALLOC_FREE(frame);
 466                 return -1;
 467         }
 468
 469         /*d_printf(">>>close: resolving %s\n", path);*/
 470         if (!cli_resolve_path(frame, "", context->internal->auth_info,
 471                         file->srv->cli, path,
 472                         &targetcli, &targetpath)) {
 473                 d_printf("Could not resolve %s\n", path);
 474                 errno = ENOENT;
 475                 TALLOC_FREE(frame);
 476                 return -1;
 477         }
 478         /*d_printf(">>>close: resolved path as %s\n", targetpath);*/
 479
 480         if (!NT_STATUS_IS_OK(cli_close(targetcli, file->cli_fd))) {
 481
 482                 DEBUG(3, ("cli_close failed on %s. purging server.\n",
 483                           file->fname));
 484                 /* Deallocate slot and remove the server
 485                  * from the server cache if unused */
 486                 errno = SMBC_errno(context, targetcli);
 487                 srv = file->srv;
 488                 DLIST_REMOVE(context->internal->files, file);
 489                 SAFE_FREE(file->fname);
 490                 SAFE_FREE(file);
 491                 smbc_getFunctionRemoveUnusedServer(context)(context, srv);
 492                 TALLOC_FREE(frame);
 493                 return -1;
 494
 495         }
 496
 497         DLIST_REMOVE(context->internal->files, file);
 498         SAFE_FREE(file->fname);
 499         SAFE_FREE(file);
 500         TALLOC_FREE(frame);
 501
 502         return 0;
 503 }
 504
 505 /*
 506  * Get info from an SMB server on a file. Use a qpathinfo call first
 507  * and if that fails, use getatr, as Win95 sometimes refuses qpathinfo
 508  */
 509 bool
 510 SMBC_getatr(SMBCCTX * context,
 511             SMBCSRV *srv,
 512             char *path,
 513             uint16 *mode,
 514             SMB_OFF_T *size,
 515             struct timespec *create_time_ts,
 516             struct timespec *access_time_ts,
 517             struct timespec *write_time_ts,
 518             struct timespec *change_time_ts,
 519             SMB_INO_T *ino)
 520 {
 521         char *fixedpath = NULL;
 522         char *targetpath = NULL;
 523         struct cli_state *targetcli = NULL;
 524         time_t write_time;
 525         TALLOC_CTX *frame = talloc_stackframe();
 526
 527         if (!context || !context->internal->initialized) {
 528
 529                 errno = EINVAL;
 530                 TALLOC_FREE(frame);
 531                 return False;
 532         }
 533
 534         /* path fixup for . and .. */
 535         if (strequal(path, ".") || strequal(path, "..")) {
 536                 fixedpath = talloc_strdup(frame, "\\");
 537                 if (!fixedpath) {
 538                         errno = ENOMEM;
 539                         TALLOC_FREE(frame);
 540                         return False;
 541                 }
 542         } else {
 543                 fixedpath = talloc_strdup(frame, path);
 544                 if (!fixedpath) {
 545                         errno = ENOMEM;
 546                         TALLOC_FREE(frame);
 547                         return False;
 548                 }
 549                 trim_string(fixedpath, NULL, "\\..");
 550                 trim_string(fixedpath, NULL, "\\.");
 551         }
 552         DEBUG(4,("SMBC_getatr: sending qpathinfo\n"));
 553
 554         if (!cli_resolve_path(frame, "", context->internal->auth_info,
 555                         srv->cli, fixedpath,
 556                         &targetcli, &targetpath)) {
 557                 d_printf("Couldn't resolve %s\n", path);
 558                 errno = ENOENT;
 559                 TALLOC_FREE(frame);
 560                 return False;
 561         }
 562
 563         if (!srv->no_pathinfo2 &&
 564             cli_qpathinfo2(targetcli, targetpath,
 565                            create_time_ts,
 566                            access_time_ts,
 567                            write_time_ts,
 568                            change_time_ts,
 569                            size, mode, ino)) {
 570                 TALLOC_FREE(frame);
 571                 return True;
 572         }
 573
 574         /* if this is NT then don't bother with the getatr */
 575         if (targetcli->capabilities & CAP_NT_SMBS) {
 576                 errno = EPERM;
 577                 TALLOC_FREE(frame);
 578                 return False;
 579         }
 580
 581         if (NT_STATUS_IS_OK(cli_getatr(targetcli, targetpath, mode, size, &write_time))) {
 582
 583                 struct timespec w_time_ts;
 584
 585                 w_time_ts = convert_time_t_to_timespec(write_time);
 586
 587                 if (write_time_ts != NULL) {
 588                         *write_time_ts = w_time_ts;
 589                 }
 590
 591                 if (create_time_ts != NULL) {
 592                         *create_time_ts = w_time_ts;
 593                 }
 594
 595                 if (access_time_ts != NULL) {
 596                         *access_time_ts = w_time_ts;
 597                 }
 598
 599                 if (change_time_ts != NULL) {
 600                         *change_time_ts = w_time_ts;
 601                 }
 602
 603                 srv->no_pathinfo2 = True;
 604                 TALLOC_FREE(frame);
 605                 return True;
 606         }
 607
 608         errno = EPERM;
 609         TALLOC_FREE(frame);
 610         return False;
 611
 612 }
 613
 614 /*
 615  * Set file info on an SMB server.  Use setpathinfo call first.  If that
 616  * fails, use setattrE..
 617  *
 618  * Access and modification time parameters are always used and must be
 619  * provided.  Create time, if zero, will be determined from the actual create
 620  * time of the file.  If non-zero, the create time will be set as well.
 621  *
 622  * "mode" (attributes) parameter may be set to -1 if it is not to be set.
 623  */
 624 bool
 625 SMBC_setatr(SMBCCTX * context, SMBCSRV *srv, char *path,
 626             time_t create_time,
 627             time_t access_time,
 628             time_t write_time,
 629             time_t change_time,
 630             uint16 mode)
 631 {
 632         uint16_t fd;
 633         int ret;
 634         TALLOC_CTX *frame = talloc_stackframe();
 635
 636         /*
 637          * First, try setpathinfo (if qpathinfo succeeded), for it is the
 638          * modern function for "new code" to be using, and it works given a
 639          * filename rather than requiring that the file be opened to have its
 640          * attributes manipulated.
 641          */
 642         if (srv->no_pathinfo ||
 643             ! cli_setpathinfo(srv->cli, path,
 644                               create_time,
 645                               access_time,
 646                               write_time,
 647                               change_time,
 648                               mode)) {
 649
 650                 /*
 651                  * setpathinfo is not supported; go to plan B.
 652                  *
 653                  * cli_setatr() does not work on win98, and it also doesn't
 654                  * support setting the access time (only the modification
 655                  * time), so in all cases, we open the specified file and use
 656                  * cli_setattrE() which should work on all OS versions, and
 657                  * supports both times.
 658                  */
 659
 660                 /* Don't try {q,set}pathinfo() again, with this server */
 661                 srv->no_pathinfo = True;
 662
 663                 /* Open the file */
 664                 if (!NT_STATUS_IS_OK(cli_open(srv->cli, path, O_RDWR, DENY_NONE, &fd))) {
 665
 666                         errno = SMBC_errno(context, srv->cli);
 667                         TALLOC_FREE(frame);
 668                         return -1;
 669                 }
 670
 671                 /* Set the new attributes */
 672                 ret = NT_STATUS_IS_OK(cli_setattrE(srv->cli, fd,
 673                                    change_time,
 674                                    access_time,
 675                                    write_time));
 676
 677                 /* Close the file */
 678                 cli_close(srv->cli, fd);
 679
 680                 /*
 681                  * Unfortunately, setattrE() doesn't have a provision for
 682                  * setting the access mode (attributes).  We'll have to try
 683                  * cli_setatr() for that, and with only this parameter, it
 684                  * seems to work on win98.
 685                  */
 686                 if (ret && mode != (uint16) -1) {
 687                         ret = NT_STATUS_IS_OK(cli_setatr(srv->cli, path, mode, 0));
 688                 }
 689
 690                 if (! ret) {
 691                         errno = SMBC_errno(context, srv->cli);
 692                         TALLOC_FREE(frame);
 693                         return False;
 694                 }
 695         }
 696
 697         TALLOC_FREE(frame);
 698         return True;
 699 }
 700
 701 /*
 702  * A routine to lseek() a file
 703  */
 704
 705 off_t
 706 SMBC_lseek_ctx(SMBCCTX *context,
 707                SMBCFILE *file,
 708                off_t offset,
 709                int whence)
 710 {
 711         SMB_OFF_T size;
 712         char *server = NULL, *share = NULL, *user = NULL, *password = NULL;
 713         char *path = NULL;
 714         char *targetpath = NULL;
 715         struct cli_state *targetcli = NULL;
 716         TALLOC_CTX *frame = talloc_stackframe();
 717
 718         if (!context || !context->internal->initialized) {
 719
 720                 errno = EINVAL;
 721                 TALLOC_FREE(frame);
 722                 return -1;
 723         }
 724
 725         if (!file || !SMBC_dlist_contains(context->internal->files, file)) {
 726
 727                 errno = EBADF;
 728                 TALLOC_FREE(frame);
 729                 return -1;
 730
 731         }
 732
 733         if (!file->file) {
 734
 735                 errno = EINVAL;
 736                 TALLOC_FREE(frame);
 737                 return -1;      /* Can't lseek a dir ... */
 738
 739         }
 740
 741         switch (whence) {
 742         case SEEK_SET:
 743                 file->offset = offset;
 744                 break;
 745
 746         case SEEK_CUR:
 747                 file->offset += offset;
 748                 break;
 749
 750         case SEEK_END:
 751                 /*d_printf(">>>lseek: parsing %s\n", file->fname);*/
 752                 if (SMBC_parse_path(frame,
 753                                     context,
 754                                     file->fname,
 755                                     NULL,
 756                                     &server,
 757                                     &share,
 758                                     &path,
 759                                     &user,
 760                                     &password,
 761                                     NULL)) {
 762                         errno = EINVAL;
 763                         TALLOC_FREE(frame);
 764                         return -1;
 765                 }
 766
 767                 /*d_printf(">>>lseek: resolving %s\n", path);*/
 768                 if (!cli_resolve_path(frame, "", context->internal->auth_info,
 769                                 file->srv->cli, path,
 770                                 &targetcli, &targetpath)) {
 771                         d_printf("Could not resolve %s\n", path);
 772                         errno = ENOENT;
 773                         TALLOC_FREE(frame);
 774                         return -1;
 775                 }
 776                 /*d_printf(">>>lseek: resolved path as %s\n", targetpath);*/
 777
 778                 if (!cli_qfileinfo(targetcli, file->cli_fd, NULL,
 779                                    &size, NULL, NULL, NULL, NULL, NULL))
 780                 {
 781                         SMB_OFF_T b_size = size;
 782                         if (!NT_STATUS_IS_OK(cli_getattrE(targetcli, file->cli_fd,
 783                                           NULL, &b_size, NULL, NULL, NULL))) {
 784                                 errno = EINVAL;
 785                                 TALLOC_FREE(frame);
 786                                 return -1;
 787                         } else
 788                                 size = b_size;
 789                 }
 790                 file->offset = size + offset;
 791                 break;
 792
 793         default:
 794                 errno = EINVAL;
 795                 break;
 796
 797         }
 798
 799         TALLOC_FREE(frame);
 800         return file->offset;
 801
 802 }
 803
 804
 805 /*
 806  * Routine to truncate a file given by its file descriptor, to a specified size
 807  */
 808
 809 int
 810 SMBC_ftruncate_ctx(SMBCCTX *context,
 811                    SMBCFILE *file,
 812                    off_t length)
 813 {
 814         SMB_OFF_T size = length;
 815         char *server = NULL;
 816         char *share = NULL;
 817         char *user = NULL;
 818         char *password = NULL;
 819         char *path = NULL;
 820         char *targetpath = NULL;
 821         struct cli_state *targetcli = NULL;
 822         TALLOC_CTX *frame = talloc_stackframe();
 823
 824         if (!context || !context->internal->initialized) {
 825
 826                 errno = EINVAL;
 827                 TALLOC_FREE(frame);
 828                 return -1;
 829         }
 830
 831         if (!file || !SMBC_dlist_contains(context->internal->files, file)) {
 832                 errno = EBADF;
 833                 TALLOC_FREE(frame);
 834                 return -1;
 835         }
 836
 837         if (!file->file) {
 838                 errno = EINVAL;
 839                 TALLOC_FREE(frame);
 840                 return -1;
 841         }
 842
 843         /*d_printf(">>>fstat: parsing %s\n", file->fname);*/
 844         if (SMBC_parse_path(frame,
 845                             context,
 846                             file->fname,
 847                             NULL,
 848                             &server,
 849                             &share,
 850                             &path,
 851                             &user,
 852                             &password,
 853                             NULL)) {
 854                 errno = EINVAL;
 855                 TALLOC_FREE(frame);
 856                 return -1;
 857         }
 858
 859         /*d_printf(">>>fstat: resolving %s\n", path);*/
 860         if (!cli_resolve_path(frame, "", context->internal->auth_info,
 861                         file->srv->cli, path,
 862                         &targetcli, &targetpath)) {
 863                 d_printf("Could not resolve %s\n", path);
 864                 errno = ENOENT;
 865                 TALLOC_FREE(frame);
 866                 return -1;
 867         }
 868         /*d_printf(">>>fstat: resolved path as %s\n", targetpath);*/
 869
 870         if (!NT_STATUS_IS_OK(cli_ftruncate(targetcli, file->cli_fd, (uint64_t)size))) {
 871                 errno = EINVAL;
 872                 TALLOC_FREE(frame);
 873                 return -1;
 874         }
 875
 876         TALLOC_FREE(frame);
 877         return 0;
 878
 879 }