home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / extra18 / makekey / clearhd.c next >
Encoding:
C/C++ Source or Header  |  1992-01-20  |  16.8 KB  |  438 lines
  1. /* ------------------------------------------------- */
  2. /*                    CLEARHD.C                      */
  3. /*  CLEARHD überprüft, ob sich die Dateien, die in   */
  4. /*  der angegebenen Schlüsseldatei vorhanden sind,   */
  5. /*  in Größe, Datum oder Uhrzeit geändert haben, ob  */
  6. /*  sie überhaupt noch existieren und ob es Dateien  */
  7. /*  gibt, die sich nicht in der Schlüsseldatei be-   */
  8. /*  finden. Bei nicht in der Schlüsseldatei vorhan-  */
  9. /*  denen Dateien wird das Löschen der entsprechen-  */
  10. /*  den Dateien angeboten, wenn der entsprechende    */
  11. /*  Schalter gesetzt wird.                           */
  12. /* ------------------------------------------------- */
  13. /*  Parameter                                        */
  14. /*  Eingabe   : argc    : Anzahl der übergebenen     */
  15. /*                        Parameter                  */
  16. /*              *argv[] : Zeiger auf die übergebenen */
  17. /*                        Parameter                  */
  18. /*   Ausgabe   : Bei fehlerhaftem Aufruf wird das    */
  19. /*               Programm abgebrochen und            */
  20. /*               setzt mit exit() den ERRORLEVEL     */
  21. /*               auf 1                               */
  22. /* ------------------------------------------------- */
  23. /*        (c) 1991 Dirk Alpers & DMV-Verlag          */
  24. /* ------------------------------------------------- */
  25.  
  26. #include "def.h"   /* enthält alle nötigen Prototypen
  27.                       und Konstanten */
  28.  
  29. /* --- Typen --------------------------------------- */
  30. struct pointer {
  31.          char    name[80];
  32.   struct pointer *next;
  33. };
  34.  
  35. /* --- Prototypen ---------------------------------- */
  36. void           Parameter_auswerten(int argc,
  37.                                    char *argv[],
  38.                                    char *source);
  39. void           Anleitung_ausgeben(void);
  40. struct pointer *vergleichen(struct pointer *rootptr,
  41.                             char *dir);
  42. int            cutstr(char *dest, char *source,
  43.                       int position, int length);
  44.  
  45. /* --- Globale Variablen --------------------------- */
  46. int    OK      = FALSE,
  47.           /* Bei korrekten Files OK ausgeben?        */
  48.        DELETE  = FALSE,
  49.           /* Bei unkorrekten Files löschen anbieten? */
  50.        NOQUERY = FALSE;
  51.           /* Löschen ohne Sicherheitsabfrage?        */
  52.  
  53. /* ------------------------------------------------- */
  54. void main(int argc,char *argv[])
  55. {
  56.   char   file[MAXPATH],
  57.            /* Zeile aus der Schlüsseldatei           */
  58.          dir[MAXPATH];
  59.            /* zu durchsuchendes Directory            */
  60.   char   source[MAXPATH];
  61.            /* Name der Schlüsseldatei                */
  62.   FILE   *fp;
  63.            /* Filepointer der Schlüsseldatei         */
  64.   struct pointer *rootptr,
  65.            /* Anfang der einfach verketteten Liste   */
  66.                  *helpptr,
  67.            /* Hilfszeiger zum Aufbau und Durchlaufen */
  68.                  *laufzeiger;
  69.            /*   der einfach verketteten Liste        */
  70.  
  71.   printf("\nCLEARHD 1.0 (c) 1991 Alpers/Dietl");
  72.   Parameter_auswerten(argc, argv, source);
  73.  
  74.   fp = fopen(source, "r");
  75.                   /* Schlüsseldatei zum Lesen öffnen */
  76.   if (errno == 0) {
  77.            /* Konnte Schlüsseldatei geöffnet werden? */
  78.     fscanf(fp, "%s", file);
  79.           /* Ersten Eintrag aus Schlüsseldatei lesen */
  80.     while (!feof(fp)) {
  81.       strcpy(dir, file+1);
  82.                          /* "*" aus String streichen */
  83.       printf("\nDir: %s", dir);
  84.         /* Zu durchsuchenden Directorynamen ausgeben */
  85.       rootptr = NULL;      /* rootptr initialisieren */
  86.       laufzeiger = NULL;
  87.       fscanf(fp, "%s", file);
  88.       /* Ersten Fileeintrag aus Schlüsseldatei lesen */
  89.       /* Alle Fileeinträge aus einem Directory in    */
  90.       /* einer Pointerkette ablegen                  */
  91.       while((file[0] != '*') && (!feof(fp)))
  92.       {
  93.         helpptr = (struct pointer *)
  94.                   malloc(sizeof(struct pointer));
  95.         strcpy(helpptr->name,file);
  96.         helpptr->next = NULL;
  97.         if (rootptr == NULL)
  98.           rootptr = helpptr;
  99.         else
  100.           laufzeiger->next = helpptr;
  101.         laufzeiger = helpptr;
  102.         fscanf(fp,"%s",file);
  103.         /* Nächsten Eintrag aus Schlüsseldatei holen */
  104.       }
  105.       errno = 0;
  106.  
  107.       rootptr = vergleichen(rootptr, dir);
  108.  
  109.       /* Nicht gefundene Dateien ausgeben und        */
  110.       /* Pointer-Speicherplatz freigeben             */
  111.       helpptr = rootptr;
  112.       while (helpptr)
  113.       {
  114.         printf("\n%s  *** MISSING ***",helpptr->name);
  115.  
  116.         laufzeiger = helpptr->next;
  117.         free(helpptr);
  118.                   /* Pointer-Speicherplatz freigeben */
  119.         helpptr = laufzeiger;
  120.       }
  121.     }
  122.  
  123.     fclose(fp);          /* Schlüsseldatei schließen */
  124.   }
  125.   else
  126.     printf("\nCan't open Keyfile\n");
  127.       /* Schlüsseldatei konnte nicht geöffnet werden */
  128.   printf("\n");
  129. } /* clearhd */
  130.  
  131.  
  132. /* ------------------------------------------------- */
  133. /*  Modulname : Parameter_auswerten                  */
  134. /*  Aufgabe   : Auswerten der dem Programm über-     */
  135. /*              gebenen Parameter                    */
  136. /*    /O, -O  : Bei Übereinstimmung "OK" ausgeben    */
  137. /*    /D, -D  : Bei Nichtübereinstimmung Löschen     */
  138. /*              anbieten                             */
  139. /*    /N, -N  : Löschen ohne Nachfrage               */
  140. /*              (nur zusammen mit D)                 */
  141. /* ------------------------------------------------- */
  142. /*  Parameter                                        */
  143. /*  Eingabe   : argc    : Anzahl der übergebenen     */
  144. /*                        Parameter                  */
  145. /*              *argv[] : Pointer auf die über-      */
  146. /*                        gebenen Parameter          */
  147. /*  Ausgabe   : *source : Name der Schlüsseldatei    */
  148. /* ------------------------------------------------- */
  149. void Parameter_auswerten(int argc, char *argv[],
  150.                          char *source)
  151. {
  152.    int  zaehler;                  /* Schleifenzähler */
  153.  
  154.    strcpy(source, "");
  155.    if ( (argc == 1) || (argv[1] == "/?") ||
  156.         (argv[1] == "-?") )
  157.      Anleitung_ausgeben();
  158.    else {
  159.      for (zaehler = 1; zaehler < argc; zaehler++) {
  160.        strupr(argv[zaehler]);
  161.  
  162.        if ( (strcmp(argv[zaehler], "/O") == 0) ||
  163.             (strcmp(argv[zaehler], "-O") == 0) )
  164.          OK = TRUE;
  165.        else if ( (strcmp(argv[zaehler], "/D") == 0) ||
  166.                  (strcmp(argv[zaehler], "-D") == 0) )
  167.          DELETE = TRUE;
  168.        else if ( (strcmp(argv[zaehler], "/N") == 0) ||
  169.                  (strcmp(argv[zaehler], "-N") == 0) )
  170.          NOQUERY = TRUE;
  171.        else strcpy(source, argv[zaehler]);
  172.      }
  173.    }
  174.  
  175.    if ((! strcmp(source, "")) ||
  176.        (NOQUERY && ! DELETE) ||
  177.        (source[0] == '/') || (source[0] == '-') )
  178.      Anleitung_ausgeben();
  179. } /* Parameter_auswerten */
  180.  
  181.  
  182. /* ------------------------------------------------- */
  183. /*  Modulname : Anleitung_ausgeben                   */
  184. /*  Aufgabe   : bei fehlerhaftem Programmaufruf eine */
  185. /*              Kurzanleitung ausgeben und Abbruch   */
  186. /*              mit exit()                           */
  187. /* ------------------------------------------------- */
  188. /*  Parameter                                        */
  189. /*  Eingabe   : Keine                                */
  190. /*  Ausgabe   : mittels exit() wird der ERRORLEVEL   */
  191. /*              von DOS gesetzt                      */
  192. /* ------------------------------------------------- */
  193. void  Anleitung_ausgeben(void)
  194. {
  195.   printf("\nCLEARHD - Dateien mit Schlüsseldatei ");
  196.   printf("vergleichen\n");
  197.   printf("\nAufruf:   CLEARHD <Schlüsseldateiname> ");
  198.   printf("[/O] [/D [/N]]");
  199.   printf("\n          /O - (OK)       für korrekte ");
  200.   printf("Dateien wird OK ausgegeben");
  201.   printf("\n          /D - (Delete)   unkorrekte ");
  202.   printf("Dateien nach Abfrage löschen");
  203.   printf("\n          /N - (No query) unkorrekte ");
  204.   printf("Dateien ohne Nachfrage löschen\n");
  205.  
  206.   exit(1);
  207.          /* Programm abbrechen und ERRORLEVEL setzen */
  208. } /* Anleitung_ausgeben */
  209.  
  210.  
  211. /* ------------------------------------------------- */
  212. /*  Modulname : vergleichen                          */
  213. /*  Aufgabe   : Sequentielles Durchlaufen des über-  */
  214. /*              gebenen Directories.                 */
  215. /*              Jede gefundene Datei wird in der     */
  216. /*              Pointerliste gesucht.                */
  217. /*              Wenn die Datei gefunden wird, wird   */
  218. /*              sie aus der Pointerliste gestrichen. */                                         *
  219. /*              Je nach gewählten Optionen wird      */
  220. /*      - bei Übereinstimmungen OK ausgegeben        */
  221. /*      - bei nicht in der Liste vorhandenen Dateien */
  222. /*        das Löschen der entsprechenden Datei       */
  223. /*        angeboten                                  */
  224. /*        Bei falscher Größe, falscher Zeit und      */
  225. /*        falschem Datum wird eine entsprechende     */
  226. /*        Meldung  ausgegeben.                       */
  227. /* ------------------------------------------------- */
  228. /*  Parameter                                        */
  229. /*   Eingabe : *rootptr: Zeiger auf den Listenanfang */
  230. /*             *dir    : Name des zu durchsuchenden  */
  231. /*                       Directory                   */
  232. /*   Ausgabe : *rootptr: Zeiger auf den Listenanfang */
  233. /* ------------------------------------------------- */
  234. struct pointer *vergleichen(struct pointer *rootptr,
  235.                             char *dir)
  236. {
  237.    char   loeschen;       /* Antwort auf Frage, ob   */
  238.                           /* unkorrektes File        */
  239.                           /* gelöscht werden soll    */
  240.    struct ffblk datei = {"",' ',0,0,0,""};
  241.    char   helpstr[80],
  242.           helpstr2[80],
  243.           helpstr3[80],
  244.           dateiname[13];
  245.                        /* Dateiname des DIR-Eintrags */
  246.    struct pointer *vorgaenger,
  247.            /* Pointer zum Bearbeiten der Liste mit   */
  248.                   *helpptr;  /*   den Dateieinträgen */
  249.  
  250.      /* Vergleich zwischen existierenden Dateien und */
  251.      /* Einträgen in Schlüsseldatei                  */
  252.    strcpy(helpstr,dir);
  253.    if (helpstr[strlen(helpstr) - 1] != '\\')
  254.          /* beim Hauptdirectory ist bereits ein '\\' */
  255.      strcat(helpstr, "\\*.*");
  256.          /*   vorhanden, bei Subdirectorys nicht     */
  257.    else strcat(helpstr, "*.*");
  258.  
  259.    findfirst(helpstr,&datei,0x27);
  260.      /* DOS: Ersten Fileeintrag im Directory suchen  */
  261.    while (errno == 0)
  262.      {   /* Noch ein Dateieintrag gefunden?          */
  263.        mkstring(helpstr,datei);
  264.          /* Aus Filedaten String machen              */
  265.          /* TURBOC: Warning: Structure passed by     */
  266.          /*                  value ist ok            */
  267.        strcat(helpstr,"__");
  268.             /* Notwendig für exakten Stringvergleich */
  269.  
  270.        cutstr(dateiname, helpstr, 0, 12);
  271.             /* Dateinamen aus helpstr schneiden      */
  272.  
  273.        /* In der Liste eine Datei mit gleichem       */
  274.        /* Namen suchen                               */
  275.        helpptr = rootptr;
  276.        while ((helpptr != NULL) &&
  277.           (strncmp(dateiname,helpptr->name, 12) != 0))
  278.          {
  279.            vorgaenger = helpptr;
  280.           /* Filenamen sind ungleich -> weitersuchen */
  281.            helpptr = helpptr->next;
  282.          } /* while */
  283.  
  284.        if (helpptr != NULL)
  285.                   /* Dateiname in der Liste gefunden */
  286.        {
  287.               /* Dateinamen isolieren und auf        */
  288.               /* Gleichheit prüfen                   */
  289.          cutstr(helpstr2, helpptr->name, 0, 12);
  290.          cutstr(helpstr3, helpstr, 0, 12);
  291.  
  292.          if (strcmp(helpstr2, helpstr3) == 0)
  293.                        /* Einträge absolut identisch */
  294.          {
  295.            if ((helpptr->name[39]=='C') ||
  296.                (strcmp(helpptr->name, helpstr) == 0))
  297.            {
  298.              if (OK)
  299.              {
  300.           /* Filedaten gleich/dürfen geändert werden */
  301.                printf("\n%s",helpptr->name);
  302.                printf("  OK");
  303.              }
  304.            }
  305.            else {
  306.              if (strcmp(helpptr->name, helpstr) != 0)
  307.              {
  308.                     /* LÄNGE, DATUM, ZEIT überprüfen */
  309.                printf("\n%s",helpptr->name);
  310.                     /* Filestring ausgeben           */
  311.  
  312.                cutstr(helpstr2,helpstr,13,8);
  313.                     /* Größe überprüfen              */
  314.                cutstr(helpstr3,helpptr->name,13,8);
  315.                if (strcmp(helpstr2,helpstr3) != NULL)
  316.                  printf("  WRONG SIZE");
  317.  
  318.                cutstr(helpstr2,helpstr,22,10);
  319.                                  /* Datum überprüfen */
  320.                cutstr(helpstr3,helpptr->name,22,10);
  321.                if (strcmp(helpstr2,helpstr3) != NULL)
  322.                  printf("  WRONG DATE");
  323.  
  324.                  cutstr(helpstr2,helpstr,33,5);
  325.                                 /* Zeit überprüfen   */
  326.                  cutstr(helpstr3,helpptr->name,33,5);
  327.                  if (strcmp(helpstr2,helpstr3) != NULL)
  328.                    printf("  WRONG TIME");
  329.                  }
  330.                } /* else */
  331.  
  332.                if (helpptr != rootptr)
  333.                {
  334.                  /* Listenelement aus der Mitte der */
  335.                  /* Liste                           */
  336.                  vorgaenger->next = helpptr->next;
  337.                  free(helpptr);
  338.                  helpptr = vorgaenger->next;
  339.                }
  340.                else
  341.                {
  342.                /* Listenelement am Anfang der Liste */
  343.                  rootptr = helpptr->next;
  344.                  free(helpptr);
  345.                  helpptr = rootptr;
  346.                  vorgaenger = helpptr;
  347.                } /* else */
  348.              }
  349.            }
  350.            else
  351.            {
  352.              /* File nicht in Schlüsseldatei, */
  353.              /* Datei löschen ?               */
  354.              printf("\n%s  *** Not required",helpstr);
  355.              /* Filestring ausgeben */
  356.              if ((DELETE) && (!NOQUERY))
  357.              /* Nachfrage: Datei löschen? */
  358.              {
  359.                printf(" - KILL (Y/N)?");
  360.                do
  361.                {
  362.                  loeschen = toupper(getche());
  363.                }
  364.                while ((loeschen != 'Y') &&
  365.                       (loeschen != 'N'));
  366.              }
  367.              else printf(" ***");
  368.  
  369.              if ( (NOQUERY) ||
  370.                   (DELETE && (loeschen =='Y')) )
  371.              {
  372.                strcpy(helpstr,dir);
  373.                   /* beim Hauptdirectory ist bereits */
  374.                   /* ein '\\' vorhanden,             */
  375.                   /* bei Subdirectories nicht        */
  376.                if (helpstr[strlen(helpstr) -1] != '\\')
  377.                  strcat(helpstr,"\\");
  378.                strcat(helpstr,datei.ff_name);
  379.                            /* Dateiname nach helpstr */
  380.                unlink(helpstr);
  381.                            /* Datei löschen          */
  382.                if (! errno)
  383.                  printf("\n%40c  KILLED", ' ');
  384.                else
  385.                  printf("\n%40c  WRITE-PROTECTED",' ');
  386.                errno = 0;
  387.              };
  388.  
  389.        }  /* else */
  390.  
  391.        findnext(&datei);
  392.         /* DOS: Nächsten Eintrag im Directory suchen */
  393.      } /* while */
  394.  
  395.   return (rootptr);
  396. } /* vergleichen */
  397.  
  398.  
  399. /* ------------------------------------------------- */
  400. /*  Modulname : cutstr                               */
  401. /*  Aufgabe   : Ausschneiden eines Strings aus einem */
  402. /*              Quellstring ab der Position position */
  403. /*              und der maximalen Länge length und   */
  404. /*              übertragen in einen Zielstring.      */
  405. /*              Wenn der Quellstring weniger Zeichen */
  406. /*              als position+length besitzt, werden  */
  407. /*              nur die Zeichen bis zum Quellstring- */
  408. /*              ende zurückgegeben.                  */
  409. /* ------------------------------------------------- */
  410. /*  Parameter                                        */
  411. /*   Eingabe : char *dest    Adresse des Zielstrings */
  412. /*             char *source  Adresse des Quellstrings*/
  413. /*             int  position ab welcher Position     */
  414. /*                           ausgeschnitten werden   */
  415. /*                           soll                    */
  416. /*             int  length   wieviele Zeichen maximal*/
  417. /*                           ausgeschnitten          */
  418. /*                           werden sollen           */
  419. /*  Ausgabe  : Anzahl der ausgeschnittenen Zeichen   */
  420. /* ------------------------------------------------- */
  421. int cutstr(char *dest, char *source,
  422.            int position, int length)
  423. {
  424.   int  i = 0;        /* Schleifenvariable */
  425.  
  426.   while ((i<length) &&
  427.          (source[position+i] != '\0')) {
  428.     dest[i] = source[position+i];
  429.     i++;
  430.   }
  431.   dest[i] = '\0';
  432.   return(i);
  433. } /* cutstr */
  434.  
  435. /* ------------------------------------------------- */
  436. /*              Ende von CLEARHD.C                   */
  437.  
  438.