See ChangeLog: Wed Apr 7 20:51:39 CEST 1999 Werner Koch
[gnupg.git] / g10 / misc.c
1 /* misc.c -  miscellaneous functions
2  *      Copyright (C) 1998, 1999 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 2 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, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #if defined(__linux__) && defined(__alpha__) && __GLIBC__ < 2
27   #include <asm/sysinfo.h>
28   #include <asm/unistd.h>
29 #endif
30 #ifdef HAVE_SETRLIMIT
31   #include <sys/time.h>
32   #include <sys/resource.h>
33 #endif
34 #include "util.h"
35 #include "main.h"
36 #include "options.h"
37 #include "i18n.h"
38
39
40 const char *g10m_revision_string(int);
41 const char *g10c_revision_string(int);
42 const char *g10u_revision_string(int);
43
44 volatile void
45 pull_in_libs(void)
46 {
47     g10m_revision_string(0);
48     g10c_revision_string(0);
49     g10u_revision_string(0);
50 }
51
52
53 #if defined(__linux__) && defined(__alpha__) && __GLIBC__ < 2
54 #warning using trap_unaligned
55 static int
56 setsysinfo(unsigned long op, void *buffer, unsigned long size,
57                      int *start, void *arg, unsigned long flag)
58 {
59     return syscall(__NR_osf_setsysinfo, op, buffer, size, start, arg, flag);
60 }
61
62 void
63 trap_unaligned(void)
64 {
65     unsigned int buf[2];
66
67     buf[0] = SSIN_UACPROC;
68     buf[1] = UAC_SIGBUS | UAC_NOPRINT;
69     setsysinfo(SSI_NVPAIRS, buf, 1, 0, 0, 0);
70 }
71 #else
72 void
73 trap_unaligned(void)
74 {  /* dummy */
75 }
76 #endif
77
78
79 void
80 disable_core_dumps()
81 {
82   #ifdef HAVE_SETRLIMIT
83     struct rlimit limit;
84
85     limit.rlim_cur = 0;
86     limit.rlim_max = 0;
87     if( !setrlimit( RLIMIT_CORE, &limit ) )
88         return;
89     if( errno != EINVAL )
90         log_fatal(_("can't disable core dumps: %s\n"), strerror(errno) );
91   #endif
92     if( !opt.quiet )
93         log_info(_("WARNING: program may create a core file!\n"));
94 }
95
96
97
98 u16
99 checksum_u16( unsigned n )
100 {
101     u16 a;
102
103     a  = (n >> 8) & 0xff;
104     if( opt.emulate_bugs & EMUBUG_GPGCHKSUM ) {
105        a |= n & 0xff;
106        log_debug("csum_u16 emulated for n=%u\n", n);
107     }
108     else
109        a += n & 0xff;
110     return a;
111 }
112
113 static u16
114 checksum_u16_nobug( unsigned n )
115 {
116     u16 a;
117
118     a  = (n >> 8) & 0xff;
119     a += n & 0xff;
120     return a;
121 }
122
123 u16
124 checksum( byte *p, unsigned n )
125 {
126     u16 a;
127
128     for(a=0; n; n-- )
129         a += *p++;
130     return a;
131 }
132
133 u16
134 checksum_mpi( MPI a )
135 {
136     u16 csum;
137     byte *buffer;
138     unsigned nbytes;
139     unsigned nbits;
140
141     buffer = mpi_get_buffer( a, &nbytes, NULL );
142     /* some versions of gpg encode wrong values for the length of an mpi
143      * so that mpi_get_nbits() which counts the mpi yields another (shorter)
144      * value than the one store with the mpi.  mpi_get_nbit_info() returns
145      * this stored value if it is still available.
146      */
147
148     if( opt.emulate_bugs & EMUBUG_GPGCHKSUM )
149         nbits = 0;
150     else
151         nbits = mpi_get_nbit_info(a);
152     if( !nbits )
153        nbits = mpi_get_nbits(a);
154     csum = checksum_u16( nbits );
155     csum += checksum( buffer, nbytes );
156     m_free( buffer );
157     return csum;
158 }
159
160 /****************
161  * This is the correct function
162  */
163 u16
164 checksum_mpi_counted_nbits( MPI a )
165 {
166     u16 csum;
167     byte *buffer;
168     unsigned nbytes;
169     unsigned nbits;
170
171     buffer = mpi_get_buffer( a, &nbytes, NULL );
172     nbits = mpi_get_nbits(a);
173     mpi_set_nbit_info(a,nbits);
174     csum = checksum_u16_nobug( nbits );
175     csum += checksum( buffer, nbytes );
176     m_free( buffer );
177     return csum;
178 }
179
180
181 u32
182 buffer_to_u32( const byte *buffer )
183 {
184     unsigned long a;
185     a =  *buffer << 24;
186     a |= buffer[1] << 16;
187     a |= buffer[2] << 8;
188     a |= buffer[3];
189     return a;
190 }
191
192
193 static void
194 no_exp_algo(void)
195 {
196     static int did_note = 0;
197
198     if( !did_note ) {
199         did_note = 1;
200         log_info(_("Experimental algorithms should not be used!\n"));
201     }
202 }
203
204 void
205 print_pubkey_algo_note( int algo )
206 {
207     if( algo >= 100 && algo <= 110 )
208         no_exp_algo();
209     else if( is_RSA( algo ) ) {
210         static int did_note = 0;
211
212         if( !did_note ) {
213             did_note = 1;
214             log_info(_("RSA keys are deprecated; please consider "
215                        "creating a new key and use this key in the future\n"));
216         }
217     }
218 }
219
220 void
221 print_cipher_algo_note( int algo )
222 {
223     if( algo >= 100 && algo <= 110 )
224         no_exp_algo();
225     else if(    algo == CIPHER_ALGO_3DES
226              || algo == CIPHER_ALGO_CAST5
227              || algo == CIPHER_ALGO_BLOWFISH
228              || algo == CIPHER_ALGO_TWOFISH
229            )
230         ;
231     else {
232         static int did_note = 0;
233
234         if( !did_note ) {
235             did_note = 1;
236             log_info(_("this cipher algorithm is depreciated; "
237                        "please use a more standard one!\n"));
238         }
239     }
240 }
241
242 void
243 print_digest_algo_note( int algo )
244 {
245     if( algo >= 100 && algo <= 110 )
246         no_exp_algo();
247 }
248
249
250