Line data    Source code

       1             : /* 
       2             :    Unix SMB/CIFS implementation.
       3             : 
       4             :    POSIX NTVFS backend - read
       5             : 
       6             :    Copyright (C) Andrew Tridgell 2004
       7             : 
       8             :    This program is free software; you can redistribute it and/or modify
       9             :    it under the terms of the GNU General Public License as published by
      10             :    the Free Software Foundation; either version 3 of the License, or
      11             :    (at your option) any later version.
      12             :    
      13             :    This program is distributed in the hope that it will be useful,
      14             :    but WITHOUT ANY WARRANTY; without even the implied warranty of
      15             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      16             :    GNU General Public License for more details.
      17             :    
      18             :    You should have received a copy of the GNU General Public License
      19             :    along with this program.  If not, see <http://www.gnu.org/licenses/>.
      20             : */
      21             : 
      22             : #include "includes.h"
      23             : #include "vfs_posix.h"
      24             : #include "lib/events/events.h"
      25             : 
      26             : /*
      27             :   read from a file
      28             : */
      29       35694 : NTSTATUS pvfs_read(struct ntvfs_module_context *ntvfs,
      30             :                    struct ntvfs_request *req, union smb_read *rd)
      31             : {
      32       35694 :         struct pvfs_state *pvfs = talloc_get_type(ntvfs->private_data,
      33             :                                   struct pvfs_state);
      34           0 :         ssize_t ret;
      35           0 :         struct pvfs_file *f;
      36           0 :         NTSTATUS status;
      37           0 :         uint32_t maxcnt;
      38           0 :         uint32_t mask;
      39             : 
      40       35694 :         if (rd->generic.level != RAW_READ_READX) {
      41         334 :                 return ntvfs_map_read(ntvfs, req, rd);
      42             :         }
      43             : 
      44       35360 :         f = pvfs_find_fd(pvfs, req, rd->readx.in.file.ntvfs);
      45       35360 :         if (!f) {
      46           0 :                 return NT_STATUS_INVALID_HANDLE;
      47             :         }
      48             : 
      49       35360 :         if (f->handle->fd == -1) {
      50           4 :                 return NT_STATUS_INVALID_DEVICE_REQUEST;
      51             :         }
      52             : 
      53       35356 :         mask = SEC_FILE_READ_DATA;
      54       35356 :         if (rd->readx.in.read_for_execute) {
      55       16669 :                 mask |= SEC_FILE_EXECUTE;
      56             :         }
      57       35356 :         if (!(f->access_mask & mask)) {
      58       12640 :                 return NT_STATUS_ACCESS_DENIED;
      59             :         }
      60             : 
      61       22716 :         maxcnt = rd->readx.in.maxcnt;
      62       22716 :         if (maxcnt > 2*UINT16_MAX && req->ctx->protocol < PROTOCOL_SMB2_02) {
      63           0 :                 DEBUG(3,(__location__ ": Invalid SMB maxcnt 0x%x\n", maxcnt));
      64           0 :                 return NT_STATUS_INVALID_PARAMETER;
      65             :         }
      66             : 
      67       22716 :         status = pvfs_check_lock(pvfs, f, req->smbpid, 
      68             :                                  rd->readx.in.offset,
      69             :                                  maxcnt,
      70             :                                  READ_LOCK);
      71       22716 :         if (!NT_STATUS_IS_OK(status)) {
      72          14 :                 return status;
      73             :         }
      74             : 
      75       22702 :         if (f->handle->name->stream_name) {
      76          18 :                 ret = pvfs_stream_read(pvfs, f->handle, 
      77          18 :                                        rd->readx.out.data, maxcnt, rd->readx.in.offset);
      78             :         } else {
      79       22684 :                 ret = pread(f->handle->fd, 
      80       22684 :                             rd->readx.out.data, 
      81             :                             maxcnt,
      82       22684 :                             rd->readx.in.offset);
      83             :         }
      84       22702 :         if (ret == -1) {
      85           6 :                 return pvfs_map_errno(pvfs, errno);
      86             :         }
      87             : 
      88             :         /* only SMB2 honors mincnt */
      89       22696 :         if (req->ctx->protocol >= PROTOCOL_SMB2_02) {
      90         251 :                 if (rd->readx.in.mincnt > ret ||
      91           8 :                     (ret == 0 && maxcnt > 0)) {
      92           9 :                         return NT_STATUS_END_OF_FILE;
      93             :                 }
      94             :         }
      95             : 
      96       22687 :         f->handle->position = f->handle->seek_offset = rd->readx.in.offset + ret;
      97             : 
      98       22687 :         rd->readx.out.nread = ret;
      99       22687 :         rd->readx.out.remaining = 0xFFFF;
     100       22687 :         rd->readx.out.compaction_mode = 0; 
     101             : 
     102       22687 :         return NT_STATUS_OK;
     103             : }