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