pgplib.c

Go to the documentation of this file.

 
#include "config.h"
#include <stdbool.h>
#include "mutt/lib.h"
#ifdef CRYPT_BACKEND_CLASSIC_PGP
#include "pgplib.h"
#endif
 
const char *pgp_pkalgbytype(unsigned char type)
{
  switch (type)
  {
    case 1:
      return "RSA";
    case 2:
      return "RSA";
    case 3:
      return "RSA";
    case 16:
      return "ElG";
    case 17:
      return "DSA";
    case 20:
      return "ElG";
    default:
      return "unk";
  }
}
 
bool pgp_canencrypt(unsigned char type)
{
  switch (type)
  {
    case 1:
    case 2:
    case 16:
    case 20:
      return true;
    default:
      return false;
  }
}
 
bool pgp_cansign(unsigned char type)
{
  switch (type)
  {
    case 1:
    case 3:
    case 17:
    case 20:
      return true;
    default:
      return false;
  }
}
 
static void pgp_uid_free(struct PgpUid **upp)
{
  struct PgpUid *up = NULL, *q = NULL;
 
  if (!upp || !*upp)
    return;
  for (up = *upp; up; up = q)
  {
    q = up->next;
    FREE(&up->addr);
    FREE(&up);
  }
 
  *upp = NULL;
}
 
struct PgpUid *pgp_copy_uids(struct PgpUid *up, struct PgpKeyInfo *parent)
{
  struct PgpUid *l = NULL;
  struct PgpUid **lp = &l;
 
  for (; up; up = up->next)
  {
    *lp = MUTT_MEM_CALLOC(1, struct PgpUid);
    (*lp)->trust = up->trust;
    (*lp)->flags = up->flags;
    (*lp)->addr = mutt_str_dup(up->addr);
    (*lp)->parent = parent;
    lp = &(*lp)->next;
  }
 
  return l;
}
 
static void key_free(struct PgpKeyInfo **ptr)
{
  if (!ptr || !*ptr)
    return;
 
  struct PgpKeyInfo *key = *ptr;
 
  pgp_uid_free(&key->address);
  FREE(&key->keyid);
  FREE(&key->fingerprint);
 
  FREE(ptr);
}
 
struct PgpKeyInfo *pgp_remove_key(struct PgpKeyInfo **klist, struct PgpKeyInfo *key)
{
  if (!klist || !*klist || !key)
    return NULL;
 
  struct PgpKeyInfo **last = NULL;
  struct PgpKeyInfo *p = NULL, *q = NULL, *r = NULL;
 
  if (key->parent && (key->parent != key))
    key = key->parent;
 
  last = klist;
  for (p = *klist; p && p != key; p = p->next)
    last = &p->next;
 
  if (!p)
    return NULL;
 
  for (q = p->next, r = p; q && q->parent == p; q = q->next)
    r = q;
 
  if (r)
    r->next = NULL;
 
  *last = q;
  return q;
}
 
void pgp_key_free(struct PgpKeyInfo **kpp)
{
  if (!kpp || !*kpp)
    return;
 
  struct PgpKeyInfo *p = NULL, *q = NULL, *r = NULL;
 
  if ((*kpp)->parent && ((*kpp)->parent != *kpp))
    *kpp = (*kpp)->parent;
 
  /* Order is important here:
   *
   * - First free all children.
   * - If we are an orphan (i.e., our parent was not in the key list),
   *   free our parent.
   * - free ourselves.  */
 
  for (p = *kpp; p; p = q)
  {
    for (q = p->next; q && q->parent == p; q = r)
    {
      r = q->next;
      key_free(&q);
    }
 
    key_free(&p->parent);
    key_free(&p);
  }
 
  *kpp = NULL;
}