#ifndef _CRT_SECURE_NO_WARNINGS

#define _CRT_SECURE_NO_WARNINGS

#endif

#include <hexrays.hpp>

#include <struct.hpp>

#include <bytes.hpp>

#include <kernwin.hpp>

#include <algorithm>

#include <pro.h>

#include "structures.h"

#include "choosers.h"

bool extract_substruct(uval_t idx, uval_t begin, uval_t end)

{

tid_t id = get_struc_by_idx( idx );

if (is_union(id))

{

msg("union!\n");

return false;

}

struc_t * struc = get_struc(id);

if(!struc)

{

msg("!struc\n");

return false;

}

int i = 1;

qstring tmpname;

get_struc_name(&tmpname, id);

char *struc_name = qstrdup(tmpname.c_str());

char * number = strstr(struc_name, "_obj_");

char * number2;

//find last _obj_

while (number && (number2 = strstr(number+1, "_obj_")))

{

number = number2;

}

if (number)

*number = 0;

char new_struc_name[MAXSTR];

char *nsn = NULL;

do

{

qsnprintf(new_struc_name, MAXSTR, "%s_obj_%d", struc_name, i);

i++;

} while ((get_name_ea(BADADDR, new_struc_name) != BADADDR) && i<100);

if (i<100)

nsn = new_struc_name;

tid_t newid = add_struc(idx+1, nsn);

struc_t * newstruc = get_struc(newid);

asize_t delta = begin;

asize_t off = begin;

while( off <= end)

{

member_t * member = get_member(struc, off);

if(member)

{

char name[MAXSTR];

get_member_name(member->id, name, sizeof(name));

opinfo_t mt;

retrieve_member_info(member, &mt);

asize_t size = get_member_size(member);

//TODO: if name is already used, this doesn't work!!!!

add_struc_member(newstruc, name, off - delta, member->flag, &mt, size);

//get_member_type(member, );

//set_member_type(newstruc, off-delta, member->flag, &mt, size);

qtype type;

qtype fields;

if(get_or_guess_member_tinfo(member, &type, &fields))

{

member_t * newmember = get_member(newstruc, off-delta);

//set_member_tinfo(idati, sptr, mptr, 0, type.c_str(), fields.c_str(), 0);

set_member_tinfo(idati, newstruc, newmember, 0, type.c_str(), fields.c_str(), SET_MEMTI_COMPATIBLE /*| SET_MEMTI_MAY_DESTROY*/);

}

}

off = get_struc_next_offset(struc, off);

}

//newstruc->age

//parse_decl(idati, "");

qtype type;

qtype fields;

qstring qname;

//guess_tinfo(newid, &type, &fields );

//

//create_typedef();

qstring tmpname2;

get_struc_name(&tmpname2, newid);

char *name = qstrdup(tmpname2.c_str());

qstrncat(name, " dummy;", MAXSTR);

parse_decl(idati, name, &qname, &type, &fields, PT_VAR);

member_t * member = get_member(struc, begin);

set_member_tinfo(idati, struc, member, 0, type.c_str(), fields.c_str(), SET_MEMTI_MAY_DESTROY);

//set_struc_cmt(newid, "generated struct", false);

//get_next_member_idx();

return true;

}

/*

Recursively travels struc_t to find which member exactly is at specified offset

returns whether succeeded.

*/

bool idaapi struct_get_member(struc_t * str, asize_t offset, member_t ** out_member )

{

if (get_struc_size(str) < offset )

return false;

member_t * member = get_member(str, offset);

if ( member )

{

if ( member->get_soff() == offset )

{

if(out_member)

*out_member = member;

return true;

}

struc_t * membstr = get_sptr(member);

if ( membstr )

{

return struct_get_member(membstr, offset-member->get_soff());

}

}

return false;

}

bool idaapi struct_has_member(struc_t * str, asize_t offset)

{

return struct_get_member(str, offset, NULL);

}

void print_struct_member_name(struc_t * str, asize_t offset, char * name, size_t len)

{

member_t * member = get_member(str, offset);

if ( member )

{

if ( member->get_soff() == offset )

{

qstring tmpname;

get_member_fullname(&tmpname, member->id);

qstrncpy(name, tmpname.c_str(), len);

return;

}

struc_t * membstr = get_sptr(member);

if ( membstr )

{

qstring tmpname;

ssize_t s = get_struc_name(&tmpname, str->id);

qstrncpy(name, tmpname.c_str(), len);

name[s]='.';

print_struct_member_name(membstr, offset - member->get_soff(), name+s+1, len-s-1);

return;

}

}

}

bool which_struct_matches_here(uval_t idx1, uval_t begin, uval_t end)

{

tid_t id = get_struc_by_idx( idx1 );

if (is_union(id))

{

msg("union!\n");

return false;

}

struc_t * struc = get_struc(id);

if(!struc)

{

msg("!struc\n");

return false;

}

asize_t size = end + get_member_size(get_member(struc, end)) - begin;

matched_structs m;

m.idcka.clear();

for( uval_t idx = get_first_struc_idx(); idx!=BADNODE; idx=get_next_struc_idx(idx) )

{

tid_t id = get_struc_by_idx(idx);

struc_t * struc_candidate = get_struc(id);

if(!struc_candidate)

continue;

if (is_union(id))

continue;

if (get_struc_size(struc_candidate) != size)

continue;

if ( compare_structs(struc, begin, struc_candidate ) )

m.idcka.push_back(id);

}

//TODO: use another functions

msg("found %d candidate structs\n", m.idcka.size());

int choosed = m.choose("possible matches");

qstring name;

if ( choosed > 0 )

{

get_struc_name(&name, m.idcka[choosed-1]);

open_structs_window(m.idcka[choosed-1], 0);

}

return true; // done

}

//compares two structs, first very simple version, recursive version will be later

//for every member of str2 we look for member with same width at str1 + begin

//

bool compare_structs(struc_t * str1, asize_t begin, struc_t * str2 )

{

asize_t off = 0;

while( off != BADADDR )

{

member_t * member2 = get_member(str2, off);

member_t * member1 = get_member(str1, off + begin);

if (!member2)

break;

if( !member1 )

{

return false;

}

if (member1->get_soff() != off + begin)

return false;

if (get_member_size( member1 ) != get_member_size( member2 ))

return false;

off = get_struc_next_offset(str2, off);

}

return true;

}

bool unpack_this_member(uval_t idx, uval_t offset)

{

tid_t id = get_struc_by_idx( idx );

if (is_union(id))

{

msg("union!\n");

return false;

}

struc_t * struc = get_struc(id);

if(!struc)

{

msg("!struc\n");

return false;

}

member_t * member = get_member( struc, offset);

if (member->get_soff() != offset)

return false;

struc_t * membstr = get_sptr(member);

if(!membstr)

return false;

if (is_union(membstr->id))

return false;

asize_t delta = offset;

asize_t off = 0;

asize_t end = get_struc_size(membstr);

del_struc_member(struc, offset);

while( off <= end )

{

member_t * member = get_member(membstr, off);

if(member)

{

char name[MAXSTR];

get_member_name(member->id, name, sizeof(name));

opinfo_t mt;

retrieve_member_info(member, &mt);

asize_t size = get_member_size(member);

add_struc_member(struc, name, off + delta, member->flag, &mt, size);

qtype type;

qtype fields;

if( get_or_guess_member_tinfo(member, &type, &fields) )

{

member_t * newmember = get_member(struc, off + delta);

//set_member_tinfo(idati, sptr, mptr, 0, type.c_str(), fields.c_str(), 0);

set_member_tinfo(idati, struc, newmember, 0, type.c_str(), fields.c_str(), /*SET_MEMTI_COMPATIBLE | */SET_MEMTI_MAY_DESTROY);

}

}

off = get_struc_next_offset(membstr, off);

}

return true;

}