Add in rety loop for query_user_list (from APP_HEAD). Deals with a bug
[nivanova/samba-autobuild/.git] / source3 / nsswitch / winbindd_cm.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    Winbind daemon connection manager
5
6    Copyright (C) Tim Potter 2001
7    Copyright (C) Andrew Bartlett 2002
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 #undef DBGC_CLASS
65 #define DBGC_CLASS DBGC_WINBIND
66
67 /* Global list of connections.  Initially a DLIST but can become a hash
68    table or whatever later. */
69
70 struct winbindd_cm_conn {
71         struct winbindd_cm_conn *prev, *next;
72         fstring domain;
73         fstring controller;
74         fstring pipe_name;
75         size_t mutex_ref_count;
76         struct cli_state *cli;
77         POLICY_HND pol;
78 };
79
80 static struct winbindd_cm_conn *cm_conns = NULL;
81
82 /* Get a domain controller name.  Cache positive and negative lookups so we
83    don't go to the network too often when something is badly broken. */
84
85 #define GET_DC_NAME_CACHE_TIMEOUT 30 /* Seconds between dc lookups */
86
87 struct get_dc_name_cache {
88         fstring domain_name;
89         fstring srv_name;
90         time_t lookup_time;
91         struct get_dc_name_cache *prev, *next;
92 };
93
94 /*
95   find the DC for a domain using methods appropriate for a ADS domain
96 */
97 static BOOL cm_ads_find_dc(const char *domain, struct in_addr *dc_ip, fstring srv_name)
98 {
99         ADS_STRUCT *ads;
100         const char *realm = domain;
101
102         if (strcasecmp(realm, lp_workgroup()) == 0)
103                 realm = lp_realm();
104
105         ads = ads_init(realm, domain, NULL);
106         if (!ads)
107                 return False;
108
109         /* we don't need to bind, just connect */
110         ads->auth.flags |= ADS_AUTH_NO_BIND;
111
112         DEBUG(4,("cm_ads_find_dc: domain=%s\n", domain));
113
114 #ifdef HAVE_ADS
115         /* a full ads_connect() is actually overkill, as we don't srictly need
116            to do the SASL auth in order to get the info we need, but libads
117            doesn't offer a better way right now */
118         ads_connect(ads);
119 #endif
120
121         if (!ads->config.realm)
122                 return False;
123
124         fstrcpy(srv_name, ads->config.ldap_server_name);
125         strupper(srv_name);
126         *dc_ip = ads->ldap_ip;
127         ads_destroy(&ads);
128         
129         DEBUG(4,("cm_ads_find_dc: using server='%s' IP=%s\n",
130                  srv_name, inet_ntoa(*dc_ip)));
131         
132         return True;
133 }
134
135
136
137 static BOOL cm_get_dc_name(const char *domain, fstring srv_name, struct in_addr *ip_out)
138 {
139         static struct get_dc_name_cache *get_dc_name_cache;
140         struct get_dc_name_cache *dcc;
141         struct in_addr dc_ip;
142         BOOL ret;
143
144         /* Check the cache for previous lookups */
145
146         for (dcc = get_dc_name_cache; dcc; dcc = dcc->next) {
147
148                 if (!strequal(domain, dcc->domain_name))
149                         continue; /* Not our domain */
150
151                 if ((time(NULL) - dcc->lookup_time) > 
152                     GET_DC_NAME_CACHE_TIMEOUT) {
153
154                         /* Cache entry has expired, delete it */
155
156                         DEBUG(10, ("get_dc_name_cache entry expired for %s\n", domain));
157
158                         DLIST_REMOVE(get_dc_name_cache, dcc);
159                         SAFE_FREE(dcc);
160
161                         break;
162                 }
163
164                 /* Return a positive or negative lookup for this domain */
165
166                 if (dcc->srv_name[0]) {
167                         DEBUG(10, ("returning positive get_dc_name_cache entry for %s\n", domain));
168                         fstrcpy(srv_name, dcc->srv_name);
169                         return True;
170                 } else {
171                         DEBUG(10, ("returning negative get_dc_name_cache entry for %s\n", domain));
172                         return False;
173                 }
174         }
175
176         /* Add cache entry for this lookup. */
177
178         DEBUG(10, ("Creating get_dc_name_cache entry for %s\n", domain));
179
180         if (!(dcc = (struct get_dc_name_cache *) 
181               malloc(sizeof(struct get_dc_name_cache))))
182                 return False;
183
184         ZERO_STRUCTP(dcc);
185
186         fstrcpy(dcc->domain_name, domain);
187         dcc->lookup_time = time(NULL);
188
189         DLIST_ADD(get_dc_name_cache, dcc);
190
191         zero_ip(&dc_ip);
192
193         ret = False;
194         if (lp_security() == SEC_ADS)
195                 ret = cm_ads_find_dc(domain, &dc_ip, srv_name);
196
197         if (!ret) {
198                 /* fall back on rpc methods if the ADS methods fail */
199                 ret = rpc_find_dc(domain, srv_name, &dc_ip);
200         }
201
202         if (!ret)
203                 return False;
204
205         /* We have a name so make the cache entry positive now */
206         fstrcpy(dcc->srv_name, srv_name);
207
208         DEBUG(3, ("cm_get_dc_name: Returning DC %s (%s) for domain %s\n", srv_name,
209                   inet_ntoa(dc_ip), domain));
210
211         *ip_out = dc_ip;
212
213         return True;
214 }
215
216 /* Choose between anonymous or authenticated connections.  We need to use
217    an authenticated connection if DCs have the RestrictAnonymous registry
218    entry set > 0, or the "Additional restrictions for anonymous
219    connections" set in the win2k Local Security Policy. 
220    
221    Caller to free() result in domain, username, password
222 */
223
224 static void cm_get_ipc_userpass(char **username, char **domain, char **password)
225 {
226         *username = secrets_fetch(SECRETS_AUTH_USER, NULL);
227         *domain = secrets_fetch(SECRETS_AUTH_DOMAIN, NULL);
228         *password = secrets_fetch(SECRETS_AUTH_PASSWORD, NULL);
229         
230         if (*username && **username) {
231
232                 if (!*domain || !**domain)
233                         *domain = smb_xstrdup(lp_workgroup());
234                 
235                 if (!*password || !**password)
236                         *password = smb_xstrdup("");
237
238                 DEBUG(3, ("IPC$ connections done by user %s\\%s\n", 
239                           *domain, *username));
240
241         } else {
242                 DEBUG(3, ("IPC$ connections done anonymously\n"));
243                 *username = smb_xstrdup("");
244                 *domain = smb_xstrdup("");
245                 *password = smb_xstrdup("");
246         }
247 }
248
249 /* Open a connction to the remote server, cache failures for 30 seconds */
250
251 static NTSTATUS cm_open_connection(const char *domain, const int pipe_index,
252                                struct winbindd_cm_conn *new_conn)
253 {
254         NTSTATUS result;
255         char *ipc_username, *ipc_domain, *ipc_password;
256         struct in_addr dc_ip;
257         int i;
258         BOOL retry = True;
259
260         ZERO_STRUCT(dc_ip);
261
262         fstrcpy(new_conn->domain, domain);
263         fstrcpy(new_conn->pipe_name, get_pipe_name_from_index(pipe_index));
264         
265         /* connection failure cache has been moved inside of get_dc_name
266            so we can deal with half dead DC's   --jerry */
267
268         if (!cm_get_dc_name(domain, new_conn->controller, &dc_ip)) {
269                 result = NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
270                 add_failed_connection_entry(domain, "", result);
271                 return result;
272         }
273                 
274         /* Initialise SMB connection */
275
276         cm_get_ipc_userpass(&ipc_username, &ipc_domain, &ipc_password);
277
278         DEBUG(5, ("connecting to %s from %s with username [%s]\\[%s]\n", 
279               new_conn->controller, global_myname(), ipc_domain, ipc_username));
280
281         for (i = 0; retry && (i < 3); i++) {
282                 BOOL got_mutex;
283                 if (!(got_mutex = secrets_named_mutex(new_conn->controller, WINBIND_SERVER_MUTEX_WAIT_TIME))) {
284                         DEBUG(0,("cm_open_connection: mutex grab failed for %s\n", new_conn->controller));
285                         result = NT_STATUS_POSSIBLE_DEADLOCK;
286                         continue;
287                 }
288                 
289                 result = cli_full_connection(&new_conn->cli, global_myname(), new_conn->controller, 
290                                              &dc_ip, 0, "IPC$", "IPC", ipc_username, ipc_domain, 
291                                              ipc_password, CLI_FULL_CONNECTION_ANNONYMOUS_FALLBACK, &retry);
292                 
293                 secrets_named_mutex_release(new_conn->controller);
294
295                 if (NT_STATUS_IS_OK(result))
296                         break;
297         }
298
299         SAFE_FREE(ipc_username);
300         SAFE_FREE(ipc_domain);
301         SAFE_FREE(ipc_password);
302
303         if (!NT_STATUS_IS_OK(result)) {
304                 add_failed_connection_entry(domain, new_conn->controller, result);
305                 return result;
306         }
307         
308         if ( !cli_nt_session_open (new_conn->cli, pipe_index) ) {
309                 result = NT_STATUS_PIPE_NOT_AVAILABLE;
310                 /* 
311                  * only cache a failure if we are not trying to open the 
312                  * **win2k** specific lsarpc UUID.  This could be an NT PDC 
313                  * and therefore a failure is normal.  This should probably
314                  * be abstracted to a check for 2k specific pipes and wondering
315                  * if the PDC is an NT4 box.   but since there is only one 2k 
316                  * specific UUID right now, i'm not going to bother.  --jerry
317                  */
318                 if ( !is_win2k_pipe(pipe_index) )
319                         add_failed_connection_entry(domain, new_conn->controller, result);
320                 cli_shutdown(new_conn->cli);
321                 return result;
322         }
323
324         return NT_STATUS_OK;
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) {
332                 smb_panic("Invalid parameter passed to connection_ok():  conn was NULL!\n");
333                 return False;
334         }
335
336         if (!conn->cli) {
337                 DEBUG(3, ("Connection to %s for domain %s (pipe %s) has NULL conn->cli!\n", 
338                           conn->controller, conn->domain, conn->pipe_name));
339                 return False;
340         }
341
342         if (!conn->cli->initialised) {
343                 DEBUG(3, ("Connection to %s for domain %s (pipe %s) was never initialised!\n", 
344                           conn->controller, conn->domain, conn->pipe_name));
345                 return False;
346         }
347
348         if (conn->cli->fd == -1) {
349                 DEBUG(3, ("Connection to %s for domain %s (pipe %s) has died or was never started (fd == -1)\n", 
350                           conn->controller, conn->domain, conn->pipe_name));
351                 return False;
352         }
353         
354         return True;
355 }
356
357 /* Search the cache for a connection. If there is a broken one,
358    shut it down properly and return NULL. */
359
360 static void find_cm_connection(const char *domain, const char *pipe_name,
361                                struct winbindd_cm_conn **conn_out) 
362 {
363         struct winbindd_cm_conn *conn;
364
365         for (conn = cm_conns; conn; ) {
366                 if (strequal(conn->domain, domain) && 
367                     strequal(conn->pipe_name, pipe_name)) {
368                         if (!connection_ok(conn)) {
369                                 /* Dead connection - remove it. */
370                                 struct winbindd_cm_conn *conn_temp = conn->next;
371                                 if (conn->cli)
372                                         cli_shutdown(conn->cli);
373                                 DLIST_REMOVE(cm_conns, conn);
374                                 SAFE_FREE(conn);
375                                 conn = conn_temp;  /* Keep the loop moving */
376                                 continue;
377                         } else {
378                                 break;
379                         }
380                 }
381                 conn = conn->next;
382         }
383
384         *conn_out = conn;
385 }
386
387 /* Initialize a new connection up to the RPC BIND. */
388
389 static NTSTATUS new_cm_connection(const char *domain, const char *pipe_name,
390                                   struct winbindd_cm_conn **conn_out)
391 {
392         struct winbindd_cm_conn *conn;
393         NTSTATUS result;
394
395         if (!(conn = malloc(sizeof(*conn))))
396                 return NT_STATUS_NO_MEMORY;
397                 
398         ZERO_STRUCTP(conn);
399                 
400         if (!NT_STATUS_IS_OK(result = cm_open_connection(domain, get_pipe_index(pipe_name), conn))) {
401                 DEBUG(3, ("Could not open a connection to %s for %s (%s)\n", 
402                           domain, pipe_name, nt_errstr(result)));
403                 SAFE_FREE(conn);
404                 return result;
405         }
406         DLIST_ADD(cm_conns, conn);
407
408         *conn_out = conn;
409         return NT_STATUS_OK;
410 }
411
412 /* Get a connection to the remote DC and open the pipe.  If there is already a connection, use that */
413
414 static NTSTATUS get_connection_from_cache(const char *domain, const char *pipe_name,
415                                           struct winbindd_cm_conn **conn_out)
416 {
417         find_cm_connection(domain, pipe_name, conn_out);
418
419         if (*conn_out != NULL)
420                 return NT_STATUS_OK;
421
422         return new_cm_connection(domain, pipe_name, conn_out);
423 }
424
425 /**********************************************************************************
426 **********************************************************************************/
427
428 BOOL cm_check_for_native_mode_win2k( const char *domain )
429 {
430         NTSTATUS                result;
431         struct winbindd_cm_conn conn;
432         DS_DOMINFO_CTR          ctr;
433         BOOL                    ret = False;
434         
435         ZERO_STRUCT( conn );
436         ZERO_STRUCT( ctr );
437         
438         
439         if ( !NT_STATUS_IS_OK(result = cm_open_connection(domain, PI_LSARPC_DS, &conn)) ) {
440                 DEBUG(5, ("cm_check_for_native_mode_win2k: Could not open a connection to %s for PIPE_LSARPC (%s)\n", 
441                           domain, nt_errstr(result)));
442                 return False;
443         }
444         
445         if ( conn.cli ) {
446                 if ( !NT_STATUS_IS_OK(cli_ds_getprimarydominfo( conn.cli, 
447                                 conn.cli->mem_ctx, DsRolePrimaryDomainInfoBasic, &ctr)) ) {
448                         ret = False;
449                         goto done;
450                 }
451         }
452                                 
453         if ( (ctr.basic->flags & DSROLE_PRIMARY_DS_RUNNING) 
454                         && !(ctr.basic->flags & DSROLE_PRIMARY_DS_MIXED_MODE) )
455                 ret = True;
456
457 done:
458         if ( conn.cli )
459                 cli_shutdown( conn.cli );
460         
461         return ret;
462 }
463
464
465
466 /* Return a LSA policy handle on a domain */
467
468 CLI_POLICY_HND *cm_get_lsa_handle(const char *domain)
469 {
470         struct winbindd_cm_conn *conn;
471         uint32 des_access = SEC_RIGHTS_MAXIMUM_ALLOWED;
472         NTSTATUS result;
473         static CLI_POLICY_HND hnd;
474
475         /* Look for existing connections */
476
477         if (!NT_STATUS_IS_OK(result = get_connection_from_cache(domain, PIPE_LSARPC, &conn)))
478                 return NULL;
479
480         /* This *shitty* code needs scrapping ! JRA */
481         if (policy_handle_is_valid(&conn->pol)) {
482                 hnd.pol = conn->pol;
483                 hnd.cli = conn->cli;
484                 return &hnd;
485         }
486         
487         result = cli_lsa_open_policy(conn->cli, conn->cli->mem_ctx, False, 
488                                      des_access, &conn->pol);
489
490         if (!NT_STATUS_IS_OK(result)) {
491                 /* Hit the cache code again.  This cleans out the old connection and gets a new one */
492                 if (conn->cli->fd == -1) { /* Try again, if the remote host disapeared */
493                         if (!NT_STATUS_IS_OK(result = get_connection_from_cache(domain, PIPE_LSARPC, &conn)))
494                                 return NULL;
495
496                         result = cli_lsa_open_policy(conn->cli, conn->cli->mem_ctx, False, 
497                                                      des_access, &conn->pol);
498                 }
499
500                 if (!NT_STATUS_IS_OK(result)) {
501                         cli_shutdown(conn->cli);
502                         DLIST_REMOVE(cm_conns, conn);
503                         SAFE_FREE(conn);
504                         return NULL;
505                 }
506         }       
507
508         hnd.pol = conn->pol;
509         hnd.cli = conn->cli;
510
511         return &hnd;
512 }
513
514 /* Return a SAM policy handle on a domain */
515
516 CLI_POLICY_HND *cm_get_sam_handle(char *domain)
517
518         struct winbindd_cm_conn *conn;
519         uint32 des_access = SEC_RIGHTS_MAXIMUM_ALLOWED;
520         NTSTATUS result;
521         static CLI_POLICY_HND hnd;
522
523         /* Look for existing connections */
524
525         if (!NT_STATUS_IS_OK(result = get_connection_from_cache(domain, PIPE_SAMR, &conn)))
526                 return NULL;
527         
528         /* This *shitty* code needs scrapping ! JRA */
529         if (policy_handle_is_valid(&conn->pol)) {
530                 hnd.pol = conn->pol;
531                 hnd.cli = conn->cli;
532                 return &hnd;
533         }
534         result = cli_samr_connect(conn->cli, conn->cli->mem_ctx,
535                                   des_access, &conn->pol);
536
537         if (!NT_STATUS_IS_OK(result)) {
538                 /* Hit the cache code again.  This cleans out the old connection and gets a new one */
539                 if (conn->cli->fd == -1) { /* Try again, if the remote host disapeared */
540                         if (!NT_STATUS_IS_OK(result = get_connection_from_cache(domain, PIPE_SAMR, &conn)))
541                                 return NULL;
542
543                         result = cli_samr_connect(conn->cli, conn->cli->mem_ctx,
544                                                   des_access, &conn->pol);
545                 }
546
547                 if (!NT_STATUS_IS_OK(result)) {
548                         cli_shutdown(conn->cli);
549                         DLIST_REMOVE(cm_conns, conn);
550                         SAFE_FREE(conn);
551                         return NULL;
552                 }
553         }       
554
555         hnd.pol = conn->pol;
556         hnd.cli = conn->cli;
557
558         return &hnd;
559 }
560
561 /* Get a handle on a netlogon pipe.  This is a bit of a hack to re-use the
562    netlogon pipe as no handle is returned. */
563
564 NTSTATUS cm_get_netlogon_cli(const char *domain, 
565                              const unsigned char *trust_passwd, 
566                              uint32 sec_channel_type,
567                              BOOL fresh,
568                              struct cli_state **cli)
569 {
570         NTSTATUS result = NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
571         struct winbindd_cm_conn *conn;
572         fstring lock_name;
573         BOOL got_mutex;
574
575         if (!cli)
576                 return NT_STATUS_INVALID_PARAMETER;
577
578         /* Open an initial conection - keep the mutex. */
579
580         find_cm_connection(domain, PIPE_NETLOGON, &conn);
581
582         if ( fresh && (conn != NULL) ) {
583                 cli_shutdown(conn->cli);
584                 conn->cli = NULL;
585
586                 conn = NULL;
587
588                 /* purge connection from cache */
589                 find_cm_connection(domain, PIPE_NETLOGON, &conn);
590                 if (conn != NULL) {
591                         DEBUG(0,("Could not purge connection\n"));
592                         return NT_STATUS_UNSUCCESSFUL;
593                 }
594         }
595
596         if (conn != NULL) {
597                 *cli = conn->cli;
598                 return NT_STATUS_OK;
599         }
600
601         result = new_cm_connection(domain, PIPE_NETLOGON, &conn);
602
603         if (!NT_STATUS_IS_OK(result))
604                 return result;
605         
606         snprintf(lock_name, sizeof(lock_name), "NETLOGON\\%s", conn->controller);
607
608         if (!(got_mutex = secrets_named_mutex(lock_name, WINBIND_SERVER_MUTEX_WAIT_TIME))) {
609                 DEBUG(0,("cm_get_netlogon_cli: mutex grab failed for %s\n", conn->controller));
610         }
611                         
612         result = cli_nt_establish_netlogon(conn->cli, sec_channel_type, trust_passwd);
613         
614         if (got_mutex)
615                 secrets_named_mutex_release(lock_name);
616                                 
617         if (!NT_STATUS_IS_OK(result)) {
618                 cli_shutdown(conn->cli);
619                 DLIST_REMOVE(cm_conns, conn);
620                 SAFE_FREE(conn);
621                 return result;
622         }
623
624         *cli = conn->cli;
625
626         return result;
627 }
628
629 /* Dump the current connection status */
630
631 static void dump_conn_list(void)
632 {
633         struct winbindd_cm_conn *con;
634
635         DEBUG(0, ("\tDomain          Controller      Pipe\n"));
636
637         for(con = cm_conns; con; con = con->next) {
638                 char *msg;
639
640                 /* Display pipe info */
641                 
642                 if (asprintf(&msg, "\t%-15s %-15s %-16s", con->domain, con->controller, con->pipe_name) < 0) {
643                         DEBUG(0, ("Error: not enough memory!\n"));
644                 } else {
645                         DEBUG(0, ("%s\n", msg));
646                         SAFE_FREE(msg);
647                 }
648         }
649 }
650
651 void winbindd_cm_status(void)
652 {
653         /* List open connections */
654
655         DEBUG(0, ("winbindd connection manager status:\n"));
656
657         if (cm_conns)
658                 dump_conn_list();
659         else
660                 DEBUG(0, ("\tNo active connections\n"));
661 }
662
663 /* Close all cached connections */
664
665 void winbindd_cm_flush(void)
666 {
667         struct winbindd_cm_conn *conn, tmp;
668
669         /* Flush connection cache */
670
671         for (conn = cm_conns; conn; conn = conn->next) {
672
673                 if (!connection_ok(conn))
674                         continue;
675
676                 DEBUG(10, ("Closing connection to %s on %s\n",
677                         conn->pipe_name, conn->controller));
678
679                 if (conn->cli)
680                         cli_shutdown(conn->cli);
681
682                 tmp.next = conn->next;
683
684                 DLIST_REMOVE(cm_conns, conn);
685                 SAFE_FREE(conn);
686                 conn = &tmp;
687         }
688
689         /* Flush failed connection cache */
690
691         flush_negative_conn_cache();
692 }