?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
removing unused variables
[Samba.git] / source / smbd / open.c
blob66a61536eade999d6c2b9716ff124c6261323f53
1 /*
2 Unix SMB/Netbios implementation.
3 Version 1.9.
4 file opening and share modes
5 Copyright (C) Andrew Tridgell 1992-1998
6 Copyright (C) Jeremy Allison 2001
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
25 extern userdom_struct current_user_info;
26 extern uint16 global_oplock_port;
27 extern BOOL global_client_failed_oplock_break;
28
29 /****************************************************************************
30 fd support routines - attempt to do a dos_open.
31 ****************************************************************************/
32
33 static int fd_open(struct connection_struct *conn, char *fname,
34 int flags, mode_t mode)
35 {
36 int fd;
37
38 #ifdef O_NOFOLLOW
39 if (!lp_symlinks(SNUM(conn)))
40 flags |= O_NOFOLLOW;
41 #endif
42
43 fd = conn->vfs_ops.open(conn,dos_to_unix_static(fname),flags,mode);
44
45 /* Fix for files ending in '.' */
46 if((fd == -1) && (errno == ENOENT) &&
47 (strchr(fname,'.')==NULL)) {
48 pstrcat(fname,".");
49 fd = conn->vfs_ops.open(conn,dos_to_unix_static(fname),flags,mode);
50 }
51
52 DEBUG(10,("fd_open: name %s, flags = 0%o mode = 0%o, fd = %d. %s\n", fname,
53 flags, (int)mode, fd, (fd == -1) ? strerror(errno) : "" ));
54
55 return fd;
56 }
57
58 /****************************************************************************
59 Close the file associated with a fsp.
60 ****************************************************************************/
61
62 int fd_close(struct connection_struct *conn, files_struct *fsp)
63 {
64 if (fsp->fd == -1)
65 return 0; /* what we used to call a stat open. */
66 return fd_close_posix(conn, fsp);
67 }
68
69
70 /****************************************************************************
71 Check a filename for the pipe string.
72 ****************************************************************************/
73
74 static void check_for_pipe(char *fname)
75 {
76 /* special case of pipe opens */
77 char s[10];
78 StrnCpy(s,fname,sizeof(s)-1);
79 strlower(s);
80 if (strstr(s,"pipe/")) {
81 DEBUG(3,("Rejecting named pipe open for %s\n",fname));
82 unix_ERR_class = ERRSRV;
83 unix_ERR_code = ERRaccess;
84 }
85 }
86
87 /****************************************************************************
88 Open a file.
89 ****************************************************************************/
90
91 static BOOL open_file(files_struct *fsp,connection_struct *conn,
92 const char *fname1,SMB_STRUCT_STAT *psbuf,int flags,mode_t mode, uint32 desired_access)
93 {
94 extern struct current_user current_user;
95 pstring fname;
96 int accmode = (flags & O_ACCMODE);
97 int local_flags = flags;
98
99 fsp->fd = -1;
100 fsp->oplock_type = NO_OPLOCK;
101 errno = EPERM;
102
103 pstrcpy(fname,fname1);
104
105 /* Check permissions */
106
107 /*
108 * This code was changed after seeing a client open request
109 * containing the open mode of (DENY_WRITE/read-only) with
110 * the 'create if not exist' bit set. The previous code
111 * would fail to open the file read only on a read-only share
112 * as it was checking the flags parameter directly against O_RDONLY,
113 * this was failing as the flags parameter was set to O_RDONLY|O_CREAT.
114 * JRA.
115 */
116
117 if (!CAN_WRITE(conn)) {
118 /* It's a read-only share - fail if we wanted to write. */
119 if(accmode != O_RDONLY) {
120 DEBUG(3,("Permission denied opening %s\n",fname));
121 check_for_pipe(fname);
122 return False;
123 } else if(flags & O_CREAT) {
124 /* We don't want to write - but we must make sure that O_CREAT
125 doesn't create the file if we have write access into the
126 directory.
127 */
128 flags &= ~O_CREAT;
129 }
130 }
131
132 /*
133 * This little piece of insanity is inspired by the
134 * fact that an NT client can open a file for O_RDONLY,
135 * but set the create disposition to FILE_EXISTS_TRUNCATE.
136 * If the client *can* write to the file, then it expects to
137 * truncate the file, even though it is opening for readonly.
138 * Quicken uses this stupid trick in backup file creation...
139 * Thanks *greatly* to "David W. Chapman Jr." <dwcjr@inethouston.net>
140 * for helping track this one down. It didn't bite us in 2.0.x
141 * as we always opened files read-write in that release. JRA.
142 */
143
144 if ((accmode == O_RDONLY) && ((flags & O_TRUNC) == O_TRUNC)) {
145 DEBUG(10,("open_file: truncate requested on read-only open for file %s\n",fname ));
146 local_flags = (flags & ~O_ACCMODE)|O_RDWR;
147 }
148
149 /* actually do the open */
150
151 if ((desired_access & (FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|FILE_EXECUTE)) ||
152 (local_flags & O_CREAT) || ((local_flags & O_TRUNC) == O_TRUNC) ) {
153
154 /*
155 * We can't actually truncate here as the file may be locked.
156 * open_file_shared will take care of the truncate later. JRA.
157 */
158
159 local_flags &= ~O_TRUNC;
160
161 #if defined(O_NONBLOCK) && defined(S_ISFIFO)
162 /*
163 * We would block on opening a FIFO with no one else on the
164 * other end. Do what we used to do and add O_NONBLOCK to the
165 * open flags. JRA.
166 */
167
168 if (VALID_STAT(*psbuf) && S_ISFIFO(psbuf->st_mode))
169 local_flags |= O_NONBLOCK;
170 #endif
171 fsp->fd = fd_open(conn, fname, local_flags, mode);
172
173 if (fsp->fd == -1) {
174 DEBUG(3,("Error opening file %s (%s) (local_flags=%d) (flags=%d)\n",
175 fname,strerror(errno),local_flags,flags));
176 check_for_pipe(fname);
177 return False;
178 }
179 } else
180 fsp->fd = -1; /* What we used to call a stat open. */
181
182 if (!VALID_STAT(*psbuf)) {
183 int ret;
184
185 if (fsp->fd == -1)
186 ret = vfs_stat(conn, fname, psbuf);
187 else {
188 ret = vfs_fstat(fsp,fsp->fd,psbuf);
189 /* If we have an fd, this stat should succeed. */
190 if (ret == -1)
191 DEBUG(0,("Error doing fstat on open file %s (%s)\n", fname,strerror(errno) ));
192 }
193
194 /* For a non-io open, this stat failing means file not found. JRA */
195 if (ret == -1) {
196 fd_close(conn, fsp);
197 return False;
198 }
199 }
200
201 /*
202 * POSIX allows read-only opens of directories. We don't
203 * want to do this (we use a different code path for this)
204 * so catch a directory open and return an EISDIR. JRA.
205 */
206
207 if(S_ISDIR(psbuf->st_mode)) {
208 fd_close(conn, fsp);
209 errno = EISDIR;
210 return False;
211 }
212
213 fsp->mode = psbuf->st_mode;
214 fsp->inode = psbuf->st_ino;
215 fsp->dev = psbuf->st_dev;
216 fsp->vuid = current_user.vuid;
217 fsp->size = psbuf->st_size;
218 fsp->pos = -1;
219 fsp->can_lock = True;
220 fsp->can_read = ((flags & O_WRONLY)==0);
221 fsp->can_write = ((flags & (O_WRONLY|O_RDWR))!=0);
222 fsp->share_mode = 0;
223 fsp->desired_access = desired_access;
224 fsp->print_file = False;
225 fsp->modified = False;
226 fsp->oplock_type = NO_OPLOCK;
227 fsp->sent_oplock_break = NO_BREAK_SENT;
228 fsp->is_directory = False;
229 fsp->directory_delete_on_close = False;
230 fsp->conn = conn;
231 /*
232 * Note that the file name here is the *untranslated* name
233 * ie. it is still in the DOS codepage sent from the client.
234 * All use of this filename will pass though the sys_xxxx
235 * functions which will do the dos_to_unix translation before
236 * mapping into a UNIX filename. JRA.
237 */
238 string_set(&fsp->fsp_name,fname);
239 fsp->wbmpx_ptr = NULL;
240 fsp->wcp = NULL; /* Write cache pointer. */
241
242 DEBUG(2,("%s opened file %s read=%s write=%s (numopen=%d)\n",
243 *current_user_info.smb_name ? current_user_info.smb_name : conn->user,fsp->fsp_name,
244 BOOLSTR(fsp->can_read), BOOLSTR(fsp->can_write),
245 conn->num_files_open + 1));
246
247 return True;
248 }
249
250 /****************************************************************************
251 C. Hoch 11/22/95
252 Helper for open_file_shared.
253 Truncate a file after checking locking; close file if locked.
254 **************************************************************************/
255
256 static int truncate_unless_locked(struct connection_struct *conn, files_struct *fsp)
257 {
258 SMB_BIG_UINT mask = (SMB_BIG_UINT)-1;
259
260 if (is_locked(fsp,fsp->conn,mask,0,WRITE_LOCK,True)){
261 errno = EACCES;
262 unix_ERR_class = ERRDOS;
263 unix_ERR_code = ERRlock;
264 return -1;
265 } else {
266 return conn->vfs_ops.ftruncate(fsp,fsp->fd,0);
267 }
268 }
269
270 /*******************************************************************
271 return True if the filename is one of the special executable types
272 ********************************************************************/
273 static BOOL is_executable(const char *fname)
274 {
275 if ((fname = strrchr(fname,'.'))) {
276 if (strequal(fname,".com") ||
277 strequal(fname,".dll") ||
278 strequal(fname,".exe") ||
279 strequal(fname,".sym")) {
280 return True;
281 }
282 }
283 return False;
284 }
285
286 enum {AFAIL,AREAD,AWRITE,AALL};
287
288 /*******************************************************************
289 reproduce the share mode access table
290 this is horrendoously complex, and really can't be justified on any
291 rational grounds except that this is _exactly_ what NT does. See
292 the DENY1 and DENY2 tests in smbtorture for a comprehensive set of
293 test routines.
294 ********************************************************************/
295 static int access_table(int new_deny,int old_deny,int old_mode,
296 BOOL same_pid, BOOL isexe)
297 {
298 if (new_deny == DENY_ALL || old_deny == DENY_ALL) return(AFAIL);
299
300 if (same_pid) {
301 if (isexe && old_mode == DOS_OPEN_RDONLY &&
302 old_deny == DENY_DOS && new_deny == DENY_READ) {
303 return AFAIL;
304 }
305 if (!isexe && old_mode == DOS_OPEN_RDONLY &&
306 old_deny == DENY_DOS && new_deny == DENY_DOS) {
307 return AREAD;
308 }
309 if (new_deny == DENY_FCB && old_deny == DENY_DOS) {
310 if (isexe) return AFAIL;
311 if (old_mode == DOS_OPEN_RDONLY) return AFAIL;
312 return AALL;
313 }
314 if (old_mode == DOS_OPEN_RDONLY && old_deny == DENY_DOS) {
315 if (new_deny == DENY_FCB || new_deny == DENY_READ) {
316 if (isexe) return AREAD;
317 return AFAIL;
318 }
319 }
320 if (old_deny == DENY_FCB) {
321 if (new_deny == DENY_DOS || new_deny == DENY_FCB) return AALL;
322 return AFAIL;
323 }
324 }
325
326 if (old_deny == DENY_DOS || new_deny == DENY_DOS ||
327 old_deny == DENY_FCB || new_deny == DENY_FCB) {
328 if (isexe) {
329 if (old_deny == DENY_FCB || new_deny == DENY_FCB) {
330 return AFAIL;
331 }
332 if (old_deny == DENY_DOS) {
333 if (new_deny == DENY_READ &&
334 (old_mode == DOS_OPEN_RDONLY ||
335 old_mode == DOS_OPEN_RDWR)) {
336 return AFAIL;
337 }
338 if (new_deny == DENY_WRITE &&
339 (old_mode == DOS_OPEN_WRONLY ||
340 old_mode == DOS_OPEN_RDWR)) {
341 return AFAIL;
342 }
343 return AALL;
344 }
345 if (old_deny == DENY_NONE) return AALL;
346 if (old_deny == DENY_READ) return AWRITE;
347 if (old_deny == DENY_WRITE) return AREAD;
348 }
349 /* it isn't a exe, dll, sym or com file */
350 if (old_deny == new_deny && same_pid)
351 return(AALL);
352
353 if (old_deny == DENY_READ || new_deny == DENY_READ) return AFAIL;
354 if (old_mode == DOS_OPEN_RDONLY) return(AREAD);
355
356 return(AFAIL);
357 }
358
359 switch (new_deny)
360 {
361 case DENY_WRITE:
362 if (old_deny==DENY_WRITE && old_mode==DOS_OPEN_RDONLY) return(AREAD);
363 if (old_deny==DENY_READ && old_mode==DOS_OPEN_RDONLY) return(AWRITE);
364 if (old_deny==DENY_NONE && old_mode==DOS_OPEN_RDONLY) return(AALL);
365 return(AFAIL);
366 case DENY_READ:
367 if (old_deny==DENY_WRITE && old_mode==DOS_OPEN_WRONLY) return(AREAD);
368 if (old_deny==DENY_READ && old_mode==DOS_OPEN_WRONLY) return(AWRITE);
369 if (old_deny==DENY_NONE && old_mode==DOS_OPEN_WRONLY) return(AALL);
370 return(AFAIL);
371 case DENY_NONE:
372 if (old_deny==DENY_WRITE) return(AREAD);
373 if (old_deny==DENY_READ) return(AWRITE);
374 if (old_deny==DENY_NONE) return(AALL);
375 return(AFAIL);
376 }
377 return(AFAIL);
378 }
379
380
381 /****************************************************************************
382 check if we can open a file with a share mode
383 ****************************************************************************/
384
385 static BOOL check_share_mode(connection_struct *conn, share_mode_entry *share, int share_mode, uint32 desired_access,
386 const char *fname, BOOL fcbopen, int *flags)
387 {
388 int deny_mode = GET_DENY_MODE(share_mode);
389 int old_open_mode = GET_OPEN_MODE(share->share_mode);
390 int old_deny_mode = GET_DENY_MODE(share->share_mode);
391
392 /*
393 * share modes = false means don't bother to check for
394 * DENY mode conflict. This is a *really* bad idea :-). JRA.
395 */
396
397 if(!lp_share_modes(SNUM(conn)))
398 return True;
399
400 /*
401 * Don't allow any opens once the delete on close flag has been
402 * set.
403 */
404
405 if (GET_DELETE_ON_CLOSE_FLAG(share->share_mode)) {
406 DEBUG(5,("check_share_mode: Failing open on file %s as delete on close flag is set.\n",
407 fname ));
408 unix_ERR_class = ERRDOS;
409 unix_ERR_code = ERRnoaccess;
410 unix_ERR_ntstatus = NT_STATUS_DELETE_PENDING;
411 return False;
412 }
413
414 /* this is a nasty hack, but necessary until we rewrite our open
415 handling to use a NTCreateX call as the basic call.
416 NT may open a file with neither read nor write access, and in
417 this case it expects the open not to conflict with any
418 existing deny modes. This happens (for example) during a
419 "xcopy /o" where the second file descriptor is used for
420 ACL sets
421 (tridge)
422 */
423
424 /*
425 * This is a bit wierd - the test for desired access not having the
426 * critical bits seems seems odd. Firstly, if both opens have no
427 * critical bits then always ignore. Then check the "allow delete"
428 * then check for either. This probably isn't quite right yet but
429 * gets us much closer. JRA.
430 */
431
432 /*
433 * If desired_access doesn't contain READ_DATA,WRITE_DATA,APPEND_DATA or EXECUTE
434 * and the existing desired_acces then share modes don't conflict.
435 */
436
437 if ( !(desired_access & (FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|FILE_EXECUTE)) &&
438 !(share->desired_access & (FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|FILE_EXECUTE)) ) {
439
440 /*
441 * Wrinkle discovered by smbtorture....
442 * If both are non-io open and requester is asking for delete and current open has delete access
443 * but neither open has allowed file share delete then deny.... this is very strange and
444 * seems to be the only case in which non-io opens conflict. JRA.
445 */
446
447 if ((desired_access & DELETE_ACCESS) && (share->desired_access & DELETE_ACCESS) &&
448 (!GET_ALLOW_SHARE_DELETE(share->share_mode) || !GET_ALLOW_SHARE_DELETE(share_mode))) {
449 DEBUG(5,("check_share_mode: Failing open on file %s as delete access requests conflict.\n",
450 fname ));
451 unix_ERR_class = ERRDOS;
452 unix_ERR_code = ERRbadshare;
453
454 return False;
455 }
456
457 DEBUG(5,("check_share_mode: Allowing open on file %s as both desired access (0x%x) \
458 and existing desired access (0x%x) are non-data opens\n",
459 fname, (unsigned int)desired_access, (unsigned int)share->desired_access ));
460 return True;
461 }
462
463 /*
464 * If delete access was requested and the existing share mode doesn't have
465 * ALLOW_SHARE_DELETE then deny.
466 */
467
468 if ((desired_access & DELETE_ACCESS) && !GET_ALLOW_SHARE_DELETE(share->share_mode)) {
469 DEBUG(5,("check_share_mode: Failing open on file %s as delete access requested and allow share delete not set.\n",
470 fname ));
471 unix_ERR_class = ERRDOS;
472 unix_ERR_code = ERRbadshare;
473
474 return False;
475 }
476
477 /*
478 * The inverse of the above.
479 * If delete access was granted and the new share mode doesn't have
480 * ALLOW_SHARE_DELETE then deny.
481 */
482
483 if ((share->desired_access & DELETE_ACCESS) && !GET_ALLOW_SHARE_DELETE(share_mode)) {
484 DEBUG(5,("check_share_mode: Failing open on file %s as delete access granted and allow share delete not requested.\n",
485 fname ));
486 unix_ERR_class = ERRDOS;
487 unix_ERR_code = ERRbadshare;
488
489 return False;
490 }
491
492 /*
493 * If desired_access doesn't contain READ_DATA,WRITE_DATA,APPEND_DATA or EXECUTE
494 * then share modes don't conflict. Likewise with existing desired access.
495 */
496
497 if ( !(desired_access & (FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|FILE_EXECUTE)) ||
498 !(share->desired_access & (FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|FILE_EXECUTE)) ) {
499 DEBUG(5,("check_share_mode: Allowing open on file %s as desired access (0x%x) doesn't conflict with\
500 existing desired access (0x%x).\n", fname, (unsigned int)desired_access, (unsigned int)share->desired_access ));
501 return True;
502 }
503
504 {
505 int access_allowed = access_table(deny_mode,old_deny_mode,old_open_mode,
506 (share->pid == sys_getpid()),is_executable(fname));
507
508 if ((access_allowed == AFAIL) ||
509 (!fcbopen && (access_allowed == AREAD && *flags == O_RDWR)) ||
510 (access_allowed == AREAD && *flags != O_RDONLY) ||
511 (access_allowed == AWRITE && *flags != O_WRONLY)) {
512
513 DEBUG(2,("Share violation on file (%d,%d,%d,%d,%s,fcbopen = %d, flags = %d) = %d\n",
514 deny_mode,old_deny_mode,old_open_mode,
515 (int)share->pid,fname, fcbopen, *flags, access_allowed));
516
517 unix_ERR_class = ERRDOS;
518 unix_ERR_code = ERRbadshare;
519
520 return False;
521 }
522
523 if (access_allowed == AREAD)
524 *flags = O_RDONLY;
525
526 if (access_allowed == AWRITE)
527 *flags = O_WRONLY;
528
529 }
530
531 return True;
532 }
533
534 /****************************************************************************
535 Deal with open deny mode and oplock break processing.
536 Invarient: Share mode must be locked on entry and exit.
537 Returns -1 on error, or number of share modes on success (may be zero).
538 ****************************************************************************/
539
540 static int open_mode_check(connection_struct *conn, const char *fname, SMB_DEV_T dev,
541 SMB_INO_T inode,
542 uint32 desired_access,
543 int share_mode, int *p_flags, int *p_oplock_request,
544 BOOL *p_all_current_opens_are_level_II)
545 {
546 int i;
547 int num_share_modes;
548 int oplock_contention_count = 0;
549 share_mode_entry *old_shares = 0;
550 BOOL fcbopen = False;
551 BOOL broke_oplock;
552
553 if(GET_OPEN_MODE(share_mode) == DOS_OPEN_FCB)
554 fcbopen = True;
555
556 num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
557
558 if(num_share_modes == 0)
559 return 0;
560
561 /*
562 * Check if the share modes will give us access.
563 */
564
565 do {
566 share_mode_entry broken_entry;
567
568 broke_oplock = False;
569 *p_all_current_opens_are_level_II = True;
570
571 for(i = 0; i < num_share_modes; i++) {
572 share_mode_entry *share_entry = &old_shares[i];
573
574 /*
575 * By observation of NetBench, oplocks are broken *before* share
576 * modes are checked. This allows a file to be closed by the client
577 * if the share mode would deny access and the client has an oplock.
578 * Check if someone has an oplock on this file. If so we must break
579 * it before continuing.
580 */
581
582 if((*p_oplock_request && EXCLUSIVE_OPLOCK_TYPE(share_entry->op_type)) ||
583 (!*p_oplock_request && (share_entry->op_type != NO_OPLOCK))) {
584
585 BOOL opb_ret;
586
587 DEBUG(5,("open_mode_check: oplock_request = %d, breaking oplock (%x) on file %s, \
588 dev = %x, inode = %.0f\n", *p_oplock_request, share_entry->op_type, fname, (unsigned int)dev, (double)inode));
589
590 /* Oplock break - unlock to request it. */
591 unlock_share_entry(conn, dev, inode);
592
593 opb_ret = request_oplock_break(share_entry);
594
595 /* Now relock. */
596 lock_share_entry(conn, dev, inode);
597
598 if(opb_ret == False) {
599 DEBUG(0,("open_mode_check: FAILED when breaking oplock (%x) on file %s, \
600 dev = %x, inode = %.0f\n", old_shares[i].op_type, fname, (unsigned int)dev, (double)inode));
601 SAFE_FREE(old_shares);
602 errno = EACCES;
603 unix_ERR_class = ERRDOS;
604 unix_ERR_code = ERRbadshare;
605 return -1;
606 }
607
608 broke_oplock = True;
609 broken_entry = *share_entry;
610 break;
611
612 } else if (!LEVEL_II_OPLOCK_TYPE(share_entry->op_type)) {
613 *p_all_current_opens_are_level_II = False;
614 }
615
616 /* someone else has a share lock on it, check to see if we can too */
617 if (!check_share_mode(conn, share_entry, share_mode, desired_access,
618 fname, fcbopen, p_flags)) {
619 SAFE_FREE(old_shares);
620 errno = EACCES;
621 return -1;
622 }
623
624 } /* end for */
625
626 if(broke_oplock) {
627 SAFE_FREE(old_shares);
628 num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
629 oplock_contention_count++;
630
631 /* Paranoia check that this is no longer an exlusive entry. */
632 for(i = 0; i < num_share_modes; i++) {
633 share_mode_entry *share_entry = &old_shares[i];
634
635 if (share_modes_identical(&broken_entry, share_entry) &&
636 EXCLUSIVE_OPLOCK_TYPE(share_entry->op_type) ) {
637
638 /*
639 * This should not happen. The target left this oplock
640 * as exlusive.... The process *must* be dead....
641 */
642
643 DEBUG(0,("open_mode_check: exlusive oplock left by process %d after break ! For file %s, \
644 dev = %x, inode = %.0f. Deleting it to continue...\n", (int)broken_entry.pid, fname, (unsigned int)dev, (double)inode));
645
646 if (process_exists(broken_entry.pid)) {
647 DEBUG(0,("open_mode_check: Existent process %u left active oplock.\n",
648 (unsigned int)broken_entry.pid ));
649 }
650
651 if (del_share_entry(dev, inode, &broken_entry, NULL) == -1) {
652 errno = EACCES;
653 unix_ERR_class = ERRDOS;
654 unix_ERR_code = ERRbadshare;
655 return -1;
656 }
657
658 /*
659 * We must reload the share modes after deleting the
660 * other process's entry.
661 */
662
663 SAFE_FREE(old_shares);
664 num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
665 break;
666 }
667 } /* end for paranoia... */
668 } /* end if broke_oplock */
669
670 } while(broke_oplock);
671
672 SAFE_FREE(old_shares);
673
674 /*
675 * Refuse to grant an oplock in case the contention limit is
676 * reached when going through the lock list multiple times.
677 */
678
679 if(oplock_contention_count >= lp_oplock_contention_limit(SNUM(conn))) {
680 *p_oplock_request = 0;
681 DEBUG(4,("open_mode_check: oplock contention = %d. Not granting oplock.\n",
682 oplock_contention_count ));
683 }
684
685 return num_share_modes;
686 }
687
688 static BOOL open_match_attributes(connection_struct *conn, char *path, mode_t existing_mode,
689 mode_t new_mode, mode_t *returned_mode)
690 {
691 uint32 old_dos_mode, new_dos_mode;
692 SMB_STRUCT_STAT sbuf;
693
694 ZERO_STRUCT(sbuf);
695
696 sbuf.st_mode = existing_mode;
697 old_dos_mode = dos_mode(conn, path, &sbuf);
698
699 sbuf.st_mode = new_mode;
700 new_dos_mode = dos_mode(conn, path, &sbuf);
701
702 /*
703 * We only set returned mode to be the same as new_mode if
704 * the file attributes need to be changed.
705 */
706
707 *returned_mode = (mode_t)0;
708
709 /* If we're mapping SYSTEM and HIDDEN ensure they match. */
710 if (lp_map_system(SNUM(conn))) {
711 if ((old_dos_mode & FILE_ATTRIBUTE_SYSTEM) && !(new_dos_mode & FILE_ATTRIBUTE_SYSTEM))
712 return False;
713 if (!(old_dos_mode & FILE_ATTRIBUTE_SYSTEM) && (new_dos_mode & FILE_ATTRIBUTE_SYSTEM))
714 *returned_mode = new_mode;
715 }
716 if (lp_map_hidden(SNUM(conn))) {
717 if ((old_dos_mode & FILE_ATTRIBUTE_HIDDEN) && !(new_dos_mode & FILE_ATTRIBUTE_HIDDEN))
718 return False;
719 if (!(old_dos_mode & FILE_ATTRIBUTE_HIDDEN) && (new_dos_mode & FILE_ATTRIBUTE_HIDDEN))
720 *returned_mode = new_mode;
721 }
722 return True;
723 }
724
725 /****************************************************************************
726 set a kernel flock on a file for NFS interoperability
727 this requires a patch to Linux
728 ****************************************************************************/
729 static void kernel_flock(files_struct *fsp, int deny_mode)
730 {
731 #if HAVE_KERNEL_SHARE_MODES
732 int kernel_mode = 0;
733 if (deny_mode == DENY_READ) kernel_mode = LOCK_MAND|LOCK_WRITE;
734 else if (deny_mode == DENY_WRITE) kernel_mode = LOCK_MAND|LOCK_READ;
735 else if (deny_mode == DENY_ALL) kernel_mode = LOCK_MAND;
736 if (kernel_mode) flock(fsp->fd, kernel_mode);
737 #endif
738 ;;
739 }
740
741
742 /****************************************************************************
743 Open a file with a share mode - old method.
744 ****************************************************************************/
745
746 files_struct *open_file_shared(connection_struct *conn,char *fname, SMB_STRUCT_STAT *psbuf,
747 int share_mode,int ofun, mode_t mode,int oplock_request, int *Access,int *action)
748 {
749 return open_file_shared1(conn, fname, psbuf, 0, share_mode, ofun, mode,
750 oplock_request, Access, action);
751 }
752
753 /****************************************************************************
754 Open a file with a share mode - called from NTCreateAndX.
755 ****************************************************************************/
756
757 files_struct *open_file_shared1(connection_struct *conn,char *fname, SMB_STRUCT_STAT *psbuf,
758 uint32 desired_access,
759 int share_mode,int ofun, mode_t mode,int oplock_request,
760 int *Access,int *action)
761 {
762 int flags=0;
763 int flags2=0;
764 int deny_mode = GET_DENY_MODE(share_mode);
765 BOOL allow_share_delete = GET_ALLOW_SHARE_DELETE(share_mode);
766 BOOL delete_on_close = GET_DELETE_ON_CLOSE_FLAG(share_mode);
767 BOOL file_existed = VALID_STAT(*psbuf);
768 BOOL fcbopen = False;
769 BOOL def_acl = False;
770 SMB_DEV_T dev = 0;
771 SMB_INO_T inode = 0;
772 int num_share_modes = 0;
773 BOOL all_current_opens_are_level_II = False;
774 BOOL fsp_open = False;
775 files_struct *fsp = NULL;
776 int open_mode=0;
777 uint16 port = 0;
778 mode_t new_mode = (mode_t)0;
779
780 if (conn->printer) {
781 /* printers are handled completely differently. Most
782 of the passed parameters are ignored */
783 if (Access)
784 *Access = DOS_OPEN_WRONLY;
785 if (action)
786 *action = FILE_WAS_CREATED;
787 return print_fsp_open(conn, fname);
788 }
789
790 fsp = file_new(conn);
791 if(!fsp)
792 return NULL;
793
794 DEBUG(10,("open_file_shared: fname = %s, share_mode = %x, ofun = %x, mode = %o, oplock request = %d\n",
795 fname, share_mode, ofun, (int)mode, oplock_request ));
796
797 if (!check_name(fname,conn)) {
798 file_free(fsp);
799 return NULL;
800 }
801
802 /* ignore any oplock requests if oplocks are disabled */
803 if (!lp_oplocks(SNUM(conn)) || global_client_failed_oplock_break) {
804 oplock_request = 0;
805 }
806
807 /* this is for OS/2 EAs - try and say we don't support them */
808 if (strstr(fname,".+,;=[].")) {
809 unix_ERR_class = ERRDOS;
810 /* OS/2 Workplace shell fix may be main code stream in a later release. */
811 #if 1 /* OS2_WPS_FIX - Recent versions of OS/2 need this. */
812 unix_ERR_code = ERRcannotopen;
813 #else /* OS2_WPS_FIX */
814 unix_ERR_code = ERROR_EAS_NOT_SUPPORTED;
815 #endif /* OS2_WPS_FIX */
816
817 DEBUG(5,("open_file_shared: OS/2 EA's are not supported.\n"));
818 file_free(fsp);
819 return NULL;
820 }
821
822 if ((GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_FAIL) && file_existed) {
823 DEBUG(5,("open_file_shared: create new requested for file %s and file already exists.\n",
824 fname ));
825 file_free(fsp);
826 errno = EEXIST;
827 return NULL;
828 }
829
830 if (CAN_WRITE(conn) && (GET_FILE_CREATE_DISPOSITION(ofun) == FILE_CREATE_IF_NOT_EXIST))
831 flags2 |= O_CREAT;
832
833 if (CAN_WRITE(conn) && (GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_TRUNCATE))
834 flags2 |= O_TRUNC;
835
836 /* We only care about matching attributes on file exists and truncate. */
837 if (file_existed && (GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_TRUNCATE)) {
838 if (!open_match_attributes(conn, fname, psbuf->st_mode, mode, &new_mode)) {
839 DEBUG(5,("open_file_shared: attributes missmatch for file %s (0%o, 0%o)\n",
840 fname, psbuf->st_mode, mode ));
841 file_free(fsp);
842 errno = EACCES;
843 return NULL;
844 }
845 }
846
847 if (GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_FAIL)
848 flags2 |= O_EXCL;
849
850 /* note that we ignore the append flag as
851 append does not mean the same thing under dos and unix */
852
853 switch (GET_OPEN_MODE(share_mode)) {
854 case DOS_OPEN_WRONLY:
855 flags = O_WRONLY;
856 if (desired_access == 0)
857 desired_access = FILE_WRITE_DATA;
858 break;
859 case DOS_OPEN_FCB:
860 fcbopen = True;
861 flags = O_RDWR;
862 if (desired_access == 0)
863 desired_access = FILE_READ_DATA|FILE_WRITE_DATA;
864 break;
865 case DOS_OPEN_RDWR:
866 flags = O_RDWR;
867 if (desired_access == 0)
868 desired_access = FILE_READ_DATA|FILE_WRITE_DATA;
869 break;
870 default:
871 flags = O_RDONLY;
872 if (desired_access == 0)
873 desired_access = FILE_READ_DATA;
874 break;
875 }
876
877 #if defined(O_SYNC)
878 if (GET_FILE_SYNC_OPENMODE(share_mode)) {
879 flags2 |= O_SYNC;
880 }
881 #endif /* O_SYNC */
882
883 if (flags != O_RDONLY && file_existed &&
884 (!CAN_WRITE(conn) || IS_DOS_READONLY(dos_mode(conn,fname,psbuf)))) {
885 if (!fcbopen) {
886 DEBUG(5,("open_file_shared: read/write access requested for file %s on read only %s\n",
887 fname, !CAN_WRITE(conn) ? "share" : "file" ));
888 file_free(fsp);
889 errno = EACCES;
890 return NULL;
891 }
892 flags = O_RDONLY;
893 }
894
895 if (deny_mode > DENY_NONE && deny_mode!=DENY_FCB) {
896 DEBUG(2,("Invalid deny mode %d on file %s\n",deny_mode,fname));
897 file_free(fsp);
898 errno = EINVAL;
899 return NULL;
900 }
901
902 if (file_existed) {
903
904 dev = psbuf->st_dev;
905 inode = psbuf->st_ino;
906
907 lock_share_entry(conn, dev, inode);
908
909 num_share_modes = open_mode_check(conn, fname, dev, inode,
910 desired_access, share_mode,
911 &flags, &oplock_request, &all_current_opens_are_level_II);
912
913 if(num_share_modes == -1) {
914
915 /*
916 * This next line is a subtlety we need for MS-Access. If a file open will
917 * fail due to share permissions and also for security (access)
918 * reasons, we need to return the access failed error, not the
919 * share error. This means we must attempt to open the file anyway
920 * in order to get the UNIX access error - even if we're going to
921 * fail the open for share reasons. This is bad, as we're burning
922 * another fd if there are existing locks but there's nothing else
923 * we can do. We also ensure we're not going to create or tuncate
924 * the file as we only want an access decision at this stage. JRA.
925 */
926 fsp_open = open_file(fsp,conn,fname,psbuf,
927 flags|(flags2&~(O_TRUNC|O_CREAT)),mode,desired_access);
928
929 DEBUG(4,("open_file_shared : share_mode deny - calling open_file with \
930 flags=0x%X flags2=0x%X mode=0%o returned %d\n",
931 flags,(flags2&~(O_TRUNC|O_CREAT)),(int)mode,(int)fsp_open ));
932
933 unlock_share_entry(conn, dev, inode);
934 if (fsp_open)
935 fd_close(conn, fsp);
936 file_free(fsp);
937 return NULL;
938 }
939
940 /*
941 * We exit this block with the share entry *locked*.....
942 */
943 }
944
945 /*
946 * Ensure we pay attention to default ACLs on directories if required.
947 */
948
949 if ((flags2 & O_CREAT) && lp_inherit_acls(SNUM(conn)) &&
950 (def_acl = directory_has_default_acl(conn, dos_to_unix_static(parent_dirname(fname)))))
951 mode = 0777;
952
953 DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o\n",
954 flags,flags2,(int)mode));
955
956 /*
957 * open_file strips any O_TRUNC flags itself.
958 */
959
960 fsp_open = open_file(fsp,conn,fname,psbuf,flags|flags2,mode,desired_access);
961
962 if (!fsp_open && (flags == O_RDWR) && (errno != ENOENT) && fcbopen) {
963 if((fsp_open = open_file(fsp,conn,fname,psbuf,O_RDONLY,mode,desired_access)) == True)
964 flags = O_RDONLY;
965 }
966
967 if (!fsp_open) {
968 if(file_existed)
969 unlock_share_entry(conn, dev, inode);
970 file_free(fsp);
971 return NULL;
972 }
973
974 /*
975 * Deal with the race condition where two smbd's detect the file doesn't
976 * exist and do the create at the same time. One of them will win and
977 * set a share mode, the other (ie. this one) should check if the
978 * requested share mode for this create is allowed.
979 */
980
981 if (!file_existed) {
982
983 lock_share_entry_fsp(fsp);
984
985 num_share_modes = open_mode_check(conn, fname, dev, inode,
986 desired_access, share_mode,
987 &flags, &oplock_request, &all_current_opens_are_level_II);
988
989 if(num_share_modes == -1) {
990 unlock_share_entry_fsp(fsp);
991 fd_close(conn,fsp);
992 file_free(fsp);
993 return NULL;
994 }
995
996 /*
997 * If there are any share modes set then the file *did*
998 * exist. Ensure we return the correct value for action.
999 */
1000
1001 if (num_share_modes > 0)
1002 file_existed = True;
1003
1004 /*
1005 * We exit this block with the share entry *locked*.....
1006 */
1007 }
1008
1009 /* note that we ignore failure for the following. It is
1010 basically a hack for NFS, and NFS will never set one of
1011 these only read them. Nobody but Samba can ever set a deny
1012 mode and we have already checked our more authoritative
1013 locking database for permission to set this deny mode. If
1014 the kernel refuses the operations then the kernel is wrong */
1015 kernel_flock(fsp, deny_mode);
1016
1017 /*
1018 * At this point onwards, we can guarentee that the share entry
1019 * is locked, whether we created the file or not, and that the
1020 * deny mode is compatible with all current opens.
1021 */
1022
1023 /*
1024 * If requested, truncate the file.
1025 */
1026
1027 if (flags2&O_TRUNC) {
1028 /*
1029 * We are modifing the file after open - update the stat struct..
1030 */
1031 if ((truncate_unless_locked(conn,fsp) == -1) || (vfs_fstat(fsp,fsp->fd,psbuf)==-1)) {
1032 unlock_share_entry_fsp(fsp);
1033 fd_close(conn,fsp);
1034 file_free(fsp);
1035 return NULL;
1036 }
1037 }
1038
1039 switch (flags) {
1040 case O_RDONLY:
1041 open_mode = DOS_OPEN_RDONLY;
1042 break;
1043 case O_RDWR:
1044 open_mode = DOS_OPEN_RDWR;
1045 break;
1046 case O_WRONLY:
1047 open_mode = DOS_OPEN_WRONLY;
1048 break;
1049 }
1050
1051 fsp->share_mode = SET_DENY_MODE(deny_mode) |
1052 SET_OPEN_MODE(open_mode) |
1053 SET_ALLOW_SHARE_DELETE(allow_share_delete);
1054
1055 DEBUG(10,("open_file_shared : share_mode = %x\n", fsp->share_mode ));
1056
1057 if (Access)
1058 (*Access) = open_mode;
1059
1060 if (action) {
1061 if (file_existed && !(flags2 & O_TRUNC))
1062 *action = FILE_WAS_OPENED;
1063 if (!file_existed)
1064 *action = FILE_WAS_CREATED;
1065 if (file_existed && (flags2 & O_TRUNC))
1066 *action = FILE_WAS_OVERWRITTEN;
1067 }
1068
1069 /*
1070 * Setup the oplock info in both the shared memory and
1071 * file structs.
1072 */
1073
1074 if(oplock_request && (num_share_modes == 0) &&
1075 !IS_VETO_OPLOCK_PATH(conn,fname) && set_file_oplock(fsp, oplock_request) ) {
1076 port = global_oplock_port;
1077 } else if (oplock_request && all_current_opens_are_level_II) {
1078 port = global_oplock_port;
1079 oplock_request = LEVEL_II_OPLOCK;
1080 set_file_oplock(fsp, oplock_request);
1081 } else {
1082 port = 0;
1083 oplock_request = 0;
1084 }
1085
1086 set_share_mode(fsp, port, oplock_request);
1087
1088 if (delete_on_close) {
1089 NTSTATUS result = set_delete_on_close_internal(fsp, delete_on_close);
1090
1091 if (NT_STATUS_V(result) != NT_STATUS_V(NT_STATUS_OK)) {
1092 /* Remember to delete the mode we just added. */
1093 del_share_mode(fsp, NULL);
1094 unlock_share_entry_fsp(fsp);
1095 fd_close(conn,fsp);
1096 file_free(fsp);
1097 return NULL;
1098 }
1099 }
1100
1101 /*
1102 * Take care of inherited ACLs on created files - if default ACL not
1103 * selected.
1104 */
1105
1106 if (!file_existed && !def_acl && (conn->vfs_ops.fchmod_acl != NULL)) {
1107
1108 int saved_errno = errno; /* We might get ENOSYS in the next call.. */
1109
1110 if (conn->vfs_ops.fchmod_acl(fsp, fsp->fd, mode) == -1 && errno == ENOSYS)
1111 errno = saved_errno; /* Ignore ENOSYS */
1112
1113 } else if (new_mode) {
1114
1115 int ret = -1;
1116
1117 /* Attributes need changing. File already existed. */
1118
1119 if (conn->vfs_ops.fchmod_acl != NULL) {
1120 int saved_errno = errno; /* We might get ENOSYS in the next call.. */
1121 ret = conn->vfs_ops.fchmod_acl(fsp, fsp->fd, new_mode);
1122
1123 if (ret == -1 && errno == ENOSYS) {
1124 errno = saved_errno; /* Ignore ENOSYS */
1125 } else {
1126 DEBUG(5, ("open_file_shared: failed to reset attributes of file %s to 0%o\n",
1127 fname, (int)new_mode));
1128 ret = 0; /* Don't do the fchmod below. */
1129 }
1130 }
1131
1132 if ((ret == -1) && (conn->vfs_ops.fchmod(fsp, fsp->fd, new_mode) == -1))
1133 DEBUG(5, ("open_file_shared: failed to reset attributes of file %s to 0%o\n",
1134 fname, (int)new_mode));
1135 }
1136
1137 unlock_share_entry_fsp(fsp);
1138
1139 conn->num_files_open++;
1140
1141 return fsp;
1142 }
1143
1144 /****************************************************************************
1145 Open a file for for write to ensure that we can fchmod it.
1146 ****************************************************************************/
1147
1148 files_struct *open_file_fchmod(connection_struct *conn, const char *fname, SMB_STRUCT_STAT *psbuf)
1149 {
1150 files_struct *fsp = NULL;
1151 BOOL fsp_open;
1152
1153 if (!VALID_STAT(*psbuf))
1154 return NULL;
1155
1156 fsp = file_new(conn);
1157 if(!fsp)
1158 return NULL;
1159
1160 /* note! we must use a non-zero desired access or we don't get
1161 a real file descriptor. Oh what a twisted web we weave. */
1162 fsp_open = open_file(fsp,conn,fname,psbuf,O_WRONLY,0,FILE_WRITE_DATA);
1163
1164 /*
1165 * This is not a user visible file open.
1166 * Don't set a share mode and don't increment
1167 * the conn->num_files_open.
1168 */
1169
1170 if (!fsp_open) {
1171 file_free(fsp);
1172 return NULL;
1173 }
1174
1175 return fsp;
1176 }
1177
1178 /****************************************************************************
1179 Close the fchmod file fd - ensure no locks are lost.
1180 ****************************************************************************/
1181
1182 int close_file_fchmod(files_struct *fsp)
1183 {
1184 int ret = fd_close(fsp->conn, fsp);
1185 file_free(fsp);
1186 return ret;
1187 }
1188
1189 /****************************************************************************
1190 Open a directory from an NT SMB call.
1191 ****************************************************************************/
1192
1193 files_struct *open_directory(connection_struct *conn, char *fname, SMB_STRUCT_STAT *psbuf,
1194 uint32 desired_access, int share_mode, int smb_ofun, mode_t unixmode, int *action)
1195 {
1196 extern struct current_user current_user;
1197 BOOL got_stat = False;
1198 files_struct *fsp = file_new(conn);
1199 BOOL delete_on_close = GET_DELETE_ON_CLOSE_FLAG(share_mode);
1200
1201 if(!fsp)
1202 return NULL;
1203
1204 fsp->conn = conn; /* The vfs_fXXX() macros need this. */
1205
1206 if (VALID_STAT(*psbuf))
1207 got_stat = True;
1208
1209 if (got_stat && (GET_FILE_OPEN_DISPOSITION(smb_ofun) == FILE_EXISTS_FAIL)) {
1210 file_free(fsp);
1211 errno = EEXIST; /* Setup so correct error is returned to client. */
1212 return NULL;
1213 }
1214
1215 if (GET_FILE_CREATE_DISPOSITION(smb_ofun) == FILE_CREATE_IF_NOT_EXIST) {
1216
1217 if (got_stat) {
1218
1219 if(!S_ISDIR(psbuf->st_mode)) {
1220 DEBUG(0,("open_directory: %s is not a directory !\n", fname ));
1221 file_free(fsp);
1222 errno = EACCES;
1223 return NULL;
1224 }
1225 *action = FILE_WAS_OPENED;
1226
1227 } else {
1228
1229 /*
1230 * Try and create the directory.
1231 */
1232
1233 if(!CAN_WRITE(conn)) {
1234 DEBUG(2,("open_directory: failing create on read-only share\n"));
1235 file_free(fsp);
1236 errno = EACCES;
1237 return NULL;
1238 }
1239
1240 if(vfs_mkdir(conn,fname, unix_mode(conn,aDIR, fname)) < 0) {
1241 DEBUG(2,("open_directory: unable to create %s. Error was %s\n",
1242 fname, strerror(errno) ));
1243 file_free(fsp);
1244 return NULL;
1245 }
1246
1247 if(vfs_stat(conn,fname, psbuf) != 0) {
1248 file_free(fsp);
1249 return NULL;
1250 }
1251
1252 *action = FILE_WAS_CREATED;
1253
1254 }
1255 } else {
1256
1257 /*
1258 * Don't create - just check that it *was* a directory.
1259 */
1260
1261 if(!got_stat) {
1262 DEBUG(0,("open_directory: unable to stat name = %s. Error was %s\n",
1263 fname, strerror(errno) ));
1264 file_free(fsp);
1265 return NULL;
1266 }
1267
1268 if(!S_ISDIR(psbuf->st_mode)) {
1269 DEBUG(0,("open_directory: %s is not a directory !\n", fname ));
1270 file_free(fsp);
1271 return NULL;
1272 }
1273
1274 *action = FILE_WAS_OPENED;
1275 }
1276
1277 DEBUG(5,("open_directory: opening directory %s\n", fname));
1278
1279 /*
1280 * Setup the files_struct for it.
1281 */
1282
1283 fsp->mode = psbuf->st_mode;
1284 fsp->inode = psbuf->st_ino;
1285 fsp->dev = psbuf->st_dev;
1286 fsp->size = psbuf->st_size;
1287 fsp->vuid = current_user.vuid;
1288 fsp->pos = -1;
1289 fsp->can_lock = True;
1290 fsp->can_read = False;
1291 fsp->can_write = False;
1292 fsp->share_mode = share_mode;
1293 fsp->desired_access = desired_access;
1294 fsp->print_file = False;
1295 fsp->modified = False;
1296 fsp->oplock_type = NO_OPLOCK;
1297 fsp->sent_oplock_break = NO_BREAK_SENT;
1298 fsp->is_directory = True;
1299 fsp->directory_delete_on_close = False;
1300 fsp->conn = conn;
1301
1302 if (delete_on_close) {
1303 NTSTATUS result = set_delete_on_close_internal(fsp, delete_on_close);
1304
1305 if (NT_STATUS_V(result) != NT_STATUS_V(NT_STATUS_OK)) {
1306 file_free(fsp);
1307 return NULL;
1308 }
1309 }
1310
1311 /*
1312 * Note that the file name here is the *untranslated* name
1313 * ie. it is still in the DOS codepage sent from the client.
1314 * All use of this filename will pass though the sys_xxxx
1315 * functions which will do the dos_to_unix translation before
1316 * mapping into a UNIX filename. JRA.
1317 */
1318 string_set(&fsp->fsp_name,fname);
1319 fsp->wbmpx_ptr = NULL;
1320
1321 conn->num_files_open++;
1322
1323 return fsp;
1324 }
1325
1326 /****************************************************************************
1327 Open a pseudo-file (no locking checks - a 'stat' open).
1328 ****************************************************************************/
1329
1330 files_struct *open_file_stat(connection_struct *conn, char *fname, SMB_STRUCT_STAT *psbuf)
1331 {
1332 extern struct current_user current_user;
1333 files_struct *fsp = NULL;
1334
1335 if (!VALID_STAT(*psbuf))
1336 return NULL;
1337
1338 /* Can't 'stat' open directories. */
1339 if(S_ISDIR(psbuf->st_mode))
1340 return NULL;
1341
1342 fsp = file_new(conn);
1343 if(!fsp)
1344 return NULL;
1345
1346 fsp->conn = conn; /* The vfs_fXXX() macros need this. */
1347
1348 DEBUG(5,("open_file_stat: 'opening' file %s\n", fname));
1349
1350 /*
1351 * Setup the files_struct for it.
1352 */
1353
1354 fsp->mode = psbuf->st_mode;
1355 /*
1356 * Don't store dev or inode, we don't want any iterator
1357 * to see this.
1358 */
1359 fsp->inode = (SMB_INO_T)0;
1360 fsp->dev = (SMB_DEV_T)0;
1361 fsp->size = psbuf->st_size;
1362 fsp->vuid = current_user.vuid;
1363 fsp->pos = -1;
1364 fsp->can_lock = False;
1365 fsp->can_read = False;
1366 fsp->can_write = False;
1367 fsp->share_mode = 0;
1368 fsp->desired_access = 0;
1369 fsp->print_file = False;
1370 fsp->modified = False;
1371 fsp->oplock_type = NO_OPLOCK;
1372 fsp->sent_oplock_break = NO_BREAK_SENT;
1373 fsp->is_directory = False;
1374 fsp->is_stat = True;
1375 fsp->directory_delete_on_close = False;
1376 fsp->conn = conn;
1377 string_set(&fsp->fsp_name,fname);
1378
1379 conn->num_files_open++;
1380
1381 return fsp;
1382 }
Samba GIT mirror