source4/ntvfs/posix/pvfs_qfileinfo.c

   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 2 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, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24 #include "vfs_posix.h"
  25 #include "librpc/gen_ndr/ndr_xattr.h"
  26
  27
  28 /*
  29   determine what access bits are needed for a call
  30 */
  31 static uint32_t pvfs_fileinfo_access(enum smb_fileinfo_level level)
  32 {
  33         uint32_t needed;
  34
  35         switch (level) {
  36         case RAW_FILEINFO_EA_LIST:
  37         case RAW_FILEINFO_ALL_EAS:
  38                 needed = SEC_FILE_READ_EA;
  39                 break;
  40
  41         case RAW_FILEINFO_IS_NAME_VALID:
  42                 needed = 0;
  43                 break;
  44
  45         case RAW_FILEINFO_SEC_DESC:
  46                 needed = SEC_STD_READ_CONTROL;
  47                 break;
  48
  49         default:
  50                 needed = SEC_FILE_READ_ATTRIBUTE;
  51                 break;
  52         }
  53         return needed;
  54 }
  55
  56 /*
  57   reply to a RAW_FILEINFO_EA_LIST call
  58 */
  59 NTSTATUS pvfs_query_ea_list(struct pvfs_state *pvfs, TALLOC_CTX *mem_ctx,
  60                             struct pvfs_filename *name, int fd,
  61                             uint_t num_names,
  62                             struct ea_name *names,
  63                             struct smb_ea_list *eas)
  64 {
  65         NTSTATUS status;
  66         int i;
  67         struct xattr_DosEAs *ealist = talloc(mem_ctx, struct xattr_DosEAs);
  68
  69         ZERO_STRUCTP(eas);
  70         status = pvfs_doseas_load(pvfs, name, fd, ealist);
  71         if (!NT_STATUS_IS_OK(status)) {
  72                 return status;
  73         }
  74         eas->eas = talloc_array(mem_ctx, struct ea_struct, num_names);
  75         if (eas->eas == NULL) {
  76                 return NT_STATUS_NO_MEMORY;
  77         }
  78         eas->num_eas = num_names;
  79         for (i=0;i<num_names;i++) {
  80                 int j;
  81                 eas->eas[i].flags = 0;
  82                 eas->eas[i].name.s = names[i].name.s;
  83                 eas->eas[i].value = data_blob(NULL, 0);
  84                 for (j=0;j<ealist->num_eas;j++) {
  85                         if (strcasecmp_m(eas->eas[i].name.s,
  86                                        ealist->eas[j].name) == 0) {
  87                                 eas->eas[i].value = ealist->eas[j].value;
  88                                 break;
  89                         }
  90                 }
  91         }
  92         return NT_STATUS_OK;
  93 }
  94
  95 /*
  96   reply to a RAW_FILEINFO_ALL_EAS call
  97 */
  98 static NTSTATUS pvfs_query_all_eas(struct pvfs_state *pvfs, TALLOC_CTX *mem_ctx,
  99                                    struct pvfs_filename *name, int fd,
 100                                    struct smb_ea_list *eas)
 101 {
 102         NTSTATUS status;
 103         int i;
 104         struct xattr_DosEAs *ealist = talloc(mem_ctx, struct xattr_DosEAs);
 105
 106         ZERO_STRUCTP(eas);
 107         status = pvfs_doseas_load(pvfs, name, fd, ealist);
 108         if (!NT_STATUS_IS_OK(status)) {
 109                 return status;
 110         }
 111         eas->eas = talloc_array(mem_ctx, struct ea_struct, ealist->num_eas);
 112         if (eas->eas == NULL) {
 113                 return NT_STATUS_NO_MEMORY;
 114         }
 115         eas->num_eas = 0;
 116         for (i=0;i<ealist->num_eas;i++) {
 117                 eas->eas[eas->num_eas].flags = 0;
 118                 eas->eas[eas->num_eas].name.s = ealist->eas[i].name;
 119                 eas->eas[eas->num_eas].value = ealist->eas[i].value;
 120                 eas->num_eas++;
 121         }
 122         return NT_STATUS_OK;
 123 }
 124
 125 /*
 126   approximately map a struct pvfs_filename to a generic fileinfo struct
 127 */
 128 static NTSTATUS pvfs_map_fileinfo(struct pvfs_state *pvfs,
 129                                   struct ntvfs_request *req,
 130                                   struct pvfs_filename *name, union smb_fileinfo *info,
 131                                   int fd)
 132 {
 133         switch (info->generic.level) {
 134         case RAW_FILEINFO_GENERIC:
 135                 return NT_STATUS_INVALID_LEVEL;
 136
 137         case RAW_FILEINFO_GETATTR:
 138                 info->getattr.out.attrib     = name->dos.attrib;
 139                 info->getattr.out.size       = name->st.st_size;
 140                 info->getattr.out.write_time = nt_time_to_unix(name->dos.write_time);
 141                 return NT_STATUS_OK;
 142
 143         case RAW_FILEINFO_GETATTRE:
 144         case RAW_FILEINFO_STANDARD:
 145                 info->standard.out.create_time = nt_time_to_unix(name->dos.create_time);
 146                 info->standard.out.access_time = nt_time_to_unix(name->dos.access_time);
 147                 info->standard.out.write_time  = nt_time_to_unix(name->dos.write_time);
 148                 info->standard.out.size        = name->st.st_size;
 149                 info->standard.out.alloc_size  = name->dos.alloc_size;
 150                 info->standard.out.attrib      = name->dos.attrib;
 151                 return NT_STATUS_OK;
 152
 153         case RAW_FILEINFO_EA_SIZE:
 154                 info->ea_size.out.create_time = nt_time_to_unix(name->dos.create_time);
 155                 info->ea_size.out.access_time = nt_time_to_unix(name->dos.access_time);
 156                 info->ea_size.out.write_time  = nt_time_to_unix(name->dos.write_time);
 157                 info->ea_size.out.size        = name->st.st_size;
 158                 info->ea_size.out.alloc_size  = name->dos.alloc_size;
 159                 info->ea_size.out.attrib      = name->dos.attrib;
 160                 info->ea_size.out.ea_size     = name->dos.ea_size;
 161                 return NT_STATUS_OK;
 162
 163         case RAW_FILEINFO_EA_LIST:
 164                 return pvfs_query_ea_list(pvfs, req, name, fd,
 165                                           info->ea_list.in.num_names,
 166                                           info->ea_list.in.ea_names,
 167                                           &info->ea_list.out);
 168
 169         case RAW_FILEINFO_ALL_EAS:
 170                 return pvfs_query_all_eas(pvfs, req, name, fd, &info->all_eas.out);
 171
 172         case RAW_FILEINFO_IS_NAME_VALID:
 173                 return NT_STATUS_OK;
 174
 175         case RAW_FILEINFO_BASIC_INFO:
 176         case RAW_FILEINFO_BASIC_INFORMATION:
 177                 info->basic_info.out.create_time = name->dos.create_time;
 178                 info->basic_info.out.access_time = name->dos.access_time;
 179                 info->basic_info.out.write_time  = name->dos.write_time;
 180                 info->basic_info.out.change_time = name->dos.change_time;
 181                 info->basic_info.out.attrib      = name->dos.attrib;
 182                 return NT_STATUS_OK;
 183
 184         case RAW_FILEINFO_STANDARD_INFO:
 185         case RAW_FILEINFO_STANDARD_INFORMATION:
 186                 info->standard_info.out.alloc_size     = name->dos.alloc_size;
 187                 info->standard_info.out.size           = name->st.st_size;
 188                 info->standard_info.out.nlink          = name->dos.nlink;
 189                 info->standard_info.out.delete_pending = 0;
 190                 info->standard_info.out.directory   =
 191                         (name->dos.attrib & FILE_ATTRIBUTE_DIRECTORY)? 1 : 0;
 192                 return NT_STATUS_OK;
 193
 194         case RAW_FILEINFO_EA_INFO:
 195         case RAW_FILEINFO_EA_INFORMATION:
 196                 info->ea_info.out.ea_size = name->dos.ea_size;
 197                 return NT_STATUS_OK;
 198
 199         case RAW_FILEINFO_NAME_INFO:
 200         case RAW_FILEINFO_NAME_INFORMATION:
 201                 info->name_info.out.fname.s = name->original_name;
 202                 return NT_STATUS_OK;
 203
 204         case RAW_FILEINFO_ALL_INFO:
 205         case RAW_FILEINFO_ALL_INFORMATION:
 206                 info->all_info.out.create_time    = name->dos.create_time;
 207                 info->all_info.out.access_time    = name->dos.access_time;
 208                 info->all_info.out.write_time     = name->dos.write_time;
 209                 info->all_info.out.change_time    = name->dos.change_time;
 210                 info->all_info.out.attrib         = name->dos.attrib;
 211                 info->all_info.out.alloc_size     = name->dos.alloc_size;
 212                 info->all_info.out.size           = name->st.st_size;
 213                 info->all_info.out.nlink          = name->dos.nlink;
 214                 info->all_info.out.delete_pending = 0;
 215                 info->all_info.out.directory      =
 216                         (name->dos.attrib & FILE_ATTRIBUTE_DIRECTORY)? 1 : 0;
 217                 info->all_info.out.ea_size        = name->dos.ea_size;
 218                 info->all_info.out.fname.s        = name->original_name;
 219                 return NT_STATUS_OK;
 220
 221         case RAW_FILEINFO_ALT_NAME_INFO:
 222         case RAW_FILEINFO_ALT_NAME_INFORMATION:
 223                 info->name_info.out.fname.s = pvfs_short_name(pvfs, name, name);
 224                 return NT_STATUS_OK;
 225
 226         case RAW_FILEINFO_STREAM_INFO:
 227         case RAW_FILEINFO_STREAM_INFORMATION:
 228                 return pvfs_stream_information(pvfs, req, name, fd, &info->stream_info.out);
 229
 230         case RAW_FILEINFO_COMPRESSION_INFO:
 231         case RAW_FILEINFO_COMPRESSION_INFORMATION:
 232                 info->compression_info.out.compressed_size = name->st.st_size;
 233                 info->compression_info.out.format          = 0;
 234                 info->compression_info.out.unit_shift      = 0;
 235                 info->compression_info.out.chunk_shift     = 0;
 236                 info->compression_info.out.cluster_shift   = 0;
 237                 return NT_STATUS_OK;
 238
 239         case RAW_FILEINFO_INTERNAL_INFORMATION:
 240                 info->internal_information.out.file_id = name->dos.file_id;
 241                 return NT_STATUS_OK;
 242
 243         case RAW_FILEINFO_ACCESS_INFORMATION:
 244                 info->access_information.out.access_flags = 0;
 245                 return NT_STATUS_OK;
 246
 247         case RAW_FILEINFO_POSITION_INFORMATION:
 248                 info->position_information.out.position = 0;
 249                 return NT_STATUS_OK;
 250
 251         case RAW_FILEINFO_MODE_INFORMATION:
 252                 info->mode_information.out.mode = 0;
 253                 return NT_STATUS_OK;
 254
 255         case RAW_FILEINFO_ALIGNMENT_INFORMATION:
 256                 info->alignment_information.out.alignment_requirement = 0;
 257                 return NT_STATUS_OK;
 258
 259         case RAW_FILEINFO_NETWORK_OPEN_INFORMATION:
 260                 info->network_open_information.out.create_time = name->dos.create_time;
 261                 info->network_open_information.out.access_time = name->dos.access_time;
 262                 info->network_open_information.out.write_time  = name->dos.write_time;
 263                 info->network_open_information.out.change_time = name->dos.change_time;
 264                 info->network_open_information.out.alloc_size  = name->dos.alloc_size;
 265                 info->network_open_information.out.size        = name->st.st_size;
 266                 info->network_open_information.out.attrib      = name->dos.attrib;
 267                 return NT_STATUS_OK;
 268
 269         case RAW_FILEINFO_ATTRIBUTE_TAG_INFORMATION:
 270                 info->attribute_tag_information.out.attrib      = name->dos.attrib;
 271                 info->attribute_tag_information.out.reparse_tag = 0;
 272                 return NT_STATUS_OK;
 273
 274         case RAW_FILEINFO_SEC_DESC:
 275                 return pvfs_acl_query(pvfs, req, name, fd, info);
 276         }
 277
 278         return NT_STATUS_INVALID_LEVEL;
 279 }
 280
 281 /*
 282   return info on a pathname
 283 */
 284 NTSTATUS pvfs_qpathinfo(struct ntvfs_module_context *ntvfs,
 285                         struct ntvfs_request *req, union smb_fileinfo *info)
 286 {
 287         struct pvfs_state *pvfs = ntvfs->private_data;
 288         struct pvfs_filename *name;
 289         NTSTATUS status;
 290
 291         /* resolve the cifs name to a posix name */
 292         status = pvfs_resolve_name(pvfs, req, info->generic.in.file.path, PVFS_RESOLVE_STREAMS, &name);
 293         if (!NT_STATUS_IS_OK(status)) {
 294                 return status;
 295         }
 296
 297         if (!name->stream_exists) {
 298                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
 299         }
 300
 301         status = pvfs_can_stat(pvfs, req, name);
 302         if (!NT_STATUS_IS_OK(status)) {
 303                 return NT_STATUS_DELETE_PENDING;
 304         }
 305
 306         status = pvfs_access_check_simple(pvfs, req, name,
 307                                           pvfs_fileinfo_access(info->generic.level));
 308         if (!NT_STATUS_IS_OK(status)) {
 309                 return status;
 310         }
 311
 312         status = pvfs_map_fileinfo(pvfs, req, name, info, -1);
 313
 314         return status;
 315 }
 316
 317 /*
 318   query info on a open file
 319 */
 320 NTSTATUS pvfs_qfileinfo(struct ntvfs_module_context *ntvfs,
 321                         struct ntvfs_request *req, union smb_fileinfo *info)
 322 {
 323         struct pvfs_state *pvfs = ntvfs->private_data;
 324         struct pvfs_file *f;
 325         struct pvfs_file_handle *h;
 326         NTSTATUS status;
 327         uint32_t access_needed;
 328
 329         f = pvfs_find_fd(pvfs, req, info->generic.in.file.fnum);
 330         if (!f) {
 331                 return NT_STATUS_INVALID_HANDLE;
 332         }
 333         h = f->handle;
 334
 335         access_needed = pvfs_fileinfo_access(info->generic.level);
 336         if ((f->access_mask & access_needed) != access_needed) {
 337                 return NT_STATUS_ACCESS_DENIED;
 338         }
 339
 340         /* update the file information */
 341         status = pvfs_resolve_name_fd(pvfs, h->fd, h->name);
 342         if (!NT_STATUS_IS_OK(status)) {
 343                 return status;
 344         }
 345
 346         status = pvfs_map_fileinfo(pvfs, req, h->name, info, h->fd);
 347
 348         /* a qfileinfo can fill in a bit more info than a qpathinfo -
 349            now modify the levels that need to be fixed up */
 350         switch (info->generic.level) {
 351         case RAW_FILEINFO_STANDARD_INFO:
 352         case RAW_FILEINFO_STANDARD_INFORMATION:
 353                 if (pvfs_delete_on_close_set(pvfs, h, NULL, NULL)) {
 354                         info->standard_info.out.delete_pending = 1;
 355                         info->standard_info.out.nlink--;
 356                 }
 357                 break;
 358
 359         case RAW_FILEINFO_ALL_INFO:
 360         case RAW_FILEINFO_ALL_INFORMATION:
 361                 if (pvfs_delete_on_close_set(pvfs, h, NULL, NULL)) {
 362                         info->all_info.out.delete_pending = 1;
 363                         info->all_info.out.nlink--;
 364                 }
 365                 break;
 366
 367         case RAW_FILEINFO_POSITION_INFORMATION:
 368                 info->position_information.out.position = h->position;
 369                 break;
 370
 371         case RAW_FILEINFO_ACCESS_INFORMATION:
 372                 info->access_information.out.access_flags = f->access_mask;
 373                 break;
 374
 375         case RAW_FILEINFO_MODE_INFORMATION:
 376                 info->mode_information.out.mode = h->mode;
 377                 break;
 378
 379         default:
 380                 break;
 381         }
 382
 383         return status;
 384 }