]>
Commit | Line | Data |
---|---|---|
1 | /* Copyright (C) 1997,1998,1999,2000,2005,2006 Free Software Foundation, Inc. | |
2 | This file is part of the GNU C Library. | |
3 | Contributed by Thorsten Kukuk <kukuk@suse.de>, 1997. | |
4 | ||
5 | The GNU C Library is free software; you can redistribute it and/or | |
6 | modify it under the terms of the GNU Lesser General Public | |
7 | License as published by the Free Software Foundation; either | |
8 | version 2.1 of the License, or (at your option) any later version. | |
9 | ||
10 | The GNU C Library is distributed in the hope that it will be useful, | |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
13 | Lesser General Public License for more details. | |
14 | ||
15 | You should have received a copy of the GNU Lesser General Public | |
16 | License along with the GNU C Library; if not, write to the Free | |
17 | Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA | |
18 | 02111-1307 USA. */ | |
19 | ||
20 | #include <errno.h> | |
21 | #include <stdio.h> | |
22 | #include <stdlib.h> | |
23 | #include <unistd.h> | |
24 | #include <libintl.h> | |
25 | #include <rpc/rpc.h> | |
26 | #include <rpc/pmap_clnt.h> | |
27 | #include <string.h> | |
28 | #include <memory.h> | |
29 | #include <syslog.h> | |
30 | #include <sys/poll.h> | |
31 | #include <sys/socket.h> | |
32 | #include <netinet/in.h> | |
33 | #include <arpa/inet.h> | |
34 | #include <rpc/key_prot.h> | |
35 | #include <rpcsvc/nis.h> | |
36 | #include <rpcsvc/nis_callback.h> | |
37 | #include <bits/libc-lock.h> | |
38 | ||
39 | #include "nis_xdr.h" | |
40 | #include "nis_intern.h" | |
41 | ||
42 | /* Sorry, we are not able to make this threadsafe. Stupid. But some | |
43 | functions doesn't send us a nis_result obj, so we don't have a | |
44 | cookie. Maybe we could use keys for threads ? Have to learn more | |
45 | about pthreads -- kukuk@vt.uni-paderborn.de */ | |
46 | ||
47 | static nis_cb *data; | |
48 | ||
49 | __libc_lock_define_initialized (static, callback) | |
50 | ||
51 | ||
52 | #if 0 | |
53 | static char * | |
54 | __nis_getpkey(const char *sname) | |
55 | { | |
56 | char buf[(strlen (sname) + 1) * 2 + 40]; | |
57 | char pkey[HEXKEYBYTES + 1]; | |
58 | char *cp, *domain; | |
59 | nis_result *res; | |
60 | unsigned int len = 0; | |
61 | ||
62 | domain = strchr (sname, '.'); | |
63 | if (domain == NULL) | |
64 | return NULL; | |
65 | ||
66 | /* Remove prefixing dot */ | |
67 | ++domain; | |
68 | ||
69 | cp = stpcpy (buf, "[cname="); | |
70 | cp = stpcpy (cp, sname); | |
71 | cp = stpcpy (cp, ",auth_type=DES],cred.org_dir."); | |
72 | cp = stpcpy (cp, domain); | |
73 | ||
74 | res = nis_list (buf, USE_DGRAM|NO_AUTHINFO|FOLLOW_LINKS|FOLLOW_PATH, | |
75 | NULL, NULL); | |
76 | ||
77 | if (res == NULL) | |
78 | return NULL; | |
79 | ||
80 | if (NIS_RES_STATUS (res) != NIS_SUCCESS) | |
81 | { | |
82 | nis_freeresult (res); | |
83 | return NULL; | |
84 | } | |
85 | ||
86 | len = ENTRY_LEN(NIS_RES_OBJECT(res), 3); | |
87 | strncpy (pkey, ENTRY_VAL(NIS_RES_OBJECT(res), 3), len); | |
88 | pkey[len] = '\0'; | |
89 | cp = strchr (pkey, ':'); | |
90 | if (cp != NULL) | |
91 | *cp = '\0'; | |
92 | ||
93 | nis_freeresult (res); | |
94 | ||
95 | return strdup (pkey); | |
96 | } | |
97 | #endif | |
98 | ||
99 | static void | |
100 | cb_prog_1 (struct svc_req *rqstp, SVCXPRT *transp) | |
101 | { | |
102 | union | |
103 | { | |
104 | cback_data cbproc_receive_1_arg; | |
105 | nis_error cbproc_error_1_arg; | |
106 | } | |
107 | argument; | |
108 | char *result; | |
109 | xdrproc_t xdr_argument, xdr_result; | |
110 | bool_t bool_result; | |
111 | ||
112 | switch (rqstp->rq_proc) | |
113 | { | |
114 | case NULLPROC: | |
115 | svc_sendreply (transp, (xdrproc_t) xdr_void, (char *) NULL); | |
116 | return; | |
117 | ||
118 | case CBPROC_RECEIVE: | |
119 | { | |
120 | unsigned int i; | |
121 | ||
122 | xdr_argument = (xdrproc_t) xdr_cback_data; | |
123 | xdr_result = (xdrproc_t) xdr_bool; | |
124 | memset (&argument, 0, sizeof (argument)); | |
125 | if (!svc_getargs (transp, xdr_argument, (caddr_t) & argument)) | |
126 | { | |
127 | svcerr_decode (transp); | |
128 | return; | |
129 | } | |
130 | bool_result = FALSE; | |
131 | for (i = 0; i < argument.cbproc_receive_1_arg.entries.entries_len; ++i) | |
132 | { | |
133 | #define cbproc_entry(a) argument.cbproc_receive_1_arg.entries.entries_val[a] | |
134 | char name[strlen (cbproc_entry(i)->zo_name) + | |
135 | strlen (cbproc_entry(i)->zo_domain) + 3]; | |
136 | char *cp; | |
137 | ||
138 | cp = stpcpy (name, cbproc_entry(i)->zo_name); | |
139 | *cp++ = '.'; | |
140 | cp = stpcpy (cp, cbproc_entry(i)->zo_domain); | |
141 | ||
142 | if ((data->callback) (name, cbproc_entry(i), data->userdata)) | |
143 | { | |
144 | bool_result = TRUE; | |
145 | data->nomore = 1; | |
146 | data->result = NIS_SUCCESS; | |
147 | break; | |
148 | } | |
149 | } | |
150 | result = (char *) &bool_result; | |
151 | } | |
152 | break; | |
153 | case CBPROC_FINISH: | |
154 | xdr_argument = (xdrproc_t) xdr_void; | |
155 | xdr_result = (xdrproc_t) xdr_void; | |
156 | memset (&argument, 0, sizeof (argument)); | |
157 | if (!svc_getargs (transp, xdr_argument, (caddr_t) & argument)) | |
158 | { | |
159 | svcerr_decode (transp); | |
160 | return; | |
161 | } | |
162 | data->nomore = 1; | |
163 | data->result = NIS_SUCCESS; | |
164 | bool_result = TRUE; /* to make gcc happy, not necessary */ | |
165 | result = (char *) &bool_result; | |
166 | break; | |
167 | case CBPROC_ERROR: | |
168 | xdr_argument = (xdrproc_t) _xdr_nis_error; | |
169 | xdr_result = (xdrproc_t) xdr_void; | |
170 | memset (&argument, 0, sizeof (argument)); | |
171 | if (!svc_getargs (transp, xdr_argument, (caddr_t) & argument)) | |
172 | { | |
173 | svcerr_decode (transp); | |
174 | return; | |
175 | } | |
176 | data->nomore = 1; | |
177 | data->result = argument.cbproc_error_1_arg; | |
178 | bool_result = TRUE; /* to make gcc happy, not necessary */ | |
179 | result = (char *) &bool_result; | |
180 | break; | |
181 | default: | |
182 | svcerr_noproc (transp); | |
183 | return; | |
184 | } | |
185 | if (result != NULL && !svc_sendreply (transp, xdr_result, result)) | |
186 | svcerr_systemerr (transp); | |
187 | if (!svc_freeargs (transp, xdr_argument, (caddr_t) & argument)) | |
188 | { | |
189 | fputs (_ ("unable to free arguments"), stderr); | |
190 | exit (1); | |
191 | } | |
192 | return; | |
193 | } | |
194 | ||
195 | static nis_error | |
196 | internal_nis_do_callback (struct dir_binding *bptr, netobj *cookie, | |
197 | struct nis_cb *cb) | |
198 | { | |
199 | struct timeval TIMEOUT = {25, 0}; | |
200 | bool_t cb_is_running; | |
201 | ||
202 | data = cb; | |
203 | ||
204 | for (;;) | |
205 | { | |
206 | struct pollfd my_pollfd[svc_max_pollfd]; | |
207 | int i; | |
208 | ||
209 | if (svc_max_pollfd == 0 && svc_pollfd == NULL) | |
210 | return NIS_CBERROR; | |
211 | ||
212 | for (i = 0; i < svc_max_pollfd; ++i) | |
213 | { | |
214 | my_pollfd[i].fd = svc_pollfd[i].fd; | |
215 | my_pollfd[i].events = svc_pollfd[i].events; | |
216 | my_pollfd[i].revents = 0; | |
217 | } | |
218 | ||
219 | switch (i = TEMP_FAILURE_RETRY (__poll (my_pollfd, svc_max_pollfd, | |
220 | 25*1000))) | |
221 | { | |
222 | case -1: | |
223 | return NIS_CBERROR; | |
224 | case 0: | |
225 | /* See if callback 'thread' in the server is still alive. */ | |
226 | cb_is_running = FALSE; | |
227 | if (clnt_call (bptr->clnt, NIS_CALLBACK, (xdrproc_t) xdr_netobj, | |
228 | (caddr_t) cookie, (xdrproc_t) xdr_bool, | |
229 | (caddr_t) &cb_is_running, TIMEOUT) != RPC_SUCCESS) | |
230 | cb_is_running = FALSE; | |
231 | ||
232 | if (cb_is_running == FALSE) | |
233 | { | |
234 | syslog (LOG_ERR, "NIS+: callback timed out"); | |
235 | return NIS_CBERROR; | |
236 | } | |
237 | break; | |
238 | default: | |
239 | svc_getreq_poll (my_pollfd, i); | |
240 | if (data->nomore) | |
241 | return data->result; | |
242 | } | |
243 | } | |
244 | } | |
245 | ||
246 | nis_error | |
247 | __nis_do_callback (struct dir_binding *bptr, netobj *cookie, | |
248 | struct nis_cb *cb) | |
249 | { | |
250 | nis_error result; | |
251 | ||
252 | __libc_lock_lock (callback); | |
253 | ||
254 | result = internal_nis_do_callback (bptr, cookie, cb); | |
255 | ||
256 | __libc_lock_unlock (callback); | |
257 | ||
258 | return result; | |
259 | } | |
260 | ||
261 | struct nis_cb * | |
262 | __nis_create_callback (int (*callback) (const_nis_name, const nis_object *, | |
263 | const void *), | |
264 | const void *userdata, unsigned int flags) | |
265 | { | |
266 | struct nis_cb *cb; | |
267 | int sock = RPC_ANYSOCK; | |
268 | struct sockaddr_in sin; | |
269 | socklen_t len = sizeof (struct sockaddr_in); | |
270 | unsigned short port; | |
271 | int nomsg = 0; | |
272 | ||
273 | cb = (struct nis_cb *) calloc (1, | |
274 | sizeof (struct nis_cb) + sizeof (nis_server)); | |
275 | if (__builtin_expect (cb == NULL, 0)) | |
276 | goto failed; | |
277 | cb->serv = (nis_server *) (cb + 1); | |
278 | cb->serv->name = strdup (nis_local_principal ()); | |
279 | if (__builtin_expect (cb->serv->name == NULL, 0)) | |
280 | goto failed; | |
281 | cb->serv->ep.ep_val = (endpoint *) calloc (2, sizeof (endpoint)); | |
282 | if (__builtin_expect (cb->serv->ep.ep_val == NULL, 0)) | |
283 | goto failed; | |
284 | cb->serv->ep.ep_len = 1; | |
285 | cb->serv->ep.ep_val[0].family = strdup ("inet"); | |
286 | if (__builtin_expect (cb->serv->ep.ep_val[0].family == NULL, 0)) | |
287 | goto failed; | |
288 | cb->callback = callback; | |
289 | cb->userdata = userdata; | |
290 | ||
291 | if ((flags & NO_AUTHINFO) || !key_secretkey_is_set ()) | |
292 | { | |
293 | cb->serv->key_type = NIS_PK_NONE; | |
294 | cb->serv->pkey.n_bytes = NULL; | |
295 | cb->serv->pkey.n_len = 0; | |
296 | } | |
297 | else | |
298 | { | |
299 | #if 0 | |
300 | if ((cb->serv->pkey.n_bytes = __nis_getpkey (cb->serv->name)) == NULL) | |
301 | { | |
302 | cb->serv->pkey.n_len = 0; | |
303 | cb->serv->key_type = NIS_PK_NONE; | |
304 | } | |
305 | else | |
306 | { | |
307 | cb->serv->key_type = NIS_PK_DH; | |
308 | cb->serv->pkey.n_len = strlen(cb->serv->pkey.n_bytes); | |
309 | } | |
310 | #else | |
311 | cb->serv->pkey.n_len =0; | |
312 | cb->serv->pkey.n_bytes = NULL; | |
313 | cb->serv->key_type = NIS_PK_NONE; | |
314 | #endif | |
315 | } | |
316 | ||
317 | cb->serv->ep.ep_val[0].proto = strdup ((flags & USE_DGRAM) ? "udp" : "tcp"); | |
318 | if (__builtin_expect (cb->serv->ep.ep_val[0].proto == NULL, 0)) | |
319 | goto failed; | |
320 | cb->xprt = ((flags & USE_DGRAM) | |
321 | ? svcudp_bufcreate (sock, 100, 8192) | |
322 | : svctcp_create (sock, 100, 8192)); | |
323 | if (cb->xprt == NULL) | |
324 | { | |
325 | nomsg = 1; | |
326 | goto failed; | |
327 | } | |
328 | cb->sock = cb->xprt->xp_sock; | |
329 | if (!svc_register (cb->xprt, CB_PROG, CB_VERS, cb_prog_1, 0)) | |
330 | { | |
331 | xprt_unregister (cb->xprt); | |
332 | svc_destroy (cb->xprt); | |
333 | xdr_free ((xdrproc_t) _xdr_nis_server, (char *) cb->serv); | |
334 | free (cb); | |
335 | syslog (LOG_ERR, "NIS+: failed to register callback dispatcher"); | |
336 | return NULL; | |
337 | } | |
338 | ||
339 | if (getsockname (cb->sock, (struct sockaddr *) &sin, &len) == -1) | |
340 | { | |
341 | xprt_unregister (cb->xprt); | |
342 | svc_destroy (cb->xprt); | |
343 | xdr_free ((xdrproc_t) _xdr_nis_server, (char *) cb->serv); | |
344 | free (cb); | |
345 | syslog (LOG_ERR, "NIS+: failed to read local socket info"); | |
346 | return NULL; | |
347 | } | |
348 | port = ntohs (sin.sin_port); | |
349 | get_myaddress (&sin); | |
350 | ||
351 | if (asprintf (&cb->serv->ep.ep_val[0].uaddr, "%s.%d.%d", | |
352 | inet_ntoa (sin.sin_addr), (port & 0xFF00) >> 8, port & 0x00FF) | |
353 | < 0) | |
354 | goto failed; | |
355 | ||
356 | return cb; | |
357 | ||
358 | failed: | |
359 | if (cb) | |
360 | { | |
361 | if (cb->xprt) | |
362 | svc_destroy (cb->xprt); | |
363 | xdr_free ((xdrproc_t) _xdr_nis_server, (char *) cb->serv); | |
364 | free (cb); | |
365 | } | |
366 | if (!nomsg) | |
367 | syslog (LOG_ERR, "NIS+: out of memory allocating callback"); | |
368 | return NULL; | |
369 | } | |
370 | ||
371 | nis_error | |
372 | __nis_destroy_callback (struct nis_cb *cb) | |
373 | { | |
374 | xprt_unregister (cb->xprt); | |
375 | svc_destroy (cb->xprt); | |
376 | close (cb->sock); | |
377 | xdr_free ((xdrproc_t) _xdr_nis_server, (char *) cb->serv); | |
378 | free (cb); | |
379 | ||
380 | return NIS_SUCCESS; | |
381 | } |