group.c

Go to the documentation of this file.

 
#include "config.h"
#include <stdbool.h>
#include <stdlib.h>
#include "group.h"
#include "address.h"

static void group_free(struct Group **ptr)
{
  if (!ptr || !*ptr)
    return;
 
  struct Group *g = *ptr;
 
  mutt_addrlist_clear(&g->al);
  mutt_regexlist_free(&g->rs);
  FREE(&g->name);
 
  FREE(ptr);
}

static struct Group *group_new(const char *name)
{
  struct Group *g = MUTT_MEM_CALLOC(1, struct Group);
 
  g->name = mutt_str_dup(name);
  STAILQ_INIT(&g->rs);
  TAILQ_INIT(&g->al);
 
  return g;
}

static void group_hash_free(int type, void *obj, intptr_t data)
{
  struct Group *g = obj;
  group_free(&g);
}

static void group_remove(struct HashTable *groups, struct Group *g)
{
  if (!groups || !g)
    return;
  mutt_hash_delete(groups, g->name, g);
}

static bool group_is_empty(struct Group *g)
{
  if (!g)
    return true;
  return TAILQ_EMPTY(&g->al) && STAILQ_EMPTY(&g->rs);
}

static void group_add_addrlist(struct Group *g, const struct AddressList *al)
{
  if (!g || !al)
    return;
 
  struct AddressList al_new = TAILQ_HEAD_INITIALIZER(al_new);
  mutt_addrlist_copy(&al_new, al, false);
  mutt_addrlist_remove_xrefs(&g->al, &al_new);
  struct Address *a = NULL, *tmp = NULL;
  TAILQ_FOREACH_SAFE(a, &al_new, entries, tmp)
  {
    TAILQ_REMOVE(&al_new, a, entries);
    mutt_addrlist_append(&g->al, a);
  }
  ASSERT(TAILQ_EMPTY(&al_new));
}

static int group_add_regex(struct Group *g, const char *str, uint16_t flags, struct Buffer *err)
{
  return mutt_regexlist_add(&g->rs, str, flags, err);
}

static int group_remove_regex(struct Group *g, const char *str)
{
  return mutt_regexlist_remove(&g->rs, str);
}

bool group_match(struct Group *g, const char *str)
{
  if (!g || !str)
    return false;
 
  if (mutt_regexlist_match(&g->rs, str))
    return true;
  struct Address *a = NULL;
  TAILQ_FOREACH(a, &g->al, entries)
  {
    if (a->mailbox && mutt_istr_equal(str, buf_string(a->mailbox)))
      return true;
  }
 
  return false;
}

void grouplist_add_group(struct GroupList *gl, struct Group *g)
{
  if (!gl || !g)
    return;
 
  struct GroupNode *np = NULL;
  STAILQ_FOREACH(np, gl, entries)
  {
    if (np->group == g)
      return;
  }
  np = MUTT_MEM_CALLOC(1, struct GroupNode);
  np->group = g;
  STAILQ_INSERT_TAIL(gl, np, entries);
}

void grouplist_destroy(struct GroupList *gl)
{
  if (!gl)
    return;
 
  struct GroupNode *np = STAILQ_FIRST(gl);
  struct GroupNode *next = NULL;
  while (np)
  {
    next = STAILQ_NEXT(np, entries);
    FREE(&np);
    np = next;
  }
  STAILQ_INIT(gl);
}

void grouplist_add_addrlist(struct GroupList *gl, struct AddressList *al)
{
  if (!gl || !al)
    return;
 
  struct GroupNode *np = NULL;
  STAILQ_FOREACH(np, gl, entries)
  {
    group_add_addrlist(np->group, al);
  }
}

int grouplist_add_regex(struct GroupList *gl, const char *str, uint16_t flags,
                        struct Buffer *err)
{
  if (!gl || !str)
    return -1;
 
  int rc = 0;
 
  struct GroupNode *np = NULL;
  STAILQ_FOREACH(np, gl, entries)
  {
    rc = group_add_regex(np->group, str, flags, err);
    if (rc)
      return rc;
  }
  return rc;
}

struct HashTable *groups_new(void)
{
  struct HashTable *groups = mutt_hash_new(1031, MUTT_HASH_NO_FLAGS);
 
  mutt_hash_set_destructor(groups, group_hash_free, 0);
 
  return groups;
}

void groups_free(struct HashTable **pptr)
{
  mutt_hash_free(pptr);
}

struct Group *groups_get_group(struct HashTable *groups, const char *name)
{
  if (!groups || !name)
    return NULL;
 
  struct Group *g = mutt_hash_find(groups, name);
  if (!g)
  {
    mutt_debug(LL_DEBUG2, "Creating group %s\n", name);
    g = group_new(name);
    mutt_hash_insert(groups, g->name, g);
  }
 
  return g;
}

void groups_remove_grouplist(struct HashTable *groups, struct GroupList *gl)
{
  if (!groups || !gl)
    return;
 
  struct GroupNode *np = STAILQ_FIRST(gl);
  struct GroupNode *next = NULL;
  while (np)
  {
    group_remove(groups, np->group);
    next = STAILQ_NEXT(np, entries);
    FREE(&np);
    np = next;
  }
  STAILQ_INIT(gl);
}

int groups_remove_addrlist(struct HashTable *groups, struct GroupList *gl,
                           struct AddressList *al)
{
  if (!groups || !gl || !al)
    return -1;
 
  struct GroupNode *gnp = NULL;
  STAILQ_FOREACH(gnp, gl, entries)
  {
    struct Address *a = NULL;
    TAILQ_FOREACH(a, al, entries)
    {
      mutt_addrlist_remove(&gnp->group->al, buf_string(a->mailbox));
    }
    if (group_is_empty(gnp->group))
    {
      group_remove(groups, gnp->group);
    }
  }
 
  return 0;
}

int groups_remove_regex(struct HashTable *groups, struct GroupList *gl, const char *str)
{
  if (!groups || !gl || !str)
    return -1;
 
  int rc = 0;
  struct GroupNode *np = NULL;
  STAILQ_FOREACH(np, gl, entries)
  {
    rc = group_remove_regex(np->group, str);
    if (group_is_empty(np->group))
      group_remove(groups, np->group);
    if (rc != 0)
      return rc;
  }
  return rc;
}