// handle command line arguments
void handle_arguments(int argc, char ** argv)
{
for (int i = 1; i < argc; ++i)
{
std::string arg1(argv[i]);
if (arg1 == "-A" || arg1 == "--algorithm")
{
if (i + 1 < argc && argv[i + 1][0] != '-')
{
algorithm = argv[i + 1];
}
else
{
print_usage(argv[0], argv[i]);
}
++i;
}
else if (arg1 == "-a" || arg1 == "--accent")
{
if (i + 1 < argc && argv[i + 1][0] != '-')
{
accents.push_back(argv[i + 1]);
}
else
{
print_usage(argv[0], argv[i]);
}
++i;
}
else if (arg1 == "-b" || arg1 == "--broadcast")
{
if (i + 1 < argc && argv[i + 1][0] != '-')
{
settings.hosts.push_back(argv[i + 1]);
settings.type = madara::transport::BROADCAST;
}
else
{
print_usage(argv[0], argv[i]);
}
++i;
}
else if (arg1 == "-c" || arg1 == "--checkpoint")
{
if (i + 1 < argc && argv[i + 1][0] != '-')
{
controller_settings.checkpoint_prefix = argv[i + 1];
}
else
{
print_usage(argv[0], argv[i]);
}
++i;
}
else if (arg1 == "--checkpoint-on-loop")
{
controller_settings.checkpoint_strategy =
gams::controllers::CHECKPOINT_EVERY_LOOP;
}
else if (arg1 == "--checkpoint-on-send")
{
controller_settings.checkpoint_strategy =
gams::controllers::CHECKPOINT_EVERY_SEND;
}
else if (arg1 == "--checkpoint-diffs")
{
controller_settings.checkpoint_strategy |=
gams::controllers::CHECKPOINT_SAVE_DIFFS;
}
else if (arg1 == "--checkpoint-single-file")
{
controller_settings.checkpoint_strategy |=
gams::controllers::CHECKPOINT_SAVE_ONE_FILE;
}
else if (arg1 == "-d" || arg1 == "--domain")
{
if (i + 1 < argc && argv[i + 1][0] != '-')
{
settings.write_domain = argv[i + 1];
}
else
{
print_usage(argv[0], argv[i]);
}
++i;
}
else if (arg1 == "-e" || arg1 == "--rebroadcasts")
{
if (i + 1 < argc && argv[i + 1][0] != '-')
{
int hops;
std::stringstream buffer(argv[i + 1]);
buffer >> hops;
settings.set_rebroadcast_ttl(hops);
settings.enable_participant_ttl(hops);
}
else
{
print_usage(argv[0], argv[i]);
}
++i;
}
int main(int argc, char *argv[])
{
errcode_t ret;
uint64_t blkno, result_blkno;
int c, len;
char *filename, *lookup_path, *buf;
char *filebuf;
char *p;
char lookup_name[256];
ocfs2_filesys *fs;
blkno = 0;
initialize_ocfs_error_table();
while ((c = getopt(argc, argv, "i:")) != EOF) {
switch (c) {
case 'i':
blkno = read_number(optarg);
if (blkno <= OCFS2_SUPER_BLOCK_BLKNO) {
fprintf(stderr,
"Invalid inode block: %s\n",
optarg);
print_usage();
return 1;
}
break;
default:
print_usage();
return 1;
break;
}
}
if (optind >= argc) {
fprintf(stderr, "Missing filename\n");
print_usage();
return 1;
}
filename = argv[optind];
optind++;
if (optind >= argc) {
fprintf(stdout, "Missing path to lookup\n");
print_usage();
return 1;
}
lookup_path = argv[optind];
ret = ocfs2_open(filename, OCFS2_FLAG_RO, 0, 0, &fs);
if (ret) {
com_err(argv[0], ret,
"while opening file \"%s\"", filename);
goto out;
}
ret = ocfs2_malloc_block(fs->fs_io, &buf);
if (ret) {
com_err(argv[0], ret,
"while allocating inode buffer");
goto out_close;
}
if (!blkno)
blkno = OCFS2_RAW_SB(fs->fs_super)->s_root_blkno;
for (p = lookup_path; *p == '/'; p++);
lookup_path = p;
for (p = lookup_path; ; p++) {
if (*p && *p != '/')
continue;
memcpy(lookup_name, lookup_path, p - lookup_path);
lookup_name[p - lookup_path] = '\0';
ret = ocfs2_lookup(fs, blkno, lookup_name,
strlen(lookup_name), NULL,
&result_blkno);
if (ret) {
com_err(argv[0], ret,
"while looking up \"%s\" in inode %"PRIu64
" on \"%s\"\n",
lookup_name, blkno, filename);
goto out_free;
}
blkno = result_blkno;
for (; *p == '/'; p++);
lookup_path = p;
if (!*p)
break;
}
if (ocfs2_check_directory(fs, blkno) != OCFS2_ET_NO_DIRECTORY) {
com_err(argv[0], ret, "\"%s\" is not a file", filename);
goto out_free;
}
ret = ocfs2_read_whole_file(fs, blkno, &filebuf, &len);
if (ret) {
com_err(argv[0], ret,
"while reading file \"%s\" -- read %d bytes",
filename, len);
goto out_free_filebuf;
}
if (!len)
fprintf(stderr, "boo!\n");
dump_filebuf(filebuf, len);
out_free_filebuf:
if (len)
ocfs2_free(&filebuf);
out_free:
ocfs2_free(&buf);
out_close:
ret = ocfs2_close(fs);
if (ret) {
com_err(argv[0], ret,
"while closing file \"%s\"", filename);
}
out:
return 0;
}
int main(int argc, char *argv[]) {
struct option longopts[] = {
{ "listen", no_argument, NULL, 'l' },
{ "connect", no_argument, NULL, 'c' },
{ "send", no_argument, NULL, 's' },
{ "receive", no_argument, NULL, 'r' },
{ "port", required_argument, NULL, 'p' },
{ "buffer", required_argument, NULL, 'b' },
{ "help", no_argument, NULL, 'h' },
{ "version", no_argument, NULL, 'V' },
{ NULL, 0, NULL, 0 }
};
int opt;
enum { LISTEN=1, CONNECT } mode = 0;
enum { SEND=1, RECEIVE } direction = 0;
int port = 0;
int buffer_size = 0;
char *rhost = NULL;
int sock;
argv0=argv[0];
while ((opt=getopt_long(argc, argv, "-lcsrp:b:hV", longopts, NULL)) != -1) {
switch (opt) {
char *tailptr;
case 'l':
if (mode==0) mode=LISTEN;
else param_error(NULL);
break;
case 'c':
if (mode==0) mode=CONNECT;
else param_error(NULL);
break;
case 's':
if (direction==0) direction=SEND;
else param_error(NULL);
break;
case 'r':
if (direction==0) direction=RECEIVE;
else param_error(NULL);
break;
case 'p':
if (port==0) {
errno=0;
port = strtol(optarg, &tailptr, 0);
if (errno || *tailptr!=0) param_error(NULL);
}
else param_error(NULL);
break;
case 'b':
if (buffer_size==0) {
errno=0;
buffer_size = strtol(optarg, &tailptr, 0);
if (errno || *tailptr!=0) param_error(NULL);
}
else param_error(NULL);
break;
case 'h':
print_usage();
break;
case 'V':
print_version();
break;
case 1:
if (rhost==NULL) rhost=optarg;
else param_error(NULL);
break;
case '?':
param_error("");
break;
default:
oops();
break;
}
}
if (mode==0) param_error(NULL);
if (direction==0) direction = mode==LISTEN ? SEND : RECEIVE;
if (port==0) param_error(NULL);
if (port<0 || port>65535) param_error(NULL);
if (buffer_size==0) buffer_size = DEFAULT_BUFFER_SIZE;
if (buffer_size<0) param_error(NULL);
if (mode==CONNECT && rhost==NULL) param_error(NULL);
switch (mode) {
case LISTEN:
sock = do_listen(port, rhost);
break;
case CONNECT:
sock = do_connect(port, rhost);
break;
default:
oops();
break;
}
switch (direction) {
case SEND:
do_transfer(STDIN_FILENO, sock, buffer_size);
break;
case RECEIVE:
do_transfer(sock, STDOUT_FILENO, buffer_size);
break;
default:
oops();
break;
}
return 0;
}
int
main(int argc, char **argv)
{
struct sigaction new_action;
new_action.sa_handler = SIG_IGN;
sigemptyset(&new_action.sa_mask);
new_action.sa_flags = 0;
sigaction(SIGPIPE, &new_action, NULL);
int rv = 0;
char *host = NULL;
char *port = NULL;
char *docroot = NULL;
size_t max_threads = 20;
char *ptr;
char *endptr;
char *tmp_host = getenv("BLOGC_RUNSERVER_DEFAULT_HOST");
char *default_host = bc_strdup(tmp_host != NULL ? tmp_host : "127.0.0.1");
char *tmp_port = getenv("BLOGC_RUNSERVER_DEFAULT_PORT");
char *default_port = bc_strdup(tmp_port != NULL ? tmp_port : "8080");
size_t args = 0;
for (size_t i = 1; i < argc; i++) {
if (argv[i][0] == '-') {
switch (argv[i][1]) {
case 'h':
print_help(default_host, default_port);
goto cleanup;
case 'v':
printf("%s\n", PACKAGE_STRING);
goto cleanup;
case 't':
if (argv[i][2] != '\0')
host = bc_strdup(argv[i] + 2);
else
host = bc_strdup(argv[++i]);
break;
case 'p':
if (argv[i][2] != '\0')
port = bc_strdup(argv[i] + 2);
else
port = bc_strdup(argv[++i]);
break;
case 'm':
if (argv[i][2] != '\0')
ptr = argv[i] + 2;
else
ptr = argv[++i];
max_threads = strtoul(ptr, &endptr, 10);
if (*ptr != '\0' && *endptr != '\0')
fprintf(stderr, "blogc-runserver: warning: invalid value "
"for -m argument: %s. using %zu instead\n", ptr, max_threads);
break;
default:
print_usage();
fprintf(stderr, "blogc-runserver: error: invalid "
"argument: -%c\n", argv[i][1]);
rv = 1;
goto cleanup;
}
}
else {
if (args > 0) {
print_usage();
fprintf(stderr, "blogc-runserver: error: only one positional "
"argument allowed\n");
rv = 1;
goto cleanup;
}
args++;
docroot = bc_strdup(argv[i]);
}
}
if (docroot == NULL) {
print_usage();
fprintf(stderr, "blogc-runserver: error: document root directory "
"required\n");
rv = 1;
goto cleanup;
}
if (max_threads <= 0 || max_threads > 1000) {
print_usage();
fprintf(stderr, "blogc-runserver: error: invalid value for -m. "
"Must be integer > 0 and <= 1000\n");
rv = 1;
goto cleanup;
}
rv = br_httpd_run(
host != NULL ? host : default_host,
port != NULL ? port : default_port,
docroot, max_threads);
cleanup:
free(default_host);
free(default_port);
free(host);
free(port);
free(docroot);
return rv;
}
void
get_options(int argc, char *argv[], struct dicod_conf_override *conf)
{
#line 176
{
#line 176
int c;
#line 176
#line 176
#ifdef HAVE_GETOPT_LONG
#line 176
while ((c = getopt_long(argc, argv, "EtifsTx:I:D:hV",
#line 176
long_options, NULL)) != EOF)
#line 176
#else
#line 176
while ((c = getopt(argc, argv, "EtifsTx:I:D:hV")) != EOF)
#line 176
#endif
#line 176
{
#line 176
switch (c)
#line 176
{
#line 176
default:
#line 176
exit(EX_USAGE); exit(EX_USAGE);
#line 176
#line 38 "cmdline.opt"
case 'E':
#line 38
{
#line 38
mode = MODE_PREPROC;
#line 40
break;
#line 40
}
#line 44 "cmdline.opt"
case 't':
#line 44
{
#line 44
config_lint_option = 1;
#line 46
break;
#line 46
}
#line 50 "cmdline.opt"
case 'i':
#line 50
{
#line 50
mode = MODE_INETD;
#line 52
break;
#line 52
}
#line 58 "cmdline.opt"
case OPTION_CONFIG:
#line 58
{
#line 58
config_file = optarg;
#line 60
break;
#line 60
}
#line 64 "cmdline.opt"
case 'f':
#line 64
{
#line 64
foreground = 1;
#line 66
break;
#line 66
}
#line 70 "cmdline.opt"
case OPTION_STDERR:
#line 70
{
#line 70
log_to_stderr = 1;
#line 72
break;
#line 72
}
#line 76 "cmdline.opt"
case OPTION_SYSLOG:
#line 76
{
#line 76
log_to_stderr = 0;
#line 78
break;
#line 78
}
#line 82 "cmdline.opt"
case 's':
#line 82
{
#line 82
single_process = 1;
#line 84
break;
#line 84
}
#line 90 "cmdline.opt"
case 'T':
#line 90
{
#line 90
conf->transcript = 1;
#line 92
break;
#line 92
}
#line 96 "cmdline.opt"
case OPTION_NO_TRANSCRIPT:
#line 96
{
#line 96
conf->transcript = 0;
#line 98
break;
#line 98
}
#line 102 "cmdline.opt"
case 'x':
#line 102
{
#line 102
debug_level_str = optarg;
debug_level = atoi(optarg);
#line 105
break;
#line 105
}
#line 109 "cmdline.opt"
case OPTION_SOURCE_INFO:
#line 109
{
#line 109
debug_source_info = 1;
#line 111
break;
#line 111
}
#line 115 "cmdline.opt"
case OPTION_TRACE_GRAMMAR:
#line 115
{
#line 115
grecs_gram_trace(1);
#line 117
break;
#line 117
}
#line 121 "cmdline.opt"
case OPTION_TRACE_LEX:
#line 121
{
#line 121
grecs_lex_trace(1);
#line 123
break;
#line 123
}
#line 129 "cmdline.opt"
case OPTION_CONFIG_HELP:
#line 129
{
#line 129
config_help();
exit(0);
#line 132
break;
#line 132
}
#line 138 "cmdline.opt"
case OPTION_PREPROCESSOR:
#line 138
{
#line 138
grecs_preprocessor = optarg;
#line 140
break;
#line 140
}
#line 144 "cmdline.opt"
case OPTION_NO_PREPROCESSOR:
#line 144
{
#line 144
grecs_preprocessor = NULL;
#line 146
break;
#line 146
}
#line 150 "cmdline.opt"
case 'I':
#line 150
{
#line 150
grecs_preproc_add_include_dir(optarg);
#line 152
break;
#line 152
}
#line 156 "cmdline.opt"
case 'D':
#line 156
{
#line 156
char *p;
if (!pp_cmd_acc)
pp_cmd_acc = grecs_txtacc_create();
grecs_txtacc_grow(pp_cmd_acc, " \"-D", 4);
for (p = optarg; *p; p++) {
if (*p == '\\' || *p == '"')
grecs_txtacc_grow_char(pp_cmd_acc, '\\');
grecs_txtacc_grow_char(pp_cmd_acc, *p);
}
grecs_txtacc_grow_char(pp_cmd_acc, '"');
#line 168
break;
#line 168
}
#line 171 "cmdline.opt"
case 'h':
#line 171
{
#line 171
#line 171
print_help ();
#line 171
exit (0);
#line 171
#line 171
break;
#line 171
}
#line 171 "cmdline.opt"
case OPTION_USAGE:
#line 171
{
#line 171
#line 171
print_usage ();
#line 171
exit (0);
#line 171
#line 171
break;
#line 171
}
#line 171 "cmdline.opt"
case 'V':
#line 171
{
#line 171
#line 171
/* Give version */
#line 171
print_version(program_version, stdout);
#line 171
exit (0);
#line 171
#line 171
break;
#line 171
}
#line 176 "cmdline.opt"
}
#line 176
}
#line 176
#line 176
if (optind < argc) {
#line 176
fprintf(stderr, "%s: unexpected arguments\n", argv[0]);
#line 176
exit(EX_USAGE);
#line 176
}
#line 176
#line 176
if (cmdline_tree)
#line 176
{
#line 176
struct grecs_node *rn = grecs_node_create(grecs_node_root, NULL);
#line 176
rn->down = cmdline_tree;
#line 176
cmdline_tree = rn;
#line 176
}
#line 176
}
#line 176
if (pp_cmd_acc && grecs_preprocessor) {
char *args, *cmd;
grecs_txtacc_grow_char(pp_cmd_acc, 0);
args = grecs_txtacc_finish(pp_cmd_acc, 0);
cmd = grecs_malloc(strlen(grecs_preprocessor) +
strlen(args) + 1);
strcpy(cmd, grecs_preprocessor);
strcat(cmd, args);
grecs_preprocessor = cmd;
}
grecs_txtacc_free(pp_cmd_acc);
}
int main (int argc, char ** argv)
{
//const clock_t begin_time = clock();
if (argc<3) {
print_usage ();
}
////////////////////////////////////////////////////////////
// Init parameters
//
std::string input_file_name;
std::string bv_file_name;
std::string output_file_name;
bool compress = false;
////////////////////////////////////////////////////////////
// Read command line arguments
//
int arg_pos = 1;
while (arg_pos < argc){
std::string flag = argv[arg_pos];
if (flag[0] != '-') {
if (input_file_name.empty()) {
input_file_name = flag;
} else if (bv_file_name.empty()){
bv_file_name = flag;
} else {
std::cerr << "The mandatory files are already set, unknown file " << flag << " -> ignore\n";
}
} else if (flag.compare("-o") == 0) {
arg_pos++;
output_file_name = argv[arg_pos];
} else if (flag.compare("-h") == 0) {
print_usage ();
return 0;
} else if (flag.compare("-v") == 0) {
std::cout << "\nextract_reads version " << version << "\n";
return 0;
} else {
std::cerr << "Unknown option " << flag << "\n";
print_usage ();
return (0);
}
arg_pos++;
}
if (input_file_name.empty()) {
std::cerr << "Error: An input file name is needed -> exit\n";
print_usage ();
return (0);
} else if (bv_file_name.empty()) {
std::cerr << "Error: A bv file name is needed -> exit\n";
print_usage ();
return (0);
}
////////////////////////////////////////////////////////////
// Open the given file to check its type (fasta, fastq, gzip ?)
//
ReadFile * read_file = NULL;
std::ifstream infile;
infile.open(input_file_name.c_str());
if (!infile.good()) {
std::cerr << "Cannot open file file " << input_file_name << " -> ignore\n";
}
// Check the first char
std::string basename = input_file_name.substr(input_file_name.rfind("/")+1);
char c = infile.get();
if (c == '>') {
infile.close();
read_file = new FastaFile(input_file_name, bv_file_name);
} else if (c == '@') {
infile.close();
read_file = new FastqFile(input_file_name, bv_file_name);
} else {
infile.close();
gzFile tmp_gz_file = (gzFile) gzopen(input_file_name.c_str(), "r");
if (!tmp_gz_file) {
std::cerr << "Cannot open file " << input_file_name << " -> ignore\n";
exit(1);
}
c = gzgetc(tmp_gz_file);
if (c == '>') {
gzclose(tmp_gz_file);
compress = true;
read_file = new GzFastaFile(input_file_name, bv_file_name);
} else if (c == '@') {
gzclose(tmp_gz_file);
compress = true;
read_file = new GzFastqFile(input_file_name, bv_file_name);
} else {
std::cerr << "Unknown format: " << input_file_name << " -> ignore\n";
}
}
////////////////////////////////////////////////////////////
// Open the output file and write selected reads in it
// Different behaviors if : - output file name is given
// - compress is true or not
//
if (compress) {
if (output_file_name.empty()) {
std::cerr << "Error, try to compress results but no output file name is given\n";
exit(1);
}
gzFile filetmp = (gzFile) gzopen(output_file_name.c_str(), "w6");
if (filetmp == NULL) {
std::cerr << "Error, cannot open file " << output_file_name << "\n";
}
std::string & current_read = read_file->get_next_read();
while (!current_read.empty()) {
gzprintf(filetmp, "%s", read_file->get_data().c_str());
current_read = read_file->get_next_read();
}
gzclose(filetmp);
} else {
if (!output_file_name.empty()) {
std::ofstream outfile;
outfile.open (output_file_name.c_str());
if (!outfile.good()) {
std::cerr << "Cannot write on file " << output_file_name << "\n";
return 1;
}
std::string & current_read = read_file->get_next_read();
while (!current_read.empty()) {
outfile << read_file->get_data();
current_read = read_file->get_next_read();
}
outfile.close();
} else {
std::string & current_read = read_file->get_next_read();
while (!current_read.empty()) {
std::cout << read_file->get_data();
current_read = read_file->get_next_read();
}
}
}
if (read_file != NULL) {
delete read_file;
}
return 0;
}
int
main(int argc, char *argv[])
#endif
{
iptc_handle_t handle = NULL;
char buffer[10240];
int c;
char curtable[IPT_TABLE_MAXNAMELEN + 1];
FILE *in;
const char *modprobe = 0;
int in_table = 0, testing = 0;
program_name = "iptables-restore";
program_version = IPTABLES_VERSION;
line = 0;
lib_dir = getenv("IPTABLES_LIB_DIR");
if (!lib_dir)
lib_dir = IPT_LIB_DIR;
#ifdef NO_SHARED_LIBS
init_extensions();
#endif
while ((c = getopt_long(argc, argv, "bcvthnM:", options, NULL)) != -1) {
switch (c) {
case 'b':
binary = 1;
break;
case 'c':
counters = 1;
break;
case 'v':
verbose = 1;
break;
case 't':
testing = 1;
break;
case 'h':
print_usage("iptables-restore",
IPTABLES_VERSION);
break;
case 'n':
noflush = 1;
break;
case 'M':
modprobe = optarg;
break;
}
}
if (optind == argc - 1) {
in = fopen(argv[optind], "r");
if (!in) {
fprintf(stderr, "Can't open %s: %s\n", argv[optind],
strerror(errno));
exit(1);
}
}
else if (optind < argc) {
fprintf(stderr, "Unknown arguments found on commandline\n");
exit(1);
}
else in = stdin;
/* Grab standard input. */
while (fgets(buffer, sizeof(buffer), in)) {
int ret = 0;
line++;
if (buffer[0] == '\n')
continue;
else if (buffer[0] == '#') {
if (verbose)
fputs(buffer, stdout);
continue;
} else if ((strcmp(buffer, "COMMIT\n") == 0) && (in_table)) {
if (!testing) {
DEBUGP("Calling commit\n");
ret = iptc_commit(&handle);
} else {
DEBUGP("Not calling commit, testing\n");
ret = 1;
}
in_table = 0;
} else if ((buffer[0] == '*') && (!in_table)) {
/* New table */
char *table;
table = strtok(buffer+1, " \t\n");
DEBUGP("line %u, table '%s'\n", line, table);
if (!table) {
exit_error(PARAMETER_PROBLEM,
"%s: line %u table name invalid\n",
program_name, line);
exit(1);
}
strncpy(curtable, table, IPT_TABLE_MAXNAMELEN);
curtable[IPT_TABLE_MAXNAMELEN] = '\0';
if (handle)
iptc_free(&handle);
handle = create_handle(table, modprobe);
if (noflush == 0) {
DEBUGP("Cleaning all chains of table '%s'\n",
table);
for_each_chain(flush_entries, verbose, 1,
&handle);
DEBUGP("Deleting all user-defined chains "
"of table '%s'\n", table);
for_each_chain(delete_chain, verbose, 0,
&handle) ;
}
ret = 1;
in_table = 1;
} else if ((buffer[0] == ':') && (in_table)) {
/* New chain. */
char *policy, *chain;
chain = strtok(buffer+1, " \t\n");
DEBUGP("line %u, chain '%s'\n", line, chain);
if (!chain) {
exit_error(PARAMETER_PROBLEM,
"%s: line %u chain name invalid\n",
program_name, line);
exit(1);
}
if (iptc_builtin(chain, handle) <= 0) {
if (noflush && iptc_is_chain(chain, handle)) {
DEBUGP("Flushing existing user defined chain '%s'\n", chain);
if (!iptc_flush_entries(chain, &handle))
exit_error(PARAMETER_PROBLEM,
"error flushing chain "
"'%s':%s\n", chain,
strerror(errno));
} else {
DEBUGP("Creating new chain '%s'\n", chain);
if (!iptc_create_chain(chain, &handle))
exit_error(PARAMETER_PROBLEM,
"error creating chain "
"'%s':%s\n", chain,
strerror(errno));
}
}
policy = strtok(NULL, " \t\n");
DEBUGP("line %u, policy '%s'\n", line, policy);
if (!policy) {
exit_error(PARAMETER_PROBLEM,
"%s: line %u policy invalid\n",
program_name, line);
exit(1);
}
if (strcmp(policy, "-") != 0) {
struct ipt_counters count;
if (counters) {
char *ctrs;
ctrs = strtok(NULL, " \t\n");
if (!ctrs || !parse_counters(ctrs, &count))
exit_error(PARAMETER_PROBLEM,
"invalid policy counters "
"for chain '%s'\n", chain);
} else {
memset(&count, 0,
sizeof(struct ipt_counters));
}
DEBUGP("Setting policy of chain %s to %s\n",
chain, policy);
if (!iptc_set_policy(chain, policy, &count,
&handle))
exit_error(OTHER_PROBLEM,
"Can't set policy `%s'"
" on `%s' line %u: %s\n",
chain, policy, line,
iptc_strerror(errno));
}
ret = 1;
} else if (in_table) {
int a;
char *ptr = buffer;
char *pcnt = NULL;
char *bcnt = NULL;
char *parsestart;
/* the parser */
char *curchar;
int quote_open;
int param_len;
/* reset the newargv */
newargc = 0;
if (buffer[0] == '[') {
/* we have counters in our input */
ptr = strchr(buffer, ']');
if (!ptr)
exit_error(PARAMETER_PROBLEM,
"Bad line %u: need ]\n",
line);
pcnt = strtok(buffer+1, ":");
if (!pcnt)
exit_error(PARAMETER_PROBLEM,
"Bad line %u: need :\n",
line);
bcnt = strtok(NULL, "]");
if (!bcnt)
exit_error(PARAMETER_PROBLEM,
"Bad line %u: need ]\n",
line);
/* start command parsing after counter */
parsestart = ptr + 1;
} else {
/* start command parsing at start of line */
parsestart = buffer;
}
add_argv(argv[0]);
add_argv("-t");
add_argv((char *) &curtable);
if (counters && pcnt && bcnt) {
add_argv("--set-counters");
add_argv((char *) pcnt);
add_argv((char *) bcnt);
}
/* After fighting with strtok enough, here's now
* a 'real' parser. According to Rusty I'm now no
* longer a real hacker, but I can live with that */
quote_open = 0;
param_len = 0;
for (curchar = parsestart; *curchar; curchar++) {
char param_buffer[1024];
if (*curchar == '"') {
/* quote_open cannot be true if there
* was no previous character. Thus,
* curchar-1 has to be within bounds */
if (quote_open &&
*(curchar-1) != '\\') {
quote_open = 0;
*curchar = ' ';
} else if (!quote_open) {
quote_open = 1;
continue;
}
}
if (*curchar == ' '
|| *curchar == '\t'
|| * curchar == '\n') {
if (quote_open) {
param_buffer[param_len++] =
*curchar;
continue;
}
if (!param_len) {
/* two spaces? */
continue;
}
param_buffer[param_len] = '\0';
/* check if table name specified */
if (!strncmp(param_buffer, "-t", 3)
|| !strncmp(param_buffer, "--table", 8)) {
exit_error(PARAMETER_PROBLEM,
"Line %u seems to have a "
"-t table option.\n", line);
exit(1);
}
add_argv(param_buffer);
param_len = 0;
} else {
/* Skip backslash that escapes quote:
* the standard input does not require
* escaping. However, the output
* generated by iptables-save
* introduces bashlash to keep
* consistent with iptables
*/
if (quote_open &&
*curchar == '\\' &&
*(curchar+1) == '"')
continue;
/* regular character, copy to buffer */
param_buffer[param_len++] = *curchar;
if (param_len >= sizeof(param_buffer))
exit_error(PARAMETER_PROBLEM,
"Parameter too long!");
}
}
DEBUGP("calling do_command(%u, argv, &%s, handle):\n",
newargc, curtable);
for (a = 0; a < newargc; a++)
DEBUGP("argv[%u]: %s\n", a, newargv[a]);
ret = do_command(newargc, newargv,
&newargv[2], &handle);
free_argv();
}
if (!ret) {
fprintf(stderr, "%s: line %u failed\n",
program_name, line);
exit(1);
}
}
if (in_table) {
fprintf(stderr, "%s: COMMIT expected at line %u\n",
program_name, line + 1);
exit(1);
}
return 0;
}
/* --------------------------------------------- */
static void print_help(void) {
print_usage() ;
printf("WARNING: this program is not yet tested!\n");
exit(1) ;
}
int main(int argc, char *const *argv){
char buf[PATH_MAX+1];
char *simcount = 0;
int simul_count = 10;
char *original_path = 0;
int path_passed = 0;
int opt= 0;
//Specifying the expected options
// TODO: set simcount as an optional parameter
static struct option long_options[] = {
{"simcount", required_argument, 0, 's' },
{"path", required_argument, 0, 'p' },
{"help", no_argument, 0, 'h' },
{0, 0, 0, 0 }
};
int long_index =0;
while ((opt = getopt_long(argc, argv, "s:p:",
long_options, &long_index )) != -1) {
switch (opt) {
// `optarg` is a global variable from getopt.h
case 's' : simcount = strdup(optarg);
break;
case 'p' : path_passed = 1; original_path = realpath(optarg, buf);
break;
case 'h' : print_usage(); exit(0);
default: print_usage();
exit(EXIT_FAILURE);
}
}
// Check that a path was specified and that it is a valid path
if (path_passed && !original_path) {
printf("Path was given, but was invalid.\n");
print_usage();
exit(EXIT_FAILURE);
} else if (!path_passed) {
printf("Path was not specified.\n");
print_usage();
exit(EXIT_FAILURE);
}
// Convert the given "simcount" to a number, store in `simul_count`
if (simcount){
errno = 0;
long tmp = strtol(simcount, 0, 10);
// TODO: implement converter
if (errno != 0){
printf("Could not convert specified simcount into a valid number.\n");
print_usage();
exit(EXIT_FAILURE);
}
simul_count = tmp;
}
printf("original_path: %s, simul_count: %d\n", original_path, simul_count);
reverse_file(original_path, simul_count);
//char* test[] = {
// "spinelessness prayed doppelgangers notabilities syllabification unflinching",
// "coccyx Msgr environments subjecting Duroc ibis fetus whack wile",
// "nippy demoed pretax voltmeters bougainvillea garish weedkillers",
//};
//int i = 0;
//for (i = 0; i < 3; ++i){
// char* rv = in_place_reverse_words(strdup(test[i]));
// free(rv);
//}
return 0;
}
void do_config(int argc, char **argv)
{
char *s;
int i, c, known;
int got_conffile = 0, print_config = 0;
size_t s_len;
for (i = 1; i < argc; i++) {
if (argv[i][0] && (argv[i][0] != '-' || argv[i][1] == '\0')) {
read_config_file(argv[i], config, 0);
got_conffile = 1;
continue;
}
known = 0;
for (c = 0; config_names[c].name != NULL && !known; c++) {
if (config_names[c].option == NULL
|| strncmp(argv[i], config_names[c].option,
strlen(config_names[c].option)) != 0)
continue;
s = NULL;
known = 1;
if (argv[i][strlen(config_names[c].option)] == '=')
s = argv[i] + strlen(config_names[c].option) + 1;
else if (argv[i][strlen(config_names[c].option)] == 0) {
if (config_names[c].needsArgument) {
if (i + 1 < argc)
s = argv[++i];
else
known = 0;
} else
s = argv[i]; /* no arg, fill in something */
} else
known = 0;
if (known)
config[config_names[c].nm] = s;
}
if (!known && strcmp(argv[i], "--version") == 0) {
print_version();
exit(0);
}
if (!known && strcmp(argv[i], "--print-config") == 0) {
print_config = 1;
known = 1;
}
if (!known && strcmp(argv[i], "--help") == 0) {
print_usage(argv[0], 0);
exit(0);
}
if (!known && strcmp(argv[i], "--long-help") == 0) {
print_usage(argv[0], 1);
exit(0);
}
if (!known) {
printf("%s: unknown option %s\n\n", argv[0], argv[i]);
print_usage(argv[0], 1);
exit(1);
}
}
if (!got_conffile) {
read_config_file("/etc/vpnc/default.conf", config, 1);
read_config_file("/etc/vpnc.conf", config, 1);
}
if (!print_config) {
for (i = 0; config_names[i].name != NULL; i++)
if (!config[config_names[i].nm]
&& config_names[i].get_def != NULL)
config[config_names[i].nm] = config_names[i].get_def();
opt_debug = (config[CONFIG_DEBUG]) ? atoi(config[CONFIG_DEBUG]) : 0;
opt_nd = (config[CONFIG_ND]) ? 1 : 0;
opt_1des = (config[CONFIG_ENABLE_1DES]) ? 1 : 0;
if (!strcmp(config[CONFIG_AUTH_MODE], "psk")) {
opt_auth_mode = AUTH_MODE_PSK;
} else if (!strcmp(config[CONFIG_AUTH_MODE], "cert")) {
opt_auth_mode = AUTH_MODE_CERT;
} else if (!strcmp(config[CONFIG_AUTH_MODE], "hybrid")) {
opt_auth_mode = AUTH_MODE_HYBRID;
} else {
printf("%s: unknown authentication mode %s\nknown modes: psk cert hybrid\n", argv[0], config[CONFIG_AUTH_MODE]);
exit(1);
}
#ifndef OPENSSL_GPL_VIOLATION
if (opt_auth_mode == AUTH_MODE_HYBRID ||
opt_auth_mode == AUTH_MODE_CERT) {
printf("%s was built without openssl: Can't do hybrid or cert mode.\n", argv[0]);
exit(1);
}
#endif
opt_no_encryption = (config[CONFIG_ENABLE_NO_ENCRYPTION]) ? 1 : 0;
opt_udpencapport=atoi(config[CONFIG_UDP_ENCAP_PORT]);
if (!strcmp(config[CONFIG_NATT_MODE], "natt")) {
opt_natt_mode = NATT_NORMAL;
} else if (!strcmp(config[CONFIG_NATT_MODE], "none")) {
opt_natt_mode = NATT_NONE;
} else if (!strcmp(config[CONFIG_NATT_MODE], "force-natt")) {
opt_natt_mode = NATT_FORCE;
} else if (!strcmp(config[CONFIG_NATT_MODE], "cisco-udp")) {
opt_natt_mode = NATT_CISCO_UDP;
} else {
printf("%s: unknown nat traversal mode %s\nknown modes: natt none force-natt cisco-udp\n", argv[0], config[CONFIG_NATT_MODE]);
exit(1);
}
if (!strcmp(config[CONFIG_IF_MODE], "tun")) {
opt_if_mode = IF_MODE_TUN;
} else if (!strcmp(config[CONFIG_IF_MODE], "tap")) {
opt_if_mode = IF_MODE_TAP;
} else {
printf("%s: unknown interface mode %s\nknown modes: tun tap\n", argv[0], config[CONFIG_IF_MODE]);
exit(1);
}
if (!strcmp(config[CONFIG_VENDOR], "cisco")) {
opt_vendor = VENDOR_CISCO;
} else if (!strcmp(config[CONFIG_VENDOR], "netscreen")) {
opt_vendor = VENDOR_NETSCREEN;
} else {
printf("%s: unknown vendor %s\nknown vendors: cisco netscreen\n", argv[0], config[CONFIG_VENDOR]);
exit(1);
}
}
if (opt_debug >= 99) {
printf("WARNING! active debug level is >= 99, output includes username and password (hex encoded)\n");
fprintf(stderr,
"WARNING! active debug level is >= 99, output includes username and password (hex encoded)\n");
}
config_deobfuscate(CONFIG_IPSEC_SECRET_OBF, CONFIG_IPSEC_SECRET);
config_deobfuscate(CONFIG_XAUTH_PASSWORD_OBF, CONFIG_XAUTH_PASSWORD);
for (i = 0; i < LAST_CONFIG; i++) {
if (config[i] != NULL || config[CONFIG_NON_INTERACTIVE] != NULL)
continue;
if (config[CONFIG_XAUTH_INTERACTIVE] && i == CONFIG_XAUTH_PASSWORD)
continue;
s = NULL;
s_len = 0;
switch (i) {
case CONFIG_IPSEC_GATEWAY:
printf("Enter IPSec gateway address: ");
break;
case CONFIG_IPSEC_ID:
printf("Enter IPSec ID for %s: ", config[CONFIG_IPSEC_GATEWAY]);
break;
case CONFIG_IPSEC_SECRET:
printf("Enter IPSec secret for %s@%s: ",
config[CONFIG_IPSEC_ID], config[CONFIG_IPSEC_GATEWAY]);
break;
case CONFIG_XAUTH_USERNAME:
printf("Enter username for %s: ", config[CONFIG_IPSEC_GATEWAY]);
break;
case CONFIG_XAUTH_PASSWORD:
printf("Enter password for %s@%s: ",
config[CONFIG_XAUTH_USERNAME],
config[CONFIG_IPSEC_GATEWAY]);
break;
}
fflush(stdout);
switch (i) {
case CONFIG_IPSEC_SECRET:
case CONFIG_XAUTH_PASSWORD:
s = strdup(getpass(""));
break;
case CONFIG_IPSEC_GATEWAY:
case CONFIG_IPSEC_ID:
case CONFIG_XAUTH_USERNAME:
getline(&s, &s_len, stdin);
}
if (s != NULL && strlen(s) > 0 && s[strlen(s) - 1] == '\n')
s[strlen(s) - 1] = 0;
config[i] = s;
}
if (print_config) {
fprintf(stderr, "vpnc.conf:\n\n");
for (i = 0; config_names[i].name != NULL; i++) {
if (config[config_names[i].nm] == NULL)
continue;
printf("%s%s\n", config_names[i].name,
config_names[i].needsArgument ?
config[config_names[i].nm] : "");
}
exit(0);
}
if (!config[CONFIG_IPSEC_GATEWAY])
error(1, 0, "missing IPSec gatway address");
if (!config[CONFIG_IPSEC_ID])
error(1, 0, "missing IPSec ID");
if (!config[CONFIG_IPSEC_SECRET])
error(1, 0, "missing IPSec secret");
if (!config[CONFIG_XAUTH_USERNAME])
error(1, 0, "missing Xauth username");
if (!config[CONFIG_XAUTH_PASSWORD] && !config[CONFIG_XAUTH_INTERACTIVE])
error(1, 0, "missing Xauth password");
if (get_dh_group_ike() == NULL)
error(1, 0, "IKE DH Group \"%s\" unsupported\n", config[CONFIG_IKE_DH]);
if (get_dh_group_ipsec(-1) == NULL)
error(1, 0, "Perfect Forward Secrecy \"%s\" unsupported\n",
config[CONFIG_IPSEC_PFS]);
if (get_dh_group_ike()->ike_sa_id == 0)
error(1, 0, "IKE DH Group must not be nopfs\n");
return;
}
/* ------------------------------------------------------ */
static void usage_exit(void) {
print_usage() ;
exit(1) ;
}
int main (int argc, char **argv)
{
const char *file_name;
const char *set_value;
const char *attr_name;
int watch_mode;
struct sigaction sigact;
sigemptyset(&sigact.sa_mask);
sigact.sa_flags = SA_SIGINFO;
sigact.sa_restorer = NULL;
sigact.sa_sigaction = sig_handler;
sigaction(SIGUSR1, &sigact, 0);
sigaction(SIGINT, &sigact, 0);
sigaction(SIGTERM, &sigact, 0);
/* Parse command line arguments. */
file_name = "./person.dat";
set_value = NULL;
watch_mode = 0;
while (1)
{
int opt;
opt = getopt (argc, argv, "ws:f:");
if (opt < 0)
break;
switch (opt)
{
case 'w':
watch_mode = 1;
break;
case 's':
set_value = optarg;
break;
case 'f':
file_name = optarg;
break;
default:
print_usage (argv[0]);
return -1;
}
}
if (!watch_mode && optind >= argc)
{
print_usage (argv[0]);
return -1;
}
attr_name = argv[optind];
/* ###################################################### */
setup(file_name);
if(watch_mode) // watch mode
{
int i = 0;
printf("waiting...\n");
printf("my pid is %x\n", getpid());
// add self on watchers list
for(i = 0; i < NOTIFY_MAX * sizeof(pid_t); i += sizeof(pid_t))
{
pid_t* p_pid = (pid_t *)((char *)p_mmap + i);
if( *p_pid == 0 )
{
*p_pid = getpid();
break;
}
}
if(i/sizeof(pid_t) == NOTIFY_MAX)
{
*((pid_t *)p_mmap) = getpid();
}
while(1){
sleep(2);
}
}
else // not watch_mode
{
int off;
char * data;
if( 0 > (off = person_get_offset_of_attr(attr_name)) )
{
fprintf(stderr, "invalid attr name \'%s\'\n", attr_name);
return -1;
}
if(set_value != NULL) // set mode
{
printf("attr name is %s(%d)\n", attr_name, off);
if( person_attr_is_integer(attr_name) )
{
int * addr = (int *)(((char *)p_mmap) + off);
*addr = atoi(set_value);
msync(addr, sizeof(int), MS_SYNC);
}
else
{
char* addr = ((char *)p_mmap) + off;
int len = strlen(set_value) * sizeof(char) + 1;
memcpy(addr, set_value, len);
msync(addr, sizeof(Person), MS_SYNC);
}
send_signal(off);
}
else // print mode
{
if( person_attr_is_integer(attr_name) )
{
int * addr = (int *)(((char *)p_mmap) + off);
printf("%d\n", *addr);
}
else
{
char* addr = ((char *)p_mmap) + off;
printf("%s\n", addr);
}
}
print_person(p_mmap);
}
cleanup();
return 0;
}
int
main(int argc, char *argv[])
#endif
{
DYNMEM_KNP_DEFN *p_dynmem_knp;
kstat_ctl_t *kctl;
KSTAT_INFO_DEF info_ksp;
int val;
char **pargs, **cur_pargs;
/*
* grab and parse argument list
*/
p_dynmem_knp = dynmem_knp;
pargs = argv;
while (*pargs) {
(void) printf("pargs=%x - %s\n", (uint_t)pargs, *pargs);
cur_pargs = pargs;
pargs++;
if (strcmp(*cur_pargs, "h") == 0) {
print_usage();
return (0);
}
if (strcmp(*cur_pargs, "wake") == 0) {
if ((p_dynmem_knp+DIRECTIVE)->newval == NO_VALUE)
(p_dynmem_knp+DIRECTIVE)->newval = 0;
(p_dynmem_knp+DIRECTIVE)->newval |= 0x01;
continue;
}
if (strcmp(*cur_pargs, "hys") == 0) {
if ((p_dynmem_knp+DIRECTIVE)->newval == NO_VALUE)
(p_dynmem_knp+DIRECTIVE)->newval = 0;
(p_dynmem_knp+DIRECTIVE)->newval |= 0x02;
continue;
}
if (strcmp (*cur_pargs, "mon") == 0) {
val = atoi(*pargs);
(void) printf("errno=%x, %s=%x\n", errno, *cur_pargs,
val);
pargs++;
(p_dynmem_knp+MONITOR)->newval = val;
}
if (strcmp (*cur_pargs, "age1") == 0) {
val = atoi(*pargs);
(void) printf("errno=%x, %s=%x\n", errno, *cur_pargs,
val);
pargs++;
(p_dynmem_knp+AGECT1)->newval = val;
}
if (strcmp(*cur_pargs, "age2") == 0) {
val = atoi(*pargs);
(void) printf("errno=%x, %s=%x\n", errno, *cur_pargs,
val);
pargs++;
(p_dynmem_knp+AGECT2)->newval = val;
}
if (strcmp(*cur_pargs, "age3") == 0) {
val = atoi(*pargs);
(void) printf("errno=%x, %s=%x\n", errno, *cur_pargs,
val);
pargs++;
(p_dynmem_knp+AGECT3)->newval = val;
}
if (strcmp (*cur_pargs, "sec1") == 0) {
val = atoi(*pargs);
(void) printf("errno=%x, %s=%x\n", errno, *cur_pargs,
val);
pargs++;
if (val == 0)
break;
else {
(p_dynmem_knp+SEC1)->newval = val;
continue;
}
}
if (strcmp(*cur_pargs, "sec2") == 0) {
val = atoi(*pargs);
pargs++;
(void) printf("errno=%x, %s=%x\n", errno, *cur_pargs,
val);
if (val == 0)
break;
else {
(p_dynmem_knp+SEC2)->newval = val;
continue;
}
}
if (strcmp(*cur_pargs, "sec3") == 0) {
val = atoi(*pargs);
pargs++;
(void) printf("errno=%x, %s=%x\n", errno, *cur_pargs,
val);
if (val == 0)
break;
else {
(p_dynmem_knp+SEC3)->newval = val;
continue;
}
}
if (strcmp(*cur_pargs, "pcnt1") == 0) {
val = atoi(*pargs);
pargs++;
(void) printf("errno=%x, %s=%x\n", errno, *cur_pargs,
val);
if (val == 0)
break;
else {
(p_dynmem_knp+PCNT1)->newval = val;
continue;
}
}
if (strcmp(*cur_pargs, "pcnt2") == 0) {
val = atoi(*pargs);
pargs++;
(void) printf("errno=%x, %s=%x\n", errno, *cur_pargs,
val);
if (val == 0)
break;
else {
(p_dynmem_knp+PCNT2)->newval = val;
continue;
}
}
if (strcmp(*cur_pargs, "hdpcnt") == 0) {
val = atoi(*pargs);
pargs++;
(void) printf("errno=%x, %s=%x\n", errno, *cur_pargs,
val);
if (val < 0)
break;
else {
(p_dynmem_knp+HDPCNT)->newval = val;
continue;
}
}
if (strcmp(*cur_pargs, "list") == 0) {
val = atoi(*pargs);
pargs++;
(void) printf("errno=%x, %s=%x\n", errno, *cur_pargs,
val);
if (val == 0)
break;
else {
(p_dynmem_knp+MAXLIST)->newval = val;
continue;
}
}
} /* while(*pargs && cl) */
/*
* open the kstat library
*/
kctl = kstat_open();
if (kctl == NULL) {
(void) printf("kstat_open() failed\n");
return (1);
}
/*
* is the name module about
*/
info_ksp.instance = 0;
info_ksp.ksp = kstat_lookup(kctl, SDBC_KSTAT_MODULE, 0,
SDBC_KSTAT_DYNMEM);
if (info_ksp.ksp == NULL) {
(void) printf("No module to report\n");
return (1);
}
/*
* using the info get a copy of the data
*/
if (kstat_read(kctl, info_ksp.ksp, NULL) == -1) {
(void) printf("Can't read kstat\n");
return (1);
}
/*
* print the current data
*/
p_dynmem_knp = dynmem_knp;
while (p_dynmem_knp->named) {
p_dynmem_knp->knp =
kstat_data_lookup(info_ksp.ksp, p_dynmem_knp->named);
if (p_dynmem_knp->knp == NULL) {
(void) printf("kstat_data_lookup(%s) failed\n",
p_dynmem_knp->named);
return (1);
} else {
(void) printf("%s: %x\n", p_dynmem_knp->named,
(uint_t)p_dynmem_knp->knp->value.ul);
p_dynmem_knp++;
}
}
/*
* modify the data and write it back
*/
p_dynmem_knp = dynmem_knp;
while (p_dynmem_knp->named) {
if (p_dynmem_knp->newval != NO_VALUE)
p_dynmem_knp->knp->value.ul = p_dynmem_knp->newval;
p_dynmem_knp++;
}
if (kstat_write(kctl, info_ksp.ksp, NULL) == -1) {
(void) printf("kstat_write() failed\n");
return (1);
}
(void) printf("Finished (h for help)\n");
return (0);
}
static void parse_opts(int argc, char *argv[])
{
while (1) {
static const struct option lopts[] = {
{ "device", 1, 0, 'D' },
{ "speed", 1, 0, 's' },
{ "delay", 1, 0, 'd' },
{ "bpw", 1, 0, 'b' },
{ "loop", 0, 0, 'l' },
{ "cpha", 0, 0, 'H' },
{ "cpol", 0, 0, 'O' },
{ "lsb", 0, 0, 'L' },
{ "cs-high", 0, 0, 'C' },
{ "3wire", 0, 0, '3' },
{ "no-cs", 0, 0, 'N' },
{ "ready", 0, 0, 'R' },
{ NULL, 0, 0, 0 },
};
int c;
c = getopt_long(argc, argv, "D:s:d:b:lHOLC3NR", lopts, NULL);
if (c == -1)
break;
switch (c) {
case 'D':
device = optarg;
break;
case 's':
speed = atoi(optarg);
break;
case 'd':
delay = atoi(optarg);
break;
case 'b':
bits = atoi(optarg);
break;
case 'l':
mode |= SPI_LOOP;
break;
case 'H':
mode |= SPI_CPHA;
break;
case 'O':
mode |= SPI_CPOL;
break;
case 'L':
mode |= SPI_LSB_FIRST;
break;
case 'C':
mode |= SPI_CS_HIGH;
break;
case '3':
mode |= SPI_3WIRE;
break;
case 'N':
mode |= SPI_NO_CS;
break;
case 'R':
mode |= SPI_READY;
break;
default:
print_usage(argv[0]);
break;
}
}
}
int bam_mpileup(int argc, char *argv[])
{
int c;
const char *file_list = NULL;
char **fn = NULL;
int nfiles = 0, use_orphan = 0;
mplp_conf_t mplp;
memset(&mplp, 0, sizeof(mplp_conf_t));
mplp.min_baseQ = 13;
mplp.capQ_thres = 0;
mplp.max_depth = 250; mplp.max_indel_depth = 250;
mplp.openQ = 40; mplp.extQ = 20; mplp.tandemQ = 100;
mplp.min_frac = 0.002; mplp.min_support = 1;
mplp.flag = MPLP_NO_ORPHAN | MPLP_REALN | MPLP_SMART_OVERLAPS;
mplp.argc = argc; mplp.argv = argv;
mplp.rflag_filter = BAM_FUNMAP | BAM_FSECONDARY | BAM_FQCFAIL | BAM_FDUP;
mplp.output_fname = NULL;
mplp.all = 0;
sam_global_args_init(&mplp.ga);
static const struct option lopts[] =
{
SAM_OPT_GLOBAL_OPTIONS('-', 0, '-', '-', 0),
{"rf", required_argument, NULL, 1}, // require flag
{"ff", required_argument, NULL, 2}, // filter flag
{"incl-flags", required_argument, NULL, 1},
{"excl-flags", required_argument, NULL, 2},
{"output", required_argument, NULL, 3},
{"open-prob", required_argument, NULL, 4},
{"illumina1.3+", no_argument, NULL, '6'},
{"count-orphans", no_argument, NULL, 'A'},
{"bam-list", required_argument, NULL, 'b'},
{"no-BAQ", no_argument, NULL, 'B'},
{"no-baq", no_argument, NULL, 'B'},
{"adjust-MQ", required_argument, NULL, 'C'},
{"adjust-mq", required_argument, NULL, 'C'},
{"max-depth", required_argument, NULL, 'd'},
{"redo-BAQ", no_argument, NULL, 'E'},
{"redo-baq", no_argument, NULL, 'E'},
{"fasta-ref", required_argument, NULL, 'f'},
{"exclude-RG", required_argument, NULL, 'G'},
{"exclude-rg", required_argument, NULL, 'G'},
{"positions", required_argument, NULL, 'l'},
{"region", required_argument, NULL, 'r'},
{"ignore-RG", no_argument, NULL, 'R'},
{"ignore-rg", no_argument, NULL, 'R'},
{"min-MQ", required_argument, NULL, 'q'},
{"min-mq", required_argument, NULL, 'q'},
{"min-BQ", required_argument, NULL, 'Q'},
{"min-bq", required_argument, NULL, 'Q'},
{"ignore-overlaps", no_argument, NULL, 'x'},
{"BCF", no_argument, NULL, 'g'},
{"bcf", no_argument, NULL, 'g'},
{"VCF", no_argument, NULL, 'v'},
{"vcf", no_argument, NULL, 'v'},
{"output-BP", no_argument, NULL, 'O'},
{"output-bp", no_argument, NULL, 'O'},
{"output-MQ", no_argument, NULL, 's'},
{"output-mq", no_argument, NULL, 's'},
{"output-tags", required_argument, NULL, 't'},
{"uncompressed", no_argument, NULL, 'u'},
{"ext-prob", required_argument, NULL, 'e'},
{"gap-frac", required_argument, NULL, 'F'},
{"tandem-qual", required_argument, NULL, 'h'},
{"skip-indels", no_argument, NULL, 'I'},
{"max-idepth", required_argument, NULL, 'L'},
{"min-ireads ", required_argument, NULL, 'm'},
{"per-sample-mF", no_argument, NULL, 'p'},
{"per-sample-mf", no_argument, NULL, 'p'},
{"platforms", required_argument, NULL, 'P'},
{NULL, 0, NULL, 0}
};
while ((c = getopt_long(argc, argv, "Agf:r:l:q:Q:uRC:BDSd:L:b:P:po:e:h:Im:F:EG:6OsVvxt:a",lopts,NULL)) >= 0) {
switch (c) {
case 'x': mplp.flag &= ~MPLP_SMART_OVERLAPS; break;
case 1 :
mplp.rflag_require = bam_str2flag(optarg);
if ( mplp.rflag_require<0 ) { fprintf(stderr,"Could not parse --rf %s\n", optarg); return 1; }
break;
case 2 :
mplp.rflag_filter = bam_str2flag(optarg);
if ( mplp.rflag_filter<0 ) { fprintf(stderr,"Could not parse --ff %s\n", optarg); return 1; }
break;
case 3 : mplp.output_fname = optarg; break;
case 4 : mplp.openQ = atoi(optarg); break;
case 'f':
mplp.fai = fai_load(optarg);
if (mplp.fai == NULL) return 1;
mplp.fai_fname = optarg;
break;
case 'd': mplp.max_depth = atoi(optarg); break;
case 'r': mplp.reg = strdup(optarg); break;
case 'l':
// In the original version the whole BAM was streamed which is inefficient
// with few BED intervals and big BAMs. Todo: devise a heuristic to determine
// best strategy, that is streaming or jumping.
mplp.bed = bed_read(optarg);
if (!mplp.bed) { print_error_errno("mpileup", "Could not read file \"%s\"", optarg); return 1; }
break;
case 'P': mplp.pl_list = strdup(optarg); break;
case 'p': mplp.flag |= MPLP_PER_SAMPLE; break;
case 'g': mplp.flag |= MPLP_BCF; break;
case 'v': mplp.flag |= MPLP_BCF | MPLP_VCF; break;
case 'u': mplp.flag |= MPLP_NO_COMP | MPLP_BCF; break;
case 'B': mplp.flag &= ~MPLP_REALN; break;
case 'D': mplp.fmt_flag |= B2B_FMT_DP; fprintf(stderr, "[warning] samtools mpileup option `-D` is functional, but deprecated. Please switch to `-t DP` in future.\n"); break;
case 'S': mplp.fmt_flag |= B2B_FMT_SP; fprintf(stderr, "[warning] samtools mpileup option `-S` is functional, but deprecated. Please switch to `-t SP` in future.\n"); break;
case 'V': mplp.fmt_flag |= B2B_FMT_DV; fprintf(stderr, "[warning] samtools mpileup option `-V` is functional, but deprecated. Please switch to `-t DV` in future.\n"); break;
case 'I': mplp.flag |= MPLP_NO_INDEL; break;
case 'E': mplp.flag |= MPLP_REDO_BAQ; break;
case '6': mplp.flag |= MPLP_ILLUMINA13; break;
case 'R': mplp.flag |= MPLP_IGNORE_RG; break;
case 's': mplp.flag |= MPLP_PRINT_MAPQ; break;
case 'O': mplp.flag |= MPLP_PRINT_POS; break;
case 'C': mplp.capQ_thres = atoi(optarg); break;
case 'q': mplp.min_mq = atoi(optarg); break;
case 'Q': mplp.min_baseQ = atoi(optarg); break;
case 'b': file_list = optarg; break;
case 'o': {
char *end;
long value = strtol(optarg, &end, 10);
// Distinguish between -o INT and -o FILE (a bit of a hack!)
if (*end == '\0') mplp.openQ = value;
else mplp.output_fname = optarg;
}
break;
case 'e': mplp.extQ = atoi(optarg); break;
case 'h': mplp.tandemQ = atoi(optarg); break;
case 'A': use_orphan = 1; break;
case 'F': mplp.min_frac = atof(optarg); break;
case 'm': mplp.min_support = atoi(optarg); break;
case 'L': mplp.max_indel_depth = atoi(optarg); break;
case 'G': {
FILE *fp_rg;
char buf[1024];
mplp.rghash = khash_str2int_init();
if ((fp_rg = fopen(optarg, "r")) == NULL)
fprintf(stderr, "(%s) Fail to open file %s. Continue anyway.\n", __func__, optarg);
while (!feof(fp_rg) && fscanf(fp_rg, "%s", buf) > 0) // this is not a good style, but forgive me...
khash_str2int_inc(mplp.rghash, strdup(buf));
fclose(fp_rg);
}
break;
case 't': mplp.fmt_flag |= parse_format_flag(optarg); break;
case 'a': mplp.all++; break;
default:
if (parse_sam_global_opt(c, optarg, lopts, &mplp.ga) == 0) break;
/* else fall-through */
case '?':
print_usage(stderr, &mplp);
return 1;
}
}
if (!mplp.fai && mplp.ga.reference) {
mplp.fai_fname = mplp.ga.reference;
mplp.fai = fai_load(mplp.fai_fname);
if (mplp.fai == NULL) return 1;
}
if ( !(mplp.flag&MPLP_REALN) && mplp.flag&MPLP_REDO_BAQ )
{
fprintf(stderr,"Error: The -B option cannot be combined with -E\n");
return 1;
}
if (use_orphan) mplp.flag &= ~MPLP_NO_ORPHAN;
if (argc == 1)
{
print_usage(stderr, &mplp);
return 1;
}
int ret;
if (file_list) {
if ( read_file_list(file_list,&nfiles,&fn) ) return 1;
ret = mpileup(&mplp,nfiles,fn);
for (c=0; c<nfiles; c++) free(fn[c]);
free(fn);
}
else
ret = mpileup(&mplp, argc - optind, argv + optind);
if (mplp.rghash) khash_str2int_destroy_free(mplp.rghash);
free(mplp.reg); free(mplp.pl_list);
if (mplp.fai) fai_destroy(mplp.fai);
if (mplp.bed) bed_destroy(mplp.bed);
return ret;
}
int
main(int ac, char **av) {
char *cmd = *av;
char *cname;
unsigned long delimiters[MAX_DELIMITER];
char *localmappers[MAX_LOCALMAPPER];
char *nameprep_version = NULL;
int ndelimiters = 0;
int nlocalmappers = 0;
char *in_code = NULL;
char *out_code = NULL;
char *resconf_file = NULL;
int no_resconf = 0;
char *encoding_alias = NULL;
int flags = DEFAULT_FLAGS;
FILE *fp;
idn_result_t r;
idn_resconf_t resconf1, resconf2;
idn_converter_t conv;
int exit_value;
#ifdef HAVE_SETLOCALE
(void)setlocale(LC_ALL, "");
#endif
/*
* If the command name begins with 'r', reverse mode is assumed.
*/
if ((cname = strrchr(cmd, '/')) != NULL)
cname++;
else
cname = cmd;
if (cname[0] == 'r')
flags |= FLAG_REVERSE;
ac--;
av++;
while (ac > 0 && **av == '-') {
#define OPT_MATCH(opt) (strcmp(*av, opt) == 0)
#define MUST_HAVE_ARG if (ac < 2) print_usage(cmd)
#define APPEND_LIST(array, size, item, what) \
if (size >= (sizeof(array) / sizeof(array[0]))) { \
errormsg("too many " what "\n"); \
exit(1); \
} \
array[size++] = item; \
ac--; av++
if (OPT_MATCH("-in") || OPT_MATCH("-i")) {
MUST_HAVE_ARG;
in_code = av[1];
ac--;
av++;
} else if (OPT_MATCH("-out") || OPT_MATCH("-o")) {
MUST_HAVE_ARG;
out_code = av[1];
ac--;
av++;
} else if (OPT_MATCH("-conf") || OPT_MATCH("-c")) {
MUST_HAVE_ARG;
resconf_file = av[1];
ac--;
av++;
} else if (OPT_MATCH("-nameprep") || OPT_MATCH("-n")) {
MUST_HAVE_ARG;
nameprep_version = av[1];
ac--;
av++;
} else if (OPT_MATCH("-noconf") || OPT_MATCH("-C")) {
no_resconf = 1;
} else if (OPT_MATCH("-reverse") || OPT_MATCH("-r")) {
flags |= FLAG_REVERSE;
} else if (OPT_MATCH("-nolocalmap") || OPT_MATCH("-L")) {
flags &= ~FLAG_LOCALMAP;
} else if (OPT_MATCH("-nonameprep") || OPT_MATCH("-N")) {
flags &= ~FLAG_NAMEPREP;
} else if (OPT_MATCH("-unassigncheck") || OPT_MATCH("-u")) {
flags |= FLAG_UNASSIGNCHECK;
} else if (OPT_MATCH("-nounassigncheck") || OPT_MATCH("-U")) {
flags &= ~FLAG_UNASSIGNCHECK;
} else if (OPT_MATCH("-nobidicheck") || OPT_MATCH("-B")) {
flags &= ~FLAG_BIDICHECK;
} else if (OPT_MATCH("-noasciicheck") || OPT_MATCH("-A")) {
flags &= ~FLAG_ASCIICHECK;
} else if (OPT_MATCH("-nolengthcheck")) {
flags &= ~FLAG_LENGTHCHECK;
} else if (OPT_MATCH("-noroundtripcheck")) {
flags &= ~FLAG_ROUNDTRIPCHECK;
} else if (OPT_MATCH("-whole") || OPT_MATCH("-w")) {
flags &= ~FLAG_SELECTIVE;
} else if (OPT_MATCH("-localmap")) {
MUST_HAVE_ARG;
APPEND_LIST(localmappers, nlocalmappers, av[1],
"local maps");
} else if (OPT_MATCH("-delimiter")) {
unsigned long v;
MUST_HAVE_ARG;
v = get_ucs(av[1]);
APPEND_LIST(delimiters, ndelimiters, v,
"delimiter maps");
} else if (OPT_MATCH("-alias") || OPT_MATCH("-a")) {
MUST_HAVE_ARG;
encoding_alias = av[1];
ac--;
av++;
} else if (OPT_MATCH("-flush")) {
flush_every_line = 1;
} else if (OPT_MATCH("-version") || OPT_MATCH("-v")) {
print_version();
} else {
print_usage(cmd);
}
#undef OPT_MATCH
#undef MUST_HAVE_ARG
#undef APPEND_LIST
ac--;
av++;
}
if (ac > 1)
print_usage(cmd);
/* Initialize. */
if ((r = idn_resconf_initialize()) != idn_success) {
errormsg("error initializing library\n");
return (1);
}
/*
* Create resource contexts.
* `resconf1' and `resconf2' are almost the same but local and
* IDN encodings are reversed.
*/
resconf1 = NULL;
resconf2 = NULL;
if (idn_resconf_create(&resconf1) != idn_success ||
idn_resconf_create(&resconf2) != idn_success) {
errormsg("error initializing configuration contexts\n");
return (1);
}
/* Load configuration file. */
if (no_resconf) {
set_defaults(resconf1);
set_defaults(resconf2);
} else {
load_conf_file(resconf1, resconf_file);
load_conf_file(resconf2, resconf_file);
}
/* Set encoding alias file. */
if (encoding_alias != NULL)
set_encoding_alias(encoding_alias);
/* Set input codeset. */
if (flags & FLAG_REVERSE) {
if (in_code == NULL) {
conv = idn_resconf_getidnconverter(resconf1);
if (conv == NULL) {
errormsg("cannot get the IDN encoding.\n"
"please specify an appropriate one "
"with `-in' option.\n");
exit(1);
}
idn_resconf_setlocalconverter(resconf2, conv);
idn_converter_destroy(conv);
} else {
set_idncode(resconf1, in_code);
set_localcode(resconf2, in_code);
}
} else {
if (in_code == NULL) {
conv = idn_resconf_getlocalconverter(resconf1);
if (conv == NULL) {
errormsg("cannot get the local encoding.\n"
"please specify an appropriate one "
"with `-in' option.\n");
exit(1);
}
idn_resconf_setidnconverter(resconf2, conv);
idn_converter_destroy(conv);
} else {
set_localcode(resconf1, in_code);
set_idncode(resconf2, in_code);
}
}
/* Set output codeset. */
if (flags & FLAG_REVERSE) {
if (out_code == NULL) {
conv = idn_resconf_getlocalconverter(resconf1);
if (conv == NULL) {
errormsg("cannot get the local encoding.\n"
"please specify an appropriate one "
"with `-out' option.\n");
exit(1);
}
idn_resconf_setidnconverter(resconf2, conv);
idn_converter_destroy(conv);
} else {
set_localcode(resconf1, out_code);
set_idncode(resconf2, out_code);
}
} else {
if (out_code == NULL) {
conv = idn_resconf_getidnconverter(resconf1);
if (conv == NULL) {
errormsg("cannot get the IDN encoding.\n"
"please specify an appropriate one "
"with `-out' option.\n");
exit(1);
}
idn_resconf_setlocalconverter(resconf2, conv);
idn_converter_destroy(conv);
} else {
set_idncode(resconf1, out_code);
set_localcode(resconf2, out_code);
}
}
/* Set delimiter map(s). */
if (ndelimiters > 0) {
set_delimitermapper(resconf1, delimiters, ndelimiters);
set_delimitermapper(resconf2, delimiters, ndelimiters);
}
/* Set local map(s). */
if (nlocalmappers > 0) {
set_localmapper(resconf1, localmappers, nlocalmappers);
set_localmapper(resconf2, localmappers, nlocalmappers);
}
/* Set NAMEPREP version. */
if (nameprep_version != NULL) {
set_nameprep(resconf1, nameprep_version);
set_nameprep(resconf2, nameprep_version);
}
idn_res_enable(1);
/* Open input file. */
if (ac > 0) {
if ((fp = fopen(av[0], "r")) == NULL) {
errormsg("cannot open file %s: %s\n",
av[0], strerror(errno));
return (1);
}
} else {
fp = stdin;
}
/* Do the conversion. */
if (flags & FLAG_REVERSE)
exit_value = decode_file(resconf1, resconf2, fp, flags);
else
exit_value = encode_file(resconf1, resconf2, fp, flags);
idn_resconf_destroy(resconf1);
idn_resconf_destroy(resconf2);
return exit_value;
}
int main(int argc, char** argv)
{
int opt,adc;
char buffer[MAX_BUFFER]={0};
int fd;
int res,c,counter,i,in;
FILE *fp;
float v_in,v_out;
char *param_port = NULL;
char *param_speed = NULL;
char *param_imagefile=NULL;
char *param_mode=NULL;
char *param_backlight=NULL;
BITMAPFILEHEADER header;
BITMAPINFO *headerinfo;
int headersize,bitmapsize;
uint8_t *i_bits=NULL,*o_bits=NULL; // input bits array from original bitmap file, output bit as converted
int chunksize=300 * 3 ; //default chunk of bytes to send must be set to max the device can handle without loss of data
uint8_t b[3] ={0};
BOOL breakout=FALSE;
BOOL verbose_mode=FALSE;
BOOL has_more_data=TRUE;
BOOL param_init=FALSE;
BOOL show_image=FALSE;
BOOL show_version=FALSE;
BOOL test_pattern_full=FALSE;
BOOL ADC_read=FALSE;
printf("-----------------------------------------------------------------------------\n");
printf("\n");
printf(" BMP image sender for Nokia LCD Backpack V.0.3 \n");
printf(" Wiki Docs: http://dangerousprototypes.com/docs/Mathieu:_Another_LCD_backpack\n");
printf(" http://www.dangerousprototypes.com\n");
printf("\n");
printf("-----------------------------------------------------------------------------\n");
if (argc <= 1) {
print_usage(argv[0]);
exit(-1);
}
while ((opt = getopt(argc, argv, "iTtvVas:p:f:d:B:")) != -1) {
switch (opt) {
case 'p': // device eg. com1 com12 etc
if ( param_port != NULL){
printf(" Device/PORT error!\n");
exit(-1);
}
param_port = strdup(optarg);
break;
case 'f':
if (param_imagefile != NULL) {
printf(" Invalid Parameter after Option -f \n");
exit(-1);
}
param_imagefile = strdup(optarg);
break;
case 's':
if (param_speed != NULL) {
printf(" Speed should be set: eg 921600 \n");
exit(-1);
}
param_speed = strdup(optarg);
break;
case 'B': // added new: chuck size should be multiply by 3
// 1 * 3 up to max of file size or max port speed?
if ((atol(optarg) < MAX_BUFFER/3 )&&(atol(optarg)!=0) )
chunksize=atol(optarg)*3;
else {
printf(" Invalid chunk size parameter: using default: %i x 3 = %i Bytes\n",chunksize/3,chunksize);
}
break;
case 'd': // dim the backlight
if ( param_backlight != NULL){
printf(" Error: Parameter required to dim the backlight, Range: 0-100\n");
exit(-1);
}
param_backlight = strdup(optarg);
break;
case 'i': // initialize
if (optarg!=NULL) {
printf("Invalid option in -i\n");
} else {
param_init=TRUE;
}
break;
case 'V': //talk show some display
if (optarg !=NULL) {
printf("Invalid option in -V\n");
}
else {
verbose_mode=TRUE;
}
break;
case 'v': //
if (optarg !=NULL) {
printf("Invalid option in -v\n");
}
else {
show_version=TRUE;
}
break;
case 'T': //
if (optarg !=NULL) {
printf("Invalid option in -T\n");
}
else {
test_pattern_full=TRUE;
}
break;
case 'a': //
if (optarg !=NULL) {
printf("Invalid option in -a\n");
}
else {
ADC_read=TRUE;
}
break;
case 'h':
print_usage(argv[0]);
exit(-1);
break;
default:
printf(" Invalid argument %c", opt);
print_usage(argv[0]);
exit(-1);
break;
}
}
if (param_port==NULL){
printf(" No serial port specified\n");
print_usage(argv[0]);
exit(-1);
}
if (param_speed==NULL)
param_speed=strdup("921600"); //default is 921600kbps
fd = serial_open(param_port);
if (fd < 0) {
fprintf(stderr, " Error opening serial port\n");
return -1;
}
//setup port and speed
serial_setup(fd,(speed_t) param_speed);
if(param_init==TRUE) {
// i Reset and initialize the LCD.
buffer[0]='i';
serial_write( fd, buffer,1 );
printf(" LCD Initialized and reset\n");
}
if(show_version==TRUE) {
// i Reset and initialize the LCD.
buffer[0]='v';
serial_write( fd, buffer,1 );
Sleep(1);
res= serial_read(fd, buffer, sizeof(buffer));
printf(" Hardware/Software Version %s\n",buffer);
}
if(test_pattern_full==TRUE) {
// i Reset and initialize the LCD.
buffer[0]='T';
serial_write( fd, buffer,1 );
printf(" Test Pattern Command Send %c\n",buffer[0]);
printf(" Hit any key to end test \n");
if (getch()) {
buffer[0]=0x00; //any bytes to end
serial_write( fd, buffer,1 );
}
Sleep(1);
res= serial_read(fd, buffer, sizeof(buffer));
printf(" Full Screen Test Ends: ");
if(res==1 && buffer[0]==0x01 ){
printf(" Success!\n");
}
else {
printf(" Reply received: ");
for (i=0;i <res;i++)
printf(" %02x",(uint8_t) buffer[i]);
printf("\n");
}
}
if( ADC_read==TRUE) {
// LCD backlight voltage reading
//Raw reading: 0x182 (386)
//Actual voltage: (386/1024)*3.3volts=1.24volts
//Scale for resistor divider: Vin = (Vout*(R1+R2))/R2 = (1.24volts*(18K+3.9K))/3.9K = 7.01volts (ideal is 7volts)
buffer[0]='a';
serial_write( fd, buffer,1);
printf(" ADC read command Send: %c \n",buffer[0]);
Sleep(1);
res= serial_read(fd, buffer, sizeof(buffer));
//expects 2 bytes at buffer[0] and buffer[1]
printf(" Voltage Reading : ");
for (i=0;i< res;i++)
printf(" %02x",buffer[i]);
adc = buffer[0] << 8;
adc += buffer[1];
v_out=((float)(adc)/1024.0)*3.3;
v_in = (1.24*(18000.0+3900.0))/3900.0;
printf("= %2.2f",v_in);
if((v_in>6.5) && (v_in<7.5)){
printf(" **PASS**\n");
}else{
printf(" FAIL!!!! :(\n");
}
}
if(param_backlight !=NULL) {
// convert 0-100 to bytes, 0x00 - 0xff
buffer[0]='d';
char dx=(atol(param_backlight)*255)/100;
buffer[1]=dx;
serial_write( fd, buffer,2 );
printf(" Dimlight Command Send: %c %c\n",buffer[0],buffer[1]);
Sleep(1);
res= serial_read(fd, buffer, sizeof(buffer));
printf(" Dim command reply: ");
if(res==1 && buffer[0]==0x01 ){
printf(" Success!\n");
}
else {
printf(" Reply received: ");
for (i=0;i <res;i++)
printf(" %02x",(uint8_t) buffer[i]);
printf("\n");
}
}
if (param_imagefile !=NULL) {
show_image=TRUE;
}
if (show_image==TRUE) {
//checks is needed to make sure this is a valid bmp file
//open the Imagefile file
if ((fp = fopen(param_imagefile, "rb")) == NULL) {
printf(" Cannot open image file: %s\n",param_imagefile);
exit(-1);
}
if (fread(&header, sizeof(BITMAPFILEHEADER), 1, fp) < 1){
printf(" Invalid Image file.. requires BMP file \n");
fclose(fp);
exit(-1);
}
if (header.bfType != BF_TYPE) { //BM as signature
printf("File: %s is not a valid bitmap file! \n ",param_imagefile);
fclose(fp);
exit(-1);
}
headersize = header.bfOffBits - sizeof(BITMAPFILEHEADER);
// printf("Header.bfoffbits: %lu Sizeof Bitmapfilehader: %i Headersize is : %i\n",header.bfOffBits,sizeof(BITMAPFILEHEADER),headersize);
if ((headerinfo = (BITMAPINFO *)malloc(headersize)) == NULL){
printf("Error allocating memory\n");
fclose(fp);
exit(-1);
}
//error in debian here-> might be because I am using 64 bit
if ((res=fread(headerinfo, 1, headersize, fp)) < headersize){
printf("Error: Headersize Error %i < %i\n",res,headersize );
fclose(fp);
exit(-1);
}
printf(" Header size is %lu\n",headerinfo->bmiHeader.biSize);
printf(" Image size is %lupx x %lupx\n",headerinfo->bmiHeader.biWidth,headerinfo->bmiHeader.biHeight);
printf(" Number of colour planes is %d\n",headerinfo->bmiHeader.biPlanes);
printf(" Bits per pixel is %d\n",headerinfo->bmiHeader.biBitCount);
// printf(" Compression type is %lu\n",headerinfo->bmiHeader.biCompression);
// printf(" Image size is %lu\n",headerinfo->bmiHeader.biSizeImage);
// printf(" Number of colours is %lu\n",headerinfo->bmiHeader.biClrUsed);
// printf(" Number of required colours is %lu\n",headerinfo->bmiHeader.biClrImportant);
if ((bitmapsize = headerinfo->bmiHeader.biSizeImage) == 0){
bitmapsize = (headerinfo->bmiHeader.biWidth * headerinfo->bmiHeader.biBitCount + 7) / 8 * abs(headerinfo->bmiHeader.biHeight);
}
if ((i_bits = malloc(bitmapsize)) == NULL){ //allocate enough memory
printf(" Error: Cannot allocate enough memory \n");
fclose(fp);
exit(-1);
}
if ((o_bits = malloc(bitmapsize/2+1)) == NULL){ //allocate enough memory
printf(" Error: Cannot allocate enough memory \n");
fclose(fp);
exit(-1);
}
for (i=0;i < bitmapsize/2+1;i++)
o_bits[i]=0x00; // make sure padding is there
fclose(fp);
fp = fopen(param_imagefile, "rb");
printf(" Offset to image data is %lu bytes\n",header.bfOffBits);
//close and reopen bmp file
//send the command //Send 'p' or 'P' send page of image data.
printf(" Setting image mode \n");
buffer[0]='P';
serial_write( fd, buffer,1 );
fseek(fp,header.bfOffBits,SEEK_SET); //and disable this if above fgets is enabled
if ((res=fread(i_bits,sizeof(unsigned char),bitmapsize,fp)) != bitmapsize) {
printf(" Header information error: image data size inconsistent. %i %i\n",res,bitmapsize);
fclose(fp);
exit(-1);
}
printf(" Opening Port on %s at %sbps, using image file %s chunksize = %i X %i \n", param_port, param_speed,param_imagefile,chunksize/3,3);
printf(" Ready to convert %d bit into 12 bit image data.. \n",headerinfo->bmiHeader.biBitCount);
printf(" Press any key when ready...\n");
getch();
switch (headerinfo->bmiHeader.biBitCount) {
case 1:
printf(" 1 bit (black and white) not yet done");
fclose(fp);
exit(-1);
break;
case 4:
printf(" 4-bit (16 colors) not yet done");
fclose(fp);
exit(-1);
break;
case 8:
printf(" 8 bit (256 colors) not yet done");
fclose(fp);
exit(-1);
break;
case 16:
printf(" 16-bit not yet done");
fclose(fp);
exit(-1);
break;
case 24: //convert i_bits to 12bits into o_bits
counter=0; // counter for original bitmap data
in=0; //counter for putting bytes in o_bits
breakout=FALSE;
while(1) {
//the LCD needs 12bit color, this is 24bit
//we need to discard the lower 4 bits of each byte
//and pack six half bytes into 3 bytes to send the LCD
//if we only have one pixel to process (3bytes) instead of 2, then the last should be 0
//need to do checks for end of data, make this more effecient
//BMP byte order of BGR...
//rrrrgggg bbbbrrrr ggggbbbb ... ggggbbbb
//grab six bytes
for (i=0;i < 6;i++){
if (counter > bitmapsize-1){
buffer[i]=0x00; //pad remaining then exit the loop
breakout=TRUE;
} else {
buffer[i]=i_bits[counter++];
}
if(verbose_mode==TRUE)
printf(" %02x",(unsigned char) buffer[i]);
}
// convert to 4 bits each RGB
if(verbose_mode==TRUE)
printf("--->");
//R G
b[0]=((buffer[2]&0xf0)|((buffer[1]>>4)&0x0f));
//B R2
b[1]=(buffer[0]&0xf0)|((buffer[5]>>4)&0x0f);
//G2B2
b[2]=(buffer[4]&0xf0)|((buffer[3]>>4)&0x0f);
// put in o_bits
o_bits[in++] =b[0];
o_bits[in++] =b[1];
o_bits[in++] =b[2];
if(verbose_mode==TRUE)
printf("%02X %02X %02X \n",b[0],b[1],b[2]);
if (breakout==TRUE) {
//try to clean
if ((b[0]==0x00)&& (b[1] == 0x00)&& (b[2]==0x00)) {
//remove excess padding
in-=3;
break;
}
}
}
break;
case 32:
printf(" 32-bit not yet done");
fclose(fp);
exit(-1);
break;
default:
printf(" Unrecognize Bit count \n");
fclose(fp);
exit(-1);
}
printf(" sending image data..\n ");
has_more_data=TRUE;
i=0;
while(i< in){
for (c=0; c < chunksize; c++) {
if (i+c < in){
buffer[c]= o_bits[i+c];
}
else {
// no more data
has_more_data=FALSE;
break; //breakout of for loop, c has the last chunk
}
}
if(verbose_mode==TRUE) {
for(counter=0;counter < c;counter++) {
printf(" [%i] %02X \n", i+counter, (uint8_t) buffer[counter]);
// printf(" %02X \n", (uint8_t) buffer[counter]);
}
}
serial_write( fd, buffer,c);
i=i+c;
if(has_more_data==FALSE)
break;
}
printf(" Total Bytes Sent: %i\n",i);
Sleep(1);
res= serial_read(fd, buffer, sizeof(buffer));
if(res==1 && buffer[0]==0x01 ){
printf(" Success!\n");
}
else {
printf(" Reply received: ");
for (i=0;i <res;i++)
printf(" %02x",(uint8_t) buffer[i]);
printf("\n");
}
printf(" Done! :-)\n\n");
//close lcd
fclose(fp);
}
serial_close(fd);
FREE(param_port);
FREE(param_speed);
FREE(param_imagefile);
FREE(param_mode);
return 0;
} //end main()
int main(int argc, char *argv[])
{
LINX *linx;
LINX_SPID server_spid;
union LINX_SIGNAL *sig;
pthread_t server_th;
int c;
int loop_cnt = LOOP_CNT;
int use_linx_api = LINX_SOCKET;
size_t msg_size = BURST_SIZE;
unsigned long burst_cnt = BURST_CNT;
size_t start_msg_size = START_MSG_SIZE;
size_t end_msg_size = END_MSG_SIZE;
unsigned long throughput_instances = THROUGHPUT_INSTANCES;
int iterations = ITERATIONS;
LINX_SIGSELECT any_sig[] = { 0 };
char *path = NULL;
char *server_name = NULL;
int run_attach_test = 0;
int run_com_test = 0;
int kill_server = 0;
int all = 0;
int use_pthreads = 0;
if (argc < 2) {
print_usage(argv[0]);
return 0;
}
while ((c = getopt(argc, argv, "S?p:ac:n:m:b:i:s:e:Alt:qP")) != -1) {
switch (c) {
case 'S':
/* Start server */
server_name = (optarg == NULL ? SERVER_NAME : optarg);
break;
case 'P':
/* Start server as posix thread */
server_name = SERVER_NAME;
use_pthreads = 1;
break;
case 'p':
/* Hunt path */
path = optarg;
break;
case 'a':
/* Run attach test */
run_attach_test = 1;
break;
case 'c':
/* Connection test */
run_com_test = atoi(optarg);
break;
case 'n':
/* Loop count */
loop_cnt = atoi(optarg);
break;
case 'm':
/* Message size */
msg_size = atol(optarg);
break;
case 'b':
/* Burst count */
burst_cnt = atol(optarg);
break;
case 'i':
/* Iterations */
iterations = atoi(optarg);
break;
case 's':
/* Start message size */
start_msg_size = atol(optarg);
break;
case 'e':
/* End message size */
end_msg_size = atol(optarg);
break;
case 'A':
/* Run all tests */
all = 1;
break;
case 'l':
/* Use linx api in tests */
use_linx_api = LINX_API;
break;
case 't':
/* Number of instances in throughput */
throughput_instances = atoi(optarg);
break;
case 'q':
/* Quit the server */
kill_server = 1;
break;
default:
print_usage(argv[0]);
return 0;
}
}
if(use_pthreads) {
kill_server = 1;
if (pthread_create(&server_th, NULL, server,
(void *)server_name)) {
fprintf(stderr, "pthread_create(): %d\n", errno);
exit(errno);
}
} else if (server_name != NULL) {
(void)server(server_name);
return 0;
}
/* Path to server */
path = path && *path ? path : CS_PATH SERVER_NAME;
/* Hunt for server */
linx = linx_open(CLIENT_NAME, 0, NULL);
linx_hunt(linx, path, NULL);
linx_receive_w_tmo(linx, &sig, 1000, any_sig);
if (sig == NULL) {
printf("Hunt failed. No server found at path '%s'.\n"
"Is the server started and path ok? "
"(Server started with -S option)\n", path);
linx_close(linx);
return 1;
}
if (sig->sigNo != LINX_OS_HUNT_SIG) {
ERR("Failed to hunt for '%s'", path);
linx_free_buf(linx, &sig);
linx_close(linx);
return 1;
}
server_spid = linx_sender(linx, &sig);
linx_free_buf(linx, &sig);
/* Attach to server */
sig = linx_alloc(linx, sizeof(LINX_SIGSELECT), ATTACH_SERV_SIG);
linx_attach(linx, &sig, server_spid);
if (run_attach_test) {
attach_test(linx, path, loop_cnt, server_spid, use_linx_api,
use_pthreads);
}
switch (run_com_test) {
case 1:
/* Start com test 1 */
linx_bmark_latency(linx, path, loop_cnt, msg_size, msg_size,
ONE_ITERATION, server_spid, use_linx_api,
use_pthreads);
break;
case 2:
/* Start com test 2 */
linx_bmark_burst(linx, path, loop_cnt, msg_size,
msg_size, ONE_ITERATION,
burst_cnt, server_spid, use_linx_api,
use_pthreads);
break;
case 3:
/* Start com test 3 */
linx_bmark_latency(linx, path, loop_cnt, start_msg_size,
end_msg_size, iterations, server_spid,
use_linx_api, use_pthreads);
break;
case 4:
/* Start com test 4 */
linx_bmark_burst(linx, path, loop_cnt, start_msg_size,
end_msg_size, iterations, burst_cnt,
server_spid, use_linx_api, use_pthreads);
break;
case 5:
/* Start com test 5 */
linx_bmark_throughput(path, loop_cnt, msg_size,
server_spid, use_linx_api,
throughput_instances, use_pthreads);
break;
default:
break;
}
if (all) {
/* All tests */
attach_test(linx, path, loop_cnt, server_spid, use_linx_api,
use_pthreads);
linx_bmark_latency(linx, path, loop_cnt, msg_size, msg_size,
ONE_ITERATION, server_spid, use_linx_api,
use_pthreads);
linx_bmark_burst(linx, path, loop_cnt, msg_size, msg_size,
ONE_ITERATION, burst_cnt,
server_spid, use_linx_api, use_pthreads);
linx_bmark_latency(linx, path, loop_cnt, start_msg_size,
end_msg_size, iterations,
server_spid, use_linx_api, use_pthreads);
linx_bmark_burst(linx, path, loop_cnt, start_msg_size,
end_msg_size, iterations, burst_cnt,
server_spid, use_linx_api, use_pthreads);
linx_bmark_throughput(path, loop_cnt, msg_size,
server_spid, use_linx_api,
throughput_instances, use_pthreads);
}
if (kill_server) {
/* If no test argument specified, let server close */
sig = linx_alloc(linx, sizeof(LINX_SIGSELECT), CONN_TERM);
linx_send(linx, &sig, server_spid);
printf("Waiting for attach from server.\n");
linx_receive(linx, &sig, any_sig);
if (sig == LINX_NIL) {
ERR("No attach signal was received from the server.");
}
if (sig->sigNo != ATTACH_SERV_SIG) {
ERR("Wrong signal received while waiting for "
"attach signal from server.");
}
linx_free_buf(linx, &sig);
/* Close client spid */
linx_close(linx);
}
if(use_pthreads)
pthread_join(server_th, NULL);
return 0;
}
static void process_command_line(int argc, char *argv[]) {
cmdline_parser_t parser;
cmdline_elem_t elem;
input_filename = NULL;
dump_filename = NULL;
dump_requested = false;
init_cmdline_parser(&parser, options, NUM_OPTIONS, argv, argc);
for (;;) {
cmdline_parse_element(&parser, &elem);
switch (elem.status) {
case cmdline_done:
goto done;
case cmdline_argument:
if (input_filename == NULL) {
input_filename = elem.arg;
} else {
fprintf(stderr, "%s: can't have several input files\n", parser.command_name);
goto bad_usage;
}
break;
case cmdline_option:
switch (elem.key) {
case version_flag:
print_version();
goto quick_exit;
case help_flag:
print_help(parser.command_name);
goto quick_exit;
case set_dump:
dump_requested = true;
if (elem.s_value != NULL) {
if (dump_filename == NULL) {
dump_filename = elem.s_value;
} else {
fprintf(stderr, "%s: can't have several dump files\n", parser.command_name);
goto bad_usage;
}
}
break;
default:
assert(false);
break;
}
break;
case cmdline_error:
cmdline_print_error(&parser, &elem);
goto bad_usage;
}
}
quick_exit:
exit(YICES_EXIT_SUCCESS);
bad_usage:
print_usage(parser.command_name);
exit(YICES_EXIT_USAGE);
done:
return;
}
int main (int argc, char **argv)
{
args_t args;
LTE_DL_FRAME_PARMS frame_parms0;
LTE_DL_FRAME_PARMS *frame_parms=&frame_parms;
char sdu0[16],sdu1[64],sdu2[1024],sdu3[1024],sdu4[1024];
unsigned short sdu_len0,sdu_len1,sdu_len2,sdu_len3,sdu_len4;
char ulsch_buffer[1024],dlsch_buffer[1024];
u8 lcid;
u8 payload_offset;
int i,comp;
logInit();
NB_UE_INST = 1;
NB_eNB_INST = 1;
NB_INST=2;
// Parse arguments
if(parse_args(argc, argv, &args) > 0) {
print_usage(argv[0]);
exit(1);
}
set_taus_seed(0);
logInit();
set_glog(LOG_TRACE, 1);
for (comp = PHY; comp < MAX_LOG_COMPONENTS ; comp++)
set_comp_log(comp,
LOG_TRACE,
LOG_NONE,
1);
/*
set_log(OMG, LOG_INFO, 20);
set_log(EMU, LOG_INFO, 10);
set_log(OCG, LOG_INFO, 1);
set_log(MAC, LOG_TRACE, 1);
set_log(RLC, LOG_TRACE, 1);
set_log(PHY, LOG_DEBUG, 1);
set_log(PDCP, LOG_TRACE, 1);
set_log(RRC, LOG_TRACE, 1);
*/
mac_xface = (MAC_xface *)malloc(sizeof(MAC_xface));
init_lte_vars (&frame_parms, 0, 1, 0, 0, 25, 0, 0, 1, 1);
l2_init(frame_parms);
// Generate eNB SI
if (args.input_sib == 0) {
openair_rrc_lite_eNB_init(0);
} else {
printf("Got SI from files (%d,%d,%d,%d,%d)\n",args.input_sib,args.input1_sdu_flag,args.input2_sdu_flag);
}
openair_rrc_on(0,0);
openair_rrc_lite_ue_init(0,0);
switch (args.SDUsource) {
case eNB_RRC:
if (args.RRCmessage == RRCSIB1) {
if (args.input1_sdu_flag == 1) {
for (i=0; i<args.input1_sdu_len; i++)
printf("%02x",args.input1_sdu[i]);
printf("\n");
ue_decode_si(0,142,0,args.input1_sdu,args.input1_sdu_len);
} else {
printf("\n\nSIB1\n\n");
for (i=0; i<eNB_rrc_inst[0].sizeof_SIB1; i++)
printf("%02x",eNB_rrc_inst[0].SIB1[i]);
printf("\n");
}
} else if (args.RRCmessage == RRCSIB2_3) {
if (args.input1_sdu_flag == 1) {
for (i=0; i<args.input2_sdu_len; i++)
printf("%02x",args.input2_sdu[i]);
printf("\n");
ue_decode_si(0,149,0,args.input1_sdu,args.input1_sdu_len);
} else {
printf("\n\nSIB2_3\n\n");
for (i=0; i<eNB_rrc_inst[0].sizeof_SIB23; i++)
printf("%02x",eNB_rrc_inst[0].SIB23[i]);
printf("\n");
}
} else if ((args.input1_sdu_flag == 1)&&
((args.RRCmessage == RRCConnectionSetup) ||
(args.RRCmessage == RRCConnectionReconfiguration))) {
sdu_len0 = attach_ue0(sdu0);
ue_send_sdu(0,143,args.input1_sdu,args.input1_sdu_len,0);
if (args.RRCmessage == RRCConnectionReconfiguration)
ue_send_sdu(0,144,args.input2_sdu,args.input2_sdu_len,0);
} else {
switch (args.RRCmessage) {
case RRCConnectionSetup:
printf("Doing eNB RRCConnectionSetup\n");
sdu_len0 = attach_ue0(sdu0);
sdu_len1 = attach_ue1(sdu1);
lcid = 0;
payload_offset = generate_dlsch_header(dlsch_buffer,
1, //num_sdus
&sdu_len1, //
&lcid, // sdu_lcid
255, // no drx
0, // no timing advance
sdu0, // contention res id
0,0);
memcpy(&dlsch_buffer[payload_offset],sdu1,sdu_len1);
printf("\nRRCConnectionSetup (DLSCH input / MAC output)\n\n");
for (i=0; i<sdu_len1+payload_offset; i++)
printf("%02x ",(unsigned char)sdu1[i]);
printf("\n");
break;
case RRCConnectionReconfiguration:
printf("Doing eNB RRCConnectionReconfiguration\n");
sdu_len0 = attach_ue0(sdu0);
sdu_len1 = attach_ue1(sdu1);
sdu_len2 = attach_ue2(sdu1,sdu_len1,sdu2);
sdu_len3 = attach_ue3(sdu2,sdu_len2,sdu3);
lcid=1;
payload_offset = generate_dlsch_header(dlsch_buffer,
// offset = generate_dlsch_header((unsigned char*)eNB_mac_inst[0].DLSCH_pdu[0][0].payload[0],
1, //num_sdus
&sdu_len3, //
&lcid,
255, // no drx
1, // timing advance
NULL, // contention res idk
0,0);
memcpy(&dlsch_buffer[payload_offset],sdu3,sdu_len3);
printf("\nRRCConnectionReconfiguration (DLSCH input / MAC output)\n\n");
for (i=0; i<sdu_len3+payload_offset; i++)
printf("%02x ",(unsigned char)dlsch_buffer[i]);
printf("\n");
break;
default:
printf("Unknown eNB_RRC SDU (%d), exiting\n",args.RRCmessage);
break;
}
break;
}
break;
case eNB_MAC:
sdu_len0 = attach_ue0(sdu0);
ue_send_sdu(0,143,args.input1_sdu,args.input1_sdu_len,0);
break;
case UE_RRC:
switch (args.RRCmessage) {
case RRCConnectionRequest:
sdu_len0 = attach_ue0(sdu0);
printf("\n\nRRCConnectionRequest\n\n");
for (i=0; i<sdu_len0; i++)
printf("%02x ",(unsigned char)sdu0[i]);
printf("\n");
break;
case RRCConnectionSetupComplete:
sdu_len0=attach_ue0(sdu0);
sdu_len1 = attach_ue1(sdu1);
sdu_len2 = attach_ue2(sdu1,sdu_len1,sdu2);
lcid=1;
printf("Got sdu of length %d\n",sdu_len2);
payload_offset = generate_ulsch_header((u8*)ulsch_buffer, // mac header
1, // num sdus
0, // short pading
&sdu_len2, // sdu length
&lcid, // sdu lcid
NULL, // power headroom
NULL, // crnti
NULL, // truncated bsr
NULL, // short bsr
NULL, // long_bsr
0);
printf("Got MAC header of length %d\n",payload_offset);
memcpy(&ulsch_buffer[payload_offset],sdu2,sdu_len2);
printf("\n\nRRCConnectionSetupComplete (ULSCH input / MAC output)\n\n");
for (i=0; i<sdu_len2+payload_offset; i++)
printf("%02x ",(unsigned char)ulsch_buffer[i]);
printf("\n");
break;
case RRCConnectionReconfigurationComplete:
sdu_len0=attach_ue0(sdu0);
sdu_len1=attach_ue1(sdu1);
sdu_len2 = attach_ue2(sdu1,sdu_len1,sdu2);
sdu_len3 = attach_ue3(sdu2,sdu_len2,sdu3);
sdu_len4 = attach_ue4(sdu3,sdu_len3,sdu4);
lcid=1;
printf("Got sdu of length %d\n",sdu_len4);
payload_offset = generate_ulsch_header((u8*)ulsch_buffer, // mac header
1, // num sdus
0, // short pading
&sdu_len4, // sdu length
&lcid, // sdu lcid
NULL, // power headroom
NULL, // crnti
NULL, // truncated bsr
NULL, // short bsr
NULL, // long_bsr
0);
printf("Got MAC header of length %d\n",payload_offset);
memcpy(&ulsch_buffer[payload_offset],sdu4,sdu_len4);
printf("\n\nRRCConnectionReconfigurationComplete (ULSCH input / MAC output)\n\n");
for (i=0; i<sdu_len4+payload_offset; i++)
printf("%02x ",(unsigned char)ulsch_buffer[i]);
printf("\n");
break;
default:
printf("Unknown UE_RRC SDU (%d), exiting\n",args.RRCmessage);
break;
}
break;
}
free(mac_xface);
return(0);
}
int main(int argc, char **argv)
{
signal(SIGINT, do_cleanup);
for(;;)
{
int options_index = 0;
int c = getopt_long(argc, argv, ":", long_options, &options_index);
if(c == -1)
break;
if(c == 1 || c == 2)
{
if(optarg == NULL)
{
print_usage(argv[0]);
}
if(strncmp("true", optarg, 5) == 0)
{
if(c == 1)
bus_pirate_flag = 0;
if(c == 2)
termiobaud = 1;
}
}
}
if (optind + 1 != argc) {
print_usage(argv[0]);
}
device_file = malloc(strlen(argv[optind])+1);
memcpy(device_file, argv[optind], strlen(argv[optind])+1);
//Initialization complete!
devicefd = open(device_file, O_RDWR | O_NOCTTY);
if(devicefd == -1)
{
fprintf(stderr, "E: Cannot open device %s\n", device_file);
exit(1);
}
printf("Device file: %s\n", device_file);
if(termiobaud)
{
struct termios options;
speed_t speed = B9600;
if(bus_pirate_flag)
{
speed = B115200;
}
tcgetattr(devicefd, &options);
//8N1
options.c_cflag &= ~PARENB;
options.c_cflag &= ~CSTOPB;
options.c_cflag &= ~CSIZE;
options.c_cflag |= CS8;
cfsetispeed(&options, speed);
cfsetospeed(&options, speed);
tcsetattr(devicefd, TCSAFLUSH, &options);
}
if(bus_pirate_flag)
{
bp_enter_uart_binary(devicefd);
bp_uart_set_power(devicefd, 1);
fprintf(stderr, "Entered BP binary mode.\n");
}
struct gt511c1r fpr;
gt511c1r_init(&fpr, devicefd, do_usrt);
gt511c1r_open(&fpr);
int userinput = 0;
int id = 0;
for(;;)
{
printf("Input number\n"
"0 - Exit program\n"
"1 - Clear fingerprint memory\n"
"2 - Enroll finger\n"
"3 - Identify finger\n"
"select>");
scanf("%d", &userinput);
switch(userinput)
{
case 0:
do_cleanup();
case 1:
gt511c1r_delete_all_fingerprint(&fpr);
break;
case 2:
printf("Input slot number: ");
scanf("%d", &userinput);
if(userinput < 0 || userinput > 19)
{
printf("Wrong number!\n");
break;
}
gt511c1r_enroll_fingerprint(&fpr, userinput);
break;
case 3:
printf("Identifying!\n");
id = gt511c1r_identify_fingerprint(&fpr);
printf("Identified as fingerprint #%d\n", id);
break;
default:
printf("Not in range!\n");
}
}
//TODO: Display interactive console.
sleep(1);
do_cleanup();
return 0;
}
int main(int argc, const char** argv)
{
argv0 = argv[0];
bool print_stats = false;
U.start();
// Set up smsh related error codes
if (! (w_error_t::insert(
"ss_m shell",
smsh_error_list, SSH_MAX_ERROR - SSH_MIN_ERROR - 1))) {
abort();
}
/*
* The following section of code sets up all the various options
* for the program. The following steps are performed:
- determine the name of the program
- setup an option group for the program
- initialize the ssm options
- scan default option configuration files ($HOME/.shoreconfig .shoreconfig)
- process any options found on the command line
- use getopt() to process smsh specific flags on the command line
- check that all required options are set before initializing sm
*/
// set prog_name to the file name of the program
const char* prog_name = strrchr(argv[0], '/');
if (prog_name == NULL) {
prog_name = argv[0];
} else {
prog_name += 1; /* skip the '/' */
if (prog_name[0] == '\0') {
prog_name = argv[0];
}
}
/*
* Set up and option group (list of options) for use by
* all layers of the system. Level "smsh" indicates
* that the program is a a part to the smsh test suite.
* Level "server" indicates
* the type of program (the smsh server program). The third
* level is the program name itself.
*/
option_group_t options(3);
W_COERCE(options.add_class_level("smsh"));
W_COERCE(options.add_class_level("server"));
W_COERCE(options.add_class_level(prog_name));
/*
* Set up and smsh option for the name of the tcl library directory
* and the name of the .smshrc file.
*/
option_t* smsh_libdir;
option_t* smsh_smshrc;
W_COERCE(options.add_option("smsh_libdir", "directory name", NULL,
"directory for smsh tcl libraries",
true, option_t::set_value_charstr, smsh_libdir));
W_COERCE(options.add_option("smsh_smshrc", "rc file name", ".smshrc",
"full path name of the .smshrc file",
false, option_t::set_value_charstr, smsh_smshrc));
// have the sm add its options to the group
W_COERCE(ss_m::setup_options(&options));
/*
* Scan the default configuration files: $HOME/.shoreconfig, .shoreconfig. Note
* That OS errors are ignored since it is not an error
* for this file to not be found.
*/
rc_t rc;
{
char opt_file[ss_m::max_devname+1];
for(int file_num = 0; file_num < 2 && !rc.is_error(); file_num++) {
// scan default option files
w_ostrstream err_stream;
const char* config = ".shoreconfig";
if (file_num == 0) {
if (!getenv("HOME")) {
// ignore it ...
// cerr << "Error: environment variable $HOME is not set" << endl;
// rc = RC(SSH_FAILURE);
break;
}
if (sizeof(opt_file) <= strlen(getenv("HOME")) + strlen("/") + strlen(config) + 1) {
cerr << "Error: environment variable $HOME is too long" << endl;
rc = RC(SSH_FAILURE);
break;
}
strcpy(opt_file, getenv("HOME"));
strcat(opt_file, "/");
strcat(opt_file, config);
} else {
w_assert3(file_num == 1);
strcpy(opt_file, "./");
strcat(opt_file, config);
}
{
option_file_scan_t opt_scan(opt_file, &options);
rc = opt_scan.scan(true, err_stream);
err_stream << ends;
if (rc.is_error()) {
// ignore OS error messages
if (rc.err_num() == fcOS) {
rc = RCOK;
} else {
// this error message is kind of gross but is
// sufficient for now
cerr << "Error in reading option file: " << opt_file << endl;
//cerr << "\t" << w_error_t::error_string(rc.err_num()) << endl;
cerr << "\t" << err_stream.c_str() << endl;
}
}
}
}
}
/*
* Assuming there has been no error so far, the command line
* is processed for any options in the option group "options".
*/
if (!rc.is_error()) {
// parse command line
w_ostrstream err_stream;
rc = options.parse_command_line(argv, argc, 2, &err_stream);
err_stream << ends;
if (rc.is_error()) {
cerr << "Error on command line " << endl;
cerr << "\t" << w_error_t::error_string(rc.err_num()) << endl;
cerr << "\t" << err_stream.c_str() << endl;
print_usage(cerr, prog_name, false, options);
}
}
/*
* Assuming there has been no error so far, the command line
* is processed for any smsh specific flags.
*/
int option;
//if (!rc)
{ // do even if error so that smsh -h can be recognized
bool verbose_opt = false; // print verbose option values
while ((option = getopt(argc, (char * const*) argv, "Cf:hLOsTvV")) != -1) {
switch (option) {
case 'T':
extern bool logtrace;
logtrace = true;
break;
case 'O':
// Force use of old sort
cout << "Force use of old sort implementation." <<endl;
newsort = false;
break;
case 'C':
// force compression of btrees
force_compress = true;
break;
case 's':
print_stats = true;
break;
case 'f':
f_arg = optarg;
break;
case 'L':
// use log warning callback
log_warn_callback = true;
break;
case 'h':
// print a help message describing options and flags
print_usage(cerr, prog_name, true, options);
// free rc structure to avoid complaints on exit
W_IGNORE(rc);
goto done;
break;
case 'v':
verbose_opt = true;
break;
case 'V':
verbose = true;
break;
default:
cerr << "unknown flag: " << option << endl;
rc = RC(SSH_COMMAND_LINE);
}
}
if (verbose_opt) {
options.print_values(false, cerr);
}
}
/*
* Assuming no error so far, check that all required options
* in option_group_t options are set.
*/
if (!rc.is_error()) {
// check required options
w_ostrstream err_stream;
rc = options.check_required(&err_stream);
err_stream << ends;
if (rc.is_error()) {
cerr << "These required options are not set:" << endl;
cerr << err_stream.c_str() << endl;
print_usage(cerr, prog_name, false, options);
}
}
/*
* If there have been any problems so far, then exit
*/
if (rc.is_error()) {
// free the rc error structure to avoid complaints on exit
W_IGNORE(rc);
goto errordone;
}
/*
* At this point, all options and flags have been properly
* set. What follows is initialization for the rest of
* the program. The ssm will be started by a tcl_thread.
*/
// setup table of sm commands - doesn't involve the Tcl_Interp
dispatch_init();
// set up the linked variables
// either these should be read-only or
// they need to be made thread-safe. We can assume for smsh they
// are for all purposes read-only, since only the mama thread sets
// them in the scripts.
linked.sm_page_sz = ss_m::page_sz;
linked.sm_max_exts = ss_m::max_exts;
linked.sm_max_vols = ss_m::max_vols;
linked.sm_max_servers = ss_m::max_servers;
linked.sm_max_keycomp = ss_m::max_keycomp;
linked.sm_max_dir_cache = ss_m::max_dir_cache;
linked.sm_max_rec_len = ss_m::max_rec_len;
linked.sm_srvid_map_sz = ss_m::srvid_map_sz;
linked.verbose_flag = verbose?1:0;
linked.verbose2_flag = verbose2?1:0;
linked.instrument_flag = instrument?1:0;
linked.compress_flag = force_compress?1:0;
linked.log_warn_callback_flag = log_warn_callback?1:0;
{
int tty = isatty(0);
interactive = tty && f_arg;
}
// Create the main tcl_thread
{
tcl_thread_t* tcl_thread = NULL;
bool ok = true;
if(ok) {
if (f_arg) {
TCL_AV char* av[2];
av[0] = TCL_AV1 "source";
av[1] = f_arg;
// smsh -f <file>
tcl_thread = new tcl_thread_t(2, av,
smsh_libdir->value(),
smsh_smshrc->value()
);
} else {
// interactive
/*
cerr << __func__ << " " << __LINE__ << " " << __FILE__
<< " INTERACTIVE libdir " << smsh_libdir->value()
<< " msshrc " << smsh_smshrc->value()
<< endl;
*/
tcl_thread = new tcl_thread_t(0, 0,
smsh_libdir->value(),
smsh_smshrc->value()
);
}
assert(tcl_thread);
W_COERCE( tcl_thread->fork() );
W_COERCE( tcl_thread->join() );
delete tcl_thread;
}
}
// Shutdown TCL and have it deallocate resources still held!
Tcl_Finalize();
U.stop(1); // 1 iteration
if(print_stats)
{
cout << "Thread stats" <<endl;
sthread_t::dump_stats(cout);
cout << endl;
cout << "Unix stats for parent:" <<endl;
cout << U << endl << endl;
}
cout << flush;
done:
clean_up_shell();
fprintf(stderr, "%d tcl threads ran\n", num_tcl_threads_ttl);
return 0;
errordone:
clean_up_shell();
return 1;
}
int main(int argc, char *argv[])
{
struct iscsi_context *iscsi;
const char *url = NULL;
struct iscsi_url *iscsi_url = NULL;
int show_help = 0, show_usage = 0, debug = 0;
int c;
int ret = 0;
int swp = 0;
struct scsi_task *sense_task = NULL;
struct scsi_task *select_task = NULL;
struct scsi_mode_sense *ms;
struct scsi_mode_page *mp;
static struct option long_options[] = {
{"help", no_argument, NULL, 'h'},
{"usage", no_argument, NULL, 'u'},
{"debug", no_argument, NULL, 'd'},
{"initiator-name", required_argument, NULL, 'i'},
{"swp", required_argument, NULL, 's'},
{0, 0, 0, 0}
};
int option_index;
while ((c = getopt_long(argc, argv, "h?udi:s:", long_options,
&option_index)) != -1) {
switch (c) {
case 'h':
case '?':
show_help = 1;
break;
case 'u':
show_usage = 1;
break;
case 'd':
debug = 1;
break;
case 'i':
initiator = optarg;
break;
case 's':
if (!strcmp(optarg, "on") || !strcmp(optarg, "ON")) {
swp = 1;
}
if (!strcmp(optarg, "off") || !strcmp(optarg, "OFF")) {
swp = 2;
}
break;
default:
fprintf(stderr, "Unrecognized option '%c'\n\n", c);
print_help();
exit(0);
}
}
if (show_help != 0) {
print_help();
exit(0);
}
if (show_usage != 0) {
print_usage();
exit(0);
}
iscsi = iscsi_create_context(initiator);
if (iscsi == NULL) {
fprintf(stderr, "Failed to create context\n");
exit(10);
}
if (debug > 0) {
iscsi_set_log_level(iscsi, debug);
iscsi_set_log_fn(iscsi, iscsi_log_to_stderr);
}
if (argv[optind] != NULL) {
url = strdup(argv[optind]);
}
if (url == NULL) {
fprintf(stderr, "You must specify the URL\n");
print_usage();
ret = 10;
goto finished;
}
iscsi_url = iscsi_parse_full_url(iscsi, url);
free(discard_const(url));
if (iscsi_url == NULL) {
fprintf(stderr, "Failed to parse URL: %s\n",
iscsi_get_error(iscsi));
ret = 10;
goto finished;
}
iscsi_set_session_type(iscsi, ISCSI_SESSION_NORMAL);
iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE_CRC32C);
if (iscsi_full_connect_sync(iscsi, iscsi_url->portal, iscsi_url->lun) != 0) {
fprintf(stderr, "Login Failed. %s\n", iscsi_get_error(iscsi));
ret = 10;
goto finished;
}
sense_task = iscsi_modesense10_sync(iscsi, iscsi_url->lun,
0, 1, SCSI_MODESENSE_PC_CURRENT,
SCSI_MODEPAGE_CONTROL,
0, 255);
if (sense_task == NULL) {
printf("Failed to send MODE_SENSE10 command: %s\n",
iscsi_get_error(iscsi));
ret = 10;
goto finished;
}
if (sense_task->status != SCSI_STATUS_GOOD) {
printf("MODE_SENSE10 failed: %s\n",
iscsi_get_error(iscsi));
ret = 10;
goto finished;
}
ms = scsi_datain_unmarshall(sense_task);
if (ms == NULL) {
printf("failed to unmarshall mode sense datain blob\n");
ret = 10;
goto finished;
}
mp = scsi_modesense_get_page(ms, SCSI_MODEPAGE_CONTROL, 0);
if (mp == NULL) {
printf("failed to read control mode page\n");
ret = 10;
goto finished;
}
/* For MODE SELECT PS is reserved and hence must be cleared */
mp->ps = 0;
printf("SWP:%d\n", mp->control.swp);
switch (swp) {
case 1:
mp->control.swp = 1;
break;
case 2:
mp->control.swp = 0;
break;
default:
goto finished;
}
printf("Turning SWP %s\n", (swp == 1) ? "ON" : "OFF");
select_task = iscsi_modeselect10_sync(iscsi, iscsi_url->lun,
1, 0, mp);
if (select_task == NULL) {
printf("Failed to send MODE_SELECT10 command: %s\n",
iscsi_get_error(iscsi));
ret = 10;
goto finished;
}
if (select_task->status != SCSI_STATUS_GOOD) {
printf("MODE_SELECT10 failed: %s\n",
iscsi_get_error(iscsi));
ret = 10;
goto finished;
}
finished:
if (sense_task != NULL) {
scsi_free_scsi_task(sense_task);
}
if (select_task != NULL) {
scsi_free_scsi_task(select_task);
}
if (iscsi_url != NULL) {
iscsi_destroy_url(iscsi_url);
}
iscsi_logout_sync(iscsi);
iscsi_destroy_context(iscsi);
return ret;
}
/*==================================
* main -- Main routine of LifeLines
*================================*/
int
main (int argc, char **argv)
{
extern char *optarg;
extern int optind;
char * msg;
int c;
BOOLEAN ok=FALSE;
STRING dbrequested=NULL; /* database (path) requested */
STRING dbused=NULL; /* database (path) found */
BOOLEAN forceopen=FALSE, lockchange=FALSE;
char lockarg = 0; /* option passed for database lock */
INT alteration=0;
LIST exprogs=NULL;
TABLE exargs=NULL;
STRING progout=NULL;
BOOLEAN graphical=TRUE;
STRING configfile=0;
STRING crashlog=NULL;
int i=0;
/* initialize all the low-level library code */
init_stdlib();
#if HAVE_SETLOCALE
/* initialize locales */
setlocale(LC_ALL, "");
#endif /* HAVE_SETLOCALE */
#if ENABLE_NLS
/* setup gettext translation */
/* NB: later we may revise locale dir or codeset
based on user settings */
ll_bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
#endif
save_original_locales();
load_usage();
/* handle conventional arguments --version and --help */
/* needed for help2man to synthesize manual pages */
for (i=1; i<argc; ++i) {
if (!strcmp(argv[i], "--version")
|| !strcmp(argv[i], "-v")) {
print_version("llines");
return 0;
}
if (!strcmp(argv[i], "--help")
|| !strcmp(argv[i], "-h")
|| !strcmp(argv[i], "-?")) {
print_usage();
return 0;
}
}
/* Parse Command-Line Arguments */
opterr = 0; /* turn off getopt's error message */
while ((c = getopt(argc, argv, "adkrwil:fntc:Fu:x:o:zC:I:vh?")) != -1) {
switch (c) {
case 'c': /* adjust cache sizes */
while(optarg && *optarg) {
if(isasciiletter((uchar)*optarg) && isupper((uchar)*optarg))
*optarg = tolower((uchar)*optarg);
if(*optarg == 'i') {
INT icsz_indi=0;
sscanf(optarg+1, "%ld,%ld", &csz_indi, &icsz_indi);
}
else if(*optarg == 'f') {
INT icsz_fam=0;
sscanf(optarg+1, "%ld,%ld", &csz_fam, &icsz_fam);
}
else if(*optarg == 's') {
INT icsz_sour=0;
sscanf(optarg+1, "%ld,%ld", &csz_sour, &icsz_sour);
}
else if(*optarg == 'e') {
INT icsz_even=0;
sscanf(optarg+1, "%ld,%ld", &csz_even, &icsz_even);
}
else if((*optarg == 'o') || (*optarg == 'x')) {
INT icsz_othr=0;
sscanf(optarg+1, "%ld,%ld", &csz_othr, &icsz_othr);
}
optarg++;
while(*optarg && isdigit((uchar)*optarg)) optarg++;
if(*optarg == ',') optarg++;
while(*optarg && isdigit((uchar)*optarg)) optarg++;
}
break;
#ifdef FINNISH
# ifdef FINNISHOPTION
case 'F': /* Finnish sorting order [toggle] */
opt_finnish = !opt_finnish;
/*
TODO - need to mark Finnish databases, as
name records are not interoperable, because of
different soundex encoding
2001-02-17, Perry Rapp
TODO, 2002-11-07, Perry Rapp:
Need to see if we can fix database so locale sort doesn't affect btree
because it would be nicer if changing locale didn't hurt the btree !
Perhaps locale collates can only be used inside name records ? needs research
*/
break;
# endif
#endif
case 'a': /* debug allocation */
alloclog = TRUE;
break;
case 'd': /* debug = no signal catchers */
debugmode = TRUE;
break;
case 'k': /* don't show key values */
keyflag = FALSE;
break;
case 'r': /* request for read only access */
readonly = TRUE;
break;
case 'w': /* request for write access */
writeable = TRUE;
break;
case 'i': /* immutable access */
immutable = TRUE;
readonly = TRUE;
break;
case 'l': /* locking switch */
lockchange = TRUE;
lockarg = *optarg;
break;
case 'f': /* force database open in all cases */
forceopen = TRUE;
break;
case 'n': /* use non-traditional family rules */
traditional = FALSE;
break;
case 't': /* show lots of trace statements for debugging */
prog_trace = TRUE;
break;
case 'u': /* specify screen dimensions */
sscanf(optarg, "%ld,%ld", &winx, &winy);
break;
case 'x': /* execute program */
if (!exprogs) {
exprogs = create_list2(LISTDOFREE);
}
push_list(exprogs, strdup(optarg ? optarg : ""));
break;
case 'I': /* program arguments */
{
STRING optname=0, optval=0;
parse_arg(optarg, &optname, &optval);
if (optname && optval) {
if (!exargs) {
exargs = create_table_str();
}
insert_table_str(exargs, optname, optval);
}
strfree(&optname);
strfree(&optval);
}
break;
case 'o': /* output directory */
progout = optarg;
break;
case 'z': /* nongraphical box */
graphical = FALSE;
break;
case 'C': /* specify config file */
configfile = optarg;
break;
case 'v': /* show version */
showversion = TRUE;
goto usage;
break;
case 'h': /* show usage */
case '?': /* show usage */
showusage = TRUE;
showversion = TRUE;
goto usage;
break;
}
}
prompt_for_db:
/* catch any fault, so we can close database */
if (!debugmode)
set_signals();
else /* developer wants to drive without seatbelt! */
stdstring_hardfail();
set_displaykeys(keyflag);
/* initialize options & misc. stuff */
llgettext_set_default_localedir(LOCALEDIR);
if (!init_lifelines_global(configfile, &msg, &main_db_notify)) {
llwprintf("%s", msg);
goto finish;
}
/* setup crashlog in case init_screen fails (eg, bad menu shortcuts) */
crashlog = getlloptstr("CrashLog_llines", NULL);
if (!crashlog) { crashlog = "CrashLog_llines.log"; }
crash_setcrashlog(crashlog);
/* start (n)curses and create windows */
{
char errmsg[512];
if (!init_screen(errmsg, sizeof(errmsg)/sizeof(errmsg[0])))
{
endwin();
fprintf(stderr, errmsg);
goto finish;
}
set_screen_graphical(graphical);
}
init_interpreter(); /* give interpreter its turn at initialization */
/* Validate Command-Line Arguments */
if ((readonly || immutable) && writeable) {
llwprintf(_(qSnorwandro));
goto finish;
}
if (forceopen && lockchange) {
llwprintf(_(qSnofandl));
goto finish;
}
if (lockchange && lockarg != 'y' && lockarg != 'n') {
llwprintf(_(qSbdlkar));
goto finish;
}
if (forceopen)
alteration = 3;
else if (lockchange) {
if (lockarg == 'y')
alteration = 2;
else
alteration = 1;
}
c = argc - optind;
if (c > 1) {
showusage = TRUE;
goto usage;
}
/* Open database, prompting user if necessary */
if (1) {
STRING errmsg=0;
if (!alldone && c>0) {
dbrequested = strsave(argv[optind]);
} else {
strupdate(&dbrequested, "");
}
if (!select_database(dbrequested, alteration, &errmsg)) {
if (errmsg) {
llwprintf(errmsg);
}
alldone = 0;
goto finish;
}
}
/* Start Program */
if (!init_lifelines_postdb()) {
llwprintf(_(qSbaddb));
goto finish;
}
if (!int_codeset[0]) {
msg_info(_("Warning: database codeset unspecified"));
} else if (!transl_are_all_conversions_ok()) {
msg_info(_("Warning: not all conversions available"));
}
init_show_module();
init_browse_module();
if (exargs) {
set_cmd_options(exargs);
release_table(exargs);
exargs = 0;
}
if (exprogs) {
BOOLEAN picklist = FALSE;
BOOLEAN timing = FALSE;
interp_main(exprogs, progout, picklist, timing);
destroy_list(exprogs);
} else {
alldone = 0;
while (!alldone)
main_menu();
}
term_show_module();
term_browse_module();
ok=TRUE;
finish:
/* we free this not because we care so much about these tiny amounts
of memory, but to ensure we have the memory management right */
/* strfree frees memory & nulls pointer */
strfree(&dbused);
strfree(&dbrequested);
strfree(&readpath_file);
shutdown_interpreter();
close_lifelines();
shutdown_ui(!ok);
if (alldone == 2)
goto prompt_for_db; /* changing databases */
termlocale();
usage:
/* Display Version and/or Command-Line Usage Help */
if (showversion) { print_version("llines"); }
if (showusage) puts(usage_summary);
/* Exit */
return !ok;
}
int main(int argc, char *argv[]) {
int nb_platform_attr = DEFAULT_ISSUER_ATTRIBUTES;
int nb_issuer_attr = DEFAULT_RECEIVER_ATTRIBUTES;
char *filename = DEFAULT_FILENAME;
char *issuer = DEFAULT_ISSUER;
int i;
char *param;
TSS_HCONTEXT hContext;
TSS_DAA_KEY_PAIR *key_pair;
TSS_DAA_PK_PROOF *public_keyproof;
TSS_RESULT result;
TSS_HDAA hDAA;
TSS_DAA_PK_PROOF_internal *public_keyproof_internal;
TSS_DAA_PK_internal *pk;
TSS_DAA_PRIVATE_KEY *private_key;
DAA_PRIVATE_KEY_internal *private_key_internal;
KEY_PAIR_WITH_PROOF_internal *key_pair_with_proof;
printf("Issuer Setup (%s:%s,%s)\n", argv[0], __DATE__, __TIME__);
i = 1;
while( i < argc) {
param = argv[ i];
if ( strcmp( param, "-if") == 0 || strcmp( param, "--issuer_file")) {
i++;
if( i == argc) return print_usage( argv[0]);
filename = argv[i];
} else if( strcmp( param, "-npa") == 0 || strcmp( param, "--nb_platform_attr")) {
i++;
if( i == argc) return print_usage( argv[0]);
nb_platform_attr = atoi( argv[i]);
} else if( strcmp( param, "-nia") == 0 || strcmp( param, "--nb_issuer_attr")) {
i++;
if( i == argc) return print_usage( argv[0]);
nb_issuer_attr = atoi(argv[i]);
} else if( strcmp( param, "-i") == 0 || strcmp( param, "--issuer")) {
i++;
if( i == argc) return print_usage( argv[0]);
issuer = argv[i];
} else {
fprintf(stderr, "%s:unrecognized option `%s'\n", argv[0], param);
return print_usage( argv[0]);
}
i++;
}
bi_init( NULL);
// Create Context
printf("Create Context\n");
result = Tspi_Context_Create( &hContext );
if ( result != TSS_SUCCESS )
{
fprintf( stderr, "Tspi_Context_Create %d\n", result );
exit( result );
}
// Connect to Context
printf("Connect to the context\n");
result = Tspi_Context_Connect( hContext, NULL );
if ( result != TSS_SUCCESS )
{
fprintf( stderr, "Tspi_Context_Connect error:%d\n", result );
Tspi_Context_FreeMemory( hContext, NULL );
Tspi_Context_Close( hContext );
exit( result );
}
//Create Object
result = obj_daa_add( hContext, &hDAA);
if (result != TSS_SUCCESS) {
goto close;
}
result = Tspi_DAA_IssueSetup(
hDAA, // in
strlen( issuer), // in
(BYTE *)issuer, // in
nb_platform_attr, // in
nb_issuer_attr, // in
(TSS_HKEY *)&key_pair, // out
&public_keyproof); // out
if( result != TSS_SUCCESS) goto close;
// TSS_DAA_KEY_PAIR_internal *key_pair_internal = DAA_KEY_PAIR_2_internal( key_pair);
public_keyproof_internal = e_2_i_TSS_DAA_PK_PROOF( public_keyproof);
pk = e_2_i_TSS_DAA_PK( key_pair->public_key);
private_key = key_pair->private_key;
private_key_internal = e_2_i_TSS_DAA_PRIVATE_KEY( private_key);
key_pair_with_proof =
(KEY_PAIR_WITH_PROOF_internal *)malloc( sizeof(KEY_PAIR_WITH_PROOF_internal));
if( key_pair_with_proof == NULL) {
fprintf("malloc of %d bytes failed", sizeof(KEY_PAIR_WITH_PROOF_internal));
goto close;
}
key_pair_with_proof->pk = pk;
key_pair_with_proof->private_key = private_key_internal;
key_pair_with_proof->proof = public_keyproof_internal;
printf("Saving key pair with proof -> \'%s\'", filename);
FILE *file = fopen( filename, "w");
if( file == NULL) {
fprintf( stderr, "%s: Error when saving \'%s\': %s\n",
argv[0],
filename,
strerror( errno));
return -1;
}
if( save_KEY_PAIR_WITH_PROOF( file, key_pair_with_proof) != 0) {
fprintf( stderr, "%s: Error when saving \'%s\': %s\n",
argv[0],
filename,
strerror( errno));
return -1;
}
fclose( file);
printf("\nDone.\n");
close:
obj_daa_remove( hDAA, hContext);
printf("Closing the context\n");
Tspi_Context_FreeMemory( hContext, NULL );
Tspi_Context_Close( hContext );
bi_release();
printf("Result: %d", result);
return result;
}
int
cmd_print(int argc, char *argv[])
{
struct smb_ctx sctx, *ctx = &sctx;
smbfh fh;
off_t offset;
char buf[8192];
char *filename;
char fnamebuf[256];
int error, opt, i, file, count;
if (argc < 2)
view_usage();
if (smb_ctx_init(ctx, argc, argv, SMBL_SHARE, SMBL_SHARE, SMB_ST_PRINTER) != 0)
exit(1);
if (smb_ctx_readrc(ctx) != 0)
exit(1);
if (smb_rc)
rc_close(smb_rc);
while ((opt = getopt(argc, argv, STDPARAM_OPT)) != EOF) {
switch(opt){
case STDPARAM_ARGS:
error = smb_ctx_opt(ctx, opt, optarg);
if (error)
exit(1);
break;
default:
view_usage();
/*NOTREACHED*/
}
}
if (optind + 1 >= argc)
print_usage();
filename = argv[optind + 1];
if (strcmp(filename, "-") == 0) {
file = 0; /* stdin */
filename = "stdin";
} else {
file = open(filename, O_RDONLY, 0);
if (file < 0) {
smb_error("could not open file %s\n", errno, filename);
exit(1);
}
}
if (smb_ctx_resolve(ctx) != 0)
exit(1);
error = smb_ctx_lookup(ctx, SMBL_SHARE, SMBLK_CREATE);
if (error) {
smb_error("could not login to server %s", error, ctx->ct_ssn.ioc_srvname);
exit(1);
}
snprintf(fnamebuf, sizeof(fnamebuf), "%s_%s_%s", ctx->ct_ssn.ioc_user,
ctx->ct_ssn.ioc_srvname, filename);
error = smb_smb_open_print_file(ctx, 0, 1, fnamebuf, &fh);
if (error) {
smb_error("could not open print job", error);
exit(1);
}
offset = 0;
error = 0;
for(;;) {
count = read(file, buf, sizeof(buf));
if (count == 0)
break;
if (count < 0) {
error = errno;
smb_error("error reading input file\n", error);
break;
}
i = smb_write(ctx, fh, offset, count, buf);
if (i < 0) {
error = errno;
smb_error("error writing spool file\n", error);
break;
}
if (i != count) {
smb_error("incomplete write to spool file\n", 0);
error = EIO;
break;
}
offset += count;
}
close(file);
error = smb_smb_close_print_file(ctx, fh);
if (error)
smb_error("an error while closing spool file\n", error);
return error ? 1 : 0;
}
int main_dbghelper(int argc, char *argv[])
{
main_argc = argc;
main_argv = argv;
#ifdef DEDI
if(argc <= 1)
return print_usage(argv[0]);
#else
if(argc <= 1)
{
//print_usage(argv[0]);
net_port = 0;
mod_basedir = "pkg/iceball/halp";
printf("Starting server on port %i, mod \"%s\"\n", net_port, mod_basedir);
main_largstart = 4;
boot_mode = 3;
} else
#endif
#ifndef DEDI
if((!strcmp(argv[1], "-h")) || (!strcmp(argv[1], "/?")) || (!strcmp(argv[1], "-?")) || (!strcmp(argv[1], "--help"))) {
return print_usage(argv[0]);
} else if(!strcmp(argv[1], "-c")) {
if(argc <= 3)
return print_usage(argv[0]);
net_addr = argv[2];
net_port = atoi(argv[3]);
printf("Connecting to \"%s\" port %i (ENet mode)\n", net_addr, net_port);
mod_basedir = NULL;
main_largstart = 4;
boot_mode = 1 | 16;
} else if(!strcmp(argv[1], "-C")) {
if(argc <= 3)
return print_usage(argv[0]);
net_addr = argv[2];
net_port = atoi(argv[3]);
printf("Connecting to \"%s\" port %i (TCP mode)\n", net_addr, net_port);
mod_basedir = NULL;
main_largstart = 4;
boot_mode = 1;
//return 101;
} else if(!strcmp(argv[1], "-s")) {
if(argc <= 3)
return print_usage(argv[0]);
net_port = atoi(argv[2]);
mod_basedir = argv[3];
printf("Starting server on port %i, mod \"%s\" (local mode client)\n", net_port, mod_basedir);
main_largstart = 4;
boot_mode = 3;
} else
#endif
if(!strcmp(argv[1], "-d")) {
if(argc <= 3)
return print_usage(argv[0]);
net_port = atoi(argv[2]);
mod_basedir = argv[3];
printf("Starting headless/dedicated server on port %i, mod \"%s\"\n", net_port, mod_basedir);
main_largstart = 4;
boot_mode = 2;
//return 101;
} else {
return print_usage(argv[0]);
}
if(boot_mode & 2)
{
if(memcmp(mod_basedir,"pkg/",4))
{
fprintf(stderr, "ERROR: package base dir must start with \"pkg/\"!\n");
return 109;
}
if(strlen(mod_basedir) < 5)
{
fprintf(stderr, "ERROR: package base dir can't actually be \"pkg/\"!\n");
return 109;
}
}
#ifndef DEDI
if((!(boot_mode & 1)) || !platform_init()) {
#endif
if(!net_init()) {
if(!icelua_init()) {
if((!(boot_mode & 2)) || !net_bind()) {
#ifndef DEDI
if((!(boot_mode & 1)) || !net_connect()) {
if((!(boot_mode & 1)) || !video_init()) {
if((!(boot_mode & 1)) || !wav_init()) {
if((!(boot_mode & 1)) || !render_init(screen->w, screen->h)) {
#endif
run_game();
#ifndef DEDI
if(boot_mode & 1) render_deinit();
} if(boot_mode & 1) wav_deinit();
} if(boot_mode & 1) video_deinit();
} if(boot_mode & 1) net_disconnect();
#endif
} if(boot_mode & 2) net_unbind();
} icelua_deinit();
} net_deinit();
#ifndef DEDI
} if(boot_mode & 1) platform_deinit();
}
#endif
return 0;
}
static int
parse_args (int argc, ACE_TCHAR *argv[])
{
if (argc == 1) // no arguments , so one button test
{
both = 1; // client and server simultaneosly
duplex = 1; // full duplex is on
host = ACE_TEXT ("localhost"); // server to connect
port = ACE_DEFAULT_SERVER_PORT; // port to connect/listen
threads = 3; // size of Proactor thread pool
senders = 20; // number of senders
loglevel = 1; // log level : 0 full/ 1 only errors
seconds = 20; // time to run in seconds
#if defined(SOMAXCONN) // The test is invalid if senders > SOMAXCONN
if(SOMAXCONN < senders)
senders = SOMAXCONN;
#endif
return 0;
}
ACE_Get_Opt get_opt (argc, argv, ACE_TEXT ("i:n:p:d:h:s:v:ub"));
int c;
while ((c = get_opt ()) != EOF)
{
switch (c)
{
case 'i': // time to run
seconds = ACE_OS::atoi (get_opt.opt_arg());
if (seconds < MIN_TIME)
seconds = MIN_TIME;
if (seconds > MAX_TIME)
seconds = MAX_TIME;
break;
case 'b': // both client and server
both = 1;
break;
case 'v': // log level
loglevel = ACE_OS::atoi (get_opt.opt_arg());
break;
case 'd': // duplex
duplex = ACE_OS::atoi (get_opt.opt_arg());
break;
case 'h': // host for sender
host = get_opt.opt_arg();
break;
case 'p': // port number
port = ACE_OS::atoi (get_opt.opt_arg());
break;
case 'n': // thread pool size
threads = ACE_OS::atoi (get_opt.opt_arg());
break;
case 's': // number of senders
senders = ACE_OS::atoi (get_opt.opt_arg());
if (size_t (senders) > MAX_SENDERS)
senders = MAX_SENDERS;
break;
case 'u':
default:
return print_usage (argc,argv);
} // switch
} // while
return 0;
}
void listen_loop(int do_init) {
struct client_struct* new_client;
struct np_sock npsock = {.count = 0};
pthread_t client_tid;
int ret;
#ifdef NP_SSH
ssh_bind sshbind = NULL;
#endif
#ifdef NP_TLS
SSL_CTX* tlsctx = NULL;
#endif
/* Init */
if (do_init) {
#ifdef NP_SSH
np_ssh_init();
#endif
#ifdef NP_TLS
np_tls_init();
#endif
}
/* Main accept loop */
do {
new_client = NULL;
/* Binds change check */
if (netopeer_options.binds_change_flag) {
/* BINDS LOCK */
pthread_mutex_lock(&netopeer_options.binds_lock);
sock_cleanup(&npsock);
sock_listen(netopeer_options.binds, &npsock);
netopeer_options.binds_change_flag = 0;
/* BINDS UNLOCK */
pthread_mutex_unlock(&netopeer_options.binds_lock);
if (npsock.count == 0) {
nc_verb_warning("Server is not listening on any address!");
}
}
#ifdef NP_SSH
sshbind = np_ssh_server_id_check(sshbind);
#endif
#ifdef NP_TLS
tlsctx = np_tls_server_id_check(tlsctx);
#endif
/* Callhome client check */
if (callhome_client != NULL) {
/* CALLHOME LOCK */
pthread_mutex_lock(&callhome_lock);
new_client = callhome_client;
callhome_client = NULL;
/* CALLHOME UNLOCK */
pthread_mutex_unlock(&callhome_lock);
}
/* Listen client check */
if (new_client == NULL) {
new_client = sock_accept(&npsock);
}
/* New client full structure creation */
if (new_client != NULL) {
/* Maximum number of sessions check */
if (netopeer_options.max_sessions > 0) {
ret = 0;
#ifdef NP_SSH
ret += np_ssh_session_count();
#endif
#ifdef NP_TLS
ret += np_tls_session_count();
#endif
if (ret >= netopeer_options.max_sessions) {
nc_verb_error("Maximum number of sessions reached, droppping the new client.");
new_client->to_free = 1;
switch (new_client->transport) {
#ifdef NP_SSH
case NC_TRANSPORT_SSH:
client_free_ssh((struct client_struct_ssh*)new_client);
break;
#endif
#ifdef NP_TLS
case NC_TRANSPORT_TLS:
client_free_tls((struct client_struct_tls*)new_client);
break;
#endif
default:
free(new_client);
nc_verb_error("%s: internal error (%s:%d)", __func__, __FILE__, __LINE__);
}
/* sleep to prevent clients from immediate connection retry */
usleep(netopeer_options.response_time*1000);
continue;
}
}
switch (new_client->transport) {
#ifdef NP_SSH
case NC_TRANSPORT_SSH:
ret = np_ssh_create_client((struct client_struct_ssh*)new_client, sshbind);
if (ret != 0) {
new_client->to_free = 1;
client_free_ssh((struct client_struct_ssh*)new_client);
}
break;
#endif
#ifdef NP_TLS
case NC_TRANSPORT_TLS:
ret = np_tls_create_client((struct client_struct_tls*)new_client, tlsctx);
if (ret != 0) {
new_client->to_free = 1;
client_free_tls((struct client_struct_tls*)new_client);
}
break;
#endif
default:
nc_verb_error("Client with an unknown transport protocol, dropping it.");
free(new_client);
ret = 1;
}
/* client is not valid, some error occured */
if (ret != 0) {
continue;
}
/* add the client into the global clients structure */
/* GLOBAL WRITE LOCK */
pthread_rwlock_wrlock(&netopeer_state.global_lock);
client_append(&netopeer_state.clients, new_client);
/* GLOBAL WRITE UNLOCK */
pthread_rwlock_unlock(&netopeer_state.global_lock);
/* start the client thread */
if ((ret = pthread_create((pthread_t*)&new_client->tid, NULL, client_main_thread, (void*)new_client)) != 0) {
nc_verb_error("%s: failed to create a thread (%s)", __func__, strerror(ret));
np_client_detach(&netopeer_state.clients, new_client);
new_client->tid = 0;
new_client->to_free = 1;
switch (new_client->transport) {
#ifdef NP_SSH
case NC_TRANSPORT_SSH:
client_free_ssh((struct client_struct_ssh*)new_client);
break;
#endif
#ifdef NP_TLS
case NC_TRANSPORT_TLS:
client_free_tls((struct client_struct_tls*)new_client);
break;
#endif
default:
free(new_client);
break;
}
continue;
}
}
} while (!quit && !restart_soft);
/* Cleanup */
sock_cleanup(&npsock);
#ifdef NP_SSH
ssh_bind_free(sshbind);
#endif
#ifdef NP_TLS
SSL_CTX_free(tlsctx);
#endif
if (!restart_soft) {
/* wait for all the clients to exit nicely themselves */
while (1) {
/* GLOBAL READ LOCK */
pthread_rwlock_rdlock(&netopeer_state.global_lock);
if (netopeer_state.clients == NULL) {
/* GLOBAL READ UNLOCK */
pthread_rwlock_unlock(&netopeer_state.global_lock);
break;
}
client_tid = netopeer_state.clients->tid;
/* GLOBAL READ UNLOCK */
pthread_rwlock_unlock(&netopeer_state.global_lock);
ret = pthread_join(client_tid, NULL);
if (ret != 0 && errno != EINTR) {
nc_verb_error("Failed to join client thread (%s).", strerror(errno));
}
}
#ifdef NP_SSH
np_ssh_cleanup();
#endif
#ifdef NP_TLS
np_tls_cleanup();
#endif
}
}
int main(int argc, char** argv) {
struct sigaction action;
sigset_t block_mask;
char *aux_string = NULL, path[PATH_MAX+1];
int next_option;
int daemonize = 0, len;
int listen_init = 1;
struct np_module* netopeer_module = NULL, *server_module = NULL;
/* initialize message system and set verbose and debug variables */
if ((aux_string = getenv(ENVIRONMENT_VERBOSE)) == NULL) {
netopeer_options.verbose = NC_VERB_ERROR;
} else {
netopeer_options.verbose = atoi(aux_string);
}
aux_string = NULL; /* for sure to avoid unwanted changes in environment */
/* parse given options */
while ((next_option = getopt(argc, argv, OPTSTRING)) != -1) {
switch (next_option) {
case 'd':
daemonize = 1;
break;
case 'h':
print_usage(argv[0]);
break;
case 'v':
netopeer_options.verbose = atoi(optarg);
break;
case 'V':
print_version(argv[0]);
break;
default:
print_usage(argv[0]);
break;
}
}
/* set signal handler */
sigfillset (&block_mask);
action.sa_handler = signal_handler;
action.sa_mask = block_mask;
action.sa_flags = 0;
sigaction(SIGINT, &action, NULL);
sigaction(SIGQUIT, &action, NULL);
sigaction(SIGABRT, &action, NULL);
sigaction(SIGTERM, &action, NULL);
sigaction(SIGHUP, &action, NULL);
nc_callback_print(clb_print);
/* normalize value if not from the enum */
if (netopeer_options.verbose > NC_VERB_DEBUG) {
netopeer_options.verbose = NC_VERB_DEBUG;
}
nc_verbosity(netopeer_options.verbose);
/* go to the background as a daemon */
if (daemonize == 1) {
if (daemon(0, 0) != 0) {
nc_verb_error("Going to background failed (%s)", strerror(errno));
return EXIT_FAILURE;
}
openlog("netopeer-server", LOG_PID, LOG_DAEMON);
} else {
openlog("netopeer-server", LOG_PID|LOG_PERROR, LOG_DAEMON);
}
/* make sure we were executed by root */
if (geteuid() != 0) {
nc_verb_error("Failed to start, must have root privileges.");
return EXIT_FAILURE;
}
/*
* this initialize the library and check potential ABI mismatches
* between the version it was compiled for and the actual shared
* library used.
*/
LIBXML_TEST_VERSION
/* initialize library including internal datastores and maybee something more */
if (nc_init(NC_INIT_ALL | NC_INIT_MULTILAYER) < 0) {
nc_verb_error("Library initialization failed.");
return EXIT_FAILURE;
}
server_start = 1;
restart:
/* start NETCONF server module */
if ((server_module = calloc(1, sizeof(struct np_module))) == NULL) {
nc_verb_error("Creating necessary NETCONF server plugin failed!");
return EXIT_FAILURE;
}
server_module->name = strdup(NCSERVER_MODULE_NAME);
if (module_enable(server_module, 0)) {
nc_verb_error("Starting necessary NETCONF server plugin failed!");
free(server_module->name);
free(server_module);
return EXIT_FAILURE;
}
/* start netopeer device module - it will start all modules that are
* in its configuration and in server configuration */
if ((netopeer_module = calloc(1, sizeof(struct np_module))) == NULL) {
nc_verb_error("Creating necessary Netopeer plugin failed!");
module_disable(server_module, 1);
return EXIT_FAILURE;
}
netopeer_module->name = strdup(NETOPEER_MODULE_NAME);
if (module_enable(netopeer_module, 0)) {
nc_verb_error("Starting necessary Netopeer plugin failed!");
module_disable(server_module, 1);
free(netopeer_module->name);
free(netopeer_module);
return EXIT_FAILURE;
}
server_start = 0;
nc_verb_verbose("Netopeer server successfully initialized.");
listen_loop(listen_init);
/* unload Netopeer module -> unload all modules */
module_disable(server_module, 1);
module_disable(netopeer_module, 1);
/* main cleanup */
if (!restart_soft) {
/* close libnetconf only when shutting down or hard restarting the server */
nc_close();
}
if (restart_soft) {
nc_verb_verbose("Server is going to soft restart.");
restart_soft = 0;
listen_init = 0;
goto restart;
} else if (restart_hard) {
nc_verb_verbose("Server is going to hard restart.");
len = readlink("/proc/self/exe", path, PATH_MAX);
if (len > 0) {
path[len] = 0;
xmlCleanupParser();
execv(path, argv);
}
nc_verb_error("Failed to get the path to self.");
xmlCleanupParser();
return EXIT_FAILURE;
}
/*
*Free the global variables that may
*have been allocated by the parser.
*/
xmlCleanupParser();
return EXIT_SUCCESS;
}
int main ( int argc , char ** argv )
{
if( argc != 2 )
{
print_usage();
return 0;
}
fprintf( stderr , "This program wil format the %s file, continue? y/n : ", argv[1]);
char in;
in = getchar();
if( 'y' != in && 'Y' != in )
{
fprintf( stderr , "format cancelled!\n");
return 0;
}
int fd;
if( (fd = open( argv[1] , O_WRONLY )) < 0 )
{
fprintf( stderr , "Error on open():%s\n", strerror( errno ) );
return 1;
}
struct sb tSuperBlock;
//good habit is to memset
memset( &tSuperBlock , 0 , sizeof( struct sb ) );
tSuperBlock.fs_size = (long)get_file_size( argv[1] ) / BLOCK_SIZE;
tSuperBlock.us_size = 1 + SUPER_BLOCK_N + BITMAP_BLOCK_N ; //because the superblock and bitmapblock and root alread occupy some blocks
tSuperBlock.bk_size = BLOCK_SIZE;
tSuperBlock.first_blk = BLOCK_SIZE * ( SUPER_BLOCK_N + BITMAP_BLOCK_N );
tSuperBlock.bitmap = BITMAP_BLOCK_N;
printf("Disk image file:%s\n" , argv[1] );
printf("Ready to Write :\n");
printf("fs_size(in blocks) : %ld\n", tSuperBlock.fs_size );
printf("us_size(in blocks) : %ld\n", tSuperBlock.us_size );
printf("bk_size(in bytes ) : %ld\n", tSuperBlock.bk_size );
printf("first_blk(location) : %ld\n", tSuperBlock.first_blk );
printf("bitmap(in blocks) : %ld\n\n", tSuperBlock.bitmap );
//diskimage too small no way to do
if( tSuperBlock.fs_size < (SUPER_BLOCK_N + BITMAP_BLOCK_N + 1 ) )
{
fprintf( stderr , "Diskimage file too small! Can't format, sorry!\n");
exit(1);
}
//write super block
lseek( fd , (off_t) 0 , SEEK_SET );
ssize_t wc;
struct u_fs_disk_block block;
memset( &block , 0 , sizeof( struct u_fs_disk_block ) );
memcpy( &block , &tSuperBlock , sizeof( struct sb ) );
wc = write( fd , (void *) &block , sizeof( struct u_fs_disk_block ));
if( wc != sizeof( struct u_fs_disk_block ))
{
fprintf( stderr , "Error on write():%s\n",strerror(errno));
exit(1); //it will help me to close file ?
}
//super block done
//write bitmap block
lseek( fd , (off_t) (SUPER_BLOCK_N * BLOCK_SIZE) , SEEK_SET );
char buffer[BLOCK_SIZE];
(void *) memset((void *) buffer , 0 , BLOCK_SIZE);
int count;
for( count=0; count < tSuperBlock.bitmap ; count++ )
{
wc = write( fd , (void *)buffer , BLOCK_SIZE);
if( wc != BLOCK_SIZE )
{
fprintf( stderr , "Error on write():%s\n",strerror(errno));
exit(1); //it will help me to close file ?
}
}
//the first block is occupy by the root dir
lseek( fd , SUPER_BLOCK_N * BLOCK_SIZE , SEEK_SET );
unsigned char oc = 0x80;
write( fd , (void *)&oc , sizeof( oc ));
//bitmap block done
//write data block. no much to do. clear the root block
struct u_fs_disk_block root;
memset( &root , 0 , sizeof( root ));
root.size=0;
root.nNextBlock=0;
lseek( fd , tSuperBlock.first_blk , SEEK_SET );
write( fd , (void*)&root , sizeof( root));
(void) close(fd);
//read and comfirm
if( (fd = open( argv[1] , O_RDONLY )) < 0 )
{
fprintf( stderr , "Error on open():%s\n", strerror( errno ) );
return 1;
}
struct sb uSuperBlock;
struct u_fs_disk_block ablock;
read( fd , (void *)&ablock , sizeof( struct u_fs_disk_block ) );
memcpy( &uSuperBlock , &ablock , sizeof( struct sb ) );
printf("Disk image file:%s\n" , argv[1] );
printf("After Writing :\n");
printf("fs_size(in blocks) : %ld\n", tSuperBlock.fs_size );
printf("us_size(in blocks) : %ld\n", tSuperBlock.us_size );
printf("bk_size(in bytes ) : %ld\n", tSuperBlock.bk_size );
printf("first_blk(location) : %ld\n", tSuperBlock.first_blk );
printf("bitmap(in blocks) : %ld\n\n", tSuperBlock.bitmap );
if( 0 == memcmp( (void*)&tSuperBlock , (void*)&uSuperBlock , sizeof( struct sb) ))
{
printf("Check....OK. Format Complete!\n");
}
else
{
fprintf( stderr , "Check....FAILED. Format Failed!\n");
}
( void ) close( fd );
return 0;
}
