/*
 * doschk - check filenames for DOS (and SYSV) compatibility
 *
 * Copyright (C) 1993 DJ Delorie
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to: The Free Software Foundation,
 * Inc.; 675 Mass Ave. Cambridge, MA 02139, USA.
 *
 * This program is intended as a utility to help software developers
 * ensure that their source file names are distinguishable on MS-DOS and
 * 14-character SYSV platforms.  To perform this task, doschk reads a
 * list of filenames and produces a report of all the conflicts that
 * would arise if the files were transferred to a MS-DOS or SYSV
 * platform.  It also reports any file names that would conflict with
 * MS-DOS device names.
 *
 * To use this program, you must feed it a list of filenames in this
 * format:
 *
 *         dir
 *         dir/file1.ext
 *         dir/file2.exe
 *         dir/dir2
 *         dir/dir2/file3.ext
 *
 * If the list does not include the directory-only lines (like dir/dir2)
 * then their names will not be checked for uniqueness, else they will
 * be.  Typical uses of this program are like these:
 *
 *         find . -print | doschk
 *         tar tf file.tar | doschk
 *
 * If this program produces no output, then all your files are MS-DOS
 * compatible.  Any output messages are designed to be self-explanatory
 * and indicate cases where the files will not transfer to MS-DOS without
 * problems.
 *
 */

#include <stdio.h>
#include <ctype.h>
#include <string.h>

extern char *malloc ();

typedef struct ENT
{
  struct ENT *next;
  char *dos_name;
  char *full_name;
  char *path;
  int tagged;
} ENT;

/* 
 * List of filenames in MSDOG that are special devices. 
 * Not all of these are problems on all MSLOSS systems, but most would not
 * work on most of them.
 */
static char *dos_special_names[] = 
{
  "NUL", 
  "CON", 
  "PRN", 
  "AUX", 
  "COM1", 
  "COM2", 
  "COM3",
  "COM4",
  "LPT1",
  "LPT2",
  "LPT3",
  "MS$MOUSE",
  "EMMXXXX0",
  "XMSXXXX0",
  "SMARTAAR",
  "SETVERXX",
  NULL
} ;

ENT *eroot = 0;

int first_inv = 1;
int first_msg = 1;

/****************************************************************\
 *  Utility routines						*
\****************************************************************/

void
invalid_msg ()
{
  if (first_inv)
    {
      if (first_msg)
	first_msg = 0;
      else
	putchar ('\n');
      printf ("The following files are not valid DOS file names:\n");
      first_inv = 0;
    }
}

char *
xmalloc (size)
     int size;
{
  char *s;

  if (size == 0) 
    return NULL; 

  s = (char *) malloc (size);

  if (s == NULL)
    {
      fprintf (stderr, "Virtual memory exhausted.\n");
      exit (1);
    }

  return s;
}

ENT *
alloc_ent ()
{
  ENT *rv = (ENT *) xmalloc (sizeof (ENT));
  memset (rv, 0, sizeof (ENT));
  return rv;
}

void
fill_ent (ent, path)
     ENT *ent;
     char *path;
{
  char *first = path;
  char *null = path + strlen (path);
  char *last_slash = strrchr (path, '/');
  char *cp, *dp;
  int dots_seen, chars_seen;

  if (last_slash + 1 == null)
    {
      *--null = '\0';
      last_slash = strrchr (path, '/');
    }

  if (!last_slash)
    {
      last_slash = first - 1;
    }

  if (null - last_slash < 13)
    ent->dos_name = (char *) xmalloc (null - last_slash);
  else
    ent->dos_name = (char *) xmalloc (13);
  ent->full_name = (char *) xmalloc (null - last_slash);
  ent->path = (char *) xmalloc (last_slash - first + 1);

  strcpy (ent->full_name, last_slash + 1);
  if (last_slash > first)
    {
      strncpy (ent->path, first, last_slash - first);
      ent->path[last_slash - first] = '\0';
    }
  else
    ent->path = "\0";

  cp = last_slash + 1;
  dp = ent->dos_name;
  dots_seen = 0;
  chars_seen = 0;
  while (1)
    {
      if (!*cp)
	break;
      switch (*cp)
	{
	case '.':
	  if (cp == last_slash + 1 && strcmp (last_slash + 1, "."))
	    {
	      invalid_msg ();
	      printf ("%s - file name cannot start with dot\n", path);
	      *dp = 0;
	      break;
	    }
	  if (dots_seen == 1)
	    {
              /* If trailing dot, it will be ignored by MSDOG, so don't */
              /* actually complain. */
              if (*(cp + 1) != NULL)
                {
                  invalid_msg ();
                  printf ("%s - too many dots\n", path);
                }
	      *dp = '\0';
	      break;
	    }
	  *dp++ = '.';
	  chars_seen = 0;
	  dots_seen++;
	  break;
	case '"':
	case '*':
	case '+':
	case ',':
	case ';':
	case '<':
	case '=':
	case '>':
	case '?':
	case '[':
	case '\\':
	case ']':
	case '|':
        case ':':
	  invalid_msg ();
	  printf ("%s - invalid character `%c'\n", path, *cp);
	  *dp++ = '?';
	  chars_seen++;
	  break;
	default:
	  if (dots_seen)
	    {
	      if (chars_seen >= 3)
		break;
	    }
	  else if (chars_seen >= 8)
	    break;
	  if ((*cp <= ' ') || (*cp >= 0x7f))
	    {
	      invalid_msg ();
	      printf ("%s - invalid character `%c'\n", path, *cp);
	      *dp++ = '?';
	      chars_seen++;
	      break;
	    }
	  if (islower (*cp))
	    *dp++ = toupper (*cp);
	  else
	    *dp++ = *cp;
	  chars_seen++;
	  break;
	}
      cp++;
    }
  *dp++ = '\0';
}

int
compare_ent_dosname (e1, e2)
     ENT **e1;
     ENT **e2;
{
  int r = strcmp ((*e1)->dos_name, (*e2)->dos_name);
  if (r == 0)
    r = strcmp ((*e1)->path, (*e2)->path);
  if (r == 0)
    r = strcmp ((*e1)->full_name, (*e2)->full_name);
  return r;
}

int
compare_ent_fullname (e1, e2)
     ENT **e1;
     ENT **e2;
{
  int r = strncmp ((*e1)->full_name, (*e2)->full_name, 14);
  if (r == 0)
    r = strcmp ((*e1)->path, (*e2)->path);
  if (r == 0)
    r = strcmp ((*e1)->full_name, (*e2)->full_name);
  return r;
}

char *
mpath (ent)
     ENT *ent;
{
  static char buf[1024];  /* fixed sizes for buffers are bad! */
  if (ent->path && ent->path[0])
    sprintf (buf, "%s/%s", ent->path, ent->full_name);
  else
    return ent->full_name;
  return buf;
}

/****************************************************************\
 *  List handling routines					*
\****************************************************************/

void
add_ent (ent)
     ENT *ent;
{
  ent->next = eroot;
  eroot = ent;
}

void
handle_input (line)
     char *line;
{
  ENT *ent = alloc_ent ();
  fill_ent (ent, line);
  add_ent (ent);
}

void
display_problems ()
{
  ENT **elist, *ent;
  int ecount, i, first, first_err;
  char **dos_dev_name;

  for (ecount = 0, ent = eroot; ent; ent = ent->next, ecount++);
  elist = (ENT **) xmalloc (sizeof (ENT *) * ecount);
  for (ecount = 0, ent = eroot; ent; ent = ent->next, ecount++)
    elist[ecount] = ent;

  qsort (elist, ecount, sizeof (ENT *), compare_ent_dosname);

  first_err = 1;
  for (i = 0; i < ecount; i++)
    {
      int elist_len = strlen (elist[i]->dos_name);

      dos_dev_name = dos_special_names; 
      while (*dos_dev_name)
        {
          if ((strcmp (elist[i]->dos_name, *dos_dev_name) == 0)
              || ((*(elist[i]->dos_name + elist_len - 1) == '.')
                  && (strncmp (elist[i]->dos_name, *dos_dev_name, elist_len - 2) == 0)))
            {
              if (first_err)
                {
                  if (first_msg)
                    first_msg = 0;
                  else
                    putchar ('\n');
                  printf ("The following resolve to special DOS device names:\n");
                  first_err = 0;
                }
              printf ("%-14s : %s\n", elist[i]->dos_name, mpath (elist[i]));
              break;
            }
          dos_dev_name++;
        }
    }
  
  first = 1;
  first_err = 1;
  for (i = 0; i < ecount - 1; i++)
    {
      int elist1_len = strlen (elist[i + 1]->dos_name);

      if (((strcmp (elist[i]->dos_name, elist[i + 1]->dos_name) == 0)
           && (strcmp (elist[i]->path, elist[i + 1]->path) == 0))
          || ((*(elist[i + 1]->dos_name + elist1_len - 1) == '.')
              && (strncmp (elist[i]->dos_name, elist[i + 1]->dos_name, elist1_len - 2) == 0)))
	{
	  if (first_err)
	    {
	      if (first_msg)
		first_msg = 0;
	      else
		putchar ('\n');
	      printf ("The following resolve to the same DOS file names:\n");
	      first_err = 0;
	    }
	  if (first)
	    {
	      printf ("%-14s : %s\n", elist[i]->dos_name, mpath (elist[i]));
	      first = 0;
	    }
	  printf ("\t\t %s\n", mpath (elist[i + 1]));
	}
      else
	first = 1;
    }

  qsort (elist, ecount, sizeof (ENT *), compare_ent_fullname);

  first = 1;
  first_err = 1;
  for (i = 0; i < ecount - 1; i++)
    {
      if ((strncmp (elist[i]->full_name, elist[i + 1]->full_name, 14) == 0) &&
	  (strcmp (elist[i]->path, elist[i + 1]->path) == 0))
	{
	  if (first_err)
	    {
	      if (first_msg)
		first_msg = 0;
	      else
		putchar ('\n');
	      printf ("The following resolve to the same SysV file names:\n");
	      first_err = 0;
	    }
	  if (first)
	    {
	      printf ("%.14s : %s\n", elist[i]->full_name, mpath (elist[i]));
	      first = 0;
	      elist[i]->tagged = 1;
	    }
	  printf ("\t\t %s\n", mpath (elist[i + 1]));
	  elist[i + 1]->tagged = 1;
	}
      else
	first = 1;
    }

  first_err = 1;
  for (i = 0; i < ecount; i++)
    {
      if ((strlen (elist[i]->full_name) > 14) && !elist[i]->tagged)
	{
	  if (first_err)
	    {
	      if (first_msg)
		first_msg = 0;
	      else
		putchar ('\n');
	      printf ("The following file names are too long for SysV:\n");
	      first_err = 0;
	    }
	  printf ("%.14s : %s\n", elist[i]->full_name, mpath (elist[i]));
	}
    }
}

/****************************************************************\
 *  Main entry point						*
\****************************************************************/

main (argc, argv)
     int argc;
     char **argv;
{
  FILE *input = stdin;
  if (argc > 1)
    {
      input = fopen (argv[1], "r");
      if (!input)
	{
	  perror (argv[1]);
	  exit (1);
	}
    }
  while (1)
    {
      char line[500];
      char *lp;
      fgets (line, 500, input);
      if (feof (input))
	break;
      lp = line + strlen (line);
      while ((lp != line) && (*lp <= ' '))
	lp--;
      lp[1] = 0;
      handle_input (line);
    }
  display_problems ();
  return 0;
}

/* End of file */