int match_fops_ioctl(struct inode *fops_inode, struct file *fops_file, unsigned int cmd, unsigned long arg)
{
static int inret = 1, otret = 1;
printk("match_fops_ioctl called.\n");
// printk("command[%d]\n", cmd);
if (_IOC_TYPE(cmd) != NF_IOC_MAGIC)
return -EINVAL;
if (_IOC_NR(cmd) > NF_IOC_MAXNR)
return -EINVAL;
switch (cmd)
{
case SET_MATCH_SEGMENT_IN :
inret = segment_load((struct segment_info*)arg, 0);
break;
case SET_MATCH_SEGMENT_OUT:
otret = segment_load((struct segment_info*)arg, 1);
break;
case SET_MATCH_PATTERN_IN :
if (inret == 0)
{
match_load((struct match_info*)arg, 0);
inret = 1;
}
break;
case SET_MATCH_PATTERN_OUT:
if (otret == 0)
{
match_load((struct match_info*)arg, 1);
otret = 1;
}
break;
}
return 0;
}
static void process_cmd_line(state *s, int argc, char **argv)
{
int i, match_files_loaded = FALSE;
while ((i=getopt(argc,argv,"avhVpdsblcxt:rm:k:")) != -1) {
switch(i) {
case 'a':
s->mode |= mode_display_all;
break;
case 'v':
if (MODE(mode_verbose))
{
print_error(s,"%s: Already at maximum verbosity", __progname);
print_error(s,
"%s: Error message display to user correctly",
__progname);
}
else
s->mode |= mode_verbose;
break;
case 'p':
s->mode |= mode_match_pretty;
break;
case 'd':
s->mode |= mode_directory;
break;
case 's':
s->mode |= mode_silent; break;
case 'b':
s->mode |= mode_barename; break;
case 'l':
s->mode |= mode_relative; break;
case 'c':
s->mode |= mode_csv; break;
case 'x':
if (MODE(mode_match) || MODE(mode_sigcompare))
fatal_error("Signature matching cannot be combined with other matching modes");
s->mode |= mode_sigcompare; break;
case 'r':
s->mode |= mode_recursive; break;
case 't':
s->threshold = (uint8_t)atol(optarg);
if (s->threshold > 100)
fatal_error("%s: Illegal threshold", __progname);
s->mode |= mode_threshold;
break;
case 'm':
if (MODE(mode_compare_unknown) || MODE(mode_sigcompare))
fatal_error("Positive matching cannot be combined with other matching modes");
s->mode |= mode_match;
if (!match_load(s,optarg))
match_files_loaded = TRUE;
break;
case 'k':
if (MODE(mode_match) || MODE(mode_sigcompare))
fatal_error("Signature matching cannot be combined with other matching modes");
s->mode |= mode_compare_unknown;
if (!match_load(s,optarg))
match_files_loaded = TRUE;
break;
case 'h':
usage();
exit (EXIT_SUCCESS);
case 'V':
print_status ("%s", VERSION);
exit (EXIT_SUCCESS);
default:
try_msg();
exit (EXIT_FAILURE);
}
}
// We don't include mode_sigcompare in this list as we haven't loaded
// the matching files yet. In that mode the matching files are in fact
// the command line arguments.
sanity_check(s,
((MODE(mode_match) || MODE(mode_compare_unknown))
&& !match_files_loaded),
"No matching files loaded");
sanity_check(s,
((s->mode & mode_barename) && (s->mode & mode_relative)),
"Relative paths and bare names are mutually exclusive");
sanity_check(s,
((s->mode & mode_match_pretty) && (s->mode & mode_directory)),
"Directory mode and pretty matching are mutallty exclusive");
}
int main(int argc, char **argv)
{
int count, status, goal = argc;
state *s;
TCHAR *fn, *cwd;
#ifndef __GLIBC__
__progname = basename(argv[0]);
#endif
s = (state *)malloc(sizeof(state));
if (NULL == s)
fatal_error("%s: Unable to allocate state variable", __progname);
if (initialize_state(s))
fatal_error("%s: Unable to initialize state variable", __progname);
process_cmd_line(s,argc,argv);
#ifdef _WIN32
if (prepare_windows_command_line(s))
fatal_error("%s: Unable to process command line arguments", __progname);
#else
s->argc = argc;
s->argv = argv;
#endif
// Anything left on the command line at this point is a file
// or directory we're supposed to process. If there's nothing
// specified, we should tackle standard input
if (optind == argc)
{
status = process_stdin(s);
}
else
{
MD5DEEP_ALLOC(TCHAR,fn,PATH_MAX);
MD5DEEP_ALLOC(TCHAR,cwd,PATH_MAX);
cwd = _tgetcwd(cwd,PATH_MAX);
if (NULL == cwd)
fatal_error("%s: %s", __progname, strerror(errno));
count = optind;
// The signature comparsion mode needs to use the command line
// arguments and argument count. We don't do wildcard expansion
// on it on Win32 (i.e. where it matters). The setting of 'goal'
// to the original argc occured at the start of main(), so we just
// need to update it if we're *not* in signature compare mode.
if (!(s->mode & mode_sigcompare))
{
goal = s->argc;
}
while (count < goal)
{
if (MODE(mode_sigcompare))
match_load(s,argv[count]);
else if (MODE(mode_compare_unknown))
match_compare_unknown(s,argv[count]);
else
{
generate_filename(s,fn,cwd,s->argv[count]);
#ifdef _WIN32
status = process_win32(s,fn);
#else
status = process_normal(s,fn);
#endif
}
++count;
}
// If we processed files, but didn't find anything large enough
// to be meaningful, we should display a warning message to the user.
// This happens mostly when people are testing very small files
// e.g. $ echo "hello world" > foo && ssdeep foo
if ( ! s->found_meaningful_file && s->processed_file)
{
print_error(s,"%s: Did not process files large enough to produce meaningful results", __progname);
}
}
// If the user has requested us to compare signature files, use
// our existng code to pretty-print directory matching to do the
// work for us.
if (s->mode & mode_sigcompare)
s->mode |= mode_match_pretty;
if (s->mode & mode_match_pretty)
match_pretty(s);
return (EXIT_SUCCESS);
}
