git-svn-id: svn://svn.berlios.de/mutt-ng/trunk@56 e385b8ad-14ed-0310-8656-cc95a2468c6d
[apps/madmutt.git] / pgplib.c
1 /*
2  * Copyright (C) 1997-2000 Thomas Roessler <roessler@does-not-exist.org>
3  * 
4  *     This program is free software; you can redistribute it
5  *     and/or modify it under the terms of the GNU General Public
6  *     License as published by the Free Software Foundation; either
7  *     version 2 of the License, or (at your option) any later
8  *     version.
9  * 
10  *     This program is distributed in the hope that it will be
11  *     useful, but WITHOUT ANY WARRANTY; without even the implied
12  *     warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
13  *     PURPOSE.  See the GNU General Public License for more
14  *     details.
15  * 
16  *     You should have received a copy of the GNU General Public
17  *     License along with this program; if not, write to the Free
18  *     Software Foundation, Inc., 59 Temple Place - Suite 330,
19  *     Boston, MA  02111, USA.
20  */
21
22 /* Generally useful, pgp-related functions. */
23
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <unistd.h>
28 #include <time.h>
29
30 #include "mutt.h"
31 #include "lib.h"
32 #include "pgplib.h"
33
34 const char *pgp_pkalgbytype (unsigned char type)
35 {
36   switch (type)
37   {
38   case 1:
39     return "RSA";
40   case 2:
41     return "RSA";
42   case 3:
43     return "RSA";
44   case 16:
45     return "ElG";
46   case 17:
47     return "DSA";
48   case 20:
49     return "ElG";
50   default:
51     return "unk";
52   }
53 }
54
55
56
57 /* unused */
58
59 #if 0
60
61 static const char *hashalgbytype (unsigned char type)
62 {
63   switch (type)
64   {
65   case 1:
66     return "MD5";
67   case 2:
68     return "SHA1";
69   case 3:
70     return "RIPE-MD/160";
71   case 4:
72     return "HAVAL";
73   default:
74     return "unknown";
75   }
76 }
77
78 #endif
79
80 short pgp_canencrypt (unsigned char type)
81 {
82   switch (type)
83   {
84   case 1:
85   case 2:
86   case 16:
87   case 20:
88     return 1;
89   default:
90     return 0;
91   }
92 }
93
94 short pgp_cansign (unsigned char type)
95 {
96   switch (type)
97   {
98   case 1:
99   case 3:
100   case 17:
101   case 20:
102     return 1;
103   default:
104     return 0;
105   }
106 }
107
108 /* return values: 
109
110  * 1 = sign only
111  * 2 = encrypt only
112  * 3 = both
113  */
114
115 short pgp_get_abilities (unsigned char type)
116 {
117   return (pgp_canencrypt (type) << 1) | pgp_cansign (type);
118 }
119
120 void pgp_free_sig (pgp_sig_t **sigp)
121 {
122   pgp_sig_t *sp, *q;
123   
124   if (!sigp || !*sigp)
125     return;
126   
127   for (sp = *sigp; sp; sp = q)
128   {
129     q = sp->next;
130     FREE (&sp);
131   }
132   
133   *sigp = NULL;
134 }
135
136 void pgp_free_uid (pgp_uid_t ** upp)
137 {
138   pgp_uid_t *up, *q;
139
140   if (!upp || !*upp)
141     return;
142   for (up = *upp; up; up = q)
143   {
144     q = up->next;
145     pgp_free_sig (&up->sigs);
146     FREE (&up->addr);
147     FREE (&up);
148   }
149
150   *upp = NULL;
151 }
152
153 pgp_uid_t *pgp_copy_uids (pgp_uid_t *up, pgp_key_t parent)
154 {
155   pgp_uid_t *l = NULL;
156   pgp_uid_t **lp = &l;
157
158   for (; up; up = up->next)
159   {
160     *lp = safe_calloc (1, sizeof (pgp_uid_t));
161     (*lp)->trust  = up->trust;
162     (*lp)->flags  = up->flags;
163     (*lp)->addr   = safe_strdup (up->addr);
164     (*lp)->parent = parent;
165     lp = &(*lp)->next;
166   }
167
168   return l;
169 }
170
171 static void _pgp_free_key (pgp_key_t *kpp)
172 {
173   pgp_key_t kp;
174
175   if (!kpp || !*kpp)
176     return;
177
178   kp = *kpp;
179
180   pgp_free_uid (&kp->address);
181   FREE (&kp->keyid);
182   FREE (kpp);
183 }
184
185 pgp_key_t pgp_remove_key (pgp_key_t *klist, pgp_key_t key)
186 {
187   pgp_key_t *last;
188   pgp_key_t p, q, r;
189
190   if (!klist || !*klist || !key)
191     return NULL;
192
193   if (key->parent && key->parent != key)
194     key = key->parent;
195
196   last = klist;
197   for (p = *klist; p && p != key; p = p->next)
198     last = &p->next;
199
200   if (!p)
201     return NULL;
202
203   for (q = p->next, r = p; q && q->parent == p; q = q->next)
204     r = q;
205
206   if (r)
207     r->next = NULL;
208
209   *last = q;
210   return q;
211 }
212
213 void pgp_free_key (pgp_key_t *kpp)
214 {
215   pgp_key_t p, q, r;
216
217   if (!kpp || !*kpp)
218     return;
219
220   if ((*kpp)->parent && (*kpp)->parent != *kpp)
221     *kpp = (*kpp)->parent;
222   
223   /* Order is important here:
224    *
225    * - First free all children.
226    * - If we are an orphan (i.e., our parent was not in the key list),
227    *   free our parent.
228    * - free ourselves.
229    */
230
231   for (p = *kpp; p; p = q)
232   {
233     for (q = p->next; q && q->parent == p; q = r)
234     {
235       r = q->next;
236       _pgp_free_key (&q);
237     }
238     if (p->parent)
239       _pgp_free_key (&p->parent);
240
241     _pgp_free_key (&p);
242   }
243
244   *kpp = NULL;
245 }
246