/*!
Main function
Based on arguments to main, either
\list
\o access files
\o send an internet message
\o write one simple file
\endlist
*/
int main( int argc, char *argv[] )
{
int fd;
printf( "%s (PID %d) running", argv[0], getpid() );
if ( argc > 1 )
{
const char *ptr = argv[1];
while ( *ptr && isdigit( *ptr++ )) {}
if ( *ptr == '\0' )
send_message( atoi( argv[1] ), argc > 2 ? argv[2] : NULL,
argc > 3 ? argv[3] : NULL );
else
process_files( argv+1, argc-1 );
}
else
{
printf( "Open and write \"test.txt\"" );
fd = open( "test.txt", O_WRONLY | O_CREAT, S_IWUSR );
if ( fd == -1 )
fatal( (char*)strerror( errno ));
write( fd, SIMPLE_MESSAGE, strlen( SIMPLE_MESSAGE ));
close( fd );
}
return 0;
}
int main(int argc, char * argv[])
{
unsigned int plateform_id;
if(argc < 2) {
fprintf(stderr, "You need to provide a <platform id> "
"<directoy>. Use make print_cl_infos "
"to discover your platform and device id.\n");
exit(EXIT_FAILURE);
}
plateform_id = atoi(argv[1]);
list_t *files = list_files(argv[3]);
clinfo_t *clinfo = clinfo_init(KERNEL_PATH, KERNEL_FUNCTION
, plateform_id);
list_t *results = process_files(clinfo, files, 0.01f);
list_t *current = results;
while(current) {
list_t *subcurrent = current->value;
while(subcurrent) {
printf("\"%s\"\n", subcurrent->value);
subcurrent = subcurrent->next;
}
printf("\n");
current = current->next;
}
return 0;
}
void build_share(char *fname, FILE *fp, FILE *fpo) {
assert(fname);
assert(fp);
assert(fpo);
process_files(fname, fp, "/usr/share", share_callback);
if (share_out == NULL)
fprintf(fpo, "blacklist /usr/share\n");
else
filedb_print(share_out, "whitelist ", fpo);
}
void build_var(char *fname, FILE *fp, FILE *fpo) {
assert(fname);
assert(fp);
assert(fpo);
process_files(fname, fp, "/var", var_callback);
if (var_out == NULL)
fprintf(fpo, "blacklist /var\n");
else
filedb_print(var_out, "whitelist ", fpo);
}
void compress(int argc, char **argv, int verb) {
int i, size;
IS is;
Dllist dir_list, DLLnode;
JRB inode, JRBnode, paths, links;
void *buf;
tar *t;
links = make_jrb();
dir_list = new_dllist();
inode = make_jrb();
JRBnode = make_jrb();
paths = make_jrb();
for(i = 2; i < argc; i++){
process_files(dir_list, inode, paths, argv[i], links);
}
dll_traverse(DLLnode, dir_list){
process_files(dir_list, inode, paths, jval_s(DLLnode->val),links);
}
void RelaxEngine::prepareFiles(CopyList &filesList, const QStringList &pathsToScan,
const QList<FilterPair> &pair)
{
QString a_path;
QStringList founds;
foreach(a_path, pathsToScan){
if(scanNested){
get_nested_files(a_path, founds);
}else{
shallowWalk(a_path, founds);
}
}
process_files(founds, filesList, pair);
}
int main(int argc, char **argv){
char *keyfilename, *outputfilename;
char **files;
FILE *keyfile;
char error = 0;
if(argc < 5 || ((argc -1)%2) != 0){
usage(argv[0]);
exit(-1);
}
keyfilename = argv[1];
outputfilename = argv[2];
ERR_load_crypto_strings();
OpenSSL_add_all_algorithms();
OPENSSL_config(NULL);
if(NULL == (keyfile = fopen(keyfilename, "r"))){
print_error("main", "unable to open private key", keyfilename);
exit(-1);
}
if(NULL == (private_key = PEM_read_PrivateKey(keyfile, NULL, NULL, NULL))){
print_error("main", "reading private key file. File in PEM format?", keyfilename);
error = 1; goto error;
}
if(NULL == (outputfile = fopen(outputfilename, "w"))){
print_error("main", "unable to open output file", outputfilename);
exit(-1);
}
files = argv+3;
process_files(files, argc - 3);
error:
CONF_modules_free();
EVP_cleanup();
ERR_free_strings();
if(keyfile) fclose(keyfile);
if(outputfile) fclose(outputfile);
if(error)
return -1;
return 0;
}
//Check on a queue and do something specific...
//If qtype == 0, directories,
//qtype ==1, files
void queue_checker(queue_t * queue,
unsigned int num_items,
unsigned int qtype,
queue_t * other_queue,
unsigned int * num_found,
char * to_find)
{
//Alright, let's check if there something in here
if(queue_empty(queue))
{
//Empty, done here.
return;
}
else
{
//Queue not empty
//Try to pull off some items
unsigned int items_got = 0;
queue_t * tmp_items = get_items(queue, num_items, &items_got);
//Did we get some items?
if(items_got > 0)
{
//Do the specfic task for these items, with specific args
if(qtype == 0)
{
//Dirs
//printf("%d got dir items\n", items_got);
process_dirs(tmp_items, other_queue, queue);
}
else
{
//Files
//printf("%d got file items\n", items_got);
process_files(tmp_items, num_found, to_find);
}
}
else
{
//No items gotten, done here
return;
}
}
}
void build_etc(char *fname, FILE *fp, FILE *fpo) {
assert(fname);
assert(fp);
assert(fpo);
process_files(fname, fp, "/etc", etc_callback);
fprintf(fpo, "private-etc ");
if (etc_out == NULL)
fprintf(fpo, "none\n");
else {
FileDB *ptr = etc_out;
while (ptr) {
fprintf(fpo, "%s,", ptr->fname);
ptr = ptr->next;
}
fprintf(fpo, "\n");
}
}
/*-----------------------------------------------------------------------------
* Parse command line, set options, including opts.files with list of
* input files, including parsing of '@' lists
*----------------------------------------------------------------------------*/
void parse_argv( int argc, char *argv[] )
{
int arg;
init_module();
if ( argc == 1 )
exit_copyright(); /* exit if no arguments */
process_options( &arg, argc, argv ); /* process all options, set arg to next */
if ( arg >= argc )
error_no_src_file(); /* no source file */
if ( opts.verbose )
display_options(); /* display status messages of select assembler options */
if ( ! get_num_errors() )
process_files( arg, argc, argv ); /* process each source file */
}
void build_dev(char *fname, FILE *fp, FILE *fpo) {
assert(fname);
assert(fp);
assert(fpo);
process_files(fname, fp, "/dev", dev_callback);
if (dev_out == NULL)
fprintf(fpo, "private-dev\n");
else {
fprintf(fpo, "\n");
fprintf(fpo, "# private-dev\n");
fprintf(fpo, "# This is the list of devices accessed (on top of regular private-dev devices:\n");
fprintf(fpo, "# ");
FileDB *ptr = dev_out;
while (ptr) {
fprintf(fpo, "%s,", ptr->fname);
ptr = ptr->next;
}
fprintf(fpo, "\n");
}
}
void build_tmp(char *fname, FILE *fp, FILE *fpo) {
assert(fname);
assert(fp);
assert(fpo);
process_files(fname, fp, "/tmp", tmp_callback);
if (tmp_out == NULL)
fprintf(fpo, "private-tmp\n");
else {
fprintf(fpo, "\n");
fprintf(fpo, "# private-tmp\n");
fprintf(fpo, "# File accessed in /tmp directory:\n");
fprintf(fpo, "# ");
FileDB *ptr = tmp_out;
while (ptr) {
fprintf(fpo, "%s,", ptr->fname);
ptr = ptr->next;
}
printf("\n");
}
}
/**
* RHash program entry point.
*
* @param argc number of program arguments including the program path
* @param argv program arguments
* @return the program exit code, zero on success and 1 on error
*/
int main(int argc, char *argv[])
{
i18n_initialize(); /* initialize locale and translation */
memset(&rhash_data, 0, sizeof(rhash_data));
rhash_data.out = stdout; /* set initial output streams */
rhash_data.log = stderr; /* can be altered by options later */
init_hash_info_table();
read_options(argc, argv); /* load config and parse command line options */
prev_sigint_handler = signal(SIGINT, ctrl_c_handler); /* install SIGINT handler */
rhash_library_init();
/* in benchmark mode just run benchmark and exit */
if(opt.mode & MODE_BENCHMARK) {
unsigned flags = (opt.flags & OPT_BENCH_RAW ? RHASH_BENCHMARK_CPB | RHASH_BENCHMARK_RAW : RHASH_BENCHMARK_CPB);
if((opt.flags & OPT_BENCH_RAW) == 0) {
fprintf(rhash_data.out, _("%s v%s benchmarking...\n"), PROGRAM_NAME, VERSION);
}
rhash_run_benchmark(opt.sum_flags, flags, rhash_data.out);
rsh_exit(0);
}
if(opt.n_files == 0) {
if(argc > 1) {
log_warning(_("no files/directories were specified at command line\n"));
}
/* print short usage help */
log_msg(_("Usage: %s [OPTION...] <FILE>...\n\n"
"Run `%s --help' for more help.\n"), CMD_FILENAME, CMD_FILENAME);
rsh_exit(0);
}
/* setup printf formating string */
rhash_data.printf_str = opt.printf_str;
if(opt.template_file) {
if(!load_printf_template()) rsh_exit(2);
} else if(!rhash_data.printf_str && !(opt.mode & (MODE_CHECK | MODE_CHECK_EMBEDDED))) {
/* initialize printf output format according to '--<hashname>' options */
init_printf_format( (rhash_data.template_text = rsh_str_new()) );
rhash_data.printf_str = rhash_data.template_text->str;
if(opt.flags & OPT_VERBOSE) {
char* str = rsh_strdup(rhash_data.printf_str);
log_msg(_("Format string is: %s\n"), str_trim(str));
free(str);
}
}
if(rhash_data.printf_str) {
rhash_data.print_list = parse_print_string(rhash_data.printf_str, &opt.sum_flags);
}
preprocess_files();
process_files();
options_destroy(&opt);
rhash_destroy(&rhash_data);
return (rhash_data.error_flag ? 1 : 0);
}
int main(int argc, char** argv)
{
try {
int c;
// int digit_optind = 0;
while (1) {
// int this_option_index = optind ? optind : 1;
int option_index = 0;
static struct option long_options[] = {
{ "help", no_argument, nullptr, 0 },
{ "version", no_argument, nullptr, 0 },
{ 0, 0, nullptr, 0 }
};
c = getopt_long(argc, argv, "", long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 0:
if (std::strncmp(long_options[option_index].name, "help", strlen("help")) == 0)
print_help(argv[0]);
if (std::strncmp(long_options[option_index].name, "version", strlen("version")) == 0)
print_version(argv[0]);
break;
case '?':
default:
print_usage(argv[0]);
break;
}
}
// no paths specified to process, so let the user know we need at least one
if (optind >= argc)
print_usage(argv[0]);
// collect all the files from the paths specified by the user
String_Bag paths_to_process;
while (optind < argc)
paths_to_process.push_back(argv[optind++]);
std::cerr << "Paths to process " << paths_to_process.size() << '\n';
File_Bag files = get_files_to_process(paths_to_process);
std::cerr << "Files found " << files.size() << '\n';
// write the hashes to our database
sqlite_db db = open_or_create_db();
process_files(files, db);
auto rv = db.close();
if (rv != SQLITE_OK)
throw std::runtime_error(db.errmsg());
}
catch (os_error& ex) {
std::cerr << argv[0] << ": os error " << ex.err() << " - " << ex.what() << std::endl;
std::exit(EXIT_FAILURE);
}
catch (std::runtime_error& ex) {
std::cerr << argv[0] << ": " << ex.what() << std::endl;
std::exit(EXIT_FAILURE);
}
catch (std::exception& ex) {
std::cerr << argv[0] << ": unknown error - " << ex.what() << std::endl;
std::exit(EXIT_FAILURE);
}
return EXIT_SUCCESS;
}
/**
* RHash program entry point.
*
* @param argc number of program arguments including the program path
* @param argv program arguments
* @return the program exit code, zero on success and 1 on error
*/
int main(int argc, char *argv[])
{
find_file_options search_opt;
timedelta_t timer;
int sfv;
i18n_initialize(); /* initialize locale and translation */
memset(&rhash_data, 0, sizeof(rhash_data));
rhash_data.out = stdout; /* set initial output streams */
rhash_data.log = stderr; /* can be altered by options later */
rhash_data.search_opt = &search_opt;
init_hash_info_table();
read_options(argc, argv); /* load config and parse command line options */
prev_sigint_handler = signal(SIGINT, ctrl_c_handler); /* install SIGINT handler */
rhash_library_init();
/* in benchmark mode just run benchmark and exit */
if(opt.mode & MODE_BENCHMARK) {
unsigned flags = (opt.flags & OPT_BENCH_RAW ? RHASH_BENCHMARK_CPB | RHASH_BENCHMARK_RAW : RHASH_BENCHMARK_CPB);
if((opt.flags & OPT_BENCH_RAW) == 0) {
fprintf(rhash_data.out, _("%s v%s benchmarking...\n"), PROGRAM_NAME, VERSION);
}
rhash_run_benchmark(opt.sum_flags, flags, rhash_data.out);
rsh_exit(0);
}
if(opt.n_files == 0) {
if(argc > 1) {
log_warning(_("no files/directories were specified at command line\n"));
}
/* print short usage help */
log_msg(_("Usage: %s [OPTION...] <FILE>...\n\n"
"Run `%s --help' for more help.\n"), CMD_FILENAME, CMD_FILENAME);
rsh_exit(0);
}
/* setup printf formating string */
rhash_data.printf_str = opt.printf_str;
if(opt.template_file) {
if(!load_printf_template()) rsh_exit(2);
} else if(!rhash_data.printf_str && !(opt.mode & (MODE_CHECK | MODE_CHECK_EMBEDDED))) {
/* initialize printf output format according to '--<hashname>' options */
init_printf_format( (rhash_data.template_text = rsh_str_new()) );
rhash_data.printf_str = rhash_data.template_text->str;
if(opt.flags & OPT_VERBOSE) {
char* str = rsh_strdup(rhash_data.printf_str);
log_msg(_("Format string is: %s\n"), str_trim(str));
free(str);
}
}
if(rhash_data.printf_str) {
rhash_data.print_list = parse_print_string(rhash_data.printf_str, &opt.sum_flags);
}
memset(&search_opt, 0, sizeof(search_opt));
search_opt.max_depth = (opt.flags & OPT_RECURSIVE ? opt.find_max_depth : 0);
search_opt.options = FIND_SKIP_DIRS;
search_opt.call_back = find_file_callback;
if((sfv = (opt.fmt == FMT_SFV && !opt.mode))) {
print_sfv_banner(rhash_data.out);
}
/* pre-process files */
if(sfv || opt.bt_batch_file) {
/* note: errors are not reported on pre-processing */
search_opt.call_back_data = (void*)1;
process_files((const char**)opt.files, opt.n_files, &search_opt);
fflush(rhash_data.out);
}
/* measure total processing time */
rhash_timer_start(&timer);
rhash_data.processed = 0;
/* process files */
search_opt.options |= FIND_LOG_ERRORS;
search_opt.call_back_data = (void*)0;
process_files((const char**)opt.files, opt.n_files, &search_opt);
if((opt.mode & MODE_CHECK_EMBEDDED) && rhash_data.processed > 1) {
print_check_stats();
}
if(!rhash_data.interrupted)
{
if(opt.bt_batch_file && rhash_data.rctx) {
rhash_final(rhash_data.rctx, 0);
save_torrent_to(opt.bt_batch_file, rhash_data.rctx);
}
if((opt.flags & OPT_SPEED) &&
!(opt.mode & (MODE_CHECK | MODE_UPDATE)) &&
rhash_data.processed > 1) {
double time = rhash_timer_stop(&timer);
print_time_stats(time, rhash_data.total_size, 1);
}
} else {
/* check if interruption was not reported yet */
if(rhash_data.interrupted == 1) report_interrupted();
}
options_destroy(&opt);
rhash_destroy(&rhash_data);
/* return non-zero error code if error occurred */
return (rhash_data.error_flag ? 1 :
search_opt.errors_count ? 2 :
rhash_data.interrupted ? 3 : 0);
}
int sed_main(int argc UNUSED_PARAM, char **argv)
{
unsigned opt;
llist_t *opt_e, *opt_f;
char *opt_i;
#if ENABLE_LONG_OPTS
static const char sed_longopts[] ALIGN1 =
/* name has_arg short */
"in-place\0" Optional_argument "i"
"regexp-extended\0" No_argument "r"
"quiet\0" No_argument "n"
"silent\0" No_argument "n"
"expression\0" Required_argument "e"
"file\0" Required_argument "f";
#endif
INIT_G();
/* destroy command strings on exit */
if (ENABLE_FEATURE_CLEAN_UP) atexit(sed_free_and_close_stuff);
/* Lie to autoconf when it starts asking stupid questions. */
if (argv[1] && strcmp(argv[1], "--version") == 0) {
puts("This is not GNU sed version 4.0");
return 0;
}
/* do normal option parsing */
opt_e = opt_f = NULL;
opt_i = NULL;
/* -i must be first, to match OPT_in_place definition */
/* -E is a synonym of -r:
* GNU sed 4.2.1 mentions it in neither --help
* nor manpage, but does recognize it.
*/
opt = getopt32long(argv, "^"
"i::rEne:*f:*"
"\0" "nn"/*count -n*/,
sed_longopts,
&opt_i, &opt_e, &opt_f,
&G.be_quiet); /* counter for -n */
//argc -= optind;
argv += optind;
if (opt & OPT_in_place) { // -i
die_func = cleanup_outname;
}
if (opt & (2|4))
G.regex_type |= REG_EXTENDED; // -r or -E
//if (opt & 8)
// G.be_quiet++; // -n (implemented with a counter instead)
while (opt_e) { // -e
add_cmd_block(llist_pop(&opt_e));
}
while (opt_f) { // -f
char *line;
FILE *cmdfile;
cmdfile = xfopen_stdin(llist_pop(&opt_f));
while ((line = xmalloc_fgetline(cmdfile)) != NULL) {
add_cmd(line);
free(line);
}
fclose_if_not_stdin(cmdfile);
}
/* if we didn't get a pattern from -e or -f, use argv[0] */
if (!(opt & 0x30)) {
if (!*argv)
bb_show_usage();
add_cmd_block(*argv++);
}
/* Flush any unfinished commands. */
add_cmd("");
/* By default, we write to stdout */
G.nonstdout = stdout;
/* argv[0..(argc-1)] should be names of file to process. If no
* files were specified or '-' was specified, take input from stdin.
* Otherwise, we process all the files specified. */
G.input_file_list = argv;
if (!argv[0]) {
if (opt & OPT_in_place)
bb_error_msg_and_die(bb_msg_requires_arg, "-i");
argv[0] = (char*)bb_msg_standard_input;
/* G.last_input_file = 0; - already is */
} else {
goto start;
for (; *argv; argv++) {
struct stat statbuf;
int nonstdoutfd;
sed_cmd_t *sed_cmd;
G.last_input_file++;
start:
if (!(opt & OPT_in_place)) {
if (LONE_DASH(*argv)) {
*argv = (char*)bb_msg_standard_input;
process_files();
}
continue;
}
/* -i: process each FILE separately: */
if (stat(*argv, &statbuf) != 0) {
bb_simple_perror_msg(*argv);
G.exitcode = EXIT_FAILURE;
G.current_input_file++;
continue;
}
G.outname = xasprintf("%sXXXXXX", *argv);
nonstdoutfd = xmkstemp(G.outname);
G.nonstdout = xfdopen_for_write(nonstdoutfd);
/* Set permissions/owner of output file */
/* chmod'ing AFTER chown would preserve suid/sgid bits,
* but GNU sed 4.2.1 does not preserve them either */
fchmod(nonstdoutfd, statbuf.st_mode);
fchown(nonstdoutfd, statbuf.st_uid, statbuf.st_gid);
process_files();
fclose(G.nonstdout);
G.nonstdout = stdout;
if (opt_i) {
char *backupname = xasprintf("%s%s", *argv, opt_i);
xrename(*argv, backupname);
free(backupname);
}
/* else unlink(*argv); - rename below does this */
xrename(G.outname, *argv); //TODO: rollback backup on error?
free(G.outname);
G.outname = NULL;
/* Fix disabled range matches and mangled ",+N" ranges */
for (sed_cmd = G.sed_cmd_head; sed_cmd; sed_cmd = sed_cmd->next) {
sed_cmd->beg_line = sed_cmd->beg_line_orig;
sed_cmd->end_line = sed_cmd->end_line_orig;
}
}
/* Here, to handle "sed 'cmds' nonexistent_file" case we did:
* if (G.current_input_file[G.current_input_file] == NULL)
* return G.exitcode;
* but it's not needed since process_files() works correctly
* in this case too. */
}
process_files();
return G.exitcode;
}
int sed_main(int argc UNUSED_PARAM, char **argv)
{
unsigned opt;
llist_t *opt_e, *opt_f;
char *opt_i;
#if ENABLE_LONG_OPTS
static const char sed_longopts[] ALIGN1 =
/* name has_arg short */
"in-place\0" Optional_argument "i"
"regexp-extended\0" No_argument "r"
"quiet\0" No_argument "n"
"silent\0" No_argument "n"
"expression\0" Required_argument "e"
"file\0" Required_argument "f";
#endif
int status = EXIT_SUCCESS;
INIT_G();
/* destroy command strings on exit */
if (ENABLE_FEATURE_CLEAN_UP) atexit(sed_free_and_close_stuff);
/* Lie to autoconf when it starts asking stupid questions. */
if (argv[1] && strcmp(argv[1], "--version") == 0) {
puts("This is not GNU sed version 4.0");
return 0;
}
/* do normal option parsing */
opt_e = opt_f = NULL;
opt_i = NULL;
opt_complementary = "e::f::" /* can occur multiple times */
"nn"; /* count -n */
IF_LONG_OPTS(applet_long_options = sed_longopts);
/* -i must be first, to match OPT_in_place definition */
opt = getopt32(argv, "i::rne:f:", &opt_i, &opt_e, &opt_f,
&G.be_quiet); /* counter for -n */
//argc -= optind;
argv += optind;
if (opt & OPT_in_place) { // -i
atexit(cleanup_outname);
}
if (opt & 0x2) G.regex_type |= REG_EXTENDED; // -r
//if (opt & 0x4) G.be_quiet++; // -n
while (opt_e) { // -e
add_cmd_block(llist_pop(&opt_e));
}
while (opt_f) { // -f
char *line;
FILE *cmdfile;
cmdfile = xfopen_for_read(llist_pop(&opt_f));
while ((line = xmalloc_fgetline(cmdfile)) != NULL) {
add_cmd(line);
free(line);
}
fclose(cmdfile);
}
/* if we didn't get a pattern from -e or -f, use argv[0] */
if (!(opt & 0x18)) {
if (!*argv)
bb_show_usage();
add_cmd_block(*argv++);
}
/* Flush any unfinished commands. */
add_cmd("");
/* By default, we write to stdout */
G.nonstdout = stdout;
/* argv[0..(argc-1)] should be names of file to process. If no
* files were specified or '-' was specified, take input from stdin.
* Otherwise, we process all the files specified. */
if (argv[0] == NULL) {
if (opt & OPT_in_place)
bb_error_msg_and_die(bb_msg_requires_arg, "-i");
add_input_file(stdin);
} else {
int i;
for (i = 0; argv[i]; i++) {
struct stat statbuf;
int nonstdoutfd;
FILE *file;
sed_cmd_t *sed_cmd;
if (LONE_DASH(argv[i]) && !(opt & OPT_in_place)) {
add_input_file(stdin);
process_files();
continue;
}
file = fopen_or_warn(argv[i], "r");
if (!file) {
status = EXIT_FAILURE;
continue;
}
add_input_file(file);
if (!(opt & OPT_in_place)) {
continue;
}
/* -i: process each FILE separately: */
G.outname = xasprintf("%sXXXXXX", argv[i]);
nonstdoutfd = xmkstemp(G.outname);
G.nonstdout = xfdopen_for_write(nonstdoutfd);
/* Set permissions/owner of output file */
fstat(fileno(file), &statbuf);
/* chmod'ing AFTER chown would preserve suid/sgid bits,
* but GNU sed 4.2.1 does not preserve them either */
fchmod(nonstdoutfd, statbuf.st_mode);
fchown(nonstdoutfd, statbuf.st_uid, statbuf.st_gid);
process_files();
fclose(G.nonstdout);
G.nonstdout = stdout;
if (opt_i) {
char *backupname = xasprintf("%s%s", argv[i], opt_i);
xrename(argv[i], backupname);
free(backupname);
}
/* else unlink(argv[i]); - rename below does this */
xrename(G.outname, argv[i]); //TODO: rollback backup on error?
free(G.outname);
G.outname = NULL;
/* Re-enable disabled range matches */
for (sed_cmd = G.sed_cmd_head; sed_cmd; sed_cmd = sed_cmd->next) {
sed_cmd->beg_line = sed_cmd->beg_line_orig;
}
}
/* Here, to handle "sed 'cmds' nonexistent_file" case we did:
* if (G.current_input_file >= G.input_file_count)
* return status;
* but it's not needed since process_files() works correctly
* in this case too. */
}
process_files();
return status;
}
static int ls(char **args, int num)
{
char **found_files;
int num_found = 0, total = 0;
int status = 0;
int retval;
#if defined(__APPLE__) && defined(__MACH__)
add_error_table(&et_del_error_table);
#else
initialize_del_error_table();
#endif
if ((retval = initialize_tree())) {
error("initialize_tree");
return retval;
}
for ( ; num; num--) {
if ((retval = get_the_files(args[num - 1], &num_found,
&found_files))) {
error(args[num - 1]);
status = retval;
continue;
}
if (num_found) {
num_found = process_files(found_files, num_found);
if (num_found < 0) {
error("process_files");
status = error_code;
continue;
}
total += num_found;
}
else {
/* What we do at this point depends on exactly what the
* filename is. There are several possible conditions:
* 1. The filename has no wildcards in it, which means that
* if we couldn't find it, that means it doesn't
* exist. Print a not found error.
* 2. Filename is an existing directory, with no deleted
* files in it. Print nothing.
* 3. Filename doesn't exist, and there are wildcards in
* it. Print "no match".
* None of these are considered error conditions, so we
* don't set the error flag.
*/
if (no_wildcards(args[num - 1])) {
if (! directory_exists(args[num - 1])) {
set_error(ENOENT);
error(args[num - 1]);
status = error_code;
continue;
}
}
else {
set_error(DELETE_ENOMATCH);
error(args[num - 1]);
status = error_code;
continue;
}
}
}
if (total) {
if (list_files()) {
error("list_files");
return error_code;
}
}
if (yield) {
char *friendly = space_to_friendly(space_total);
printf("\nTotal space taken up by file%s: %s\n",
(total == 1 ? "" : "s"), friendly);
free(friendly);
}
return status;
}
int sed_main(int argc ATTRIBUTE_UNUSED, char **argv)
{
enum {
OPT_in_place = 1 << 0,
};
unsigned opt;
llist_t *opt_e, *opt_f;
int status = EXIT_SUCCESS;
INIT_G();
/* destroy command strings on exit */
if (ENABLE_FEATURE_CLEAN_UP) atexit(sed_free_and_close_stuff);
/* Lie to autoconf when it starts asking stupid questions. */
if (argv[1] && !strcmp(argv[1], "--version")) {
puts("This is not GNU sed version 4.0");
return 0;
}
/* do normal option parsing */
opt_e = opt_f = NULL;
opt_complementary = "e::f::" /* can occur multiple times */
"nn"; /* count -n */
opt = getopt32(argv, "irne:f:", &opt_e, &opt_f,
&G.be_quiet); /* counter for -n */
//argc -= optind;
argv += optind;
if (opt & OPT_in_place) { // -i
atexit(cleanup_outname);
}
if (opt & 0x2) G.regex_type |= REG_EXTENDED; // -r
//if (opt & 0x4) G.be_quiet++; // -n
while (opt_e) { // -e
add_cmd_block(llist_pop(&opt_e));
}
while (opt_f) { // -f
char *line;
FILE *cmdfile;
cmdfile = xfopen(llist_pop(&opt_f), "r");
while ((line = xmalloc_fgetline(cmdfile)) != NULL) {
add_cmd(line);
free(line);
}
fclose(cmdfile);
}
/* if we didn't get a pattern from -e or -f, use argv[0] */
if (!(opt & 0x18)) {
if (!*argv)
bb_show_usage();
add_cmd_block(*argv++);
}
/* Flush any unfinished commands. */
add_cmd("");
/* By default, we write to stdout */
G.nonstdout = stdout;
/* argv[0..(argc-1)] should be names of file to process. If no
* files were specified or '-' was specified, take input from stdin.
* Otherwise, we process all the files specified. */
if (argv[0] == NULL) {
if (opt & OPT_in_place)
bb_error_msg_and_die(bb_msg_requires_arg, "-i");
add_input_file(stdin);
process_files();
} else {
int i;
FILE *file;
for (i = 0; argv[i]; i++) {
struct stat statbuf;
int nonstdoutfd;
if (LONE_DASH(argv[i]) && !(opt & OPT_in_place)) {
add_input_file(stdin);
process_files();
continue;
}
file = fopen_or_warn(argv[i], "r");
if (!file) {
status = EXIT_FAILURE;
continue;
}
if (!(opt & OPT_in_place)) {
add_input_file(file);
continue;
}
G.outname = xasprintf("%sXXXXXX", argv[i]);
nonstdoutfd = mkstemp(G.outname);
if (-1 == nonstdoutfd)
bb_perror_msg_and_die("cannot create temp file %s", G.outname);
G.nonstdout = fdopen(nonstdoutfd, "w");
/* Set permissions of output file */
fstat(fileno(file), &statbuf);
fchmod(nonstdoutfd, statbuf.st_mode);
add_input_file(file);
process_files();
fclose(G.nonstdout);
G.nonstdout = stdout;
/* unlink(argv[i]); */
xrename(G.outname, argv[i]);
free(G.outname);
G.outname = NULL;
}
if (G.input_file_count > G.current_input_file)
process_files();
}
return status;
}
int main(int argc, char** argv)
{
SETTINGS settings;
int option_index = 1,
ret,
i,
bits;
#ifdef _WIN32
char CmdDir[MAX_PATH];
char *p;
#endif
memset(&settings, 0, sizeof(settings));
settings.first_file = 1;
settings.radio = 1;
settings.clip_prev = 1;
settings.outbitwidth = 16;
settings.format = WAV_NO_FMT;
#ifdef _WIN32
/* Is this good enough? Or do we need to consider multi-byte codepages as
* well?
*/
SetConsoleOutputCP(GetACP());
GetModuleFileName(NULL, CmdDir, MAX_PATH);
p = strrchr(CmdDir, '\\') + 1;
p[0] = '\0';
#endif
while ((ret = getopt_long(argc, argv, ARG_STRING, long_options, &option_index)) != -1) {
switch(ret) {
case 0:
if (!strcmp(long_options[option_index].name, "force")) {
settings.force = 1;
}
else if (!strcmp(long_options[option_index].name, "undo-gain")) {
settings.undo = 1;
}
else {
fprintf(stderr, "Internal error parsing command line options\n");
exit(1);
}
break;
case 'h':
usage();
exit(0);
break;
case 'a':
settings.audiophile = 1;
break;
case 'r':
settings.radio = 1;
break;
case 'q':
settings.adc = 1;
break;
case 'p':
settings.no_offset = 1;
break;
case 'c':
settings.apply_gain = 0;
break;
case 'x':
settings.scale = 1;
break;
case 'y':
settings.apply_gain = 1;
settings.scale = 0;
break;
case 'w':
settings.write_chunk = 1;
break;
case 's':
settings.fast = 1;
break;
case 'o':
settings.std_out = 1;
break;
#ifdef ENABLE_RECURSIVE
case 'z':
settings.recursive = 1;
break;
#endif
case 'l':
write_to_log = 1;
#ifdef _WIN32
strcpy(log_file_name, CmdDir);
strcat(log_file_name, LOG_NAME);
#else
strcpy(log_file_name, LOG_NAME);
#endif
break;
case 'f':
write_to_log = 1;
strcpy(log_file_name, optarg);
break;
case 'n':
settings.clip_prev = 0;
break;
case 'd':
settings.need_to_process = 1;
settings.dithering = 1;
if(sscanf(optarg, "%d", &settings.shapingtype) != 1) {
fprintf(stderr, "Warning: dither type %s not recognised, using default\n", optarg);
break;
}
if (settings.shapingtype == 0)
settings.dithering = 0;
else if (settings.shapingtype == 1)
settings.shapingtype = 0;
else if (settings.shapingtype == 2)
settings.shapingtype = 1;
else if (settings.shapingtype == 3)
settings.shapingtype = 2;
else if (settings.shapingtype == 4)
settings.shapingtype = 3;
break;
case 't':
settings.limiter = 1;
break;
case 'g':
if(sscanf(optarg, "%lf", &settings.man_gain) != 1) {
fprintf(stderr, "Warning: manual gain %s not recognised, ignoring\n", optarg);
break;
}
if(settings.man_gain < -20.0) {
fprintf(stderr, "Warning: manual gain %s is out of range, "
"applying gain of -20.0dB\n", optarg);
settings.man_gain = -20.0;
}
else if(settings.man_gain > 12.0) {
fprintf(stderr, "Warning: manual gain %s is out of range, "
"applying gain of +12.0dB\n", optarg);
settings.man_gain = 12.0;
}
break;
case 'b':
settings.need_to_process = 1;
if(sscanf(optarg, "%d", &bits) != 1) {
fprintf(stderr, "Warning: output format %s not recognised, using default\n", optarg);
break;
}
if (bits == 1) {
settings.outbitwidth = 8;
settings.format = WAV_FMT_8BIT;
break;
}
else if (bits == 2) {
settings.outbitwidth = 16;
settings.format = WAV_FMT_16BIT;
break;
}
else if (bits == 3) {
settings.outbitwidth = 24;
settings.format = WAV_FMT_24BIT;
break;
}
else if (bits == 4) {
settings.outbitwidth = 32;
settings.format = WAV_FMT_32BIT;
break;
}
else if (bits == 5) {
settings.outbitwidth = 32;
settings.format = WAV_FMT_FLOAT;
break;
}
else if (bits == 6) {
settings.outbitwidth = 16;
settings.format = WAV_FMT_AIFF;
break;
}
else {
fprintf(stderr, "Warning: output format %s not recognised, using default\n", optarg);
break;
}
break;
#ifdef _WIN32
case 'e': {
char *p;
int k;
char * lpPart[MAX_PATH]={NULL};
settings.cmd = (char *) malloc(1024*8); /* 8Kb is XP's limit */
if (settings.cmd == NULL) {
fprintf(stderr, "Failed to allocate memory for cmd...\n");
return 1;
}
p = settings.cmd;
k = GetFullPathName(argv[optind - 1], 1024*8, p, lpPart);
k = GetShortPathName(p, p, MAX_PATH);
if (k == 0) {
p += sprintf (p, "%s", argv[optind - 1]);
} else {
p += k;
}
for (k = optind; k < argc; ++k) {
p += sprintf(p, " \"%s\"", argv[k]);
}
argc = optind;
break;
}
#endif
}
}
if (settings.undo == 1) {
settings.write_chunk = 0;
settings.no_offset = 1;
}
if (optind >= argc) {
fprintf(stderr, _("No files specified.\n"));
usage();
return EXIT_SUCCESS;
}
if (write_to_log) {
write_log("Command line:\n\t");
for(i = 0; i < argc; i++)
write_log("%s ", argv[i]);
write_log("\n");
}
if (!strcmp(argv[optind], "-")) {
double track_peak, track_gain;
double dc_offset;
double offset;
if (!get_gain("-", &track_peak, &track_gain,
&dc_offset, &offset, &settings))
return -1;
}
else {
for (i = optind; i < argc; ++i) {
#ifdef ENABLE_RECURSIVE
if (process_argument(argv[i], &settings) < 0) {
free_list(settings.file_list);
return EXIT_FAILURE;
}
#else
if (add_to_list(&settings.file_list, argv[i]) < 0)
return EXIT_FAILURE;
#endif
}
/* Process files (perhaps remaining) in list */
ret = process_files(settings.file_list, &settings, ".");
free_list(settings.file_list);
settings.file_list = NULL;
if (settings.cmd) free(settings.cmd);
settings.cmd = NULL;
}
return (ret < 0) ? EXIT_FAILURE : EXIT_SUCCESS;
}
int main(int _argc,const char *_argv[]){
cov_state cvs[NUM_PROCS];
#if COMPUTE_NATHAN
trans_ctx ctx[NUM_PROCS];
double r[SUPPORT*SUPPORT]; /* maximum for 2d */
#else
trans_ctx *ctx=NULL;
#endif
int i;
#if BLOCKSIZE==4
f=OD_FILTER_PARAMS4;
#elif BLOCKSIZE==8
f=OD_FILTER_PARAMS8;
#elif BLOCKSIZE==16
f=OD_FILTER_PARAMS16;
#else
# error "Need filter params for this block size."
#endif
for(i=0;i<NUM_PROCS;i++){
#if USE_2D
cov_init(&cvs[i],SUPPORT*SUPPORT);
#else
cov_init(&cvs[i],SUPPORT);
#endif
}
#if COMPUTE_NATHAN
for(i=0;i<NUM_PROCS;i++){
#if USE_2D
trans_data_init(&ctx[i].td,SUPPORT*SUPPORT);
#else
trans_data_init(&ctx[i].td,SUPPORT);
#endif
}
#endif
OD_OMP_SET_THREADS(NUM_PROCS);
process_files(ctx,cvs,_argc,_argv);
for(i=1;i<NUM_PROCS;i++)
cov_combine(&cvs[0],&cvs[i]);
cov_compute(&cvs[0]);
#if COMPUTE_NATHAN
for(i=1;i<NUM_PROCS;i++)
trans_data_combine(&ctx[0].td,&ctx[i].td);
trans_data_normalize(&ctx[0].td);
#endif
#if PRINT_COV
{
int i,j;
fprintf(stdout,"collapsed_cov=\n");
for(j=0;j<cvs[0].sz/SUPPORT;j++){
for(i=0;i<SUPPORT;i++){
fprintf(stdout,"%s %- 12.6G",i>0?",":"",cvs[0].cov[j*SUPPORT+i]);
}
fprintf(stdout,"\n");
}
}
#endif
#if USE_2D
#if COMPUTE_NATHAN
fprintf(stdout,"original cg=%-24.16G\n",
cg_2d((double(*)[SUPPORT][SUPPORT][SUPPORT])ctx[0].td.cov,f));
trans_data_collapse(&ctx[0].td,SUPPORT,r);
fprintf(stdout,"collapse cg=%-24.16G\n",
cg_2d_collapsed((double(*)[SUPPORT])r,f));
#endif
fprintf(stdout,"monty cg=%-24.16G\n",
cg_2d_collapsed((double(*)[SUPPORT])cvs[0].cov,f));
#else
#if COMPUTE_NATHAN
fprintf(stdout,"original cg=%-24.16G\n",
cg_1d((double (*)[SUPPORT])ctx[0].td.cov,f));
trans_data_collapse(&ctx[0].td,1,r);
fprintf(stdout,"collapse cg=%-24.16G\n",
cg_1d_collapsed(r,f));
#endif
fprintf(stdout,"monty cg=%-24.16G\n",
cg_1d_collapsed(cvs[0].cov,f));
#endif
for(i=0;i<NUM_PROCS;i++)
cov_clear(&cvs[i]);
#if COMPUTE_NATHAN
for(i=0;i<NUM_PROCS;i++)
trans_data_clear(&ctx[i].td);
#endif
return EXIT_SUCCESS;
}
