r15854: more talloc_set_destructor() typesafe fixes
[bbaumbach/samba-autobuild/.git] / source4 / libcli / smb2 / transport.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    SMB2 client transport context management functions
5
6    Copyright (C) Andrew Tridgell 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 2 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, write to the Free Software
20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 */
22
23 #include "includes.h"
24 #include "libcli/raw/libcliraw.h"
25 #include "libcli/smb2/smb2.h"
26 #include "libcli/smb2/smb2_calls.h"
27 #include "lib/socket/socket.h"
28 #include "lib/events/events.h"
29 #include "lib/stream/packet.h"
30 #include "include/dlinklist.h"
31
32
33 /*
34   an event has happened on the socket
35 */
36 static void smb2_transport_event_handler(struct event_context *ev, 
37                                          struct fd_event *fde, 
38                                          uint16_t flags, void *private)
39 {
40         struct smb2_transport *transport = talloc_get_type(private,
41                                                            struct smb2_transport);
42         if (flags & EVENT_FD_READ) {
43                 packet_recv(transport->packet);
44                 return;
45         }
46         if (flags & EVENT_FD_WRITE) {
47                 packet_queue_run(transport->packet);
48         }
49 }
50
51 /*
52   destroy a transport
53  */
54 static int transport_destructor(struct smb2_transport *transport)
55 {
56         smb2_transport_dead(transport);
57         return 0;
58 }
59
60
61 /*
62   handle receive errors
63 */
64 static void smb2_transport_error(void *private, NTSTATUS status)
65 {
66         struct smb2_transport *transport = talloc_get_type(private, 
67                                                            struct smb2_transport);
68         smb2_transport_dead(transport);
69 }
70
71 static NTSTATUS smb2_transport_finish_recv(void *private, DATA_BLOB blob);
72
73 /*
74   create a transport structure based on an established socket
75 */
76 struct smb2_transport *smb2_transport_init(struct smbcli_socket *sock,
77                                            TALLOC_CTX *parent_ctx)
78 {
79         struct smb2_transport *transport;
80
81         transport = talloc_zero(parent_ctx, struct smb2_transport);
82         if (!transport) return NULL;
83
84         transport->socket = talloc_steal(transport, sock);
85
86         /* setup the stream -> packet parser */
87         transport->packet = packet_init(transport);
88         if (transport->packet == NULL) {
89                 talloc_free(transport);
90                 return NULL;
91         }
92         packet_set_private(transport->packet, transport);
93         packet_set_socket(transport->packet, transport->socket->sock);
94         packet_set_callback(transport->packet, smb2_transport_finish_recv);
95         packet_set_full_request(transport->packet, packet_full_request_nbt);
96         packet_set_error_handler(transport->packet, smb2_transport_error);
97         packet_set_event_context(transport->packet, transport->socket->event.ctx);
98         packet_set_nofree(transport->packet);
99
100         /* take over event handling from the socket layer - it only
101            handles events up until we are connected */
102         talloc_free(transport->socket->event.fde);
103         transport->socket->event.fde = event_add_fd(transport->socket->event.ctx,
104                                                     transport->socket,
105                                                     socket_get_fd(transport->socket->sock),
106                                                     EVENT_FD_READ,
107                                                     smb2_transport_event_handler,
108                                                     transport);
109
110         packet_set_fde(transport->packet, transport->socket->event.fde);
111         packet_set_serialise(transport->packet);
112
113         talloc_set_destructor(transport, transport_destructor);
114
115         transport->options.timeout = 30;
116
117         return transport;
118 }
119
120 /*
121   mark the transport as dead
122 */
123 void smb2_transport_dead(struct smb2_transport *transport)
124 {
125         smbcli_sock_dead(transport->socket);
126
127         /* kill all pending receives */
128         while (transport->pending_recv) {
129                 struct smb2_request *req = transport->pending_recv;
130                 req->state = SMB2_REQUEST_ERROR;
131                 req->status = NT_STATUS_NET_WRITE_FAULT;
132                 DLIST_REMOVE(transport->pending_recv, req);
133                 if (req->async.fn) {
134                         req->async.fn(req);
135                 }
136         }
137 }
138
139 /*
140   we have a full request in our receive buffer - match it to a pending request
141   and process
142  */
143 static NTSTATUS smb2_transport_finish_recv(void *private, DATA_BLOB blob)
144 {
145         struct smb2_transport *transport = talloc_get_type(private, 
146                                                              struct smb2_transport);
147         uint8_t *buffer, *hdr;
148         int len;
149         struct smb2_request *req = NULL;
150         uint64_t seqnum;
151         uint16_t buffer_code;
152         uint32_t dynamic_size;
153
154         buffer = blob.data;
155         len = blob.length;
156
157         hdr = buffer+NBT_HDR_SIZE;
158
159         if (len < SMB2_MIN_SIZE) {
160                 DEBUG(1,("Discarding smb2 reply of size %d\n", len));
161                 goto error;
162         }
163
164         seqnum = BVAL(hdr, SMB2_HDR_SEQNUM);
165
166         /* match the incoming request against the list of pending requests */
167         for (req=transport->pending_recv; req; req=req->next) {
168                 if (req->seqnum == seqnum) break;
169         }
170
171         if (!req) {
172                 DEBUG(1,("Discarding unmatched reply with seqnum 0x%llx op %d\n", 
173                          (long long)seqnum, SVAL(hdr, SMB2_HDR_OPCODE)));
174                 goto error;
175         }
176
177         /* fill in the 'in' portion of the matching request */
178         req->in.buffer = buffer;
179         talloc_steal(req, buffer);
180         req->in.size = len;
181         req->in.allocated = req->in.size;
182
183         req->in.hdr       = hdr;
184         req->in.body      = hdr+SMB2_HDR_BODY;
185         req->in.body_size = req->in.size - (SMB2_HDR_BODY+NBT_HDR_SIZE);
186         req->status       = NT_STATUS(IVAL(hdr, SMB2_HDR_STATUS));
187
188         if (NT_STATUS_EQUAL(req->status, STATUS_PENDING)) {
189                 /* the server has helpfully told us that this request is still being
190                    processed. how useful :) */
191                 talloc_free(buffer);
192                 return NT_STATUS_OK;
193         }
194
195         buffer_code = SVAL(req->in.body, 0);
196         req->in.dynamic = NULL;
197         dynamic_size = req->in.body_size - (buffer_code & ~1);
198         if (dynamic_size != 0 && (buffer_code & 1)) {
199                 req->in.dynamic = req->in.body + (buffer_code & ~1);
200                 if (smb2_oob(&req->in, req->in.dynamic, dynamic_size)) {
201                         DEBUG(1,("SMB2 request invalid dynamic size 0x%x\n", 
202                                  dynamic_size));
203                         goto error;
204                 }
205         }
206
207         DEBUG(2, ("SMB2 RECV seqnum=0x%llx\n", (long long)req->seqnum));
208         dump_data(5, req->in.body, req->in.body_size);
209
210         /* if this request has an async handler then call that to
211            notify that the reply has been received. This might destroy
212            the request so it must happen last */
213         DLIST_REMOVE(transport->pending_recv, req);
214         req->state = SMB2_REQUEST_DONE;
215         if (req->async.fn) {
216                 req->async.fn(req);
217         }
218         return NT_STATUS_OK;
219
220 error:
221         dump_data(5, buffer, len);
222         if (req) {
223                 DLIST_REMOVE(transport->pending_recv, req);
224                 req->state = SMB2_REQUEST_ERROR;
225                 if (req->async.fn) {
226                         req->async.fn(req);
227                 }
228         } else {
229                 talloc_free(buffer);
230         }
231         return NT_STATUS_UNSUCCESSFUL;
232 }
233
234 /*
235   handle timeouts of individual smb requests
236 */
237 static void smb2_timeout_handler(struct event_context *ev, struct timed_event *te, 
238                                  struct timeval t, void *private)
239 {
240         struct smb2_request *req = talloc_get_type(private, struct smb2_request);
241
242         if (req->state == SMB2_REQUEST_RECV) {
243                 DLIST_REMOVE(req->transport->pending_recv, req);
244         }
245         req->status = NT_STATUS_IO_TIMEOUT;
246         req->state = SMB2_REQUEST_ERROR;
247         if (req->async.fn) {
248                 req->async.fn(req);
249         }
250 }
251
252
253 /*
254   destroy a request
255 */
256 static int smb2_request_destructor(struct smb2_request *req)
257 {
258         if (req->state == SMB2_REQUEST_RECV) {
259                 DLIST_REMOVE(req->transport->pending_recv, req);
260         }
261         return 0;
262 }
263
264
265 /*
266   put a request into the send queue
267 */
268 void smb2_transport_send(struct smb2_request *req)
269 {
270         DATA_BLOB blob;
271         NTSTATUS status;
272
273         _smb2_setlen(req->out.buffer, req->out.size - NBT_HDR_SIZE);
274
275         DEBUG(2, ("SMB2 send seqnum=0x%llx\n", (long long)req->seqnum));
276         dump_data(5, req->out.body, req->out.body_size);
277
278         /* check if the transport is dead */
279         if (req->transport->socket->sock == NULL) {
280                 req->state = SMB2_REQUEST_ERROR;
281                 req->status = NT_STATUS_NET_WRITE_FAULT;
282                 return;
283         }
284
285         blob = data_blob_const(req->out.buffer, req->out.size);
286         status = packet_send(req->transport->packet, blob);
287         if (!NT_STATUS_IS_OK(status)) {
288                 req->state = SMB2_REQUEST_ERROR;
289                 req->status = status;
290                 return;
291         }
292
293         req->state = SMB2_REQUEST_RECV;
294         DLIST_ADD(req->transport->pending_recv, req);
295
296         /* add a timeout */
297         if (req->transport->options.timeout) {
298                 event_add_timed(req->transport->socket->event.ctx, req, 
299                                 timeval_current_ofs(req->transport->options.timeout, 0), 
300                                 smb2_timeout_handler, req);
301         }
302
303         talloc_set_destructor(req, smb2_request_destructor);
304 }