void script_command_parser::add_script_command(std::string& input) {
std::transform(input.begin(), input.end(), input.begin(), ::tolower);
std::regex check_binary(".*b:.+?\\s(.+?)\\s.+");
std::smatch matches;
if (std::regex_match(input, matches, check_binary)) {
if (isscript_command((std::string)matches[1], script_command::Type::LEFT_RIGHT)) { return; }
script_command command = script_command(matches[1], script_command::Type::LEFT_RIGHT);
commands.push_back(command);
}
else {
std::regex check_unary(".*u:(.+)?\\s.+");
if (std::regex_match(input, matches, check_unary)) {
if (isscript_command((std::string)matches[1], script_command::Type::RIGHT)) { return; }
script_command command = script_command(matches[1], script_command::Type::RIGHT);
commands.push_back(command);
}
else {
std::regex check_null(".*n:(.+)");
if (std::regex_match(input, matches, check_null)) {
if (isscript_command((std::string)matches[1], script_command::Type::NONE)) { return; }
script_command command = script_command(matches[1], script_command::Type::NONE);
commands.push_back(command);
}
}
}
}
/*
* Extra a token from input.
* If TOKEN_ERROR, something bad has happened in the attempt to do so.
* Otherwise, this returns a valid token (possibly end of input).
*/
static enum token
tokenise(const char **v, char *buf, enum token lasttok)
{
size_t i, sz;
/* Short-circuit this case. */
if ('\0' == **v)
return(TOKEN_END);
/* Look for token in our predefined inputs. */
for (i = 0; i < TOK__MAX; i++)
if ('\0' != toks[i].key && **v == toks[i].key) {
switch (toks[i].arity) {
case (ARITY_NONE):
(*v)++;
return((enum token)i);
case (ARITY_ONE):
if ( ! check_unary(lasttok))
continue;
break;
case (ARITY_TWO):
if ( ! check_binary(lasttok))
continue;
break;
}
(*v)++;
return((enum token)i);
}
/* See if we're a real number or identifier. */
if (isdigit((int)**v) || '.' == **v) {
sz = 0;
for ( ; isdigit((int)**v) || '.' == **v; (*v)++) {
assert(sz < BUFSZ);
buf[sz++] = **v;
}
buf[sz] = '\0';
return(TOKEN_NUMBER);
} else if (isalpha((int)**v)) {
sz = 0;
for ( ; isalpha((int)**v); (*v)++) {
assert(sz < BUFSZ);
buf[sz++] = **v;
}
buf[sz] = '\0';
if (0 == strcmp(buf, "sqrt"))
return(TOKEN_SQRT);
else if (0 == strcmp(buf, "exp"))
return(TOKEN_EXPF);
}
/* Eh... */
return(TOKEN_ERROR);
}
expression make_binary(location loc, int binop, expression e1, expression e2)
{
expression result = CAST(expression, newkind_binary(parse_region, binop, loc, e1, e2));
result->type = check_binary(binop, e1, e2);
if (result->type != error_type)
{
result->cst = fold_binary(result->type, result);
}
/* XXX: The warn_parentheses stuff (and a <= b <= c) */
#if 0
unsigned_conversion_warning (result, arg1);
unsigned_conversion_warning (result, arg2);
overflow_warning (result);
#endif
return result;
}
void add_reserved_word(std::string input_) {
std::regex check_binary(".*b:.+?\\s(.+?)\\s.+");
std::smatch matches;
if (std::regex_match(input_, matches, check_binary)) {
reserved_words.insert(matches[1]);
}
else {
std::regex check_unary(".*u:(.+)?\\s.+");
if (std::regex_match(input_, matches, check_unary)) {
reserved_words.insert(matches[1]);
}
else {
std::regex check_null(".*n:(.+)");
if (std::regex_match(input_, matches, check_null)) {
reserved_words.insert(matches[1]);
}
}
}
script_command_parser::add_script_command(input_);
}
int
pocl_binary_check_binary(cl_device_id device, const unsigned char *binary)
{
return (check_binary(device, binary) != NULL);
}
int main(int argc, char **argv)
{
uid_t uid, euid;
pid_t pid, parent_pid;
gid_t gid;
int pipe_fds[2];
int err;
parent_pid = getpid ();
/* get real user and group ids, effective user id */
uid = getuid ();
gid = getgid ();
euid = geteuid ();
/* are we running suid root? */
if (uid != 0) {
if (euid != 0) {
fprintf (stderr, "jackstart: not running suid root, can't use capabilities\n");
fprintf (stderr, " (currently running with uid=%d and euid=%d),\n", uid, euid);
fprintf (stderr, " make jackstart suid root or start jackd directly\n\n");
}
}
/* see if we can get the required capabilities */
if (check_capabilities () == 0) {
size_t size;
cap_t cap = cap_init();
capgetp(0, cap);
fprintf (stderr, "jackstart: cannot get realtime capabilities, current capabilities are:\n");
fprintf (stderr, " %s\n", cap_to_text(cap, &size));
fprintf (stderr, " probably running under a kernel with capabilities disabled,\n");
fprintf (stderr, " a suitable kernel would have printed something like \"=eip\"\n\n");
}
/* check the executable, owner, permissions, md5 checksum */
if (check_binary(jackd_bin_path)) {
exit(1);
}
/* set process group to current pid */
if (setpgid (0, getpid())) {
fprintf (stderr, "jackstart: failed to set process group: %s\n",
strerror(errno));
exit (1);
}
/* create pipe to synchronize with jackd */
if (pipe (pipe_fds)) {
fprintf (stderr, "jackstart: could not create pipe: %s\n",
strerror(errno));
exit (1);
}
/* make sure the file descriptors are the right ones,
otherwise dup them, this is to make sure that both
jackstart and jackd use the same fds
*/
if (pipe_fds[0] != PIPE_READ_FD) {
if (dup2 (pipe_fds[0], PIPE_READ_FD) != PIPE_READ_FD) {
fprintf (stderr, "jackstart: could not dup pipe read file descriptor: %s\n",
strerror(errno));
exit (1);
}
}
if (pipe_fds[1] != PIPE_WRITE_FD) {
if (dup2(pipe_fds[1], PIPE_WRITE_FD)!=PIPE_WRITE_FD) {
fprintf (stderr, "jackstart: could not dup pipe write file descriptor: %s\n",
strerror(errno));
exit (1);
}
}
/* fork off a child to wait for jackd to start */
fflush(NULL);
pid = fork();
if (pid == -1) {
fprintf (stderr, "jackstart: fork failed\n");
exit (1);
}
if (pid) {
/* mother process: drops privileges, execs jackd */
close(PIPE_READ_FD);
/* get rid of any supplemental groups */
if (!getuid () && setgroups (0, 0)) {
fprintf (stderr, "jackstart: setgroups failed: %s\n", strerror(errno));
exit (1);
}
/* set gid and uid */
setregid(gid, gid);
setreuid(uid, uid);
execvp(jackd_bin_path, argv);
/* we could not start jackd, clean up and exit */
fprintf(stderr, "jackstart: unable to execute %s: %s\n", jackd_bin_path, strerror(errno));
close (PIPE_WRITE_FD);
wait (&err);
exit (1);
} else {
/* child process: grants privileges to jackd */
close(PIPE_WRITE_FD);
/* wait for jackd to start */
while (1) {
int ret;
char c;
/* picking up pipe closure is a tricky business.
this seems to work as well as anything else.
*/
ret = read(PIPE_READ_FD, &c, 1);
fprintf (stderr, "back from read, ret = %d errno == %s\n", ret, strerror (errno));
if (ret == 1) {
break;
} else if (errno != EINTR) {
break;
}
}
/* set privileges on jackd process */
give_capabilities (parent_pid);
}
exit (0);
}
int check_types_in_expr(ast_node root) {
symhashtable_t *hash = NULL;
symnode_t *node = NULL;
ast_node anode = NULL;
switch (root->node_type) {
case OP_ASSIGN_N:
//check_binary(root);
check_assignment(root);
break;
case OP_PLUS_N:
check_binary(root);
break;
case OP_MINUS_N:
check_binary(root);
break;
case OP_NEG_N:
check_unary(root);
break;
case OP_TIMES_N:
check_binary(root);
break;
case OP_DIVIDE_N:
check_binary(root);
break;
case OP_EQUALS_N:
check_binary(root);
break;
case OP_INCREMENT_N:
check_unary(root);
break;
case OP_DECREMENT_N:
check_unary(root);
break;
case OP_MODULUS_N:
check_binary(root);
break;
case OP_LESS_THAN_N:
check_binary(root);
break;
case OP_LESS_EQUAL_N:
check_binary(root);
break;
case OP_GREATER_THAN_N:
check_binary(root);
break;
case OP_GREATER_EQUAL_N:
check_binary(root);
break;
case OP_NOT_EQUAL_N:
check_binary(root);
break;
case OP_AND_N:
check_binary(root);
break;
case OP_OR_N:
check_binary(root);
break;
case OP_NOT_N:
check_unary(root);
break;
case RETURN_N:
check_unary(root);
break;
default:
// printf("at default of switch\n");
break;
}
/* Recurse on each child of the subtree root, with a depth one
greater than the root's depth. */
ast_node child;
for (child = root->left_child; child != NULL; child = child->right_sibling)
check_types_in_expr(child);
return 0;
}
int main (int argc, char *argv[], char *arge[]) {
if (argc < 2) {
print_usage();
return 0;
}
// check if argv[1] is a binary string
if (!check_binary(argv[1])) {
fprintf(stderr, "%s is not a binary string\n", argv[1]);
return -1;
}
// init rand()
srand(time(NULL));
// copy the argv[1] message
// calculate final message length
// so we don't need to realloc it everytime
int len = strlen(argv[1]);
int parity_len = 2;
for (int i = 0; i<=len; i++) {
//printf("t:%d - %s\n",t,power_of_2(t+1) ? "YES" : "NO");
parity_len++;
if (power_of_2(parity_len)) {
parity_len++;
}
}
printf("F2^%d -> F2^%d\n",len, parity_len-1);
char *message = (char*)malloc(parity_len*sizeof(char));
strncpy(message, argv[1], len+1);
// print the raw binary message
printf("[•] encoding '%s' (len:%d)\n",message,len);
// then add spaces for parity bits
// and calculate them
add_parity_space(message);
calculate_parity(message);
printf("[•] sent '%s' (len:%d)\n",message,(int)strlen(message));
// copy the message and alter one bit
char *bad = (char*)malloc(strlen(message)*sizeof(char));
strncpy(bad, message, strlen(message));
alter_a_bit(bad);
// print altered message
printf("[•] recieve '%s' (len:%d)\n",bad,(int)strlen(bad));
// check parity to correct the altered message
int *bad_bits = bad_parity(bad);
int i = 0, sum=0;
printf("[?] corrupted parity bits :");
while (bad_bits[i] != -1) {
sum+=bad_bits[i]+1;
printf(" %d",bad_bits[i]+1);
i++;
}
printf("\n");
printf("[?] fixed data bit at index %d\n",sum);
free(bad_bits);
// correct if necessary
if (sum>0) {
bad[sum-1] = (bad[sum-1] == '0') ? '1' : '0';
printf("[•] corrected '%s' (len:%d)\n",bad,(int)strlen(bad));
}else {
printf("[•] already_ok '%s' (len:%d)\n",bad,(int)strlen(bad));
}
// remove the parity bits
remove_parity_space(bad);
printf("[•] decoding '%s' (len:%d)\n",bad,(int)strlen(bad));
// compare with original message
printf("[•] %s\n",strncmp(argv[1],bad,len) == 0 ? "message successfully decoded" : "failed to decode message");
//printf(" in: '%s'\n",argv[1]);
//printf("out: '%s'\n",bad);
// free memory space
free(message);
free(bad);
return 0;
}
