diff options
Diffstat (limited to 'source/libsmb/namequery.c')
| -rw-r--r-- | source/libsmb/namequery.c | 1332 |
1 files changed, 647 insertions, 685 deletions
diff --git a/source/libsmb/namequery.c b/source/libsmb/namequery.c index b9bc4e11664..7ce8486b150 100644 --- a/source/libsmb/namequery.c +++ b/source/libsmb/namequery.c @@ -1,5 +1,6 @@ /* - Unix SMB/CIFS implementation. + Unix SMB/Netbios implementation. + Version 1.9. name query routines Copyright (C) Andrew Tridgell 1994-1998 @@ -32,9 +33,8 @@ static int generate_trn_id(void) { static int trn_id; - if (trn_id == 0) { + if (trn_id == 0) sys_srandom(sys_getpid()); - } trn_id = sys_random(); @@ -52,8 +52,7 @@ static struct node_status *parse_node_status(char *p, int *num_names) *num_names = CVAL(p,0); - if (*num_names == 0) - return NULL; + if (*num_names == 0) return NULL; ret = (struct node_status *)malloc(sizeof(struct node_status)* (*num_names)); if (!ret) return NULL; @@ -61,17 +60,14 @@ static struct node_status *parse_node_status(char *p, int *num_names) p++; for (i=0;i< *num_names;i++) { StrnCpy(ret[i].name,p,15); - trim_char(ret[i].name,'\0',' '); + trim_string(ret[i].name,NULL," "); ret[i].type = CVAL(p,15); ret[i].flags = p[16]; p += 18; - DEBUG(10, ("%s#%02x: flags = 0x%02x\n", ret[i].name, - ret[i].type, ret[i].flags)); } return ret; } - /**************************************************************************** Do a NBT node status query on an open socket and return an array of structures holding the returned names or NULL if the query failed. @@ -158,196 +154,145 @@ struct node_status *node_status_query(int fd,struct nmb_name *name, return NULL; } + /**************************************************************************** - Find the first type XX name in a node status reply - used for finding - a servers name given its IP. Return the matched name in *name. +find the first type XX name in a node status reply - used for finding +a servers name given its IP +return the matched name in *name **************************************************************************/ -BOOL name_status_find(const char *q_name, int q_type, int type, struct in_addr to_ip, fstring name) +BOOL name_status_find(const char *q_name, int q_type, int type, struct in_addr to_ip, char *name) { - struct node_status *status = NULL; + struct node_status *status; struct nmb_name nname; int count, i; int sock; - BOOL result = False; - - if (lp_disable_netbios()) { - DEBUG(5,("name_status_find(%s#%02x): netbios is disabled\n", q_name, q_type)); - return False; - } - - DEBUG(10, ("name_status_find: looking up %s#%02x at %s\n", q_name, - q_type, inet_ntoa(to_ip))); - - /* Check the cache first. */ - - if (namecache_status_fetch(q_name, q_type, type, to_ip, name)) - return True; sock = open_socket_in(SOCK_DGRAM, 0, 3, interpret_addr(lp_socket_address()), True); if (sock == -1) - goto done; + return False; /* W2K PDC's seem not to respond to '*'#0. JRA */ make_nmb_name(&nname, q_name, q_type); status = node_status_query(sock, &nname, to_ip, &count); close(sock); if (!status) - goto done; + return False; for (i=0;i<count;i++) { if (status[i].type == type) break; } if (i == count) - goto done; - - pull_ascii_nstring(name, sizeof(fstring), status[i].name); + return False; - /* Store the result in the cache. */ - /* but don't store an entry for 0x1c names here. Here we have - a single host and DOMAIN<0x1c> names should be a list of hosts */ - - if ( q_type != 0x1c ) - namecache_status_store(q_name, q_type, type, to_ip, name); + StrnCpy(name, status[i].name, 15); - result = True; + dos_to_unix(name); - done: SAFE_FREE(status); + return True; +} - DEBUG(10, ("name_status_find: name %sfound", result ? "" : "not ")); +/**************************************************************************** + Do a NetBIOS name registation to try to claim a name ... +***************************************************************************/ +BOOL name_register(int fd, const char *name, int name_type, + struct in_addr name_ip, int opcode, + BOOL bcast, + struct in_addr to_ip, int *count) +{ + int retries = 3; + struct timeval tval; + struct packet_struct p; + struct packet_struct *p2; + struct nmb_packet *nmb = &p.packet.nmb; + struct in_addr register_ip; - if (result) - DEBUGADD(10, (", name %s ip address is %s", name, inet_ntoa(to_ip))); + DEBUG(4, ("name_register: %s as %s on %s\n", name, inet_ntoa(name_ip), inet_ntoa(to_ip))); - DEBUG(10, ("\n")); + register_ip.s_addr = name_ip.s_addr; /* Fix this ... */ + + memset((char *)&p, '\0', sizeof(p)); - return result; -} + *count = 0; -/* - comparison function used by sort_ip_list -*/ + nmb->header.name_trn_id = generate_trn_id(); + nmb->header.opcode = opcode; + nmb->header.response = False; + nmb->header.nm_flags.bcast = False; + nmb->header.nm_flags.recursion_available = False; + nmb->header.nm_flags.recursion_desired = True; /* ? */ + nmb->header.nm_flags.trunc = False; + nmb->header.nm_flags.authoritative = True; -static int ip_compare(struct in_addr *ip1, struct in_addr *ip2) -{ - int max_bits1=0, max_bits2=0; - int num_interfaces = iface_count(); - int i; + nmb->header.qdcount = 1; + nmb->header.ancount = 0; + nmb->header.nscount = 0; + nmb->header.arcount = 1; - for (i=0;i<num_interfaces;i++) { - struct in_addr ip; - int bits1, bits2; - ip = *iface_n_bcast(i); - bits1 = matching_quad_bits((uchar *)&ip1->s_addr, (uchar *)&ip.s_addr); - bits2 = matching_quad_bits((uchar *)&ip2->s_addr, (uchar *)&ip.s_addr); - max_bits1 = MAX(bits1, max_bits1); - max_bits2 = MAX(bits2, max_bits2); - } - - /* bias towards directly reachable IPs */ - if (iface_local(*ip1)) { - max_bits1 += 32; - } - if (iface_local(*ip2)) { - max_bits2 += 32; - } + make_nmb_name(&nmb->question.question_name, name, name_type); - return max_bits2 - max_bits1; -} + nmb->question.question_type = 0x20; + nmb->question.question_class = 0x1; -/******************************************************************* - compare 2 ldap IPs by nearness to our interfaces - used in qsort -*******************************************************************/ + /* Now, create the additional stuff for a registration request */ -static int ip_service_compare(struct ip_service *ip1, struct ip_service *ip2) -{ - int result; - - if ( (result = ip_compare(&ip1->ip, &ip2->ip)) != 0 ) - return result; - - if ( ip1->port > ip2->port ) - return 1; - - if ( ip1->port < ip2->port ) - return -1; - - return 0; -} + if ((nmb->additional = (struct res_rec *)malloc(sizeof(struct res_rec))) == NULL) { -/* - sort an IP list so that names that are close to one of our interfaces - are at the top. This prevents the problem where a WINS server returns an IP that - is not reachable from our subnet as the first match -*/ + DEBUG(0, ("name_register: malloc fail for additional record.\n")); + return False; -static void sort_ip_list(struct in_addr *iplist, int count) -{ - if (count <= 1) { - return; - } + } - qsort(iplist, count, sizeof(struct in_addr), QSORT_CAST ip_compare); -} + memset((char *)nmb->additional, '\0', sizeof(struct res_rec)); -static void sort_ip_list2(struct ip_service *iplist, int count) -{ - if (count <= 1) { - return; - } + nmb->additional->rr_name = nmb->question.question_name; + nmb->additional->rr_type = RR_TYPE_NB; + nmb->additional->rr_class = RR_CLASS_IN; - qsort(iplist, count, sizeof(struct ip_service), QSORT_CAST ip_service_compare); -} + /* See RFC 1002, sections 5.1.1.1, 5.1.1.2 and 5.1.1.3 */ + if (nmb->header.nm_flags.bcast) + nmb->additional->ttl = PERMANENT_TTL; + else + nmb->additional->ttl = lp_max_ttl(); -/********************************************************************** - Remove any duplicate address/port pairs in the list - *********************************************************************/ + nmb->additional->rdlength = 6; -static int remove_duplicate_addrs2( struct ip_service *iplist, int count ) -{ - int i, j; - - DEBUG(10,("remove_duplicate_addrs2: looking for duplicate address/port pairs\n")); - - /* one loop to remove duplicates */ - for ( i=0; i<count; i++ ) { - if ( is_zero_ip(iplist[i].ip) ) - continue; - - for ( j=i+1; j<count; j++ ) { - if ( ip_service_equal(iplist[i], iplist[j]) ) - zero_ip(&iplist[j].ip); - } - } - - /* one loop to clean up any holes we left */ - /* first ip should never be a zero_ip() */ - for (i = 0; i<count; ) { - if ( is_zero_ip(iplist[i].ip) ) { - if (i != count-1 ) - memmove(&iplist[i], &iplist[i+1], (count - i - 1)*sizeof(iplist[i])); - count--; - continue; - } - i++; - } + nmb->additional->rdata[0] = NB_MFLAG & 0xFF; + + /* Set the address for the name we are registering. */ + putip(&nmb->additional->rdata[2], ®ister_ip); + + p.ip = to_ip; + p.port = NMB_PORT; + p.fd = fd; + p.timestamp = time(NULL); + p.packet_type = NMB_PACKET; + + GetTimeOfDay(&tval); + + if (!send_packet(&p)) + return False; + + retries--; - return count; + if ((p2 = receive_nmb_packet(fd, 10, nmb->header.name_trn_id))) { + debug_nmb_packet(p2); + SAFE_FREE(p2); /* No memory leaks ... */ + } + + return True; } /**************************************************************************** Do a netbios name query to find someones IP. Returns an array of IP addresses or NULL if none. *count will be set to the number of addresses returned. - *timed_out is set if we failed by timing out ****************************************************************************/ - struct in_addr *name_query(int fd,const char *name,int name_type, BOOL bcast,BOOL recurse, - struct in_addr to_ip, int *count, int *flags, - BOOL *timed_out) + struct in_addr to_ip, int *count, int *flags) { BOOL found=False; int i, retries = 3; @@ -358,19 +303,10 @@ struct in_addr *name_query(int fd,const char *name,int name_type, struct nmb_packet *nmb = &p.packet.nmb; struct in_addr *ip_list = NULL; - if (lp_disable_netbios()) { - DEBUG(5,("name_query(%s#%02x): netbios is disabled\n", name, name_type)); - return NULL; - } - - if (timed_out) { - *timed_out = False; - } - memset((char *)&p,'\0',sizeof(p)); (*count) = 0; (*flags) = 0; - + nmb->header.name_trn_id = generate_trn_id(); nmb->header.opcode = 0; nmb->header.response = False; @@ -384,29 +320,29 @@ struct in_addr *name_query(int fd,const char *name,int name_type, nmb->header.ancount = 0; nmb->header.nscount = 0; nmb->header.arcount = 0; - + make_nmb_name(&nmb->question.question_name,name,name_type); - + nmb->question.question_type = 0x20; nmb->question.question_class = 0x1; - + p.ip = to_ip; p.port = NMB_PORT; p.fd = fd; p.timestamp = time(NULL); p.packet_type = NMB_PACKET; - + GetTimeOfDay(&tval); - + if (!send_packet(&p)) return NULL; - + retries--; - + while (1) { struct timeval tval2; struct in_addr *tmp_ip_list; - + GetTimeOfDay(&tval2); if (TvalDiff(&tval,&tval2) > retry_time) { if (!retries) @@ -416,19 +352,19 @@ struct in_addr *name_query(int fd,const char *name,int name_type, GetTimeOfDay(&tval); retries--; } - + if ((p2=receive_nmb_packet(fd,90,nmb->header.name_trn_id))) { struct nmb_packet *nmb2 = &p2->packet.nmb; debug_nmb_packet(p2); - + /* If we get a Negative Name Query Response from a WINS * server, we should report it and give up. */ if( 0 == nmb2->header.opcode /* A query response */ - && !(bcast) /* from a WINS server */ - && nmb2->header.rcode /* Error returned */ + && !(bcast) /* from a WINS server */ + && nmb2->header.rcode /* Error returned */ ) { - + if( DEBUGLVL( 3 ) ) { /* Only executed if DEBUGLEVEL >= 3 */ dbgtext( "Negative name query response, rcode 0x%02x: ", nmb2->header.rcode ); @@ -453,14 +389,15 @@ struct in_addr *name_query(int fd,const char *name,int name_type, break; } } + free_packet(p2); return( NULL ); } - + if (nmb2->header.opcode != 0 || - nmb2->header.nm_flags.bcast || - nmb2->header.rcode || - !nmb2->header.ancount) { + nmb2->header.nm_flags.bcast || + nmb2->header.rcode || + !nmb2->header.ancount) { /* * XXXX what do we do with this? Could be a * redirect, but we'll discard it for the @@ -469,17 +406,17 @@ struct in_addr *name_query(int fd,const char *name,int name_type, free_packet(p2); continue; } - + tmp_ip_list = (struct in_addr *)Realloc( ip_list, sizeof( ip_list[0] ) - * ( (*count) + nmb2->answers->rdlength/6 ) ); - + * ( (*count) + nmb2->answers->rdlength/6 ) ); + if (!tmp_ip_list) { DEBUG(0,("name_query: Realloc failed.\n")); - SAFE_FREE(ip_list); + SAFE_FREE(ip_list); } - + ip_list = tmp_ip_list; - + if (ip_list) { DEBUG(2,("Got a positive name query response from %s ( ", inet_ntoa(p2->ip))); for (i=0;i<nmb2->answers->rdlength/6;i++) { @@ -489,23 +426,24 @@ struct in_addr *name_query(int fd,const char *name,int name_type, } DEBUGADD(2,(")\n")); } - + found=True; retries=0; /* We add the flags back ... */ if (nmb2->header.response) - (*flags) |= NM_FLAGS_RS; + (*flags) |= NM_FLAGS_RS; if (nmb2->header.nm_flags.authoritative) - (*flags) |= NM_FLAGS_AA; + (*flags) |= NM_FLAGS_AA; if (nmb2->header.nm_flags.trunc) - (*flags) |= NM_FLAGS_TC; + (*flags) |= NM_FLAGS_TC; if (nmb2->header.nm_flags.recursion_desired) - (*flags) |= NM_FLAGS_RD; + (*flags) |= NM_FLAGS_RD; if (nmb2->header.nm_flags.recursion_available) - (*flags) |= NM_FLAGS_RA; + (*flags) |= NM_FLAGS_RA; if (nmb2->header.nm_flags.bcast) - (*flags) |= NM_FLAGS_B; + (*flags) |= NM_FLAGS_B; free_packet(p2); + /* * If we're doing a unicast lookup we only * expect one reply. Don't wait the full 2 @@ -516,15 +454,12 @@ struct in_addr *name_query(int fd,const char *name,int name_type, } } - /* only set timed_out if we didn't fund what we where looking for*/ - - if ( !found && timed_out ) { - *timed_out = True; + /* Reach here if we've timed out waiting for replies.. */ + if( !bcast && !found ) { + /* Timed out wating for WINS server to respond. Mark it dead. */ + wins_srv_died( to_ip ); } - /* sort the ip list so we choose close servers first if possible */ - sort_ip_list(ip_list, *count); - return ip_list; } @@ -532,26 +467,26 @@ struct in_addr *name_query(int fd,const char *name,int name_type, Start parsing the lmhosts file. *********************************************************/ -XFILE *startlmhosts(char *fname) +FILE *startlmhosts(const char *fname) { - XFILE *fp = x_fopen(fname,O_RDONLY, 0); - if (!fp) { - DEBUG(4,("startlmhosts: Can't open lmhosts file %s. Error was %s\n", - fname, strerror(errno))); - return NULL; - } - return fp; + FILE *fp = sys_fopen(fname,"r"); + if (!fp) { + DEBUG(4,("startlmhosts: Can't open lmhosts file %s. Error was %s\n", + fname, strerror(errno))); + return NULL; + } + return fp; } /******************************************************** Parse the next line in the lmhosts file. *********************************************************/ -BOOL getlmhostsent( XFILE *fp, pstring name, int *name_type, struct in_addr *ipaddr) +BOOL getlmhostsent( FILE *fp, pstring name, int *name_type, struct in_addr *ipaddr) { pstring line; - while(!x_feof(fp) && !x_ferror(fp)) { + while(!feof(fp) && !ferror(fp)) { pstring ip,flags,extra; const char *ptr; char *ptr1; @@ -597,7 +532,7 @@ BOOL getlmhostsent( XFILE *fp, pstring name, int *name_type, struct in_addr *ipa DEBUG(4, ("getlmhostsent: lmhost entry: %s %s %s\n", ip, name, flags)); - if (strchr_m(flags,'G') || strchr_m(flags,'S')) + if (strchr(flags,'G') || strchr(flags,'S')) { DEBUG(0,("getlmhostsent: group flag in lmhosts ignored (obsolete)\n")); continue; @@ -607,7 +542,7 @@ BOOL getlmhostsent( XFILE *fp, pstring name, int *name_type, struct in_addr *ipa /* Extra feature. If the name ends in '#XX', where XX is a hex number, then only add that name type. */ - if((ptr1 = strchr_m(name, '#')) != NULL) + if((ptr1 = strchr(name, '#')) != NULL) { char *endptr; @@ -633,54 +568,88 @@ BOOL getlmhostsent( XFILE *fp, pstring name, int *name_type, struct in_addr *ipa Finish parsing the lmhosts file. *********************************************************/ -void endlmhosts(XFILE *fp) +void endlmhosts(FILE *fp) { - x_fclose(fp); + fclose(fp); } -/******************************************************** - convert an array if struct in_addrs to struct ip_service - return False on failure. Port is set to PORT_NONE; -*********************************************************/ - -static BOOL convert_ip2service( struct ip_service **return_iplist, struct in_addr *ip_list, int count ) +BOOL name_register_wins(const char *name, int name_type) { - int i; + int sock, i, return_count; + int num_interfaces = iface_count(); + struct in_addr sendto_ip; - if ( count==0 || !ip_list ) - return False; - - /* copy the ip address; port will be PORT_NONE */ - if ( (*return_iplist = (struct ip_service*)malloc(count*sizeof(struct ip_service))) == NULL ) { - DEBUG(0,("convert_ip2service: malloc failed for %d enetries!\n", count )); - return False; - } - - for ( i=0; i<count; i++ ) { - (*return_iplist)[i].ip = ip_list[i]; - (*return_iplist)[i].port = PORT_NONE; - } + /* + * Check if we have any interfaces, prevents a segfault later + */ + + if (num_interfaces <= 0) + return False; /* Should return some indication of the problem */ + + /* + * Do a broadcast register ... + */ + + if (!lp_wins_server()) + return False; + + DEBUG(4, ("name_register_wins:Registering my name %s on %s\n", name, lp_wins_server())); + + sock = open_socket_in(SOCK_DGRAM, 0, 3, + interpret_addr("0.0.0.0"), True); + + if (sock == -1) return False; + + set_socket_options(sock, "SO_BROADCAST"); + + sendto_ip.s_addr = inet_addr(lp_wins_server()); + + if (num_interfaces > 1) { + + for (i = 0; i < num_interfaces; i++) { + + if (!name_register(sock, name, name_type, *iface_n_ip(i), + NMB_NAME_MULTIHOMED_REG_OPCODE, + True, sendto_ip, &return_count)) { + + close(sock); + return False; + + } + + } + + } + else { + + if (!name_register(sock, name, name_type, *iface_n_ip(0), + NMB_NAME_REG_OPCODE, + True, sendto_ip, &return_count)) { + + close(sock); + return False; + + } + + } + + close(sock); + + return True; + +} - return True; -} /******************************************************** Resolve via "bcast" method. *********************************************************/ BOOL name_resolve_bcast(const char *name, int name_type, - struct ip_service **return_iplist, int *return_count) + struct in_addr **return_ip_list, int *return_count) { int sock, i; int num_interfaces = iface_count(); - struct in_addr *ip_list; - BOOL ret; - - if (lp_disable_netbios()) { - DEBUG(5,("name_resolve_bcast(%s#%02x): netbios is disabled\n", name, name_type)); - return False; - } - *return_iplist = NULL; + *return_ip_list = NULL; *return_count = 0; /* @@ -703,129 +672,79 @@ BOOL name_resolve_bcast(const char *name, int name_type, struct in_addr sendto_ip; int flags; /* Done this way to fix compiler error on IRIX 5.x */ - sendto_ip = *iface_n_bcast(i); - ip_list = name_query(sock, name, name_type, True, - True, sendto_ip, return_count, &flags, NULL); - if( ip_list ) - goto success; + sendto_ip = *iface_bcast(*iface_n_ip(i)); + *return_ip_list = name_query(sock, name, name_type, True, + True, sendto_ip, return_count, &flags); + if(*return_ip_list != NULL) { + close(sock); + return True; + } } - - /* failed - no response */ - + close(sock); return False; - -success: - ret = True; - if ( !convert_ip2service(return_iplist, ip_list, *return_count) ) - ret = False; - - SAFE_FREE( ip_list ); - close(sock); - return ret; } /******************************************************** Resolve via "wins" method. *********************************************************/ -BOOL resolve_wins(const char *name, int name_type, - struct ip_service **return_iplist, int *return_count) +static BOOL resolve_wins(const char *name, int name_type, + struct in_addr **return_iplist, int *return_count) { - int sock, t, i; - char **wins_tags; - struct in_addr src_ip, *ip_list = NULL; - BOOL ret; - - if (lp_disable_netbios()) { - DEBUG(5,("resolve_wins(%s#%02x): netbios is disabled\n", name, name_type)); - return False; - } + int sock; + struct in_addr wins_ip; + BOOL wins_ismyip; *return_iplist = NULL; *return_count = 0; + /* + * "wins" means do a unicast lookup to the WINS server. + * Ignore if there is no WINS server specified or if the + * WINS server is one of our interfaces (if we're being + * called from within nmbd - we can't do this call as we + * would then block). + */ + DEBUG(3,("resolve_wins: Attempting wins lookup for name %s<0x%x>\n", name, name_type)); - if (wins_srv_count() < 1) { + if (lp_wins_support()) { + /* + * We're providing WINS support. Call ourselves so + * long as we're not nmbd. + */ + extern struct in_addr loopback_ip; + wins_ip = loopback_ip; + wins_ismyip = True; + } else if( wins_srv_count() < 1 ) { DEBUG(3,("resolve_wins: WINS server resolution selected and no WINS servers listed.\n")); return False; + } else { + wins_ip = wins_srv_ip(); + wins_ismyip = ismyip(wins_ip); } - /* we try a lookup on each of the WINS tags in turn */ - wins_tags = wins_srv_tags(); - - if (!wins_tags) { - /* huh? no tags?? give up in disgust */ - return False; - } - - /* the address we will be sending from */ - src_ip = *interpret_addr2(lp_socket_address()); - - /* in the worst case we will try every wins server with every - tag! */ - for (t=0; wins_tags && wins_tags[t]; t++) { - int srv_count = wins_srv_count_tag(wins_tags[t]); - for (i=0; i<srv_count; i++) { - struct in_addr wins_ip; - int flags; - BOOL timed_out; - - wins_ip = wins_srv_ip_tag(wins_tags[t], src_ip); - - if (global_in_nmbd && ismyip(wins_ip)) { - /* yikes! we'll loop forever */ - continue; - } - - /* skip any that have been unresponsive lately */ - if (wins_srv_is_dead(wins_ip, src_ip)) { - continue; - } - - DEBUG(3,("resolve_wins: using WINS server %s and tag '%s'\n", inet_ntoa(wins_ip), wins_tags[t])); - - sock = open_socket_in(SOCK_DGRAM, 0, 3, src_ip.s_addr, True); - if (sock == -1) { - continue; + DEBUG(3, ("resolve_wins: WINS server == <%s>\n", inet_ntoa(wins_ip)) ); + if((wins_ismyip && !global_in_nmbd) || !wins_ismyip) { + sock = open_socket_in( SOCK_DGRAM, 0, 3, + interpret_addr(lp_socket_address()), + True ); + if (sock != -1) { + int flags; + *return_iplist = name_query( sock, name, + name_type, False, + True, wins_ip, + return_count, &flags); + if(*return_iplist != NULL) { + close(sock); + return True; } - - ip_list = name_query(sock,name,name_type, False, - True, wins_ip, return_count, &flags, - &timed_out); - - /* exit loop if we got a list of addresses */ - - if ( ip_list ) - goto success; - close(sock); - - if (timed_out) { - /* Timed out wating for WINS server to respond. Mark it dead. */ - wins_srv_died(wins_ip, src_ip); - } else { - /* The name definately isn't in this - group of WINS servers. goto the next group */ - break; - } } } - wins_srv_tags_free(wins_tags); return False; - -success: - ret = True; - if ( !convert_ip2service( return_iplist, ip_list, *return_count ) ) - ret = False; - - SAFE_FREE( ip_list ); - wins_srv_tags_free(wins_tags); - close(sock); - - return ret; } /******************************************************** @@ -833,13 +752,13 @@ success: *********************************************************/ static BOOL resolve_lmhosts(const char *name, int name_type, - struct ip_service **return_iplist, int *return_count) + struct in_addr **return_iplist, int *return_count) { /* * "lmhosts" means parse the local lmhosts file. */ - XFILE *fp; + FILE *fp; pstring lmhost_name; int name_type2; struct in_addr return_ip; @@ -849,19 +768,19 @@ static BOOL resolve_lmhosts(const char *name, int name_type, DEBUG(3,("resolve_lmhosts: Attempting lmhosts lookup for name %s<0x%x>\n", name, name_type)); - fp = startlmhosts(dyn_LMHOSTSFILE); + fp = startlmhosts( LMHOSTSFILE ); if(fp) { while (getlmhostsent(fp, lmhost_name, &name_type2, &return_ip)) { if (strequal(name, lmhost_name) && ((name_type2 == -1) || (name_type == name_type2)) ) { endlmhosts(fp); - if ( (*return_iplist = (struct ip_service *)malloc(sizeof(struct ip_service))) == NULL ) { + *return_iplist = (struct in_addr *)malloc(sizeof(struct in_addr)); + if(*return_iplist == NULL) { DEBUG(3,("resolve_lmhosts: malloc fail !\n")); return False; } - (*return_iplist)[0].ip = return_ip; - (*return_iplist)[0].port = PORT_NONE; + **return_iplist = return_ip; *return_count = 1; return True; } @@ -876,120 +795,45 @@ static BOOL resolve_lmhosts(const char *name, int name_type, Resolve via "hosts" method. *********************************************************/ -static BOOL resolve_hosts(const char *name, int name_type, - struct ip_service **return_iplist, int *return_count) +static BOOL resolve_hosts(const char *name, + struct in_addr **return_iplist, int *return_count) { /* * "host" means do a localhost, or dns lookup. */ struct hostent *hp; - - if ( name_type != 0x20 && name_type != 0x0) { - DEBUG(5, ("resolve_hosts: not appropriate for name type <0x%x>\n", name_type)); - return False; - } *return_iplist = NULL; *return_count = 0; - DEBUG(3,("resolve_hosts: Attempting host lookup for name %s<0x%x>\n", name, name_type)); + DEBUG(3,("resolve_hosts: Attempting host lookup for name %s<0x20>\n", name)); if (((hp = sys_gethostbyname(name)) != NULL) && (hp->h_addr != NULL)) { - struct in_addr return_ip; - putip((char *)&return_ip,(char *)hp->h_addr); - *return_iplist = (struct ip_service *)malloc(sizeof(struct ip_service)); + int i = 0, j; + while (hp->h_addr_list[i]) i++; + DEBUG(10, ("%d addresses returned\n", i)); + *return_iplist = (struct in_addr *)malloc(i*sizeof(struct in_addr)); if(*return_iplist == NULL) { DEBUG(3,("resolve_hosts: malloc fail !\n")); return False; } - (*return_iplist)->ip = return_ip; - (*return_iplist)->port = PORT_NONE; - *return_count = 1; + for (j = 0; j < i; j++) + putip(&(*return_iplist)[j], (char *)hp->h_addr_list[j]); + *return_count = i; return True; } return False; } /******************************************************** - Resolve via "ADS" method. -*********************************************************/ - -static BOOL resolve_ads(const char *name, int name_type, - struct ip_service **return_iplist, int *return_count) -{ - -#ifdef HAVE_ADS - if ( name_type == 0x1c ) { - int count, i = 0; - char *list = NULL; - const char *ptr; - pstring tok; - - /* try to lookup the _ldap._tcp.<domain> if we are using ADS */ - if ( lp_security() != SEC_ADS ) - return False; - - DEBUG(5,("resolve_hosts: Attempting to resolve DC's for %s using DNS\n", - name)); - - if (ldap_domain2hostlist(name, &list) != LDAP_SUCCESS) - return False; - - count = count_chars(list, ' ') + 1; - if ( (*return_iplist = malloc(count * sizeof(struct ip_service))) == NULL ) { - DEBUG(0,("resolve_hosts: malloc failed for %d entries\n", count )); - return False; - } - - ptr = list; - while (next_token(&ptr, tok, " ", sizeof(tok))) { - unsigned port = LDAP_PORT; - char *p = strchr(tok, ':'); - if (p) { - *p = 0; - port = atoi(p+1); - } - (*return_iplist)[i].ip = *interpret_addr2(tok); - (*return_iplist)[i].port = port; - - /* make sure it is a valid IP. I considered checking the negative - connection cache, but this is the wrong place for it. Maybe only - as a hac. After think about it, if all of the IP addresses retuend - from DNS are dead, what hope does a netbios name lookup have? - The standard reason for falling back to netbios lookups is that - our DNS server doesn't know anything about the DC's -- jerry */ - - if ( is_zero_ip((*return_iplist)[i].ip) ) - continue; - - i++; - } - SAFE_FREE(list); - - *return_count = i; - - return True; - } else -#endif /* HAVE_ADS */ - { - return False; - } -} - -/******************************************************************* Internal interface to resolve a name into an IP address. Use this function if the string is either an IP address, DNS or host name or NetBIOS name. This uses the name switch in the smb.conf to determine the order of name resolution. - - Added support for ip addr/port to support ADS ldap servers. - the only place we currently care about the port is in the - resolve_hosts() when looking up DC's via SRV RR entries in DNS -**********************************************************************/ +*********************************************************/ static BOOL internal_resolve_name(const char *name, int name_type, - struct ip_service **return_iplist, - int *return_count, const char *resolve_order) + struct in_addr **return_iplist, int *return_count) { pstring name_resolve_list; fstring tok; @@ -998,92 +842,65 @@ static BOOL internal_resolve_name(const char *name, int name_type, BOOL allzeros = (strcmp(name,"0.0.0.0") == 0); BOOL is_address = is_ipaddress(name); BOOL result = False; + struct in_addr *nodupes_iplist; int i; *return_iplist = NULL; *return_count = 0; - DEBUG(10, ("internal_resolve_name: looking up %s#%x\n", name, name_type)); - if (allzeros || allones || is_address) { - - if ( (*return_iplist = (struct ip_service *)malloc(sizeof(struct ip_service))) == NULL ) { - DEBUG(0,("internal_resolve_name: malloc fail !\n")); + *return_iplist = (struct in_addr *)malloc(sizeof(struct in_addr)); + if(*return_iplist == NULL) { + DEBUG(3,("internal_resolve_name: malloc fail !\n")); return False; } - if(is_address) { - /* ignore the port here */ - (*return_iplist)->port = PORT_NONE; - /* if it's in the form of an IP address then get the lib to interpret it */ - if (((*return_iplist)->ip.s_addr = inet_addr(name)) == 0xFFFFFFFF ){ + if (((*return_iplist)->s_addr = inet_addr(name)) == 0xFFFFFFFF ){ DEBUG(1,("internal_resolve_name: inet_addr failed on %s\n", name)); return False; } } else { - (*return_iplist)->ip.s_addr = allones ? 0xFFFFFFFF : 0; + (*return_iplist)->s_addr = allones ? 0xFFFFFFFF : 0; + *return_count = 1; } - *return_count = 1; - return True; + return True; } - - /* Check name cache */ + + /* Check netbios name cache */ if (namecache_fetch(name, name_type, return_iplist, return_count)) { - /* This could be a negative response */ - return (*return_count > 0); + /* This could be a negative response */ + return (*return_count > 0); } - /* set the name resolution order */ - - if ( strcmp( resolve_order, "NULL") == 0 ) { - DEBUG(8,("internal_resolve_name: all lookups disabled\n")); - return False; - } - - if ( !resolve_order ) - pstrcpy(name_resolve_list, lp_name_resolve_order()); - else - pstrcpy(name_resolve_list, resolve_order); - - if ( !name_resolve_list[0] ) + pstrcpy(name_resolve_list, lp_name_resolve_order()); + ptr = name_resolve_list; + if (!ptr || !*ptr) ptr = "host"; - else - ptr = name_resolve_list; - /* iterate through the name resolution backends */ - while (next_token(&ptr, tok, LIST_SEP, sizeof(tok))) { if((strequal(tok, "host") || strequal(tok, "hosts"))) { - if (resolve_hosts(name, name_type, return_iplist, return_count)) { + if (name_type == 0x20 && resolve_hosts(name, return_iplist, return_count)) { result = True; - goto done; - } - } else if(strequal( tok, "ads")) { - /* deal with 0x1c names here. This will result in a - SRV record lookup for _ldap._tcp.<domain> if we - are using 'security = ads' */ - if (resolve_ads(name, name_type, return_iplist, return_count)) { - result = True; - goto done; + goto done; } } else if(strequal( tok, "lmhosts")) { if (resolve_lmhosts(name, name_type, return_iplist, return_count)) { - result = True; - goto done; + result = True; + goto done; } } else if(strequal( tok, "wins")) { /* don't resolve 1D via WINS */ if (name_type != 0x1D && - resolve_wins(name, name_type, return_iplist, return_count)) { - result = True; - goto done; + resolve_wins(name, name_type, return_iplist, return_count)) { + result = True; + goto done; } } else if(strequal( tok, "bcast")) { if (name_resolve_bcast(name, name_type, return_iplist, return_count)) { - result = True; - goto done; + result = True; + goto done; } } else { DEBUG(0,("resolve_name: unknown name switch type %s\n", tok)); @@ -1093,42 +910,60 @@ static BOOL internal_resolve_name(const char *name, int name_type, /* All of the resolve_* functions above have returned false. */ SAFE_FREE(*return_iplist); - *return_count = 0; - return False; - done: + done: /* Remove duplicate entries. Some queries, notably #1c (domain controllers) return the PDC in iplist[0] and then all domain controllers including the PDC in iplist[1..n]. Iterating over the iplist when the PDC is down will cause two sets of timeouts. */ - if ( *return_count ) { - *return_count = remove_duplicate_addrs2( *return_iplist, *return_count ); - } + if (*return_count && (nodupes_iplist = + (struct in_addr *)malloc(sizeof(struct in_addr) * (*return_count)))) { + int nodupes_count = 0; + + /* Iterate over return_iplist looking for duplicates */ - /* Save in name cache */ - if ( DEBUGLEVEL >= 100 ) { - for (i = 0; i < *return_count && DEBUGLEVEL == 100; i++) - DEBUG(100, ("Storing name %s of type %d (%s:%d)\n", name, - name_type, inet_ntoa((*return_iplist)[i].ip), (*return_iplist)[i].port)); + for (i = 0; i < *return_count; i++) { + BOOL is_dupe = False; + int j; + + for (j = i + 1; j < *return_count; j++) { + if (ip_equal((*return_iplist)[i], + (*return_iplist)[j])) { + is_dupe = True; + break; + } + } + + if (!is_dupe) { + + /* This one not a duplicate */ + + nodupes_iplist[nodupes_count] = (*return_iplist)[i]; + nodupes_count++; + } + } + + /* Switcheroo with original list */ + + free(*return_iplist); + + *return_iplist = nodupes_iplist; + *return_count = nodupes_count; } - - namecache_store(name, name_type, *return_count, *return_iplist); - + /* Display some debugging info */ - - if ( DEBUGLEVEL >= 10 ) { - DEBUG(10, ("internal_resolve_name: returning %d addresses: ", - *return_count)); - - for (i = 0; i < *return_count; i++) - DEBUGADD(10, ("%s:%d ", inet_ntoa((*return_iplist)[i].ip), (*return_iplist)[i].port)); - - DEBUG(10, ("\n")); - } - + + DEBUG(10, ("internal_resolve_name: returning %d addresses: ", + *return_count)); + + for (i = 0; i < *return_count; i++) + DEBUGADD(10, ("%s ", inet_ntoa((*return_iplist)[i]))); + + DEBUG(10, ("\n")); + return result; } @@ -1141,7 +976,7 @@ static BOOL internal_resolve_name(const char *name, int name_type, BOOL resolve_name(const char *name, struct in_addr *return_ip, int name_type) { - struct ip_service *ip_list = NULL; + struct in_addr *ip_list = NULL; int count = 0; if (is_ipaddress(name)) { @@ -1149,48 +984,95 @@ BOOL resolve_name(const char *name, struct in_addr *return_ip, int name_type) return True; } - if (internal_resolve_name(name, name_type, &ip_list, &count, lp_name_resolve_order())) { + if(internal_resolve_name(name, name_type, &ip_list, &count)) { int i; - /* only return valid addresses for TCP connections */ for (i=0; i<count; i++) { - char *ip_str = inet_ntoa(ip_list[i].ip); + char *ip_str = inet_ntoa(ip_list[i]); if (ip_str && - strcmp(ip_str, "255.255.255.255") != 0 && - strcmp(ip_str, "0.0.0.0") != 0) - { - *return_ip = ip_list[i].ip; + strcmp(ip_str, "255.255.255.255") != 0 && + strcmp(ip_str, "0.0.0.0") != 0) { + *return_ip = ip_list[i]; SAFE_FREE(ip_list); return True; } } } - SAFE_FREE(ip_list); return False; } +/************************************************************************** + Resolve a name to a list of addresses +**************************************************************************/ +BOOL resolve_name_2(const char *name, struct in_addr **return_ip, int *count, int name_type) +{ + + return internal_resolve_name(name, name_type, return_ip, count); + +} + +/******************************************************** + resolve a name of format \\server_name or \\ipaddress + into a name. also, cut the \\ from the front for us. +*********************************************************/ + +BOOL resolve_srv_name(const char* srv_name, fstring dest_host, + struct in_addr *ip) +{ + BOOL ret; + const char *sv_name = srv_name; + + DEBUG(10,("resolve_srv_name: %s\n", srv_name)); + + if (srv_name == NULL || strequal("\\\\.", srv_name)) + { + extern pstring global_myname; + fstrcpy(dest_host, global_myname); + ip = interpret_addr2("127.0.0.1"); + return True; + } + + if (strnequal("\\\\", srv_name, 2)) + { + sv_name = &srv_name[2]; + } + + fstrcpy(dest_host, sv_name); + /* treat the '*' name specially - it is a magic name for the PDC */ + if (strcmp(dest_host,"*") == 0) { + extern pstring global_myname; + ret = resolve_name(lp_workgroup(), ip, 0x1B); + lookup_dc_name(global_myname, lp_workgroup(), ip, dest_host); + } else { + ret = resolve_name(dest_host, ip, 0x20); + } + + if (is_ipaddress(dest_host)) + { + fstrcpy(dest_host, "*SMBSERVER"); + } + + return ret; +} + + /******************************************************** Find the IP address of the master browser or DMB for a workgroup. *********************************************************/ -BOOL find_master_ip(const char *group, struct in_addr *master_ip) +BOOL find_master_ip(char *group, struct in_addr *master_ip) { - struct ip_service *ip_list = NULL; + struct in_addr *ip_list = NULL; int count = 0; - if (lp_disable_netbios()) { - DEBUG(5,("find_master_ip(%s): netbios is disabled\n", group)); - return False; - } - - if (internal_resolve_name(group, 0x1D, &ip_list, &count, lp_name_resolve_order())) { - *master_ip = ip_list[0].ip; + if (internal_resolve_name(group, 0x1D, &ip_list, &count)) { + *master_ip = ip_list[0]; SAFE_FREE(ip_list); return True; } - if(internal_resolve_name(group, 0x1B, &ip_list, &count, lp_name_resolve_order())) { - *master_ip = ip_list[0].ip; + if(internal_resolve_name(group, 0x1B, &ip_list, &count)) { + *master_ip = ip_list[0]; SAFE_FREE(ip_list); return True; } @@ -1200,207 +1082,287 @@ BOOL find_master_ip(const char *group, struct in_addr *master_ip) } /******************************************************** - Get the IP address list of the primary domain controller - for a domain. + Lookup a DC name given a Domain name and IP address. *********************************************************/ -BOOL get_pdc_ip(const char *domain, struct in_addr *ip) +BOOL lookup_dc_name(const char *srcname, const char *domain, + struct in_addr *dc_ip, char *ret_name) { - struct ip_service *ip_list; - int count; +#if !defined(I_HATE_WINDOWS_REPLY_CODE) - /* Look up #1B name */ + fstring dc_name; + BOOL ret; - if (!internal_resolve_name(domain, 0x1b, &ip_list, &count, lp_name_resolve_order())) - return False; + /* + * Due to the fact win WinNT *sucks* we must do a node status + * query here... JRA. + */ + + *dc_name = '\0'; + + ret = name_status_find(domain, 0x1c, 0x20, *dc_ip, dc_name); + + if(ret && *dc_name) { + fstrcpy(ret_name, dc_name); + return True; + } + + return False; + +#else /* defined(I_HATE_WINDOWS_REPLY_CODE) */ - /* if we get more than 1 IP back we have to assume it is a - multi-homed PDC and not a mess up */ +JRA - This code is broken with BDC rollover - we need to do a full +NT GETDC call, UNICODE, NT domain SID and uncle tom cobbley and all... - if ( count > 1 ) { - DEBUG(6,("get_pdc_ip: PDC has %d IP addresses!\n", count)); - sort_ip_list2( ip_list, count ); + int retries = 3; + int retry_time = 2000; + struct timeval tval; + struct packet_struct p; + struct dgram_packet *dgram = &p.packet.dgram; + char *ptr,*p2; + char tmp[4]; + int len; + struct sockaddr_in sock_name; + int sock_len = sizeof(sock_name); + const char *mailslot = NET_LOGON_MAILSLOT; + char *mailslot_name; + char buffer[1024]; + char *bufp; + int dgm_id = generate_trn_id(); + int sock = open_socket_in(SOCK_DGRAM, 0, 3, interpret_addr(lp_socket_address()), True ); + + if(sock == -1) + return False; + + /* Find out the transient UDP port we have been allocated. */ + if(getsockname(sock, (struct sockaddr *)&sock_name, &sock_len)<0) { + DEBUG(0,("lookup_dc_name: Failed to get local UDP port. Error was %s\n", + strerror(errno))); + close(sock); + return False; } - *ip = ip_list[0].ip; + /* + * Create the request data. + */ + + memset(buffer,'\0',sizeof(buffer)); + bufp = buffer; + SSVAL(bufp,0,QUERYFORPDC); + bufp += 2; + fstrcpy(bufp,srcname); + bufp += (strlen(bufp) + 1); + slprintf(bufp, sizeof(fstring)-1, "\\MAILSLOT\\NET\\GETDC%d", dgm_id); + mailslot_name = bufp; + bufp += (strlen(bufp) + 1); + bufp = ALIGN2(bufp, buffer); + bufp += dos_PutUniCode(bufp, srcname, sizeof(buffer) - (bufp - buffer) - 1, True); + SIVAL(bufp,0,1); + SSVAL(bufp,4,0xFFFF); + SSVAL(bufp,6,0xFFFF); + bufp += 8; + len = PTR_DIFF(bufp,buffer); + + memset((char *)&p,'\0',sizeof(p)); + + /* DIRECT GROUP or UNIQUE datagram. */ + dgram->header.msg_type = 0x10; + dgram->header.flags.node_type = M_NODE; + dgram->header.flags.first = True; + dgram->header.flags.more = False; + dgram->header.dgm_id = dgm_id; + dgram->header.source_ip = *iface_ip(*pdc_ip); + dgram->header.source_port = ntohs(sock_name.sin_port); + dgram->header.dgm_length = 0; /* Let build_dgram() handle this. */ + dgram->header.packet_offset = 0; - SAFE_FREE(ip_list); + make_nmb_name(&dgram->source_name,srcname,0); + make_nmb_name(&dgram->dest_name,domain,0x1C); + + ptr = &dgram->data[0]; + + /* Setup the smb part. */ + ptr -= 4; /* XXX Ugliness because of handling of tcp SMB length. */ + memcpy(tmp,ptr,4); + set_message(ptr,17,17 + len,True); + memcpy(ptr,tmp,4); + + CVAL(ptr,smb_com) = SMBtrans; + SSVAL(ptr,smb_vwv1,len); + SSVAL(ptr,smb_vwv11,len); + SSVAL(ptr,smb_vwv12,70 + strlen(mailslot)); + SSVAL(ptr,smb_vwv13,3); + SSVAL(ptr,smb_vwv14,1); + SSVAL(ptr,smb_vwv15,1); + SSVAL(ptr,smb_vwv16,2); + p2 = smb_buf(ptr); + pstrcpy(p2,mailslot); + p2 = skip_string(p2,1); + + memcpy(p2,buffer,len); + p2 += len; + + dgram->datasize = PTR_DIFF(p2,ptr+4); /* +4 for tcp length. */ + + p.ip = *pdc_ip; + p.port = DGRAM_PORT; + p.fd = sock; + p.timestamp = time(NULL); + p.packet_type = DGRAM_PACKET; + + GetTimeOfDay(&tval); + + if (!send_packet(&p)) { + DEBUG(0,("lookup_dc_name: send_packet failed.\n")); + close(sock); + return False; + } + + retries--; + + while (1) { + struct timeval tval2; + struct packet_struct *p_ret; + + GetTimeOfDay(&tval2); + if (TvalDiff(&tval,&tval2) > retry_time) { + if (!retries) + break; + if (!send_packet(&p)) { + DEBUG(0,("lookup_dc_name: send_packet failed.\n")); + close(sock); + return False; + } + GetTimeOfDay(&tval); + retries--; + } - return True; + if ((p_ret = receive_dgram_packet(sock,90,mailslot_name))) { + struct dgram_packet *dgram2 = &p_ret->packet.dgram; + char *buf; + char *buf2; + + buf = &dgram2->data[0]; + buf -= 4; + + if (CVAL(buf,smb_com) != SMBtrans) { + DEBUG(0,("lookup_dc_name: datagram type %u != SMBtrans(%u)\n", (unsigned int) + CVAL(buf,smb_com), (unsigned int)SMBtrans )); + free_packet(p_ret); + continue; + } + + len = SVAL(buf,smb_vwv11); + buf2 = smb_base(buf) + SVAL(buf,smb_vwv12); + + if (len <= 0) { + DEBUG(0,("lookup_dc_name: datagram len < 0 (%d)\n", len )); + free_packet(p_ret); + continue; + } + + DEBUG(4,("lookup_dc_name: datagram reply from %s to %s IP %s for %s of type %d len=%d\n", + nmb_namestr(&dgram2->source_name),nmb_namestr(&dgram2->dest_name), + inet_ntoa(p_ret->ip), smb_buf(buf),SVAL(buf2,0),len)); + + if(SVAL(buf2,0) != QUERYFORPDC_R) { + DEBUG(0,("lookup_dc_name: datagram type (%u) != QUERYFORPDC_R(%u)\n", + (unsigned int)SVAL(buf,0), (unsigned int)QUERYFORPDC_R )); + free_packet(p_ret); + continue; + } + + buf2 += 2; + /* Note this is safe as it is a bounded strcpy. */ + fstrcpy(ret_name, buf2); + ret_name[sizeof(fstring)-1] = '\0'; + close(sock); + free_packet(p_ret); + return True; + } + } + + close(sock); + return False; +#endif /* defined(I_HATE_WINDOWS_REPLY_CODE) */ } + /******************************************************** - Get the IP address list of the domain controllers for - a domain. + Get the IP address list of the PDC/BDC's of a Domain. *********************************************************/ -static BOOL get_dc_list(const char *domain, struct ip_service **ip_list, - int *count, BOOL ads_only, int *ordered) +BOOL get_dc_list(BOOL pdc_only, const char *group, struct in_addr **ip_list, int *count) { - fstring resolve_order; - - /* if we are restricted to solely using DNS for looking - up a domain controller, make sure that host lookups - are enabled for the 'name resolve order'. If host lookups - are disabled and ads_only is True, then set the string to - NULL. */ - - fstrcpy( resolve_order, lp_name_resolve_order() ); - strlower_m( resolve_order ); - if ( ads_only ) { - if ( strstr( resolve_order, "host" ) ) - fstrcpy( resolve_order, "ads" ); - else - fstrcpy( resolve_order, "NULL" ); - } + int name_type = pdc_only ? 0x1B : 0x1C; - - *ordered = False; - - /* If it's our domain then use the 'password server' parameter. */ + /* + * If it's our domain then + * use the 'password server' parameter. + */ - if ( strequal(domain, lp_workgroup()) || strequal(domain, lp_realm()) ) { + if (strequal(group, lp_workgroup())) { const char *p; - char *pserver = lp_passwordserver(); /* UNIX charset. */ - char *port_str; - int port; + char *pserver = lp_passwordserver(); fstring name; int num_addresses = 0; - int local_count, i, j; - struct ip_service *return_iplist = NULL; - struct ip_service *auto_ip_list = NULL; - BOOL done_auto_lookup = False; - int auto_count = 0; - + struct in_addr *return_iplist = NULL; - if (!*pserver) - return internal_resolve_name(domain, 0x1C, ip_list, count, resolve_order); + if (! *pserver) + return internal_resolve_name(group, name_type, ip_list, count); p = pserver; - - /* - * if '*' appears in the "password server" list then add - * an auto lookup to the list of manually configured - * DC's. If any DC is listed by name, then the list should be - * considered to be ordered - */ - while (next_token(&p,name,LIST_SEP,sizeof(name))) { if (strequal(name, "*")) { - if ( internal_resolve_name(domain, 0x1C, &auto_ip_list, &auto_count, resolve_order) ) - num_addresses += auto_count; - done_auto_lookup = True; - DEBUG(8,("Adding %d DC's from auto lookup\n", auto_count)); + /* + * Use 1C followed by 1B. This shouldn't work but with + * broken WINS servers it might. JRA. + */ + if (!pdc_only && internal_resolve_name(group, 0x1C, ip_list, count)) + return True; + return internal_resolve_name(group, 0x1B, ip_list, count); } - else - num_addresses++; + num_addresses++; } + if (num_addresses == 0) + return internal_resolve_name(group, name_type, ip_list, count); - /* if we have no addresses and haven't done the auto lookup, then - just return the list of DC's */ - - if ( (num_addresses == 0) && !done_auto_lookup ) - return internal_resolve_name(domain, 0x1C, ip_list, count, resolve_order); - - /* maybe we just failed? */ - - if ( num_addresses == 0 ) { - DEBUG(4,("get_dc_list: no servers found\n")); - return False; - } - - if ( (return_iplist = (struct ip_service *) - malloc(num_addresses * sizeof(struct ip_service))) == NULL ) - { + return_iplist = (struct in_addr *)malloc(num_addresses * sizeof(struct in_addr)); + if(return_iplist == NULL) { DEBUG(3,("get_dc_list: malloc fail !\n")); return False; } - p = pserver; - local_count = 0; - - /* fill in the return list now with real IP's */ - - while ( (local_count<num_addresses) && next_token(&p,name,LIST_SEP,sizeof(name)) ) { - struct in_addr name_ip; - - /* copy any addersses from the auto lookup */ - - if ( strequal(name, "*") ) { - for ( j=0; j<auto_count; j++ ) { - return_iplist[local_count].ip = auto_ip_list[j].ip; - return_iplist[local_count].port = auto_ip_list[j].port; - local_count++; - } + *count = 0; + while (next_token(&p,name,LIST_SEP,sizeof(name))) { + struct in_addr *more_ip, *tmp; + int count_more; + if (resolve_name_2( name, &more_ip, &count_more, 0x20) == False) continue; + tmp = (struct in_addr *)realloc(return_iplist,(num_addresses + count_more) * sizeof(struct in_addr)); + if (return_iplist == NULL) { + DEBUG(3, ("realloc failed with %d addresses\n", num_addresses + count_more)); + SAFE_FREE(return_iplist); + SAFE_FREE(more_ip); + return False; } - - - /* added support for address:port syntax for ads (not that I think - anyone will ever run the LDAP server in an AD domain on something - other than port 389 */ - - port = (lp_security() == SEC_ADS) ? LDAP_PORT : PORT_NONE; - if ( (port_str=strchr(name, ':')) != NULL ) { - *port_str = '\0'; - port_str++; - port = atoi( port_str ); - } - - /* explicit lookup; resolve_name() will handle names & IP addresses */ - if ( resolve_name( name, &name_ip, 0x20 ) ) { - return_iplist[local_count].ip = name_ip; - return_iplist[local_count].port = port; - local_count++; - *ordered = True; - } - } - - SAFE_FREE(auto_ip_list); - - /* need to remove duplicates in the list if we have any - explicit password servers */ - - if ( local_count ) - local_count = remove_duplicate_addrs2( return_iplist, local_count ); - - if ( DEBUGLEVEL >= 4 ) { - DEBUG(4,("get_dc_list: returning %d ip addresses in an %sordered list\n", local_count, - *ordered ? "":"un")); - DEBUG(4,("get_dc_list: ")); - for ( i=0; i<local_count; i++ ) - DEBUGADD(4,("%s:%d ", inet_ntoa(return_iplist[i].ip), return_iplist[i].port )); - DEBUGADD(4,("\n")); + return_iplist = tmp; + memmove(&return_iplist[(*count)], more_ip, count_more * sizeof(struct in_addr)); + SAFE_FREE(more_ip); /* Done with this ... */ + *count += count_more; + num_addresses += count_more - 1; } - *ip_list = return_iplist; - *count = local_count; - return (*count != 0); - } - - DEBUG(10,("get_dc_list: defaulting to internal auto lookup for domain %s\n", domain)); - - return internal_resolve_name(domain, 0x1C, ip_list, count, resolve_order); + } else + return internal_resolve_name(group, name_type, ip_list, count); } -/********************************************************************* - small wrapper function to get the DC list and sort it if neccessary -*********************************************************************/ -BOOL get_sorted_dc_list( const char *domain, struct ip_service **ip_list, int *count, BOOL ads_only ) +/******************************************************** + Get the IP address list of the Local Master Browsers +********************************************************/ + +BOOL get_lmb_list(struct in_addr **ip_list, int *count) { - BOOL ordered; - - DEBUG(8,("get_sorted_dc_list: attempting lookup using [%s]\n", - (ads_only ? "ads" : lp_name_resolve_order()))); - - if ( !get_dc_list(domain, ip_list, count, ads_only, &ordered) ) - return False; - - /* only sort if we don't already have an ordered list */ - if ( !ordered ) - sort_ip_list2( *ip_list, *count ); - - return True; + return internal_resolve_name( MSBROWSE, 0x1, ip_list, count); } - |