pith/folder.c

   1 #if !defined(lint) && !defined(DOS)
   2 static char rcsid[] = "$Id: folder.c 1142 2008-08-13 17:22:21Z hubert@u.washington.edu $";
   3 #endif
   4
   5 /*
   6  * ========================================================================
   7  * Copyright 2013-2020 Eduardo Chappa
   8  * Copyright 2006-2008 University of Washington
   9  *
  10  * Licensed under the Apache License, Version 2.0 (the "License");
  11  * you may not use this file except in compliance with the License.
  12  * You may obtain a copy of the License at
  13  *
  14  *     http://www.apache.org/licenses/LICENSE-2.0
  15  *
  16  * ========================================================================
  17  */
  18
  19 #include "../pith/headers.h"
  20 #include "../c-client/utf8aux.h"
  21 #include "../pith/folder.h"
  22 #include "../pith/state.h"
  23 #include "../pith/context.h"
  24 #include "../pith/init.h"
  25 #include "../pith/conf.h"
  26 #include "../pith/stream.h"
  27 #include "../pith/imap.h"
  28 #include "../pith/util.h"
  29 #include "../pith/flag.h"
  30 #include "../pith/status.h"
  31 #include "../pith/busy.h"
  32 #include "../pith/mailindx.h"
  33
  34
  35 typedef struct _build_folder_list_data {
  36     long         mask;                  /* bitmap of responses to ignore    */
  37     LISTARGS_S   args;
  38     LISTRES_S    response;
  39     int          is_move_folder;
  40     FLIST       *list;
  41 } BFL_DATA_S;
  42
  43
  44 #define FCHUNK  64
  45
  46
  47 /*
  48  * Internal prototypes
  49  */
  50 void        mail_list_exists(MAILSTREAM *, char *, int, long, void *, unsigned);
  51 void        init_incoming_folder_list(struct pine *, CONTEXT_S *);
  52 void        mail_list_filter(MAILSTREAM *, char *, int, long, void *, unsigned);
  53 void        mail_lsub_filter(MAILSTREAM *, char *, int, long, void *, unsigned);
  54 int         mail_list_in_collection(char **, char *, char *, char *);
  55 char       *folder_last_cmpnt(char *, int);
  56 void        free_folder_entries(FLIST **);
  57 int         folder_insert_sorted(int, int, int, FOLDER_S *, FLIST *,
  58                                  int (*)(FOLDER_S *, FOLDER_S *));
  59 void        folder_insert_index(FOLDER_S *, int, FLIST *);
  60 void        resort_folder_list(FLIST *flist);
  61 int         compare_folders_alpha_qsort(const qsort_t *a1, const qsort_t *a2);
  62 int         compare_folders_dir_alpha_qsort(const qsort_t *a1, const qsort_t *a2);
  63 int         compare_folders_alpha_dir_qsort(const qsort_t *a1, const qsort_t *a2);
  64 int         compare_names(const qsort_t *, const qsort_t *);
  65 void        init_incoming_unseen_data(struct pine *, FOLDER_S *f);
  66
  67
  68 char *
  69 folder_lister_desc(CONTEXT_S *cntxt, FDIR_S *fdp)
  70 {
  71     char *p, *q;
  72     unsigned char *fname;
  73
  74     q = ((p = strstr(cntxt->context, "%s")) && !*(p+2)
  75          && !strncmp(fdp->ref, cntxt->context, p - cntxt->context))
  76          ? fdp->ref + (p - cntxt->context) : fdp->ref;
  77     fname = folder_name_decoded((unsigned char *) q);
  78     /* Provide context in new collection header */
  79     snprintf(tmp_20k_buf, SIZEOF_20KBUF, "Dir: %s", fname ? (char *) fname : q);
  80     if(fname) fs_give((void **)&fname);
  81
  82     return(cpystr(tmp_20k_buf));
  83 }
  84
  85
  86 void
  87 reset_context_folders(CONTEXT_S *cntxt)
  88 {
  89     CONTEXT_S *tc;
  90
  91     for(tc = cntxt; tc && tc->prev ; tc = tc->prev)
  92       ;                         /* start at beginning */
  93
  94     for( ; tc ; tc = tc->next){
  95         free_folder_list(tc);
  96
  97         while(tc->dir->prev){
  98             FDIR_S *tp = tc->dir->prev;
  99             free_fdir(&tc->dir, 0);
 100             tc->dir = tp;
 101         }
 102     }
 103 }
 104
 105
 106 /*
 107  * next_folder_dir - return a directory structure with the folders it
 108  *                   contains
 109  */
 110 FDIR_S *
 111 next_folder_dir(CONTEXT_S *context, char *new_dir, int build_list, MAILSTREAM **streamp)
 112 {
 113     char      tmp[MAILTMPLEN], dir[3];
 114     FDIR_S   *tmp_fp, *fp;
 115
 116     fp = (FDIR_S *) fs_get(sizeof(FDIR_S));
 117     memset(fp, 0, sizeof(FDIR_S));
 118     (void) context_apply(tmp, context, new_dir, MAILTMPLEN);
 119     dir[0] = context->dir->delim;
 120     dir[1] = '\0';
 121     strncat(tmp, dir, sizeof(tmp)-1-strlen(tmp));
 122     fp->ref           = cpystr(tmp);
 123     fp->delim         = context->dir->delim;
 124     fp->view.internal = cpystr(NEWS_TEST(context) ? "*" : "%");
 125     fp->folders       = init_folder_entries();
 126     fp->status        = CNTXT_NOFIND;
 127     tmp_fp            = context->dir;   /* temporarily rebind */
 128     context->dir      = fp;
 129
 130     if(build_list)
 131       build_folder_list(streamp, context, NULL, NULL,
 132                         NEWS_TEST(context) ? BFL_LSUB : BFL_NONE);
 133
 134     context->dir = tmp_fp;
 135     return(fp);
 136 }
 137
 138
 139 /*
 140  * Return which pinerc incoming folder #index is in.
 141  */
 142 EditWhich
 143 config_containing_inc_fldr(FOLDER_S *folder)
 144 {
 145     char    **t;
 146     int       i, keep_going = 1, inheriting = 0;
 147     struct variable *v = &ps_global->vars[V_INCOMING_FOLDERS];
 148
 149     if(v->is_fixed)
 150       return(None);
 151
 152     /* is it in exceptions config? */
 153     if(v->post_user_val.l){
 154         for(i = 0, t=v->post_user_val.l; t[i]; i++){
 155             if(expand_variables(tmp_20k_buf, SIZEOF_20KBUF, t[i], 0)){
 156                 keep_going = 0;
 157
 158                 if(!strcmp(tmp_20k_buf, INHERIT))
 159                   inheriting = 1;
 160                 else if(folder->varhash == line_hash(tmp_20k_buf))
 161                   return(Post);
 162             }
 163         }
 164     }
 165
 166     if(inheriting)
 167       keep_going = 1;
 168
 169     /* is it in main config? */
 170     if(keep_going && v->main_user_val.l){
 171         for(i = 0, t=v->main_user_val.l; t[i]; i++){
 172             if(expand_variables(tmp_20k_buf, SIZEOF_20KBUF, t[i], 0) &&
 173                folder->varhash == line_hash(tmp_20k_buf))
 174               return(Main);
 175         }
 176     }
 177
 178     return(None);
 179 }
 180
 181
 182 /*----------------------------------------------------------------------
 183       Format the given folder name for display for the user
 184
 185    Args: folder -- The folder name to fix up
 186
 187 Not sure this always makes it prettier. It could do nice truncation if we
 188 passed in a length. Right now it adds the path name of the mail
 189 subdirectory if appropriate.
 190  ----*/
 191
 192 char *
 193 pretty_fn(char *folder)
 194 {
 195     if(!strucmp(folder, ps_global->inbox_name))
 196       return(ps_global->inbox_name);
 197     else
 198       return(folder);
 199 }
 200
 201
 202 /*----------------------------------------------------------------------
 203   Return the path delimiter for the given folder on the given server
 204
 205   Args: folder -- folder type for delimiter
 206
 207     ----*/
 208 int
 209 get_folder_delimiter(char *folder)
 210 {
 211     MM_LIST_S    ldata;
 212     LISTRES_S    response;
 213     int          ourstream = 0;
 214
 215     memset(mm_list_info = &ldata, 0, sizeof(MM_LIST_S));
 216     ldata.filter = mail_list_response;
 217     memset(ldata.data = &response, 0, sizeof(LISTRES_S));
 218
 219     if(*folder == '{'
 220        && !(ldata.stream = sp_stream_get(folder, SP_MATCH))
 221        && !(ldata.stream = sp_stream_get(folder, SP_SAME))){
 222         if((ldata.stream = pine_mail_open(NULL,folder,
 223                                  OP_HALFOPEN|OP_SILENT|SP_USEPOOL|SP_TEMPUSE,
 224                                          NULL)) != NULL){
 225             ourstream++;
 226         }
 227         else{
 228             return(FEX_ERROR);
 229         }
 230     }
 231
 232     pine_mail_list(ldata.stream, folder, "", NULL);
 233
 234     if(ourstream)
 235       pine_mail_close(ldata.stream);
 236
 237     return(response.delim);
 238 }
 239
 240
 241 /*----------------------------------------------------------------------
 242        Check to see if folder exists in given context
 243
 244   Args: cntxt -- context inwhich to interpret "file" arg
 245         file  -- name of folder to check
 246
 247  Result: returns FEX_ISFILE if the folder exists and is a folder
 248                  FEX_ISDIR  if the folder exists and is a directory
 249                  FEX_NOENT  if it doesn't exist
 250                  FEX_ERROR  on error
 251
 252   The two existence return values above may be logically OR'd
 253
 254   Uses mail_list to sniff out the existence of the requested folder.
 255   The context string is just here for convenience.  Checking for
 256   folder's existence within a given context is probably more efficiently
 257   handled outside this function for now using build_folder_list().
 258
 259     ----*/
 260 int
 261 folder_exists(CONTEXT_S *cntxt, char *file)
 262 {
 263     return(folder_name_exists(cntxt, file, NULL));
 264 }
 265
 266
 267 /*----------------------------------------------------------------------
 268        Check to see if folder exists in given context
 269
 270   Args: cntxt -- context in which to interpret "file" arg
 271         file  -- name of folder to check
 272         name  -- name of folder folder with context applied
 273
 274  Result: returns FEX_ISFILE if the folder exists and is a folder
 275                  FEX_ISDIR  if the folder exists and is a directory
 276                  FEX_NOENT  if it doesn't exist
 277                  FEX_ERROR  on error
 278
 279   The two existence return values above may be logically OR'd
 280
 281   Uses mail_list to sniff out the existence of the requested folder.
 282   The context string is just here for convenience.  Checking for
 283   folder's existence within a given context is probably more efficiently
 284   handled outside this function for now using build_folder_list().
 285
 286     ----*/
 287 int
 288 folder_name_exists(CONTEXT_S *cntxt, char *file, char **fullpath)
 289 {
 290     MM_LIST_S    ldata;
 291     EXISTDATA_S  parms;
 292     int          we_cancel = 0, res;
 293     char        *p, reference[MAILTMPLEN], tmp[MAILTMPLEN], *tfolder = NULL;
 294
 295     /*
 296      * No folder means "inbox".
 297      */
 298     if(*file == '{' && (p = strchr(file, '}')) && (!*(p+1))){
 299         size_t l;
 300
 301         l = strlen(file)+strlen("inbox");
 302         tfolder = (char *) fs_get((l+1) * sizeof(char));
 303         snprintf(tfolder, l+1, "%s%s", file, "inbox");
 304         file = tfolder;
 305         cntxt = NULL;
 306     }
 307
 308     mm_list_info = &ldata;              /* tie down global reference */
 309     memset(&ldata, 0, sizeof(ldata));
 310     ldata.filter = mail_list_exists;
 311
 312     ldata.stream = sp_stream_get(context_apply(tmp, cntxt, file, sizeof(tmp)),
 313                                  SP_SAME);
 314
 315     memset(ldata.data = &parms, 0, sizeof(EXISTDATA_S));
 316
 317     /*
 318      * If no preset reference string, must be at top of context
 319      */
 320     if(cntxt && context_isambig(file)){
 321         /* inbox in first context is the real inbox */
 322         if(ps_global->context_list == cntxt && !strucmp(file, ps_global->inbox_name)){
 323             reference[0] = '\0';
 324             parms.args.reference = reference;
 325         }
 326         else if(!(parms.args.reference = cntxt->dir->ref)){
 327             char *p;
 328
 329             if((p = strstr(cntxt->context, "%s")) != NULL){
 330                 strncpy(parms.args.reference = reference,
 331                         cntxt->context,
 332                         MIN(p - cntxt->context, sizeof(reference)-1));
 333                 reference[MIN(p - cntxt->context, sizeof(reference)-1)] = '\0';
 334                 if(*(p += 2))
 335                   parms.args.tail = p;
 336             }
 337             else
 338               parms.args.reference = cntxt->context;
 339         }
 340
 341         parms.fullname = fullpath;
 342     }
 343
 344     ps_global->mm_log_error = 0;
 345     ps_global->noshow_error = 1;
 346
 347     we_cancel = busy_cue(NULL, NULL, 1);
 348
 349     parms.args.name = file;
 350
 351     res = pine_mail_list(ldata.stream, parms.args.reference, parms.args.name,
 352                          &ldata.options);
 353
 354     if(we_cancel)
 355       cancel_busy_cue(-1);
 356
 357     ps_global->noshow_error = 0;
 358
 359     if(cntxt && cntxt->dir && parms.response.delim)
 360       cntxt->dir->delim = parms.response.delim;
 361
 362     if(tfolder)
 363       fs_give((void **)&tfolder);
 364     return(((res == FALSE) || ps_global->mm_log_error)
 365             ? FEX_ERROR
 366             : (((parms.response.isfile)
 367                   ? FEX_ISFILE : 0 )
 368                | ((parms.response.isdir)
 369                   ? FEX_ISDIR : 0)
 370                | ((parms.response.ismarked)
 371                   ? FEX_ISMARKED : 0)
 372                | ((parms.response.unmarked)
 373                   ? FEX_UNMARKED : 0)));
 374 }
 375
 376
 377 void
 378 mail_list_exists(MAILSTREAM *stream, char *mailbox, int delim, long int attribs,
 379                  void *data, unsigned int options)
 380 {
 381     if(delim)
 382       ((EXISTDATA_S *) data)->response.delim = delim;
 383
 384     if(mailbox && *mailbox){
 385         if(!(attribs & LATT_NOSELECT)){
 386             ((EXISTDATA_S *) data)->response.isfile  = 1;
 387             ((EXISTDATA_S *) data)->response.count  += 1;
 388         }
 389
 390         if(!(attribs & LATT_NOINFERIORS)){
 391             ((EXISTDATA_S *) data)->response.isdir  = 1;
 392             ((EXISTDATA_S *) data)->response.count  += 1;
 393         }
 394
 395         if(attribs & LATT_MARKED)
 396           ((EXISTDATA_S *) data)->response.ismarked = 1;
 397
 398         /* don't mark #move folders unmarked */
 399         if(attribs & LATT_UNMARKED && !(options & PML_IS_MOVE_MBOX))
 400           ((EXISTDATA_S *) data)->response.unmarked = 1;
 401
 402         if(attribs & LATT_HASCHILDREN)
 403           ((EXISTDATA_S *) data)->response.haschildren = 1;
 404
 405         if(attribs & LATT_HASNOCHILDREN)
 406           ((EXISTDATA_S *) data)->response.hasnochildren = 1;
 407
 408         if(((EXISTDATA_S *) data)->fullname
 409            && ((((EXISTDATA_S *) data)->args.reference[0] != '\0')
 410                  ? struncmp(((EXISTDATA_S *) data)->args.reference, mailbox,
 411                             strlen(((EXISTDATA_S *)data)->args.reference))
 412                  : struncmp(((EXISTDATA_S *) data)->args.name, mailbox,
 413                             strlen(((EXISTDATA_S *) data)->args.name)))){
 414             char   *p;
 415             size_t  alloclen;
 416             size_t  len = (((stream && stream->mailbox)
 417                               ? strlen(stream->mailbox) : 0)
 418                            + strlen(((EXISTDATA_S *) data)->args.reference)
 419                            + strlen(((EXISTDATA_S *) data)->args.name)
 420                            + strlen(mailbox)) * sizeof(char);
 421
 422             /*
 423              * Fully qualify (in the c-client name structure sense)
 424              * anything that's not in the context of the "reference"...
 425              */
 426             if(*((EXISTDATA_S *) data)->fullname)
 427               fs_give((void **) ((EXISTDATA_S *) data)->fullname);
 428
 429             alloclen = len;
 430             *((EXISTDATA_S *) data)->fullname = (char *) fs_get(alloclen);
 431             if(*mailbox != '{'
 432                && stream && stream->mailbox && *stream->mailbox == '{'
 433                && (p = strindex(stream->mailbox, '}'))){
 434                 len = (p - stream->mailbox) + 1;
 435                 strncpy(*((EXISTDATA_S *) data)->fullname,
 436                         stream->mailbox, MIN(len,alloclen));
 437                 p = *((EXISTDATA_S *) data)->fullname + len;
 438             }
 439             else
 440               p = *((EXISTDATA_S *) data)->fullname;
 441
 442             strncpy(p, mailbox, alloclen-(p-(*((EXISTDATA_S *) data)->fullname)));
 443             (*((EXISTDATA_S *) data)->fullname)[alloclen-1] = '\0';;
 444         }
 445     }
 446 }
 447
 448
 449 void
 450 mail_list_response(MAILSTREAM *stream, char *mailbox, int delim, long int attribs,
 451                    void *data, unsigned int options)
 452 {
 453     int counted = 0;
 454
 455     if(delim)
 456       ((LISTRES_S *) data)->delim = delim;
 457
 458     if(mailbox && *mailbox){
 459         if(!(attribs & LATT_NOSELECT)){
 460             counted++;
 461             ((LISTRES_S *) data)->isfile  = 1;
 462             ((LISTRES_S *) data)->count  += 1;
 463         }
 464
 465         if(!(attribs & LATT_NOINFERIORS)){
 466             ((LISTRES_S *) data)->isdir  = 1;
 467
 468             if(!counted)
 469               ((LISTRES_S *) data)->count += 1;
 470         }
 471
 472         if(attribs & LATT_HASCHILDREN)
 473           ((LISTRES_S *) data)->haschildren = 1;
 474
 475         if(attribs & LATT_HASNOCHILDREN)
 476           ((LISTRES_S *) data)->hasnochildren = 1;
 477     }
 478 }
 479
 480
 481 char *
 482 folder_as_breakout(CONTEXT_S *cntxt, char *name)
 483 {
 484     if(context_isambig(name)){          /* if simple check doesn't pan out */
 485         char tmp[2*MAILTMPLEN], *p, *f; /* look harder */
 486
 487         if(!cntxt->dir->delim){
 488             (void) context_apply(tmp, cntxt, "", sizeof(tmp)/2);
 489             cntxt->dir->delim = get_folder_delimiter(tmp);
 490         }
 491
 492         if((p = strindex(name, cntxt->dir->delim)) != NULL){
 493             if(p == name){              /* assumption 6,321: delim is root */
 494                 if(cntxt->context[0] == '{'
 495                    && (p = strindex(cntxt->context, '}'))){
 496                     strncpy(tmp, cntxt->context,
 497                             MIN((p - cntxt->context) + 1, sizeof(tmp)/2));
 498                     tmp[MIN((p - cntxt->context) + 1, sizeof(tmp)/2)] = '\0';
 499                     strncpy(&tmp[MIN((p - cntxt->context) + 1, sizeof(tmp)/2)],
 500                             name, sizeof(tmp)/2-strlen(tmp));
 501                     tmp[sizeof(tmp)-1] = '\0';
 502                     return(cpystr(tmp));
 503                 }
 504                 else
 505                   return(cpystr(name));
 506             }
 507             else{                       /* assumption 6,322: no create ~foo */
 508                 strncpy(tmp, name, MIN(p - name, MAILTMPLEN));
 509                 /* lop off trailingpath */
 510                 tmp[MIN(p - name, sizeof(tmp)/2)] = '\0';
 511                 f             = NULL;
 512                 (void)folder_name_exists(cntxt, tmp, &f);
 513                 if(f){
 514                     snprintf(tmp, sizeof(tmp), "%s%s",f,p);
 515                     tmp[sizeof(tmp)-1] = '\0';
 516                     fs_give((void **) &f);
 517                     return(cpystr(tmp));
 518                 }
 519             }
 520         }
 521     }
 522
 523     return(NULL);
 524 }
 525
 526
 527 /*----------------------------------------------------------------------
 528  Initialize global list of contexts for folder collections.
 529
 530  Interprets collections defined in the pinerc and orders them for
 531  pine's use.  Parses user-provided context labels and sets appropriate
 532  use flags and the default prototype for that collection.
 533  (See find_folders for how the actual folder list is found).
 534
 535   ----*/
 536 void
 537 init_folders(struct pine *ps)
 538 {
 539     CONTEXT_S  *tc, *top = NULL, **clist;
 540     int         i, prime = 0;
 541
 542     clist = &top;
 543
 544     /*
 545      * If no incoming folders are config'd, but the user asked for
 546      * them via feature, make sure at least "inbox" ends up there...
 547      */
 548     if(F_ON(F_ENABLE_INCOMING, ps) && !ps->VAR_INCOMING_FOLDERS){
 549         ps->VAR_INCOMING_FOLDERS    = (char **)fs_get(2 * sizeof(char *));
 550         ps->VAR_INCOMING_FOLDERS[0] = cpystr(ps->inbox_name);
 551         ps->VAR_INCOMING_FOLDERS[1] = NULL;
 552     }
 553
 554     /*
 555      * Build context that's a list of folders the user's defined
 556      * as receiving new messages.  At some point, this should
 557      * probably include adding a prefix with the new message count.
 558      * fake new context...
 559      */
 560     if(ps->VAR_INCOMING_FOLDERS && ps->VAR_INCOMING_FOLDERS[0]
 561        && (tc = new_context("Incoming-Folders []", NULL))){
 562         tc->dir->status &= ~CNTXT_NOFIND;
 563         tc->use    |= CNTXT_INCMNG;     /* mark this as incoming collection */
 564         if(tc->label)
 565           fs_give((void **) &tc->label);
 566
 567         /* TRANSLATORS: a label */
 568         tc->label = cpystr(_("Incoming Message Folders"));
 569
 570         *clist = tc;
 571         clist  = &tc->next;
 572
 573         init_incoming_folder_list(ps, tc);
 574     }
 575
 576     /*
 577      * Build list of folder collections.  Because of the way init.c
 578      * works, we're guaranteed at least a default.  Also write any
 579      * "bogus format" messages...
 580      */
 581     for(i = 0; ps->VAR_FOLDER_SPEC && ps->VAR_FOLDER_SPEC[i] ; i++)
 582       if((tc = new_context(ps->VAR_FOLDER_SPEC[i], &prime)) != NULL){
 583           *clist    = tc;                       /* add it to list   */
 584           clist     = &tc->next;                /* prepare for next */
 585           tc->var.v = &ps->vars[V_FOLDER_SPEC];
 586           tc->var.i = i;
 587       }
 588
 589
 590     /*
 591      * Whoah cowboy!!!  Guess we couldn't find a valid folder
 592      * collection???
 593      */
 594     if(!prime)
 595       alpine_panic(_("No folder collections defined"));
 596
 597     /*
 598      * At this point, insert the INBOX mapping as the leading
 599      * folder entry of the first collection...
 600      */
 601     init_inbox_mapping(ps->VAR_INBOX_PATH, top);
 602
 603     set_news_spec_current_val(TRUE, TRUE);
 604
 605     /*
 606      * If news groups, loop thru list adding to collection list
 607      */
 608     for(i = 0; ps->VAR_NEWS_SPEC && ps->VAR_NEWS_SPEC[i] ; i++)
 609       if(ps->VAR_NEWS_SPEC[i][0]
 610          && (tc = new_context(ps->VAR_NEWS_SPEC[i], NULL))){
 611           *clist      = tc;                     /* add it to list   */
 612           clist       = &tc->next;              /* prepare for next */
 613           tc->var.v   = &ps->vars[V_NEWS_SPEC];
 614           tc->var.i   = i;
 615       }
 616
 617     ps->context_list    = top;  /* init pointers */
 618     ps->context_current = (top->use & CNTXT_INCMNG) ? top->next : top;
 619     ps->context_last    = NULL;
 620     /* Tie up all the previous pointers */
 621     for(; top; top = top->next)
 622       if(top->next)
 623         top->next->prev = top;
 624
 625 #ifdef  DEBUG
 626       dump_contexts();
 627 #endif
 628 }
 629
 630
 631 /*
 632  * Add incoming list of folders to context.
 633  */
 634 void
 635 init_incoming_folder_list(struct pine *ps, CONTEXT_S *cntxt)
 636 {
 637     int       i;
 638     char     *folder_string, *nickname;
 639     FOLDER_S *f;
 640
 641     for(i = 0; ps->VAR_INCOMING_FOLDERS[i] ; i++){
 642         /*
 643          * Parse folder line for nickname and folder name.
 644          * No nickname on line is OK.
 645          */
 646         get_pair(ps->VAR_INCOMING_FOLDERS[i], &nickname, &folder_string,0,0);
 647
 648         /*
 649          * Allow for inbox to be specified in the incoming list, but
 650          * don't let it show up along side the one magically inserted
 651          * above!
 652          */
 653         if(!folder_string || !strucmp(ps->inbox_name, folder_string)){
 654             if(folder_string)
 655               fs_give((void **)&folder_string);
 656
 657             if(nickname)
 658               fs_give((void **)&nickname);
 659
 660             continue;
 661         }
 662         else if(update_bboard_spec(folder_string, tmp_20k_buf, SIZEOF_20KBUF)){
 663             fs_give((void **) &folder_string);
 664             folder_string = cpystr(tmp_20k_buf);
 665         }
 666
 667         f = new_folder(folder_string,
 668                        line_hash(ps->VAR_INCOMING_FOLDERS[i]));
 669         f->isfolder = 1;
 670         fs_give((void **)&folder_string);
 671
 672         if(nickname){
 673             if(strucmp(ps->inbox_name, nickname)){
 674                 f->nickname = nickname;
 675                 f->name_len = strlen(f->nickname);
 676             }
 677             else
 678               fs_give((void **)&nickname);
 679         }
 680
 681         init_incoming_unseen_data(ps, f);
 682
 683         folder_insert(f->nickname
 684                       && (strucmp(f->nickname, ps->inbox_name) == 0)
 685                             ? -1 : folder_total(FOLDERS(cntxt)),
 686                       f, FOLDERS(cntxt));
 687     }
 688 }
 689
 690
 691 void
 692 init_incoming_unseen_data(struct pine *ps, FOLDER_S *f)
 693 {
 694     int j, check_this = 0;
 695
 696     if(!f)
 697       return;
 698
 699     /* see if this folder is in the monitoring list */
 700     if(F_ON(F_ENABLE_INCOMING_CHECKING, ps)){
 701         if(!ps->VAR_INCCHECKLIST)
 702           check_this++;                 /* everything in by default */
 703         else{
 704             for(j = 0; !check_this && ps->VAR_INCCHECKLIST[j]; j++){
 705                 if((f->nickname && !strucmp(ps->VAR_INCCHECKLIST[j],f->nickname))
 706                    || (f->name && !strucmp(ps->VAR_INCCHECKLIST[j],f->name)))
 707                   check_this++;
 708             }
 709         }
 710     }
 711
 712     if(check_this)
 713       f->last_unseen_update = LUU_INIT;
 714     else
 715       f->last_unseen_update = LUU_NEVERCHK;
 716 }
 717
 718
 719 void
 720 reinit_incoming_folder_list(struct pine *ps, CONTEXT_S *context)
 721 {
 722     free_folder_entries(&(FOLDERS(context)));
 723     FOLDERS(context) = init_folder_entries();
 724     init_incoming_folder_list(ps_global, context);
 725     init_inbox_mapping(ps_global->VAR_INBOX_PATH, context);
 726 }
 727
 728
 729 /*
 730  *
 731  */
 732 void
 733 init_inbox_mapping(char *path, CONTEXT_S *cntxt)
 734 {
 735     FOLDER_S *f;
 736     int check_this, j;
 737
 738     /*
 739      * If mapping already exists, blast it and replace it below...
 740      */
 741     if((f = folder_entry(0, FOLDERS(cntxt)))
 742        && f->nickname && !strcmp(f->nickname, ps_global->inbox_name))
 743       folder_delete(0, FOLDERS(cntxt));
 744
 745     if(path){
 746         f = new_folder(path, 0);
 747         f->nickname = cpystr(ps_global->inbox_name);
 748         f->name_len = strlen(f->nickname);
 749     }
 750     else
 751       f = new_folder(ps_global->inbox_name, 0);
 752
 753     f->isfolder = 1;
 754
 755     /* see if this folder is in the monitoring list */
 756     check_this = 0;
 757     if(F_ON(F_ENABLE_INCOMING_CHECKING, ps_global) && ps_global->VAR_INCOMING_FOLDERS && ps_global->VAR_INCOMING_FOLDERS[0]){
 758         if(!ps_global->VAR_INCCHECKLIST)
 759           check_this++;                 /* everything in by default */
 760         else{
 761             for(j = 0; !check_this && ps_global->VAR_INCCHECKLIST[j]; j++){
 762                 if((f->nickname && !strucmp(ps_global->VAR_INCCHECKLIST[j],f->nickname))
 763                    || (f->name && !strucmp(ps_global->VAR_INCCHECKLIST[j],f->name)))
 764                   check_this++;
 765             }
 766         }
 767     }
 768
 769     if(check_this)
 770       f->last_unseen_update = LUU_INIT;
 771     else
 772       f->last_unseen_update = LUU_NEVERCHK;
 773
 774     folder_insert(0, f, FOLDERS(cntxt));
 775 }
 776
 777
 778 FDIR_S *
 779 new_fdir(char *ref, char *view, int wildcard)
 780 {
 781     FDIR_S *rv = (FDIR_S *) fs_get(sizeof(FDIR_S));
 782
 783     memset((void *) rv, 0, sizeof(FDIR_S));
 784
 785     /* Monkey with the view to make sure it has wildcard? */
 786     if(view && *view){
 787         rv->view.user = cpystr(view);
 788
 789         /*
 790          * This is sorta hairy since, for simplicity we allow
 791          * users to use '*' in the view, but for mail
 792          * we really mean '%' as def'd in 2060...
 793          */
 794         if(wildcard == '*'){    /* must be #news. */
 795             if(strindex(view, wildcard))
 796               rv->view.internal = cpystr(view);
 797         }
 798         else{                   /* must be mail */
 799             char *p;
 800
 801             if((p = strpbrk(view, "*%")) != NULL){
 802                 rv->view.internal = p = cpystr(view);
 803                 while((p = strpbrk(p, "*%")) != NULL)
 804                   *p++ = '%';   /* convert everything to '%' */
 805             }
 806         }
 807
 808         if(!rv->view.internal){
 809             size_t l;
 810
 811             l = strlen(view)+2;
 812             rv->view.internal = (char *) fs_get((l+1) * sizeof(char));
 813             snprintf(rv->view.internal, l+1, "%c%s%c", wildcard, view, wildcard);
 814         }
 815     }
 816     else{
 817         rv->view.internal = (char *) fs_get(2 * sizeof(char));
 818         snprintf(rv->view.internal, 2, "%c", wildcard);
 819     }
 820
 821     if(ref)
 822       rv->ref = ref;
 823
 824     rv->folders = init_folder_entries();
 825     rv->status = CNTXT_NOFIND;
 826     return(rv);
 827 }
 828
 829
 830 void
 831 free_fdir(FDIR_S **f, int recur)
 832 {
 833     if(f && *f){
 834         if((*f)->prev && recur)
 835           free_fdir(&(*f)->prev, 1);
 836
 837         if((*f)->ref)
 838           fs_give((void **)&(*f)->ref);
 839
 840         if((*f)->view.user)
 841           fs_give((void **)&(*f)->view.user);
 842
 843         if((*f)->view.internal)
 844           fs_give((void **)&(*f)->view.internal);
 845
 846         if((*f)->desc)
 847           fs_give((void **)&(*f)->desc);
 848
 849         free_folder_entries(&(*f)->folders);
 850         fs_give((void **) f);
 851     }
 852 }
 853
 854
 855 int
 856 update_bboard_spec(char *bboard, char *buf, size_t buflen)
 857 {
 858     char *p = NULL, *origbuf;
 859     int   nntp = 0, bracket = 0;
 860
 861     origbuf = buf;
 862
 863     if(*bboard == '*'
 864        || (*bboard == '{' && (p = strindex(bboard, '}')) && *(p+1) == '*')){
 865         /* server name ? */
 866         if(p || (*(bboard+1) == '{' && (p = strindex(++bboard, '}'))))
 867           while(bboard <= p && (buf-origbuf < buflen))          /* copy it */
 868             if((*buf++ = *bboard++) == '/' && !strncmp(bboard, "nntp", 4))
 869               nntp++;
 870
 871         if(*bboard == '*')
 872           bboard++;
 873
 874         if(!nntp){
 875           /*
 876            * See if path portion looks newsgroup-ish while being aware
 877            * of the "view" portion of the spec...
 878            */
 879           for(p = bboard; *p; p++)
 880             if(*p == '['){
 881                 if(bracket)             /* only one set allowed! */
 882                   break;
 883                 else
 884                   bracket++;
 885             }
 886             else if(*p == ']'){
 887                 if(bracket != 1)        /* must be closing bracket */
 888                   break;
 889                 else
 890                   bracket++;
 891             }
 892             else if(!(isalnum((unsigned char) *p) || strindex(".-", *p)))
 893               break;
 894         }
 895
 896         snprintf(buf, buflen-(buf-origbuf), "%s%s%s",
 897                 (!nntp && *p) ? "#public" : "#news.",
 898                 (!nntp && *p && *bboard != '/') ? "/" : "",
 899                 bboard);
 900
 901         return(1);
 902     }
 903
 904     return(0);
 905 }
 906
 907
 908 /*
 909  * build_folder_list - call mail_list to fetch us a list of folders
 910  *                     from the given context.
 911  */
 912 void
 913 build_folder_list(MAILSTREAM **stream, CONTEXT_S *context, char *pat, char *content, int flags)
 914 {
 915     MM_LIST_S  ldata;
 916     BFL_DATA_S response;
 917     int        local_open = 0, we_cancel = 0, resort = 0;
 918     char       reference[2*MAILTMPLEN], *p;
 919
 920     if(!(context->dir->status & CNTXT_NOFIND)
 921        || (context->dir->status & CNTXT_PARTFIND))
 922       return;                           /* find already done! */
 923
 924     dprint((7, "build_folder_list: %s %s\n",
 925                context ? context->context : "NULL",
 926                pat ? pat : "NULL"));
 927
 928     we_cancel = busy_cue(NULL, NULL, 1);
 929
 930     /*
 931      * Set up the pattern of folder name's to match within the
 932      * given context.
 933      */
 934     if(!pat || ((*pat == '*' || *pat == '%') && *(pat+1) == '\0')){
 935         context->dir->status &= ~CNTXT_NOFIND;  /* let'em know we tried */
 936         pat = context->dir->view.internal;
 937     }
 938     else
 939       context->use |= CNTXT_PARTFIND;   /* or are in a partial find */
 940
 941     memset(mm_list_info = &ldata, 0, sizeof(MM_LIST_S));
 942     ldata.filter = (NEWS_TEST(context)) ? mail_lsub_filter : mail_list_filter;
 943     memset(ldata.data = &response, 0, sizeof(BFL_DATA_S));
 944     response.list = FOLDERS(context);
 945
 946     if(flags & BFL_FLDRONLY)
 947       response.mask = LATT_NOSELECT;
 948
 949     /*
 950      * if context is associated with a server, prepare a stream for
 951      * sending our request.
 952      */
 953     if(*context->context == '{'){
 954         /*
 955          * Try using a stream we've already got open...
 956          */
 957         if(stream && *stream
 958            && !(ldata.stream = same_stream(context->context, *stream))){
 959             pine_mail_close(*stream);
 960             *stream = NULL;
 961         }
 962
 963         if(!ldata.stream)
 964           ldata.stream = sp_stream_get(context->context, SP_MATCH);
 965
 966         if(!ldata.stream)
 967           ldata.stream = sp_stream_get(context->context, SP_SAME);
 968
 969         /* gotta open a new one? */
 970         if((F_OFF(F_CMBND_FOLDER_DISP, ps_global)
 971                 || context->update == LUU_INIT) && !ldata.stream){
 972             ldata.stream = mail_cmd_stream(context, &local_open);
 973             if(stream)
 974               *stream = ldata.stream;
 975         }
 976
 977         dprint((ldata.stream ? 7 : 1, "build_folder_list: mail_open(%s) %s.\n",
 978                 context->server ? context->server : "?",
 979                 ldata.stream ? "OK" : "FAILED"));
 980
 981         if(!ldata.stream){
 982             context->use &= ~CNTXT_PARTFIND;    /* unset partial find bit */
 983             context->update = LUU_NOMORECHK;
 984             if(we_cancel)
 985               cancel_busy_cue(-1);
 986
 987             return;
 988         }
 989     }
 990     else if(stream && *stream){                 /* no server, simple case */
 991         if(!sp_flagged(*stream, SP_LOCKED))
 992           pine_mail_close(*stream);
 993
 994         *stream = NULL;
 995     }
 996
 997     /*
 998      * If preset reference string, we're somewhere in the hierarchy.
 999      * ELSE we must be at top of context...
1000      */
1001     response.args.name = pat;
1002     if(!(response.args.reference = context->dir->ref)){
1003         if((p = strstr(context->context, "%s")) != NULL){
1004             strncpy(response.args.reference = reference,
1005                     context->context,
1006                     MIN(p - context->context, sizeof(reference)/2));
1007             reference[MIN(p - context->context, sizeof(reference)/2)] = '\0';
1008             if(*(p += 2))
1009               response.args.tail = p;
1010         }
1011         else
1012           response.args.reference = context->context;
1013     }
1014
1015     if(flags & BFL_SCAN)
1016       mail_scan(ldata.stream, response.args.reference,
1017                 response.args.name, content);
1018     else if(flags & BFL_LSUB)
1019       mail_lsub(ldata.stream, response.args.reference, response.args.name);
1020     else{
1021       set_read_predicted(1);
1022       pine_mail_list(ldata.stream, response.args.reference, response.args.name,
1023                      &ldata.options);
1024       set_read_predicted(0);
1025     }
1026
1027     context->update = LUU_INIT;
1028     if(context->dir && response.response.delim)
1029       context->dir->delim = response.response.delim;
1030
1031     if(!(flags & (BFL_LSUB|BFL_SCAN)) && F_ON(F_QUELL_EMPTY_DIRS, ps_global)){
1032         LISTRES_S  listres;
1033         FOLDER_S  *f;
1034         int        i;
1035
1036         for(i = 0; i < folder_total(response.list); i++)
1037           if((f = folder_entry(i, FOLDERS(context)))->isdir){
1038               /*
1039                * we don't need to do a list if we know already
1040                * whether there are children or not.
1041                */
1042               if(!f->haschildren && !f->hasnochildren){
1043                   memset(ldata.data = &listres, 0, sizeof(LISTRES_S));
1044                   ldata.filter = mail_list_response;
1045
1046                   if(context->dir->ref)
1047                     snprintf(reference, sizeof(reference), "%s%s", context->dir->ref, f->name);
1048                   else
1049                     context_apply(reference, context, f->name, sizeof(reference)/2);
1050
1051                   /* append the delimiter to the reference */
1052                   for(p = reference; *p; p++)
1053                     ;
1054
1055                   *p++ = context->dir->delim;
1056                   *p   = '\0';
1057
1058                   pine_mail_list(ldata.stream, reference, "%", NULL);
1059
1060                   /* anything interesting inside? */
1061                   f->hasnochildren = (listres.count <= 1L);
1062                   f->haschildren   = !f->hasnochildren;;
1063               }
1064
1065               if(f->hasnochildren){
1066                   if(f->isfolder){
1067                       f->isdir = 0;
1068                       if(ps_global->fld_sort_rule == FLD_SORT_ALPHA_DIR_FIRST
1069                          || ps_global->fld_sort_rule == FLD_SORT_ALPHA_DIR_LAST)
1070                         resort = 1;
1071                   }
1072                   /*
1073                    * We don't want to hide directories
1074                    * that are only directories even if they are
1075                    * empty. We only want to hide the directory
1076                    * piece of a dual-use folder when there are
1077                    * no children in the directory (and the user
1078                    * most likely thinks of it as a folder instead
1079                    * of a folder and a directory).
1080                    */
1081                   else if(f->isdir && f->isdual){
1082                       folder_delete(i, FOLDERS(context));
1083                       i--;
1084                   }
1085               }
1086           }
1087     }
1088
1089     if(resort)
1090       resort_folder_list(response.list);
1091
1092     if(local_open && !stream)
1093       pine_mail_close(ldata.stream);
1094
1095     if(context->use & CNTXT_PRESRV)
1096       folder_select_restore(context);
1097
1098     context->use &= ~CNTXT_PARTFIND;    /* unset partial list bit */
1099     if(we_cancel)
1100       cancel_busy_cue(-1);
1101 }
1102
1103
1104 /*
1105  * Validate LIST response to command issued from build_folder_list
1106  *
1107  */
1108 void
1109 mail_list_filter(MAILSTREAM *stream, char *mailbox, int delim, long int attribs, void *data, unsigned int options)
1110 {
1111     BFL_DATA_S *ld = (BFL_DATA_S *) data;
1112     FOLDER_S   *new_f = NULL, *dual_f = NULL;
1113     int         suppress_folder_add = 0;
1114
1115     if(!ld)
1116       return;
1117
1118     if(delim)
1119       ld->response.delim = delim;
1120
1121     /* test against mask of DIS-allowed attributes */
1122     if((ld->mask & attribs)){
1123         dprint((3, "mail_list_filter: failed attribute test"));
1124         return;
1125     }
1126
1127     /*
1128      * First, make sure response fits our "reference" arg
1129      * NOTE: build_folder_list can't supply breakout?
1130      */
1131     if(!mail_list_in_collection(&mailbox, ld->args.reference,
1132                                 ld->args.name, ld->args.tail))
1133       return;
1134
1135     /* ignore dotfolders unless told not to */
1136     if(F_OFF(F_ENABLE_DOT_FOLDERS, ps_global) && *mailbox == '.'){
1137         dprint((3, "mail_list_filter: dotfolder disallowed"));
1138         return;
1139     }
1140
1141     /*
1142      * If this response is INBOX we have to handle it specially.
1143      * The special cases are:
1144      *
1145      * Incoming folders are enabled and this INBOX is in the Incoming
1146      * folders list already. We don't want to list it here, as well,
1147      * unless it is also a directory.
1148      *
1149      * Incoming folders are not enabled, but we inserted INBOX into
1150      * this primary collection (with init_inbox_mapping()) so it is
1151      * already accounted for unless it is also a directory.
1152      *
1153      * Incoming folders are not enabled, but we inserted INBOX into
1154      * the primary collection (which we are not looking at here) so
1155      * it is already accounted for there. We'll add it as a directory
1156      * as well here if that is what is called for.
1157      */
1158     if(!strucmp(mailbox, ps_global->inbox_name)){
1159         int ftotal, i;
1160         FOLDER_S *f;
1161         char fullname[1000], tmp1[1000], tmp2[1000], *l1, *l2;
1162
1163         /* fullname is the name of the mailbox in the list response */
1164         if(ld->args.reference){
1165             strncpy(fullname, ld->args.reference, sizeof(fullname)-1);
1166             fullname[sizeof(fullname)-1] = '\0';
1167         }
1168         else
1169           fullname[0] = '\0';
1170
1171         strncat(fullname, mailbox, sizeof(fullname)-strlen(fullname)-1);
1172         fullname[sizeof(fullname)-1] = '\0';
1173
1174         /* check if Incoming Folders are enabled */
1175         if(ps_global->context_list && ps_global->context_list->use & CNTXT_INCMNG){
1176             int this_inbox_is_in_incoming = 0;
1177
1178             /*
1179              * Figure out if this INBOX is already in the Incoming list.
1180              */
1181
1182             /* compare fullname to each incoming folder */
1183             ftotal = folder_total(FOLDERS(ps_global->context_list));
1184             for(i = 0; i < ftotal && !this_inbox_is_in_incoming; i++){
1185                 f = folder_entry(i, FOLDERS(ps_global->context_list));
1186                 if(f && f->name){
1187                     if(same_remote_mailboxes(fullname, f->name)
1188                        || ((!IS_REMOTE(fullname) && !IS_REMOTE(f->name))
1189                            && (l1=mailboxfile(tmp1,fullname))
1190                            && (l2=mailboxfile(tmp2,f->name))
1191                            && !strcmp(l1,l2)))
1192                       this_inbox_is_in_incoming++;
1193                 }
1194             }
1195
1196             if(this_inbox_is_in_incoming){
1197                 /*
1198                  * Don't add a folder for this, only a directory if called for.
1199                  * If it isn't a directory, skip it.
1200                  */
1201                 if(!(delim && !(attribs & LATT_NOINFERIORS)))
1202                   return;
1203
1204                 suppress_folder_add++;
1205             }
1206         }
1207         else{
1208             int inbox_is_in_this_collection = 0;
1209
1210             /* is INBOX already in this folder list? */
1211             ftotal = folder_total(ld->list);
1212             for(i = 0; i < ftotal && !inbox_is_in_this_collection; i++){
1213                 f = folder_entry(i, ld->list);
1214                 if(!strucmp(FLDR_NAME(f), ps_global->inbox_name))
1215                   inbox_is_in_this_collection++;
1216             }
1217
1218             if(inbox_is_in_this_collection){
1219
1220                 /*
1221                  * Inbox is already inserted in this collection. Unless
1222                  * it is also a directory, we are done.
1223                  */
1224                 if(!(delim && !(attribs & LATT_NOINFERIORS)))
1225                   return;
1226
1227                 /*
1228                  * Since it is also a directory, what we do depends on
1229                  * the F_SEP feature. If that feature is not set we just
1230                  * want to mark the existing entry dual-use. If F_SEP is
1231                  * set we want to add a new directory entry.
1232                  */
1233                 if(F_ON(F_SEPARATE_FLDR_AS_DIR, ps_global)){
1234                     f->isdir = 0;
1235                     f->haschildren = 0;
1236                     f->hasnochildren = 0;
1237                     /* fall through and add a new directory */
1238                 }
1239                 else{
1240                     /* mark existing entry dual-use and return */
1241                     ld->response.count++;
1242                     ld->response.isdir = 1;
1243                     f->isdir = 1;
1244                     if(attribs & LATT_HASCHILDREN)
1245                       f->haschildren = 1;
1246
1247                     if(attribs & LATT_HASNOCHILDREN)
1248                       f->hasnochildren = 1;
1249
1250                     return;
1251                 }
1252
1253                 suppress_folder_add++;
1254             }
1255             else{
1256                 int found_it = 0;
1257                 int this_inbox_is_primary_inbox = 0;
1258
1259                 /*
1260                  * See if this INBOX is the same as the INBOX we inserted
1261                  * in the primary collection.
1262                  */
1263
1264                 /* first find the existing INBOX entry */
1265                 ftotal = folder_total(FOLDERS(ps_global->context_list));
1266                 for(i = 0; i < ftotal && !found_it; i++){
1267                     f = folder_entry(i, FOLDERS(ps_global->context_list));
1268                     if(!strucmp(FLDR_NAME(f), ps_global->inbox_name))
1269                       found_it++;
1270                 }
1271
1272                 if(found_it && f && f->name){
1273                     if(same_remote_mailboxes(fullname, f->name)
1274                        || ((!IS_REMOTE(fullname) && !IS_REMOTE(f->name))
1275                            && (l1=mailboxfile(tmp1,fullname))
1276                            && (l2=mailboxfile(tmp2,f->name))
1277                            && !strcmp(l1,l2)))
1278                       this_inbox_is_primary_inbox++;
1279                 }
1280
1281                 if(this_inbox_is_primary_inbox){
1282                     /*
1283                      * Don't add a folder for this, only a directory if called for.
1284                      * If it isn't a directory, skip it.
1285                      */
1286                     if(!(delim && !(attribs & LATT_NOINFERIORS)))
1287                       return;
1288
1289                     suppress_folder_add++;
1290                 }
1291             }
1292         }
1293     }
1294
1295     /* is it a mailbox? */
1296     if(!(attribs & LATT_NOSELECT) && !suppress_folder_add){
1297         ld->response.count++;
1298         ld->response.isfile = 1;
1299         new_f = new_folder(mailbox, 0);
1300         new_f->isfolder = 1;
1301
1302         if(F_ON(F_SEPARATE_FLDR_AS_DIR, ps_global)){
1303             folder_insert(-1, new_f, ld->list);
1304             dual_f = new_f;
1305             new_f = NULL;
1306         }
1307     }
1308
1309     /* directory? */
1310     if(delim && !(attribs & LATT_NOINFERIORS)){
1311         ld->response.count++;
1312         ld->response.isdir = 1;
1313
1314         if(!new_f)
1315           new_f = new_folder(mailbox, 0);
1316
1317         new_f->isdir = 1;
1318         if(attribs & LATT_HASCHILDREN)
1319           new_f->haschildren = 1;
1320         if(attribs & LATT_HASNOCHILDREN)
1321           new_f->hasnochildren = 1;
1322
1323         /*
1324          * When we have F_SEPARATE_FLDR_AS_DIR we still want to know
1325          * whether the name really represents both so that we don't
1326          * inadvertently delete both when the user meant one or the
1327          * other.
1328          */
1329         if(dual_f){
1330             if(attribs & LATT_HASCHILDREN)
1331               dual_f->haschildren = 1;
1332
1333             if(attribs & LATT_HASNOCHILDREN)
1334               dual_f->hasnochildren = 1;
1335
1336             dual_f->isdual = 1;
1337             new_f->isdual = 1;
1338         }
1339     }
1340
1341     if(new_f)
1342       folder_insert(-1, new_f, ld->list);
1343
1344     if(attribs & LATT_MARKED)
1345       ld->response.ismarked = 1;
1346
1347     /* don't mark #move folders unmarked */
1348     if(attribs & LATT_UNMARKED && !(options & PML_IS_MOVE_MBOX))
1349       ld->response.unmarked = 1;
1350
1351     if(attribs & LATT_HASCHILDREN)
1352       ld->response.haschildren = 1;
1353
1354     if(attribs & LATT_HASNOCHILDREN)
1355       ld->response.hasnochildren = 1;
1356 }
1357
1358
1359 /*
1360  * Validate LSUB response to command issued from build_folder_list
1361  *
1362  */
1363 void
1364 mail_lsub_filter(MAILSTREAM *stream, char *mailbox, int delim, long int attribs,
1365                  void *data, unsigned int options)
1366 {
1367     BFL_DATA_S *ld = (BFL_DATA_S *) data;
1368     FOLDER_S   *new_f = NULL;
1369     char       *ref;
1370
1371     if(delim)
1372       ld->response.delim = delim;
1373
1374     /* test against mask of DIS-allowed attributes */
1375     if((ld->mask & attribs)){
1376         dprint((3, "mail_lsub_filter: failed attribute test"));
1377         return;
1378     }
1379
1380     /* Normalize mailbox and reference strings re: namespace */
1381     if(!strncmp(mailbox, "#news.", 6))
1382       mailbox += 6;
1383
1384     if(!strncmp(ref = ld->args.reference, "#news.", 6))
1385       ref += 6;
1386
1387     if(!mail_list_in_collection(&mailbox, ref, ld->args.name, ld->args.tail))
1388       return;
1389
1390     if(!(attribs & LATT_NOSELECT)){
1391         ld->response.count++;
1392         ld->response.isfile = 1;
1393         new_f = new_folder(mailbox, 0);
1394         new_f->isfolder = 1;
1395         folder_insert(F_ON(F_READ_IN_NEWSRC_ORDER, ps_global)
1396                         ? folder_total(ld->list) : -1,
1397                       new_f, ld->list);
1398     }
1399
1400     /* We don't support directories in #news */
1401 }
1402
1403 /* human readable name for a folder. memory freed by caller
1404  * This is a jacket to conversion from modified utf7 to utf8.
1405  */
1406 unsigned char *folder_name_decoded(unsigned char *mailbox)
1407 {
1408   unsigned char *s;
1409   s = (unsigned char *) utf8_from_mutf7((unsigned char *) mailbox);
1410   if (s == NULL) s = (unsigned char *) cpystr((char *)mailbox);
1411   return s;
1412 }
1413
1414 /* mutf7 encoded name of a folder, from its name in utf8.
1415  * memory freed by caller.
1416  */
1417 unsigned char *folder_name_encoded(unsigned char *mailbox)
1418 {
1419   unsigned char *s;
1420   if ((s = utf8_to_mutf7(mailbox)) == NULL)
1421      s = (unsigned char *) cpystr((char *) mailbox);
1422   return s;
1423 }
1424
1425 int
1426 mail_list_in_collection(char **mailbox, char *ref, char *name, char *tail)
1427 {
1428     int   boxlen, reflen, taillen;
1429     char *p;
1430
1431     boxlen  = strlen(*mailbox);
1432     reflen  = ref ? strlen(ref) : 0;
1433     taillen = tail ? strlen(tail) : 0;
1434
1435     if(boxlen
1436        && (reflen ? !struncmp(*mailbox, ref, reflen)
1437                   : (p = strpbrk(name, "%*"))
1438                        ? !struncmp(*mailbox, name, p - name)
1439                        : !strucmp(*mailbox,name))
1440        && (!taillen
1441            || (taillen < boxlen - reflen
1442                && !strucmp(&(*mailbox)[boxlen - taillen], tail)))){
1443         if(taillen)
1444           (*mailbox)[boxlen - taillen] = '\0';
1445
1446         if(*(*mailbox += reflen))
1447           return(TRUE);
1448     }
1449     /*
1450      * else don't worry about context "breakouts" since
1451      * build_folder_list doesn't let the user introduce
1452      * one...
1453      */
1454
1455     return(FALSE);
1456 }
1457
1458
1459 /*
1460  * rebuild_folder_list -- free up old list and re-issue commands to build
1461  *                        a new list.
1462  */
1463 void
1464 refresh_folder_list(CONTEXT_S *context, int nodirs, int startover, MAILSTREAM **streamp)
1465 {
1466     if(startover)
1467       free_folder_list(context);
1468
1469     build_folder_list(streamp, context, NULL, NULL,
1470                       (NEWS_TEST(context) ? BFL_LSUB : BFL_NONE)
1471                         | ((nodirs) ? BFL_FLDRONLY : BFL_NONE));
1472 }
1473
1474
1475 /*
1476  * free_folder_list - loop thru the context's lists of folders
1477  *                     clearing all entries without nicknames
1478  *                     (as those were user provided) AND reset the
1479  *                     context's find flag.
1480  *
1481  * NOTE: if fetched() information (e.g., like message counts come back
1482  *       in bboard collections), we may want to have a check before
1483  *       executing the loop and setting the FIND flag.
1484  */
1485 void
1486 free_folder_list(CONTEXT_S *cntxt)
1487 {
1488     int n, i;
1489
1490     /*
1491      * In this case, don't blast the list as it was given to us by the
1492      * user and not the result of a mail_list call...
1493      */
1494     if(cntxt->use & CNTXT_INCMNG)
1495       return;
1496
1497     if(cntxt->use & CNTXT_PRESRV)
1498       folder_select_preserve(cntxt);
1499
1500     for(n = folder_total(FOLDERS(cntxt)), i = 0; n > 0; n--)
1501       if(folder_entry(i, FOLDERS(cntxt))->nickname)
1502         i++;                                    /* entry wasn't from LIST */
1503       else
1504         folder_delete(i, FOLDERS(cntxt));
1505
1506     cntxt->dir->status |= CNTXT_NOFIND;         /* do find next time...  */
1507                                                 /* or add the fake entry */
1508     cntxt->use &= ~(CNTXT_PSEUDO | CNTXT_PRESRV | CNTXT_ZOOM);
1509 }
1510
1511
1512 /*
1513  * default_save_context - return the default context for saved messages
1514  */
1515 CONTEXT_S *
1516 default_save_context(CONTEXT_S *cntxt)
1517 {
1518     while(cntxt)
1519       if((cntxt->use) & CNTXT_SAVEDFLT)
1520         return(cntxt);
1521       else
1522         cntxt = cntxt->next;
1523
1524     return(NULL);
1525 }
1526
1527
1528
1529 /*
1530  * folder_complete - foldername completion routine
1531  *
1532  *   Result: returns 0 if the folder doesn't have a any completion
1533  *                   1 if the folder has a completion (*AND* "name" is
1534  *                     replaced with the completion)
1535  *
1536  */
1537 int
1538 folder_complete(CONTEXT_S *context, char *name, size_t namelen, int *completions)
1539 {
1540     return(folder_complete_internal(context, name, namelen, completions, FC_NONE));
1541 }
1542
1543
1544 /*
1545  *
1546  */
1547 int
1548 folder_complete_internal(CONTEXT_S *context, char *name, size_t namelen,
1549                          int *completions, int flags)
1550 {
1551     int       i, match = -1, ftotal;
1552     char      tmp[MAXFOLDER+2], *a, *b, *fn, *pat;
1553     FOLDER_S *f;
1554
1555     if(completions)
1556       *completions = 0;
1557
1558     if(*name == '\0' || !context_isambig(name))
1559       return(0);
1560
1561     if(!((context->use & CNTXT_INCMNG) || ALL_FOUND(context))){
1562         /*
1563          * Build the folder list from scratch since we may need to
1564          * traverse hierarchy...
1565          */
1566
1567         free_folder_list(context);
1568         snprintf(tmp, sizeof(tmp), "%s%c", name, NEWS_TEST(context) ? '*' : '%');
1569         build_folder_list(NULL, context, tmp, NULL,
1570                           (NEWS_TEST(context) & !(flags & FC_FORCE_LIST))
1571                             ? BFL_LSUB : BFL_NONE);
1572     }
1573
1574     *tmp = '\0';                        /* find uniq substring */
1575     ftotal = folder_total(FOLDERS(context));
1576     for(i = 0; i < ftotal; i++){
1577         f   = folder_entry(i, FOLDERS(context));
1578         fn  = FLDR_NAME(f);
1579         pat = name;
1580         if(!(NEWS_TEST(context) || (context->use & CNTXT_INCMNG))){
1581             fn  = folder_last_cmpnt(fn, context->dir->delim);
1582             pat = folder_last_cmpnt(pat, context->dir->delim);
1583         }
1584
1585         if(!strncmp(fn, pat, strlen(pat))){
1586             if(match != -1){            /* oh well, do best we can... */
1587                 a = fn;
1588                 if(match >= 0){
1589                     f  = folder_entry(match, FOLDERS(context));
1590                     fn = FLDR_NAME(f);
1591                     if(!NEWS_TEST(context))
1592                       fn = folder_last_cmpnt(fn, context->dir->delim);
1593
1594                     strncpy(tmp, fn, sizeof(tmp)-1);
1595                     tmp[sizeof(tmp)-1] = '\0';
1596                 }
1597
1598                 match = -2;
1599                 b     = tmp;            /* remember largest common text */
1600                 while(*a && *b && *a == *b)
1601                   *b++ = *a++;
1602
1603                 *b = '\0';
1604             }
1605             else
1606               match = i;                /* bingo?? */
1607         }
1608     }
1609
1610     if(match >= 0){                     /* found! */
1611         f  = folder_entry(match, FOLDERS(context));
1612         fn = FLDR_NAME(f);
1613         if(!(NEWS_TEST(context) || (context->use & CNTXT_INCMNG)))
1614           fn = folder_last_cmpnt(fn, context->dir->delim);
1615
1616         strncpy(pat, fn, namelen-(pat-name));
1617         name[namelen-1] = '\0';
1618         if(f->isdir && !f->isfolder){
1619             name[i = strlen(name)] = context->dir->delim;
1620             name[i+1] = '\0';
1621         }
1622     }
1623     else if(match == -2){               /* closest we could find */
1624         strncpy(pat, tmp, namelen-(pat-name));
1625         name[namelen-1] = '\0';
1626     }
1627
1628     if(completions)
1629       *completions = ftotal;
1630
1631     if(!((context->use & CNTXT_INCMNG) || ALL_FOUND(context)))
1632       free_folder_list(context);
1633
1634     return((match >= 0) ? ftotal : 0);
1635 }
1636
1637
1638 char *
1639 folder_last_cmpnt(char *s, int d)
1640 {
1641     register char *p;
1642
1643     if(d)
1644       for(p = s; (p = strindex(p, d)); s = ++p)
1645         ;
1646
1647     return(s);
1648 }
1649
1650
1651 /*
1652  * init_folder_entries - return a piece of memory suitable for attaching
1653  *                   a list of folders...
1654  *
1655  */
1656 FLIST *
1657 init_folder_entries(void)
1658 {
1659     FLIST *flist = (FLIST *) fs_get(sizeof(FLIST));
1660     flist->folders = (FOLDER_S **) fs_get(FCHUNK * sizeof(FOLDER_S *));
1661     memset((void *)flist->folders, 0, (FCHUNK * sizeof(FOLDER_S *)));
1662     flist->allocated = FCHUNK;
1663     flist->used      = 0;
1664     return(flist);
1665 }
1666
1667
1668 /*
1669  * new_folder - return a brand new folder entry, with the given name
1670  *              filled in.
1671  *
1672  * NOTE: THIS IS THE ONLY WAY TO PUT A NAME INTO A FOLDER ENTRY!!!
1673  * STRCPY WILL NOT WORK!!!
1674  */
1675 FOLDER_S *
1676 new_folder(char *name, long unsigned int hash)
1677 {
1678     FOLDER_S *tmp;
1679     size_t    l = strlen(name);
1680
1681     tmp = (FOLDER_S *)fs_get(sizeof(FOLDER_S) + (l * sizeof(char)));
1682     memset((void *)tmp, 0, sizeof(FOLDER_S));
1683     strncpy(tmp->name, name, l);
1684     tmp->name[l] = '\0';
1685     tmp->name_len = (unsigned char) l;
1686     tmp->varhash = hash;
1687     return(tmp);
1688 }
1689
1690
1691 /*
1692  * folder_entry - folder struct access routine.  Permit reference to
1693  *                folder structs via index number. Serves two purposes:
1694  *            1) easy way for callers to access folder data
1695  *               conveniently
1696  *            2) allows for a custom manager to limit memory use
1697  *               under certain rather limited "operating systems"
1698  *               who shall renameless, but whose initials are DOS
1699  *
1700  *
1701  */
1702 FOLDER_S *
1703 folder_entry(int i, FLIST *flist)
1704 {
1705     return((i >= flist->used) ? NULL:flist->folders[i]);
1706 }
1707
1708
1709 /*
1710  * free_folder_entries - release all resources associated with the given
1711  *                       list of folder entries
1712  */
1713 void
1714 free_folder_entries(FLIST **flist)
1715 {
1716     register int i;
1717
1718     if(!(flist && *flist))
1719       return;
1720
1721     i = (*flist)->used;
1722     while(i--){
1723         if((*flist)->folders[i]->nickname)
1724           fs_give((void **) &(*flist)->folders[i]->nickname);
1725
1726         fs_give((void **) &((*flist)->folders[i]));
1727     }
1728
1729     fs_give((void **) &((*flist)->folders));
1730     fs_give((void **) flist);
1731 }
1732
1733
1734 /*
1735  * return the number of folders associated with the given folder list
1736  */
1737 int
1738 folder_total(FLIST *flist)
1739 {
1740     return((int) flist->used);
1741 }
1742
1743
1744 /*
1745  * return the index number of the given name in the given folder list
1746  */
1747 int
1748 folder_index(char *name, CONTEXT_S *cntxt, int flags)
1749 {
1750     register  int i = 0;
1751     FOLDER_S *f;
1752     char     *fname;
1753
1754     for(i = 0; (f = folder_entry(i, FOLDERS(cntxt))); i++)
1755       if(((flags & FI_FOLDER) && (f->isfolder || (cntxt->use & CNTXT_INCMNG)))
1756          || ((flags & FI_DIR) && f->isdir)){
1757           fname = FLDR_NAME(f);
1758 #if defined(DOS) || defined(OS2)
1759           if(flags & FI_RENAME){        /* case-dependent for rename */
1760             if(*name == *fname && strcmp(name, fname) == 0)
1761               return(i);
1762           }
1763           else{
1764             if(toupper((unsigned char)(*name))
1765                == toupper((unsigned char)(*fname)) && strucmp(name, fname) == 0)
1766               return(i);
1767           }
1768 #else
1769           if(*name == *fname && strcmp(name, fname) == 0)
1770             return(i);
1771 #endif
1772       }
1773
1774     return(-1);
1775 }
1776
1777
1778 /*
1779  * folder_is_nick - check to see if the given name is a nickname
1780  *                  for some folder in the given context...
1781  *
1782  *  NOTE: no need to check if mm_list_names has been done as
1783  *        nicknames can only be set by configuration...
1784  */
1785 char *
1786 folder_is_nick(char *nickname, FLIST *flist, int flags)
1787 {
1788     register  int  i = 0;
1789     FOLDER_S *f;
1790
1791     if(!(nickname && *nickname && flist))
1792       return(NULL);
1793
1794     while((f = folder_entry(i, flist)) != NULL){
1795         /*
1796          * The second part of the OR is checking in a case-indep
1797          * way for INBOX. It should be restricted to the context
1798          * to which we add the INBOX folder, which would be either
1799          * the Incoming Folders collection or the first collection
1800          * if there is no Incoming collection. We don't need to check
1801          * the collection because nickname assignment has already
1802          * done that for us. Most folders don't have nicknames, only
1803          * incoming folders and folders like inbox if not in incoming.
1804          */
1805         if(f->nickname
1806            && (!strcmp(nickname, f->nickname)
1807                || (!strucmp(nickname, f->nickname)
1808                    && !strucmp(nickname, ps_global->inbox_name)))){
1809             char source[MAILTMPLEN], *target = NULL;
1810
1811             /*
1812              * If f is a maildrop, then we want to return the
1813              * destination folder, not the whole #move thing.
1814              */
1815             if(!(flags & FN_WHOLE_NAME)
1816                && check_for_move_mbox(f->name, source, sizeof(source), &target))
1817               return(target);
1818             else
1819               return(f->name);
1820         }
1821         else
1822           i++;
1823     }
1824
1825     return(NULL);
1826 }
1827
1828
1829 char *
1830 folder_is_target_of_nick(char *longname, CONTEXT_S *cntxt)
1831 {
1832     register  int  i = 0;
1833     FOLDER_S *f;
1834     FLIST *flist = NULL;
1835
1836     if(cntxt && cntxt == ps_global->context_list)
1837       flist = FOLDERS(cntxt);
1838
1839     if(!(longname && *longname && flist))
1840       return(NULL);
1841
1842     while((f = folder_entry(i, flist)) != NULL){
1843         if(f->nickname && f->name && !strcmp(longname, f->name))
1844           return(f->nickname);
1845         else
1846           i++;
1847     }
1848
1849     return(NULL);
1850 }
1851
1852
1853 /*----------------------------------------------------------------------
1854   Insert the given folder name into the sorted folder list
1855   associated with the given context.  Only allow ambiguous folder
1856   names IF associated with a nickname.
1857
1858    Args: index  -- Index to insert at, OR insert in sorted order if -1
1859          folder -- folder structure to insert into list
1860          flist  -- folder list to insert folder into
1861
1862   **** WARNING ****
1863   DON'T count on the folder pointer being valid after this returns
1864   *** ALL FOLDER ELEMENT READS SHOULD BE THROUGH folder_entry() ***
1865
1866   ----*/
1867 int
1868 folder_insert(int index, FOLDER_S *folder, FLIST *flist)
1869 {
1870     /* requested index < 0 means add to sorted list */
1871     if(index < 0 && (index = folder_total(flist)) > 0)
1872       index = folder_insert_sorted(index / 2, 0, index, folder, flist,
1873                      (ps_global->fld_sort_rule == FLD_SORT_ALPHA_DIR_FIRST)
1874                         ? compare_folders_dir_alpha
1875                         : (ps_global->fld_sort_rule == FLD_SORT_ALPHA_DIR_LAST)
1876                              ? compare_folders_alpha_dir
1877                              : compare_folders_alpha);
1878
1879     folder_insert_index(folder, index, flist);
1880     return(index);
1881 }
1882
1883
1884 /*
1885  * folder_insert_sorted - Insert given folder struct into given list
1886  *                        observing sorting specified by given
1887  *                        comparison function
1888  */
1889 int
1890 folder_insert_sorted(int index, int min_index, int max_index, FOLDER_S *folder,
1891                      FLIST *flist, int (*compf)(FOLDER_S *, FOLDER_S *))
1892 {
1893     int       i;
1894
1895     return(((i = (*compf)(folder_entry(index, flist), folder)) == 0)
1896              ? index
1897              : (i < 0)
1898                 ? ((++index >= max_index)
1899                     ? max_index
1900                     : ((*compf)(folder_entry(index, flist), folder) > 0)
1901                        ? index
1902                        : folder_insert_sorted((index + max_index) / 2, index,
1903                                               max_index, folder, flist, compf))
1904                 : ((index <= min_index)
1905                     ? min_index
1906                     : folder_insert_sorted((min_index + index) / 2, min_index, index,
1907                                            folder, flist, compf)));
1908 }
1909
1910
1911 /*
1912  * folder_insert_index - Insert the given folder struct into the global list
1913  *                 at the given index.
1914  */
1915 void
1916 folder_insert_index(FOLDER_S *folder, int index, FLIST *flist)
1917 {
1918     register FOLDER_S **flp, **iflp;
1919
1920     /* if index is beyond size, place at end of list */
1921     index = MIN(index, flist->used);
1922
1923     /* grow array ? */
1924     if(flist->used + 1 > flist->allocated){
1925         flist->allocated += FCHUNK;
1926         fs_resize((void **)&(flist->folders),
1927                   flist->allocated * sizeof(FOLDER_S *));
1928     }
1929
1930     /* shift array left */
1931     iflp = &((flist->folders)[index]);
1932     for(flp = &((flist->folders)[flist->used]);
1933         flp > iflp; flp--)
1934       flp[0] = flp[-1];
1935
1936     flist->folders[index] = folder;
1937     flist->used          += 1;
1938 }
1939
1940
1941 void
1942 resort_folder_list(FLIST *flist)
1943 {
1944     if(flist && folder_total(flist) > 1 && flist->folders)
1945       qsort(flist->folders, folder_total(flist), sizeof(flist->folders[0]),
1946             (ps_global->fld_sort_rule == FLD_SORT_ALPHA_DIR_FIRST)
1947                 ? compare_folders_dir_alpha_qsort
1948                 : (ps_global->fld_sort_rule == FLD_SORT_ALPHA_DIR_LAST)
1949                      ? compare_folders_alpha_dir_qsort
1950                      : compare_folders_alpha_qsort);
1951 }
1952
1953
1954 /*----------------------------------------------------------------------
1955     Removes a folder at the given index in the given context's
1956     list.
1957
1958 Args: index -- Index in folder list of folder to be removed
1959       flist -- folder list
1960  ----*/
1961 void
1962 folder_delete(int index, FLIST *flist)
1963 {
1964     register int  i;
1965     FOLDER_S     *f;
1966
1967     if(flist->used
1968        && (index < 0 || index >= flist->used))
1969       return;                           /* bogus call! */
1970
1971     if((f = folder_entry(index, flist))->nickname)
1972       fs_give((void **)&(f->nickname));
1973
1974     fs_give((void **) &(flist->folders[index]));
1975     for(i = index; i < flist->used - 1; i++)
1976       flist->folders[i] = flist->folders[i+1];
1977
1978
1979     flist->used -= 1;
1980 }
1981
1982
1983 /*----------------------------------------------------------------------
1984       compare two names for qsort, case independent
1985
1986    Args: pointers to strings to compare
1987
1988  Result: integer result of strcmp of the names.  Uses simple
1989          efficiency hack to speed the string comparisons up a bit.
1990
1991   ----------------------------------------------------------------------*/
1992 int
1993 compare_names(const qsort_t *x, const qsort_t *y)
1994 {
1995     char *a = *(char **)x, *b = *(char **)y;
1996     int r;
1997 #define CMPI(X,Y)       ((X)[0] - (Y)[0])
1998 #define UCMPI(X,Y)      ((isupper((unsigned char)((X)[0]))      \
1999                                 ? (X)[0] - 'A' + 'a' : (X)[0])  \
2000                           - (isupper((unsigned char)((Y)[0]))   \
2001                                 ? (Y)[0] - 'A' + 'a' : (Y)[0]))
2002
2003     /*---- Inbox always sorts to the top ----*/
2004     if(UCMPI(a, ps_global->inbox_name) == 0
2005        && strucmp(a, ps_global->inbox_name) == 0)
2006       return((CMPI(a, b) == 0 && strcmp(a, b) == 0) ? 0 : -1);
2007     else if((UCMPI(b, ps_global->inbox_name)) == 0
2008        && strucmp(b, ps_global->inbox_name) == 0)
2009       return((CMPI(a, b) == 0 && strcmp(a, b) == 0) ? 0 : 1);
2010
2011     /*----- The sent-mail folder, is always next unless... ---*/
2012     else if(F_OFF(F_SORT_DEFAULT_FCC_ALPHA, ps_global)
2013             && CMPI(a, ps_global->VAR_DEFAULT_FCC) == 0
2014             && strcmp(a, ps_global->VAR_DEFAULT_FCC) == 0)
2015       return((CMPI(a, b) == 0 && strcmp(a, b) == 0) ? 0 : -1);
2016     else if(F_OFF(F_SORT_DEFAULT_FCC_ALPHA, ps_global)
2017             && CMPI(b, ps_global->VAR_DEFAULT_FCC) == 0
2018             && strcmp(b, ps_global->VAR_DEFAULT_FCC) == 0)
2019       return((CMPI(a, b) == 0 && strcmp(a, b) == 0) ? 0 : 1);
2020
2021     /*----- The saved-messages folder, is always next unless... ---*/
2022     else if(F_OFF(F_SORT_DEFAULT_SAVE_ALPHA, ps_global)
2023             && CMPI(a, ps_global->VAR_DEFAULT_SAVE_FOLDER) == 0
2024             && strcmp(a, ps_global->VAR_DEFAULT_SAVE_FOLDER) == 0)
2025       return((CMPI(a, b) == 0 && strcmp(a, b) == 0) ? 0 : -1);
2026     else if(F_OFF(F_SORT_DEFAULT_SAVE_ALPHA, ps_global)
2027             && CMPI(b, ps_global->VAR_DEFAULT_SAVE_FOLDER) == 0
2028             && strcmp(b, ps_global->VAR_DEFAULT_SAVE_FOLDER) == 0)
2029       return((CMPI(a, b) == 0 && strcmp(a, b) == 0) ? 0 : 1);
2030
2031     else
2032       return((r = CMPI(a, b)) ? r : strcmp(a, b));
2033 }
2034
2035
2036 /*----------------------------------------------------------------------
2037       compare two folder structs for ordering alphabetically
2038
2039    Args: pointers to folder structs to compare
2040
2041  Result: integer result of dir-bit and strcmp of the folders.
2042   ----------------------------------------------------------------------*/
2043 int
2044 compare_folders_alpha(FOLDER_S *f1, FOLDER_S *f2)
2045 {
2046     int   i;
2047     char *f1name = FLDR_NAME(f1),
2048          *f2name = FLDR_NAME(f2);
2049
2050     return(((i = compare_names(&f1name, &f2name)) != 0)
2051                ? i : (f2->isdir - f1->isdir));
2052 }
2053
2054
2055 int
2056 compare_folders_alpha_qsort(const qsort_t *a1, const qsort_t *a2)
2057 {
2058     FOLDER_S *f1 = *((FOLDER_S **) a1);
2059     FOLDER_S *f2 = *((FOLDER_S **) a2);
2060
2061     return(compare_folders_alpha(f1, f2));
2062 }
2063
2064
2065 /*----------------------------------------------------------------------
2066       compare two folder structs alphabetically with dirs first
2067
2068    Args: pointers to folder structs to compare
2069
2070  Result: integer result of dir-bit and strcmp of the folders.
2071   ----------------------------------------------------------------------*/
2072 int
2073 compare_folders_dir_alpha(FOLDER_S *f1, FOLDER_S *f2)
2074 {
2075     int   i;
2076
2077     if((i = (f2->isdir - f1->isdir)) == 0){
2078         char *f1name = FLDR_NAME(f1),
2079              *f2name = FLDR_NAME(f2);
2080
2081         return(compare_names(&f1name, &f2name));
2082     }
2083
2084     return(i);
2085 }
2086
2087
2088 int
2089 compare_folders_dir_alpha_qsort(const qsort_t *a1, const qsort_t *a2)
2090 {
2091     FOLDER_S *f1 = *((FOLDER_S **) a1);
2092     FOLDER_S *f2 = *((FOLDER_S **) a2);
2093
2094     return(compare_folders_dir_alpha(f1, f2));
2095 }
2096
2097
2098 /*----------------------------------------------------------------------
2099       compare two folder structs alphabetically with dirs last
2100
2101    Args: pointers to folder structs to compare
2102
2103  Result: integer result of dir-bit and strcmp of the folders.
2104   ----------------------------------------------------------------------*/
2105 int
2106 compare_folders_alpha_dir(FOLDER_S *f1, FOLDER_S *f2)
2107 {
2108     int   i;
2109
2110     if((i = (f1->isdir - f2->isdir)) == 0){
2111         char *f1name = FLDR_NAME(f1),
2112              *f2name = FLDR_NAME(f2);
2113
2114         return(compare_names(&f1name, &f2name));
2115     }
2116
2117     return(i);
2118 }
2119
2120
2121 int
2122 compare_folders_alpha_dir_qsort(const qsort_t *a1, const qsort_t *a2)
2123 {
2124     FOLDER_S *f1 = *((FOLDER_S **) a1);
2125     FOLDER_S *f2 = *((FOLDER_S **) a2);
2126
2127     return(compare_folders_alpha_dir(f1, f2));
2128 }
2129
2130
2131 /*
2132  * Find incoming folders and update the unseen counts
2133  * if necessary.
2134  */
2135 void
2136 folder_unseen_count_updater(unsigned long flags)
2137 {
2138   CONTEXT_S *ctxt;
2139   time_t oldest, started_checking;
2140   int ftotal, i, first = -1;
2141   FOLDER_S *f;
2142
2143   /*
2144    * We would only do this if there is an incoming collection, the
2145    * user wants us to monitor, and we're in the folder screen.
2146    */
2147   if(ps_global->in_folder_screen && F_ON(F_ENABLE_INCOMING_CHECKING, ps_global)
2148      && (ctxt=ps_global->context_list) && ctxt->use & CNTXT_INCMNG
2149      && (ftotal = folder_total(FOLDERS(ctxt)))){
2150     /*
2151      * Search through the last_unseen_update times to find
2152      * the one that was updated longest ago, and start with
2153      * that one. We don't want to delay long doing these
2154      * checks so may only check some of them each time we
2155      * get called. An update time equal to 1 means don't check
2156      * this folder at all.
2157      */
2158     for(i = 0; i < ftotal; i++){
2159       f = folder_entry(i, FOLDERS(ctxt));
2160       if(f && LUU_YES(f->last_unseen_update)){
2161         first = i;
2162         oldest = f->last_unseen_update;
2163         break;
2164       }
2165     }
2166
2167     /*
2168      * Now first is the first in the list that
2169      * should ever be checked. Next find the
2170      * one that should be checked next, the one
2171      * that was checked longest ago.
2172      */
2173     if(first >= 0){
2174       for(i = 1; i < ftotal; i++){
2175         f = folder_entry(i, FOLDERS(ctxt));
2176         if(f && LUU_YES(f->last_unseen_update) && f->last_unseen_update < oldest){
2177           first = i;
2178           oldest = f->last_unseen_update;
2179         }
2180       }
2181     }
2182
2183     /* now first is the next one to be checked */
2184
2185     started_checking = time(0);
2186
2187     for(i = first; i < ftotal; i++){
2188       /* update the next one */
2189       f = folder_entry(i, FOLDERS(ctxt));
2190       if(f && LUU_YES(f->last_unseen_update)
2191          && (flags & UFU_FORCE
2192              /* or it's been long enough and we've not been in this function too long */
2193              || (((time(0) - f->last_unseen_update) >= ps_global->inc_check_interval)
2194                  && ((time(0) - started_checking) < MIN(4,ps_global->inc_check_timeout)))))
2195         update_folder_unseen(f, ctxt, flags, NULL);
2196     }
2197
2198     for(i = 0; i < first; i++){
2199       f = folder_entry(i, FOLDERS(ctxt));
2200       if(f && LUU_YES(f->last_unseen_update)
2201          && (flags & UFU_FORCE
2202              || (((time(0) - f->last_unseen_update) >= ps_global->inc_check_interval)
2203                  && ((time(0) - started_checking) < MIN(4,ps_global->inc_check_timeout)))))
2204         update_folder_unseen(f, ctxt, flags, NULL);
2205     }
2206   }
2207 }
2208
2209
2210 /*
2211  * Update the count of unseen in the FOLDER_S struct
2212  * for this folder. This will update if the time
2213  * interval has passed or if the FORCE flag is set.
2214  */
2215 void
2216 update_folder_unseen(FOLDER_S *f, CONTEXT_S *ctxt, unsigned long flags,
2217                      MAILSTREAM *this_is_the_stream)
2218 {
2219     time_t now;
2220     int orig_valid;
2221     int use_imap_interval = 0;
2222     int stream_is_open = 0;
2223     unsigned long orig_unseen, orig_new, orig_tot;
2224     char mailbox_name[MAILTMPLEN];
2225     char *target = NULL;
2226     DRIVER *d;
2227
2228     if(!f || !LUU_YES(f->last_unseen_update))
2229       return;
2230
2231     now = time(0);
2232     context_apply(mailbox_name, ctxt, f->name, MAILTMPLEN);
2233
2234     if(!mailbox_name[0])
2235       return;
2236
2237     if(check_for_move_mbox(mailbox_name, NULL, 0, &target)){
2238         MAILSTREAM *strm;
2239
2240         /*
2241          * If this maildrop is the currently open stream use that.
2242          * I'm not altogether sure that this is a good way to
2243          * check this.
2244          */
2245         if(target
2246            && ((strm=ps_global->mail_stream)
2247                 && strm->snarf.name
2248                 && (!strcmp(target,strm->mailbox)
2249                     || !strcmp(target,strm->original_mailbox)))){
2250             stream_is_open++;
2251         }
2252     }
2253     else{
2254         MAILSTREAM *m = NULL;
2255
2256         stream_is_open = (this_is_the_stream
2257                           || (m=sp_stream_get(mailbox_name, SP_MATCH | SP_RO_OK))
2258                           || ((m=ps_global->mail_stream) && !sp_dead_stream(m)
2259                               && same_stream_and_mailbox(mailbox_name,m))
2260                           || (!IS_REMOTE(mailbox_name)
2261                               && (m=already_open_stream(mailbox_name, AOS_NONE)))) ? 1 : 0;
2262
2263         if(stream_is_open){
2264             if(!this_is_the_stream)
2265               this_is_the_stream = m;
2266         }
2267         else{
2268             /*
2269              * If it's IMAP or local we use a shorter interval.
2270              */
2271             d = mail_valid(NIL, mailbox_name, (char *) NIL);
2272             if((d && !strcmp(d->name, "imap")) || !IS_REMOTE(mailbox_name))
2273               use_imap_interval++;
2274         }
2275     }
2276
2277     /*
2278      * Update if forced, or if it's been a while, or if we have a
2279      * stream open to this mailbox already.
2280      */
2281     if(flags & UFU_FORCE
2282        || stream_is_open
2283        || ((use_imap_interval
2284             && (now - f->last_unseen_update) >= ps_global->inc_check_interval)
2285            || ((now - f->last_unseen_update) >= ps_global->inc_second_check_interval))){
2286         unsigned long tot, uns, new;
2287         unsigned long *totp = NULL, *unsp = NULL, *newp = NULL;
2288
2289         orig_valid  = f->unseen_valid;
2290         orig_unseen = f->unseen;
2291         orig_new    = f->new;
2292         orig_tot    = f->total;
2293
2294         if(F_ON(F_INCOMING_CHECKING_RECENT, ps_global))
2295           newp = &new;
2296         else
2297           unsp = &uns;
2298
2299         if(F_ON(F_INCOMING_CHECKING_TOTAL, ps_global))
2300           totp = &tot;
2301
2302         f->unseen_valid = 0;
2303
2304         dprint((9, "update_folder_unseen(%s)", FLDR_NAME(f)));
2305         if(get_recent_in_folder(mailbox_name, newp, unsp, totp, this_is_the_stream)){
2306             f->last_unseen_update = time(0);
2307             f->unseen_valid = 1;
2308             if(unsp)
2309               f->unseen = uns;
2310
2311             if(newp)
2312               f->new = new;
2313
2314             if(totp)
2315               f->total = tot;
2316
2317             if(!orig_valid){
2318                 dprint((9, "update_folder_unseen(%s): original: %s%s%s%s",
2319                     FLDR_NAME(f),
2320                     F_ON(F_INCOMING_CHECKING_RECENT,ps_global) ? "new=" : "unseen=",
2321                     F_ON(F_INCOMING_CHECKING_RECENT,ps_global) ? comatose(f->new) : comatose(f->unseen),
2322                     F_ON(F_INCOMING_CHECKING_TOTAL,ps_global) ? " tot=" : "",
2323                     F_ON(F_INCOMING_CHECKING_TOTAL,ps_global) ? comatose(f->total) : ""));
2324             }
2325
2326             if(orig_valid
2327                && ((F_ON(F_INCOMING_CHECKING_RECENT, ps_global)
2328                     && orig_new != f->new)
2329                    ||
2330                    (F_OFF(F_INCOMING_CHECKING_RECENT, ps_global)
2331                     && orig_unseen != f->unseen)
2332                    ||
2333                    (F_ON(F_INCOMING_CHECKING_TOTAL, ps_global)
2334                     && orig_tot != f->total))){
2335
2336                 if(ps_global->in_folder_screen)
2337                   ps_global->noticed_change_in_unseen = 1;
2338
2339                 dprint((9, "update_folder_unseen(%s): changed: %s%s%s%s",
2340                     FLDR_NAME(f),
2341                     F_ON(F_INCOMING_CHECKING_RECENT,ps_global) ? "new=" : "unseen=",
2342                     F_ON(F_INCOMING_CHECKING_RECENT,ps_global) ? comatose(f->new) : comatose(f->unseen),
2343                     F_ON(F_INCOMING_CHECKING_TOTAL,ps_global) ? " tot=" : "",
2344                     F_ON(F_INCOMING_CHECKING_TOTAL,ps_global) ? comatose(f->total) : ""));
2345
2346                 if(flags & UFU_ANNOUNCE
2347                    && ((F_ON(F_INCOMING_CHECKING_RECENT, ps_global)
2348                         && orig_new < f->new)
2349                        ||
2350                        (F_OFF(F_INCOMING_CHECKING_RECENT, ps_global)
2351                         && orig_unseen < f->unseen))){
2352                     if(F_ON(F_INCOMING_CHECKING_RECENT, ps_global))
2353                       q_status_message3(SM_ASYNC, 1, 3, "%s: %s %s",
2354                                         FLDR_NAME(f), comatose(f->new),
2355                                         _("new"));
2356                     else
2357                       q_status_message3(SM_ASYNC, 1, 3, "%s: %s %s",
2358                                         FLDR_NAME(f), comatose(f->unseen),
2359                                         _("unseen"));
2360                 }
2361             }
2362         }
2363         else
2364           f->last_unseen_update = LUU_NOMORECHK;        /* no further checking */
2365     }
2366 }
2367
2368
2369 void
2370 update_folder_unseen_by_stream(MAILSTREAM *strm, unsigned long flags)
2371 {
2372   CONTEXT_S *ctxt;
2373   int ftotal, i;
2374   char mailbox_name[MAILTMPLEN], *target;
2375   char *cn, tmp[MAILTMPLEN];
2376   FOLDER_S *f;
2377
2378   /*
2379    * Attempt to figure out which incoming folder this stream
2380    * is open to, if any, so we can update the unseen counters.
2381    */
2382   if(strm
2383      && F_ON(F_ENABLE_INCOMING_CHECKING, ps_global)
2384      && (ctxt=ps_global->context_list) && ctxt->use & CNTXT_INCMNG
2385      && (ftotal = folder_total(FOLDERS(ctxt)))){
2386     for(i = 0; i < ftotal; i++){
2387       f = folder_entry(i, FOLDERS(ctxt));
2388       context_apply(mailbox_name, ctxt, f->name, MAILTMPLEN);
2389
2390       if((check_for_move_mbox(mailbox_name, NULL, 0, &target)
2391                 && strm->snarf.name
2392                 && (!strcmp(target,strm->mailbox)
2393                     || !strcmp(target,strm->original_mailbox)))
2394          || same_stream_and_mailbox(mailbox_name, strm)
2395          || (!IS_REMOTE(mailbox_name) && (cn=mailboxfile(tmp,mailbox_name)) && (*cn) && (!strcmp(cn, strm->mailbox) || !strcmp(cn, strm->original_mailbox)))){
2396         /* if we failed earlier on this one, give it another go */
2397         if(f->last_unseen_update == LUU_NOMORECHK)
2398           init_incoming_unseen_data(ps_global, f);
2399
2400         update_folder_unseen(f, ctxt, flags, strm);
2401         return;
2402       }
2403     }
2404   }
2405 }
2406
2407
2408 /*
2409  * Find the number of new, unseen, and the total number of
2410  * messages in mailbox_name.
2411  * If the corresponding arg is NULL it will skip the work
2412  * necessary for that flag.
2413  *
2414  * Returns 1 if successful, 0 if not.
2415  */
2416 int
2417 get_recent_in_folder(char *mailbox_name, long unsigned int *new,
2418                      long unsigned int *unseen, long unsigned int *total,
2419                      MAILSTREAM *this_is_the_stream)
2420 {
2421     MAILSTREAM   *strm = NIL;
2422     unsigned long tot, nw, uns;
2423     int           gotit = 0;
2424     int           maildrop = 0;
2425     char         *target = NULL;
2426     MSGNO_S      *msgmap;
2427     long          excluded, flags;
2428     extern MAILSTATUS mm_status_result;
2429
2430     dprint((9, "get_recent_in_folder(%s)", mailbox_name ? mailbox_name : "?"));
2431
2432     if(check_for_move_mbox(mailbox_name, NULL, 0, &target)){
2433
2434         maildrop++;
2435
2436         /*
2437          * If this maildrop is the currently open stream use that.
2438          */
2439         if(target
2440            && ((strm=ps_global->mail_stream)
2441                 && strm->snarf.name
2442                 && (!strcmp(target,strm->mailbox)
2443                     || !strcmp(target,strm->original_mailbox)))){
2444             gotit++;
2445             msgmap = sp_msgmap(strm);
2446             excluded = any_lflagged(msgmap, MN_EXLD);
2447
2448             tot = strm->nmsgs - excluded;
2449             if(tot){
2450               if(new){
2451                   if(sp_recent_since_visited(strm) == 0)
2452                     nw = 0;
2453                   else
2454                     nw = count_flagged(strm, F_RECENT | F_UNSEEN | F_UNDEL);
2455               }
2456
2457               if(unseen)
2458                 uns = count_flagged(strm, F_UNSEEN | F_UNDEL);
2459             }
2460             else{
2461               nw = 0;
2462               uns = 0;
2463             }
2464         }
2465         /* else fall through to just open it case */
2466     }
2467
2468     /* do we already have it selected? */
2469     if(!gotit
2470        && ((strm = this_is_the_stream)
2471            || (strm = sp_stream_get(mailbox_name, SP_MATCH | SP_RO_OK))
2472            || (!IS_REMOTE(mailbox_name)
2473                && (strm = already_open_stream(mailbox_name, AOS_NONE))))){
2474         gotit++;
2475
2476         /*
2477          * Unfortunately, we have to worry about excluded
2478          * messages. The user doesn't want to have
2479          * excluded messages count in the totals, especially
2480          * recent excluded messages.
2481          */
2482
2483         msgmap = sp_msgmap(strm);
2484         excluded = any_lflagged(msgmap, MN_EXLD);
2485
2486         tot = strm->nmsgs - excluded;
2487         if(tot){
2488           if(new){
2489               if(sp_recent_since_visited(strm) == 0)
2490                 nw = 0;
2491               else
2492                 nw = count_flagged(strm, F_RECENT | F_UNSEEN | F_UNDEL);
2493           }
2494
2495           if(unseen)
2496             uns = count_flagged(strm, F_UNSEEN | F_UNDEL);
2497         }
2498         else{
2499           nw = 0;
2500           uns = 0;
2501         }
2502     }
2503     /*
2504      * No, but how about another stream to same server which
2505      * could be used for a STATUS command?
2506      */
2507     else if(!gotit && (strm = sp_stream_get(mailbox_name, SP_SAME))
2508             && modern_imap_stream(strm)){
2509
2510         flags = 0L;
2511         if(total)
2512           flags |= SA_MESSAGES;
2513
2514         if(new)
2515           flags |= SA_RECENT;
2516
2517         if(unseen)
2518           flags |= SA_UNSEEN;
2519
2520         mm_status_result.flags = 0L;
2521
2522         pine_mail_status(strm, mailbox_name, flags);
2523         if(total){
2524             if(mm_status_result.flags & SA_MESSAGES){
2525                 tot = mm_status_result.messages;
2526                 gotit++;
2527             }
2528         }
2529
2530         if(!(total && !gotit)){
2531             if(new){
2532                 if(mm_status_result.flags & SA_RECENT){
2533                     nw = mm_status_result.recent;
2534                     gotit++;
2535                 }
2536                 else
2537                   gotit = 0;
2538             }
2539         }
2540
2541         if(!((total || new) && !gotit)){
2542             if(unseen){
2543                 if(mm_status_result.flags & SA_UNSEEN){
2544                     uns = mm_status_result.unseen;
2545                     gotit++;
2546                 }
2547                 else
2548                   gotit = 0;
2549             }
2550         }
2551     }
2552
2553     /* Let's just Select it. */
2554     if(!gotit){
2555         long saved_timeout;
2556         long openflags;
2557
2558         /*
2559          * Traditional unix folders don't notice new mail if
2560          * they are opened readonly. So maildrops with unix folder
2561          * targets will snarf to the file but the stream that is
2562          * opened won't see the new mail. So make all maildrop
2563          * opens non-readonly here.
2564          */
2565         openflags = SP_USEPOOL | SP_TEMPUSE | (maildrop ? 0 : OP_READONLY);
2566
2567         saved_timeout = (long) mail_parameters(NULL, GET_OPENTIMEOUT, NULL);
2568         mail_parameters(NULL, SET_OPENTIMEOUT, (void *) (long) ps_global->inc_check_timeout);
2569         strm = pine_mail_open(NULL, mailbox_name, openflags, NULL);
2570         mail_parameters(NULL, SET_OPENTIMEOUT, (void *) saved_timeout);
2571
2572         if(strm){
2573             gotit++;
2574             msgmap = sp_msgmap(strm);
2575             excluded = any_lflagged(msgmap, MN_EXLD);
2576
2577             tot = strm->nmsgs - excluded;
2578             if(tot){
2579               if(new){
2580                   if(sp_recent_since_visited(strm) == 0)
2581                     nw = 0;
2582                   else
2583                     nw = count_flagged(strm, F_RECENT | F_UNSEEN | F_UNDEL);
2584               }
2585
2586               if(unseen)
2587                 uns = count_flagged(strm, F_UNSEEN | F_UNDEL);
2588             }
2589             else{
2590               nw = 0;
2591               uns = 0;
2592             }
2593
2594             pine_mail_close(strm);
2595         }
2596     }
2597
2598     if(gotit){
2599         if(new)
2600           *new = nw;
2601
2602         if(unseen)
2603           *unseen = uns;
2604
2605         if(total)
2606           *total = tot;
2607     }
2608
2609     return(gotit);
2610 }
2611
2612
2613 void
2614 clear_incoming_valid_bits(void)
2615 {
2616     CONTEXT_S *ctxt;
2617     int ftotal, i;
2618     FOLDER_S *f;
2619
2620     if(F_ON(F_ENABLE_INCOMING_CHECKING, ps_global)
2621        && (ctxt=ps_global->context_list) && ctxt->use & CNTXT_INCMNG
2622        && (ftotal = folder_total(FOLDERS(ctxt))))
2623       for(i = 0; i < ftotal; i++){
2624           f = folder_entry(i, FOLDERS(ctxt));
2625           init_incoming_unseen_data(ps_global, f);
2626       }
2627 }
2628
2629
2630 int
2631 selected_folders(CONTEXT_S *context)
2632 {
2633     int       i, n, total;
2634
2635     n = folder_total(FOLDERS(context));
2636     for(total = i = 0; i < n; i++)
2637       if(folder_entry(i, FOLDERS(context))->selected)
2638         total++;
2639
2640     return(total);
2641 }
2642
2643
2644 SELECTED_S *
2645 new_selected(void)
2646 {
2647   SELECTED_S *selp;
2648
2649   selp = (SELECTED_S *)fs_get(sizeof(SELECTED_S));
2650   selp->sub = NULL;
2651   selp->reference = NULL;
2652   selp->folders = NULL;
2653   selp->zoomed = 0;
2654
2655   return selp;
2656 }
2657
2658
2659 /*
2660  *  Free the current selected struct and all of the
2661  *  following structs in the list
2662  */
2663 void
2664 free_selected(SELECTED_S **selp)
2665 {
2666     if(!selp || !(*selp))
2667       return;
2668     if((*selp)->sub)
2669       free_selected(&((*selp)->sub));
2670
2671     free_strlist(&(*selp)->folders);
2672     if((*selp)->reference)
2673       fs_give((void **) &(*selp)->reference);
2674
2675     fs_give((void **) selp);
2676 }
2677
2678
2679 void
2680 folder_select_preserve(CONTEXT_S *context)
2681 {
2682     if(context
2683        && !(context->use & CNTXT_PARTFIND)){
2684         FOLDER_S   *fp;
2685         STRLIST_S **slpp;
2686         SELECTED_S *selp = &context->selected;
2687         int         i, folder_n;
2688
2689         if(!context->dir->ref){
2690           if(!context->selected.folders)
2691             slpp     = &context->selected.folders;
2692           else
2693             return;
2694         }
2695         else{
2696           if(!selected_folders(context))
2697             return;
2698           else{
2699             while(selp->sub){
2700               selp = selp->sub;
2701               if(!strcmp(selp->reference, context->dir->ref))
2702                 return;
2703             }
2704             selp->sub = new_selected();
2705             selp = selp->sub;
2706             slpp = &(selp->folders);
2707           }
2708         }
2709         folder_n = folder_total(FOLDERS(context));
2710
2711         for(i = 0; i < folder_n; i++)
2712           if((fp = folder_entry(i, FOLDERS(context)))->selected){
2713               *slpp = new_strlist(fp->name);
2714               slpp = &(*slpp)->next;
2715           }
2716
2717         /* Only remember "ref" if any folders were selected */
2718         if(selp->folders && context->dir->ref)
2719           selp->reference = cpystr(context->dir->ref);
2720
2721         selp->zoomed = (context->use & CNTXT_ZOOM) != 0;
2722     }
2723 }
2724
2725
2726 int
2727 folder_select_restore(CONTEXT_S *context)
2728 {
2729     int rv = 0;
2730
2731     if(context
2732        && !(context->use & CNTXT_PARTFIND)){
2733         STRLIST_S *slp;
2734         SELECTED_S *selp, *pselp = NULL;
2735         int        i, found = 0;
2736
2737         selp = &(context->selected);
2738
2739         if(context->dir->ref){
2740           pselp = selp;
2741           selp = selp->sub;
2742           while(selp && strcmp(selp->reference, context->dir->ref)){
2743             pselp = selp;
2744             selp = selp->sub;
2745           }
2746           if (selp)
2747             found = 1;
2748         }
2749         else
2750           found = selp->folders != 0;
2751         if(found){
2752           for(slp = selp->folders; slp; slp = slp->next)
2753             if(slp->name
2754                && (i = folder_index(slp->name, context, FI_FOLDER)) >= 0){
2755                 folder_entry(i, FOLDERS(context))->selected = 1;
2756                 rv++;
2757             }
2758
2759           /* Used, always clean them up */
2760           free_strlist(&selp->folders);
2761           if(selp->reference)
2762             fs_give((void **) &selp->reference);
2763
2764           if(selp->zoomed){
2765             context->use |= CNTXT_ZOOM;
2766             selp->zoomed = 0;
2767           }
2768           if(!(selp == &context->selected)){
2769             if(pselp){
2770               pselp->sub = selp->sub;
2771               fs_give((void **) &selp);
2772             }
2773           }
2774         }
2775     }
2776
2777     return(rv);
2778 }
2779