/*Moves a process from the input queue into the in memory queue*/
void input_to_mem(MANAGER* mm, PROCESS* p) {
if (p->prev == NULL) {
mm->input_q = p->next;
if (p->next != NULL) {
p->next->prev = NULL;
}
} else {
p->prev->next = p->next;
if (p->next != NULL) {
p->next->prev = p->prev;
}
}
p->next = NULL;
p->prev = NULL;
add_mem(mm, p);
}
/*
* read /proc/dma
*/
void read_dmas(misc_t *m)
{
char buf[100];
misc_dma_t *d;
unsigned u;
str_list_t *sl;
if(!(m->proc_dma = read_file(PROC_DMA, 0, 0))) return;
for(sl = m->proc_dma; sl; sl = sl->next) {
if(sscanf(sl->str, " %u : %99[^\n]", &u, buf) == 2) {
m->dma = add_mem(m->dma, sizeof *m->dma, m->dma_len);
d = m->dma + m->dma_len++;
d->channel = u;
d->dev = new_str(buf);
}
}
}
/*
* read /proc/ioports
*/
void read_ioports(misc_t *m)
{
char buf[100];
misc_io_t *r;
uint64_t u, v;
str_list_t *sl;
if(!(m->proc_io = read_file(PROC_IOPORTS, 0, 0))) return;
for(sl = m->proc_io; sl; sl = sl->next) {
if(sscanf(sl->str, " %"PRIx64" - %"PRIx64" : %99[^\n]", &u, &v, buf) == 3) {
m->io = add_mem(m->io, sizeof *m->io, m->io_len);
r = m->io + m->io_len++;
r->addr = u;
r->size = v >= u ? v - u + 1 : 0;
r->dev = new_str(buf);
}
}
}
int init_mem_list(void)
{
mem_block_ptr mem_block;
alloc_list=add_mem(alloc_list, 0x00, 0x0500, LOW_MEM, SYSTEM_MEM);
mem_block=add_mem(alloc_list, 0x0a0000, 0x0c0000-0x0a0000, LOW_MEM, SYSTEM_MEM);
mem_block=add_mem(mem_block, 0x0c0000, 0x00100000-0x0c0000, LOW_MEM, SYSTEM_MEM);
mem_block=add_mem(mem_block, 0x00100000, 0x00200000-0x00100000, HIGH_MEM, KERNEL_MEM);
mem_block=add_mem(mem_block, 0x00200000, 0x00300000-0x00200000, HIGH_MEM, KERNEL_MEM);
free_list=add_mem(free_list, 0x0500, 0x0a0000-0x0500, LOW_MEM, 0);
mem_block=add_mem(free_list, 0x00300000, physical_mem_size-0x00300000, HIGH_MEM, 0);
return(0);
}
state_t* eval_stmts(ast_t *p, state_t *state)
{
ast_list_t *stmts;
ast_list_t *ip;
ast_t *t1, *t2;
ast_t *s;
value_t v;
int just_tainted = 0;
int i;
assert(p != NULL);
assert(p->info.node.tag == SEQ);
ip = p->info.node.arguments;
while(ip != NULL)
{
s = ip->elem;
switch(s->info.node.tag){
case ASSIGN:
printf("\nthis is ASSIGN\n");
/* the lhs */
t1 = s->info.node.arguments->elem;
/* the rhs */
t2 = s->info.node.arguments->next->elem;
v = eval_exp(t2, state->tbl, state->mem);
switch(t1->tag){
case var_ast:
printf("\n var ast horela.");
state->tbl = update_var(t1->info.string, v, state->tbl);// check is tf == 1=>add tbl->name & reset tf= 0
printf("\n var ast ke baad tbl name : %s",state->tbl->name);
if(tf==1){
printf("\nVal od type = %d",type);
printf("\nTainted. Adding this up! : %s\n",state->tbl->name);
add_var(state->tbl->name);
printf("\nAdded Taint! %s \n",state->tbl->name);
tf = 0;
just_tainted = 1;
tvar_index = 0;
type = 0;
}
if(constant_check == 1 && just_tainted == 0){
printf("\n constant present...\n");
printf("\nvariable name is ..%s\n",state->tbl->name);
if(check_tain_var(state->tbl->name)){
printf("\n removing taint!\n\n");
remove_taint_var(state->tbl->name);
printf("\nremoved!\n");
constant_check = 0;
type = 0;
}
}
just_tainted = 0;
break;
case node_ast:
printf("\nMemo horela. ");
assert(t1->info.node.tag == MEM);
state->mem = store(eval_exp(t1->info.node.arguments->elem,
state->tbl,
state->mem), v, state->mem);//same here.
if(tf == 1){
printf("\ntaint detected. Adding address %u up\n",state->mem->addr);
add_mem(state->mem->addr);
printf("\nMemory tainted! Addr : %u \n",state->mem->addr);
tf = 0;
tmem_index = 0;
type = 0;
memo = 0;
}
printf("\nafter nost ast..mem val is : %u",state->mem->addr);
if(cc_mem == 2){
printf("\n constant present...\n");
if(check_tain_mem(state->mem->addr)){
printf("\n removing taint!\n\n");
remove_taint_mem(state->mem->addr);
printf("\nremoved!\n");
cc_mem = 0;
}
}
break;
default:
assert(0);
}
break;
case PRINT:
printf("\n this is printttt\n");
switch(s->info.node.arguments->elem->tag){
case str_ast:
printf("\nin str-ast");
printf("str asgn %s\n", s->info.node.arguments->elem->info.string);
fprintf(stderr,"Tainted variable: None\n");
break;
default:
printf("\n default.\n");
printf("\n Memory addrs now : %u \n",state->mem->addr);
printf("\n var name now :%s\n",state->tbl->name);
coming_from_print =1;
printf("def %u\n", eval_exp(s->info.node.arguments->elem,
state->tbl,
state->mem));
if (tf==0)
fprintf(stderr,"Tainted variable: None\n");
if(tf == 1){
printf("\nTaint detected!! with type %d and tvar_index %d\n",type,tvar_index);
fprintf(stderr,"Tainted variable: ");
/*switch(type){
case 1 : printf("\nIts a variable!\n");
%s\n",tvar_arr[tvar_index]);
break;
case 2 : printf("\nIts a memory!\n");
fprintf(stderr,"Tainted variable: mem[%u]\n",tmem_arr[tmem_index]);
break;
case 3 : printf("\nIts kinda both.\n");
fprintf(stderr,"Tainted variable: %s, mem[%u]\n",tvar_arr[tvar_index],tmem_arr[tmem_index]);
break;
case 4 : printf("\nIts direct!\n");
fprintf(stderr," direct");
break;
}
fprintf(stderr,"Tainted variable: ");*/
for (i=0;i<=tvar_index; i++)
{ if (tvar_arr[i][1] == 2)
{
// printf("\nIts direct!\n");
fprintf(stderr,"direct");
}
else if (tvar_arr[i][1] == 1)
{
// printf("\nIts a variable!\n");
fprintf(stderr,"mem[%d]",tvar_arr[i][0]);
}
else
{
// printf("\nIts a variable!\n");
fprintf(stderr,"%s",tvar_arr[i]);
}
if (i>0 && i<tvar_index)
fprintf(stderr,", ");
}
fprintf(stderr,"\n");
}
type = 0;
tf = 0;
tvar_index = 0;
tmem_index = 0;
coming_from_print = 0;
break;
}
break;
case IF:
printf("\nthis is IFFF\n");
if(eval_exp(s->info.node.arguments->elem, state->tbl, state->mem)){
state = eval_stmts(s->info.node.arguments->next->elem, state);
} else {
state = eval_stmts(s->info.node.arguments->next->next->elem, state);
}
break;
case SEQ:
printf("\n this is SEQQQ\n");
state = eval_stmts(s->info.node.arguments->next->elem, state);
break;
case ASSERT:
if(eval_exp(s->info.node.arguments->elem, state->tbl,state->mem) ==0){
printf("Assert failed!\n");
}
break;
default:
printf("Unknown statement type\n");
assert(0);
break;
}
ip = ip->next;
}
return state;
}
bool CTempMemory_list::add_tmp_allocate(const CEE_handle_def* call_id,void*ptr)
{
return add_mem( call_id, ptr );
}
/*
* read /proc/interrupts
*
* This is somewhat more tricky, as the irq event counts are done separately
* per cpu *and* there may be irq sharing.
*/
void read_irqs(misc_t *m)
{
char buf[100], buf2[100], *s;
misc_irq_t *ir;
int i, j;
unsigned u, v, k;
str_list_t *sl;
if(!(m->proc_irq = read_file(PROC_INTERRUPTS, 1, 0))) return;
for(sl = m->proc_irq; sl; sl = sl->next) {
/* irq */
i = 0;
if(sscanf(sl->str, " %u: %n", &u, &i) < 1) continue;
v = 0;
j = i;
/* add up all event counters */
while(j < (int) strlen(sl->str) && sscanf(sl->str + j, " %u %n", &k, &i) >= 1) {
if(!i) break;
v += k;
j += i;
}
/* device driver name string */
#if defined(__PPC__)
if(
sscanf(sl->str + j, " %*s Edge %99[^\n]", buf) == 1 ||
sscanf(sl->str + j, " %*s Level %99[^\n]", buf) == 1 ||
sscanf(sl->str + j, " %*s %99[^\n]", buf) == 1
) {
#else
#if defined(__alpha__) || defined(__sparc__)
if(sscanf(sl->str + j, " %99[^\n]", buf) == 1) {
#else /* __i386__ || __x86_64__ || __ia64__ */
if(sscanf(sl->str + j, " %*s %99[^\n]", buf) == 1) {
#endif
#endif
m->irq = add_mem(m->irq, sizeof *m->irq, m->irq_len);
ir = m->irq + m->irq_len++;
ir->irq = u;
ir->events = v;
/* split device driver names (separated by ',') */
s = buf;
while(*s && sscanf(s, " %99[^,] %n", buf2, &j) >= 1) {
ir->dev = add_mem(ir->dev, sizeof *ir->dev, ir->devs);
ir->dev[ir->devs++] = new_str(buf2);
s += j;
if(*s) s++; /* skip ',' */
}
}
}
}
void gather_resources(misc_t *m, hd_res_t **r, char *name, unsigned which)
{
int i, j;
hd_res_t *res;
if(!m) return;
if(!which) which = W_IO | W_DMA | W_IRQ;
if((which & W_IO)) for(i = 0; (unsigned) i < m->io_len; i++) {
if(!strcmp(name, m->io[i].dev)) {
res = add_res_entry(r, new_mem(sizeof **r));
res->io.type = res_io;
res->io.enabled = 1;
res->io.base = m->io[i].addr;
res->io.range = m->io[i].size;
res->io.access = acc_rw;
m->io[i].tag++;
}
}
if((which & W_DMA)) for(i = 0; (unsigned) i < m->dma_len; i++) {
if(!strcmp(name, m->dma[i].dev)) {
res = add_res_entry(r, new_mem(sizeof **r));
res->dma.type = res_dma;
res->dma.enabled = 1;
res->dma.base = m->dma[i].channel;
m->dma[i].tag++;
}
}
if((which & W_IRQ)) for(i = 0; (unsigned) i < m->irq_len; i++) {
for(j = 0; j < m->irq[i].devs; j++) {
if(!strcmp(name, m->irq[i].dev[j])) {
res = add_res_entry(r, new_mem(sizeof **r));
res->irq.type = res_irq;
res->irq.enabled = 1;
res->irq.base = m->irq[i].irq;
res->irq.triggered = m->irq[i].events;
m->irq[i].tag++;
}
}
}
}
int active_vga_card(hd_t *hd)
{
hd_res_t *res;
if(hd->bus.id != bus_pci) return 1;
for(res = hd->res; res; res = res->next) {
if(
(res->mem.type == res_mem && res->mem.enabled) ||
(res->io.type == res_io && res->io.enabled)
) return 1;
}
return 0;
}
