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 * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
22 * Use is subject to license terms.
23 */
24
25 /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
26 /* All Rights Reserved */
27
28 /*
29 * Portions of this source code were derived from Berkeley
30 * under license from the Regents of the University of
31 * California.
32 */
33
34 #pragma ident "%Z%%M% %I% %E% SMI"
35
36 #include <sys/types.h>
37 #include <sys/file.h>
38 #include <stdlib.h>
39 #include <ctype.h>
40 #include <string.h>
41 #include <tiuser.h>
42 #include <netinet/in.h>
43 #include <arpa/inet.h>
44 #include <sys/socket.h>
45 #include <netdir.h>
46 #include <netdb.h>
47 #include <rpc/rpc.h>
48 #include <rpc/pmap_clnt.h>
49 #include <rpcsvc/nis.h>
50
51 CLIENT *__clnt_tp_create_bootstrap();
52 int __rpcb_getaddr_bootstrap();
53 struct hostent *__files_gethostbyname(char *, sa_family_t);
54
55 extern int hostNotKnownLocally;
56
57 static char *__map_addr();
58 static struct hostent host;
59 static char hostaddr[sizeof (struct in6_addr)];
60 static char *host_aliases[MAXALIASES];
61 static char *host_addrs[] = {
62 hostaddr,
63 NULL
64 };
65
66 /*
67 * __clnt_tp_create_bootstrap()
68 *
69 * This routine is NOT TRANSPORT INDEPENDENT.
70 *
71 * It relies on the local /etc/hosts file for hostname to address
72 * translation and does it itself instead of calling netdir_getbyname
73 * thereby avoids recursion. Secondarily, it will use a validated
74 * IP address directly.
75 */
76 CLIENT *
__clnt_tp_create_bootstrap(hostname,prog,vers,nconf)77 __clnt_tp_create_bootstrap(hostname, prog, vers, nconf)
78 char *hostname;
79 ulong_t prog, vers;
80 struct netconfig *nconf;
81 {
82 CLIENT *cl;
83 struct netbuf *svc_taddr;
84 struct sockaddr_in6 *sa;
85 int fd;
86
87 if (nconf == (struct netconfig *)NULL) {
88 rpc_createerr.cf_stat = RPC_N2AXLATEFAILURE;
89 return (NULL);
90 }
91 if ((fd = t_open(nconf->nc_device, O_RDWR, NULL)) == -1) {
92 rpc_createerr.cf_stat = RPC_TLIERROR;
93 return (NULL);
94 }
95 svc_taddr = (struct netbuf *)malloc(sizeof (struct netbuf));
96 if (! svc_taddr) {
97 rpc_createerr.cf_stat = RPC_SYSTEMERROR;
98 t_close(fd);
99 return (NULL);
100 }
101 sa = (struct sockaddr_in6 *)calloc(1, sizeof (*sa));
102 if (! sa) {
103 rpc_createerr.cf_stat = RPC_SYSTEMERROR;
104 t_close(fd);
105 free(svc_taddr);
106 return (NULL);
107 }
108 svc_taddr->maxlen = svc_taddr->len = sizeof (*sa);
109 svc_taddr->buf = (char *)sa;
110 if (__rpcb_getaddr_bootstrap(prog,
111 vers, nconf, svc_taddr, hostname) == FALSE) {
112 t_close(fd);
113 free(svc_taddr);
114 free(sa);
115 return (NULL);
116 }
117 rpc_createerr.cf_stat = RPC_SUCCESS;
118 cl = __nis_clnt_create(fd, nconf, 0, svc_taddr, 0, prog, vers, 0, 0);
119 if (cl == 0) {
120 if (rpc_createerr.cf_stat == RPC_SUCCESS)
121 rpc_createerr.cf_stat = RPC_TLIERROR;
122 t_close(fd);
123 }
124 free(svc_taddr);
125 free(sa);
126 return (cl);
127 }
128
129 /*
130 * __rpcb_getaddr_bootstrap()
131 *
132 * This is our internal function that replaces rpcb_getaddr(). We
133 * build our own to prevent calling netdir_getbyname() which could
134 * recurse to the nameservice.
135 */
136 int
__rpcb_getaddr_bootstrap(program,version,nconf,address,hostname)137 __rpcb_getaddr_bootstrap(program, version, nconf, address, hostname)
138 ulong_t program;
139 ulong_t version;
140 struct netconfig *nconf;
141 struct netbuf *address; /* populate with the taddr of the service */
142 char *hostname;
143 {
144 char *svc_uaddr;
145 struct hostent *hent, tmphent;
146 struct sockaddr_in *sa;
147 struct sockaddr_in6 *sa6;
148 struct netbuf rpcb_taddr;
149 struct sockaddr_in local_sa;
150 struct sockaddr_in6 local_sa6;
151 in_port_t inport;
152 int p1, p2;
153 char *ipaddr, *port;
154 int i, ipaddrlen;
155 sa_family_t type;
156 char addr[sizeof (in6_addr_t)];
157 char *tmphost_addrs[2];
158
159 if (strcmp(nconf->nc_protofmly, NC_INET6) == 0) {
160 type = AF_INET6;
161 } else if (strcmp(nconf->nc_protofmly, NC_INET) == 0) {
162 type = AF_INET;
163 } else {
164 rpc_createerr.cf_stat = RPC_UNKNOWNADDR;
165 return (FALSE);
166 }
167
168 /* Get the address of the RPCBIND at hostname */
169 hent = __files_gethostbyname(hostname, type);
170 if (hent == (struct hostent *)NULL) {
171 /* Make sure this is not an IP address before giving up */
172 if (inet_pton(type, hostname, addr) == 1) {
173 /* This is a numeric address, fill in the blanks */
174 hent = &tmphent;
175 memset(&tmphent, 0, sizeof (struct hostent));
176 hent->h_addrtype = type;
177 hent->h_length = (type == AF_INET6) ?
178 sizeof (in6_addr_t) : sizeof (in_addr_t);
179 hent->h_addr_list = tmphost_addrs;
180 tmphost_addrs[0] = addr;
181 tmphost_addrs[1] = NULL;
182 } else {
183 rpc_createerr.cf_stat = RPC_UNKNOWNHOST;
184 hostNotKnownLocally = 1;
185 return (FALSE);
186 }
187 }
188
189 switch (hent->h_addrtype) {
190 case AF_INET:
191 local_sa.sin_family = AF_INET;
192 local_sa.sin_port = htons(111); /* RPCBIND port */
193 memcpy((char *)&(local_sa.sin_addr.s_addr),
194 hent->h_addr_list[0], hent->h_length);
195 rpcb_taddr.buf = (char *)&local_sa;
196 rpcb_taddr.maxlen = sizeof (local_sa);
197 rpcb_taddr.len = rpcb_taddr.maxlen;
198 break;
199 case AF_INET6:
200 local_sa6.sin6_family = AF_INET6;
201 local_sa6.sin6_port = htons(111); /* RPCBIND port */
202 memcpy((char *)&(local_sa6.sin6_addr.s6_addr),
203 hent->h_addr_list[0], hent->h_length);
204 rpcb_taddr.buf = (char *)&local_sa6;
205 rpcb_taddr.maxlen = sizeof (local_sa6);
206 rpcb_taddr.len = rpcb_taddr.maxlen;
207 break;
208 default:
209 rpc_createerr.cf_stat = RPC_N2AXLATEFAILURE;
210 return (FALSE);
211 }
212
213 svc_uaddr = __map_addr(nconf, &rpcb_taddr, program, version);
214 if (! svc_uaddr)
215 return (FALSE);
216
217 /* do a local uaddr2taddr and stuff in the memory supplied by the caller */
218 ipaddr = svc_uaddr;
219 ipaddrlen = strlen(ipaddr);
220 /* Look for the first '.' starting from the end */
221 for (i = ipaddrlen-1; i >= 0; i--)
222 if (ipaddr[i] == '.')
223 break;
224 /* Find the second dot (still counting from the end) */
225 for (i--; i >= 0; i--)
226 if (ipaddr[i] == '.')
227 break;
228 /* If we didn't find it, the uaddr has a syntax error */
229 if (i < 0) {
230 rpc_createerr.cf_stat = RPC_N2AXLATEFAILURE;
231 return (FALSE);
232 }
233 port = &ipaddr[i+1];
234 ipaddr[i] = '\0';
235 sscanf(port, "%d.%d", &p1, &p2);
236 inport = (p1 << 8) + p2;
237 if (hent->h_addrtype == AF_INET) {
238 sa = (struct sockaddr_in *)address->buf;
239 address->len = sizeof (*sa);
240 if (inet_pton(AF_INET, ipaddr, &sa->sin_addr) != 1) {
241 rpc_createerr.cf_stat = RPC_N2AXLATEFAILURE;
242 return (FALSE);
243 }
244 sa->sin_port = htons(inport);
245 sa->sin_family = AF_INET;
246 } else {
247 sa6 = (struct sockaddr_in6 *)address->buf;
248 address->len = sizeof (*sa6);
249 if (inet_pton(AF_INET6, ipaddr, &sa6->sin6_addr) != 1) {
250 rpc_createerr.cf_stat = RPC_N2AXLATEFAILURE;
251 return (FALSE);
252 }
253 sa6->sin6_port = htons(inport);
254 sa6->sin6_family = AF_INET6;
255 }
256 return (TRUE);
257 }
258
259 /*
260 * __map_addr()
261 *
262 */
263 static char *
__map_addr(nc,rpcb_taddr,prog,ver)264 __map_addr(nc, rpcb_taddr, prog, ver)
265 struct netconfig *nc; /* Our transport */
266 struct netbuf *rpcb_taddr; /* RPCBIND address */
267 ulong_t prog, ver; /* Name service Prog/vers */
268 {
269 register CLIENT *client;
270 RPCB parms; /* Parameters for RPC binder */
271 enum clnt_stat clnt_st; /* Result from the rpc call */
272 int fd; /* Stream file descriptor */
273 char *ua = NULL; /* Universal address of service */
274 struct timeval tv; /* Timeout for our rpcb call */
275
276 /*
277 * First we open a connection to the remote rpcbind process.
278 */
279 if ((fd = t_open(nc->nc_device, O_RDWR, NULL)) == -1) {
280 rpc_createerr.cf_stat = RPC_TLIERROR;
281 return (NULL);
282 }
283
284 client = __nis_clnt_create(fd, nc, 0, rpcb_taddr, 0,
285 RPCBPROG, RPCBVERS, 0, 0);
286 if (!client) {
287 t_close(fd);
288 rpc_createerr.cf_stat = RPC_TLIERROR;
289 return (NULL);
290 }
291
292 /*
293 * Now make the call to get the NIS service address.
294 */
295 tv.tv_sec = 10;
296 tv.tv_usec = 0;
297 parms.r_prog = prog;
298 parms.r_vers = ver;
299 parms.r_netid = nc->nc_netid; /* not needed */
300 parms.r_addr = ""; /* not needed; just for xdring */
301 parms.r_owner = ""; /* not needed; just for xdring */
302 clnt_st = clnt_call(client, RPCBPROC_GETADDR, xdr_rpcb, (char *)&parms,
303 xdr_wrapstring, (char *)&ua, tv);
304
305 rpc_createerr.cf_stat = clnt_st;
306 if (clnt_st == RPC_SUCCESS) {
307
308 clnt_destroy(client);
309 t_close(fd);
310 if (*ua == '\0') {
311 xdr_free(xdr_wrapstring, (char *)&ua);
312 return (NULL);
313 }
314 return (ua);
315 } else if (((clnt_st == RPC_PROGVERSMISMATCH) ||
316 (clnt_st == RPC_PROGUNAVAIL) ||
317 (clnt_st == RPC_TIMEDOUT)) &&
318 (strcmp(nc->nc_protofmly, NC_INET) == 0)) {
319 /*
320 * version 3 not available. Try version 2
321 * The assumption here is that the netbuf
322 * is arranged in the sockaddr_in
323 * style for IP cases.
324 */
325 ushort_t port;
326 struct sockaddr_in *sa;
327 struct netbuf remote;
328 int protocol;
329 char buf[32];
330 char *res;
331
332 clnt_control(client, CLGET_SVC_ADDR, (char *)&remote);
333 sa = (struct sockaddr_in *)(remote.buf);
334 protocol = strcmp(nc->nc_proto, NC_TCP) ? IPPROTO_UDP :
335 IPPROTO_TCP;
336 port = (ushort_t)pmap_getport(sa, prog, ver, protocol);
337
338 if (port != 0) {
339 /* print s_addr (and port) in host byte order */
340 sa->sin_addr.s_addr = ntohl(sa->sin_addr.s_addr);
341 sprintf(buf, "%d.%d.%d.%d.%d.%d",
342 (sa->sin_addr.s_addr >> 24) & 0xff,
343 (sa->sin_addr.s_addr >> 16) & 0xff,
344 (sa->sin_addr.s_addr >> 8) & 0xff,
345 (sa->sin_addr.s_addr) & 0xff,
346 (port >> 8) & 0xff,
347 port & 0xff);
348 res = strdup(buf);
349 if (res != 0) {
350 rpc_createerr.cf_stat = RPC_SUCCESS;
351 } else {
352 rpc_createerr.cf_stat = RPC_SYSTEMERROR;
353 }
354 } else {
355 rpc_createerr.cf_stat = RPC_UNKNOWNADDR;
356 res = NULL;
357 }
358 clnt_destroy(client);
359 t_close(fd);
360 return (res);
361 }
362 clnt_destroy(client);
363 t_close(fd);
364 return (NULL);
365 }
366
367 #define bcmp(s1, s2, len) memcmp(s1, s2, len)
368 #define bcopy(s1, s2, len) memcpy(s2, s1, len)
369
370 #define MAXALIASES 35
371
372 static char line[BUFSIZ+1];
373
374 static char *_hosts4_6[] = { "/etc/inet/hosts", "/etc/inet/ipnodes", 0 };
375
376 static char *any();
377
378 static struct hostent *__files_gethostent();
379
380 struct hostent *
__files_gethostbyname(char * nam,sa_family_t af)381 __files_gethostbyname(char *nam, sa_family_t af)
382 {
383 register struct hostent *hp;
384 register char **cp;
385 char **file = _hosts4_6;
386 FILE *hostf;
387
388 if ((af != AF_INET) && (af != AF_INET6))
389 return (0);
390
391 for (; *file != 0; file++) {
392
393 if ((hostf = fopen(*file, "r")) == 0)
394 continue;
395
396 while (hp = __files_gethostent(hostf)) {
397 if (hp->h_addrtype != af)
398 continue;
399 if (strcasecmp(hp->h_name, nam) == 0) {
400 (void) fclose(hostf);
401 return (hp);
402 }
403 for (cp = hp->h_aliases; cp != 0 && *cp != 0; cp++)
404 if (strcasecmp(*cp, nam) == 0) {
405 (void) fclose(hostf);
406 return (hp);
407 }
408 }
409
410 (void) fclose(hostf);
411 }
412
413 return (0);
414 }
415
416 #define isV6Addr(s) (strchr(s, (int)':') != 0)
417
418 static struct hostent *
__files_gethostent(FILE * hostf)419 __files_gethostent(FILE *hostf)
420 {
421 char *p;
422 register char *cp, **q;
423 struct in6_addr in6;
424 struct in_addr in4;
425 void *addr;
426 sa_family_t af;
427 int len;
428
429 if (hostf == NULL)
430 return (NULL);
431 again:
432 if ((p = fgets(line, BUFSIZ, hostf)) == NULL)
433 return (NULL);
434 if (*p == '#')
435 goto again;
436 cp = any(p, "#\n");
437 if (cp == NULL)
438 goto again;
439 *cp = '\0';
440 cp = any(p, " \t");
441 if (cp == NULL)
442 goto again;
443 *cp++ = '\0';
444 /* THIS STUFF IS INTERNET SPECIFIC */
445 host.h_addr_list = host_addrs;
446 if (isV6Addr(p)) {
447 af = AF_INET6;
448 addr = (void *)&in6;
449 len = sizeof (in6);
450 } else {
451 af = AF_INET;
452 addr = (void *)&in4;
453 len = sizeof (in4);
454 }
455 if (inet_pton(af, p, addr) != 1)
456 goto again;
457 bcopy(addr, host.h_addr_list[0], len);
458 host.h_length = len;
459 host.h_addrtype = af;
460 while (*cp == ' ' || *cp == '\t')
461 cp++;
462 host.h_name = cp;
463 q = host.h_aliases = host_aliases;
464 cp = any(cp, " \t");
465 if (cp != NULL)
466 *cp++ = '\0';
467 while (cp && *cp) {
468 if (*cp == ' ' || *cp == '\t') {
469 cp++;
470 continue;
471 }
472 if (q < &host_aliases[MAXALIASES - 1])
473 *q++ = cp;
474 cp = any(cp, " \t");
475 if (cp != NULL)
476 *cp++ = '\0';
477 }
478 *q = NULL;
479 return (&host);
480 }
481
482 static char *
any(cp,match)483 any(cp, match)
484 register char *cp;
485 char *match;
486 {
487 register char *mp, c;
488
489 while (c = *cp) {
490 for (mp = match; *mp; mp++)
491 if (*mp == c)
492 return (cp);
493 cp++;
494 }
495 return ((char *)0);
496 }
497