Update.
[glibc.git] / nis / nis_callback.c
blobb867b39ab73c6ce0744b54353b6ce7db01d46c8a
1 /* Copyright (C) 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3 Contributed by Thorsten Kukuk <kukuk@suse.de>, 1997.
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.
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.
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. */
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>
39 #include "nis_xdr.h"
40 #include "nis_intern.h"
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 */
47 static nis_cb *data;
49 __libc_lock_define_initialized (static, callback)
52 #if 0
53 static char *
54 __nis_getpkey(const char *sname)
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;
62 domain = strchr (sname, '.');
63 if (domain == NULL)
64 return NULL;
66 /* Remove prefixing dot */
67 ++domain;
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);
74 res = nis_list (buf, USE_DGRAM|NO_AUTHINFO|FOLLOW_LINKS|FOLLOW_PATH,
75 NULL, NULL);
77 if (res == NULL)
78 return NULL;
80 if (NIS_RES_STATUS (res) != NIS_SUCCESS)
82 nis_freeresult (res);
83 return NULL;
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';
93 nis_freeresult (res);
95 return strdup (pkey);
97 #endif
99 static void
100 cb_prog_1 (struct svc_req *rqstp, SVCXPRT *transp)
102 union
104 cback_data cbproc_receive_1_arg;
105 nis_error cbproc_error_1_arg;
107 argument;
108 char *result;
109 xdrproc_t xdr_argument, xdr_result;
110 bool_t bool_result;
112 switch (rqstp->rq_proc)
114 case NULLPROC:
115 svc_sendreply (transp, (xdrproc_t) xdr_void, (char *) NULL);
116 return;
118 case CBPROC_RECEIVE:
120 unsigned int i;
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))
127 svcerr_decode (transp);
128 return;
130 bool_result = FALSE;
131 for (i = 0; i < argument.cbproc_receive_1_arg.entries.entries_len; ++i)
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;
138 cp = stpcpy (name, cbproc_entry(i)->zo_name);
139 *cp++ = '.';
140 cp = stpcpy (cp, cbproc_entry(i)->zo_domain);
142 if ((data->callback) (name, cbproc_entry(i), data->userdata))
144 bool_result = TRUE;
145 data->nomore = 1;
146 data->result = NIS_SUCCESS;
147 break;
150 result = (char *) &bool_result;
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))
159 svcerr_decode (transp);
160 return;
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))
173 svcerr_decode (transp);
174 return;
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;
185 if (result != NULL && !svc_sendreply (transp, xdr_result, result))
186 svcerr_systemerr (transp);
187 if (!svc_freeargs (transp, xdr_argument, (caddr_t) & argument))
189 fputs (_ ("unable to free arguments"), stderr);
190 exit (1);
192 return;
195 static nis_error
196 internal_nis_do_callback (struct dir_binding *bptr, netobj *cookie,
197 struct nis_cb *cb)
199 struct timeval TIMEOUT = {25, 0};
200 bool_t cb_is_running = FALSE;
202 data = cb;
204 for (;;)
206 struct pollfd *my_pollfd;
207 int i;
209 if (svc_max_pollfd == 0 && svc_pollfd == NULL)
210 return NIS_CBERROR;
212 my_pollfd = malloc (sizeof (struct pollfd) * svc_max_pollfd);
213 if (__builtin_expect (my_pollfd == NULL, 0))
214 return NIS_NOMEMORY;
216 for (i = 0; i < svc_max_pollfd; ++i)
218 my_pollfd[i].fd = svc_pollfd[i].fd;
219 my_pollfd[i].events = svc_pollfd[i].events;
220 my_pollfd[i].revents = 0;
223 switch (i = __poll (my_pollfd, svc_max_pollfd, 25*1000))
225 case -1:
226 free (my_pollfd);
227 if (errno == EINTR)
228 continue;
229 return NIS_CBERROR;
230 case 0:
231 free (my_pollfd);
232 /* See if callback 'thread' in the server is still alive. */
233 memset ((char *) &cb_is_running, 0, sizeof (cb_is_running));
234 if (clnt_call (bptr->clnt, NIS_CALLBACK, (xdrproc_t) xdr_netobj,
235 (caddr_t) cookie, (xdrproc_t) xdr_bool,
236 (caddr_t) & cb_is_running, TIMEOUT) != RPC_SUCCESS)
237 cb_is_running = FALSE;
239 if (cb_is_running == FALSE)
241 syslog (LOG_ERR, "NIS+: callback timed out");
242 return NIS_CBERROR;
244 break;
245 default:
246 svc_getreq_poll (my_pollfd, i);
247 free (my_pollfd);
248 if (data->nomore)
249 return data->result;
254 nis_error
255 __nis_do_callback (struct dir_binding *bptr, netobj *cookie,
256 struct nis_cb *cb)
258 nis_error result;
260 __libc_lock_lock (callback);
262 result = internal_nis_do_callback (bptr, cookie, cb);
264 __libc_lock_unlock (callback);
266 return result;
269 struct nis_cb *
270 __nis_create_callback (int (*callback) (const_nis_name, const nis_object *,
271 const void *),
272 const void *userdata, unsigned int flags)
274 struct nis_cb *cb;
275 int sock = RPC_ANYSOCK;
276 struct sockaddr_in sin;
277 int len = sizeof (struct sockaddr_in);
278 char addr[NIS_MAXNAMELEN + 1];
279 unsigned short port;
281 cb = (struct nis_cb *) calloc (1, sizeof (struct nis_cb));
282 if (__builtin_expect (cb == NULL, 0))
283 goto failed;
284 cb->serv = (nis_server *) calloc (1, sizeof (nis_server));
285 if (__builtin_expect (cb->serv == NULL, 0))
286 goto failed;
287 cb->serv->name = strdup (nis_local_principal ());
288 if (__builtin_expect (cb->serv->name == NULL, 0))
289 goto failed;
290 cb->serv->ep.ep_val = (endpoint *) calloc (2, sizeof (endpoint));
291 if (__builtin_expect (cb->serv->ep.ep_val == NULL, 0))
292 goto failed;
293 cb->serv->ep.ep_len = 1;
294 cb->serv->ep.ep_val[0].family = strdup ("inet");
295 if (__builtin_expect (cb->serv->ep.ep_val[0].family == NULL, 0))
296 goto failed;
297 cb->callback = callback;
298 cb->userdata = userdata;
300 if ((flags & NO_AUTHINFO) || !key_secretkey_is_set ())
302 cb->serv->key_type = NIS_PK_NONE;
303 cb->serv->pkey.n_bytes = NULL;
304 cb->serv->pkey.n_len = 0;
306 else
308 #if 0
309 if ((cb->serv->pkey.n_bytes = __nis_getpkey (cb->serv->name)) == NULL)
311 cb->serv->pkey.n_len = 0;
312 cb->serv->key_type = NIS_PK_NONE;
314 else
316 cb->serv->key_type = NIS_PK_DH;
317 cb->serv->pkey.n_len = strlen(cb->serv->pkey.n_bytes);
319 #else
320 cb->serv->pkey.n_len =0;
321 cb->serv->pkey.n_bytes = NULL;
322 cb->serv->key_type = NIS_PK_NONE;
323 #endif
326 cb->serv->ep.ep_val[0].proto = strdup ((flags & USE_DGRAM) ? "udp" : "tcp");
327 if (__builtin_expect (cb->serv->ep.ep_val[0].proto == NULL, 0))
328 goto failed;
329 cb->xprt = (flags & USE_DGRAM) ? svcudp_bufcreate (sock, 100, 8192) :
330 svctcp_create (sock, 100, 8192);
331 cb->sock = cb->xprt->xp_sock;
332 if (!svc_register (cb->xprt, CB_PROG, CB_VERS, cb_prog_1, 0))
334 xprt_unregister (cb->xprt);
335 svc_destroy (cb->xprt);
336 xdr_free ((xdrproc_t) _xdr_nis_server, (char *) cb->serv);
337 free (cb->serv);
338 free (cb);
339 syslog (LOG_ERR, "NIS+: failed to register callback dispatcher");
340 return NULL;
343 if (getsockname (cb->sock, (struct sockaddr *) &sin, &len) == -1)
345 xprt_unregister (cb->xprt);
346 svc_destroy (cb->xprt);
347 xdr_free ((xdrproc_t) _xdr_nis_server, (char *) cb->serv);
348 free (cb->serv);
349 free (cb);
350 syslog (LOG_ERR, "NIS+: failed to read local socket info");
351 return NULL;
353 port = ntohs (sin.sin_port);
354 get_myaddress (&sin);
355 snprintf (addr, sizeof (addr), "%s.%d.%d", inet_ntoa (sin.sin_addr),
356 (port & 0xFF00) >> 8, port & 0x00FF);
357 cb->serv->ep.ep_val[0].uaddr = strdup (addr);
359 return cb;
361 failed:
362 if (cb)
364 if (cb->serv)
366 xdr_free ((xdrproc_t) _xdr_nis_server, (char *) cb->serv);
367 free (cb->serv);
369 free (cb);
371 syslog (LOG_ERR, "NIS+: out of memory allocating callback");
372 return NULL;
375 nis_error
376 __nis_destroy_callback (struct nis_cb *cb)
378 xprt_unregister (cb->xprt);
379 svc_destroy (cb->xprt);
380 close (cb->sock);
381 xdr_free ((xdrproc_t) _xdr_nis_server, (char *) cb->serv);
382 free (cb->serv);
383 free (cb);
385 return NIS_SUCCESS;