lib: Move full_path_tos to util_str.c
[kai/samba-autobuild/.git] / source3 / smbd / files.c
1 /* 
2    Unix SMB/CIFS implementation.
3    Files[] structure handling
4    Copyright (C) Andrew Tridgell 1998
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program.  If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "includes.h"
21 #include "smbd/smbd.h"
22 #include "smbd/globals.h"
23 #include "libcli/security/security.h"
24 #include "util_tdb.h"
25 #include <ccan/hash/hash.h>
26 #include "lib/util/bitmap.h"
27
28 #define FILE_HANDLE_OFFSET 0x1000
29
30 /**
31  * create new fsp to be used for file_new or a durable handle reconnect
32  */
33 NTSTATUS fsp_new(struct connection_struct *conn, TALLOC_CTX *mem_ctx,
34                  files_struct **result)
35 {
36         NTSTATUS status = NT_STATUS_NO_MEMORY;
37         files_struct *fsp = NULL;
38         struct smbd_server_connection *sconn = conn->sconn;
39
40         fsp = talloc_zero(mem_ctx, struct files_struct);
41         if (fsp == NULL) {
42                 goto fail;
43         }
44
45         /*
46          * This can't be a child of fsp because the file_handle can be ref'd
47          * when doing a dos/fcb open, which will then share the file_handle
48          * across multiple fsps.
49          */
50         fsp->fh = talloc_zero(mem_ctx, struct fd_handle);
51         if (fsp->fh == NULL) {
52                 goto fail;
53         }
54
55         fsp->fh->ref_count = 1;
56         fsp->fh->fd = -1;
57
58         fsp->fnum = FNUM_FIELD_INVALID;
59         fsp->conn = conn;
60
61         DLIST_ADD(sconn->files, fsp);
62         sconn->num_files += 1;
63
64         conn->num_files_open++;
65
66         *result = fsp;
67         return NT_STATUS_OK;
68
69 fail:
70         if (fsp != NULL) {
71                 TALLOC_FREE(fsp->fh);
72         }
73         TALLOC_FREE(fsp);
74
75         return status;
76 }
77
78 /****************************************************************************
79  Find first available file slot.
80 ****************************************************************************/
81
82 NTSTATUS file_new(struct smb_request *req, connection_struct *conn,
83                   files_struct **result)
84 {
85         struct smbd_server_connection *sconn = conn->sconn;
86         files_struct *fsp;
87         NTSTATUS status;
88
89         status = fsp_new(conn, conn, &fsp);
90         if (!NT_STATUS_IS_OK(status)) {
91                 return status;
92         }
93
94         GetTimeOfDay(&fsp->open_time);
95
96         if (sconn->conn) {
97                 struct smbXsrv_open *op = NULL;
98                 NTTIME now = timeval_to_nttime(&fsp->open_time);
99
100                 status = smbXsrv_open_create(sconn->conn,
101                                              conn->session_info,
102                                              now, &op);
103                 if (!NT_STATUS_IS_OK(status)) {
104                         file_free(NULL, fsp);
105                         return status;
106                 }
107                 fsp->op = op;
108                 op->compat = fsp;
109                 fsp->fnum = op->local_id;
110                 fsp->fh->gen_id = smbXsrv_open_hash(op);
111         }
112
113         /*
114          * Create an smb_filename with "" for the base_name.  There are very
115          * few NULL checks, so make sure it's initialized with something. to
116          * be safe until an audit can be done.
117          */
118         fsp->fsp_name = synthetic_smb_fname(fsp, "", NULL, NULL);
119         if (fsp->fsp_name == NULL) {
120                 file_free(NULL, fsp);
121                 return NT_STATUS_NO_MEMORY;
122         }
123
124         DEBUG(5,("allocated file structure %s (%u used)\n",
125                  fsp_fnum_dbg(fsp), (unsigned int)sconn->num_files));
126
127         if (req != NULL) {
128                 fsp->mid = req->mid;
129                 req->chain_fsp = fsp;
130         }
131
132         /* A new fsp invalidates the positive and
133           negative fsp_fi_cache as the new fsp is pushed
134           at the start of the list and we search from
135           a cache hit to the *end* of the list. */
136
137         ZERO_STRUCT(sconn->fsp_fi_cache);
138
139         *result = fsp;
140         return NT_STATUS_OK;
141 }
142
143 /****************************************************************************
144  Close all open files for a connection.
145 ****************************************************************************/
146
147 void file_close_conn(connection_struct *conn)
148 {
149         files_struct *fsp, *next;
150
151         for (fsp=conn->sconn->files; fsp; fsp=next) {
152                 next = fsp->next;
153                 if (fsp->conn != conn) {
154                         continue;
155                 }
156                 if (fsp->op != NULL && fsp->op->global->durable) {
157                         /*
158                          * A tree disconnect closes a durable handle
159                          */
160                         fsp->op->global->durable = false;
161                 }
162                 close_file(NULL, fsp, SHUTDOWN_CLOSE);
163         }
164 }
165
166 /****************************************************************************
167  Close all open files for a pid and a vuid.
168 ****************************************************************************/
169
170 void file_close_pid(struct smbd_server_connection *sconn, uint16 smbpid,
171                     uint64_t vuid)
172 {
173         files_struct *fsp, *next;
174
175         for (fsp=sconn->files;fsp;fsp=next) {
176                 next = fsp->next;
177                 if ((fsp->file_pid == smbpid) && (fsp->vuid == vuid)) {
178                         close_file(NULL, fsp, SHUTDOWN_CLOSE);
179                 }
180         }
181 }
182
183 /****************************************************************************
184  Initialise file structures.
185 ****************************************************************************/
186
187 static int files_max_open_fds;
188
189 bool file_init_global(void)
190 {
191         int request_max = lp_max_open_files();
192         int real_lim;
193         int real_max;
194
195         if (files_max_open_fds != 0) {
196                 return true;
197         }
198
199         /*
200          * Set the max_open files to be the requested
201          * max plus a fudgefactor to allow for the extra
202          * fd's we need such as log files etc...
203          */
204         real_lim = set_maxfiles(request_max + MAX_OPEN_FUDGEFACTOR);
205
206         real_max = real_lim - MAX_OPEN_FUDGEFACTOR;
207
208         if (real_max + FILE_HANDLE_OFFSET + MAX_OPEN_PIPES > 65536) {
209                 real_max = 65536 - FILE_HANDLE_OFFSET - MAX_OPEN_PIPES;
210         }
211
212         if (real_max != request_max) {
213                 DEBUG(1, ("file_init_global: Information only: requested %d "
214                           "open files, %d are available.\n",
215                           request_max, real_max));
216         }
217
218         SMB_ASSERT(real_max > 100);
219
220         files_max_open_fds = real_max;
221         return true;
222 }
223
224 bool file_init(struct smbd_server_connection *sconn)
225 {
226         bool ok;
227
228         ok = file_init_global();
229         if (!ok) {
230                 return false;
231         }
232
233         sconn->real_max_open_files = files_max_open_fds;
234
235         return true;
236 }
237
238 /****************************************************************************
239  Close files open by a specified vuid.
240 ****************************************************************************/
241
242 void file_close_user(struct smbd_server_connection *sconn, uint64_t vuid)
243 {
244         files_struct *fsp, *next;
245
246         for (fsp=sconn->files; fsp; fsp=next) {
247                 next=fsp->next;
248                 if (fsp->vuid == vuid) {
249                         close_file(NULL, fsp, SHUTDOWN_CLOSE);
250                 }
251         }
252 }
253
254 /*
255  * Walk the files table until "fn" returns non-NULL
256  */
257
258 struct files_struct *files_forall(
259         struct smbd_server_connection *sconn,
260         struct files_struct *(*fn)(struct files_struct *fsp,
261                                    void *private_data),
262         void *private_data)
263 {
264         struct files_struct *fsp, *next;
265
266         for (fsp = sconn->files; fsp; fsp = next) {
267                 struct files_struct *ret;
268                 next = fsp->next;
269                 ret = fn(fsp, private_data);
270                 if (ret != NULL) {
271                         return ret;
272                 }
273         }
274         return NULL;
275 }
276
277 /****************************************************************************
278  Find a fsp given a file descriptor.
279 ****************************************************************************/
280
281 files_struct *file_find_fd(struct smbd_server_connection *sconn, int fd)
282 {
283         int count=0;
284         files_struct *fsp;
285
286         for (fsp=sconn->files; fsp; fsp=fsp->next,count++) {
287                 if (fsp->fh->fd == fd) {
288                         if (count > 10) {
289                                 DLIST_PROMOTE(sconn->files, fsp);
290                         }
291                         return fsp;
292                 }
293         }
294
295         return NULL;
296 }
297
298 /****************************************************************************
299  Find a fsp given a device, inode and file_id.
300 ****************************************************************************/
301
302 files_struct *file_find_dif(struct smbd_server_connection *sconn,
303                             struct file_id id, unsigned long gen_id)
304 {
305         int count=0;
306         files_struct *fsp;
307
308         if (gen_id == 0) {
309                 return NULL;
310         }
311
312         for (fsp=sconn->files; fsp; fsp=fsp->next,count++) {
313                 /* We can have a fsp->fh->fd == -1 here as it could be a stat open. */
314                 if (file_id_equal(&fsp->file_id, &id) &&
315                     fsp->fh->gen_id == gen_id ) {
316                         if (count > 10) {
317                                 DLIST_PROMOTE(sconn->files, fsp);
318                         }
319                         /* Paranoia check. */
320                         if ((fsp->fh->fd == -1) &&
321                             (fsp->oplock_type != NO_OPLOCK)) {
322                                 DEBUG(0,("file_find_dif: file %s file_id = "
323                                          "%s, gen = %u oplock_type = %u is a "
324                                          "stat open with oplock type !\n",
325                                          fsp_str_dbg(fsp),
326                                          file_id_string_tos(&fsp->file_id),
327                                          (unsigned int)fsp->fh->gen_id,
328                                          (unsigned int)fsp->oplock_type ));
329                                 smb_panic("file_find_dif");
330                         }
331                         return fsp;
332                 }
333         }
334
335         return NULL;
336 }
337
338 /****************************************************************************
339  Find the first fsp given a device and inode.
340  We use a singleton cache here to speed up searching from getfilepathinfo
341  calls.
342 ****************************************************************************/
343
344 files_struct *file_find_di_first(struct smbd_server_connection *sconn,
345                                  struct file_id id)
346 {
347         files_struct *fsp;
348
349         if (file_id_equal(&sconn->fsp_fi_cache.id, &id)) {
350                 /* Positive or negative cache hit. */
351                 return sconn->fsp_fi_cache.fsp;
352         }
353
354         sconn->fsp_fi_cache.id = id;
355
356         for (fsp=sconn->files;fsp;fsp=fsp->next) {
357                 if (file_id_equal(&fsp->file_id, &id)) {
358                         /* Setup positive cache. */
359                         sconn->fsp_fi_cache.fsp = fsp;
360                         return fsp;
361                 }
362         }
363
364         /* Setup negative cache. */
365         sconn->fsp_fi_cache.fsp = NULL;
366         return NULL;
367 }
368
369 /****************************************************************************
370  Find the next fsp having the same device and inode.
371 ****************************************************************************/
372
373 files_struct *file_find_di_next(files_struct *start_fsp)
374 {
375         files_struct *fsp;
376
377         for (fsp = start_fsp->next;fsp;fsp=fsp->next) {
378                 if (file_id_equal(&fsp->file_id, &start_fsp->file_id)) {
379                         return fsp;
380                 }
381         }
382
383         return NULL;
384 }
385
386 /****************************************************************************
387  Find any fsp open with a pathname below that of an already open path.
388 ****************************************************************************/
389
390 bool file_find_subpath(files_struct *dir_fsp)
391 {
392         files_struct *fsp;
393         size_t dlen;
394         char *d_fullname = NULL;
395
396         d_fullname = talloc_asprintf(talloc_tos(), "%s/%s",
397                                      dir_fsp->conn->connectpath,
398                                      dir_fsp->fsp_name->base_name);
399
400         if (!d_fullname) {
401                 return false;
402         }
403
404         dlen = strlen(d_fullname);
405
406         for (fsp=dir_fsp->conn->sconn->files; fsp; fsp=fsp->next) {
407                 char *d1_fullname;
408
409                 if (fsp == dir_fsp) {
410                         continue;
411                 }
412
413                 d1_fullname = talloc_asprintf(talloc_tos(),
414                                         "%s/%s",
415                                         fsp->conn->connectpath,
416                                         fsp->fsp_name->base_name);
417
418                 /*
419                  * If the open file has a path that is a longer
420                  * component, then it's a subpath.
421                  */
422                 if (strnequal(d_fullname, d1_fullname, dlen) &&
423                                 (d1_fullname[dlen] == '/')) {
424                         TALLOC_FREE(d1_fullname);
425                         TALLOC_FREE(d_fullname);
426                         return true;
427                 }
428                 TALLOC_FREE(d1_fullname);
429         }
430
431         TALLOC_FREE(d_fullname);
432         return false;
433 }
434
435 /****************************************************************************
436  Sync open files on a connection.
437 ****************************************************************************/
438
439 void file_sync_all(connection_struct *conn)
440 {
441         files_struct *fsp, *next;
442
443         for (fsp=conn->sconn->files; fsp; fsp=next) {
444                 next=fsp->next;
445                 if ((conn == fsp->conn) && (fsp->fh->fd != -1)) {
446                         sync_file(conn, fsp, True /* write through */);
447                 }
448         }
449 }
450
451 /****************************************************************************
452  Free up a fsp.
453 ****************************************************************************/
454
455 void fsp_free(files_struct *fsp)
456 {
457         struct smbd_server_connection *sconn = fsp->conn->sconn;
458
459         DLIST_REMOVE(sconn->files, fsp);
460         SMB_ASSERT(sconn->num_files > 0);
461         sconn->num_files--;
462
463         TALLOC_FREE(fsp->fake_file_handle);
464
465         if (fsp->fh->ref_count == 1) {
466                 TALLOC_FREE(fsp->fh);
467         } else {
468                 fsp->fh->ref_count--;
469         }
470
471         fsp->conn->num_files_open--;
472
473         /* this is paranoia, just in case someone tries to reuse the
474            information */
475         ZERO_STRUCTP(fsp);
476
477         /* fsp->fsp_name is a talloc child and is free'd automatically. */
478         TALLOC_FREE(fsp);
479 }
480
481 void file_free(struct smb_request *req, files_struct *fsp)
482 {
483         struct smbd_server_connection *sconn = fsp->conn->sconn;
484         uint64_t fnum = fsp->fnum;
485
486         if (fsp->notify) {
487                 struct notify_context *notify_ctx =
488                         fsp->conn->sconn->notify_ctx;
489                 notify_remove(notify_ctx, fsp);
490                 TALLOC_FREE(fsp->notify);
491         }
492
493         /* Ensure this event will never fire. */
494         TALLOC_FREE(fsp->update_write_time_event);
495
496         if (fsp->op != NULL) {
497                 fsp->op->compat = NULL;
498         }
499         TALLOC_FREE(fsp->op);
500
501         if ((req != NULL) && (fsp == req->chain_fsp)) {
502                 req->chain_fsp = NULL;
503         }
504
505         /*
506          * Clear all possible chained fsp
507          * pointers in the SMB2 request queue.
508          */
509         if (req != NULL && req->smb2req) {
510                 remove_smb2_chained_fsp(fsp);
511         }
512
513         /* Closing a file can invalidate the positive cache. */
514         if (fsp == sconn->fsp_fi_cache.fsp) {
515                 ZERO_STRUCT(sconn->fsp_fi_cache);
516         }
517
518         /* Drop all remaining extensions. */
519         vfs_remove_all_fsp_extensions(fsp);
520
521         fsp_free(fsp);
522
523         DEBUG(5,("freed files structure %llu (%u used)\n",
524                  (unsigned long long)fnum, (unsigned int)sconn->num_files));
525 }
526
527 /****************************************************************************
528  Get an fsp from a packet given a 16 bit fnum.
529 ****************************************************************************/
530
531 files_struct *file_fsp(struct smb_request *req, uint16 fid)
532 {
533         struct smbXsrv_open *op;
534         NTSTATUS status;
535         NTTIME now = 0;
536         files_struct *fsp;
537
538         if (req == NULL) {
539                 /*
540                  * We should never get here. req==NULL could in theory
541                  * only happen from internal opens with a non-zero
542                  * root_dir_fid. Internal opens just don't do that, at
543                  * least they are not supposed to do so. And if they
544                  * start to do so, they better fake up a smb_request
545                  * from which we get the right smbd_server_conn. While
546                  * this should never happen, let's return NULL here.
547                  */
548                 return NULL;
549         }
550
551         if (req->chain_fsp != NULL) {
552                 if (req->chain_fsp->deferred_close) {
553                         return NULL;
554                 }
555                 return req->chain_fsp;
556         }
557
558         if (req->sconn->conn == NULL) {
559                 return NULL;
560         }
561
562         now = timeval_to_nttime(&req->request_time);
563
564         status = smb1srv_open_lookup(req->sconn->conn,
565                                      fid, now, &op);
566         if (!NT_STATUS_IS_OK(status)) {
567                 return NULL;
568         }
569
570         fsp = op->compat;
571         if (fsp == NULL) {
572                 return NULL;
573         }
574
575         if (fsp->deferred_close) {
576                 return NULL;
577         }
578
579         req->chain_fsp = fsp;
580         return fsp;
581 }
582
583 struct files_struct *file_fsp_get(struct smbd_smb2_request *smb2req,
584                                   uint64_t persistent_id,
585                                   uint64_t volatile_id)
586 {
587         struct smbXsrv_open *op;
588         NTSTATUS status;
589         NTTIME now = 0;
590         struct files_struct *fsp;
591
592         now = timeval_to_nttime(&smb2req->request_time);
593
594         status = smb2srv_open_lookup(smb2req->sconn->conn,
595                                      persistent_id, volatile_id,
596                                      now, &op);
597         if (!NT_STATUS_IS_OK(status)) {
598                 return NULL;
599         }
600
601         fsp = op->compat;
602         if (fsp == NULL) {
603                 return NULL;
604         }
605
606         if (smb2req->tcon == NULL) {
607                 return NULL;
608         }
609
610         if (smb2req->tcon->compat != fsp->conn) {
611                 return NULL;
612         }
613
614         if (smb2req->session == NULL) {
615                 return NULL;
616         }
617
618         if (smb2req->session->compat == NULL) {
619                 return NULL;
620         }
621
622         if (smb2req->session->compat->vuid != fsp->vuid) {
623                 return NULL;
624         }
625
626         if (fsp->deferred_close) {
627                 return NULL;
628         }
629
630         return fsp;
631 }
632
633 struct files_struct *file_fsp_smb2(struct smbd_smb2_request *smb2req,
634                                    uint64_t persistent_id,
635                                    uint64_t volatile_id)
636 {
637         struct files_struct *fsp;
638
639         if (smb2req->compat_chain_fsp != NULL) {
640                 if (smb2req->compat_chain_fsp->deferred_close) {
641                         return NULL;
642                 }
643                 return smb2req->compat_chain_fsp;
644         }
645
646         fsp = file_fsp_get(smb2req, persistent_id, volatile_id);
647         if (fsp == NULL) {
648                 return NULL;
649         }
650
651         smb2req->compat_chain_fsp = fsp;
652         return fsp;
653 }
654
655 /****************************************************************************
656  Duplicate the file handle part for a DOS or FCB open.
657 ****************************************************************************/
658
659 NTSTATUS dup_file_fsp(struct smb_request *req, files_struct *from,
660                       uint32 access_mask, uint32 share_access,
661                       uint32 create_options, files_struct *to)
662 {
663         /* this can never happen for print files */
664         SMB_ASSERT(from->print_file == NULL);
665
666         TALLOC_FREE(to->fh);
667
668         to->fh = from->fh;
669         to->fh->ref_count++;
670
671         to->file_id = from->file_id;
672         to->initial_allocation_size = from->initial_allocation_size;
673         to->file_pid = from->file_pid;
674         to->vuid = from->vuid;
675         to->open_time = from->open_time;
676         to->access_mask = access_mask;
677         to->share_access = share_access;
678         to->oplock_type = from->oplock_type;
679         to->can_lock = from->can_lock;
680         to->can_read = ((access_mask & FILE_READ_DATA) != 0);
681         to->can_write =
682                 CAN_WRITE(from->conn) &&
683                 ((access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) != 0);
684         to->modified = from->modified;
685         to->is_directory = from->is_directory;
686         to->aio_write_behind = from->aio_write_behind;
687
688         return fsp_set_smb_fname(to, from->fsp_name);
689 }
690
691 /**
692  * Return a jenkins hash of a pathname on a connection.
693  */
694
695 NTSTATUS file_name_hash(connection_struct *conn,
696                         const char *name, uint32_t *p_name_hash)
697 {
698         char tmpbuf[PATH_MAX];
699         char *fullpath, *to_free;
700         size_t len;
701
702         /* Set the hash of the full pathname. */
703
704         len = full_path_tos(conn->connectpath, name, tmpbuf, sizeof(tmpbuf),
705                             &fullpath, &to_free);
706         if (len == -1) {
707                 return NT_STATUS_NO_MEMORY;
708         }
709         *p_name_hash = hash(fullpath, len+1, 0);
710
711         DEBUG(10,("file_name_hash: %s hash 0x%x\n",
712                   fullpath,
713                 (unsigned int)*p_name_hash ));
714
715         TALLOC_FREE(to_free);
716         return NT_STATUS_OK;
717 }
718
719 /**
720  * The only way that the fsp->fsp_name field should ever be set.
721  */
722 NTSTATUS fsp_set_smb_fname(struct files_struct *fsp,
723                            const struct smb_filename *smb_fname_in)
724 {
725         struct smb_filename *smb_fname_new;
726
727         smb_fname_new = cp_smb_filename(fsp, smb_fname_in);
728         if (smb_fname_new == NULL) {
729                 return NT_STATUS_NO_MEMORY;
730         }
731
732         TALLOC_FREE(fsp->fsp_name);
733         fsp->fsp_name = smb_fname_new;
734
735         return file_name_hash(fsp->conn,
736                         smb_fname_str_dbg(fsp->fsp_name),
737                         &fsp->name_hash);
738 }