home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 25 / CDROM25.iso / Share / linux / apache / contrib / patches / 1.2 / IndexWidth.patch < prev    next >
Encoding:
Text File  |  1998-06-11  |  27.7 KB  |  985 lines
  1. Title: Variable-length fields in FancyIndexing output in mod_dir.
  2. Submitter: Ken Coar <Coar@DECUS.Org>
  3. Date: Tue Jan  7 12:22:27 EST 1997
  4. Patch built against: Apache 1.2b4
  5.  
  6.     This patch provides the IndexNameWidth and IndexDescWidth directives
  7.     to control the width of the filename and description fields,
  8.     respectively, in FancyIndexed generated directory indices.  These
  9.     directives can appear in any configuration file in which the
  10.     IndexOptions directive is available.
  11.  
  12.     The module and directive documentation pages are also patched to
  13.     reflect the new directives and their explanations.
  14.  
  15.     To apply the patch, cd to the Apache source directory and use the
  16.     command
  17.  
  18.     patch -c -s -b + + + -d ../htdocs/manual/mod < [patch-file]
  19.  
  20.     [Adjust the command appropriately if you've moved your manual
  21.     pages.]
  22.  
  23.     BEWARE if you're not patching the 1.2b4 distribution!  Caveat
  24.     emptor!
  25.  
  26.     #ken    :-)}
  27.  
  28. Index: mod_dir.c
  29. ===================================================================
  30. *** 1.1    1996/12/31 12:37:02
  31. --- mod_dir.c    1997/01/05 18:39:55
  32. ***************
  33. *** 82,87 ****
  34. --- 82,92 ----
  35.   #define SUPPRESS_SIZE 16
  36.   #define SUPPRESS_DESC 32
  37.   
  38. + #define DEFAULT_NAME_WIDTH 23
  39. + #define DEFAULT_DESC_WIDTH 23
  40. + #define LAST_MOD_WIDTH 17
  41. + #define SIZE_WIDTH SEND_SIZE_CHARS + 2
  42. + 
  43.   struct item {
  44.       char *type;
  45.       char *apply_to;
  46. ***************
  47. *** 95,101 ****
  48.       char *index_names;
  49.     
  50.       array_header *icon_list, *alt_list, *desc_list, *ign_list;
  51. !     array_header *hdr_list, *rdme_list, *opts_list;
  52.     
  53.   } dir_config_rec;
  54.   
  55. --- 100,106 ----
  56.       char *index_names;
  57.     
  58.       array_header *icon_list, *alt_list, *desc_list, *ign_list;
  59. !     array_header *hdr_list, *rdme_list, *opts_list, *nw_list, *dw_list;
  60.     
  61.   } dir_config_rec;
  62.   
  63. ***************
  64. *** 173,178 ****
  65. --- 178,220 ----
  66.       return NULL;
  67.   }
  68.   
  69. + /*
  70. + ** This routine adds the value of the read IndexNameWidth directive to the
  71. + ** appropriate directory entry.  This value controls the width of the filename
  72. + ** field in FancyIndexed generated indices.
  73. + */
  74. + const char *add_name_width (cmd_parms *cmd, void *d, char *cwidth) {
  75. +     int width = atoi (cwidth);
  76. + 
  77. +     push_item
  78. +     (
  79. +         ((dir_config_rec *) d)->nw_list,
  80. +         (char *) width,
  81. +         NULL,
  82. +         cmd->path,
  83. +         NULL
  84. +     );
  85. +     return NULL;
  86. + }
  87. + 
  88. + /*
  89. + ** Like its brother add_name_width above, this routine adds the value of the
  90. + ** just-read IndexDescWidth directive to the appropriate directory entry.
  91. + ** This controls the width of the description field in FancyIndexed generated
  92. + ** indices.
  93. + */
  94. + const char *add_desc_width (cmd_parms *cmd, void *d, char *cwidth) {
  95. +     push_item
  96. +     (
  97. +         ((dir_config_rec *) d)->dw_list,
  98. +         (char *) atoi (cwidth),
  99. +         NULL,
  100. +         cmd->path,
  101. +         NULL
  102. +     );
  103. +     return NULL;
  104. + }
  105. + 
  106.   
  107.   const char *add_opts_int(cmd_parms *cmd, void *d, int opts) {
  108.       push_item(((dir_config_rec *)d)->opts_list, (char*)opts, NULL,
  109. ***************
  110. *** 241,246 ****
  111. --- 283,304 ----
  112.   { "DirectoryIndex", set_string_slot,
  113.       (void*)XtOffsetOf(dir_config_rec, index_names),
  114.       DIR_CMD_PERMS, RAW_ARGS, NULL },
  115. + {
  116. +     "IndexNameWidth",
  117. +     add_name_width,
  118. +     NULL,
  119. +     DIR_CMD_PERMS,
  120. +     TAKE1,
  121. +     "width of filename field in generated indices"
  122. + },
  123. + {
  124. +     "IndexDescWidth",
  125. +     add_desc_width,
  126. +     NULL,
  127. +     DIR_CMD_PERMS,
  128. +     TAKE1,
  129. +     "width of description field in generated indices"
  130. + },
  131.   { NULL }
  132.   };
  133.   
  134. ***************
  135. *** 257,262 ****
  136. --- 315,322 ----
  137.       new->hdr_list = make_array (p, 4, sizeof (struct item));
  138.       new->rdme_list = make_array (p, 4, sizeof (struct item));
  139.       new->opts_list = make_array (p, 4, sizeof (struct item));
  140. +     new->nw_list = make_array (p, 4, sizeof (struct item));
  141. +     new->dw_list = make_array (p, 4, sizeof (struct item));
  142.       
  143.       return (void *)new;
  144.   }
  145. ***************
  146. *** 277,282 ****
  147. --- 337,344 ----
  148.       new->icon_list = append_arrays (p, add->icon_list, base->icon_list);
  149.       new->rdme_list = append_arrays (p, add->rdme_list, base->rdme_list);
  150.       new->opts_list = append_arrays (p, add->opts_list, base->opts_list);
  151. +     new->nw_list = append_arrays (p, add->nw_list, base->nw_list);
  152. +     new->dw_list = append_arrays (p, add->dw_list, base->dw_list);
  153.       
  154.       return new;
  155.   }
  156. ***************
  157. *** 382,401 ****
  158.       return 0;
  159.   }
  160.   
  161. ! int find_opts(dir_config_rec *d, request_rec *r) {
  162. !     char *path = r->filename;
  163. !     array_header *list = d->opts_list;
  164. !     struct item *items = (struct item *)list->elts;
  165.       int i;
  166.   
  167.       for (i = 0; i < list->nelts; ++i) {
  168.           struct item *p = &items[i];
  169.       
  170. !         if(!strcmp_match(path,p->apply_path))
  171.               return (int)p->type;
  172.       }
  173.       return 0;
  174.   }
  175.   
  176.   /*****************************************************************
  177.    *
  178. --- 444,504 ----
  179.       return 0;
  180.   }
  181.   
  182. ! /*
  183. ! ** This routine looks through the array of options settings for one applying
  184. ! ** to the specified path, returning the value if found or zero otherwise.
  185. ! */
  186. ! int find_opts (dir_config_rec *d, request_rec *r) {
  187. !     int value;
  188. ! 
  189. !     value = find_int (r->filename, d->opts_list);
  190. !     return value;
  191. ! }
  192. ! 
  193. ! /*
  194. ! ** This routine scans the specified item array for a matching path, and
  195. ! ** returns the integer value from the item when one is found.  If none is
  196. ! ** found, we return zero.
  197. ! */
  198. ! int find_int (char *path, array_header *list) {
  199. !     struct item *items;
  200.       int i;
  201.   
  202. +     if (list == NULL) {
  203. +     return 0;
  204. +     };
  205. +     items = (struct item *)list->elts;
  206. +     if (items == NULL) {
  207. +     return 0;
  208. +     };
  209. + 
  210.       for (i = 0; i < list->nelts; ++i) {
  211.           struct item *p = &items[i];
  212.       
  213. !         if(!strcmp_match (path, p->apply_path))
  214.               return (int)p->type;
  215.       }
  216.       return 0;
  217.   }
  218. + /*
  219. + ** This routine looks through the list of user-defined widths for the file
  220. + ** name until it finds one that applies to the specified path.  If none is
  221. + ** found, it returns zero, which means `use the default width.'
  222. + */
  223. + int find_name_width (dir_config_rec *d, request_rec *r) {
  224. +     int value;
  225. + 
  226. +     value = find_int (r->filename, d->nw_list);
  227. +     return value;
  228. + }
  229. + 
  230. + /*
  231. + ** This routine is the same as its brother find_name_width above, except that
  232. + ** it looks for a value for the width of the description field for this path.
  233. + */
  234. + int find_desc_width (dir_config_rec *d, request_rec *r) {
  235. +     return find_int (r->filename, d->dw_list);
  236. + }
  237.   
  238.   /*****************************************************************
  239.    *
  240. ***************
  241. *** 417,426 ****
  242.           if(stat(fn,&finfo) == -1)
  243.               return 0;
  244.           plaintext=1;
  245. !         if(rule) rputs("<HR>\n", r);
  246. !         rputs("<PRE>\n", r);
  247.       }
  248. !     else if (rule) rputs("<HR>\n", r);
  249.       if(!(f = pfopen(r->pool,fn,"r")))
  250.           return 0;
  251.       if (!plaintext)
  252. --- 520,529 ----
  253.           if(stat(fn,&finfo) == -1)
  254.               return 0;
  255.           plaintext=1;
  256. !         if (rule) rputs ("  <HR>\n", r);
  257. !         rputs ("  <PRE>\n", r);
  258.       }
  259. !     else if (rule) rputs("  <HR>\n", r);
  260.       if(!(f = pfopen(r->pool,fn,"r")))
  261.           return 0;
  262.       if (!plaintext)
  263. ***************
  264. *** 452,458 ****
  265.       }
  266.       pfclose(r->pool, f);
  267.       if(plaintext)
  268. !         rputs("</PRE>\n", r);
  269.       return 1;
  270.   }
  271.   
  272. --- 555,561 ----
  273.       }
  274.       pfclose(r->pool, f);
  275.       if(plaintext)
  276. !         rputs("  </PRE>\n", r);
  277.       return 1;
  278.   }
  279.   
  280. ***************
  281. *** 535,646 ****
  282.       return(p);
  283.   }
  284.   
  285. ! char *terminate_description(dir_config_rec *d, char *desc, int dir_opts) {
  286. !     int maxsize = 23;
  287. !     register int x;
  288. !     
  289. !     if(dir_opts & SUPPRESS_LAST_MOD) maxsize += 17;
  290. !     if(dir_opts & SUPPRESS_SIZE) maxsize += 7;
  291. ! 
  292. !     for(x=0;desc[x] && maxsize;x++) {
  293. !         if(desc[x] == '<') {
  294. !             while(desc[x] != '>') {
  295. !                 if(!desc[x]) {
  296. !                     maxsize = 0;
  297. !                     break;
  298. !                 }
  299. !                 ++x;
  300. !             }
  301. !         }
  302. !         else --maxsize;
  303. !     }
  304. !     if(!maxsize) {
  305. !         desc[x-1] = '>';    /* Grump. */
  306. !     desc[x] = '\0';        /* Double Grump! */
  307. !     }
  308. !     return desc;
  309.   }
  310.   
  311.   void output_directories(struct ent **ar, int n,
  312. !             dir_config_rec *d, request_rec *r, int dir_opts)
  313.   {
  314.       int x, len;
  315.       char *name = r->uri;
  316.       char *tp;
  317.       pool *scratch = make_sub_pool (r->pool);
  318.       
  319.       if(name[0] == '\0') name = "/";
  320.   
  321.       if(dir_opts & FANCY_INDEXING) {
  322. !         rputs("<PRE>", r);
  323.           if((tp = find_default_icon(d,"^^BLANKICON^^")))
  324. !             rvputs(r, "<IMG SRC=\"", escape_html(scratch, tp),
  325. !            "\" ALT=\"     \"> ", NULL);
  326. !         rputs("Name                   ", r);
  327.           if(!(dir_opts & SUPPRESS_LAST_MOD))
  328. !             rputs("Last modified     ", r);
  329.           if(!(dir_opts & SUPPRESS_SIZE))
  330. !             rputs("Size  ", r);
  331. !         if(!(dir_opts & SUPPRESS_DESC))
  332. !             rputs("Description", r);
  333. !         rputs("\n<HR>\n", r);
  334.       }
  335.       else {
  336. !         rputs("<UL>", r);
  337.       }
  338.           
  339. !     for(x=0;x<n;x++) {
  340.       char *anchor = NULL, *t = NULL, *t2 = NULL;
  341.       
  342.       clear_pool (scratch);
  343.       
  344. !         if((!strcmp(ar[x]->name,"../")) || (!strcmp(ar[x]->name,".."))) {
  345.               char *t = make_full_path (scratch, name, "../");
  346. !             getparents(t);
  347. !             if(t[0] == '\0') t = "/";
  348. !         anchor = pstrcat (scratch, "<A HREF=\"",
  349. !                   escape_html(scratch, os_escape_path(scratch, t, 0)),
  350. !                   "\">", NULL);
  351. !         t2 = "Parent Directory</A>       ";
  352.           }
  353.           else {
  354.           t = ar[x]->name;
  355. !         len = strlen(t);
  356. !             if(len > 23) {
  357. !         t2 = pstrdup(scratch, t);
  358. !         t2[21] = '.';
  359. !         t2[22] = '.';
  360. !                 t2[23] = '\0';
  361. !         t2 = escape_html(scratch, t2);
  362. !         t2 = pstrcat(scratch, t2, "</A>", NULL);
  363. !             } else 
  364. !         {
  365. !         char buff[24]="                       ";
  366. !         t2 = escape_html(scratch, t);
  367. !         buff[23-len] = '\0';
  368. !         t2 = pstrcat(scratch, t2, "</A>", buff, NULL);
  369. !         }
  370. !         anchor = pstrcat (scratch, "<A HREF=\"",
  371. !                   escape_html(scratch, os_escape_path(scratch, t, 0)),
  372. !                   "\">", NULL);
  373.           }
  374.   
  375. !         if(dir_opts & FANCY_INDEXING) {
  376. !             if(dir_opts & ICONS_ARE_LINKS)
  377. !                 rputs(anchor, r);
  378. !             if((ar[x]->icon) || d->default_icon) {
  379. !                 rvputs(r, "<IMG SRC=\"", 
  380. !                escape_html(scratch, ar[x]->icon ?
  381. !                    ar[x]->icon : d->default_icon),
  382. !                "\" ALT=\"[", (ar[x]->alt ? ar[x]->alt : "   "),
  383. !                "]\">", NULL);
  384.               }
  385. !             if(dir_opts & ICONS_ARE_LINKS) 
  386. !                 rputs("</A>", r);
  387.   
  388. !             rvputs(r," ", anchor, t2, NULL);
  389. !             if(!(dir_opts & SUPPRESS_LAST_MOD)) {
  390. !                 if(ar[x]->lm != -1) {
  391.               char time[MAX_STRING_LEN];
  392.                       struct tm *ts = localtime(&ar[x]->lm);
  393.                       strftime(time,MAX_STRING_LEN,"%d-%b-%y %H:%M  ",ts);
  394. --- 638,845 ----
  395.       return(p);
  396.   }
  397.   
  398. ! /*
  399. ! ** This routine sizes the specified text into the output buffer.  If the text
  400. ! ** is larger than the specified maximum width, it is truncated and the tail
  401. ! ** end is replaced with the overflow text (as much as will fit).  The suffix
  402. ! ** buffer is filled with enough spaces to reach the specified width whn added
  403. ! ** to the output buffer.  Naturally, the assumption is made that the buffers
  404. ! ** are at least as wide as the maximum width plus one.  We use the suffix
  405. ! ** buffer as a work area before finally filling it with the right number of
  406. ! ** spaces.
  407. ! */
  408. ! void *size_field
  409. !     (
  410. !         char *buffer,        /* Buffer into which text is to be sized */
  411. !         char *suffix,        /* Preallocated working/suffix buffer */
  412. !         int width,            /* Maximum width of text in buffer */
  413. !         char *contents,        /* Text to be inserted */
  414. !         char *overflow        /* Suffix if text is too long */
  415. !     ) {
  416. !     int content_len = strlen (contents);
  417. !     int overflow_len = strlen (overflow);
  418. !     int actual_len = (content_len < width) ? content_len : width;
  419. !     int suffix_len = (width < overflow_len) ? width : overflow_len;
  420. ! 
  421. !     strcpy (buffer, contents);
  422. !     if (content_len > width) {
  423. !     int i;
  424. !     char *s1 = overflow;
  425. !     char *s2;
  426. ! 
  427. !     s2 = &buffer[width-suffix_len];
  428. !     for (i = 0; i < suffix_len; i++) {
  429. !         *s2++ = *s1++;
  430. !     };
  431. !     *s2 = '\0';
  432. !     };
  433. !     /*
  434. !     ** At this point, the output buffer contains the (possibly truncated) input
  435. !     ** string.  Put the right number of blanks into the suffix buffer.
  436. !     */
  437. !     sprintf (suffix, "%*s", (width - actual_len), "");
  438. !     return NULL;
  439.   }
  440.   
  441.   void output_directories(struct ent **ar, int n,
  442. !             dir_config_rec *d, request_rec *r, int dir_opts,
  443. !             int name_width, int desc_width)
  444.   {
  445.       int x, len;
  446. +     int nwidth = name_width;
  447. +     int dwidth = desc_width;
  448. +     int total_width;
  449.       char *name = r->uri;
  450.       char *tp;
  451. +     char *name_buff, *space_buff;
  452.       pool *scratch = make_sub_pool (r->pool);
  453.       
  454. +     if (nwidth == 0) {
  455. +     nwidth = DEFAULT_NAME_WIDTH;
  456. +     };
  457. +     /*
  458. +      * Figure out how wide the description can be.  If we're suppressing any
  459. +      * of the other fields, add their widths to this.
  460. +      */
  461. +     if (dwidth == 0) {
  462. +     dwidth = DEFAULT_DESC_WIDTH;
  463. +     if (dir_opts & SUPPRESS_LAST_MOD) dwidth += 17;
  464. +     if (dir_opts & SUPPRESS_SIZE) dwidth += 7;
  465. +     };
  466. +     /*
  467. +      * Make sure we allocate space for the largest resizable item we'll need.
  468. +      * This is static for the duration of the request, so we allocate it from
  469. +      * the request pool rather than the subpool.
  470. +      */
  471. +     len = (nwidth > dwidth) ? nwidth : dwidth;
  472. +     name_buff = (char *) palloc (r->pool, len + 5);
  473. +     space_buff = (char *) palloc (r->pool, len + 5);
  474. + 
  475. + 
  476.       if(name[0] == '\0') name = "/";
  477.   
  478.       if(dir_opts & FANCY_INDEXING) {
  479. !         rputs ("  <PRE", r);
  480. !     total_width = nwidth;
  481. !     if (! (dir_opts & SUPPRESS_LAST_MOD)) {
  482. !         total_width += LAST_MOD_WIDTH;
  483. !     };
  484. !     if (! (dir_opts & SUPPRESS_SIZE)) {
  485. !         total_width += SIZE_WIDTH;
  486. !     };
  487. !     if (! (dir_opts & SUPPRESS_DESC)) {
  488. !         total_width += dwidth;
  489. !     };
  490. !     if (total_width > 80) {
  491. !         sprintf (name_buff, " WIDTH=%d", total_width);
  492. !         rputs (name_buff, r);
  493. !     };
  494. !         rputs (">", r);
  495.           if((tp = find_default_icon(d,"^^BLANKICON^^")))
  496. !             rvputs
  497. !         (
  498. !             r,
  499. !             "<IMG SRC=\"",
  500. !             escape_html (scratch, tp),
  501. !             "\" ALT=\"     \"> ",
  502. !             NULL
  503. !         );
  504. !     size_field (name_buff, space_buff, nwidth, "Name", "..");
  505. !     rvputs (r, name_buff, space_buff, " ", NULL);
  506.           if(!(dir_opts & SUPPRESS_LAST_MOD))
  507. !             rputs ("Last modified    ", r);
  508.           if(!(dir_opts & SUPPRESS_SIZE))
  509. !             rputs (" Size  ", r);
  510. !         if (!(dir_opts & SUPPRESS_DESC)) {
  511. !         size_field (name_buff, space_buff, dwidth, "Description", "..");
  512. !             rputs (name_buff, r);
  513. !     };
  514. !         rputs("\n  <HR>\n", r);
  515.       }
  516.       else {
  517. !         rputs("  <UL>\n", r);
  518.       }
  519.           
  520. !     for (x = 0; x < n; x++) {
  521.       char *anchor = NULL, *t = NULL, *t2 = NULL;
  522.       
  523.       clear_pool (scratch);
  524.       
  525. !         if ((!strcmp (ar[x]->name, "../")) || (!strcmp (ar[x]->name, ".."))) {
  526.               char *t = make_full_path (scratch, name, "../");
  527. !             getparents (t);
  528. !             if (t[0] == '\0') t = "/";
  529. !         anchor = pstrcat
  530. !             (
  531. !                 scratch,
  532. !                 "<A HREF=\"",
  533. !                 escape_html
  534. !                 (
  535. !                     scratch,
  536. !                     os_escape_path (scratch, t, 0)
  537. !                 ),
  538. !                 "\">",
  539. !                 NULL
  540. !             );
  541. !         if (dir_opts & FANCY_INDEXING) {
  542. !         size_field
  543. !             (
  544. !             name_buff,
  545. !             space_buff,
  546. !             nwidth,
  547. !             "Parent Directory",
  548. !             ".."
  549. !             );
  550. !         t2 = name_buff;
  551. !         } else {
  552. !         t2 = "Parent Directory";
  553. !         space_buff[0] = '\0';
  554. !         };
  555.           }
  556.           else {
  557.           t = ar[x]->name;
  558. !         len = strlen (t);
  559. !         t2 = escape_html (scratch, t);
  560. !         anchor = pstrcat
  561. !             (
  562. !                 scratch,
  563. !                 "<A HREF=\"",
  564. !                 escape_html
  565. !                 (
  566. !                     scratch,
  567. !                     os_escape_path (scratch, t, 0)
  568. !                 ),
  569. !                 "\">",
  570. !                 NULL
  571. !             );
  572.           }
  573.   
  574. !         if (dir_opts & FANCY_INDEXING) {
  575. !             if (dir_opts & ICONS_ARE_LINKS)
  576. !                 rputs (anchor, r);
  577. !             if ((ar[x]->icon) || d->default_icon) {
  578. !                 rvputs
  579. !             (
  580. !             r,
  581. !             "  <IMG SRC=\"",
  582. !             escape_html
  583. !                 (
  584. !                 scratch,
  585. !                 ar[x]->icon ? ar[x]->icon : d->default_icon
  586. !                 ),
  587. !             "\" ALT=\"[",
  588. !             (ar[x]->alt ? ar[x]->alt : "   "),
  589. !             "]\">",
  590. !             NULL
  591. !             );
  592.               }
  593. !             if (dir_opts & ICONS_ARE_LINKS) 
  594. !                 rputs ("</A>", r);
  595.   
  596. !             size_field (name_buff, space_buff, nwidth, t2, "..");
  597. !         rvputs (r, " ", anchor, name_buff, "</A>", space_buff, " ", NULL);
  598. !             if (!(dir_opts & SUPPRESS_LAST_MOD)) {
  599. !                 if (ar[x]->lm != -1) {
  600.               char time[MAX_STRING_LEN];
  601.                       struct tm *ts = localtime(&ar[x]->lm);
  602.                       strftime(time,MAX_STRING_LEN,"%d-%b-%y %H:%M  ",ts);
  603. ***************
  604. *** 647,679 ****
  605.               rputs(time, r);
  606.                   }
  607.                   else {
  608. !                     rputs("                 ", r);
  609.                   }
  610.               }
  611. !             if(!(dir_opts & SUPPRESS_SIZE)) {
  612. !                 send_size(ar[x]->size,r);
  613. !                 rputs("  ", r);
  614.               }
  615.               if(!(dir_opts & SUPPRESS_DESC)) {
  616. !                 if(ar[x]->desc) {
  617. !                     rputs(terminate_description(d, ar[x]->desc, dir_opts), r);
  618.                   }
  619.               }
  620.           }
  621.           else
  622. !             rvputs(r, "<LI> ", anchor," ", t2, NULL);
  623. !         rputc('\n', r);
  624.       }
  625.       if(dir_opts & FANCY_INDEXING) {
  626. !         rputs("</PRE>", r);
  627.       }
  628.       else {
  629. !         rputs("</UL>", r);
  630.       }
  631.   }
  632.   
  633.   
  634. ! int dsortf(struct ent **s1,struct ent **s2)
  635.   {
  636.       return(strcmp((*s1)->name,(*s2)->name));
  637.   }
  638. --- 846,886 ----
  639.               rputs(time, r);
  640.                   }
  641.                   else {
  642. !                     rputs ("                 ", r);
  643.                   }
  644.               }
  645. !             if (!(dir_opts & SUPPRESS_SIZE)) {
  646. !                 send_size (ar[x]->size, r);
  647. !                 rputs ("  ", r);
  648.               }
  649.               if(!(dir_opts & SUPPRESS_DESC)) {
  650. !                 if (ar[x]->desc) {
  651. !             size_field
  652. !             (
  653. !                 name_buff,
  654. !                 space_buff,
  655. !                 dwidth,
  656. !                 ar[x]->desc,
  657. !                 ".."
  658. !             );
  659. !                     rputs (name_buff, r);
  660.                   }
  661.               }
  662.           }
  663.           else
  664. !             rvputs (r, "   <LI> ", anchor," ", t2, "</A>", NULL);
  665. !         rputc ('\n', r);
  666.       }
  667.       if(dir_opts & FANCY_INDEXING) {
  668. !         rputs ("  </PRE>\n", r);
  669.       }
  670.       else {
  671. !         rputs ("  </UL>\n", r);
  672.       }
  673.   }
  674.   
  675.   
  676. ! int dsortf (struct ent **s1, struct ent **s2)
  677.   {
  678.       return(strcmp((*s1)->name,(*s2)->name));
  679.   }
  680. ***************
  681. *** 692,697 ****
  682. --- 899,906 ----
  683.       struct ent **ar = NULL;
  684.       char *tmp;
  685.       int dir_opts = find_opts(dir_conf, r);
  686. +     int name_width = find_name_width (dir_conf, r);
  687. +     int desc_width = find_desc_width (dir_conf, r);
  688.   
  689.       if(!(d=opendir(name))) return FORBIDDEN;
  690.   
  691. ***************
  692. *** 712,722 ****
  693.       while (title_endp > title_name && *title_endp == '/')
  694.       *title_endp-- = '\0';
  695.       
  696. !     rvputs(r, "<HEAD><TITLE>Index of ", title_name, "</TITLE></HEAD><BODY>\n",
  697. !        NULL);
  698.   
  699.       if((!(tmp = find_header(dir_conf,r))) || (!(insert_readme(name,tmp,0,r))))
  700. !         rvputs(r, "<H1>Index of ", title_name, "</H1>\n", NULL);
  701.   
  702.       /* 
  703.        * Since we don't know how many dir. entries there are, put them into a 
  704. --- 921,940 ----
  705.       while (title_endp > title_name && *title_endp == '/')
  706.       *title_endp-- = '\0';
  707.       
  708. !     rvputs
  709. !     (
  710. !         r,
  711. !         "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\n",
  712. !         "<HTML>\n",
  713. !         " <HEAD>\n",
  714. !         "  <TITLE>Index of ", title_name, "</TITLE>\n",
  715. !         " </HEAD>\n",
  716. !         " <BODY>\n",
  717. !         NULL
  718. !     );
  719.   
  720.       if((!(tmp = find_header(dir_conf,r))) || (!(insert_readme(name,tmp,0,r))))
  721. !         rvputs(r, "  <H1>Index of ", title_name, "</H1>\n", NULL);
  722.   
  723.       /* 
  724.        * Since we don't know how many dir. entries there are, put them into a 
  725. ***************
  726. *** 746,752 ****
  727.             (int (*)(const void *,const void *))dsortf);
  728.   #endif
  729.       }
  730. !     output_directories(ar, num_ent, dir_conf, r, dir_opts);
  731.       closedir(d);
  732.   
  733.       if (dir_opts & FANCY_INDEXING)
  734. --- 964,979 ----
  735.             (int (*)(const void *,const void *))dsortf);
  736.   #endif
  737.       }
  738. !     output_directories
  739. !     (
  740. !         ar,
  741. !         num_ent,
  742. !         dir_conf,
  743. !         r,
  744. !         dir_opts,
  745. !         name_width,
  746. !         desc_width
  747. !     );
  748.       closedir(d);
  749.   
  750.       if (dir_opts & FANCY_INDEXING)
  751. ***************
  752. *** 753,762 ****
  753.           if((tmp = find_readme(dir_conf, r)))
  754.               insert_readme(name,tmp,1,r);
  755.       else {
  756. !         rputs("</UL>", r);
  757.       }
  758.   
  759. !     rputs("</BODY>", r);
  760.       return 0;
  761.   }
  762.   
  763. --- 980,989 ----
  764.           if((tmp = find_readme(dir_conf, r)))
  765.               insert_readme(name,tmp,1,r);
  766.       else {
  767. !         rputs("  </UL>", r);
  768.       }
  769.   
  770. !     rvputs (r, " </BODY>\n", "</HTML>\n", NULL);
  771.       return 0;
  772.   }
  773.   
  774. Index: util_script.h
  775. ===================================================================
  776. *** 1.1    1997/01/01 01:49:37
  777. --- util_script.h    1997/01/02 12:22:53
  778. ***************
  779. *** 65,70 ****
  780. --- 65,74 ----
  781.   void add_common_vars(request_rec *r);
  782.   #define scan_script_header(a1,a2) scan_script_header_err(a1,a2,NULL)
  783.   int scan_script_header_err(request_rec *r, FILE *f, char *buffer);
  784. + /*
  785. +  * Define the canonical width of the output from the send_size () routine.
  786. +  */
  787. + #define SEND_SIZE_CHARS 5
  788.   void send_size(size_t size, request_rec *r);
  789.   void call_exec (request_rec *r, char *argv0, char **env, int shellcmd);
  790.   
  791. Index: util_script.c
  792. ===================================================================
  793. *** 1.1    1997/01/01 04:28:30
  794. --- util_script.c    1997/01/02 12:24:54
  795. ***************
  796. *** 376,397 ****
  797.       }
  798.   }
  799.   
  800. ! void send_size(size_t size, request_rec *r) {
  801.       char ss[20];
  802.   
  803. !     if(size == -1) 
  804. !         strcpy(ss, "    -");
  805. !     else if(!size) 
  806. !         strcpy(ss, "   0k");
  807. !     else if(size < 1024) 
  808. !         strcpy(ss, "   1k");
  809. !     else if(size < 1048576)
  810. !         sprintf(ss, "%4dk", (size + 512) / 1024);
  811. !     else if(size < 103809024)
  812. !     sprintf(ss, "%4.1fM", size / 1048576.0);
  813.       else
  814. !         sprintf(ss, "%4dM", (size + 524288) / 1048576);
  815. !     rputs(ss, r);
  816.   }
  817.   
  818.   #ifdef __EMX__
  819. --- 376,410 ----
  820.       }
  821.   }
  822.   
  823. ! /*
  824. ! ** This routine converts the specified value into an abbreviated character
  825. ! ** representation (e.g., in kilo- or mega-units).  The result is emitted to
  826. ! ** the output stream.  The size of the output is fixed; if this routine is
  827. ! ** changed to output more or fewer characters, be sure to update the
  828. ! ** SEND_SIZE_CHARS definition in util_script.h, which makes this width
  829. ! ** available to calling routines that want to line things up.
  830. ! */
  831. ! #define SIZE_1K 1024
  832. ! #define SIZE_1M (SIZE_1K * SIZE_1K)
  833. ! #define SIZE_500K (SIZE_1M / 2)
  834. ! #define SIZE_1G (SIZE_1M * SIZE_1K)
  835. ! #define SIZE_500M (SIZE_1G / 2)
  836. ! void send_size (size_t size, request_rec *r) {
  837.       char ss[20];
  838.   
  839. !     if (size == -1) 
  840. !         strcpy (ss, "    -");
  841. !     else if (!size) 
  842. !         strcpy (ss, "   0k");
  843. !     else if (size < SIZE_1K) 
  844. !         strcpy (ss, "   1k");
  845. !     else if (size < SIZE_1M)
  846. !         sprintf (ss, "%4dk", (size + 512) / SIZE_1K);
  847. !     else if (size < (SIZE_1M * 100))
  848. !     sprintf (ss, "%4.1fM", ((float) size / (float) SIZE_1M));
  849.       else
  850. !         sprintf (ss, "%4dM", (size + SIZE_500K) / SIZE_1M);
  851. !     rputs (ss, r);
  852.   }
  853.   
  854.   #ifdef __EMX__
  855.  
  856. Index: mod_dir.html
  857. ===================================================================
  858. *** 1.1    1997/01/05 18:42:12
  859. --- mod_dir.html    1997/01/05 23:08:42
  860. ***************
  861. *** 39,45 ****
  862. --- 39,47 ----
  863.   <li><A HREF="#directoryindex">DirectoryIndex</A>
  864.   <li><A HREF="#fancyindexing">FancyIndexing</A>
  865.   <li><A HREF="#headername">HeaderName</A>
  866. + <li><A HREF="#indexdescwidth">IndexDescWidth</A>
  867.   <li><A HREF="#indexignore">IndexIgnore</A>
  868. + <li><A HREF="#indexnamewidth">IndexNameWidth</A>
  869.   <li><A HREF="#indexoptions">IndexOptions</A>
  870.   <li><A HREF="#readmename">ReadmeName</A>
  871.   </menu>
  872. ***************
  873. *** 207,212 ****
  874. --- 209,254 ----
  875.   
  876.   <p>See also <A HREF="#readmename">ReadmeName</A>.<p><hr>
  877.   
  878. + <A NAME="indexdescwidth">
  879. +  <H2>IndexDescWidth</H2>
  880. + </A>
  881. + <!--%plaintext <?INDEX {\tt IndexDescWidth} directive> -->
  882. + <STRONG>Syntax:</STRONG> IndexDescWidth <EM>number</EM>
  883. + <BR>
  884. + <STRONG>Context:</STRONG> server config, virtual host, directory, .htaccess
  885. + <BR>
  886. + <STRONG>Override:</STRONG> Indexes
  887. + <BR>
  888. + <STRONG>Status:</STRONG> Base
  889. + <BR>
  890. + <STRONG>Module:</STRONG> mod_dir
  891. + <P>
  892. + The IndexDescWidth sets a specific width for the description field in
  893. + FancyIndexed directory listings.  By default, the width of this field
  894. + depends upon what other options are selected; SuppressLastModified and
  895. + SuppressSize will cause more space to be available for the description.
  896. + Using IndexDescWidth overrides this adjustment and allocates the
  897. + specified number of columns for the descriptive text.
  898. + <EM>Number</EM> is a decimal number
  899. + indicating exactly how wide the field should be.
  900. + Descriptions which are too long will be truncated.
  901. + Example:
  902. + <BLOCKQUOTE>
  903. +  <CODE>
  904. +   IndexDescWidth 32
  905. +  </CODE>
  906. + </BLOCKQUOTE>
  907. + </P>
  908. + <P>
  909. + See also
  910. + <A HREF="#adddescription">AddDescription</A>,
  911. + <A HREF="#indexnamewidth">IndexNameWidth</A>,
  912. + <A HREF="#indexoptions">IndexOptions</A>,
  913. + and
  914. + <A HREF="#fancyindexing">FancyIndexing</A>.
  915. + </P>
  916. + <HR>
  917. + 
  918.   <A name="indexignore"><h2>IndexIgnore</h2></A>
  919.   <!--%plaintext <?INDEX {\tt IndexIgnore} directive> -->
  920.   <strong>Syntax:</strong> IndexIgnore <em>file file ...</em><br>
  921. ***************
  922. *** 224,229 ****
  923. --- 266,309 ----
  924.   IndexIgnore README .htaccess *~
  925.   </code></blockquote><p><hr>
  926.   
  927. + <A NAME="indexnamewidth">
  928. +  <H2>IndexNameWidth</H2>
  929. + </A>
  930. + <!--%plaintext <?INDEX {\tt IndexNameWidth} directive> -->
  931. + <STRONG>Syntax:</STRONG> IndexNameWidth <EM>number</EM>
  932. + <BR>
  933. + <STRONG>Context:</STRONG> server config, virtual host, directory, .htaccess
  934. + <BR>
  935. + <STRONG>Override:</STRONG> Indexes
  936. + <BR>
  937. + <STRONG>Status:</STRONG> Base
  938. + <BR>
  939. + <STRONG>Module:</STRONG> mod_dir
  940. + <P>
  941. + The IndexNameWidth sets a specific width for the filename field in
  942. + FancyIndexed directory listings.  By default, this field is 23 columns
  943. + wide.  Using IndexNameWidth overrides this default width and allocates the
  944. + specified number of columns for the filename.
  945. + <EM>Number</EM> is a decimal number
  946. + indicating how wide the field should be.  Filenames which are longer
  947. + than this value will be truncated and "<SAMP>..</SAMP>"
  948. + substituted for the overflow.
  949. + Example:
  950. + <BLOCKQUOTE>
  951. +  <CODE>
  952. +   IndexNameWidth 32
  953. +  </CODE>
  954. + </BLOCKQUOTE>
  955. + </P>
  956. + <P>
  957. + See also
  958. + <A HREF="#indexdescwidth">IndexDescWidth</A>,
  959. + <A HREF="#indexoptions">IndexOptions</A>,
  960. + and
  961. + <A HREF="#fancyindexing">FancyIndexing</A>.
  962. + </P>
  963. + <HR>
  964. + 
  965.   <A name="indexoptions"><h2>IndexOptions</h2></A>
  966.   <!--%plaintext <?INDEX {\tt IndexOptions} directive> -->
  967.   <strong>Syntax:</strong> IndexOptions <em>option option ...</em><br>
  968.  
  969. Index: directives.html
  970. ===================================================================
  971. *** 1.1    1997/01/05 22:46:43
  972. --- directives.html    1997/01/05 23:07:57
  973. ***************
  974. *** 78,84 ****
  975. --- 78,86 ----
  976.   <li><A HREF="mod_imap.html#imapbase">ImapBase</A>
  977.   <li><A HREF="mod_imap.html#imapdefault">ImapDefault</A>
  978.   <li><A HREF="mod_imap.html#imapmenu">ImapMenu</A>
  979. + <li><A HREF="mod_dir.html#indexdescwidth">IndexDescWidth</A>
  980.   <li><A HREF="mod_dir.html#indexignore">IndexIgnore</A>
  981. + <li><A HREF="mod_dir.html#indexnamewidth">IndexNameWidth</A>
  982.   <li><A HREF="mod_dir.html#indexoptions">IndexOptions</A>
  983.   <li><A HREF="core.html#keepalive">KeepAlive</A>
  984.   <li><A HREF="core.html#keepalivetimeout">KeepAliveTimeout</A>
  985.