?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
negoex.idl: use DATA_BLOB for negoex_BYTE_VECTOR
[Samba.git] / source3 / smbd / dosmode.c
blob099600793203b4de978fde039cc21a5c4c258226
1 /*
2 Unix SMB/CIFS implementation.
3 dos mode handling functions
4 Copyright (C) Andrew Tridgell 1992-1998
5 Copyright (C) James Peach 2006
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "includes.h"
22 #include "system/filesys.h"
23 #include "librpc/gen_ndr/ndr_xattr.h"
24 #include "librpc/gen_ndr/ioctl.h"
25 #include "../libcli/security/security.h"
26 #include "smbd/smbd.h"
27 #include "lib/param/loadparm.h"
28
29 static NTSTATUS get_file_handle_for_metadata(connection_struct *conn,
30 struct smb_filename *smb_fname,
31 files_struct **ret_fsp,
32 bool *need_close);
33
34 static void dos_mode_debug_print(const char *func, uint32_t mode)
35 {
36 fstring modestr;
37
38 if (DEBUGLEVEL < DBGLVL_INFO) {
39 return;
40 }
41
42 modestr[0] = '\0';
43
44 if (mode & FILE_ATTRIBUTE_HIDDEN) {
45 fstrcat(modestr, "h");
46 }
47 if (mode & FILE_ATTRIBUTE_READONLY) {
48 fstrcat(modestr, "r");
49 }
50 if (mode & FILE_ATTRIBUTE_SYSTEM) {
51 fstrcat(modestr, "s");
52 }
53 if (mode & FILE_ATTRIBUTE_DIRECTORY) {
54 fstrcat(modestr, "d");
55 }
56 if (mode & FILE_ATTRIBUTE_ARCHIVE) {
57 fstrcat(modestr, "a");
58 }
59 if (mode & FILE_ATTRIBUTE_SPARSE) {
60 fstrcat(modestr, "[sparse]");
61 }
62 if (mode & FILE_ATTRIBUTE_OFFLINE) {
63 fstrcat(modestr, "[offline]");
64 }
65 if (mode & FILE_ATTRIBUTE_COMPRESSED) {
66 fstrcat(modestr, "[compressed]");
67 }
68
69 DBG_INFO("%s returning (0x%x): \"%s\"\n", func, (unsigned)mode,
70 modestr);
71 }
72
73 static uint32_t filter_mode_by_protocol(uint32_t mode)
74 {
75 if (get_Protocol() <= PROTOCOL_LANMAN2) {
76 DEBUG(10,("filter_mode_by_protocol: "
77 "filtering result 0x%x to 0x%x\n",
78 (unsigned int)mode,
79 (unsigned int)(mode & 0x3f) ));
80 mode &= 0x3f;
81 }
82 return mode;
83 }
84
85 static int set_link_read_only_flag(const SMB_STRUCT_STAT *const sbuf)
86 {
87 #ifdef S_ISLNK
88 #if LINKS_READ_ONLY
89 if (S_ISLNK(sbuf->st_mode) && S_ISDIR(sbuf->st_mode))
90 return FILE_ATTRIBUTE_READONLY;
91 #endif
92 #endif
93 return 0;
94 }
95
96 /****************************************************************************
97 Change a dos mode to a unix mode.
98 Base permission for files:
99 if creating file and inheriting (i.e. parent_dir != NULL)
100 apply read/write bits from parent directory.
101 else
102 everybody gets read bit set
103 dos readonly is represented in unix by removing everyone's write bit
104 dos archive is represented in unix by the user's execute bit
105 dos system is represented in unix by the group's execute bit
106 dos hidden is represented in unix by the other's execute bit
107 if !inheriting {
108 Then apply create mask,
109 then add force bits.
110 }
111 Base permission for directories:
112 dos directory is represented in unix by unix's dir bit and the exec bit
113 if !inheriting {
114 Then apply create mask,
115 then add force bits.
116 }
117 ****************************************************************************/
118
119 mode_t unix_mode(connection_struct *conn, int dosmode,
120 const struct smb_filename *smb_fname,
121 const char *inherit_from_dir)
122 {
123 mode_t result = (S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR | S_IWGRP | S_IWOTH);
124 mode_t dir_mode = 0; /* Mode of the inherit_from directory if
125 * inheriting. */
126
127 if (!lp_store_dos_attributes(SNUM(conn)) && IS_DOS_READONLY(dosmode)) {
128 result &= ~(S_IWUSR | S_IWGRP | S_IWOTH);
129 }
130
131 if ((inherit_from_dir != NULL) && lp_inherit_permissions(SNUM(conn))) {
132 struct smb_filename *smb_fname_parent;
133
134 DEBUG(2, ("unix_mode(%s) inheriting from %s\n",
135 smb_fname_str_dbg(smb_fname),
136 inherit_from_dir));
137
138 smb_fname_parent = synthetic_smb_fname(
139 talloc_tos(), inherit_from_dir, NULL, NULL);
140 if (smb_fname_parent == NULL) {
141 DEBUG(1,("unix_mode(%s) failed, [dir %s]: No memory\n",
142 smb_fname_str_dbg(smb_fname),
143 inherit_from_dir));
144 return(0);
145 }
146
147 if (SMB_VFS_STAT(conn, smb_fname_parent) != 0) {
148 DEBUG(4,("unix_mode(%s) failed, [dir %s]: %s\n",
149 smb_fname_str_dbg(smb_fname),
150 inherit_from_dir, strerror(errno)));
151 TALLOC_FREE(smb_fname_parent);
152 return(0); /* *** shouldn't happen! *** */
153 }
154
155 /* Save for later - but explicitly remove setuid bit for safety. */
156 dir_mode = smb_fname_parent->st.st_ex_mode & ~S_ISUID;
157 DEBUG(2,("unix_mode(%s) inherit mode %o\n",
158 smb_fname_str_dbg(smb_fname), (int)dir_mode));
159 /* Clear "result" */
160 result = 0;
161 TALLOC_FREE(smb_fname_parent);
162 }
163
164 if (IS_DOS_DIR(dosmode)) {
165 /* We never make directories read only for the owner as under DOS a user
166 can always create a file in a read-only directory. */
167 result |= (S_IFDIR | S_IWUSR);
168
169 if (dir_mode) {
170 /* Inherit mode of parent directory. */
171 result |= dir_mode;
172 } else {
173 /* Provisionally add all 'x' bits */
174 result |= (S_IXUSR | S_IXGRP | S_IXOTH);
175
176 /* Apply directory mask */
177 result &= lp_directory_mask(SNUM(conn));
178 /* Add in force bits */
179 result |= lp_force_directory_mode(SNUM(conn));
180 }
181 } else {
182 if (lp_map_archive(SNUM(conn)) && IS_DOS_ARCHIVE(dosmode))
183 result |= S_IXUSR;
184
185 if (lp_map_system(SNUM(conn)) && IS_DOS_SYSTEM(dosmode))
186 result |= S_IXGRP;
187
188 if (lp_map_hidden(SNUM(conn)) && IS_DOS_HIDDEN(dosmode))
189 result |= S_IXOTH;
190
191 if (dir_mode) {
192 /* Inherit 666 component of parent directory mode */
193 result |= dir_mode & (S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR | S_IWGRP | S_IWOTH);
194 } else {
195 /* Apply mode mask */
196 result &= lp_create_mask(SNUM(conn));
197 /* Add in force bits */
198 result |= lp_force_create_mode(SNUM(conn));
199 }
200 }
201
202 DBG_INFO("unix_mode(%s) returning 0%o\n",
203 smb_fname_str_dbg(smb_fname), (int)result);
204
205 return(result);
206 }
207
208 /****************************************************************************
209 Change a unix mode to a dos mode.
210 ****************************************************************************/
211
212 static uint32_t dos_mode_from_sbuf(connection_struct *conn,
213 const struct smb_filename *smb_fname)
214 {
215 int result = 0;
216 enum mapreadonly_options ro_opts = (enum mapreadonly_options)lp_map_readonly(SNUM(conn));
217
218 #if defined(UF_IMMUTABLE) && defined(SF_IMMUTABLE)
219 /* if we can find out if a file is immutable we should report it r/o */
220 if (smb_fname->st.st_ex_flags & (UF_IMMUTABLE | SF_IMMUTABLE)) {
221 result |= FILE_ATTRIBUTE_READONLY;
222 }
223 #endif
224 if (ro_opts == MAP_READONLY_YES) {
225 /* Original Samba method - map inverse of user "w" bit. */
226 if ((smb_fname->st.st_ex_mode & S_IWUSR) == 0) {
227 result |= FILE_ATTRIBUTE_READONLY;
228 }
229 } else if (ro_opts == MAP_READONLY_PERMISSIONS) {
230 /* Check actual permissions for read-only. */
231 if (!can_write_to_file(conn, smb_fname)) {
232 result |= FILE_ATTRIBUTE_READONLY;
233 }
234 } /* Else never set the readonly bit. */
235
236 if (MAP_ARCHIVE(conn) && ((smb_fname->st.st_ex_mode & S_IXUSR) != 0))
237 result |= FILE_ATTRIBUTE_ARCHIVE;
238
239 if (MAP_SYSTEM(conn) && ((smb_fname->st.st_ex_mode & S_IXGRP) != 0))
240 result |= FILE_ATTRIBUTE_SYSTEM;
241
242 if (MAP_HIDDEN(conn) && ((smb_fname->st.st_ex_mode & S_IXOTH) != 0))
243 result |= FILE_ATTRIBUTE_HIDDEN;
244
245 if (S_ISDIR(smb_fname->st.st_ex_mode))
246 result = FILE_ATTRIBUTE_DIRECTORY | (result & FILE_ATTRIBUTE_READONLY);
247
248 result |= set_link_read_only_flag(&smb_fname->st);
249
250 dos_mode_debug_print(__func__, result);
251
252 return result;
253 }
254
255 /****************************************************************************
256 Get DOS attributes from an EA.
257 This can also pull the create time into the stat struct inside smb_fname.
258 ****************************************************************************/
259
260 static bool get_ea_dos_attribute(connection_struct *conn,
261 struct smb_filename *smb_fname,
262 uint32_t *pattr)
263 {
264 struct xattr_DOSATTRIB dosattrib;
265 enum ndr_err_code ndr_err;
266 DATA_BLOB blob;
267 ssize_t sizeret;
268 fstring attrstr;
269 uint32_t dosattr;
270
271 if (!lp_store_dos_attributes(SNUM(conn))) {
272 return False;
273 }
274
275 /* Don't reset pattr to zero as we may already have filename-based attributes we
276 need to preserve. */
277
278 sizeret = SMB_VFS_GETXATTR(conn, smb_fname->base_name,
279 SAMBA_XATTR_DOS_ATTRIB, attrstr,
280 sizeof(attrstr));
281 if (sizeret == -1) {
282 if (errno == ENOSYS
283 #if defined(ENOTSUP)
284 || errno == ENOTSUP) {
285 #else
286 ) {
287 #endif
288 DEBUG(1,("get_ea_dos_attribute: Cannot get attribute "
289 "from EA on file %s: Error = %s\n",
290 smb_fname_str_dbg(smb_fname),
291 strerror(errno)));
292 set_store_dos_attributes(SNUM(conn), False);
293 }
294 return False;
295 }
296
297 blob.data = (uint8_t *)attrstr;
298 blob.length = sizeret;
299
300 ndr_err = ndr_pull_struct_blob(&blob, talloc_tos(), &dosattrib,
301 (ndr_pull_flags_fn_t)ndr_pull_xattr_DOSATTRIB);
302
303 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
304 DEBUG(1,("get_ea_dos_attribute: bad ndr decode "
305 "from EA on file %s: Error = %s\n",
306 smb_fname_str_dbg(smb_fname),
307 ndr_errstr(ndr_err)));
308 return false;
309 }
310
311 DEBUG(10,("get_ea_dos_attribute: %s attr = %s\n",
312 smb_fname_str_dbg(smb_fname), dosattrib.attrib_hex));
313
314 switch (dosattrib.version) {
315 case 0xFFFF:
316 dosattr = dosattrib.info.compatinfoFFFF.attrib;
317 break;
318 case 1:
319 dosattr = dosattrib.info.info1.attrib;
320 if (!null_nttime(dosattrib.info.info1.create_time)) {
321 struct timespec create_time =
322 nt_time_to_unix_timespec(
323 dosattrib.info.info1.create_time);
324
325 update_stat_ex_create_time(&smb_fname->st,
326 create_time);
327
328 DEBUG(10,("get_ea_dos_attribute: file %s case 1 "
329 "set btime %s\n",
330 smb_fname_str_dbg(smb_fname),
331 time_to_asc(convert_timespec_to_time_t(
332 create_time)) ));
333 }
334 break;
335 case 2:
336 dosattr = dosattrib.info.oldinfo2.attrib;
337 /* Don't know what flags to check for this case. */
338 break;
339 case 3:
340 dosattr = dosattrib.info.info3.attrib;
341 if ((dosattrib.info.info3.valid_flags & XATTR_DOSINFO_CREATE_TIME) &&
342 !null_nttime(dosattrib.info.info3.create_time)) {
343 struct timespec create_time =
344 nt_time_to_unix_timespec(
345 dosattrib.info.info3.create_time);
346
347 update_stat_ex_create_time(&smb_fname->st,
348 create_time);
349
350 DEBUG(10,("get_ea_dos_attribute: file %s case 3 "
351 "set btime %s\n",
352 smb_fname_str_dbg(smb_fname),
353 time_to_asc(convert_timespec_to_time_t(
354 create_time)) ));
355 }
356 break;
357 default:
358 DEBUG(1,("get_ea_dos_attribute: Badly formed DOSATTRIB on "
359 "file %s - %s\n", smb_fname_str_dbg(smb_fname),
360 attrstr));
361 return false;
362 }
363
364 if (S_ISDIR(smb_fname->st.st_ex_mode)) {
365 dosattr |= FILE_ATTRIBUTE_DIRECTORY;
366 }
367 /* FILE_ATTRIBUTE_SPARSE is valid on get but not on set. */
368 *pattr |= (uint32_t)(dosattr & (SAMBA_ATTRIBUTES_MASK|FILE_ATTRIBUTE_SPARSE));
369
370 dos_mode_debug_print(__func__, *pattr);
371
372 return True;
373 }
374
375 /****************************************************************************
376 Set DOS attributes in an EA.
377 Also sets the create time.
378 ****************************************************************************/
379
380 static bool set_ea_dos_attribute(connection_struct *conn,
381 struct smb_filename *smb_fname,
382 uint32_t dosmode)
383 {
384 struct xattr_DOSATTRIB dosattrib;
385 enum ndr_err_code ndr_err;
386 DATA_BLOB blob;
387
388 ZERO_STRUCT(dosattrib);
389 ZERO_STRUCT(blob);
390
391 dosattrib.version = 3;
392 dosattrib.info.info3.valid_flags = XATTR_DOSINFO_ATTRIB|
393 XATTR_DOSINFO_CREATE_TIME;
394 dosattrib.info.info3.attrib = dosmode;
395 dosattrib.info.info3.create_time = unix_timespec_to_nt_time(
396 smb_fname->st.st_ex_btime);
397
398 DEBUG(10,("set_ea_dos_attributes: set attribute 0x%x, btime = %s on file %s\n",
399 (unsigned int)dosmode,
400 time_to_asc(convert_timespec_to_time_t(smb_fname->st.st_ex_btime)),
401 smb_fname_str_dbg(smb_fname) ));
402
403 ndr_err = ndr_push_struct_blob(
404 &blob, talloc_tos(), &dosattrib,
405 (ndr_push_flags_fn_t)ndr_push_xattr_DOSATTRIB);
406
407 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
408 DEBUG(5, ("create_acl_blob: ndr_push_xattr_DOSATTRIB failed: %s\n",
409 ndr_errstr(ndr_err)));
410 return false;
411 }
412
413 if (blob.data == NULL || blob.length == 0) {
414 return false;
415 }
416
417 if (SMB_VFS_SETXATTR(conn, smb_fname->base_name,
418 SAMBA_XATTR_DOS_ATTRIB, blob.data, blob.length,
419 0) == -1) {
420 bool ret = false;
421 bool need_close = false;
422 files_struct *fsp = NULL;
423
424 if((errno != EPERM) && (errno != EACCES)) {
425 if (errno == ENOSYS
426 #if defined(ENOTSUP)
427 || errno == ENOTSUP) {
428 #else
429 ) {
430 #endif
431 DEBUG(1,("set_ea_dos_attributes: Cannot set "
432 "attribute EA on file %s: Error = %s\n",
433 smb_fname_str_dbg(smb_fname),
434 strerror(errno) ));
435 set_store_dos_attributes(SNUM(conn), False);
436 }
437 return false;
438 }
439
440 /* We want DOS semantics, ie allow non owner with write permission to change the
441 bits on a file. Just like file_ntimes below.
442 */
443
444 /* Check if we have write access. */
445 if(!CAN_WRITE(conn) || !lp_dos_filemode(SNUM(conn)))
446 return false;
447
448 if (!can_write_to_file(conn, smb_fname)) {
449 return false;
450 }
451
452 /*
453 * We need to get an open file handle to do the
454 * metadata operation under root.
455 */
456
457 if (!NT_STATUS_IS_OK(get_file_handle_for_metadata(conn,
458 smb_fname,
459 &fsp,
460 &need_close))) {
461 return false;
462 }
463
464 become_root();
465 if (SMB_VFS_FSETXATTR(fsp,
466 SAMBA_XATTR_DOS_ATTRIB, blob.data,
467 blob.length, 0) == 0) {
468 ret = true;
469 }
470 unbecome_root();
471 if (need_close) {
472 close_file(NULL, fsp, NORMAL_CLOSE);
473 }
474 return ret;
475 }
476 DEBUG(10,("set_ea_dos_attribute: set EA 0x%x on file %s\n",
477 (unsigned int)dosmode,
478 smb_fname_str_dbg(smb_fname)));
479 return true;
480 }
481
482 /****************************************************************************
483 Change a unix mode to a dos mode for an ms dfs link.
484 ****************************************************************************/
485
486 uint32_t dos_mode_msdfs(connection_struct *conn,
487 const struct smb_filename *smb_fname)
488 {
489 uint32_t result = 0;
490
491 DEBUG(8,("dos_mode_msdfs: %s\n", smb_fname_str_dbg(smb_fname)));
492
493 if (!VALID_STAT(smb_fname->st)) {
494 return 0;
495 }
496
497 /* First do any modifications that depend on the path name. */
498 /* hide files with a name starting with a . */
499 if (lp_hide_dot_files(SNUM(conn))) {
500 const char *p = strrchr_m(smb_fname->base_name, '/');
501 if (p) {
502 p++;
503 } else {
504 p = smb_fname->base_name;
505 }
506
507 /* Only . and .. are not hidden. */
508 if (p[0] == '.' && !((p[1] == '\0') ||
509 (p[1] == '.' && p[2] == '\0'))) {
510 result |= FILE_ATTRIBUTE_HIDDEN;
511 }
512 }
513
514 result |= dos_mode_from_sbuf(conn, smb_fname);
515
516 /* Optimization : Only call is_hidden_path if it's not already
517 hidden. */
518 if (!(result & FILE_ATTRIBUTE_HIDDEN) &&
519 IS_HIDDEN_PATH(conn, smb_fname->base_name)) {
520 result |= FILE_ATTRIBUTE_HIDDEN;
521 }
522
523 if (result == 0) {
524 result = FILE_ATTRIBUTE_NORMAL;
525 }
526
527 result = filter_mode_by_protocol(result);
528
529 /*
530 * Add in that it is a reparse point
531 */
532 result |= FILE_ATTRIBUTE_REPARSE_POINT;
533
534 dos_mode_debug_print(__func__, result);
535
536 return(result);
537 }
538
539 /*
540 * check whether a file or directory is flagged as compressed.
541 */
542 static NTSTATUS dos_mode_check_compressed(connection_struct *conn,
543 struct smb_filename *smb_fname,
544 bool *is_compressed)
545 {
546 NTSTATUS status;
547 uint16_t compression_fmt;
548 TALLOC_CTX *tmp_ctx = talloc_new(NULL);
549 if (tmp_ctx == NULL) {
550 status = NT_STATUS_NO_MEMORY;
551 goto err_out;
552 }
553
554 status = SMB_VFS_GET_COMPRESSION(conn, tmp_ctx, NULL, smb_fname,
555 &compression_fmt);
556 if (!NT_STATUS_IS_OK(status)) {
557 goto err_ctx_free;
558 }
559
560 if (compression_fmt == COMPRESSION_FORMAT_LZNT1) {
561 *is_compressed = true;
562 } else {
563 *is_compressed = false;
564 }
565 status = NT_STATUS_OK;
566
567 err_ctx_free:
568 talloc_free(tmp_ctx);
569 err_out:
570 return status;
571 }
572
573 /****************************************************************************
574 Change a unix mode to a dos mode.
575 May also read the create timespec into the stat struct in smb_fname
576 if "store dos attributes" is true.
577 ****************************************************************************/
578
579 uint32_t dos_mode(connection_struct *conn, struct smb_filename *smb_fname)
580 {
581 uint32_t result = 0;
582 bool offline;
583
584 DEBUG(8,("dos_mode: %s\n", smb_fname_str_dbg(smb_fname)));
585
586 if (!VALID_STAT(smb_fname->st)) {
587 return 0;
588 }
589
590 /* First do any modifications that depend on the path name. */
591 /* hide files with a name starting with a . */
592 if (lp_hide_dot_files(SNUM(conn))) {
593 const char *p = strrchr_m(smb_fname->base_name,'/');
594 if (p) {
595 p++;
596 } else {
597 p = smb_fname->base_name;
598 }
599
600 /* Only . and .. are not hidden. */
601 if (p[0] == '.' && !((p[1] == '\0') ||
602 (p[1] == '.' && p[2] == '\0'))) {
603 result |= FILE_ATTRIBUTE_HIDDEN;
604 }
605 }
606
607 /* Get the DOS attributes from an EA by preference. */
608 if (!get_ea_dos_attribute(conn, smb_fname, &result)) {
609 result |= dos_mode_from_sbuf(conn, smb_fname);
610 }
611
612 offline = SMB_VFS_IS_OFFLINE(conn, smb_fname, &smb_fname->st);
613 if (S_ISREG(smb_fname->st.st_ex_mode) && offline) {
614 result |= FILE_ATTRIBUTE_OFFLINE;
615 }
616
617 if (conn->fs_capabilities & FILE_FILE_COMPRESSION) {
618 bool compressed = false;
619 NTSTATUS status = dos_mode_check_compressed(conn, smb_fname,
620 &compressed);
621 if (NT_STATUS_IS_OK(status) && compressed) {
622 result |= FILE_ATTRIBUTE_COMPRESSED;
623 }
624 }
625
626 /* Optimization : Only call is_hidden_path if it's not already
627 hidden. */
628 if (!(result & FILE_ATTRIBUTE_HIDDEN) &&
629 IS_HIDDEN_PATH(conn, smb_fname->base_name)) {
630 result |= FILE_ATTRIBUTE_HIDDEN;
631 }
632
633 if (result == 0) {
634 result = FILE_ATTRIBUTE_NORMAL;
635 }
636
637 result = filter_mode_by_protocol(result);
638
639 dos_mode_debug_print(__func__, result);
640
641 return result;
642 }
643
644 /*******************************************************************
645 chmod a file - but preserve some bits.
646 If "store dos attributes" is also set it will store the create time
647 from the stat struct in smb_fname (in NTTIME format) in the EA
648 attribute also.
649 ********************************************************************/
650
651 int file_set_dosmode(connection_struct *conn, struct smb_filename *smb_fname,
652 uint32_t dosmode, const char *parent_dir, bool newfile)
653 {
654 int mask=0;
655 mode_t tmp;
656 mode_t unixmode;
657 int ret = -1, lret = -1;
658 uint32_t old_mode;
659 struct timespec new_create_timespec;
660 files_struct *fsp = NULL;
661 bool need_close = false;
662 NTSTATUS status;
663
664 if (!CAN_WRITE(conn)) {
665 errno = EROFS;
666 return -1;
667 }
668
669 /* We only allow READONLY|HIDDEN|SYSTEM|DIRECTORY|ARCHIVE here. */
670 dosmode &= (SAMBA_ATTRIBUTES_MASK | FILE_ATTRIBUTE_OFFLINE);
671
672 DEBUG(10,("file_set_dosmode: setting dos mode 0x%x on file %s\n",
673 dosmode, smb_fname_str_dbg(smb_fname)));
674
675 unixmode = smb_fname->st.st_ex_mode;
676
677 get_acl_group_bits(conn, smb_fname->base_name,
678 &smb_fname->st.st_ex_mode);
679
680 if (S_ISDIR(smb_fname->st.st_ex_mode))
681 dosmode |= FILE_ATTRIBUTE_DIRECTORY;
682 else
683 dosmode &= ~FILE_ATTRIBUTE_DIRECTORY;
684
685 new_create_timespec = smb_fname->st.st_ex_btime;
686
687 old_mode = dos_mode(conn, smb_fname);
688
689 if ((dosmode & FILE_ATTRIBUTE_OFFLINE) &&
690 !(old_mode & FILE_ATTRIBUTE_OFFLINE)) {
691 lret = SMB_VFS_SET_OFFLINE(conn, smb_fname);
692 if (lret == -1) {
693 if (errno == ENOTSUP) {
694 DEBUG(10, ("Setting FILE_ATTRIBUTE_OFFLINE for "
695 "%s/%s is not supported.\n",
696 parent_dir,
697 smb_fname_str_dbg(smb_fname)));
698 } else {
699 DEBUG(0, ("An error occurred while setting "
700 "FILE_ATTRIBUTE_OFFLINE for "
701 "%s/%s: %s", parent_dir,
702 smb_fname_str_dbg(smb_fname),
703 strerror(errno)));
704 }
705 }
706 }
707
708 dosmode &= ~FILE_ATTRIBUTE_OFFLINE;
709 old_mode &= ~FILE_ATTRIBUTE_OFFLINE;
710
711 smb_fname->st.st_ex_btime = new_create_timespec;
712
713 /* Store the DOS attributes in an EA by preference. */
714 if (lp_store_dos_attributes(SNUM(conn))) {
715 /*
716 * Don't fall back to using UNIX modes. Finally
717 * follow the smb.conf manpage.
718 */
719 if (!set_ea_dos_attribute(conn, smb_fname, dosmode)) {
720 return -1;
721 }
722 if (!newfile) {
723 notify_fname(conn, NOTIFY_ACTION_MODIFIED,
724 FILE_NOTIFY_CHANGE_ATTRIBUTES,
725 smb_fname->base_name);
726 }
727 smb_fname->st.st_ex_mode = unixmode;
728 return 0;
729 }
730
731 unixmode = unix_mode(conn, dosmode, smb_fname, parent_dir);
732
733 /* preserve the file type bits */
734 mask |= S_IFMT;
735
736 /* preserve the s bits */
737 mask |= (S_ISUID | S_ISGID);
738
739 /* preserve the t bit */
740 #ifdef S_ISVTX
741 mask |= S_ISVTX;
742 #endif
743
744 /* possibly preserve the x bits */
745 if (!MAP_ARCHIVE(conn))
746 mask |= S_IXUSR;
747 if (!MAP_SYSTEM(conn))
748 mask |= S_IXGRP;
749 if (!MAP_HIDDEN(conn))
750 mask |= S_IXOTH;
751
752 unixmode |= (smb_fname->st.st_ex_mode & mask);
753
754 /* if we previously had any r bits set then leave them alone */
755 if ((tmp = smb_fname->st.st_ex_mode & (S_IRUSR|S_IRGRP|S_IROTH))) {
756 unixmode &= ~(S_IRUSR|S_IRGRP|S_IROTH);
757 unixmode |= tmp;
758 }
759
760 /* if we previously had any w bits set then leave them alone
761 whilst adding in the new w bits, if the new mode is not rdonly */
762 if (!IS_DOS_READONLY(dosmode)) {
763 unixmode |= (smb_fname->st.st_ex_mode & (S_IWUSR|S_IWGRP|S_IWOTH));
764 }
765
766 /*
767 * From the chmod 2 man page:
768 *
769 * "If the calling process is not privileged, and the group of the file
770 * does not match the effective group ID of the process or one of its
771 * supplementary group IDs, the S_ISGID bit will be turned off, but
772 * this will not cause an error to be returned."
773 *
774 * Simply refuse to do the chmod in this case.
775 */
776
777 if (S_ISDIR(smb_fname->st.st_ex_mode) && (unixmode & S_ISGID) &&
778 geteuid() != sec_initial_uid() &&
779 !current_user_in_group(conn, smb_fname->st.st_ex_gid)) {
780 DEBUG(3,("file_set_dosmode: setgid bit cannot be "
781 "set for directory %s\n",
782 smb_fname_str_dbg(smb_fname)));
783 errno = EPERM;
784 return -1;
785 }
786
787 ret = SMB_VFS_CHMOD(conn, smb_fname->base_name, unixmode);
788 if (ret == 0) {
789 if(!newfile || (lret != -1)) {
790 notify_fname(conn, NOTIFY_ACTION_MODIFIED,
791 FILE_NOTIFY_CHANGE_ATTRIBUTES,
792 smb_fname->base_name);
793 }
794 smb_fname->st.st_ex_mode = unixmode;
795 return 0;
796 }
797
798 if((errno != EPERM) && (errno != EACCES))
799 return -1;
800
801 if(!lp_dos_filemode(SNUM(conn)))
802 return -1;
803
804 /* We want DOS semantics, ie allow non owner with write permission to change the
805 bits on a file. Just like file_ntimes below.
806 */
807
808 if (!can_write_to_file(conn, smb_fname)) {
809 errno = EACCES;
810 return -1;
811 }
812
813 /*
814 * We need to get an open file handle to do the
815 * metadata operation under root.
816 */
817
818 status = get_file_handle_for_metadata(conn,
819 smb_fname,
820 &fsp,
821 &need_close);
822 if (!NT_STATUS_IS_OK(status)) {
823 errno = map_errno_from_nt_status(status);
824 return -1;
825 }
826
827 become_root();
828 ret = SMB_VFS_FCHMOD(fsp, unixmode);
829 unbecome_root();
830 if (need_close) {
831 close_file(NULL, fsp, NORMAL_CLOSE);
832 }
833 if (!newfile) {
834 notify_fname(conn, NOTIFY_ACTION_MODIFIED,
835 FILE_NOTIFY_CHANGE_ATTRIBUTES,
836 smb_fname->base_name);
837 }
838 if (ret == 0) {
839 smb_fname->st.st_ex_mode = unixmode;
840 }
841
842 return( ret );
843 }
844
845
846 NTSTATUS file_set_sparse(connection_struct *conn,
847 files_struct *fsp,
848 bool sparse)
849 {
850 uint32_t old_dosmode;
851 uint32_t new_dosmode;
852 NTSTATUS status;
853
854 if (!CAN_WRITE(conn)) {
855 DEBUG(9,("file_set_sparse: fname[%s] set[%u] "
856 "on readonly share[%s]\n",
857 smb_fname_str_dbg(fsp->fsp_name),
858 sparse,
859 lp_servicename(talloc_tos(), SNUM(conn))));
860 return NT_STATUS_MEDIA_WRITE_PROTECTED;
861 }
862
863 /*
864 * Windows Server 2008 & 2012 permit FSCTL_SET_SPARSE if any of the
865 * following access flags are granted.
866 */
867 if ((fsp->access_mask & (FILE_WRITE_DATA
868 | FILE_WRITE_ATTRIBUTES
869 | SEC_FILE_APPEND_DATA)) == 0) {
870 DEBUG(9,("file_set_sparse: fname[%s] set[%u] "
871 "access_mask[0x%08X] - access denied\n",
872 smb_fname_str_dbg(fsp->fsp_name),
873 sparse,
874 fsp->access_mask));
875 return NT_STATUS_ACCESS_DENIED;
876 }
877
878 if (fsp->is_directory) {
879 DEBUG(9, ("invalid attempt to %s sparse flag on dir %s\n",
880 (sparse ? "set" : "clear"),
881 smb_fname_str_dbg(fsp->fsp_name)));
882 return NT_STATUS_INVALID_PARAMETER;
883 }
884
885 if (IS_IPC(conn) || IS_PRINT(conn)) {
886 DEBUG(9, ("attempt to %s sparse flag over invalid conn\n",
887 (sparse ? "set" : "clear")));
888 return NT_STATUS_INVALID_PARAMETER;
889 }
890
891 DEBUG(10,("file_set_sparse: setting sparse bit %u on file %s\n",
892 sparse, smb_fname_str_dbg(fsp->fsp_name)));
893
894 if (!lp_store_dos_attributes(SNUM(conn))) {
895 return NT_STATUS_INVALID_DEVICE_REQUEST;
896 }
897
898 status = vfs_stat_fsp(fsp);
899 if (!NT_STATUS_IS_OK(status)) {
900 return status;
901 }
902
903 old_dosmode = dos_mode(conn, fsp->fsp_name);
904
905 if (sparse && !(old_dosmode & FILE_ATTRIBUTE_SPARSE)) {
906 new_dosmode = old_dosmode | FILE_ATTRIBUTE_SPARSE;
907 } else if (!sparse && (old_dosmode & FILE_ATTRIBUTE_SPARSE)) {
908 new_dosmode = old_dosmode & ~FILE_ATTRIBUTE_SPARSE;
909 } else {
910 return NT_STATUS_OK;
911 }
912
913 /* Store the DOS attributes in an EA. */
914 if (!set_ea_dos_attribute(conn, fsp->fsp_name,
915 new_dosmode)) {
916 if (errno == 0) {
917 errno = EIO;
918 }
919 return map_nt_error_from_unix(errno);
920 }
921
922 notify_fname(conn, NOTIFY_ACTION_MODIFIED,
923 FILE_NOTIFY_CHANGE_ATTRIBUTES,
924 fsp->fsp_name->base_name);
925
926 fsp->is_sparse = sparse;
927
928 return NT_STATUS_OK;
929 }
930
931 /*******************************************************************
932 Wrapper around the VFS ntimes that possibly allows DOS semantics rather
933 than POSIX.
934 *******************************************************************/
935
936 int file_ntimes(connection_struct *conn, const struct smb_filename *smb_fname,
937 struct smb_file_time *ft)
938 {
939 int ret = -1;
940
941 errno = 0;
942
943 DEBUG(6, ("file_ntime: actime: %s",
944 time_to_asc(convert_timespec_to_time_t(ft->atime))));
945 DEBUG(6, ("file_ntime: modtime: %s",
946 time_to_asc(convert_timespec_to_time_t(ft->mtime))));
947 DEBUG(6, ("file_ntime: ctime: %s",
948 time_to_asc(convert_timespec_to_time_t(ft->ctime))));
949 DEBUG(6, ("file_ntime: createtime: %s",
950 time_to_asc(convert_timespec_to_time_t(ft->create_time))));
951
952 /* Don't update the time on read-only shares */
953 /* We need this as set_filetime (which can be called on
954 close and other paths) can end up calling this function
955 without the NEED_WRITE protection. Found by :
956 Leo Weppelman <leo@wau.mis.ah.nl>
957 */
958
959 if (!CAN_WRITE(conn)) {
960 return 0;
961 }
962
963 if(SMB_VFS_NTIMES(conn, smb_fname, ft) == 0) {
964 return 0;
965 }
966
967 if((errno != EPERM) && (errno != EACCES)) {
968 return -1;
969 }
970
971 if(!lp_dos_filetimes(SNUM(conn))) {
972 return -1;
973 }
974
975 /* We have permission (given by the Samba admin) to
976 break POSIX semantics and allow a user to change
977 the time on a file they don't own but can write to
978 (as DOS does).
979 */
980
981 /* Check if we have write access. */
982 if (can_write_to_file(conn, smb_fname)) {
983 /* We are allowed to become root and change the filetime. */
984 become_root();
985 ret = SMB_VFS_NTIMES(conn, smb_fname, ft);
986 unbecome_root();
987 }
988
989 return ret;
990 }
991
992 /******************************************************************
993 Force a "sticky" write time on a pathname. This will always be
994 returned on all future write time queries and set on close.
995 ******************************************************************/
996
997 bool set_sticky_write_time_path(struct file_id fileid, struct timespec mtime)
998 {
999 if (null_timespec(mtime)) {
1000 return true;
1001 }
1002
1003 if (!set_sticky_write_time(fileid, mtime)) {
1004 return false;
1005 }
1006
1007 return true;
1008 }
1009
1010 /******************************************************************
1011 Force a "sticky" write time on an fsp. This will always be
1012 returned on all future write time queries and set on close.
1013 ******************************************************************/
1014
1015 bool set_sticky_write_time_fsp(struct files_struct *fsp, struct timespec mtime)
1016 {
1017 if (null_timespec(mtime)) {
1018 return true;
1019 }
1020
1021 fsp->write_time_forced = true;
1022 TALLOC_FREE(fsp->update_write_time_event);
1023
1024 return set_sticky_write_time_path(fsp->file_id, mtime);
1025 }
1026
1027 /******************************************************************
1028 Set a create time EA.
1029 ******************************************************************/
1030
1031 NTSTATUS set_create_timespec_ea(connection_struct *conn,
1032 const struct smb_filename *psmb_fname,
1033 struct timespec create_time)
1034 {
1035 struct smb_filename *smb_fname;
1036 uint32_t dosmode;
1037 int ret;
1038
1039 if (!lp_store_dos_attributes(SNUM(conn))) {
1040 return NT_STATUS_OK;
1041 }
1042
1043 smb_fname = synthetic_smb_fname(talloc_tos(), psmb_fname->base_name,
1044 NULL, &psmb_fname->st);
1045
1046 if (smb_fname == NULL) {
1047 return NT_STATUS_NO_MEMORY;
1048 }
1049
1050 dosmode = dos_mode(conn, smb_fname);
1051
1052 smb_fname->st.st_ex_btime = create_time;
1053
1054 ret = file_set_dosmode(conn, smb_fname, dosmode, NULL, false);
1055 if (ret == -1) {
1056 map_nt_error_from_unix(errno);
1057 }
1058
1059 DEBUG(10,("set_create_timespec_ea: wrote create time EA for file %s\n",
1060 smb_fname_str_dbg(smb_fname)));
1061
1062 return NT_STATUS_OK;
1063 }
1064
1065 /******************************************************************
1066 Return a create time.
1067 ******************************************************************/
1068
1069 struct timespec get_create_timespec(connection_struct *conn,
1070 struct files_struct *fsp,
1071 const struct smb_filename *smb_fname)
1072 {
1073 return smb_fname->st.st_ex_btime;
1074 }
1075
1076 /******************************************************************
1077 Return a change time (may look at EA in future).
1078 ******************************************************************/
1079
1080 struct timespec get_change_timespec(connection_struct *conn,
1081 struct files_struct *fsp,
1082 const struct smb_filename *smb_fname)
1083 {
1084 return smb_fname->st.st_ex_mtime;
1085 }
1086
1087 /****************************************************************************
1088 Get a real open file handle we can do meta-data operations on. As it's
1089 going to be used under root access only on meta-data we should look for
1090 any existing open file handle first, and use that in preference (also to
1091 avoid kernel self-oplock breaks). If not use an INTERNAL_OPEN_ONLY handle.
1092 ****************************************************************************/
1093
1094 static NTSTATUS get_file_handle_for_metadata(connection_struct *conn,
1095 struct smb_filename *smb_fname,
1096 files_struct **ret_fsp,
1097 bool *need_close)
1098 {
1099 NTSTATUS status;
1100 files_struct *fsp;
1101 struct file_id file_id;
1102
1103 *need_close = false;
1104
1105 if (!VALID_STAT(smb_fname->st)) {
1106 return NT_STATUS_INVALID_PARAMETER;
1107 }
1108
1109 file_id = vfs_file_id_from_sbuf(conn, &smb_fname->st);
1110
1111 for(fsp = file_find_di_first(conn->sconn, file_id);
1112 fsp;
1113 fsp = file_find_di_next(fsp)) {
1114 if (fsp->fh->fd != -1) {
1115 *ret_fsp = fsp;
1116 return NT_STATUS_OK;
1117 }
1118 }
1119
1120 /* Opens an INTERNAL_OPEN_ONLY write handle. */
1121 status = SMB_VFS_CREATE_FILE(
1122 conn, /* conn */
1123 NULL, /* req */
1124 0, /* root_dir_fid */
1125 smb_fname, /* fname */
1126 FILE_WRITE_DATA, /* access_mask */
1127 (FILE_SHARE_READ | FILE_SHARE_WRITE | /* share_access */
1128 FILE_SHARE_DELETE),
1129 FILE_OPEN, /* create_disposition*/
1130 0, /* create_options */
1131 0, /* file_attributes */
1132 INTERNAL_OPEN_ONLY, /* oplock_request */
1133 NULL, /* lease */
1134 0, /* allocation_size */
1135 0, /* private_flags */
1136 NULL, /* sd */
1137 NULL, /* ea_list */
1138 ret_fsp, /* result */
1139 NULL, /* pinfo */
1140 NULL, NULL); /* create context */
1141
1142 if (NT_STATUS_IS_OK(status)) {
1143 *need_close = true;
1144 }
1145 return status;
1146 }
Samba GIT mirror