r100: remember the user session key during session setup so it can be used in various...
[samba.git] / source4 / include / cli_context.h
1 /*
2    Unix SMB/CIFS implementation.
3    SMB parameters and setup
4    Copyright (C) Andrew Tridgell 1992-1998
5    Copyright (C) Luke Kenneth Casson Leighton 1996-1998
6    Copyright (C) Jeremy Allison 1998
7    Copyright (C) James Myers 2003 <myersjj@samba.org>
8
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 2 of the License, or
12    (at your option) any later version.
13
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18
19    You should have received a copy of the GNU General Public License
20    along with this program; if not, write to the Free Software
21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 */
23
24 #ifndef _CLI_CONTEXT_H
25 #define _CLI_CONTEXT_H
26
27 struct cli_tree;  /* forward declare */
28 struct cli_request;  /* forward declare */
29 struct cli_session;  /* forward declare */
30 struct cli_transport;  /* forward declare */
31
32 typedef struct smb_sign_info {
33         void (*sign_outgoing_message)(struct cli_request *req);
34         BOOL (*check_incoming_message)(struct cli_request *req);
35         void (*free_signing_context)(struct cli_transport *transport);
36         void *signing_context;
37
38         BOOL doing_signing;
39 } smb_sign_info;
40
41 /* context that will be and has been negotiated between the client and server */
42 struct cli_negotiate {
43         /* 
44          * negotiated maximum transmit size - this is given to us by the server
45          */
46         unsigned max_xmit;
47
48         /* maximum number of requests that can be multiplexed */
49         uint16 max_mux;
50
51         /* the negotiatiated protocol */
52         enum protocol_types protocol;
53
54         int sec_mode;           /* security mode returned by negprot */
55         DATA_BLOB secblob;      /* cryptkey or negTokenInit blob */
56         uint32 sesskey;
57         
58         smb_sign_info sign_info;
59
60         /* capabilities that the server reported */
61         uint32 capabilities;
62         
63         int server_zone;
64         time_t server_time;
65         unsigned int readbraw_supported:1;
66         unsigned int writebraw_supported:1;
67
68         const char *server_domain;
69
70         /* remember the session key for data encryption in various sub-protocols
71            such as LSA */
72         uint8 user_session_key[16];
73 };
74         
75 /* this is the context for a SMB socket associated with the socket itself */
76 struct cli_socket {
77         TALLOC_CTX *mem_ctx;    /* life of socket pool */
78
79         /* when the reference count reaches zero then the socket is destroyed */
80         int reference_count;
81
82         struct in_addr dest_ip;
83
84         /* the port used */
85         int port;
86         
87         /* the open file descriptor */
88         int fd;
89
90         /* a count of the number of packets we have received. We
91          * actually only care about zero/non-zero at this stage */
92         unsigned pkt_count;
93
94         /* the network address of the client */
95         char *client_addr;
96         
97         /* timeout for socket operations in milliseconds. */
98         int timeout;
99 };
100
101 /*
102   this structure allows applications to control the behaviour of the
103   client library
104 */
105 struct cli_options {
106         unsigned int use_oplocks:1;
107         unsigned int use_level2_oplocks:1;
108         unsigned int use_spnego:1;
109 };
110
111 /* this is the context for the client transport layer */
112 struct cli_transport {
113         TALLOC_CTX *mem_ctx;
114
115         /* when the reference count reaches zero then the transport is destroyed */
116         int reference_count;
117
118         /* socket level info */
119         struct cli_socket *socket;
120
121         /* the next mid to be allocated - needed for signing and
122            request matching */
123         uint16 next_mid;
124         
125         /* negotiated protocol information */
126         struct cli_negotiate negotiate;
127
128         /* options to control the behaviour of the client code */
129         struct cli_options options;
130
131         /* is a readbraw pending? we need to handle that case
132            specially on receiving packets */
133         unsigned int readbraw_pending:1;
134         
135         /* an idle function - if this is defined then it will be
136            called once every period milliseconds while we are waiting
137            for a packet */
138         struct {
139                 void (*func)(struct cli_transport *, void *);
140                 void *private;
141                 uint_t period;
142         } idle;
143
144         /* the error fields from the last message */
145         struct {
146                 enum {ETYPE_NONE, ETYPE_DOS, ETYPE_NT, ETYPE_SOCKET, ETYPE_NBT} etype;
147                 union {
148                         struct {
149                                 uint8 eclass;
150                                 uint16 ecode;
151                         } dos;
152                         NTSTATUS nt_status;
153                         enum socket_error socket_error;
154                         unsigned nbt_error;
155                 } e;
156         } error;
157
158         struct {
159                 /* a oplock break request handler */
160                 BOOL (*handler)(struct cli_transport *transport, 
161                                 uint16 tid, uint16 fnum, uint8 level, void *private);
162                 /* private data passed to the oplock handler */
163                 void *private;
164         } oplock;
165
166         /* a list of async requests that are pending on this connection */
167         struct cli_request *pending_requests;
168
169         /* remember the called name - some sub-protocols require us to
170            know the server name */
171         struct nmb_name called;
172 };
173
174 /* this is the context for the user */
175
176 /* this is the context for the session layer */
177 struct cli_session {    
178         TALLOC_CTX *mem_ctx;    /* life of session */
179
180         /* when the reference count reaches zero then the session is destroyed */
181         int reference_count;    
182         
183         /* transport layer info */
184         struct cli_transport *transport;
185         
186         /* after a session setup the server provides us with
187            a vuid identifying the security context */
188         uint16 vuid;
189
190         /* default pid for this session */
191         uint32 pid;
192 };
193
194 /* 
195    cli_tree context: internal state for a tree connection. 
196  */
197 struct cli_tree {
198         /* life of tree tree */
199         TALLOC_CTX *mem_ctx;
200
201         /* when the reference count reaches zero then the tree is destroyed */
202         int reference_count;    
203
204         /* session layer info */
205         struct cli_session *session;
206
207         uint16 tid;                     /* tree id, aka cnum */
208         char *device;
209         char *fs_type;
210 };
211
212 /* the context for a single SMB request. This is passed to any request-context 
213  * functions (similar to context.h, the server version).
214  * This will allow requests to be multi-threaded. */
215 struct cli_request {
216         /* allow a request to be part of a list of requests */
217         struct cli_request *next, *prev;
218
219         /* a talloc context for the lifetime of this request */
220         TALLOC_CTX *mem_ctx;
221         
222         /* a request always has a transport context, nearly always has
223            a session context and usually has a tree context */
224         struct cli_transport *transport;
225         struct cli_session *session;
226         struct cli_tree *tree;
227
228         /* the flags2 from the SMB request, in raw form (host byte
229            order). Used to parse strings */
230         uint16 flags2;
231
232         /* the NT status for this request. Set by packet receive code
233            or code detecting error. */
234         NTSTATUS status;
235         
236         /* the sequence number of this packet - used for signing */
237         unsigned seq_num;
238
239         /* set if this is a one-way request, meaning we are not
240            expecting a reply from the server. */
241         unsigned int one_way_request:1;
242
243         /* the mid of this packet - used to match replies */
244         uint16 mid;
245
246         struct {
247                 /* the raw SMB buffer, including the 4 byte length header */
248                 char *buffer;
249                 
250                 /* the size of the raw buffer, including 4 byte header */
251                 unsigned size;
252
253                 /* how much has been allocated - on reply the buffer is over-allocated to 
254                    prevent too many realloc() calls 
255                 */
256                 unsigned allocated;
257
258                 /* the start of the SMB header - this is always buffer+4 */
259                 char *hdr;
260
261                 /* the command words and command word count. vwv points
262                    into the raw buffer */
263                 char *vwv;
264                 unsigned wct;
265
266                 /* the data buffer and size. data points into the raw buffer */
267                 char *data;
268                 unsigned data_size;
269
270                 /* ptr is used as a moving pointer into the data area
271                  * of the packet. The reason its here and not a local
272                  * variable in each function is that when a realloc of
273                  * a send packet is done we need to move this
274                  * pointer */
275                 char *ptr;
276         } in, out;
277
278         /* information on what to do with a reply when it is received
279            asyncronously. If this is not setup when a reply is received then
280            the reply is discarded
281
282            The private pointer is private to the caller of the client
283            library (the application), not private to the library
284         */
285         struct {
286                 void (*fn)(struct cli_request *);
287                 void *private;
288         } async;
289 };
290
291 /* 
292    cli_state: internal state used in libcli library for single-threaded callers, 
293    i.e. a single session on a single socket. 
294  */
295 struct cli_state {
296         TALLOC_CTX *mem_ctx;    /* life of client pool */
297         struct cli_transport *transport;
298         struct cli_session *session;
299         struct cli_tree *tree;
300         struct substitute_context substitute;
301 };
302
303 /* useful way of catching wct errors with file and line number */
304 #define CLI_CHECK_MIN_WCT(req, wcount) if ((req)->in.wct < (wcount)) { \
305       DEBUG(1,("Unexpected WCT %d at %s(%d) - expected min %d\n", (req)->in.wct, __FILE__, __LINE__, wcount)); \
306       req->status = NT_STATUS_INVALID_PARAMETER; \
307       goto failed; \
308 }
309
310 #define CLI_CHECK_WCT(req, wcount) if ((req)->in.wct != (wcount)) { \
311       DEBUG(1,("Unexpected WCT %d at %s(%d) - expected %d\n", (req)->in.wct, __FILE__, __LINE__, wcount)); \
312       req->status = NT_STATUS_INVALID_PARAMETER; \
313       goto failed; \
314 }
315
316 #endif /* _CLI_CONTEXT_H */