s4-pvfs: the STREAM_INFORMATION calls don't need any access flags
[ira/wip.git] / 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 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 "librpc/gen_ndr/xattr.h"
25
26
27 /*
28   determine what access bits are needed for a call
29 */
30 static uint32_t pvfs_fileinfo_access(union smb_fileinfo *info)
31 {
32         uint32_t needed;
33
34         switch (info->generic.level) {
35         case RAW_FILEINFO_EA_LIST:
36         case RAW_FILEINFO_ALL_EAS:
37                 needed = SEC_FILE_READ_EA;
38                 break;
39
40         case RAW_FILEINFO_IS_NAME_VALID:
41                 needed = 0;
42                 break;
43
44         case RAW_FILEINFO_ACCESS_INFORMATION:
45                 needed = 0;
46                 break;
47
48         case RAW_FILEINFO_STREAM_INFO:
49         case RAW_FILEINFO_STREAM_INFORMATION:
50                 needed = 0;
51                 break;
52
53         case RAW_FILEINFO_SEC_DESC:
54                 needed = 0;
55                 if (info->query_secdesc.in.secinfo_flags & (SECINFO_OWNER|SECINFO_GROUP)) {
56                         needed |= SEC_STD_READ_CONTROL;
57                 }
58                 if (info->query_secdesc.in.secinfo_flags & SECINFO_DACL) {
59                         needed |= SEC_STD_READ_CONTROL;
60                 }
61                 if (info->query_secdesc.in.secinfo_flags & SECINFO_SACL) {
62                         needed |= SEC_FLAG_SYSTEM_SECURITY;
63                 }
64                 break;
65
66         default:
67                 needed = SEC_FILE_READ_ATTRIBUTE;
68                 break;
69         }
70
71         return needed;
72 }
73
74 /*
75   reply to a RAW_FILEINFO_EA_LIST call
76 */
77 NTSTATUS pvfs_query_ea_list(struct pvfs_state *pvfs, TALLOC_CTX *mem_ctx, 
78                             struct pvfs_filename *name, int fd, 
79                             uint_t num_names,
80                             struct ea_name *names,
81                             struct smb_ea_list *eas)
82 {
83         NTSTATUS status;
84         int i;
85         struct xattr_DosEAs *ealist = talloc(mem_ctx, struct xattr_DosEAs);
86
87         ZERO_STRUCTP(eas);
88         status = pvfs_doseas_load(pvfs, name, fd, ealist);
89         if (!NT_STATUS_IS_OK(status)) {
90                 return status;
91         }
92         eas->eas = talloc_array(mem_ctx, struct ea_struct, num_names);
93         if (eas->eas == NULL) {
94                 return NT_STATUS_NO_MEMORY;
95         }
96         eas->num_eas = num_names;
97         for (i=0;i<num_names;i++) {
98                 int j;
99                 eas->eas[i].flags = 0;
100                 eas->eas[i].name.s = names[i].name.s;
101                 eas->eas[i].value = data_blob(NULL, 0);
102                 for (j=0;j<ealist->num_eas;j++) {
103                         if (strcasecmp_m(eas->eas[i].name.s, 
104                                        ealist->eas[j].name) == 0) {
105                                 eas->eas[i].value = ealist->eas[j].value;
106                                 break;
107                         }
108                 }
109         }
110         return NT_STATUS_OK;
111 }
112
113 /*
114   reply to a RAW_FILEINFO_ALL_EAS call
115 */
116 static NTSTATUS pvfs_query_all_eas(struct pvfs_state *pvfs, TALLOC_CTX *mem_ctx, 
117                                    struct pvfs_filename *name, int fd, 
118                                    struct smb_ea_list *eas)
119 {
120         NTSTATUS status;
121         int i;
122         struct xattr_DosEAs *ealist = talloc(mem_ctx, struct xattr_DosEAs);
123
124         ZERO_STRUCTP(eas);
125         status = pvfs_doseas_load(pvfs, name, fd, ealist);
126         if (!NT_STATUS_IS_OK(status)) {
127                 return status;
128         }
129         eas->eas = talloc_array(mem_ctx, struct ea_struct, ealist->num_eas);
130         if (eas->eas == NULL) {
131                 return NT_STATUS_NO_MEMORY;
132         }
133         eas->num_eas = 0;
134         for (i=0;i<ealist->num_eas;i++) {
135                 eas->eas[eas->num_eas].flags = 0;
136                 eas->eas[eas->num_eas].name.s = ealist->eas[i].name;
137                 eas->eas[eas->num_eas].value = ealist->eas[i].value;
138                 eas->num_eas++;
139         }
140         return NT_STATUS_OK;
141 }
142
143 /*
144   approximately map a struct pvfs_filename to a generic fileinfo struct
145 */
146 static NTSTATUS pvfs_map_fileinfo(struct pvfs_state *pvfs, 
147                                   struct ntvfs_request *req,
148                                   struct pvfs_filename *name, union smb_fileinfo *info, 
149                                   int fd)
150 {
151         switch (info->generic.level) {
152         case RAW_FILEINFO_GENERIC:
153                 return NT_STATUS_INVALID_LEVEL;
154
155         case RAW_FILEINFO_GETATTR:
156                 info->getattr.out.attrib     = name->dos.attrib;
157                 info->getattr.out.size       = name->st.st_size;
158                 info->getattr.out.write_time = nt_time_to_unix(name->dos.write_time);
159                 return NT_STATUS_OK;
160
161         case RAW_FILEINFO_GETATTRE:
162         case RAW_FILEINFO_STANDARD:
163                 info->standard.out.create_time = nt_time_to_unix(name->dos.create_time);
164                 info->standard.out.access_time = nt_time_to_unix(name->dos.access_time);
165                 info->standard.out.write_time  = nt_time_to_unix(name->dos.write_time);
166                 info->standard.out.size        = name->st.st_size;
167                 info->standard.out.alloc_size  = name->dos.alloc_size;
168                 info->standard.out.attrib      = name->dos.attrib;
169                 return NT_STATUS_OK;
170
171         case RAW_FILEINFO_EA_SIZE:
172                 info->ea_size.out.create_time = nt_time_to_unix(name->dos.create_time);
173                 info->ea_size.out.access_time = nt_time_to_unix(name->dos.access_time);
174                 info->ea_size.out.write_time  = nt_time_to_unix(name->dos.write_time);
175                 info->ea_size.out.size        = name->st.st_size;
176                 info->ea_size.out.alloc_size  = name->dos.alloc_size;
177                 info->ea_size.out.attrib      = name->dos.attrib;
178                 info->ea_size.out.ea_size     = name->dos.ea_size;
179                 return NT_STATUS_OK;
180
181         case RAW_FILEINFO_EA_LIST:
182                 return pvfs_query_ea_list(pvfs, req, name, fd, 
183                                           info->ea_list.in.num_names,
184                                           info->ea_list.in.ea_names, 
185                                           &info->ea_list.out);
186
187         case RAW_FILEINFO_ALL_EAS:
188                 return pvfs_query_all_eas(pvfs, req, name, fd, &info->all_eas.out);
189
190         case RAW_FILEINFO_SMB2_ALL_EAS: {
191                 NTSTATUS status = pvfs_query_all_eas(pvfs, req, name, fd, &info->all_eas.out);
192                 if (NT_STATUS_IS_OK(status) &&
193                     info->all_eas.out.num_eas == 0) {
194                         return NT_STATUS_NO_EAS_ON_FILE;
195                 }
196                 return status;
197         }
198
199         case RAW_FILEINFO_IS_NAME_VALID:
200                 return NT_STATUS_OK;
201
202         case RAW_FILEINFO_BASIC_INFO:
203         case RAW_FILEINFO_BASIC_INFORMATION:
204                 info->basic_info.out.create_time = name->dos.create_time;
205                 info->basic_info.out.access_time = name->dos.access_time;
206                 info->basic_info.out.write_time  = name->dos.write_time;
207                 info->basic_info.out.change_time = name->dos.change_time;
208                 info->basic_info.out.attrib      = name->dos.attrib;
209                 return NT_STATUS_OK;
210
211         case RAW_FILEINFO_STANDARD_INFO:
212         case RAW_FILEINFO_STANDARD_INFORMATION:
213                 info->standard_info.out.alloc_size     = name->dos.alloc_size;
214                 info->standard_info.out.size           = name->st.st_size;
215                 info->standard_info.out.nlink          = name->dos.nlink;
216                 info->standard_info.out.delete_pending = 0; /* only for qfileinfo */
217                 info->standard_info.out.directory   = 
218                         (name->dos.attrib & FILE_ATTRIBUTE_DIRECTORY)? 1 : 0;
219                 return NT_STATUS_OK;
220
221         case RAW_FILEINFO_EA_INFO:
222         case RAW_FILEINFO_EA_INFORMATION:
223                 info->ea_info.out.ea_size = name->dos.ea_size;
224                 return NT_STATUS_OK;
225
226         case RAW_FILEINFO_NAME_INFO:
227         case RAW_FILEINFO_NAME_INFORMATION:
228                 if (req->ctx->protocol == PROTOCOL_SMB2) {
229                         /* strange that SMB2 doesn't have this */
230                         return NT_STATUS_NOT_SUPPORTED;
231                 }
232                 info->name_info.out.fname.s = name->original_name;
233                 return NT_STATUS_OK;
234
235         case RAW_FILEINFO_ALL_INFO:
236         case RAW_FILEINFO_ALL_INFORMATION:
237                 info->all_info.out.create_time    = name->dos.create_time;
238                 info->all_info.out.access_time    = name->dos.access_time;
239                 info->all_info.out.write_time     = name->dos.write_time;
240                 info->all_info.out.change_time    = name->dos.change_time;
241                 info->all_info.out.attrib         = name->dos.attrib;
242                 info->all_info.out.alloc_size     = name->dos.alloc_size;
243                 info->all_info.out.size           = name->st.st_size;
244                 info->all_info.out.nlink          = name->dos.nlink;
245                 info->all_info.out.delete_pending = 0; /* only set by qfileinfo */
246                 info->all_info.out.directory      = 
247                         (name->dos.attrib & FILE_ATTRIBUTE_DIRECTORY)? 1 : 0;
248                 info->all_info.out.ea_size        = name->dos.ea_size;
249                 info->all_info.out.fname.s        = name->original_name;
250                 return NT_STATUS_OK;
251
252         case RAW_FILEINFO_ALT_NAME_INFO:
253         case RAW_FILEINFO_ALT_NAME_INFORMATION:
254                 info->name_info.out.fname.s = pvfs_short_name(pvfs, name, name);
255                 return NT_STATUS_OK;
256
257         case RAW_FILEINFO_STREAM_INFO:
258         case RAW_FILEINFO_STREAM_INFORMATION:
259                 return pvfs_stream_information(pvfs, req, name, fd, &info->stream_info.out);
260
261         case RAW_FILEINFO_COMPRESSION_INFO:
262         case RAW_FILEINFO_COMPRESSION_INFORMATION:
263                 info->compression_info.out.compressed_size = name->st.st_size;
264                 info->compression_info.out.format          = 0;
265                 info->compression_info.out.unit_shift      = 0;
266                 info->compression_info.out.chunk_shift     = 0;
267                 info->compression_info.out.cluster_shift   = 0;
268                 return NT_STATUS_OK;
269
270         case RAW_FILEINFO_INTERNAL_INFORMATION:
271                 info->internal_information.out.file_id = name->dos.file_id;
272                 return NT_STATUS_OK;
273
274         case RAW_FILEINFO_ACCESS_INFORMATION:
275                 info->access_information.out.access_flags = 0; /* only set by qfileinfo */
276                 return NT_STATUS_OK;
277
278         case RAW_FILEINFO_POSITION_INFORMATION:
279                 info->position_information.out.position = 0; /* only set by qfileinfo */
280                 return NT_STATUS_OK;
281
282         case RAW_FILEINFO_MODE_INFORMATION:
283                 info->mode_information.out.mode = 0; /* only set by qfileinfo */
284                 return NT_STATUS_OK;
285
286         case RAW_FILEINFO_ALIGNMENT_INFORMATION:
287                 info->alignment_information.out.alignment_requirement = 0;
288                 return NT_STATUS_OK;
289
290         case RAW_FILEINFO_NETWORK_OPEN_INFORMATION:
291                 info->network_open_information.out.create_time = name->dos.create_time;
292                 info->network_open_information.out.access_time = name->dos.access_time;
293                 info->network_open_information.out.write_time  = name->dos.write_time;
294                 info->network_open_information.out.change_time = name->dos.change_time;
295                 info->network_open_information.out.alloc_size  = name->dos.alloc_size;
296                 info->network_open_information.out.size        = name->st.st_size;
297                 info->network_open_information.out.attrib      = name->dos.attrib;
298                 return NT_STATUS_OK;
299
300         case RAW_FILEINFO_ATTRIBUTE_TAG_INFORMATION:
301                 info->attribute_tag_information.out.attrib      = name->dos.attrib;
302                 info->attribute_tag_information.out.reparse_tag = 0;
303                 return NT_STATUS_OK;
304
305         case RAW_FILEINFO_SEC_DESC:
306                 return pvfs_acl_query(pvfs, req, name, fd, info);
307
308         case RAW_FILEINFO_SMB2_ALL_INFORMATION:
309                 info->all_info2.out.create_time    = name->dos.create_time;
310                 info->all_info2.out.access_time    = name->dos.access_time;
311                 info->all_info2.out.write_time     = name->dos.write_time;
312                 info->all_info2.out.change_time    = name->dos.change_time;
313                 info->all_info2.out.attrib         = name->dos.attrib;
314                 info->all_info2.out.unknown1       = 0;
315                 info->all_info2.out.alloc_size     = name->dos.alloc_size;
316                 info->all_info2.out.size           = name->st.st_size;
317                 info->all_info2.out.nlink          = name->dos.nlink;
318                 info->all_info2.out.delete_pending = 0; /* only set by qfileinfo */
319                 info->all_info2.out.directory      = 
320                         (name->dos.attrib & FILE_ATTRIBUTE_DIRECTORY)? 1 : 0;
321                 info->all_info2.out.file_id        = name->dos.file_id;
322                 info->all_info2.out.ea_size        = name->dos.ea_size;
323                 info->all_info2.out.access_mask    = 0; /* only set by qfileinfo */
324                 info->all_info2.out.position       = 0; /* only set by qfileinfo */
325                 info->all_info2.out.mode           = 0; /* only set by qfileinfo */
326                 /* windows wants the full path on disk for this
327                    result, but I really don't want to expose that on
328                    the wire, so I'll give the path with a share
329                    prefix, which is a good approximation */
330                 info->all_info2.out.fname.s = talloc_asprintf(req, "\\%s\\%s",
331                                                               pvfs->share_name, 
332                                                               name->original_name);
333                 NT_STATUS_HAVE_NO_MEMORY(info->all_info2.out.fname.s);
334                 return NT_STATUS_OK;
335         }
336
337         return NT_STATUS_INVALID_LEVEL;
338 }
339
340 /*
341   return info on a pathname
342 */
343 NTSTATUS pvfs_qpathinfo(struct ntvfs_module_context *ntvfs,
344                         struct ntvfs_request *req, union smb_fileinfo *info)
345 {
346         struct pvfs_state *pvfs = talloc_get_type(ntvfs->private_data,
347                                   struct pvfs_state);
348         struct pvfs_filename *name;
349         NTSTATUS status;
350
351         /* resolve the cifs name to a posix name */
352         status = pvfs_resolve_name(pvfs, req, info->generic.in.file.path, PVFS_RESOLVE_STREAMS, &name);
353         if (!NT_STATUS_IS_OK(status)) {
354                 return status;
355         }
356
357         if (!name->stream_exists) {
358                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
359         }
360
361         status = pvfs_can_stat(pvfs, req, name);
362         if (!NT_STATUS_IS_OK(status)) {
363                 return status;
364         }
365
366         status = pvfs_access_check_simple(pvfs, req, name, 
367                                           pvfs_fileinfo_access(info));
368         if (!NT_STATUS_IS_OK(status)) {
369                 return status;
370         }
371
372         status = pvfs_map_fileinfo(pvfs, req, name, info, -1);
373
374         return status;
375 }
376
377 /*
378   query info on a open file
379 */
380 NTSTATUS pvfs_qfileinfo(struct ntvfs_module_context *ntvfs,
381                         struct ntvfs_request *req, union smb_fileinfo *info)
382 {
383         struct pvfs_state *pvfs = talloc_get_type(ntvfs->private_data,
384                                   struct pvfs_state);
385         struct pvfs_file *f;
386         struct pvfs_file_handle *h;
387         NTSTATUS status;
388         uint32_t access_needed;
389
390         f = pvfs_find_fd(pvfs, req, info->generic.in.file.ntvfs);
391         if (!f) {
392                 return NT_STATUS_INVALID_HANDLE;
393         }
394         h = f->handle;
395
396         access_needed = pvfs_fileinfo_access(info);
397         if ((f->access_mask & access_needed) != access_needed) {
398                 return NT_STATUS_ACCESS_DENIED;
399         }
400
401         /* update the file information */
402         status = pvfs_resolve_name_handle(pvfs, h);
403         if (!NT_STATUS_IS_OK(status)) {
404                 return status;
405         }
406         
407         status = pvfs_map_fileinfo(pvfs, req, h->name, info, h->fd);
408
409         /* a qfileinfo can fill in a bit more info than a qpathinfo -
410            now modify the levels that need to be fixed up */
411         switch (info->generic.level) {
412         case RAW_FILEINFO_STANDARD_INFO:
413         case RAW_FILEINFO_STANDARD_INFORMATION:
414                 if (pvfs_delete_on_close_set(pvfs, h)) {
415                         info->standard_info.out.delete_pending = 1;
416                         info->standard_info.out.nlink--;
417                 }
418                 break;
419
420         case RAW_FILEINFO_ALL_INFO:
421         case RAW_FILEINFO_ALL_INFORMATION:
422                 if (pvfs_delete_on_close_set(pvfs, h)) {
423                         info->all_info.out.delete_pending = 1;
424                         info->all_info.out.nlink--;
425                 }
426                 break;
427
428         case RAW_FILEINFO_POSITION_INFORMATION:
429                 info->position_information.out.position = h->position;
430                 break;
431
432         case RAW_FILEINFO_ACCESS_INFORMATION:
433                 info->access_information.out.access_flags = f->access_mask;
434                 break;
435
436         case RAW_FILEINFO_MODE_INFORMATION:
437                 info->mode_information.out.mode = h->mode;
438                 break;
439
440         case RAW_FILEINFO_SMB2_ALL_INFORMATION:
441                 if (pvfs_delete_on_close_set(pvfs, h)) {
442                         info->all_info2.out.delete_pending = 1;
443                         info->all_info2.out.nlink--;
444                 }
445                 info->all_info2.out.position    = h->position;
446                 info->all_info2.out.access_mask = f->access_mask;
447                 info->all_info2.out.mode        = h->mode;
448                 break;
449
450         default:
451                 break;
452         }
453         
454         return status;
455 }