int root_thread_init (void)
{
u_long err, args[4];
err = q_create("CNSQ",16,Q_LIMIT|Q_FIFO,&message_qid);
args[0] = message_qid;
if (err != SUCCESS)
{
xnprintf("q_create() failed, errno %lu",err);
return err;
}
err = t_create("CONS",
CONSUMER_TASK_PRI,
CONSUMER_SSTACK_SIZE,
CONSUMER_USTACK_SIZE,
0,
&consumer_tid);
if (err != SUCCESS)
{
xnprintf("t_create() failed, errno %lu",err);
return err;
}
err = t_start(consumer_tid,0,consumer_task,args);
if (err != SUCCESS)
{
xnprintf("t_start() failed, errno %lu",err);
return err;
}
err = t_create("PROD",
PRODUCER_TASK_PRI,
PRODUCER_SSTACK_SIZE,
PRODUCER_USTACK_SIZE,
0,
&producer_tid);
if (err != SUCCESS)
{
xnprintf("t_create() failed, errno %lu",err);
return err;
}
err = t_start(producer_tid,0,producer_task,args);
if (err != SUCCESS)
{
xnprintf("t_start() failed, errno %lu",err);
return err;
}
return 0;
}
int main(int argc, char **argv)
{
int ret, r2;
runcmd_init();
t_set_colors(0);
t_start("exec output comparison");
{
int i;
char *out = calloc(1, BUF_SIZE);
for (i = 0; cases[i].input != NULL; i++) {
memset(out, 0, BUF_SIZE);
int pfd[2] = {-1, -1}, pfderr[2] = {-1, -1};
int fd;
char *cmd;
asprintf(&cmd, "/bin/echo -n %s", cases[i].input);
fd = runcmd_open(cmd, pfd, pfderr, NULL);
read(pfd[0], out, BUF_SIZE);
ok_str(cases[i].output, out, "Echoing a command should give expected output");
close(pfd[0]);
close(pfderr[0]);
close(fd);
}
}
ret = t_end();
t_reset();
t_start("anomaly detection");
{
int i;
for (i = 0; anomaly[i].cmd; i++) {
int out_argc;
char *out_argv[256];
int result = runcmd_cmd2strv(anomaly[i].cmd, &out_argc, out_argv);
ok_int(result, anomaly[i].ret, anomaly[i].cmd);
}
}
r2 = t_end();
ret = r2 ? r2 : ret;
t_reset();
t_start("argument splitting");
{
int i;
for (i = 0; parse_case[i].cmd; i++) {
int x, out_argc;
char *out_argv[256];
int result = runcmd_cmd2strv(parse_case[i].cmd, &out_argc, out_argv);
out_argv[out_argc] = NULL;
ok_int(result, 0, parse_case[i].cmd);
ok_int(out_argc, parse_case[i].argc_exp, parse_case[i].cmd);
for (x = 0; x < parse_case[x].argc_exp && out_argv[x]; x++) {
ok_str(parse_case[i].argv_exp[x], out_argv[x], "argv comparison test");
}
}
}
r2 = t_end();
return r2 ? r2 : ret;
}
int main(int argc, char **argv)
{
unsigned long k;
struct test_data *td;
t_set_colors(0);
t_start("fanout tests");
run_tests(10, 64);
run_tests(512, 64);
run_tests(64, 64);
run_tests(511, 17);
destroyed = 0;
fot = fanout_create(512);
ok_int(fanout_remove(fot, 12398) == NULL, 1,
"remove on empty table must yield NULL");
ok_int(fanout_get(fot, 123887987) == NULL, 1,
"get on empty table must yield NULL");
for (k = 0; k < 16385; k++) {
struct test_data *tdata = calloc(1, sizeof(*td));
tdata->key = k;
asprintf(&tdata->name, "%lu", k);
fanout_add(fot, k, tdata);
}
td = fanout_get(fot, k - 1);
ok_int(td != NULL, 1, "get must get what add inserts");
ok_int(fanout_remove(fot, k + 1) == NULL, 1,
"remove on non-inserted key must yield NULL");
ok_int(fanout_get(fot, k + 1) == NULL, 1,
"get on non-inserted must yield NULL");
fanout_destroy(fot, pdest);
ok_int((int)destroyed, (int)k, "destroy counter while free()'ing");
return t_end();
}
/* MAIN */
int main(int argc, char *argv[]) {
if ( argc < 4 ) return EXIT_FAILURE;
t_timemes t_run = {0};
t_init(t_run);
const char *patterns_filename = argv[1], *patt_size_pch = argv[2], *filename = argv[3];
unsigned int patt_size = atoi(patt_size_pch), text_size = 0;
uchar *text = NULL, *pattern = NULL;
FILE * file = NULL;
text_size = read_file_content<uchar>(&text, filename);
if (text == NULL) return EXIT_FAILURE;
pattern = (uchar*)calloc (patt_size+1, CH_SIZE);
if (pattern == NULL) { free(text); report_critical_error("Error: Can't allocate memory for pattern."); }
file = fopen (patterns_filename, "rb");
if (!file) { free(text); free(pattern); report_critical_error("Error: Can't open patterns file."); }
while (fread (pattern, CH_SIZE, patt_size, file)==patt_size) {
t_start(t_run);
cf::cf1<cf::cf1_verif_lev>(pattern, patt_size, text, text_size, K_DIFF, NULL);
t_stop(t_run);
}
approx_cf::print_result(t_get_seconds(t_run), 0, indexes.size(), text_size, patt_size, K_DIFF);
indexes.clear();
free(text);
free(pattern);
fclose(file);
return EXIT_SUCCESS;
}
/** Computes the elapsed time (in seconds) since the passed timeval */
static suClock computeTDiff(const timeval &arg_t_start)
{
//To compute the elapsed time since the clock was initialized.
timeval t_tick,t_diff,t_start(arg_t_start);
//Get the current system time
gettimeofday(&t_tick,NULL);
if (t_tick.tv_usec < t_start.tv_usec)
{
long int nsec = (t_start.tv_usec - t_tick.tv_usec) / 1000000 + 1;
t_start.tv_usec -= 1000000 * nsec;
t_start.tv_sec += nsec;
}
if (t_tick.tv_usec - t_start.tv_usec > 1000000)
{
long int nsec = (t_tick.tv_usec - t_start.tv_usec) / 1000000;
t_start.tv_usec += 1000000 * nsec;
t_start.tv_sec -= nsec;
}
// Compute the remaining time. tv_usec is positive.
t_diff.tv_sec = t_tick.tv_sec - t_start.tv_sec;
t_diff.tv_usec = t_tick.tv_usec - t_start.tv_usec;
return static_cast<suClock>(t_diff.tv_sec)+(static_cast<suClock>(t_diff.tv_usec)/1000000.00);
}
int main(int argc, char *argv[])
{
u_long args[] = { 1, 2, 3, 4 };
int ret;
copperplate_init(argc, argv);
traceobj_init(&trobj, argv[0], sizeof(tseq) / sizeof(int));
traceobj_mark(&trobj, 1);
ret = t_create("TASK", 20, 0, 0, 0, &tid);
traceobj_assert(&trobj, ret == SUCCESS);
ret = t_start(tid, 0, task, args);
traceobj_assert(&trobj, ret == SUCCESS);
traceobj_mark(&trobj, 2);
traceobj_join(&trobj);
traceobj_verify(&trobj, tseq, sizeof(tseq) / sizeof(int));
exit(0);
}
int main(int argc, char **argv)
{
if (argc != 5)
{
printf("usage: ./cli X Y THETA TIMEOUT\n"
" where X and Y are in meters,\n"
" THETA is in radians,\n"
" and TIMEOUT is in seconds.\n");
return 1;
}
ros::init(argc, argv);
double max_secs = atof(argv[4]);
WavefrontCLI wf_cli(atof(argv[1]), atof(argv[2]), atof(argv[3]));
ros::Time t_start(ros::Time::now());
while (wf_cli.ok() && wf_cli.state != WavefrontCLI::WF_DONE &&
ros::Time::now() - t_start < ros::Duration().fromSec(max_secs))
ros::Duration().fromSec(0.1).sleep();
if (wf_cli.ok() && wf_cli.state != WavefrontCLI::WF_DONE) // didn't get there
{
printf("timeout\n");
wf_cli.deactivate_goal();
}
else
printf("success\n");
ros::fini();
return 0;
}
int main(int argc, char *argv[])
{
u_long args[] = { 1, 2, 3, 4 }, msgbuf[4], count;
int ret, n;
copperplate_init(argc, argv);
traceobj_init(&trobj, argv[0], sizeof(tseq) / sizeof(int));
ret = q_create("QUEUE", Q_NOLIMIT, 0, &qid);
traceobj_assert(&trobj, ret == SUCCESS);
ret = t_create("TSKA", 21, 0, 0, 0, &tidA);
traceobj_assert(&trobj, ret == SUCCESS);
ret = t_create("TSKB", 20, 0, 0, 0, &tidB);
traceobj_assert(&trobj, ret == SUCCESS);
ret = t_start(tidA, 0, task_A, args);
traceobj_assert(&trobj, ret == SUCCESS);
ret = t_start(tidB, 0, task_B, args);
traceobj_assert(&trobj, ret == SUCCESS);
for (n = 0; n < 3; n++) {
msgbuf[0] = n + 1;
msgbuf[1] = n + 2;
msgbuf[2] = n + 3;
msgbuf[3] = n + 4;
count = 0;
traceobj_mark(&trobj, 7);
ret = q_broadcast(qid, msgbuf, &count);
traceobj_assert(&trobj, ret == SUCCESS && count == 2);
}
traceobj_mark(&trobj, 8);
traceobj_join(&trobj);
traceobj_verify(&trobj, tseq, sizeof(tseq) / sizeof(int));
ret = q_delete(qid);
traceobj_assert(&trobj, ret == SUCCESS);
exit(0);
}
int main(int argc, char **argv)
{
unsigned int i;
struct strcode sc[] = {
ADDSTR("\n"),
ADDSTR("\0\0"),
ADDSTR("XXXxXXX"),
ADDSTR("LALALALALALALAKALASBALLE\n"),
};
t_set_colors(0);
t_start("iocache_use_delim() test");
for (i = 0; i < ARRAY_SIZE(sc); i++) {
t_start("Testing delimiter of len %d", sc[i].len);
test_delimiter(sc[i].str, sc[i].len);
t_end();
}
return t_end();
}
/* create a biarc for a bezier curve.
*
* extends the tangent lines to the bezier curve at its first and last control
* points, and intersects them to find a third point.
* the biarc passes through the first and last control points, and the incenter
* of the circle defined by the first, last and intersection points.
*/
HIDDEN ON_Arc
make_biarc(const ON_BezierCurve& bezier)
{
ON_2dPoint isect, arc_pt;
ON_2dPoint p_start(bezier.PointAt(0)), p_end(bezier.PointAt(1.0));
ON_2dVector t_start(bezier.TangentAt(0)), t_end(bezier.TangentAt(1.0));
ON_Ray r_start(p_start, t_start), r_end(p_end, t_end);
r_start.IntersectRay(r_end, isect);
arc_pt = incenter(p_start, p_end, isect);
return ON_Arc(p_start, arc_pt, p_end);
}
void prof_pmk(char *essid)
{
TIME_STRUCT p1,p2;
char key[16][128];
unsigned char pmk_sol[16][40];
unsigned char pmk_fast[16][40];
int i,j;
for(i=0;i<16;i++)
{
strcpy(key[i],"atest");
key[i][0]+=i;
}
p1 = t_start();
for(i=0;i<16;i++)
calc_pmk(key[i],essid,pmk_sol[i]); //key값과 essid로부터 pmk 값을 계산함
t_end(&p1);
p2 = t_start();
calc_16pmk(key,essid,pmk_fast);
t_end(&p2);
//diff
for(i=0;i<16;i++)
{
if(memcmp(pmk_sol[i],pmk_fast[i],sizeof(pmk_sol[i])) != 0)
{
printf("* %d wrong case (key:%s)\n",i,key[i]);
dump_key("pmk_sol",pmk_sol[i],sizeof(pmk_sol[i]));
dump_key("pmk_fst",pmk_fast[i],sizeof(pmk_fast[i]));
}
}
printf("original : %0.2lf ms\n",t_get(p1)/1000);
printf("simd ver : %0.2lf ms\n",t_get(p2)/1000);
printf("performance : x%0.2lf\n",t_get(p1)/t_get(p2));
}
void TextRenderer::fillVerts(const std::string &text,
const vec2 &origin,
const vec2 &scale,
std::vector<float> &coords,
std::vector<float> &tcs)
{
const int ROWS = 16;
const int COLS = 16;
const int WIDTH = 256/COLS * scale.x;
const int HEIGHT = 256/ROWS * scale.y;
vec2 offset = origin;
offset.y -= HEIGHT / 2;
offset.x -= (WIDTH * text.size()) / 4;
for (size_t i = 0; i < text.size(); ++i) {
char ascii = text[i];
int map_x = ascii % COLS;
int map_y = ascii / ROWS;
vec2 c_start = offset;
vec2 c_end = offset + vec2(WIDTH, HEIGHT);
vec2 t_start(static_cast<float>(map_x) / COLS /*+ 1.0/256.0*/,
static_cast<float>(map_y) / ROWS /*+ 1.0/256.0*/);
vec2 t_end(static_cast<float>(map_x + 1) / COLS /*+ 1.0/256.0*/,
static_cast<float>(map_y + 1) / ROWS /*+ 1.0/256.0*/);
coords.push_back(c_start.x);
coords.push_back(c_start.y);
coords.push_back(c_end.x);
coords.push_back(c_start.y);
coords.push_back(c_end.x);
coords.push_back(c_end.y);
coords.push_back(c_start.x);
coords.push_back(c_end.y);
tcs.push_back(t_start.x);
tcs.push_back(t_start.y);
tcs.push_back(t_end.x);
tcs.push_back(t_start.y);
tcs.push_back(t_end.x);
tcs.push_back(t_end.y);
tcs.push_back(t_start.x);
tcs.push_back(t_end.y);
offset.x += static_cast<float>(WIDTH) / 2.0f;
}
}
int main(int argc, char **argv)
{
int listen_fd, flags, sockopt = 1;
struct sockaddr_in sain;
int error;
const char *err_msg;
t_set_colors(0);
t_start("iobroker ipc test");
error = iobroker_get_max_fds(NULL);
ok_int(error, IOBROKER_ENOSET, "test errors when passing null");
err_msg = iobroker_strerror(error);
test(err_msg && !strcmp(err_msg, iobroker_errors[(~error) + 1].string), "iobroker_strerror() returns the right string");
iobs = iobroker_create();
error = iobroker_get_max_fds(iobs);
test(iobs && error >= 0, "max fd's for real iobroker set must be > 0");
listen_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
flags = fcntl(listen_fd, F_GETFD);
flags |= FD_CLOEXEC;
fcntl(listen_fd, F_SETFD, flags);
(void)setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &sockopt, sizeof(sockopt));
memset(&sain, 0, sizeof(sain));
sain.sin_port = ntohs(9123);
sain.sin_family = AF_INET;
bind(listen_fd, (struct sockaddr *)&sain, sizeof(sain));
listen(listen_fd, 128);
iobroker_register(iobs, listen_fd, iobs, listen_handler);
if (argc == 1)
conn_spam(&sain);
for (;;) {
iobroker_poll(iobs, -1);
if (iobroker_get_num_fds(iobs) <= 1) {
break;
}
}
iobroker_close(iobs, listen_fd);
iobroker_destroy(iobs, 0);
t_end();
return 0;
}
int tty_expect(char *what,int timeout)
{
time_t t1;
int to=timeout,got=0,p=0,ch;
calling=0;
while(!got&&to>0) {
t1=t_start();
ch=tty_getc(to);
if(ch<0)return ch;
to-=t_time(t1);
if(ch==what[p])p++;
else p=0;
if(!what[p])got=1;
}
return got?OK:TIMEOUT;
}
struct osip_thread *
osip_thread_create (int stacksize, void *(*func) (void *), void *arg)
{
osip_thread_t *thread = (osip_thread_t *) osip_malloc (sizeof (osip_thread_t));
if (thread==NULL) return (NULL);
if (t_create ("sip", 150, stacksize, 0, 0, &thread->tid) != 0)
{
osip_free (thread);
return (NULL);
}
if (t_start (thread->tid, T_PREEMPT | T_ISR, func, 0) != 0)
{
osip_free (thread);
return (NULL);
}
return (struct osip_thread *)thread;
}
/*
* start as many threads as might be needed for the current queue
*/
int task_start (TASKQ *q)
{
int num_tasks = 0;
TASK *t;
wait_mutex (q);
q->stop = 0;
for (t = q->queue; t != NULL; t = t->next)
num_tasks++;
num_tasks -= q->waiting;
set_ready (q);
while ((num_tasks-- > 0) && (q->running < q->maxthreads))
{
debug ("starting new task\n");
q->running++;
t_start (task_run, q);
}
end_mutex (q);
return (0);
}
int tty_gets(char *what,size_t n,int timeout)
{
time_t t1;
int to=timeout,p=0,ch=0;
*what=0;
while(to>0&&p<n-1&&ch!='\r'&&ch!='\n') {
t1=t_start();
ch=tty_getc(to);
if(NOTTO(ch))return ch;
to-=t_time(t1);
if(ch>=0)what[p++]=ch;
}
what[p>0?--p:0]=0;
if(p>0)DEBUG(('M',1,"<< %s",what));
if(ch=='\r'||ch=='\n') {
DEBUG(('M',5,"tty_gets: completed"));
return OK;
} else if(to<=0) {
DEBUG(('M',3,"tty_gets: timed out"));
} else DEBUG(('M',3,"tty_gets: line too long"));
return TIMEOUT;
}
/**************************** Main ****************************************/
void main(void)
{
unsigned char zaehlertief, zaehlerhoch, data[256];
long periode = 1000000L; /* Zeitintervall zwischen Messungen */
int i, start = TRUE;
initcom();
ginit();
gwindow(0,255,0,255);
t_start(); /* Installiere Timer-Software */
t_alarm_start(); /* Installiere Alarm-Uhr */
printf("\nPOISSON V1.0\n");
for ( i = 0; i <= 255; i++ ) data[i] = 0;
t_alarm_set(0,periode,T_ONCE);
do {
do ; while ( t_alarm_check(0) == 0 );
t_alarm_set(0,periode,T_ONCE);
txchar(SYNCHBYTE);
zaehlertief = rxcharw();
zaehlerhoch = rxcharw();
if ( start ) start = FALSE; /* Erster Wert unbrauchbar */
else data[zaehlertief]++;
gclear();
for ( i = 0; i <= 255; i++ ) {
if ( i == 0 ) gpos(i, data[i]);
else gdraw(i, data[i]);
}
} while ( !kbhit() );
t_stop(); /* Desinstalliere Timer */
printf("\nDr�cke Taste..."); getch(); getch();
gend();
}
int main(int argc, char **argv)
{
int i, j;
struct kvvec *kvv, *kvv2, *kvv3;
struct kvvec_buf *kvvb, *kvvb2;
struct kvvec k = KVVEC_INITIALIZER;
t_set_colors(0);
t_start("key/value vector tests");
kvv = kvvec_create(1);
kvv2 = kvvec_create(1);
kvv3 = kvvec_create(1);
add_vars(kvv, test_data, 1239819);
add_vars(kvv, (const char **)argv + 1, argc - 1);
kvvec_sort(kvv);
kvvec_foreach(kvv, NULL, walker);
/* kvvec2buf -> buf2kvvec -> kvvec2buf -> buf2kvvec conversion */
kvvb = kvvec2buf(kvv, KVSEP, PAIRSEP, OVERALLOC);
kvv3 = buf2kvvec(kvvb->buf, kvvb->buflen, KVSEP, PAIRSEP, KVVEC_COPY);
kvvb2 = kvvec2buf(kvv3, KVSEP, PAIRSEP, OVERALLOC);
buf2kvvec_prealloc(kvv2, kvvb->buf, kvvb->buflen, KVSEP, PAIRSEP, KVVEC_ASSIGN);
kvvec_foreach(kvv2, kvv, walker);
kvvb = kvvec2buf(kvv, KVSEP, PAIRSEP, OVERALLOC);
test(kvv->kv_pairs == kvv2->kv_pairs, "pairs should be identical");
for (i = 0; i < kvv->kv_pairs; i++) {
struct key_value *kv1, *kv2;
kv1 = &kvv->kv[i];
if (i >= kvv2->kv_pairs) {
t_fail("missing var %d in kvv2", i);
printf("[%s=%s] (%d+%d)\n", kv1->key, kv1->value, kv1->key_len, kv1->value_len);
continue;
}
kv2 = &kvv2->kv[i];
if (!test(!kv_compare(kv1, kv2), "kv pair %d must match", i)) {
printf("%d failed: [%s=%s] (%d+%d) != [%s=%s (%d+%d)]\n",
i,
kv1->key, kv1->value, kv1->key_len, kv1->value_len,
kv2->key, kv2->value, kv2->key_len, kv2->value_len);
}
}
test(kvvb2->buflen == kvvb->buflen, "buflens must match");
test(kvvb2->bufsize == kvvb->bufsize, "bufsizes must match");
if (kvvb2->buflen == kvvb->buflen && kvvb2->bufsize == kvvb->bufsize &&
!memcmp(kvvb2->buf, kvvb->buf, kvvb->bufsize))
{
t_pass("kvvec -> buf -> kvvec conversion works flawlessly");
} else {
t_fail("kvvec -> buf -> kvvec conversion failed :'(");
}
free(kvvb->buf);
free(kvvb);
free(kvvb2->buf);
free(kvvb2);
kvvec_destroy(kvv, 1);
kvvec_destroy(kvv3, KVVEC_FREE_ALL);
for (j = 0; pair_term_missing[j]; j++) {
buf2kvvec_prealloc(&k, strdup(pair_term_missing[j]), strlen(pair_term_missing[j]), '=', ';', KVVEC_COPY);
for (i = 0; i < k.kv_pairs; i++) {
struct key_value *kv = &k.kv[i];
test(kv->key_len == kv->value_len, "%d.%d; key_len=%d; value_len=%d (%s = %s)",
j, i, kv->key_len, kv->value_len, kv->key, kv->value);
test(kv->value_len == strlen(kv->value),
"%d.%d; kv->value_len(%d) == strlen(%s)(%d)",
j, i, kv->value_len, kv->value, (int)strlen(kv->value));
}
}
t_end();
return 0;
}
bool RazerHydra::poll(uint32_t ms_to_wait)
{
if (hidraw_fd < 0)
{
ROS_ERROR("couldn't poll");
return false;
}
ros::Time t_start(ros::Time::now());
uint8_t buf[64];
while (ros::Time::now() < t_start + ros::Duration(0.001 * ms_to_wait))
{
ssize_t nread = read(hidraw_fd, buf, sizeof(buf));
//ROS_INFO("read %d bytes", (int)nread);
if (nread > 0)
{
raw_pos[0] = *((int16_t *)(buf+8));
raw_pos[1] = *((int16_t *)(buf+10));
raw_pos[2] = *((int16_t *)(buf+12));
raw_quat[0] = *((int16_t *)(buf+14));
raw_quat[1] = *((int16_t *)(buf+16));
raw_quat[2] = *((int16_t *)(buf+18));
raw_quat[3] = *((int16_t *)(buf+20));
raw_buttons[0] = buf[22] & 0x7f;
raw_analog[0] = *((int16_t *)(buf+23));
raw_analog[1] = *((int16_t *)(buf+25));
raw_analog[2] = buf[27];
raw_pos[3] = *((int16_t *)(buf+30));
raw_pos[4] = *((int16_t *)(buf+32));
raw_pos[5] = *((int16_t *)(buf+34));
raw_quat[4] = *((int16_t *)(buf+36));
raw_quat[5] = *((int16_t *)(buf+38));
raw_quat[6] = *((int16_t *)(buf+40));
raw_quat[7] = *((int16_t *)(buf+42));
raw_buttons[1] = buf[44] & 0x7f;
raw_analog[3] = *((int16_t *)(buf+45));
raw_analog[4] = *((int16_t *)(buf+47));
raw_analog[5] = buf[49];
// mangle the reported pose into the ROS frame conventions
tf::Matrix3x3 ros_to_razer( 0, -1, 0,
-1, 0, 0,
0, 0, -1 );
for (int i = 0; i < 2; i++)
{
pos[i].setX(raw_pos[3*i+0] * 0.001);
pos[i].setY(raw_pos[3*i+1] * 0.001);
pos[i].setZ(raw_pos[3*i+2] * 0.001);
pos[i] = ros_to_razer*pos[i];
tf::Quaternion q(raw_quat[i*4+1] / 32768.0,
raw_quat[i*4+2] / 32768.0,
raw_quat[i*4+3] / 32768.0,
raw_quat[i*4+0] / 32768.0);
tf::Matrix3x3 mat(q);
mat = ros_to_razer*mat*tf::Matrix3x3(tf::createQuaternionFromRPY(0, 0, M_PI_2));
mat.getRotation(quat[i]);
}
analog[0] = raw_analog[0] / 32768.0;
analog[1] = raw_analog[1] / 32768.0;
analog[2] = raw_analog[2] / 255.0;
analog[3] = raw_analog[3] / 32768.0;
analog[4] = raw_analog[4] / 32768.0;
analog[5] = raw_analog[5] / 255.0;
for (int i = 0; i < 2; i++)
{
buttons[i*7 ] = (raw_buttons[i] & 0x01) ? 1 : 0;
buttons[i*7+1] = (raw_buttons[i] & 0x04) ? 1 : 0;
buttons[i*7+2] = (raw_buttons[i] & 0x08) ? 1 : 0;
buttons[i*7+3] = (raw_buttons[i] & 0x02) ? 1 : 0;
buttons[i*7+4] = (raw_buttons[i] & 0x10) ? 1 : 0;
buttons[i*7+5] = (raw_buttons[i] & 0x20) ? 1 : 0;
buttons[i*7+6] = (raw_buttons[i] & 0x40) ? 1 : 0;
}
return true;
}
else
{
//ROS_ERROR( "Error reading: %s\n", strerror( errno ) );
usleep(1000);
}
}
//ROS_INFO("Ran out of time, returning!");
return false;
}
int main(int argc, char **argv)
{
dkhash_table *tx, *t;
unsigned int x;
int ret, r2;
struct test_data s;
char *p1, *p2;
char *strs[10];
char tmp[32];
t_set_colors(0);
t_start("dkhash basic test");
t = dkhash_create(512);
p1 = strdup("a not-so secret value");
dkhash_insert(t, "nisse", NULL, p1);
ok_int(dkhash_num_entries_max(t), 1, "Added one entry, so that's max");
ok_int(dkhash_num_entries_added(t), 1, "Added one entry, so one added");
ok_int(dkhash_table_size(t), 512, "Table must be sized properly");
ok_int(dkhash_collisions(t), 0, "One entry, so zero collisions");
p2 = dkhash_get(t, "nisse", NULL);
test(p1 == p2, "get should get what insert set");
dkhash_insert(t, "kalle", "bananas", p1);
p2 = dkhash_get(t, "kalle", "bezinga");
test(p1 != p2, "we should never get the wrong key");
ok_int(2, dkhash_num_entries(t), "should be 2 entries after 2 inserts");
p2 = dkhash_remove(t, "kalle", "bezinga");
ok_int(2, dkhash_num_entries(t), "should be 2 entries after 2 inserts and 1 failed remove");
ok_int(0, dkhash_num_entries_removed(t), "should be 0 removed entries after failed remove");
p2 = dkhash_remove(t, "kalle", "bananas");
test(p1 == p2, "dkhash_remove() should return removed data");
ok_int(dkhash_num_entries(t), 1, "should be 1 entries after 2 inserts and 1 successful remove");
p2 = dkhash_remove(t, "nisse", NULL);
test(p1 == p2, "dkhash_remove() should return removed data");
ret = t_end();
t_reset();
/* lots of tests below, so we shut up while they're running */
t_verbose = 0;
t_start("dkhash_walk_data() test");
memset(&s, 0, sizeof(s));
/* first we set up the dkhash-tables */
tx = dkhash_create(16);
for (x = 0; x < ARRAY_SIZE(keys); x++) {
dkhash_insert(tx, keys[x].k1, NULL, ddup(x, 0, 0));
dkhash_insert(tx, keys[x].k2, NULL, ddup(x, 0, 0));
dkhash_insert(tx, keys[x].k1, keys[x].k2, ddup(x, 0, 0));
s.x += 3;
ok_int(s.x, dkhash_num_entries(tx), "x table adding");
}
ok_int(s.x, dkhash_num_entries(tx), "x table done adding");
for (x = 0; x < ARRAY_SIZE(keys); x++) {
del.x = x;
del.i = del.j = 0;
ok_int(s.x, dkhash_num_entries(tx), "x table pre-delete");
s.x -= 3;
dkhash_walk_data(tx, del_matching);
ok_int(s.x, dkhash_num_entries(tx), "x table post-delete");
}
test(0 == dkhash_num_entries(tx), "x table post all ops");
test(0 == dkhash_check_table(tx), "x table consistency post all ops");
dkhash_debug_table(tx, 0);
r2 = t_end();
ret = r2 ? r2 : ret;
t_reset();
for (x = 0; x < 10; x++) {
sprintf(tmp, "string %d", x);
strs[x] = strdup(tmp);
}
t_start("dkhash single bucket add remove forward");
t = dkhash_create(1);
for (x = 0; x < 10; x++) {
dkhash_insert(t, strs[x], NULL, strs[x]);
}
for (x = 0; x < 10; x++) {
p1 = strs[x];
p2 = dkhash_remove(t, p1, NULL);
test(p1 == p2, "remove should return a value");
}
r2 = t_end();
ret = r2 ? r2 : ret;
t_reset();
t_start("dkhash single bucket add remove backward");
t = dkhash_create(1);
for (x = 0; x < 10; x++) {
dkhash_insert(t, strs[x], NULL, strs[x]);
}
for (x = 9; x; x--) {
p1 = strs[x];
p2 = dkhash_remove(t, p1, NULL);
test(p1 == p2, "remove should return a value");
}
dkhash_destroy(t);
r2 = t_end();
return r2 ? r2 : ret;
}
int main(int argc, char **argv)
{
squeue_t *sq;
struct timeval tv;
sq_test_event a, b, c, d, *x;
t_set_colors(0);
t_start("squeue tests");
a.id = 1;
b.id = 2;
c.id = 3;
d.id = 4;
gettimeofday(&tv, NULL);
/* Order in is a, b, c, d, but we should get b, c, d, a out. */
srand(tv.tv_usec ^ tv.tv_sec);
t((sq = squeue_create(1024)) != NULL);
t(squeue_size(sq) == 0);
/* we fill and empty the squeue completely once before testing */
sq_test_random(sq);
t(squeue_size(sq) == 0, "Size should be 0 after first sq_test_random");
t((a.evt = squeue_add(sq, time(NULL) + 9, &a)) != NULL);
t(squeue_size(sq) == 1);
t((b.evt = squeue_add(sq, time(NULL) + 3, &b)) != NULL);
t(squeue_size(sq) == 2);
t((c.evt = squeue_add_msec(sq, time(NULL) + 5, 0, &c)) != NULL);
t(squeue_size(sq) == 3);
t((d.evt = squeue_add_usec(sq, time(NULL) + 5, 1, &d)) != NULL);
t(squeue_size(sq) == 4);
/* add and remove lots. remainder should be what we have above */
sq_test_random(sq);
/* testing squeue_peek() */
t((x = (sq_test_event *)squeue_peek(sq)) != NULL);
t(x == &b, "x: %p; a: %p; b: %p; c: %p; d: %p\n", x, &a, &b, &c, &d);
t(x->id == b.id);
t(squeue_size(sq) == 4);
/* testing squeue_remove() and re-add */
t(squeue_remove(sq, b.evt) == 0);
t(squeue_size(sq) == 3);
t((x = squeue_peek(sq)) != NULL);
t(x == &c);
t((b.evt = squeue_add(sq, time(NULL) + 3, &b)) != NULL);
t(squeue_size(sq) == 4);
/* peek should now give us the &b event (again) */
t((x = squeue_peek(sq)) != NULL);
if (x != &b) {
printf("about to fail pretty f*****g hard...\n");
printf("ea: %p; &b: %p; &c: %p; ed: %p; x: %p\n",
&a, &b, &c, &d, x);
}
t(x == &b);
t(x->id == b.id);
t(squeue_size(sq) == 4);
/* testing squeue_pop(), lifo manner */
t((x = squeue_pop(sq)) != NULL);
t(squeue_size(sq) == 3,
"squeue_size(sq) = %d\n", squeue_size(sq));
t(x == &b, "x: %p; &b: %p\n", x, &b);
t(x->id == b.id, "x->id: %lu; d.id: %lu\n", x->id, d.id);
/* Test squeue_pop() */
t((x = squeue_pop(sq)) != NULL);
t(squeue_size(sq) == 2);
t(x == &c, "x->id: %lu; c.id: %lu\n", x->id, c.id);
t(x->id == c.id, "x->id: %lu; c.id: %lu\n", x->id, c.id);
/* this should fail gracefully (-1 return from squeue_remove()) */
t(squeue_remove(NULL, NULL) == -1);
t(squeue_remove(NULL, a.evt) == -1);
squeue_foreach(sq, sq_walker, NULL);
/* clean up to prevent false valgrind positives */
squeue_destroy(sq, 0);
return t_end();
}
void crack_wpa(char *fn)
{
hccap_t hc;
int res, i, itr;
unsigned char pmk[128];
unsigned char pke[100];
unsigned char ptk[80];
unsigned char mic[20];
char key[128]; // passphase 키값
int keylen;
memset(key,0,sizeof(key));
strcpy(key,"dekdekdek");
keylen = strlen(key);
// load from file
if((res = hccap_load(fn,&hc)))
{
printf("hashcat file load failed! code : %d\n",res);
return ;
}
memcpy( pke,"Pairwise key expansion", 23);
if(memcmp(hc.mac2,hc.mac1,6) < 0) {
memcpy( pke + 23, hc.mac2, 6);
memcpy( pke + 29, hc.mac1,6 );
} else {
memcpy(pke + 23, hc.mac1, 6);
memcpy(pke + 29, hc.mac2, 6);
}
if( memcmp( hc.nonce1,hc.nonce2, 32) < 0 ) {
memcpy(pke + 35, hc.nonce1,32);
memcpy(pke + 67, hc.nonce2,32);
}
else {
memcpy(pke + 35, hc.nonce2,32);
memcpy(pke + 67, hc.nonce1,32);
}
#pragma omp parallel
#pragma omp master
printf("Initializing ... %d/%d threads\n",omp_get_num_threads(),omp_get_max_threads());
prof_pmk(hc.essid);
return;
//#pragma omp parallel for private(i) shared(key,hc,pmk,pke,mic)
{
char key[16][128];
unsigned char pmk_sol[16][40];
unsigned char pmk_fast[16][40];
TIME_STRUCT p1;
int i,j;
for(i=0;i<16;i++)
{
strcpy(key[i],"atest");
key[i][0]+=i;
}
p1 = t_start();
#pragma omp parallel for
for(itr=0;itr<16000;itr+=16)
{
calc_16pmk(key,hc.essid,pmk_fast); //key값과 essid로부터 pmk 값을 계산함
//t_end(&p1);
// p2 = t_start();
for(i=0;i<4;i++)
{
pke[99] = i;
HMAC(EVP_sha1(), pmk, 32, pke, 100, ptk + i * 20, NULL);
}
if(hc.keyver == 1)
HMAC(EVP_md5(), ptk, 16,hc.eapol,hc.eapol_size,mic,NULL);
else
HMAC(EVP_sha1(), ptk, 16, hc.eapol,hc.eapol_size,mic,NULL);
// show_wpa_stats(key,keylen,pmk,ptk,mic);
if(memcmp(mic,hc.keymic,16) == 0)
{
// printf("success\n");
// return ;
}
// t_end(&p2);
}
t_end(&p1);
printf("time : %0.2lf ms\n",t_get(p1)/1000);
}
// printf("failed\n");
return;
}
int main(int argc, char **argv)
{
int ret, r2;
runcmd_init();
t_set_colors(0);
t_start("exec output comparison");
{
int i;
char *out = calloc(1, BUF_SIZE);
for (i = 0; cases[i].input != NULL; i++) {
memset(out, 0, BUF_SIZE);
int pfd[2] = {-1, -1}, pfderr[2] = {-1, -1};
/* We need a stub iobregarg since runcmd_open()'s prototype
* declares it attribute non-null. */
int stub_iobregarg = 0;
int fd;
char *cmd;
asprintf(&cmd, ECHO_COMMAND " -n %s", cases[i].input);
fd = runcmd_open(cmd, pfd, pfderr, NULL, stub_iobreg, &stub_iobregarg);
free(cmd);
read(pfd[0], out, BUF_SIZE);
ok_str(cases[i].output, out, "Echoing a command should give expected output");
close(pfd[0]);
close(pfderr[0]);
close(fd);
}
free(out);
}
ret = t_end();
t_reset();
t_start("anomaly detection");
{
int i;
for (i = 0; anomaly[i].cmd; i++) {
int out_argc;
char *out_argv[256];
int result = runcmd_cmd2strv(anomaly[i].cmd, &out_argc, out_argv);
ok_int(result, anomaly[i].ret, anomaly[i].cmd);
if (out_argv[0]) free(out_argv[0]);
}
}
r2 = t_end();
ret = r2 ? r2 : ret;
t_reset();
t_start("argument splitting");
{
int i;
for (i = 0; parse_case[i].cmd; i++) {
int x, out_argc;
char *out_argv[256];
int result = runcmd_cmd2strv(parse_case[i].cmd, &out_argc, out_argv);
/*out_argv[out_argc] = NULL;*//* This must be NULL terminated already. */
ok_int(result, parse_case[i].ret, parse_case[i].cmd);
ok_int(out_argc, parse_case[i].argc_exp, parse_case[i].cmd);
for (x = 0; x < parse_case[x].argc_exp && out_argv[x]; x++) {
ok_str(parse_case[i].argv_exp[x], out_argv[x], "argv comparison test");
}
if (out_argv[0]) free(out_argv[0]);
}
}
r2 = t_end();
return r2 ? r2 : ret;
}