source3/libsmb/libsmb_stat.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  * Generate an inode number from file name for those things that need it
  32  */
  33
  34 static ino_t
  35 generate_inode(SMBCCTX *context,
  36                const char *name)
  37 {
  38         if (!context || !context->internal->initialized) {
  39                 errno = EINVAL;
  40                 return -1;
  41         }
  42
  43         if (!*name) return 2; /* FIXME, why 2 ??? */
  44         return (ino_t)str_checksum(name);
  45 }
  46
  47 /*
  48  * Routine to put basic stat info into a stat structure ... Used by stat and
  49  * fstat below.
  50  */
  51
  52 static int
  53 setup_stat(SMBCCTX *context,
  54            struct stat *st,
  55            char *fname,
  56            SMB_OFF_T size,
  57            int mode)
  58 {
  59         TALLOC_CTX *frame = talloc_stackframe();
  60
  61         st->st_mode = 0;
  62
  63         if (IS_DOS_DIR(mode)) {
  64                 st->st_mode = SMBC_DIR_MODE;
  65         } else {
  66                 st->st_mode = SMBC_FILE_MODE;
  67         }
  68
  69         if (IS_DOS_ARCHIVE(mode)) st->st_mode |= S_IXUSR;
  70         if (IS_DOS_SYSTEM(mode)) st->st_mode |= S_IXGRP;
  71         if (IS_DOS_HIDDEN(mode)) st->st_mode |= S_IXOTH;
  72         if (!IS_DOS_READONLY(mode)) st->st_mode |= S_IWUSR;
  73
  74         st->st_size = size;
  75 #ifdef HAVE_STAT_ST_BLKSIZE
  76         st->st_blksize = 512;
  77 #endif
  78 #ifdef HAVE_STAT_ST_BLOCKS
  79         st->st_blocks = (size+511)/512;
  80 #endif
  81 #ifdef HAVE_STRUCT_STAT_ST_RDEV
  82         st->st_rdev = 0;
  83 #endif
  84         st->st_uid = getuid();
  85         st->st_gid = getgid();
  86
  87         if (IS_DOS_DIR(mode)) {
  88                 st->st_nlink = 2;
  89         } else {
  90                 st->st_nlink = 1;
  91         }
  92
  93         if (st->st_ino == 0) {
  94                 st->st_ino = generate_inode(context, fname);
  95         }
  96
  97         TALLOC_FREE(frame);
  98         return True;  /* FIXME: Is this needed ? */
  99 }
 100
 101 /*
 102  * Routine to stat a file given a name
 103  */
 104
 105 int
 106 SMBC_stat_ctx(SMBCCTX *context,
 107               const char *fname,
 108               struct stat *st)
 109 {
 110         SMBCSRV *srv = NULL;
 111         char *server = NULL;
 112         char *share = NULL;
 113         char *user = NULL;
 114         char *password = NULL;
 115         char *workgroup = NULL;
 116         char *path = NULL;
 117         struct timespec write_time_ts;
 118         struct timespec access_time_ts;
 119         struct timespec change_time_ts;
 120         SMB_OFF_T size = 0;
 121         uint16 mode = 0;
 122         SMB_INO_T ino = 0;
 123         TALLOC_CTX *frame = talloc_stackframe();
 124
 125         if (!context || !context->internal->initialized) {
 126                 errno = EINVAL;  /* Best I can think of ... */
 127                 TALLOC_FREE(frame);
 128                 return -1;
 129         }
 130
 131         if (!fname) {
 132                 errno = EINVAL;
 133                 TALLOC_FREE(frame);
 134                 return -1;
 135         }
 136
 137         DEBUG(4, ("smbc_stat(%s)\n", fname));
 138
 139         if (SMBC_parse_path(frame,
 140                             context,
 141                             fname,
 142                             &workgroup,
 143                             &server,
 144                             &share,
 145                             &path,
 146                             &user,
 147                             &password,
 148                             NULL)) {
 149                 errno = EINVAL;
 150                 TALLOC_FREE(frame);
 151                 return -1;
 152         }
 153
 154         if (!user || user[0] == (char)0) {
 155                 user = talloc_strdup(frame, smbc_getUser(context));
 156                 if (!user) {
 157                         errno = ENOMEM;
 158                         TALLOC_FREE(frame);
 159                         return -1;
 160                 }
 161         }
 162
 163         srv = SMBC_server(frame, context, True,
 164                           server, share, &workgroup, &user, &password);
 165         if (!srv) {
 166                 TALLOC_FREE(frame);
 167                 return -1;  /* errno set by SMBC_server */
 168         }
 169
 170         if (!SMBC_getatr(context, srv, path, &mode, &size,
 171                          NULL,
 172                          &access_time_ts,
 173                          &write_time_ts,
 174                          &change_time_ts,
 175                          &ino)) {
 176                 errno = SMBC_errno(context, srv->cli);
 177                 TALLOC_FREE(frame);
 178                 return -1;
 179         }
 180
 181         st->st_ino = ino;
 182
 183         setup_stat(context, st, (char *) fname, size, mode);
 184
 185         st->st_atime = convert_timespec_to_time_t(access_time_ts);
 186         st->st_ctime = convert_timespec_to_time_t(change_time_ts);
 187         st->st_mtime = convert_timespec_to_time_t(write_time_ts);
 188         st->st_dev   = srv->dev;
 189
 190         TALLOC_FREE(frame);
 191         return 0;
 192 }
 193
 194 /*
 195  * Routine to stat a file given an fd
 196  */
 197
 198 int
 199 SMBC_fstat_ctx(SMBCCTX *context,
 200                SMBCFILE *file,
 201                struct stat *st)
 202 {
 203         struct timespec change_time_ts;
 204         struct timespec access_time_ts;
 205         struct timespec write_time_ts;
 206         SMB_OFF_T size;
 207         uint16 mode;
 208         char *server = NULL;
 209         char *share = NULL;
 210         char *user = NULL;
 211         char *password = NULL;
 212         char *path = NULL;
 213         char *targetpath = NULL;
 214         struct cli_state *targetcli = NULL;
 215         SMB_INO_T ino = 0;
 216         TALLOC_CTX *frame = talloc_stackframe();
 217
 218         if (!context || !context->internal->initialized) {
 219                 errno = EINVAL;
 220                 TALLOC_FREE(frame);
 221                 return -1;
 222         }
 223
 224         if (!file || !SMBC_dlist_contains(context->internal->files, file)) {
 225                 errno = EBADF;
 226                 TALLOC_FREE(frame);
 227                 return -1;
 228         }
 229
 230         if (!file->file) {
 231                 TALLOC_FREE(frame);
 232                 return smbc_getFunctionFstatdir(context)(context, file, st);
 233         }
 234
 235         /*d_printf(">>>fstat: parsing %s\n", file->fname);*/
 236         if (SMBC_parse_path(frame,
 237                             context,
 238                             file->fname,
 239                             NULL,
 240                             &server,
 241                             &share,
 242                             &path,
 243                             &user,
 244                             &password,
 245                             NULL)) {
 246                 errno = EINVAL;
 247                 TALLOC_FREE(frame);
 248                 return -1;
 249         }
 250
 251         /*d_printf(">>>fstat: resolving %s\n", path);*/
 252         if (!cli_resolve_path(frame, "", context->internal->auth_info,
 253                         file->srv->cli, path,
 254                         &targetcli, &targetpath)) {
 255                 d_printf("Could not resolve %s\n", path);
 256                 errno = ENOENT;
 257                 TALLOC_FREE(frame);
 258                 return -1;
 259         }
 260         /*d_printf(">>>fstat: resolved path as %s\n", targetpath);*/
 261
 262         if (!cli_qfileinfo_basic(targetcli, file->cli_fd, &mode, &size,
 263                                  NULL,
 264                                  &access_time_ts,
 265                                  &write_time_ts,
 266                                  &change_time_ts,
 267                                  &ino)) {
 268                 time_t change_time, access_time, write_time;
 269
 270                 if (!NT_STATUS_IS_OK(cli_getattrE(targetcli, file->cli_fd, &mode, &size,
 271                                   &change_time, &access_time, &write_time))) {
 272                         errno = EINVAL;
 273                         TALLOC_FREE(frame);
 274                         return -1;
 275                 }
 276                 change_time_ts = convert_time_t_to_timespec(change_time);
 277                 access_time_ts = convert_time_t_to_timespec(access_time);
 278                 write_time_ts = convert_time_t_to_timespec(write_time);
 279         }
 280
 281         st->st_ino = ino;
 282
 283         setup_stat(context, st, file->fname, size, mode);
 284
 285         st->st_atime = convert_timespec_to_time_t(access_time_ts);
 286         st->st_ctime = convert_timespec_to_time_t(change_time_ts);
 287         st->st_mtime = convert_timespec_to_time_t(write_time_ts);
 288         st->st_dev = file->srv->dev;
 289
 290         TALLOC_FREE(frame);
 291         return 0;
 292 }
 293
 294
 295 /*
 296  * Routine to obtain file system information given a path
 297  */
 298 int
 299 SMBC_statvfs_ctx(SMBCCTX *context,
 300                  char *path,
 301                  struct statvfs *st)
 302 {
 303         int             ret;
 304         bool            bIsDir;
 305         struct stat     statbuf;
 306         SMBCFILE *      pFile;
 307
 308         /* Determine if the provided path is a file or a folder */
 309         if (SMBC_stat_ctx(context, path, &statbuf) < 0) {
 310                 return -1;
 311         }
 312
 313         /* Is it a file or a directory?  */
 314         if (S_ISDIR(statbuf.st_mode)) {
 315                 /* It's a directory. */
 316                 if ((pFile = SMBC_opendir_ctx(context, path)) == NULL) {
 317                         return -1;
 318                 }
 319                 bIsDir = true;
 320         } else if (S_ISREG(statbuf.st_mode)) {
 321                 /* It's a file. */
 322                 if ((pFile = SMBC_open_ctx(context, path,
 323                                            O_RDONLY, 0)) == NULL) {
 324                         return -1;
 325                 }
 326                 bIsDir = false;
 327         } else {
 328                 /* It's neither a file nor a directory. Not supported. */
 329                 errno = ENOSYS;
 330                 return -1;
 331         }
 332
 333         /* Now we have an open file handle, so just use SMBC_fstatvfs */
 334         ret = SMBC_fstatvfs_ctx(context, pFile, st);
 335
 336         /* Close the file or directory */
 337         if (bIsDir) {
 338                 SMBC_closedir_ctx(context, pFile);
 339         } else {
 340                 SMBC_close_ctx(context, pFile);
 341         }
 342
 343         return ret;
 344 }
 345
 346
 347 /*
 348  * Routine to obtain file system information given an fd
 349  */
 350
 351 int
 352 SMBC_fstatvfs_ctx(SMBCCTX *context,
 353                   SMBCFILE *file,
 354                   struct statvfs *st)
 355 {
 356         unsigned long flags = 0;
 357         uint32 fs_attrs = 0;
 358         struct cli_state *cli = file->srv->cli;
 359
 360         /* Initialize all fields (at least until we actually use them) */
 361         memset(st, 0, sizeof(*st));
 362
 363         /*
 364          * The state of each flag is such that the same bits are unset as
 365          * would typically be unset on a local file system on a POSIX OS. Thus
 366          * the bit is on, for example, only for case-insensitive file systems
 367          * since most POSIX file systems are case sensitive and fstatvfs()
 368          * would typically return zero in these bits on such a local file
 369          * system.
 370          */
 371
 372         /* See if the server has UNIX CIFS support */
 373         if (! SERVER_HAS_UNIX_CIFS(cli)) {
 374                 uint64_t total_allocation_units;
 375                 uint64_t caller_allocation_units;
 376                 uint64_t actual_allocation_units;
 377                 uint64_t sectors_per_allocation_unit;
 378                 uint64_t bytes_per_sector;
 379
 380                 /* Nope. If size data is available... */
 381                 if (cli_get_fs_full_size_info(cli,
 382                                               &total_allocation_units,
 383                                               &caller_allocation_units,
 384                                               &actual_allocation_units,
 385                                               &sectors_per_allocation_unit,
 386                                               &bytes_per_sector)) {
 387
 388                         /* ... then provide it */
 389                         st->f_bsize =
 390                                 (unsigned long) bytes_per_sector;
 391 #if HAVE_FRSIZE
 392                         st->f_frsize =
 393                                 (unsigned long) sectors_per_allocation_unit;
 394 #endif
 395                         st->f_blocks =
 396                                 (fsblkcnt_t) total_allocation_units;
 397                         st->f_bfree =
 398                                 (fsblkcnt_t) actual_allocation_units;
 399                 }
 400
 401                 flags |= SMBC_VFS_FEATURE_NO_UNIXCIFS;
 402         } else {
 403                 uint32 optimal_transfer_size;
 404                 uint32 block_size;
 405                 uint64_t total_blocks;
 406                 uint64_t blocks_available;
 407                 uint64_t user_blocks_available;
 408                 uint64_t total_file_nodes;
 409                 uint64_t free_file_nodes;
 410                 uint64_t fs_identifier;
 411
 412                 /* Has UNIXCIFS. If POSIX filesystem info is available... */
 413                 if (cli_get_posix_fs_info(cli,
 414                                           &optimal_transfer_size,
 415                                           &block_size,
 416                                           &total_blocks,
 417                                           &blocks_available,
 418                                           &user_blocks_available,
 419                                           &total_file_nodes,
 420                                           &free_file_nodes,
 421                                           &fs_identifier)) {
 422
 423                         /* ... then what's provided here takes precedence. */
 424                         st->f_bsize =
 425                                 (unsigned long) block_size;
 426                         st->f_blocks =
 427                                 (fsblkcnt_t) total_blocks;
 428                         st->f_bfree =
 429                                 (fsblkcnt_t) blocks_available;
 430                         st->f_bavail =
 431                                 (fsblkcnt_t) user_blocks_available;
 432                         st->f_files =
 433                                 (fsfilcnt_t) total_file_nodes;
 434                         st->f_ffree =
 435                                 (fsfilcnt_t) free_file_nodes;
 436 #if HAVE_FSID_INT
 437                         st->f_fsid =
 438                                 (unsigned long) fs_identifier;
 439 #endif
 440                 }
 441         }
 442
 443         /* See if the share is case sensitive */
 444         if (!NT_STATUS_IS_OK(cli_get_fs_attr_info(cli, &fs_attrs))) {
 445                 /*
 446                  * We can't determine the case sensitivity of
 447                  * the share. We have no choice but to use the
 448                  * user-specified case sensitivity setting.
 449                  */
 450                 if (! smbc_getOptionCaseSensitive(context)) {
 451                         flags |= SMBC_VFS_FEATURE_CASE_INSENSITIVE;
 452                 }
 453         } else {
 454                 if (! (fs_attrs & FILE_CASE_SENSITIVE_SEARCH)) {
 455                         flags |= SMBC_VFS_FEATURE_CASE_INSENSITIVE;
 456                 }
 457         }
 458
 459         /* See if DFS is supported */
 460         if ((cli->capabilities & CAP_DFS) &&  cli->dfsroot) {
 461                 flags |= SMBC_VFS_FEATURE_DFS;
 462         }
 463
 464 #if HAVE_STATVFS_F_FLAG
 465         st->f_flag = flags;
 466 #elif HAVE_STATVFS_F_FLAGS
 467         st->f_flags = flags;
 468 #endif
 469
 470         return 0;
 471 }