summaryrefslogtreecommitdiff
path: root/source3/smbd/globals.c
blob: 3f8cb411e562b289014583392719b5db67bd84da (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
/*
   Unix SMB/Netbios implementation.
   smbd globals
   Copyright (C) Stefan Metzmacher 2009

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "includes.h"
#include "smbd/globals.h"

#if defined(WITH_AIO)
struct aio_extra *aio_list_head = NULL;
struct tevent_signal *aio_signal_event = NULL;
int aio_pending_size = 0;
int outstanding_aio_calls = 0;
#endif

/* dlink list we store pending lock records on. */
struct blocking_lock_record *blocking_lock_queue = NULL;

/* dlink list we move cancelled lock records onto. */
struct blocking_lock_record *blocking_lock_cancelled_queue = NULL;

/* The event that makes us process our blocking lock queue */
struct timed_event *brl_timeout = NULL;

bool blocking_lock_unlock_state = false;
bool blocking_lock_cancel_state = false;

#ifdef USE_DMAPI
struct smbd_dmapi_context *dmapi_ctx = NULL;
#endif

connection_struct *Connections = NULL;
/* number of open connections */
struct bitmap *bmap = 0;
int num_open = 0;


bool dfree_broken = false;

struct bitmap *dptr_bmap = NULL;
struct dptr_struct *dirptrs = NULL;
int dirhandles_open = 0;

/* how many write cache buffers have been allocated */
unsigned int allocated_write_caches = 0;

int real_max_open_files = 0;
struct bitmap *file_bmap = NULL;
files_struct *Files = NULL;
int files_used = 0;
struct fsp_singleton_cache fsp_fi_cache = {
	.fsp = NULL,
	.id = {
		.devid = 0,
		.inode = 0
	}
};
unsigned long file_gen_counter = 0;
int first_file = 0;

const struct mangle_fns *mangle_fns = NULL;

unsigned char *chartest = NULL;
TDB_CONTEXT *tdb_mangled_cache = NULL;

/* these tables are used to provide fast tests for characters */
unsigned char char_flags[256];
/*
  this determines how many characters are used from the original filename
  in the 8.3 mangled name. A larger value leads to a weaker hash and more collisions.
  The largest possible value is 6.
*/
unsigned mangle_prefix = 0;
unsigned char base_reverse[256];

char *last_from = NULL;
char *last_to = NULL;

struct msg_state *smbd_msg_state = NULL;

bool global_encrypted_passwords_negotiated = false;
bool global_spnego_negotiated = false;
struct auth_context *negprot_global_auth_context = NULL;
bool done_negprot = false;

bool logged_ioctl_message = false;

/* users from session setup */
char *session_userlist = NULL;
/* workgroup from session setup. */
char *session_workgroup = NULL;
/* this holds info on user ids that are already validated for this VC */
user_struct *validated_users = NULL;
uint16_t next_vuid = VUID_OFFSET;
int num_validated_vuids = 0;
#ifdef HAVE_NETGROUP
char *my_yp_domain = NULL;
#endif

bool already_got_session = false;

/*
 * Size of data we can send to client. Set
 *  by the client for all protocols above CORE.
 *  Set by us for CORE protocol.
 */
int max_send = BUFFER_SIZE;
/*
 * Size of the data we can receive. Set by us.
 * Can be modified by the max xmit parameter.
 */
int max_recv = BUFFER_SIZE;
uint16 last_session_tag = UID_FIELD_INVALID;
int trans_num = 0;
char *orig_inbuf = NULL;
pid_t mypid = 0;
time_t last_smb_conf_reload_time = 0;
time_t last_printer_reload_time = 0;
/****************************************************************************
 structure to hold a linked list of queued messages.
 for processing.
****************************************************************************/
struct pending_message_list *deferred_open_queue = NULL;
uint32_t common_flags2 = FLAGS2_LONG_PATH_COMPONENTS|FLAGS2_32_BIT_ERROR_CODES;

struct smb_srv_trans_enc_ctx *partial_srv_trans_enc_ctx = NULL;
struct smb_srv_trans_enc_ctx *srv_trans_enc_ctx = NULL;

/* A stack of security contexts.  We include the current context as being
   the first one, so there is room for another MAX_SEC_CTX_DEPTH more. */
struct sec_ctx sec_ctx_stack[MAX_SEC_CTX_DEPTH + 1];
int sec_ctx_stack_ndx = 0;
bool become_uid_done = false;
bool become_gid_done = false;

connection_struct *last_conn = NULL;
uint16_t last_flags = 0;

struct db_context *session_db_ctx_ptr = NULL;

uint32_t global_client_caps = 0;
bool done_sesssetup = false;
/****************************************************************************
 List to store partial SPNEGO auth fragments.
****************************************************************************/
struct pending_auth_data *pd_list = NULL;

uint16_t fnf_handle = 257;

/* A stack of current_user connection contexts. */
struct conn_ctx conn_ctx_stack[MAX_SEC_CTX_DEPTH];
int conn_ctx_stack_ndx = 0;

struct vfs_init_function_entry *backends = NULL;
char *sparse_buf = NULL;
char *LastDir = NULL;

/* Current number of oplocks we have outstanding. */
int32_t exclusive_oplocks_open = 0;
int32_t level_II_oplocks_open = 0;
bool global_client_failed_oplock_break = false;
struct kernel_oplocks *koplocks = NULL;

struct notify_mid_map *notify_changes_by_mid = NULL;

int am_parent = 1;
int server_fd = -1;
struct event_context *smbd_event_ctx = NULL;
struct messaging_context *smbd_msg_ctx = NULL;
struct memcache *smbd_memcache_ctx = NULL;
bool exit_firsttime = true;
struct child_pid *children = 0;
int num_children = 0;

struct smbd_server_connection *smbd_server_conn = NULL;

void smbd_init_globals(void)
{
	ZERO_STRUCT(char_flags);
	ZERO_STRUCT(base_reverse);

	ZERO_STRUCT(conn_ctx_stack);

	ZERO_STRUCT(sec_ctx_stack);
}