source: trunk/athena/bin/delete/pattern.c @ 2081

/*
 * $Source: /afs/dev.mit.edu/source/repository/athena/bin/delete/pattern.c,v $
 * $Author: jik $
 *
 * This program is part of a package including delete, undelete,
 * lsdel, expunge and purge.  The software suite is meant as a
 * replacement for rm which allows for file recovery.
 * 
 * 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_pattern_c[] = "$Header: /afs/dev.mit.edu/source/repository/athena/bin/delete/pattern.c,v 1.10 1989-09-03 17:49:10 jik Exp $";
#endif

#include <stdio.h>
#include <sys/types.h>
#include <sys/dir.h>
#include <sys/param.h>
#include <strings.h>
#include <sys/stat.h>
#include "directories.h"
#include "pattern.h"
#include "util.h"
#include "undelete.h"
#include "mit-copyright.h"

static char *add_char();

extern char *malloc(), *realloc();

extern char *whoami, *error_buf;

/*
 * parse_pattern returns an area of memory allocated by malloc when it
 * is successful.  Therefore, other procedures calling parse_pattern
 * should use free() to free the region of memory when they are done
 * with it.
 */
char *parse_pattern(file_pattern)
char *file_pattern;
{
     char *re_pattern, *cur_ptr, *re_ptr;
     int guess_length;
     
     guess_length = strlen(file_pattern) + 5;
     re_ptr = re_pattern = malloc(guess_length);
     if (! re_ptr) {
          perror(sprintf(error_buf, "%s: parse_pattern", whoami));
          exit(1);
     }
     
     for (cur_ptr = file_pattern, re_ptr = re_pattern; *cur_ptr != NULL;
          cur_ptr++) {
          if (*cur_ptr == '\\') {
               if (! cur_ptr[1]) {
                    fprintf(stderr,
                            "%s: parse_pattern: incomplete expression\n",
                            whoami);
                    return((char *) NULL);
               }
               if (! add_char(&re_pattern, &re_ptr, &guess_length, '\\'))
                    return ((char *) NULL);
               cur_ptr++;
               if (! add_char(&re_pattern, &re_ptr, &guess_length, *cur_ptr))
                    return ((char *) NULL);
               continue;
          }
          else if (*cur_ptr == '*') {
               if (! add_char(&re_pattern, &re_ptr, &guess_length, '.'))
                    return ((char *) NULL);
               if (! add_char(&re_pattern, &re_ptr, &guess_length, '*'))
                    return ((char *) NULL);
               continue;
          }
          else if (*cur_ptr == '?') {
               if (! add_char(&re_pattern, &re_ptr, &guess_length, '.'))
                    return ((char *) NULL);
               continue;
          }
          else if (*cur_ptr == '.') {
               if (! add_char(&re_pattern, &re_ptr, &guess_length, '\\'))
                    return ((char *) NULL);
               if (! add_char(&re_pattern, &re_ptr, &guess_length, '.'))
                    return ((char *) NULL);
          }
          else {
               if (! add_char(&re_pattern, &re_ptr, &guess_length, *cur_ptr))
                    return ((char *) NULL);
          }
     }
     if (! add_char(&re_pattern, &re_ptr, &guess_length, '\0'))
          return ((char *) NULL);
     return (re_pattern);
}






/*
 * add_char() takes two char **, a length which is the current amount
 * of space implemented for the string pointed to by the first *(char **),
 * and a character to add to the string.  It reallocs extra space if
 * necessary, adds the character, and messes with the pointers if necessary.
 */
static char *add_char(start, finish, length, chr)
char **start, **finish;
int *length;
char chr;
{
     if (*finish - *start == *length) {
          *start = realloc(*start, *length + 5);
          if (! *start) {
               perror(sprintf(error_buf, "%s: add_char", whoami));
               exit(1);
          }
          *finish = *start + *length - 1;
          *length += 5;
     }
     **finish = chr;
     (*finish)++;
     return(*start);
}

          




/*
 * add_arrays() takes pointers to two arrays of char **'s and their
 * lengths, merges the two into the first by realloc'ing the first and
 * then free's the second's memory usage.
 */  
add_arrays(array1, num1, array2, num2)
char ***array1, ***array2;
int *num1, *num2;
{
     int counter;
     
     *array1 = (char **) realloc(*array1, sizeof(char *) * (*num1 + *num2));
     if (! *array1) {
          perror(sprintf(error_buf, "%s: add_arrays", whoami));
          exit(1);
     }
     for (counter = *num1; counter < *num1 + *num2; counter++)
          *(*array1 + counter) = *(*array2 + counter - *num1);
     free (*array2);
     *num1 += *num2;
     return(0);
}







char **add_str(strs, num, str)
char **strs;
int num;
char *str;
{
     strs = (char **) realloc(strs, sizeof(char *) * (num + 1));
     if (! strs) {
          perror(sprintf(error_buf, "%s: add_str", whoami));
          exit(1);
     }
     strs[num] = malloc(strlen(str) + 1);
     if (! strs[num]) {
          perror(sprintf(error_buf, "%s: add_str", whoami));
          exit(1);
     }
     strcpy(strs[num], str);
     return(strs);
}







char **find_deleted_matches(base, expression, num_found)
char *base, *expression;
int *num_found;
{
     struct direct *dp;
     DIR *dirp;
     char **found;
     int num;
     char **next;
     int num_next;
     char first[MAXNAMLEN], rest[MAXPATHLEN];
     char new[MAXPATHLEN];

#ifdef DEBUG
     printf("Looking for %s in %s\n", expression, base);
#endif
     found = (char **) malloc(0);
     *num_found = num = 0;

     dirp = opendir(base);
     if (! dirp)
          return(found);

     strcpy(first, reg_firstpart(expression, rest));
     re_comp(first);

     for (dp = readdir(dirp); dp != NULL; dp = readdir(dirp)) {
          if (re_exec(dp->d_name) && *rest) {
               strcpy(new, append(base, dp->d_name));
               next = find_deleted_matches(new, rest, &num_next);
               add_arrays(&found, &num, &next, &num_next);
          }
          else if (is_deleted(dp->d_name)) if (re_exec(&dp->d_name[2])) {
               if (*rest) {
                    strcpy(new, append(base, dp->d_name));
                    next = find_deleted_matches(new, rest, &num_next);
                    add_arrays(&found, &num, &next, &num_next);
               }
               else {
                    found = add_str(found, num, append(base, dp->d_name));
                    num++;
               }
          }
     }
     closedir(dirp);
     *num_found = num;
     return(found);
}





char **find_matches(base, expression, num_found)
char *base, *expression;
int *num_found;
{
     struct direct *dp;
     DIR *dirp;
     char **found;
     int num;
     char **next;
     int num_next;
     char first[MAXNAMLEN], rest[MAXPATHLEN];
     char new[MAXPATHLEN];
     
#ifdef DEBUG
     printf("Looking for %s in %s\n", expression, base);
#endif
     found = (char **) malloc(0);
     *num_found = num = 0;

     dirp = opendir(base);
     if (! dirp)
          return(found);

     strcpy(first, reg_firstpart(expression, rest));

     for (dp = readdir(dirp); dp != NULL; dp = readdir(dirp)) {
          re_comp(first);
          if (re_exec(dp->d_name)) {
               if (*rest) {
                    strcpy(new, append(base, dp->d_name));
                    next = find_matches(new, rest, &num_next);
                    add_arrays(&found, &num, &next, &num_next);
               }
               else {
                    found = add_str(found, num, append(base, dp->d_name));
                    num++;
               }
          }
          else if (is_deleted(dp->d_name)) if (re_exec(&dp->d_name[2])) {
               if (*rest) {
                    strcpy(new, append(base, dp->d_name));
                    next = find_matches(new, rest, &num_next);
                    add_arrays(&found, &num, &next, &num_next);
               }
               else {
                    found = add_str(found, num, append(base, dp->d_name));
                    num++;
               }
          }
     }
     closedir(dirp);
     *num_found = num;
     return(found);
}







char **find_recurses(base, num_found)
char *base;
int *num_found;
{
     DIR *dirp;
     struct direct *dp;
     char newname[MAXPATHLEN];
     char **found, **new_found;
     int found_num, new_found_num;
     struct stat stat_buf;
     
#ifdef DEBUG
     printf("Looking for subs of %s\n", base);
#endif
     found = (char **) malloc(0);
     *num_found = found_num = 0;
     
     dirp = opendir(base);
     if (! dirp)
          return(found);

     for (dp = readdir(dirp); dp != NULL; dp = readdir(dirp)) {
          if (is_dotfile(dp->d_name))
               continue;
          strcpy(newname, append(base, dp->d_name));
          found = add_str(found, found_num, newname);
          found_num++;
          if (lstat(newname, &stat_buf))
               continue;
          if ((stat_buf.st_mode & S_IFMT) == S_IFDIR) {
               new_found = find_recurses(newname, &new_found_num);
               add_arrays(&found, &found_num, &new_found, &new_found_num);
          }
     }
     closedir(dirp);
     *num_found = found_num;
     return(found);
}






char **find_deleted_recurses(base, num_found)
char *base;
int *num_found;
{
     DIR *dirp;
     struct direct *dp;
     char newname[MAXPATHLEN];
     char **found, **new_found;
     int found_num, new_found_num;
     struct stat stat_buf;
     
     found = (char **) malloc(0);
     *num_found = found_num = 0;
     
     dirp = opendir(base);
     if (! dirp)
          return(found);

     for (dp = readdir(dirp); dp != NULL; dp = readdir(dirp)) {
          if (is_dotfile(dp->d_name))
               continue;

          strcpy(newname, append(base, dp->d_name));
          
          if (is_deleted(dp->d_name)) {
               found = add_str(found, found_num, newname);
               found_num++;
          }
          if (lstat(newname, &stat_buf)) {
               continue;
          }
          if ((stat_buf.st_mode & S_IFMT) == S_IFDIR) {
               new_found = find_deleted_recurses(newname, &new_found_num);
               add_arrays(&found, &found_num, &new_found, &new_found_num);
          }
     }
     closedir(dirp);
     *num_found = found_num;
     return(found);
}






char **find_contents(base, num_found)
char *base;
int *num_found;
{
     DIR *dirp;
     struct direct *dp;
     char **found;
     int num;

#ifdef DEBUG
     printf("Looking for contents of %s\n", base);
#endif
     found = (char **) malloc(0);
     *num_found = num = 0;
   
     dirp = opendir(base);
     if (! dirp)
          return(found);

     for (dp = readdir(dirp); dp != NULL; dp = readdir(dirp)) {
          if (is_dotfile(dp->d_name))
               continue;
          found = add_str(found, num, append(base, dp->d_name));
          num += 1;
     }
     closedir(dirp);
     *num_found = num;
     return(found);
}


     
char **find_deleted_contents(base, num_found)
char *base;
int *num_found;
{
     DIR *dirp;
     struct direct *dp;
     char **found;
     int num;

#ifdef DEBUG
     printf("Looking for deleted contents of %s\n", base);
#endif
     found = (char **) malloc(0);
     *num_found = num = 0;
   
     dirp = opendir(base);
     if (! dirp)
          return(found);

     for (dp = readdir(dirp); dp != NULL; dp = readdir(dirp)) {
          if (is_dotfile(dp->d_name))
               continue;
          if (is_deleted(dp->d_name)) {
               found = add_str(found, num, append(base, dp->d_name));
               num += 1;
          }
     }
     closedir(dirp);
     *num_found = num;
     return(found);
}




char **find_deleted_contents_recurs(base, num_found)
char *base;
int *num_found;
{
     DIR *dirp;
     struct direct *dp;
     char **found;
     int num;
     struct stat stat_buf;
     char newname[MAXPATHLEN];
     char **new_found;
     int new_found_num;
     
#ifdef DEBUG
     printf("Looking for recursive deleted contents of %s\n", base);
#endif
     found = (char **) malloc(0);
     *num_found = num = 0;
   
     dirp = opendir(base);
     if (! dirp)
          return(found);

     for (dp = readdir(dirp); dp != NULL; dp = readdir(dirp)) {
          if (is_dotfile(dp->d_name))
               continue;
          if (is_deleted(dp->d_name)) {
               strcpy(newname, append(base, dp->d_name));
               found = add_str(found, num, newname);
               num += 1;
               if (lstat(newname, &stat_buf))
                    continue;
               if ((stat_buf.st_mode & S_IFMT) == S_IFDIR) {
                    new_found = find_recurses(newname, &new_found_num);
                    add_arrays(&found, &num, &new_found, &new_found_num);
               }
          }
     }
     closedir(dirp);
     *num_found = num;
     return(found);
}
     


/*
 * returns true if the filename has no regular expression wildcards in
 * it.  That means no non-quoted dots or asterisks.  Assumes a
 * null-terminated string, and a valid regular expression.
 */
int no_wildcards(name)
char *name;
{
     do {
          switch (*name) {
          case '\\':
               name++;
               break;
          case '.':
               return(0);
          case '*':
               return(0);
          }
     } while (*++name);
     return(1);
}