Insert public key of user in callback data.
[kopensolaris-gnu/glibc.git] / nis / nis_callback.c
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.
4
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.
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    Library General Public License for more details.
14
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.  */
19
20 #include <errno.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <unistd.h>
24 #include <rpc/rpc.h>
25 #include <rpc/pmap_clnt.h>
26 #include <string.h>
27 #include <memory.h>
28 #include <syslog.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 <bits/libc-lock.h>
35
36 #include "nis_intern.h"
37
38 /* Sorry, we are not able to make this threadsafe. Stupid. But some
39    functions doesn't send us a nis_result obj, so we don't have a
40    cookie. Maybe we could use keys for threads ? Have to learn more
41    about pthreads -- kukuk@vt.uni-paderborn.de */
42
43 #define CB_PROG ((u_long)100302)
44 #define CB_VERS ((u_long)1)
45 #define CBPROC_RECEIVE ((u_long)1)
46 #define CBPROC_FINISH ((u_long)2)
47 #define CBPROC_ERROR ((u_long)3)
48
49 typedef nis_object *obj_p;
50
51 struct cback_data
52   {
53     struct
54       {
55         u_int entries_len;
56         obj_p *entries_val;
57       }
58     entries;
59   };
60 typedef struct cback_data cback_data;
61
62 static nis_cb *data;
63
64 __libc_lock_define_initialized (static, callback)
65
66
67 static char *
68 __nis_getpkey(const char *sname)
69 {
70   char buf[(strlen (sname) + 1) * 2 + 40];
71   char pkey[HEXKEYBYTES + 1];
72   char *cp, *domain;
73   nis_result *res;
74   u_int len = 0;
75
76   domain = strchr (sname, '.');
77   if (domain == NULL)
78     return NULL;
79
80   /* Remove prefixing dot */
81   ++domain;
82
83   cp = stpcpy (buf, "[cname=");
84   cp = stpcpy (cp, sname);
85   cp = stpcpy (cp, ",auth_type=DES],cred.org_dir.");
86   cp = stpcpy (cp, domain);
87
88   res = nis_list (buf, USE_DGRAM|NO_AUTHINFO|FOLLOW_LINKS|FOLLOW_PATH,
89                   NULL, NULL);
90
91   if (res == NULL)
92     return NULL;
93
94   if (res->status != NIS_SUCCESS)
95     {
96       nis_freeresult (res);
97       return NULL;
98     }
99
100   len = ENTRY_LEN(NIS_RES_OBJECT(res), 3);
101   strncpy (pkey, ENTRY_VAL(NIS_RES_OBJECT(res), 3), len);
102   pkey[len] = '\0';
103   cp = strchr (pkey, ':');
104   if (cp != NULL)
105     *cp = '\0';
106
107   nis_freeresult (res);
108
109   return strdup (pkey);
110 }
111
112
113 static bool_t xdr_cback_data (XDR *, cback_data *);
114
115 static void
116 cb_prog_1 (struct svc_req *rqstp, SVCXPRT *transp)
117 {
118   union
119     {
120       cback_data cbproc_receive_1_arg;
121       nis_error cbproc_error_1_arg;
122     }
123   argument;
124   char *result;
125   xdrproc_t xdr_argument, xdr_result;
126   bool_t bool_result;
127
128   switch (rqstp->rq_proc)
129     {
130     case NULLPROC:
131       svc_sendreply (transp, (xdrproc_t) xdr_void, (char *) NULL);
132       return;
133
134     case CBPROC_RECEIVE:
135       {
136         u_long i;
137
138         xdr_argument = (xdrproc_t) xdr_cback_data;
139         xdr_result = (xdrproc_t) xdr_bool;
140         memset (&argument, 0, sizeof (argument));
141         if (!svc_getargs (transp, xdr_argument, (caddr_t) & argument))
142           {
143             svcerr_decode (transp);
144             return;
145           }
146         bool_result = FALSE;
147         for (i = 0; i < argument.cbproc_receive_1_arg.entries.entries_len; ++i)
148           {
149 #define cbproc_entry(a) argument.cbproc_receive_1_arg.entries.entries_val[a]
150             char name[strlen (cbproc_entry(i)->zo_name) +
151                       strlen (cbproc_entry(i)->zo_domain) + 3];
152             char *cp;
153
154             cp = stpcpy (name, cbproc_entry(i)->zo_name);
155             *cp++ = '.';
156             cp = stpcpy (cp, cbproc_entry(i)->zo_domain);
157
158             fprintf (stderr, "name=%s\n", name);
159
160             if ((data->callback) (name, cbproc_entry(i), data->userdata))
161               {
162                 bool_result = TRUE;
163                 data->nomore = 1;
164                 data->result = NIS_SUCCESS;
165                 break;
166               }
167           }
168         result = (char *) &bool_result;
169       }
170       break;
171     case CBPROC_FINISH:
172       xdr_argument = (xdrproc_t) xdr_void;
173       xdr_result = (xdrproc_t) xdr_void;
174       memset (&argument, 0, sizeof (argument));
175       if (!svc_getargs (transp, xdr_argument, (caddr_t) & argument))
176         {
177           svcerr_decode (transp);
178           return;
179         }
180       data->nomore = 1;
181       data->result = NIS_SUCCESS;
182       bool_result = TRUE;       /* to make gcc happy, not necessary */
183       result = (char *) &bool_result;
184       break;
185     case CBPROC_ERROR:
186       xdr_argument = (xdrproc_t) xdr_nis_error;
187       xdr_result = (xdrproc_t) xdr_void;
188       memset (&argument, 0, sizeof (argument));
189       if (!svc_getargs (transp, xdr_argument, (caddr_t) & argument))
190         {
191           svcerr_decode (transp);
192           return;
193         }
194       data->nomore = 1;
195       data->result = argument.cbproc_error_1_arg;
196       bool_result = TRUE;       /* to make gcc happy, not necessary */
197       result = (char *) &bool_result;
198       break;
199     default:
200       svcerr_noproc (transp);
201       return;
202     }
203   if (result != NULL && !svc_sendreply (transp, xdr_result, result))
204     svcerr_systemerr (transp);
205   if (!svc_freeargs (transp, xdr_argument, (caddr_t) & argument))
206     {
207       fputs (_ ("unable to free arguments"), stderr);
208       exit (1);
209     }
210   return;
211 }
212
213 static bool_t
214 xdr_obj_p (XDR * xdrs, obj_p *objp)
215 {
216   if (!xdr_pointer (xdrs, (char **) objp, sizeof (nis_object),
217                     (xdrproc_t) xdr_nis_object))
218     return FALSE;
219   return TRUE;
220 }
221
222 static bool_t
223 xdr_cback_data (XDR *xdrs, cback_data *objp)
224 {
225   if (!xdr_array (xdrs, (char **) &objp->entries.entries_val,
226                   (u_int *) & objp->entries.entries_len, ~0, sizeof (obj_p),
227                   (xdrproc_t) xdr_obj_p))
228     return FALSE;
229   return TRUE;
230 }
231
232 static nis_error
233 internal_nis_do_callback (struct dir_binding *bptr, netobj *cookie,
234                           struct nis_cb *cb)
235 {
236   /* Default timeout can be changed using clnt_control() */
237   static struct timeval TIMEOUT = {25, 0};
238 #ifdef FD_SETSIZE
239   fd_set readfds;
240 #else
241   int readfds;
242 #endif /* def FD_SETSIZE */
243   struct timeval tv;
244   bool_t cb_is_running = FALSE;
245
246   data = cb;
247
248   for (;;)
249     {
250 #ifdef FD_SETSIZE
251       readfds = svc_fdset;
252 #else
253       readfds = svc_fds;
254 #endif /* def FD_SETSIZE */
255       tv.tv_sec = 25;
256       tv.tv_usec = 0;
257       switch (select (_rpc_dtablesize (), &readfds, NULL, NULL, &tv))
258         {
259         case -1:
260           if (errno == EINTR)
261             continue;
262           return NIS_CBERROR;
263         case 0:
264           /* See if callback 'thread' in the server is still alive. */
265           memset ((char *) &cb_is_running, 0, sizeof (cb_is_running));
266           if (clnt_call (bptr->clnt, NIS_CALLBACK, (xdrproc_t) xdr_netobj,
267                          (caddr_t) cookie, (xdrproc_t) xdr_bool,
268                          (caddr_t) & cb_is_running, TIMEOUT) != RPC_SUCCESS)
269             cb_is_running = FALSE;
270
271           if (cb_is_running == FALSE)
272             {
273               syslog (LOG_ERR, "NIS+: callback timed out");
274               return NIS_CBERROR;
275             }
276           break;
277         default:
278           svc_getreqset (&readfds);
279           if (data->nomore)
280             return data->result;
281         }
282     }
283 }
284
285 nis_error
286 __nis_do_callback (struct dir_binding *bptr, netobj *cookie,
287                    struct nis_cb *cb)
288 {
289   nis_error result;
290
291   __libc_lock_lock (callback);
292
293   result = internal_nis_do_callback (bptr, cookie, cb);
294
295   __libc_lock_unlock (callback);
296
297   return result;
298 }
299
300 struct nis_cb *
301 __nis_create_callback (int (*callback) (const_nis_name, const nis_object *,
302                                         const void *),
303                        const void *userdata, u_long flags)
304 {
305   struct nis_cb *cb;
306   int sock = RPC_ANYSOCK;
307   struct sockaddr_in sin;
308   int len = sizeof (struct sockaddr_in);
309   char addr[NIS_MAXNAMELEN + 1];
310   unsigned short port;
311
312   cb = (struct nis_cb *) calloc (1, sizeof (struct nis_cb));
313   if (cb == NULL)
314     {
315       syslog (LOG_ERR, "NIS+: out of memory allocating callback");
316       return NULL;
317     }
318
319   cb->serv = (nis_server *) calloc (1, sizeof (nis_server));
320   if (cb->serv == NULL)
321     {
322       free (cb);
323       syslog (LOG_ERR, "NIS+: out of memory allocating callback");
324       return (NULL);
325     }
326   cb->serv->name = strdup (nis_local_principal ());
327   cb->serv->ep.ep_val = (endpoint *) calloc (2, sizeof (endpoint));
328   cb->serv->ep.ep_len = 1;
329   cb->serv->ep.ep_val[0].family = strdup ("inet");
330   cb->callback = callback;
331   cb->userdata = userdata;
332
333   if ((flags & NO_AUTHINFO) && key_secretkey_is_set ())
334     {
335       cb->serv->key_type = NIS_PK_NONE;
336       cb->serv->pkey.n_bytes = NULL;
337       cb->serv->pkey.n_len = 0;
338     }
339   else
340     {
341       if ((cb->serv->pkey.n_bytes = __nis_getpkey (cb->serv->name)) == NULL)
342         {
343           cb->serv->pkey.n_len = 0;
344           cb->serv->key_type = NIS_PK_NONE;
345         }
346       else
347         {
348           cb->serv->key_type = NIS_PK_DH;
349           cb->serv->pkey.n_len = strlen(cb->serv->pkey.n_bytes);
350         }
351     }
352
353   if (flags & USE_DGRAM)
354     {
355       cb->serv->ep.ep_val[0].proto = strdup ("udp");
356       cb->xprt = svcudp_bufcreate (sock, 100, 8192);
357     }
358   else
359     {
360       cb->serv->ep.ep_val[0].proto = strdup ("tcp");
361       cb->xprt = svctcp_create (sock, 100, 8192);
362     }
363   cb->sock = cb->xprt->xp_sock;
364   if (!svc_register (cb->xprt, CB_PROG, CB_VERS, cb_prog_1, 0))
365     {
366       xprt_unregister (cb->xprt);
367       svc_destroy (cb->xprt);
368       xdr_free ((xdrproc_t) xdr_nis_server, (char *) cb->serv);
369       free (cb->serv);
370       free (cb);
371       syslog (LOG_ERR, "NIS+: failed to register callback dispatcher");
372       return NULL;
373     }
374
375   if (getsockname (cb->sock, (struct sockaddr *) &sin, &len) == -1)
376     {
377       xprt_unregister (cb->xprt);
378       svc_destroy (cb->xprt);
379       xdr_free ((xdrproc_t) xdr_nis_server, (char *) cb->serv);
380       free (cb->serv);
381       free (cb);
382       syslog (LOG_ERR, "NIS+: failed to read local socket info");
383       return (NULL);
384     }
385   port = sin.sin_port;
386   get_myaddress (&sin);
387   snprintf (addr, sizeof (addr), "%s.%d.%d", inet_ntoa (sin.sin_addr),
388             port & 0x00FF, (port & 0xFF00) >> 8);
389   cb->serv->ep.ep_val[0].uaddr = strdup (addr);
390
391   return cb;
392 }
393
394 nis_error
395 __nis_destroy_callback (struct nis_cb *cb)
396 {
397   xprt_unregister (cb->xprt);
398   svc_destroy (cb->xprt);
399   close (cb->sock);
400   xdr_free ((xdrproc_t) xdr_nis_server, (char *) cb->serv);
401   free (cb->serv);
402   free (cb);
403
404   return NIS_SUCCESS;
405 }