// display the current galois
void galois_show() {
printf("\n");
printf("b_n = ");
int first = 1;
for (int i=0;i<64;i++) {
if (BIT(i,galois_taps) == 1) {
if (first == 0) printf("+ ");
printf("b_n-%d ", i+1);
first = 0;
}
}
printf("(taps: "); print_bin(galois_taps,galois_size); printf(")\n");
printf("\n");
printf("current state: 0x%lx (", galois_state);
print_bin(galois_state,galois_size);printf(")\n");
printf("\n");
}
void print_memory(const void *addr, size_t size)
{
unsigned int i;
i = 0;
while (addr && i < size)
{
print_bin(addr, i, size);
ft_putchar2(' ');
print_dump(addr, i, size);
ft_putchar2('\n');
i += 16;
}
}
int main(void){
print_bin(32);
/* for (int count = 0 ; count < 32;count ++){
int number = (1<<count);
int valor = 0;
printf("%d\t",number);
for (int count_bin = 0 ;count_bin < 32 ; count_bin ++){
valor=number&(1<<(31-count_bin));
printf("%d",valor>0?1:0);
}
printf("\n");
}
*/
}
static void do_rev () {
unsigned int v = 219; // input bits to be reversed
print_bin(v);
unsigned int r = v; // r will be reversed bits of v; first get LSB of v
int s = sizeof(v) * CHAR_BIT - 1; // extra shift needed at end
//
// for (v >>= 1; v; v >>= 1)
// {
// r <<= 1;
// r |= v & 1;
// s--;
// }
while(v) {
v >>= 1; //TODO:Use this method for rotation (n rotation) n times or O.M. use left_shift | right_shift(K-n)
//K = total bits and n = no of rotation.
r <<= 1;
r |= v & 1; //get only one bit of v every time/
s--;
}
r <<= s; // shift when v's highest bits are zero
printf("%d \n",r);
print_bin(r);
}
void print_value_vakje(Sudoku* s, int r, int k){
SudokuVakje *vakje=NULL;
vakje = &(s->gegevens[r-1][k-1]);
if(vakje->gevonden == T){
printf("gevonden: (%i,%i)=%i\n", r,k, vakje->inhoud);
}else{
printf("nog niet gevoden\n");
print_bin_Header(); printf("\n");
print_bin(vakje->inhoud);printf("\n");
}
}
static ssize_t vmnet_skyeye_write(struct file *file, const char __user *data, size_t len, loff_t *ppos)
{
vmnet_private *my_vmnet_private = NULL;
uint8_t *mac_addr = data + mac_addr_offset;
uint8_t *mac_saddr = data + mac_saddr_offset;
uint8_t mac_broadcast[6] = {0xff,0xff,0xff,0xff,0xff,0xff};
print_bin_with_name("skyeye_write mac_taddr", mac_addr ,6);
print_bin_with_name("skyeye_write mac_saddr", mac_saddr ,6);
print_bin(data,len);
if(vmnet_mac_match(mac_addr, mac_broadcast) == 0)
{
printk("this is broadcast\n");
vmnet_data *vmnet_data_new = kmalloc(sizeof(vmnet_data), GFP_KERNEL);
vmnet_data_new->data = (uint8_t *)kmalloc(len, GFP_KERNEL);
vmnet_data_new->length = len;
vmnet_data_new->next = NULL;
if(copy_from_user(vmnet_data_new->data, data, vmnet_data_new->length))
{
printk("write:error in write\n");
}
add_broad_to_vmnet_private(vmnet_private_head, vmnet_data_new, mac_saddr);
return 0;
}
if((my_vmnet_private = search_vmnet_private(vmnet_private_head,mac_addr)) == NULL)
{
printk("write:can not find src vmnet\n");
return 0;
}
//printk("search my_vmnet_private %p\n",my_vmnet_private);
vmnet_data *vmnet_data_head = my_vmnet_private->vmnet_data_head;
vmnet_data *vmnet_data_new = kmalloc(sizeof(vmnet_data), GFP_KERNEL);
vmnet_data_new->data = (uint8_t *)kmalloc(len, GFP_KERNEL);
vmnet_data_new->length = len;
vmnet_data_new->next = NULL;
if(copy_from_user(vmnet_data_new->data, data, vmnet_data_new->length))
{
printk("write:error in write\n");
}
printk("vmnet_skyeye_write\n");
//add_to_vmnet_data(&vmnet_data_head, vmnet_data_new);
add_to_vmnet_data(&my_vmnet_private->vmnet_data_head, vmnet_data_new);
return 0;
}
/**
* Método usado para mostrar os BINs que foram criados na lista de BINs.
* Percorre a lista de BINs e para cada BIN exibe os números que existem nele,
* Assim como o espaço restante "left" e outras informações.
*
* \param bins Lista de BINs para imprimir.
* \see print_bin
*/
int print_list_bins (bin_list *bins)
{
unsigned short int i;
/**
* Percorre os elementos que existem na lista de BINs e para cada um deles
* Chama a função que imprime o BIN.
*/
for (i = 0; i < bins->count; i++)
{
bin *aux = (bins->itens + i);
printf(" {%04d} ", i);
print_bin(aux);
}
printf("\n\n");
return 0;
}
int main() {
student john;
//john->first = "John";
strcpy(john.first, "John");
printf("Name:\t%s\n", john.first);
printf("Size:\t%zu\n", sizeof(john.first));
printf("Address:\t%p\n\n", &john.first);
printf("Address of struct:\t%p\n", &john);
printf("Size of struct:\t%zu\n", sizeof(&john));
printf("Binary of 5: ");
print_bin(5);
return 0;
}
int main(void) {
char x, y;
// 0bXX notation is a GNU extension (https://gcc.gnu.org/onlinedocs/gcc/Binary-constants.html)
x = 0b00011010;
y = 0b00000011;
printf("x:\n");
print_bin(x);
printf("y:\n");
print_bin(y);
// AND
printf("LOGICAL AND: x&y\n");
print_bin(x&y);
// OR
printf("LOGICAL OR: x|y\n");
print_bin(x|y);
// XOR
printf("LOGICAL XOR: x^y\n");
print_bin(x^y);
// NOT
printf("LOGICAL NOT: ~x\n");
print_bin(~x);
// LEFT SHIFT (1 BIT)
printf("LEFT SHIFT (1 BIT): x<<1\n");
print_bin(x<<1);
// RIGHT SHIFT (1 BIT)
printf("RIGHT SHIFT (1 BIT): x>>1\n");
print_bin(x>>1);
// LEFT SHIFT (2 BIT)
printf("LEFT SHIFT (2 BIT): x<<2\n");
print_bin(x<<2);
// RIGHT SHIFT (2 BIT)
printf("RIGHT SHIFT (2 BIT): x>>2\n");
print_bin(x>>2);
// SET A BIT ////////////////////////////////
int N, M;
printf("x:\n");
print_bin(x);
// SET THE Nth BIT OF x TO 1
N = 2;
printf("SET THE Nth BIT OF x TO 1 (WITH HERE N=2 IE THE THIRD BIT)\n");
printf("- LONG VERSION: x = x | (1<<N)\n");
printf("- SHORT VERSION: x |= (1<<N)\n");
printf("USUALLY, x IS PORTB, PORTC or PORTD\n");
print_bin(x | (1<<N));
// SET THE Nth BIT OF x TO 0
N = 3;
printf("SET THE Nth BIT OF x TO 0 (WITH HERE N=3 IE THE FOURTH BIT)\n");
printf("- LONG VERSION: x = x & ~(1<<N)\n");
printf("- SHORT VERSION: x &= ~(1<<N)\n");
printf("USUALLY, x IS PORTB, PORTC or PORTD\n");
print_bin(x & ~(1<<N));
// SET THE Nth AND THE Mth BIT OF x TO 1
N = 2;
M = 0;
printf("SET THE Nth AND THE Mth BIT OF x TO 1 (WITH HERE N=2 IE THE THIRD BIT AND M=0 IE THE FIRST BIT)\n");
printf("- LONG VERSION: x = x | ( (1<<N)|(1<<M) )\n");
printf("- SHORT VERSION: x |= (1<<N)|(1<<M)\n");
printf("USUALLY, x IS PORTB, PORTC or PORTD\n");
print_bin(x | ( (1<<N)|(1<<M) ));
// SET THE Nth AND THE Mth BIT OF x TO 0
N = 3;
M = 1;
printf("SET THE Nth AND THE Mth BIT OF x TO 0 (WITH HERE N=3 IE THE FOURTH BIT AND M=1 IE THE SECOND BIT)\n");
printf("- LONG VERSION: x = x & ~( (1<<N)|(1<<M) )\n");
printf("- SHORT VERSION: x &= ~( (1<<N)|(1<<M) )\n");
printf("USUALLY, x IS PORTB, PORTC or PORTD\n");
print_bin(x & ~( (1<<N)|(1<<M) ));
// TEST A BIT ///////////////////////////////
printf("x:\n");
print_bin(x);
// TEST THE Nth BIT OF x
N = 2;
printf("TEST THE Nth BIT OF x (WITH HERE N=2 IE THE THIRD BIT)\n");
printf("res = x & (1<<N)\n");
printf("USUALLY, x IS PORTB, PORTC or PORTD\n");
if(x & (1<<N)) printf(">>> true\n");
else printf(">>> false\n");
printf("\n");
// TOGGLE A BIT /////////////////////////////
printf("x:\n");
print_bin(x);
// TOGGLE THE Nth BIT OF x
N = 2;
printf("TOGGLE THE Nth BIT OF x (WITH HERE N=2 IE THE THIRD BIT)\n");
printf("- LONG VERSION: x = x ^ (1<<N)\n");
printf("- SHORT VERSION: x ^= (1<<N)\n");
printf("USUALLY, x IS PORTB, PORTC or PORTD\n");
print_bin(x ^ (1<<N));
// TOGGLE THE Nth AND THE Mth BIT OF x
N = 2;
M = 1;
printf("TOGGLE THE Nth AND THE Mth BIT OF x (WITH HERE N=2 IE THE THIRD BIT AND M=1 IE THE SECOND BIT)\n");
printf("- LONG VERSION: x = x ^ ( (1<<N)|(1<<M) )\n");
printf("- SHORT VERSION: x ^= (1<<N)|(1<<M)\n");
printf("USUALLY, x IS PORTB, PORTC or PORTD\n");
print_bin(x ^ ( (1<<N)|(1<<M) ));
return 0;
}
int main(int argc, char *argv[])
{
printf("MISD assembler, version 1.00. Copyright: Bauman State Technical University\n");
printf("Usage: misdasm [options] asm_file [output_file] [map_file]\n");
printf("Options: -m - Generate map file\n");
if (argc > 1) {
if (argv[1]=='-m'){
make_map=true;
} else {
make_map=false;
asm_filename=argv[1];
asm_file = fopen(asm_filename, "r");
if (asm_file == NULL) {
printf("Failure to open asm file.");
exit(EXIT_FAILURE);
}
}
} else {
printf("Error in argument list\n");
exit(EXIT_FAILURE);
}
/////////////////////////////////////////
// Try to open files
/////////////////////////////////////////
if (argc > 2) {
strcpy(output_filename,argv[2]);
} else {
chr = strchr(asm_filename, '.');
if (chr==NULL) {
strncat(output_filename,asm_filename,strlen(asm_filename));
strcpy(map_filename,output_filename);
strncat(output_filename,".mo",3);
strncat(map_filename,".map",4);
} else {
strncpy(output_filename, asm_filename,(int)chr-(int)asm_filename);
strcpy(map_filename,output_filename);
strncat(output_filename,".mo",3);
strncat(map_filename,".map",4);
}
}
output_file = fopen(output_filename, "w");
if (output_file == NULL) {
printf("Failure to open output file.");
exit(EXIT_FAILURE);
}
if (make_map) {
if (argc > 3) {
strcpy(map_filename[0],argv[3]);
}
map_file = fopen(map_filename, "rw");
if (output_file == NULL) {
printf("Failure to open map file.");
exit(EXIT_FAILURE);
}
}
/////////////////////////////////////////
// Start to translate
/////////////////////////////////////////
//Memory point
mem_point = 0;
//New opcode is ready
new_opcode = false;
s=0; //string number
//Create program image
while (!feof(asm_file)) {
line[0]='\0';
fgets(line, LINE_SIZE, asm_file);
//Try to find comments
j = (int)strchr(line,';')-(int)&line;
if (j>=0) {line[j]='\0';}
//Search spaces
i=0; //translation pointer
while ((line[i]==' ')||(line[i]=='\t')) {
i++;
}
//Try to find label
j = (int)strchr(line+i,' ')-(int)&line;
if (j<0) {j=strlen(line);}
k = (int)strchr(line+i,':')-(int)&line;
if ((j>=k)&&(k>=0)) {
strncpy(prog[mem_point].label,line+i,k-i);
i=k+1;
}
while (((line[i]==' ')||(line[i]=='\t'))&&(line[i]!='\0')) {
i++;
}
//Try to find opcode
j = (int)strchr(line+i,' ')-(int)&line;
if (j>0) {
if ((j-i)>10) {
printf("Error in string [%d] near: %s\n",s,line+i);
exit(EXIT_FAILURE);
}
strncpy(opcode,line+i,j-i);
opcode[j-i]='\0';
i=j;
new_opcode = true;
prog[mem_point].tag[0]=true;
prog[mem_point].tag[1]=true;
prog[mem_point].tag[2]=true;
op_count = 0;
//printf("%s\n",prog[mem_point].opcode);
if (strcmp(opcode,"add")==0) {
prog[mem_point].opcode=ADD;
op_count=ADD_C;
prog[mem_point].q=false;
}
if (strcmp(opcode,"del")==0) {
prog[mem_point].opcode=DEL;
op_count=DEL_C;
prog[mem_point].q=false;
}
if (strcmp(opcode,"search")==0) {
prog[mem_point].opcode=SEARCH;
op_count=SEARCH_C;
prog[mem_point].q=false;
}
if (strcmp(opcode,"min")==0) {
prog[mem_point].opcode=MIN;
op_count=MIN_C;
prog[mem_point].q=false;
}
if (strcmp(opcode,"max")==0) {
prog[mem_point].opcode=MAX;
op_count=MAX_C;
prog[mem_point].q=false;
}
if (strcmp(opcode,"power")==0) {
prog[mem_point].opcode=POWER;
op_count=POWER_C;
prog[mem_point].q=true; //power is queued mandatory
}
if (strcmp(opcode,"dels")==0) {
prog[mem_point].opcode=DELS;
op_count=DELS_C;
prog[mem_point].q=false;
}
if (strcmp(opcode,"and")==0) {
prog[mem_point].opcode=AND;
op_count=AND_C;
prog[mem_point].q=false;
}
if (strcmp(opcode,"or")==0) {
prog[mem_point].opcode=OR;
op_count=OR_C;
prog[mem_point].q=false;
}
if (strcmp(opcode,"not")==0) {
prog[mem_point].opcode=NOT;
op_count=NOT_C;
prog[mem_point].q=false;
}
if (strcmp(opcode,"gr")==0) {
prog[mem_point].opcode=GR;
op_count=GR_C;
prog[mem_point].q=false;
}
if (strcmp(opcode,"greq")==0) {
prog[mem_point].opcode=GREQ;
op_count=GREQ_C;
prog[mem_point].q=false;
}
if (strcmp(opcode,"ls")==0) {
prog[mem_point].opcode=LS;
op_count=LS_C;
prog[mem_point].q=false;
}
if (strcmp(opcode,"lseq")==0) {
prog[mem_point].opcode=LSEQ;
op_count=LSEQ_C;
prog[mem_point].q=false;
}
if (strcmp(opcode,"sq")==0) {
prog[mem_point].opcode=SQUIZ;
op_count=SQUIZ_C;
prog[mem_point].q=false;
}
if (strcmp(opcode,"jwt")==0) {
prog[mem_point].opcode=JWT;
op_count=JWT_C;
prog[mem_point].tag[0]=false;
}
if (strcmp(opcode,"jnw")==0) {
prog[mem_point].opcode=JNW;
op_count=JNW_C;
prog[mem_point].tag[0]=true;
}
//for queueing commands
if (strcmp(opcode,"addq")==0) {
prog[mem_point].opcode=ADD;
op_count=ADD_C;
prog[mem_point].q=true;
}
if (strcmp(opcode,"delq")==0) {
prog[mem_point].opcode=DEL;
op_count=DEL_C;
prog[mem_point].q=true;
}
if (strcmp(opcode,"searchq")==0) {
prog[mem_point].opcode=SEARCH;
op_count=SEARCH_C;
prog[mem_point].q=true;
}
if (strcmp(opcode,"minq")==0) {
prog[mem_point].opcode=MIN;
op_count=MIN_C;
prog[mem_point].q=true;
}
if (strcmp(opcode,"maxq")==0) {
prog[mem_point].opcode=MAX;
op_count=MAX_C;
prog[mem_point].q=true;
}
if (strcmp(opcode,"powerq")==0) {
prog[mem_point].opcode=POWER;
op_count=POWER_C;
prog[mem_point].q=true;
}
if (strcmp(opcode,"delsq")==0) {
prog[mem_point].opcode=DELS;
op_count=DELS_C;
prog[mem_point].q=true;
}
if (strcmp(opcode,"andq")==0) {
prog[mem_point].opcode=AND;
op_count=AND_C;
prog[mem_point].q=true;
}
if (strcmp(opcode,"orq")==0) {
prog[mem_point].opcode=OR;
op_count=OR_C;
prog[mem_point].q=true;
}
if (strcmp(opcode,"notq")==0) {
prog[mem_point].opcode=NOT;
op_count=NOT_C;
prog[mem_point].q=true;
}
if (strcmp(opcode,"grq")==0) {
prog[mem_point].opcode=GR;
op_count=GR_C;
prog[mem_point].q=true;
}
if (strcmp(opcode,"greqq")==0) {
prog[mem_point].opcode=GREQ;
op_count=GREQ_C;
prog[mem_point].q=true;
}
if (strcmp(opcode,"lsq")==0) {
prog[mem_point].opcode=LS;
op_count=LS_C;
prog[mem_point].q=true;
}
if (strcmp(opcode,"lseqq")==0) {
prog[mem_point].opcode=LSEQ;
op_count=LSEQ_C;
prog[mem_point].q=true;
}
if (strcmp(opcode,"sqq")==0) {
prog[mem_point].opcode=SQUIZ;
op_count=SQUIZ_C;
prog[mem_point].q=true;
}
if (op_count==0) {
printf("Unknown opcode in string [%d] near: %s\n",s,line+i);
exit(EXIT_FAILURE);
}
//try to find ops
for (k=0;k<op_count;k++) {
while ((line[i]==' ')||(line[i]=="\t")) i++;
if (i>=strlen(line)) {
printf("Operands are not corresponds to opcode in string [%d]\n",s);
exit(EXIT_FAILURE);
}
j = (int)strchr(line+i,' ')-(int)&line;
l = (int)strchr(line+i,',')-(int)&line;
//find minimum positive
if (j<0) {j=strlen(line);}
if ((l>0)&&(l<j)) {j=l;}
if (j<=i) {
printf("Operands are not corresponds to opcode in string [%d]\n",s);
exit(EXIT_FAILURE);
}
if (prog[mem_point].opcode==JWT) {
if (prog[mem_point].tag[0]) {
// if jnw
strncpy(prog[mem_point].jmp_label,line+i,j-i);
l = (int)strchr(prog[mem_point].jmp_label,'\t')-(int)&(prog[mem_point].jmp_label);
if (l>=0) {prog[mem_point].jmp_label[l]='\0';}
l = (int)strchr(prog[mem_point].jmp_label,' ')-(int)&(prog[mem_point].jmp_label);
if (l>=0) {prog[mem_point].jmp_label[l]='\0';}
if (prog[mem_point].jmp_label[0]=='?') {
printf("JNW command should have operand in string [%d]\n",s);
exit(EXIT_FAILURE);
} else {
prog[mem_point].tag[1] = true;
}
} else {
// if jwt
strncpy(prog[mem_point].jmp_label,line+i,j-i);
l = (int)strchr(prog[mem_point].jmp_label,'\t')-(int)&(prog[mem_point].jmp_label);
if (l>=0) {prog[mem_point].jmp_label[l]='\0';}
l = (int)strchr(prog[mem_point].jmp_label,' ')-(int)&(prog[mem_point].jmp_label);
if (l>=0) {prog[mem_point].jmp_label[l]='\0';}
if (prog[mem_point].jmp_label[0]=='?') {
prog[mem_point].tag[1] = false;
} else {
prog[mem_point].tag[1] = true;
}
}
prog[mem_point].tag[2] = true;
} else {
//if a number
strncpy(operand,line+i,j-i);
if (operand[0]=='?') {
prog[mem_point].tag[k] = false;
} else {
prog[mem_point].op[k] = atoi(operand);
prog[mem_point].tag[k] = true;
}
}
i=j+1;
}
if (new_opcode) {
new_opcode = false;
mem_point++;
opcode[0]='\0';
}
}
s++;
}
//Solve internal links
for (i=0; i<mem_point; i++) {
if ((prog[i].opcode==JWT)&&(prog[i].jmp_label[0]!='?')) {
flag=false;
for (j=0; j<mem_point; j++) {
if (strcmp(prog[i].jmp_label,prog[j].label)==0) {
prog[i].jmp_adr=j;
flag=true;
}
}
if (!flag) {
printf("Jump address unknown in string [%s]\n",prog[i].jmp_label);
exit(EXIT_FAILURE);
}
}
}
//Make output bit file
for (i=0; i<mem_point; i++) {
switch (prog[i].opcode) {
// format 1
case DELS: case MAX: case MIN: case POWER: case SQUIZ: {
print_bin(0,32);
print_bin(0,32);
//queue
if (prog[i].q) {
print_bin(1,1);
} else {
print_bin(0,1);
}
print_bin(prog[i].op[0],7);
print_bin(prog[i].opcode,5);
for (j=2;j>=0;j--) {
if (prog[i].tag[j]) {
print_bin(1,1);
} else {
print_bin(0,1);
}
}
fprintf(output_file,"\n");
break;
}
// format 2
case DEL: case SEARCH: {
print_bin(0,32);
print_bin(prog[i].op[1],32);
//queue
if (prog[i].q) {
print_bin(1,1);
} else {
print_bin(0,1);
}
print_bin(prog[i].op[0],7);
print_bin(prog[i].opcode,5);
for (j=2;j>=0;j--) {
if (prog[i].tag[j]) {
print_bin(1,1);
} else {
print_bin(0,1);
}
}
fprintf(output_file,"\n");
break;
}
// format 3
case ADD: {
print_bin(prog[i].op[2],32);
print_bin(prog[i].op[1],32);
//queue
if (prog[i].q) {
print_bin(1,1);
} else {
print_bin(0,1);
}
print_bin(prog[i].op[0],7);
print_bin(prog[i].opcode,5);
for (j=2;j>=0;j--) {
if (prog[i].tag[j]) {
print_bin(1,1);
} else {
print_bin(0,1);
}
}
fprintf(output_file,"\n");
break;
}
// format 4
case AND: case OR: case NOT: {
print_bin(0,32);
print_bin(0,16);
print_bin(prog[i].op[2],8);
print_bin(prog[i].op[1],8);
//queue
if (prog[i].q) {
print_bin(1,1);
} else {
print_bin(0,1);
}
print_bin(prog[i].op[0],7);
print_bin(prog[i].opcode,5);
for (j=2;j>=0;j--) {
if (prog[i].tag[j]) {
print_bin(1,1);
} else {
print_bin(0,1);
}
}
fprintf(output_file,"\n");
break;
}
// format 5
case LS: case LSEQ: case GR: case GREQ: {
print_bin(0,24);
print_bin(prog[i].op[2],32);
print_bin(prog[i].op[1],8);
//queue
if (prog[i].q) {
print_bin(1,1);
} else {
print_bin(0,1);
}
print_bin(prog[i].op[0],7);
print_bin(prog[i].opcode,5);
for (j=2;j>=0;j--) {
if (prog[i].tag[j]) {
print_bin(1,1);
} else {
print_bin(0,1);
}
}
fprintf(output_file,"\n");
break;
}
// format 6
case JNW: {
print_bin(0,32);
print_bin(0,8);
print_bin(prog[i].jmp_adr,32);
print_bin(prog[i].opcode,5);
for (j=2;j>=0;j--) {
if (prog[i].tag[j]) {
print_bin(1,1);
} else {
print_bin(0,1);
}
}
fprintf(output_file,"\n");
break;
}
}
}
for (i=mem_point; i<255; i++) {
for (j=0; j<80; j++) {
fprintf(output_file,"0");
}
fprintf(output_file,"\n");
}
//Important! For ISE to avoid BRAM packing!!!
fprintf(output_file,"11011100101110111100010011010101111001101111011111101110010111011110001001101010");
//Make a map file
/////////////////////////////////////////
// Try to close files
/////////////////////////////////////////
fclose(asm_file);
fclose(output_file);
if (make_map) {
fclose(map_file);
}
return 0;
}
int
ECPKParameters_print(BIO * bp, const EC_GROUP * x, int off)
{
unsigned char *buffer = NULL;
size_t buf_len = 0, i;
int ret = 0, reason = ERR_R_BIO_LIB;
BN_CTX *ctx = NULL;
const EC_POINT *point = NULL;
BIGNUM *p = NULL, *a = NULL, *b = NULL, *gen = NULL, *order = NULL,
*cofactor = NULL;
const unsigned char *seed;
size_t seed_len = 0;
const char *nname;
static const char *gen_compressed = "Generator (compressed):";
static const char *gen_uncompressed = "Generator (uncompressed):";
static const char *gen_hybrid = "Generator (hybrid):";
if (!x) {
reason = ERR_R_PASSED_NULL_PARAMETER;
goto err;
}
ctx = BN_CTX_new();
if (ctx == NULL) {
reason = ERR_R_MALLOC_FAILURE;
goto err;
}
if (EC_GROUP_get_asn1_flag(x)) {
/* the curve parameter are given by an asn1 OID */
int nid;
if (!BIO_indent(bp, off, 128))
goto err;
nid = EC_GROUP_get_curve_name(x);
if (nid == 0)
goto err;
if (BIO_printf(bp, "ASN1 OID: %s", OBJ_nid2sn(nid)) <= 0)
goto err;
if (BIO_printf(bp, "\n") <= 0)
goto err;
nname = EC_curve_nid2nist(nid);
if (nname) {
if (!BIO_indent(bp, off, 128))
goto err;
if (BIO_printf(bp, "NIST CURVE: %s\n", nname) <= 0)
goto err;
}
} else {
/* explicit parameters */
int is_char_two = 0;
point_conversion_form_t form;
int tmp_nid = EC_METHOD_get_field_type(EC_GROUP_method_of(x));
if (tmp_nid == NID_X9_62_characteristic_two_field)
is_char_two = 1;
if ((p = BN_new()) == NULL || (a = BN_new()) == NULL ||
(b = BN_new()) == NULL || (order = BN_new()) == NULL ||
(cofactor = BN_new()) == NULL) {
reason = ERR_R_MALLOC_FAILURE;
goto err;
}
#ifndef OPENSSL_NO_EC2M
if (is_char_two) {
if (!EC_GROUP_get_curve_GF2m(x, p, a, b, ctx)) {
reason = ERR_R_EC_LIB;
goto err;
}
} else /* prime field */
#endif
{
if (!EC_GROUP_get_curve_GFp(x, p, a, b, ctx)) {
reason = ERR_R_EC_LIB;
goto err;
}
}
if ((point = EC_GROUP_get0_generator(x)) == NULL) {
reason = ERR_R_EC_LIB;
goto err;
}
if (!EC_GROUP_get_order(x, order, NULL) ||
!EC_GROUP_get_cofactor(x, cofactor, NULL)) {
reason = ERR_R_EC_LIB;
goto err;
}
form = EC_GROUP_get_point_conversion_form(x);
if ((gen = EC_POINT_point2bn(x, point,
form, NULL, ctx)) == NULL) {
reason = ERR_R_EC_LIB;
goto err;
}
buf_len = (size_t) BN_num_bytes(p);
if (buf_len < (i = (size_t) BN_num_bytes(a)))
buf_len = i;
if (buf_len < (i = (size_t) BN_num_bytes(b)))
buf_len = i;
if (buf_len < (i = (size_t) BN_num_bytes(gen)))
buf_len = i;
if (buf_len < (i = (size_t) BN_num_bytes(order)))
buf_len = i;
if (buf_len < (i = (size_t) BN_num_bytes(cofactor)))
buf_len = i;
if ((seed = EC_GROUP_get0_seed(x)) != NULL)
seed_len = EC_GROUP_get_seed_len(x);
buf_len += 10;
if ((buffer = malloc(buf_len)) == NULL) {
reason = ERR_R_MALLOC_FAILURE;
goto err;
}
if (!BIO_indent(bp, off, 128))
goto err;
/* print the 'short name' of the field type */
if (BIO_printf(bp, "Field Type: %s\n", OBJ_nid2sn(tmp_nid))
<= 0)
goto err;
if (is_char_two) {
/* print the 'short name' of the base type OID */
int basis_type = EC_GROUP_get_basis_type(x);
if (basis_type == 0)
goto err;
if (!BIO_indent(bp, off, 128))
goto err;
if (BIO_printf(bp, "Basis Type: %s\n",
OBJ_nid2sn(basis_type)) <= 0)
goto err;
/* print the polynomial */
if ((p != NULL) && !ASN1_bn_print(bp, "Polynomial:", p, buffer,
off))
goto err;
} else {
if ((p != NULL) && !ASN1_bn_print(bp, "Prime:", p, buffer, off))
goto err;
}
if ((a != NULL) && !ASN1_bn_print(bp, "A: ", a, buffer, off))
goto err;
if ((b != NULL) && !ASN1_bn_print(bp, "B: ", b, buffer, off))
goto err;
if (form == POINT_CONVERSION_COMPRESSED) {
if ((gen != NULL) && !ASN1_bn_print(bp, gen_compressed, gen,
buffer, off))
goto err;
} else if (form == POINT_CONVERSION_UNCOMPRESSED) {
if ((gen != NULL) && !ASN1_bn_print(bp, gen_uncompressed, gen,
buffer, off))
goto err;
} else { /* form == POINT_CONVERSION_HYBRID */
if ((gen != NULL) && !ASN1_bn_print(bp, gen_hybrid, gen,
buffer, off))
goto err;
}
if ((order != NULL) && !ASN1_bn_print(bp, "Order: ", order,
buffer, off))
goto err;
if ((cofactor != NULL) && !ASN1_bn_print(bp, "Cofactor: ", cofactor,
buffer, off))
goto err;
if (seed && !print_bin(bp, "Seed:", seed, seed_len, off))
goto err;
}
ret = 1;
err:
if (!ret)
ECerror(reason);
BN_free(p);
BN_free(a);
BN_free(b);
BN_free(gen);
BN_free(order);
BN_free(cofactor);
BN_CTX_free(ctx);
free(buffer);
return (ret);
}
int main(int argc, char** argv)
{
// error case
if (argc != 2)
return 1;
// Seed random
int seed = atoi(argv[1]);
srand(seed);
int byte0 = 0;
unsigned char p[8];
// Populate our array with random numbers
int i;
for (i = 0; i < 8; i++)
{
int num = (rand() % 256);
p[i] = num;
}
// Can generate from [0 - 255]
byte0 = rand() % 256;
printf("The initial array in decimal is: \n");
print_decimal(p);
printf("Byte 0 in decimal is: %d\n", byte0);
printf("-----------------------------------------------------------------------------------------------------------------------------------------------------------\n");
printf("The initial array in bianary is: \n");
print_bin(p);
printf("Byte 0 in bianary is: ");
PRINTBIN(byte0);
printf("\n");
printf("-----------------------------------------------------------------------------------------------------------------------------------------------------------\n");
// Call setlsbs
setlsbs(p, byte0);
printf("The modified array in decimal is: \n");
print_decimal(p);
printf("-----------------------------------------------------------------------------------------------------------------------------------------------------------\n");
printf("The modified array in bianary is: \n");
print_bin(p);
printf("-----------------------------------------------------------------------------------------------------------------------------------------------------------\n");
// Get back our value
unsigned char r = getlsbs(p);
printf("The returned value from getlsbs is decimal is: %d\n", r);
printf("The returned value from getlsbs in bianary is: ");
PRINTBIN(r);
printf("\n");
return 0;
}
main ()
{
sTest src;
sTest trg;
float a = 1234567890.123456;
float b = 1.1;
int i;
int size;
FILE *fp;
float av[9];
float bv[9];
av[0] = 0.19550715;
av[1] = 1.9550715;
av[2] = 19.550715;
av[3] = 195.50715;
av[4] = 1955.0715;
av[5] = 19550.715;
av[6] = 195507.15;
av[7] = 1955071.5;
av[8] = 19550715.;
printf("a1 ..............:% 22.10f %12e %s\n", av[0], av[0], print_bin((int *)&av[0]));
printf("a2 ..............:% 22.10f %12e %s\n", av[1], av[1], print_bin((int *)&av[1]));
printf("a3 ..............:% 22.10f %12e %s\n", av[2], av[2], print_bin((int *)&av[2]));
printf("a4 ..............:% 22.10f %12e %s\n", av[3], av[3], print_bin((int *)&av[3]));
printf("a5 ..............:% 22.10f %12e %s\n", av[4], av[4], print_bin((int *)&av[4]));
printf("a6 ..............:% 22.10f %12e %s\n", av[5], av[5], print_bin((int *)&av[5]));
printf("a7 ..............:% 22.10f %12e %s\n", av[6], av[6], print_bin((int *)&av[6]));
printf("a8 ..............:% 22.10f %12e %s\n", av[7], av[7], print_bin((int *)&av[7]));
printf("a9 ..............:% 22.10f %12e %s\n", av[8], av[8], print_bin((int *)&av[8]));
#if !defined(__vms)
for (i = 0; i < 10; i++) {
src.b_int_v[i] = i*i * 2300000;
printf("a_int_v[%3.3d] ..:% 12.12d %s\n", i, src.b_int_v[i], print_bin((int *)&src.b_int_v[i]));
}
for (i = 0; i < 100; i++) {
a /= b;
src.a_float_v[i] = a;
printf("a_float_v[%3.3d] :% 22.10f %12e %s\n", i, a, a, print_bin((int *)&a));
}
src.a_int = 1507153392;
printf("a_int .........:% 12.12d %s\n", src.a_int, print_bin((int *)&src.a_int));
for (i = 0; i < 5; i++) {
src.a_short_v[i] = i*i * 32000;
printf("a_short_v[%3.3d] :% 12.12d\n", i, src.a_short_v[i]);
}
for (i = 0; i < 5; i++) {
src.a_int_v[i] = i*i * 23000000;
printf("a_int_v[%3.3d] ..:% 12.12d %s\n", i, src.a_int_v[i], print_bin((int *)&src.a_int_v[i]));
}
src.a_char = 'L';
printf("a_char ........: %c\n", src.a_char);
src.a_float = 550715.3392;
printf("a_float .......:% 22.10f %18e %s\n", src.a_float, src.a_float, print_bin((int *)&src.a_float));
fp = fopen("/view/pwr_x2_3_1/vobs/pwr_src/src/lib/rt/tst/test_vms.dat", "wb");
if (fp == NULL) exit(0);
size = fwrite(av, sizeof(av), 1, fp);
size = fwrite(&src, sizeof(src), 1, fp);
fclose(fp);
exit(1);
#else
fp = fopen("/pwr_root/src/lib/rt/tst/test_vms.dat", "rb");
if (fp == NULL) exit(0);
size = fread(av, sizeof(av), 1, fp);
printf("\nRead %d bytes\n\n", size);
printf("a1 ..............:% 22.10f %12e %s\n", av[0], av[0], print_bin((int *)&av[0]));
printf("a2 ..............:% 22.10f %12e %s\n", av[1], av[1], print_bin((int *)&av[1]));
printf("a3 ..............:% 22.10f %12e %s\n", av[2], av[2], print_bin((int *)&av[2]));
printf("a4 ..............:% 22.10f %12e %s\n", av[3], av[3], print_bin((int *)&av[3]));
printf("a5 ..............:% 22.10f %12e %s\n", av[4], av[4], print_bin((int *)&av[4]));
printf("a6 ..............:% 22.10f %12e %s\n", av[5], av[5], print_bin((int *)&av[5]));
printf("a7 ..............:% 22.10f %12e %s\n", av[6], av[6], print_bin((int *)&av[6]));
printf("a8 ..............:% 22.10f %12e %s\n", av[7], av[7], print_bin((int *)&av[7]));
printf("a9 ..............:% 22.10f %12e %s\n", av[8], av[8], print_bin((int *)&av[8]));
size = 9 * sizeof(float);
decode_sfloat(9, (char *)bv, (char *)&av, &size);
printf("\ndeocde\n\n", size);
printf("a1 ..............:% 22.10f %12e %s\n", bv[0], bv[0], print_bin((int *)&bv[0]));
printf("a2 ..............:% 22.10f %12e %s\n", bv[1], bv[1], print_bin((int *)&bv[1]));
printf("a3 ..............:% 22.10f %12e %s\n", bv[2], bv[2], print_bin((int *)&bv[2]));
printf("a4 ..............:% 22.10f %12e %s\n", bv[3], bv[3], print_bin((int *)&bv[3]));
printf("a5 ..............:% 22.10f %12e %s\n", bv[4], bv[4], print_bin((int *)&bv[4]));
printf("a6 ..............:% 22.10f %12e %s\n", bv[5], bv[5], print_bin((int *)&bv[5]));
printf("a7 ..............:% 22.10f %12e %s\n", bv[6], bv[6], print_bin((int *)&bv[6]));
printf("a8 ..............:% 22.10f %12e %s\n", bv[7], bv[7], print_bin((int *)&bv[7]));
printf("a9 ..............:% 22.10f %12e %s\n", bv[8], bv[8], print_bin((int *)&bv[8]));
size = fread(&src, sizeof(src), 1, fp);
printf("\nRead %d bytes\n\n", size);
for (i = 0; i < 10; i++)
CONVERT_INT(&trg.b_int_v[i], &src.b_int_v[i]);
size = sizeof(trg.a_float_v);
decode_sfloat(100, (char *) trg.a_float_v, (char *) src.a_float_v, &size);
CONVERT_INT(&trg.a_int, &src.a_int);
for (i = 0; i < 5; i++)
CONVERT_SHORT(&trg.a_short_v[i], &src.a_short_v[i]);
for (i = 0; i < 5; i++)
CONVERT_INT(&trg.a_int_v[i], &src.a_int_v[i]);
trg.a_char = src.a_char;
size = sizeof(trg.a_float);
decode_sfloat(1, (char *) &trg.a_float, (char *) &src.a_float, &size);
for (i = 0; i < 10; i++) {
printf("b_int_v[%3.3d] ..:% 12.12d %s\n", i, trg.b_int_v[i], print_bin(&trg.b_int_v[i]));
}
for (i = 0; i < 100; i++) {
printf("a_float_v[%3.3d] :% 22.10f %15e %s\n", i, trg.a_float_v[i], trg.a_float_v[i], print_bin((int *)&trg.a_float_v[i]));
}
printf("a_int .........:% 12.12d %s\n", trg.a_int, print_bin(&trg.a_int));
for (i = 0; i < 5; i++) {
printf("a_short_v[%3.3d] :% 12.12d\n", i, trg.a_short_v[i]);
}
for (i = 0; i < 5; i++) {
printf("a_int_v[%3.3d] ..:% 12.12d %s\n", i, trg.a_int_v[i], print_bin(&trg.a_int_v[i]));
}
printf("a_char ........: %c\n", trg.a_char);
printf("a_float .......:% 22.10f %15e %s\n", trg.a_float, trg.a_float, print_bin((int *)&trg.a_float));
fclose(fp);
exit(1);
#endif
}
///////////////////////////////////////////////////////////////////////////
// Connect the mouse by opening a serial port (19200 baud, 8 data, 1 stop,
// no parity). Reset the mouse once connected and verify diagnostics.
//
// Return: file descriptor to serial port or -1 if error opening port
//////////////////////////////////////////////////////////////////////////
int ThreeDMouse::logitechOpen(const std::string& port_name)
{
int fd;
struct termios t;
unsigned char data[DIAGNOSTIC_SIZE]; /* for diagnostics info */
/* open a serial port, read/write */
if ( (fd = open(port_name.c_str(), O_RDWR)) < 0 )
{
perror(port_name.c_str());
return(-1);
}
/// Can now safely set the mouseFD value
mouseFD = fd;
/* disable all input mode processing */
t.c_iflag = 0;
/* disable all output mode processing */
t.c_oflag = 0;
/* hardware control flags: 19200 baud, 8 data bits, 1 stop bits,
no parity, enable receiver */
t.c_cflag = B19200 | CS8 | CSTOPB | CREAD;
/* disable local control processing (canonical, control sigs, etc) */
t.c_lflag = 0;
/* set control characters for non-canonical reads */
t.c_cc[VMIN] = 1;
t.c_cc[VTIME]= 0;
/* control port immediately (TCSANOW) */
if ( tcsetattr(mouseFD, TCSANOW, &t) < 0 )
{
perror("error controlling serial port");
return(-1);
}
/* reset the mouse */
ThreeDMouse::resetControlUnit();
/* do diagnostics */
ThreeDMouse::getDiagnostics(data);
#ifdef DEBUG
printf("diag[0]: %2x=", data[0]);
print_bin(data[0]);
printf("\n");
printf("diag[1]: %2x=", data[1]);
print_bin(data[1]);
printf("\n");
#endif
/* check diagnostic return */
if ( (data[0] != 0xbf) || (data[1] != 0x3f) )
{
fprintf(stderr, "Mouse diagnostics failed\n");
return(-1);
}
return(fd);
}
// Read DID from ID (GM)
// For now we are only setting this up to work with the BCM
// 244 [3] 02 1A 90
void handle_gm_read_did_by_id(int can, struct canfd_frame frame) {
if(verbose) plog("Received GM Read DID by ID Request\n");
char resp[300];
char *buf;
char *tracenum = "874602RA51950204";
unsigned char chksum;
int pktsize;
switch(frame.data[2]) {
case 0x90: // VIN
if(verbose) plog(" + Requested VIN\n");
switch(fuzz_level) {
case 0:
if(verbose) plog("Sending VIN %s\n", vin);
resp[0] = frame.data[1] + 0x40;
resp[1] = frame.data[2];
memcpy(&resp[2], vin, strlen(vin));
isotp_send_to(can, resp, 3 + strlen(vin), 0x644);
break;
case 1:
if(verbose) plog("Fuzzing VIN with printable chars\n");
resp[0] = frame.data[1] + 0x40;
resp[1] = frame.data[2];
buf = gen_data(DATA_ALPHANUM, 17);
chksum = calc_vin_checksum(buf, 17);
buf[8] = chksum;
if(verbose) plog("Using VIN: %s\n", buf);
memcpy(&resp[2], buf, 17);
free(buf);
isotp_send_to(can, resp, 3 + 17, 0x644);
break;
case 2:
case 3: // At 3 the ISOTP spec gets flaky
pktsize = rand() % 252;
if(verbose) plog("Fuzzing big VIN with printable chars\n");
resp[0] = frame.data[1] + 0x40;
resp[1] = frame.data[2];
buf = gen_data(DATA_ALPHANUM, pktsize);
chksum = calc_vin_checksum(buf, pktsize);
buf[8] = chksum;
if(verbose) plog("Using big VIN (%d chars): %s\n",pktsize, buf);
memcpy(&resp[2], buf, pktsize);
free(buf);
isotp_send_to(can, resp, 3 + pktsize, 0x644);
break;
case 4:
if(verbose) plog("Fuzzing VIN with binary data\n");
resp[0] = frame.data[1] + 0x40;
resp[1] = frame.data[2];
buf = gen_data(DATA_BINARY, 17);
chksum = calc_vin_checksum(buf, 17);
buf[8] = chksum;
if(verbose) print_bin(buf, 17);
memcpy(&resp[2], buf, 17);
free(buf);
isotp_send_to(can, resp, 3 + 17, 0x644);
break;
case 5:
default:
pktsize = rand() % 252;
if(verbose) plog("Fuzzing VIN with binary data with size %d\n", pktsize);
resp[0] = frame.data[1] + 0x40;
resp[1] = frame.data[2];
buf = gen_data(DATA_BINARY, pktsize);
if(verbose) print_bin(buf, pktsize);
memcpy(&resp[2], buf, pktsize);
free(buf);
isotp_send_to(can, resp, 3 + pktsize, 0x644);
break;
}
break;
case 0xA1: // SDM Primary Key
if(verbose) plog(" + Requested SDM Primary Key\n");
switch(fuzz_level) {
case 0:
default:
if(verbose) plog("Sending SDM Key %04X\n", 0x6966);
resp[0] = frame.data[1] + 0x40;
resp[1] = frame.data[2];
resp[2] = 0x69;
resp[3] = 0x66;
isotp_send_to(can, resp, 5, 0x644);
break;
}
break;
case 0xB4: // Traceability Number
if(verbose) plog(" + Requested Traceability Number\n");
switch(fuzz_level) {
case 0:
default:
if(verbose) plog("Sending Traceabiliity number %s\n", tracenum);
resp[0] = frame.data[1] + 0x40;
resp[1] = frame.data[2];
memcpy(&resp[2], tracenum, strlen(tracenum));
isotp_send_to(can, resp, 3 + strlen(tracenum), 0x644);
break;
}
break;
case 0xB7: // Software Number
if(verbose) plog(" + Requested Software Number\n");
switch(fuzz_level) {
case 0:
default:
if(verbose) plog("Sending SW # %d\n", 600);
resp[0] = frame.data[1] + 0x40;
resp[1] = frame.data[2];
resp[2] = 0x42;
resp[3] = 0xAA;
resp[4] = 6;
resp[5] = 2; // 600
resp[6] = 0x58;
isotp_send_to(can, resp, 6, 0x644);
break;
}
break;
case 0xCB: // End Model Part #
if(verbose) plog(" + Requested End Model Part Number\n");
switch(fuzz_level) {
case 0:
default:
if(verbose) plog("Sending End Model Part Number %d\n", 15804602);
resp[0] = frame.data[1] + 0x40;
resp[1] = frame.data[2];
resp[2] = 0x00;
resp[3] = 0xF1;
resp[4] = 0x28;
resp[5] = 0xBA;
isotp_send_to(can, resp, 6, 0x644);
break;
}
break;
default:
break;
}
}
void handle_vehicle_info(int can, struct canfd_frame frame) {
char *buf;
int pktsize = 0;
unsigned char chksum;
if(verbose) plog("Received Vehicle info request\n");
char resp[300];
switch(frame.data[2]) {
case 0x00: // Supported PIDs
if(verbose) plog("Replying with ALL Pids supported\n");
resp[0] = frame.data[1] + 0x40;
resp[1] = frame.data[2];
resp[2] = 0x55;
resp[3] = 0;
resp[4] = 0;
resp[5] = 0;
isotp_send(can, resp, 6);
break;
case 0x02: // Get VIN
switch(fuzz_level) {
case 0:
if(verbose) plog("Sending VIN %s\n", vin);
resp[0] = frame.data[1] + 0x40;
resp[1] = frame.data[2];
resp[2] = 1;
memcpy(&resp[3], vin, strlen(vin));
isotp_send(can, resp, 4 + strlen(vin));
break;
case 1:
if(verbose) plog("Fuzzing VIN with printable chars\n");
resp[0] = frame.data[1] + 0x40;
resp[1] = frame.data[2];
resp[2] = 1;
buf = gen_data(DATA_ALPHANUM, 17);
chksum = calc_vin_checksum(buf, 17);
buf[8] = chksum;
if(verbose) plog("Using VIN: %s\n", buf);
memcpy(&resp[3], buf, 17);
free(buf);
isotp_send(can, resp, 4 + 17);
break;
case 2:
case 3: // At 3 the ISOTP spec gets flaky
pktsize = rand() % 252;
if(verbose) plog("Fuzzing big VIN with printable chars\n");
resp[0] = frame.data[1] + 0x40;
resp[1] = frame.data[2];
resp[2] = 1;
buf = gen_data(DATA_ALPHANUM, pktsize);
chksum = calc_vin_checksum(buf, pktsize);
buf[8] = chksum;
if(verbose) plog("Using big VIN (%d chars): %s\n",pktsize, buf);
memcpy(&resp[3], buf, pktsize);
free(buf);
isotp_send(can, resp, 4 + pktsize);
break;
case 4:
if(verbose) plog("Fuzzing VIN with binary data\n");
resp[0] = frame.data[1] + 0x40;
resp[1] = frame.data[2];
resp[2] = 1;
buf = gen_data(DATA_BINARY, 17);
chksum = calc_vin_checksum(buf, 17);
buf[8] = chksum;
if(verbose) print_bin(buf, 17);
memcpy(&resp[3], buf, 17);
free(buf);
isotp_send(can, resp, 4 + 17);
break;
case 5:
default:
pktsize = rand() % 252;
if(verbose) plog("Fuzzing VIN with binary data with size %d\n", pktsize);
resp[0] = frame.data[1] + 0x40;
resp[1] = frame.data[2];
resp[2] = 1;
buf = gen_data(DATA_BINARY, pktsize);
if(verbose) print_bin(buf, pktsize);
memcpy(&resp[3], buf, pktsize);
free(buf);
isotp_send(can, resp, 4 + pktsize);
break;
}
break;
default:
break;
}
}
