]> diplodocus.org Git - nmh/blob - uip/new.c
2fa483787be43606ce0b1efc8b75bc59daa985ee
[nmh] / uip / new.c
1 /* new.c -- as new, list all folders with unseen messages
2 * -- as fnext, move to next folder with unseen messages
3 * -- as fprev, move to previous folder with unseen messages
4 * -- as unseen, scan all unseen messages
5 * This code is Copyright (c) 2008, by the authors of nmh. See the
6 * COPYRIGHT file in the root directory of the nmh distribution for
7 * complete copyright information.
8 *
9 * Inspired by Luke Mewburn's new: http://www.mewburn.net/luke/src/new
10 */
11
12 #include <sys/types.h>
13
14 #include "h/mh.h"
15 #include "sbr/print_help.h"
16 #include "sbr/error.h"
17 #include "h/crawl_folders.h"
18 #include "h/done.h"
19 #include "h/utils.h"
20 #include "sbr/lock_file.h"
21 #include "sbr/m_maildir.h"
22
23 #define NEW_SWITCHES \
24 X("mode", 1, MODESW) \
25 X("folders", 1, FOLDERSSW) \
26 X("version", 1, VERSIONSW) \
27 X("help", 1, HELPSW) \
28
29 #define X(sw, minchars, id) id,
30 DEFINE_SWITCH_ENUM(NEW);
31 #undef X
32
33 #define X(sw, minchars, id) { sw, minchars, id },
34 DEFINE_SWITCH_ARRAY(NEW, switches);
35 #undef X
36
37 /* What to do, based on argv[0]. */
38 static enum {
39 RM_NEW,
40 RM_FNEXT,
41 RM_FPREV,
42 RM_UNSEEN
43 } run_mode = RM_NEW;
44
45 /* check_folders uses this to maintain state with both .folders list of
46 * folders and with crawl_folders. */
47 struct list_state {
48 struct node **first, **cur_node;
49 size_t *maxlen;
50 char *cur;
51 char **sequences;
52 struct node *node;
53 };
54
55 /* Return the number of messages in a string list of message numbers. */
56 static int
57 count_messages(char *field)
58 {
59 int total = 0;
60 int j, k;
61 char *cp, **ap;
62
63 field = getcpy(field);
64
65 /* copied from seq_read.c:seq_init */
66 for (ap = brkstring (field, " ", "\n"); *ap; ap++) {
67 if ((cp = strchr(*ap, '-')))
68 *cp++ = '\0';
69 if ((j = m_atoi (*ap)) > 0) {
70 k = cp ? m_atoi (cp) : j;
71
72 total += k - j + 1;
73 }
74 }
75
76 free(field);
77
78 return total;
79 }
80
81 /* Return true if the sequence 'name' is in 'sequences'. */
82 static bool
83 seq_in_list(char *name, char *sequences[])
84 {
85 int i;
86
87 for (i = 0; sequences[i] != NULL; i++) {
88 if (strcmp(name, sequences[i]) == 0) {
89 return true;
90 }
91 }
92
93 return false;
94 }
95
96 /* Return the string list of message numbers from the sequences file, or NULL
97 * if none. */
98 static char *
99 get_msgnums(char *folder, char *sequences[])
100 {
101 char *seqfile = NULL;
102 FILE *fp;
103 int state;
104 char name[NAMESZ], field[NMH_BUFSIZ];
105 char *cp;
106 char *msgnums = NULL, *this_msgnums, *old_msgnums;
107 int failed_to_lock = 0;
108 m_getfld_state_t gstate;
109
110 /* copied from seq_read.c:seq_public */
111 /*
112 * If mh_seq == NULL or if *mh_seq == '\0' (the user has defined
113 * the "mh-sequences" profile entry, but left it empty),
114 * then just return, and do not initialize any public sequences.
115 */
116 if (mh_seq == NULL || *mh_seq == '\0')
117 return NULL;
118
119 /* get filename of sequence file */
120 seqfile = concat(m_maildir(folder), "/", mh_seq, NULL);
121
122 if (seqfile == NULL)
123 return NULL;
124
125 if ((fp = lkfopendata (seqfile, "r", & failed_to_lock)) == NULL) {
126 if (failed_to_lock)
127 adios (seqfile, "failed to lock");
128 free(seqfile);
129 return NULL;
130 }
131
132 /* Use m_getfld2 to scan sequence file */
133 gstate = m_getfld_state_init(fp);
134 for (;;) {
135 int fieldsz = sizeof field;
136 switch (state = m_getfld2(&gstate, name, field, &fieldsz)) {
137 case FLD:
138 case FLDPLUS:
139 if (state == FLDPLUS) {
140 cp = getcpy (field);
141 while (state == FLDPLUS) {
142 fieldsz = sizeof field;
143 state = m_getfld2(&gstate, name, field, &fieldsz);
144 cp = add (field, cp);
145 }
146
147 /* Here's where we differ from seq_public: if it's in a
148 * sequence we want, save the list of messages. */
149 if (seq_in_list(name, sequences)) {
150 this_msgnums = trimcpy(cp);
151 if (msgnums == NULL) {
152 msgnums = this_msgnums;
153 } else {
154 old_msgnums = msgnums;
155 msgnums = concat(old_msgnums, " ",
156 this_msgnums, NULL);
157 free(old_msgnums);
158 free(this_msgnums);
159 }
160 }
161 free (cp);
162 } else {
163 /* and here */
164 if (seq_in_list(name, sequences)) {
165 this_msgnums = trimcpy(field);
166 if (msgnums == NULL) {
167 msgnums = this_msgnums;
168 } else {
169 old_msgnums = msgnums;
170 msgnums = concat(old_msgnums, " ",
171 this_msgnums, NULL);
172 free(old_msgnums);
173 free(this_msgnums);
174 }
175 }
176 }
177
178 continue;
179
180 case BODY:
181 die("no blank lines are permitted in %s", seqfile);
182 break;
183
184 case FILEEOF:
185 break;
186
187 default:
188 die("%s is poorly formatted", seqfile);
189 }
190 break; /* break from for loop */
191 }
192 m_getfld_state_destroy (&gstate);
193
194 lkfclosedata (fp, seqfile);
195
196 free(seqfile);
197
198 return msgnums;
199 }
200
201 /* Check `folder' (of length `len') for interesting messages, filling in the
202 * list in `b'. */
203 static void
204 check_folder(char *folder, size_t len, struct list_state *b)
205 {
206 char *msgnums = get_msgnums(folder, b->sequences);
207 int is_cur = strcmp(folder, b->cur) == 0;
208
209 if (is_cur || msgnums != NULL) {
210 if (*b->first == NULL) {
211 NEW(b->node);
212 *b->first = b->node;
213 } else {
214 NEW(b->node->n_next);
215 b->node = b->node->n_next;
216 }
217 b->node->n_name = folder;
218 b->node->n_field = msgnums;
219
220 if (*b->maxlen < len) {
221 *b->maxlen = len;
222 }
223 }
224
225 /* Save the node for the current folder, so we can fall back to it. */
226 if (is_cur) {
227 *b->cur_node = b->node;
228 }
229 }
230
231 static bool
232 crawl_callback(char *folder, void *baton)
233 {
234 check_folder(folder, strlen(folder), baton);
235 return true;
236 }
237
238 /* Scan folders, returning:
239 * first -- list of nodes for all folders which have desired messages;
240 * if the current folder is listed in .folders, it is also in
241 * the list regardless of whether it has any desired messages
242 * last -- last node in list
243 * cur_node -- node of current folder, if listed in .folders
244 * maxlen -- length of longest folder name
245 *
246 * `cur' points to the name of the current folder, `folders' points to the
247 * name of a .folder (if NULL, crawl all folders), and `sequences' points to
248 * the array of sequences for which to look.
249 *
250 * An empty list is returned as first=last=NULL.
251 */
252 static void
253 check_folders(struct node **first, struct node **last,
254 struct node **cur_node, size_t *maxlen,
255 char *cur, char *folders, char *sequences[])
256 {
257 struct list_state b;
258 FILE *fp;
259 char *line;
260 size_t len;
261
262 *first = *last = *cur_node = NULL;
263 *maxlen = 0;
264
265 b.first = first;
266 b.cur_node = cur_node;
267 b.maxlen = maxlen;
268 b.cur = cur;
269 b.sequences = sequences;
270
271 if (folders == NULL) {
272 if (chdir(m_maildir("")) < 0) {
273 advise (m_maildir(""), "chdir");
274 }
275 crawl_folders(".", crawl_callback, &b);
276 } else {
277 fp = fopen(folders, "r");
278 if (fp == NULL) {
279 die("failed to read %s", folders);
280 }
281 while (vfgets(fp, &line) == OK) {
282 len = strlen(line) - 1;
283 line[len] = '\0';
284 check_folder(mh_xstrdup(line), len, &b);
285 }
286 fclose(fp);
287 }
288
289 if (*first != NULL) {
290 b.node->n_next = NULL;
291 *last = b.node;
292 }
293 }
294
295 /* Return a single string of the `sequences' joined by a space (' '). */
296 static char *
297 join_sequences(char *sequences[])
298 {
299 int i;
300 size_t len = 0;
301 char *result, *cp;
302
303 for (i = 0; sequences[i] != NULL; i++) {
304 len += strlen(sequences[i]) + 1;
305 }
306 result = mh_xmalloc(len + 1);
307
308 for (i = 0, cp = result; sequences[i] != NULL; i++, cp += len + 1) {
309 len = strlen(sequences[i]);
310 memcpy(cp, sequences[i], len);
311 cp[len] = ' ';
312 }
313 /* -1 to overwrite the last delimiter */
314 *--cp = '\0';
315
316 return result;
317 }
318
319 /* Return a struct node for the folder to change to. This is the next
320 * (previous, if RM_FPREV mode) folder with desired messages, or the current
321 * folder if no folders have desired. If RM_NEW or RM_UNSEEN mode, print the
322 * output but don't change folders.
323 *
324 * n_name is the folder to change to, and n_field is the string list of
325 * desired message numbers.
326 */
327 static struct node *
328 doit(char *cur, char *folders, char *sequences[])
329 {
330 struct node *first, *cur_node, *node, *last, *prev;
331 size_t folder_len;
332 int count, total = 0;
333 char *command = NULL, *sequences_s = NULL;
334
335 if (cur == NULL || cur[0] == '\0') {
336 cur = "inbox";
337 }
338
339 check_folders(&first, &last, &cur_node, &folder_len, cur,
340 folders, sequences);
341
342 if (run_mode == RM_FNEXT || run_mode == RM_FPREV) {
343 if (first == NULL) {
344 /* No folders at all... */
345 return NULL;
346 }
347 if (first->n_next == NULL) {
348 /* We have only one node; any desired messages in it? */
349 if (first->n_field == NULL) {
350 return NULL;
351 }
352 return first;
353 }
354 if (cur_node == NULL) {
355 /* Current folder is not listed in .folders, return first. */
356 return first;
357 }
358 } else if (run_mode == RM_UNSEEN) {
359 sequences_s = join_sequences(sequences);
360 }
361
362 for (node = first, prev = NULL;
363 node != NULL;
364 prev = node, node = node->n_next) {
365 if (run_mode == RM_FNEXT) {
366 /* If we have a previous node and it is the current
367 * folder, return this node. */
368 if (prev != NULL && strcmp(prev->n_name, cur) == 0) {
369 return node;
370 }
371 } else if (run_mode == RM_FPREV) {
372 if (strcmp(node->n_name, cur) == 0) {
373 /* Found current folder in fprev mode; if we have a
374 * previous node in the list, return it; else return
375 * the last node. */
376 if (prev)
377 return prev;
378 return last;
379 }
380 } else if (run_mode == RM_UNSEEN) {
381 int status;
382
383 if (node->n_field == NULL) {
384 continue;
385 }
386
387 printf("\n%d %s messages in %s",
388 count_messages(node->n_field),
389 sequences_s,
390 node->n_name);
391 if (strcmp(node->n_name, cur) == 0) {
392 puts(" (*: current folder)");
393 } else {
394 putchar('\n');
395 }
396 fflush(stdout);
397
398 /* TODO: Split enough of scan.c out so that we can call it here. */
399 command = concat("scan +", node->n_name, " ", sequences_s,
400 NULL);
401 status = system(command);
402 if (! WIFEXITED (status)) {
403 adios (command, "system");
404 }
405 free(command);
406 } else {
407 if (node->n_field == NULL) {
408 continue;
409 }
410
411 count = count_messages(node->n_field);
412 total += count;
413
414 printf("%-*s %6d.%c %s\n",
415 (int) folder_len, node->n_name,
416 count,
417 (strcmp(node->n_name, cur) == 0 ? '*' : ' '),
418 node->n_field);
419 }
420 }
421
422 /* If we're fnext, we haven't checked the last node yet. If it's the
423 * current folder, return the first node. */
424 if (run_mode == RM_FNEXT) {
425 assert(last != NULL);
426 if (strcmp(last->n_name, cur) == 0) {
427 return first;
428 }
429 }
430
431 if (run_mode == RM_NEW) {
432 printf("%-*s %6d.\n", (int) folder_len, " total", total);
433 }
434
435 return cur_node;
436 }
437
438 int
439 main(int argc, char **argv)
440 {
441 char **ap, *cp, **argp, **arguments;
442 char help[BUFSIZ];
443 char *folders = NULL;
444 svector_t sequences = svector_create (0);
445 int i = 0;
446 char *unseen;
447 struct node *folder;
448
449 if (nmh_init(argv[0], true, true)) { return 1; }
450
451 arguments = getarguments (invo_name, argc, argv, 1);
452 argp = arguments;
453
454 /*
455 * Parse arguments
456 */
457 while ((cp = *argp++)) {
458 if (*cp == '-') {
459 switch (smatch (++cp, switches)) {
460 case AMBIGSW:
461 ambigsw (cp, switches);
462 done (1);
463 case UNKWNSW:
464 die("-%s unknown", cp);
465
466 case HELPSW:
467 snprintf (help, sizeof(help), "%s [switches] [sequences]",
468 invo_name);
469 print_help (help, switches, 1);
470 done (0);
471 case VERSIONSW:
472 print_version(invo_name);
473 done (0);
474
475 case FOLDERSSW:
476 if (!(folders = *argp++) || *folders == '-')
477 die("missing argument to %s", argp[-2]);
478 continue;
479 case MODESW:
480 if (!(invo_name = *argp++) || *invo_name == '-')
481 die("missing argument to %s", argp[-2]);
482 invo_name = r1bindex(invo_name, '/');
483 continue;
484 }
485 }
486 /* have a sequence argument */
487 if (!seq_in_list(cp, svector_strs (sequences))) {
488 svector_push_back (sequences, cp);
489 ++i;
490 }
491 }
492
493 if (strcmp(invo_name, "fnext") == 0) {
494 run_mode = RM_FNEXT;
495 } else if (strcmp(invo_name, "fprev") == 0) {
496 run_mode = RM_FPREV;
497 } else if (strcmp(invo_name, "unseen") == 0) {
498 run_mode = RM_UNSEEN;
499 }
500
501 if (folders == NULL) {
502 /* will flists */
503 } else {
504 if (folders[0] != '/') {
505 folders = m_maildir(folders);
506 }
507 }
508
509 if (i == 0) {
510 /* no sequence arguments; use unseen */
511 unseen = context_find(usequence);
512 if (unseen == NULL || unseen[0] == '\0') {
513 die("must specify sequences or set %s", usequence);
514 }
515 for (ap = brkstring(unseen, " ", "\n"); *ap; ap++) {
516 svector_push_back (sequences, *ap);
517 ++i;
518 }
519 }
520
521 folder = doit(context_find(pfolder), folders, svector_strs (sequences));
522 if (folder == NULL) {
523 done(0);
524 return 1;
525 }
526
527 if (run_mode == RM_UNSEEN) {
528 /* All the scan(1)s it runs change the current folder, so we
529 * need to put it back. Unfortunately, context_replace lamely
530 * ignores the new value you give it if it is the same one it
531 * has in memory. So, we'll be lame, too. I'm not sure if i
532 * should just change context_replace... */
533 context_replace(pfolder, "defeat_context_replace_optimization");
534 }
535
536 /* update current folder */
537 context_replace(pfolder, folder->n_name);
538
539 if (run_mode == RM_FNEXT || run_mode == RM_FPREV) {
540 printf("%s %s\n", folder->n_name, folder->n_field);
541 }
542
543 context_save();
544
545 svector_free (sequences);
546 done (0);
547 return 1;
548 }