Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

947 lines
31 KiB

// Analyses the output from the new chkeckrel
// t-mhills
#include <direct.h>
#include <io.h>
#include <ctype.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#define F_flag 1 //Values to store in the command line switches flag
#define I1_flag 2
#define I2_flag 4
#define X_flag 8
// These codes should match the codes below in the usage description
#define par_err 6 //comand line parameter error exit code 5
#define exep_err 5 //error in the exception file
#define chk_err 4 //error in the one of the source files
#define mem_err 3 //memory allocation error
#define file_err 2 //file find/read error
#define comp_err 1 //comparison found differences
#define no_err 0 // files compared okay
#define exceptionfilelinelength 512 //These value used to control the size of temporary strings
#define chkfilelinelength 2048 //Ideally there would be no limit but file reads require static variables
#define maxpathlength 200
struct translatetable //Used to store translate commands from the exception file.
{
struct translatetable *next;
char *source1name;
char *source2name;
};
struct excludetable //Used to store exclude commands from the exception file.
{
struct excludetable *next;
char *path;
};
struct checksums //Used to store checksums with file names.
{
struct checksums *next;
long sum;
char filename; // This structure is of variable length to accomodate any string length.
};
void error (char exitcode); //Ends program and returns exitcode to the system.
void showchecksumlist (struct checksums *list); //Displays Checksums with filenames.
void showdualchecksumlist (struct checksums *list); //Shows checksums in a format good for missmatched checksums.
char excluded (char *str, struct excludetable *ex); //If any of the exclude strings are in str it returns true.
char *translate (char *str, struct translatetable *tran); //Make a copy of str with changes from exception file.
long readhex (char *str); //Convert hex string to long.
char proccessline (char *tempstr, struct translatetable *translations, struct excludetable *exclusions,
char *startpath, char flags, char **filename, long *filesum);
//Parse line and apply all exceptions and flags
char loadsource1 (char *filename, struct checksums **sums,
struct translatetable *translations, struct excludetable * exclusions,
char *startpath, char flags); //Load source1 into a checksum list.
char comparesource2 (char *filename, struct checksums **sums,
struct checksums **extrasource2, struct checksums **missmatched,
struct translatetable *translations, struct excludetable * exclusions,
char *startpath, char flags); //Compare the second file to the checksum list.
void removewhitespace (char *str); //Removes whitespace from the end of a string.
char *strstrupcase (char *str1, char *str2); //Case insensitive strstr.
char proccess_exception_file (char *filename, struct translatetable **trans, struct excludetable **exclude, char **path);
//Parse exception file.
char proccess_command_line (int argc, char *argv[ ], char **source1, char **source2, char *flags, char **exception);
//Parse command line arguments
void completehelp (); //Show nearly complete documentation
// ******************************** MAIN ***************************
void __cdecl
main(
int argc,
char *argv[ ]
)
{
char errnum = 0;
char *source1filename = NULL;
char *source2filename = NULL;
char *exceptionfilename = NULL;
char flags; // flags: /F=1=(F_flag); /I1=2=(I1_flag); /I2=4=(I2_flag); /X=8=(X_flag)
struct translatetable *translations = NULL; //
struct excludetable *exclusions = NULL; //Information from exception file stored here.
char *startpath = NULL; //
struct checksums *source1checksums = NULL; //List of extra files in Source1
struct checksums *source2checksums = NULL; //List of extra files in Source2
struct checksums *missmatched = NULL; //List of files with chechsums that don't match.
struct translatetable *temp = NULL; //
struct checksums *temp2 = NULL; //Temporary pointers used to help deallocate memory
//Parse command line.
if (errnum = proccess_command_line (argc, argv, &source1filename, &source2filename, &flags, &exceptionfilename))
{
goto freecommandline; // skip to end and deallocate memory
}
//Show information obtained from command line.
printf ("Source1 = %s\n", source1filename);
printf ("Source2 = %s\n", source2filename);
if (flags & F_flag)
printf ("Comparing flat Share.\n");
if (flags & I1_flag)
printf ("Ignoring extra files in Source1.\n");
if (flags & I2_flag)
printf ("Ignoring extra files in Source2.\n");
if (flags & X_flag)
printf ("Exception file = %s\n", exceptionfilename);
//Parse the excpetion file if it exists.
if (flags & X_flag)
{
if (errnum = proccess_exception_file (exceptionfilename, &translations, &exclusions, &startpath))
{
goto freeexceptiontable; //skip to end and dealocate memory
};
//Display information from exception file.
temp = translations;
while (temp != NULL)
{
printf ("TRANSLATE %s --> %s\n", temp->source1name, temp->source2name);
temp = temp->next;
};
temp = (struct translatetable *) exclusions; //note: using wrong type to avoid making another temp pointer
while (temp != NULL)
{
printf ("EXCLUDE %s\n", temp->source1name);
temp = temp->next;
};
if (startpath != NULL)
printf ("STARTPATH %s\n", startpath);
};
//Read source1 and store files and checksums in source1checksums.
if (errnum = loadsource1 (source1filename, &source1checksums, translations, exclusions, startpath, flags))
{
goto freesource1checksums;
};
//printf ("\n\nSource1:\n\n"); //for debugging
//showchecksumlist (source1checksums);
//Read source2 and compare it to the files/checksums from source1. Store differences.
if (errnum = comparesource2 (source2filename, &source1checksums, &source2checksums, &missmatched,
translations, exclusions, startpath, flags))
{
goto freesource2checksums;
};
//Display extra files unless /I1 or /I2 was used in the command line.
if ((!(flags & I1_flag)) & (source1checksums != NULL))
{
errnum = 1;
printf ("\n********** Extra files in %s **********\n", source1filename);
showchecksumlist (source1checksums);
};
if ((!(flags & I2_flag)) & (source2checksums != NULL))
{
errnum = 1;
printf ("\n********** Extra files in %s **********\n", source2filename);
showchecksumlist (source2checksums);
};
//Display missmatched checksums.
if (missmatched != NULL)
{
errnum = 1;
printf ("\n********** Checksums from %s != checksums from %s.**********\n", source1filename, source2filename);
showdualchecksumlist (missmatched);
};
//Deallocate memory.
freesource2checksums:
while (source2checksums != NULL)
{
temp2 = source2checksums;
source2checksums = source2checksums->next;
free (temp2);
};
while (missmatched != NULL)
{
temp2 = missmatched;
missmatched = missmatched->next;
free (temp2);
};
freesource1checksums:
while (source1checksums != NULL)
{
temp2 = source1checksums;
source1checksums = source1checksums->next;
free (temp2);
};
freeexceptiontable:
if (startpath != NULL)
free (startpath);
while (translations != NULL)
{
if (translations->source1name != NULL)
free (translations->source1name);
if (translations->source2name != NULL)
free (translations->source2name);
temp = translations;
translations = translations->next;
free (temp);
};
while (exclusions != NULL)
{
if (exclusions->path != NULL)
free (exclusions->path);
temp = (struct translatetable *) exclusions;
exclusions = exclusions->next;
free (temp);
};
freecommandline:
if (source1filename != NULL)
free (source1filename);
if (source2filename != NULL)
free (source2filename);
if (exceptionfilename != NULL)
free (exceptionfilename);
//End program and show help if needed.
error (errnum);
};
void showchecksumlist (struct checksums *list)
{
while (list != NULL)
{
printf ("%d %s\n", list->sum, &(list->filename));
list = list->next;
};
};
void showdualchecksumlist (struct checksums *list)
//This can only be used with the missmatched checksums list since it assumes that the files
//come in pairs of identical filenames with different checksums.
{
while (list != NULL)
{
if (list->next == NULL)
{
printf ("Error: list corruption detected in showdualchecksumlist function.\n");
return;
};
printf ("%d != %d %s\n", list->sum, list->next->sum, &(list->filename));
list = list->next->next;
};
};
char excluded (char *str, struct excludetable *ex) //If any of the exclude strings are in str it returns true.
{
while (ex != NULL)
{
if (strstr (str, ex->path))
return (1);
ex = ex->next;
}
return (0);
};
char *translate (char *str, struct translatetable *tran)
{
char *temp;
char *newstr;
while (tran != NULL) //Search translate table.
{
if ((temp = strstr (str, tran->source1name)) != NULL) //If we found one that needs translating
{
//Allocate memory for new string.
if ((newstr = malloc (strlen (str) + strlen (tran->source2name) - strlen(tran->source1name) + 1))==NULL)
return (NULL);
strncpy(newstr, str, (size_t)(temp - str)); //Write part before translations.
strcpy (&newstr [temp-str], tran->source2name); //Add translated part
strcat (newstr, &temp [strlen (tran->source1name)]); //Add end of string
return (newstr);
};
tran = tran->next;
};
return (_strdup (str)); //If didn't need to be translated, make a new copy anyway for uniformity.
};
long readhex (char *str)
{
long temp = 0;
int position = 0;
for (position = 0; 1;position++)
{
if ((str[position] == ' ')|(str[position] == '\n')|(str[position] == '\x00'))
{
return (temp);
}
else
{
temp *= 16;
if ((str [position] >= '0') & (str [position] <= '9'))
{
temp+=(str[position]-'0');
}
else if ((str [position] >= 'a') & (str [position] <= 'f'))
{
temp+=(str[position]-'a'+10);
}
else
return (-1);
};
};
};
char proccessline (char *tempstr, struct translatetable *translations, struct excludetable *exclusions,
char *startpath, char flags, char **filename, long *filesum)
{
char *name;
char *newname;
char *sumstr;
*filename = NULL; //Make sure that if no name is returned this is blank
removewhitespace (tempstr);
//If it is a line that says "- N0 files" then the sum is assigned to 0
if ((sumstr = strstr (tempstr, " - No files")) != NULL)
{
*filesum=0;
sumstr [0]=0;
}
//Otherwise find checksum
else
{
sumstr = tempstr + strlen (tempstr); //Find checksum by finding the last space in the line
while ((sumstr [0] != ' ')&(sumstr != tempstr)) //
sumstr--; //
if (sumstr==tempstr) //
{
printf ("Comment: %s", tempstr); //If there is no space before the first character,
return (chk_err); //the line is invalid. Assume it is a comment.
};
sumstr [0] = 0; //Split string into path/filename and checksum
sumstr++; //
//convert checksum string to a number
if ((*filesum = readhex (sumstr))==-1)
{
printf ("Comment: %s %s\n", tempstr, sumstr); //If the checksum isn't a valid hex number
return (chk_err); //assume the line is a commment.
};
};
//Apply any translations that may be valid for this path/file.
if ((name = translate (tempstr, translations)) == NULL)
{
printf ("Need memory.");
return (mem_err);
};
//Make sure this file isn't excluded.
if (!excluded (name, exclusions))
{
//If there isn't a startpath then all files will be proccessed
//If there is a startpath then only the ones containing the path will be proccessed
if (startpath == NULL)
{
newname = name;
goto instartpath;
}
else if ((newname = strstr (name, startpath)) != NULL) //If this file is in startpath
{
newname = newname + strlen (startpath); //Remove startpath
instartpath: //This happens if one of the above conditions was true
//Remove path if doing a flat compare.
if (flags & F_flag)
{
while (strstr (newname, "\\") != NULL) // Remove path
{ //
newname = strstr (newname, "\\"); //
newname++; // and leading "\\"
};
};
//Make a final copy of the path/file to return
if ((*filename = _strdup (newname)) == NULL)
{
printf ("Memory err.");
free (name);
return (mem_err);
};
};
};
free (name);
return (0);
};
char loadsource1 (char *filename, struct checksums **sums,
struct translatetable *translations, struct excludetable * exclusions,
char *startpath, char flags)
{
FILE *chkfile;
char tempstr [chkfilelinelength];
char *name;
char err;
long tempsum;
struct checksums *newsum;
struct checksums **last; //Used to keep trak of the end of the linked list.
last = sums;
if ((chkfile = fopen (filename, "r"))==NULL)
{
printf ("Error opening source1.\n\n");
return (file_err);
};
//Proccess all lines
while (fgets (tempstr, chkfilelinelength, chkfile) != NULL)
{
//Verify that the entire line was read in and not just part of it
if (tempstr [strlen (tempstr)-1] != '\n')
{
printf ("Unexpected end of line. chkfilelinelength may need to be larger.\n %s\n", tempstr);
fclose (chkfile);
return (chk_err);
};
//Parse line
if ((err = proccessline (tempstr, translations, exclusions, startpath, flags, &name, &tempsum)) == 0)
{
//If this line was excluded or not in the path don't do anything, just go on to the next line.
if (name != NULL)
{
//Create a new structure and add it to the end of the linked list.
if ((newsum = malloc (sizeof (struct checksums) + strlen (name))) == NULL)
{ //Note: this is a variable length structure to fit any size of string.
printf ("Memory err.");
fclose (chkfile);
return (mem_err);
};
*last = newsum;
newsum->next = NULL;
newsum->sum = tempsum;
strcpy(&(newsum->filename), name);
last = &((*last)->next);
//Free temporary storage.
free (name);
};
}
else
{
if (err != chk_err) //Just skip line if it isn't understandable.
{
fclose (chkfile);
return (err);
};
};
};
//Ckeck to make sure it quit because it was done and not because of file errors.
if (ferror (chkfile))
{
printf ("Error reading source1.\n\n");
return (file_err);
};
if (fclose (chkfile))
{
printf ("Error closing source1.\n\nContinuing anyway...");
};
return (0);
};
char notnull_strcmp (struct checksums *sum, char *str)
// perform short circuit evaluation of ((sum != NULL) & (strcmp (&(sum->filename), str) != 0)
{
if (sum != NULL)
{
if (strcmp (&(sum->filename), str) != 0)
{
return (1);
};
};
return (0);
};
char comparesource2 (char *filename, struct checksums **sums,
struct checksums **extrasource2, struct checksums **missmatched,
struct translatetable *translations, struct excludetable * exclusions,
char *startpath, char flags)
{
FILE *chkfile;
char tempstr [chkfilelinelength];
char *name;
char err;
long tempsum;
struct checksums *newsum;
struct checksums *search;
struct checksums **lastlink;
if ((chkfile = fopen (filename, "r"))==NULL)
{
printf ("Error opening source2.\n\n");
return (file_err);
};
while (fgets (tempstr, chkfilelinelength, chkfile) != NULL)
{
//Verify that the entire line was read.
if (tempstr [strlen (tempstr)-1] != '\n')
{
printf ("Unexpected end of line. chkfilelinelength may need to be larger.\n %s\n", tempstr);
fclose (chkfile);
return (chk_err);
};
//Parse line
if ((err = proccessline (tempstr, NULL, exclusions, startpath, flags, &name, &tempsum)) == 0)
{
//If file was skipped do nothing
if (name != NULL)
{
//Prepare to look for a match
search = *sums;
lastlink = sums;
//short circuit evaluation of:(search != NULL) & (strcmp (&(search->filename), name) != 0)
while (notnull_strcmp (search, name))
{
search = search->next;
lastlink = &((*lastlink)->next);
};
if (search != NULL) //If a match was found
{ // remove it from the sums list
*lastlink = search->next; // by linking around it
if (search->sum == tempsum) // If checksums match
{ //
search->sum=0;
free (search); // Deallocate memory
} //
else // If the checksums didn't match
{ //
if ((newsum = malloc (sizeof (struct checksums) + strlen (name))) == NULL)
{ // Add 2nd name and checksum to missmatched list
printf ("Memory err."); //
fclose (chkfile); //
return (mem_err); //
}; //
newsum->next = *missmatched; //
newsum->sum = tempsum; //
strcpy(&(newsum->filename), name);
*missmatched = newsum; //
search->next = *missmatched; // Add 1st name to the missmatched list
*missmatched = search; //
}; //
} //
else //If no match was found
{ // this needs to be added to extrasource2 list
if ((newsum = malloc (sizeof (struct checksums) + strlen (name))) == NULL)
{ //Note: this is a variable length structure to fit any size of string.
printf ("Memory err.");
fclose (chkfile);
return (mem_err);
};
newsum->next = *extrasource2;
newsum->sum = tempsum;
strcpy(&(newsum->filename), name);
*extrasource2 = newsum;
};
//free temporary storage
free (name);
};
}
else
{
if (err != chk_err) //Just skip the line (don't abort) if it is bad
{
fclose (chkfile);
return (err);
};
};
};
if (ferror (chkfile))
{
printf ("Error reading source2.\n\n");
return (file_err);
};
if (fclose (chkfile))
{
printf ("Error closing source2.\n\nContinuing anyway...");
};
return (0);
};
void removewhitespace (char *str) // removes whitespace from the end of a string
{
int end;
end = strlen (str);
while ((end > 0)&((str [end-1] == '\n')|(str [end-1] == ' ')))
end--;
str [end] = 0;
};
char *strstrupcase (char *str1, char *str2)
{
char *temp;
size_t count;
size_t length;
length = strlen (str2);
for (temp = str1; strlen (temp) > length; temp++)
{
for (count = 0; (toupper (temp [count]) == toupper (str2 [count]))&(count < length); count++);
if (count==length)
{
return (temp);
};
};
return (NULL);
};
char proccess_exception_file (char *filename, struct translatetable **trans, struct excludetable **exclude, char **path)
{
FILE *efile;
char tempstr [exceptionfilelinelength];
char *start;
char *end;
struct translatetable *temp;
if ((efile = fopen (filename, "r"))==NULL)
{
printf ("Error opening excetion file.\n\n");
return (file_err);
}
while (fgets (tempstr, exceptionfilelinelength, efile) != NULL)
{
start = tempstr;
while (start [0] == ' ') //Remove leading whitespace
start++;
//If it is a translate command
if (strstrupcase (start, "TRANSLATE") == start)
{
start = start + 10; //Go past translate
while (start [0] == ' ') //skip spaces
start++;
if (start [0] == 0)
{
printf ("Unexpected end of line in exception file:\n%s", tempstr);
return (exep_err);
};
end = strstr (start, "-->"); //Find second part of string
if (end == NULL)
{
printf ("Line: %s \nmust have two file names separated by -->", tempstr);
return (exep_err);
}
end [0] = '\0'; //Split string
removewhitespace (start);
if ((temp = malloc (sizeof (struct translatetable))) == NULL)
{
printf ("Insufficient memory to load exception table.");
return (mem_err);
}
if ((temp->source1name = _strdup (start)) == NULL)
{
printf ("Unable to allocate memory for char temp->source1name in proccess_exception_file.\n");
free (temp);
return (mem_err);
}
start = end + 3;
while (start [0] == ' ') //Remove leading whitespace
start++;
if (start [0] == 0)
{
printf ("Unexpected end of line in exception file:\n %s", tempstr);
free (temp->source1name);
free (temp);
return (exep_err);
};
removewhitespace (start);
if ((temp->source2name = _strdup (start)) == NULL)
{
printf ("Unable to allocate memory for char temp->source1name in proccess_exception_file.\n");
free (temp->source1name);
free (temp);
return (mem_err);
}
temp->next = *trans;
*trans = temp;
}
//If it is an exclude command.
else if (strstrupcase (start, "EXCLUDE") == start)
{
start = start + 7; //Go past exclude
while (start [0] == ' ') //skip spaces
start++;
if (start [0] == 0)
{
printf ("Unexpected end of line in exception file:\n %s", tempstr);
return (exep_err);
};
removewhitespace (start);
if ((temp = malloc (sizeof (struct excludetable))) == NULL)
{
printf ("Insufficient memory to load exception table.");
return (mem_err);
}
if ((temp->source1name = _strdup (start)) == NULL) //source1name coresponds to path
{
printf ("Unable to allocate memory for char temp->path in proccess_exception_file.\n");
free (temp);
return (mem_err);
}
temp->next = (struct translatetable *) *exclude;
*exclude = (struct excludetable *) temp;
}
//If it is a startpath command
else if (strstrupcase (start, "STARTPATH") == start)
{
if (*path != NULL)
{
printf ("Only one STARTPATH command is allowed in the exception file.\n");
return (exep_err);
};
start = start + 9; //Go past startpath
while (start [0] == ' ') //skip spaces
start++;
if (start [0] == 0)
{
printf ("Unexpected end of line in exception file:\n %s", tempstr);
return (exep_err);
};
removewhitespace (start);
if ((*path = _strdup (start)) == NULL)
{
printf ("Unable to allocate memory for char path in proccess_exception_file.\n");
return (mem_err);
}
}
else if (!start [0] == ';') //if it's not a comment
{
printf ("Unexpected line in exception file:\n %s", tempstr);
return (exep_err);
};
};
if (ferror (efile))
{
printf ("Error reading exception file.\n\n");
return (file_err);
};
if (fclose (efile))
{
printf ("Error closing excetion file.\n\nContinuing anyway...");
};
return (0);
};
char proccess_command_line (int argc, char *argv[ ], char **source1, char **source2, char *flags, char **exception)
// flags: /F=1=(F_flag); /I1=2=(I1_flag); /I2=4=(I2_flag); /X=8=(X_flag)
{
int argloop;
*flags=0; //temporarily using 16=source1 found; 32=source2 found
for (argloop = 1;argloop < argc; argloop++)
{
if (argv[argloop][0] == '/')
{
if ((argv[argloop][1] == 'F')|(argv[argloop][1] == 'f')) //we got a /f
{
*flags|=F_flag; //duplicate flags will not cause errors
}
else if (argv[argloop][1] == '?')
{
completehelp ();
}
else if ((argv[argloop][1] == 'I')|(argv[argloop][1] == 'i'))
{
if (argv[argloop][2] == '1')
{
*flags|=I1_flag; //we got a /i1
}
else if (argv[argloop][2] == '2')
{
*flags|=I2_flag; //we got a /i2
}
else
{
printf ("Unknown switch \"/I%c\" .\n\n", argv[argloop][2]);
return (par_err);
}
}
else if ((argv[argloop][1] == 'X')|(argv[argloop][1] == 'x'))
{
*flags|=X_flag; // we got a /x
if (argloop+1 == argc)
{
printf ("Parameter /X must be followed by a filename.\n\n");
return (par_err);
};
if ((*exception = _strdup (argv [argloop + 1]))==NULL)
{
printf ("Unable to allocate memory for char *exception in proccess_command_line.\n");
error (mem_err);
};
argloop++; //to skip this parameter in the general parser
}
else
{
printf ("Unknown switch \"/%c\" .\n\n", argv[argloop][1]);
return (par_err);
}
}
else // it must be a source filename
{
if (!(*flags & 16)) //first source in command line
{
if ((*source1 = _strdup (argv [argloop]))==NULL)
{
printf ("Unable to allocate memory for char *source1 in proccess_command_line.\n");
return (mem_err);
};
*flags|=16;
}
else if (!(*flags & 32)) //second source in command line
{
if ((*source2 = _strdup (argv [argloop]))==NULL)
{
printf ("Unable to allocate memory for char *source2 in proccess_command_line.\n");
return (mem_err);
};
*flags|=32;
}
else
{
printf ("Too many source filenames in the command line.\n\n");
return (par_err);
};
};
};
if (!(*flags & 32))
{
printf ("Command line must contain two source files.\n\n");
return (par_err);
};
*flags|=(!(32+16)); // clear temporary source1 and source2 flags
return (0);
};
void completehelp ()
{
printf ("Usage:\n"
"CHKVERFY <Source1> <Source2> [/F] [/X <exceptionfile>] [/I1] [/I2]\n"
" /F = Flat share (ignore paths).\n"
" /I1 = Ignore extra files in Source1.\n"
" /I2 = Ignore extra files in Source2.\n"
" /X = excetion file with the following commands.\n"
" TRANSLATE <Source1name> --> <Source2name>\n"
" Replaces <Source1name> with <Sourece2name> whereever found.\n"
" Note: make sure the filename you are using is only in the full\n"
" filename of the files you mant to translate.\n\n"
" EXCLUDE <pathsegment>\n"
" Any path and file containing this string will be ignored.\n\n"
" STARTPATH <directory name>\n"
" Files without this string in the path will be ignored.\n"
" The part of the path before this string will be ignored.\n\n"
" Note: These three commands are proccessed in the order shown above. \n"
" For example, the command \"TRANSLATE C:\\nt --> C:\\\" will\n"
" override the command \"EXCLUDE C:\\nt\".\n"
" The order of commands in the exception files doesn't matter\n"
" unless two commands both try to translate the same file.\n"
" In that case, the last command in the file takes precedence.\n"
"Exit codes:\n" // These code values should match the codes defined above.
" 6 = Invalid command line arguments.\n"
" 5 = Error in exception file format.\n"
" 4 = Error in chkfile.\n"
" 3 = Memory allocation error.\n"
" 2 = File access error.\n"
" 1 = No errors: Source1 and Source2 failed compare.\n"
" 0 = No errors: Source1 and Source2 compared successfully.\n\n"
);
exit (0);
};
void error (char exitcode)
{
if (exitcode >= exep_err)
{
printf ("Usage:\n"
"CHKVERFY <Source1> <Source2> [/F] [/X <exceptionfile>] [/I1] [/I2]\n"
" /? = Complete help.\n"
" /F = Flat share (ignore paths).\n"
" /I1 = Ignore extra files in Source1.\n"
" /I2 = Ignore extra files in Source2.\n"
" /X = excetion file with the following commands.\n"
);
};
switch (exitcode)
{
case 0:
printf ("\n\n(0) Files compare okay.\n");
break;
case 1:
printf ("\n\n(1) Some files or checksums don't match.\n");
break;
case 2:
printf ("\n\n(2) Terminated due to file access error.\n");
break;
case 3:
printf ("\n\n(3) Terminated due to memory allocation error.\n");
break;
case 4:
printf ("\n\n(4) The format of the source files was not as expected.\n");
break;
case 5:
printf ("\n\n(5) Error in exception file format.\n");
break;
case 6:
printf ("\n\n(6) Bad command line argument.\n");
break;
};
exit (exitcode);
};