group.c

   1 /*
   2  * Copyright (C) 2006 Thomas Roessler <roessler@does-not-exist.org>
   3  *
   4  *     This program is free software; you can redistribute it and/or modify
   5  *     it under the terms of the GNU General Public License as published by
   6  *     the Free Software Foundation; either version 2 of the License, or
   7  *     (at your option) any later version.
   8  *
   9  *     This program is distributed in the hope that it will be useful,
  10  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *     GNU General Public License for more details.
  13  *
  14  *     You should have received a copy of the GNU General Public License
  15  *     along with this program; if not, write to the Free Software
  16  *     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  17  */
  18
  19 #if HAVE_CONFIG_H
  20 # include "config.h"
  21 #endif
  22
  23 #include "mutt.h"
  24 #include "mapping.h"
  25 #include "mutt_curses.h"
  26 #include "mutt_regex.h"
  27 #include "history.h"
  28 #include "keymap.h"
  29 #include "mbyte.h"
  30 #include "charset.h"
  31 #include "mutt_crypt.h"
  32 #include "mutt_idna.h"
  33
  34 #include <ctype.h>
  35 #include <stdlib.h>
  36 #include <unistd.h>
  37 #include <string.h>
  38 #include <sys/utsname.h>
  39 #include <errno.h>
  40 #include <sys/wait.h>
  41
  42 group_t *mutt_pattern_group (const char *k)
  43 {
  44   group_t *p;
  45
  46   if (!k)
  47     return 0;
  48
  49   if (!(p = hash_find (Groups, k)))
  50   {
  51     dprint (2, (debugfile, "mutt_pattern_group: Creating group %s.\n", k));
  52     p = safe_calloc (1, sizeof (group_t));
  53     p->name = safe_strdup (k);
  54     hash_insert (Groups, p->name, p, 0);
  55   }
  56
  57   return p;
  58 }
  59
  60 void mutt_group_context_add (group_context_t **ctx, group_t *group)
  61 {
  62   for (; *ctx; ctx = &((*ctx)->next))
  63   {
  64     if ((*ctx)->g == group)
  65       return;
  66   }
  67
  68   *ctx = safe_calloc (1, sizeof (group_context_t));
  69   (*ctx)->g = group;
  70 }
  71
  72 void mutt_group_context_destroy (group_context_t **ctx)
  73 {
  74   group_context_t *p;
  75   for (; *ctx; *ctx = p)
  76   {
  77     p = (*ctx)->next;
  78     FREE (ctx);         /* __FREE_CHECKED__ */
  79   }
  80 }
  81
  82 void mutt_group_add_adrlist (group_t *g, ADDRESS *a)
  83 {
  84   ADDRESS **p, *q;
  85
  86   if (!g)
  87     return;
  88   if (!a)
  89     return;
  90
  91   for (p = &g->as; *p; p = &((*p)->next))
  92     ;
  93
  94   q = rfc822_cpy_adr (a);
  95   q = mutt_remove_xrefs (g->as, q);
  96   *p = q;
  97 }
  98
  99 int mutt_group_add_rx (group_t *g, const char *s, int flags, BUFFER *err)
 100 {
 101   return mutt_add_to_rx_list (&g->rs, s, flags, err);
 102 }
 103
 104 void mutt_group_context_add_adrlist (group_context_t *ctx, ADDRESS *a)
 105 {
 106   for (; ctx; ctx = ctx->next)
 107     mutt_group_add_adrlist (ctx->g, a);
 108 }
 109
 110 int mutt_group_context_add_rx (group_context_t *ctx, const char *s, int flags, BUFFER *err)
 111 {
 112   int rv = 0;
 113
 114   for (; (!rv) && ctx; ctx = ctx->next)
 115     rv = mutt_group_add_rx (ctx->g, s, flags, err);
 116
 117   return rv;
 118 }
 119
 120 int mutt_group_match (group_t *g, const char *s)
 121 {
 122   ADDRESS *ap;
 123
 124   if (s && g)
 125   {
 126     if (mutt_match_rx_list (s, g->rs))
 127       return 1;
 128     for (ap = g->as; ap; ap = ap->next)
 129       if (ap->mailbox && !mutt_strcasecmp (s, ap->mailbox))
 130         return 1;
 131   }
 132   return 0;
 133 }
 134