smbd: Use share_entry_stale_pid() in share_mode_stale_pid()
[samba.git] / source3 / locking / proto.h
1 /*
2  *  Unix SMB/CIFS implementation.
3  *  Locking functions
4  *
5  *  Copyright (C) Andrew Tridgell       1992-2000
6  *  Copyright (C) Jeremy Allison        1992-2006
7  *  Copyright (C) Volker Lendecke       2005
8  *
9  *  This program is free software; you can redistribute it and/or modify
10  *  it under the terms of the GNU General Public License as published by
11  *  the Free Software Foundation; either version 3 of the License, or
12  *  (at your option) any later version.
13  *
14  *  This program is distributed in the hope that it will be useful,
15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  *  GNU General Public License for more details.
18  *
19  *  You should have received a copy of the GNU General Public License
20  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
21  */
22
23 #ifndef _LOCKING_PROTO_H_
24 #define _LOCKING_PROTO_H_
25
26 /* The following definitions come from locking/brlock.c  */
27
28 void brl_init(bool read_only);
29 void brl_shutdown(void);
30
31 unsigned int brl_num_locks(const struct byte_range_lock *brl);
32 struct files_struct *brl_fsp(struct byte_range_lock *brl);
33 TALLOC_CTX *brl_req_mem_ctx(const struct byte_range_lock *brl);
34 const struct GUID *brl_req_guid(const struct byte_range_lock *brl);
35
36 bool byte_range_valid(uint64_t ofs, uint64_t len);
37 bool byte_range_overlap(uint64_t ofs1,
38                         uint64_t len1,
39                         uint64_t ofs2,
40                         uint64_t len2);
41
42 NTSTATUS brl_lock_windows_default(struct byte_range_lock *br_lck,
43                                   struct lock_struct *plock);
44
45 NTSTATUS brl_lock(
46         struct byte_range_lock *br_lck,
47         uint64_t smblctx,
48         struct server_id pid,
49         br_off start,
50         br_off size,
51         enum brl_type lock_type,
52         enum brl_flavour lock_flav,
53         struct server_id *blocker_pid,
54         uint64_t *psmblctx);
55 bool brl_unlock(struct byte_range_lock *br_lck,
56                 uint64_t smblctx,
57                 struct server_id pid,
58                 br_off start,
59                 br_off size,
60                 enum brl_flavour lock_flav);
61 bool brl_unlock_windows_default(struct byte_range_lock *br_lck,
62                                 const struct lock_struct *plock);
63 bool brl_locktest(struct byte_range_lock *br_lck,
64                   const struct lock_struct *rw_probe);
65 NTSTATUS brl_lockquery(struct byte_range_lock *br_lck,
66                 uint64_t *psmblctx,
67                 struct server_id pid,
68                 br_off *pstart,
69                 br_off *psize,
70                 enum brl_type *plock_type,
71                 enum brl_flavour lock_flav);
72 bool brl_mark_disconnected(struct files_struct *fsp);
73 bool brl_reconnect_disconnected(struct files_struct *fsp);
74 void brl_close_fnum(struct byte_range_lock *br_lck);
75 int brl_forall(void (*fn)(struct file_id id, struct server_id pid,
76                           enum brl_type lock_type,
77                           enum brl_flavour lock_flav,
78                           br_off start, br_off size,
79                           void *private_data),
80                void *private_data);
81 struct byte_range_lock *brl_get_locks_for_locking(TALLOC_CTX *mem_ctx,
82                                                   files_struct *fsp,
83                                                   TALLOC_CTX *req_mem_ctx,
84                                                   const struct GUID *req_guid);
85 struct byte_range_lock *brl_get_locks(TALLOC_CTX *mem_ctx,
86                                         files_struct *fsp);
87 struct byte_range_lock *brl_get_locks_readonly(files_struct *fsp);
88 bool brl_cleanup_disconnected(struct file_id fid, uint64_t open_persistent_id);
89
90 /* The following definitions come from locking/locking.c  */
91
92 const char *lock_type_name(enum brl_type lock_type);
93 const char *lock_flav_name(enum brl_flavour lock_flav);
94 void init_strict_lock_struct(files_struct *fsp,
95                                 uint64_t smblctx,
96                                 br_off start,
97                                 br_off size,
98                                 enum brl_type lock_type,
99                                 struct lock_struct *plock);
100 bool strict_lock_check_default(files_struct *fsp,
101                                struct lock_struct *plock);
102 NTSTATUS query_lock(files_struct *fsp,
103                         uint64_t *psmblctx,
104                         uint64_t *pcount,
105                         uint64_t *poffset,
106                         enum brl_type *plock_type,
107                         enum brl_flavour lock_flav);
108 NTSTATUS do_lock(files_struct *fsp,
109                  TALLOC_CTX *req_mem_ctx,
110                  const struct GUID *req_guid,
111                  uint64_t smblctx,
112                  uint64_t count,
113                  uint64_t offset,
114                  enum brl_type lock_type,
115                  enum brl_flavour lock_flav,
116                  struct server_id *pblocker_pid,
117                  uint64_t *psmblctx);
118 NTSTATUS do_unlock(files_struct *fsp,
119                    uint64_t smblctx,
120                    uint64_t count,
121                    uint64_t offset,
122                    enum brl_flavour lock_flav);
123 void locking_close_file(files_struct *fsp,
124                         enum file_close_type close_type);
125 bool locking_init(void);
126 bool locking_init_readonly(void);
127 bool locking_end(void);
128 char *share_mode_str(TALLOC_CTX *ctx, int num,
129                      const struct file_id *id,
130                      const struct share_mode_entry *e);
131 struct share_mode_lock *get_existing_share_mode_lock(TALLOC_CTX *mem_ctx,
132                                                      struct file_id id);
133 struct share_mode_lock *get_share_mode_lock(
134         TALLOC_CTX *mem_ctx,
135         struct file_id id,
136         const char *servicepath,
137         const struct smb_filename *smb_fname,
138         const struct timespec *old_write_time);
139
140 bool file_has_read_lease(struct files_struct *fsp);
141
142 struct db_record;
143 NTSTATUS share_mode_do_locked(
144         struct file_id id,
145         void (*fn)(struct db_record *rec,
146                    bool *modified_dependent,
147                    void *private_data),
148         void *private_data);
149 NTSTATUS share_mode_wakeup_waiters(struct file_id id);
150
151 struct share_mode_lock *fetch_share_mode_unlocked(TALLOC_CTX *mem_ctx,
152                                                   struct file_id id);
153 struct tevent_req *fetch_share_mode_send(TALLOC_CTX *mem_ctx,
154                                          struct tevent_context *ev,
155                                          struct file_id id,
156                                          bool *queued);
157 NTSTATUS fetch_share_mode_recv(struct tevent_req *req,
158                                TALLOC_CTX *mem_ctx,
159                                struct share_mode_lock **_lck);
160 bool rename_share_filename(struct messaging_context *msg_ctx,
161                         struct share_mode_lock *lck,
162                         struct file_id id,
163                         const char *servicepath,
164                         uint32_t orig_name_hash,
165                         uint32_t new_name_hash,
166                         const struct smb_filename *smb_fname);
167 void get_file_infos(struct file_id id,
168                     uint32_t name_hash,
169                     bool *delete_on_close,
170                     struct timespec *write_time);
171 bool is_valid_share_mode_entry(const struct share_mode_entry *e);
172 bool share_entry_stale_pid(struct share_mode_entry *e);
173 bool share_mode_stale_pid(struct share_mode_data *d, uint32_t idx);
174 bool set_share_mode(struct share_mode_lock *lck,
175                     struct files_struct *fsp,
176                     uid_t uid,
177                     uint64_t mid,
178                     uint16_t op_type,
179                     uint32_t share_access,
180                     uint32_t access_mask);
181 NTSTATUS remove_lease_if_stale(const struct share_mode_data *d,
182                                const struct GUID *client_guid,
183                                const struct smb2_lease_key *lease_key);
184 void remove_stale_share_mode_entries(struct share_mode_data *d);
185 bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp);
186 bool mark_share_mode_disconnected(struct share_mode_lock *lck,
187                                   struct files_struct *fsp);
188 bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp);
189 bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp);
190 bool get_delete_on_close_token(struct share_mode_lock *lck,
191                                 uint32_t name_hash,
192                                 const struct security_token **pp_nt_tok,
193                                 const struct security_unix_token **pp_tok);
194 void reset_delete_on_close_lck(files_struct *fsp,
195                                struct share_mode_lock *lck);
196 void set_delete_on_close_lck(files_struct *fsp,
197                         struct share_mode_lock *lck,
198                         const struct security_token *nt_tok,
199                         const struct security_unix_token *tok);
200 bool set_delete_on_close(files_struct *fsp, bool delete_on_close,
201                         const struct security_token *nt_tok,
202                         const struct security_unix_token *tok);
203 bool is_delete_on_close_set(struct share_mode_lock *lck, uint32_t name_hash);
204 bool set_sticky_write_time(struct file_id fileid, struct timespec write_time);
205 bool set_write_time(struct file_id fileid, struct timespec write_time);
206 struct timespec get_share_mode_write_time(struct share_mode_lock *lck);
207 bool file_has_open_streams(files_struct *fsp);
208 int share_mode_forall(int (*fn)(struct file_id fid,
209                                 const struct share_mode_data *data,
210                                 void *private_data),
211                       void *private_data);
212 int share_entry_forall(int (*fn)(struct file_id fid,
213                                  const struct share_mode_data *data,
214                                  const struct share_mode_entry *entry,
215                                  void *private_data),
216                       void *private_data);
217 bool share_mode_cleanup_disconnected(struct file_id id,
218                                      uint64_t open_persistent_id);
219 bool share_mode_forall_leases(
220         struct share_mode_lock *lck,
221         bool (*fn)(struct share_mode_lock *lck,
222                    struct share_mode_entry *e,
223                    void *private_data),
224         void *private_data);
225
226
227 /* The following definitions come from locking/posix.c  */
228
229 bool is_posix_locked(files_struct *fsp,
230                         uint64_t *pu_offset,
231                         uint64_t *pu_count,
232                         enum brl_type *plock_type,
233                         enum brl_flavour lock_flav);
234 bool posix_locking_init(bool read_only);
235 bool posix_locking_end(void);
236 int fd_close_posix(const struct files_struct *fsp);
237 bool set_posix_lock_windows_flavour(files_struct *fsp,
238                         uint64_t u_offset,
239                         uint64_t u_count,
240                         enum brl_type lock_type,
241                         const struct lock_context *lock_ctx,
242                         const struct lock_struct *plocks,
243                         int num_locks,
244                         int *errno_ret);
245 bool release_posix_lock_windows_flavour(files_struct *fsp,
246                                 uint64_t u_offset,
247                                 uint64_t u_count,
248                                 enum brl_type deleted_lock_type,
249                                 const struct lock_context *lock_ctx,
250                                 const struct lock_struct *plocks,
251                                 int num_locks);
252 bool set_posix_lock_posix_flavour(files_struct *fsp,
253                         uint64_t u_offset,
254                         uint64_t u_count,
255                         enum brl_type lock_type,
256                         const struct lock_context *lock_ctx,
257                         int *errno_ret);
258 bool release_posix_lock_posix_flavour(files_struct *fsp,
259                                 uint64_t u_offset,
260                                 uint64_t u_count,
261                                 const struct lock_context *lock_ctx,
262                                 const struct lock_struct *plocks,
263                                 int num_locks);
264
265 /* The following definitions come from locking/leases_util.c */
266 uint32_t map_oplock_to_lease_type(uint16_t op_type);
267 uint32_t fsp_lease_type(struct files_struct *fsp);
268 bool fsp_lease_type_is_exclusive(struct files_struct *fsp);
269 const struct GUID *fsp_client_guid(const files_struct *fsp);
270
271 #endif /* _LOCKING_PROTO_H_ */