nsswitch/libwbclient/wbc_util_async.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    Winbind client API
   5
   6    Copyright (C) 2009,2010 Kai Blin  <kai@samba.org>
   7
   8    This library is free software; you can redistribute it and/or
   9    modify it under the terms of the GNU Lesser General Public
  10    License as published by the Free Software Foundation; either
  11    version 3 of the License, or (at your option) any later version.
  12
  13    This library 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 GNU
  16    Library General Public License for more details.
  17
  18    You should have received a copy of the GNU Lesser General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 /* Required Headers */
  23
  24 #include "replace.h"
  25 #include "libwbclient.h"
  26
  27 struct wbc_ping_state {
  28         struct winbindd_request req;
  29 };
  30
  31 static void wbcPing_done(struct tevent_req *subreq);
  32
  33 /** @brief Ping winbind to see if the service is up and running
  34  *
  35  * @param mem_ctx       talloc context to allocate the request from
  36  * @param ev            event context to use for async operation
  37  * @param wb_ctx        winbind context to use
  38  *
  39  * @return Async request on successful dispatch of the request, NULL on error
  40  */
  41
  42 struct tevent_req *wbcPing_send(TALLOC_CTX *mem_ctx,
  43                                 struct tevent_context *ev,
  44                                 struct wb_context *wb_ctx)
  45 {
  46         struct tevent_req *req, *subreq;
  47         struct wbc_ping_state *state;
  48
  49         req = tevent_req_create(mem_ctx, &state, struct wbc_ping_state);
  50         if (req == NULL) {
  51                 return NULL;
  52         }
  53
  54         ZERO_STRUCT(state->req);
  55
  56         state->req.cmd = WINBINDD_PING;
  57         subreq = wb_trans_send(state, ev, wb_ctx, false, &state->req);
  58         if (tevent_req_nomem(subreq, req)) {
  59                 return tevent_req_post(req, ev);
  60         }
  61
  62         tevent_req_set_callback(subreq, wbcPing_done, req);
  63         return req;
  64 }
  65
  66 static void wbcPing_done(struct tevent_req *subreq)
  67 {
  68         struct tevent_req *req = tevent_req_callback_data(
  69                         subreq, struct tevent_req);
  70         struct wbc_ping_state *state = tevent_req_data(
  71                         req, struct wbc_ping_state);
  72         struct winbindd_response *resp;
  73         wbcErr wbc_status;
  74
  75         wbc_status = wb_trans_recv(subreq, state, &resp);
  76         TALLOC_FREE(subreq);
  77         if (!WBC_ERROR_IS_OK(wbc_status)) {
  78                 tevent_req_error(req, wbc_status);
  79                 return;
  80         }
  81         TALLOC_FREE(resp);
  82
  83         tevent_req_done(req);
  84 }
  85
  86 /** @brief Receive ping response from winbind
  87  *
  88  * @param req           async request sent in #wbcPing_send
  89  *
  90  * @return NT_STATUS_OK on success, an error status on error.
  91  */
  92
  93 wbcErr wbcPing_recv(struct tevent_req *req)
  94 {
  95         wbcErr wbc_status;
  96
  97         if (tevent_req_is_wbcerr(req, &wbc_status)) {
  98                 tevent_req_received(req);
  99                 return wbc_status;
 100         }
 101
 102         tevent_req_received(req);
 103         return WBC_ERR_SUCCESS;
 104 }
 105
 106
 107 struct wbc_interface_version_state {
 108         struct winbindd_request req;
 109         uint32_t version;
 110 };
 111
 112 static void wbcInterfaceVersion_done(struct tevent_req *subreq);
 113
 114 /**
 115  * @brief Request the interface version from winbind
 116  *
 117  * @param mem_ctx       talloc context to allocate memory from
 118  * @param ev            tevent context to use for async requests
 119  * @param wb_ctx        winbind context
 120  *
 121  * @return tevevt_req on success, NULL on failure
 122  */
 123
 124 struct tevent_req *wbcInterfaceVersion_send(TALLOC_CTX *mem_ctx,
 125                                             struct tevent_context *ev,
 126                                             struct wb_context *wb_ctx)
 127 {
 128         struct tevent_req *req, *subreq;
 129         struct wbc_interface_version_state *state;
 130
 131         req = tevent_req_create(mem_ctx, &state, struct wbc_interface_version_state);
 132         if (req == NULL) {
 133                 return NULL;
 134         }
 135
 136         ZERO_STRUCT(state->req);
 137         state->req.cmd = WINBINDD_INTERFACE_VERSION;
 138
 139         subreq = wb_trans_send(state, ev, wb_ctx, false, &state->req);
 140         if (tevent_req_nomem(subreq, req)) {
 141                 return tevent_req_post(req, ev);
 142         }
 143
 144         tevent_req_set_callback(subreq, wbcInterfaceVersion_done, req);
 145
 146         return req;
 147 }
 148
 149 static void wbcInterfaceVersion_done(struct tevent_req *subreq)
 150 {
 151         struct tevent_req *req = tevent_req_callback_data(
 152                         subreq, struct tevent_req);
 153         struct wbc_interface_version_state *state = tevent_req_data(
 154                         req, struct wbc_interface_version_state);
 155         struct winbindd_response *resp;
 156         wbcErr wbc_status;
 157
 158         wbc_status = wb_trans_recv(subreq, state, &resp);
 159         TALLOC_FREE(subreq);
 160         if (!WBC_ERROR_IS_OK(wbc_status)) {
 161                 tevent_req_error(req, wbc_status);
 162                 return;
 163         }
 164         state->version = resp->data.interface_version;
 165         TALLOC_FREE(resp);
 166
 167         tevent_req_done(req);
 168 }
 169
 170 /**
 171  * @brief Receive the winbind interface version
 172  *
 173  * @param req                   tevent_req containing the request
 174  * @param interface_version     pointer to uint32_t to hold the interface
 175  *                              version
 176  *
 177  * @return #wbcErr
 178  */
 179
 180 wbcErr wbcInterfaceVersion_recv(struct tevent_req *req,
 181                                 uint32_t *interface_version)
 182 {
 183         struct wbc_interface_version_state *state = tevent_req_data(
 184                         req, struct wbc_interface_version_state);
 185         wbcErr wbc_status;
 186
 187         if (tevent_req_is_wbcerr(req, &wbc_status)) {
 188                 tevent_req_received(req);
 189                 return wbc_status;
 190         }
 191
 192         *interface_version = state->version;
 193
 194         tevent_req_received(req);
 195         return WBC_ERR_SUCCESS;
 196 }
 197
 198 struct wbc_info_state {
 199         struct winbindd_request req;
 200         char separator;
 201         char *version_string;
 202 };
 203
 204 static void wbcInfo_done(struct tevent_req *subreq);
 205
 206 /**
 207  * @brief Request information about the winbind service
 208  *
 209  * @param mem_ctx       talloc context to allocate memory from
 210  * @param ev            tevent context to use for async requests
 211  * @param wb_ctx        winbind context
 212  *
 213  * @return tevent_req on success, NULL on failure
 214  */
 215
 216 struct tevent_req *wbcInfo_send(TALLOC_CTX *mem_ctx,
 217                                 struct tevent_context *ev,
 218                                 struct wb_context *wb_ctx)
 219 {
 220         struct tevent_req *req, *subreq;
 221         struct wbc_info_state *state;
 222
 223         req = tevent_req_create(mem_ctx, &state, struct wbc_info_state);
 224         if (req == NULL) {
 225                 return NULL;
 226         }
 227
 228         ZERO_STRUCT(state->req);
 229         state->req.cmd = WINBINDD_INFO;
 230
 231         subreq = wb_trans_send(state, ev, wb_ctx, false, &state->req);
 232         if (tevent_req_nomem(subreq, req)) {
 233                 return tevent_req_post(req, ev);
 234         }
 235
 236         tevent_req_set_callback(subreq, wbcInfo_done, req);
 237         return req;
 238 }
 239
 240 static void wbcInfo_done(struct tevent_req *subreq)
 241 {
 242         struct tevent_req *req = tevent_req_callback_data(
 243                         subreq, struct tevent_req);
 244         struct wbc_info_state *state = tevent_req_data(
 245                         req, struct wbc_info_state);
 246         struct winbindd_response *resp;
 247         wbcErr wbc_status;
 248
 249         wbc_status = wb_trans_recv(subreq, state, &resp);
 250         TALLOC_FREE(subreq);
 251         if (!WBC_ERROR_IS_OK(wbc_status)) {
 252                 tevent_req_error(req, wbc_status);
 253                 return;
 254         }
 255         state->version_string = talloc_strdup(state,
 256                                         resp->data.info.samba_version);
 257         if (tevent_req_nomem(state->version_string, subreq)) {
 258                 return;
 259         }
 260         state->separator = resp->data.info.winbind_separator;
 261         TALLOC_FREE(resp);
 262
 263         tevent_req_done(req);
 264 }
 265
 266 /**
 267  * @brief Receive information about the running winbind service
 268  *
 269  * @param req                   tevent_req containing the request
 270  * @param mem_ctx               talloc context to allocate memory from
 271  * @param winbind_separator     pointer to a char to hold the separator
 272  * @param version_string        pointer to a string to hold the version string
 273  *
 274  * @return #wbcErr
 275  */
 276
 277 wbcErr wbcInfo_recv(struct tevent_req *req,
 278                     TALLOC_CTX *mem_ctx,
 279                     char *winbind_separator,
 280                     char **version_string)
 281 {
 282         struct wbc_info_state *state = tevent_req_data(
 283                         req, struct wbc_info_state);
 284         wbcErr wbc_status;
 285
 286         if (tevent_req_is_wbcerr(req, &wbc_status)) {
 287                 tevent_req_received(req);
 288                 return wbc_status;
 289         }
 290
 291         *winbind_separator = state->separator;
 292         *version_string = talloc_steal(mem_ctx, state->version_string);
 293
 294         tevent_req_received(req);
 295         return WBC_ERR_SUCCESS;
 296 }
 297
 298 struct wbc_netbios_name_state {
 299         struct winbindd_request req;
 300         char *netbios_name;
 301 };
 302
 303 static void wbcNetbiosName_done(struct tevent_req *subreq);
 304
 305 /**
 306  * @brief Request the machine's netbios name
 307  *
 308  * @param mem_ctx       talloc context to allocate memory from
 309  * @param ev            tevent context to use for async requests
 310  * @param wb_ctx        winbind context
 311  *
 312  * @return tevent_req on success, NULL on failure
 313  */
 314
 315 struct tevent_req *wbcNetbiosName_send(TALLOC_CTX *mem_ctx,
 316                                        struct tevent_context *ev,
 317                                        struct wb_context *wb_ctx)
 318 {
 319         struct tevent_req *req, *subreq;
 320         struct wbc_netbios_name_state *state;
 321
 322         req = tevent_req_create(mem_ctx, &state, struct wbc_netbios_name_state);
 323         if (req == NULL) {
 324                 return NULL;
 325         }
 326
 327         ZERO_STRUCT(state->req);
 328         state->req.cmd = WINBINDD_NETBIOS_NAME;
 329
 330         subreq = wb_trans_send(state, ev, wb_ctx, false, &state->req);
 331         if (tevent_req_nomem(subreq, req)) {
 332                 return tevent_req_post(req, ev);
 333         }
 334
 335         tevent_req_set_callback(subreq, wbcNetbiosName_done, req);
 336         return req;
 337 }
 338
 339 static void wbcNetbiosName_done(struct tevent_req *subreq)
 340 {
 341         struct tevent_req *req = tevent_req_callback_data(
 342                         subreq, struct tevent_req);
 343         struct wbc_netbios_name_state *state = tevent_req_data(
 344                         req, struct wbc_netbios_name_state);
 345         struct winbindd_response *resp;
 346         wbcErr wbc_status;
 347
 348         wbc_status = wb_trans_recv(subreq, state, &resp);
 349         TALLOC_FREE(subreq);
 350         if (!WBC_ERROR_IS_OK(wbc_status)) {
 351                 tevent_req_error(req, wbc_status);
 352                 return;
 353         }
 354         state->netbios_name = talloc_strdup(state,
 355                                         resp->data.info.samba_version);
 356         if (tevent_req_nomem(state->netbios_name, subreq)) {
 357                 return;
 358         }
 359         TALLOC_FREE(resp);
 360
 361         tevent_req_done(req);
 362 }
 363
 364 /**
 365  * @brief Receive the machine's netbios name
 366  *
 367  * @param req           tevent_req containing the request
 368  * @param mem_ctx       talloc context to allocate memory from
 369  * @param netbios_name  pointer to a string to hold the netbios name
 370  *
 371  * @return #wbcErr
 372  */
 373
 374 wbcErr wbcNetbiosName_recv(struct tevent_req *req,
 375                            TALLOC_CTX *mem_ctx,
 376                            char **netbios_name)
 377 {
 378         struct wbc_netbios_name_state *state = tevent_req_data(
 379                         req, struct wbc_netbios_name_state);
 380         wbcErr wbc_status;
 381
 382         if (tevent_req_is_wbcerr(req, &wbc_status)) {
 383                 tevent_req_received(req);
 384                 return wbc_status;
 385         }
 386
 387         *netbios_name = talloc_steal(mem_ctx, state->netbios_name);
 388
 389         tevent_req_received(req);
 390         return WBC_ERR_SUCCESS;
 391 }
 392
 393 struct wbc_domain_name_state {
 394         struct winbindd_request req;
 395         char *domain_name;
 396 };
 397
 398 static void wbcDomainName_done(struct tevent_req *subreq);
 399
 400 /**
 401  * @brief Request the machine's domain name
 402  *
 403  * @param mem_ctx       talloc context to allocate memory from
 404  * @param ev            tevent context to use for async requests
 405  * @param wb_ctx        winbind context
 406  *
 407  * @return tevent_req on success, NULL on failure
 408  */
 409
 410 struct tevent_req *wbcDomainName_send(TALLOC_CTX *mem_ctx,
 411                                       struct tevent_context *ev,
 412                                       struct wb_context *wb_ctx)
 413 {
 414         struct tevent_req *req, *subreq;
 415         struct wbc_domain_name_state *state;
 416
 417         req = tevent_req_create(mem_ctx, &state, struct wbc_domain_name_state);
 418         if (req == NULL) {
 419                 return NULL;
 420         }
 421
 422         ZERO_STRUCT(state->req);
 423         state->req.cmd = WINBINDD_DOMAIN_NAME;
 424
 425         subreq = wb_trans_send(state, ev, wb_ctx, false, &state->req);
 426         if (tevent_req_nomem(subreq, req)) {
 427                 return tevent_req_post(req, ev);
 428         }
 429
 430         tevent_req_set_callback(subreq, wbcDomainName_done, req);
 431         return req;
 432 }
 433
 434 static void wbcDomainName_done(struct tevent_req *subreq)
 435 {
 436         struct tevent_req *req = tevent_req_callback_data(
 437                         subreq, struct tevent_req);
 438         struct wbc_domain_name_state *state = tevent_req_data(
 439                         req, struct wbc_domain_name_state);
 440         struct winbindd_response *resp;
 441         wbcErr wbc_status;
 442
 443         wbc_status = wb_trans_recv(subreq, state, &resp);
 444         TALLOC_FREE(subreq);
 445         if (!WBC_ERROR_IS_OK(wbc_status)) {
 446                 tevent_req_error(req, wbc_status);
 447                 return;
 448         }
 449         state->domain_name = talloc_strdup(state, resp->data.domain_name);
 450         if (tevent_req_nomem(state->domain_name, subreq)) {
 451                 return;
 452         }
 453         TALLOC_FREE(resp);
 454
 455         tevent_req_done(req);
 456 }
 457
 458 /**
 459  * @brief Receive the machine's domain name
 460  *
 461  * @param req           tevent_req containing the request
 462  * @param mem_ctx       talloc context to allocate memory from
 463  * @param domain_name   pointer to a string to hold the domain name
 464  *
 465  * @return #wbcErr
 466  */
 467
 468 wbcErr wbcDomainName_recv(struct tevent_req *req,
 469                           TALLOC_CTX *mem_ctx,
 470                           char **domain_name)
 471 {
 472         struct wbc_domain_name_state *state = tevent_req_data(
 473                         req, struct wbc_domain_name_state);
 474         wbcErr wbc_status;
 475
 476         if (tevent_req_is_wbcerr(req, &wbc_status)) {
 477                 tevent_req_received(req);
 478                 return wbc_status;
 479         }
 480
 481         *domain_name = talloc_steal(mem_ctx, state->domain_name);
 482
 483         tevent_req_received(req);
 484         return WBC_ERR_SUCCESS;
 485 }
 486
 487 struct wbc_interface_details_state {
 488         struct tevent_context *ev;
 489         struct wb_context *wb_ctx;
 490         struct wbcDomainInfo *dinfo;
 491         struct wbcInterfaceDetails *details;
 492 };
 493
 494 static void wbcInterfaceDetails_version(struct tevent_req *subreq);
 495 static void wbcInterfaceDetails_info(struct tevent_req *subreq);
 496 static void wbcInterfaceDetails_netbios_name(struct tevent_req *subreq);
 497 static void wbcInterfaceDetails_domain_name(struct tevent_req *subreq);
 498 static void wbcInterfaceDetails_domain_info(struct tevent_req *subreq);
 499
 500 /**
 501  * @brief Request some useful details about the winbind service
 502  *
 503  * @param mem_ctx       talloc context to allocate memory from
 504  * @param ev            tevent context to use for async requests
 505  * @param wb_ctx        winbind context
 506  *
 507  * @return tevent_req on success, NULL on failure
 508  */
 509
 510 struct tevent_req *wbcInterfaceDetails_send(TALLOC_CTX *mem_ctx,
 511                                             struct tevent_context *ev,
 512                                             struct wb_context *wb_ctx)
 513 {
 514         struct tevent_req *req, *subreq;
 515         struct wbc_interface_details_state *state;
 516
 517         req = tevent_req_create(mem_ctx, &state,
 518                                 struct wbc_interface_details_state);
 519         if (req == NULL) {
 520                 return NULL;
 521         }
 522
 523         state->ev = ev;
 524         state->wb_ctx = wb_ctx;
 525         state->details = talloc(state, struct wbcInterfaceDetails);
 526         if (tevent_req_nomem(state->details, req)) {
 527                 return tevent_req_post(req, ev);
 528         }
 529
 530         subreq = wbcInterfaceVersion_send(state, ev, wb_ctx);
 531         if (tevent_req_nomem(subreq, req)) {
 532                 return tevent_req_post(req, ev);
 533         }
 534
 535         tevent_req_set_callback(subreq, wbcInterfaceDetails_version, req);
 536         return req;
 537 }
 538
 539 static void wbcInterfaceDetails_version(struct tevent_req *subreq)
 540 {
 541         struct tevent_req *req = tevent_req_callback_data(
 542                         subreq, struct tevent_req);
 543         struct wbc_interface_details_state *state = tevent_req_data(
 544                         req, struct wbc_interface_details_state);
 545         wbcErr wbc_status;
 546
 547
 548         wbc_status  = wbcInterfaceVersion_recv(subreq,
 549                                         &state->details->interface_version);
 550         TALLOC_FREE(subreq);
 551         if (!WBC_ERROR_IS_OK(wbc_status)) {
 552                 tevent_req_error(req, wbc_status);
 553                 return;
 554         }
 555
 556         subreq = wbcInfo_send(state, state->ev, state->wb_ctx);
 557         if (tevent_req_nomem(subreq, req)) {
 558                 return;
 559         }
 560
 561         tevent_req_set_callback(subreq, wbcInterfaceDetails_info, req);
 562 }
 563
 564 static void wbcInterfaceDetails_info(struct tevent_req *subreq)
 565 {
 566         struct tevent_req *req = tevent_req_callback_data(
 567                         subreq, struct tevent_req);
 568         struct wbc_interface_details_state *state = tevent_req_data(
 569                         req, struct wbc_interface_details_state);
 570         wbcErr wbc_status;
 571
 572         wbc_status  = wbcInfo_recv(subreq, state->details,
 573                                    &state->details->winbind_separator,
 574                                    &state->details->winbind_version);
 575         TALLOC_FREE(subreq);
 576         if (!WBC_ERROR_IS_OK(wbc_status)) {
 577                 tevent_req_error(req, wbc_status);
 578                 return;
 579         }
 580
 581         subreq = wbcNetbiosName_send(state, state->ev, state->wb_ctx);
 582         if (tevent_req_nomem(subreq, req)) {
 583                 return;
 584         }
 585
 586         tevent_req_set_callback(subreq, wbcInterfaceDetails_netbios_name, req);
 587 }
 588
 589 static void wbcInterfaceDetails_netbios_name(struct tevent_req *subreq)
 590 {
 591         struct tevent_req *req = tevent_req_callback_data(
 592                         subreq, struct tevent_req);
 593         struct wbc_interface_details_state *state = tevent_req_data(
 594                         req, struct wbc_interface_details_state);
 595         wbcErr wbc_status;
 596
 597         wbc_status  = wbcNetbiosName_recv(subreq, state->details,
 598                                           &state->details->netbios_name);
 599         TALLOC_FREE(subreq);
 600         if (!WBC_ERROR_IS_OK(wbc_status)) {
 601                 tevent_req_error(req, wbc_status);
 602                 return;
 603         }
 604
 605         subreq = wbcDomainName_send(state, state->ev, state->wb_ctx);
 606         if (tevent_req_nomem(subreq, req)) {
 607                 return;
 608         }
 609
 610         tevent_req_set_callback(subreq, wbcInterfaceDetails_domain_name, req);
 611 }
 612
 613 static void wbcInterfaceDetails_domain_name(struct tevent_req *subreq)
 614 {
 615         struct tevent_req *req = tevent_req_callback_data(
 616                         subreq, struct tevent_req);
 617         struct wbc_interface_details_state *state = tevent_req_data(
 618                         req, struct wbc_interface_details_state);
 619         wbcErr wbc_status;
 620
 621         wbc_status  = wbcDomainName_recv(subreq, state->details,
 622                                          &state->details->netbios_domain);
 623         TALLOC_FREE(subreq);
 624         if (!WBC_ERROR_IS_OK(wbc_status)) {
 625                 tevent_req_error(req, wbc_status);
 626                 return;
 627         }
 628
 629         subreq = wbcDomainInfo_send(state, state->ev, state->wb_ctx,
 630                                     state->details->netbios_domain);
 631         if (tevent_req_nomem(subreq, req)) {
 632                 return;
 633         }
 634
 635         tevent_req_set_callback(subreq, wbcInterfaceDetails_domain_info, req);
 636 }
 637
 638 static void wbcInterfaceDetails_domain_info(struct tevent_req *subreq)
 639 {
 640         struct tevent_req *req = tevent_req_callback_data(
 641                         subreq, struct tevent_req);
 642         struct wbc_interface_details_state *state = tevent_req_data(
 643                         req, struct wbc_interface_details_state);
 644         struct wbcDomainInfo *domain;
 645         wbcErr wbc_status;
 646
 647         wbc_status = wbcDomainInfo_recv(subreq, state, &domain);
 648         TALLOC_FREE(subreq);
 649         if (wbc_status == WBC_ERR_DOMAIN_NOT_FOUND) {
 650                 tevent_req_done(req);
 651                 return;
 652         }
 653
 654         if (!WBC_ERROR_IS_OK(wbc_status)) {
 655                 tevent_req_error(req, wbc_status);
 656                 return;
 657         }
 658         state->details->dns_domain = talloc_strdup(state->details,
 659                                                    domain->dns_name);
 660         if (tevent_req_nomem(state->details->dns_domain, req)) {
 661                 return;
 662         }
 663
 664         TALLOC_FREE(domain);
 665         tevent_req_done(req);
 666 }
 667
 668 /**
 669  * @brief Receive useful information about the winbind service
 670  *
 671  * @param req           tevent_req containing the request
 672  * @param mem_ctx       talloc context to allocate memory from
 673  * @param *details      pointer to hold the struct wbcInterfaceDetails
 674  *
 675  * @return #wbcErr
 676  */
 677
 678 wbcErr wbcInterfaceDetails_recv(struct tevent_req *req,
 679                                 TALLOC_CTX *mem_ctx,
 680                                 struct wbcInterfaceDetails **details)
 681 {
 682         struct wbc_interface_details_state *state = tevent_req_data(
 683                         req, struct wbc_interface_details_state);
 684         wbcErr wbc_status;
 685
 686         if (tevent_req_is_wbcerr(req, &wbc_status)) {
 687                 tevent_req_received(req);
 688                 return wbc_status;
 689         }
 690
 691         *details = talloc_steal(mem_ctx, state->details);
 692
 693         tevent_req_received(req);
 694         return WBC_ERR_SUCCESS;
 695 }
 696
 697 struct wbc_domain_info_state {
 698         struct winbindd_request req;
 699         struct wbcDomainInfo *info;
 700 };
 701
 702 static void wbcDomainInfo_done(struct tevent_req *subreq);
 703
 704 /**
 705  * @brief Request status of a given trusted domain
 706  *
 707  * @param mem_ctx       talloc context to allocate memory from
 708  * @param ev            tevent context to use for async requests
 709  * @param wb_ctx        winbind context
 710  * @param domain        domain to request status from
 711  *
 712  * @return tevent_req on success, NULL on failure
 713  */
 714
 715 struct tevent_req *wbcDomainInfo_send(TALLOC_CTX *mem_ctx,
 716                                       struct tevent_context *ev,
 717                                       struct wb_context *wb_ctx,
 718                                       const char *domain)
 719 {
 720         struct tevent_req *req, *subreq;
 721         struct wbc_domain_info_state *state;
 722
 723         if (!domain) {
 724                 return NULL;
 725         }
 726
 727         req = tevent_req_create(mem_ctx, &state, struct wbc_domain_info_state);
 728         if (req == NULL) {
 729                 return NULL;
 730         }
 731
 732         state->info = talloc(state, struct wbcDomainInfo);
 733         if (tevent_req_nomem(state->info, req)) {
 734                 return tevent_req_post(req, ev);
 735         }
 736
 737         ZERO_STRUCT(state->req);
 738
 739         strncpy(state->req.domain_name, domain,
 740                 sizeof(state->req.domain_name)-1);
 741
 742         state->req.cmd = WINBINDD_DOMAIN_INFO;
 743
 744         subreq = wb_trans_send(state, ev, wb_ctx, false, &state->req);
 745         if (tevent_req_nomem(subreq, req)) {
 746                 return tevent_req_post(req, ev);
 747         }
 748
 749         tevent_req_set_callback(subreq, wbcDomainInfo_done, req);
 750         return req;
 751 }
 752
 753 static void wbcDomainInfo_done(struct tevent_req *subreq)
 754 {
 755         struct tevent_req *req = tevent_req_callback_data(
 756                         subreq, struct tevent_req);
 757         struct wbc_domain_info_state *state = tevent_req_data(
 758                         req, struct wbc_domain_info_state);
 759         struct winbindd_response *resp;
 760         wbcErr wbc_status;
 761
 762         wbc_status = wb_trans_recv(subreq, state, &resp);
 763         TALLOC_FREE(subreq);
 764         if (!WBC_ERROR_IS_OK(wbc_status)) {
 765                 tevent_req_error(req, wbc_status);
 766                 return;
 767         }
 768
 769         state->info->short_name = talloc_strdup(state->info,
 770                         resp->data.domain_info.name);
 771         if (tevent_req_nomem(state->info->short_name, req)) {
 772                 return;
 773         }
 774
 775         state->info->dns_name = talloc_strdup(state->info,
 776                         resp->data.domain_info.alt_name);
 777         if (tevent_req_nomem(state->info->dns_name, req)) {
 778                 return;
 779         }
 780
 781         wbc_status = wbcStringToSid(resp->data.domain_info.sid,
 782                                     &state->info->sid);
 783         if (!WBC_ERROR_IS_OK(wbc_status)) {
 784                 tevent_req_error(req, wbc_status);
 785                 return;
 786         }
 787
 788         if (resp->data.domain_info.native_mode) {
 789                 state->info->domain_flags |= WBC_DOMINFO_DOMAIN_NATIVE;
 790         }
 791         if (resp->data.domain_info.active_directory) {
 792                 state->info->domain_flags |= WBC_DOMINFO_DOMAIN_AD;
 793         }
 794         if (resp->data.domain_info.primary) {
 795                 state->info->domain_flags |= WBC_DOMINFO_DOMAIN_PRIMARY;
 796         }
 797
 798         TALLOC_FREE(resp);
 799
 800         tevent_req_done(req);
 801 }
 802
 803 /**
 804  * @brief Receive information about a trusted domain
 805  *
 806  * @param req           tevent_req containing the request
 807  * @param mem_ctx       talloc context to allocate memory from
 808  * @param *dinfo        pointer to returned struct wbcDomainInfo
 809  *
 810  * @return #wbcErr
 811  */
 812
 813 wbcErr wbcDomainInfo_recv(struct tevent_req *req,
 814                           TALLOC_CTX *mem_ctx,
 815                           struct wbcDomainInfo **dinfo)
 816 {
 817         struct wbc_domain_info_state *state = tevent_req_data(
 818                         req, struct wbc_domain_info_state);
 819         wbcErr wbc_status;
 820
 821         if (tevent_req_is_wbcerr(req, &wbc_status)) {
 822                 tevent_req_received(req);
 823                 return wbc_status;
 824         }
 825
 826         if (dinfo == NULL) {
 827                 tevent_req_received(req);
 828                 return WBC_ERR_INVALID_PARAM;
 829         }
 830
 831         *dinfo = talloc_steal(mem_ctx, state->info);
 832
 833         tevent_req_received(req);
 834         return WBC_ERR_SUCCESS;
 835 }