1 /* Copyright (C) 1997-2015 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 <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 (__glibc_unlikely (cb
== NULL
))
276 cb
->serv
= (nis_server
*) (cb
+ 1);
277 cb
->serv
->name
= strdup (nis_local_principal ());
278 if (__glibc_unlikely (cb
->serv
->name
== NULL
))
280 cb
->serv
->ep
.ep_val
= (endpoint
*) calloc (2, sizeof (endpoint
));
281 if (__glibc_unlikely (cb
->serv
->ep
.ep_val
== NULL
))
283 cb
->serv
->ep
.ep_len
= 1;
284 cb
->serv
->ep
.ep_val
[0].family
= strdup ("inet");
285 if (__glibc_unlikely (cb
->serv
->ep
.ep_val
[0].family
== NULL
))
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 (__glibc_unlikely (cb
->serv
->ep
.ep_val
[0].proto
== NULL
))
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
);