1 /* Copyright (C) 1997, 1998 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3 Contributed by Thorsten Kukuk <kukuk@vt.uni-paderborn.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 Library General Public License as
7 published by the Free Software Foundation; either version 2 of the
8 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 Library General Public License for more details.
15 You should have received a copy of the GNU Library General Public
16 License along with the GNU C Library; see the file COPYING.LIB. If not,
17 write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 Boston, MA 02111-1307, USA. */
25 #include <rpc/pmap_clnt.h>
29 #include <sys/socket.h>
30 #include <netinet/in.h>
31 #include <arpa/inet.h>
32 #include <rpc/key_prot.h>
33 #include <rpcsvc/nis.h>
34 #include <rpcsvc/nis_callback.h>
35 #include <bits/libc-lock.h>
38 #include "nis_intern.h"
40 /* Sorry, we are not able to make this threadsafe. Stupid. But some
41 functions doesn't send us a nis_result obj, so we don't have a
42 cookie. Maybe we could use keys for threads ? Have to learn more
43 about pthreads -- kukuk@vt.uni-paderborn.de */
47 __libc_lock_define_initialized (static, callback)
52 __nis_getpkey(const char *sname)
54 char buf[(strlen (sname) + 1) * 2 + 40];
55 char pkey[HEXKEYBYTES + 1];
60 domain = strchr (sname, '.');
64 /* Remove prefixing dot */
67 cp = stpcpy (buf, "[cname=");
68 cp = stpcpy (cp, sname);
69 cp = stpcpy (cp, ",auth_type=DES],cred.org_dir.");
70 cp = stpcpy (cp, domain);
72 res = nis_list (buf, USE_DGRAM|NO_AUTHINFO|FOLLOW_LINKS|FOLLOW_PATH,
78 if (NIS_RES_STATUS (res) != NIS_SUCCESS)
84 len = ENTRY_LEN(NIS_RES_OBJECT(res), 3);
85 strncpy (pkey, ENTRY_VAL(NIS_RES_OBJECT(res), 3), len);
87 cp = strchr (pkey, ':');
98 cb_prog_1 (struct svc_req *rqstp, SVCXPRT *transp)
102 cback_data cbproc_receive_1_arg;
103 nis_error cbproc_error_1_arg;
107 xdrproc_t xdr_argument, xdr_result;
110 switch (rqstp->rq_proc)
113 svc_sendreply (transp, (xdrproc_t) xdr_void, (char *) NULL);
120 xdr_argument = (xdrproc_t) xdr_cback_data;
121 xdr_result = (xdrproc_t) xdr_bool;
122 memset (&argument, 0, sizeof (argument));
123 if (!svc_getargs (transp, xdr_argument, (caddr_t) & argument))
125 svcerr_decode (transp);
129 for (i = 0; i < argument.cbproc_receive_1_arg.entries.entries_len; ++i)
131 #define cbproc_entry(a) argument.cbproc_receive_1_arg.entries.entries_val[a]
132 char name[strlen (cbproc_entry(i)->zo_name) +
133 strlen (cbproc_entry(i)->zo_domain) + 3];
136 cp = stpcpy (name, cbproc_entry(i)->zo_name);
138 cp = stpcpy (cp, cbproc_entry(i)->zo_domain);
140 if ((data->callback) (name, cbproc_entry(i), data->userdata))
144 data->result = NIS_SUCCESS;
148 result = (char *) &bool_result;
152 xdr_argument = (xdrproc_t) xdr_void;
153 xdr_result = (xdrproc_t) xdr_void;
154 memset (&argument, 0, sizeof (argument));
155 if (!svc_getargs (transp, xdr_argument, (caddr_t) & argument))
157 svcerr_decode (transp);
161 data->result = NIS_SUCCESS;
162 bool_result = TRUE; /* to make gcc happy, not necessary */
163 result = (char *) &bool_result;
166 xdr_argument = (xdrproc_t) _xdr_nis_error;
167 xdr_result = (xdrproc_t) xdr_void;
168 memset (&argument, 0, sizeof (argument));
169 if (!svc_getargs (transp, xdr_argument, (caddr_t) & argument))
171 svcerr_decode (transp);
175 data->result = argument.cbproc_error_1_arg;
176 bool_result = TRUE; /* to make gcc happy, not necessary */
177 result = (char *) &bool_result;
180 svcerr_noproc (transp);
183 if (result != NULL && !svc_sendreply (transp, xdr_result, result))
184 svcerr_systemerr (transp);
185 if (!svc_freeargs (transp, xdr_argument, (caddr_t) & argument))
187 fputs (_ ("unable to free arguments"), stderr);
194 internal_nis_do_callback (struct dir_binding *bptr, netobj *cookie,
197 /* Default timeout can be changed using clnt_control() */
198 static struct timeval TIMEOUT = {25, 0};
203 #endif /* def FD_SETSIZE */
205 bool_t cb_is_running = FALSE;
215 #endif /* def FD_SETSIZE */
218 switch (select (_rpc_dtablesize (), &readfds, NULL, NULL, &tv))
225 /* See if callback 'thread' in the server is still alive. */
226 memset ((char *) &cb_is_running, 0, sizeof (cb_is_running));
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;
232 if (cb_is_running == FALSE)
234 syslog (LOG_ERR, "NIS+: callback timed out");
239 svc_getreqset (&readfds);
247 __nis_do_callback (struct dir_binding *bptr, netobj *cookie,
252 __libc_lock_lock (callback);
254 result = internal_nis_do_callback (bptr, cookie, cb);
256 __libc_lock_unlock (callback);
262 __nis_create_callback (int (*callback) (const_nis_name, const nis_object *,
264 const void *userdata, u_long flags)
267 int sock = RPC_ANYSOCK;
268 struct sockaddr_in sin;
269 int len = sizeof (struct sockaddr_in);
270 char addr[NIS_MAXNAMELEN + 1];
273 cb = (struct nis_cb *) calloc (1, sizeof (struct nis_cb));
276 syslog (LOG_ERR, "NIS+: out of memory allocating callback");
280 cb->serv = (nis_server *) calloc (1, sizeof (nis_server));
281 if (cb->serv == NULL)
284 syslog (LOG_ERR, "NIS+: out of memory allocating callback");
287 cb->serv->name = strdup (nis_local_principal ());
288 cb->serv->ep.ep_val = (endpoint *) calloc (2, sizeof (endpoint));
289 cb->serv->ep.ep_len = 1;
290 cb->serv->ep.ep_val[0].family = strdup ("inet");
291 cb->callback = callback;
292 cb->userdata = userdata;
294 if ((flags & NO_AUTHINFO) || !key_secretkey_is_set ())
296 cb->serv->key_type = NIS_PK_NONE;
297 cb->serv->pkey.n_bytes = NULL;
298 cb->serv->pkey.n_len = 0;
303 if ((cb->serv->pkey.n_bytes = __nis_getpkey (cb->serv->name)) == NULL)
305 cb->serv->pkey.n_len = 0;
306 cb->serv->key_type = NIS_PK_NONE;
310 cb->serv->key_type = NIS_PK_DH;
311 cb->serv->pkey.n_len = strlen(cb->serv->pkey.n_bytes);
314 cb->serv->pkey.n_len =0;
315 cb->serv->pkey.n_bytes = NULL;
316 cb->serv->key_type = NIS_PK_DH;
320 if (flags & USE_DGRAM)
322 cb->serv->ep.ep_val[0].proto = strdup ("udp");
323 cb->xprt = svcudp_bufcreate (sock, 100, 8192);
327 cb->serv->ep.ep_val[0].proto = strdup ("tcp");
328 cb->xprt = svctcp_create (sock, 100, 8192);
330 cb->sock = cb->xprt->xp_sock;
331 if (!svc_register (cb->xprt, CB_PROG, CB_VERS, cb_prog_1, 0))
333 xprt_unregister (cb->xprt);
334 svc_destroy (cb->xprt);
335 xdr_free ((xdrproc_t) _xdr_nis_server, (char *) cb->serv);
338 syslog (LOG_ERR, "NIS+: failed to register callback dispatcher");
342 if (getsockname (cb->sock, (struct sockaddr *) &sin, &len) == -1)
344 xprt_unregister (cb->xprt);
345 svc_destroy (cb->xprt);
346 xdr_free ((xdrproc_t) _xdr_nis_server, (char *) cb->serv);
349 syslog (LOG_ERR, "NIS+: failed to read local socket info");
353 get_myaddress (&sin);
354 snprintf (addr, sizeof (addr), "%s.%d.%d", inet_ntoa (sin.sin_addr),
355 port & 0x00FF, (port & 0xFF00) >> 8);
356 cb->serv->ep.ep_val[0].uaddr = strdup (addr);
362 __nis_destroy_callback (struct nis_cb *cb)
364 xprt_unregister (cb->xprt);
365 svc_destroy (cb->xprt);
367 xdr_free ((xdrproc_t) _xdr_nis_server, (char *) cb->serv);