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.
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, see
17 <http://www.gnu.org/licenses/>. */
25 #include <rpc/pmap_clnt.h>
30 #include <sys/socket.h>
31 #include <netinet/in.h>
32 #include <arpa/inet.h>
33 #include <rpc/key_prot.h>
34 #include <rpcsvc/nis.h>
35 #include <rpcsvc/nis_callback.h>
36 #include <bits/libc-lock.h>
39 #include "nis_intern.h"
41 /* Sorry, we are not able to make this threadsafe. Stupid. But some
42 functions doesn't send us a nis_result obj, so we don't have a
43 cookie. Maybe we could use keys for threads ? Have to learn more
44 about pthreads -- kukuk@vt.uni-paderborn.de */
48 __libc_lock_define_initialized (static, callback)
53 __nis_getpkey(const char *sname)
55 char buf[(strlen (sname) + 1) * 2 + 40];
56 char pkey[HEXKEYBYTES + 1];
61 domain = strchr (sname, '.');
65 /* Remove prefixing dot */
68 cp = stpcpy (buf, "[cname=");
69 cp = stpcpy (cp, sname);
70 cp = stpcpy (cp, ",auth_type=DES],cred.org_dir.");
71 cp = stpcpy (cp, domain);
73 res = nis_list (buf, USE_DGRAM|NO_AUTHINFO|FOLLOW_LINKS|FOLLOW_PATH,
79 if (NIS_RES_STATUS (res) != NIS_SUCCESS)
85 len = ENTRY_LEN(NIS_RES_OBJECT(res), 3);
86 strncpy (pkey, ENTRY_VAL(NIS_RES_OBJECT(res), 3), len);
88 cp = strchr (pkey, ':');
99 cb_prog_1 (struct svc_req *rqstp, SVCXPRT *transp)
103 cback_data cbproc_receive_1_arg;
104 nis_error cbproc_error_1_arg;
108 xdrproc_t xdr_argument, xdr_result;
111 switch (rqstp->rq_proc)
114 svc_sendreply (transp, (xdrproc_t) xdr_void, (char *) NULL);
121 xdr_argument = (xdrproc_t) xdr_cback_data;
122 xdr_result = (xdrproc_t) xdr_bool;
123 memset (&argument, 0, sizeof (argument));
124 if (!svc_getargs (transp, xdr_argument, (caddr_t) & argument))
126 svcerr_decode (transp);
130 for (i = 0; i < argument.cbproc_receive_1_arg.entries.entries_len; ++i)
132 #define cbproc_entry(a) argument.cbproc_receive_1_arg.entries.entries_val[a]
133 char name[strlen (cbproc_entry(i)->zo_name) +
134 strlen (cbproc_entry(i)->zo_domain) + 3];
137 cp = stpcpy (name, cbproc_entry(i)->zo_name);
139 cp = stpcpy (cp, cbproc_entry(i)->zo_domain);
141 if ((data->callback) (name, cbproc_entry(i), data->userdata))
145 data->result = NIS_SUCCESS;
149 result = (char *) &bool_result;
153 xdr_argument = (xdrproc_t) xdr_void;
154 xdr_result = (xdrproc_t) xdr_void;
155 memset (&argument, 0, sizeof (argument));
156 if (!svc_getargs (transp, xdr_argument, (caddr_t) & argument))
158 svcerr_decode (transp);
162 data->result = NIS_SUCCESS;
163 bool_result = TRUE; /* to make gcc happy, not necessary */
164 result = (char *) &bool_result;
167 xdr_argument = (xdrproc_t) _xdr_nis_error;
168 xdr_result = (xdrproc_t) xdr_void;
169 memset (&argument, 0, sizeof (argument));
170 if (!svc_getargs (transp, xdr_argument, (caddr_t) & argument))
172 svcerr_decode (transp);
176 data->result = argument.cbproc_error_1_arg;
177 bool_result = TRUE; /* to make gcc happy, not necessary */
178 result = (char *) &bool_result;
181 svcerr_noproc (transp);
184 if (result != NULL && !svc_sendreply (transp, xdr_result, result))
185 svcerr_systemerr (transp);
186 if (!svc_freeargs (transp, xdr_argument, (caddr_t) & argument))
188 fputs (_ ("unable to free arguments"), stderr);
195 internal_nis_do_callback (struct dir_binding *bptr, netobj *cookie,
198 struct timeval TIMEOUT = {25, 0};
199 bool_t cb_is_running;
205 struct pollfd my_pollfd[svc_max_pollfd];
208 if (svc_max_pollfd == 0 && svc_pollfd == NULL)
211 for (i = 0; i < svc_max_pollfd; ++i)
213 my_pollfd[i].fd = svc_pollfd[i].fd;
214 my_pollfd[i].events = svc_pollfd[i].events;
215 my_pollfd[i].revents = 0;
218 switch (i = TEMP_FAILURE_RETRY (__poll (my_pollfd, svc_max_pollfd,
224 /* See if callback 'thread' in the server is still alive. */
225 cb_is_running = FALSE;
226 if (clnt_call (bptr->clnt, NIS_CALLBACK, (xdrproc_t) xdr_netobj,
227 (caddr_t) cookie, (xdrproc_t) xdr_bool,
228 (caddr_t) &cb_is_running, TIMEOUT) != RPC_SUCCESS)
229 cb_is_running = FALSE;
231 if (cb_is_running == FALSE)
233 syslog (LOG_ERR, "NIS+: callback timed out");
238 svc_getreq_poll (my_pollfd, i);
246 __nis_do_callback (struct dir_binding *bptr, netobj *cookie,
251 __libc_lock_lock (callback);
253 result = internal_nis_do_callback (bptr, cookie, cb);
255 __libc_lock_unlock (callback);
261 __nis_create_callback (int (*callback) (const_nis_name, const nis_object *,
263 const void *userdata, unsigned int flags)
266 int sock = RPC_ANYSOCK;
267 struct sockaddr_in sin;
268 socklen_t len = sizeof (struct sockaddr_in);
272 cb = (struct nis_cb *) calloc (1,
273 sizeof (struct nis_cb) + sizeof (nis_server));
274 if (__builtin_expect (cb == NULL, 0))
276 cb->serv = (nis_server *) (cb + 1);
277 cb->serv->name = strdup (nis_local_principal ());
278 if (__builtin_expect (cb->serv->name == NULL, 0))
280 cb->serv->ep.ep_val = (endpoint *) calloc (2, sizeof (endpoint));
281 if (__builtin_expect (cb->serv->ep.ep_val == NULL, 0))
283 cb->serv->ep.ep_len = 1;
284 cb->serv->ep.ep_val[0].family = strdup ("inet");
285 if (__builtin_expect (cb->serv->ep.ep_val[0].family == NULL, 0))
287 cb->callback = callback;
288 cb->userdata = userdata;
290 if ((flags & NO_AUTHINFO) || !key_secretkey_is_set ())
292 cb->serv->key_type = NIS_PK_NONE;
293 cb->serv->pkey.n_bytes = NULL;
294 cb->serv->pkey.n_len = 0;
299 if ((cb->serv->pkey.n_bytes = __nis_getpkey (cb->serv->name)) == NULL)
301 cb->serv->pkey.n_len = 0;
302 cb->serv->key_type = NIS_PK_NONE;
306 cb->serv->key_type = NIS_PK_DH;
307 cb->serv->pkey.n_len = strlen(cb->serv->pkey.n_bytes);
310 cb->serv->pkey.n_len =0;
311 cb->serv->pkey.n_bytes = NULL;
312 cb->serv->key_type = NIS_PK_NONE;
316 cb->serv->ep.ep_val[0].proto = strdup ((flags & USE_DGRAM) ? "udp" : "tcp");
317 if (__builtin_expect (cb->serv->ep.ep_val[0].proto == NULL, 0))
319 cb->xprt = ((flags & USE_DGRAM)
320 ? svcudp_bufcreate (sock, 100, 8192)
321 : svctcp_create (sock, 100, 8192));
322 if (cb->xprt == NULL)
327 cb->sock = cb->xprt->xp_sock;
328 if (!svc_register (cb->xprt, CB_PROG, CB_VERS, cb_prog_1, 0))
330 xprt_unregister (cb->xprt);
331 svc_destroy (cb->xprt);
332 xdr_free ((xdrproc_t) _xdr_nis_server, (char *) cb->serv);
334 syslog (LOG_ERR, "NIS+: failed to register callback dispatcher");
338 if (getsockname (cb->sock, (struct sockaddr *) &sin, &len) == -1)
340 xprt_unregister (cb->xprt);
341 svc_destroy (cb->xprt);
342 xdr_free ((xdrproc_t) _xdr_nis_server, (char *) cb->serv);
344 syslog (LOG_ERR, "NIS+: failed to read local socket info");
347 port = ntohs (sin.sin_port);
348 get_myaddress (&sin);
350 if (asprintf (&cb->serv->ep.ep_val[0].uaddr, "%s.%d.%d",
351 inet_ntoa (sin.sin_addr), (port & 0xFF00) >> 8, port & 0x00FF)
361 svc_destroy (cb->xprt);
362 xdr_free ((xdrproc_t) _xdr_nis_server, (char *) cb->serv);
366 syslog (LOG_ERR, "NIS+: out of memory allocating callback");
371 __nis_destroy_callback (struct nis_cb *cb)
373 xprt_unregister (cb->xprt);
374 svc_destroy (cb->xprt);
376 xdr_free ((xdrproc_t) _xdr_nis_server, (char *) cb->serv);