tools: Fix option parsing for gpg-zip.
[gnupg.git] / cipher / rndegd.c
1 /* rndegd.c  -  interface to the EGD
2  *      Copyright (C) 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <assert.h>
24 #include <errno.h>
25 #include <sys/time.h>
26 #include <sys/stat.h>
27 #include <string.h>
28 #include <unistd.h>
29 #include <sys/types.h>
30 #include <sys/socket.h>
31 #include <sys/un.h>
32 #include "types.h"
33 #include "util.h"
34 #include "ttyio.h"
35 #include "algorithms.h"
36 #include "cipher.h"
37 #include "i18n.h"
38
39
40 #ifndef offsetof
41 #define offsetof(type, member) ((size_t) &((type *)0)->member)
42 #endif
43
44 static int egd_socket = -1;
45
46 static int
47 do_write( int fd, void *buf, size_t nbytes )
48 {
49     size_t nleft = nbytes;
50     int nwritten;
51
52     while( nleft > 0 ) {
53         nwritten = write( fd, buf, nleft);
54         if( nwritten < 0 ) {
55             if( errno == EINTR )
56                 continue;
57             return -1;
58         }
59         nleft -= nwritten;
60         buf = (char*)buf + nwritten;
61     }
62     return 0;
63 }
64
65 static int
66 do_read( int fd, void *buf, size_t nbytes )
67 {
68   int n, nread = 0;
69   
70   while (nbytes)
71     {
72       do {
73         n = read(fd, (char*)buf + nread, nbytes );
74       } while( n == -1 && errno == EINTR );
75       if( n == -1 )
76         return nread? nread:-1;
77       else if( n == 0 ) {
78         /* EGD probably died. */
79         errno = ECONNRESET;
80         return -1;
81       }
82       nread += n;
83       nbytes -= n;
84     } 
85   return nread;
86 }
87
88 /* Connect to the EGD and return the file descriptor.  Return -1 on
89    error.  With NOFAIL set to true, silently fail and return the
90    error, otherwise print an error message and die. */
91 int
92 rndegd_connect_socket (int nofail)
93 {
94   int fd;
95   const char *bname = NULL;
96   char *name;
97   struct sockaddr_un addr;
98   int addr_len;
99
100   if (egd_socket != -1)
101     {
102       close (egd_socket);
103       egd_socket = -1;
104     }
105
106 #ifdef EGD_SOCKET_NAME
107   bname = EGD_SOCKET_NAME;
108 #endif
109   if ( !bname || !*bname )
110     bname = "=entropy";
111   
112   if ( *bname == '=' && bname[1] )
113     name = make_filename( g10_opt_homedir, bname+1 , NULL );
114   else
115     name = make_filename( bname , NULL );
116   
117   if ( strlen(name)+1 >= sizeof addr.sun_path ) 
118     g10_log_fatal ("EGD socketname is too long\n");
119   
120   memset( &addr, 0, sizeof addr );
121   addr.sun_family = AF_UNIX;
122   strcpy( addr.sun_path, name );          
123   addr_len = (offsetof( struct sockaddr_un, sun_path )
124               + strlen( addr.sun_path ));
125   
126   fd = socket(AF_UNIX, SOCK_STREAM, 0);
127   if (fd == -1 && !nofail)
128     g10_log_fatal("can't create unix domain socket: %s\n",
129                   strerror(errno) );
130   else if (connect (fd, (struct sockaddr*)&addr, addr_len) == -1)
131     {
132       if (!nofail)
133         g10_log_fatal("can't connect to `%s': %s\n",
134                       name, strerror(errno) );
135       close (fd);
136       fd = -1;
137     }
138   xfree(name);
139   if (fd != -1)
140     egd_socket = fd;
141   return fd;
142 }
143
144
145 /****************
146  * Note: we always use the highest level.
147  * TO boost the performance we may want to add some
148  * additional code for level 1
149  *
150  * Using a level of 0 should never block and better add nothing
151  * to the pool.  So this is just a dummy for EGD.
152  */
153 int
154 rndegd_gather_random( void (*add)(const void*, size_t, int), int requester,
155                                           size_t length, int level )
156 {
157     int fd = egd_socket;
158     int n;
159     byte buffer[256+2];
160     int nbytes;
161     int do_restart = 0;
162
163     if( !length )
164         return 0;
165     if( !level )
166         return 0;
167
168   restart:
169     if (fd == -1 || do_restart)
170       fd = rndegd_connect_socket (0);
171
172     do_restart = 0;
173
174     nbytes = length < 255? length : 255;
175     /* first time we do it with a non blocking request */
176     buffer[0] = 1; /* non blocking */
177     buffer[1] = nbytes;
178     if( do_write( fd, buffer, 2 ) == -1 )
179         g10_log_fatal("can't write to the EGD: %s\n", strerror(errno) );
180     n = do_read( fd, buffer, 1 );
181     if( n == -1 ) {
182         g10_log_error("read error on EGD: %s\n", strerror(errno));
183         do_restart = 1;
184         goto restart;
185     }
186     n = buffer[0];
187     if( n ) {
188         n = do_read( fd, buffer, n );
189         if( n == -1 ) {
190             g10_log_error("read error on EGD: %s\n", strerror(errno));
191             do_restart = 1;
192             goto restart;
193         }
194         (*add)( buffer, n, requester );
195         length -= n;
196     }
197
198     if( length ) {
199         tty_printf(
200          _("Please wait, entropy is being gathered. Do some work if it would\n"
201            "keep you from getting bored, because it will improve the quality\n"
202            "of the entropy.\n") );
203     }
204     while( length ) {
205         nbytes = length < 255? length : 255;
206
207         buffer[0] = 2; /* blocking */
208         buffer[1] = nbytes;
209         if( do_write( fd, buffer, 2 ) == -1 )
210             g10_log_fatal("can't write to the EGD: %s\n", strerror(errno) );
211         n = do_read( fd, buffer, nbytes );
212         if( n == -1 ) {
213             g10_log_error("read error on EGD: %s\n", strerror(errno));
214             do_restart = 1;
215             goto restart;
216         }
217         (*add)( buffer, n, requester );
218         length -= n;
219     }
220     wipememory(buffer, sizeof(buffer) );
221
222     return 0; /* success */
223 }