?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3:torture:delete: fix a comment
[Samba/gebeck_regimport.git] / source4 / ntvfs / posix / pvfs_setfileinfo.c
blob3c9b18d91ce5f7f8dc995afd9e9f2a400bd3b87f
1 /*
2 Unix SMB/CIFS implementation.
3
4 POSIX NTVFS backend - setfileinfo
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 "system/time.h"
25 #include "librpc/gen_ndr/xattr.h"
26
27
28 /*
29 determine what access bits are needed for a call
30 */
31 static uint32_t pvfs_setfileinfo_access(union smb_setfileinfo *info)
32 {
33 uint32_t needed;
34
35 switch (info->generic.level) {
36 case RAW_SFILEINFO_EA_SET:
37 needed = SEC_FILE_WRITE_EA;
38 break;
39
40 case RAW_SFILEINFO_DISPOSITION_INFO:
41 case RAW_SFILEINFO_DISPOSITION_INFORMATION:
42 needed = SEC_STD_DELETE;
43 break;
44
45 case RAW_SFILEINFO_END_OF_FILE_INFO:
46 needed = SEC_FILE_WRITE_DATA;
47 break;
48
49 case RAW_SFILEINFO_POSITION_INFORMATION:
50 needed = 0;
51 break;
52
53 case RAW_SFILEINFO_SEC_DESC:
54 needed = 0;
55 if (info->set_secdesc.in.secinfo_flags & (SECINFO_OWNER|SECINFO_GROUP)) {
56 needed |= SEC_STD_WRITE_OWNER;
57 }
58 if (info->set_secdesc.in.secinfo_flags & SECINFO_DACL) {
59 needed |= SEC_STD_WRITE_DAC;
60 }
61 if (info->set_secdesc.in.secinfo_flags & SECINFO_SACL) {
62 needed |= SEC_FLAG_SYSTEM_SECURITY;
63 }
64 break;
65
66 case RAW_SFILEINFO_RENAME_INFORMATION:
67 case RAW_SFILEINFO_RENAME_INFORMATION_SMB2:
68 needed = SEC_STD_DELETE;
69 break;
70
71 default:
72 needed = SEC_FILE_WRITE_ATTRIBUTE;
73 break;
74 }
75
76 return needed;
77 }
78
79 /*
80 rename_information level for streams
81 */
82 static NTSTATUS pvfs_setfileinfo_rename_stream(struct pvfs_state *pvfs,
83 struct ntvfs_request *req,
84 struct pvfs_filename *name,
85 int fd,
86 DATA_BLOB *odb_locking_key,
87 union smb_setfileinfo *info)
88 {
89 NTSTATUS status;
90 struct odb_lock *lck = NULL;
91
92 /* strangely, this gives a sharing violation, not invalid
93 parameter */
94 if (info->rename_information.in.new_name[0] != ':') {
95 return NT_STATUS_SHARING_VIOLATION;
96 }
97
98 status = pvfs_access_check_simple(pvfs, req, name, SEC_FILE_WRITE_ATTRIBUTE);
99 if (!NT_STATUS_IS_OK(status)) {
100 return status;
101 }
102
103 lck = odb_lock(req, pvfs->odb_context, odb_locking_key);
104 if (lck == NULL) {
105 DEBUG(0,("Unable to lock opendb for can_stat\n"));
106 return NT_STATUS_INTERNAL_DB_CORRUPTION;
107 }
108
109
110 status = pvfs_stream_rename(pvfs, name, fd,
111 info->rename_information.in.new_name+1,
112 info->rename_information.in.overwrite);
113 return status;
114 }
115
116 /*
117 rename_information level
118 */
119 static NTSTATUS pvfs_setfileinfo_rename(struct pvfs_state *pvfs,
120 struct ntvfs_request *req,
121 struct pvfs_filename *name,
122 int fd,
123 DATA_BLOB *odb_locking_key,
124 union smb_setfileinfo *info)
125 {
126 NTSTATUS status;
127 struct pvfs_filename *name2;
128 char *new_name, *p;
129 struct odb_lock *lck = NULL;
130
131 /* renames are only allowed within a directory */
132 if (strchr_m(info->rename_information.in.new_name, '\\') &&
133 (req->ctx->protocol < PROTOCOL_SMB2_02)) {
134 return NT_STATUS_NOT_SUPPORTED;
135 }
136
137 /* handle stream renames specially */
138 if (name->stream_name) {
139 return pvfs_setfileinfo_rename_stream(pvfs, req, name, fd,
140 odb_locking_key, info);
141 }
142
143 /* w2k3 does not appear to allow relative rename. On SMB2, vista sends it sometimes,
144 but I suspect it is just uninitialised memory */
145 if (info->rename_information.in.root_fid != 0 &&
146 (req->ctx->protocol < PROTOCOL_SMB2_02)) {
147 return NT_STATUS_INVALID_PARAMETER;
148 }
149
150 /* construct the fully qualified windows name for the new file name */
151 if (req->ctx->protocol >= PROTOCOL_SMB2_02) {
152 /* SMB2 sends the full path of the new name */
153 new_name = talloc_asprintf(req, "\\%s", info->rename_information.in.new_name);
154 } else {
155 new_name = talloc_strdup(req, name->original_name);
156 if (new_name == NULL) {
157 return NT_STATUS_NO_MEMORY;
158 }
159 p = strrchr_m(new_name, '\\');
160 if (p == NULL) {
161 return NT_STATUS_OBJECT_NAME_INVALID;
162 } else {
163 *p = 0;
164 }
165
166 new_name = talloc_asprintf(req, "%s\\%s", new_name,
167 info->rename_information.in.new_name);
168 }
169 if (new_name == NULL) {
170 return NT_STATUS_NO_MEMORY;
171 }
172
173 /* resolve the new name */
174 status = pvfs_resolve_name(pvfs, req, new_name, 0, &name2);
175 if (!NT_STATUS_IS_OK(status)) {
176 return status;
177 }
178
179 /* if the destination exists, then check the rename is allowed */
180 if (name2->exists) {
181 if (strcmp(name2->full_name, name->full_name) == 0) {
182 /* rename to same name is null-op */
183 return NT_STATUS_OK;
184 }
185
186 if (!info->rename_information.in.overwrite) {
187 return NT_STATUS_OBJECT_NAME_COLLISION;
188 }
189
190 status = pvfs_can_delete(pvfs, req, name2, NULL);
191 if (NT_STATUS_EQUAL(status, NT_STATUS_DELETE_PENDING)) {
192 return NT_STATUS_ACCESS_DENIED;
193 }
194 if (NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION)) {
195 return NT_STATUS_ACCESS_DENIED;
196 }
197 if (!NT_STATUS_IS_OK(status)) {
198 return status;
199 }
200 }
201
202 status = pvfs_access_check_parent(pvfs, req, name2, SEC_DIR_ADD_FILE);
203 if (!NT_STATUS_IS_OK(status)) {
204 return status;
205 }
206
207 lck = odb_lock(req, pvfs->odb_context, odb_locking_key);
208 if (lck == NULL) {
209 DEBUG(0,("Unable to lock opendb for can_stat\n"));
210 return NT_STATUS_INTERNAL_DB_CORRUPTION;
211 }
212
213 status = pvfs_do_rename(pvfs, lck, name, name2->full_name);
214 talloc_free(lck);
215 NT_STATUS_NOT_OK_RETURN(status);
216 if (NT_STATUS_IS_OK(status)) {
217 name->full_name = talloc_steal(name, name2->full_name);
218 name->original_name = talloc_steal(name, name2->original_name);
219 }
220
221 return NT_STATUS_OK;
222 }
223
224 /*
225 add a single DOS EA
226 */
227 NTSTATUS pvfs_setfileinfo_ea_set(struct pvfs_state *pvfs,
228 struct pvfs_filename *name,
229 int fd, uint16_t num_eas,
230 struct ea_struct *eas)
231 {
232 struct xattr_DosEAs *ealist;
233 int i, j;
234 NTSTATUS status;
235
236 if (num_eas == 0) {
237 return NT_STATUS_OK;
238 }
239
240 if (!(pvfs->flags & PVFS_FLAG_XATTR_ENABLE)) {
241 return NT_STATUS_NOT_SUPPORTED;
242 }
243
244 ealist = talloc(name, struct xattr_DosEAs);
245
246 /* load the current list */
247 status = pvfs_doseas_load(pvfs, name, fd, ealist);
248 if (!NT_STATUS_IS_OK(status)) {
249 return status;
250 }
251
252 for (j=0;j<num_eas;j++) {
253 struct ea_struct *ea = &eas[j];
254 /* see if its already there */
255 for (i=0;i<ealist->num_eas;i++) {
256 if (strcasecmp_m(ealist->eas[i].name, ea->name.s) == 0) {
257 ealist->eas[i].value = ea->value;
258 break;
259 }
260 }
261
262 if (i==ealist->num_eas) {
263 /* add it */
264 ealist->eas = talloc_realloc(ealist, ealist->eas,
265 struct xattr_EA,
266 ealist->num_eas+1);
267 if (ealist->eas == NULL) {
268 return NT_STATUS_NO_MEMORY;
269 }
270 ealist->eas[i].name = ea->name.s;
271 ealist->eas[i].value = ea->value;
272 ealist->num_eas++;
273 }
274 }
275
276 /* pull out any null EAs */
277 for (i=0;i<ealist->num_eas;i++) {
278 if (ealist->eas[i].value.length == 0) {
279 memmove(&ealist->eas[i],
280 &ealist->eas[i+1],
281 (ealist->num_eas-(i+1)) * sizeof(ealist->eas[i]));
282 ealist->num_eas--;
283 i--;
284 }
285 }
286
287 status = pvfs_doseas_save(pvfs, name, fd, ealist);
288 if (!NT_STATUS_IS_OK(status)) {
289 return status;
290 }
291
292 notify_trigger(pvfs->notify_context,
293 NOTIFY_ACTION_MODIFIED,
294 FILE_NOTIFY_CHANGE_EA,
295 name->full_name);
296
297 name->dos.ea_size = 4;
298 for (i=0;i<ealist->num_eas;i++) {
299 name->dos.ea_size += 4 + strlen(ealist->eas[i].name)+1 +
300 ealist->eas[i].value.length;
301 }
302
303 /* update the ea_size attrib */
304 return pvfs_dosattrib_save(pvfs, name, fd);
305 }
306
307 /*
308 set info on a open file
309 */
310 NTSTATUS pvfs_setfileinfo(struct ntvfs_module_context *ntvfs,
311 struct ntvfs_request *req,
312 union smb_setfileinfo *info)
313 {
314 struct pvfs_state *pvfs = talloc_get_type(ntvfs->private_data,
315 struct pvfs_state);
316 struct pvfs_file *f;
317 struct pvfs_file_handle *h;
318 struct pvfs_filename newstats;
319 NTSTATUS status;
320 uint32_t access_needed;
321 uint32_t change_mask = 0;
322
323 f = pvfs_find_fd(pvfs, req, info->generic.in.file.ntvfs);
324 if (!f) {
325 return NT_STATUS_INVALID_HANDLE;
326 }
327
328 h = f->handle;
329
330 access_needed = pvfs_setfileinfo_access(info);
331 if ((f->access_mask & access_needed) != access_needed) {
332 return NT_STATUS_ACCESS_DENIED;
333 }
334
335 /* update the file information */
336 status = pvfs_resolve_name_handle(pvfs, h);
337 if (!NT_STATUS_IS_OK(status)) {
338 return status;
339 }
340
341 /* we take a copy of the current file stats, then update
342 newstats in each of the elements below. At the end we
343 compare, and make any changes needed */
344 newstats = *h->name;
345
346 switch (info->generic.level) {
347 case RAW_SFILEINFO_SETATTR:
348 if (!null_time(info->setattr.in.write_time)) {
349 unix_to_nt_time(&newstats.dos.write_time, info->setattr.in.write_time);
350 }
351 if (info->setattr.in.attrib != FILE_ATTRIBUTE_NORMAL) {
352 newstats.dos.attrib = info->setattr.in.attrib;
353 }
354 break;
355
356 case RAW_SFILEINFO_SETATTRE:
357 case RAW_SFILEINFO_STANDARD:
358 if (!null_time(info->setattre.in.create_time)) {
359 unix_to_nt_time(&newstats.dos.create_time, info->setattre.in.create_time);
360 }
361 if (!null_time(info->setattre.in.access_time)) {
362 unix_to_nt_time(&newstats.dos.access_time, info->setattre.in.access_time);
363 }
364 if (!null_time(info->setattre.in.write_time)) {
365 unix_to_nt_time(&newstats.dos.write_time, info->setattre.in.write_time);
366 }
367 break;
368
369 case RAW_SFILEINFO_EA_SET:
370 return pvfs_setfileinfo_ea_set(pvfs, h->name, h->fd,
371 info->ea_set.in.num_eas,
372 info->ea_set.in.eas);
373
374 case RAW_SFILEINFO_BASIC_INFO:
375 case RAW_SFILEINFO_BASIC_INFORMATION:
376 if (!null_nttime(info->basic_info.in.create_time)) {
377 newstats.dos.create_time = info->basic_info.in.create_time;
378 }
379 if (!null_nttime(info->basic_info.in.access_time)) {
380 newstats.dos.access_time = info->basic_info.in.access_time;
381 }
382 if (!null_nttime(info->basic_info.in.write_time)) {
383 newstats.dos.write_time = info->basic_info.in.write_time;
384 }
385 if (!null_nttime(info->basic_info.in.change_time)) {
386 newstats.dos.change_time = info->basic_info.in.change_time;
387 }
388 if (info->basic_info.in.attrib != 0) {
389 newstats.dos.attrib = info->basic_info.in.attrib;
390 }
391 break;
392
393 case RAW_SFILEINFO_DISPOSITION_INFO:
394 case RAW_SFILEINFO_DISPOSITION_INFORMATION:
395 return pvfs_set_delete_on_close(pvfs, req, f,
396 info->disposition_info.in.delete_on_close);
397
398 case RAW_SFILEINFO_ALLOCATION_INFO:
399 case RAW_SFILEINFO_ALLOCATION_INFORMATION:
400 status = pvfs_break_level2_oplocks(f);
401 NT_STATUS_NOT_OK_RETURN(status);
402
403 newstats.dos.alloc_size = info->allocation_info.in.alloc_size;
404 if (newstats.dos.alloc_size < newstats.st.st_size) {
405 newstats.st.st_size = newstats.dos.alloc_size;
406 }
407 newstats.dos.alloc_size = pvfs_round_alloc_size(pvfs,
408 newstats.dos.alloc_size);
409 break;
410
411 case RAW_SFILEINFO_END_OF_FILE_INFO:
412 case RAW_SFILEINFO_END_OF_FILE_INFORMATION:
413 status = pvfs_break_level2_oplocks(f);
414 NT_STATUS_NOT_OK_RETURN(status);
415
416 newstats.st.st_size = info->end_of_file_info.in.size;
417 break;
418
419 case RAW_SFILEINFO_POSITION_INFORMATION:
420 h->position = info->position_information.in.position;
421 break;
422
423 case RAW_SFILEINFO_MODE_INFORMATION:
424 /* this one is a puzzle */
425 if (info->mode_information.in.mode != 0 &&
426 info->mode_information.in.mode != 2 &&
427 info->mode_information.in.mode != 4 &&
428 info->mode_information.in.mode != 6) {
429 return NT_STATUS_INVALID_PARAMETER;
430 }
431 h->mode = info->mode_information.in.mode;
432 break;
433
434 case RAW_SFILEINFO_RENAME_INFORMATION:
435 case RAW_SFILEINFO_RENAME_INFORMATION_SMB2:
436 return pvfs_setfileinfo_rename(pvfs, req, h->name, f->handle->fd,
437 &h->odb_locking_key,
438 info);
439
440 case RAW_SFILEINFO_SEC_DESC:
441 notify_trigger(pvfs->notify_context,
442 NOTIFY_ACTION_MODIFIED,
443 FILE_NOTIFY_CHANGE_SECURITY,
444 h->name->full_name);
445 return pvfs_acl_set(pvfs, req, h->name, h->fd, f->access_mask, info);
446
447 default:
448 return NT_STATUS_INVALID_LEVEL;
449 }
450
451 /* possibly change the file size */
452 if (newstats.st.st_size != h->name->st.st_size) {
453 if (h->name->dos.attrib & FILE_ATTRIBUTE_DIRECTORY) {
454 return NT_STATUS_FILE_IS_A_DIRECTORY;
455 }
456 if (h->name->stream_name) {
457 status = pvfs_stream_truncate(pvfs, h->name, h->fd, newstats.st.st_size);
458 if (!NT_STATUS_IS_OK(status)) {
459 return status;
460 }
461
462 change_mask |= FILE_NOTIFY_CHANGE_STREAM_SIZE;
463 } else {
464 int ret;
465 if (f->access_mask &
466 (SEC_FILE_WRITE_DATA|SEC_FILE_APPEND_DATA)) {
467 ret = ftruncate(h->fd, newstats.st.st_size);
468 } else {
469 ret = truncate(h->name->full_name, newstats.st.st_size);
470 }
471 if (ret == -1) {
472 return pvfs_map_errno(pvfs, errno);
473 }
474 change_mask |= FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_ATTRIBUTES;
475 }
476 }
477
478 /* possibly change the file timestamps */
479 if (newstats.dos.create_time != h->name->dos.create_time) {
480 change_mask |= FILE_NOTIFY_CHANGE_CREATION;
481 }
482 if (newstats.dos.access_time != h->name->dos.access_time) {
483 change_mask |= FILE_NOTIFY_CHANGE_LAST_ACCESS;
484 }
485 if (newstats.dos.write_time != h->name->dos.write_time) {
486 change_mask |= FILE_NOTIFY_CHANGE_LAST_WRITE;
487 }
488 if ((change_mask & FILE_NOTIFY_CHANGE_LAST_ACCESS) ||
489 (change_mask & FILE_NOTIFY_CHANGE_LAST_WRITE)) {
490 struct timeval tv[2];
491
492 nttime_to_timeval(&tv[0], newstats.dos.access_time);
493 nttime_to_timeval(&tv[1], newstats.dos.write_time);
494
495 if (!timeval_is_zero(&tv[0]) || !timeval_is_zero(&tv[1])) {
496 if (utimes(h->name->full_name, tv) == -1) {
497 DEBUG(0,("pvfs_setfileinfo: utimes() failed '%s' - %s\n",
498 h->name->full_name, strerror(errno)));
499 return pvfs_map_errno(pvfs, errno);
500 }
501 }
502 }
503 if (change_mask & FILE_NOTIFY_CHANGE_LAST_WRITE) {
504 struct odb_lock *lck;
505
506 lck = odb_lock(req, h->pvfs->odb_context, &h->odb_locking_key);
507 if (lck == NULL) {
508 DEBUG(0,("Unable to lock opendb for write time update\n"));
509 return NT_STATUS_INTERNAL_ERROR;
510 }
511
512 status = odb_set_write_time(lck, newstats.dos.write_time, true);
513 if (!NT_STATUS_IS_OK(status)) {
514 DEBUG(0,("Unable to update write time: %s\n",
515 nt_errstr(status)));
516 talloc_free(lck);
517 return status;
518 }
519
520 talloc_free(lck);
521
522 h->write_time.update_forced = true;
523 h->write_time.update_on_close = false;
524 talloc_free(h->write_time.update_event);
525 h->write_time.update_event = NULL;
526 }
527
528 /* possibly change the attribute */
529 if (newstats.dos.attrib != h->name->dos.attrib) {
530 mode_t mode;
531 if ((newstats.dos.attrib & FILE_ATTRIBUTE_DIRECTORY) &&
532 !(h->name->dos.attrib & FILE_ATTRIBUTE_DIRECTORY)) {
533 return NT_STATUS_INVALID_PARAMETER;
534 }
535 mode = pvfs_fileperms(pvfs, newstats.dos.attrib);
536 if (!(h->name->dos.attrib & FILE_ATTRIBUTE_DIRECTORY)) {
537 if (pvfs_sys_fchmod(pvfs, h->fd, mode, h->name->allow_override) == -1) {
538 return pvfs_map_errno(pvfs, errno);
539 }
540 }
541 change_mask |= FILE_NOTIFY_CHANGE_ATTRIBUTES;
542 }
543
544 *h->name = newstats;
545
546 notify_trigger(pvfs->notify_context,
547 NOTIFY_ACTION_MODIFIED,
548 change_mask,
549 h->name->full_name);
550
551 return pvfs_dosattrib_save(pvfs, h->name, h->fd);
552 }
553
554 /*
555 retry an open after a sharing violation
556 */
557 static void pvfs_retry_setpathinfo(struct pvfs_odb_retry *r,
558 struct ntvfs_module_context *ntvfs,
559 struct ntvfs_request *req,
560 void *_info,
561 void *private_data,
562 enum pvfs_wait_notice reason)
563 {
564 union smb_setfileinfo *info = talloc_get_type(_info,
565 union smb_setfileinfo);
566 NTSTATUS status = NT_STATUS_INTERNAL_ERROR;
567
568 talloc_free(r);
569
570 switch (reason) {
571 case PVFS_WAIT_CANCEL:
572 /*TODO*/
573 status = NT_STATUS_CANCELLED;
574 break;
575 case PVFS_WAIT_TIMEOUT:
576 /* if it timed out, then give the failure
577 immediately */
578 /*TODO*/
579 status = NT_STATUS_SHARING_VIOLATION;
580 break;
581 case PVFS_WAIT_EVENT:
582
583 /* try the open again, which could trigger another retry setup
584 if it wants to, so we have to unmark the async flag so we
585 will know if it does a second async reply */
586 req->async_states->state &= ~NTVFS_ASYNC_STATE_ASYNC;
587
588 status = pvfs_setpathinfo(ntvfs, req, info);
589 if (req->async_states->state & NTVFS_ASYNC_STATE_ASYNC) {
590 /* the 2nd try also replied async, so we don't send
591 the reply yet */
592 return;
593 }
594
595 /* re-mark it async, just in case someone up the chain does
596 paranoid checking */
597 req->async_states->state |= NTVFS_ASYNC_STATE_ASYNC;
598 break;
599 }
600
601 /* send the reply up the chain */
602 req->async_states->status = status;
603 req->async_states->send_fn(req);
604 }
605
606 /*
607 setup for a unlink retry after a sharing violation
608 or a non granted oplock
609 */
610 static NTSTATUS pvfs_setpathinfo_setup_retry(struct ntvfs_module_context *ntvfs,
611 struct ntvfs_request *req,
612 union smb_setfileinfo *info,
613 struct odb_lock *lck,
614 NTSTATUS status)
615 {
616 struct pvfs_state *pvfs = talloc_get_type(ntvfs->private_data,
617 struct pvfs_state);
618 struct timeval end_time;
619
620 if (NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION)) {
621 end_time = timeval_add(&req->statistics.request_time,
622 0, pvfs->sharing_violation_delay);
623 } else if (NT_STATUS_EQUAL(status, NT_STATUS_OPLOCK_NOT_GRANTED)) {
624 end_time = timeval_add(&req->statistics.request_time,
625 pvfs->oplock_break_timeout, 0);
626 } else {
627 return NT_STATUS_INTERNAL_ERROR;
628 }
629
630 return pvfs_odb_retry_setup(ntvfs, req, lck, end_time, info, NULL,
631 pvfs_retry_setpathinfo);
632 }
633
634 /*
635 set info on a pathname
636 */
637 NTSTATUS pvfs_setpathinfo(struct ntvfs_module_context *ntvfs,
638 struct ntvfs_request *req, union smb_setfileinfo *info)
639 {
640 struct pvfs_state *pvfs = talloc_get_type(ntvfs->private_data,
641 struct pvfs_state);
642 struct pvfs_filename *name;
643 struct pvfs_filename newstats;
644 NTSTATUS status;
645 uint32_t access_needed;
646 uint32_t change_mask = 0;
647 struct odb_lock *lck = NULL;
648 DATA_BLOB odb_locking_key;
649
650 /* resolve the cifs name to a posix name */
651 status = pvfs_resolve_name(pvfs, req, info->generic.in.file.path,
652 PVFS_RESOLVE_STREAMS, &name);
653 if (!NT_STATUS_IS_OK(status)) {
654 return status;
655 }
656
657 if (!name->exists) {
658 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
659 }
660
661 access_needed = pvfs_setfileinfo_access(info);
662 status = pvfs_access_check_simple(pvfs, req, name, access_needed);
663 if (!NT_STATUS_IS_OK(status)) {
664 return status;
665 }
666
667 /* we take a copy of the current file stats, then update
668 newstats in each of the elements below. At the end we
669 compare, and make any changes needed */
670 newstats = *name;
671
672 switch (info->generic.level) {
673 case RAW_SFILEINFO_SETATTR:
674 if (!null_time(info->setattr.in.write_time)) {
675 unix_to_nt_time(&newstats.dos.write_time, info->setattr.in.write_time);
676 }
677 if (info->setattr.in.attrib == 0) {
678 newstats.dos.attrib = FILE_ATTRIBUTE_NORMAL;
679 } else if (info->setattr.in.attrib != FILE_ATTRIBUTE_NORMAL) {
680 newstats.dos.attrib = info->setattr.in.attrib;
681 }
682 break;
683
684 case RAW_SFILEINFO_SETATTRE:
685 case RAW_SFILEINFO_STANDARD:
686 if (!null_time(info->setattre.in.create_time)) {
687 unix_to_nt_time(&newstats.dos.create_time, info->setattre.in.create_time);
688 }
689 if (!null_time(info->setattre.in.access_time)) {
690 unix_to_nt_time(&newstats.dos.access_time, info->setattre.in.access_time);
691 }
692 if (!null_time(info->setattre.in.write_time)) {
693 unix_to_nt_time(&newstats.dos.write_time, info->setattre.in.write_time);
694 }
695 break;
696
697 case RAW_SFILEINFO_EA_SET:
698 return pvfs_setfileinfo_ea_set(pvfs, name, -1,
699 info->ea_set.in.num_eas,
700 info->ea_set.in.eas);
701
702 case RAW_SFILEINFO_BASIC_INFO:
703 case RAW_SFILEINFO_BASIC_INFORMATION:
704 if (!null_nttime(info->basic_info.in.create_time)) {
705 newstats.dos.create_time = info->basic_info.in.create_time;
706 }
707 if (!null_nttime(info->basic_info.in.access_time)) {
708 newstats.dos.access_time = info->basic_info.in.access_time;
709 }
710 if (!null_nttime(info->basic_info.in.write_time)) {
711 newstats.dos.write_time = info->basic_info.in.write_time;
712 }
713 if (!null_nttime(info->basic_info.in.change_time)) {
714 newstats.dos.change_time = info->basic_info.in.change_time;
715 }
716 if (info->basic_info.in.attrib != 0) {
717 newstats.dos.attrib = info->basic_info.in.attrib;
718 }
719 break;
720
721 case RAW_SFILEINFO_ALLOCATION_INFO:
722 case RAW_SFILEINFO_ALLOCATION_INFORMATION:
723 status = pvfs_can_update_file_size(pvfs, req, name, &lck);
724 /*
725 * on a sharing violation we need to retry when the file is closed by
726 * the other user, or after 1 second
727 * on a non granted oplock we need to retry when the file is closed by
728 * the other user, or after 30 seconds
729 */
730 if ((NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION) ||
731 NT_STATUS_EQUAL(status, NT_STATUS_OPLOCK_NOT_GRANTED)) &&
732 (req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
733 return pvfs_setpathinfo_setup_retry(pvfs->ntvfs, req, info, lck, status);
734 }
735 NT_STATUS_NOT_OK_RETURN(status);
736
737 if (info->allocation_info.in.alloc_size > newstats.dos.alloc_size) {
738 /* strange. Increasing the allocation size via setpathinfo
739 should be silently ignored */
740 break;
741 }
742 newstats.dos.alloc_size = info->allocation_info.in.alloc_size;
743 if (newstats.dos.alloc_size < newstats.st.st_size) {
744 newstats.st.st_size = newstats.dos.alloc_size;
745 }
746 newstats.dos.alloc_size = pvfs_round_alloc_size(pvfs,
747 newstats.dos.alloc_size);
748 break;
749
750 case RAW_SFILEINFO_END_OF_FILE_INFO:
751 case RAW_SFILEINFO_END_OF_FILE_INFORMATION:
752 status = pvfs_can_update_file_size(pvfs, req, name, &lck);
753 /*
754 * on a sharing violation we need to retry when the file is closed by
755 * the other user, or after 1 second
756 * on a non granted oplock we need to retry when the file is closed by
757 * the other user, or after 30 seconds
758 */
759 if ((NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION) ||
760 NT_STATUS_EQUAL(status, NT_STATUS_OPLOCK_NOT_GRANTED)) &&
761 (req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
762 return pvfs_setpathinfo_setup_retry(pvfs->ntvfs, req, info, lck, status);
763 }
764 NT_STATUS_NOT_OK_RETURN(status);
765
766 newstats.st.st_size = info->end_of_file_info.in.size;
767 break;
768
769 case RAW_SFILEINFO_MODE_INFORMATION:
770 if (info->mode_information.in.mode != 0 &&
771 info->mode_information.in.mode != 2 &&
772 info->mode_information.in.mode != 4 &&
773 info->mode_information.in.mode != 6) {
774 return NT_STATUS_INVALID_PARAMETER;
775 }
776 return NT_STATUS_OK;
777
778 case RAW_SFILEINFO_RENAME_INFORMATION:
779 case RAW_SFILEINFO_RENAME_INFORMATION_SMB2:
780 status = pvfs_locking_key(name, name, &odb_locking_key);
781 NT_STATUS_NOT_OK_RETURN(status);
782 status = pvfs_setfileinfo_rename(pvfs, req, name, -1,
783 &odb_locking_key, info);
784 NT_STATUS_NOT_OK_RETURN(status);
785 return NT_STATUS_OK;
786
787 case RAW_SFILEINFO_DISPOSITION_INFO:
788 case RAW_SFILEINFO_DISPOSITION_INFORMATION:
789 case RAW_SFILEINFO_POSITION_INFORMATION:
790 return NT_STATUS_OK;
791
792 default:
793 return NT_STATUS_INVALID_LEVEL;
794 }
795
796 /* possibly change the file size */
797 if (newstats.st.st_size != name->st.st_size) {
798 if (name->stream_name) {
799 status = pvfs_stream_truncate(pvfs, name, -1, newstats.st.st_size);
800 if (!NT_STATUS_IS_OK(status)) {
801 return status;
802 }
803 } else if (truncate(name->full_name, newstats.st.st_size) == -1) {
804 return pvfs_map_errno(pvfs, errno);
805 }
806 change_mask |= FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_ATTRIBUTES;
807 }
808
809 /* possibly change the file timestamps */
810 if (newstats.dos.create_time != name->dos.create_time) {
811 change_mask |= FILE_NOTIFY_CHANGE_CREATION;
812 }
813 if (newstats.dos.access_time != name->dos.access_time) {
814 change_mask |= FILE_NOTIFY_CHANGE_LAST_ACCESS;
815 }
816 if (newstats.dos.write_time != name->dos.write_time) {
817 change_mask |= FILE_NOTIFY_CHANGE_LAST_WRITE;
818 }
819 if ((change_mask & FILE_NOTIFY_CHANGE_LAST_ACCESS) ||
820 (change_mask & FILE_NOTIFY_CHANGE_LAST_WRITE)) {
821 struct timeval tv[2];
822
823 nttime_to_timeval(&tv[0], newstats.dos.access_time);
824 nttime_to_timeval(&tv[1], newstats.dos.write_time);
825
826 if (!timeval_is_zero(&tv[0]) || !timeval_is_zero(&tv[1])) {
827 if (utimes(name->full_name, tv) == -1) {
828 DEBUG(0,("pvfs_setpathinfo: utimes() failed '%s' - %s\n",
829 name->full_name, strerror(errno)));
830 return pvfs_map_errno(pvfs, errno);
831 }
832 }
833 }
834 if (change_mask & FILE_NOTIFY_CHANGE_LAST_WRITE) {
835 if (lck == NULL) {
836 DATA_BLOB lkey;
837 status = pvfs_locking_key(name, name, &lkey);
838 NT_STATUS_NOT_OK_RETURN(status);
839
840 lck = odb_lock(req, pvfs->odb_context, &lkey);
841 data_blob_free(&lkey);
842 if (lck == NULL) {
843 DEBUG(0,("Unable to lock opendb for write time update\n"));
844 return NT_STATUS_INTERNAL_ERROR;
845 }
846 }
847
848 status = odb_set_write_time(lck, newstats.dos.write_time, true);
849 if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
850 /* it could be that nobody has opened the file */
851 } else if (!NT_STATUS_IS_OK(status)) {
852 DEBUG(0,("Unable to update write time: %s\n",
853 nt_errstr(status)));
854 return status;
855 }
856 }
857
858 /* possibly change the attribute */
859 newstats.dos.attrib |= (name->dos.attrib & FILE_ATTRIBUTE_DIRECTORY);
860 if (newstats.dos.attrib != name->dos.attrib) {
861 mode_t mode = pvfs_fileperms(pvfs, newstats.dos.attrib);
862 if (pvfs_sys_chmod(pvfs, name->full_name, mode, name->allow_override) == -1) {
863 return pvfs_map_errno(pvfs, errno);
864 }
865 change_mask |= FILE_NOTIFY_CHANGE_ATTRIBUTES;
866 }
867
868 *name = newstats;
869
870 if (change_mask != 0) {
871 notify_trigger(pvfs->notify_context,
872 NOTIFY_ACTION_MODIFIED,
873 change_mask,
874 name->full_name);
875 }
876
877 return pvfs_dosattrib_save(pvfs, name, -1);
878 }
879
reg import