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