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 size_t smbXsrv_client_valid_connections(struct smbXsrv_client *client); 223 void smbd_server_connection_terminate_ex(struct smbXsrv_connection *xconn, 224 const char *reason, 225 const char *location); 226 #define smbd_server_connection_terminate(xconn, reason) \ 227 smbd_server_connection_terminate_ex(xconn, reason, __location__) 228 229 const char *smb2_opcode_name(uint16_t opcode); 230 bool smbd_is_smb2_header(const uint8_t *inbuf, size_t size); 231 bool smbd_smb2_is_compound(const struct smbd_smb2_request *req); 232 233 NTSTATUS smbd_add_connection(struct smbXsrv_client *client, int sock_fd, 234 struct smbXsrv_connection **_xconn); 235 236 NTSTATUS reply_smb2002(struct smb_request *req, uint16_t choice); 237 NTSTATUS reply_smb20ff(struct smb_request *req, uint16_t choice); 238 NTSTATUS smbd_smb2_process_negprot(struct smbXsrv_connection *xconn, 239 uint64_t expected_seq_low, 240 const uint8_t *inpdu, size_t size); 241 242 DATA_BLOB smbd_smb2_generate_outbody(struct smbd_smb2_request *req, size_t size); 243 244 NTSTATUS smbd_smb2_request_error_ex(struct smbd_smb2_request *req, 245 NTSTATUS status, 246 DATA_BLOB *info, 247 const char *location); 248 #define smbd_smb2_request_error(req, status) \ 249 smbd_smb2_request_error_ex(req, status, NULL, __location__) 250 NTSTATUS smbd_smb2_request_done_ex(struct smbd_smb2_request *req, 251 NTSTATUS status, 252 DATA_BLOB body, DATA_BLOB *dyn, 253 const char *location); 254 #define smbd_smb2_request_done(req, body, dyn) \ 255 smbd_smb2_request_done_ex(req, NT_STATUS_OK, body, dyn, __location__) 256 257 NTSTATUS smbd_smb2_send_oplock_break(struct smbXsrv_connection *xconn, 258 struct smbXsrv_session *session, 259 struct smbXsrv_tcon *tcon, 260 struct smbXsrv_open *op, 261 uint8_t oplock_level); 262 NTSTATUS smbd_smb2_send_lease_break(struct smbXsrv_connection *xconn, 263 uint16_t new_epoch, 264 uint32_t lease_flags, 265 struct smb2_lease_key *lease_key, 266 uint32_t current_lease_state, 267 uint32_t new_lease_state); 268 269 NTSTATUS smbd_smb2_request_pending_queue(struct smbd_smb2_request *req, 270 struct tevent_req *subreq, 271 uint32_t defer_time); 272 273 struct smb_request *smbd_smb2_fake_smb_request(struct smbd_smb2_request *req); 274 size_t smbd_smb2_unread_bytes(struct smbd_smb2_request *req); 275 void remove_smb2_chained_fsp(files_struct *fsp); 276 277 NTSTATUS smbd_smb2_request_verify_creditcharge(struct smbd_smb2_request *req, 278 uint32_t data_length); 279 280 NTSTATUS smbd_smb2_request_verify_sizes(struct smbd_smb2_request *req, 281 size_t expected_body_size); 282 283 void smb2_request_set_async_internal(struct smbd_smb2_request *req, 284 bool async_internal); 285 286 enum protocol_types smbd_smb2_protocol_dialect_match(const uint8_t *indyn, 287 const int dialect_count, 288 uint16_t *dialect); 289 NTSTATUS smbd_smb2_request_process_negprot(struct smbd_smb2_request *req); 290 NTSTATUS smbd_smb2_request_process_sesssetup(struct smbd_smb2_request *req); 291 NTSTATUS smbd_smb2_request_process_logoff(struct smbd_smb2_request *req); 292 NTSTATUS smbd_smb2_request_process_tcon(struct smbd_smb2_request *req); 293 NTSTATUS smbd_smb2_request_process_tdis(struct smbd_smb2_request *req); 294 NTSTATUS smbd_smb2_request_process_create(struct smbd_smb2_request *req); 295 NTSTATUS smbd_smb2_request_process_close(struct smbd_smb2_request *req); 296 NTSTATUS smbd_smb2_request_process_flush(struct smbd_smb2_request *req); 297 NTSTATUS smbd_smb2_request_process_read(struct smbd_smb2_request *req); 298 NTSTATUS smb2_read_complete(struct tevent_req *req, ssize_t nread, int err); 299 NTSTATUS smbd_smb2_request_process_write(struct smbd_smb2_request *req); 300 NTSTATUS smb2_write_complete(struct tevent_req *req, ssize_t nwritten, int err); 301 NTSTATUS smb2_write_complete_nosync(struct tevent_req *req, ssize_t nwritten, 302 int err); 303 NTSTATUS smbd_smb2_request_process_lock(struct smbd_smb2_request *req); 304 NTSTATUS smbd_smb2_request_process_ioctl(struct smbd_smb2_request *req); 305 NTSTATUS smbd_smb2_request_process_keepalive(struct smbd_smb2_request *req); 306 NTSTATUS smbd_smb2_request_process_query_directory(struct smbd_smb2_request *req); 307 NTSTATUS smbd_smb2_request_process_notify(struct smbd_smb2_request *req); 308 NTSTATUS smbd_smb2_request_process_getinfo(struct smbd_smb2_request *req); 309 NTSTATUS smbd_smb2_request_process_setinfo(struct smbd_smb2_request *req); 310 NTSTATUS smbd_smb2_request_process_break(struct smbd_smb2_request *req); 311 NTSTATUS smbd_smb2_request_dispatch(struct smbd_smb2_request *req); 312 void smbd_smb2_request_dispatch_immediate(struct tevent_context *ctx, 313 struct tevent_immediate *im, 314 void *private_data); 315 316 struct deferred_open_record; 317 318 /* SMB1 -> SMB2 glue. */ 319 void send_break_message_smb2(files_struct *fsp, 320 uint32_t break_from, 321 uint32_t break_to); 322 /* From smbd/smb2_create.c */ 323 int map_smb2_oplock_levels_to_samba(uint8_t in_oplock_level); 324 bool get_deferred_open_message_state_smb2(struct smbd_smb2_request *smb2req, 325 struct timeval *p_request_time, 326 struct deferred_open_record **open_rec); 327 bool open_was_deferred_smb2( 328 struct smbXsrv_connection *xconn, uint64_t mid); 329 void remove_deferred_open_message_smb2( 330 struct smbXsrv_connection *xconn, uint64_t mid); 331 bool schedule_deferred_open_message_smb2( 332 struct smbXsrv_connection *xconn, uint64_t mid); 333 bool push_deferred_open_message_smb2(struct smbd_smb2_request *smb2req, 334 struct timeval request_time, 335 struct timeval timeout, 336 struct file_id id, 337 struct deferred_open_record *open_rec); 338 339 struct smbXsrv_client; 340 341 struct smbXsrv_preauth { 342 uint8_t sha512_value[64]; 343 }; 344 345 struct smbXsrv_connection { 346 struct smbXsrv_connection *prev, *next; 347 348 struct smbXsrv_client *client; 349 350 const struct tsocket_address *local_address; 351 const struct tsocket_address *remote_address; 352 const char *remote_hostname; 353 354 enum protocol_types protocol; 355 356 struct { 357 NTSTATUS status; 358 int sock; 359 struct tevent_fd *fde; 360 361 struct { 362 bool got_session; 363 } nbt; 364 } transport; 365 366 struct { 367 struct { 368 /* 369 * fd for the fcntl lock and process shared 370 * robust mutex to coordinate access to the 371 * client socket. When the system supports 372 * process shared robust mutexes, those are 373 * used. If not, then the fcntl lock will be 374 * used. 375 */ 376 int socket_lock_fd; 377 #ifdef HAVE_ROBUST_MUTEXES 378 pthread_mutex_t *socket_mutex; 379 #endif 380 381 /* 382 * fd for the trusted pipe from 383 * echo handler child 384 */ 385 int trusted_fd; 386 387 /* 388 * fde for the trusted_fd 389 */ 390 struct tevent_fd *trusted_fde; 391 392 /* 393 * Reference count for the fcntl lock to 394 * allow recursive locks. 395 */ 396 int ref_count; 397 } echo_handler; 398 399 struct { 400 bool encrypted_passwords; 401 bool spnego; 402 struct auth4_context *auth_context; 403 bool done; 404 /* 405 * Size of the data we can receive. Set by us. 406 * Can be modified by the max xmit parameter. 407 */ 408 int max_recv; 409 } negprot; 410 411 struct { 412 bool done_sesssetup; 413 /* 414 * Size of data we can send to client. Set 415 * by the client for all protocols above CORE. 416 * Set by us for CORE protocol. 417 */ 418 int max_send; 419 } sessions; 420 struct smb_signing_state *signing_state; 421 422 struct { 423 uint16_t client_major; 424 uint16_t client_minor; 425 uint32_t client_cap_low; 426 uint32_t client_cap_high; 427 } unix_info; 428 429 struct msg_state *msg_state; 430 } smb1; 431 struct { 432 struct smbd_smb2_request_read_state { 433 struct smbd_smb2_request *req; 434 struct { 435 uint8_t nbt[NBT_HDR_SIZE]; 436 bool done; 437 } hdr; 438 struct iovec vector; 439 bool doing_receivefile; 440 size_t min_recv_size; 441 size_t pktfull; 442 size_t pktlen; 443 uint8_t *pktbuf; 444 } request_read_state; 445 struct smbd_smb2_send_queue *send_queue; 446 size_t send_queue_len; 447 448 struct { 449 /* 450 * seq_low is the lowest sequence number 451 * we will accept. 452 */ 453 uint64_t seq_low; 454 /* 455 * seq_range is the range of credits we have 456 * granted from the sequence windows starting 457 * at seq_low. 458 * 459 * This gets incremented when new credits are 460 * granted and gets decremented when the 461 * lowest sequence number is consumed 462 * (when seq_low gets incremented). 463 */ 464 uint16_t seq_range; 465 /* 466 * The number of credits we have currently granted 467 * to the client. 468 * 469 * This gets incremented when new credits are 470 * granted and gets decremented when any credit 471 * is comsumed. 472 * 473 * Note: the decrementing is different compared 474 * to seq_range. 475 */ 476 uint16_t granted; 477 /* 478 * The maximum number of credits we will ever 479 * grant to the client. 480 * 481 * Typically we will only grant 1/16th of 482 * max_credits. 483 * 484 * This is the "server max credits" parameter. 485 */ 486 uint16_t max; 487 /* 488 * a bitmap of size max_credits 489 */ 490 struct bitmap *bitmap; 491 bool multicredit; 492 } credits; 493 494 bool allow_2ff; 495 struct { 496 uint32_t capabilities; 497 struct GUID guid; 498 bool guid_verified; 499 uint16_t security_mode; 500 uint16_t num_dialects; 501 uint16_t *dialects; 502 } client; 503 struct { 504 uint32_t capabilities; 505 struct GUID guid; 506 uint16_t security_mode; 507 uint16_t dialect; 508 uint32_t max_trans; 509 uint32_t max_read; 510 uint32_t max_write; 511 uint16_t cipher; 512 } server; 513 514 struct smbXsrv_preauth preauth; 515 516 struct smbd_smb2_request *requests; 517 } smb2; 518 }; 519 520 const char *smbXsrv_connection_dbg(const struct smbXsrv_connection *xconn); 521 522 NTSTATUS smbXsrv_version_global_init(const struct server_id *server_id); 523 uint32_t smbXsrv_version_global_current(void); 524 525 struct smbXsrv_client_table; 526 NTSTATUS smbXsrv_client_global_init(void); 527 NTSTATUS smbXsrv_client_create(TALLOC_CTX *mem_ctx, 528 struct tevent_context *ev_ctx, 529 struct messaging_context *msg_ctx, 530 NTTIME now, 531 struct smbXsrv_client **_client); 532 NTSTATUS smbXsrv_client_update(struct smbXsrv_client *client); 533 NTSTATUS smbXsrv_client_remove(struct smbXsrv_client *client); 534 NTSTATUS smb2srv_client_lookup_global(struct smbXsrv_client *client, 535 struct GUID client_guid, 536 TALLOC_CTX *mem_ctx, 537 struct smbXsrv_client_global0 **_pass); 538 NTSTATUS smb2srv_client_connection_pass(struct smbd_smb2_request *smb2req, 539 struct smbXsrv_client_global0 *global); 540 541 NTSTATUS smbXsrv_connection_init_tables(struct smbXsrv_connection *conn, 542 enum protocol_types protocol); 543 544 NTSTATUS smbXsrv_session_global_init(struct messaging_context *msg_ctx); 545 NTSTATUS smbXsrv_session_create(struct smbXsrv_connection *conn, 546 NTTIME now, 547 struct smbXsrv_session **_session); 548 NTSTATUS smbXsrv_session_add_channel(struct smbXsrv_session *session, 549 struct smbXsrv_connection *conn, 550 struct smbXsrv_channel_global0 **_c); 551 NTSTATUS smbXsrv_session_update(struct smbXsrv_session *session); 552 struct smbXsrv_channel_global0; 553 NTSTATUS smbXsrv_session_find_channel(const struct smbXsrv_session *session, 554 const struct smbXsrv_connection *conn, 555 struct smbXsrv_channel_global0 **_c); 556 NTSTATUS smbXsrv_session_find_auth(const struct smbXsrv_session *session, 557 const struct smbXsrv_connection *conn, 558 NTTIME now, 559 struct smbXsrv_session_auth0 **_a); 560 NTSTATUS smbXsrv_session_create_auth(struct smbXsrv_session *session, 561 struct smbXsrv_connection *conn, 562 NTTIME now, 563 uint8_t in_flags, 564 uint8_t in_security_mode, 565 struct smbXsrv_session_auth0 **_a); 566 struct tevent_req *smb2srv_session_shutdown_send(TALLOC_CTX *mem_ctx, 567 struct tevent_context *ev, 568 struct smbXsrv_session *session, 569 struct smbd_smb2_request *current_req); 570 NTSTATUS smb2srv_session_shutdown_recv(struct tevent_req *req); 571 NTSTATUS smbXsrv_session_logoff(struct smbXsrv_session *session); 572 NTSTATUS smbXsrv_session_logoff_all(struct smbXsrv_client *client); 573 NTSTATUS smb1srv_session_table_init(struct smbXsrv_connection *conn); 574 NTSTATUS smb1srv_session_lookup(struct smbXsrv_connection *conn, 575 uint16_t vuid, NTTIME now, 576 struct smbXsrv_session **session); 577 NTSTATUS smbXsrv_session_info_lookup(struct smbXsrv_client *client, 578 uint64_t session_wire_id, 579 struct auth_session_info **si); 580 NTSTATUS smb2srv_session_table_init(struct smbXsrv_connection *conn); 581 NTSTATUS smb2srv_session_lookup_conn(struct smbXsrv_connection *conn, 582 uint64_t session_id, NTTIME now, 583 struct smbXsrv_session **session); 584 NTSTATUS smb2srv_session_lookup_client(struct smbXsrv_client *client, 585 uint64_t session_id, NTTIME now, 586 struct smbXsrv_session **session); 587 NTSTATUS get_valid_smbXsrv_session(struct smbXsrv_client *client, 588 uint64_t session_wire_id, 589 struct smbXsrv_session **session); 590 NTSTATUS smbXsrv_session_local_traverse( 591 struct smbXsrv_client *client, 592 int (*caller_cb)(struct smbXsrv_session *session, 593 void *caller_data), 594 void *caller_data); 595 struct smbXsrv_session_global0; 596 NTSTATUS smbXsrv_session_global_traverse( 597 int (*fn)(struct smbXsrv_session_global0 *, void *), 598 void *private_data); 599 struct tevent_req *smb2srv_session_close_previous_send(TALLOC_CTX *mem_ctx, 600 struct tevent_context *ev, 601 struct smbXsrv_connection *conn, 602 struct auth_session_info *session_info, 603 uint64_t previous_session_id, 604 uint64_t current_session_id); 605 NTSTATUS smb2srv_session_close_previous_recv(struct tevent_req *req); 606 607 NTSTATUS smbXsrv_tcon_global_init(void); 608 NTSTATUS smbXsrv_tcon_update(struct smbXsrv_tcon *tcon); 609 NTSTATUS smbXsrv_tcon_disconnect(struct smbXsrv_tcon *tcon, uint64_t vuid); 610 NTSTATUS smb1srv_tcon_table_init(struct smbXsrv_connection *conn); 611 NTSTATUS smb1srv_tcon_create(struct smbXsrv_connection *conn, 612 NTTIME now, 613 struct smbXsrv_tcon **_tcon); 614 NTSTATUS smb1srv_tcon_lookup(struct smbXsrv_connection *conn, 615 uint16_t tree_id, NTTIME now, 616 struct smbXsrv_tcon **tcon); 617 NTSTATUS smb1srv_tcon_disconnect_all(struct smbXsrv_client *client); 618 NTSTATUS smb2srv_tcon_table_init(struct smbXsrv_session *session); 619 NTSTATUS smb2srv_tcon_create(struct smbXsrv_session *session, 620 NTTIME now, 621 struct smbXsrv_tcon **_tcon); 622 NTSTATUS smb2srv_tcon_lookup(struct smbXsrv_session *session, 623 uint32_t tree_id, NTTIME now, 624 struct smbXsrv_tcon **tcon); 625 NTSTATUS smb2srv_tcon_disconnect_all(struct smbXsrv_session *session); 626 struct smbXsrv_tcon_global0; 627 NTSTATUS smbXsrv_tcon_global_traverse( 628 int (*fn)(struct smbXsrv_tcon_global0 *, void *), 629 void *private_data); 630 631 NTSTATUS smbXsrv_open_global_init(void); 632 NTSTATUS smbXsrv_open_create(struct smbXsrv_connection *conn, 633 struct auth_session_info *session_info, 634 NTTIME now, 635 struct smbXsrv_open **_open); 636 NTSTATUS smbXsrv_open_update(struct smbXsrv_open *_open); 637 NTSTATUS smbXsrv_open_close(struct smbXsrv_open *op, NTTIME now); 638 NTSTATUS smb1srv_open_table_init(struct smbXsrv_connection *conn); 639 NTSTATUS smb1srv_open_lookup(struct smbXsrv_connection *conn, 640 uint16_t fnum, NTTIME now, 641 struct smbXsrv_open **_open); 642 NTSTATUS smb2srv_open_table_init(struct smbXsrv_connection *conn); 643 NTSTATUS smb2srv_open_lookup(struct smbXsrv_connection *conn, 644 uint64_t persistent_id, 645 uint64_t volatile_id, 646 NTTIME now, 647 struct smbXsrv_open **_open); 648 NTSTATUS smb2srv_open_lookup_replay_cache(struct smbXsrv_connection *conn, 649 const struct GUID *create_guid, 650 NTTIME now, 651 struct smbXsrv_open **_open); 652 NTSTATUS smb2srv_open_recreate(struct smbXsrv_connection *conn, 653 struct auth_session_info *session_info, 654 uint64_t persistent_id, 655 const struct GUID *create_guid, 656 NTTIME now, 657 struct smbXsrv_open **_open); 658 struct smbXsrv_open_global0; 659 NTSTATUS smbXsrv_open_global_traverse( 660 int (*fn)(struct smbXsrv_open_global0 *, void *), 661 void *private_data); 662 663 NTSTATUS smbXsrv_open_cleanup(uint64_t persistent_id); 664 bool smbXsrv_is_encrypted(uint8_t encryption_flags); 665 bool smbXsrv_is_partially_encrypted(uint8_t encryption_flags); 666 bool smbXsrv_set_crypto_flag(uint8_t *flags, uint8_t flag); 667 bool smbXsrv_is_signed(uint8_t signing_flags); 668 bool smbXsrv_is_partially_signed(uint8_t signing_flags); 669 670 struct smbd_smb2_send_queue { 671 struct smbd_smb2_send_queue *prev, *next; 672 673 DATA_BLOB *sendfile_header; 674 NTSTATUS *sendfile_status; 675 struct iovec *vector; 676 int count; 677 678 TALLOC_CTX *mem_ctx; 679 }; 680 681 struct smbd_smb2_request { 682 struct smbd_smb2_request *prev, *next; 683 684 struct smbd_server_connection *sconn; 685 struct smbXsrv_connection *xconn; 686 687 struct smbd_smb2_send_queue queue_entry; 688 689 /* the session the request operates on, maybe NULL */ 690 struct smbXsrv_session *session; 691 uint64_t last_session_id; 692 693 /* the tcon the request operates on, maybe NULL */ 694 struct smbXsrv_tcon *tcon; 695 uint32_t last_tid; 696 697 int current_idx; 698 bool do_signing; 699 /* Was the request encrypted? */ 700 bool was_encrypted; 701 /* Should we encrypt? */ 702 bool do_encryption; 703 struct tevent_timer *async_te; 704 bool compound_related; 705 706 /* 707 * Give the implementation of an SMB2 req a way to tell the SMB2 request 708 * processing engine that the internal request is going async, while 709 * preserving synchronous SMB2 behaviour. 710 */ 711 bool async_internal; 712 713 /* 714 * the encryption key for the whole 715 * compound chain 716 */ 717 DATA_BLOB first_key; 718 /* 719 * the signing key for the last 720 * request/response of a compound chain 721 */ 722 DATA_BLOB last_key; 723 struct smbXsrv_preauth *preauth; 724 725 struct timeval request_time; 726 727 SMBPROFILE_IOBYTES_ASYNC_STATE(profile); 728 729 /* fake smb1 request. */ 730 struct smb_request *smb1req; 731 struct files_struct *compat_chain_fsp; 732 733 /* 734 * Keep track of whether the outstanding request counters 735 * had been updated in dispatch, so that they need to be 736 * adapted again in reply. 737 */ 738 bool request_counters_updated; 739 uint64_t channel_generation; 740 741 /* 742 * The sub request for async backend calls. 743 * This is used for SMB2 Cancel. 744 */ 745 struct tevent_req *subreq; 746 747 #define SMBD_SMB2_TF_IOV_OFS 0 748 #define SMBD_SMB2_HDR_IOV_OFS 1 749 #define SMBD_SMB2_BODY_IOV_OFS 2 750 #define SMBD_SMB2_DYN_IOV_OFS 3 751 752 #define SMBD_SMB2_NUM_IOV_PER_REQ 4 753 754 #define SMBD_SMB2_IOV_IDX_OFS(req,dir,idx,ofs) \ 755 (&req->dir.vector[(idx)+(ofs)]) 756 757 #define SMBD_SMB2_IDX_TF_IOV(req,dir,idx) \ 758 SMBD_SMB2_IOV_IDX_OFS(req,dir,idx,SMBD_SMB2_TF_IOV_OFS) 759 #define SMBD_SMB2_IDX_HDR_IOV(req,dir,idx) \ 760 SMBD_SMB2_IOV_IDX_OFS(req,dir,idx,SMBD_SMB2_HDR_IOV_OFS) 761 #define SMBD_SMB2_IDX_BODY_IOV(req,dir,idx) \ 762 SMBD_SMB2_IOV_IDX_OFS(req,dir,idx,SMBD_SMB2_BODY_IOV_OFS) 763 #define SMBD_SMB2_IDX_DYN_IOV(req,dir,idx) \ 764 SMBD_SMB2_IOV_IDX_OFS(req,dir,idx,SMBD_SMB2_DYN_IOV_OFS) 765 766 #define SMBD_SMB2_IN_TF_IOV(req) SMBD_SMB2_IDX_TF_IOV(req,in,req->current_idx) 767 #define SMBD_SMB2_IN_TF_PTR(req) (uint8_t *)(SMBD_SMB2_IN_TF_IOV(req)->iov_base) 768 #define SMBD_SMB2_IN_HDR_IOV(req) SMBD_SMB2_IDX_HDR_IOV(req,in,req->current_idx) 769 #define SMBD_SMB2_IN_HDR_PTR(req) (uint8_t *)(SMBD_SMB2_IN_HDR_IOV(req)->iov_base) 770 #define SMBD_SMB2_IN_BODY_IOV(req) SMBD_SMB2_IDX_BODY_IOV(req,in,req->current_idx) 771 #define SMBD_SMB2_IN_BODY_PTR(req) (uint8_t *)(SMBD_SMB2_IN_BODY_IOV(req)->iov_base) 772 #define SMBD_SMB2_IN_BODY_LEN(req) (SMBD_SMB2_IN_BODY_IOV(req)->iov_len) 773 #define SMBD_SMB2_IN_DYN_IOV(req) SMBD_SMB2_IDX_DYN_IOV(req,in,req->current_idx) 774 #define SMBD_SMB2_IN_DYN_PTR(req) (uint8_t *)(SMBD_SMB2_IN_DYN_IOV(req)->iov_base) 775 #define SMBD_SMB2_IN_DYN_LEN(req) (SMBD_SMB2_IN_DYN_IOV(req)->iov_len) 776 777 #define SMBD_SMB2_OUT_TF_IOV(req) SMBD_SMB2_IDX_TF_IOV(req,out,req->current_idx) 778 #define SMBD_SMB2_OUT_TF_PTR(req) (uint8_t *)(SMBD_SMB2_OUT_TF_IOV(req)->iov_base) 779 #define SMBD_SMB2_OUT_HDR_IOV(req) SMBD_SMB2_IDX_HDR_IOV(req,out,req->current_idx) 780 #define SMBD_SMB2_OUT_HDR_PTR(req) (uint8_t *)(SMBD_SMB2_OUT_HDR_IOV(req)->iov_base) 781 #define SMBD_SMB2_OUT_BODY_IOV(req) SMBD_SMB2_IDX_BODY_IOV(req,out,req->current_idx) 782 #define SMBD_SMB2_OUT_BODY_PTR(req) (uint8_t *)(SMBD_SMB2_OUT_BODY_IOV(req)->iov_base) 783 #define SMBD_SMB2_OUT_BODY_LEN(req) (SMBD_SMB2_OUT_BODY_IOV(req)->iov_len) 784 #define SMBD_SMB2_OUT_DYN_IOV(req) SMBD_SMB2_IDX_DYN_IOV(req,out,req->current_idx) 785 #define SMBD_SMB2_OUT_DYN_PTR(req) (uint8_t *)(SMBD_SMB2_OUT_DYN_IOV(req)->iov_base) 786 #define SMBD_SMB2_OUT_DYN_LEN(req) (SMBD_SMB2_OUT_DYN_IOV(req)->iov_len) 787 788 #define SMBD_SMB2_SHORT_RECEIVEFILE_WRITE_LEN (SMB2_HDR_BODY + 0x30) 789 790 struct { 791 /* 792 * vector[0] TRANSPORT HEADER (empty) 793 * . 794 * vector[1] SMB2_TRANSFORM (optional) 795 * vector[2] SMB2 796 * vector[3] fixed body 797 * vector[4] dynamic body 798 * . 799 * . 800 * . 801 * vector[5] SMB2_TRANSFORM (optional) 802 * vector[6] SMB2 803 * vector[7] fixed body 804 * vector[8] dynamic body 805 * . 806 * . 807 * . 808 */ 809 struct iovec *vector; 810 int vector_count; 811 struct iovec _vector[1 + SMBD_SMB2_NUM_IOV_PER_REQ]; 812 } in; 813 struct { 814 /* the NBT header is not allocated */ 815 uint8_t nbt_hdr[4]; 816 /* 817 * vector[0] TRANSPORT HEADER 818 * . 819 * vector[1] SMB2_TRANSFORM (optional) 820 * vector[2] SMB2 821 * vector[3] fixed body 822 * vector[4] dynamic body 823 * . 824 * . 825 * . 826 * vector[5] SMB2_TRANSFORM (empty) 827 * vector[6] SMB2 828 * vector[7] fixed body 829 * vector[8] dynamic body 830 * . 831 * . 832 * . 833 */ 834 struct iovec *vector; 835 int vector_count; 836 struct iovec _vector[1 + SMBD_SMB2_NUM_IOV_PER_REQ]; 837 #define OUTVEC_ALLOC_SIZE (SMB2_HDR_BODY + 9) 838 uint8_t _hdr[OUTVEC_ALLOC_SIZE]; 839 uint8_t _body[0x58]; 840 } out; 841 }; 842 843 struct smbd_server_connection; 844 845 struct pending_message_list; 846 struct pending_auth_data; 847 848 struct pthreadpool_tevent; 849 850 struct smbd_server_connection { 851 const struct tsocket_address *local_address; 852 const struct tsocket_address *remote_address; 853 const char *remote_hostname; 854 struct tevent_context *ev_ctx; 855 struct messaging_context *msg_ctx; 856 struct notify_context *notify_ctx; 857 bool using_smb2; 858 int trans_num; 859 860 size_t num_users; 861 862 size_t num_connections; 863 struct connection_struct *connections; 864 865 size_t num_files; 866 struct files_struct *files; 867 868 int real_max_open_files; 869 struct fsp_singleton_cache fsp_fi_cache; 870 871 struct pending_message_list *deferred_open_queue; 872 873 874 /* open directory handles. */ 875 struct { 876 struct bitmap *dptr_bmap; 877 struct dptr_struct *dirptrs; 878 } searches; 879 880 uint64_t num_requests; 881 882 /* Current number of oplocks we have outstanding. */ 883 struct { 884 int32_t exclusive_open; 885 int32_t level_II_open; 886 struct kernel_oplocks *kernel_ops; 887 } oplocks; 888 889 struct { 890 struct notify_mid_map *notify_mid_maps; 891 } smb1; 892 893 struct pthreadpool_tevent *pool; 894 895 struct smbXsrv_client *client; 896 }; 897 898 extern struct smbXsrv_client *global_smbXsrv_client; 899 900 void smbd_init_globals(void); 901 902 #endif /* _SOURCE3_SMBD_GLOBALS_H_ */ 903