xref: /titanic_41/usr/src/lib/libtsnet/common/tsol_getrhent.c (revision 909c1a3310e6a348a85950c7179fefda50d0e37d)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  *
25  * From "tsol_getrhent.c	7.6	00/09/22 SMI; TSOL 2.x"
26  */
27 
28 #pragma ident	"%Z%%M%	%I%	%E% SMI"
29 
30 #include <stdio.h>
31 #include <nss_dbdefs.h>
32 #include <libtsnet.h>
33 #include <sys/types.h>
34 #include <sys/socket.h>
35 #include <netinet/in.h>
36 #include <arpa/inet.h>
37 #include <string.h>
38 #include <secdb.h>
39 #include <nss.h>
40 #include <libtsnet.h>
41 #include <libintl.h>
42 
43 extern void _nss_XbyY_fgets(FILE *, nss_XbyY_args_t *);	/* from lib.c */
44 
45 static int tsol_rh_stayopen;	/* Unsynchronized, but it affects only	*/
46 				/*   efficiency, not correctness	*/
47 static DEFINE_NSS_DB_ROOT(db_root);
48 static DEFINE_NSS_GETENT(context);
49 
50 static void
_nss_initf_tsol_rh(nss_db_params_t * p)51 _nss_initf_tsol_rh(nss_db_params_t *p)
52 {
53 	p->name	= NSS_DBNAM_TSOL_RH;
54 	p->default_config = NSS_DEFCONF_TSOL_RH;
55 }
56 
57 tsol_rhent_t *
tsol_getrhbyaddr(const void * addrp,size_t len,int af)58 tsol_getrhbyaddr(const void *addrp, size_t len, int af)
59 {
60 	int		err = 0;
61 	char		*errstr = NULL;
62 	char		buf[NSS_BUFLEN_TSOL_RH];
63 	tsol_rhstr_t	result;
64 	tsol_rhstr_t	*rhstrp = NULL;
65 	nss_XbyY_args_t arg;
66 
67 	NSS_XbyY_INIT(&arg, &result, buf, sizeof (buf), str_to_rhstr);
68 
69 	arg.key.hostaddr.addr = (const char *)addrp;
70 	arg.key.hostaddr.len = len;
71 	arg.key.hostaddr.type = af;
72 	arg.stayopen = tsol_rh_stayopen;
73 	arg.h_errno = TSOL_NOT_FOUND;
74 	arg.status = nss_search(&db_root, _nss_initf_tsol_rh,
75 	    NSS_DBOP_TSOL_RH_BYADDR, &arg);
76 	rhstrp = (tsol_rhstr_t *)NSS_XbyY_FINI(&arg);
77 
78 #ifdef	DEBUG
79 	(void) fprintf(stdout, "tsol_getrhbyaddr %s: %s\n",
80 	    (char *)addrp, rhstrp ? rhstrp->template : "NULL");
81 #endif	/* DEBUG */
82 
83 	if (rhstrp == NULL)
84 		return (NULL);
85 
86 	return (rhstr_to_ent(rhstrp, &err, &errstr));
87 }
88 
89 void
tsol_setrhent(int stay)90 tsol_setrhent(int stay)
91 {
92 	tsol_rh_stayopen |= stay;
93 	nss_setent(&db_root, _nss_initf_tsol_rh, &context);
94 }
95 
96 void
tsol_endrhent(void)97 tsol_endrhent(void)
98 {
99 	tsol_rh_stayopen = 0;
100 	nss_endent(&db_root, _nss_initf_tsol_rh, &context);
101 	nss_delete(&db_root);
102 }
103 
104 tsol_rhent_t *
tsol_getrhent(void)105 tsol_getrhent(void)
106 {
107 	int			err = 0;
108 	char			*errstr = NULL;
109 	char			buf[NSS_BUFLEN_TSOL_RH];
110 	tsol_rhstr_t		result;
111 	tsol_rhstr_t		*rhstrp = NULL;
112 	nss_XbyY_args_t		arg;
113 
114 	NSS_XbyY_INIT(&arg, &result, buf, sizeof (buf), str_to_rhstr);
115 	/* No key, no stayopen */
116 	arg.status = nss_getent(&db_root, _nss_initf_tsol_rh, &context, &arg);
117 	rhstrp = (tsol_rhstr_t *)NSS_XbyY_FINI(&arg);
118 
119 #ifdef	DEBUG
120 	(void) fprintf(stdout, "tsol_getrhent: %s\n",
121 	    rhstrp ? rhstrp->template : "NULL");
122 #endif	/* DEBUG */
123 
124 	if (rhstrp == NULL)
125 		return (NULL);
126 
127 	return (rhstr_to_ent(rhstrp, &err, &errstr));
128 }
129 
130 tsol_rhent_t *
tsol_fgetrhent(FILE * f,boolean_t * error)131 tsol_fgetrhent(FILE *f, boolean_t *error)
132 {
133 	int		err = 0;
134 	char		*errstr = NULL;
135 	char		buf[NSS_BUFLEN_TSOL_RH];
136 	tsol_rhstr_t	result;
137 	tsol_rhstr_t	*rhstrp = NULL;
138 	tsol_rhent_t	*rhentp = NULL;
139 	nss_XbyY_args_t	arg;
140 
141 	NSS_XbyY_INIT(&arg, &result, buf, sizeof (buf), str_to_rhstr);
142 	_nss_XbyY_fgets(f, &arg);
143 	rhstrp = (tsol_rhstr_t *)NSS_XbyY_FINI(&arg);
144 	if (rhstrp == NULL)
145 		return (NULL);
146 	rhentp = rhstr_to_ent(rhstrp, &err, &errstr);
147 	while (rhentp == NULL) {
148 		/*
149 		 * Loop until we find a non-blank, non-comment line, or
150 		 * until EOF. No need to log blank lines, comments.
151 		 */
152 		if (err != LTSNET_EMPTY) {
153 			(void) fprintf(stderr, "%s: %.32s%s: %s\n",
154 			    gettext("Error parsing tnrhdb file"), errstr,
155 			    (strlen(errstr) > 32)? "...": "",
156 			    (char *)tsol_strerror(err, errno));
157 			*error = B_TRUE;
158 		}
159 		_nss_XbyY_fgets(f, &arg);
160 		rhstrp = (tsol_rhstr_t *)NSS_XbyY_FINI(&arg);
161 		if (rhstrp == NULL)	/* EOF */
162 			return (NULL);
163 		rhentp = rhstr_to_ent(rhstrp, &err, &errstr);
164 	}
165 	return (rhentp);
166 }
167 
168 /*
169  * This is the callback routine for nss.
170  */
171 int
str_to_rhstr(const char * instr,int lenstr,void * entp,char * buffer,int buflen)172 str_to_rhstr(const char *instr, int lenstr, void *entp, char *buffer,
173     int buflen)
174 {
175 	int		len;
176 	char		*str = NULL;
177 	char		*last = NULL;
178 	char		*sep = KV_TOKEN_DELIMIT;
179 	tsol_rhstr_t	*rhstrp = (tsol_rhstr_t *)entp;
180 
181 	if ((instr >= buffer && (buffer + buflen) > instr) ||
182 	    (buffer >= instr && (instr + lenstr) > buffer))
183 		return (NSS_STR_PARSE_PARSE);
184 	if (lenstr >= buflen)
185 		return (NSS_STR_PARSE_ERANGE);
186 	(void) strncpy(buffer, instr, buflen);
187 	str = _strtok_escape(buffer, sep, &last);
188 	rhstrp->address = _do_unescape(str);
189 	/*
190 	 * _do_unesape uses isspace() which removes "\n".
191 	 * we keep "\n" as we use it in checking for
192 	 * blank lines.
193 	 */
194 	if (strcmp(instr, "\n") == 0)
195 		rhstrp->address = "\n";
196 	rhstrp->template = _strtok_escape(NULL, sep, &last);
197 	if (rhstrp->template != NULL) {
198 		len = strlen(rhstrp->template);
199 		if (rhstrp->template[len - 1] == '\n')
200 			rhstrp->template[len - 1] = '\0';
201 	}
202 	if (rhstrp->address == NULL)
203 		rhstrp->family = 0;
204 	else if (strchr(rhstrp->address, ':') == NULL)
205 		rhstrp->family = AF_INET;
206 	else
207 		rhstrp->family = AF_INET6;
208 
209 #ifdef	DEBUG
210 	(void) fprintf(stdout,
211 	    "str_to_rhstr:str - %s\taddress - %s\n\ttemplate - %s\n",
212 	    instr, rhstrp->address ? rhstrp->address : "NULL",
213 	    rhstrp->template ? rhstrp->template : "NULL");
214 #endif	/* DEBUG */
215 
216 	return (NSS_STR_PARSE_SUCCESS);
217 }
218 
219 tsol_host_type_t
tsol_getrhtype(char * rhost)220 tsol_getrhtype(char *rhost) {
221 	int herr;
222 	struct hostent *hp;
223 	in6_addr_t in6;
224 	char abuf[INET6_ADDRSTRLEN];
225 	tsol_rhent_t rhent;
226 	tsol_tpent_t tp;
227 
228 	if ((hp = getipnodebyname(rhost, AF_INET6,
229 	    AI_ALL | AI_ADDRCONFIG | AI_V4MAPPED, &herr)) == NULL) {
230 		return (UNLABELED);
231 	}
232 
233 	(void) memset(&rhent, 0, sizeof (rhent));
234 	(void) memcpy(&in6, hp->h_addr, hp->h_length);
235 
236 	if (IN6_IS_ADDR_V4MAPPED(&in6)) {
237 		rhent.rh_address.ta_family = AF_INET;
238 		IN6_V4MAPPED_TO_INADDR(&in6, &rhent.rh_address.ta_addr_v4);
239 		(void) inet_ntop(AF_INET, &rhent.rh_address.ta_addr_v4, abuf,
240 		    sizeof (abuf));
241 	} else {
242 		rhent.rh_address.ta_family = AF_INET6;
243 		rhent.rh_address.ta_addr_v6 = in6;
244 		(void) inet_ntop(AF_INET6, &in6, abuf, sizeof (abuf));
245 	}
246 
247 	if (tnrh(TNDB_GET, &rhent) != 0)
248 		return (UNLABELED);
249 
250 	if (rhent.rh_template[0] == '\0')
251 		return (UNLABELED);
252 
253 	(void) strlcpy(tp.name, rhent.rh_template, sizeof (tp.name));
254 
255 	if (tnrhtp(TNDB_GET, &tp) != 0)
256 		return (UNLABELED);
257 
258 	return (tp.host_type);
259 }
260