Fix compiler warnings
[wget] / src / ftp-ls.c
1 /* Parsing FTP `ls' output.
2    Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3    2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation,
4    Inc.
5
6 This file is part of GNU Wget.
7
8 GNU Wget is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 GNU Wget is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with Wget.  If not, see <http://www.gnu.org/licenses/>.
20
21 Additional permission under GNU GPL version 3 section 7
22
23 If you modify this program, or any covered work, by linking or
24 combining it with the OpenSSL project's OpenSSL library (or a
25 modified version of that library), containing parts covered by the
26 terms of the OpenSSL or SSLeay licenses, the Free Software Foundation
27 grants you additional permission to convey the resulting work.
28 Corresponding Source for a non-source form of such a combination
29 shall include the source code for the parts of OpenSSL used as well
30 as that of the covered work.  */
31
32 #include "wget.h"
33
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <string.h>
37 #include <unistd.h>
38 #include <errno.h>
39 #include <time.h>
40 #include "utils.h"
41 #include "ftp.h"
42 #include "url.h"
43 #include "convert.h"            /* for html_quote_string prototype */
44 #include "retr.h"               /* for output_stream */
45
46 /* Converts symbolic permissions to number-style ones, e.g. string
47    rwxr-xr-x to 755.  For now, it knows nothing of
48    setuid/setgid/sticky.  ACLs are ignored.  */
49 static int
50 symperms (const char *s)
51 {
52   int perms = 0, i;
53
54   if (strlen (s) < 9)
55     return 0;
56   for (i = 0; i < 3; i++, s += 3)
57     {
58       perms <<= 3;
59       perms += (((s[0] == 'r') << 2) + ((s[1] == 'w') << 1) +
60                 (s[2] == 'x' || s[2] == 's'));
61     }
62   return perms;
63 }
64
65
66 /* Cleans a line of text so that it can be consistently parsed. Destroys
67    <CR> and <LF> in case that thay occur at the end of the line and
68    replaces all <TAB> character with <SPACE>. Returns the length of the
69    modified line. */
70 static int
71 clean_line (char *line, int len)
72 {
73   if (len <= 0) return 0;
74
75   while (len > 0 && (line[len - 1] == '\n' || line[len - 1] == '\r'))
76     line[--len] = '\0';
77
78   if (!len) return 0;
79
80   for ( ; *line ; line++ ) if (*line == '\t') *line = ' ';
81
82   return len;
83 }
84
85 /* Convert the Un*x-ish style directory listing stored in FILE to a
86    linked list of fileinfo (system-independent) entries.  The contents
87    of FILE are considered to be produced by the standard Unix `ls -la'
88    output (whatever that might be).  BSD (no group) and SYSV (with
89    group) listings are handled.
90
91    The time stamps are stored in a separate variable, time_t
92    compatible (I hope).  The timezones are ignored.  */
93 static struct fileinfo *
94 ftp_parse_unix_ls (const char *file, int ignore_perms)
95 {
96   FILE *fp;
97   static const char *months[] = {
98     "Jan", "Feb", "Mar", "Apr", "May", "Jun",
99     "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
100   };
101   int next, len, i, error, ignore;
102   int year, month, day;         /* for time analysis */
103   int hour, min, sec, ptype;
104   struct tm timestruct, *tnow;
105   time_t timenow;
106   size_t bufsize = 0;
107
108   char *line = NULL, *tok, *ptok;      /* tokenizer */
109   struct fileinfo *dir, *l, cur; /* list creation */
110
111   fp = fopen (file, "rb");
112   if (!fp)
113     {
114       logprintf (LOG_NOTQUIET, "%s: %s\n", file, strerror (errno));
115       return NULL;
116     }
117   dir = l = NULL;
118
119   /* Line loop to end of file: */
120   while ((len = getline (&line, &bufsize, fp)) > 0)
121     {
122       len = clean_line (line, len);
123       /* Skip if total...  */
124       if (!strncasecmp (line, "total", 5))
125         continue;
126       /* Get the first token (permissions).  */
127       tok = strtok (line, " ");
128       if (!tok)
129         continue;
130
131       cur.name = NULL;
132       cur.linkto = NULL;
133
134       /* Decide whether we deal with a file or a directory.  */
135       switch (*tok)
136         {
137         case '-':
138           cur.type = FT_PLAINFILE;
139           DEBUGP (("PLAINFILE; "));
140           break;
141         case 'd':
142           cur.type = FT_DIRECTORY;
143           DEBUGP (("DIRECTORY; "));
144           break;
145         case 'l':
146           cur.type = FT_SYMLINK;
147           DEBUGP (("SYMLINK; "));
148           break;
149         default:
150           cur.type = FT_UNKNOWN;
151           DEBUGP (("UNKNOWN; "));
152           break;
153         }
154
155       if (ignore_perms)
156         {
157           switch (cur.type)
158             {
159             case FT_PLAINFILE:
160               cur.perms = 0644;
161               break;
162             case FT_DIRECTORY:
163               cur.perms = 0755;
164               break;
165             default:
166               /*cur.perms = 1023;*/     /* #### What is this?  --hniksic */
167               cur.perms = 0644;
168             }
169           DEBUGP (("implicit perms %0o; ", cur.perms));
170         }
171        else
172          {
173            cur.perms = symperms (tok + 1);
174            DEBUGP (("perms %0o; ", cur.perms));
175          }
176
177       error = ignore = 0;       /* Erroneous and ignoring entries are
178                                    treated equally for now.  */
179       year = hour = min = sec = 0; /* Silence the compiler.  */
180       month = day = 0;
181       ptype = TT_DAY;
182       next = -1;
183       /* While there are tokens on the line, parse them.  Next is the
184          number of tokens left until the filename.
185
186          Use the month-name token as the "anchor" (the place where the
187          position wrt the file name is "known").  When a month name is
188          encountered, `next' is set to 5.  Also, the preceding
189          characters are parsed to get the file size.
190
191          This tactic is quite dubious when it comes to
192          internationalization issues (non-English month names), but it
193          works for now.  */
194       tok = line;
195       while (ptok = tok,
196              (tok = strtok (NULL, " ")) != NULL)
197         {
198           --next;
199           if (next < 0)         /* a month name was not encountered */
200             {
201               for (i = 0; i < 12; i++)
202                 if (!strcasecmp (tok, months[i]))
203                   break;
204               /* If we got a month, it means the token before it is the
205                  size, and the filename is three tokens away.  */
206               if (i != 12)
207                 {
208                   wgint size;
209
210                   /* Parse the previous token with str_to_wgint.  */
211                   if (ptok == line)
212                     {
213                       /* Something has gone wrong during parsing. */
214                       error = 1;
215                       break;
216                     }
217                   errno = 0;
218                   size = str_to_wgint (ptok, NULL, 10);
219                   if (size == WGINT_MAX && errno == ERANGE)
220                     /* Out of range -- ignore the size.  #### Should
221                        we refuse to start the download.  */
222                     cur.size = 0;
223                   else
224                     cur.size = size;
225                   DEBUGP (("size: %s; ", number_to_static_string(cur.size)));
226
227                   month = i;
228                   next = 5;
229                   DEBUGP (("month: %s; ", months[month]));
230                 }
231             }
232           else if (next == 4)   /* days */
233             {
234               if (tok[1])       /* two-digit... */
235                 day = 10 * (*tok - '0') + tok[1] - '0';
236               else              /* ...or one-digit */
237                 day = *tok - '0';
238               DEBUGP (("day: %d; ", day));
239             }
240           else if (next == 3)
241             {
242               /* This ought to be either the time, or the year.  Let's
243                  be flexible!
244
245                  If we have a number x, it's a year.  If we have x:y,
246                  it's hours and minutes.  If we have x:y:z, z are
247                  seconds.  */
248               year = 0;
249               min = hour = sec = 0;
250               /* We must deal with digits.  */
251               if (c_isdigit (*tok))
252                 {
253                   /* Suppose it's year.  */
254                   for (; c_isdigit (*tok); tok++)
255                     year = (*tok - '0') + 10 * year;
256                   if (*tok == ':')
257                     {
258                       /* This means these were hours!  */
259                       hour = year;
260                       year = 0;
261                       ptype = TT_HOUR_MIN;
262                       ++tok;
263                       /* Get the minutes...  */
264                       for (; c_isdigit (*tok); tok++)
265                         min = (*tok - '0') + 10 * min;
266                       if (*tok == ':')
267                         {
268                           /* ...and the seconds.  */
269                           ++tok;
270                           for (; c_isdigit (*tok); tok++)
271                             sec = (*tok - '0') + 10 * sec;
272                         }
273                     }
274                 }
275               if (year)
276                 DEBUGP (("year: %d (no tm); ", year));
277               else
278                 DEBUGP (("time: %02d:%02d:%02d (no yr); ", hour, min, sec));
279             }
280           else if (next == 2)    /* The file name */
281             {
282               int fnlen;
283               char *p;
284
285               /* Since the file name may contain a SPC, it is possible
286                  for strtok to handle it wrong.  */
287               fnlen = strlen (tok);
288               if (fnlen < len - (tok - line))
289                 {
290                   /* So we have a SPC in the file name.  Restore the
291                      original.  */
292                   tok[fnlen] = ' ';
293                   /* If the file is a symbolic link, it should have a
294                      ` -> ' somewhere.  */
295                   if (cur.type == FT_SYMLINK)
296                     {
297                       p = strstr (tok, " -> ");
298                       if (!p)
299                         {
300                           error = 1;
301                           break;
302                         }
303                       cur.linkto = xstrdup (p + 4);
304                       DEBUGP (("link to: %s\n", cur.linkto));
305                       /* And separate it from the file name.  */
306                       *p = '\0';
307                     }
308                 }
309               /* If we have the filename, add it to the list of files or
310                  directories.  */
311               /* "." and ".." are an exception!  */
312               if (!strcmp (tok, ".") || !strcmp (tok, ".."))
313                 {
314                   DEBUGP (("\nIgnoring `.' and `..'; "));
315                   ignore = 1;
316                   break;
317                 }
318               /* Some FTP sites choose to have ls -F as their default
319                  LIST output, which marks the symlinks with a trailing
320                  `@', directory names with a trailing `/' and
321                  executables with a trailing `*'.  This is no problem
322                  unless encountering a symbolic link ending with `@',
323                  or an executable ending with `*' on a server without
324                  default -F output.  I believe these cases are very
325                  rare.  */
326               fnlen = strlen (tok); /* re-calculate `fnlen' */
327               cur.name = xmalloc (fnlen + 1);
328               memcpy (cur.name, tok, fnlen + 1);
329               if (fnlen)
330                 {
331                   if (cur.type == FT_DIRECTORY && cur.name[fnlen - 1] == '/')
332                     {
333                       cur.name[fnlen - 1] = '\0';
334                       DEBUGP (("trailing `/' on dir.\n"));
335                     }
336                   else if (cur.type == FT_SYMLINK && cur.name[fnlen - 1] == '@')
337                     {
338                       cur.name[fnlen - 1] = '\0';
339                       DEBUGP (("trailing `@' on link.\n"));
340                     }
341                   else if (cur.type == FT_PLAINFILE
342                            && (cur.perms & 0111)
343                            && cur.name[fnlen - 1] == '*')
344                     {
345                       cur.name[fnlen - 1] = '\0';
346                       DEBUGP (("trailing `*' on exec.\n"));
347                     }
348                 } /* if (fnlen) */
349               else
350                 error = 1;
351               break;
352             }
353           else
354             abort ();
355         } /* while */
356
357       if (!cur.name || (cur.type == FT_SYMLINK && !cur.linkto))
358         error = 1;
359
360       DEBUGP (("%s\n", cur.name ? cur.name : ""));
361
362       if (error || ignore)
363         {
364           DEBUGP (("Skipping.\n"));
365           xfree_null (cur.name);
366           xfree_null (cur.linkto);
367           continue;
368         }
369
370       if (!dir)
371         {
372           l = dir = xnew (struct fileinfo);
373           memcpy (l, &cur, sizeof (cur));
374           l->prev = l->next = NULL;
375         }
376       else
377         {
378           cur.prev = l;
379           l->next = xnew (struct fileinfo);
380           l = l->next;
381           memcpy (l, &cur, sizeof (cur));
382           l->next = NULL;
383         }
384       /* Get the current time.  */
385       timenow = time (NULL);
386       tnow = localtime (&timenow);
387       /* Build the time-stamp (the idea by zaga@fly.cc.fer.hr).  */
388       timestruct.tm_sec   = sec;
389       timestruct.tm_min   = min;
390       timestruct.tm_hour  = hour;
391       timestruct.tm_mday  = day;
392       timestruct.tm_mon   = month;
393       if (year == 0)
394         {
395           /* Some listings will not specify the year if it is "obvious"
396              that the file was from the previous year.  E.g. if today
397              is 97-01-12, and you see a file of Dec 15th, its year is
398              1996, not 1997.  Thanks to Vladimir Volovich for
399              mentioning this!  */
400           if (month > tnow->tm_mon)
401             timestruct.tm_year = tnow->tm_year - 1;
402           else
403             timestruct.tm_year = tnow->tm_year;
404         }
405       else
406         timestruct.tm_year = year;
407       if (timestruct.tm_year >= 1900)
408         timestruct.tm_year -= 1900;
409       timestruct.tm_wday  = 0;
410       timestruct.tm_yday  = 0;
411       timestruct.tm_isdst = -1;
412       l->tstamp = mktime (&timestruct); /* store the time-stamp */
413       l->ptype = ptype;
414     }
415
416   xfree (line);
417   fclose (fp);
418   return dir;
419 }
420
421 static struct fileinfo *
422 ftp_parse_winnt_ls (const char *file)
423 {
424   FILE *fp;
425   int len;
426   int year, month, day;         /* for time analysis */
427   int hour, min;
428   size_t bufsize = 0;
429   struct tm timestruct;
430
431   char *line = NULL, *tok;             /* tokenizer */
432   char *filename;
433   struct fileinfo *dir, *l, cur; /* list creation */
434
435   fp = fopen (file, "rb");
436   if (!fp)
437     {
438       logprintf (LOG_NOTQUIET, "%s: %s\n", file, strerror (errno));
439       return NULL;
440     }
441   dir = l = NULL;
442
443   /* Line loop to end of file: */
444   while ((len = getline (&line, &bufsize, fp)) > 0)
445     {
446       len = clean_line (line, len);
447
448       /* Name begins at 39 column of the listing if date presented in `mm-dd-yy'
449          format or at 41 column if date presented in `mm-dd-yyyy' format. Thus,
450          we cannot extract name before we parse date. Using this information we
451          also can recognize filenames that begin with a series of space
452          characters (but who really wants to use such filenames anyway?). */
453       if (len < 40) continue;
454       filename = line + 39;
455
456       /* First column: mm-dd-yy or mm-dd-yyyy. Should atoi() on the month fail,
457          january will be assumed.  */
458       tok = strtok(line, "-");
459       if (tok == NULL) continue;
460       month = atoi(tok) - 1;
461       if (month < 0) month = 0;
462       tok = strtok(NULL, "-");
463       if (tok == NULL) continue;
464       day = atoi(tok);
465       tok = strtok(NULL, " ");
466       if (tok == NULL) continue;
467       year = atoi(tok);
468       /* Assuming the epoch starting at 1.1.1970 */
469       if (year <= 70)
470         {
471           year += 100;
472         }
473       else if (year >= 1900)
474         {
475           year -= 1900;
476           filename += 2;
477         }
478       /* Now it is possible to determine the position of the first symbol in
479          filename. */
480       cur.name = xstrdup(filename);
481       DEBUGP (("Name: '%s'\n", cur.name));
482
483
484       /* Second column: hh:mm[AP]M, listing does not contain value for
485          seconds */
486       tok = strtok(NULL,  ":");
487       if (tok == NULL) continue;
488       hour = atoi(tok);
489       tok = strtok(NULL,  "M");
490       if (tok == NULL) continue;
491       min = atoi(tok);
492       /* Adjust hour from AM/PM. Just for the record, the sequence goes
493          11:00AM, 12:00PM, 01:00PM ... 11:00PM, 12:00AM, 01:00AM . */
494       tok+=2;
495       if (hour == 12)  hour  = 0;
496       if (*tok == 'P') hour += 12;
497
498       DEBUGP (("YYYY/MM/DD HH:MM - %d/%02d/%02d %02d:%02d\n",
499               year+1900, month, day, hour, min));
500
501       /* Build the time-stamp (copy & paste from above) */
502       timestruct.tm_sec   = 0;
503       timestruct.tm_min   = min;
504       timestruct.tm_hour  = hour;
505       timestruct.tm_mday  = day;
506       timestruct.tm_mon   = month;
507       timestruct.tm_year  = year;
508       timestruct.tm_wday  = 0;
509       timestruct.tm_yday  = 0;
510       timestruct.tm_isdst = -1;
511       cur.tstamp = mktime (&timestruct); /* store the time-stamp */
512       cur.ptype = TT_HOUR_MIN;
513
514       DEBUGP (("Timestamp: %ld\n", cur.tstamp));
515
516       /* Third column: Either file length, or <DIR>. We also set the
517          permissions (guessed as 0644 for plain files and 0755 for
518          directories as the listing does not give us a clue) and filetype
519          here. */
520       tok = strtok(NULL, " ");
521       if (tok == NULL) continue;
522       while ((tok != NULL) && (*tok == '\0'))  tok = strtok(NULL, " ");
523       if (tok == NULL) continue;
524       if (*tok == '<')
525         {
526           cur.type  = FT_DIRECTORY;
527           cur.size  = 0;
528           cur.perms = 0755;
529           DEBUGP (("Directory\n"));
530         }
531       else
532         {
533           wgint size;
534           cur.type  = FT_PLAINFILE;
535           errno = 0;
536           size = str_to_wgint (tok, NULL, 10);
537           if (size == WGINT_MAX && errno == ERANGE)
538             cur.size = 0;       /* overflow */
539           else
540             cur.size = size;
541           cur.perms = 0644;
542           DEBUGP (("File, size %s bytes\n", number_to_static_string (cur.size)));
543         }
544
545       cur.linkto = NULL;
546
547       /* And put everything into the linked list */
548       if (!dir)
549         {
550           l = dir = xnew (struct fileinfo);
551           memcpy (l, &cur, sizeof (cur));
552           l->prev = l->next = NULL;
553         }
554       else
555         {
556           cur.prev = l;
557           l->next = xnew (struct fileinfo);
558           l = l->next;
559           memcpy (l, &cur, sizeof (cur));
560           l->next = NULL;
561         }
562     }
563
564   xfree (line);
565   fclose(fp);
566   return dir;
567 }
568
569
570
571 /* Convert the VMS-style directory listing stored in "file" to a
572    linked list of fileinfo (system-independent) entries.  The contents
573    of FILE are considered to be produced by the standard VMS
574    "DIRECTORY [/SIZE [= ALL]] /DATE [/OWNER] [/PROTECTION]" command,
575    more or less.  (Different VMS FTP servers may have different headers,
576    and may not supply the same data, but all should be subsets of this.)
577
578    VMS normally provides local (server) time and date information.
579    Define the logical name or environment variable
580    "WGET_TIMEZONE_DIFFERENTIAL" (seconds) to adjust the receiving local
581    times if different from the remote local times.
582
583    2005-02-23 SMS.
584    Added code to eliminate "^" escape characters from ODS5 extended file
585    names.  The TCPIP FTP server (V5.4) seems to prefer requests which do
586    not use the escaped names which it provides.
587 */
588
589 #define VMS_DEFAULT_PROT_FILE 0644
590 #define VMS_DEFAULT_PROT_DIR 0755
591
592 /* 2005-02-23 SMS.
593    eat_carets().
594
595    Delete ODS5 extended file name escape characters ("^") in the
596    original buffer.
597    Note that the current scheme does not handle all EFN cases, but it
598    could be made more complicated.
599 */
600
601 static void eat_carets( char *str)
602 /* char *str;      Source pointer. */
603 {
604   char *strd;   /* Destination pointer. */
605   char hdgt;
606   unsigned char uchr;
607   unsigned char prop;
608
609   /* Skip ahead to the first "^", if any. */
610   while ((*str != '\0') && (*str != '^'))
611      str++;
612
613   /* If no caret was found, quit early. */
614   if (*str != '\0')
615   {
616     /* Shift characters leftward as carets are found. */
617     strd = str;
618     while (*str != '\0')
619     {
620       uchr = *str;
621       if (uchr == '^')
622       {
623         /* Found a caret.  Skip it, and check the next character. */
624         uchr = *(++str);
625         prop = char_prop[ uchr];
626         if (prop& 64)
627         {
628           /* Hex digit.  Get char code from this and next hex digit. */
629           if (uchr <= '9')
630           {
631             hdgt = uchr- '0';           /* '0' - '9' -> 0 - 9. */
632           }
633           else
634           {
635             hdgt = ((uchr- 'A')& 7)+ 10;    /* [Aa] - [Ff] -> 10 - 15. */
636           }
637           hdgt <<= 4;                   /* X16. */
638           uchr = *(++str);              /* Next char must be hex digit. */
639           if (uchr <= '9')
640           {
641             uchr = hdgt+ uchr- '0';
642           }
643           else
644           {
645             uchr = hdgt+ ((uchr- 'A')& 15)+ 10;
646           }
647         }
648         else if (uchr == '_')
649         {
650           /* Convert escaped "_" to " ". */
651           uchr = ' ';
652         }
653         else if (uchr == '/')
654         {
655           /* Convert escaped "/" (invalid Zip) to "?" (invalid VMS). */
656           /* Note that this is a left-over from Info-ZIP code, and is
657              probably of little value here, except perhaps to avoid
658              directory confusion which an unconverted slash might cause.
659           */
660           uchr = '?';
661         }
662         /* Else, not a hex digit.  Must be a simple escaped character
663            (or Unicode, which is not yet handled here).
664         */
665       }
666       /* Else, not a caret.  Use as-is. */
667       *strd = uchr;
668
669       /* Advance destination and source pointers. */
670       strd++;
671       str++;
672     }
673     /* Terminate the destination string. */
674     *strd = '\0';
675   }
676 }
677
678
679 static struct fileinfo *
680 ftp_parse_vms_ls (const char *file)
681 {
682   FILE *fp;
683   int dt, i, j, len;
684   int perms;
685   size_t bufsize = 0;
686   time_t timenow;
687   struct tm *timestruct;
688   char date_str[ 32];
689
690   char *line = NULL, *tok; /* tokenizer */
691   struct fileinfo *dir, *l, cur; /* list creation */
692
693   fp = fopen (file, "r");
694   if (!fp)
695     {
696       logprintf (LOG_NOTQUIET, "%s: %s\n", file, strerror (errno));
697       return NULL;
698     }
699   dir = l = NULL;
700
701   /* Skip blank lines, Directory heading, and more blank lines. */
702
703   for (j = 0; (i = getline (&line, &bufsize, fp)) > 0; )
704     {
705       i = clean_line (line, i);
706       if (i <= 0)
707         continue; /* Ignore blank line. */
708
709       if ((j == 0) && (line[i - 1] == ']'))
710         {
711           /* Found Directory heading line.  Next non-blank line
712           is significant. */
713           j = 1;
714         }
715       else if (!strncmp (line, "Total of ", 9))
716         {
717           /* Found "Total of ..." footing line.  No valid data
718              will follow (empty directory). */
719           i = 0; /* Arrange for early exit. */
720           break;
721         }
722       else
723         {
724           break; /* Must be significant data. */
725         }
726     }
727
728   /* Read remainder of file until the next blank line or EOF. */
729
730   while (i > 0)
731     {
732       char *p;
733
734       /* The first token is the file name.  After a long name, other
735          data may be on the following line.  A valid directory name ends
736          in ".DIR;1" (any case), although some VMS FTP servers may omit
737          the version number (";1").
738       */
739
740       tok = strtok(line, " ");
741       if (tok == NULL) tok = line;
742       DEBUGP (("file name:   '%s'\n", tok));
743
744       /* Stripping the version number on a VMS system would be wrong.
745          It may be foolish on a non-VMS system, too, but that's someone
746          else's problem.  (Define PRESERVE_VMS_VERSIONS for proper
747          operation on other operating systems.)
748
749          2005-02-23 SMS.
750          ODS5 extended file names may contain escaped semi-colons, so
751          the version number is identified as right-side decimal digits
752          led by a non-escaped semi-colon.  It may be absent.
753       */
754
755 #if (!defined( __VMS) && !defined( PRESERVE_VMS_VERSIONS))
756       for (p = tok + strlen (tok); (--p > tok) && c_isdigit( *p); );
757       if ((*p == ';') && (*(p- 1) != '^'))
758         {
759           *p = '\0';
760         }
761 #endif /* (!defined( __VMS) && !defined( PRESERVE_VMS_VERSIONS)) */
762
763       /* 2005-02-23 SMS.
764          Eliminate "^" escape characters from ODS5 extended file name.
765          (A caret is invalid in an ODS2 name, so this is always safe.)
766       */
767       eat_carets (tok);
768       DEBUGP (("file name-^: '%s'\n", tok));
769
770       /* Differentiate between a directory and any other file.  A VMS
771          listing may not include file protections (permissions).  Set a
772          default permissions value (according to the file type), which
773          may be overwritten later.  Store directory names without the
774          ".DIR;1" file type and version number, as the plain name is
775          what will work in a CWD command.
776       */
777       len = strlen (tok);
778       if (!strncasecmp((tok + (len - 4)), ".DIR", 4))
779         {
780           *(tok+ (len - 4)) = '\0'; /* Discard ".DIR". */
781           cur.type  = FT_DIRECTORY;
782           cur.perms = VMS_DEFAULT_PROT_DIR;
783           DEBUGP (("Directory (nv)\n"));
784         }
785       else if (!strncasecmp ((tok + (len - 6)), ".DIR;1", 6))
786         {
787           *(tok+ (len - 6)) = '\0'; /* Discard ".DIR;1". */
788           cur.type  = FT_DIRECTORY;
789           cur.perms = VMS_DEFAULT_PROT_DIR;
790           DEBUGP (("Directory (v)\n"));
791         }
792       else
793         {
794           cur.type  = FT_PLAINFILE;
795           cur.perms = VMS_DEFAULT_PROT_FILE;
796           DEBUGP (("File\n"));
797         }
798       cur.name = xstrdup (tok);
799       DEBUGP (("Name: '%s'\n", cur.name));
800
801       /* Null the date and time string. */
802       *date_str = '\0';
803
804       /* VMS lacks symbolic links. */
805       cur.linkto = NULL;
806
807       /* VMS reports file sizes in (512-byte) disk blocks, not bytes,
808          hence useless for an integrity check based on byte-count.
809          Set size to unknown.
810       */
811       cur.size = 0;
812
813       /* Get token 2, if any.  A long name may force all other data onto
814          a second line.  If needed, read the second line.
815       */
816
817       tok = strtok (NULL, " ");
818       if (tok == NULL)
819         {
820           DEBUGP (("Getting additional line.\n"));
821           i = getline (&line, &bufsize, fp);
822           if (i <= 0)
823             {
824               DEBUGP (("EOF.  Leaving listing parser.\n"));
825               break;
826             }
827
828           /* Second line must begin with " ".  Otherwise, it's a first
829              line (and we may be confused).
830           */
831           i = clean_line (line, i);
832           if (i <= 0)
833             {
834               /* Blank line.  End of significant file listing. */
835               DEBUGP (("Blank line.  Leaving listing parser.\n"));
836               break;
837             }
838           else if (line[0] != ' ')
839             {
840               DEBUGP (("Non-blank in column 1.  Must be a new file name?\n"));
841               continue;
842             }
843           else
844             {
845               tok = strtok (line, " ");
846               if (tok == NULL)
847                 {
848                   /* Unexpected non-empty but apparently blank line. */
849                   DEBUGP (("Null token.  Leaving listing parser.\n"));
850                   break;
851                 }
852             }
853         }
854
855       /* Analyze tokens.  (Order is not significant, except date must
856          precede time.)
857
858          Size:       ddd or ddd/ddd (where "ddd" is a decimal number)
859          Date:       DD-MMM-YYYY
860          Time:       HH:MM or HH:MM:SS or HH:MM:SS.CC
861          Owner:      [user] or [user,group]
862          Protection: (ppp,ppp,ppp,ppp) (where "ppp" is "RWED" or some
863          subset thereof, for System, Owner, Group, World.
864
865          If permission is lacking, info may be replaced by the string:
866          "No privilege for attempted operation".
867       */
868       while (tok != NULL)
869         {
870           DEBUGP (("Token: >%s<: ", tok));
871
872           if ((strlen (tok) < 12) && (strchr( tok, '-') != NULL))
873             {
874               /* Date. */
875               DEBUGP (("Date.\n"));
876               strcpy( date_str, tok);
877               strcat( date_str, " ");
878             }
879           else if ((strlen (tok) < 12) && (strchr( tok, ':') != NULL))
880             {
881               /* Time. */
882               DEBUGP (("Time. "));
883               strncat( date_str,
884                        tok,
885                        (sizeof( date_str)- strlen (date_str) - 1));
886               DEBUGP (("Date time: >%s<\n", date_str));
887             }
888           else if (strchr (tok, '[') != NULL)
889             {
890               /* Owner.  (Ignore.) */
891               DEBUGP (("Owner.\n"));
892             }
893           else if (strchr (tok, '(') != NULL)
894             {
895               /* Protections (permissions). */
896               perms = 0;
897               j = 0;
898               /*FIXME: Should not be using the variable like this. */
899               for (i = 0; i < (int) strlen(tok); i++)
900                 {
901                   switch (tok[ i])
902                     {
903                     case '(':
904                       break;
905                     case ')':
906                       break;
907                     case ',':
908                       if (j == 0)
909                         {
910                           perms = 0;
911                           j = 1;
912                         }
913                       else
914                         {
915                           perms <<= 3;
916                         }
917                       break;
918                     case 'R':
919                       perms |= 4;
920                       break;
921                     case 'W':
922                       perms |= 2;
923                       break;
924                     case 'E':
925                       perms |= 1;
926                       break;
927                     case 'D':
928                       perms |= 2;
929                       break;
930                     }
931                 }
932               cur.perms = perms;
933               DEBUGP (("Prot.  perms = %0o.\n", cur.perms));
934             }
935           else
936             {
937               /* Nondescript.  Probably size(s), probably in blocks.
938                  Could be "No privilege ..." message.  (Ignore.)
939               */
940               DEBUGP (("Ignored (size?).\n"));
941             }
942
943           tok = strtok (NULL, " ");
944         }
945
946       /* Tokens exhausted.  Interpret the data, and fill in the
947          structure.
948       */
949       /* Fill tm timestruct according to date-time string.  Fractional
950          seconds are ignored.  Default to current time, if conversion
951          fails.
952       */
953       timenow = time( NULL);
954       timestruct = localtime( &timenow );
955       strptime( date_str, "%d-%b-%Y %H:%M:%S", timestruct);
956
957       /* Convert struct tm local time to time_t local time. */
958       timenow = mktime (timestruct);
959       /* Offset local time according to environment variable (seconds). */
960       if ((tok = getenv ( "WGET_TIMEZONE_DIFFERENTIAL")) != NULL)
961         {
962           dt = atoi (tok);
963           DEBUGP (("Time differential = %d.\n", dt));
964         }
965       else
966         dt = 0;
967
968       if (dt >= 0)
969         timenow += dt;
970       else
971         timenow -= (-dt);
972
973       cur.tstamp = timenow; /* Store the time-stamp. */
974       DEBUGP (("Timestamp: %ld\n", cur.tstamp));
975       cur.ptype = TT_HOUR_MIN;
976
977       /* Add the data for this item to the linked list, */
978       if (!dir)
979         {
980           l = dir = (struct fileinfo *)xmalloc (sizeof (struct fileinfo));
981           memcpy (l, &cur, sizeof (cur));
982           l->prev = l->next = NULL;
983         }
984       else
985         {
986           cur.prev = l;
987           l->next = (struct fileinfo *)xmalloc (sizeof (struct fileinfo));
988           l = l->next;
989           memcpy (l, &cur, sizeof (cur));
990           l->next = NULL;
991         }
992
993       i = getline (&line, &bufsize, fp);
994       if (i > 0)
995         {
996           i = clean_line (line, i);
997           if (i <= 0)
998             {
999               /* Blank line.  End of significant file listing. */
1000               break;
1001             }
1002         }
1003     }
1004
1005   xfree (line);
1006   fclose (fp);
1007   return dir;
1008 }
1009
1010
1011 /* This function switches between the correct parsing routine depending on
1012    the SYSTEM_TYPE. The system type should be based on the result of the
1013    "SYST" response of the FTP server. According to this repsonse we will
1014    use on of the three different listing parsers that cover the most of FTP
1015    servers used nowadays.  */
1016
1017 struct fileinfo *
1018 ftp_parse_ls (const char *file, const enum stype system_type)
1019 {
1020   switch (system_type)
1021     {
1022     case ST_UNIX:
1023       return ftp_parse_unix_ls (file, 0);
1024     case ST_WINNT:
1025       {
1026         /* Detect whether the listing is simulating the UNIX format */
1027         FILE *fp;
1028         int   c;
1029         fp = fopen (file, "rb");
1030         if (!fp)
1031         {
1032           logprintf (LOG_NOTQUIET, "%s: %s\n", file, strerror (errno));
1033           return NULL;
1034         }
1035         c = fgetc(fp);
1036         fclose(fp);
1037         /* If the first character of the file is '0'-'9', it's WINNT
1038            format. */
1039         if (c >= '0' && c <='9')
1040           return ftp_parse_winnt_ls (file);
1041         else
1042           return ftp_parse_unix_ls (file, 1);
1043       }
1044     case ST_VMS:
1045       return ftp_parse_vms_ls (file);
1046     case ST_MACOS:
1047       return ftp_parse_unix_ls (file, 1);
1048     default:
1049       logprintf (LOG_NOTQUIET, _("\
1050 Unsupported listing type, trying Unix listing parser.\n"));
1051       return ftp_parse_unix_ls (file, 0);
1052     }
1053 }
1054 \f
1055 /* Stuff for creating FTP index. */
1056
1057 /* The function creates an HTML index containing references to given
1058    directories and files on the appropriate host.  The references are
1059    FTP.  */
1060 uerr_t
1061 ftp_index (const char *file, struct url *u, struct fileinfo *f)
1062 {
1063   FILE *fp;
1064   char *upwd;
1065   char *htcldir;                /* HTML-clean dir name */
1066   char *htclfile;               /* HTML-clean file name */
1067   char *urlclfile;              /* URL-clean file name */
1068
1069   if (!output_stream)
1070     {
1071       fp = fopen (file, "wb");
1072       if (!fp)
1073         {
1074           logprintf (LOG_NOTQUIET, "%s: %s\n", file, strerror (errno));
1075           return FOPENERR;
1076         }
1077     }
1078   else
1079     fp = output_stream;
1080   if (u->user)
1081     {
1082       char *tmpu, *tmpp;        /* temporary, clean user and passwd */
1083
1084       tmpu = url_escape (u->user);
1085       tmpp = u->passwd ? url_escape (u->passwd) : NULL;
1086       if (tmpp)
1087         upwd = concat_strings (tmpu, ":", tmpp, "@", (char *) 0);
1088       else
1089         upwd = concat_strings (tmpu, "@", (char *) 0);
1090       xfree (tmpu);
1091       xfree_null (tmpp);
1092     }
1093   else
1094     upwd = xstrdup ("");
1095
1096   htcldir = html_quote_string (u->dir);
1097
1098   fprintf (fp, "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\n");
1099   fprintf (fp, "<html>\n<head>\n<title>");
1100   fprintf (fp, _("Index of /%s on %s:%d"), htcldir, u->host, u->port);
1101   fprintf (fp, "</title>\n</head>\n<body>\n<h1>");
1102   fprintf (fp, _("Index of /%s on %s:%d"), htcldir, u->host, u->port);
1103   fprintf (fp, "</h1>\n<hr>\n<pre>\n");
1104
1105   while (f)
1106     {
1107       fprintf (fp, "  ");
1108       if (f->tstamp != -1)
1109         {
1110           /* #### Should we translate the months?  Or, even better, use
1111              ISO 8601 dates?  */
1112           static const char *months[] = {
1113             "Jan", "Feb", "Mar", "Apr", "May", "Jun",
1114             "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
1115           };
1116           time_t tstamp = f->tstamp;
1117           struct tm *ptm = localtime (&tstamp);
1118
1119           fprintf (fp, "%d %s %02d ", ptm->tm_year + 1900, months[ptm->tm_mon],
1120                   ptm->tm_mday);
1121           if (f->ptype == TT_HOUR_MIN)
1122             fprintf (fp, "%02d:%02d  ", ptm->tm_hour, ptm->tm_min);
1123           else
1124             fprintf (fp, "       ");
1125         }
1126       else
1127         fprintf (fp, _("time unknown       "));
1128       switch (f->type)
1129         {
1130         case FT_PLAINFILE:
1131           fprintf (fp, _("File        "));
1132           break;
1133         case FT_DIRECTORY:
1134           fprintf (fp, _("Directory   "));
1135           break;
1136         case FT_SYMLINK:
1137           fprintf (fp, _("Link        "));
1138           break;
1139         default:
1140           fprintf (fp, _("Not sure    "));
1141           break;
1142         }
1143       htclfile = html_quote_string (f->name);
1144       urlclfile = url_escape_unsafe_and_reserved (f->name);
1145       fprintf (fp, "<a href=\"ftp://%s%s:%d", upwd, u->host, u->port);
1146       if (*u->dir != '/')
1147         putc ('/', fp);
1148       /* XXX: Should probably URL-escape dir components here, rather
1149        * than just HTML-escape, for consistency with the next bit where
1150        * we use urlclfile for the file component. Anyway, this is safer
1151        * than what we had... */
1152       fprintf (fp, "%s", htcldir);
1153       if (*u->dir)
1154         putc ('/', fp);
1155       fprintf (fp, "%s", urlclfile);
1156       if (f->type == FT_DIRECTORY)
1157         putc ('/', fp);
1158       fprintf (fp, "\">%s", htclfile);
1159       if (f->type == FT_DIRECTORY)
1160         putc ('/', fp);
1161       fprintf (fp, "</a> ");
1162       if (f->type == FT_PLAINFILE)
1163         fprintf (fp, _(" (%s bytes)"), number_to_static_string (f->size));
1164       else if (f->type == FT_SYMLINK)
1165         fprintf (fp, "-> %s", f->linkto ? f->linkto : "(nil)");
1166       putc ('\n', fp);
1167       xfree (htclfile);
1168       xfree (urlclfile);
1169       f = f->next;
1170     }
1171   fprintf (fp, "</pre>\n</body>\n</html>\n");
1172   xfree (htcldir);
1173   xfree (upwd);
1174   if (!output_stream)
1175     fclose (fp);
1176   else
1177     fflush (fp);
1178   return FTPOK;
1179 }