fedora core 6 1.2949 + vserver 2.2.0
[linux-2.6.git] / crypto / mpi / mpiutil.c
1 /* mpiutil.ac  -  Utility functions for MPI
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 "mpi-internal.h"
22
23
24 /****************
25  * Note:  It was a bad idea to use the number of limbs to allocate
26  *        because on a alpha the limbs are large but we normally need
27  *        integers of n bits - So we should chnage this to bits (or bytes).
28  *
29  *        But mpi_alloc is used in a lot of places :-)
30  */
31 MPI mpi_alloc(unsigned nlimbs)
32 {
33         MPI a;
34
35         a = (MPI) kmalloc(sizeof *a,GFP_KERNEL);
36         if (!a)
37                 return a;
38
39         if (nlimbs) {
40                 a->d = mpi_alloc_limb_space(nlimbs);
41                 if (!a->d) {
42                         kfree(a);
43                         return NULL;
44                 }
45         }
46         else {
47                 a->d = NULL;
48         }
49
50         a->alloced = nlimbs;
51         a->nlimbs = 0;
52         a->sign = 0;
53         a->flags = 0;
54         a->nbits = 0;
55         return a;
56 }
57
58 mpi_ptr_t mpi_alloc_limb_space( unsigned nlimbs )
59 {
60     size_t len = nlimbs * sizeof(mpi_limb_t);
61
62     return kmalloc(len,GFP_KERNEL);
63 }
64
65 void mpi_free_limb_space( mpi_ptr_t a )
66 {
67     if( !a )
68         return;
69
70     kfree(a);
71 }
72
73
74 void mpi_assign_limb_space(MPI a, mpi_ptr_t ap, unsigned nlimbs)
75 {
76     mpi_free_limb_space(a->d);
77     a->d = ap;
78     a->alloced = nlimbs;
79 }
80
81 /****************
82  * Resize the array of A to NLIMBS. the additional space is cleared
83  * (set to 0) [done by m_realloc()]
84  */
85 int mpi_resize(MPI a, unsigned nlimbs)
86 {
87         void *p;
88
89         if (nlimbs <= a->alloced)
90                 return 0; /* no need to do it */
91
92         if (a->d) {
93                 p = kmalloc(nlimbs * sizeof(mpi_limb_t), GFP_KERNEL);
94                 if (!p)
95                         return -ENOMEM;
96                 memcpy(p, a->d, a->alloced * sizeof(mpi_limb_t));
97                 kfree(a->d);
98                 a->d = p;
99         } else {
100                 a->d = kzalloc( nlimbs * sizeof(mpi_limb_t), GFP_KERNEL);
101                 if (!a->d)
102                         return -ENOMEM;
103         }
104         a->alloced = nlimbs;
105         return 0;
106 }
107
108 void mpi_clear(MPI a)
109 {
110         a->nlimbs = 0;
111         a->nbits = 0;
112         a->flags = 0;
113 }
114
115 void mpi_free(MPI a)
116 {
117         if (!a)
118                 return;
119
120         if (a->flags & 4)
121                 kfree(a->d);
122         else {
123                 mpi_free_limb_space(a->d);
124         }
125
126         if (a->flags & ~7 )
127                 printk("invalid flag value in mpi\n");
128         kfree(a);
129 }
130
131
132 /****************
133  * Note: This copy function should not interpret the MPI
134  *       but copy it transparently.
135  */
136 int mpi_copy(MPI *copied, const MPI a )
137 {
138         size_t i;
139         MPI b;
140
141         *copied = MPI_NULL;
142
143         if ( a ) {
144                 b = mpi_alloc( a->nlimbs );
145                 if (!b)
146                         return -ENOMEM;
147
148                 b->nlimbs = a->nlimbs;
149                 b->sign = a->sign;
150                 b->flags  = a->flags;
151                 b->nbits = a->nbits;
152
153                 for (i = 0; i < b->nlimbs; i++ )
154                         b->d[i] = a->d[i];
155
156                 *copied = b;
157         }
158
159         return 0;
160 }
161
162
163 int mpi_set(MPI w, const MPI u)
164 {
165         mpi_ptr_t wp, up;
166         mpi_size_t usize = u->nlimbs;
167         int usign = u->sign;
168
169         if (RESIZE_IF_NEEDED(w, (size_t) usize) < 0)
170                 return -ENOMEM;
171
172         wp = w->d;
173         up = u->d;
174         MPN_COPY(wp, up, usize);
175         w->nlimbs = usize;
176         w->nbits = u->nbits;
177         w->flags = u->flags;
178         w->sign = usign;
179         return 0;
180 }
181
182
183 int mpi_set_ui(MPI w, unsigned long u)
184 {
185         if (RESIZE_IF_NEEDED(w, 1) < 0)
186                 return -ENOMEM;
187         w->d[0] = u;
188         w->nlimbs = u? 1:0;
189         w->sign = 0;
190         w->nbits = 0;
191         w->flags = 0;
192         return 0;
193 }
194
195 MPI mpi_alloc_set_ui(unsigned long u)
196 {
197         MPI w = mpi_alloc(1);
198         if (!w)
199                 return w;
200         w->d[0] = u;
201         w->nlimbs = u? 1:0;
202         w->sign = 0;
203         return w;
204 }
205
206
207 void mpi_swap(MPI a, MPI b)
208 {
209         struct gcry_mpi tmp;
210
211         tmp = *a; *a = *b; *b = tmp;
212 }
213