]> git.llucax.com Git - software/mutt-debian.git/blob - addrbook.c
IMAP: only close socket when not already disconnected (Closes: 493719)
[software/mutt-debian.git] / addrbook.c
1 /*
2  * Copyright (C) 1996-2000,2007 Michael R. Elkins <me@mutt.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 "mutt_menu.h"
25 #include "mapping.h"
26 #include "sort.h"
27
28 #include "mutt_idna.h"
29
30 #include <string.h>
31 #include <stdlib.h>
32 #include <ctype.h>
33
34 #define RSORT(x) (SortAlias & SORT_REVERSE) ? -x : x
35
36 static struct mapping_t AliasHelp[] = {
37   { N_("Exit"),   OP_EXIT },
38   { N_("Del"),    OP_DELETE },
39   { N_("Undel"),  OP_UNDELETE },
40   { N_("Select"), OP_GENERIC_SELECT_ENTRY },
41   { N_("Help"),   OP_HELP },
42   { NULL }
43 };
44
45 static const char *
46 alias_format_str (char *dest, size_t destlen, size_t col, char op, const char *src,
47                   const char *fmt, const char *ifstring, const char *elsestring,
48                   unsigned long data, format_flag flags)
49 {
50   char tmp[SHORT_STRING], adr[SHORT_STRING];
51   ALIAS *alias = (ALIAS *) data;
52
53   switch (op)
54   {
55     case 'f':
56       snprintf (tmp, sizeof (tmp), "%%%ss", fmt);
57       snprintf (dest, destlen, tmp, alias->del ? "D" : " ");
58       break;
59     case 'a':
60       mutt_format_s (dest, destlen, fmt, alias->name);
61       break;
62     case 'r':
63       adr[0] = 0;
64       rfc822_write_address (adr, sizeof (adr), alias->addr, 1);
65       snprintf (tmp, sizeof (tmp), "%%%ss", fmt);
66       snprintf (dest, destlen, tmp, adr);
67       break;
68     case 'n':
69       snprintf (tmp, sizeof (tmp), "%%%sd", fmt);
70       snprintf (dest, destlen, tmp, alias->num + 1);
71       break;
72     case 't':
73       dest[0] = alias->tagged ? '*' : ' ';
74       dest[1] = 0;
75       break;
76   }
77
78   return (src);
79 }
80
81 static void alias_entry (char *s, size_t slen, MUTTMENU *m, int num)
82 {
83   mutt_FormatString (s, slen, 0, NONULL (AliasFmt), alias_format_str, (unsigned long) ((ALIAS **) m->data)[num], M_FORMAT_ARROWCURSOR);
84 }
85
86 static int alias_tag (MUTTMENU *menu, int n, int m)
87 {
88   ALIAS *cur = ((ALIAS **) menu->data)[n];
89   int ot = cur->tagged;
90   
91   cur->tagged = (m >= 0 ? m : !cur->tagged);
92   
93   return cur->tagged - ot;
94 }
95
96 static int alias_SortAlias (const void *a, const void *b)
97 {
98   ALIAS *pa = *(ALIAS **) a;
99   ALIAS *pb = *(ALIAS **) b;
100   int r = mutt_strcasecmp (pa->name, pb->name);
101
102   return (RSORT (r));
103 }
104
105 static int alias_SortAddress (const void *a, const void *b)
106 {
107   ADDRESS *pa = (*(ALIAS **) a)->addr;
108   ADDRESS *pb = (*(ALIAS **) b)->addr;
109   int r;
110
111   if (pa == pb)
112     r = 0;
113   else if (pa == NULL)
114     r = -1;
115   else if (pb == NULL)
116     r = 1;
117   else if (pa->personal)
118   { 
119     if (pb->personal)
120       r = mutt_strcasecmp (pa->personal, pb->personal);
121     else
122       r = 1;
123   }
124   else if (pb->personal)
125     r = -1;
126   else
127     r = ascii_strcasecmp (pa->mailbox, pb->mailbox);
128   return (RSORT (r));
129 }
130
131 void mutt_alias_menu (char *buf, size_t buflen, ALIAS *aliases)
132 {
133   ALIAS *aliasp;
134   MUTTMENU *menu;
135   ALIAS **AliasTable = NULL;
136   int t = -1;
137   int i, done = 0;
138   int op;
139   char helpstr[LONG_STRING];
140
141   int omax;
142   
143   if (!aliases)
144   {
145     mutt_error _("You have no aliases!");
146     return;
147   }
148   
149   /* tell whoever called me to redraw the screen when I return */
150   set_option (OPTNEEDREDRAW);
151   
152   menu = mutt_new_menu (MENU_ALIAS);
153   menu->make_entry = alias_entry;
154   menu->tag = alias_tag;
155   menu->title = _("Aliases");
156   menu->help = mutt_compile_help (helpstr, sizeof (helpstr), MENU_ALIAS, AliasHelp);
157
158 new_aliases:
159
160   omax = menu->max;
161   
162   /* count the number of aliases */
163   for (aliasp = aliases; aliasp; aliasp = aliasp->next)
164   {
165     aliasp->self->del    = 0;
166     aliasp->self->tagged = 0;
167     menu->max++;
168   }
169
170   safe_realloc (&AliasTable, menu->max * sizeof (ALIAS *));
171   menu->data = AliasTable;
172
173   for (i = omax, aliasp = aliases; aliasp; aliasp = aliasp->next, i++)
174   {
175     AliasTable[i] = aliasp->self;
176     aliases       = aliasp;
177   }
178
179   if ((SortAlias & SORT_MASK) != SORT_ORDER)
180   {
181     qsort (AliasTable, i, sizeof (ALIAS *),
182          (SortAlias & SORT_MASK) == SORT_ADDRESS ? alias_SortAddress : alias_SortAlias);
183   }
184
185   for (i=0; i<menu->max; i++) AliasTable[i]->num = i;
186
187   while (!done)
188   {
189     if (aliases->next)
190     {
191       menu->redraw |= REDRAW_FULL;
192       aliases       = aliases->next;
193       goto new_aliases;
194     }
195     
196     switch ((op = mutt_menuLoop (menu)))
197     {
198       case OP_DELETE:
199       case OP_UNDELETE:
200         if (menu->tagprefix)
201         {
202           for (i = 0; i < menu->max; i++)
203             if (AliasTable[i]->tagged)
204               AliasTable[i]->del = (op == OP_DELETE) ? 1 : 0;
205           menu->redraw |= REDRAW_INDEX;
206         }
207         else
208         {
209           AliasTable[menu->current]->self->del = (op == OP_DELETE) ? 1 : 0;
210           menu->redraw |= REDRAW_CURRENT;
211           if (option (OPTRESOLVE) && menu->current < menu->max - 1)
212           {
213             menu->current++;
214             menu->redraw |= REDRAW_INDEX;
215           }
216         }
217         break;
218       case OP_GENERIC_SELECT_ENTRY:
219         t = menu->current;
220       case OP_EXIT:
221         done = 1;
222         break;
223     }
224   }
225
226   for (i = 0; i < menu->max; i++)
227   {
228     if (AliasTable[i]->tagged)
229     {
230       mutt_addrlist_to_local (AliasTable[i]->addr);
231       rfc822_write_address (buf, buflen, AliasTable[i]->addr, 0);
232       t = -1;
233     }
234   }
235
236   if(t != -1)
237   {
238       mutt_addrlist_to_local (AliasTable[t]->addr);
239     rfc822_write_address (buf, buflen, AliasTable[t]->addr, 0);
240   }
241
242   mutt_menuDestroy (&menu);
243   FREE (&AliasTable);
244   
245 }