Release 0.1.4
[gpgme.git] / gpgme / trustlist.c
1 /* trustlist.c -  key listing
2  *      Copyright (C) 2000 Werner Koch (dd9jn)
3  *
4  * This file is part of GPGME.
5  *
6  * GPGME 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  * GPGME 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 <time.h>
26 #include <assert.h>
27
28 #include "util.h"
29 #include "context.h"
30 #include "ops.h"
31
32 #define my_isdigit(a) ( (a) >='0' && (a) <= '9' )
33
34 struct gpgme_trust_item_s {
35     int level;
36     char keyid[16+1];
37     int type;   
38     char ot[2];
39     char val[2];
40     char *name;
41 };
42
43
44 static GpgmeTrustItem
45 trust_item_new (void)
46 {
47     GpgmeTrustItem item;
48
49     item = xtrycalloc (1, sizeof *item);
50     return item;
51 }
52
53
54
55 static void
56 trustlist_status_handler ( GpgmeCtx ctx, GpgStatusCode code, char *args )
57 {
58     if ( ctx->out_of_core )
59         return;
60
61     switch (code) {
62       case STATUS_EOF:
63         break;
64
65       default:
66         break;
67     }
68 }
69
70
71
72 /* 
73  * This handler is used to parse the output of --list-trust-path:
74  * Format:
75  *   level:keyid:type:recno:ot:val:mc:cc:name:
76  * With TYPE = U for a user ID
77  *             K for a key
78  * The RECNO is either the one of the dir record or the one of the uid record.
79  * OT is the the usual trust letter and only availabel on K lines.
80  * VAL is the calcualted validity
81  * MC is the marginal trust counter and only available on U lines
82  * CC is the same for the complete count
83  * NAME ist the username and only printed on U lines
84  */
85 static void
86 trustlist_colon_handler ( GpgmeCtx ctx, char *line )
87 {
88     char *p, *pend;
89     int field = 0;
90     GpgmeTrustItem item = NULL;
91     struct trust_queue_item_s *q, *q2;
92
93     if ( ctx->out_of_core )
94         return;
95     if (!line)
96         return; /* EOF */
97
98     for (p = line; p; p = pend) {
99         field++;
100         pend = strchr (p, ':');
101         if (pend) 
102             *pend++ = 0;
103
104         switch (field) {
105           case 1: /* level */
106             q = xtrymalloc ( sizeof *q );
107             if ( !q ) {
108                 ctx->out_of_core = 1;
109                 return;
110             }
111             q->next = NULL;
112             q->item = item = trust_item_new ();
113             if (!q->item) {
114                 xfree (q);
115                 ctx->out_of_core = 1;
116                 return;
117             }
118             /* fixme: lock queue, keep a tail pointer */
119             if ( !(q2 = ctx->trust_queue) )
120                 ctx->trust_queue = q;
121             else {
122                 for ( ; q2->next; q2 = q2->next )
123                     ;
124                 q2->next = q;
125             }
126             /* fixme: unlock queue */
127             item->level = atoi (p);
128             break;
129           case 2: /* long keyid */
130             if ( strlen (p) == DIM(item->keyid)-1 )
131                 strcpy (item->keyid, p);
132             break;
133           case 3: /* type */
134             item->type = *p == 'K'? 1 : *p == 'U'? 2 : 0;
135             break;
136           case 5: /* owner trust */
137             item->ot[0] = *p;
138             item->ot[1] = 0;
139             break;
140           case 6: /* validity */
141             item->val[0] = *p;
142             item->val[1] = 0;
143             break;
144           case 9: /* user ID */
145             item->name = xtrystrdup (p);
146             if (!item->name)
147                 ctx->out_of_core = 1;
148             break;
149         }
150     }
151
152     if (field)
153         ctx->key_cond = 1;
154 }
155
156
157
158 GpgmeError
159 gpgme_op_trustlist_start ( GpgmeCtx c, const char *pattern, int max_level )
160 {
161     GpgmeError rc = 0;
162
163     fail_on_pending_request( c );
164     if ( !pattern || !*pattern ) {
165         return mk_error (Invalid_Value);
166     }
167
168     c->pending = 1;
169
170     _gpgme_release_result (c);
171     c->out_of_core = 0;
172
173     if ( c->gpg ) {
174         _gpgme_gpg_release ( c->gpg ); 
175         c->gpg = NULL;
176     }
177     
178     rc = _gpgme_gpg_new ( &c->gpg );
179     if (rc)
180         goto leave;
181
182     _gpgme_gpg_set_status_handler ( c->gpg, trustlist_status_handler, c );
183     rc = _gpgme_gpg_set_colon_line_handler ( c->gpg,
184                                              trustlist_colon_handler, c );
185     if (rc)
186         goto leave;
187
188     /* build the commandline */
189     _gpgme_gpg_add_arg ( c->gpg, "--with-colons" );
190     _gpgme_gpg_add_arg ( c->gpg, "--list-trust-path" );
191     
192     /* Tell the gpg object about the data */
193     _gpgme_gpg_add_arg ( c->gpg, "--" );
194     _gpgme_gpg_add_arg ( c->gpg, pattern );
195
196     /* and kick off the process */
197     rc = _gpgme_gpg_spawn ( c->gpg, c );
198
199  leave:
200     if (rc) {
201         c->pending = 0; 
202         _gpgme_gpg_release ( c->gpg ); c->gpg = NULL;
203     }
204     return rc;
205 }
206
207
208 GpgmeError
209 gpgme_op_trustlist_next ( GpgmeCtx c, GpgmeTrustItem *r_item )
210 {
211     struct trust_queue_item_s *q;
212
213     if (!r_item)
214         return mk_error (Invalid_Value);
215     *r_item = NULL;
216     if (!c)
217         return mk_error (Invalid_Value);
218     if ( !c->pending )
219         return mk_error (No_Request);
220     if ( c->out_of_core )
221         return mk_error (Out_Of_Core);
222
223     if ( !c->trust_queue ) {
224         _gpgme_wait_on_condition (c, 1, &c->key_cond );
225         if ( c->out_of_core )
226             return mk_error (Out_Of_Core);
227         if ( !c->key_cond )
228             return mk_error (EOF);
229         c->key_cond = 0; 
230         assert ( c->trust_queue );
231     }
232     q = c->trust_queue;
233     c->trust_queue = q->next;
234
235     *r_item = q->item;
236     xfree (q);
237     return 0;
238 }
239
240
241 void
242 gpgme_trust_item_release ( GpgmeTrustItem item )
243 {
244     if (!item)
245         return;
246     xfree (item->name);
247     xfree (item);
248 }
249
250
251 const char *
252 gpgme_trust_item_get_string_attr ( GpgmeTrustItem item, GpgmeAttr what,
253                                    const void *reserved, int idx )
254 {
255     const char *val = NULL;
256
257     if (!item)
258         return NULL;
259     if (reserved)
260         return NULL;
261     if (idx)
262         return NULL;
263
264     switch (what) {
265       case GPGME_ATTR_KEYID:
266         val = item->keyid;
267         break;
268       case GPGME_ATTR_OTRUST:  
269         val = item->ot;
270         break;
271       case GPGME_ATTR_VALIDITY:
272         val = item->val;
273         break;
274       case GPGME_ATTR_USERID:  
275         val = item->name;
276         break;
277       default:
278         break;
279     }
280     return val;
281 }
282
283
284 int
285 gpgme_trust_item_get_int_attr ( GpgmeTrustItem item, GpgmeAttr what,
286                                 const void *reserved, int idx )
287 {
288     int val = 0;
289
290     if (!item)
291         return 0;
292     if (reserved)
293         return 0;
294     if (idx)
295         return 0;
296
297     switch (what) {
298       case GPGME_ATTR_LEVEL:    
299         val = item->level;
300         break;
301       case GPGME_ATTR_TYPE:    
302         val = item->type;
303         break;
304       default:
305         break;
306     }
307     return val;
308 }
309