/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 1992 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #pragma ident "%Z%%M% %I% %E% SMI" #include #include #include #include #include #include #include #include #include "yp_prot.h" #include "ypv1_prot.h" #include "ypclnt.h" /* * This is the same as struct dom_binding used by the base __yp_dobind(). * Named differently here to avoid name conflict with the compat * struct dom_binding. */ /* Copied from base */ struct netconfig { char *nc_netid; /* network identifier */ unsigned long nc_semantics; /* defined below */ unsigned long nc_flag; /* defined below */ char *nc_protofmly; /* protocol family name */ char *nc_proto; /* protocol name */ char *nc_device; /* device name for network id */ unsigned long nc_nlookups; /* # of entries in nc_lookups */ char **nc_lookups; /* list of lookup directories */ unsigned long nc_unused[8]; }; /* Copied from base */ struct netbuf { unsigned int maxlen; unsigned int len; char *buf; }; struct s5_dom_binding { struct s5_dom_binding *dom_next; char *dom_domain; struct s5_ypbind_binding *dom_binding; CLIENT *dom_client; }; struct s5_ypbind_binding { struct netconfig *ypbind_conf; struct netbuf *ypbind_svcaddr; char *ypbind_servername; long ypbind_hi_vers; long ypbind_lo_vers; }; static void _yp_unbind(); static struct dom_binding *load_dom_binding_cache(); static struct dom_binding *bound_domains; /* List of bound domains */ /* * This is a "wrapper" function that is implemented by the yp_bind() * function in base libnsl/yp. */ #ifdef NOTDEFINED int yp_bind(domain) char *domain; { /* XXX */ _yp_bind(domain); } #endif /* * Attempts to find a dom_binding in the list at bound_domains having the * domain name field equal to the passed domain name, and removes it if found. * The domain-server binding will not exist after the call to this function. * All resources associated with the binding will be freed. */ #ifdef NOTDEFINED void yp_unbind (domain) char *domain; { _yp_unbind(domain); /* clean our local cache */ /* XXX */ _yp_unbind(domain); } #endif /* * This is a wrapper around the yp_get_default_domain() * function in base libnsl/yp. */ #ifdef NOTDEFINED int yp_get_default_domain(domain) char **domain; { /* XXX */ _yp_get_default_domain(domain); } #endif /* * Attempts to locate a NIS server that serves a passed domain. * This is a wrapper around the __yp_dobind() function in base * libnsl/yp; it converts the libnsl [netbuf based] dom_binding structure into * the [sockaddr based] one that is expected by binary compat apps. Note that, * the wrapper must allocate memory resources in order to hold * the */ int _yp_dobind(domain, binding) char *domain; struct dom_binding **binding; /* if result == 0, ptr to dom_binding */ { int retval; struct s5_dom_binding *dom_binding; /* Ptr to dom_binding from libnsl __yp_dobind() */ int status; /* XXX */ retval = __yp_dobind(domain, &dom_binding); if (retval != 0) return(retval); if ((*binding = load_dom_binding_cache(domain, dom_binding)) == NULL) return (YPERR_RESRC); /* make sure it is in our cache */ return (0); /* This is the go path */ } /* * This allocates some memory for a domain binding, initialize it, and * returns a pointer to it. Based on the program version we ended up * talking to ypbind with, fill out an opvector of appropriate protocol * modules. */ static struct dom_binding * load_dom_binding_cache(domain, dom_binding) char *domain; struct s5_dom_binding *dom_binding; { struct dom_binding *pdomb = NULL; struct sockaddr_in *sa; /* To get a port bound to socket */ struct sockaddr_in local_name; int local_name_len = sizeof(struct sockaddr_in); for (pdomb = bound_domains; pdomb != NULL; pdomb = pdomb->dom_pnext) { if (strcmp(domain, pdomb->dom_domain) == 0) return (pdomb); } if ((pdomb = (struct dom_binding *) malloc(sizeof(struct dom_binding))) == NULL) { (void) syslog(LOG_ERR, "load_dom_binding_cache: malloc failure."); return (struct dom_binding *) (NULL); } sa = (struct sockaddr_in *)dom_binding->dom_binding->ypbind_svcaddr->buf; pdomb->dom_server_addr.sin_family = sa->sin_family; pdomb->dom_server_addr.sin_port = sa->sin_port; pdomb->dom_server_addr.sin_addr.s_addr = sa->sin_addr.s_addr; bzero(pdomb->dom_server_addr.sin_zero, 8); pdomb->dom_server_port = sa->sin_port; pdomb->dom_socket = RPC_ANYSOCK; pdomb->dom_vers = dom_binding->dom_binding->ypbind_hi_vers; /* the claim is 5.0 CLIENT * can be used by a 4.x RPC user */ pdomb->dom_client = dom_binding->dom_client; (void) strcpy(pdomb->dom_domain, domain);/* Remember the domain name */ pdomb->dom_pnext = bound_domains; /* Link this to the list as */ bound_domains = pdomb; /* ... the head entry */ return (pdomb); } static void _yp_unbind (domain) char *domain; { struct dom_binding *pdomb; struct dom_binding *ptrail = 0; if ( (domain == NULL) ||(strlen(domain) == 0) ) { return; } for (pdomb = bound_domains; pdomb != NULL; ptrail = pdomb, pdomb = pdomb->dom_pnext) { if (strcmp(domain, pdomb->dom_domain) == 0) { if (pdomb == bound_domains) bound_domains = pdomb->dom_pnext; else ptrail->dom_pnext = pdomb->dom_pnext; free((char *) pdomb); break; } } } int yp_ismapthere(stat) int stat; { switch (stat) { case 0: /* it actually succeeded! */ case YPERR_KEY: /* no such key in map */ case YPERR_NOMORE: case YPERR_BUSY: return (TRUE); } return (FALSE); }