6088853743bb941626bf5afc651e0fd33f799c1a
[samba.git] / source4 / smb_server / smb_server.h
1 /* 
2    Unix SMB/CIFS implementation.
3    
4    Copyright (C) Andrew Tridgell              2003
5    Copyright (C) James J Myers                2003 <myersjj@samba.org>
6    Copyright (C) Stefan Metzmacher            2004-2005
7    
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12    
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17    
18    You should have received a copy of the GNU General Public License
19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "libcli/raw/request.h"
23 #include "libcli/raw/interfaces.h"
24 #include "lib/socket/socket.h"
25 #include "../lib/util/dlinklist.h"
26 #include "../librpc/gen_ndr/nbt.h"
27
28 struct tevent_context;
29
30 /*
31   this header declares the core context structures associated with smb
32   sockets, tree connects, requests etc
33
34   the idea is that we will eventually get rid of all our global
35   variables and instead store our state from structures hanging off
36   these basic elements
37 */
38
39 struct smbsrv_tcons_context {
40         /* an id tree used to allocate tids */
41         struct idr_context *idtree_tid;
42
43         /* this is the limit of vuid values for this connection */
44         uint32_t idtree_limit;
45
46         /* list of open tree connects */
47         struct smbsrv_tcon *list;
48 };
49
50 struct smbsrv_sessions_context {
51         /* an id tree used to allocate vuids */
52         /* this holds info on session vuids that are already
53          * validated for this VC */
54         struct idr_context *idtree_vuid;
55
56         /* this is the limit of vuid values for this connection */
57         uint64_t idtree_limit;
58
59         /* also kept as a link list so it can be enumerated by
60            the management code */
61         struct smbsrv_session *list;
62 };
63
64 struct smbsrv_handles_context {
65         /* an id tree used to allocate file handles */
66         struct idr_context *idtree_hid;
67
68         /* this is the limit of handle values for this context */
69         uint64_t idtree_limit;
70
71         /* also kept as a link list so it can be enumerated by
72            the management code */
73         struct smbsrv_handle *list;
74 };
75
76 /* the current user context for a request */
77 struct smbsrv_session {
78         struct smbsrv_session *prev, *next;
79
80         struct smbsrv_connection *smb_conn;
81
82         /*
83          * in SMB2 tcons belong to just one session
84          * and not to the whole connection
85          */
86         struct smbsrv_tcons_context smb2_tcons;
87
88         /*
89          * the open file handles for this session,
90          * used for SMBexit, SMBulogoff and SMB2 SessionLogoff
91          */
92         struct smbsrv_handle_session_item *handles;
93
94         /* 
95          * an index passed over the wire:
96          * - 16 bit for smb
97          * - 64 bit for smb2
98          */
99         uint64_t vuid;
100
101         struct gensec_security *gensec_ctx;
102
103         struct auth_session_info *session_info;
104
105         struct {
106                 bool required;
107                 bool active;
108         } smb2_signing;
109
110         /* some statistics for the management tools */
111         struct {
112                 /* the time when the session setup started */
113                 struct timeval connect_time;
114                 /* the time when the session setup was finished */
115                 struct timeval auth_time;
116                 /* the time when the last request comes in */
117                 struct timeval last_request_time;
118         } statistics;
119 };
120
121 /* we need a forward declaration of the ntvfs_ops strucutre to prevent
122    include recursion */
123 struct ntvfs_context;
124
125 struct smbsrv_tcon {
126         struct smbsrv_tcon *next, *prev;
127
128         /* the server context that this was created on */
129         struct smbsrv_connection *smb_conn;
130
131         /* the open file handles on this tcon */
132         struct smbsrv_handles_context handles;
133
134         /* 
135          * an index passed over the wire:
136          * - 16 bit for smb
137          * - 32 bit for smb2
138          */
139         uint32_t tid; /* an index passed over the wire (the TID) */
140
141         /* the share name */
142         const char *share_name;
143
144         /* the NTVFS context - see source/ntvfs/ for details */
145         struct ntvfs_context *ntvfs;
146
147         /* some stuff to support share level security */
148         struct {
149                 /* in share level security we need to fake up a session */
150                 struct smbsrv_session *session;
151         } sec_share;
152
153         /* some stuff to support share level security */
154         struct {
155                 /* in SMB2 a tcon always belongs to one session */
156                 struct smbsrv_session *session;
157         } smb2;
158
159         /* some statistics for the management tools */
160         struct {
161                 /* the time when the tree connect started */
162                 struct timeval connect_time;
163                 /* the time when the last request comes in */
164                 struct timeval last_request_time;
165         } statistics;
166 };
167
168 struct smbsrv_handle {
169         struct smbsrv_handle *next, *prev;
170
171         /* the tcon the handle belongs to */
172         struct smbsrv_tcon *tcon;
173
174         /* the session the handle was opened on */
175         struct smbsrv_session *session;
176
177         /* the smbpid used on the open, used for SMBexit */
178         uint16_t smbpid;
179
180         /*
181          * this is for adding the handle into a linked list
182          * on the smbsrv_session, we can't use *next,*prev
183          * for this because they're used for the linked list on the 
184          * smbsrv_tcon
185          */
186         struct smbsrv_handle_session_item {
187                 struct smbsrv_handle_session_item *prev, *next;
188                 struct smbsrv_handle *handle;
189         } session_item;
190
191         /*
192          * the value passed over the wire
193          * - 16 bit for smb
194          * - 32 bit for smb2
195          *   Note: for SMB2 handles are 128 bit
196          *         we'll fill them with
197          *         - 32 bit HID
198          *         - 32 bit TID
199          *         - 64 bit VUID
200          */
201         uint32_t hid;
202
203         /*
204          * the ntvfs handle passed to the ntvfs backend
205          */
206         struct ntvfs_handle *ntvfs;
207
208         /* some statistics for the management tools */
209         struct {
210                 /* the time when the tree connect started */
211                 struct timeval open_time;
212                 /* the time when the last request comes in */
213                 struct timeval last_use_time;
214         } statistics;
215 };
216
217 /* a set of flags to control handling of request structures */
218 #define SMBSRV_REQ_CONTROL_LARGE     (1<<1) /* allow replies larger than max_xmit */
219
220 #define SMBSRV_REQ_DEFAULT_STR_FLAGS(req) (((req)->flags2 & FLAGS2_UNICODE_STRINGS) ? STR_UNICODE : STR_ASCII)
221
222 /* the context for a single SMB request. This is passed to any request-context 
223    functions */
224 struct smbsrv_request {
225         /* the smbsrv_connection needs a list of requests queued for send */
226         struct smbsrv_request *next, *prev;
227
228         /* the server_context contains all context specific to this SMB socket */
229         struct smbsrv_connection *smb_conn;
230
231         /* conn is only set for operations that have a valid TID */
232         struct smbsrv_tcon *tcon;
233
234         /* the session context is derived from the vuid */
235         struct smbsrv_session *session;
236
237         /* a set of flags to control usage of the request. See SMBSRV_REQ_CONTROL_* */
238         uint32_t control_flags;
239
240         /* the system time when the request arrived */
241         struct timeval request_time;
242
243         /* a pointer to the per request union smb_* io structure */
244         void *io_ptr;
245
246         /* the ntvfs_request */
247         struct ntvfs_request *ntvfs;
248
249         /* Now the SMB specific stuff */
250
251         /* the flags from the SMB request, in raw form (host byte order) */
252         uint16_t flags2;
253
254         /* this can contain a fnum from an earlier part of a chained
255          * message (such as an SMBOpenX), or -1 */
256         int chained_fnum;
257
258         /* how far through the chain of SMB commands have we gone? */
259         unsigned chain_count;
260
261         /* the sequence number for signing */
262         uint64_t seq_num;
263
264         struct smb_request_buffer in;
265         struct smb_request_buffer out;
266 };
267
268 enum security_types {SEC_SHARE,SEC_USER};
269
270 /* smb server context structure. This should contain all the state
271  * information associated with a SMB server connection 
272  */
273 struct smbsrv_connection {
274         /* context that has been negotiated between the client and server */
275         struct {
276                 /* have we already done the NBT session establishment? */
277                 bool done_nbt_session;
278         
279                 /* only one negprot per connection is allowed */
280                 bool done_negprot;
281         
282                 /* multiple session setups are allowed, but some parameters are
283                    ignored in any but the first */
284                 bool done_sesssetup;
285                 
286                 /* 
287                  * Size of data we can send to client. Set
288                  *  by the client for all protocols above CORE.
289                  *  Set by us for CORE protocol.
290                  */
291                 unsigned max_send; /* init to BUFFER_SIZE */
292         
293                 /*
294                  * Size of the data we can receive. Set by us.
295                  * Can be modified by the max xmit parameter.
296                  */
297                 unsigned max_recv; /* init to BUFFER_SIZE */
298         
299                 /* the negotiatiated protocol */
300                 enum protocol_types protocol;
301
302                 /* authentication context for multi-part negprot */
303                 struct auth_context *auth_context;
304         
305                 /* reference to the kerberos keytab, or machine trust account */
306                 struct cli_credentials *server_credentials;
307         
308                 /* did we tell the client we support encrypted passwords? */
309                 bool encrypted_passwords;
310         
311                 /* Did we choose SPNEGO, or perhaps raw NTLMSSP, or even no extended security at all? */
312                 const char *oid;
313         
314                 /* client capabilities */
315                 uint32_t client_caps;
316         
317                 /* the timezone we sent to the client */
318                 int zone_offset;
319
320                 /* NBT names only set when done_nbt_session is true */
321                 struct nbt_name *called_name;
322                 struct nbt_name *calling_name;
323         } negotiate;
324
325         /* the context associated with open tree connects on a smb socket, not for SMB2 */
326         struct smbsrv_tcons_context smb_tcons;
327
328         /* context associated with currently valid session setups */
329         struct smbsrv_sessions_context sessions;
330
331         /*
332          * the server_context holds a linked list of pending requests,
333          * this is used for finding the request structures on ntcancel requests
334          * For SMB only
335          */
336         struct smbsrv_request *requests;
337
338         /*
339          * the server_context holds a linked list of pending requests,
340          * and an idtree for finding the request structures on SMB2 Cancel
341          * For SMB2 only
342          */
343         struct {
344                 /* an id tree used to allocate ids */
345                 struct idr_context *idtree_req;
346
347                 /* this is the limit of pending requests values for this connection */
348                 uint32_t idtree_limit;
349
350                 /* list of open tree connects */
351                 struct smb2srv_request *list;
352         } requests2;
353
354         struct smb_signing_context signing;
355
356         struct stream_connection *connection;
357
358         /* this holds a partially received request */
359         struct packet_context *packet;
360
361         /* a list of partially received transaction requests */
362         struct smbsrv_trans_partial {
363                 struct smbsrv_trans_partial *next, *prev;
364                 struct smbsrv_request *req;
365                 uint8_t command;
366                 union {
367                         struct smb_trans2 *trans;
368                         struct smb_nttrans *nttrans;
369                 } u;
370         } *trans_partial;
371
372         /* configuration parameters */
373         struct {
374                 enum security_types security;
375                 bool nt_status_support;
376         } config;
377
378         /* some statictics for the management tools */
379         struct {
380                 /* the time when the client connects */
381                 struct timeval connect_time;
382                 /* the time when the last request comes in */
383                 struct timeval last_request_time;
384         } statistics;
385
386         struct share_context *share_context;
387
388         struct loadparm_context *lp_ctx;
389
390         bool smb2_signing_required;
391
392         uint64_t highest_smb2_seqnum;
393 };
394
395 struct model_ops;
396 struct loadparm_context;
397
398 NTSTATUS smbsrv_add_socket(TALLOC_CTX *mem_ctx,
399                            struct tevent_context *event_context,
400                            struct loadparm_context *lp_ctx,
401                            const struct model_ops *model_ops,
402                            const char *address);
403
404 struct loadparm_context;
405
406 #include "smb_server/smb_server_proto.h"
407 #include "smb_server/smb/smb_proto.h"
408
409 /* useful way of catching wct errors with file and line number */
410 #define SMBSRV_CHECK_WCT(req, wcount) do { \
411         if ((req)->in.wct != (wcount)) { \
412                 DEBUG(1,("Unexpected WCT %u at %s(%d) - expected %d\n", \
413                          (req)->in.wct, __FILE__, __LINE__, wcount)); \
414                 smbsrv_send_error(req, NT_STATUS_DOS(ERRSRV, ERRerror)); \
415                 return; \
416         } \
417 } while (0)
418         
419 /* useful wrapper for talloc with NO_MEMORY reply */
420 #define SMBSRV_TALLOC_IO_PTR(ptr, type) do { \
421         ptr = talloc(req, type); \
422         if (!ptr) { \
423                 smbsrv_send_error(req, NT_STATUS_NO_MEMORY); \
424                 return; \
425         } \
426         req->io_ptr = ptr; \
427 } while (0)
428
429 #define SMBSRV_SETUP_NTVFS_REQUEST(send_fn, state) do { \
430         req->ntvfs = ntvfs_request_create(req->tcon->ntvfs, req, \
431                                           req->session->session_info,\
432                                           SVAL(req->in.hdr,HDR_PID), \
433                                           req->request_time, \
434                                           req, send_fn, state); \
435         if (!req->ntvfs) { \
436                 smbsrv_send_error(req, NT_STATUS_NO_MEMORY); \
437                 return; \
438         } \
439         (void)talloc_steal(req->tcon->ntvfs, req); \
440         req->ntvfs->frontend_data.private_data = req; \
441 } while (0)
442
443 #define SMBSRV_CHECK_FILE_HANDLE(handle) do { \
444         if (!handle) { \
445                 smbsrv_send_error(req, NT_STATUS_INVALID_HANDLE); \
446                 return; \
447         } \
448 } while (0)
449
450 #define SMBSRV_CHECK_FILE_HANDLE_ERROR(handle, _status) do { \
451         if (!handle) { \
452                 smbsrv_send_error(req, _status); \
453                 return; \
454         } \
455 } while (0)
456
457 #define SMBSRV_CHECK_FILE_HANDLE_NTSTATUS(handle) do { \
458         if (!handle) { \
459                 return NT_STATUS_INVALID_HANDLE; \
460         } \
461 } while (0)
462
463 #define SMBSRV_CHECK(cmd) do {\
464         NTSTATUS _status; \
465         _status = cmd; \
466         if (!NT_STATUS_IS_OK(_status)) { \
467                 smbsrv_send_error(req,  _status); \
468                 return; \
469         } \
470 } while (0)
471
472 /* 
473    check if the backend wants to handle the request asynchronously.
474    if it wants it handled synchronously then call the send function
475    immediately
476 */
477 #define SMBSRV_CALL_NTVFS_BACKEND(cmd) do { \
478         req->ntvfs->async_states->status = cmd; \
479         if (req->ntvfs->async_states->state & NTVFS_ASYNC_STATE_ASYNC) { \
480                 DLIST_ADD_END(req->smb_conn->requests, req, struct smbsrv_request *); \
481         } else { \
482                 req->ntvfs->async_states->send_fn(req->ntvfs); \
483         } \
484 } while (0)
485
486 /* check req->ntvfs->async_states->status and if not OK then send an error reply */
487 #define SMBSRV_CHECK_ASYNC_STATUS_ERR_SIMPLE do { \
488         req = talloc_get_type(ntvfs->async_states->private_data, struct smbsrv_request); \
489         if (ntvfs->async_states->state & NTVFS_ASYNC_STATE_CLOSE || NT_STATUS_EQUAL(ntvfs->async_states->status, NT_STATUS_NET_WRITE_FAULT)) { \
490                 smbsrv_terminate_connection(req->smb_conn, get_friendly_nt_error_msg (ntvfs->async_states->status)); \
491                 talloc_free(req); \
492                 return; \
493         } \
494         if (NT_STATUS_IS_ERR(ntvfs->async_states->status)) { \
495                 smbsrv_send_error(req, ntvfs->async_states->status); \
496                 return; \
497         } \
498 } while (0)
499 #define SMBSRV_CHECK_ASYNC_STATUS_ERR(ptr, type) do { \
500         SMBSRV_CHECK_ASYNC_STATUS_ERR_SIMPLE; \
501         ptr = talloc_get_type(req->io_ptr, type); \
502 } while (0)
503 #define SMBSRV_CHECK_ASYNC_STATUS_SIMPLE do { \
504         req = talloc_get_type(ntvfs->async_states->private_data, struct smbsrv_request); \
505         if (ntvfs->async_states->state & NTVFS_ASYNC_STATE_CLOSE || NT_STATUS_EQUAL(ntvfs->async_states->status, NT_STATUS_NET_WRITE_FAULT)) { \
506                 smbsrv_terminate_connection(req->smb_conn, get_friendly_nt_error_msg (ntvfs->async_states->status)); \
507                 talloc_free(req); \
508                 return; \
509         } \
510         if (!NT_STATUS_IS_OK(ntvfs->async_states->status)) { \
511                 smbsrv_send_error(req, ntvfs->async_states->status); \
512                 return; \
513         } \
514 } while (0)
515 #define SMBSRV_CHECK_ASYNC_STATUS(ptr, type) do { \
516         SMBSRV_CHECK_ASYNC_STATUS_SIMPLE; \
517         ptr = talloc_get_type(req->io_ptr, type); \
518 } while (0)
519
520 /* zero out some reserved fields in a reply */
521 #define SMBSRV_VWV_RESERVED(start, count) memset(req->out.vwv + VWV(start), 0, (count)*2)
522
523 #include "smb_server/service_smb_proto.h"