4ffa40d1349d2e900ec35f9acd609f7f8fb64476
[ira/wip.git] / source / libcli / cldap / cldap.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    cldap client library
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 /*
24   see RFC1798 for details of CLDAP
25
26   basic properties
27     - carried over UDP on port 389
28     - request and response matched by message ID
29     - request consists of only a single searchRequest element
30     - response can be in one of two forms
31        - a single searchResponse, followed by a searchResult
32        - a single searchResult
33 */
34
35 #include "includes.h"
36 #include "lib/events/events.h"
37 #include "dlinklist.h"
38 #include "libcli/ldap/ldap.h"
39 #include "libcli/cldap/cldap.h"
40 #include "lib/socket/socket.h"
41 #include "include/asn_1.h"
42
43 /*
44   destroy a pending request
45 */
46 static int cldap_request_destructor(void *ptr)
47 {
48         struct cldap_request *req = talloc_get_type(ptr, struct cldap_request);
49         if (req->state == CLDAP_REQUEST_SEND) {
50                 DLIST_REMOVE(req->cldap->send_queue, req);
51         }
52         if (!req->is_reply && req->message_id != 0) {
53                 idr_remove(req->cldap->idr, req->message_id);
54                 req->message_id = 0;
55         }
56         return 0;
57 }
58
59 /*
60   handle recv events on a cldap socket
61 */
62 static void cldap_socket_recv(struct cldap_socket *cldap)
63 {
64         TALLOC_CTX *tmp_ctx = talloc_new(cldap);
65         NTSTATUS status;
66         const char *src_addr;
67         int src_port;
68         DATA_BLOB blob;
69         size_t nread, dsize;
70         struct asn1_data asn1;
71         struct ldap_message *ldap_msg;
72         struct cldap_request *req;
73
74         status = socket_pending(cldap->sock, &dsize);
75         if (!NT_STATUS_IS_OK(status)) {
76                 talloc_free(tmp_ctx);
77                 return;
78         }
79
80         blob = data_blob_talloc(tmp_ctx, NULL, dsize);
81         if (blob.data == NULL) {
82                 talloc_free(tmp_ctx);
83                 return;
84         }
85
86         status = socket_recvfrom(cldap->sock, blob.data, blob.length, &nread, 0,
87                                  &src_addr, &src_port);
88         if (!NT_STATUS_IS_OK(status)) {
89                 talloc_free(tmp_ctx);
90                 return;
91         }
92         talloc_steal(tmp_ctx, src_addr);
93         blob.length = nread;
94
95         DEBUG(2,("Received cldap packet of length %d from %s:%d\n", 
96                  (int)blob.length, src_addr, src_port));
97
98         if (!asn1_load(&asn1, blob)) {
99                 DEBUG(2,("Failed to setup for asn.1 decode\n"));
100                 talloc_free(tmp_ctx);
101                 return;
102         }
103         talloc_steal(tmp_ctx, asn1.data);
104
105         ldap_msg = talloc(tmp_ctx, struct ldap_message);
106         if (ldap_msg == NULL) {
107                 talloc_free(tmp_ctx);
108                 return;
109         }
110
111         /* this initial decode is used to find the message id */
112         if (!ldap_decode(&asn1, ldap_msg)) {
113                 DEBUG(2,("Failed to decode ldap message\n"));
114                 talloc_free(tmp_ctx);
115                 return;
116         }
117
118         /* find the pending request */
119         req = idr_find(cldap->idr, ldap_msg->messageid);
120         if (req == NULL) {
121                 if (cldap->incoming.handler) {
122                         cldap->incoming.handler(cldap, ldap_msg, src_addr, src_port);
123                 } else {
124                         DEBUG(2,("Mismatched cldap reply %u from %s:%d\n",
125                                  ldap_msg->messageid, src_addr, src_port));
126                 }
127                 talloc_free(tmp_ctx);
128                 return;
129         }
130
131         req->asn1 = asn1;
132         talloc_steal(req, asn1.data);
133         req->asn1.ofs = 0;
134
135         req->state = CLDAP_REQUEST_DONE;
136         talloc_free(req->te);
137
138         talloc_free(tmp_ctx);
139
140         if (req->async.fn) {
141                 req->async.fn(req);
142         }
143 }
144
145 /*
146   handle request timeouts
147 */
148 static void cldap_request_timeout(struct event_context *event_ctx, 
149                                   struct timed_event *te, struct timeval t,
150                                   void *private)
151 {
152         struct cldap_request *req = talloc_get_type(private, struct cldap_request);
153
154         /* possibly try again */
155         if (req->num_retries != 0) {
156                 size_t len = req->encoded.length;
157
158                 req->num_retries--;
159
160                 socket_sendto(req->cldap->sock, &req->encoded, &len, 0, 
161                               req->dest_addr, req->dest_port);
162
163                 req->te = event_add_timed(req->cldap->event_ctx, req, 
164                                           timeval_current_ofs(req->timeout, 0),
165                                           cldap_request_timeout, req);
166                 return;
167         }
168
169         req->state = CLDAP_REQUEST_TIMEOUT;
170         if (req->async.fn) {
171                 req->async.fn(req);
172         }
173 }
174
175 /*
176   handle send events on a cldap socket
177 */
178 static void cldap_socket_send(struct cldap_socket *cldap)
179 {
180         struct cldap_request *req;
181         NTSTATUS status;
182
183         while ((req = cldap->send_queue)) {
184                 size_t len;
185                 
186                 len = req->encoded.length;
187                 status = socket_sendto(cldap->sock, &req->encoded, &len, 0, 
188                                        req->dest_addr, req->dest_port);
189                 if (NT_STATUS_IS_ERR(status)) {
190                         DEBUG(3,("Failed to send cldap request of length %u to %s:%d\n",
191                                  (unsigned)req->encoded.length, req->dest_addr, req->dest_port));
192                         DLIST_REMOVE(cldap->send_queue, req);
193                         talloc_free(req);
194                         continue;
195                 }
196
197                 if (!NT_STATUS_IS_OK(status)) return;
198
199                 DLIST_REMOVE(cldap->send_queue, req);
200
201                 if (req->is_reply) {
202                         talloc_free(req);
203                 } else {
204                         req->state = CLDAP_REQUEST_WAIT;
205
206                         req->te = event_add_timed(cldap->event_ctx, req, 
207                                                   timeval_current_ofs(req->timeout, 0),
208                                                   cldap_request_timeout, req);
209
210                         EVENT_FD_READABLE(cldap->fde);
211                 }
212         }
213
214         EVENT_FD_NOT_WRITEABLE(cldap->fde);
215         return;
216 }
217
218
219 /*
220   handle fd events on a cldap_socket
221 */
222 static void cldap_socket_handler(struct event_context *ev, struct fd_event *fde,
223                                  uint16_t flags, void *private)
224 {
225         struct cldap_socket *cldap = talloc_get_type(private, struct cldap_socket);
226         if (flags & EVENT_FD_WRITE) {
227                 cldap_socket_send(cldap);
228         } 
229         if (flags & EVENT_FD_READ) {
230                 cldap_socket_recv(cldap);
231         }
232 }
233
234 /*
235   initialise a cldap_socket. The event_ctx is optional, if provided
236   then operations will use that event context
237 */
238 struct cldap_socket *cldap_socket_init(TALLOC_CTX *mem_ctx, 
239                                        struct event_context *event_ctx)
240 {
241         struct cldap_socket *cldap;
242         NTSTATUS status;
243
244         cldap = talloc(mem_ctx, struct cldap_socket);
245         if (cldap == NULL) goto failed;
246
247         if (event_ctx == NULL) {
248                 cldap->event_ctx = event_context_init(cldap);
249         } else {
250                 cldap->event_ctx = talloc_reference(cldap, event_ctx);
251         }
252         if (cldap->event_ctx == NULL) goto failed;
253
254         cldap->idr = idr_init(cldap);
255         if (cldap->idr == NULL) goto failed;
256
257         status = socket_create("ip", SOCKET_TYPE_DGRAM, &cldap->sock, 0);
258         if (!NT_STATUS_IS_OK(status)) goto failed;
259
260         talloc_steal(cldap, cldap->sock);
261
262         cldap->fde = event_add_fd(cldap->event_ctx, cldap, 
263                                       socket_get_fd(cldap->sock), 0,
264                                       cldap_socket_handler, cldap);
265
266         cldap->send_queue = NULL;
267         cldap->incoming.handler = NULL;
268         
269         return cldap;
270
271 failed:
272         talloc_free(cldap);
273         return NULL;
274 }
275
276
277 /*
278   setup a handler for incoming requests
279 */
280 NTSTATUS cldap_set_incoming_handler(struct cldap_socket *cldap,
281                                   void (*handler)(struct cldap_socket *, struct ldap_message *, 
282                                                   const char *, int ),
283                                   void *private)
284 {
285         cldap->incoming.handler = handler;
286         cldap->incoming.private = private;
287         EVENT_FD_READABLE(cldap->fde);
288         return NT_STATUS_OK;
289 }
290
291 /*
292   queue a cldap request for send
293 */
294 struct cldap_request *cldap_search_send(struct cldap_socket *cldap, 
295                                         struct cldap_search *io)
296 {
297         struct ldap_message *msg;
298         struct cldap_request *req;
299         struct ldap_SearchRequest *search;
300
301         req = talloc_zero(cldap, struct cldap_request);
302         if (req == NULL) goto failed;
303
304         req->cldap       = cldap;
305         req->state       = CLDAP_REQUEST_SEND;
306         req->timeout     = io->in.timeout;
307         req->num_retries = io->in.retries;
308         req->is_reply    = False;
309
310         req->dest_addr = talloc_strdup(req, io->in.dest_address);
311         if (req->dest_addr == NULL) goto failed;
312         req->dest_port = lp_cldap_port();
313
314         req->message_id = idr_get_new_random(cldap->idr, req, UINT16_MAX);
315         if (req->message_id == -1) goto failed;
316
317         talloc_set_destructor(req, cldap_request_destructor);
318
319         msg = talloc(req, struct ldap_message);
320         if (msg == NULL) goto failed;
321         msg->messageid       = req->message_id;
322         msg->type            = LDAP_TAG_SearchRequest;
323         msg->num_controls    = 0;
324         msg->controls        = NULL;
325         search = &msg->r.SearchRequest;
326
327         search->basedn         = "";
328         search->scope          = LDAP_SEARCH_SCOPE_BASE;
329         search->deref          = LDAP_DEREFERENCE_NEVER;
330         search->timelimit      = 0;
331         search->sizelimit      = 0;
332         search->attributesonly = False;
333         search->num_attributes = str_list_length(io->in.attributes);
334         search->attributes     = io->in.attributes;
335         search->tree           = ldb_parse_tree(req, io->in.filter);
336         if (search->tree == NULL) {
337                 goto failed;
338         }
339
340         if (!ldap_encode(msg, &req->encoded)) {
341                 DEBUG(0,("Failed to encode cldap message to %s:%d\n",
342                          req->dest_addr, req->dest_port));
343                 goto failed;
344         }
345         talloc_steal(req, req->encoded.data);
346
347         DLIST_ADD_END(cldap->send_queue, req, struct cldap_request *);
348
349         EVENT_FD_WRITEABLE(cldap->fde);
350
351         return req;
352
353 failed:
354         talloc_free(req);
355         return NULL;
356 }
357
358
359 /*
360   queue a cldap reply for send
361 */
362 NTSTATUS cldap_reply_send(struct cldap_socket *cldap, struct cldap_reply *io)
363 {
364         struct ldap_message *msg;
365         struct cldap_request *req;
366         DATA_BLOB blob1, blob2;
367         NTSTATUS status = NT_STATUS_NO_MEMORY;
368
369         req = talloc_zero(cldap, struct cldap_request);
370         if (req == NULL) goto failed;
371
372         req->cldap       = cldap;
373         req->state       = CLDAP_REQUEST_SEND;
374         req->is_reply    = True;
375
376         req->dest_addr = talloc_strdup(req, io->dest_address);
377         if (req->dest_addr == NULL) goto failed;
378         req->dest_port = io->dest_port;
379
380         talloc_set_destructor(req, cldap_request_destructor);
381
382         msg = talloc(req, struct ldap_message);
383         if (msg == NULL) goto failed;
384         msg->messageid       = io->messageid;
385         msg->num_controls    = 0;
386         msg->controls        = NULL;
387         
388         if (io->response) {
389                 msg->type = LDAP_TAG_SearchResultEntry;
390                 msg->r.SearchResultEntry = *io->response;
391
392                 if (!ldap_encode(msg, &blob1)) {
393                         DEBUG(0,("Failed to encode cldap message to %s:%d\n",
394                                  req->dest_addr, req->dest_port));
395                         status = NT_STATUS_INVALID_PARAMETER;
396                         goto failed;
397                 }
398                 talloc_steal(req, blob1.data);
399         } else {
400                 blob1 = data_blob(NULL, 0);
401         }
402
403         msg->type = LDAP_TAG_SearchResultDone;
404         msg->r.SearchResultDone = *io->result;
405
406         if (!ldap_encode(msg, &blob2)) {
407                 DEBUG(0,("Failed to encode cldap message to %s:%d\n",
408                          req->dest_addr, req->dest_port));
409                 status = NT_STATUS_INVALID_PARAMETER;
410                 goto failed;
411         }
412         talloc_steal(req, blob2.data);
413
414         req->encoded = data_blob_talloc(req, NULL, blob1.length + blob2.length);
415         if (req->encoded.data == NULL) goto failed;
416
417         memcpy(req->encoded.data, blob1.data, blob1.length);
418         memcpy(req->encoded.data+blob1.length, blob2.data, blob2.length);
419
420         DLIST_ADD_END(cldap->send_queue, req, struct cldap_request *);
421
422         EVENT_FD_WRITEABLE(cldap->fde);
423
424         return NT_STATUS_OK;
425
426 failed:
427         talloc_free(req);
428         return status;
429 }
430
431 /*
432   receive a cldap reply
433 */
434 NTSTATUS cldap_search_recv(struct cldap_request *req, 
435                            TALLOC_CTX *mem_ctx, 
436                            struct cldap_search *io)
437 {
438         struct ldap_message *ldap_msg;
439
440         if (req == NULL) {
441                 return NT_STATUS_NO_MEMORY;
442         }
443
444         while (req->state < CLDAP_REQUEST_DONE) {
445                 if (event_loop_once(req->cldap->event_ctx) != 0) {
446                         talloc_free(req);
447                         return NT_STATUS_UNEXPECTED_NETWORK_ERROR;
448                 }
449         }
450
451         if (req->state == CLDAP_REQUEST_TIMEOUT) {
452                 talloc_free(req);
453                 return NT_STATUS_IO_TIMEOUT;
454         }
455
456         ldap_msg = talloc(mem_ctx, struct ldap_message);
457         NT_STATUS_HAVE_NO_MEMORY(ldap_msg);
458
459         if (!ldap_decode(&req->asn1, ldap_msg)) {
460                 talloc_free(req);
461                 return NT_STATUS_INVALID_PARAMETER;
462         }
463
464         ZERO_STRUCT(io->out);
465
466         /* the first possible form has a search result in first place */
467         if (ldap_msg->type == LDAP_TAG_SearchResultEntry) {
468                 io->out.response = talloc(mem_ctx, struct ldap_SearchResEntry);
469                 NT_STATUS_HAVE_NO_MEMORY(io->out.response);
470                 *io->out.response = ldap_msg->r.SearchResultEntry;
471
472                 /* decode the 2nd part */
473                 if (!ldap_decode(&req->asn1, ldap_msg)) {
474                         talloc_free(req);
475                         return NT_STATUS_INVALID_PARAMETER;
476                 }
477         }
478
479         if (ldap_msg->type != LDAP_TAG_SearchResultDone) {
480                 talloc_free(req);
481                 return NT_STATUS_UNEXPECTED_NETWORK_ERROR;
482         }
483
484         io->out.result = talloc(mem_ctx, struct ldap_Result);
485         NT_STATUS_HAVE_NO_MEMORY(io->out.result);
486         *io->out.result = ldap_msg->r.SearchResultDone;
487
488         talloc_free(req);
489         return NT_STATUS_OK;
490 }
491
492
493 /*
494   synchronous cldap search
495 */
496 NTSTATUS cldap_search(struct cldap_socket *cldap, 
497                       TALLOC_CTX *mem_ctx, 
498                       struct cldap_search *io)
499 {
500         struct cldap_request *req = cldap_search_send(cldap, io);
501         return cldap_search_recv(req, mem_ctx, io);
502 }
503
504
505
506 /*
507   queue a cldap netlogon for send
508 */
509 struct cldap_request *cldap_netlogon_send(struct cldap_socket *cldap, 
510                                           struct cldap_netlogon *io)
511 {
512         struct cldap_search search;
513         char *filter;
514         struct cldap_request *req;
515         const char *attr[] = { "NetLogon", NULL };
516         TALLOC_CTX *tmp_ctx = talloc_new(cldap);
517
518         filter = talloc_asprintf(tmp_ctx, "(&(NtVer=%s)", 
519                                  ldap_encode_ndr_uint32(tmp_ctx, io->in.version));
520         if (filter == NULL) goto failed;
521         if (io->in.user) {
522                 filter = talloc_asprintf_append(filter, "(User=%s)", io->in.user);
523                 if (filter == NULL) goto failed;
524         }
525         if (io->in.host) {
526                 filter = talloc_asprintf_append(filter, "(Host=%s)", io->in.host);
527                 if (filter == NULL) goto failed;
528         }
529         if (io->in.realm) {
530                 filter = talloc_asprintf_append(filter, "(DnsDomain=%s)", io->in.realm);
531                 if (filter == NULL) goto failed;
532         }
533         if (io->in.acct_control != -1) {
534                 filter = talloc_asprintf_append(filter, "(AAC=%s)", 
535                                                 ldap_encode_ndr_uint32(tmp_ctx, io->in.acct_control));
536                 if (filter == NULL) goto failed;
537         }
538         if (io->in.domain_sid) {
539                 struct dom_sid *sid = dom_sid_parse_talloc(tmp_ctx, io->in.domain_sid);
540                 if (sid == NULL) goto failed;
541                 filter = talloc_asprintf_append(filter, "(domainSid=%s)",
542                                                 ldap_encode_ndr_dom_sid(tmp_ctx, sid));
543                 if (filter == NULL) goto failed;
544         }
545         if (io->in.domain_guid) {
546                 struct GUID guid;
547                 NTSTATUS status;
548                 status = GUID_from_string(io->in.domain_guid, &guid);
549                 if (!NT_STATUS_IS_OK(status)) goto failed;
550                 filter = talloc_asprintf_append(filter, "(DomainGuid=%s)",
551                                                 ldap_encode_ndr_GUID(tmp_ctx, &guid));
552                 if (filter == NULL) goto failed;
553         }
554         filter = talloc_asprintf_append(filter, ")");
555         if (filter == NULL) goto failed;
556
557         search.in.dest_address = io->in.dest_address;
558         search.in.filter       = filter;
559         search.in.attributes   = attr;
560         search.in.timeout      = 2;
561         search.in.retries      = 2;
562
563         req = cldap_search_send(cldap, &search);
564
565         talloc_free(tmp_ctx);
566         return req;
567 failed:
568         talloc_free(tmp_ctx);
569         return NULL;
570 }
571
572
573 /*
574   receive a cldap netlogon reply
575 */
576 NTSTATUS cldap_netlogon_recv(struct cldap_request *req, 
577                              TALLOC_CTX *mem_ctx, 
578                              struct cldap_netlogon *io)
579 {
580         NTSTATUS status;
581         struct cldap_search search;
582         DATA_BLOB *data;
583
584         status = cldap_search_recv(req, mem_ctx, &search);
585         if (!NT_STATUS_IS_OK(status)) {
586                 return status;
587         }
588         if (search.out.response == NULL) {
589                 return NT_STATUS_NOT_FOUND;
590         }
591
592         if (search.out.response->num_attributes != 1 ||
593             strcasecmp(search.out.response->attributes[0].name, "netlogon") != 0 ||
594             search.out.response->attributes[0].num_values != 1 ||
595             search.out.response->attributes[0].values->length < 2) {
596                 return NT_STATUS_UNEXPECTED_NETWORK_ERROR;
597         }
598         data = search.out.response->attributes[0].values;
599
600         status = ndr_pull_union_blob(data, mem_ctx, &io->out.netlogon, 
601                                      io->in.version & 0xF,
602                                      (ndr_pull_flags_fn_t)ndr_pull_nbt_cldap_netlogon);
603         if (!NT_STATUS_IS_OK(status)) {
604                 DEBUG(2,("cldap failed to parse netlogon response of type 0x%02x\n",
605                          SVAL(data->data, 0)));
606                 dump_data(10, data->data, data->length);
607         }
608
609         return status;
610 }
611
612 /*
613   sync cldap netlogon search
614 */
615 NTSTATUS cldap_netlogon(struct cldap_socket *cldap, 
616                         TALLOC_CTX *mem_ctx, struct cldap_netlogon *io)
617 {
618         struct cldap_request *req = cldap_netlogon_send(cldap, io);
619         return cldap_netlogon_recv(req, mem_ctx, io);
620 }
621
622
623 /*
624   send an empty reply (used on any error, so the client doesn't keep waiting
625   or send the bad request again)
626 */
627 NTSTATUS cldap_empty_reply(struct cldap_socket *cldap, 
628                            uint32_t message_id,
629                            const char *src_address, int src_port)
630 {
631         NTSTATUS status;
632         struct cldap_reply reply;
633         struct ldap_Result result;
634
635         reply.messageid    = message_id;
636         reply.dest_address = src_address;
637         reply.dest_port    = src_port;
638         reply.response     = NULL;
639         reply.result       = &result;
640
641         ZERO_STRUCT(result);
642
643         status = cldap_reply_send(cldap, &reply);
644
645         return status;
646 }
647
648
649 /*
650   send a netlogon reply 
651 */
652 NTSTATUS cldap_netlogon_reply(struct cldap_socket *cldap, 
653                               uint32_t message_id,
654                               const char *src_address, int src_port,
655                               uint32_t version,
656                               union nbt_cldap_netlogon *netlogon)
657 {
658         NTSTATUS status;
659         struct cldap_reply reply;
660         struct ldap_SearchResEntry response;
661         struct ldap_Result result;
662         TALLOC_CTX *tmp_ctx = talloc_new(cldap);
663         DATA_BLOB blob;
664
665         status = ndr_push_union_blob(&blob, tmp_ctx, netlogon, version & 0xF, 
666                                      (ndr_push_flags_fn_t)ndr_push_nbt_cldap_netlogon);
667         if (!NT_STATUS_IS_OK(status)) {
668                 talloc_free(tmp_ctx);
669                 return status;
670         }
671
672         reply.messageid    = message_id;
673         reply.dest_address = src_address;
674         reply.dest_port    = src_port;
675         reply.response     = &response;
676         reply.result       = &result;
677
678         ZERO_STRUCT(result);
679
680         response.dn = "";
681         response.num_attributes = 1;
682         response.attributes = talloc(tmp_ctx, struct ldb_message_element);
683         NT_STATUS_HAVE_NO_MEMORY(response.attributes);
684         response.attributes->name = "netlogon";
685         response.attributes->num_values = 1;
686         response.attributes->values = &blob;
687
688         status = cldap_reply_send(cldap, &reply);
689
690         talloc_free(tmp_ctx);
691
692         return status;
693 }
694
695