src/exim_monitor/em_queue.c

   1 /*************************************************
   2 *                 Exim Monitor                   *
   3 *************************************************/
   4
   5 /* Copyright (c) University of Cambridge 1995 - 2009 */
   6 /* See the file NOTICE for conditions of use and distribution. */
   7
   8
   9 #include "em_hdr.h"
  10
  11
  12 /* This module contains functions to do with scanning exim's
  13 queue and displaying the data therefrom. */
  14
  15
  16 /* If we are anonymizing for screen shots, define a function to anonymize
  17 addresses. Otherwise, define a macro that does nothing. */
  18
  19 #ifdef ANONYMIZE
  20 static uschar *anon(uschar *s)
  21 {
  22 static uschar anon_result[256];
  23 uschar *ss = anon_result;
  24 for (; *s != 0; s++) *ss++ = (*s == '@' || *s == '.')? *s : 'x';
  25 *ss = 0;
  26 return anon_result;
  27 }
  28 #else
  29 #define anon(x) x
  30 #endif
  31
  32
  33 /*************************************************
  34 *                 Static variables               *
  35 *************************************************/
  36
  37 static int queue_total = 0;   /* number of items in queue */
  38
  39 /* Table for turning base-62 numbers into binary */
  40
  41 static uschar tab62[] =
  42           {0,1,2,3,4,5,6,7,8,9,0,0,0,0,0,0,     /* 0-9 */
  43            0,10,11,12,13,14,15,16,17,18,19,20,  /* A-K */
  44           21,22,23,24,25,26,27,28,29,30,31,32,  /* L-W */
  45           33,34,35, 0, 0, 0, 0, 0,              /* X-Z */
  46            0,36,37,38,39,40,41,42,43,44,45,46,  /* a-k */
  47           47,48,49,50,51,52,53,54,55,56,57,58,  /* l-w */
  48           59,60,61};                            /* x-z */
  49
  50 /* Index for quickly finding things in the ordered queue. */
  51
  52 static queue_item *queue_index[queue_index_size];
  53
  54
  55
  56 /*************************************************
  57 *         Find/Create/Delete a destination       *
  58 *************************************************/
  59
  60 /* If the action is dest_noop, then just return item or NULL;
  61 if it is dest_add, then add if not present, and return item;
  62 if it is dest_remove, remove if present and return NULL. The
  63 address is lowercased to start with, unless it begins with
  64 "*", which it does for error messages. */
  65
  66 dest_item *
  67 find_dest(queue_item *q, uschar *name, int action, BOOL caseless)
  68 {
  69 dest_item *dd;
  70 dest_item **d = &(q->destinations);
  71
  72 while (*d != NULL)
  73   {
  74   if ((caseless? strcmpic(name,(*d)->address) : Ustrcmp(name,(*d)->address))
  75         == 0)
  76     {
  77     dest_item *ddd;
  78
  79     if (action != dest_remove) return *d;
  80     dd = *d;
  81     *d = dd->next;
  82     store_free(dd);
  83
  84     /* Unset any parent pointers that were to this address */
  85
  86     for (ddd = q->destinations; ddd != NULL; ddd = ddd->next)
  87       {
  88       if (ddd->parent == dd) ddd->parent = NULL;
  89       }
  90
  91     return NULL;
  92     }
  93   d = &((*d)->next);
  94   }
  95
  96 if (action != dest_add) return NULL;
  97
  98 dd = (dest_item *)store_malloc(sizeof(dest_item) + Ustrlen(name));
  99 Ustrcpy(dd->address, name);
 100 dd->next = NULL;
 101 dd->parent = NULL;
 102 *d = dd;
 103 return dd;
 104 }
 105
 106
 107
 108 /*************************************************
 109 *            Clean up a dead queue item          *
 110 *************************************************/
 111
 112 static void
 113 clean_up(queue_item *p)
 114 {
 115 dest_item *dd = p->destinations;
 116 while (dd != NULL)
 117   {
 118   dest_item *next = dd->next;
 119   store_free(dd);
 120   dd = next;
 121   }
 122 if (p->sender != NULL) store_free(p->sender);
 123 store_free(p);
 124 }
 125
 126
 127 /*************************************************
 128 *         Set up an ACL variable                 *
 129 *************************************************/
 130
 131 /* The spool_read_header() function calls acl_var_create() when it reads in an
 132 ACL variable. We know that in this case, the variable will be new, not re-used,
 133 so this is a cut-down version, to save including the whole acl.c module (which
 134 would need conditional compilation to cut most of it out). */
 135
 136 tree_node *
 137 acl_var_create(uschar *name)
 138 {
 139 tree_node *node, **root;
 140 root = (name[0] == 'c')? &acl_var_c : &acl_var_m;
 141 node = store_get(sizeof(tree_node) + Ustrlen(name));
 142 Ustrcpy(node->name, name);
 143 node->data.ptr = NULL;
 144 (void)tree_insertnode(root, node);
 145 return node;
 146 }
 147
 148
 149
 150 /*************************************************
 151 *             Set up new queue item              *
 152 *************************************************/
 153
 154 static queue_item *
 155 set_up(uschar *name, int dir_char)
 156 {
 157 int i, rc, save_errno;
 158 struct stat statdata;
 159 void *reset_point;
 160 uschar *p;
 161 queue_item *q = (queue_item *)store_malloc(sizeof(queue_item));
 162 uschar buffer[256];
 163
 164 /* Initialize the block */
 165
 166 q->next = q->prev = NULL;
 167 q->destinations = NULL;
 168 Ustrncpy(q->name, name, sizeof(q->name));
 169 q->seen = TRUE;
 170 q->frozen = FALSE;
 171 q->dir_char = dir_char;
 172 q->sender = NULL;
 173 q->size = 0;
 174
 175 /* Read the header file from the spool; if there is a failure it might mean
 176 inaccessibility as a result of protections. A successful read will have caused
 177 sender_address to get set and the recipients fields to be initialized. If
 178 there's a format error in the headers, we can still display info from the
 179 envelope.
 180
 181 Before reading the header remember the position in the dynamic store so that
 182 we can recover the store into which the header is read. All data read by
 183 spool_read_header that is to be preserved is copied into malloc store. */
 184
 185 reset_point = store_get(0);
 186 message_size = 0;
 187 message_subdir[0] = dir_char;
 188 sprintf(CS buffer, "%s-H", name);
 189 rc =  spool_read_header(buffer, FALSE, TRUE);
 190 save_errno = errno;
 191
 192 /* If we failed to read the envelope, compute the input time by
 193 interpreting the id as a base-62 number. */
 194
 195 if (rc != spool_read_OK && rc != spool_read_hdrerror)
 196   {
 197   int t = 0;
 198   for (i = 0; i < 6; i++) t = t * 62 + tab62[name[i] - '0'];
 199   q->update_time = q->input_time = t;
 200   }
 201
 202 /* Envelope read; get input time and remove qualify_domain from sender address,
 203 if it's there. */
 204
 205 else
 206   {
 207   q->update_time = q->input_time = received_time;
 208   if ((p = strstric(sender_address+1, qualify_domain, FALSE)) != NULL &&
 209     *(--p) == '@') *p = 0;
 210   }
 211
 212 /* If we didn't read the whole header successfully, generate an error
 213 message. If the envelope was read, this appears as a first recipient;
 214 otherwise it sets set up in the sender field. */
 215
 216 if (rc != spool_read_OK)
 217   {
 218   uschar *msg;
 219
 220   if (save_errno == ERRNO_SPOOLFORMAT)
 221     {
 222     struct stat statbuf;
 223     sprintf(CS big_buffer, "%s/input/%s", spool_directory, buffer);
 224     if (Ustat(big_buffer, &statbuf) == 0)
 225       msg = string_sprintf("*** Format error in spool file: size = %d ***",
 226         statbuf.st_size);
 227     else msg = string_sprintf("*** Format error in spool file ***");
 228     }
 229   else msg = string_sprintf("*** Cannot read spool file ***");
 230
 231   if (rc == spool_read_hdrerror)
 232     {
 233     (void)find_dest(q, msg, dest_add, FALSE);
 234     }
 235   else
 236     {
 237     deliver_freeze = FALSE;
 238     sender_address = msg;
 239     recipients_count = 0;
 240     }
 241   }
 242
 243 /* Now set up the remaining data. */
 244
 245 q->frozen = deliver_freeze;
 246
 247 if (sender_set_untrusted)
 248   {
 249   if (sender_address[0] == 0)
 250     {
 251     q->sender = store_malloc(Ustrlen(originator_login) + 6);
 252     sprintf(CS q->sender, "<> (%s)", originator_login);
 253     }
 254   else
 255     {
 256     q->sender = store_malloc(Ustrlen(sender_address) +
 257       Ustrlen(originator_login) + 4);
 258     sprintf(CS q->sender, "%s (%s)", sender_address, originator_login);
 259     }
 260   }
 261 else
 262   {
 263   q->sender = store_malloc(Ustrlen(sender_address) + 1);
 264   Ustrcpy(q->sender, sender_address);
 265   }
 266
 267 sender_address = NULL;
 268
 269 snprintf(CS buffer, sizeof(buffer), "%s/input/%s/%s/%s-D",
 270   spool_directory, queue_name, message_subdir, name);
 271 if (Ustat(buffer, &statdata) == 0)
 272   q->size = message_size + statdata.st_size - SPOOL_DATA_START_OFFSET + 1;
 273
 274 /* Scan and process the recipients list, skipping any that have already
 275 been delivered, and removing visible names. */
 276
 277 if (recipients_list != NULL)
 278   for (i = 0; i < recipients_count; i++)
 279     {
 280     uschar *r = recipients_list[i].address;
 281     if (tree_search(tree_nonrecipients, r) == NULL)
 282       {
 283       if ((p = strstric(r+1, qualify_domain, FALSE)) != NULL &&
 284         *(--p) == '@') *p = 0;
 285       (void)find_dest(q, r, dest_add, FALSE);
 286       }
 287     }
 288
 289 /* Recover the dynamic store used by spool_read_header(). */
 290
 291 store_reset(reset_point);
 292 return q;
 293 }
 294
 295
 296
 297 /*************************************************
 298 *             Find/Create a queue item           *
 299 *************************************************/
 300
 301 /* The queue is kept as a doubly-linked list, sorted by name. However,
 302 to speed up searches, an index into the list is used. This is maintained
 303 by the scan_spool_input function when it goes down the list throwing
 304 out entries that are no longer needed. When the action is "add" and
 305 we don't need to add, mark the found item as seen. */
 306
 307
 308 #ifdef never
 309 static void debug_queue(void)
 310 {
 311 int i;
 312 int count = 0;
 313 queue_item *p;
 314 printf("\nqueue_total=%d\n", queue_total);
 315
 316 for (i = 0; i < queue_index_size; i++)
 317   printf("index %d = %d %s\n", i, (int)(queue_index[i]),
 318     (queue_index[i])->name);
 319
 320 printf("Queue is:\n");
 321 p = queue_index[0];
 322 while (p != NULL)
 323   {
 324   count++;
 325   for (i = 0; i < queue_index_size; i++)
 326     {
 327     if (queue_index[i] == p) printf("count=%d index=%d\n", count, (int)p);
 328     }
 329   printf("%d %d %d %s\n", (int)p, (int)p->next, (int)p->prev, p->name);
 330   p = p->next;
 331   }
 332 }
 333 #endif
 334
 335
 336
 337 queue_item *
 338 find_queue(uschar *name, int action, int dir_char)
 339 {
 340 int first = 0;
 341 int last = queue_index_size - 1;
 342 int middle = (first + last)/2;
 343 queue_item *p, *q, *qq;
 344
 345 /* Handle the empty queue as a special case. */
 346
 347 if (queue_total == 0)
 348   {
 349   if (action != queue_add) return NULL;
 350   if ((qq = set_up(name, dir_char)) != NULL)
 351     {
 352     int i;
 353     for (i = 0; i < queue_index_size; i++) queue_index[i] = qq;
 354     queue_total++;
 355     return qq;
 356     }
 357   return NULL;
 358   }
 359
 360 /* Also handle insertion at the start or end of the queue
 361 as special cases. */
 362
 363 if (Ustrcmp(name, (queue_index[0])->name) < 0)
 364   {
 365   if (action != queue_add) return NULL;
 366   if ((qq = set_up(name, dir_char)) != NULL)
 367     {
 368     qq->next = queue_index[0];
 369     (queue_index[0])->prev = qq;
 370     queue_index[0] = qq;
 371     queue_total++;
 372     return qq;
 373     }
 374   return NULL;
 375   }
 376
 377 if (Ustrcmp(name, (queue_index[queue_index_size-1])->name) > 0)
 378   {
 379   if (action != queue_add) return NULL;
 380   if ((qq = set_up(name, dir_char)) != NULL)
 381     {
 382     qq->prev = queue_index[queue_index_size-1];
 383     (queue_index[queue_index_size-1])->next = qq;
 384     queue_index[queue_index_size-1] = qq;
 385     queue_total++;
 386     return qq;
 387     }
 388   return NULL;
 389   }
 390
 391 /* Use binary chopping on the index to get a range of the queue to search
 392 when the name is somewhere in the middle, if present. */
 393
 394 while (middle > first)
 395   {
 396   if (Ustrcmp(name, (queue_index[middle])->name) >= 0) first = middle;
 397     else last = middle;
 398   middle = (first + last)/2;
 399   }
 400
 401 /* Now search down the part of the queue in which the item must
 402 lie if it exists. Both end points are inclusive - though in fact
 403 the bottom one can only be = if it is the original bottom. */
 404
 405 p = queue_index[first];
 406 q = queue_index[last];
 407
 408 for (;;)
 409   {
 410   int c = Ustrcmp(name, p->name);
 411
 412   /* Already on queue; mark seen if required. */
 413
 414   if (c == 0)
 415     {
 416     if (action == queue_add) p->seen = TRUE;
 417     return p;
 418     }
 419
 420   /* Not on the queue; add an entry if required. Note that set-up might
 421   fail (the file might vanish under our feet). Note also that we know
 422   there is always a previous item to p because the end points are
 423   inclusive. */
 424
 425   else if (c < 0)
 426     {
 427     if (action == queue_add)
 428       {
 429       if ((qq = set_up(name, dir_char)) != NULL)
 430         {
 431         qq->next = p;
 432         qq->prev = p->prev;
 433         p->prev->next = qq;
 434         p->prev = qq;
 435         queue_total++;
 436         return qq;
 437         }
 438       }
 439     return NULL;
 440     }
 441
 442   /* Control should not reach here if p == q, because the name
 443   is supposed to be <= the name of the bottom item. */
 444
 445   if (p == q) return NULL;
 446
 447   /* Else might be further down the queue; continue */
 448
 449   p = p->next;
 450   }
 451
 452 /* Control should never reach here. */
 453 }
 454
 455
 456
 457 /*************************************************
 458 *        Scan the exim spool directory           *
 459 *************************************************/
 460
 461 /* If we discover that there are subdirectories, set a flag so that the menu
 462 code knows to look for them. We count the entries to set the value for the
 463 queue stripchart, and set up data for the queue display window if the "full"
 464 option is given. */
 465
 466 void scan_spool_input(int full)
 467 {
 468 int i;
 469 int subptr;
 470 int subdir_max = 1;
 471 int count = 0;
 472 int indexptr = 1;
 473 queue_item *p;
 474 struct dirent *ent;
 475 DIR *dd;
 476 uschar input_dir[256];
 477 uschar subdirs[64];
 478
 479 subdirs[0] = 0;
 480 stripchart_total[0] = 0;
 481
 482 sprintf(CS input_dir, "%s/input", spool_directory);
 483 subptr = Ustrlen(input_dir);
 484 input_dir[subptr+2] = 0;               /* terminator for lengthened name */
 485
 486 /* Loop for each spool file on the queue - searching any subdirectories that
 487 may exist. When initializing eximon, every file will have to be read. To show
 488 there is progress, output a dot for each one to the standard output. */
 489
 490 for (i = 0; i < subdir_max; i++)
 491   {
 492   int subdirchar = subdirs[i];      /* 0 for main directory */
 493   if (subdirchar != 0)
 494     {
 495     input_dir[subptr] = '/';
 496     input_dir[subptr+1] = subdirchar;
 497     }
 498
 499   dd = opendir(CS input_dir);
 500   if (dd == NULL) continue;
 501
 502   while ((ent = readdir(dd)) != NULL)
 503     {
 504     uschar *name = US ent->d_name;
 505     int len = Ustrlen(name);
 506
 507     /* If we find a single alphameric sub-directory on the first
 508     pass, add it to the list for subsequent scans, and remember that
 509     we are dealing with a split directory. */
 510
 511     if (i == 0 && len == 1 && isalnum(*name))
 512       {
 513       subdirs[subdir_max++] = *name;
 514       spool_is_split = TRUE;
 515       continue;
 516       }
 517
 518     /* Otherwise, if it is a header spool file, add it to the list */
 519
 520     if (len == SPOOL_NAME_LENGTH &&
 521         name[SPOOL_NAME_LENGTH - 2] == '-' &&
 522         name[SPOOL_NAME_LENGTH - 1] == 'H')
 523       {
 524       uschar basename[SPOOL_NAME_LENGTH + 1];
 525       stripchart_total[0]++;
 526       if (!eximon_initialized) { printf("."); fflush(stdout); }
 527       Ustrcpy(basename, name);
 528       basename[SPOOL_NAME_LENGTH - 2] = 0;
 529       if (full) find_queue(basename, queue_add, subdirchar);
 530       }
 531     }
 532   closedir(dd);
 533   }
 534
 535 /* If simply counting the number, we are done; same if there are no
 536 items in the in-store queue. */
 537
 538 if (!full || queue_total == 0) return;
 539
 540 /* Now scan the queue and remove any items that were not in the directory. At
 541 the same time, set up the index pointers into the queue. Because we are
 542 removing items, the total that we are comparing against isn't actually correct,
 543 but in a long queue it won't make much difference, and in a short queue it
 544 doesn't matter anyway!*/
 545
 546 p = queue_index[0];
 547 while (p != NULL)
 548   {
 549   if (!p->seen)
 550     {
 551     queue_item *next = p->next;
 552     if (p->prev == NULL) queue_index[0] = next;
 553       else p->prev->next = next;
 554     if (next == NULL)
 555       {
 556       int i;
 557       queue_item *q = queue_index[queue_index_size-1];
 558       for (i = queue_index_size - 1; i >= 0; i--)
 559         if (queue_index[i] == q) queue_index[i] = p->prev;
 560       }
 561     else next->prev = p->prev;
 562     clean_up(p);
 563     queue_total--;
 564     p = next;
 565     }
 566   else
 567     {
 568     if (++count > (queue_total * indexptr)/(queue_index_size-1))
 569       {
 570       queue_index[indexptr++] = p;
 571       }
 572     p->seen = FALSE;  /* for next time */
 573     p = p->next;
 574     }
 575   }
 576
 577 /* If a lot of messages have been removed at the bottom, we may not
 578 have got the index all filled in yet. Make sure all the pointers
 579 are legal. */
 580
 581 while (indexptr < queue_index_size - 1)
 582   {
 583   queue_index[indexptr++] = queue_index[queue_index_size-1];
 584   }
 585 }
 586
 587
 588
 589
 590 /*************************************************
 591 *    Update the recipients list for a message    *
 592 *************************************************/
 593
 594 /* We read the spool file only if its update time differs from last time,
 595 or if there is a journal file in existence. */
 596
 597 /* First, a local subroutine to scan the non-recipients tree and
 598 remove any of them from the address list */
 599
 600 static void
 601 scan_tree(queue_item *p, tree_node *tn)
 602 {
 603 if (tn != NULL)
 604   {
 605   if (tn->left != NULL) scan_tree(p, tn->left);
 606   if (tn->right != NULL) scan_tree(p, tn->right);
 607   (void)find_dest(p, tn->name, dest_remove, FALSE);
 608   }
 609 }
 610
 611 /* The main function */
 612
 613 static void update_recipients(queue_item *p)
 614 {
 615 int i;
 616 FILE *jread;
 617 void *reset_point;
 618 struct stat statdata;
 619 uschar buffer[1024];
 620
 621 message_subdir[0] = p->dir_char;
 622
 623 snprintf(CS buffer, sizeof(buffer), "%s/input/%s/%s/%s-J",
 624   spool_directory, queue_name, message_subdir, p->name);
 625
 626 if (!(jread = fopen(CS buffer, "r")))
 627   {
 628   snprintf(CS buffer, sizeof(buffer), "%s/input/%s/%s/%s-H",
 629     spool_directory, queue_name, message_subdir, p->name);
 630   if (Ustat(buffer, &statdata) < 0 || p->update_time == statdata.st_mtime)
 631     return;
 632   }
 633
 634 /* Get the contents of the header file; if any problem, just give up.
 635 Arrange to recover the dynamic store afterwards. */
 636
 637 reset_point = store_get(0);
 638 sprintf(CS buffer, "%s-H", p->name);
 639 if (spool_read_header(buffer, FALSE, TRUE) != spool_read_OK)
 640   {
 641   store_reset(reset_point);
 642   if (jread != NULL) fclose(jread);
 643   return;
 644   }
 645
 646 /* If there's a journal file, add its contents to the non-recipients tree */
 647
 648 if (jread != NULL)
 649   {
 650   while (Ufgets(big_buffer, big_buffer_size, jread) != NULL)
 651     {
 652     int n = Ustrlen(big_buffer);
 653     big_buffer[n-1] = 0;
 654     tree_add_nonrecipient(big_buffer);
 655     }
 656   fclose(jread);
 657   }
 658
 659 /* Scan and process the recipients list, removing any that have already
 660 been delivered, and removing visible names. In the nonrecipients tree,
 661 domains are lower cased. */
 662
 663 if (recipients_list)
 664   for (i = 0; i < recipients_count; i++)
 665     {
 666     uschar * pp;
 667     uschar * r = recipients_list[i].address;
 668     tree_node * node;
 669
 670     if (!(node = tree_search(tree_nonrecipients, r)))
 671       node = tree_search(tree_nonrecipients, string_copylc(r));
 672
 673     if ((pp = strstric(r+1, qualify_domain, FALSE)) && *(--pp) == '@')
 674        *pp = 0;
 675     if (!node)
 676       (void)find_dest(p, r, dest_add, FALSE);
 677     else
 678       (void)find_dest(p, r, dest_remove, FALSE);
 679     }
 680
 681 /* We also need to scan the tree of non-recipients, which might
 682 contain child addresses that are not in the recipients list, but
 683 which may have got onto the address list as a result of eximon
 684 noticing an == line in the log. Then remember the update time,
 685 recover the dynamic store, and we are done. */
 686
 687 scan_tree(p, tree_nonrecipients);
 688 p->update_time = statdata.st_mtime;
 689 store_reset(reset_point);
 690 }
 691
 692
 693
 694 /*************************************************
 695 *              Display queue data                *
 696 *************************************************/
 697
 698 /* The present implementation simple re-writes the entire information each
 699 time. Take some care to keep the scrolled position as it previously was, but,
 700 if it was at the bottom, keep it at the bottom. Take note of any hide list, and
 701 time out the entries as appropriate. */
 702
 703 void
 704 queue_display(void)
 705 {
 706 int now = (int)time(NULL);
 707 queue_item *p = queue_index[0];
 708
 709 if (menu_is_up) return;            /* Avoid nasty interactions */
 710
 711 text_empty(queue_widget);
 712
 713 while (p != NULL)
 714   {
 715   int count = 1;
 716   dest_item *dd, *ddd;
 717   uschar u = 'm';
 718   int t = (now - p->input_time)/60;  /* minutes on queue */
 719
 720   if (t > 90)
 721     {
 722     u = 'h';
 723     t = (t + 30)/60;
 724     if (t > 72)
 725       {
 726       u = 'd';
 727       t = (t + 12)/24;
 728       if (t > 99)                    /* someone had > 99 days */
 729         {
 730         u = 'w';
 731         t = (t + 3)/7;
 732         if (t > 99)                  /* so, just in case */
 733           {
 734           u = 'y';
 735           t = (t + 26)/52;
 736           }
 737         }
 738       }
 739     }
 740
 741   update_recipients(p);                   /* update destinations */
 742
 743   /* Can't set this earlier, as header data may change things. */
 744
 745   dd = p->destinations;
 746
 747   /* Check to see if this message is on the hide list; if any hide
 748   item has timed out, remove it from the list. Hide if all destinations
 749   are on the hide list. */
 750
 751   for (ddd = dd; ddd != NULL; ddd = ddd->next)
 752     {
 753     skip_item *sk;
 754     skip_item **skp;
 755     int len_address;
 756
 757     if (ddd->address[0] == '*') break;
 758     len_address = Ustrlen(ddd->address);
 759
 760     for (skp = &queue_skip; ; skp = &(sk->next))
 761       {
 762       int len_skip;
 763
 764       sk = *skp;
 765       while (sk != NULL && now >= sk->reveal)
 766         {
 767         *skp = sk->next;
 768         store_free(sk);
 769         sk = *skp;
 770         if (queue_skip == NULL)
 771           {
 772           XtDestroyWidget(unhide_widget);
 773           unhide_widget = NULL;
 774           }
 775         }
 776       if (sk == NULL) break;
 777
 778       /* If this address matches the skip item, break (sk != NULL) */
 779
 780       len_skip = Ustrlen(sk->text);
 781       if (len_skip <= len_address &&
 782           Ustrcmp(ddd->address + len_address - len_skip, sk->text) == 0)
 783         break;
 784       }
 785
 786     if (sk == NULL) break;
 787     }
 788
 789   /* Don't use more than one call of anon() in one statement - it uses
 790   a fixed static buffer. */
 791
 792   if (ddd != NULL || dd == NULL)
 793     {
 794     text_showf(queue_widget, "%c%2d%c %s %s %-8s ",
 795       (p->frozen)? '*' : ' ',
 796       t, u,
 797       string_format_size(p->size, big_buffer),
 798       p->name,
 799       (p->sender == NULL)? US"       " :
 800         (p->sender[0] == 0)? US"<>     " : anon(p->sender));
 801
 802     text_showf(queue_widget, "%s%s%s",
 803       (dd == NULL || dd->address[0] == '*')? "" : "<",
 804       (dd == NULL)? US"" : anon(dd->address),
 805       (dd == NULL || dd->address[0] == '*')? "" : ">");
 806
 807     if (dd != NULL && dd->parent != NULL && dd->parent->address[0] != '*')
 808       text_showf(queue_widget, " parent <%s>", anon(dd->parent->address));
 809
 810     text_show(queue_widget, US"\n");
 811
 812     if (dd != NULL) dd = dd->next;
 813     while (dd != NULL && count++ < queue_max_addresses)
 814       {
 815       text_showf(queue_widget, "                                     <%s>",
 816         anon(dd->address));
 817       if (dd->parent != NULL && dd->parent->address[0] != '*')
 818         text_showf(queue_widget, " parent <%s>", anon(dd->parent->address));
 819       text_show(queue_widget, US"\n");
 820       dd = dd->next;
 821       }
 822     if (dd != NULL)
 823       text_showf(queue_widget, "                                     ...\n");
 824     }
 825
 826   p = p->next;
 827   }
 828 }
 829
 830 /* End of em_queue.c */