git.gag.com Git - debian/amanda/blob - server-src/amtrmidx.c

   1 /*
   2  * Amanda, The Advanced Maryland Automatic Network Disk Archiver
   3  * Copyright (c) 1991-1998 University of Maryland at College Park
   4  * All Rights Reserved.
   5  *
   6  * Permission to use, copy, modify, distribute, and sell this software and its
   7  * documentation for any purpose is hereby granted without fee, provided that
   8  * the above copyright notice appear in all copies and that both that
   9  * copyright notice and this permission notice appear in supporting
  10  * documentation, and that the name of U.M. not be used in advertising or
  11  * publicity pertaining to distribution of the software without specific,
  12  * written prior permission.  U.M. makes no representations about the
  13  * suitability of this software for any purpose.  It is provided "as is"
  14  * without express or implied warranty.
  15  *
  16  * U.M. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL U.M.
  18  * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  19  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  20  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  21  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22  *
  23  * Authors: the Amanda Development Team.  Its members are listed in a
  24  * file named AUTHORS, in the root directory of this distribution.
  25  */
  26 /*
  27  * $Id: amtrmidx.c,v 1.21.4.1.4.2.2.5.2.2 2005/09/20 21:31:52 jrjackson Exp $
  28  *
  29  * trims number of index files to only those still in system.  Well
  30  * actually, it keeps a few extra, plus goes back to the last level 0
  31  * dump.
  32  */
  33
  34 #include "amanda.h"
  35 #include "arglist.h"
  36 #ifdef HAVE_NETINET_IN_SYSTM_H
  37 #include <netinet/in_systm.h>
  38 #endif
  39 #include "conffile.h"
  40 #include "diskfile.h"
  41 #include "tapefile.h"
  42 #include "find.h"
  43 #include "version.h"
  44
  45 static int sort_by_name_reversed(a, b)
  46 const void *a;
  47 const void *b;
  48 {
  49     char **ap = (char **) a;
  50     char **bp = (char **) b;
  51
  52     return -1 * strcmp(*ap, *bp);
  53 }
  54
  55 int main(argc, argv)
  56 int argc;
  57 char **argv;
  58 {
  59     disk_t *diskp;
  60     disklist_t *diskl;
  61     int i;
  62     char *conffile;
  63     char *conf_diskfile;
  64     char *conf_tapelist;
  65     char *conf_indexdir;
  66     find_result_t *output_find;
  67     time_t tmp_time;
  68     int amtrmidx_debug = 0;
  69
  70     safe_fd(-1, 0);
  71     safe_cd();
  72
  73     set_pname("amtrmidx");
  74
  75     dbopen();
  76     dbprintf(("%s: version %s\n", argv[0], version()));
  77
  78     if (argc > 1 && strcmp(argv[1], "-t") == 0) {
  79         amtrmidx_debug = 1;
  80         argc--;
  81         argv++;
  82     }
  83
  84     if (argc < 2) {
  85         fprintf(stderr, "Usage: %s [-t] <config>\n", argv[0]);
  86         return 1;
  87     }
  88
  89     config_name = argv[1];
  90
  91     config_dir = vstralloc(CONFIG_DIR, "/", config_name, "/", NULL);
  92     conffile = stralloc2(config_dir, CONFFILE_NAME);
  93     if(read_conffile(conffile)) {
  94         error("errors processing config file \"%s\"", conffile);
  95     }
  96     amfree(conffile);
  97     conf_diskfile = getconf_str(CNF_DISKFILE);
  98     if(*conf_diskfile == '/') {
  99         conf_diskfile = stralloc(conf_diskfile);
 100     } else {
 101         conf_diskfile = stralloc2(config_dir, conf_diskfile);
 102     }
 103     if((diskl = read_diskfile(conf_diskfile)) == NULL) {
 104         error("could not load disklist \"%s\".", conf_diskfile);
 105     }
 106     amfree(conf_diskfile);
 107     conf_tapelist = getconf_str(CNF_TAPELIST);
 108     if(*conf_tapelist == '/') {
 109         conf_tapelist = stralloc(conf_tapelist);
 110     } else {
 111         conf_tapelist = stralloc2(config_dir, conf_tapelist);
 112     }
 113     if(read_tapelist(conf_tapelist)) {
 114         error("could not load tapelist \"%s\"", conf_tapelist);
 115     }
 116     amfree(conf_tapelist);
 117
 118     output_find = find_dump(1, diskl);
 119
 120     conf_indexdir = getconf_str(CNF_INDEXDIR);
 121     if(*conf_indexdir == '/') {
 122         conf_indexdir = stralloc(conf_indexdir);
 123     } else {
 124         conf_indexdir = stralloc2(config_dir, conf_indexdir);
 125     }
 126
 127     /* now go through the list of disks and find which have indexes */
 128     time(&tmp_time);
 129     tmp_time -= 7*24*60*60;                     /* back one week */
 130     for (diskp = diskl->head; diskp != NULL; diskp = diskp->next) {
 131         if (diskp->index) {
 132             char *indexdir;
 133             DIR *d;
 134             struct dirent *f;
 135             char **names;
 136             int name_length;
 137             int name_count;
 138             char *host;
 139             char *disk;
 140
 141             dbprintf(("%s %s\n", diskp->host->hostname, diskp->name));
 142
 143             /* get listing of indices, newest first */
 144             host = sanitise_filename(diskp->host->hostname);
 145             disk = sanitise_filename(diskp->name);
 146             indexdir = vstralloc (conf_indexdir, "/",
 147                                   host, "/",
 148                                   disk, "/",
 149                                   NULL);
 150             amfree(host);
 151             amfree(disk);
 152             if((d = opendir(indexdir)) == NULL) {
 153                 dbprintf(("could not open index directory \"%s\"\n", indexdir));
 154                 amfree(indexdir);
 155                 continue;
 156             }
 157             name_length = 100;
 158             names = (char **)alloc(name_length * sizeof(char *));
 159             name_count = 0;
 160             while ((f = readdir(d)) != NULL) {
 161                 int l;
 162
 163                 if(is_dot_or_dotdot(f->d_name)) {
 164                     continue;
 165                 }
 166                 for(i = 0; i < sizeof("YYYYMMDD")-1; i++) {
 167                     if(! isdigit((int)(f->d_name[i]))) {
 168                         break;
 169                     }
 170                 }
 171                 if(i < sizeof("YYYYMMDD")-1
 172                     || f->d_name[i] != '_'
 173                     || ! isdigit((int)(f->d_name[i+1]))) {
 174                     continue;                   /* not an index file */
 175                 }
 176                 /*
 177                  * Clear out old index temp files.
 178                  */
 179                 l = strlen(f->d_name) - (sizeof(".tmp")-1);
 180                 if(l > sizeof("YYYYMMDD_L")-1
 181                     && strcmp (f->d_name + l, ".tmp") == 0) {
 182                     struct stat sbuf;
 183                     char *path;
 184
 185                     path = stralloc2(indexdir, f->d_name);
 186                     if(lstat(path, &sbuf) != -1
 187                         && (sbuf.st_mode & S_IFMT) == S_IFREG
 188                         && sbuf.st_mtime < tmp_time) {
 189                         dbprintf(("rm %s\n", path));
 190                         if(amtrmidx_debug == 0 && unlink(path) == -1) {
 191                             dbprintf(("Error removing \"%s\": %s\n",
 192                                       path, strerror(errno)));
 193                         }
 194                     }
 195                     amfree(path);
 196                     continue;
 197                 }
 198                 if(name_count >= name_length) {
 199                     char **new_names;
 200
 201                     new_names = alloc((name_length + 100) * sizeof(char *));
 202                     memcpy(new_names, names, name_length * sizeof(char *));
 203                     name_length += 100;
 204                     amfree(names);
 205                     names = new_names;
 206                 }
 207                 names[name_count++] = stralloc(f->d_name);
 208             }
 209             closedir(d);
 210             qsort(names, name_count, sizeof(char *), sort_by_name_reversed);
 211
 212             /*
 213              * Search for the first full dump past the minimum number
 214              * of index files to keep.
 215              */
 216             for(i = 0; i < name_count; i++) {
 217                 if(!dump_exist(output_find,
 218                                          diskp->host->hostname,diskp->name,
 219                                          atoi(names[i]),
 220                                          names[i][sizeof("YYYYMMDD_L")-1-1] - '0')) {
 221                     char *path;
 222                     path = stralloc2(indexdir, names[i]);
 223                     dbprintf(("rm %s\n", path));
 224                     if(amtrmidx_debug == 0 && unlink(path) == -1) {
 225                         dbprintf(("Error removing \"%s\": %s\n",
 226                                   path, strerror(errno)));
 227                     }
 228                     amfree(path);
 229                 }
 230                 amfree(names[i]);
 231             }
 232             amfree(names);
 233             amfree(indexdir);
 234         }
 235     }
 236
 237     amfree(conf_indexdir);
 238     amfree(config_dir);
 239     free_find_result(&output_find);
 240
 241     dbclose();
 242
 243     return 0;
 244 }