static void
do_ne(enum size_tag size, gp_boolean is_const, int value, char *name)
{
switch (size) {
case size_bit:
assert(0);
break;
case size_uint8:
case size_int8:
case size_uint16:
case size_int16:
case size_uint24:
case size_int24:
case size_uint32:
case size_int32:
do_xor(size, is_const, value, name);
gen_boolean(size);
move_to_working(size);
break;
case size_float:
default:
assert(0);
}
}
static void
do_eq(enum size_tag size,
gp_boolean is_const,
int value,
char *name,
char *bank_addr)
{
switch (size) {
case size_bit:
assert(0);
break;
case size_uint8:
case size_int8:
case size_uint16:
case size_int16:
case size_uint24:
case size_int24:
case size_uint32:
case size_int32:
do_xor(size, is_const, value, name, bank_addr);
gen_boolean(size);
codegen_write_asm("xorlw 1");
move_to_working(size);
break;
case size_float:
default:
assert(0);
}
}
void Crypter::doXor()
{
for(int i = 0; i < w.size(); i++) {
int r = do_xor(w.at(i).toAscii(), i);
if(r) {
w[i] = QChar(r);
}
}
}
/*
recv_msg_421
id = mailbox ID number
msg - unsigned char array in user space
n = maximum number of bytes
key = encryption key
Finds the first message in mailbox with ID and performs
the XOR cipher on it then copies it to user space.
Returns number of bytes copied, which is less than or
equal to n.
*/
asmlinkage long sys_recv_msg_421(unsigned long id, unsigned char* msg, unsigned long n, unsigned long key){
mbox* itr = mbox_list;
unsigned long not_copied = n;
unsigned long num_bytes = n;
mbox_msg* temp;
spin_lock(&xor_lock);
//Find our mailbox
while(itr != NULL){
if(itr->id_num == id){
//printk("recv: found mailbox\n");
//If there are any messages
if(itr->msg_count > 0){
//printk("recv: exists a message of length%d\n", itr->first->length);
temp = itr->first;
//Perform the XOR
//printk("recv before xor: %.*s\n", temp->length, temp->msg);
do_xor(temp->msg, key, temp->length);
//printk("recv after xor: %.*s\n", temp->length, temp->msg);
itr->first = itr->first->next;
itr->msg_count--;
if(itr->msg_count == 0)
itr->last = NULL;
//Find min between n and msg length
if(temp->length < n)
num_bytes = temp->length;
//Attempt to copy to user space, then delete in kernel space
//printk("recv: Attempting to copy %d bytes\n", num_bytes);
not_copied = copy_to_user(msg, temp->msg, num_bytes);
//Checking for not null just to be safe
if(temp->msg != NULL)
kfree(temp->msg);
if(temp != NULL)
kfree(temp);
}
}
itr = itr->next;
}
spin_unlock(&xor_lock);
//Return the number successfully copied
return (num_bytes - not_copied);
}
void run_scu_operation(machinecode *program, int *pc, int *convert, union bit *reg) {
switch(program[*pc].opcode) {
case 0: /* set reg */
reg_set(reg, program[*pc].dr, reg_ref(reg,program[*pc].sr2,convert), convert);
(*pc)++;
break;
case (0 + IMD_SIZE): /* set imd */
reg_set(reg, program[*pc].dr, program[*pc].imd, convert);
(*pc)++;
break;
case 1: /* + reg */
reg_set(reg, program[*pc].dr, do_plus(reg_ref(reg,program[*pc].sr1,convert),reg_ref(reg,program[*pc].sr2,convert)), convert);
(*pc)++;
break;
case (1 + IMD_SIZE): /* + imd */
reg_set(reg, program[*pc].dr, do_plus(reg_ref(reg,program[*pc].sr1,convert),program[*pc].imd), convert);
(*pc)++;
break;
case 2: /* - reg */
reg_set(reg, program[*pc].dr, do_minus(reg_ref(reg,program[*pc].sr1,convert),reg_ref(reg,program[*pc].sr2,convert)), convert);
(*pc)++;
break;
case (2 + IMD_SIZE): /* - imd */
reg_set(reg, program[*pc].dr, do_minus(reg_ref(reg,program[*pc].sr1,convert),program[*pc].imd), convert);
(*pc)++;
break;
case 3: /* xor reg */
reg_set(reg, program[*pc].dr, do_xor(reg_ref(reg,program[*pc].sr1,convert),reg_ref(reg,program[*pc].sr2,convert)), convert);
(*pc)++;
break;
case (3 + IMD_SIZE): /* xor imd */
reg_set(reg, program[*pc].dr, do_xor(reg_ref(reg,program[*pc].sr1,convert),program[*pc].imd), convert);
(*pc)++;
break;
case 4: /* or reg */
reg_set(reg, program[*pc].dr, do_or(reg_ref(reg,program[*pc].sr1,convert),reg_ref(reg,program[*pc].sr2,convert)), convert);
(*pc)++;
break;
case (4 + IMD_SIZE): /* or imd */
reg_set(reg, program[*pc].dr, do_or(reg_ref(reg,program[*pc].sr1,convert),program[*pc].imd), convert);
(*pc)++;
break;
case 5: /* and reg */
reg_set(reg, program[*pc].dr, do_and(reg_ref(reg,program[*pc].sr1,convert),reg_ref(reg,program[*pc].sr2,convert)), convert);
(*pc)++;
break;
case (5 + IMD_SIZE): /* adn imd */
reg_set(reg, program[*pc].dr, do_and(reg_ref(reg,program[*pc].sr1,convert),program[*pc].imd), convert);
(*pc)++;
break;
case 6: /* not reg */
reg_set(reg, program[*pc].dr, do_not(reg_ref(reg,program[*pc].sr2,convert)), convert);
(*pc)++;
break;
case (6 + IMD_SIZE): /* not imd */
reg_set(reg, program[*pc].dr, do_not(program[*pc].imd), convert);
(*pc)++;
break;
default:
fprintf(stderr, "%2x : unknown instruction\n", (program[*pc].info)+(program[*pc].opcode));
exit(EXIT_FAILURE);
}
}
static void
codegen14(enum node_op op,
enum size_tag size,
gp_boolean is_const,
int value,
char *name)
{
switch (op) {
case op_assign:
assert(0);
break;
case op_add:
do_add(size, is_const, value, name);
break;
case op_sub:
do_sub(size, is_const, value, name);
break;
case op_neg:
do_neg(size, is_const, value, name);
break;
case op_com:
do_com(size, is_const, value, name);
break;
case op_and:
do_and(size, is_const, value, name);
break;
case op_or:
do_or(size, is_const, value, name);
break;
case op_xor:
do_xor(size, is_const, value, name);
break;
case op_not:
do_not(size, is_const, value, name);
break;
case op_lsh:
do_lsh(size, is_const, value, name);
break;
case op_rsh:
do_rsh(size, is_const, value, name);
break;
case op_land:
do_and(size_uint8, is_const, value, name);
break;
case op_lor:
do_or(size_uint8, is_const, value, name);
break;
case op_eq:
do_eq(size, is_const, value, name);
break;
case op_ne:
do_ne(size, is_const, value, name);
break;
case op_lt:
do_lt(size, is_const, value, name);
break;
case op_lte:
do_lte(size, is_const, value, name);
break;
case op_gt:
case op_gte:
/* This is replaced in the optimizer.*/
assert(0);
break;
case op_mult:
do_mult(size, is_const, value, name);
break;
case op_div:
do_div(size, is_const, value, name);
break;
case op_mod:
do_mod(size, is_const, value, name);
break;
case op_clr:
case op_inc:
case op_dec:
/* Shoud use unopgen14.*/
assert(0);
break;
default:
assert(0); /* Unhandled binary operator */
}
}
/*
send_msg_421
id = mailbox id number
msg = character array in user space to put in mailbox
n = the number of bytes(characters) to send
key = the encryption key to use
Creates a new message and attaches it to the end of
the list of messages in mailbox for ID. Copies
msg from user space to kernel space and performs
the XOR cipher on it using the given key.
Returns number of bytes stored, which should be equal
to n.
*/
asmlinkage long sys_send_msg_421(unsigned long id, unsigned char* msg, unsigned long n, unsigned long key){
unsigned char* in_kernel;
unsigned long num_bytes;
mbox* itr;
mbox_msg* temp;
//Obtain lock
spin_lock(&xor_lock);
//Allocated kernel buffer for message
in_kernel = kmalloc((sizeof(unsigned char)*n), GFP_KERNEL);
//Return 0 bytes if no memory available
if(in_kernel == NULL){
spin_unlock(&xor_lock);
return -ENOMEM;
}
num_bytes = 0;
itr = mbox_list;
//Try to find our mailbox
while(itr != NULL){
//If this mailbox exists, add the message
if(itr->id_num == id){
//Copy message to kernel space
num_bytes = copy_from_user(in_kernel, msg, n);
//printk("copy_from_user copied %li bytes\n", num_bytes);
//Perform the XOR
//printk("send before xor: %.*s\n", num_bytes, in_kernel);
do_xor(in_kernel, key, (n-num_bytes));
//printk("send: after xor %.*s\n", num_bytes, in_kernel);
//Allocate space for a message, return
//0 bytes if out of memory
temp = kmalloc(sizeof(mbox_msg), GFP_KERNEL);
if(temp == NULL){
spin_unlock(&xor_lock);
return -ENOMEM;
}
temp->msg = in_kernel;
temp->length = (n-num_bytes);
temp->next = NULL;
if(itr->first == NULL){
//printk("send: inserting head with %d length\n", temp->length);
itr->first = temp;
}
if(mbox_list->last != NULL)
mbox_list->last->next = temp;
mbox_list->last = temp;
itr->msg_count++;
}
itr = itr->next;
}
spin_unlock(&xor_lock);
return (n-num_bytes);
}
