int main(int argc, char **argv)
{
struct timeval tv;
// Parse command line options.
Options *options = parseopts(argc, argv);
// Start time.
gettimeofday(&tv, NULL);
int64_t t0 = (tv.tv_sec*1000) + (tv.tv_usec/1000);
// Benchmark computation of a DAG.
// benchmark_dag(options);
benchmark_count_with_qip(options);
// End time.
gettimeofday(&tv, NULL);
int64_t t1 = (tv.tv_sec*1000) + (tv.tv_usec/1000);
// Show wall clock time.
printf("Elapsed Time: %.3f seconds\n", ((float)(t1-t0))/1000);
// Clean up.
Options_free(options);
return 0;
}
int
main(int argc, char *argv[]) {
gchar **uris = NULL;
xdgHandle xdg;
/* clean up any zombies */
sigchld(0);
gtk_init(&argc, &argv);
if (!g_thread_supported())
g_thread_init(NULL);
/* parse command line opts and get uris to load */
uris = parseopts(argc, argv);
/* get XDG basedir data */
xdgInitHandle(&xdg);
init_directories(&xdg);
init_lua(uris, &xdg);
/* we are finished with this */
xdgWipeHandle(&xdg);
gtk_main();
return EXIT_SUCCESS;
}
void qObjProto::EvalQMail(qCtx *ctx, qStr *out, qArgAry *args)
{
if (args->Count() >= 1) {
qMailOpts qmop;
int argc = args->Count();
const char **argv = *args;
try {
parseopts(&qmop, argc, const_cast<char **&>(argv));
} catch (CEx ex) {
ctx->Throw(out, ex.id+600, ex.msg);
}
if (qsUnreg) {
qmop.unreg = true;
}
try {
int errVal = qsmtp(&qmop);
if (errVal)
ctx->ThrowF(out, errVal+600, "Mail error #%d.", errVal);
} catch (CEx ex) {
ctx->Throw(out, ex.id+600, ex.msg);
}
}
return;
}
int
main(int argc, char *argv[]) {
gchar **uris = NULL;
/* clean up any zombies */
struct sigaction sigact;
sigact.sa_handler=sigchld;
sigemptyset (&sigact.sa_mask);
sigact.sa_flags = SA_NOCLDSTOP;
if (sigaction(SIGCHLD, &sigact, NULL))
fatal("Can't install SIGCHLD handler");
/* parse command line opts and get uris to load */
uris = parseopts(argc, argv);
gtk_init(&argc, &argv);
if (!g_thread_supported())
g_thread_init(NULL);
init_directories();
init_lua(uris);
/* parse and run configuration file */
if(!luaH_parserc(globalconf.confpath, TRUE))
fatal("couldn't find rc file");
if (!globalconf.windows->len)
fatal("no windows spawned by rc file, exiting");
gtk_main();
return EXIT_SUCCESS;
}
gint
main(gint argc, gchar *argv[]) {
gboolean *nonblock = NULL;
gchar **uris = NULL;
pid_t pid, sid;
globalconf.starttime = l_time();
/* clean up any zombies */
struct sigaction sigact;
sigact.sa_handler=sigchld;
sigemptyset (&sigact.sa_mask);
sigact.sa_flags = SA_NOCLDSTOP;
if (sigaction(SIGCHLD, &sigact, NULL))
fatal("Can't install SIGCHLD handler");
/* set numeric locale to C (required for compatibility with
LuaJIT and luakit scripts) */
gtk_set_locale();
gtk_disable_setlocale();
setlocale(LC_NUMERIC, "C");
/* parse command line opts and get uris to load */
uris = parseopts(&argc, argv, &nonblock);
/* if non block mode - respawn, detach and continue in child */
if (nonblock) {
pid = fork();
if (pid < 0) {
fatal("Cannot fork: %d", errno);
} else if (pid > 0) {
exit(EXIT_SUCCESS);
}
sid = setsid();
if (sid < 0) {
fatal("New SID creation failure: %d", errno);
}
}
gtk_init(&argc, &argv);
init_directories();
init_lua(uris);
/* hide command line parameters so process lists don't leak (possibly
confidential) URLs */
for (gint i = 1; i < argc; i++)
memset(argv[i], 0, strlen(argv[i]));
/* parse and run configuration file */
if(!luaH_parserc(globalconf.confpath, TRUE))
fatal("couldn't find rc file");
if (!globalconf.windows->len)
fatal("no windows spawned by rc file, exiting");
gtk_main();
return EXIT_SUCCESS;
}
int main(int argc, char * const argv[])
{
parseopts(argc, argv);
printdesc("Regression testsuite palette handling\n\n");
testcase1("Draw green box");
printsummary();
return 0;
}
int main(int argc, char * const argv[])
{
parseopts(argc, argv);
printdesc("Regression testsuite for ggLock(3) & friends.\n\n");
testcase1("Checks behaviour of locking functions, whether they match documentation.");
printsummary();
return 0;
}
int main(int argc, char **argv) {
if (parseopts(argc, argv) != 0) {
fprintf(stderr, "Try the -h option for usage help.\n");
return 1;
}
if (MergeImages() != 0) {
return 1;
}
return 0;
}
int main(int argc, char * const argv[])
{
parseopts(argc, argv);
printdesc("Regression testsuite for libgg init/exit handling\n\n");
testcase1("Check that ggInit() behaves as documented.");
testcase2("Check that ggExit() behaves as documented.");
printsummary();
return 0;
}
int main(int argc, char **argv)
{
char *res;
char buffer[1024];
info.base = 0;
parseopts(argc, argv);
if (!(res = num2bin(info.num, buffer, sizeof(buffer))))
_throwerror(1, "%s is a too large number.", argv[1]);
printf("[dec]\t%llu\t=\t[hex]\t%llx\t[oct]\t%llo\t[bin]\t%s\n", info.num, info.num, info.num, res);
return 0;
}
int
main(int argc, char *argv[]) {
gboolean *nonblock = NULL;
gchar **uris = NULL;
pid_t pid, sid;
/* clean up any zombies */
struct sigaction sigact;
sigact.sa_handler=sigchld;
sigemptyset (&sigact.sa_mask);
sigact.sa_flags = SA_NOCLDSTOP;
if (sigaction(SIGCHLD, &sigact, NULL))
fatal("Can't install SIGCHLD handler");
/* parse command line opts and get uris to load */
uris = parseopts(argc, argv, &nonblock);
/* if non block mode - respawn, detach and continue in child */
if (nonblock) {
pid = fork();
if (pid < 0) {
fatal("Cannot fork: %d", errno);
} else if (pid > 0) {
exit(EXIT_SUCCESS);
}
sid = setsid();
if (sid < 0) {
fatal("New SID creation failure: %d", errno);
}
}
gtk_init(&argc, &argv);
if (!g_thread_supported())
g_thread_init(NULL);
init_directories();
init_lua(uris);
/* parse and run configuration file */
if(!luaH_parserc(globalconf.confpath, TRUE))
fatal("couldn't find rc file");
if (!globalconf.windows->len)
fatal("no windows spawned by rc file, exiting");
gtk_main();
return EXIT_SUCCESS;
}
int main(int argc, char * const argv[])
{
int rc;
parseopts(argc, argv);
printdesc("Regression testsuite for display-x(7).\n\n");
rc = ggiInit();
if (rc < 0) ggPanic("Couldn't initialize libggi");
testcase1("See, if mansync actually runs in SYNC mode - sets up the mode the same way as XGGI does");
printsummary();
return 0;
}
int main(int argc, char** argv) {
setup_error_handling();
if (argc > 1) {
int* script_argc = (int*)malloc(sizeof(int));
char** script_and_args = parseopts(argc, argv, script_argc);
if (*(script_argc)) {
return script(*(script_argc), script_and_args);
}
return 0;
} else {
print_version_info(argv[0]);
return prompt();
}
}
int main(int argc, char *argv[])
{
afskmodulator.next = &fskmodulator;
afskdemodulator.next = &fskdemodulator;
fskmodulator.next = &pammodulator;
fskdemodulator.next = &fskpspdemodulator;
fskpspdemodulator.next = &pamdemodulator;
pammodulator.next = &pskmodulator;
pamdemodulator.next = &pskdemodulator;
pskmodulator.next = &newqpskmodulator;
pskdemodulator.next = &newqpskdemodulator;
newqpskdemodulator.next = &p3ddemodulator;
ioinit_filein();
ioinit_soundcard();
ioinit_sim();
parseopts(argc, argv);
pkttransmitloop(&state);
exit(0);
}
int main(int argc, char * const argv[])
{
parseopts(argc, argv);
printdesc("Regression testsuite mode handling\n\n");
testcase1("Check that ggiCheckMode() doesn't return GGI_AUTO");
testcase2("Check that ggiSetMode() can actually set the mode that has been suggested by ggiCheckMode");
testcase3("Check setting a mode with a given number of frames");
testcase4("Check setting a mode by its physical size");
testcase5("Set up the mode in the ggiterm way");
testcase6("Check that re-setting of a different mode works [async mode]");
testcase7("Check that re-setting of a different mode works [sync mode]");
testcase8("Check checking then setting a mode with braindamaged visual size");
testcase9("Check modelist");
printsummary();
return 0;
}
static int
parseboot(char *arg, char **filename, int *howto)
{
char *opts = NULL;
*filename = 0;
*howto = 0;
/* if there were no arguments */
if (*arg == NULL)
return (1);
/* format is... */
/* [[xxNx:]filename] [-adqsv] */
/* check for just args */
if (arg[0] == '-') {
opts = arg;
} else {
/* there's a file name */
*filename = arg;
opts = gettrailer(arg);
if (*opts == NULL) {
opts = NULL;
} else if (*opts != '-') {
printf("invalid arguments\n");
bootcmd_help(NULL);
return (0);
}
}
/* at this point, we have dealt with filenames. */
/* now, deal with options */
if (opts) {
if (parseopts(opts, howto) == 0) {
return (0);
}
}
return (1);
}
int main(int argc, char *argv[])
{
parseopts(argc, argv);
printdesc("Regression testsuite for libgg's internal ggParseTarget() function.\n\n");
testcase1("Passes a string with whitespaces only. Expected to return \\0.");
testcase2("Passes a string with an too short target buffer. "
"This expects to fill up the buffer as much as possible, "
"but not completely - buffer overflow protection.");
testcase3("Passes a string with valid arguments.");
testcase4("Passes a string with syntax error: "
"A closing bracket doesn\'t match an opening bracket.");
testcase5("Passes a string with syntax error: "
"Number of opening and closing brackets matches, but wrong ordered.");
printsummary();
return 0;
}
int
main(int argc, char **argv) {
int rotval = 13;
const char *msg = NULL;
const char *rotmsg = NULL;
parseopts(argc, argv, &rotval);
msg = argvtostr(argc, argv);
if (msg == NULL) {
usage(argc, argv);
}
rotmsg = rot(rotval, msg);
if (rotmsg != NULL) {
printf("%s\n", rotmsg);
}
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
client_t client;
int cmd, err = 0;
cmd = parseopts(argc, argv, &client);
if (cmd < 0)
return 1;
/* call function for command */
switch (cmd) {
case 1:
err = do_bind(&client);
break;
case 2:
err = do_unbind(&client);
break;
case 3:
err = do_setcache(&client);
break;
}
client_shutdown(&client);
return err;
}
int main(int argc, char *argv[]) {
char shell[strlen(stub) + strlen(shellcode) + 1];
sprintf(shell, "%s%s", stub, shellcode);
parseopts(argc, argv);
int pid = atoi(argv[1]);
attach(pid);
struct user_regs_struct *tmp = inject(pid, shell);
struct sigaction hook_ret;
memset(&hook_ret, 0, sizeof(struct sigaction));
hook_ret.sa_handler = ret_handler;
sigaction(0xc, &hook_ret, 0);
cont(pid);
while(hit == 0) {}
set_regs(pid, tmp);
detach(pid);
return 0;
}
int main(int argc, char **argv)
{
struct user_opt opt;
struct crack_data cdata;
struct capture_data capdata;
struct wpa_eapol_key *eapkeypacket;
u8 eapolkey_nomic[99];
struct timeval start, end;
int ret;
char passphrase[MAXPASSLEN + 1];
printf("%s %s - WPA-PSK dictionary attack. <*****@*****.**>\n",
PROGNAME, VER);
memset(&opt, 0, sizeof(struct user_opt));
memset(&capdata, 0, sizeof(struct capture_data));
memset(&cdata, 0, sizeof(struct crack_data));
memset(&eapolkey_nomic, 0, sizeof(eapolkey_nomic));
/* Collect and test command-line arguments */
parseopts(&opt, argc, argv);
testopts(&opt);
printf("\n");
/* Populate capdata struct */
strncpy(capdata.pcapfilename, opt.pcapfile,
sizeof(capdata.pcapfilename));
if (openpcap(&capdata) != 0) {
printf("Unsupported or unrecognized pcap file.\n");
exit(-1);
}
/* populates global *packet */
while (getpacket(&capdata) > 0) {
if (opt.verbose > 2) {
lamont_hdump(packet, h->len);
}
/* test packet for data that we are looking for */
if (memcmp(&packet[capdata.l2type_offset], DOT1X_LLCTYPE, 2) ==
0 && (h->len >
capdata.l2type_offset + sizeof(struct wpa_eapol_key))) {
/* It's a dot1x frame, process it */
handle_dot1x(&cdata, &capdata, &opt);
if (cdata.aaset && cdata.spaset && cdata.snonceset &&
cdata.anonceset && cdata.keymicset
&& cdata.eapolframeset) {
/* We've collected everything we need. */
break;
}
}
}
if (!(cdata.aaset && cdata.spaset && cdata.snonceset &&
cdata.anonceset && cdata.keymicset && cdata.eapolframeset)) {
cdata.aaset = 0;
cdata.spaset = 0;
cdata.snonceset = 0;
cdata.anonceset = 0;
cdata.keymicset = 0;
cdata.eapolframeset = 0;
opt.nonstrict = 1;
memset(&capdata, 0, sizeof(struct capture_data));
memset(&cdata, 0, sizeof(struct crack_data));
memset(&eapolkey_nomic, 0, sizeof(eapolkey_nomic));
/* Populate capdata struct */
strncpy(capdata.pcapfilename, opt.pcapfile,
sizeof(capdata.pcapfilename));
if (openpcap(&capdata) != 0) {
printf("Unsupported or unrecognized pcap file.\n");
exit(-1);
}
/* populates global *packet */
while (getpacket(&capdata) > 0) {
if (opt.verbose > 2) {
lamont_hdump(packet, h->len);
}
/* test packet for data that we are looking for */
if (memcmp(&packet[capdata.l2type_offset], DOT1X_LLCTYPE, 2) ==
0 && (h->len >capdata.l2type_offset + sizeof(struct wpa_eapol_key))) {
/* It's a dot1x frame, process it */
handle_dot1x(&cdata, &capdata, &opt);
if (cdata.aaset && cdata.spaset && cdata.snonceset
&& cdata.anonceset && cdata.keymicset
&& cdata.eapolframeset) {
if (cdata.replay_counter1 != 0
&& cdata.replay_counter2 != 0) {
if (memcmp (cdata.replay_counter1,
cdata.replay_counter2, 8) == 0) {
cdata.counters = 1;
/* We've collected everything we need. */
break;
}
}
if (cdata.replay_counter3 != 0
&& cdata.replay_counter4 != 0) {
if (memcmp (cdata.replay_counter3,
cdata.replay_counter4, 8) == 0) {
cdata.counters = 1;
/* We've collected everything we need. */
break;
}
}
}
}
}
}
closepcap(&capdata);
if (!(cdata.aaset && cdata.spaset && cdata.snonceset &&
cdata.anonceset && cdata.keymicset && cdata.eapolframeset && cdata.counters)) {
printf("End of pcap capture file, incomplete four-way handshake "
"exchange. Try using a\ndifferent capture.\n");
exit(-1);
} else {
if (cdata.ver == WPA_KEY_INFO_TYPE_HMAC_SHA1_AES) {
printf("Collected all necessary data to mount crack"
" against WPA2/PSK passphrase.\n");
} else if (cdata.ver == WPA_KEY_INFO_TYPE_HMAC_MD5_RC4) {
printf("Collected all necessary data to mount crack"
" against WPA/PSK passphrase.\n");
}
}
if (opt.verbose > 1) {
dump_all_fields(cdata, &opt);
}
if (opt.checkonly) {
/* Don't attack the PSK, just return non-error return code */
return 0;
}
/* Zero mic and length data for hmac-md5 calculation */
eapkeypacket =
(struct wpa_eapol_key *)&cdata.eapolframe[EAPDOT1XOFFSET];
memset(&eapkeypacket->key_mic, 0, sizeof(eapkeypacket->key_mic));
if (opt.nonstrict == 0) {
eapkeypacket->key_data_length = 0;
}
printf("Starting dictionary attack. Please be patient.\n");
fflush(stdout);
signal(SIGINT, cleanup);
signal(SIGTERM, cleanup);
signal(SIGQUIT, cleanup);
gettimeofday(&start, 0);
if (!IsBlank(opt.hashfile)) {
ret = hashfile_attack(&opt, passphrase, &cdata);
} else if (!IsBlank(opt.dictfile)) {
ret = dictfile_attack(&opt, passphrase, &cdata);
} else {
usage("Must specify dictfile or hashfile (-f or -d)");
exit(-1);
}
if (ret == 0) {
printf("\nThe PSK is \"%s\".\n", passphrase);
gettimeofday(&end, 0);
printstats(start, end, wordstested);
return 0;
} else {
printf("Unable to identify the PSK from the dictionary file. "
"Try expanding your\npassphrase list, and double-check"
" the SSID. Sorry it didn't work out.\n");
gettimeofday(&end, 0);
printstats(start, end, wordstested);
return 1;
}
return 1;
}
int main(int argc, char *argv[])
{
struct gw_host *gw;
struct ini_file *ini;
struct ini_section *sec;
sigset_t bmask;
int idx;
debug_stream = stderr;
parseopts(argc, argv);
ini = read_configfile(cfgfile, &sec);
free(cfgfile);
proc_per_gw = pflock_new(NULL, NULL);
sigemptyset(&bmask);
sigaddset(&bmask ,SIGUSR1);
sigaddset(&bmask ,SIGTERM);
if(sigprocmask(SIG_BLOCK, &bmask, NULL) < 0)
log_exit_perror(FATAL_ERROR, "sigprocmask() blocking setup");
while(sec) {
if(pflock_fork_data(proc_per_gw, sec) == NULL) {
pflock_destroy(proc_per_gw);
prog_name = safemalloc(64, "new progname");
snprintf(prog_name, 63, "autotun-%s", sec->name);
debug("New child process pid %d", getpid());
setup_signals_for_child();
gw = process_section_to_gw(sec);
ini_free_data(ini);
connect_ssh_session(&gw->session);
authenticate_ssh_session(gw->session);
return run_gateway(gw);
}
sec = sec->next;
}
setup_signals_parent();
debug("Signal children GO");
pflock_sendall(proc_per_gw, SIGUSR1);
sigprocmask(SIG_UNBLOCK, &bmask, NULL);
do {
idx = pflock_wait_remove(proc_per_gw, PF_KILLED);
debug("pflock_wait(): returned %d%s", idx,
(idx == PFW_REMOVED) ? ": Removed proc from flock" : "");
if(finish_main_loop != 0) {
debug("Sending %s to all", !hard_shutdown ? "SIGINT" : "SIGTERM");
pflock_sendall(proc_per_gw, hard_shutdown ? SIGTERM : SIGINT );
finish_main_loop = 0;
}
} while(idx != PFW_NOCHILD && idx != PFW_ERROR && !hard_shutdown);
if(pflock_get_numrun(proc_per_gw) > 0)
pflock_sendall(proc_per_gw, SIGTERM);
ini_free_data(ini);
pflock_destroy(proc_per_gw);
return 0;
}
int
main(int argc, const char *argv[])
{
if (argc < 2) {
usage();
exit(EXIT_FAILURE);
}
parseopts(argv[1]);
nfc_init(&context);
if (context == NULL) {
ERR("Unable to init libnfc (malloc)");
exit(EXIT_FAILURE);
}
// Try to open the NFC reader
pnd = nfc_open(context, NULL);
if (pnd == NULL) {
ERR("Error opening NFC reader");
nfc_exit(context);
exit(EXIT_FAILURE);
}
if (nfc_initiator_init(pnd) < 0) {
nfc_perror(pnd, "nfc_initiator_init");
nfc_close(pnd);
nfc_exit(context);
exit(EXIT_FAILURE);
};
// Let the reader only try once to find a tag
if (nfc_device_set_property_bool(pnd, NP_INFINITE_SELECT, false) < 0) {
nfc_perror(pnd, "nfc_device_set_property_bool");
nfc_close(pnd);
nfc_exit(context);
exit(EXIT_FAILURE);
}
// Disable ISO14443-4 switching in order to read devices that emulate Mifare Classic with ISO14443-4 compliance.
if (nfc_device_set_property_bool(pnd, NP_AUTO_ISO14443_4, false) < 0) {
nfc_perror(pnd, "nfc_device_set_property_bool");
nfc_close(pnd);
nfc_exit(context);
exit(EXIT_FAILURE);
}
// Configure the CRC
if (nfc_device_set_property_bool(pnd, NP_HANDLE_CRC, false) < 0) {
nfc_perror(pnd, "nfc_device_set_property_bool");
nfc_close(pnd);
nfc_exit(context);
exit(EXIT_FAILURE);
}
// Use raw send/receive methods
if (nfc_device_set_property_bool(pnd, NP_EASY_FRAMING, false) < 0) {
nfc_perror(pnd, "nfc_device_set_property_bool");
nfc_close(pnd);
nfc_exit(context);
exit(EXIT_FAILURE);
}
printf("NFC reader: %s opened\n", nfc_device_get_name(pnd));
// Try to find a MIFARE Classic tag
if (select_target(pnd, &nt) <= 0) {
printf("Error: no tag was found\n");
nfc_close(pnd);
nfc_exit(context);
exit(EXIT_FAILURE);
}
// Test if we are dealing with a MIFARE compatible tag
if ((nt.nti.nai.btSak & 0x08) == 0) {
printf("Warning: tag is probably not a MFC!\n");
}
printf("Found MIFARE Classic card:\n");
nt.nm = nmMifare;
print_nfc_target(&nt, false);
// Guessing size
if ((nt.nti.nai.abtAtqa[1] & 0x02) == 0x02)
// 4K
uiBlocks = 0xff;
else if ((nt.nti.nai.btSak & 0x01) == 0x01)
// 320b
uiBlocks = 0x13;
else
// 1K/2K, checked through RATS
uiBlocks = 0x3f;
printf("Guessing size: seems to be a %i-byte card\n", (uiBlocks + 1) * 16);
if (parse_card()) {
printf("Done, %d blocks read.\n", uiBlocks + 1);
fflush(stdout);
}
if(is_addv) if(!easy_add_value(0xff) || !parse_card()) printf("Failed Add Value!!\n");
printTag(&e);
nfc_close(pnd);
nfc_exit(context);
exit(EXIT_SUCCESS);
}
int
main(int argc, char *argv[])
{
char *types = NULL, data[512] = "", *resolvpath = NULL;
char *files[] = { "/proc/mounts", "/etc/fstab", NULL };
const char *source, *target;
struct mntent *me = NULL;
int aflag = 0, oflag = 0, status = 0, i, r;
unsigned long flags = 0;
FILE *fp;
ARGBEGIN {
case 'B':
argflags |= MS_BIND;
break;
case 'M':
argflags |= MS_MOVE;
break;
case 'R':
argflags |= MS_REC;
break;
case 'a':
aflag = 1;
break;
case 'o':
oflag = 1;
argopts = EARGF(usage());
parseopts(argopts, &flags, data, sizeof(data));
break;
case 't':
types = EARGF(usage());
break;
case 'n':
break;
default:
usage();
} ARGEND;
if (argc < 1 && aflag == 0) {
if (!(fp = fopen(files[0], "r")))
eprintf("fopen %s:", files[0]);
concat(fp, files[0], stdout, "<stdout>");
fclose(fp);
return 0;
}
if (aflag == 1)
goto mountall;
source = argv[0];
target = argv[1];
if (!target) {
target = argv[0];
source = NULL;
if (!(resolvpath = realpath(target, NULL)))
eprintf("realpath %s:", target);
target = resolvpath;
}
for (i = 0; files[i]; i++) {
if (!(fp = setmntent(files[i], "r"))) {
if (strcmp(files[i], "/proc/mounts") != 0)
weprintf("setmntent %s:", files[i]);
continue;
}
while ((me = getmntent(fp))) {
if (strcmp(me->mnt_dir, target) == 0 ||
strcmp(me->mnt_fsname, target) == 0 ||
(source && strcmp(me->mnt_dir, source) == 0) ||
(source && strcmp(me->mnt_fsname, source) == 0)) {
if (!source) {
target = me->mnt_dir;
source = me->mnt_fsname;
}
if (!oflag)
parseopts(me->mnt_opts, &flags, data, sizeof(data));
if (!types)
types = me->mnt_type;
goto mountsingle;
}
}
endmntent(fp);
fp = NULL;
}
if (!source)
eprintf("can't find %s in /etc/fstab\n", target);
mountsingle:
r = mounthelper(source, target, types);
if (r == -1)
status = 1;
if (r > 0 && mount(source, target, types, argflags | flags, data) < 0) {
weprintf("mount: %s:", source);
status = 1;
}
if (fp)
endmntent(fp);
free(resolvpath);
return status;
mountall:
if (!(fp = setmntent("/etc/fstab", "r")))
eprintf("setmntent %s:", "/etc/fstab");
while ((me = getmntent(fp))) {
/* has "noauto" option or already mounted: skip */
if (hasmntopt(me, MNTOPT_NOAUTO) || mounted(me->mnt_dir))
continue;
flags = 0;
parseopts(me->mnt_opts, &flags, data, sizeof(data));
/* if -t types specified:
* if non-match, skip
* if match and prefixed with "no", skip */
if (types &&
((types[0] == 'n' && types[1] == 'o' &&
findtype(types + 2, me->mnt_type)) ||
(!findtype(types, me->mnt_type))))
continue;
r = mounthelper(me->mnt_fsname, me->mnt_dir, me->mnt_type);
if (r > 0 && mount(me->mnt_fsname, me->mnt_dir, me->mnt_type,
argflags | flags, data) < 0) {
weprintf("mount: %s:", me->mnt_fsname);
status = 1;
}
}
endmntent(fp);
return status;
}
int main(int argc, char *argv[])
{
if(!init_cfg())
{
fprintf(stderr, "Unable to open config file or invalid content in config file.\n");
exit(1);
}
parseopts(argc, argv, conf);
if(conf->msg)
{
if(!open_producer())
{
printf("Unable to contact Bluemote server!\n");
exit(1);
}
if(ipc_write(conf->device, strlen(conf->device))<=0)
{
printf("Unable to send message to Bluemote server!\n");
close_producer();
exit(1);
}
close_producer();
exit(0);
}
else
{
if(!get_lock())
{
printf("Another instance of Bluemote already running!\n");
exit(1);
}
if(!open_consumer())
{
printf("Unable to listen for messages!\n");
exit(1);
}
}
strcpy(logfile, getenv("HOME"));
strcat(logfile, BLUEMOTEDIR);
strcat(logfile, LOGFILE);
printf("Setting up signal handlers.\n");
logger("INIT", "Setting up signal handlers");
if(!init_signals())
{
perror("init_signals()");
exit(1);
}
if(conf->daemon)
{
printf("Entering daemon mode.\n");
logger("INIT", "Entering daemon mode.\n");
if(daemon(TRUE, FALSE)==-1)
{
printf("Unable to enter daemon mode. Exiting.\n");
logger("ERROR", "Unable to enter daemon mode. Exiting.\n");
exit(1);
}
}
while(TRUE)
{
closeport();
printf("Connecting to phone...\n");
logger("INIT", "Connecting to phone...");
while(openport(conf->device) == -1)
{
sprintf(buf,"Unable to connect to phone. Will retry after %d secs.",conf->retrysecs);
logger("INIT", buf);
sleep(conf->retrysecs);
logger("INIT", "Retrying...");
}
printf("Connected to phone.\n");
logger("INIT", "Connected to phone.");
printf("Initialising the connection.\n");
logger("INIT", "Initialising the connection.\n");
if(!initport()) exit(1);
printf("Waiting for commands from phone\n");
logger("INIT", "Waiting for commands from phone\n");
/* Not looping to take care of timeout because timeout is very unlikely and
* this function is called again inside remote(). In the worst case, the I/O
* commands for Connect event won't have any effect. */
if(init_mainmenu()==-1) continue;
exec_event("Connect");
if(!manual)
{
exec_event("MoveIn");
}
manual = FALSE;
remote();
if(!manual)
{
exec_event("MoveOut");
}
exec_event("Disconnect");
}
return(0);
}
int
main(int argc, char *argv[])
#endif
{
char fromhost[MAX_RDC_HOST_SIZE];
char tohost[MAX_RDC_HOST_SIZE];
char fromfile[NSC_MAXPATH];
char tofile[NSC_MAXPATH];
char frombitmap[NSC_MAXPATH];
char tobitmap[NSC_MAXPATH];
char directfile[NSC_MAXPATH];
char diskqueue[NSC_MAXPATH];
char group[NSC_MAXPATH];
char lhost[MAX_RDC_HOST_SIZE];
int pairs;
int pid;
int flag = 0;
int doasync;
int rc;
char *required;
int setid;
(void) setlocale(LC_ALL, "");
(void) textdomain("rdc");
program = basename(argv[0]);
rc = rdc_check_release(&required);
if (rc < 0) {
rdc_err(NULL,
gettext("unable to determine the current "
"Solaris release: %s\n"), strerror(errno));
} else if (rc == FALSE) {
rdc_err(NULL,
gettext("incorrect Solaris release (requires %s)\n"),
required);
}
rdc_maxsets = rdc_get_maxsets();
if (rdc_maxsets == -1) {
spcs_log("sndr", NULL,
gettext("%s unable to get maxsets value from kernel"),
program);
rdc_err(NULL,
gettext("unable to get maxsets value from kernel"));
}
pair_list = calloc(rdc_maxsets, sizeof (*pair_list));
if (pair_list == NULL) {
rdc_err(NULL,
gettext(
"unable to allocate pair_list"
" array for %d sets"),
rdc_maxsets);
}
if (parseopts(argc, argv, &flag))
return (1);
pairs = read_libcfg(flag);
if (flag == RDC_CMD_FIXSETIDS) {
if (pairs) {
spcs_log("sndr", NULL, gettext("Fixed %d Remote Mirror"
" set IDs"), pairs);
#ifdef DEBUG
rdc_warn(NULL, gettext("Fixed %d Remote Mirror set "
"IDs"), pairs);
#endif
}
return (0);
}
if (pairs == 0) {
#ifdef DEBUG
rdc_err(NULL,
gettext("Config contains no dual copy sets"));
#else
return (0);
#endif
}
while (pairs--) {
pid = fork();
if (pid == -1) { /* error forking */
perror("fork");
continue;
}
if (pid > 0) /* this is parent process */
continue;
/*
* At this point, this is the child process. Do the operation
*/
strncpy(fromfile,
pair_list[pairs].ffile, NSC_MAXPATH);
strncpy(tofile,
pair_list[pairs].tfile, NSC_MAXPATH);
strncpy(frombitmap,
pair_list[pairs].fbitmap, NSC_MAXPATH);
strncpy(fromhost,
pair_list[pairs].fhost, MAX_RDC_HOST_SIZE);
strncpy(tohost,
pair_list[pairs].thost, MAX_RDC_HOST_SIZE);
strncpy(tobitmap,
pair_list[pairs].tbitmap, NSC_MAXPATH);
strncpy(directfile,
pair_list[pairs].directfile, NSC_MAXPATH);
strncpy(diskqueue,
pair_list[pairs].diskqueue, NSC_MAXPATH);
strncpy(group,
pair_list[pairs].group, NSC_MAXPATH);
strncpy(lhost,
pair_list[pairs].lhost, MAX_RDC_HOST_SIZE);
doasync = pair_list[pairs].doasync;
setid = pair_list[pairs].setid;
if (rdc_operation(fromhost, fromfile, frombitmap,
tohost, tofile, tobitmap, flag, directfile, group,
diskqueue, doasync, lhost, setid)
< 0) {
exit(255);
}
exit(0);
}
while ((wait((int *)0) > 0))
;
return (0);
}
static xiosingle_t *xioparse_single(const char **addr) {
xiofile_t *xfd;
xiosingle_t *sfd;
struct addrname *ae;
const struct addrdesc *addrdesc = NULL;
const char *ends[4+1];
const char *hquotes[] = {
"'",
NULL
} ;
const char *squotes[] = {
"\"",
NULL
} ;
const char *nests[] = {
"'", "'",
"(", ")",
"[", "]",
"{", "}",
NULL
} ;
char token[512], *tokp;
size_t len;
int i;
/* init */
i = 0;
/*ends[i++] = xioopts.chainsep;*/ /* default: "|" */
ends[i++] = xioopts.pipesep; /* default: "!!" */
ends[i++] = ","/*xioopts.comma*/; /* default: "," */
ends[i++] = ":"/*xioopts.colon*/; /* default: ":" */
ends[i++] = NULL;
if ((xfd = xioallocfd()) == NULL) {
return NULL;
}
sfd = &xfd->stream;
sfd->argc = 0;
len = sizeof(token);
tokp = token;
if (nestlex(addr, &tokp, &len, ends, hquotes, squotes, nests,
true, true, false) < 0) {
Error2("keyword too long, in address \"%s%s\"", token, *addr);
}
*tokp = '\0'; /*! len? */
ae = (struct addrname *)
keyw((struct wordent *)&addressnames, token,
sizeof(addressnames)/sizeof(struct addrname)-1);
if (ae) {
addrdesc = ae->desc;
/* keyword */
if ((sfd->argv[sfd->argc++] = strdup(token)) == NULL) {
Error1("strdup(\"%s\"): out of memory", token);
}
} else {
if (false) {
;
#if WITH_FDNUM
} else if (isdigit(token[0]&0xff) && token[1] == '\0') {
Info1("interpreting address \"%s\" as file descriptor", token);
addrdesc = &addr_fd;
if ((sfd->argv[sfd->argc++] = strdup("FD")) == NULL) {
Error("strdup(\"FD\"): out of memory");
}
if ((sfd->argv[sfd->argc++] = strdup(token)) == NULL) {
Error1("strdup(\"%s\"): out of memory", token);
}
/*! check argc overflow */
#endif /* WITH_FDNUM */
#if WITH_GOPEN
} else if (strchr(token, '/')) {
Info1("interpreting address \"%s\" as file name", token);
addrdesc = &addr_gopen;
if ((sfd->argv[sfd->argc++] = strdup("GOPEN")) == NULL) {
Error("strdup(\"GOPEN\"): out of memory");
}
if ((sfd->argv[sfd->argc++] = strdup(token)) == NULL) {
Error1("strdup(\"%s\"): out of memory", token);
}
/*! check argc overflow */
#endif /* WITH_GOPEN */
} else {
Error1("unknown device/address \"%s\"", token);
/*!!! free something*/ return NULL;
}
}
sfd->tag = XIO_TAG_RDWR;
sfd->addr = addrdesc;
while (!strncmp(*addr, xioopts.paramsep, strlen(xioopts.paramsep))) {
*addr += strlen(xioopts.paramsep);
len = sizeof(token);
tokp = token;
if (nestlex(addr, &tokp, &len, ends, hquotes, squotes, nests,
true, true, false) != 0) {
Error2("syntax error in address \"%s%s\"", token, *addr);
}
*tokp = '\0';
if ((sfd->argv[sfd->argc++] = strdup(token)) == NULL) {
Error1("strdup(\"%s\"): out of memory", token);
}
}
if (parseopts(addr, addrdesc->groups, &sfd->opts) < 0) {
free(xfd);
return NULL;
}
return sfd;
}
int
getoptx(int argc, const char **argv, const char *minus, const char *plus)
{
Opttable *tab;
Optentry *ent = NULL;
boolean single = FALSE;
int code = '?';
Params param = NONE;
int loc = 1;
if (minustab == NULL)
minustab = new_opttable();
if (plustab == NULL)
plustab = new_opttable();
if (minustab == NULL || plustab == NULL)
return EOF;
if (minus == NULL)
minus = "";
if (plus == NULL)
plus = "";
if (optind < 1 || lastargc != argc || lastargv != argv ||
lastminus == NULL || !streq(lastminus, minus) ||
lastplus == NULL || !streq(lastplus, plus))
{
lastargc = argc;
lastargv = argv;
lastminus = minus;
lastplus = plus;
optind = 0;
endflag = FALSE;
singlechars = NULL;
lasttab = NULL;
parseopts(minustab, minus);
parseopts(plustab, plus);
}
if (endflag)
return EOF;
if (singlechars != NULL && singlechars[0] != '\0')
{
char name[2];
name[0] = *singlechars++;
name[1] = '\0';
tab = lasttab;
ent = find_opttable(tab, name);
single = TRUE;
}
else
{
optind++;
if (optind >= argc)
{
endflag = TRUE;
return EOF;
}
/* --opt is same as +opt */
if (argv[optind][0] == '+' ||
(argv[optind][0] == '-' && argv[optind][1] == '-' &&
argv[optind][2]))
{
if (argv[optind][0] != '+')
loc++;
tab = plustab;
optsign = '+';
}
else if (argv[optind][0] == '-')
{
if (argv[optind][1] == '\0')
{
endflag = TRUE;
return EOF;
}
else if (argv[optind][1] == '-' && argv[optind][2] == '\0')
{
optind++;
endflag = TRUE;
return EOF;
}
tab = minustab;
optsign = '-';
}
else
{
endflag = TRUE;
return EOF;
}
ent = find_opttable(tab, &argv[optind][loc]); /* multi-char name */
if (ent == NULL) /* did not find it */
{
char name[2];
name[0] = argv[optind][loc];
name[1] = '\0';
ent = find_opttable(tab, name); /* single-char name */
if (ent == NULL && (isdigit(name[0]) || name[0] == '-'))
ent = find_opttable(tab, "(#)"); /* numeric */
else /* do not care if found or not found */
{
single = TRUE;
singlechars = &argv[optind][loc + 1];
lasttab = tab;
}
}
}
if (ent != NULL)
{
code = ent->code;
param = ent->params;
optname = ent->name;
}
else
optname = NULL;
switch (param)
{
case PARAM:
if (single && singlechars[0] != '\0')
{
optarg = (char *)singlechars;
singlechars = NULL;
}
else
{
optind++;
if (optind >= argc)
{
optarg = NULL;
return '?';
}
optarg = (char *)argv[optind];
}
break;
case NUMERIC:
optarg = (char *)&argv[optind][loc];
if (streq(optarg, "(#)"))
optarg = NULL;
break;
default:
optarg = NULL;
break;
}
return code;
}
int dictfile_attack(struct user_opt *opt, char *passphrase,
struct crack_data *cdata)
{
FILE *fp;
int fret;
u8 pmk[32];
u8 ptk[64];
u8 keymic[16];
struct wpa_ptk *ptkset;
#ifdef FPGA
// int i;
opt_g = opt;
cdata_g = cdata;
if(usefpga)
initfpga();
#endif
/* Open the dictionary file */
if (*opt->dictfile == '-') {
printf("Using STDIN for words.\n");
fp = stdin;
} else {
fp = fopen(opt->dictfile, "r");
if (fp == NULL) {
perror("fopen");
exit(-1);
}
}
while (feof(fp) == 0 && sig == 0) {
/* Populate "passphrase" with the next word */
fret = nextdictword(passphrase, fp);
if (fret < 0) {
break;
}
if (opt->verbose > 1) {
printf("Testing passphrase: %s\n", passphrase);
}
/*
* Test length of word. IEEE 802.11i indicates the passphrase
* must be at least 8 characters in length, and no more than 63
* characters in length.
*/
if (fret < 8 || fret > 63) {
if (opt->verbose) {
printf("Invalid passphrase length: %s (%d).\n",
passphrase, strlen(passphrase));
}
continue;
} else {
/* This word is good, increment the words tested
counter */
wordstested++;
}
/* Status display */
#ifdef FPGA
if ((wordstested % 100) == 0) {
#else
if ((wordstested % 1000) == 0) {
#endif
printf("key no. %ld: %s\n", wordstested, passphrase);
fflush(stdout);
}
if (opt->verbose > 1) {
printf("Calculating PMK for \"%s\".\n", passphrase);
}
pbkdf2_sha1(passphrase, opt->ssid, strlen(opt->ssid), 4096,
pmk, sizeof(pmk), USECACHED);
#ifdef FPGA
if (!usefpga) {
#endif
if (opt->verbose > 2) {
printf("PMK is");
lamont_hdump(pmk, sizeof(pmk));
}
if (opt->verbose > 1) {
printf("Calculating PTK with collected data and "
"PMK.\n");
}
#ifdef FPGA
/*
for(i = 0; i < 32; i++)
printf("%02x ", pmk[i]);
printf("\n");
*/
#endif
wpa_pmk_to_ptk(pmk, cdata->aa, cdata->spa, cdata->anonce,
cdata->snonce, ptk, sizeof(ptk));
if (opt->verbose > 2) {
printf("Calculated PTK for \"%s\" is", passphrase);
lamont_hdump(ptk, sizeof(ptk));
}
ptkset = (struct wpa_ptk *)ptk;
if (opt->verbose > 1) {
printf("Calculating hmac-MD5 Key MIC for this "
"frame.\n");
}
hmac_md5(ptkset->mic_key, 16, cdata->eapolframe,
sizeof(cdata->eapolframe), keymic);
if (opt->verbose > 2) {
printf("Calculated MIC with \"%s\" is", passphrase);
lamont_hdump(keymic, sizeof(keymic));
}
if (memcmp(&cdata->keymic, &keymic, sizeof(keymic)) == 0) {
return 0;
} else {
continue;
}
#ifdef FPGA
}
#endif
}
#ifdef FPGA
if(usefpga) {
printf("waiting..."); fflush(stdout);
finishreg();
printf("\ndone\n");
}
#endif
return 1;
}
int main(int argc, char **argv)
{
struct user_opt opt;
struct crack_data cdata;
struct capture_data capdata;
struct wpa_eapol_key *eapkeypacket;
u8 eapolkey_nomic[99];
struct timeval start, end;
int ret;
char passphrase[MAXPASSLEN + 1];
printf("%s %s - WPA-PSK dictionary attack. <*****@*****.**>\n",
PROGNAME, VER);
memset(&opt, 0, sizeof(struct user_opt));
memset(&capdata, 0, sizeof(struct capture_data));
memset(&cdata, 0, sizeof(struct crack_data));
memset(&eapolkey_nomic, 0, sizeof(eapolkey_nomic));
/* Collect and test command-line arguments */
parseopts(&opt, argc, argv);
testopts(&opt);
printf("\n");
/* Populate capdata struct */
strncpy(capdata.pcapfilename, opt.pcapfile,
sizeof(capdata.pcapfilename));
if (openpcap(&capdata) != 0) {
printf("Unsupported or unrecognized pcap file.\n");
exit(1);
}
/* populates global *packet */
while (getpacket(&capdata) > 0) {
if (opt.verbose > 2) {
lamont_hdump(packet, h->len);
}
/* test packet for data that we are looking for */
if (memcmp(&packet[capdata.l2type_offset], DOT1X_LLCTYPE, 2) ==
0 && (h->len >
capdata.l2type_offset + sizeof(struct wpa_eapol_key))) {
/* It's a dot1x frame, process it */
handle_dot1x(&cdata, &capdata);
if (cdata.aaset && cdata.spaset && cdata.snonceset &&
cdata.anonceset && cdata.keymicset
&& cdata.eapolframeset) {
/* We've collected everything we need. */
break;
}
}
}
closepcap(&capdata);
if (!(cdata.aaset && cdata.spaset && cdata.snonceset &&
cdata.anonceset && cdata.keymicset && cdata.eapolframeset)) {
printf("End of pcap capture file, incomplete TKIP four-way "
"exchange. Try using a\ndifferent capture.\n");
exit(1);
} else {
printf("Collected all necessary data to mount crack against "
"passphrase.\n");
}
if (opt.verbose > 1) {
dump_all_fields(cdata);
}
/* Zero mic and length data for hmac-md5 calculation */
eapkeypacket =
(struct wpa_eapol_key *)&cdata.eapolframe[EAPDOT1XOFFSET];
memset(&eapkeypacket->key_mic, 0, sizeof(eapkeypacket->key_mic));
eapkeypacket->key_data_length = 0;
printf("Starting dictionary attack. Please be patient.\n");
fflush(stdout);
// signal(SIGINT, cleanup);
// signal(SIGTERM, cleanup);
// signal(SIGQUIT, cleanup);
gettimeofday(&start, NULL);
#ifdef FPGA
start_g = start;
#endif
if (!IsBlank(opt.hashfile)) {
ret = hashfile_attack(&opt, passphrase, &cdata);
} else if (!IsBlank(opt.dictfile)) {
ret = dictfile_attack(&opt, passphrase, &cdata);
} else {
usage("Must specify dictfile or hashfile (-f or -d)");
exit(1);
}
if (ret == 0) {
printf("\nThe PSK is \"%s\".\n", passphrase);
} else {
printf("Unable to identify the PSK from the dictionary file. "
"Try expanding your\npassphrase list, and double-check"
" the SSID. Sorry it didn't work out.\n");
}
gettimeofday(&end, NULL);
printstats(start, end, wordstested);
return (1);
}
/*
* Main entry point
*/
int main(int argc, char *argv[]) {
p = parseopts(argc, argv);
if (p == INVALID_PARAMETER) {
usage(EXIT_FAILURE);
}
int num_params = parseinput(argc, argv);
if (num_params == 0) {
usage(EXIT_FAILURE);
}
// Everything should be okay from here on
double sigma = MODEL_PARAMS[s].sigma;
double epsilon = MODEL_PARAMS[s].epsilon;
double m = MODEL_PARAMS[s].m;
double r = MODEL_PARAMS[s].r_nn;
if (p == OMEGA || p == GAMMA) {
vec3 dq = { 0, 0, 0 };
if (num_params == 2) {
dq[X] = (q2[X] - q1[X])/(npoints - 1);
dq[Y] = (q2[Y] - q1[Y])/(npoints - 1);
dq[Z] = (q2[Z] - q1[Z])/(npoints - 1);
}
if (p == OMEGA) {
vec3 omega;
double a = A(epsilon, sigma, r);
double b = B(epsilon, sigma, r);
if (num_params == 1) {
frequencies(a, b, m, q1, omega, NULL);
print_result(q1, omega);
}
else if (num_params == 2) {
for (int i = 0; i < npoints; i++) {
frequencies(a, b, m, q1, omega, NULL);
print_result(q1, omega);
q1[X] += dq[X];
q1[Y] += dq[Y];
q1[Z] += dq[Z];
}
}
}
else { // Gamma
vec3 gamma;
double delta = 1e-20;
if (num_params == 1) {
calc_gamma(gamma, q1, delta, r, sigma, epsilon, m);
print_result(q1, gamma);
}
else if (num_params == 2) {
for (int i = 0; i < npoints; i++) {
calc_gamma(gamma, q1, delta, r, sigma, epsilon, m);
print_result(q1, gamma);
q1[X] += dq[X];
q1[Y] += dq[Y];
q1[Z] += dq[Z];
}
}
}
}
else { // Cv
double cv;
if (num_params == 1) {
cv = calc_cv(t1, r, sigma, epsilon, m);
printf("%g %g\n", t1, cv);
}
else if (num_params == 2) {
double dt = (t2 - t1)/(npoints - 1);
for (int i = 0; i < npoints; i++) {
cv = calc_cv(t1, r, sigma, epsilon, m);
printf("%g %g\n", t1, cv);
t1 += dt;
}
}
}
return 0;
}
