?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
smbd: Remove callback for release_ip when "state" is free'ed
[Samba.git] / libcli / cldap / cldap.c
blob8176946e8b5734098e567e8fc567286415f4edcd
1 /*
2 Unix SMB/CIFS implementation.
3
4 cldap client library
5
6 Copyright (C) Andrew Tridgell 2005
7 Copyright (C) Stefan Metzmacher 2009
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 3 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, see <http://www.gnu.org/licenses/>.
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 <tevent.h>
37 #include "../lib/util/dlinklist.h"
38 #include "../libcli/ldap/ldap_message.h"
39 #include "../libcli/ldap/ldap_ndr.h"
40 #include "../libcli/cldap/cldap.h"
41 #include "../lib/tsocket/tsocket.h"
42 #include "../libcli/security/dom_sid.h"
43 #include "../librpc/gen_ndr/ndr_nbt.h"
44 #include "../lib/util/asn1.h"
45 #include "../lib/util/tevent_ntstatus.h"
46 #include "lib/util/idtree_random.h"
47
48 #undef strcasecmp
49
50 /*
51 context structure for operations on cldap packets
52 */
53 struct cldap_socket {
54 /* the low level socket */
55 struct tdgram_context *sock;
56
57 /*
58 * Are we in connected mode, which means
59 * we get ICMP errors back instead of timing
60 * out requests. And we can only send requests
61 * to the connected peer.
62 */
63 bool connected;
64
65 /* the queue for outgoing dgrams */
66 struct tevent_queue *send_queue;
67
68 /* do we have an async tsocket_recvfrom request pending */
69 struct tevent_req *recv_subreq;
70
71 struct {
72 /* a queue of pending search requests */
73 struct cldap_search_state *list;
74
75 /* mapping from message_id to pending request */
76 struct idr_context *idr;
77 } searches;
78
79 /* what to do with incoming request packets */
80 struct {
81 struct tevent_context *ev;
82 void (*handler)(struct cldap_socket *,
83 void *private_data,
84 struct cldap_incoming *);
85 void *private_data;
86 } incoming;
87 };
88
89 struct cldap_search_state {
90 struct cldap_search_state *prev, *next;
91
92 struct {
93 struct tevent_context *ev;
94 struct cldap_socket *cldap;
95 } caller;
96
97 int message_id;
98
99 struct {
100 uint32_t idx;
101 uint32_t delay;
102 uint32_t count;
103 struct tsocket_address *dest;
104 DATA_BLOB blob;
105 } request;
106
107 struct {
108 struct cldap_incoming *in;
109 struct asn1_data *asn1;
110 } response;
111
112 struct tevent_req *req;
113 };
114
115 /*
116 * For CLDAP we limit the maximum search request size to 4kb
117 */
118 #define MAX_SEARCH_REQUEST 4096
119
120 static int cldap_socket_destructor(struct cldap_socket *c)
121 {
122 while (c->searches.list) {
123 struct cldap_search_state *s = c->searches.list;
124 DLIST_REMOVE(c->searches.list, s);
125 ZERO_STRUCT(s->caller);
126 }
127
128 talloc_free(c->recv_subreq);
129 talloc_free(c->send_queue);
130 talloc_free(c->sock);
131 return 0;
132 }
133
134 static void cldap_recvfrom_done(struct tevent_req *subreq);
135
136 static bool cldap_recvfrom_setup(struct cldap_socket *c)
137 {
138 struct tevent_context *ev;
139
140 if (c->recv_subreq) {
141 return true;
142 }
143
144 if (!c->searches.list && !c->incoming.handler) {
145 return true;
146 }
147
148 ev = c->incoming.ev;
149 if (ev == NULL) {
150 /* this shouldn't happen but should be protected against */
151 if (c->searches.list == NULL) {
152 return false;
153 }
154 ev = c->searches.list->caller.ev;
155 }
156
157 c->recv_subreq = tdgram_recvfrom_send(c, ev, c->sock);
158 if (!c->recv_subreq) {
159 return false;
160 }
161 tevent_req_set_callback(c->recv_subreq, cldap_recvfrom_done, c);
162
163 return true;
164 }
165
166 static void cldap_recvfrom_stop(struct cldap_socket *c)
167 {
168 if (!c->recv_subreq) {
169 return;
170 }
171
172 if (c->searches.list || c->incoming.handler) {
173 return;
174 }
175
176 talloc_free(c->recv_subreq);
177 c->recv_subreq = NULL;
178 }
179
180 static bool cldap_socket_recv_dgram(struct cldap_socket *c,
181 struct cldap_incoming *in);
182
183 static void cldap_recvfrom_done(struct tevent_req *subreq)
184 {
185 struct cldap_socket *c = tevent_req_callback_data(subreq,
186 struct cldap_socket);
187 struct cldap_incoming *in = NULL;
188 ssize_t ret;
189 bool setup_done;
190
191 c->recv_subreq = NULL;
192
193 in = talloc_zero(c, struct cldap_incoming);
194 if (!in) {
195 goto nomem;
196 }
197
198 ret = tdgram_recvfrom_recv(subreq,
199 &in->recv_errno,
200 in,
201 &in->buf,
202 &in->src);
203 talloc_free(subreq);
204 subreq = NULL;
205 if (ret >= 0) {
206 in->len = ret;
207 }
208 if (ret == -1 && in->recv_errno == 0) {
209 in->recv_errno = EIO;
210 }
211
212 /* this function should free or steal 'in' */
213 setup_done = cldap_socket_recv_dgram(c, in);
214 in = NULL;
215
216 if (!setup_done && !cldap_recvfrom_setup(c)) {
217 goto nomem;
218 }
219
220 return;
221
222 nomem:
223 talloc_free(subreq);
224 talloc_free(in);
225 }
226
227 /*
228 handle recv events on a cldap socket
229 */
230 static bool cldap_socket_recv_dgram(struct cldap_socket *c,
231 struct cldap_incoming *in)
232 {
233 struct asn1_data *asn1;
234 void *p;
235 struct cldap_search_state *search;
236 NTSTATUS status;
237 struct ldap_request_limits limits = {
238 .max_search_size = MAX_SEARCH_REQUEST
239 };
240
241 if (in->recv_errno != 0) {
242 goto error;
243 }
244
245 asn1 = asn1_init(in, ASN1_MAX_TREE_DEPTH);
246 if (!asn1) {
247 goto nomem;
248 }
249
250 asn1_load_nocopy(asn1, in->buf, in->len);
251
252 in->ldap_msg = talloc(in, struct ldap_message);
253 if (in->ldap_msg == NULL) {
254 goto nomem;
255 }
256
257 /* this initial decode is used to find the message id */
258 status = ldap_decode(asn1, &limits, NULL, in->ldap_msg);
259 if (!NT_STATUS_IS_OK(status)) {
260 goto nterror;
261 }
262
263 /* find the pending request */
264 p = idr_find(c->searches.idr, in->ldap_msg->messageid);
265 if (p == NULL) {
266 if (!c->incoming.handler) {
267 TALLOC_FREE(in);
268 return true;
269 }
270
271 /* this function should free or steal 'in' */
272 c->incoming.handler(c, c->incoming.private_data, in);
273 return false;
274 }
275
276 search = talloc_get_type_abort(p, struct cldap_search_state);
277 search->response.in = talloc_move(search, &in);
278
279 search->response.asn1 = asn1;
280
281 asn1_load_nocopy(search->response.asn1,
282 search->response.in->buf, search->response.in->len);
283
284 DLIST_REMOVE(c->searches.list, search);
285
286 if (cldap_recvfrom_setup(c)) {
287 tevent_req_done(search->req);
288 return true;
289 }
290
291 /*
292 * This request was ok, just defer the notify of the caller
293 * and then just fail the next request if needed
294 */
295 tevent_req_defer_callback(search->req, search->caller.ev);
296 tevent_req_done(search->req);
297
298 status = NT_STATUS_NO_MEMORY;
299 /* in is NULL it this point */
300 goto nterror;
301 nomem:
302 in->recv_errno = ENOMEM;
303 error:
304 status = map_nt_error_from_unix_common(in->recv_errno);
305 nterror:
306 TALLOC_FREE(in);
307 /* in connected mode the first pending search gets the error */
308 if (!c->connected) {
309 /* otherwise we just ignore the error */
310 return false;
311 }
312 if (!c->searches.list) {
313 return false;
314 }
315 /*
316 * We might called tevent_req_done() for a successful
317 * search before, so we better deliver the failure
318 * after the success, that is why we better also
319 * use tevent_req_defer_callback() here.
320 */
321 tevent_req_defer_callback(c->searches.list->req,
322 c->searches.list->caller.ev);
323 tevent_req_nterror(c->searches.list->req, status);
324 return false;
325 }
326
327 /*
328 initialise a cldap_sock
329 */
330 NTSTATUS cldap_socket_init(TALLOC_CTX *mem_ctx,
331 const struct tsocket_address *local_addr,
332 const struct tsocket_address *remote_addr,
333 struct cldap_socket **_cldap)
334 {
335 struct cldap_socket *c = NULL;
336 struct tsocket_address *any = NULL;
337 NTSTATUS status;
338 int ret;
339 const char *fam = NULL;
340
341 if (local_addr == NULL && remote_addr == NULL) {
342 return NT_STATUS_INVALID_PARAMETER_MIX;
343 }
344
345 if (remote_addr) {
346 bool is_ipv4;
347 bool is_ipv6;
348
349 is_ipv4 = tsocket_address_is_inet(remote_addr, "ipv4");
350 is_ipv6 = tsocket_address_is_inet(remote_addr, "ipv6");
351
352 if (is_ipv4) {
353 fam = "ipv4";
354 } else if (is_ipv6) {
355 fam = "ipv6";
356 } else {
357 return NT_STATUS_INVALID_ADDRESS;
358 }
359 }
360
361 c = talloc_zero(mem_ctx, struct cldap_socket);
362 if (!c) {
363 goto nomem;
364 }
365
366 if (!local_addr) {
367 /*
368 * Here we know the address family of the remote address.
369 */
370 if (fam == NULL) {
371 return NT_STATUS_INVALID_PARAMETER_MIX;
372 }
373
374 ret = tsocket_address_inet_from_strings(c, fam,
375 NULL, 0,
376 &any);
377 if (ret != 0) {
378 status = map_nt_error_from_unix_common(errno);
379 goto nterror;
380 }
381 local_addr = any;
382 }
383
384 c->searches.idr = idr_init(c);
385 if (!c->searches.idr) {
386 goto nomem;
387 }
388
389 ret = tdgram_inet_udp_socket(local_addr, remote_addr,
390 c, &c->sock);
391 if (ret != 0) {
392 status = map_nt_error_from_unix_common(errno);
393 goto nterror;
394 }
395 talloc_free(any);
396
397 if (remote_addr) {
398 c->connected = true;
399 }
400
401 c->send_queue = tevent_queue_create(c, "cldap_send_queue");
402 if (!c->send_queue) {
403 goto nomem;
404 }
405
406 talloc_set_destructor(c, cldap_socket_destructor);
407
408 *_cldap = c;
409 return NT_STATUS_OK;
410
411 nomem:
412 status = NT_STATUS_NO_MEMORY;
413 nterror:
414 talloc_free(c);
415 return status;
416 }
417
418 /*
419 setup a handler for incoming requests
420 */
421 NTSTATUS cldap_set_incoming_handler(struct cldap_socket *c,
422 struct tevent_context *ev,
423 void (*handler)(struct cldap_socket *,
424 void *private_data,
425 struct cldap_incoming *),
426 void *private_data)
427 {
428 if (c->connected) {
429 return NT_STATUS_PIPE_CONNECTED;
430 }
431
432 c->incoming.ev = ev;
433 c->incoming.handler = handler;
434 c->incoming.private_data = private_data;
435
436 if (!cldap_recvfrom_setup(c)) {
437 ZERO_STRUCT(c->incoming);
438 return NT_STATUS_NO_MEMORY;
439 }
440
441 return NT_STATUS_OK;
442 }
443
444 struct cldap_reply_state {
445 struct tsocket_address *dest;
446 DATA_BLOB blob;
447 };
448
449 static void cldap_reply_state_destroy(struct tevent_req *subreq);
450
451 /*
452 queue a cldap reply for send
453 */
454 NTSTATUS cldap_reply_send(struct cldap_socket *cldap, struct cldap_reply *io)
455 {
456 struct cldap_reply_state *state = NULL;
457 struct ldap_message *msg;
458 DATA_BLOB blob1, blob2;
459 NTSTATUS status;
460 struct tevent_req *subreq;
461
462 if (cldap->connected) {
463 return NT_STATUS_PIPE_CONNECTED;
464 }
465
466 if (cldap->incoming.ev == NULL) {
467 return NT_STATUS_INVALID_PIPE_STATE;
468 }
469
470 if (!io->dest) {
471 return NT_STATUS_INVALID_ADDRESS;
472 }
473
474 state = talloc(cldap, struct cldap_reply_state);
475 NT_STATUS_HAVE_NO_MEMORY(state);
476
477 state->dest = tsocket_address_copy(io->dest, state);
478 if (!state->dest) {
479 goto nomem;
480 }
481
482 msg = talloc(state, struct ldap_message);
483 if (!msg) {
484 goto nomem;
485 }
486
487 msg->messageid = io->messageid;
488 msg->controls = NULL;
489
490 if (io->response) {
491 msg->type = LDAP_TAG_SearchResultEntry;
492 msg->r.SearchResultEntry = *io->response;
493
494 if (!ldap_encode(msg, NULL, &blob1, state)) {
495 status = NT_STATUS_INVALID_PARAMETER;
496 goto failed;
497 }
498 } else {
499 blob1 = data_blob(NULL, 0);
500 }
501
502 msg->type = LDAP_TAG_SearchResultDone;
503 msg->r.SearchResultDone = *io->result;
504
505 if (!ldap_encode(msg, NULL, &blob2, state)) {
506 status = NT_STATUS_INVALID_PARAMETER;
507 goto failed;
508 }
509 talloc_free(msg);
510
511 state->blob = data_blob_talloc(state, NULL, blob1.length + blob2.length);
512 if (!state->blob.data) {
513 goto nomem;
514 }
515
516 if (blob1.data != NULL) {
517 memcpy(state->blob.data, blob1.data, blob1.length);
518 }
519 memcpy(state->blob.data+blob1.length, blob2.data, blob2.length);
520 data_blob_free(&blob1);
521 data_blob_free(&blob2);
522
523 subreq = tdgram_sendto_queue_send(state,
524 cldap->incoming.ev,
525 cldap->sock,
526 cldap->send_queue,
527 state->blob.data,
528 state->blob.length,
529 state->dest);
530 if (!subreq) {
531 goto nomem;
532 }
533 /* the callback will just free the state, as we don't need a result */
534 tevent_req_set_callback(subreq, cldap_reply_state_destroy, state);
535
536 return NT_STATUS_OK;
537
538 nomem:
539 status = NT_STATUS_NO_MEMORY;
540 failed:
541 talloc_free(state);
542 return status;
543 }
544
545 static void cldap_reply_state_destroy(struct tevent_req *subreq)
546 {
547 struct cldap_reply_state *state = tevent_req_callback_data(subreq,
548 struct cldap_reply_state);
549
550 /* we don't want to know the result here, we just free the state */
551 talloc_free(subreq);
552 talloc_free(state);
553 }
554
555 static int cldap_search_state_destructor(struct cldap_search_state *s)
556 {
557 if (s->caller.cldap) {
558 if (s->message_id != -1) {
559 idr_remove(s->caller.cldap->searches.idr, s->message_id);
560 s->message_id = -1;
561 }
562 DLIST_REMOVE(s->caller.cldap->searches.list, s);
563 cldap_recvfrom_stop(s->caller.cldap);
564 ZERO_STRUCT(s->caller);
565 }
566
567 return 0;
568 }
569
570 static void cldap_search_state_queue_done(struct tevent_req *subreq);
571 static void cldap_search_state_wakeup_done(struct tevent_req *subreq);
572
573 /*
574 queue a cldap reply for send
575 */
576 struct tevent_req *cldap_search_send(TALLOC_CTX *mem_ctx,
577 struct tevent_context *ev,
578 struct cldap_socket *cldap,
579 const struct cldap_search *io)
580 {
581 struct tevent_req *req, *subreq;
582 struct cldap_search_state *state = NULL;
583 struct ldap_message *msg;
584 struct ldap_SearchRequest *search;
585 struct timeval now;
586 struct timeval end;
587 uint32_t i;
588 int ret;
589
590 req = tevent_req_create(mem_ctx, &state,
591 struct cldap_search_state);
592 if (!req) {
593 return NULL;
594 }
595 state->caller.ev = ev;
596 state->req = req;
597 state->caller.cldap = cldap;
598 state->message_id = -1;
599
600 talloc_set_destructor(state, cldap_search_state_destructor);
601
602 if (state->caller.cldap == NULL) {
603 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
604 goto post;
605 }
606
607 if (io->in.dest_address) {
608 if (cldap->connected) {
609 tevent_req_nterror(req, NT_STATUS_PIPE_CONNECTED);
610 goto post;
611 }
612 ret = tsocket_address_inet_from_strings(state,
613 "ip",
614 io->in.dest_address,
615 io->in.dest_port,
616 &state->request.dest);
617 if (ret != 0) {
618 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
619 goto post;
620 }
621 } else {
622 if (!cldap->connected) {
623 tevent_req_nterror(req, NT_STATUS_INVALID_ADDRESS);
624 goto post;
625 }
626 state->request.dest = NULL;
627 }
628
629 state->message_id = idr_get_new_random(
630 cldap->searches.idr, state, 1, UINT16_MAX);
631 if (state->message_id == -1) {
632 tevent_req_nterror(req, NT_STATUS_INSUFFICIENT_RESOURCES);
633 goto post;
634 }
635
636 msg = talloc(state, struct ldap_message);
637 if (tevent_req_nomem(msg, req)) {
638 goto post;
639 }
640
641 msg->messageid = state->message_id;
642 msg->type = LDAP_TAG_SearchRequest;
643 msg->controls = NULL;
644 search = &msg->r.SearchRequest;
645
646 search->basedn = "";
647 search->scope = LDAP_SEARCH_SCOPE_BASE;
648 search->deref = LDAP_DEREFERENCE_NEVER;
649 search->timelimit = 0;
650 search->sizelimit = 0;
651 search->attributesonly = false;
652 search->num_attributes = str_list_length(io->in.attributes);
653 search->attributes = io->in.attributes;
654 search->tree = ldb_parse_tree(msg, io->in.filter);
655 if (tevent_req_nomem(search->tree, req)) {
656 goto post;
657 }
658
659 if (!ldap_encode(msg, NULL, &state->request.blob, state)) {
660 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
661 goto post;
662 }
663 talloc_free(msg);
664
665 state->request.idx = 0;
666 state->request.delay = 10*1000*1000;
667 state->request.count = 3;
668 if (io->in.timeout > 0) {
669 state->request.delay = io->in.timeout * 1000 * 1000;
670 state->request.count = io->in.retries + 1;
671 }
672
673 now = tevent_timeval_current();
674 end = now;
675 for (i = 0; i < state->request.count; i++) {
676 end = tevent_timeval_add(&end, state->request.delay / 1000000,
677 state->request.delay % 1000000);
678 }
679
680 if (!tevent_req_set_endtime(req, state->caller.ev, end)) {
681 goto post;
682 }
683
684 subreq = tdgram_sendto_queue_send(state,
685 state->caller.ev,
686 state->caller.cldap->sock,
687 state->caller.cldap->send_queue,
688 state->request.blob.data,
689 state->request.blob.length,
690 state->request.dest);
691 if (tevent_req_nomem(subreq, req)) {
692 goto post;
693 }
694 tevent_req_set_callback(subreq, cldap_search_state_queue_done, req);
695
696 DLIST_ADD_END(cldap->searches.list, state);
697
698 return req;
699
700 post:
701 return tevent_req_post(req, state->caller.ev);
702 }
703
704 static void cldap_search_state_queue_done(struct tevent_req *subreq)
705 {
706 struct tevent_req *req = tevent_req_callback_data(subreq,
707 struct tevent_req);
708 struct cldap_search_state *state = tevent_req_data(req,
709 struct cldap_search_state);
710 ssize_t ret;
711 int sys_errno = 0;
712 struct timeval next;
713
714 ret = tdgram_sendto_queue_recv(subreq, &sys_errno);
715 talloc_free(subreq);
716 if (ret == -1) {
717 NTSTATUS status;
718 status = map_nt_error_from_unix_common(sys_errno);
719 DLIST_REMOVE(state->caller.cldap->searches.list, state);
720 ZERO_STRUCT(state->caller.cldap);
721 tevent_req_nterror(req, status);
722 return;
723 }
724
725 state->request.idx++;
726
727 /* wait for incoming traffic */
728 if (!cldap_recvfrom_setup(state->caller.cldap)) {
729 tevent_req_oom(req);
730 return;
731 }
732
733 if (state->request.idx > state->request.count) {
734 /* we just wait for the response or a timeout */
735 return;
736 }
737
738 next = tevent_timeval_current_ofs(state->request.delay / 1000000,
739 state->request.delay % 1000000);
740 subreq = tevent_wakeup_send(state,
741 state->caller.ev,
742 next);
743 if (tevent_req_nomem(subreq, req)) {
744 return;
745 }
746 tevent_req_set_callback(subreq, cldap_search_state_wakeup_done, req);
747 }
748
749 static void cldap_search_state_wakeup_done(struct tevent_req *subreq)
750 {
751 struct tevent_req *req = tevent_req_callback_data(subreq,
752 struct tevent_req);
753 struct cldap_search_state *state = tevent_req_data(req,
754 struct cldap_search_state);
755 bool ok;
756
757 ok = tevent_wakeup_recv(subreq);
758 talloc_free(subreq);
759 if (!ok) {
760 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
761 return;
762 }
763
764 subreq = tdgram_sendto_queue_send(state,
765 state->caller.ev,
766 state->caller.cldap->sock,
767 state->caller.cldap->send_queue,
768 state->request.blob.data,
769 state->request.blob.length,
770 state->request.dest);
771 if (tevent_req_nomem(subreq, req)) {
772 return;
773 }
774 tevent_req_set_callback(subreq, cldap_search_state_queue_done, req);
775 }
776
777 /*
778 receive a cldap reply
779 */
780 NTSTATUS cldap_search_recv(struct tevent_req *req,
781 TALLOC_CTX *mem_ctx,
782 struct cldap_search *io)
783 {
784 struct cldap_search_state *state = tevent_req_data(req,
785 struct cldap_search_state);
786 struct ldap_message *ldap_msg;
787 NTSTATUS status;
788 struct ldap_request_limits limits = {
789 .max_search_size = MAX_SEARCH_REQUEST
790 };
791
792 if (tevent_req_is_nterror(req, &status)) {
793 goto failed;
794 }
795
796 ldap_msg = talloc(mem_ctx, struct ldap_message);
797 if (!ldap_msg) {
798 goto nomem;
799 }
800
801 status = ldap_decode(state->response.asn1, &limits, NULL, ldap_msg);
802 if (!NT_STATUS_IS_OK(status)) {
803 goto failed;
804 }
805
806 ZERO_STRUCT(io->out);
807
808 /* the first possible form has a search result in first place */
809 if (ldap_msg->type == LDAP_TAG_SearchResultEntry) {
810 io->out.response = talloc(mem_ctx, struct ldap_SearchResEntry);
811 if (!io->out.response) {
812 goto nomem;
813 }
814 *io->out.response = ldap_msg->r.SearchResultEntry;
815
816 /* decode the 2nd part */
817 status = ldap_decode(
818 state->response.asn1, &limits, NULL, ldap_msg);
819 if (!NT_STATUS_IS_OK(status)) {
820 goto failed;
821 }
822 }
823
824 if (ldap_msg->type != LDAP_TAG_SearchResultDone) {
825 status = NT_STATUS_LDAP(LDAP_PROTOCOL_ERROR);
826 goto failed;
827 }
828
829 io->out.result = talloc(mem_ctx, struct ldap_Result);
830 if (!io->out.result) {
831 goto nomem;
832 }
833 *io->out.result = ldap_msg->r.SearchResultDone;
834
835 if (io->out.result->resultcode != LDAP_SUCCESS) {
836 status = NT_STATUS_LDAP(io->out.result->resultcode);
837 goto failed;
838 }
839
840 tevent_req_received(req);
841 return NT_STATUS_OK;
842
843 nomem:
844 status = NT_STATUS_NO_MEMORY;
845 failed:
846 tevent_req_received(req);
847 return status;
848 }
849
850
851 /*
852 synchronous cldap search
853 */
854 NTSTATUS cldap_search(struct cldap_socket *cldap,
855 TALLOC_CTX *mem_ctx,
856 struct cldap_search *io)
857 {
858 TALLOC_CTX *frame;
859 struct tevent_req *req;
860 struct tevent_context *ev;
861 NTSTATUS status;
862
863 if (cldap->searches.list) {
864 return NT_STATUS_PIPE_BUSY;
865 }
866
867 if (cldap->incoming.handler) {
868 return NT_STATUS_INVALID_PIPE_STATE;
869 }
870
871 frame = talloc_stackframe();
872
873 ev = samba_tevent_context_init(frame);
874 if (ev == NULL) {
875 TALLOC_FREE(frame);
876 return NT_STATUS_NO_MEMORY;
877 }
878
879 req = cldap_search_send(mem_ctx, ev, cldap, io);
880 if (req == NULL) {
881 TALLOC_FREE(frame);
882 return NT_STATUS_NO_MEMORY;
883 }
884
885 if (!tevent_req_poll(req, ev)) {
886 status = map_nt_error_from_unix_common(errno);
887 TALLOC_FREE(frame);
888 return status;
889 }
890
891 status = cldap_search_recv(req, mem_ctx, io);
892 if (!NT_STATUS_IS_OK(status)) {
893 TALLOC_FREE(frame);
894 return status;
895 }
896
897 TALLOC_FREE(frame);
898 return NT_STATUS_OK;
899 }
900
901 struct cldap_netlogon_state {
902 struct cldap_search search;
903 };
904
905 char *cldap_netlogon_create_filter(TALLOC_CTX *mem_ctx,
906 const struct cldap_netlogon *io)
907 {
908 char *filter;
909
910 filter = talloc_asprintf(mem_ctx, "(&(NtVer=%s)",
911 ldap_encode_ndr_uint32(mem_ctx, io->in.version));
912
913 if (io->in.user) {
914 talloc_asprintf_addbuf(&filter, "(User=%s)", io->in.user);
915 }
916 if (io->in.host) {
917 talloc_asprintf_addbuf(&filter, "(Host=%s)", io->in.host);
918 }
919 if (io->in.realm) {
920 talloc_asprintf_addbuf(&filter, "(DnsDomain=%s)", io->in.realm);
921 }
922 if (io->in.acct_control != -1) {
923 talloc_asprintf_addbuf(
924 &filter,
925 "(AAC=%s)",
926 ldap_encode_ndr_uint32(mem_ctx, io->in.acct_control));
927 }
928 if (io->in.domain_sid) {
929 struct dom_sid *sid = dom_sid_parse_talloc(mem_ctx, io->in.domain_sid);
930
931 talloc_asprintf_addbuf(&filter, "(domainSid=%s)",
932 ldap_encode_ndr_dom_sid(mem_ctx, sid));
933 }
934 if (io->in.domain_guid) {
935 struct GUID guid;
936 GUID_from_string(io->in.domain_guid, &guid);
937
938 talloc_asprintf_addbuf(&filter, "(DomainGuid=%s)",
939 ldap_encode_ndr_GUID(mem_ctx, &guid));
940 }
941 talloc_asprintf_addbuf(&filter, ")");
942
943 return filter;
944 }
945
946 static void cldap_netlogon_state_done(struct tevent_req *subreq);
947 /*
948 queue a cldap netlogon for send
949 */
950 struct tevent_req *cldap_netlogon_send(TALLOC_CTX *mem_ctx,
951 struct tevent_context *ev,
952 struct cldap_socket *cldap,
953 const struct cldap_netlogon *io)
954 {
955 struct tevent_req *req, *subreq;
956 struct cldap_netlogon_state *state;
957 char *filter;
958 static const char * const attr[] = { "NetLogon", NULL };
959
960 req = tevent_req_create(mem_ctx, &state,
961 struct cldap_netlogon_state);
962 if (!req) {
963 return NULL;
964 }
965
966 filter = cldap_netlogon_create_filter(state, io);
967 if (tevent_req_nomem(filter, req)) {
968 goto post;
969 }
970
971 if (io->in.dest_address) {
972 state->search.in.dest_address = talloc_strdup(state,
973 io->in.dest_address);
974 if (tevent_req_nomem(state->search.in.dest_address, req)) {
975 goto post;
976 }
977 state->search.in.dest_port = io->in.dest_port;
978 } else {
979 state->search.in.dest_address = NULL;
980 state->search.in.dest_port = 0;
981 }
982 state->search.in.filter = filter;
983 state->search.in.attributes = attr;
984 state->search.in.timeout = 2;
985 state->search.in.retries = 2;
986
987 subreq = cldap_search_send(state, ev, cldap, &state->search);
988 if (tevent_req_nomem(subreq, req)) {
989 goto post;
990 }
991 tevent_req_set_callback(subreq, cldap_netlogon_state_done, req);
992
993 return req;
994 post:
995 return tevent_req_post(req, ev);
996 }
997
998 static void cldap_netlogon_state_done(struct tevent_req *subreq)
999 {
1000 struct tevent_req *req = tevent_req_callback_data(subreq,
1001 struct tevent_req);
1002 struct cldap_netlogon_state *state = tevent_req_data(req,
1003 struct cldap_netlogon_state);
1004 NTSTATUS status;
1005
1006 status = cldap_search_recv(subreq, state, &state->search);
1007 talloc_free(subreq);
1008
1009 if (tevent_req_nterror(req, status)) {
1010 return;
1011 }
1012
1013 tevent_req_done(req);
1014 }
1015
1016 /*
1017 receive a cldap netlogon reply
1018 */
1019 NTSTATUS cldap_netlogon_recv(struct tevent_req *req,
1020 TALLOC_CTX *mem_ctx,
1021 struct cldap_netlogon *io)
1022 {
1023 struct cldap_netlogon_state *state = tevent_req_data(req,
1024 struct cldap_netlogon_state);
1025 NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
1026 DATA_BLOB *data;
1027
1028 if (tevent_req_is_nterror(req, &status)) {
1029 goto failed;
1030 }
1031
1032 if (state->search.out.response == NULL) {
1033 status = NT_STATUS_NOT_FOUND;
1034 goto failed;
1035 }
1036
1037 if (state->search.out.response->num_attributes != 1 ||
1038 strcasecmp(state->search.out.response->attributes[0].name, "netlogon") != 0 ||
1039 state->search.out.response->attributes[0].num_values != 1 ||
1040 state->search.out.response->attributes[0].values->length < 2) {
1041 status = NT_STATUS_UNEXPECTED_NETWORK_ERROR;
1042 goto failed;
1043 }
1044 data = state->search.out.response->attributes[0].values;
1045
1046 status = pull_netlogon_samlogon_response(data, mem_ctx,
1047 &io->out.netlogon);
1048 if (!NT_STATUS_IS_OK(status)) {
1049 goto failed;
1050 }
1051
1052 if (io->in.map_response) {
1053 map_netlogon_samlogon_response(&io->out.netlogon);
1054 }
1055
1056 status = NT_STATUS_OK;
1057 failed:
1058 tevent_req_received(req);
1059 return status;
1060 }
1061
1062 /*
1063 sync cldap netlogon search
1064 */
1065 NTSTATUS cldap_netlogon(struct cldap_socket *cldap,
1066 TALLOC_CTX *mem_ctx,
1067 struct cldap_netlogon *io)
1068 {
1069 TALLOC_CTX *frame;
1070 struct tevent_req *req;
1071 struct tevent_context *ev;
1072 NTSTATUS status;
1073
1074 if (cldap->searches.list) {
1075 return NT_STATUS_PIPE_BUSY;
1076 }
1077
1078 if (cldap->incoming.handler) {
1079 return NT_STATUS_INVALID_PIPE_STATE;
1080 }
1081
1082 frame = talloc_stackframe();
1083
1084 ev = samba_tevent_context_init(frame);
1085 if (ev == NULL) {
1086 TALLOC_FREE(frame);
1087 return NT_STATUS_NO_MEMORY;
1088 }
1089
1090 req = cldap_netlogon_send(mem_ctx, ev, cldap, io);
1091 if (req == NULL) {
1092 TALLOC_FREE(frame);
1093 return NT_STATUS_NO_MEMORY;
1094 }
1095
1096 if (!tevent_req_poll(req, ev)) {
1097 status = map_nt_error_from_unix_common(errno);
1098 TALLOC_FREE(frame);
1099 return status;
1100 }
1101
1102 status = cldap_netlogon_recv(req, mem_ctx, io);
1103 if (!NT_STATUS_IS_OK(status)) {
1104 TALLOC_FREE(frame);
1105 return status;
1106 }
1107
1108 TALLOC_FREE(frame);
1109 return NT_STATUS_OK;
1110 }
1111
1112
1113 /*
1114 send an empty reply (used on any error, so the client doesn't keep waiting
1115 or send the bad request again)
1116 */
1117 NTSTATUS cldap_empty_reply(struct cldap_socket *cldap,
1118 uint32_t message_id,
1119 struct tsocket_address *dest)
1120 {
1121 NTSTATUS status;
1122 struct cldap_reply reply;
1123 struct ldap_Result result;
1124
1125 reply.messageid = message_id;
1126 reply.dest = dest;
1127 reply.response = NULL;
1128 reply.result = &result;
1129
1130 ZERO_STRUCT(result);
1131
1132 status = cldap_reply_send(cldap, &reply);
1133
1134 return status;
1135 }
1136
1137 /*
1138 send an error reply (used on any error, so the client doesn't keep waiting
1139 or send the bad request again)
1140 */
1141 NTSTATUS cldap_error_reply(struct cldap_socket *cldap,
1142 uint32_t message_id,
1143 struct tsocket_address *dest,
1144 int resultcode,
1145 const char *errormessage)
1146 {
1147 NTSTATUS status;
1148 struct cldap_reply reply;
1149 struct ldap_Result result;
1150
1151 reply.messageid = message_id;
1152 reply.dest = dest;
1153 reply.response = NULL;
1154 reply.result = &result;
1155
1156 ZERO_STRUCT(result);
1157 result.resultcode = resultcode;
1158 result.errormessage = errormessage;
1159
1160 status = cldap_reply_send(cldap, &reply);
1161
1162 return status;
1163 }
1164
1165
1166 /*
1167 send a netlogon reply
1168 */
1169 NTSTATUS cldap_netlogon_reply(struct cldap_socket *cldap,
1170 uint32_t message_id,
1171 struct tsocket_address *dest,
1172 uint32_t version,
1173 struct netlogon_samlogon_response *netlogon)
1174 {
1175 NTSTATUS status;
1176 struct cldap_reply reply;
1177 struct ldap_SearchResEntry response;
1178 struct ldap_Result result;
1179 TALLOC_CTX *tmp_ctx = talloc_new(cldap);
1180 DATA_BLOB blob;
1181
1182 status = push_netlogon_samlogon_response(&blob, tmp_ctx,
1183 netlogon);
1184 if (!NT_STATUS_IS_OK(status)) {
1185 talloc_free(tmp_ctx);
1186 return status;
1187 }
1188 reply.messageid = message_id;
1189 reply.dest = dest;
1190 reply.response = &response;
1191 reply.result = &result;
1192
1193 ZERO_STRUCT(result);
1194
1195 response.dn = "";
1196 response.num_attributes = 1;
1197 response.attributes = talloc(tmp_ctx, struct ldb_message_element);
1198 NT_STATUS_HAVE_NO_MEMORY(response.attributes);
1199 response.attributes->name = "netlogon";
1200 response.attributes->num_values = 1;
1201 response.attributes->values = &blob;
1202
1203 status = cldap_reply_send(cldap, &reply);
1204
1205 talloc_free(tmp_ctx);
1206
1207 return status;
1208 }
1209
Samba GIT mirror