See ChangeLog: Thu Feb 25 18:47:39 CET 1999 Werner Koch
[gnupg.git] / g10 / pkclist.c
1 /* pkclist.c
2  *      Copyright (C) 1998 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 #include <assert.h>
27
28 #include "options.h"
29 #include "packet.h"
30 #include "errors.h"
31 #include "keydb.h"
32 #include "memory.h"
33 #include "util.h"
34 #include "trustdb.h"
35 #include "ttyio.h"
36 #include "status.h"
37 #include "i18n.h"
38
39
40 #define CONTROL_D ('D' - 'A' + 1)
41
42
43 static void
44 show_paths( ulong lid, int only_first )
45 {
46     void *context = NULL;
47     unsigned otrust, validity;
48     int last_level, level;
49
50     last_level = 0;
51     while( (level=enum_cert_paths( &context, &lid, &otrust, &validity)) != -1){
52         char *p;
53         int rc;
54         size_t n;
55         u32 keyid[2];
56         PKT_public_key *pk ;
57
58         if( level < last_level && only_first )
59             break;
60         last_level = level;
61
62         rc = keyid_from_lid( lid, keyid );
63         if( rc ) {
64             log_error("ooops: can't get keyid for lid %lu\n", lid);
65             return;
66         }
67
68         pk = m_alloc_clear( sizeof *pk );
69         rc = get_pubkey( pk, keyid );
70         if( rc ) {
71             log_error("key %08lX: public key not found: %s\n",
72                                     (ulong)keyid[1], g10_errstr(rc) );
73             return;
74         }
75
76         tty_printf("%*s%4u%c/%08lX.%lu %s \"",
77                   level*2, "",
78                   nbits_from_pk( pk ), pubkey_letter( pk->pubkey_algo ),
79                   (ulong)keyid[1], lid, datestr_from_pk( pk ) );
80      #if 0
81         c = trust_letter(otrust);
82         if( c )
83             putchar( c );
84         else
85             printf( "%02x", otrust );
86         putchar('/');
87         c = trust_letter(validity);
88         if( c )
89             putchar( c );
90         else
91             printf( "%02x", validity );
92         putchar(' ');
93       #endif
94
95
96         p = get_user_id( keyid, &n );
97         tty_print_string( p, n ),
98         m_free(p);
99         tty_printf("\"\n");
100         free_public_key( pk );
101     }
102     enum_cert_paths( &context, NULL, NULL, NULL ); /* release context */
103     tty_printf("\n");
104 }
105
106
107
108
109 /****************
110  * Returns true if an ownertrust has changed.
111  */
112 int
113 edit_ownertrust( ulong lid, int mode )
114 {
115     char *p;
116     int rc;
117     size_t n;
118     u32 keyid[2];
119     PKT_public_key *pk ;
120     int changed=0;
121     int quit=0;
122
123     rc = keyid_from_lid( lid, keyid );
124     if( rc ) {
125         log_error("ooops: can't get keyid for lid %lu\n", lid);
126         return 0;
127     }
128
129     pk = m_alloc_clear( sizeof *pk );
130     rc = get_pubkey( pk, keyid );
131     if( rc ) {
132         log_error("key %08lX: public key not found: %s\n",
133                                 (ulong)keyid[1], g10_errstr(rc) );
134         return 0;
135     }
136
137     if( !mode ) {
138         tty_printf(_("No trust value assigned to %lu:\n"
139                    "%4u%c/%08lX %s \""), lid,
140                   nbits_from_pk( pk ), pubkey_letter( pk->pubkey_algo ),
141                   (ulong)keyid[1], datestr_from_pk( pk ) );
142         p = get_user_id( keyid, &n );
143         tty_print_string( p, n ),
144         m_free(p);
145         tty_printf("\"\n\n");
146     }
147     tty_printf(_(
148 "Please decide how far you trust this user to correctly\n"
149 "verify other users' keys (by looking at passports,\n"
150 "checking fingerprints from different sources...)?\n\n"
151 " 1 = Don't know\n"
152 " 2 = I do NOT trust\n"
153 " 3 = I trust marginally\n"
154 " 4 = I trust fully\n"
155 " s = please show me more information\n") );
156     if( mode )
157         tty_printf(_(" m = back to the main menu\n"));
158     else
159         tty_printf(_(" q = quit\n"));
160     tty_printf("\n");
161
162     for(;;) {
163         /* a string with valid answers */
164         char *ans = _("sSmMqQ");
165
166         if( strlen(ans) != 6 )
167             BUG();
168         p = cpr_get("edit_ownertrust.value",_("Your decision? "));
169         trim_spaces(p);
170         cpr_kill_prompt();
171         if( *p && p[1] )
172             ;
173         else if( !p[1] && (*p >= '1' && *p <= '4') ) {
174             unsigned trust;
175             switch( *p ) {
176               case '1': trust = TRUST_UNDEFINED; break;
177               case '2': trust = TRUST_NEVER    ; break;
178               case '3': trust = TRUST_MARGINAL ; break;
179               case '4': trust = TRUST_FULLY    ; break;
180               default: BUG();
181             }
182             if( !update_ownertrust( lid, trust ) )
183                 changed++;
184             break;
185         }
186         else if( *p == ans[0] || *p == ans[1] ) {
187             tty_printf(_(
188                 "Certificates leading to an ultimately trusted key:\n"));
189             show_paths( lid, 1  );
190         }
191         else if( mode && (*p == ans[2] || *p == ans[3] || *p == CONTROL_D ) ) {
192             break ; /* back to the menu */
193         }
194         else if( !mode && (*p == ans[4] || *p == ans[5] ) ) {
195             quit = 1;
196             break ; /* back to the menu */
197         }
198         m_free(p); p = NULL;
199     }
200     m_free(p);
201     m_free(pk);
202     return quit? -1 : changed;
203 }
204
205
206 /****************
207  * Try to add some more owner trusts (interactive)
208  * This function presents all the signator in a certificate
209  * chain who have no trust value assigned.
210  * Returns: -1 if no ownertrust were added.
211  */
212 static int
213 add_ownertrust( PKT_public_key *pk, int *quit )
214 {
215     int rc;
216     void *context = NULL;
217     ulong lid;
218     unsigned otrust, validity;
219     int any=0, changed=0, any_undefined=0;
220
221     *quit = 0;
222     tty_printf(
223 _("Could not find a valid trust path to the key.  Let's see whether we\n"
224   "can assign some missing owner trust values.\n\n"));
225
226     rc = query_trust_record( pk );
227     if( rc ) {
228         log_error("Ooops: not in trustdb\n");
229         return -1;
230     }
231
232     lid = pk->local_id;
233     while( enum_cert_paths( &context, &lid, &otrust, &validity ) != -1 ) {
234         if( lid == pk->local_id )
235             continue;
236         any=1;
237         if( changed ) {
238             /* because enum_cert_paths() makes a snapshop of the
239              * trust paths, the otrust and validity are not anymore
240              * valid after changing an entry - we have to reread
241              * those values from then on
242              */
243             otrust = get_ownertrust( lid );
244         }
245         if( otrust == TRUST_UNDEFINED ) {
246             any_undefined=1;
247             enum_cert_paths_print( &context, NULL, changed, lid );
248             tty_printf("\n");
249             rc = edit_ownertrust( lid, 0 );
250             if( rc == -1 ) {
251                 *quit = 1;
252                 break;
253             }
254             else if( rc > 0 )
255                changed = 1;
256         }
257     }
258     enum_cert_paths( &context, NULL, NULL, NULL ); /* release context */
259
260     if( !any )
261         tty_printf(_("No path leading to one of our keys found.\n\n") );
262     else if( !any_undefined )
263         tty_printf(_("No certificates with undefined trust found.\n\n") );
264     else if( !changed )
265         tty_printf(_("No trust values changed.\n\n") );
266
267     return changed? 0:-1;
268 }
269
270 /****************
271  * Check whether we can trust this pk which has a trustlevel of TRUSTLEVEL
272  * Returns: true if we trust.
273  */
274 static int
275 do_we_trust( PKT_public_key *pk, int trustlevel )
276 {
277     int rc;
278
279     if( (trustlevel & TRUST_FLAG_REVOKED) ) {
280         log_info(_("key %08lX: key has been revoked!\n"),
281                                         (ulong)keyid_from_pk( pk, NULL) );
282         if( opt.batch )
283             return 0;
284
285         if( !cpr_get_answer_is_yes("revoked_key.override",
286                                     _("Use this key anyway? ")) )
287             return 0;
288     }
289
290
291     switch( (trustlevel & TRUST_MASK) ) {
292       case TRUST_UNKNOWN: /* No pubkey in trustDB: Insert and check again */
293         rc = insert_trust_record( pk );
294         if( rc ) {
295             log_error("failed to insert it into the trustdb: %s\n",
296                                                       g10_errstr(rc) );
297             return 0; /* no */
298         }
299         rc = check_trust( pk, &trustlevel );
300         if( rc )
301             log_fatal("trust check after insert failed: %s\n",
302                                                       g10_errstr(rc) );
303         if( trustlevel == TRUST_UNKNOWN || trustlevel == TRUST_EXPIRED )
304             BUG();
305         return do_we_trust( pk, trustlevel );
306
307       case TRUST_EXPIRED:
308         log_info(_("%08lX: key has expired\n"),
309                                     (ulong)keyid_from_pk( pk, NULL) );
310         return 0; /* no */
311
312       case TRUST_UNDEFINED:
313         if( opt.batch || opt.answer_no )
314             log_info(_("%08lX: no info to calculate a trust probability\n"),
315                                         (ulong)keyid_from_pk( pk, NULL) );
316         else {
317             int quit;
318
319             rc = add_ownertrust( pk, &quit );
320             if( !rc && !quit ) {
321                 rc = check_trust( pk, &trustlevel );
322                 if( rc )
323                     log_fatal("trust check after add_ownertrust failed: %s\n",
324                                                               g10_errstr(rc) );
325                 /* fixme: this is recursive; we should unroll it */
326                 return do_we_trust( pk, trustlevel );
327             }
328         }
329         return 0;
330
331       case TRUST_NEVER:
332         log_info(_("%08lX: We do NOT trust this key\n"),
333                                         (ulong)keyid_from_pk( pk, NULL) );
334         return 0; /* no */
335
336       case TRUST_MARGINAL:
337         log_info(
338        _("%08lX: It is not sure that this key really belongs to the owner\n"
339          "but it is accepted anyway\n"), (ulong)keyid_from_pk( pk, NULL) );
340         return 1; /* yes */
341
342       case TRUST_FULLY:
343         if( opt.verbose )
344             log_info(_("This key probably belongs to the owner\n"));
345         return 1; /* yes */
346
347       case TRUST_ULTIMATE:
348         if( opt.verbose )
349             log_info(_("This key belongs to us\n"));
350         return 1; /* yes */
351
352       default: BUG();
353     }
354
355
356     /* Eventuell fragen falls der trustlevel nicht ausreichend ist */
357
358
359     return 1; /* yes */
360 }
361
362
363 /****************
364  * wrapper around do_we_trust, so we can ask whether to use the
365  * key anyway.
366  */
367 static int
368 do_we_trust_pre( PKT_public_key *pk, int trustlevel )
369 {
370     int rc;
371
372     rc = do_we_trust( pk, trustlevel );
373
374     if( (trustlevel & TRUST_FLAG_REVOKED) && !rc )
375         return 0;
376     else if( !opt.batch && !rc ) {
377         tty_printf(_(
378 "It is NOT certain that the key belongs to its owner.\n"
379 "If you *really* know what you are doing, you may answer\n"
380 "the next question with yes\n\n") );
381
382         if( cpr_get_answer_is_yes("untrusted_key.override",
383                                   _("Use this key anyway? "))  )
384             rc = 1;
385     }
386     else if( opt.always_trust && !rc ) {
387         log_info(_("WARNING: Using untrusted key!\n"));
388         rc = 1;
389     }
390     return rc;
391 }
392
393
394
395 /****************
396  * Check whether we can trust this signature.
397  * Returns: Error if we shall not trust this signatures.
398  */
399 int
400 check_signatures_trust( PKT_signature *sig )
401 {
402     PKT_public_key *pk = m_alloc_clear( sizeof *pk );
403     int trustlevel;
404     int dont_try = 0;
405     int rc=0;
406
407     rc = get_pubkey( pk, sig->keyid );
408     if( rc ) { /* this should not happen */
409         log_error("Ooops; the key vanished  - can't check the trust\n");
410         rc = G10ERR_NO_PUBKEY;
411         goto leave;
412     }
413
414   retry:
415     rc = check_trust( pk, &trustlevel );
416     if( rc ) {
417         log_error("check trust failed: %s\n", g10_errstr(rc));
418         goto leave;
419     }
420
421     if( (trustlevel & TRUST_FLAG_REVOKED) ) {
422         write_status( STATUS_KEYREVOKED );
423         log_info(_("WARNING: This key has been revoked by its owner!\n"));
424         log_info(_("         This could mean that the signature is forgery.\n"));
425     }
426
427
428     switch( (trustlevel & TRUST_MASK) ) {
429       case TRUST_UNKNOWN: /* No pubkey in trustDB: Insert and check again */
430         rc = insert_trust_record( pk );
431         if( rc ) {
432             log_error("failed to insert it into the trustdb: %s\n",
433                                                       g10_errstr(rc) );
434             goto leave;
435         }
436         rc = check_trust( pk, &trustlevel );
437         if( rc )
438             log_fatal("trust check after insert failed: %s\n",
439                                                       g10_errstr(rc) );
440         if( trustlevel == TRUST_UNKNOWN || trustlevel == TRUST_EXPIRED )
441             BUG();
442         goto retry;
443
444       case TRUST_EXPIRED:
445         log_info(_("Note: This key has expired!\n"));
446         break;
447
448       case TRUST_UNDEFINED:
449         if( dont_try || opt.batch || opt.answer_no ) {
450             write_status( STATUS_TRUST_UNDEFINED );
451             log_info(_(
452             "WARNING: This key is not certified with a trusted signature!\n"));
453             log_info(_(
454             "         There is no indication that the "
455                                     "signature belongs to the owner.\n" ));
456         }
457         else {
458             int quit;
459             rc = add_ownertrust( pk, &quit );
460             if( rc || quit ) {
461                 dont_try = 1;
462                 rc = 0;
463             }
464             goto retry;
465         }
466         break;
467
468       case TRUST_NEVER:
469         write_status( STATUS_TRUST_NEVER );
470         log_info(_("WARNING: We do NOT trust this key!\n"));
471         log_info(_("         The signature is probably a FORGERY.\n"));
472         rc = G10ERR_BAD_SIGN;
473         break;
474
475       case TRUST_MARGINAL:
476         write_status( STATUS_TRUST_MARGINAL );
477         log_info(_(
478          "WARNING: This key is not certified with sufficiently trusted signatures!\n"
479                 ));
480         log_info(_(
481          "         It is not certain that the signature belongs to the owner.\n"
482                  ));
483         break;
484
485       case TRUST_FULLY:
486         write_status( STATUS_TRUST_FULLY );
487         break;
488
489       case TRUST_ULTIMATE:
490         write_status( STATUS_TRUST_ULTIMATE );
491         break;
492
493       default: BUG();
494     }
495
496
497   leave:
498     free_public_key( pk );
499     return rc;
500 }
501
502
503 void
504 release_pk_list( PK_LIST pk_list )
505 {
506     PK_LIST pk_rover;
507
508     for( ; pk_list; pk_list = pk_rover ) {
509         pk_rover = pk_list->next;
510         free_public_key( pk_list->pk );
511         m_free( pk_list );
512     }
513 }
514
515 int
516 build_pk_list( STRLIST remusr, PK_LIST *ret_pk_list, unsigned use )
517 {
518     PK_LIST pk_list = NULL;
519     PKT_public_key *pk=NULL;
520     int rc=0;
521     int any_recipients=0;
522     STRLIST rov;
523
524     /* check whether there are any recipients in the list and build the
525      * list of the encrypt-to ones (we always trust them) */
526     for( rov = remusr; rov; rov = rov->next ) {
527         if( !(rov->flags & 1) )
528             any_recipients = 1;
529         else if( (use & PUBKEY_USAGE_ENC) && !opt.no_encrypt_to ) {
530             pk = m_alloc_clear( sizeof *pk );
531             pk->pubkey_usage = use;
532             if( (rc = get_pubkey_byname( NULL, pk, rov->d, NULL )) ) {
533                 free_public_key( pk ); pk = NULL;
534                 log_error(_("%s: skipped: %s\n"), rov->d, g10_errstr(rc) );
535             }
536             else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use )) ) {
537                 PK_LIST r;
538
539                 r = m_alloc( sizeof *r );
540                 r->pk = pk; pk = NULL;
541                 r->next = pk_list;
542                 r->mark = 0;
543                 pk_list = r;
544             }
545             else {
546                 free_public_key( pk ); pk = NULL;
547                 log_error(_("%s: skipped: %s\n"), rov->d, g10_errstr(rc) );
548             }
549         }
550     }
551
552     if( !any_recipients && !opt.batch ) { /* ask */
553         char *answer=NULL;
554
555         tty_printf(_(
556                 "You did not specify a user ID. (you may use \"-r\")\n\n"));
557         for(;;) {
558             rc = 0;
559             m_free(answer);
560             answer = cpr_get_utf8("pklist.user_id.enter",
561                                    _("Enter the user ID: "));
562             trim_spaces(answer);
563             cpr_kill_prompt();
564             if( !*answer )
565                 break;
566             if( pk )
567                 free_public_key( pk );
568             pk = m_alloc_clear( sizeof *pk );
569             pk->pubkey_usage = use;
570             rc = get_pubkey_byname( NULL, pk, answer, NULL );
571             if( rc )
572                 tty_printf(_("No such user ID.\n"));
573             else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use)) ) {
574                 int trustlevel;
575
576                 rc = check_trust( pk, &trustlevel );
577                 if( rc ) {
578                     log_error("error checking pk of `%s': %s\n",
579                                                       answer, g10_errstr(rc) );
580                 }
581                 else if( do_we_trust_pre( pk, trustlevel ) ) {
582                     PK_LIST r;
583
584                     r = m_alloc( sizeof *r );
585                     r->pk = pk; pk = NULL;
586                     r->next = pk_list;
587                     r->mark = 0;
588                     pk_list = r;
589                     any_recipients = 1;
590                     break;
591                 }
592             }
593         }
594         m_free(answer);
595         if( pk ) {
596             free_public_key( pk );
597             pk = NULL;
598         }
599     }
600     else {
601         for(; remusr; remusr = remusr->next ) {
602             if( (remusr->flags & 1) )
603                 continue; /* encrypt-to keys are already handled */
604
605             pk = m_alloc_clear( sizeof *pk );
606             pk->pubkey_usage = use;
607             if( (rc = get_pubkey_byname( NULL, pk, remusr->d, NULL )) ) {
608                 free_public_key( pk ); pk = NULL;
609                 log_error(_("%s: skipped: %s\n"), remusr->d, g10_errstr(rc) );
610             }
611             else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use )) ) {
612                 int trustlevel;
613
614                 rc = check_trust( pk, &trustlevel );
615                 if( rc ) {
616                     free_public_key( pk ); pk = NULL;
617                     log_error(_("%s: error checking key: %s\n"),
618                                                       remusr->d, g10_errstr(rc) );
619                 }
620                 else if( do_we_trust_pre( pk, trustlevel ) ) {
621                     /* note: do_we_trust may have changed the trustlevel */
622                     PK_LIST r;
623
624                     r = m_alloc( sizeof *r );
625                     r->pk = pk; pk = NULL;
626                     r->next = pk_list;
627                     r->mark = 0;
628                     pk_list = r;
629                     any_recipients = 1;
630                 }
631                 else { /* we don't trust this pk */
632                     free_public_key( pk ); pk = NULL;
633                 }
634             }
635             else {
636                 free_public_key( pk ); pk = NULL;
637                 log_error(_("%s: skipped: %s\n"), remusr->d, g10_errstr(rc) );
638             }
639         }
640     }
641
642     if( !rc && !any_recipients ) {
643         log_error(_("no valid addressees\n"));
644         rc = G10ERR_NO_USER_ID;
645     }
646
647     if( rc )
648         release_pk_list( pk_list );
649     else
650         *ret_pk_list = pk_list;
651     return rc;
652 }
653
654
655
656 static int
657 algo_available( int preftype, int algo )
658 {
659     if( preftype == PREFTYPE_SYM ) {
660         return algo && !check_cipher_algo( algo );
661     }
662     else if( preftype == PREFTYPE_HASH ) {
663         return algo && !check_digest_algo( algo );
664     }
665     else if( preftype == PREFTYPE_COMPR ) {
666         return !algo || algo == 1 || algo == 2;
667     }
668     else
669         return 0;
670 }
671
672 /****************
673  * Return -1 if we could not find an algorithm.
674  */
675 int
676 select_algo_from_prefs( PK_LIST pk_list, int preftype )
677 {
678     PK_LIST pkr;
679     u32 bits[8];
680     byte *pref = NULL;
681     size_t npref;
682     int i, j;
683     int compr_hack=0;
684     int any;
685
686     if( !pk_list )
687         return -1;
688
689     memset( bits, ~0, 8 * sizeof *bits );
690     for( pkr = pk_list; pkr; pkr = pkr->next ) {
691         u32 mask[8];
692
693         memset( mask, 0, 8 * sizeof *mask );
694         if( !pkr->pk->local_id ) { /* try to set the local id */
695             query_trust_info( pkr->pk );
696             if( !pkr->pk->local_id ) {
697                 log_debug("select_algo_from_prefs: can't get LID\n");
698                 continue;
699             }
700         }
701         if( preftype == PREFTYPE_SYM )
702             mask[0] |= (1<<2); /* 3DES is implicitly there */
703         m_free(pref);
704         pref = get_pref_data( pkr->pk->local_id, pkr->pk->namehash, &npref);
705         any = 0;
706         if( pref ) {
707            #if 0
708             log_hexdump("raw: ", pref, npref );
709            #endif
710             for(i=0; i+1 < npref; i+=2 ) {
711                 if( pref[i] == preftype ) {
712                     mask[pref[i+1]/32] |= 1 << (pref[i+1]%32);
713                     any = 1;
714                 }
715             }
716         }
717         if( (!pref || !any) && preftype == PREFTYPE_COMPR ) {
718             mask[0] |= 3; /* asume no_compression and old pgp */
719             compr_hack = 1;
720         }
721
722       #if 0
723         log_debug("mask=%08lX%08lX%08lX%08lX%08lX%08lX%08lX%08lX\n",
724                (ulong)mask[7], (ulong)mask[6], (ulong)mask[5], (ulong)mask[4],
725              (ulong)mask[3], (ulong)mask[2], (ulong)mask[1], (ulong)mask[0]);
726       #endif
727         for(i=0; i < 8; i++ )
728             bits[i] &= mask[i];
729       #if 0
730         log_debug("bits=%08lX%08lX%08lX%08lX%08lX%08lX%08lX%08lX\n",
731                (ulong)bits[7], (ulong)bits[6], (ulong)bits[5], (ulong)bits[4],
732              (ulong)bits[3], (ulong)bits[2], (ulong)bits[1], (ulong)bits[0]);
733       #endif
734     }
735     /* usable algorithms are now in bits
736      * We now use the last key from pk_list to select
737      * the algorithm we want to use. there are no
738      * preferences for the last key, we select the one
739      * corresponding to first set bit.
740      */
741     i = -1;
742     any = 0;
743     if( pref ) {
744         for(j=0; j+1 < npref; j+=2 ) {
745             if( pref[j] == preftype ) {
746                 any = 1;
747                 if( (bits[pref[j+1]/32] & (1<<(pref[j+1]%32))) ) {
748                     if( algo_available( preftype, pref[j+1] ) ) {
749                         i = pref[j+1];
750                         break;
751                     }
752                 }
753             }
754         }
755     }
756     if( !pref || !any ) {
757         for(j=0; j < 256; j++ )
758             if( (bits[j/32] & (1<<(j%32))) ) {
759                 if( algo_available( preftype, j ) ) {
760                     i = j;
761                     break;
762                 }
763             }
764     }
765   #if 0
766     log_debug("prefs of type %d: selected %d\n", preftype, i );
767   #endif
768     if( compr_hack && !i ) {
769         /* selected no compression, but we should check whether
770          * algorithm 1 is also available (the ordering is not relevant
771          * in this case). */
772         if( bits[0] & (1<<1) )
773             i = 1;  /* yep; we can use compression algo 1 */
774     }
775
776     m_free(pref);
777     return i;
778 }
779
780