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