root/source4/ntvfs/cifs_posix_cli/vfs_cifs_posix.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. cifspsx_connect
  2. cifspsx_disconnect
  3. find_fd
  4. cifspsx_unlink
  5. cifspsx_ioctl
  6. cifspsx_chkpath
  7. cifspsx_file_id
  8. cifspsx_map_fileinfo
  9. cifspsx_qpathinfo
  10. cifspsx_qfileinfo
  11. cifspsx_open
  12. cifspsx_mkdir
  13. cifspsx_rmdir
  14. cifspsx_rename
  15. cifspsx_copy
  16. cifspsx_read
  17. cifspsx_write
  18. cifspsx_seek
  19. cifspsx_flush
  20. cifspsx_close
  21. cifspsx_exit
  22. cifspsx_logoff
  23. cifspsx_async_setup
  24. cifspsx_cancel
  25. cifspsx_lock
  26. cifspsx_setpathinfo
  27. cifspsx_setfileinfo
  28. cifspsx_fsinfo
  29. cifspsx_fsattr
  30. cifspsx_lpq
  31. cifspsx_search_first
  32. cifspsx_search_next
  33. cifspsx_search_close
  34. cifspsx_trans
  35. ntvfs_cifs_posix_init

   1 /* 
   2    Unix SMB/CIFS implementation.
   3 
   4    simpler Samba VFS filesystem backend for clients which support the
   5    CIFS Unix Extensions or newer CIFS POSIX protocol extensions
   6 
   7    Copyright (C) Andrew Tridgell 2003
   8    Copyright (C) Steve French 2006
   9 
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14    
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19    
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22 */
  23 /*
  24   this implements a very simple NTVFS filesystem backend. 
  25   this backend largely ignores the POSIX -> CIFS mappings, just doing absolutely
  26   minimal work to give a working backend.
  27 */
  28 
  29 #include "includes.h"
  30 #include "system/dir.h"
  31 #include "system/filesys.h"
  32 #include "cifsposix.h"
  33 #include "system/time.h"
  34 #include "../lib/util/dlinklist.h"
  35 #include "ntvfs/ntvfs.h"
  36 #include "ntvfs/cifs_posix_cli/proto.h"
  37 
  38 #ifndef O_DIRECTORY
  39 #define O_DIRECTORY 0
  40 #endif
  41 
  42 #define CHECK_READ_ONLY(req) do { if (share_bool_option(ntvfs->ctx->config, SHARE_READONLY, true)) return NT_STATUS_ACCESS_DENIED; } while (0)
  43 
  44 /*
  45   connect to a share - used when a tree_connect operation comes
  46   in. For a disk based backend we needs to ensure that the base
  47   directory exists (tho it doesn't need to be accessible by the user,
  48   that comes later)
  49 */
  50 static NTSTATUS cifspsx_connect(struct ntvfs_module_context *ntvfs,
     /* [<][>][^][v][top][bottom][index][help] */
  51                              struct ntvfs_request *req, const char *sharename)
  52 {
  53         struct stat st;
  54         struct cifspsx_private *p;
  55         struct share_config *scfg = ntvfs->ctx->config;
  56 
  57         p = talloc(ntvfs, struct cifspsx_private);
  58         NT_STATUS_HAVE_NO_MEMORY(p);
  59         p->ntvfs = ntvfs;
  60         p->next_search_handle = 0;
  61         p->connectpath = talloc_strdup(p, share_string_option(scfg, SHARE_PATH, ""));
  62         p->open_files = NULL;
  63         p->search = NULL;
  64 
  65         /* the directory must exist */
  66         if (stat(p->connectpath, &st) != 0 || !S_ISDIR(st.st_mode)) {
  67                 DEBUG(0,("'%s' is not a directory, when connecting to [%s]\n", 
  68                          p->connectpath, sharename));
  69                 return NT_STATUS_BAD_NETWORK_NAME;
  70         }
  71 
  72         ntvfs->ctx->fs_type = talloc_strdup(ntvfs->ctx, "NTFS");
  73         NT_STATUS_HAVE_NO_MEMORY(ntvfs->ctx->fs_type);
  74         ntvfs->ctx->dev_type = talloc_strdup(ntvfs->ctx, "A:");
  75         NT_STATUS_HAVE_NO_MEMORY(ntvfs->ctx->dev_type);
  76 
  77         ntvfs->private_data = p;
  78 
  79         DEBUG(0,("WARNING: ntvfs cifs posix: connect to share [%s] with ROOT privileges!!!\n",sharename));
  80 
  81         return NT_STATUS_OK;
  82 }
  83 
  84 /*
  85   disconnect from a share
  86 */
  87 static NTSTATUS cifspsx_disconnect(struct ntvfs_module_context *ntvfs)
     /* [<][>][^][v][top][bottom][index][help] */
  88 {
  89         return NT_STATUS_OK;
  90 }
  91 
  92 /*
  93   find open file handle given fd
  94 */
  95 static struct cifspsx_file *find_fd(struct cifspsx_private *cp, struct ntvfs_handle *handle)
     /* [<][>][^][v][top][bottom][index][help] */
  96 {
  97         struct cifspsx_file *f;
  98         void *p;
  99 
 100         p = ntvfs_handle_get_backend_data(handle, cp->ntvfs);
 101         if (!p) return NULL;
 102 
 103         f = talloc_get_type(p, struct cifspsx_file);
 104         if (!f) return NULL;
 105 
 106         return f;
 107 }
 108 
 109 /*
 110   delete a file - the dirtype specifies the file types to include in the search. 
 111   The name can contain CIFS wildcards, but rarely does (except with OS/2 clients)
 112 */
 113 static NTSTATUS cifspsx_unlink(struct ntvfs_module_context *ntvfs,
     /* [<][>][^][v][top][bottom][index][help] */
 114                             struct ntvfs_request *req,
 115                             union smb_unlink *unl)
 116 {
 117         char *unix_path;
 118 
 119         CHECK_READ_ONLY(req);
 120 
 121         unix_path = cifspsx_unix_path(ntvfs, req, unl->unlink.in.pattern);
 122 
 123         /* ignoring wildcards ... */
 124         if (unlink(unix_path) == -1) {
 125                 return map_nt_error_from_unix(errno);
 126         }
 127 
 128         return NT_STATUS_OK;
 129 }
 130 
 131 
 132 /*
 133   ioctl interface - we don't do any
 134 */
 135 static NTSTATUS cifspsx_ioctl(struct ntvfs_module_context *ntvfs,
     /* [<][>][^][v][top][bottom][index][help] */
 136                            struct ntvfs_request *req, union smb_ioctl *io)
 137 {
 138         return NT_STATUS_INVALID_PARAMETER;
 139 }
 140 
 141 /*
 142   check if a directory exists
 143 */
 144 static NTSTATUS cifspsx_chkpath(struct ntvfs_module_context *ntvfs,
     /* [<][>][^][v][top][bottom][index][help] */
 145                              struct ntvfs_request *req,
 146                              union smb_chkpath *cp)
 147 {
 148         char *unix_path;
 149         struct stat st;
 150 
 151         unix_path = cifspsx_unix_path(ntvfs, req, cp->chkpath.in.path);
 152 
 153         if (stat(unix_path, &st) == -1) {
 154                 return map_nt_error_from_unix(errno);
 155         }
 156 
 157         if (!S_ISDIR(st.st_mode)) {
 158                 return NT_STATUS_NOT_A_DIRECTORY;
 159         }
 160 
 161         return NT_STATUS_OK;
 162 }
 163 
 164 /*
 165   build a file_id from a stat struct
 166 */
 167 static uint64_t cifspsx_file_id(struct stat *st)
     /* [<][>][^][v][top][bottom][index][help] */
 168 {
 169         uint64_t ret = st->st_ino;
 170         ret <<= 32;
 171         ret |= st->st_dev;
 172         return ret;
 173 }
 174 
 175 /*
 176   approximately map a struct stat to a generic fileinfo struct
 177 */
 178 static NTSTATUS cifspsx_map_fileinfo(struct ntvfs_module_context *ntvfs,
     /* [<][>][^][v][top][bottom][index][help] */
 179                                   struct ntvfs_request *req, union smb_fileinfo *info, 
 180                                   struct stat *st, const char *unix_path)
 181 {
 182         struct cifspsx_dir *dir = NULL;
 183         char *pattern = NULL;
 184         int i;
 185         const char *s, *short_name;
 186 
 187         s = strrchr(unix_path, '/');
 188         if (s) {
 189                 short_name = s+1;
 190         } else {
 191                 short_name = "";
 192         }
 193 
 194         asprintf(&pattern, "%s:*", unix_path);
 195         
 196         if (pattern) {
 197                 dir = cifspsx_list_unix(req, req, pattern);
 198         }
 199 
 200         unix_to_nt_time(&info->generic.out.create_time, st->st_ctime);
 201         unix_to_nt_time(&info->generic.out.access_time, st->st_atime);
 202         unix_to_nt_time(&info->generic.out.write_time,  st->st_mtime);
 203         unix_to_nt_time(&info->generic.out.change_time, st->st_mtime);
 204         info->generic.out.alloc_size = st->st_size;
 205         info->generic.out.size = st->st_size;
 206         info->generic.out.attrib = cifspsx_unix_to_dos_attrib(st->st_mode);
 207         info->generic.out.alloc_size = st->st_blksize * st->st_blocks;
 208         info->generic.out.nlink = st->st_nlink;
 209         info->generic.out.directory = S_ISDIR(st->st_mode) ? 1 : 0;
 210         info->generic.out.file_id = cifspsx_file_id(st);
 211         /* REWRITE: TODO stuff in here */
 212         info->generic.out.delete_pending = 0;
 213         info->generic.out.ea_size = 0;
 214         info->generic.out.num_eas = 0;
 215         info->generic.out.fname.s = talloc_strdup(req, short_name);
 216         info->generic.out.alt_fname.s = talloc_strdup(req, short_name);
 217         info->generic.out.compressed_size = 0;
 218         info->generic.out.format = 0;
 219         info->generic.out.unit_shift = 0;
 220         info->generic.out.chunk_shift = 0;
 221         info->generic.out.cluster_shift = 0;
 222         
 223         info->generic.out.access_flags = 0;
 224         info->generic.out.position = 0;
 225         info->generic.out.mode = 0;
 226         info->generic.out.alignment_requirement = 0;
 227         info->generic.out.reparse_tag = 0;
 228         info->generic.out.num_streams = 0;
 229         /* setup a single data stream */
 230         info->generic.out.num_streams = 1 + (dir?dir->count:0);
 231         info->generic.out.streams = talloc_array(req, 
 232                                                    struct stream_struct,
 233                                                    info->generic.out.num_streams);
 234         if (!info->generic.out.streams) {
 235                 return NT_STATUS_NO_MEMORY;
 236         }
 237         info->generic.out.streams[0].size = st->st_size;
 238         info->generic.out.streams[0].alloc_size = st->st_size;
 239         info->generic.out.streams[0].stream_name.s = talloc_strdup(req,"::$DATA");
 240 
 241         for (i=0;dir && i<dir->count;i++) {
 242                 s = strchr(dir->files[i].name, ':');
 243                 info->generic.out.streams[1+i].size = dir->files[i].st.st_size;
 244                 info->generic.out.streams[1+i].alloc_size = dir->files[i].st.st_size;
 245                 info->generic.out.streams[1+i].stream_name.s = s?s:dir->files[i].name;
 246         }
 247 
 248         return NT_STATUS_OK;
 249 }
 250 
 251 /*
 252   return info on a pathname
 253 */
 254 static NTSTATUS cifspsx_qpathinfo(struct ntvfs_module_context *ntvfs,
     /* [<][>][^][v][top][bottom][index][help] */
 255                                struct ntvfs_request *req, union smb_fileinfo *info)
 256 {
 257         char *unix_path;
 258         struct stat st;
 259 
 260         DEBUG(19,("cifspsx_qpathinfo: file %s level 0x%x\n", info->generic.in.file.path, info->generic.level));
 261         if (info->generic.level != RAW_FILEINFO_GENERIC) {
 262                 return ntvfs_map_qpathinfo(ntvfs, req, info);
 263         }
 264         
 265         unix_path = cifspsx_unix_path(ntvfs, req, info->generic.in.file.path);
 266         DEBUG(19,("cifspsx_qpathinfo: file %s\n", unix_path));
 267         if (stat(unix_path, &st) == -1) {
 268                 DEBUG(19,("cifspsx_qpathinfo: file %s errno=%d\n", unix_path, errno));
 269                 return map_nt_error_from_unix(errno);
 270         }
 271         DEBUG(19,("cifspsx_qpathinfo: file %s, stat done\n", unix_path));
 272         return cifspsx_map_fileinfo(ntvfs, req, info, &st, unix_path);
 273 }
 274 
 275 /*
 276   query info on a open file
 277 */
 278 static NTSTATUS cifspsx_qfileinfo(struct ntvfs_module_context *ntvfs,
     /* [<][>][^][v][top][bottom][index][help] */
 279                                struct ntvfs_request *req, union smb_fileinfo *info)
 280 {
 281         struct cifspsx_private *p = ntvfs->private_data;
 282         struct cifspsx_file *f;
 283         struct stat st;
 284 
 285         if (info->generic.level != RAW_FILEINFO_GENERIC) {
 286                 return ntvfs_map_qfileinfo(ntvfs, req, info);
 287         }
 288 
 289         f = find_fd(p, info->generic.in.file.ntvfs);
 290         if (!f) {
 291                 return NT_STATUS_INVALID_HANDLE;
 292         }
 293         
 294         if (fstat(f->fd, &st) == -1) {
 295                 return map_nt_error_from_unix(errno);
 296         }
 297 
 298         return cifspsx_map_fileinfo(ntvfs, req,info, &st, f->name);
 299 }
 300 
 301 
 302 /*
 303   open a file
 304 */
 305 static NTSTATUS cifspsx_open(struct ntvfs_module_context *ntvfs,
     /* [<][>][^][v][top][bottom][index][help] */
 306                           struct ntvfs_request *req, union smb_open *io)
 307 {
 308         struct cifspsx_private *p = ntvfs->private_data;
 309         char *unix_path;
 310         struct stat st;
 311         int fd, flags;
 312         struct cifspsx_file *f;
 313         int create_flags, rdwr_flags;
 314         bool readonly;
 315         NTSTATUS status;
 316         struct ntvfs_handle *handle;
 317         
 318         if (io->generic.level != RAW_OPEN_GENERIC) {
 319                 return ntvfs_map_open(ntvfs, req, io);
 320         }
 321 
 322         readonly = share_bool_option(ntvfs->ctx->config, SHARE_READONLY, SHARE_READONLY_DEFAULT);
 323         if (readonly) {
 324                 create_flags = 0;
 325                 rdwr_flags = O_RDONLY;
 326         } else {
 327                 create_flags = O_CREAT;
 328                 rdwr_flags = O_RDWR;
 329         }
 330 
 331         unix_path = cifspsx_unix_path(ntvfs, req, io->ntcreatex.in.fname);
 332 
 333         switch (io->generic.in.open_disposition) {
 334         case NTCREATEX_DISP_SUPERSEDE:
 335         case NTCREATEX_DISP_OVERWRITE_IF:
 336                 flags = create_flags | O_TRUNC;
 337                 break;
 338         case NTCREATEX_DISP_OPEN:
 339         case NTCREATEX_DISP_OVERWRITE:
 340                 flags = 0;
 341                 break;
 342         case NTCREATEX_DISP_CREATE:
 343                 flags = create_flags | O_EXCL;
 344                 break;
 345         case NTCREATEX_DISP_OPEN_IF:
 346                 flags = create_flags;
 347                 break;
 348         default:
 349                 flags = 0;
 350                 break;
 351         }
 352         
 353         flags |= rdwr_flags;
 354 
 355         if (io->generic.in.create_options & NTCREATEX_OPTIONS_DIRECTORY) {
 356                 flags = O_RDONLY | O_DIRECTORY;
 357                 if (readonly) {
 358                         goto do_open;
 359                 }
 360                 switch (io->generic.in.open_disposition) {
 361                 case NTCREATEX_DISP_CREATE:
 362                         if (mkdir(unix_path, 0755) == -1) {
 363                                 DEBUG(9,("cifspsx_open: mkdir %s errno=%d\n", unix_path, errno));
 364                                 return map_nt_error_from_unix(errno);
 365                         }
 366                         break;
 367                 case NTCREATEX_DISP_OPEN_IF:
 368                         if (mkdir(unix_path, 0755) == -1 && errno != EEXIST) {
 369                                 DEBUG(9,("cifspsx_open: mkdir %s errno=%d\n", unix_path, errno));
 370                                 return map_nt_error_from_unix(errno);
 371                         }
 372                         break;
 373                 }
 374         }
 375 
 376 do_open:
 377         fd = open(unix_path, flags, 0644);
 378         if (fd == -1) {
 379                 return map_nt_error_from_unix(errno);
 380         }
 381 
 382         if (fstat(fd, &st) == -1) {
 383                 DEBUG(9,("cifspsx_open: fstat errno=%d\n", errno));
 384                 close(fd);
 385                 return map_nt_error_from_unix(errno);
 386         }
 387 
 388         status = ntvfs_handle_new(ntvfs, req, &handle);
 389         NT_STATUS_NOT_OK_RETURN(status);
 390 
 391         f = talloc(handle, struct cifspsx_file);
 392         NT_STATUS_HAVE_NO_MEMORY(f);
 393         f->fd = fd;
 394         f->name = talloc_strdup(f, unix_path);
 395         NT_STATUS_HAVE_NO_MEMORY(f->name);
 396 
 397         DLIST_ADD(p->open_files, f);
 398 
 399         status = ntvfs_handle_set_backend_data(handle, ntvfs, f);
 400         NT_STATUS_NOT_OK_RETURN(status);
 401 
 402         ZERO_STRUCT(io->generic.out);
 403         
 404         unix_to_nt_time(&io->generic.out.create_time, st.st_ctime);
 405         unix_to_nt_time(&io->generic.out.access_time, st.st_atime);
 406         unix_to_nt_time(&io->generic.out.write_time,  st.st_mtime);
 407         unix_to_nt_time(&io->generic.out.change_time, st.st_mtime);
 408         io->generic.out.file.ntvfs = handle;
 409         io->generic.out.alloc_size = st.st_size;
 410         io->generic.out.size = st.st_size;
 411         io->generic.out.attrib = cifspsx_unix_to_dos_attrib(st.st_mode);
 412         io->generic.out.is_directory = S_ISDIR(st.st_mode) ? 1 : 0;
 413 
 414         return NT_STATUS_OK;
 415 }
 416 
 417 /*
 418   create a directory
 419 */
 420 static NTSTATUS cifspsx_mkdir(struct ntvfs_module_context *ntvfs,
     /* [<][>][^][v][top][bottom][index][help] */
 421                            struct ntvfs_request *req, union smb_mkdir *md)
 422 {
 423         char *unix_path;
 424 
 425         CHECK_READ_ONLY(req);
 426 
 427         if (md->generic.level != RAW_MKDIR_MKDIR) {
 428                 return NT_STATUS_INVALID_LEVEL;
 429         }
 430 
 431         unix_path = cifspsx_unix_path(ntvfs, req, md->mkdir.in.path);
 432 
 433         if (mkdir(unix_path, 0777) == -1) {
 434                 return map_nt_error_from_unix(errno);
 435         }
 436 
 437         return NT_STATUS_OK;
 438 }
 439 
 440 /*
 441   remove a directory
 442 */
 443 static NTSTATUS cifspsx_rmdir(struct ntvfs_module_context *ntvfs,
     /* [<][>][^][v][top][bottom][index][help] */
 444                            struct ntvfs_request *req, struct smb_rmdir *rd)
 445 {
 446         char *unix_path;
 447 
 448         CHECK_READ_ONLY(req);
 449 
 450         unix_path = cifspsx_unix_path(ntvfs, req, rd->in.path);
 451 
 452         if (rmdir(unix_path) == -1) {
 453                 return map_nt_error_from_unix(errno);
 454         }
 455 
 456         return NT_STATUS_OK;
 457 }
 458 
 459 /*
 460   rename a set of files
 461 */
 462 static NTSTATUS cifspsx_rename(struct ntvfs_module_context *ntvfs,
     /* [<][>][^][v][top][bottom][index][help] */
 463                             struct ntvfs_request *req, union smb_rename *ren)
 464 {
 465         char *unix_path1, *unix_path2;
 466 
 467         CHECK_READ_ONLY(req);
 468 
 469         if (ren->generic.level != RAW_RENAME_RENAME) {
 470                 return NT_STATUS_INVALID_LEVEL;
 471         }
 472 
 473         unix_path1 = cifspsx_unix_path(ntvfs, req, ren->rename.in.pattern1);
 474         unix_path2 = cifspsx_unix_path(ntvfs, req, ren->rename.in.pattern2);
 475 
 476         if (rename(unix_path1, unix_path2) == -1) {
 477                 return map_nt_error_from_unix(errno);
 478         }
 479         
 480         return NT_STATUS_OK;
 481 }
 482 
 483 /*
 484   copy a set of files
 485 */
 486 static NTSTATUS cifspsx_copy(struct ntvfs_module_context *ntvfs,
     /* [<][>][^][v][top][bottom][index][help] */
 487                           struct ntvfs_request *req, struct smb_copy *cp)
 488 {
 489         return NT_STATUS_NOT_SUPPORTED;
 490 }
 491 
 492 /*
 493   read from a file
 494 */
 495 static NTSTATUS cifspsx_read(struct ntvfs_module_context *ntvfs,
     /* [<][>][^][v][top][bottom][index][help] */
 496                           struct ntvfs_request *req, union smb_read *rd)
 497 {
 498         struct cifspsx_private *p = ntvfs->private_data;
 499         struct cifspsx_file *f;
 500         ssize_t ret;
 501 
 502         if (rd->generic.level != RAW_READ_READX) {
 503                 return NT_STATUS_NOT_SUPPORTED;
 504         }
 505 
 506         f = find_fd(p, rd->readx.in.file.ntvfs);
 507         if (!f) {
 508                 return NT_STATUS_INVALID_HANDLE;
 509         }
 510 
 511         ret = pread(f->fd, 
 512                     rd->readx.out.data, 
 513                     rd->readx.in.maxcnt,
 514                     rd->readx.in.offset);
 515         if (ret == -1) {
 516                 return map_nt_error_from_unix(errno);
 517         }
 518 
 519         rd->readx.out.nread = ret;
 520         rd->readx.out.remaining = 0; /* should fill this in? */
 521         rd->readx.out.compaction_mode = 0; 
 522 
 523         return NT_STATUS_OK;
 524 }
 525 
 526 /*
 527   write to a file
 528 */
 529 static NTSTATUS cifspsx_write(struct ntvfs_module_context *ntvfs,
     /* [<][>][^][v][top][bottom][index][help] */
 530                            struct ntvfs_request *req, union smb_write *wr)
 531 {
 532         struct cifspsx_private *p = ntvfs->private_data;
 533         struct cifspsx_file *f;
 534         ssize_t ret;
 535 
 536         if (wr->generic.level != RAW_WRITE_WRITEX) {
 537                 return ntvfs_map_write(ntvfs, req, wr);
 538         }
 539 
 540         CHECK_READ_ONLY(req);
 541 
 542         f = find_fd(p, wr->writex.in.file.ntvfs);
 543         if (!f) {
 544                 return NT_STATUS_INVALID_HANDLE;
 545         }
 546 
 547         ret = pwrite(f->fd, 
 548                      wr->writex.in.data, 
 549                      wr->writex.in.count,
 550                      wr->writex.in.offset);
 551         if (ret == -1) {
 552                 return map_nt_error_from_unix(errno);
 553         }
 554                 
 555         wr->writex.out.nwritten = ret;
 556         wr->writex.out.remaining = 0; /* should fill this in? */
 557         
 558         return NT_STATUS_OK;
 559 }
 560 
 561 /*
 562   seek in a file
 563 */
 564 static NTSTATUS cifspsx_seek(struct ntvfs_module_context *ntvfs,
     /* [<][>][^][v][top][bottom][index][help] */
 565                           struct ntvfs_request *req,
 566                           union smb_seek *io)
 567 {
 568         return NT_STATUS_NOT_SUPPORTED;
 569 }
 570 
 571 /*
 572   flush a file
 573 */
 574 static NTSTATUS cifspsx_flush(struct ntvfs_module_context *ntvfs,
     /* [<][>][^][v][top][bottom][index][help] */
 575                            struct ntvfs_request *req,
 576                            union smb_flush *io)
 577 {
 578         struct cifspsx_private *p = ntvfs->private_data;
 579         struct cifspsx_file *f;
 580 
 581         switch (io->generic.level) {
 582         case RAW_FLUSH_FLUSH:
 583         case RAW_FLUSH_SMB2:
 584                 /* ignore the additional unknown option in SMB2 */
 585                 f = find_fd(p, io->generic.in.file.ntvfs);
 586                 if (!f) {
 587                         return NT_STATUS_INVALID_HANDLE;
 588                 }
 589                 fsync(f->fd);
 590                 return NT_STATUS_OK;
 591 
 592         case RAW_FLUSH_ALL:
 593                 for (f=p->open_files;f;f=f->next) {
 594                         fsync(f->fd);
 595                 }
 596                 return NT_STATUS_OK;
 597         }
 598 
 599         return NT_STATUS_INVALID_LEVEL;
 600 }
 601 
 602 /*
 603   close a file
 604 */
 605 static NTSTATUS cifspsx_close(struct ntvfs_module_context *ntvfs,
     /* [<][>][^][v][top][bottom][index][help] */
 606                            struct ntvfs_request *req,
 607                            union smb_close *io)
 608 {
 609         struct cifspsx_private *p = ntvfs->private_data;
 610         struct cifspsx_file *f;
 611 
 612         if (io->generic.level != RAW_CLOSE_CLOSE) {
 613                 /* we need a mapping function */
 614                 return NT_STATUS_INVALID_LEVEL;
 615         }
 616 
 617         f = find_fd(p, io->close.in.file.ntvfs);
 618         if (!f) {
 619                 return NT_STATUS_INVALID_HANDLE;
 620         }
 621 
 622         if (close(f->fd) == -1) {
 623                 return map_nt_error_from_unix(errno);
 624         }
 625 
 626         DLIST_REMOVE(p->open_files, f);
 627         talloc_free(f->name);
 628         talloc_free(f);
 629 
 630         return NT_STATUS_OK;
 631 }
 632 
 633 /*
 634   exit - closing files
 635 */
 636 static NTSTATUS cifspsx_exit(struct ntvfs_module_context *ntvfs,
     /* [<][>][^][v][top][bottom][index][help] */
 637                           struct ntvfs_request *req)
 638 {
 639         return NT_STATUS_NOT_SUPPORTED;
 640 }
 641 
 642 /*
 643   logoff - closing files
 644 */
 645 static NTSTATUS cifspsx_logoff(struct ntvfs_module_context *ntvfs,
     /* [<][>][^][v][top][bottom][index][help] */
 646                             struct ntvfs_request *req)
 647 {
 648         return NT_STATUS_NOT_SUPPORTED;
 649 }
 650 
 651 /*
 652   setup for an async call
 653 */
 654 static NTSTATUS cifspsx_async_setup(struct ntvfs_module_context *ntvfs,
     /* [<][>][^][v][top][bottom][index][help] */
 655                                  struct ntvfs_request *req, 
 656                                  void *private_data)
 657 {
 658         return NT_STATUS_OK;
 659 }
 660 
 661 /*
 662   cancel an async call
 663 */
 664 static NTSTATUS cifspsx_cancel(struct ntvfs_module_context *ntvfs, struct ntvfs_request *req)
     /* [<][>][^][v][top][bottom][index][help] */
 665 {
 666         return NT_STATUS_UNSUCCESSFUL;
 667 }
 668 
 669 /*
 670   lock a byte range
 671 */
 672 static NTSTATUS cifspsx_lock(struct ntvfs_module_context *ntvfs,
     /* [<][>][^][v][top][bottom][index][help] */
 673                           struct ntvfs_request *req, union smb_lock *lck)
 674 {
 675         DEBUG(0,("REWRITE: not doing byte range locking!\n"));
 676         return NT_STATUS_OK;
 677 }
 678 
 679 /*
 680   set info on a pathname
 681 */
 682 static NTSTATUS cifspsx_setpathinfo(struct ntvfs_module_context *ntvfs,
     /* [<][>][^][v][top][bottom][index][help] */
 683                                  struct ntvfs_request *req, union smb_setfileinfo *st)
 684 {
 685         CHECK_READ_ONLY(req);
 686 
 687         return NT_STATUS_NOT_SUPPORTED;
 688 }
 689 
 690 /*
 691   set info on a open file
 692 */
 693 static NTSTATUS cifspsx_setfileinfo(struct ntvfs_module_context *ntvfs,
     /* [<][>][^][v][top][bottom][index][help] */
 694                                  struct ntvfs_request *req, 
 695                                  union smb_setfileinfo *info)
 696 {
 697         struct cifspsx_private *p = ntvfs->private_data;
 698         struct cifspsx_file *f;
 699         struct utimbuf unix_times;
 700 
 701         CHECK_READ_ONLY(req);
 702 
 703         f = find_fd(p, info->generic.in.file.ntvfs);
 704         if (!f) {
 705                 return NT_STATUS_INVALID_HANDLE;
 706         }
 707         
 708         switch (info->generic.level) {
 709         case RAW_SFILEINFO_END_OF_FILE_INFO:
 710         case RAW_SFILEINFO_END_OF_FILE_INFORMATION:
 711                 if (ftruncate(f->fd, 
 712                               info->end_of_file_info.in.size) == -1) {
 713                         return map_nt_error_from_unix(errno);
 714                 }
 715                 break;
 716         case RAW_SFILEINFO_SETATTRE:
 717                 unix_times.actime = info->setattre.in.access_time;
 718                 unix_times.modtime = info->setattre.in.write_time;
 719 
 720                 if (unix_times.actime == 0 && unix_times.modtime == 0) {
 721                         break;
 722                 } 
 723 
 724                 /* set modify time = to access time if modify time was 0 */
 725                 if (unix_times.actime != 0 && unix_times.modtime == 0) {
 726                         unix_times.modtime = unix_times.actime;
 727                 }
 728 
 729                 /* Set the date on this file */
 730                 if (cifspsx_file_utime(f->fd, &unix_times) != 0) {
 731                         return NT_STATUS_ACCESS_DENIED;
 732                 }
 733                 break;
 734         default:
 735                 DEBUG(2,("cifspsx_setfileinfo: level %d not implemented\n", 
 736                          info->generic.level));
 737                 return NT_STATUS_NOT_IMPLEMENTED;
 738         }
 739         return NT_STATUS_OK;
 740 }
 741 
 742 
 743 /*
 744   return filesystem space info
 745 */
 746 static NTSTATUS cifspsx_fsinfo(struct ntvfs_module_context *ntvfs,
     /* [<][>][^][v][top][bottom][index][help] */
 747                             struct ntvfs_request *req, union smb_fsinfo *fs)
 748 {
 749         struct cifspsx_private *p = ntvfs->private_data;
 750         struct stat st;
 751 
 752         if (fs->generic.level != RAW_QFS_GENERIC) {
 753                 return ntvfs_map_fsinfo(ntvfs, req, fs);
 754         }
 755 
 756         if (sys_fsusage(p->connectpath,
 757                         &fs->generic.out.blocks_free, 
 758                         &fs->generic.out.blocks_total) == -1) {
 759                 return map_nt_error_from_unix(errno);
 760         }
 761 
 762         fs->generic.out.block_size = 512;
 763 
 764         if (stat(p->connectpath, &st) != 0) {
 765                 return NT_STATUS_DISK_CORRUPT_ERROR;
 766         }
 767         
 768         fs->generic.out.fs_id = st.st_ino;
 769         unix_to_nt_time(&fs->generic.out.create_time, st.st_ctime);
 770         fs->generic.out.serial_number = st.st_ino;
 771         fs->generic.out.fs_attr = 0;
 772         fs->generic.out.max_file_component_length = 255;
 773         fs->generic.out.device_type = 0;
 774         fs->generic.out.device_characteristics = 0;
 775         fs->generic.out.quota_soft = 0;
 776         fs->generic.out.quota_hard = 0;
 777         fs->generic.out.quota_flags = 0;
 778         fs->generic.out.volume_name = talloc_strdup(req, ntvfs->ctx->config->name);
 779         fs->generic.out.fs_type = ntvfs->ctx->fs_type;
 780 
 781         return NT_STATUS_OK;
 782 }
 783 
 784 #if 0
 785 /*
 786   return filesystem attribute info
 787 */
 788 static NTSTATUS cifspsx_fsattr(struct ntvfs_module_context *ntvfs,
     /* [<][>][^][v][top][bottom][index][help] */
 789                             struct ntvfs_request *req, union smb_fsattr *fs)
 790 {
 791         struct stat st;
 792         struct cifspsx_private *p = ntvfs->private_data;
 793 
 794         if (fs->generic.level != RAW_FSATTR_GENERIC) {
 795                 return ntvfs_map_fsattr(ntvfs, req, fs);
 796         }
 797 
 798         if (stat(p->connectpath, &st) == -1) {
 799                 return map_nt_error_from_unix(errno);
 800         }
 801 
 802         unix_to_nt_time(&fs->generic.out.create_time, st.st_ctime);
 803         fs->generic.out.fs_attr = 
 804                 FILE_CASE_PRESERVED_NAMES | 
 805                 FILE_CASE_SENSITIVE_SEARCH | 
 806                 FILE_PERSISTENT_ACLS;
 807         fs->generic.out.max_file_component_length = 255;
 808         fs->generic.out.serial_number = 1;
 809         fs->generic.out.fs_type = talloc_strdup(req, "NTFS");
 810         fs->generic.out.volume_name = talloc_strdup(req, 
 811                                                     lp_servicename(req->tcon->service));
 812 
 813         return NT_STATUS_OK;
 814 }
 815 #endif
 816 
 817 /*
 818   return print queue info
 819 */
 820 static NTSTATUS cifspsx_lpq(struct ntvfs_module_context *ntvfs,
     /* [<][>][^][v][top][bottom][index][help] */
 821                          struct ntvfs_request *req, union smb_lpq *lpq)
 822 {
 823         return NT_STATUS_NOT_SUPPORTED;
 824 }
 825 
 826 /* 
 827    list files in a directory matching a wildcard pattern
 828 */
 829 static NTSTATUS cifspsx_search_first(struct ntvfs_module_context *ntvfs,
     /* [<][>][^][v][top][bottom][index][help] */
 830                                   struct ntvfs_request *req, union smb_search_first *io, 
 831                                   void *search_private, 
 832                                   bool (*callback)(void *, const union smb_search_data *))
 833 {
 834         struct cifspsx_dir *dir;
 835         int i;
 836         struct cifspsx_private *p = ntvfs->private_data;
 837         struct search_state *search;
 838         union smb_search_data file;
 839         uint_t max_count;
 840 
 841         if (io->generic.level != RAW_SEARCH_TRANS2) {
 842                 return NT_STATUS_NOT_SUPPORTED;
 843         }
 844 
 845         if (io->generic.data_level != RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO) {
 846                 return NT_STATUS_NOT_SUPPORTED;
 847         }
 848 
 849         search = talloc_zero(p, struct search_state);
 850         if (!search) {
 851                 return NT_STATUS_NO_MEMORY;
 852         }
 853 
 854         max_count = io->t2ffirst.in.max_count;
 855 
 856         dir = cifspsx_list(ntvfs, req, io->t2ffirst.in.pattern);
 857         if (!dir) {
 858                 return NT_STATUS_FOOBAR;
 859         }
 860 
 861         search->handle = p->next_search_handle;
 862         search->dir = dir;
 863 
 864         if (dir->count < max_count) {
 865                 max_count = dir->count;
 866         }
 867 
 868         for (i=0; i < max_count;i++) {
 869                 ZERO_STRUCT(file);
 870                 unix_to_nt_time(&file.both_directory_info.create_time, dir->files[i].st.st_ctime);
 871                 unix_to_nt_time(&file.both_directory_info.access_time, dir->files[i].st.st_atime);
 872                 unix_to_nt_time(&file.both_directory_info.write_time,  dir->files[i].st.st_mtime);
 873                 unix_to_nt_time(&file.both_directory_info.change_time, dir->files[i].st.st_mtime);
 874                 file.both_directory_info.name.s = dir->files[i].name;
 875                 file.both_directory_info.short_name.s = dir->files[i].name;
 876                 file.both_directory_info.size = dir->files[i].st.st_size;
 877                 file.both_directory_info.attrib = cifspsx_unix_to_dos_attrib(dir->files[i].st.st_mode);
 878 
 879                 if (!callback(search_private, &file)) {
 880                         break;
 881                 }
 882         }
 883 
 884         search->current_index = i;
 885 
 886         io->t2ffirst.out.count = i;
 887         io->t2ffirst.out.handle = search->handle;
 888         io->t2ffirst.out.end_of_search = (i == dir->count) ? 1 : 0;
 889 
 890         /* work out if we are going to keep the search state */
 891         if ((io->t2ffirst.in.flags & FLAG_TRANS2_FIND_CLOSE) ||
 892             ((io->t2ffirst.in.flags & FLAG_TRANS2_FIND_CLOSE_IF_END) && (i == dir->count))) {
 893                 talloc_free(search);
 894         } else {
 895                 p->next_search_handle++;
 896                 DLIST_ADD(p->search, search);
 897         }
 898 
 899         return NT_STATUS_OK;
 900 }
 901 
 902 /* continue a search */
 903 static NTSTATUS cifspsx_search_next(struct ntvfs_module_context *ntvfs,
     /* [<][>][^][v][top][bottom][index][help] */
 904                                  struct ntvfs_request *req, union smb_search_next *io, 
 905                                  void *search_private, 
 906                                  bool (*callback)(void *, const union smb_search_data *))
 907 {
 908         struct cifspsx_dir *dir;
 909         int i;
 910         struct cifspsx_private *p = ntvfs->private_data;
 911         struct search_state *search;
 912         union smb_search_data file;
 913         uint_t max_count;
 914 
 915         if (io->generic.level != RAW_SEARCH_TRANS2) {
 916                 return NT_STATUS_NOT_SUPPORTED;
 917         }
 918 
 919         if (io->generic.data_level != RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO) {
 920                 return NT_STATUS_NOT_SUPPORTED;
 921         }
 922 
 923         for (search=p->search; search; search = search->next) {
 924                 if (search->handle == io->t2fnext.in.handle) break;
 925         }
 926         
 927         if (!search) {
 928                 /* we didn't find the search handle */
 929                 return NT_STATUS_FOOBAR;
 930         }
 931 
 932         dir = search->dir;
 933 
 934         /* the client might be asking for something other than just continuing
 935            with the search */
 936         if (!(io->t2fnext.in.flags & FLAG_TRANS2_FIND_CONTINUE) &&
 937             (io->t2fnext.in.flags & FLAG_TRANS2_FIND_REQUIRE_RESUME) &&
 938             io->t2fnext.in.last_name && *io->t2fnext.in.last_name) {
 939                 /* look backwards first */
 940                 for (i=search->current_index; i > 0; i--) {
 941                         if (strcmp(io->t2fnext.in.last_name, dir->files[i-1].name) == 0) {
 942                                 search->current_index = i;
 943                                 goto found;
 944                         }
 945                 }
 946 
 947                 /* then look forwards */
 948                 for (i=search->current_index+1; i <= dir->count; i++) {
 949                         if (strcmp(io->t2fnext.in.last_name, dir->files[i-1].name) == 0) {
 950                                 search->current_index = i;
 951                                 goto found;
 952                         }
 953                 }
 954         }
 955 
 956 found:  
 957         max_count = search->current_index + io->t2fnext.in.max_count;
 958 
 959         if (max_count > dir->count) {
 960                 max_count = dir->count;
 961         }
 962 
 963         for (i = search->current_index; i < max_count;i++) {
 964                 ZERO_STRUCT(file);
 965                 unix_to_nt_time(&file.both_directory_info.create_time, dir->files[i].st.st_ctime);
 966                 unix_to_nt_time(&file.both_directory_info.access_time, dir->files[i].st.st_atime);
 967                 unix_to_nt_time(&file.both_directory_info.write_time,  dir->files[i].st.st_mtime);
 968                 unix_to_nt_time(&file.both_directory_info.change_time, dir->files[i].st.st_mtime);
 969                 file.both_directory_info.name.s = dir->files[i].name;
 970                 file.both_directory_info.short_name.s = dir->files[i].name;
 971                 file.both_directory_info.size = dir->files[i].st.st_size;
 972                 file.both_directory_info.attrib = cifspsx_unix_to_dos_attrib(dir->files[i].st.st_mode);
 973 
 974                 if (!callback(search_private, &file)) {
 975                         break;
 976                 }
 977         }
 978 
 979         io->t2fnext.out.count = i - search->current_index;
 980         io->t2fnext.out.end_of_search = (i == dir->count) ? 1 : 0;
 981 
 982         search->current_index = i;
 983 
 984         /* work out if we are going to keep the search state */
 985         if ((io->t2fnext.in.flags & FLAG_TRANS2_FIND_CLOSE) ||
 986             ((io->t2fnext.in.flags & FLAG_TRANS2_FIND_CLOSE_IF_END) && (i == dir->count))) {
 987                 DLIST_REMOVE(p->search, search);
 988                 talloc_free(search);
 989         }
 990 
 991         return NT_STATUS_OK;
 992 }
 993 
 994 /* close a search */
 995 static NTSTATUS cifspsx_search_close(struct ntvfs_module_context *ntvfs,
     /* [<][>][^][v][top][bottom][index][help] */
 996                                   struct ntvfs_request *req, union smb_search_close *io)
 997 {
 998         struct cifspsx_private *p = ntvfs->private_data;
 999         struct search_state *search;
1000 
1001         for (search=p->search; search; search = search->next) {
1002                 if (search->handle == io->findclose.in.handle) break;
1003         }
1004         
1005         if (!search) {
1006                 /* we didn't find the search handle */
1007                 return NT_STATUS_FOOBAR;
1008         }
1009 
1010         DLIST_REMOVE(p->search, search);
1011         talloc_free(search);
1012 
1013         return NT_STATUS_OK;
1014 }
1015 
1016 /* SMBtrans - not used on file shares */
1017 static NTSTATUS cifspsx_trans(struct ntvfs_module_context *ntvfs,
     /* [<][>][^][v][top][bottom][index][help] */
1018                            struct ntvfs_request *req, struct smb_trans2 *trans2)
1019 {
1020         return NT_STATUS_ACCESS_DENIED;
1021 }
1022 
1023 
1024 /*
1025   initialialise the POSIX disk backend, registering ourselves with the ntvfs subsystem
1026  */
1027 NTSTATUS ntvfs_cifs_posix_init(void)
     /* [<][>][^][v][top][bottom][index][help] */
1028 {
1029         NTSTATUS ret;
1030         struct ntvfs_ops ops;
1031         NTVFS_CURRENT_CRITICAL_SIZES(vers);
1032 
1033         ZERO_STRUCT(ops);
1034 
1035         /* fill in all the operations */
1036         ops.connect = cifspsx_connect;
1037         ops.disconnect = cifspsx_disconnect;
1038         ops.unlink = cifspsx_unlink;
1039         ops.chkpath = cifspsx_chkpath;
1040         ops.qpathinfo = cifspsx_qpathinfo;
1041         ops.setpathinfo = cifspsx_setpathinfo;
1042         ops.open = cifspsx_open;
1043         ops.mkdir = cifspsx_mkdir;
1044         ops.rmdir = cifspsx_rmdir;
1045         ops.rename = cifspsx_rename;
1046         ops.copy = cifspsx_copy;
1047         ops.ioctl = cifspsx_ioctl;
1048         ops.read = cifspsx_read;
1049         ops.write = cifspsx_write;
1050         ops.seek = cifspsx_seek;
1051         ops.flush = cifspsx_flush;      
1052         ops.close = cifspsx_close;
1053         ops.exit = cifspsx_exit;
1054         ops.lock = cifspsx_lock;
1055         ops.setfileinfo = cifspsx_setfileinfo;
1056         ops.qfileinfo = cifspsx_qfileinfo;
1057         ops.fsinfo = cifspsx_fsinfo;
1058         ops.lpq = cifspsx_lpq;
1059         ops.search_first = cifspsx_search_first;
1060         ops.search_next = cifspsx_search_next;
1061         ops.search_close = cifspsx_search_close;
1062         ops.trans = cifspsx_trans;
1063         ops.logoff = cifspsx_logoff;
1064         ops.async_setup = cifspsx_async_setup;
1065         ops.cancel = cifspsx_cancel;
1066 
1067         /* register ourselves with the NTVFS subsystem. We register
1068            under names 'cifsposix'
1069         */
1070 
1071         ops.type = NTVFS_DISK;
1072         ops.name = "cifsposix";
1073         ret = ntvfs_register(&ops, &vers);
1074 
1075         if (!NT_STATUS_IS_OK(ret)) {
1076                 DEBUG(0,("Failed to register cifs posix backend with name: %s!\n",
1077                          ops.name));
1078         }
1079 
1080         return ret;
1081 }

/* [<][>][^][v][top][bottom][index][help] */