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 2006 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #pragma ident "%Z%%M% %I% %E% SMI"
27
28 #include <ctype.h>
29 #include <sys/types.h>
30 #include <sys/socket.h>
31 #include <netinet/in.h>
32 #include <arpa/inet.h>
33 #include <netdb.h>
34 #include <stdlib.h>
35 #include <string.h>
36 #include <nss_dbdefs.h>
37
38
39 int str2netent(const char *, int, void *, char *, int);
40
41 static int net_stayopen;
42 /*
43 * Unsynchronized, but it affects only
44 * efficiency, not correctness
45 */
46
47 static DEFINE_NSS_DB_ROOT(db_root);
48 static DEFINE_NSS_GETENT(context);
49
50 void
_nss_initf_net(nss_db_params_t * p)51 _nss_initf_net(nss_db_params_t *p)
52 {
53 p->name = NSS_DBNAM_NETWORKS;
54 p->default_config = NSS_DEFCONF_NETWORKS;
55 }
56
57 struct netent *
getnetbyname_r(const char * name,struct netent * result,char * buffer,int buflen)58 getnetbyname_r(const char *name, struct netent *result,
59 char *buffer, int buflen)
60 {
61 nss_XbyY_args_t arg;
62 nss_status_t res;
63
64 if (name == (const char *)NULL) {
65 errno = ERANGE;
66 return (NULL);
67 }
68 NSS_XbyY_INIT(&arg, result, buffer, buflen, str2netent);
69 arg.key.name = name;
70 arg.stayopen = net_stayopen;
71 res = nss_search(&db_root, _nss_initf_net,
72 NSS_DBOP_NETWORKS_BYNAME, &arg);
73 arg.status = res;
74 (void) NSS_XbyY_FINI(&arg);
75 return ((struct netent *)arg.returnval);
76 }
77
78 struct netent *
getnetbyaddr_r(long net,int type,struct netent * result,char * buffer,int buflen)79 getnetbyaddr_r(long net, int type, struct netent *result,
80 char *buffer, int buflen)
81 {
82 nss_XbyY_args_t arg;
83 nss_status_t res;
84
85 NSS_XbyY_INIT(&arg, result, buffer, buflen, str2netent);
86 arg.key.netaddr.net = (uint32_t)net;
87 arg.key.netaddr.type = type;
88 arg.stayopen = net_stayopen;
89 res = nss_search(&db_root, _nss_initf_net,
90 NSS_DBOP_NETWORKS_BYADDR, &arg);
91 arg.status = res;
92 (void) NSS_XbyY_FINI(&arg);
93 return ((struct netent *)arg.returnval);
94 }
95
96 int
setnetent(int stay)97 setnetent(int stay)
98 {
99 net_stayopen |= stay; /* === Or maybe just "=" ? */
100 nss_setent(&db_root, _nss_initf_net, &context);
101 return (0);
102 }
103
104 int
endnetent()105 endnetent()
106 {
107 net_stayopen = 0;
108 nss_endent(&db_root, _nss_initf_net, &context);
109 nss_delete(&db_root);
110 return (0);
111 }
112
113 struct netent *
getnetent_r(struct netent * result,char * buffer,int buflen)114 getnetent_r(struct netent *result, char *buffer, int buflen)
115 {
116 nss_XbyY_args_t arg;
117 nss_status_t res;
118
119 NSS_XbyY_INIT(&arg, result, buffer, buflen, str2netent);
120 /* No stayopen flag; of course you stay open for iteration */
121 res = nss_getent(&db_root, _nss_initf_net, &context, &arg);
122 arg.status = res;
123 (void) NSS_XbyY_FINI(&arg);
124 return ((struct netent *)arg.returnval);
125 }
126
127 /*
128 * Return values: 0 = success, 1 = parse error, 2 = erange ...
129 * The structure pointer passed in is a structure in the caller's space
130 * wherein the field pointers would be set to areas in the buffer if
131 * need be. instring and buffer should be separate areas.
132 */
133 int
str2netent(const char * instr,int lenstr,void * ent,char * buffer,int buflen)134 str2netent(const char *instr, int lenstr,
135 void *ent /* really (struct netnet *) */, char *buffer, int buflen)
136 {
137 struct netent *net = (struct netent *)ent;
138 const char *p, *numstart, *limit, *namestart;
139 int namelen = 0;
140 ptrdiff_t numlen;
141 char numbuf[16];
142
143 if ((instr >= buffer && (buffer + buflen) > instr) ||
144 (buffer >= instr && (instr + lenstr) > buffer)) {
145 return (NSS_STR_PARSE_PARSE);
146 }
147
148 p = instr;
149 limit = p + lenstr;
150
151 while (p < limit && isspace(*p)) {
152 p++;
153 }
154 namestart = p;
155 while (p < limit && !isspace(*p)) {
156 p++; /* Skip over the canonical name */
157 }
158 namelen = (int)(p - namestart);
159
160 if (buflen <= namelen) { /* not enough buffer */
161 return (NSS_STR_PARSE_ERANGE);
162 }
163 (void) memcpy(buffer, namestart, namelen);
164 buffer[namelen] = '\0';
165 net->n_name = buffer;
166
167 while (p < limit && isspace(*p)) {
168 p++;
169 }
170 if (p >= limit) {
171 /* Syntax error -- no net number */
172 return (NSS_STR_PARSE_PARSE);
173 }
174 numstart = p;
175 do {
176 p++; /* Find the end of the net number */
177 } while (p < limit && !isspace(*p));
178 numlen = p - numstart;
179 if (numlen >= (ptrdiff_t)sizeof (numbuf)) {
180 /* Syntax error -- supposed number is too long */
181 return (NSS_STR_PARSE_PARSE);
182 }
183 (void) memcpy(numbuf, numstart, numlen);
184 numbuf[numlen] = '\0';
185 net->n_net = inet_network(numbuf);
186 if (net->n_net == (in_addr_t)-1) {
187 /* inet_network failed to parse the string */
188 return (NSS_STR_PARSE_PARSE);
189 }
190
191 net->n_addrtype = AF_INET;
192
193 while (p < limit && isspace(*p)) {
194 p++;
195 }
196 /*
197 * Although nss_files_XY_all calls us with # stripped,
198 * we should be able to deal with it here in order to
199 * be more useful.
200 */
201 if (p >= limit || *p == '#') { /* no aliases, no problem */
202 char **ptr;
203
204 ptr = (char **)ROUND_UP(buffer + namelen + 1,
205 sizeof (char *));
206 if ((char *)ptr >= buffer + buflen) {
207 net->n_aliases = 0; /* hope they don't try to peek in */
208 return (NSS_STR_PARSE_ERANGE);
209 } else {
210 *ptr = 0;
211 net->n_aliases = ptr;
212 return (NSS_STR_PARSE_SUCCESS);
213 }
214 }
215 net->n_aliases = _nss_netdb_aliases(p, lenstr - (int)(p - instr),
216 buffer + namelen + 1, buflen - namelen - 1);
217 return (NSS_STR_PARSE_SUCCESS);
218 }
219