Esempio n. 1
0
File: main.c Progetto: kirg/zMsgr
int zMsgrMain()
{
	WSADATA wsaData;
	unsigned short portStart;

	o=VirtualAlloc(0,totalBufSize,MEM_RESERVE|MEM_COMMIT,PAGE_READWRITE);
	if (!o )
		err("error! allocating memory ...");
	buf=(char *)o + sizeof(struct options);
	tStr=(tmsg=(smsg=(rmsg=(msg=buf+editBufSize)+msgSize)+msgSize)+msgSize)+msgSize;
	tbuf0=(tbuf=tStr+msgSize)+bufSize;

	initprog(0);

	i=	+sizeof(struct options)	//o
		+editBufSize			//buf
		+msgSize				//msg
		+msgSize				//rmsg
		+msgSize				//smsg
		+msgSize				//tmsg
		+msgSize				//tStr
		+bufSize				//tbuf
		+bufSize				//tbuf0
		+maxNumOfUsers*sizeof(struct info)	//info
		+maxNumOfUsers*sizeof(SOCKET)			//conn
		+maxNumOfUsers*sizeof(struct todo)	//todo
		;
	if (i>totalBufSize)
		err("memory allocated will not suffice!");

	info=(struct info *)(tbuf0+bufSize);
	conn=(SOCKET *)((char *)info+maxNumOfUsers/*o->maxNumOfUsers*/*sizeof(struct info));
	todo=(struct todo *)((char *)conn+maxNumOfUsers*sizeof(SOCKET));

	for(i=0;i<maxNumOfUsers;++i)
		conn[i]=~0;//INVALID_SOCKET
	todoNum=numUsers=0;

//wsprintf(tStr,"memory usage status\n%u bytes required\n%u bytes allocated",i,totalBufSize);
//imb(tStr);

	WSAStartup(0x101,&wsaData);
	//port=portStart;
	port=(portStart=9999+((unsigned short)GetTickCount()&32767));
	sListen=socket(AF_INET,SOCK_STREAM,0);
	sChk_udp=socket(AF_INET,SOCK_DGRAM,0);
	sUdp=socket(AF_INET,SOCK_DGRAM,0);
tryNextPort:
	++port;
	sockAddr.sin_family=AF_INET;
	sockAddr.sin_addr.s_addr=INADDR_ANY;
	sockAddr.sin_port=htons(port);
	if (port!=portStart)
	{
		if (bind(sListen,(SOCKADDR *)&sockAddr,sizeof(sockAddr)))
			goto tryNextPort;
		if (bind(sChk_udp,(SOCKADDR *)&sockAddr,sizeof(sockAddr)))
		{
			closesocket(sListen);//un-bind(sListen);
			sListen=socket(AF_INET,SOCK_STREAM,0);
			goto tryNextPort;
		}
		if (listen(sListen,maxNumOfUsers))
		{
			closesocket(sListen);//un-bind(sListen);
			closesocket(sChk_udp);//un-bind(sListenUdp);
			sListen=socket(AF_INET,SOCK_STREAM,0);
			sChk_udp=socket(AF_INET,SOCK_DGRAM,0);
			goto tryNextPort;
		}
	}
	else
		err("no ports available!!");
	RtlFillMemory(conn,maxNumOfUsers*sizeof(SOCKET),0xff);//INVALID_SOCKET; 
	DialogBox(GetModuleHandle(0),MAKEINTRESOURCE(IDD_dlg),0,(DLGPROC)dlgproc);
	closesocket(sListen);
	WSACleanup();
	
	VirtualFree(buf,0,MEM_DECOMMIT|MEM_RELEASE);
	return 0;
}
Esempio n. 2
0
int loadELF (char* name,int mode,uint32_t addr) {
    if(mode==1) {
        //printf("loading at adress :");
        textStart = addr;
        //printf("%X\n", textStart);
    }
    else {
        textStart=DEFAULT_S_ADDR;
    }
    if(textStart%0x1000>0) {
        textStart = textStart+0x1000-textStart%0x1000;
    }


    char* section_names[NB_SECTIONS]= {TEXT_SECTION_STR,RODATA_SECTION_STR,DATA_SECTION_STR,BSS_SECTION_STR};
    unsigned int segment_permissions[NB_SECTIONS]= {R_X,R__,RW_,RW_};
    unsigned int nsegments;
    int i=0,j=0;
    unsigned int type_machine;
    unsigned int endianness;   //little ou big endian
    unsigned int bus_width;    // 32 bits ou 64bits
    unsigned int next_segment_start = textStart; // compteur pour designer le debut de la prochaine section

    symtab=new_stab(0);
    stab symtab_libc= new_stab(0); // table des symboles de la libc
    FILE * pf_elf, *pf_libc;


    if ((pf_elf = fopen(name,"r")) == NULL) {
        WARNING_MSG("cannot open file '%s'", name);
        return -1;
    }

    if (!assert_elf_file(pf_elf)) {
        WARNING_MSG("file %s is not an ELF file", name);
        return -1;
    }


    if ((pf_libc = fopen(PATH_TO_LIBC,"r")) == NULL) {
        ERROR_MSG("cannot open file %s", PATH_TO_LIBC);
    }

    if (!assert_elf_file(pf_libc))
        ERROR_MSG("file %s is not an ELF file", PATH_TO_LIBC);

    // recuperation des info de l'architecture
    elf_get_arch_info(pf_elf, &type_machine, &endianness, &bus_width);
    // et des symboles
    elf_load_symtab(pf_elf, bus_width, endianness, &symtab);
    elf_load_symtab(pf_libc, bus_width, endianness, &symtab_libc);
    elf_load_symtab(pf_libc, bus_width, endianness, &libcsymtab);


    nsegments = get_nsegments(symtab,section_names,NB_SECTIONS);
    nsegments += get_nsegments(symtab_libc,section_names,NB_SECTIONS);
    // allouer la memoire virtuelle
    memory=init_mem(nsegments);


    next_segment_start = LIBC_MEM_END;
    //printf("\ndebut : %08x\n",next_segment_start);
    j=0;

    // on alloue libc
    for (i=0; i<NB_SECTIONS; i++) {
        if (is_in_symbols(section_names[i],symtab_libc)) {
            elf_load_section_in_memory(pf_libc,memory, section_names[i],segment_permissions[i],next_segment_start);
            next_segment_start-= ((memory->seg[j].size._32+0x1000)>>12 )<<12; // on arrondit au 1k supp�rieur
            memory->seg[j].start._32 = next_segment_start;
//            print_segment_raw_content(&memory->seg[j]);
            j++;
        }
    }
    if(verbose>0) {
        INFO_MSG("--------------Relocation of %s-------------------",PATH_TO_LIBC);
    }
    for (i=0; i<j; i++) {
        reloc_segment(pf_libc, memory->seg[i], memory,endianness,&symtab_libc,NULL,NULL);
    }

    // on change le nom des differents segments de libc
    for (i=0; i<j; i++) {
        char seg_name [256]= {0};
        strcpy(seg_name,"libc");
        strcat(seg_name,memory->seg[i].name);
        free(memory->seg[i].name);
        memory->seg[i].name=strdup(seg_name);
    }


    // On va chercher les sections du fichier
    int k =j;
    next_segment_start = textStart;




    for (i=0; i<NB_SECTIONS; i++) {
        if (is_in_symbols(section_names[i],symtab)) {
            elf_load_section_in_memory(pf_elf,memory, section_names[i],segment_permissions[i],next_segment_start);
            next_segment_start+= ((memory->seg[j].size._32+0x1000)>>12 )<<12; // on arrondit au 1k supperieur
//            print_segment_raw_content(&memory->seg[j]);
            j++;
        }
    }

    // on reloge chaque section du fichier
    if(verbose>0) {
        INFO_MSG("--------------Relocation of %s-------------------",name);
    }
    for (i=k; i<j; i++) {
        reloc_segment(pf_elf, memory->seg[i], memory,endianness,&symtab,&symtab_libc,pf_libc);
    }
    //TODO allouer la pile (et donc modifier le nb de segments)

    // printf("\n------ Fichier ELF \"%s\" : sections lues lors du chargement ------\n", name) ;
    // print_mem(memory);
    //stab32_print( symtab);
    //stab32_print( symtab_libc);
    // on fait le menage avant de partir
    //del_mem(memory);
    //del_stab(symtab_libc);
    //del_stab(symtab);

    //Recuperation des bornes des segments rx
    for (k = 0; k < memory->nseg; k++) {
        if(strcmp(memory->seg[k].name,".text")==0) {
            textStart=memory->seg[k].start._32;
            textEnd=memory->seg[k].start._32+memory->seg[k].size._32;
        }
        if(strcmp(memory->seg[k].name,"libc.text")==0) {
            libcTextStart=memory->seg[k].start._32;
            libcTextEnd=memory->seg[k].start._32+memory->seg[k].size._32;
        }
    }
    if(verbose>0)INFO_MSG("R_X segments: %8.8X-%8.8X and %8.8X-%8.8X",textStart,textEnd,libcTextStart,libcTextEnd );


    //Initialisation de l'emulateur en vu d'un run
    initprog();



    INFO_MSG("File loaded :'%s'",name);
    fclose(pf_elf);
    fclose(pf_libc);
    //puts("");
    return 0;
}