(getspnam_plususer): Preserve original return value.
[kopensolaris-gnu/glibc.git] / nis / nis_callback.c
1 /* Copyright (C) 1997, 1998, 1999, 2000, 2005 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 = FALSE;
201
202   data = cb;
203
204   for (;;)
205     {
206       struct pollfd *my_pollfd;
207       int i;
208
209       if (svc_max_pollfd == 0 && svc_pollfd == NULL)
210         return NIS_CBERROR;
211
212       my_pollfd = malloc (sizeof (struct pollfd) * svc_max_pollfd);
213       if (__builtin_expect (my_pollfd == NULL, 0))
214         return NIS_NOMEMORY;
215
216       for (i = 0; i < svc_max_pollfd; ++i)
217         {
218           my_pollfd[i].fd = svc_pollfd[i].fd;
219           my_pollfd[i].events = svc_pollfd[i].events;
220           my_pollfd[i].revents = 0;
221         }
222
223       switch (i = __poll (my_pollfd, svc_max_pollfd, 25*1000))
224         {
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;
238
239           if (cb_is_running == FALSE)
240             {
241               syslog (LOG_ERR, "NIS+: callback timed out");
242               return NIS_CBERROR;
243             }
244           break;
245         default:
246           svc_getreq_poll (my_pollfd, i);
247           free (my_pollfd);
248           if (data->nomore)
249             return data->result;
250         }
251     }
252 }
253
254 nis_error
255 __nis_do_callback (struct dir_binding *bptr, netobj *cookie,
256                    struct nis_cb *cb)
257 {
258   nis_error result;
259
260   __libc_lock_lock (callback);
261
262   result = internal_nis_do_callback (bptr, cookie, cb);
263
264   __libc_lock_unlock (callback);
265
266   return result;
267 }
268
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)
273 {
274   struct nis_cb *cb;
275   int sock = RPC_ANYSOCK;
276   struct sockaddr_in sin;
277   socklen_t len = sizeof (struct sockaddr_in);
278   char addr[NIS_MAXNAMELEN + 1];
279   unsigned short port;
280
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;
299
300   if ((flags & NO_AUTHINFO) || !key_secretkey_is_set ())
301     {
302       cb->serv->key_type = NIS_PK_NONE;
303       cb->serv->pkey.n_bytes = NULL;
304       cb->serv->pkey.n_len = 0;
305     }
306   else
307     {
308 #if 0
309       if ((cb->serv->pkey.n_bytes = __nis_getpkey (cb->serv->name)) == NULL)
310         {
311           cb->serv->pkey.n_len = 0;
312           cb->serv->key_type = NIS_PK_NONE;
313         }
314       else
315         {
316           cb->serv->key_type = NIS_PK_DH;
317           cb->serv->pkey.n_len = strlen(cb->serv->pkey.n_bytes);
318         }
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
324     }
325
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))
333     {
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;
341     }
342
343   if (getsockname (cb->sock, (struct sockaddr *) &sin, &len) == -1)
344     {
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;
352     }
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);
358
359   return cb;
360
361  failed:
362   if (cb)
363     {
364       if (cb->serv)
365         {
366           xdr_free ((xdrproc_t) _xdr_nis_server, (char *) cb->serv);
367           free (cb->serv);
368         }
369       free (cb);
370     }
371   syslog (LOG_ERR, "NIS+: out of memory allocating callback");
372   return NULL;
373 }
374
375 nis_error
376 __nis_destroy_callback (struct nis_cb *cb)
377 {
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);
384
385   return NIS_SUCCESS;
386 }