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
39static int services_marshal_func(struct servent *, char *, size_t *);
40static int services_lookup_func(const char *, size_t, char **, size_t *);
41static void *services_mp_init_func(void);
42static int services_mp_lookup_func(char **, size_t *, void *);
43static void services_mp_destroy_func(void *);
44
45static int
46services_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
120static int
121services_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
205static void *
206services_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
215static int
216services_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
233static void
234services_mp_destroy_func(void *mdata)
235{
236	TRACE_IN(services_mp_destroy_func);
237	TRACE_OUT(services_mp_destroy_func);
238}
239
240struct agent *
241init_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
259struct agent *
260init_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