fdwalk should return 0 on an empty directory
[kopensolaris-gnu/glibc.git] / sunrpc / key_call.c
1 /*
2  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
3  * unrestricted use provided that this legend is included on all tape
4  * media and as a part of the software program in whole or part.  Users
5  * may copy or modify Sun RPC without charge, but are not authorized
6  * to license or distribute it to anyone else except as part of a product or
7  * program developed by the user.
8  *
9  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
10  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
11  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
12  *
13  * Sun RPC is provided with no support and without any obligation on the
14  * part of Sun Microsystems, Inc. to assist in its use, correction,
15  * modification or enhancement.
16  *
17  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
18  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
19  * OR ANY PART THEREOF.
20  *
21  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
22  * or profits or other special, indirect and consequential damages, even if
23  * Sun has been advised of the possibility of such damages.
24  *
25  * Sun Microsystems, Inc.
26  * 2550 Garcia Avenue
27  * Mountain View, California  94043
28  */
29 /*
30  * Copyright (c) 1988 by Sun Microsystems, Inc.
31  */
32 /*
33  * The original source is from the RPCSRC 4.0 package from Sun Microsystems.
34  * The Interface to keyserver protocoll 2, RPC over AF_UNIX and Linux/doors
35  * was added by Thorsten Kukuk <kukuk@suse.de>
36  * Since the Linux/doors project was stopped, I doubt that this code will
37  * ever be useful <kukuk@suse.de>.
38  */
39
40 #include <stdio.h>
41 #include <errno.h>
42 #include <fcntl.h>
43 #include <signal.h>
44 #include <unistd.h>
45 #include <string.h>
46 #include <rpc/rpc.h>
47 #include <rpc/auth.h>
48 #include <sys/wait.h>
49 #include <sys/param.h>
50 #include <sys/socket.h>
51 #include <rpc/key_prot.h>
52 #include <bits/libc-lock.h>
53
54 #define KEY_TIMEOUT     5       /* per-try timeout in seconds */
55 #define KEY_NRETRY      12      /* number of retries */
56
57 #define debug(msg)              /* turn off debugging */
58
59 #ifndef SO_PASSCRED
60 extern int _openchild (const char *command, FILE **fto, FILE **ffrom);
61 #endif
62
63 static int key_call (u_long, xdrproc_t xdr_arg, char *,
64                      xdrproc_t xdr_rslt, char *) internal_function;
65
66 static const struct timeval trytimeout = {KEY_TIMEOUT, 0};
67 static const struct timeval tottimeout = {KEY_TIMEOUT *KEY_NRETRY, 0};
68
69 int
70 key_setsecret (char *secretkey)
71 {
72   keystatus status;
73
74   if (!key_call ((u_long) KEY_SET, (xdrproc_t) INTUSE(xdr_keybuf), secretkey,
75                  (xdrproc_t) INTUSE(xdr_keystatus), (char *) &status))
76     return -1;
77   if (status != KEY_SUCCESS)
78     {
79       debug ("set status is nonzero");
80       return -1;
81     }
82   return 0;
83 }
84
85 /* key_secretkey_is_set() returns 1 if the keyserver has a secret key
86  * stored for the caller's effective uid; it returns 0 otherwise
87  *
88  * N.B.:  The KEY_NET_GET key call is undocumented.  Applications shouldn't
89  * be using it, because it allows them to get the user's secret key.
90  */
91 int
92 key_secretkey_is_set (void)
93 {
94   struct key_netstres kres;
95
96   memset (&kres, 0, sizeof (kres));
97   if (key_call ((u_long) KEY_NET_GET, (xdrproc_t) INTUSE(xdr_void),
98                 (char *) NULL, (xdrproc_t) INTUSE(xdr_key_netstres),
99                 (char *) &kres) &&
100       (kres.status == KEY_SUCCESS) &&
101       (kres.key_netstres_u.knet.st_priv_key[0] != 0))
102     {
103       /* avoid leaving secret key in memory */
104       memset (kres.key_netstres_u.knet.st_priv_key, 0, HEXKEYBYTES);
105       return 1;
106     }
107   return 0;
108 }
109
110 int
111 key_encryptsession (char *remotename, des_block *deskey)
112 {
113   cryptkeyarg arg;
114   cryptkeyres res;
115
116   arg.remotename = remotename;
117   arg.deskey = *deskey;
118   if (!key_call ((u_long) KEY_ENCRYPT, (xdrproc_t) INTUSE(xdr_cryptkeyarg),
119                  (char *) &arg, (xdrproc_t) INTUSE(xdr_cryptkeyres),
120                  (char *) &res))
121     return -1;
122
123   if (res.status != KEY_SUCCESS)
124     {
125       debug ("encrypt status is nonzero");
126       return -1;
127     }
128   *deskey = res.cryptkeyres_u.deskey;
129   return 0;
130 }
131
132 int
133 key_decryptsession (char *remotename, des_block *deskey)
134 {
135   cryptkeyarg arg;
136   cryptkeyres res;
137
138   arg.remotename = remotename;
139   arg.deskey = *deskey;
140   if (!key_call ((u_long) KEY_DECRYPT, (xdrproc_t) INTUSE(xdr_cryptkeyarg),
141                  (char *) &arg, (xdrproc_t) INTUSE(xdr_cryptkeyres),
142                  (char *) &res))
143     return -1;
144   if (res.status != KEY_SUCCESS)
145     {
146       debug ("decrypt status is nonzero");
147       return -1;
148     }
149   *deskey = res.cryptkeyres_u.deskey;
150   return 0;
151 }
152
153 int
154 key_encryptsession_pk (char *remotename, netobj *remotekey,
155                        des_block *deskey)
156 {
157   cryptkeyarg2 arg;
158   cryptkeyres res;
159
160   arg.remotename = remotename;
161   arg.remotekey = *remotekey;
162   arg.deskey = *deskey;
163   if (!key_call ((u_long) KEY_ENCRYPT_PK, (xdrproc_t) INTUSE(xdr_cryptkeyarg2),
164                  (char *) &arg, (xdrproc_t) INTUSE(xdr_cryptkeyres),
165                  (char *) &res))
166     return -1;
167
168   if (res.status != KEY_SUCCESS)
169     {
170       debug ("encrypt status is nonzero");
171       return -1;
172     }
173   *deskey = res.cryptkeyres_u.deskey;
174   return 0;
175 }
176 libc_hidden_def (key_encryptsession_pk)
177
178 int
179 key_decryptsession_pk (char *remotename, netobj *remotekey,
180                        des_block *deskey)
181 {
182   cryptkeyarg2 arg;
183   cryptkeyres res;
184
185   arg.remotename = remotename;
186   arg.remotekey = *remotekey;
187   arg.deskey = *deskey;
188   if (!key_call ((u_long) KEY_DECRYPT_PK, (xdrproc_t) INTUSE(xdr_cryptkeyarg2),
189                  (char *) &arg, (xdrproc_t) INTUSE(xdr_cryptkeyres),
190                  (char *) &res))
191     return -1;
192
193   if (res.status != KEY_SUCCESS)
194     {
195       debug ("decrypt status is nonzero");
196       return -1;
197     }
198   *deskey = res.cryptkeyres_u.deskey;
199   return 0;
200 }
201 libc_hidden_def (key_decryptsession_pk)
202
203 int
204 key_gendes (des_block *key)
205 {
206   struct sockaddr_in sin;
207   CLIENT *client;
208   int socket;
209   enum clnt_stat stat;
210
211   sin.sin_family = AF_INET;
212   sin.sin_port = 0;
213   sin.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
214   __bzero (sin.sin_zero, sizeof (sin.sin_zero));
215   socket = RPC_ANYSOCK;
216   client = INTUSE(clntudp_bufcreate) (&sin, (u_long) KEY_PROG,
217                                       (u_long) KEY_VERS, trytimeout, &socket,
218                                       RPCSMALLMSGSIZE, RPCSMALLMSGSIZE);
219   if (client == NULL)
220     return -1;
221
222   stat = clnt_call (client, KEY_GEN, (xdrproc_t) INTUSE(xdr_void), NULL,
223                     (xdrproc_t) INTUSE(xdr_des_block), (caddr_t) key,
224                     tottimeout);
225   clnt_destroy (client);
226   __close (socket);
227   if (stat != RPC_SUCCESS)
228     return -1;
229
230   return 0;
231 }
232 libc_hidden_def (key_gendes)
233
234 int
235 key_setnet (struct key_netstarg *arg)
236 {
237   keystatus status;
238
239   if (!key_call ((u_long) KEY_NET_PUT, (xdrproc_t) INTUSE(xdr_key_netstarg),
240                  (char *) arg,(xdrproc_t) INTUSE(xdr_keystatus),
241                  (char *) &status))
242     return -1;
243
244   if (status != KEY_SUCCESS)
245     {
246       debug ("key_setnet status is nonzero");
247       return -1;
248     }
249   return 1;
250 }
251
252 int
253 key_get_conv (char *pkey, des_block *deskey)
254 {
255   cryptkeyres res;
256
257   if (!key_call ((u_long) KEY_GET_CONV, (xdrproc_t) INTUSE(xdr_keybuf), pkey,
258                  (xdrproc_t) INTUSE(xdr_cryptkeyres), (char *) &res))
259     return -1;
260
261   if (res.status != KEY_SUCCESS)
262     {
263       debug ("get_conv status is nonzero");
264       return -1;
265     }
266   *deskey = res.cryptkeyres_u.deskey;
267   return 0;
268 }
269
270 /*
271  * Hack to allow the keyserver to use AUTH_DES (for authenticated
272  * NIS+ calls, for example).  The only functions that get called
273  * are key_encryptsession_pk, key_decryptsession_pk, and key_gendes.
274  *
275  * The approach is to have the keyserver fill in pointers to local
276  * implementations of these functions, and to call those in key_call().
277  */
278
279 cryptkeyres *(*__key_encryptsession_pk_LOCAL) (uid_t, char *);
280 cryptkeyres *(*__key_decryptsession_pk_LOCAL) (uid_t, char *);
281 des_block *(*__key_gendes_LOCAL) (uid_t, char *);
282
283 #ifndef SO_PASSCRED
284 static int
285 internal_function
286 key_call_keyenvoy (u_long proc, xdrproc_t xdr_arg, char *arg,
287                    xdrproc_t xdr_rslt, char *rslt)
288 {
289   XDR xdrargs;
290   XDR xdrrslt;
291   FILE *fargs;
292   FILE *frslt;
293   sigset_t oldmask, mask;
294   union wait status;
295   int pid;
296   int success;
297   uid_t ruid;
298   uid_t euid;
299   static const char MESSENGER[] = "/usr/etc/keyenvoy";
300
301   success = 1;
302   sigemptyset (&mask);
303   sigaddset (&mask, SIGCHLD);
304   __sigprocmask (SIG_BLOCK, &mask, &oldmask);
305
306   /*
307    * We are going to exec a set-uid program which makes our effective uid
308    * zero, and authenticates us with our real uid. We need to make the
309    * effective uid be the real uid for the setuid program, and
310    * the real uid be the effective uid so that we can change things back.
311    */
312   euid = __geteuid ();
313   ruid = __getuid ();
314   __setreuid (euid, ruid);
315   pid = _openchild (MESSENGER, &fargs, &frslt);
316   __setreuid (ruid, euid);
317   if (pid < 0)
318     {
319       debug ("open_streams");
320       __sigprocmask (SIG_SETMASK, &oldmask, NULL);
321       return (0);
322     }
323   xdrstdio_create (&xdrargs, fargs, XDR_ENCODE);
324   xdrstdio_create (&xdrrslt, frslt, XDR_DECODE);
325
326   if (!INTUSE(xdr_u_long) (&xdrargs, &proc) || !(*xdr_arg) (&xdrargs, arg))
327     {
328       debug ("xdr args");
329       success = 0;
330     }
331   fclose (fargs);
332
333   if (success && !(*xdr_rslt) (&xdrrslt, rslt))
334     {
335       debug ("xdr rslt");
336       success = 0;
337     }
338   fclose(frslt);
339
340  wait_again:
341   if (__wait4 (pid, &status, 0, NULL) < 0)
342     {
343       if (errno == EINTR)
344         goto wait_again;
345       debug ("wait4");
346       if (errno == ECHILD || errno == ESRCH)
347         perror ("wait");
348       else
349         success = 0;
350     }
351   else
352     if (status.w_retcode)
353       {
354         debug ("wait4 1");
355         success = 0;
356       }
357   __sigprocmask (SIG_SETMASK, &oldmask, NULL);
358
359   return success;
360 }
361 #endif
362
363 struct  key_call_private {
364   CLIENT  *client;        /* Client handle */
365   pid_t   pid;            /* process-id at moment of creation */
366   uid_t   uid;            /* user-id at last authorization */
367 };
368 #ifdef _RPC_THREAD_SAFE_
369 #define key_call_private_main RPC_THREAD_VARIABLE(key_call_private_s)
370 #else
371 static struct key_call_private *key_call_private_main;
372 #endif
373 __libc_lock_define_initialized (static, keycall_lock)
374
375 /*
376  * Keep the handle cached.  This call may be made quite often.
377  */
378 static CLIENT *
379 getkeyserv_handle (int vers)
380 {
381   struct key_call_private *kcp = key_call_private_main;
382   struct timeval wait_time;
383   int fd;
384   struct sockaddr_un name;
385   socklen_t namelen = sizeof(struct sockaddr_un);
386
387 #define TOTAL_TIMEOUT   30      /* total timeout talking to keyserver */
388 #define TOTAL_TRIES     5       /* Number of tries */
389
390   if (kcp == (struct key_call_private *)NULL)
391     {
392       kcp = (struct key_call_private *)malloc (sizeof (*kcp));
393       if (kcp == (struct key_call_private *)NULL)
394         return (CLIENT *) NULL;
395
396       key_call_private_main = kcp;
397       kcp->client = NULL;
398     }
399
400   /* if pid has changed, destroy client and rebuild */
401   if (kcp->client != NULL && kcp->pid != __getpid ())
402     {
403       auth_destroy (kcp->client->cl_auth);
404       clnt_destroy (kcp->client);
405       kcp->client = NULL;
406     }
407
408   if (kcp->client != NULL)
409     {
410       /* if other side closed socket, build handle again */
411       clnt_control (kcp->client, CLGET_FD, (char *)&fd);
412       if (__getpeername (fd,(struct sockaddr *)&name,&namelen) == -1)
413         {
414           auth_destroy (kcp->client->cl_auth);
415           clnt_destroy (kcp->client);
416           kcp->client = NULL;
417         }
418     }
419
420   if (kcp->client != NULL)
421     {
422       /* if uid has changed, build client handle again */
423       if (kcp->uid != __geteuid ())
424         {
425         kcp->uid = __geteuid ();
426         auth_destroy (kcp->client->cl_auth);
427         kcp->client->cl_auth =
428           INTUSE(authunix_create) ((char *)"", kcp->uid, 0, 0, NULL);
429         if (kcp->client->cl_auth == NULL)
430           {
431             clnt_destroy (kcp->client);
432             kcp->client = NULL;
433             return ((CLIENT *) NULL);
434           }
435         }
436       /* Change the version number to the new one */
437       clnt_control (kcp->client, CLSET_VERS, (void *)&vers);
438       return kcp->client;
439     }
440
441   if ((kcp->client == (CLIENT *) NULL))
442     /* Use the AF_UNIX transport */
443     kcp->client = INTUSE(clnt_create) ("/var/run/keyservsock", KEY_PROG, vers,
444                                        "unix");
445
446   if (kcp->client == (CLIENT *) NULL)
447     return (CLIENT *) NULL;
448
449   kcp->uid = __geteuid ();
450   kcp->pid = __getpid ();
451   kcp->client->cl_auth = INTUSE(authunix_create) ((char *)"", kcp->uid, 0, 0,
452                                                   NULL);
453   if (kcp->client->cl_auth == NULL)
454     {
455       clnt_destroy (kcp->client);
456       kcp->client = NULL;
457       return (CLIENT *) NULL;
458     }
459
460   wait_time.tv_sec = TOTAL_TIMEOUT/TOTAL_TRIES;
461   wait_time.tv_usec = 0;
462   clnt_control (kcp->client, CLSET_RETRY_TIMEOUT,
463                 (char *)&wait_time);
464   if (clnt_control (kcp->client, CLGET_FD, (char *)&fd))
465     __fcntl (fd, F_SETFD, 1);  /* make it "close on exec" */
466
467   return kcp->client;
468 }
469
470 /* returns  0 on failure, 1 on success */
471 static int
472 internal_function
473 key_call_socket (u_long proc, xdrproc_t xdr_arg, char *arg,
474                xdrproc_t xdr_rslt, char *rslt)
475 {
476   CLIENT *clnt;
477   struct timeval wait_time;
478   int result = 0;
479
480   __libc_lock_lock (keycall_lock);
481   if ((proc == KEY_ENCRYPT_PK) || (proc == KEY_DECRYPT_PK) ||
482       (proc == KEY_NET_GET) || (proc == KEY_NET_PUT) ||
483       (proc == KEY_GET_CONV))
484     clnt = getkeyserv_handle(2); /* talk to version 2 */
485   else
486     clnt = getkeyserv_handle(1); /* talk to version 1 */
487
488   if (clnt != NULL)
489     {
490       wait_time.tv_sec = TOTAL_TIMEOUT;
491       wait_time.tv_usec = 0;
492
493       if (clnt_call (clnt, proc, xdr_arg, arg, xdr_rslt, rslt,
494                      wait_time) == RPC_SUCCESS)
495         result = 1;
496     }
497
498   __libc_lock_unlock (keycall_lock);
499
500   return result;
501 }
502
503
504 /* returns 0 on failure, 1 on success */
505 static int
506 internal_function
507 key_call (u_long proc, xdrproc_t xdr_arg, char *arg,
508           xdrproc_t xdr_rslt, char *rslt)
509 {
510 #ifndef SO_PASSCRED
511   static int use_keyenvoy;
512 #endif
513
514   if (proc == KEY_ENCRYPT_PK && __key_encryptsession_pk_LOCAL)
515     {
516       cryptkeyres *res;
517       res = (*__key_encryptsession_pk_LOCAL) (__geteuid (), arg);
518       *(cryptkeyres *) rslt = *res;
519       return 1;
520     }
521   else if (proc == KEY_DECRYPT_PK && __key_decryptsession_pk_LOCAL)
522     {
523       cryptkeyres *res;
524       res = (*__key_decryptsession_pk_LOCAL) (__geteuid (), arg);
525       *(cryptkeyres *) rslt = *res;
526       return 1;
527     }
528   else if (proc == KEY_GEN && __key_gendes_LOCAL)
529     {
530       des_block *res;
531       res = (*__key_gendes_LOCAL) (__geteuid (), 0);
532       *(des_block *) rslt = *res;
533       return 1;
534     }
535
536 #ifdef SO_PASSCRED
537   return key_call_socket (proc, xdr_arg, arg, xdr_rslt, rslt);
538 #else
539   if (!use_keyenvoy)
540     {
541       if (key_call_socket (proc, xdr_arg, arg, xdr_rslt, rslt))
542         return 1;
543       use_keyenvoy = 1;
544     }
545   return key_call_keyenvoy (proc, xdr_arg, arg, xdr_rslt, rslt);
546 #endif
547 }
548
549 #ifdef _RPC_THREAD_SAFE_
550 void
551 __rpc_thread_key_cleanup (void)
552 {
553         struct key_call_private *kcp = RPC_THREAD_VARIABLE(key_call_private_s);
554
555         if (kcp) {
556                 if (kcp->client) {
557                         if (kcp->client->cl_auth)
558                                 auth_destroy (kcp->client->cl_auth);
559                         clnt_destroy(kcp->client);
560                 }
561                 free (kcp);
562         }
563 }
564 #endif /* _RPC_THREAD_SAFE_ */