/*
 * $Source: /afs/dev.mit.edu/source/repository/athena/bin/delete/delete.c,v $
 * $Author: jik $
 *
 * This program is a replacement for rm.  Instead of actually deleting
 * files, it marks them for deletion by prefixing them with a ".#"
 * prefix.
 *
 * Copyright (c) 1989 by the Massachusetts Institute of Technology.
 * For copying and distribution information, see the file "mit-copyright.h."
 */

#if (!defined(lint) && !defined(SABER))
     static char rcsid_delete_c[] = "$Header: /afs/dev.mit.edu/source/repository/athena/bin/delete/delete.c,v 1.17 1989-03-27 12:05:58 jik Exp $";
#endif

#include <sys/types.h>
#include <stdio.h>
#include <sys/stat.h>
#include <sys/dir.h>
#include <strings.h>
#include <sys/param.h>
#include <sys/file.h>
#include "util.h"
#include "delete.h"
#include "mit-copyright.h"




/*
 * ALGORITHM:
 *
 * 1. Parse command-line arguments and set flags.
 * 2. Call the function delete() for each filename command-line argument.
 *
 * delete():
 *
 * 1. Can the file be lstat'd?
 *    no -- abort
 *    yes -- continue
 * 2. Is the file a directory?
 *    yes -- is it a dotfile?
 *           yes -- abort
 *           no -- continue
 *        -- is the filesonly option set?
 *           yes -- is the recursive option specified?
 *                  yes -- continue
 *                  no -- abort
 *           no -- is the directory empty?
 *                  yes -- remove it
 *                  no -- is the directoriesonly option set?
 * 			  yes -- abort
 * 			  no -- continue
 * 		       -- is the recursive option specified?
 * 			  yes -- continue
 * 			  no -- abort
 *    no -- is the directoriesonly option set?
 * 	    yes -- abort
 * 	    no -- continue
 * 3. If the file is a file, remove it.
 * 4. If the file is a directory, open it and pass each of its members
 *    (excluding . files) to delete().
 */


int force, interactive, recursive, noop, verbose, filesonly, directoriesonly;
char *whoami;
char *malloc();

main(argc, argv)
int argc;
char *argv[];
{
     extern char *optarg;
     extern int optind;
     int arg;
     int status = 0;
     
     whoami = lastpart(argv[0]);

     force = interactive = recursive = noop = verbose = filesonly =
	  directoriesonly = 0;
     while ((arg = getopt(argc, argv, "firnvFD")) != -1) {
	  switch (arg) {
	  case 'r':
	       recursive++;
	       if (directoriesonly) {
		    fprintf(stderr, "%s: -r and -D are mutually exclusive.\n",
			    whoami);
		    usage();
		    exit(! force);
	       }
	       break;
	  case 'f':
	       force++;
	       break;
	  case 'i':
	       interactive++;
	       break;
	  case 'n':
	       noop++;
	       break;
	  case 'v':
	       verbose++;
	       break;
	  case 'F':
	       filesonly++;
	       if (directoriesonly) {
		    fprintf(stderr, "%s: -F and -D are mutually exclusive.\n",
			    whoami);
		    usage();
		    exit(! force);
	       }
	       break;
	  case 'D':
	       directoriesonly++;
	       if (recursive) {
		    fprintf(stderr, "%s: -r and -D are mutually exclusive.\n",
			    whoami);
		    usage();
		    exit(! force);
	       }
	       if (filesonly) {
		    fprintf(stderr, "%s: -F and -D are mutually exclusive.\n",
			    whoami);
		    usage();
		    exit(! force);
	       }
	       break;
	  default:
	       usage();
	       exit(! force);
	  }
     }
     if (optind == argc) {
	  fprintf(stderr, "%s: no files specified.\n", whoami);
	  usage();
	  exit(! force);
     }
     while (optind < argc) {
	  status = status | delete(argv[optind], 0);
	  optind++;
     }
     exit((! force) && (status & ERROR_MASK));
}




usage()
{
     printf("Usage: %s [ options ] filename ...\n", whoami);
     printf("Options are:\n");
     printf("     -r     recursive\n");
     printf("     -i     interactive\n");
     printf("     -f     force\n");
     printf("     -n     noop\n");
     printf("     -v     verbose\n");
     printf("     -F     files only\n");
     printf("     -D     directories only\n");
     printf("     --     end options and start filenames\n");
     printf("-r and -D are mutually exclusive\n");
     printf("-F and -D are mutually exclusive\n");
}






delete(filename, recursed)
char *filename;
int recursed;
{
     struct stat stat_buf;

     /* can the file be lstat'd? */
     if (lstat(filename, &stat_buf) == -1) {
	  if (! force)
	       fprintf(stderr, "%s: %s nonexistent\n", whoami, filename);
	  return(ERROR_MASK);
     }
     
     /* is the file a directory? */
     if ((stat_buf.st_mode & S_IFMT) == S_IFDIR) {
	  /* is the file a dot file? */
	  if (is_dotfile(filename)) {
	       if (! force)
		    fprintf(stderr, "%s: cannot remove `.' or `..'\n",
			    whoami);
	       return(ERROR_MASK);
	  }
	  /* is the filesonly option set? */
	  if (filesonly) {
	       /* is the recursive option specified? */
	       if (recursive) {
		    return(recursive_delete(filename, stat_buf, recursed));
	       }
	       else {
		    if (! force)
			 fprintf(stderr, "%s: %s directory\n", whoami,
				 filename);
		    return(ERROR_MASK);
	       }
	  }
	  else {
	       /* is the directory empty? */
	       if (empty_directory(filename)) {
		    /* remove it */
		    return(do_move(filename, stat_buf, 0));
	       }
	       else {
		    /* is the directoriesonly option set? */
		    if (directoriesonly) {
			 if (! force)
			      fprintf(stderr, "%s: %s: Directory not empty\n",
				     whoami, filename);
			 return(ERROR_MASK);
		    }
		    else {
			 /* is the recursive option specified? */
			 if (recursive) {
			      return(recursive_delete(filename, stat_buf,
						      recursed));
			 }
			 else {
			      if (! force)
				   fprintf(stderr, "%s: %s not empty\n",
					   whoami, filename);
			      return(ERROR_MASK);
			 }
		    }
	       }
	  }
     }
     else {
	  /* is the directoriesonly option set? */
	  if (directoriesonly) {
	       if (! force)
		    fprintf(stderr, "%s: %s: Not a directory\n", whoami,
			    filename);
	       return(ERROR_MASK);
	  }
	  else
	       return(do_move(filename, stat_buf, 0));
     }
}

		 
			 
	       
empty_directory(filename)
char *filename;
{
     DIR *dirp;
     struct direct *dp;

     dirp = opendir(filename);
     if (! dirp) {
	  return(0);
     }
     for (dp = readdir(dirp); dp != NULL; dp = readdir(dirp)) {
	  if (is_dotfile(dp->d_name))
	       continue;
	  if (is_deleted(dp->d_name))
	       continue;
	  else {
	       closedir(dirp);
	       return(0);
	  }
     }
     closedir(dirp);
     return(1);
}




recursive_delete(filename, stat_buf, recursed)
char *filename;
struct stat stat_buf;
int recursed;
{
     DIR *dirp;
     struct direct *dp;
     int status = 0;
     char newfile[MAXPATHLEN];
     
     if (interactive && recursed) {
	  printf("%s: remove directory %s? ", whoami, filename);
	  if (! yes())
	       return(NO_DELETE_MASK);
     }
     dirp = opendir(filename);
     if (! dirp) {
	  if (! force)
	       fprintf(stderr, "%s: %s not changed\n", whoami, filename);
	  return(ERROR_MASK);
     }
     for (dp = readdir(dirp); dp != NULL; dp = readdir(dirp)) {
	  if (is_dotfile(dp->d_name))
	       continue;
	  if (is_deleted(dp->d_name))
	       continue;
	  else {
	       strcpy(newfile, append(filename, dp->d_name, !force));
	       if (*newfile)
		    status = status | delete(newfile, 1);
	       else
		    status = ERROR_MASK;
	  }
     }
     closedir(dirp);
     status = status | do_move(filename, stat_buf, status);
     return(status);
}

					 




do_move(filename, stat_buf, err_mask)
char *filename;
struct stat stat_buf;
int err_mask;
{
     char *last;
     char buf[MAXPATHLEN];
     char name[MAXNAMLEN];
     struct stat deleted_buf;

     strncpy(buf, filename, MAXPATHLEN);
     last = lastpart(buf);
     if (strlen(last) > MAXNAMLEN) {
	  if (! force)
	       fprintf(stderr, "%s: %s: filename too long\n", whoami,
		       filename);
	  return(ERROR_MASK);
     }
     strcpy(name, last);
     if (strlen(buf) + 3 > MAXPATHLEN) {
	  if (! force)
	       fprintf(stderr, "%s: %s: pathname too long\n", whoami,
		       filename);
	  return(ERROR_MASK);
     }
     *last = '\0';
     strcat(buf, ".#");
     strcat(buf, name);
     if (err_mask) {
	  if (! force)
	       fprintf(stderr, "%s: %s not removed\n", whoami, filename);
	  return(err_mask);
     }
     if (interactive) {
	  printf("%s: remove %s? ", whoami, filename);
	  if (! yes())
	       return(NO_DELETE_MASK);
     }
     else if ((! force) && ((stat_buf.st_mode & S_IFMT) != S_IFLNK)
	      && access(filename, W_OK)) {
	  printf("%s: override protection %o for %s? ", whoami,
		 stat_buf.st_mode & 0777, filename);
	  if (! yes())
	       return(NO_DELETE_MASK);
     }
     if (noop) {
	  fprintf(stderr, "%s: %s would be removed\n", whoami, filename);
	  return(0);
     }
     if (! lstat(buf, &deleted_buf))
	  unlink_completely(buf);
     if (rename(filename, buf)) {
	  if (! force)
	       fprintf(stderr, "%s: %s not removed\n", whoami, filename);
	  return(ERROR_MASK);
     }
     else {
	  if (verbose)
	       fprintf(stderr, "%s: %s removed\n", whoami, filename);
	  return(0);
     }
}



unlink_completely(filename)
char *filename;
{
     char buf[MAXPATHLEN];
     struct stat stat_buf;
     DIR *dirp;
     struct direct *dp;
     int status = 0;
     
     if (lstat(filename, &stat_buf))
	  return(1);

     if ((stat_buf.st_mode & S_IFMT) == S_IFDIR) {
	  dirp = opendir(filename);
	  if (! dirp)
	       return(1);
	  readdir(dirp); readdir(dirp); /* get rid of . and .. */
	  for (dp = readdir(dirp); dp != NULL; dp = readdir(dirp)) {
	       strcpy(buf, append(filename, dp->d_name, 0));
	       if (! buf) {
		    status = 1;
		    continue;
	       }
	       status = status | unlink_completely(buf);
	  }
	  closedir(dirp);
	  status = status | rmdir(filename);
	  return(status);
     }
     else
	  return(unlink(filename) == -1);
}