smbd: Remove write cache
[samba.git] / source3 / smbd / globals.h
1 /*
2    Unix SMB/Netbios implementation.
3    smbd globals
4    Copyright (C) Stefan Metzmacher 2009
5    Copyright (C) Jeremy Allison 2010
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 #ifndef _SOURCE3_SMBD_GLOBALS_H_
22 #define _SOURCE3_SMBD_GLOBALS_H_
23
24 #include "system/select.h"
25 #include "librpc/gen_ndr/smbXsrv.h"
26 #include "smbprofile.h"
27
28 #ifdef USE_DMAPI
29 struct smbd_dmapi_context;
30 extern struct smbd_dmapi_context *dmapi_ctx;
31 #endif
32
33 /* A singleton cache to speed up searching by dev/inode. */
34 struct fsp_singleton_cache {
35         files_struct *fsp;
36         struct file_id id;
37 };
38
39 extern const struct mangle_fns *mangle_fns;
40
41 extern unsigned char *chartest;
42 struct tdb_context;
43 extern struct tdb_context *tdb_mangled_cache;
44
45 /*
46   this determines how many characters are used from the original filename
47   in the 8.3 mangled name. A larger value leads to a weaker hash and more collisions.
48   The largest possible value is 6.
49 */
50 extern unsigned mangle_prefix;
51
52 struct msg_state;
53
54 extern bool logged_ioctl_message;
55
56 extern int trans_num;
57
58 extern time_t last_smb_conf_reload_time;
59 extern time_t last_printer_reload_time;
60 extern pid_t background_lpq_updater_pid;
61
62 /****************************************************************************
63  structure to hold a linked list of queued messages.
64  for processing.
65 ****************************************************************************/
66 extern uint32_t common_flags2;
67
68 extern struct smb_trans_enc_state *partial_srv_trans_enc_ctx;
69 extern struct smb_trans_enc_state *srv_trans_enc_ctx;
70
71 struct sec_ctx {
72         struct security_unix_token ut;
73         struct security_token *token;
74 };
75 /* A stack of security contexts.  We include the current context as being
76    the first one, so there is room for another MAX_SEC_CTX_DEPTH more. */
77 extern struct sec_ctx sec_ctx_stack[MAX_SEC_CTX_DEPTH + 1];
78 extern int sec_ctx_stack_ndx;
79 extern bool become_uid_done;
80 extern bool become_gid_done;
81
82 extern connection_struct *last_conn;
83 extern uint16_t last_flags;
84
85 extern uint32_t global_client_caps;
86
87 extern uint16_t fnf_handle;
88
89 struct conn_ctx {
90         connection_struct *conn;
91         uint64_t vuid;
92         userdom_struct user_info;
93 };
94 /* A stack of current_user connection contexts. */
95 extern struct conn_ctx conn_ctx_stack[MAX_SEC_CTX_DEPTH];
96 extern int conn_ctx_stack_ndx;
97
98 struct vfs_init_function_entry;
99 extern struct vfs_init_function_entry *backends;
100 extern char *sparse_buf;
101 extern char *LastDir;
102
103 struct smbd_parent_context;
104 extern struct smbd_parent_context *am_parent;
105 extern struct memcache *smbd_memcache_ctx;
106 extern bool exit_firsttime;
107
108 struct tstream_context;
109 struct smbd_smb2_request;
110
111 DATA_BLOB negprot_spnego(TALLOC_CTX *ctx, struct smbXsrv_connection *xconn);
112
113 void smbd_lock_socket(struct smbXsrv_connection *xconn);
114 void smbd_unlock_socket(struct smbXsrv_connection *xconn);
115
116 struct GUID smbd_request_guid(struct smb_request *smb1req, uint16_t idx);
117
118 NTSTATUS smbd_do_unlocking(struct smb_request *req,
119                            files_struct *fsp,
120                            uint16_t num_ulocks,
121                            struct smbd_lock_element *ulocks,
122                            enum brl_flavour lock_flav);
123
124 NTSTATUS smbd_do_qfilepathinfo(connection_struct *conn,
125                                TALLOC_CTX *mem_ctx,
126                                struct smb_request *req,
127                                uint16_t info_level,
128                                files_struct *fsp,
129                                struct smb_filename *smb_fname,
130                                bool delete_pending,
131                                struct timespec write_time_ts,
132                                struct ea_list *ea_list,
133                                int lock_data_count,
134                                char *lock_data,
135                                uint16_t flags2,
136                                unsigned int max_data_bytes,
137                                size_t *fixed_portion,
138                                char **ppdata,
139                                unsigned int *pdata_size);
140
141 NTSTATUS smbd_do_setfsinfo(connection_struct *conn,
142                                 struct smb_request *req,
143                                 TALLOC_CTX *mem_ctx,
144                                 uint16_t info_level,
145                                 files_struct *fsp,
146                                 const DATA_BLOB *pdata);
147
148 NTSTATUS smbd_do_setfilepathinfo(connection_struct *conn,
149                                 struct smb_request *req,
150                                 TALLOC_CTX *mem_ctx,
151                                 uint16_t info_level,
152                                 files_struct *fsp,
153                                 struct smb_filename *smb_fname,
154                                 char **ppdata, int total_data,
155                                 int *ret_data_size);
156
157 NTSTATUS smbd_do_qfsinfo(struct smbXsrv_connection *xconn,
158                          connection_struct *conn,
159                          TALLOC_CTX *mem_ctx,
160                          uint16_t info_level,
161                          uint16_t flags2,
162                          unsigned int max_data_bytes,
163                          size_t *fixed_portion,
164                          struct smb_filename *smb_fname,
165                          char **ppdata,
166                          int *ret_data_len);
167
168 bool smbd_dirptr_get_entry(TALLOC_CTX *ctx,
169                            struct dptr_struct *dirptr,
170                            const char *mask,
171                            uint32_t dirtype,
172                            bool dont_descend,
173                            bool ask_sharemode,
174                            bool get_dosmode,
175                            bool (*match_fn)(TALLOC_CTX *ctx,
176                                             void *private_data,
177                                             const char *dname,
178                                             const char *mask,
179                                             char **_fname),
180                            bool (*mode_fn)(TALLOC_CTX *ctx,
181                                            void *private_data,
182                                            struct smb_filename *smb_fname,
183                                            bool get_dosmode,
184                                            uint32_t *_mode),
185                            void *private_data,
186                            char **_fname,
187                            struct smb_filename **_smb_fname,
188                            uint32_t *_mode,
189                            long *_prev_offset);
190
191 NTSTATUS smbd_dirptr_lanman2_entry(TALLOC_CTX *ctx,
192                                connection_struct *conn,
193                                struct dptr_struct *dirptr,
194                                uint16_t flags2,
195                                const char *path_mask,
196                                uint32_t dirtype,
197                                int info_level,
198                                int requires_resume_key,
199                                bool dont_descend,
200                                bool ask_sharemode,
201                                bool get_dosmode,
202                                uint8_t align,
203                                bool do_pad,
204                                char **ppdata,
205                                char *base_data,
206                                char *end_data,
207                                int space_remaining,
208                                struct smb_filename **smb_fname,
209                                bool *got_exact_match,
210                                int *_last_entry_off,
211                                struct ea_list *name_list,
212                                struct file_id *file_id);
213
214 NTSTATUS smbd_calculate_access_mask(connection_struct *conn,
215                                     const struct smb_filename *smb_fname,
216                                     bool use_privs,
217                                     uint32_t access_mask,
218                                     uint32_t *access_mask_out);
219
220 void smbd_notify_cancel_by_smbreq(const struct smb_request *smbreq);
221
222 void smbd_server_connection_terminate_ex(struct smbXsrv_connection *xconn,
223                                          const char *reason,
224                                          const char *location);
225 #define smbd_server_connection_terminate(xconn, reason) \
226         smbd_server_connection_terminate_ex(xconn, reason, __location__)
227
228 const char *smb2_opcode_name(uint16_t opcode);
229 bool smbd_is_smb2_header(const uint8_t *inbuf, size_t size);
230 bool smbd_smb2_is_compound(const struct smbd_smb2_request *req);
231
232 NTSTATUS smbd_add_connection(struct smbXsrv_client *client, int sock_fd,
233                              struct smbXsrv_connection **_xconn);
234
235 void reply_smb2002(struct smb_request *req, uint16_t choice);
236 void reply_smb20ff(struct smb_request *req, uint16_t choice);
237 void smbd_smb2_process_negprot(struct smbXsrv_connection *xconn,
238                                uint64_t expected_seq_low,
239                                const uint8_t *inpdu, size_t size);
240
241 DATA_BLOB smbd_smb2_generate_outbody(struct smbd_smb2_request *req, size_t size);
242
243 NTSTATUS smbd_smb2_request_error_ex(struct smbd_smb2_request *req,
244                                     NTSTATUS status,
245                                     DATA_BLOB *info,
246                                     const char *location);
247 #define smbd_smb2_request_error(req, status) \
248         smbd_smb2_request_error_ex(req, status, NULL, __location__)
249 NTSTATUS smbd_smb2_request_done_ex(struct smbd_smb2_request *req,
250                                    NTSTATUS status,
251                                    DATA_BLOB body, DATA_BLOB *dyn,
252                                    const char *location);
253 #define smbd_smb2_request_done(req, body, dyn) \
254         smbd_smb2_request_done_ex(req, NT_STATUS_OK, body, dyn, __location__)
255
256 NTSTATUS smbd_smb2_send_oplock_break(struct smbXsrv_connection *xconn,
257                                      struct smbXsrv_session *session,
258                                      struct smbXsrv_tcon *tcon,
259                                      struct smbXsrv_open *op,
260                                      uint8_t oplock_level);
261 NTSTATUS smbd_smb2_send_lease_break(struct smbXsrv_connection *xconn,
262                                     uint16_t new_epoch,
263                                     uint32_t lease_flags,
264                                     struct smb2_lease_key *lease_key,
265                                     uint32_t current_lease_state,
266                                     uint32_t new_lease_state);
267
268 NTSTATUS smbd_smb2_request_pending_queue(struct smbd_smb2_request *req,
269                                          struct tevent_req *subreq,
270                                          uint32_t defer_time);
271
272 struct smb_request *smbd_smb2_fake_smb_request(struct smbd_smb2_request *req);
273 size_t smbd_smb2_unread_bytes(struct smbd_smb2_request *req);
274 void remove_smb2_chained_fsp(files_struct *fsp);
275
276 NTSTATUS smbd_smb2_request_verify_creditcharge(struct smbd_smb2_request *req,
277                                                uint32_t data_length);
278
279 NTSTATUS smbd_smb2_request_verify_sizes(struct smbd_smb2_request *req,
280                                         size_t expected_body_size);
281
282 void smb2_request_set_async_internal(struct smbd_smb2_request *req,
283                                      bool async_internal);
284
285 enum protocol_types smbd_smb2_protocol_dialect_match(const uint8_t *indyn,
286                                                      const int dialect_count,
287                                                      uint16_t *dialect);
288 NTSTATUS smbd_smb2_request_process_negprot(struct smbd_smb2_request *req);
289 NTSTATUS smbd_smb2_request_process_sesssetup(struct smbd_smb2_request *req);
290 NTSTATUS smbd_smb2_request_process_logoff(struct smbd_smb2_request *req);
291 NTSTATUS smbd_smb2_request_process_tcon(struct smbd_smb2_request *req);
292 NTSTATUS smbd_smb2_request_process_tdis(struct smbd_smb2_request *req);
293 NTSTATUS smbd_smb2_request_process_create(struct smbd_smb2_request *req);
294 NTSTATUS smbd_smb2_request_process_close(struct smbd_smb2_request *req);
295 NTSTATUS smbd_smb2_request_process_flush(struct smbd_smb2_request *req);
296 NTSTATUS smbd_smb2_request_process_read(struct smbd_smb2_request *req);
297 NTSTATUS smb2_read_complete(struct tevent_req *req, ssize_t nread, int err);
298 NTSTATUS smbd_smb2_request_process_write(struct smbd_smb2_request *req);
299 NTSTATUS smb2_write_complete(struct tevent_req *req, ssize_t nwritten, int err);
300 NTSTATUS smb2_write_complete_nosync(struct tevent_req *req, ssize_t nwritten,
301                                     int err);
302 NTSTATUS smbd_smb2_request_process_lock(struct smbd_smb2_request *req);
303 NTSTATUS smbd_smb2_request_process_ioctl(struct smbd_smb2_request *req);
304 NTSTATUS smbd_smb2_request_process_keepalive(struct smbd_smb2_request *req);
305 NTSTATUS smbd_smb2_request_process_query_directory(struct smbd_smb2_request *req);
306 NTSTATUS smbd_smb2_request_process_notify(struct smbd_smb2_request *req);
307 NTSTATUS smbd_smb2_request_process_getinfo(struct smbd_smb2_request *req);
308 NTSTATUS smbd_smb2_request_process_setinfo(struct smbd_smb2_request *req);
309 NTSTATUS smbd_smb2_request_process_break(struct smbd_smb2_request *req);
310 NTSTATUS smbd_smb2_request_dispatch(struct smbd_smb2_request *req);
311 void smbd_smb2_request_dispatch_immediate(struct tevent_context *ctx,
312                                 struct tevent_immediate *im,
313                                 void *private_data);
314
315 struct deferred_open_record;
316
317 /* SMB1 -> SMB2 glue. */
318 void send_break_message_smb2(files_struct *fsp,
319                              uint32_t break_from,
320                              uint32_t break_to);
321 /* From smbd/smb2_create.c */
322 int map_smb2_oplock_levels_to_samba(uint8_t in_oplock_level);
323 bool get_deferred_open_message_state_smb2(struct smbd_smb2_request *smb2req,
324                         struct timeval *p_request_time,
325                         struct deferred_open_record **open_rec);
326 bool open_was_deferred_smb2(
327         struct smbXsrv_connection *xconn, uint64_t mid);
328 void remove_deferred_open_message_smb2(
329         struct smbXsrv_connection *xconn, uint64_t mid);
330 bool schedule_deferred_open_message_smb2(
331         struct smbXsrv_connection *xconn, uint64_t mid);
332 bool push_deferred_open_message_smb2(struct smbd_smb2_request *smb2req,
333                                 struct timeval request_time,
334                                 struct timeval timeout,
335                                 struct file_id id,
336                                 struct deferred_open_record *open_rec);
337
338 struct smbXsrv_client;
339
340 struct smbXsrv_preauth {
341         uint8_t sha512_value[64];
342 };
343
344 struct smbXsrv_connection {
345         struct smbXsrv_connection *prev, *next;
346
347         struct smbXsrv_client *client;
348
349         const struct tsocket_address *local_address;
350         const struct tsocket_address *remote_address;
351         const char *remote_hostname;
352
353         enum protocol_types protocol;
354
355         struct {
356                 NTSTATUS status;
357                 int sock;
358                 struct tevent_fd *fde;
359
360                 struct {
361                         bool got_session;
362                 } nbt;
363         } transport;
364
365         struct {
366                 struct {
367                         /*
368                          * fd for the fcntl lock and process shared
369                          * robust mutex to coordinate access to the
370                          * client socket. When the system supports
371                          * process shared robust mutexes, those are
372                          * used. If not, then the fcntl lock will be
373                          * used.
374                          */
375                         int socket_lock_fd;
376 #ifdef HAVE_ROBUST_MUTEXES
377                         pthread_mutex_t *socket_mutex;
378 #endif
379
380                         /*
381                          * fd for the trusted pipe from
382                          * echo handler child
383                          */
384                         int trusted_fd;
385
386                         /*
387                          * fde for the trusted_fd
388                          */
389                         struct tevent_fd *trusted_fde;
390
391                         /*
392                          * Reference count for the fcntl lock to
393                          * allow recursive locks.
394                          */
395                         int ref_count;
396                 } echo_handler;
397
398                 struct {
399                         bool encrypted_passwords;
400                         bool spnego;
401                         struct auth4_context *auth_context;
402                         bool done;
403                         /*
404                          * Size of the data we can receive. Set by us.
405                          * Can be modified by the max xmit parameter.
406                          */
407                         int max_recv;
408                 } negprot;
409
410                 struct {
411                         bool done_sesssetup;
412                         /*
413                          * Size of data we can send to client. Set
414                          *  by the client for all protocols above CORE.
415                          *  Set by us for CORE protocol.
416                          */
417                         int max_send;
418                 } sessions;
419                 struct smb_signing_state *signing_state;
420
421                 struct {
422                         uint16_t client_major;
423                         uint16_t client_minor;
424                         uint32_t client_cap_low;
425                         uint32_t client_cap_high;
426                 } unix_info;
427
428                 struct msg_state *msg_state;
429         } smb1;
430         struct {
431                 struct smbd_smb2_request_read_state {
432                         struct smbd_smb2_request *req;
433                         struct {
434                                 uint8_t nbt[NBT_HDR_SIZE];
435                                 bool done;
436                         } hdr;
437                         struct iovec vector;
438                         bool doing_receivefile;
439                         size_t min_recv_size;
440                         size_t pktfull;
441                         size_t pktlen;
442                         uint8_t *pktbuf;
443                 } request_read_state;
444                 struct smbd_smb2_send_queue *send_queue;
445                 size_t send_queue_len;
446
447                 struct {
448                         /*
449                          * seq_low is the lowest sequence number
450                          * we will accept.
451                          */
452                         uint64_t seq_low;
453                         /*
454                          * seq_range is the range of credits we have
455                          * granted from the sequence windows starting
456                          * at seq_low.
457                          *
458                          * This gets incremented when new credits are
459                          * granted and gets decremented when the
460                          * lowest sequence number is consumed
461                          * (when seq_low gets incremented).
462                          */
463                         uint16_t seq_range;
464                         /*
465                          * The number of credits we have currently granted
466                          * to the client.
467                          *
468                          * This gets incremented when new credits are
469                          * granted and gets decremented when any credit
470                          * is comsumed.
471                          *
472                          * Note: the decrementing is different compared
473                          *       to seq_range.
474                          */
475                         uint16_t granted;
476                         /*
477                          * The maximum number of credits we will ever
478                          * grant to the client.
479                          *
480                          * Typically we will only grant 1/16th of
481                          * max_credits.
482                          *
483                          * This is the "server max credits" parameter.
484                          */
485                         uint16_t max;
486                         /*
487                          * a bitmap of size max_credits
488                          */
489                         struct bitmap *bitmap;
490                         bool multicredit;
491                 } credits;
492
493                 bool allow_2ff;
494                 struct {
495                         uint32_t capabilities;
496                         struct GUID guid;
497                         bool guid_verified;
498                         uint16_t security_mode;
499                         uint16_t num_dialects;
500                         uint16_t *dialects;
501                 } client;
502                 struct {
503                         uint32_t capabilities;
504                         struct GUID guid;
505                         uint16_t security_mode;
506                         uint16_t dialect;
507                         uint32_t max_trans;
508                         uint32_t max_read;
509                         uint32_t max_write;
510                         uint16_t cipher;
511                 } server;
512
513                 struct smbXsrv_preauth preauth;
514
515                 struct smbd_smb2_request *requests;
516         } smb2;
517 };
518
519 const char *smbXsrv_connection_dbg(const struct smbXsrv_connection *xconn);
520
521 NTSTATUS smbXsrv_version_global_init(const struct server_id *server_id);
522 uint32_t smbXsrv_version_global_current(void);
523
524 struct smbXsrv_client_table;
525 NTSTATUS smbXsrv_client_global_init(void);
526 NTSTATUS smbXsrv_client_create(TALLOC_CTX *mem_ctx,
527                                struct tevent_context *ev_ctx,
528                                struct messaging_context *msg_ctx,
529                                NTTIME now,
530                                struct smbXsrv_client **_client);
531 NTSTATUS smbXsrv_client_update(struct smbXsrv_client *client);
532 NTSTATUS smbXsrv_client_remove(struct smbXsrv_client *client);
533 NTSTATUS smb2srv_client_lookup_global(struct smbXsrv_client *client,
534                                       struct GUID client_guid,
535                                       TALLOC_CTX *mem_ctx,
536                                       struct smbXsrv_client_global0 **_pass);
537 NTSTATUS smb2srv_client_connection_pass(struct smbd_smb2_request *smb2req,
538                                         struct smbXsrv_client_global0 *global);
539
540 NTSTATUS smbXsrv_connection_init_tables(struct smbXsrv_connection *conn,
541                                         enum protocol_types protocol);
542
543 NTSTATUS smbXsrv_session_global_init(struct messaging_context *msg_ctx);
544 NTSTATUS smbXsrv_session_create(struct smbXsrv_connection *conn,
545                                 NTTIME now,
546                                 struct smbXsrv_session **_session);
547 NTSTATUS smbXsrv_session_add_channel(struct smbXsrv_session *session,
548                                      struct smbXsrv_connection *conn,
549                                      struct smbXsrv_channel_global0 **_c);
550 NTSTATUS smbXsrv_session_update(struct smbXsrv_session *session);
551 struct smbXsrv_channel_global0;
552 NTSTATUS smbXsrv_session_find_channel(const struct smbXsrv_session *session,
553                                       const struct smbXsrv_connection *conn,
554                                       struct smbXsrv_channel_global0 **_c);
555 NTSTATUS smbXsrv_session_find_auth(const struct smbXsrv_session *session,
556                                    const struct smbXsrv_connection *conn,
557                                    NTTIME now,
558                                    struct smbXsrv_session_auth0 **_a);
559 NTSTATUS smbXsrv_session_create_auth(struct smbXsrv_session *session,
560                                      struct smbXsrv_connection *conn,
561                                      NTTIME now,
562                                      uint8_t in_flags,
563                                      uint8_t in_security_mode,
564                                      struct smbXsrv_session_auth0 **_a);
565 struct tevent_req *smb2srv_session_shutdown_send(TALLOC_CTX *mem_ctx,
566                                         struct tevent_context *ev,
567                                         struct smbXsrv_session *session,
568                                         struct smbd_smb2_request *current_req);
569 NTSTATUS smb2srv_session_shutdown_recv(struct tevent_req *req);
570 NTSTATUS smbXsrv_session_logoff(struct smbXsrv_session *session);
571 NTSTATUS smbXsrv_session_logoff_all(struct smbXsrv_client *client);
572 NTSTATUS smb1srv_session_table_init(struct smbXsrv_connection *conn);
573 NTSTATUS smb1srv_session_lookup(struct smbXsrv_connection *conn,
574                                 uint16_t vuid, NTTIME now,
575                                 struct smbXsrv_session **session);
576 NTSTATUS smb2srv_session_table_init(struct smbXsrv_connection *conn);
577 NTSTATUS smb2srv_session_lookup_conn(struct smbXsrv_connection *conn,
578                                      uint64_t session_id, NTTIME now,
579                                      struct smbXsrv_session **session);
580 NTSTATUS smb2srv_session_lookup_client(struct smbXsrv_client *client,
581                                        uint64_t session_id, NTTIME now,
582                                        struct smbXsrv_session **session);
583 struct smbXsrv_session_global0;
584 NTSTATUS smbXsrv_session_global_traverse(
585                         int (*fn)(struct smbXsrv_session_global0 *, void *),
586                         void *private_data);
587 struct tevent_req *smb2srv_session_close_previous_send(TALLOC_CTX *mem_ctx,
588                                         struct tevent_context *ev,
589                                         struct smbXsrv_connection *conn,
590                                         struct auth_session_info *session_info,
591                                         uint64_t previous_session_id,
592                                         uint64_t current_session_id);
593 NTSTATUS smb2srv_session_close_previous_recv(struct tevent_req *req);
594
595 NTSTATUS smbXsrv_tcon_global_init(void);
596 NTSTATUS smbXsrv_tcon_update(struct smbXsrv_tcon *tcon);
597 NTSTATUS smbXsrv_tcon_disconnect(struct smbXsrv_tcon *tcon, uint64_t vuid);
598 NTSTATUS smb1srv_tcon_table_init(struct smbXsrv_connection *conn);
599 NTSTATUS smb1srv_tcon_create(struct smbXsrv_connection *conn,
600                              NTTIME now,
601                              struct smbXsrv_tcon **_tcon);
602 NTSTATUS smb1srv_tcon_lookup(struct smbXsrv_connection *conn,
603                              uint16_t tree_id, NTTIME now,
604                              struct smbXsrv_tcon **tcon);
605 NTSTATUS smb1srv_tcon_disconnect_all(struct smbXsrv_client *client);
606 NTSTATUS smb2srv_tcon_table_init(struct smbXsrv_session *session);
607 NTSTATUS smb2srv_tcon_create(struct smbXsrv_session *session,
608                              NTTIME now,
609                              struct smbXsrv_tcon **_tcon);
610 NTSTATUS smb2srv_tcon_lookup(struct smbXsrv_session *session,
611                              uint32_t tree_id, NTTIME now,
612                              struct smbXsrv_tcon **tcon);
613 NTSTATUS smb2srv_tcon_disconnect_all(struct smbXsrv_session *session);
614 struct smbXsrv_tcon_global0;
615 NTSTATUS smbXsrv_tcon_global_traverse(
616                         int (*fn)(struct smbXsrv_tcon_global0 *, void *),
617                         void *private_data);
618
619 NTSTATUS smbXsrv_open_global_init(void);
620 NTSTATUS smbXsrv_open_create(struct smbXsrv_connection *conn,
621                              struct auth_session_info *session_info,
622                              NTTIME now,
623                              struct smbXsrv_open **_open);
624 NTSTATUS smbXsrv_open_update(struct smbXsrv_open *_open);
625 NTSTATUS smbXsrv_open_close(struct smbXsrv_open *op, NTTIME now);
626 NTSTATUS smb1srv_open_table_init(struct smbXsrv_connection *conn);
627 NTSTATUS smb1srv_open_lookup(struct smbXsrv_connection *conn,
628                              uint16_t fnum, NTTIME now,
629                              struct smbXsrv_open **_open);
630 NTSTATUS smb2srv_open_table_init(struct smbXsrv_connection *conn);
631 NTSTATUS smb2srv_open_lookup(struct smbXsrv_connection *conn,
632                              uint64_t persistent_id,
633                              uint64_t volatile_id,
634                              NTTIME now,
635                              struct smbXsrv_open **_open);
636 NTSTATUS smb2srv_open_lookup_replay_cache(struct smbXsrv_connection *conn,
637                                           const struct GUID *create_guid,
638                                           NTTIME now,
639                                           struct smbXsrv_open **_open);
640 NTSTATUS smb2srv_open_recreate(struct smbXsrv_connection *conn,
641                                struct auth_session_info *session_info,
642                                uint64_t persistent_id,
643                                const struct GUID *create_guid,
644                                NTTIME now,
645                                struct smbXsrv_open **_open);
646 struct smbXsrv_open_global0;
647 NTSTATUS smbXsrv_open_global_traverse(
648         int (*fn)(struct smbXsrv_open_global0 *, void *),
649         void *private_data);
650
651 NTSTATUS smbXsrv_open_cleanup(uint64_t persistent_id);
652 bool smbXsrv_is_encrypted(uint8_t encryption_flags);
653 bool smbXsrv_is_partially_encrypted(uint8_t encryption_flags);
654 bool smbXsrv_set_crypto_flag(uint8_t *flags, uint8_t flag);
655 bool smbXsrv_is_signed(uint8_t signing_flags);
656 bool smbXsrv_is_partially_signed(uint8_t signing_flags);
657
658 struct smbd_smb2_send_queue {
659         struct smbd_smb2_send_queue *prev, *next;
660
661         DATA_BLOB *sendfile_header;
662         NTSTATUS *sendfile_status;
663         struct iovec *vector;
664         int count;
665
666         TALLOC_CTX *mem_ctx;
667 };
668
669 struct smbd_smb2_request {
670         struct smbd_smb2_request *prev, *next;
671
672         struct smbd_server_connection *sconn;
673         struct smbXsrv_connection *xconn;
674
675         struct smbd_smb2_send_queue queue_entry;
676
677         /* the session the request operates on, maybe NULL */
678         struct smbXsrv_session *session;
679         uint64_t last_session_id;
680
681         /* the tcon the request operates on, maybe NULL */
682         struct smbXsrv_tcon *tcon;
683         uint32_t last_tid;
684
685         int current_idx;
686         bool do_signing;
687         /* Was the request encrypted? */
688         bool was_encrypted;
689         /* Should we encrypt? */
690         bool do_encryption;
691         struct tevent_timer *async_te;
692         bool compound_related;
693
694         /*
695          * Give the implementation of an SMB2 req a way to tell the SMB2 request
696          * processing engine that the internal request is going async, while
697          * preserving synchronous SMB2 behaviour.
698          */
699         bool async_internal;
700
701         /*
702          * the encryption key for the whole
703          * compound chain
704          */
705         DATA_BLOB first_key;
706         /*
707          * the signing key for the last
708          * request/response of a compound chain
709          */
710         DATA_BLOB last_key;
711         struct smbXsrv_preauth *preauth;
712
713         struct timeval request_time;
714
715         SMBPROFILE_IOBYTES_ASYNC_STATE(profile);
716
717         /* fake smb1 request. */
718         struct smb_request *smb1req;
719         struct files_struct *compat_chain_fsp;
720
721         /*
722          * Keep track of whether the outstanding request counters
723          * had been updated in dispatch, so that they need to be
724          * adapted again in reply.
725          */
726         bool request_counters_updated;
727         uint64_t channel_generation;
728
729         /*
730          * The sub request for async backend calls.
731          * This is used for SMB2 Cancel.
732          */
733         struct tevent_req *subreq;
734
735 #define SMBD_SMB2_TF_IOV_OFS 0
736 #define SMBD_SMB2_HDR_IOV_OFS 1
737 #define SMBD_SMB2_BODY_IOV_OFS 2
738 #define SMBD_SMB2_DYN_IOV_OFS 3
739
740 #define SMBD_SMB2_NUM_IOV_PER_REQ 4
741
742 #define SMBD_SMB2_IOV_IDX_OFS(req,dir,idx,ofs) \
743         (&req->dir.vector[(idx)+(ofs)])
744
745 #define SMBD_SMB2_IDX_TF_IOV(req,dir,idx) \
746         SMBD_SMB2_IOV_IDX_OFS(req,dir,idx,SMBD_SMB2_TF_IOV_OFS)
747 #define SMBD_SMB2_IDX_HDR_IOV(req,dir,idx) \
748         SMBD_SMB2_IOV_IDX_OFS(req,dir,idx,SMBD_SMB2_HDR_IOV_OFS)
749 #define SMBD_SMB2_IDX_BODY_IOV(req,dir,idx) \
750         SMBD_SMB2_IOV_IDX_OFS(req,dir,idx,SMBD_SMB2_BODY_IOV_OFS)
751 #define SMBD_SMB2_IDX_DYN_IOV(req,dir,idx) \
752         SMBD_SMB2_IOV_IDX_OFS(req,dir,idx,SMBD_SMB2_DYN_IOV_OFS)
753
754 #define SMBD_SMB2_IN_TF_IOV(req)    SMBD_SMB2_IDX_TF_IOV(req,in,req->current_idx)
755 #define SMBD_SMB2_IN_TF_PTR(req)    (uint8_t *)(SMBD_SMB2_IN_TF_IOV(req)->iov_base)
756 #define SMBD_SMB2_IN_HDR_IOV(req)    SMBD_SMB2_IDX_HDR_IOV(req,in,req->current_idx)
757 #define SMBD_SMB2_IN_HDR_PTR(req)    (uint8_t *)(SMBD_SMB2_IN_HDR_IOV(req)->iov_base)
758 #define SMBD_SMB2_IN_BODY_IOV(req)   SMBD_SMB2_IDX_BODY_IOV(req,in,req->current_idx)
759 #define SMBD_SMB2_IN_BODY_PTR(req)   (uint8_t *)(SMBD_SMB2_IN_BODY_IOV(req)->iov_base)
760 #define SMBD_SMB2_IN_BODY_LEN(req)   (SMBD_SMB2_IN_BODY_IOV(req)->iov_len)
761 #define SMBD_SMB2_IN_DYN_IOV(req)    SMBD_SMB2_IDX_DYN_IOV(req,in,req->current_idx)
762 #define SMBD_SMB2_IN_DYN_PTR(req)    (uint8_t *)(SMBD_SMB2_IN_DYN_IOV(req)->iov_base)
763 #define SMBD_SMB2_IN_DYN_LEN(req)    (SMBD_SMB2_IN_DYN_IOV(req)->iov_len)
764
765 #define SMBD_SMB2_OUT_TF_IOV(req)   SMBD_SMB2_IDX_TF_IOV(req,out,req->current_idx)
766 #define SMBD_SMB2_OUT_TF_PTR(req)   (uint8_t *)(SMBD_SMB2_OUT_TF_IOV(req)->iov_base)
767 #define SMBD_SMB2_OUT_HDR_IOV(req)   SMBD_SMB2_IDX_HDR_IOV(req,out,req->current_idx)
768 #define SMBD_SMB2_OUT_HDR_PTR(req)   (uint8_t *)(SMBD_SMB2_OUT_HDR_IOV(req)->iov_base)
769 #define SMBD_SMB2_OUT_BODY_IOV(req)  SMBD_SMB2_IDX_BODY_IOV(req,out,req->current_idx)
770 #define SMBD_SMB2_OUT_BODY_PTR(req)  (uint8_t *)(SMBD_SMB2_OUT_BODY_IOV(req)->iov_base)
771 #define SMBD_SMB2_OUT_BODY_LEN(req)  (SMBD_SMB2_OUT_BODY_IOV(req)->iov_len)
772 #define SMBD_SMB2_OUT_DYN_IOV(req)   SMBD_SMB2_IDX_DYN_IOV(req,out,req->current_idx)
773 #define SMBD_SMB2_OUT_DYN_PTR(req)   (uint8_t *)(SMBD_SMB2_OUT_DYN_IOV(req)->iov_base)
774 #define SMBD_SMB2_OUT_DYN_LEN(req)   (SMBD_SMB2_OUT_DYN_IOV(req)->iov_len)
775
776 #define SMBD_SMB2_SHORT_RECEIVEFILE_WRITE_LEN (SMB2_HDR_BODY + 0x30)
777
778         struct {
779                 /*
780                  * vector[0] TRANSPORT HEADER (empty)
781                  * .
782                  * vector[1] SMB2_TRANSFORM (optional)
783                  * vector[2] SMB2
784                  * vector[3] fixed body
785                  * vector[4] dynamic body
786                  * .
787                  * .
788                  * .
789                  * vector[5] SMB2_TRANSFORM (optional)
790                  * vector[6] SMB2
791                  * vector[7] fixed body
792                  * vector[8] dynamic body
793                  * .
794                  * .
795                  * .
796                  */
797                 struct iovec *vector;
798                 int vector_count;
799                 struct iovec _vector[1 + SMBD_SMB2_NUM_IOV_PER_REQ];
800         } in;
801         struct {
802                 /* the NBT header is not allocated */
803                 uint8_t nbt_hdr[4];
804                 /*
805                  * vector[0] TRANSPORT HEADER
806                  * .
807                  * vector[1] SMB2_TRANSFORM (optional)
808                  * vector[2] SMB2
809                  * vector[3] fixed body
810                  * vector[4] dynamic body
811                  * .
812                  * .
813                  * .
814                  * vector[5] SMB2_TRANSFORM (empty)
815                  * vector[6] SMB2
816                  * vector[7] fixed body
817                  * vector[8] dynamic body
818                  * .
819                  * .
820                  * .
821                  */
822                 struct iovec *vector;
823                 int vector_count;
824                 struct iovec _vector[1 + SMBD_SMB2_NUM_IOV_PER_REQ];
825 #define OUTVEC_ALLOC_SIZE (SMB2_HDR_BODY + 9)
826                 uint8_t _hdr[OUTVEC_ALLOC_SIZE];
827                 uint8_t _body[0x58];
828         } out;
829 };
830
831 struct smbd_server_connection;
832 struct user_struct;
833
834 struct pending_message_list;
835 struct pending_auth_data;
836
837 struct user_struct {
838         struct user_struct *next, *prev;
839         uint64_t vuid; /* Tag for this entry. */
840
841         char *session_keystr; /* used by utmp and pam session code.
842                                  TDB key string */
843         int homes_snum;
844
845         struct auth_session_info *session_info;
846
847         struct smbXsrv_session *session;
848 };
849
850 struct pthreadpool_tevent;
851
852 struct smbd_server_connection {
853         const struct tsocket_address *local_address;
854         const struct tsocket_address *remote_address;
855         const char *remote_hostname;
856         struct tevent_context *ev_ctx;
857         struct messaging_context *msg_ctx;
858         struct notify_context *notify_ctx;
859         bool using_smb2;
860         int trans_num;
861
862         size_t num_users;
863         struct user_struct *users;
864
865         size_t num_connections;
866         struct connection_struct *connections;
867
868         size_t num_files;
869         struct files_struct *files;
870
871         int real_max_open_files;
872         struct fsp_singleton_cache fsp_fi_cache;
873
874         struct pending_message_list *deferred_open_queue;
875
876
877         /* open directory handles. */
878         struct {
879                 struct bitmap *dptr_bmap;
880                 struct dptr_struct *dirptrs;
881         } searches;
882
883         uint64_t num_requests;
884
885         /* Current number of oplocks we have outstanding. */
886         struct {
887                 int32_t exclusive_open;
888                 int32_t level_II_open;
889                 struct kernel_oplocks *kernel_ops;
890         } oplocks;
891
892         struct {
893                 struct notify_mid_map *notify_mid_maps;
894         } smb1;
895
896         struct pthreadpool_tevent *pool;
897
898         struct smbXsrv_client *client;
899 };
900
901 extern struct smbXsrv_client *global_smbXsrv_client;
902
903 void smbd_init_globals(void);
904
905 #endif /* _SOURCE3_SMBD_GLOBALS_H_ */