source/nsswitch/winbindd_cm.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 3.0
   4
   5    Winbind daemon connection manager
   6
   7    Copyright (C) Tim Potter 2001
   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 2 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, write to the Free Software
  21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22 */
  23
  24 /*
  25    We need to manage connections to domain controllers without having to
  26    mess up the main winbindd code with other issues.  The aim of the
  27    connection manager is to:
  28
  29        - make connections to domain controllers and cache them
  30        - re-establish connections when networks or servers go down
  31        - centralise the policy on connection timeouts, domain controller
  32          selection etc
  33        - manage re-entrancy for when winbindd becomes able to handle
  34          multiple outstanding rpc requests
  35
  36    Why not have connection management as part of the rpc layer like tng?
  37    Good question.  This code may morph into libsmb/rpc_cache.c or something
  38    like that but at the moment it's simply staying as part of winbind.  I
  39    think the TNG architecture of forcing every user of the rpc layer to use
  40    the connection caching system is a bad idea.  It should be an optional
  41    method of using the routines.
  42
  43    The TNG design is quite good but I disagree with some aspects of the
  44    implementation. -tpot
  45
  46  */
  47
  48 /*
  49    TODO:
  50
  51      - I'm pretty annoyed by all the make_nmb_name() stuff.  It should be
  52        moved down into another function.
  53
  54      - There needs to be a utility function in libsmb/namequery.c that does
  55        cm_get_dc_name()
  56
  57      - Take care when destroying cli_structs as they can be shared between
  58        various sam handles.
  59
  60  */
  61
  62 #include "winbindd.h"
  63
  64 /* Global list of connections.  Initially a DLIST but can become a hash
  65    table or whatever later. */
  66
  67 struct winbindd_cm_conn {
  68         struct winbindd_cm_conn *prev, *next;
  69         fstring domain;
  70         fstring controller;
  71         fstring pipe_name;
  72         struct cli_state *cli;
  73         POLICY_HND pol;
  74 };
  75
  76 struct winbindd_cm_conn *cm_conns = NULL;
  77
  78 /* Get a domain controller name.  Cache positive and negative lookups so we
  79    don't go to the network too often when something is badly broken. */
  80
  81 #define GET_DC_NAME_CACHE_TIMEOUT 30 /* Seconds between dc lookups */
  82
  83 struct get_dc_name_cache {
  84         fstring domain_name;
  85         fstring srv_name;
  86         time_t lookup_time;
  87         struct get_dc_name_cache *prev, *next;
  88 };
  89
  90 static BOOL cm_get_dc_name(char *domain, fstring srv_name)
  91 {
  92         static struct get_dc_name_cache *get_dc_name_cache;
  93         struct get_dc_name_cache *dcc;
  94         struct in_addr *ip_list, dc_ip;
  95         int count, i;
  96
  97         /* Check the cache for previous lookups */
  98
  99         for (dcc = get_dc_name_cache; dcc; dcc = dcc->next) {
 100
 101                 if (!strequal(domain, dcc->domain_name))
 102                         continue; /* Not our domain */
 103
 104                 if ((time(NULL) - dcc->lookup_time) >
 105                     GET_DC_NAME_CACHE_TIMEOUT) {
 106
 107                         /* Cache entry has expired, delete it */
 108
 109                         DEBUG(10, ("get_dc_name_cache entry expired for %s\n", domain));
 110
 111                         DLIST_REMOVE(get_dc_name_cache, dcc);
 112                         SAFE_FREE(dcc);
 113
 114                         break;
 115                 }
 116
 117                 /* Return a positive or negative lookup for this domain */
 118
 119                 if (dcc->srv_name[0]) {
 120                         DEBUG(10, ("returning positive get_dc_name_cache entry for %s\n", domain));
 121                         fstrcpy(srv_name, dcc->srv_name);
 122                         return True;
 123                 } else {
 124                         DEBUG(10, ("returning negative get_dc_name_cache entry for %s\n", domain));
 125                         return False;
 126                 }
 127         }
 128
 129         /* Add cache entry for this lookup. */
 130
 131         DEBUG(10, ("Creating get_dc_name_cache entry for %s\n", domain));
 132
 133         if (!(dcc = (struct get_dc_name_cache *)
 134               malloc(sizeof(struct get_dc_name_cache))))
 135                 return False;
 136
 137         ZERO_STRUCTP(dcc);
 138
 139         fstrcpy(dcc->domain_name, domain);
 140         dcc->lookup_time = time(NULL);
 141
 142         DLIST_ADD(get_dc_name_cache, dcc);
 143
 144         /* Lookup domain controller name */
 145
 146         if (!get_dc_list(False, domain, &ip_list, &count)) {
 147                 DEBUG(3, ("Could not look up dc's for domain %s\n", domain));
 148                 return False;
 149         }
 150
 151         /* Firstly choose a PDC/BDC who has the same network address as any
 152            of our interfaces. */
 153
 154         for (i = 0; i < count; i++) {
 155                 if(is_local_net(ip_list[i]))
 156                         goto got_ip;
 157         }
 158
 159         if (count == 0) {
 160                 DEBUG(3, ("No domain controllers for domain %s\n", domain));
 161                 return False;
 162         }
 163
 164         i = (sys_random() % count);
 165
 166  got_ip:
 167         dc_ip = ip_list[i];
 168         SAFE_FREE(ip_list);
 169
 170         /* We really should be doing a GETDC call here rather than a node
 171            status lookup. */
 172
 173         if (!name_status_find(domain, 0x1c, 0x20, dc_ip, srv_name)) {
 174                 DEBUG(3, ("Error looking up DC name for %s in domain %s\n", inet_ntoa(dc_ip), domain));
 175                 return False;
 176         }
 177
 178         /* We have a name so make the cache entry positive now */
 179
 180         fstrcpy(dcc->srv_name, srv_name);
 181
 182         return True;
 183 }
 184
 185 /* Choose between anonymous or authenticated connections.  We need to use
 186    an authenticated connection if DCs have the RestrictAnonymous registry
 187    entry set > 0, or the "Additional restrictions for anonymous
 188    connections" set in the win2k Local Security Policy. */
 189
 190 void cm_init_creds(struct ntuser_creds *creds)
 191 {
 192         char *username, *password;
 193
 194         ZERO_STRUCTP(creds);
 195
 196         creds->pwd.null_pwd = True; /* anonymoose */
 197
 198         username = secrets_fetch(SECRETS_AUTH_USER, NULL);
 199         password = secrets_fetch(SECRETS_AUTH_PASSWORD, NULL);
 200
 201         if (username && *username) {
 202                 pwd_set_cleartext(&creds->pwd, password);
 203                 pwd_make_lm_nt_16(&creds->pwd, password);
 204
 205                 fstrcpy(creds->user_name, username);
 206                 fstrcpy(creds->domain, lp_workgroup());
 207
 208                 DEBUG(3, ("IPC$ connections done %s\\%s\n", creds->domain,
 209                           creds->user_name));
 210         } else
 211                 DEBUG(3, ("IPC$ connections done anonymously\n"));
 212 }
 213
 214 /* Open a new smb pipe connection to a DC on a given domain.  Cache
 215    negative creation attempts so we don't try and connect to broken
 216    machines too often. */
 217
 218 #define OPEN_CONNECTION_CACHE_TIMEOUT 30 /* Seconds between attempts */
 219
 220 struct open_connection_cache {
 221         fstring domain_name;
 222         fstring controller;
 223         time_t lookup_time;
 224         struct open_connection_cache *prev, *next;
 225 };
 226
 227 static BOOL cm_open_connection(char *domain, char *pipe_name,
 228                                struct winbindd_cm_conn *new_conn)
 229 {
 230         static struct open_connection_cache *open_connection_cache;
 231         struct open_connection_cache *occ;
 232         struct nmb_name calling, called;
 233         extern pstring global_myname;
 234         fstring dest_host;
 235         struct in_addr dest_ip;
 236         BOOL result = False;
 237         struct ntuser_creds creds;
 238
 239         fstrcpy(new_conn->domain, domain);
 240         fstrcpy(new_conn->pipe_name, pipe_name);
 241
 242         /* Look for a domain controller for this domain.  Negative results
 243                 are cached so don't bother applying the caching for this
 244                 function just yet.  */
 245
 246         if (!cm_get_dc_name(domain, new_conn->controller))
 247                 goto done;
 248
 249         /* Return false if we have tried to look up this domain and netbios
 250                 name before and failed. */
 251
 252         for (occ = open_connection_cache; occ; occ = occ->next) {
 253
 254                 if (!(strequal(domain, occ->domain_name) &&
 255                       strequal(new_conn->controller, occ->controller)))
 256                         continue; /* Not our domain */
 257
 258                 if ((time(NULL) - occ->lookup_time) >
 259                     OPEN_CONNECTION_CACHE_TIMEOUT) {
 260
 261                         /* Cache entry has expired, delete it */
 262
 263                         DEBUG(10, ("cm_open_connection cache entry expired for %s, %s\n", domain, new_conn->controller));
 264
 265                         DLIST_REMOVE(open_connection_cache, occ);
 266                         SAFE_FREE(occ);
 267
 268                         break;
 269                 }
 270
 271                 /* The timeout hasn't expired yet so return false */
 272
 273                 DEBUG(10, ("returning negative open_connection_cache entry for %s, %s\n", domain, new_conn->controller));
 274
 275                 goto done;
 276         }
 277
 278         /* Initialise SMB connection */
 279
 280         if (!(new_conn->cli = cli_initialise(NULL)))
 281                 goto done;
 282
 283         if (!resolve_srv_name(new_conn->controller, dest_host, &dest_ip))
 284                 goto done;
 285
 286         make_nmb_name(&called, dns_to_netbios_name(new_conn->controller), 0x20);
 287         make_nmb_name(&calling, dns_to_netbios_name(global_myname), 0);
 288
 289         cm_init_creds(&creds);
 290
 291         cli_init_creds(new_conn->cli, &creds);
 292
 293         if (!cli_establish_connection(new_conn->cli, new_conn->controller,
 294                                       &dest_ip, &calling, &called, "IPC$",
 295                                       "IPC", False, True))
 296                 goto done;
 297
 298         if (!cli_nt_session_open (new_conn->cli, pipe_name))
 299                 goto done;
 300
 301         result = True;
 302
 303  done:
 304
 305         /* Create negative lookup cache entry for this domain and controller */
 306
 307         if (!result) {
 308                 if (!(occ = (struct open_connection_cache *)
 309                       malloc(sizeof(struct open_connection_cache))))
 310                         return False;
 311
 312                 ZERO_STRUCTP(occ);
 313
 314                 fstrcpy(occ->domain_name, domain);
 315                 fstrcpy(occ->controller, new_conn->controller);
 316                 occ->lookup_time = time(NULL);
 317
 318                 DLIST_ADD(open_connection_cache, occ);
 319         }
 320
 321         if (!result && new_conn->cli)
 322                 cli_shutdown(new_conn->cli);
 323
 324         return result;
 325 }
 326
 327 /* Return true if a connection is still alive */
 328
 329 static BOOL connection_ok(struct winbindd_cm_conn *conn)
 330 {
 331         if (!conn->cli->initialised)
 332                 return False;
 333
 334         if (conn->cli->fd == -1)
 335                 return False;
 336
 337         return True;
 338 }
 339
 340 /* Return a LSA policy handle on a domain */
 341
 342 CLI_POLICY_HND *cm_get_lsa_handle(char *domain)
 343 {
 344         struct winbindd_cm_conn *conn;
 345         uint32 des_access = SEC_RIGHTS_MAXIMUM_ALLOWED;
 346         NTSTATUS result;
 347         static CLI_POLICY_HND hnd;
 348
 349         /* Look for existing connections */
 350
 351         for (conn = cm_conns; conn; conn = conn->next) {
 352                 if (strequal(conn->domain, domain) &&
 353                     strequal(conn->pipe_name, PIPE_LSARPC)) {
 354
 355                         if (!connection_ok(conn)) {
 356                                 DLIST_REMOVE(cm_conns, conn);
 357                                 return NULL;
 358                         }
 359
 360                         goto ok;
 361                 }
 362         }
 363
 364         /* Create a new one */
 365
 366         if (!(conn = (struct winbindd_cm_conn *) malloc(sizeof(struct winbindd_cm_conn))))
 367                 return NULL;
 368
 369         ZERO_STRUCTP(conn);
 370
 371         if (!cm_open_connection(domain, PIPE_LSARPC, conn)) {
 372                 DEBUG(3, ("Could not connect to a dc for domain %s\n", domain));
 373                 return NULL;
 374         }
 375
 376         result = cli_lsa_open_policy(conn->cli, conn->cli->mem_ctx, False,
 377                                      des_access, &conn->pol);
 378
 379         if (!NT_STATUS_IS_OK(result))
 380                 return NULL;
 381
 382         /* Add to list */
 383
 384         DLIST_ADD(cm_conns, conn);
 385
 386  ok:
 387         hnd.pol = conn->pol;
 388         hnd.cli = conn->cli;
 389
 390         return &hnd;
 391 }
 392
 393 /* Return a SAM policy handle on a domain */
 394
 395 CLI_POLICY_HND *cm_get_sam_handle(char *domain)
 396 {
 397         struct winbindd_cm_conn *conn;
 398         uint32 des_access = SEC_RIGHTS_MAXIMUM_ALLOWED;
 399         NTSTATUS result;
 400         static CLI_POLICY_HND hnd;
 401
 402         /* Look for existing connections */
 403
 404         for (conn = cm_conns; conn; conn = conn->next) {
 405                 if (strequal(conn->domain, domain) && strequal(conn->pipe_name, PIPE_SAMR)) {
 406
 407                         if (!connection_ok(conn)) {
 408                                 DLIST_REMOVE(cm_conns, conn);
 409                                 return NULL;
 410                         }
 411
 412                         goto ok;
 413                 }
 414         }
 415
 416         /* Create a new one */
 417
 418         if (!(conn = (struct winbindd_cm_conn *)
 419               malloc(sizeof(struct winbindd_cm_conn))))
 420                 return NULL;
 421
 422         ZERO_STRUCTP(conn);
 423
 424         if (!cm_open_connection(domain, PIPE_SAMR, conn)) {
 425                 DEBUG(3, ("Could not connect to a dc for domain %s\n", domain));
 426                 return NULL;
 427         }
 428
 429         result = cli_samr_connect(conn->cli, conn->cli->mem_ctx,
 430                                   des_access, &conn->pol);
 431
 432         if (!NT_STATUS_IS_OK(result))
 433                 return NULL;
 434
 435         /* Add to list */
 436
 437         DLIST_ADD(cm_conns, conn);
 438
 439  ok:
 440         hnd.pol = conn->pol;
 441         hnd.cli = conn->cli;
 442
 443         return &hnd;
 444 }
 445
 446 #if 0
 447
 448 /* Return a SAM domain policy handle on a domain */
 449
 450 CLI_POLICY_HND *cm_get_sam_dom_handle(char *domain, DOM_SID *domain_sid)
 451 {
 452         struct winbindd_cm_conn *conn, *basic_conn = NULL;
 453         static CLI_POLICY_HND hnd;
 454         NTSTATUS result;
 455         uint32 des_access = SEC_RIGHTS_MAXIMUM_ALLOWED;
 456
 457         /* Look for existing connections */
 458
 459         for (conn = cm_conns; conn; conn = conn->next) {
 460                 if (strequal(conn->domain, domain) &&
 461                     strequal(conn->pipe_name, PIPE_SAMR) &&
 462                     conn->pipe_data.samr.pipe_type == SAM_PIPE_DOM) {
 463
 464                         if (!connection_ok(conn)) {
 465                                 DLIST_REMOVE(cm_conns, conn);
 466                                 return NULL;
 467                         }
 468
 469                         goto ok;
 470                 }
 471         }
 472
 473         /* Create a basic handle to open a domain handle from */
 474
 475         if (!cm_get_sam_handle(domain))
 476                 return False;
 477
 478         for (conn = cm_conns; conn; conn = conn->next) {
 479                 if (strequal(conn->domain, domain) &&
 480                     strequal(conn->pipe_name, PIPE_SAMR) &&
 481                     conn->pipe_data.samr.pipe_type == SAM_PIPE_BASIC)
 482                         basic_conn = conn;
 483         }
 484
 485         if (!(conn = (struct winbindd_cm_conn *)
 486               malloc(sizeof(struct winbindd_cm_conn))))
 487                 return NULL;
 488
 489         ZERO_STRUCTP(conn);
 490
 491         fstrcpy(conn->domain, basic_conn->domain);
 492         fstrcpy(conn->controller, basic_conn->controller);
 493         fstrcpy(conn->pipe_name, basic_conn->pipe_name);
 494
 495         conn->pipe_data.samr.pipe_type = SAM_PIPE_DOM;
 496         conn->cli = basic_conn->cli;
 497
 498         result = cli_samr_open_domain(conn->cli, conn->cli->mem_ctx,
 499                                       &basic_conn->pol, des_access,
 500                                       domain_sid, &conn->pol);
 501
 502         if (!NT_STATUS_IS_OK(result))
 503                 return NULL;
 504
 505         /* Add to list */
 506
 507         DLIST_ADD(cm_conns, conn);
 508
 509  ok:
 510         hnd.pol = conn->pol;
 511         hnd.cli = conn->cli;
 512
 513         return &hnd;
 514 }
 515
 516 /* Return a SAM policy handle on a domain user */
 517
 518 CLI_POLICY_HND *cm_get_sam_user_handle(char *domain, DOM_SID *domain_sid,
 519                                        uint32 user_rid)
 520 {
 521         struct winbindd_cm_conn *conn, *basic_conn = NULL;
 522         static CLI_POLICY_HND hnd;
 523         NTSTATUS result;
 524         uint32 des_access = SEC_RIGHTS_MAXIMUM_ALLOWED;
 525
 526         /* Look for existing connections */
 527
 528         for (conn = cm_conns; conn; conn = conn->next) {
 529                 if (strequal(conn->domain, domain) &&
 530                     strequal(conn->pipe_name, PIPE_SAMR) &&
 531                     conn->pipe_data.samr.pipe_type == SAM_PIPE_USER &&
 532                     conn->pipe_data.samr.rid == user_rid) {
 533
 534                         if (!connection_ok(conn)) {
 535                                 DLIST_REMOVE(cm_conns, conn);
 536                                 return NULL;
 537                         }
 538
 539                         goto ok;
 540                 }
 541         }
 542
 543         /* Create a domain handle to open a user handle from */
 544
 545         if (!cm_get_sam_dom_handle(domain, domain_sid))
 546                 return NULL;
 547
 548         for (conn = cm_conns; conn; conn = conn->next) {
 549                 if (strequal(conn->domain, domain) &&
 550                     strequal(conn->pipe_name, PIPE_SAMR) &&
 551                     conn->pipe_data.samr.pipe_type == SAM_PIPE_DOM)
 552                         basic_conn = conn;
 553         }
 554
 555         if (!basic_conn) {
 556                 DEBUG(0, ("No domain sam handle was created!\n"));
 557                 return NULL;
 558         }
 559
 560         if (!(conn = (struct winbindd_cm_conn *)
 561               malloc(sizeof(struct winbindd_cm_conn))))
 562                 return NULL;
 563
 564         ZERO_STRUCTP(conn);
 565
 566         fstrcpy(conn->domain, basic_conn->domain);
 567         fstrcpy(conn->controller, basic_conn->controller);
 568         fstrcpy(conn->pipe_name, basic_conn->pipe_name);
 569
 570         conn->pipe_data.samr.pipe_type = SAM_PIPE_USER;
 571         conn->cli = basic_conn->cli;
 572         conn->pipe_data.samr.rid = user_rid;
 573
 574         result = cli_samr_open_user(conn->cli, conn->cli->mem_ctx,
 575                                     &basic_conn->pol, des_access, user_rid,
 576                                     &conn->pol);
 577
 578         if (!NT_STATUS_IS_OK(result))
 579                 return NULL;
 580
 581         /* Add to list */
 582
 583         DLIST_ADD(cm_conns, conn);
 584
 585  ok:
 586         hnd.pol = conn->pol;
 587         hnd.cli = conn->cli;
 588
 589         return &hnd;
 590 }
 591
 592 /* Return a SAM policy handle on a domain group */
 593
 594 CLI_POLICY_HND *cm_get_sam_group_handle(char *domain, DOM_SID *domain_sid,
 595                                         uint32 group_rid)
 596 {
 597         struct winbindd_cm_conn *conn, *basic_conn = NULL;
 598         static CLI_POLICY_HND hnd;
 599         NTSTATUS result;
 600         uint32 des_access = SEC_RIGHTS_MAXIMUM_ALLOWED;
 601
 602         /* Look for existing connections */
 603
 604         for (conn = cm_conns; conn; conn = conn->next) {
 605                 if (strequal(conn->domain, domain) &&
 606                     strequal(conn->pipe_name, PIPE_SAMR) &&
 607                     conn->pipe_data.samr.pipe_type == SAM_PIPE_GROUP &&
 608                     conn->pipe_data.samr.rid == group_rid) {
 609
 610                         if (!connection_ok(conn)) {
 611                                 DLIST_REMOVE(cm_conns, conn);
 612                                 return NULL;
 613                         }
 614
 615                         goto ok;
 616                 }
 617         }
 618
 619         /* Create a domain handle to open a user handle from */
 620
 621         if (!cm_get_sam_dom_handle(domain, domain_sid))
 622                 return NULL;
 623
 624         for (conn = cm_conns; conn; conn = conn->next) {
 625                 if (strequal(conn->domain, domain) &&
 626                     strequal(conn->pipe_name, PIPE_SAMR) &&
 627                     conn->pipe_data.samr.pipe_type == SAM_PIPE_DOM)
 628                         basic_conn = conn;
 629         }
 630
 631         if (!basic_conn) {
 632                 DEBUG(0, ("No domain sam handle was created!\n"));
 633                 return NULL;
 634         }
 635
 636         if (!(conn = (struct winbindd_cm_conn *)
 637               malloc(sizeof(struct winbindd_cm_conn))))
 638                 return NULL;
 639
 640         ZERO_STRUCTP(conn);
 641
 642         fstrcpy(conn->domain, basic_conn->domain);
 643         fstrcpy(conn->controller, basic_conn->controller);
 644         fstrcpy(conn->pipe_name, basic_conn->pipe_name);
 645
 646         conn->pipe_data.samr.pipe_type = SAM_PIPE_GROUP;
 647         conn->cli = basic_conn->cli;
 648         conn->pipe_data.samr.rid = group_rid;
 649
 650         result = cli_samr_open_group(conn->cli, conn->cli->mem_ctx,
 651                                     &basic_conn->pol, des_access, group_rid,
 652                                     &conn->pol);
 653
 654         if (!NT_STATUS_IS_OK(result))
 655                 return NULL;
 656
 657         /* Add to list */
 658
 659         DLIST_ADD(cm_conns, conn);
 660
 661  ok:
 662         hnd.pol = conn->pol;
 663         hnd.cli = conn->cli;
 664
 665         return &hnd;
 666 }
 667
 668 #endif
 669
 670 /* Get a handle on a netlogon pipe.  This is a bit of a hack to re-use the
 671    netlogon pipe as no handle is returned. */
 672
 673 NTSTATUS cm_get_netlogon_cli(char *domain, unsigned char *trust_passwd,
 674                              struct cli_state **cli)
 675 {
 676         struct winbindd_cm_conn conn;
 677         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 678
 679         /* Open an initial conection */
 680
 681         ZERO_STRUCT(conn);
 682
 683         if (!cm_open_connection(domain, PIPE_NETLOGON, &conn)) {
 684                 DEBUG(3, ("Could not open a connection to %s\n", domain));
 685                 return result;
 686         }
 687
 688         result = cli_nt_setup_creds(conn.cli, trust_passwd);
 689
 690         if (!NT_STATUS_IS_OK(result)) {
 691                 DEBUG(0, ("error connecting to domain password server: %s\n",
 692                         get_nt_error_msg(result)));
 693                         cli_shutdown(conn.cli);
 694                         return result;
 695         }
 696
 697         if (cli)
 698                 *cli = conn.cli;
 699
 700         return result;
 701 }
 702
 703 /* Dump the current connection status */
 704
 705 static void dump_conn_list(void)
 706 {
 707         struct winbindd_cm_conn *con;
 708
 709         DEBUG(0, ("\tDomain          Controller      Pipe\n"));
 710
 711         for(con = cm_conns; con; con = con->next) {
 712                 char *msg;
 713
 714                 /* Display pipe info */
 715
 716                 if (asprintf(&msg, "\t%-15s %-15s %-16s", con->domain, con->controller, con->pipe_name) < 0) {
 717                         DEBUG(0, ("Error: not enough memory!\n"));
 718                 } else {
 719                         DEBUG(0, ("%s\n", msg));
 720                         SAFE_FREE(msg);
 721                 }
 722         }
 723 }
 724
 725 void winbindd_cm_status(void)
 726 {
 727         /* List open connections */
 728
 729         DEBUG(0, ("winbindd connection manager status:\n"));
 730
 731         if (cm_conns)
 732                 dump_conn_list();
 733         else
 734                 DEBUG(0, ("\tNo active connections\n"));
 735 }