1 /*
2  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
3  * Use is subject to license terms.
4  */
5 
6 #pragma ident	"%Z%%M%	%I%	%E% SMI"
7 
8 
9 /*
10  * The contents of this file are subject to the Netscape Public
11  * License Version 1.1 (the "License"); you may not use this file
12  * except in compliance with the License. You may obtain a copy of
13  * the License at http://www.mozilla.org/NPL/
14  *
15  * Software distributed under the License is distributed on an "AS
16  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
17  * implied. See the License for the specific language governing
18  * rights and limitations under the License.
19  *
20  * The Original Code is Mozilla Communicator client code, released
21  * March 31, 1998.
22  *
23  * The Initial Developer of the Original Code is Netscape
24  * Communications Corporation. Portions created by Netscape are
25  * Copyright (C) 1998-1999 Netscape Communications Corporation. All
26  * Rights Reserved.
27  *
28  * Contributor(s):
29  */
30 
31 /*
32  * DNS callback functions for libldap that use the NSPR (Netscape
33  * Portable Runtime) thread API.
34  *
35  */
36 
37 #ifdef _SOLARIS_SDK
38 #include "solaris-int.h"
39 #include <libintl.h>
40 #include <syslog.h>
41 #include <nsswitch.h>
42 #include <synch.h>
43 #include <nss_dbdefs.h>
44 #include <netinet/in.h>
45 static char *host_service = NULL;
46 static DEFINE_NSS_DB_ROOT(db_root_hosts);
47 #endif
48 
49 #include "ldappr-int.h"
50 
51 static LDAPHostEnt *prldap_gethostbyname( const char *name,
52 	LDAPHostEnt *result, char *buffer, int buflen, int *statusp,
53 	void *extradata );
54 static LDAPHostEnt *prldap_gethostbyaddr( const char *addr, int length,
55 	int type, LDAPHostEnt *result, char *buffer, int buflen,
56 	int *statusp, void *extradata );
57 static int prldap_getpeername( LDAP *ld, struct sockaddr *addr,
58 	char *buffer, int buflen );
59 static LDAPHostEnt *prldap_convert_hostent( LDAPHostEnt *ldhp,
60 	PRHostEnt *prhp );
61 
62 #ifdef _SOLARIS_SDK
63 static LDAPHostEnt *
64 prldap_gethostbyname1(const char *name, LDAPHostEnt *result,
65 	char *buffer, int buflen, int *statusp, void *extradata);
66 extern int
67 str2hostent(const char *instr, int lenstr, void *ent, char *buffer,
68 	int buflen);
69 #endif /* _SOLARIS_SDK */
70 
71 
72 /*
73  * Install NSPR DNS functions into ld (if ld is NULL, they are installed
74  * as the default functions for new LDAP * handles).
75  *
76  * Returns 0 if all goes well and -1 if not.
77  */
78 int
prldap_install_dns_functions(LDAP * ld)79 prldap_install_dns_functions( LDAP *ld )
80 {
81     struct ldap_dns_fns			dnsfns;
82 
83     memset( &dnsfns, '\0', sizeof(struct ldap_dns_fns) );
84     dnsfns.lddnsfn_bufsize = PR_NETDB_BUF_SIZE;
85     dnsfns.lddnsfn_gethostbyname = prldap_gethostbyname;
86     dnsfns.lddnsfn_gethostbyaddr = prldap_gethostbyaddr;
87 	    dnsfns.lddnsfn_getpeername = prldap_getpeername;
88 	    if ( ldap_set_option( ld, LDAP_OPT_DNS_FN_PTRS, (void *)&dnsfns ) != 0 ) {
89 		return( -1 );
90 	    }
91 
92     return( 0 );
93 }
94 
95 
96 static LDAPHostEnt *
prldap_gethostbyname(const char * name,LDAPHostEnt * result,char * buffer,int buflen,int * statusp,void * extradata)97 prldap_gethostbyname( const char *name, LDAPHostEnt *result,
98 	char *buffer, int buflen, int *statusp, void *extradata )
99 {
100 	PRHostEnt	prhent;
101 
102 	if( !statusp || ( *statusp = (int)PR_GetIPNodeByName( name,
103 		PRLDAP_DEFAULT_ADDRESS_FAMILY, PR_AI_DEFAULT,
104 		buffer, buflen, &prhent )) == PR_FAILURE ) {
105 		return( NULL );
106 	}
107 
108 	return( prldap_convert_hostent( result, &prhent ));
109 }
110 
111 
112 static LDAPHostEnt *
prldap_gethostbyaddr(const char * addr,int length,int type,LDAPHostEnt * result,char * buffer,int buflen,int * statusp,void * extradata)113 prldap_gethostbyaddr( const char *addr, int length, int type,
114 	LDAPHostEnt *result, char *buffer, int buflen, int *statusp,
115 	void *extradata )
116 {
117     PRHostEnt	prhent;
118     PRNetAddr	iaddr;
119 
120 	if ( PR_SetNetAddr(PR_IpAddrNull, PRLDAP_DEFAULT_ADDRESS_FAMILY,
121 		0, &iaddr) == PR_FAILURE
122  		|| PR_StringToNetAddr( addr, &iaddr ) == PR_FAILURE ) {
123 		return( NULL );
124 	}
125 
126     if( !statusp || (*statusp = PR_GetHostByAddr(&iaddr, buffer,
127 	     buflen, &prhent )) == PR_FAILURE ) {
128 	return( NULL );
129     }
130     return( prldap_convert_hostent( result, &prhent ));
131 }
132 
133 static int
prldap_getpeername(LDAP * ld,struct sockaddr * addr,char * buffer,int buflen)134 prldap_getpeername( LDAP *ld, struct sockaddr *addr, char *buffer, int buflen)
135 {
136     PRLDAPIOSocketArg *sa;
137     PRFileDesc	*fd;
138     PRNetAddr	iaddr;
139     int		ret;
140 
141     if (NULL != ld) {
142 	    ret = prldap_socket_arg_from_ld( ld, &sa );
143 	    if (ret != LDAP_SUCCESS) {
144 		return (-1);
145 	    }
146 	    ret = PR_GetPeerName(sa->prsock_prfd, &iaddr);
147 	    if( ret == PR_FAILURE ) {
148 		return( -1 );
149 	    }
150 	    *addr = *((struct sockaddr *)&iaddr.raw);
151 	    ret = PR_NetAddrToString(&iaddr, buffer, buflen);
152 	    if( ret == PR_FAILURE ) {
153 		return( -1 );
154 	    }
155 	    return (0);
156     }
157     return (-1);
158 }
159 
160 
161 /*
162  * Function: prldap_convert_hostent()
163  * Description: copy the fields of a PRHostEnt struct to an LDAPHostEnt
164  * Returns: the LDAPHostEnt pointer passed in.
165  */
166 static LDAPHostEnt *
prldap_convert_hostent(LDAPHostEnt * ldhp,PRHostEnt * prhp)167 prldap_convert_hostent( LDAPHostEnt *ldhp, PRHostEnt *prhp )
168 {
169 	ldhp->ldaphe_name = prhp->h_name;
170 	ldhp->ldaphe_aliases = prhp->h_aliases;
171 	ldhp->ldaphe_addrtype = prhp->h_addrtype;
172 	ldhp->ldaphe_length =  prhp->h_length;
173 	ldhp->ldaphe_addr_list =  prhp->h_addr_list;
174 	return( ldhp );
175 }
176 
177 #ifdef _SOLARIS_SDK
178 /*
179  * prldap_x_install_dns_skipdb attempts to prevent recursion in resolving
180  * the hostname to an IP address when a host name is given to LDAP user.
181  *
182  * For example, libsldap cannot use LDAP to resolve the host name to an
183  * address because of recursion. The caller is instructing libldap to skip
184  * the specified name service when resolving addresses for the specified
185  * ldap connection.
186  *
187  * Note:
188  *      This only supports ipv4 addresses currently.
189  *
190  *      Since host_service applies to all connections, calling
191  *      prldap_x_install_dns_skipdb with name services other than
192  *      ldap or what uses ldap (for example nis+ might use ldap) to
193  *      skip will lead to unpredictable results.
194  *
195  * Returns:
196  *      0       if success and data base found
197  *      -1      if failure
198  */
199 
200 int
prldap_x_install_dns_skipdb(LDAP * ld,const char * skip)201 prldap_x_install_dns_skipdb(LDAP *ld, const char *skip)
202 {
203 	enum __nsw_parse_err		pserr;
204 	struct __nsw_switchconfig       *conf;
205 	struct __nsw_lookup             *lkp;
206 	struct ldap_dns_fns             dns_fns;
207 	char                            *name_list = NULL;
208 	char                            *tmp;
209 	const char                      *name;
210 	int                             len;
211 	boolean_t                       got_skip = B_FALSE;
212 
213 	/*
214 	 * db_root_hosts.lock mutex is used to ensure that the name list
215 	 * is not in use by the name service switch while we are updating
216 	 * the host_service
217 	 */
218 
219         (void) mutex_lock(&db_root_hosts.lock);
220         conf = __nsw_getconfig("hosts", &pserr);
221         if (conf == NULL) {
222                 (void) mutex_unlock(&db_root_hosts.lock);
223                 return (0);
224         }
225 
226         /* check for skip and count other backends */
227         for (lkp = conf->lookups; lkp != NULL; lkp = lkp->next) {
228                 name = lkp->service_name;
229                 if (strcmp(name, skip) == 0) {
230                         got_skip = B_TRUE;
231                         continue;
232                 }
233                 if (name_list == NULL)
234                         name_list = strdup(name);
235                 else {
236                         len = strlen(name_list);
237                         tmp = realloc(name_list, len + strlen(name) + 2);
238                         if (tmp == NULL) {
239                                 free(name_list);
240                                 name_list = NULL;
241                         } else {
242                                 name_list = tmp;
243                                 name_list[len++] = ' ';
244                                 (void) strcpy(name_list+len, name);
245                         }
246                 }
247                 if (name_list == NULL) {        /* alloc error */
248                         (void) mutex_unlock(&db_root_hosts.lock);
249                         __nsw_freeconfig(conf);
250                         return (-1);
251                 }
252         }
253         __nsw_freeconfig(conf);
254         if (!got_skip) {
255 		/*
256 		 * Since skip name service not used for hosts, we do not need
257 		 * to install our private address resolution function
258 		 */
259                 (void) mutex_unlock(&db_root_hosts.lock);
260                 if (name_list != NULL)
261                         free(name_list);
262                 return (0);
263         }
264         if (host_service != NULL)
265                 free(host_service);
266         host_service = name_list;
267         (void) mutex_unlock(&db_root_hosts.lock);
268 
269         if (ldap_get_option(ld, LDAP_OPT_DNS_FN_PTRS, &dns_fns) != 0)
270                 return (-1);
271         dns_fns.lddnsfn_bufsize = PR_NETDB_BUF_SIZE;
272         dns_fns.lddnsfn_gethostbyname = prldap_gethostbyname1;
273         if (ldap_set_option(ld, LDAP_OPT_DNS_FN_PTRS, &dns_fns) != 0)
274                 return (-1);
275         return (0);
276 }
277 
278 /*
279  * prldap_initf_hosts is passed to and called by nss_search() as a
280  * service routine.
281  *
282  * Returns:
283  *      None
284  */
285 
286 static void
prldap_initf_hosts(nss_db_params_t * p)287 prldap_initf_hosts(nss_db_params_t *p)
288 {
289         static char *no_service = "";
290 
291         p->name = NSS_DBNAM_HOSTS;
292         p->flags |= NSS_USE_DEFAULT_CONFIG;
293         p->default_config = host_service == NULL ? no_service : host_service;
294 }
295 
296 /*
297  * called by prldap_gethostbyname1()
298  */
299 /*
300  * prldap_switch_gethostbyname_r is called by prldap_gethostbyname1 as a
301  * substitute for gethostbyname_r(). A method which prevents recursion. see
302  * prldap_gethostbyname1() and prldap_x_install_dns_skipdb().
303  *
304  * Returns:
305  *      PR_SUCCESS                    if success
306  *      PR_FAILURE                    if failure
307  */
308 
309 static int
prldap_switch_gethostbyname_r(const char * name,struct hostent * result,char * buffer,int buflen,int * h_errnop)310 prldap_switch_gethostbyname_r(const char *name,
311         struct hostent *result, char *buffer, int buflen,
312         int *h_errnop)
313 {
314         nss_XbyY_args_t arg;
315         nss_status_t    res;
316 	struct hostent	*resp;
317 
318 	/*
319 	 * Log the information indicating that we are trying to
320 	 * resolve the LDAP server name.
321 	 */
322 	syslog(LOG_INFO, "libldap: Resolving server name \"%s\"", name);
323 
324         NSS_XbyY_INIT(&arg, result, buffer, buflen, str2hostent);
325 
326         arg.key.name = name;
327         arg.stayopen = 0;
328 
329         res = nss_search(&db_root_hosts, prldap_initf_hosts,
330             NSS_DBOP_HOSTS_BYNAME, &arg);
331         arg.status = res;
332         *h_errnop = arg.h_errno;
333 	resp = (struct hostent *)NSS_XbyY_FINI(&arg);
334 
335 	return (resp != NULL ? PR_SUCCESS : PR_FAILURE);
336 }
337 
338 /*
339  * prldap_gethostbyname1 is used to be a substitute gethostbyname_r for
340  * libldap when it is unsafe to use the normal nameservice functions.
341  *
342  * Returns:
343  *      pointer to LDAPHostEnt:         if success contains the address
344  *      NULL pointer:                   if failure
345  */
346 
347 static LDAPHostEnt *
prldap_gethostbyname1(const char * name,LDAPHostEnt * result,char * buffer,int buflen,int * statusp,void * extradata)348 prldap_gethostbyname1(const char *name, LDAPHostEnt *result,
349 	char *buffer, int buflen, int *statusp, void *extradata)
350 {
351         int         h_errno;
352 	LDAPHostEnt prhent;
353 
354 	memset(&prhent, '\0', sizeof (prhent));
355         if (!statusp || ( *statusp = prldap_switch_gethostbyname_r(name,
356                         &prhent, buffer, buflen, &h_errno )) == PR_FAILURE) {
357 		/*
358 		 * If we got here, it means that we are not able to
359 		 * resolve the LDAP server name and so warn the system
360 		 * adminstrator accordingly.
361 		 */
362 		syslog(LOG_WARNING, "libldap: server name \"%s\" could not "
363 		"be resolved", name);
364 		return (NULL);
365         }
366 
367         return (prldap_convert_hostent(result, &prhent));
368 }
369 
370 #endif  /* _SOLARIS_SDK */
371