int process_pe(char* filename,int file,void* p,int len)
{

	PIMAGE_DOS_HEADER pDosHeader;
	PIMAGE_NT_HEADERS pNTHeaders;

	char* pStr;
	PSTAB_ENTRY pStab;
	DWORD nStabLen,nSym;
	char* pStrTab;
	char* pSymTab;

	char szSymName[2048];
	HANDLE fileout;
	int nSymStrLen,nStabStrLen;
    int iRetVal = 0;

	pDosHeader = (PIMAGE_DOS_HEADER)p;
	pNTHeaders = (PIMAGE_NT_HEADERS)((DWORD)p + pDosHeader->e_lfanew);

    if ((pDosHeader->e_magic == IMAGE_DOS_SIGNATURE)
       && (pDosHeader->e_lfanew != 0L)
       && (pNTHeaders->Signature == IMAGE_NT_SIGNATURE))
    {
		if( pNTHeaders->FileHeader.PointerToSymbolTable ){

			pSymTab = (char*)((DWORD)p + pNTHeaders->FileHeader.PointerToSymbolTable);
			nSym = pNTHeaders->FileHeader.NumberOfSymbols;
			//string table follows immediately after symbol table. first 4 bytes give the length of the table
			//references to string table include the first 4 bytes.
			pStrTab = (char*)((PIMAGE_SYMBOL)pSymTab + nSym);
			nSymStrLen = *((DWORD*)pStrTab);
			find_stab_sections(p,IMAGE_FIRST_SECTION(pNTHeaders),pNTHeaders->FileHeader.NumberOfSections,
					&pStab,&nStabLen,&pStr,&nStabStrLen);

			if(pStab && nStabLen && pStr && nStabStrLen)
			{
				LPSTR pDot;

				strcpy(szSymName,filename);
				//printf("LOADER: file name = %s\n",szSymName);
				if((pDot = strchr(szSymName,'.')))
				{
					*pDot = 0;
					strcat(pDot,".dbg");
				}
				else
				{
					strcat(szSymName,".dbg");
				}
				//printf("LOADER: symbol file name = %s\n",szSymName);
	            printf("LOADER: creating symbol file %s for %s\n",szSymName,filename);

				fileout = CreateFile(szSymName,
								     GENERIC_READ | GENERIC_WRITE,
								     0,
								     NULL,
								     CREATE_ALWAYS,
								     0,
								     0);

	            if(fileout != INVALID_HANDLE_VALUE)
				{
					printf("NumberOfSections: %d, size: %d\n", pNTHeaders->FileHeader.NumberOfSections,sizeof(IMAGE_SECTION_HEADER));
					process_stabs(szSymName,
								  fileout,
								  IMAGE_FIRST_SECTION(pNTHeaders),
								  pNTHeaders->FileHeader.NumberOfSections*sizeof(IMAGE_SECTION_HEADER),
								  p,
								  pStab,
								  nStabLen,
								  pStr,
								  nStabStrLen,
								  (char*)pSymTab,
								  nSym*sizeof(IMAGE_SYMBOL),
								  pStrTab,
								  nSymStrLen);

					CloseHandle(fileout);
				}
	            else
	            {
	                printf("LOADER: creation of symbol file %s failed\n",szSymName);
					iRetVal = 2;
	            }

			}
	        else
	        {
	            printf("LOADER: file %s has no data inside symbol tables\n",filename);
				if( ulGlobalVerbose )
				{
	                if( !pStab || !nStabLen )
	                    printf("LOADER: - symbol table is empty or not present\n");
	                if( !pStr  || !nStabStrLen )
	                    printf("LOADER: - string table is empty or not present\n");
				}
	            iRetVal = 2;
	        }
		}
		else{
            printf("LOADER: file %s does not have a symbol table\n",filename);
            iRetVal = 2;
		}
    }
    else
    {
        printf("LOADER: file %s is not an ELF binary\n",filename);
        iRetVal = 1;
    }

    //printf("LOADER: leave process_pe()\n");
    return iRetVal;
}

///////////////////////////////////////////////////////////////////////////////////
// process_file()
//
///////////////////////////////////////////////////////////////////////////////////
int process_file(char* filename)
{
	int file;
	void* p;
	off_t len;
	int iRetVal=0;

    //printf("LOADER: enter process_file()\n");
    file = _open(filename,O_RDONLY|_O_BINARY);
    if(file>0)
    {
        //printf("LOADER: opened %s as FD %x\n",filename,file);

        len = _lseek(file,0,SEEK_END);
        printf("LOADER: file %s is %u bytes\n",filename,(int)len);

        _lseek(file,0,SEEK_SET);

        p = malloc(len+16);
        if(p)
        {
			long count;
            //printf("LOADER: malloc'd @ %x\n",p);
            memset(p,0,len+16);
            if(len == (count = _read(file,p,len)))
            {
                //printf("LOADER: trying ELF format\n");
                iRetVal = process_pe(filename,file,p,len);
            }
        }
        _close(file);
    }
    else
    {
        printf("LOADER: file %s could not be opened\n",filename);
		iRetVal = 1;
    }

    //printf("LOADER: leave process_file()\n");
    return iRetVal;
}

///////////////////////////////////////////////////////////////////////////////////
// open_debugger()
//
///////////////////////////////////////////////////////////////////////////////////
HANDLE	open_debugger(void)
{
    debugger_file = CreateFile("\\Device\\Pice",GENERIC_READ,0,NULL,OPEN_EXISTING,NULL,NULL);
	if(debugger_file == INVALID_HANDLE_VALUE)
	{
		printf("LOADER: debugger is not loaded. Last Error: %ld\n", GetLastError());
	}

	return debugger_file;
}

///////////////////////////////////////////////////////////////////////////////////
// close_debugger()
//
///////////////////////////////////////////////////////////////////////////////////
void close_debugger(void)
{
	if( !CloseHandle(debugger_file) ){
		printf("Error closing debugger handle: %ld\n", GetLastError());
	}
}

int ioctl( HANDLE device, DWORD ioctrlcode, PDEBUGGER_STATUS_BLOCK psb)
{
	 DEBUGGER_STATUS_BLOCK tsb;
	 DWORD bytesreturned;
	 if( !DeviceIoControl( device, ioctrlcode, psb, sizeof(DEBUGGER_STATUS_BLOCK),
			&tsb, sizeof(DEBUGGER_STATUS_BLOCK),&bytesreturned, NULL) ){
		printf("Error in DeviceIoControl: %ld\n", GetLastError());
		return -EINVAL;
	 }
	 else{
		memcpy( psb, &tsb, sizeof(DEBUGGER_STATUS_BLOCK) );
	 }
	 return 0;
}

///////////////////////////////////////////////////////////////////////////////////
// banner()
//
///////////////////////////////////////////////////////////////////////////////////
void banner(void)
{
    printf("#########################################################\n");
    printf("####       Symbols LOADER/TRANSLATOR for PICE        ####\n");
    printf("#########################################################\n");
}

#define ACTION_NONE             0
#define ACTION_LOAD             1
#define ACTION_UNLOAD           2
#define ACTION_TRANS            3
#define ACTION_RELOAD           4
#define ACTION_INSTALL          5
#define ACTION_UNINSTALL        6
#define ACTION_STATUS           7
#define ACTION_BREAK            8
#define ACTION_TERMINAL         9

///////////////////////////////////////////////////////////////////////////////////
// change_symbols()
//
///////////////////////////////////////////////////////////////////////////////////
void change_symbols(int action,char* pfilename)
{
    int iRetVal = 0;
	DEBUGGER_STATUS_BLOCK sb;

	strcpy(sb.filename, pfilename);

	switch(action)
	{
		case ACTION_LOAD:
			printf("LOADER: loading symbols from %s\n",pfilename);
			if(open_debugger() != INVALID_HANDLE_VALUE)
			{
				iRetVal = ioctl(debugger_file,PICE_IOCTL_LOAD,&sb);
				close_debugger();
			}
			break;
		case ACTION_UNLOAD:
			printf("LOADER: unloading symbols from %s\n",pfilename);
			if(open_debugger() != INVALID_HANDLE_VALUE)
			{
				iRetVal = ioctl(debugger_file,PICE_IOCTL_UNLOAD,&sb);
				close_debugger();
			}
			break;
		case ACTION_RELOAD:
			printf("LOADER: reloading all symbols\n");
			if(open_debugger() != INVALID_HANDLE_VALUE)
			{
				ioctl(debugger_file,PICE_IOCTL_RELOAD,NULL);
				close_debugger();
    			printf("LOADER: reloading DONE!\n");
			}
			break;
        default :
            printf("LOADER: an internal error has occurred at change_symbols\n");
	}

    switch( iRetVal )
	{
	    case -EINVAL :
			printf("LOADER: debugger return value = -EINVAL, operation has failed\n");
			break;
		case 0 :
			// success - silently proceed
			break;
		default :
			printf("LOADER: debugger return value = %i, operation possibly failed\n",iRetVal);
	}
}

// Dynamic install to be added later
#if 0
///////////////////////////////////////////////////////////////////////////////////
// tryinstall()
//
///////////////////////////////////////////////////////////////////////////////////
int tryinstall(void)
{
    char *argv[]={"/sbin/insmod","pice.o",NULL};
    int err = 0;
    int pid,status;

    banner();
    printf("LOADER: trying to install debugger...\n");

    if( open_debugger() != INVALID_HANDLE_VALUE  )
    {
        printf("LOADER: debugger already installed...\n");
        close_debugger();
        return 0;
    }

    // create a separate thread
    pid = fork();
    switch(pid)
    {
        case -1:
            // error when forking, i.e. out E_NOMEM
            err = errno;
            printf("LOADER: fork failed for execution of '%s' (errno = %u).\n",argv[0],err);
            break;
        case 0:
            // child process handler
            execve(argv[0],argv,NULL);
            // returns only on error, with return value -1, errno is set
            printf("LOADER: couldn't execute '%s' (errno = %u)\n",argv[0],errno);
            exit(255);
            break;
        default:
            // parent process handler
            printf("LOADER: waiting for debugger to load...\n");
            pid = waitpid(pid, &status, 0); // suspend until child is done
            if( (pid>0) && WIFEXITED(status) && (WEXITSTATUS(status) == 0) )
                printf("LOADER: debugger loaded!\n");
            else if( pid<=0 )
            {
                printf("LOADER: Error on loading debugger! (waitpid() = %i)\n",pid);
                err = -1;
            }
            else if( !WIFEXITED(status) )
            {
                printf("LOADER: Error on loading debugger! (ifexited = %i)\n",WIFEXITED(status));
                err = -1;
            }
            else