1 /*-
2 * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 *
26 */
27
28 #include <sys/param.h>
29
30 #include <assert.h>
31 #include <netdb.h>
32 #include <nsswitch.h>
33 #include <stdlib.h>
34 #include <string.h>
35
36 #include "../debug.h"
37 #include "services.h"
38
39 static int services_marshal_func(struct servent *, char *, size_t *);
40 static int services_lookup_func(const char *, size_t, char **, size_t *);
41 static void *services_mp_init_func(void);
42 static int services_mp_lookup_func(char **, size_t *, void *);
43 static void services_mp_destroy_func(void *);
44
45 static int
services_marshal_func(struct servent * serv,char * buffer,size_t * buffer_size)46 services_marshal_func(struct servent *serv, char *buffer, size_t *buffer_size)
47 {
48 struct servent new_serv;
49 size_t desired_size;
50 char **alias;
51 char *p;
52 size_t size;
53 size_t aliases_size;
54
55 TRACE_IN(services_marshal_func);
56 desired_size = ALIGNBYTES + sizeof(struct servent) + sizeof(char *);
57 if (serv->s_name != NULL)
58 desired_size += strlen(serv->s_name) + 1;
59 if (serv->s_proto != NULL)
60 desired_size += strlen(serv->s_proto) + 1;
61
62 aliases_size = 0;
63 if (serv->s_aliases != NULL) {
64 for (alias = serv->s_aliases; *alias; ++alias) {
65 desired_size += strlen(*alias) + 1;
66 ++aliases_size;
67 }
68
69 desired_size += ALIGNBYTES + sizeof(char *) *
70 (aliases_size + 1);
71 }
72
73 if ((*buffer_size < desired_size) || (buffer == NULL)) {
74 *buffer_size = desired_size;
75 TRACE_OUT(services_marshal_func);
76 return (NS_RETURN);
77 }
78
79 memcpy(&new_serv, serv, sizeof(struct servent));
80 memset(buffer, 0, desired_size);
81
82 *buffer_size = desired_size;
83 p = buffer + sizeof(struct servent) + sizeof(char *);
84 memcpy(buffer + sizeof(struct servent), &p, sizeof(char *));
85 p = (char *)ALIGN(p);
86
87 if (new_serv.s_name != NULL) {
88 size = strlen(new_serv.s_name);
89 memcpy(p, new_serv.s_name, size);
90 new_serv.s_name = p;
91 p += size + 1;
92 }
93
94 if (new_serv.s_proto != NULL) {
95 size = strlen(new_serv.s_proto);
96 memcpy(p, new_serv.s_proto, size);
97 new_serv.s_proto = p;
98 p += size + 1;
99 }
100
101 if (new_serv.s_aliases != NULL) {
102 p = (char *)ALIGN(p);
103 memcpy(p, new_serv.s_aliases, sizeof(char *) * aliases_size);
104 new_serv.s_aliases = (char **)p;
105 p += sizeof(char *) * (aliases_size + 1);
106
107 for (alias = new_serv.s_aliases; *alias; ++alias) {
108 size = strlen(*alias);
109 memcpy(p, *alias, size);
110 *alias = p;
111 p += size + 1;
112 }
113 }
114
115 memcpy(buffer, &new_serv, sizeof(struct servent));
116 TRACE_OUT(services_marshal_func);
117 return (NS_SUCCESS);
118 }
119
120 static int
services_lookup_func(const char * key,size_t key_size,char ** buffer,size_t * buffer_size)121 services_lookup_func(const char *key, size_t key_size, char **buffer,
122 size_t *buffer_size)
123 {
124 enum nss_lookup_type lookup_type;
125 char *name = NULL;
126 char *proto = NULL;
127 size_t size, size2;
128 int port;
129
130 struct servent *result;
131
132 TRACE_IN(services_lookup_func);
133
134 assert(buffer != NULL);
135 assert(buffer_size != NULL);
136
137 if (key_size < sizeof(enum nss_lookup_type)) {
138 TRACE_OUT(passwd_lookup_func);
139 return (NS_UNAVAIL);
140 }
141 memcpy(&lookup_type, key, sizeof(enum nss_lookup_type));
142
143 switch (lookup_type) {
144 case nss_lt_name:
145 size = key_size - sizeof(enum nss_lookup_type);
146 name = calloc(1, size + 1);
147 assert(name != NULL);
148 memcpy(name, key + sizeof(enum nss_lookup_type), size);
149
150 size2 = strlen(name) + 1;
151
152 if (size2 < size)
153 proto = name + size2;
154 else
155 proto = NULL;
156 break;
157 case nss_lt_id:
158 if (key_size < sizeof(enum nss_lookup_type) +
159 sizeof(int)) {
160 TRACE_OUT(passwd_lookup_func);
161 return (NS_UNAVAIL);
162 }
163
164 memcpy(&port, key + sizeof(enum nss_lookup_type),
165 sizeof(int));
166
167 size = key_size - sizeof(enum nss_lookup_type) - sizeof(int);
168 if (size > 0) {
169 proto = calloc(1, size + 1);
170 assert(proto != NULL);
171 memcpy(proto, key + sizeof(enum nss_lookup_type) +
172 sizeof(int), size);
173 }
174 break;
175 default:
176 TRACE_OUT(passwd_lookup_func);
177 return (NS_UNAVAIL);
178 }
179
180 switch (lookup_type) {
181 case nss_lt_name:
182 result = getservbyname(name, proto);
183 free(name);
184 break;
185 case nss_lt_id:
186 result = getservbyport(port, proto);
187 free(proto);
188 break;
189 default:
190 /* SHOULD NOT BE REACHED */
191 break;
192 }
193
194 if (result != NULL) {
195 services_marshal_func(result, NULL, buffer_size);
196 *buffer = malloc(*buffer_size);
197 assert(*buffer != NULL);
198 services_marshal_func(result, *buffer, buffer_size);
199 }
200
201 TRACE_OUT(services_lookup_func);
202 return (result == NULL ? NS_NOTFOUND : NS_SUCCESS);
203 }
204
205 static void *
services_mp_init_func(void)206 services_mp_init_func(void)
207 {
208 TRACE_IN(services_mp_init_func);
209 setservent(0);
210 TRACE_OUT(services_mp_init_func);
211
212 return (NULL);
213 }
214
215 static int
services_mp_lookup_func(char ** buffer,size_t * buffer_size,void * mdata)216 services_mp_lookup_func(char **buffer, size_t *buffer_size, void *mdata)
217 {
218 struct servent *result;
219
220 TRACE_IN(services_mp_lookup_func);
221 result = getservent();
222 if (result != NULL) {
223 services_marshal_func(result, NULL, buffer_size);
224 *buffer = malloc(*buffer_size);
225 assert(*buffer != NULL);
226 services_marshal_func(result, *buffer, buffer_size);
227 }
228
229 TRACE_OUT(services_mp_lookup_func);
230 return (result == NULL ? NS_NOTFOUND : NS_SUCCESS);
231 }
232
233 static void
services_mp_destroy_func(void * mdata)234 services_mp_destroy_func(void *mdata)
235 {
236 TRACE_IN(services_mp_destroy_func);
237 TRACE_OUT(services_mp_destroy_func);
238 }
239
240 struct agent *
init_services_agent(void)241 init_services_agent(void)
242 {
243 struct common_agent *retval;
244 TRACE_IN(init_services_agent);
245
246 retval = calloc(1, sizeof(*retval));
247 assert(retval != NULL);
248
249 retval->parent.name = strdup("services");
250 assert(retval->parent.name != NULL);
251
252 retval->parent.type = COMMON_AGENT;
253 retval->lookup_func = services_lookup_func;
254
255 TRACE_OUT(init_services_agent);
256 return ((struct agent *)retval);
257 }
258
259 struct agent *
init_services_mp_agent(void)260 init_services_mp_agent(void)
261 {
262 struct multipart_agent *retval;
263
264 TRACE_IN(init_services_mp_agent);
265 retval = calloc(1,
266 sizeof(*retval));
267 assert(retval != NULL);
268
269 retval->parent.name = strdup("services");
270 retval->parent.type = MULTIPART_AGENT;
271 retval->mp_init_func = services_mp_init_func;
272 retval->mp_lookup_func = services_mp_lookup_func;
273 retval->mp_destroy_func = services_mp_destroy_func;
274 assert(retval->parent.name != NULL);
275
276 TRACE_OUT(init_services_mp_agent);
277 return ((struct agent *)retval);
278 }
279