コード例 #1
0
ファイル: et199_encrypt.c プロジェクト: dulton/nampu
static int et199_encrypt_excute_flie(void *encrypt, char *file_name, char *inbuf, char *outbuf, char *passwd)
{
	ENCRYPT *encrypt_ins = (ENCRYPT *)encrypt;
	struct ET_CONTEXT*pContext = (struct ET_CONTEXT*)encrypt_ins->private_data;
	int dwRet = 0;
	long unsigned int len = 0;

	dwRet = ETVerifyPin(&pContext[0], (unsigned char *)passwd, strlen(passwd), ET_USER_PIN);
	if(dwRet)
	{
		if(dwRet == ET_E_KEY_REMOVED || dwRet == ET_E_NO_LIST)
		{
			return DEV_REMOVED;
		}
		PostError("et199_encrypt_excute_flie ETVerifyPin", dwRet);
		return VERIFYPASSWD_ERR;
	}

	dwRet = ETExecute(&pContext[0], file_name, (unsigned char *)inbuf, strlen(inbuf), (unsigned char *)outbuf, BUF_LEN, &len);
	if(dwRet)
	{
		if(dwRet == ET_E_KEY_REMOVED || dwRet == ET_E_NO_LIST)
		{
			return DEV_REMOVED;
		}
		PostError("et199_encrypt_excute_flie ETExecute",dwRet);
		return EXCUTEFILE_ERR;
	}

	return len;
}
コード例 #2
0
ファイル: Log.cpp プロジェクト: AlphaPixel/3DNature
void MessageLog::PostStockError(unsigned int StockNum, const char *ErrorMsg)
{

if (StockNum <= WCS_LOG_ERR_NULL)
	{
	TempBuffer[0] = NULL;
	if (StockErrors[StockNum].Severity >= WCS_LOG_SEVERITY_ERR)
		{
		strcpy(TempBuffer, "ERR:"); 
		} // if
	else if (StockErrors[StockNum].Severity >= WCS_LOG_SEVERITY_WNG)
		{
		strcpy(TempBuffer, "WNG:"); 
		} // if
	else if (StockErrors[StockNum].Severity >= WCS_LOG_SEVERITY_MSG)
		{
		strcpy(TempBuffer, "MSG:"); 
		} // if
	else if (StockErrors[StockNum].Severity >= WCS_LOG_SEVERITY_DTA)
		{
		strcpy(TempBuffer, "DTA:"); 
		} // if
	strcat(TempBuffer, StockErrors[StockNum].Text);
	strncat(TempBuffer, ErrorMsg, WCS_LOG_LINE_WIDTH - strlen(TempBuffer) - 5);
	TempBuffer[WCS_LOG_LINE_WIDTH - 1] = NULL;
	PostError(StockErrors[StockNum].Severity, TempBuffer);
	} // if
else
	{
	PostError(WCS_LOG_SEVERITY_ERR, "Unknown Error.");
	} // else

} // MessageLog::PostStockError
コード例 #3
0
ファイル: et199_encrypt.c プロジェクト: dulton/nampu
static int et199_encrypt_write_data(void *encrypt, char *src_data, int length, FILE_TYPE type)
{
	ENCRYPT *encrypt_ins = (ENCRYPT *)encrypt;
	struct ET_CONTEXT*pContext = (struct ET_CONTEXT*)encrypt_ins->private_data;
	int dwRet = 0;
	if(length > DATA_FILE_LENGTH)
	{
		return WRITE_LEN_LONGER;
	}
	dwRet = ETVerifyPin(&pContext[0], (unsigned char *)encrypt_ins->dev_passwd,
		strlen(encrypt_ins->dev_passwd), ET_DEV_PIN);
	if(dwRet)
	{
		if(dwRet == ET_E_KEY_REMOVED || dwRet == ET_E_NO_LIST)
		{
			return DEV_REMOVED;
		}
		PostError("ETVerifyPin", dwRet);
		return VERIFYPASSWD_ERR;
	}

	dwRet = ETWriteFile(&pContext[0], file_name[type], 0, (unsigned char *)src_data, length);
	if(dwRet)
	{
		if(dwRet == ET_E_KEY_REMOVED || dwRet == ET_E_NO_LIST)
		{
			return DEV_REMOVED;
		}
		PostError("ETWriteFile", dwRet);
		return WRITEFILE_ERR;
	}

	return 0;
}
コード例 #4
0
ファイル: PolyHook.cpp プロジェクト: 1833183060/PolyHook
void PLH::VEHHook::UnHook()
{
	std::lock_guard<std::mutex> m_Lock(m_TargetMutex);
	
	if (m_ThisCtx.m_Type == VEHMethod::INT3_BP)
	{
		MemoryProtect Protector(m_ThisCtx.m_Src, 1, PAGE_EXECUTE_READWRITE);
		*m_ThisCtx.m_Src = m_ThisCtx.m_StorageByte;
	}else if (m_ThisCtx.m_Type == VEHMethod::HARDWARE_BP) {
		CONTEXT Ctx;
		Ctx.ContextFlags = CONTEXT_DEBUG_REGISTERS;
		if (!GetThreadContext(GetCurrentThread(), &Ctx))
		{
			PostError(PLH::RuntimeError(RuntimeError::Severity::Critical, "Failed to get context"));
			return;
		}
		Ctx.Dr7 &= ~(1 << (2 * m_ThisCtx.m_StorageByte));
		//Still need to call suspend thread
		if (!SetThreadContext(GetCurrentThread(), &Ctx))
		{
			PostError(PLH::RuntimeError(RuntimeError::Severity::Critical, "Failed to set context"));
			return;
		}
	}else if (m_ThisCtx.m_Type == VEHMethod::GUARD_PAGE) {
		volatile BYTE GenerateExceptionRead = *m_ThisCtx.m_Src;
	}
	m_HookTargets.erase(std::remove(m_HookTargets.begin(), m_HookTargets.end(), m_ThisCtx), m_HookTargets.end());
}
コード例 #5
0
ファイル: Log.cpp プロジェクト: AlphaPixel/3DNature
void MessageLog::OpenLogFile(char *LogName)
{
char *TimeStr /*, *FileBase */;
time_t Now;

strncpy(LogFileName, LogName, 250);
LogFileName[254] = NULL;
LogFileEnable = 1;

/*
for(FileBase = LogName; *FileBase != NULL; FileBase++);

while(!(FileBase < LogName))
	{
	if ((*FileBase == '\\') || (*FileBase == '/'))
		{
		break;
		} // if
	FileBase--;
	} // while
*/
time(&Now);
TimeStr = ctime(&Now);
TimeStr[24] = NULL;
sprintf(TempBuffer, "Log File \"%s\" opened on %s.", LogName, TimeStr);
PostError(0, TempBuffer);

} // MessageLog::OpenLogFile
コード例 #6
0
ファイル: Log.cpp プロジェクト: AlphaPixel/3DNature
void MessageLog::CloseLogFile(void)
{

LogFileEnable = 0;
PostError(0, "Log File Closed.");

} // MessageLog::CloseLogFile
コード例 #7
0
ファイル: module.cpp プロジェクト: 63n/LASzip
  // Initialize the module, staring a worker thread to load the shared object.
  virtual bool Init(uint32_t argc, const char* argn[], const char* argv[]) {
      nacl_io_init_ppapi( pp_instance(), 
                          pp::Module::Get()->get_browser_interface());
      // printf( "Constructor thread id '%p'\n", pthread_self());                    


      // printf( "createFS thread id '%p'\n", pthread_self());          
      umount("/");
      int res = mount("", "/", "memfs", 0, "");
      // int res = mount("", "/web", "httpfs", 0, "");
      if (res)
      {
          // std::cout << "unable to mount httpfs file system!" << std::endl;
          bCreatedFS_ = true; 
          return false;
      }
      // std::cout << "mount res: " << res << std::endl;

      if (pthread_create( &message_thread_, 
                      NULL, 
                      &LASzipInstance::HandleMessageThread, 
                      this))
      {
          PostError("Init", "Unable to initialize thread!", "null");
          return false;
      }
      InitializeMessageQueue();
      return true;
      
  }
コード例 #8
0
static DWORD WINAPI CrashReportGenerateThread(LPVOID data)
{
  MINIDUMP_EXCEPTION_INFORMATION *ExceptionInfo=(MINIDUMP_EXCEPTION_INFORMATION *)data;
  HWND hwnd;
  int res;

  if (MiniDumpWriteDumpFn!=NULL)
  {
	hwnd=CreateWindowEx(WS_EX_TOPMOST,"STATIC","V programu nastala chyba\r\n\r\nSystem Windows nyni sbira informace o chybe a generuje potrebne soubory.\r\nProsim cekejte, tato operace muze trvat trochu dele...",WS_POPUP|
	  WS_DLGFRAME|WS_VISIBLE|SS_CENTER,0,0,640,80,NULL,NULL,GetModuleHandle(NULL),NULL);
	UpdateWindow(hwnd);
    if (GenerateMinidump(ExceptionInfo,MiniDumpWithIndirectlyReferencedMemory,".short.dmp")==false) return 0;
//    GenerateMinidump(ExceptionInfo,MiniDumpWithDataSegs|MiniDumpWithIndirectlyReferencedMemory,".long.dmp");
    GenerateMinidump(ExceptionInfo,MiniDumpWithFullMemory,".full.dmp");
    PostError(0);
	DestroyWindow(hwnd);
  }
  else
  {
	res=MessageBox(0,"V programu nastala chyba. Bohuzel neni pritomen soubor DbgHelp.dll v adresari hry, "
				"neni tedy mozne vytvorit zaznam o chybe. Ze stranek http://skeldal.vyletnici.net je mozne"
				"tento soubor stahnout a tim pomoci autorovi odhalit a opravit tyto zaludne pady.\r\n\r\n"
				"Chcete prejit na stranky obsahujici posledni verze potrebnych souboru?",0,MB_YESNO|MB_SYSTEMMODAL);
	if (res==IDYES)
	  ShellExecute(0,0,"http://skeldal.vyletnici.net/main.php?page=download",0,0,SW_NORMAL);
  }
  return 0;
}
コード例 #9
0
ファイル: PolyHook.cpp プロジェクト: johndpope/PolyHook
bool PLH::VEHHook::Hook()
{
	//Lock the TargetMutex for thread safe vector operations
	std::lock_guard<std::mutex> m_Lock(m_TargetMutex);

	if (m_ThisCtx.m_Type == VEHMethod::INT3_BP)
	{
		//Write INT3 BreakPoint
		MemoryProtect Protector(m_ThisCtx.m_Src, 1, PAGE_EXECUTE_READWRITE);
		m_ThisCtx.m_OriginalByte = *m_ThisCtx.m_Src;
		*m_ThisCtx.m_Src = 0xCC;
		m_HookTargets.push_back(m_ThisCtx);
	}else if (m_ThisCtx.m_Type == VEHMethod::GUARD_PAGE){
		//Read current page protection
		MEMORY_BASIC_INFORMATION mbi;
		VirtualQuery(m_ThisCtx.m_Src, &mbi, sizeof(mbi));

		//can't use Page Guards with NO_ACCESS flag
		if (mbi.Protect & PAGE_NOACCESS)
		{
			PostError(RuntimeError(RuntimeError::Severity::UnRecoverable, "PolyHook VEH: Cannot hook page with NOACCESS Flag"));
			return false;
		}

		if (AreInSamePage((BYTE*)&PLH::VEHHook::VEHHandler, m_ThisCtx.m_Src))
		{
			PostError(RuntimeError(RuntimeError::Severity::UnRecoverable, "PolyHook VEH: Cannot hook page on same page as the VEH"));
			return false;
		}

		//!!!!COMPILER SPECIFIC HACK HERE!!!!!
		bool(PLH::VEHHook::* pHookFunc)(void) = &PLH::VEHHook::Hook;
		if (AreInSamePage((BYTE*&)pHookFunc, m_ThisCtx.m_Src))
		{
			PostError(RuntimeError(RuntimeError::Severity::UnRecoverable, "PolyHook VEH: Cannot hook page on same page as the hooking function"));
			return false;
		}
		
		m_HookTargets.push_back(m_ThisCtx);

		//Write Page Guard protection
		DWORD OldProtection;
		VirtualProtect(m_ThisCtx.m_Src, 1 ,PAGE_EXECUTE_READWRITE | PAGE_GUARD, &OldProtection);
	}
	return true;
}
コード例 #10
0
ファイル: et199_encrypt.c プロジェクト: dulton/nampu
static int et199_encrypt_init(void *encrypt)
{
	int dwCount = 0;
	int dwRet = 0;
	ENCRYPT *encrypt_ins = encrypt;
	struct ET_CONTEXT *pContext = (struct ET_CONTEXT *)encrypt_ins->private_data;

	dwRet = ETEnum(0, &dwCount);
	if(dwRet != ET_E_INSUFFICIENT_BUFFER && dwRet)
	{
		PostError("ETEnum 1", dwRet);
		return PROBE_ERR;
	}

	if(dwCount > PCONTEXT_COUNT)
	{
		return MORE_DEV;
	}

	memset(pContext, 0, sizeof(struct ET_CONTEXT)*dwCount);

	dwRet = ETEnum(pContext, &dwCount);
	if(dwRet)
	{
		PostError("ETEnum 2", dwRet);
		return PROBE_ERR;
	}

	//Open ET199
	dwRet = ETOpen(&pContext[0]);
	if(dwRet)
	{
		PostError("ETOpen", dwRet);
		return OPENDEV_ERR;
	}

	dwRet = et199_encrypt_verfiy_serial_num(encrypt_ins);
	if(dwRet != 0)
	{
		return dwRet;
	}

	return SUCCESS;
}
コード例 #11
0
ファイル: et199_encrypt.c プロジェクト: dulton/nampu
static int et199_encrypt_creat_flie(void *encrypt, char *file_name, int size, char *passwd, int file_type)
{
	ENCRYPT *encrypt_ins = (ENCRYPT *)encrypt;
	struct ET_CONTEXT *pContext = (struct ET_CONTEXT *)encrypt_ins->private_data;
	int dwRet = 0;

	dwRet = ETVerifyPin(&pContext[0], (unsigned char *)passwd, strlen(passwd), ET_DEV_PIN);
	if(dwRet)
	{
		PostError("ETVerifyPin",dwRet);
		return VERIFYPASSWD_ERR;
	}
	dwRet = ETCreateFile(&pContext[0], file_name, size, file_type);
	if(dwRet)
	{
		PostError("ETCreateFile", dwRet);
		return CREATEFILE_ERR;
	}
	return SUCCESS;
}
コード例 #12
0
ファイル: PolyHook.cpp プロジェクト: johndpope/PolyHook
bool PLH::X86Detour::Hook()
{
	DWORD OldProtection;

	m_hkLength = CalculateLength(m_hkSrc, 5);
	m_OriginalLength = m_hkLength;
	if (m_hkLength == 0)
	{
		XTrace("Function to small to hook\n");
		return false;
	}

	m_Trampoline = new BYTE[m_hkLength + 30];   //Allocate Space for original plus extra to jump back and for jmp table
	VirtualProtect(m_Trampoline, m_hkLength + 5, PAGE_EXECUTE_READWRITE, &OldProtection); //Allow Execution
	m_NeedFree = true;

	memcpy(m_OriginalCode, m_hkSrc, m_hkLength);
	memcpy(m_Trampoline, m_hkSrc, m_hkLength); //Copy original into allocated space
	RelocateASM(m_Trampoline, m_hkLength, (DWORD)m_hkSrc, (DWORD)m_Trampoline);
	WriteRelativeJMP((DWORD)&m_Trampoline[m_hkLength], (DWORD)m_hkSrc + m_hkLength); //JMP back to original code

	//Change protection to allow write on original function
	MemoryProtect Protector(m_hkSrc, m_hkLength, PAGE_EXECUTE_READWRITE);
	//Encode Jump from Hooked Function to the Destination function
	WriteRelativeJMP((DWORD)m_hkSrc, (DWORD)m_hkDest);

	//Write nops over bytes of overwritten instructions
	for (int i = 5; i < m_OriginalLength; i++)
		m_hkSrc[i] = 0x90;
	FlushSrcInsCache();
	//Revert to old protection on original function
	VirtualProtect(m_hkSrc, m_hkLength, OldProtection, &OldProtection);
	PostError(RuntimeError(RuntimeError::Severity::Warning, "PolyHook x86Detour: Some opcodes may not be relocated properly"));
	return true;
	/*Original
	-JMP Destination
	-NOP (extends to length of overwritten opcode)
	-Rest of function

	Destination
	-Do your shit
	-Return Trampoline (goes to trampoline)

	Trampoline
	-Execute Overwritten Opcodes
	-Patch original relative jmps to point to jump table (JE Jumptable entry 1)
	-JMP to rest of function (in original)
	-*BEGIN JUMPTABLE*
	-1)JMP to location of relative jmp one
	-2)...continue pattern for all relative jmps
	*/
}
コード例 #13
0
ファイル: et199_encrypt.c プロジェクト: dulton/nampu
static int et199_encrypt_control(void *encrypt, int cmd, void *para)
{
	ENCRYPT *encrypt_ins = (ENCRYPT *)encrypt;
	struct ET_CONTEXT*pContext = (struct ET_CONTEXT*)encrypt_ins->private_data;
	int dwRet = 0;
	dwRet = ETControl(&pContext[0], cmd, (unsigned char *)para, sizeof(para), NULL, 0, NULL);
	if(dwRet)
	{
		PostError("ETControl ",dwRet);
		return CONTROL_ERR;
	}
	return SUCCESS;
}
コード例 #14
0
ファイル: PolyHook.cpp プロジェクト: johndpope/PolyHook
PLH::VEHHook::VEHHook()
{
	//Get size of pages
	SYSTEM_INFO si;
	GetSystemInfo(&si);
	m_PageSize = si.dwPageSize;

	void* pVEH = AddVectoredExceptionHandler(1, &PLH::VEHHook::VEHHandler);
	if (pVEH == nullptr)
	{
		PostError(RuntimeError(RuntimeError::Severity::UnRecoverable, "PolyHook VEH: Failed to create top level handler"));
	}
}
コード例 #15
0
ファイル: Log.cpp プロジェクト: AlphaPixel/3DNature
void MessageLog::ForceLogOpen(void)
{

if (LoggedLines)
	{
	OpenLogWin();
	} // if
else
	{
	PostError(255, "Log Window Opened.");
	} // else

} // MessageLog::ForceLogOpen
コード例 #16
0
ファイル: PolyHook.cpp プロジェクト: johndpope/PolyHook
/*----------------------------------------------*/
bool PLH::IATHook::Hook()
{
	PIMAGE_THUNK_DATA Thunk;
	if (!FindIATFunc(m_hkLibraryName.c_str(), m_hkSrcFunc.c_str(), &Thunk, m_hkModuleName.c_str()))
	{
		PostError(RuntimeError(RuntimeError::Severity::UnRecoverable, "PolyHook IATHook: Failed to find import"));
		return false;
	}

	MemoryProtect Protector(Thunk, sizeof(ULONG_PTR), PAGE_EXECUTE_READWRITE);
	m_pIATFuncOrig = (void*)Thunk->u1.Function;
	Thunk->u1.Function = (ULONG_PTR)m_hkDest;
	return true;
}
コード例 #17
0
ファイル: et199_encrypt.c プロジェクト: dulton/nampu
static int et199_encrypt_get_serial_num(void *encrypt, unsigned char *serial_num)
{
	unsigned long count = 0;
	int dwRet = 0;
	ENCRYPT *encrypt_ins = encrypt;
	struct ET_CONTEXT *pContext = (struct ET_CONTEXT *)encrypt_ins->private_data;
	dwRet = ETControl(&pContext[0], ET_GET_SERIAL_NUMBER, NULL, 0, (unsigned char *)serial_num, WDD_HARDWARE_ID_LEN, &count);
	if(dwRet)
	{
		PostError("et199_encrypt_get_serial_num", dwRet);
		printf("dwtret = %x\n", dwRet);
		return GET_SERIAL_ERR;
	}
	return SUCCESS;
}
コード例 #18
0
ファイル: command.c プロジェクト: TimofonicJunkRoom/linice
/******************************************************************************
*                                                                             *
*   BOOL cmdHelp(char *args, int subClass)                                    *
*                                                                             *
*******************************************************************************
*
*   Display Help info
*
******************************************************************************/
BOOL cmdHelp(char *args, int subClass)
{
    int nLine = 1;
    int i;

    if( *args )
    {
        // Help on a specific command
        // Search for the specified command in the command array
        i = 0;
        while( Cmd[i].sCmd )
        {
            if( !strnicmp(args, Cmd[i].sCmd, strlen(args)) )
                break;
            i++;
        }

        // Did we find it?
        if( Cmd[i].sCmd )
        {
            dprinth(nLine++, "%s", sHelp[Cmd[i].iHelp] + 9);
            dprinth(nLine++, "%s", Cmd[i].sSyntax);
            dprinth(nLine++, "%s", Cmd[i].sExample);
        }
        else
        {
            // Nope - user typed invalid command
            PostError(ERR_COMMAND, 0);
        }
    }
    else
    {
        // General help - list all commands and their short descriptions
        i = 0;
        do
        {
            if(dprinth(nLine++, "%s", sHelp[i++])==FALSE)
                break;

        } while( sHelp[i] != NULL );
    }

    return(TRUE);
}
コード例 #19
0
ファイル: command.c プロジェクト: TimofonicJunkRoom/linice
/******************************************************************************
*                                                                             *
*   int GetOnOff(char *args)                                                  *
*                                                                             *
*******************************************************************************
*
*   Parser helper: Returns [ON | OFF] state + extra
*       ON = 1
*       OFF = 2
*       <none> = 3
*       KERNEL = 4
*   For any other token, it prints the syntax error and returns 0.
*
******************************************************************************/
int GetOnOff(char *args)
{
    int len;

    while( *args==' ') args++;
    len = strlen(args);

    if( len==0 )
        return( 3 );                    // No token - end of argument
    if( len==2 && !strnicmp(args, "on", 2) )
        return( 1 );                    // ON
    if( len==3 && !strnicmp(args, "off", 3) )
        return( 2 );                    // OFF
    if( len==6 && !strnicmp(args, "kernel", 6) )
        return( 4 );                    // KERNEL

    PostError(ERR_SYNTAX, 0);

    return( 0 );
}
コード例 #20
0
//*****************************************************************************
// Set the pointers to consecutive areas of a large buffer.
//*****************************************************************************
HRESULT CMiniMd::SetTablePointers(
    BYTE        *pBase,
    ULONG       cbData)
{
    ULONG       ulOffset = 0;           // Offset so far in the table.
    int         i;                      // Loop control.

	for (i=0; i<TBL_COUNT; ++i)
	{
        METADATATRACKER_ONLY(MetaDataTracker::NoteSection(i, pBase + ulOffset, m_TableDefs[i].m_cbRec * m_Schema.m_cRecs[i], m_TableDefs[i].m_cbRec));
        // Table pointer points before start of data.  Allows using RID as
        //  an index, without adjustment.
        m_pTable[i] = pBase + ulOffset - m_TableDefs[i].m_cbRec;
        ulOffset += m_TableDefs[i].m_cbRec * m_Schema.m_cRecs[i];
    }

    if (ulOffset > cbData)
        return PostError(CLDB_E_FILE_CORRUPT);

    return S_OK;
} // HRESULT CMiniMd::SetTablePointers()
コード例 #21
0
UINT ValidateUpdate(HINSTANCE hInst, CDownloadUI *piDownloadUI, LPCSTR szAppTitle, __in LPSTR szUpdatePath, LPCSTR szModuleFile, ULONG ulMinVer)
{
    UINT uiRet = ERROR_SUCCESS;

    char szShortPath[MAX_PATH]          = {0};

    // ensure Update is right version for Windows Installer upgrade
    if (!IsUpdateRequiredVersion(szUpdatePath, ulMinVer))
    {
        // Update won't get us the right upgrade
        PostFormattedError(hInst, piDownloadUI->GetCurrentWindow(), szAppTitle, IDS_INCORRECT_UPDATE, szUpdatePath);
        return ERROR_INVALID_PARAMETER;
    }

    // upgrade msi
    uiRet = ExecuteUpgradeMsi(szUpdatePath);
    switch (uiRet)
    {
    case ERROR_SUCCESS:
    case ERROR_SUCCESS_REBOOT_REQUIRED:    
        {
            // nothing required at this time
            break;
        }
    case ERROR_FILE_NOT_FOUND:
        {
            // Update executable not found
            PostFormattedError(hInst, piDownloadUI->GetCurrentWindow(), szAppTitle, IDS_NOUPDATE, szUpdatePath);
            break;
        }
    default: // failure
        {
            // report error
            PostError(hInst, piDownloadUI->GetCurrentWindow(), szAppTitle, IDS_FAILED_TO_UPGRADE_MSI);
            break;
        }
    }
    return uiRet;
}
コード例 #22
0
ファイル: command.c プロジェクト: TimofonicJunkRoom/linice
/******************************************************************************
*                                                                             *
*   BOOL Unsupported(char *args, int subClass)                                *
*                                                                             *
*******************************************************************************
*
*   Unsupported command stub
*
******************************************************************************/
BOOL Unsupported(char *args, int subClass)
{
    PostError(ERR_NOT_IMPLEMENTED, 0);

    return( TRUE );
}
コード例 #23
0
ファイル: command.c プロジェクト: TimofonicJunkRoom/linice
/******************************************************************************
*                                                                             *
*   BOOL CommandExecute( char *pOrigCmd )                                     *
*                                                                             *
*******************************************************************************
*
*   Executes commands stored in a string. If the command contains a macro,
*   this function is called recursively.
*
*   We also exit if there was an error evaluating a command.
*
*   Where:
*       pOrigCmd is the string with commands. Multiple commands may be separated
*            with ';'
*
*   Returns:
*       FALSE if the command reuqested debugger to continue running
*             the debugee program (such are commands 'g' or 't')
*       TRUE if suggested staying in the debugger
*
******************************************************************************/
BOOL CommandExecute( char *pOrigCmd )
{
    static int nDeep = 0;               // Recursion depth count
    char Command[MAX_STRING];           // Command buffer on the stack
    char *pCmd = Command;               // Pointer to a local buffer
    char *pCmdNext, cDelimiter;
    char *pMacro;                       // Pointer to a macro string (expanded)
    BOOL fInString, fRet = TRUE;
    int i;

    nDeep++;                            // Inside the function, recursion count

    // Copy given command(s) into a local buffer so we can recurse
    strcpy(pCmd, pOrigCmd);

    do
    {
        // Find the first non-space, non-delimiter character of the current command
        while( (*pCmd==' ' || *pCmd==';') && (*pCmd!=0) ) pCmd++;

        // Look for the ";" delimiter, ignore it within a string
        pCmdNext = pCmd;
        fInString = FALSE;
        while( *pCmdNext!=0 && (*pCmdNext!=';' || fInString) )
        {
            if( *pCmdNext=='"' )
                fInString = !fInString;
            pCmdNext++;
        }

        // If the command is empty, return
        if( *pCmd==0 )
            break;

        // Got the first character.. Search all known command keywords from
        // back to front to find a match
        for( i=iLast; i>=0; i--)
        {
            if( !strnicmp(pCmd, Cmd[i].sCmd, Cmd[i].nLen)
              && !isalnum(pCmd[Cmd[i].nLen]))
                break;
        }

        // Separate current string from the next one
        cDelimiter = *pCmdNext;
        *pCmdNext = 0;

        if( i>= 0 )
        {
            // Find the first non-space character to assign it as a pointer to the first argument
            pCmd += Cmd[i].nLen;
            while( *pCmd==' ' ) pCmd++;

            // Call the command function handler
            fRet = (Cmd[i].pfnCommand)( pCmd, Cmd[i].subClass );
        }
        else
        {
            // Command was not found.  Search all defined macros.
            pMacro = MacroExpand(pCmd);
            if( pMacro != NULL )
            {
                // Recursively submit expanded macro for execution
                // Keep the recursion count so we can terminate if too deep
                if( nDeep <= MAX_MACRO_RECURSE )
                    fRet = CommandExecute(pMacro);
                else
                    fRet = TRUE;
            }
            else
            {
                // The last thing we search the extended commands (DOT-commands)
                // Only if the first character is a DOT, though
                if( *pCmd=='.' )
                {
                    return( DispatchExtCommand(pCmd+1) );
                }
                else
                {
                    PostError(ERR_COMMAND, 0);
                    return( TRUE );
                }
            }
        }

        // Restore the delimiter character
        *pCmdNext = cDelimiter;

        pCmd = pCmdNext;

    } while( (*pCmd != 0) && fRet );

    nDeep--;                            // Leaving the function, recursion count
    return( fRet );
}
コード例 #24
0
char *WriteSeq(    char *outSpec,  /* Output sequence spec              */
               SeqEntry *seq,      /* Seq Entry data structure          */
                    int  format)   /* Output format                     */
{

#define SIZE   255    /* String size                         */

char line[SIZE], header[SIZE], code[SIZE], testCode[SIZE];
char outFName[SIZE];

char *cPos, *pStrand;

int lineSize, blockSize;
int count, nOut;

Boolean twoFiles;
Boolean doText;
char errMsg[SIZE];

static char outFileName[SIZE];    /* Static because it's the return value */

FILE *outFile, *inFile;


/*
** Process available text for formats which allow freely formated text.
*/

	switch ( format ) {
	  case PIR:
	  case GCG:
	    doText = (seq->text != NULL); break;
	  default:
	    doText = 0; break;
	}

/*
** Set LineSize and BlockSize for variou formats
*/
	switch ( seq->spec->format ) {
	  case GCG:
	    lineSize = 50; blockSize= 10; break;
	  case PIR:
	  case IBI:
	    lineSize = 60; blockSize = 10; break;
	  case  IG:
	  case STRIDER:
	  default:
	    lineSize = blockSize= 80;
	}
/*
** Extract the the code from OutSpec for multi-entry files. If OutSpec just 
** has a filename then strip off the extension and use the filename as the code.
** Filenames are to the right of the equals.  
** N.B. does not yet support pathnames.
**
**    Outspec will look like either:
**
**                code=filename.ext     OR    filename.ext
*/

	if ( (cPos = strchr(outSpec,';')) ) *cPos = '\0'; /* Remove version */

	strcpy(code,outSpec);
	if ( (cPos = strchr(code,'=')) ) *cPos = '\0'; /* code=filename.ext */
	if ( (cPos = strchr(code,'.')) ) *cPos = '\0'; /* filename.ext */
	StrToUpper(code);
	strcpy(outFName,outSpec);
	if ( (cPos = strchr(outFName,'=')) ) strcpy(outFName, ++cPos);

/*
**  Are we dealing with a new or old sequence file?  Test for an existing
**  file set "twoFiles" flag accordingly.
*/

	if ( (inFile = fopen(outFName, "r")) ) {
	  if ( !(outFile = fopen(outFName, "w")) ) goto Error;
	  twoFiles = 1;
	} else {
	  if ( !(outFile = fopen(outFName, "w")) ) goto Error;
	  twoFiles = 0;
	}

/*
** Do what needs to be done to prepare the file for writing or over-writing
** the new sequence data.
**
**  PIR    - create header, read into filename until we find the entry to
**           replace or reach EOF. Save existing text if there is no new text.
**
**  IG     - Save any lines beginning with ";" these are comment characters.
**           Write out codeword.  Generate circular/linear flag.
**
**  STADEN - Translate symbols from IUPAC to STADEN, append end of sequence
**           character, "@".
**
**  GCG    - Save all text at the top of the file up to but not including the
**           line with ".." in it, unless we have new text. Convert "-"'s to
**           "."'s.  Recalculate CheckSum.  Write a new GCG descriptor line.
**
**  IBI    - Rewrite the LOCUS line and ORIGIN line.
**
**  STRIDER- Write out strider header line and sequnce title.
**
**  RAWSEQ - Do nothing.
*/

	switch ( format ) {

	  case PIR:
	    strcpy(header, ">");
	    switch (seq->type ) {
	      case  PROTEIN: strcat(header,"P1;"); break;
	      case FRAGMENT: strcat(header,"F1;"); break;
	      case      DNA: 
	        seq->circular ? strcat(header,"DC;"):strcat(header,"DL;") ; break;
	      case      RNA:
	        seq->circular ? strcat(header,"RC;"):strcat(header,"RL;") ; break;
	      case     RRNA: strcat(header,"N1;"); break;
	      case     TRNA: strcat(header,"N3;"); break;
	            default: strcat(header,"XX;"); break;
	    }
	    strcat(header, code);

	    /* 
	    ** Read in/out until the beginning of entry to be overwritten
	    **  or End of File.
	    */
	    
	    if ( twoFiles ) {
	      testCode[0] = '\0';
	      while ( fgets(line, 255, inFile) ) {
	        if( line[0] == '>') {
	          strcpy(testCode, &line[4]);
	          if ( (cPos = strchr(testCode, '\n')) ) *cPos = '\0';
	          StrToUpper(StrCollapse(testCode));
	          if( strcmp(testCode,code) == 0 ) break;
	        }  
                fputs(line,outFile);
	      }
	    }

	    /* 
	    **  Write out the header and title lines.
	    */

	    fprintf(outFile,"%s\n", header);
	    fprintf(outFile,"%s\n", seq->title);
	    break;

	/****************************************************************/

	  case IG:
	  /*
	  **  For IG format save any lines beginning with ";" these
	  **  are comment characters
	  */
	    if ( twoFiles && !doText ) {
	      while ( fgets(line, 255, inFile) ) {
	        if ( line[0] != ';' )  break;
                fputs(line,outFile);
	      }
	    } else if ( doText ) {
	      if ( seq->text ) fputs(seq->text,outFile);
	    } else
	      fprintf(outFile, "; %s\n; %s\n", seq->title,seq->desc);

	    fprintf(outFile, "%s\n", code);
	    break;

	/****************************************************************/

	   case STADEN:
	    if (seq->type >= DNA ) {
	      StrChange(seq->mem,'M','5');
	      StrChange(seq->mem,'K','6');
	      StrChange(seq->mem,'W','7');
	      StrChange(seq->mem,'S','8');
	      StrChange(seq->mem,'m','5');
	      StrChange(seq->mem,'k','6');
	      StrChange(seq->mem,'w','7');
	      StrChange(seq->mem,'s','8');
	    }
	    break;

	/****************************************************************/

	  case GCG:
	    if ( twoFiles && !doText ) {
	      while ( fgets(line, 255, inFile) ) {
	        if ( StrIndex("..",line) )  break;
                fputs(line,outFile);
	      }
	    } else if ( doText ) {
	        if ( seq->text ) fputs(seq->text,outFile);
	    } else
	      fprintf(outFile, "  %s\n  %s\n\n", seq->title,seq->desc);

	    StrChange(seq->mem,'-','.');
	    seq->checkSum = CheckSum(seq->mem);
	    fprintf(outFile, "  %s  Length: %ld  %s  Check: %d ..\n",
	            outFName, seq->length, GetTime(3), seq->checkSum);
	    fprintf(outFile,"        1 ");
	    break;
	  
	/****************************************************************/

	  case IBI:
	    fprintf(outFile,
	      "LOCUS       %s         %ld BP           UPDATED  %s\n",
	       code, seq->length, GetTime(0));
	    if ( twoFiles && !doText ) {
	      while ( fgets(line, 255, inFile) ) {
	        if ( StrIndex("LOCUS",line) ) continue;
	        if ( StrIndex("ORIGIN",line) )  break;
                fputs(line,outFile);
	      }
	    } else if ( doText && seq->text ) {
	      if ( (cPos = StrIndex("LOCUS     ",seq->text)) )
	        strcpy(seq->text,strchr(cPos,'\n'));
	      if ( (cPos = StrIndex("\nORIGIN",seq->text)) )
	        *cPos = '\0';
	      fputs(seq->text,outFile);
	    }
	    fprintf(outFile, "ORIGIN      %s\n", seq->title);
	    fprintf(outFile,"        1 ");
	    break;

	/****************************************************************/

	   case STRIDER:
	    fprintf(outFile,"; ### from DNA Strider  %s\n",GetTime(3));
	    fprintf(outFile,"; %s sequence  %s length %ld",
	      DecodeType(seq->type),seq->name,seq->length);
	    if ( seq->type <= PROTEIN )
	      fprintf(outFile," a.a. complete sequence\n; %s\n",seq->title);
	    else
	      fprintf(outFile," n.a. complete sequence\n; %s\n",seq->title);
	    break;

	/****************************************************************/

	  case RAWSEQ:
	  default:
	    break;

	}
/*
**  Write the sequence in Block/Line size.  "NOut" counts the number 
**  of symbols written in each line.  Support GCG and IBI line numbering
**  schemes.
*/

	nOut = 0;
	count = 1;
	pStrand = seq->mem;
	while( *pStrand ) {
	  fprintf(outFile, "%c", *pStrand);
	  nOut++;
	  count++;
	  if ( nOut == lineSize ) {
	    switch ( format ) {
	      case IBI:
	      case GCG:
	       fprintf(outFile,"\n%9d ",count);
	       break;
	      default:
	       fprintf(outFile, "\n");
	    }
	    nOut=0;
	  } else 
	    if ( nOut%blockSize == 0 ) fprintf(outFile, " ");
	  pStrand++;
	}

/*
** Depending on the format we have some finishing up to do.
**
** PIR     - Add the End of sequence character. Read past the old sequence
**           form the original file. If "DoText" is true, write out the new 
**           text comments, skip over the comments in the old file, if any.
**           Finally, copy the balance of the old file into the new file.
**
** IBI     - Add sequence terminator "//"
**
** IG      - Append linear/circular flag at end of sequence.
**
** STRIDER - Add sequence terminator "//"
**
** STADEN  - Add end of sequence character. Convert sequence symbols back 
**           to IUPAC.
**
** GCG     - Convert "."'s back to "-"'s. Recalc CheckSum.
*/
	
	switch ( format ) {

	  case PIR:

	    fprintf(outFile,"*\n");

	    /* Skip over sequence in the old file */

	    if ( twoFiles )
	      while ( fgets(line, 255, inFile) )
	        if( strchr(line,'*' ) ) break;

	    /* Skip over old comments, if any. */

	    if ( doText ) {
	      if ( seq->text ) fputs(seq->text,outFile);
	      if ( twoFiles )
	        while ( fgets(line, 255, inFile) )
	          if( *line == '>' ) {
	            fputs(line,outFile);
	            break;
	          }
	    }

	    /* Copy the remainder of the file */

	    if ( twoFiles ) {
	      while ( fgets(line, 255, inFile) )
	        fputs(line, outFile);
	    }
	    break;

	/****************************************************************/

	  case IBI:
	    fprintf(outFile,"\n//");  
	    break;

	/****************************************************************/

	  case IG:
	    fprintf(outFile,"%c",seq->circular ? '2' : '1');
	    break;

	/****************************************************************/

	  case STRIDER:
	    fprintf(outFile,"\n//");  
	    break;

	/****************************************************************/

	  case STADEN:
	    fprintf(outFile,"@");  
	    if (seq->type >= DNA ) {
	      StrChange(seq->mem,'5','M');
	      StrChange(seq->mem,'6','K');
	      StrChange(seq->mem,'7','W');
	      StrChange(seq->mem,'8','S');
	    }
	    break;

	/****************************************************************/

	  case GCG:
	    StrChange(seq->mem,'.','-');
	    seq->checkSum = CheckSum(seq->mem);
	    break;
	}	

	/*	fgetname(outFile, outFileName); NO IDEA PUT strcopy to compile il*/
	strcpy(outFileName,outFName);

	fclose(outFile);
	if ( twoFiles ) fclose(inFile);

	return(outFileName);

/*
** The output file could not be created.  Set error message and return
**  NULL
*/

Error:
	sprintf(errMsg, "Output file \"%s\" could not be created.", outFName);
	PostError(2,errMsg);
	return(NULL);

} /* End of WriteSeq */
コード例 #25
0
ファイル: btn_load.cpp プロジェクト: Akkarinage/Neoncube
//########################################################################
// Loads all bitmap buttons
//########################################################################
void LoadButtonBitmap(void)
{
	IMAGEPATH *img = (IMAGEPATH*)GlobalAlloc(GMEM_FIXED, sizeof(IMAGEPATH));

	if(img == NULL)
		PostError(TRUE, "Failed to allocate memory.");

	lstrcpyA(img->szCancelBmp, SKINFOLDER);
	lstrcpyA(img->szCancelHoverBmp, SKINFOLDER);

	lstrcpyA(img->szCloseBmp, SKINFOLDER);
	lstrcpyA(img->szCloseHoverBmp, SKINFOLDER);

	lstrcpyA(img->szMinimizeBmp, SKINFOLDER);
	lstrcpyA(img->szMinimizeHoverBmp, SKINFOLDER);

	lstrcpyA(img->szRegisterBmp, SKINFOLDER);
	lstrcpyA(img->szRegisterHoverBmp, SKINFOLDER);

	lstrcpyA(img->szStartgameBmp, SKINFOLDER);
	lstrcpyA(img->szStartgameHoverBmp, SKINFOLDER);


	lstrcatA(img->szCancelBmp, "\\cancel.bmp");
	lstrcatA(img->szCancelHoverBmp, "\\cancel_hover.bmp");

	lstrcatA(img->szCloseBmp, "\\close.bmp");
	lstrcatA(img->szCloseHoverBmp, "\\close_hover.bmp");

	lstrcatA(img->szMinimizeBmp, "\\minimize.bmp");
	lstrcatA(img->szMinimizeHoverBmp, "\\minimize_hover.bmp");

	lstrcatA(img->szRegisterBmp, "\\register.bmp");
	lstrcatA(img->szRegisterHoverBmp, "\\register_hover.bmp");

	lstrcatA(img->szStartgameBmp, "\\startgame.bmp");
	lstrcatA(img->szStartgameHoverBmp, "\\startgame_hover.bmp");

	//------------------------
	// MINIMIZE BUTTON
	//------------------------
	hbmMinimize = (HBITMAP)LoadImage(NULL, img->szMinimizeBmp,
	                                 IMAGE_BITMAP,
	                                 0, 0, LR_LOADFROMFILE
	                                );

	if(!hbmMinimize)
	{
		PostError(TRUE, "Failed to load minimize.bmp.");
	}

	hbmMinimize_hover = (HBITMAP)LoadImage(NULL, img->szMinimizeHoverBmp,
	                                       IMAGE_BITMAP,
	                                       0, 0, LR_LOADFROMFILE
	                                      );

	if(!hbmMinimize_hover)
	{
		PostError(TRUE, "Failed to load minimize_hover.bmp.");
	}


	hbmClose = (HBITMAP)LoadImage(NULL, img->szCloseBmp,
	                              IMAGE_BITMAP,
	                              0, 0, LR_LOADFROMFILE
	                             );

	if(!hbmClose)
	{
		PostError(TRUE, "Failed to load close.bmp.");
	}

	hbmClose_hover = (HBITMAP)LoadImage(NULL, img->szCloseHoverBmp,
	                                    IMAGE_BITMAP,
	                                    0, 0, LR_LOADFROMFILE
	                                   );

	if(!hbmMinimize_hover)
	{
		PostError(TRUE, "Failed to load close_hover.bmp.");
	}


	hbmStartGame = (HBITMAP)LoadImage(NULL, img->szStartgameBmp,
	                                  IMAGE_BITMAP,
	                                  0, 0, LR_LOADFROMFILE
	                                 );

	if(!hbmStartGame)
	{
		PostError(TRUE, "Failed to load startgame.bmp.");
	}

	hbmStartGame_hover = (HBITMAP)LoadImage(NULL, img->szStartgameHoverBmp,
	                                        IMAGE_BITMAP, 0, 0,
	                                        LR_LOADFROMFILE
	                                       );

	if(!hbmStartGame_hover)
	{
		PostError(TRUE, "Failed to load startgame_hover.bmp.");
	}

	hbmRegister = (HBITMAP)LoadImage(NULL, img->szRegisterBmp,
	                                 IMAGE_BITMAP,
	                                 0, 0,
	                                 LR_LOADFROMFILE
	                                );

	if(!hbmRegister)
	{
		PostError(TRUE, "Failed to load register.bmp.");
	}

	hbmRegister_hover = (HBITMAP)LoadImage(NULL, img->szRegisterHoverBmp,
	                                       IMAGE_BITMAP, 0, 0,
	                                       LR_LOADFROMFILE
	                                      );

	if(!hbmRegister_hover)
	{
		PostError(TRUE, "Failed to load register_hover.bmp.");
	}


	hbmCancel = (HBITMAP)LoadImage(NULL, img->szCancelBmp,
	                               IMAGE_BITMAP,
	                               0, 0,
	                               LR_LOADFROMFILE
	                              );

	if(!hbmCancel)
	{
		PostError(TRUE, "Failed to load cancel.bmp.");

	}

	hbmCancel_hover = (HBITMAP)LoadImage(NULL, img->szCancelHoverBmp,
	                                     IMAGE_BITMAP,
	                                     0, 0,
	                                     LR_LOADFROMFILE
	                                    );

	if(!hbmCancel_hover)
	{
		PostError(TRUE, "Failed to load cancel_hover.bmp.");
	}

}
コード例 #26
0
/// SimpleDPX::BuildScanPattern
// Build the scan pattern for the given element and element description
// Returns true for YUV scans.
bool SimpleDPX::BuildScanPattern(struct ImageElement *el)
{
  struct ScanElement **slp = &(el->m_pScanPattern);
  bool yuv = false;
  UBYTE i;

  switch(el->m_ucDescriptor) {
  case 0:
  case 1:
  case 2:
  case 3:
  case 6:
  case 4:
  case 8: // Depth image. Ok, encode this as alpha for the time being.
    // This is alpha only
    // These are single-component elements.
    if (el->m_ucDescriptor == 4 || el->m_ucDescriptor == 8) {
      el->m_ucAlphaDepth = 1;
    } else {
      el->m_ucDepth      = 1;
    }
    //
    new ScanElement(slp,0);
    break;
  case 7: // This is CbCr, alternating. Is this also subsampled in Y direction?
    el->m_ucDepth      = 2;
    el->m_ucSubX       = 2;
    el->m_ucSubY       = 2; // I hope so...
    yuv                = true;
    //
    // Create two scan elements. The first scans Cb, the second Cr.
    new ScanElement(slp,0);
    new ScanElement(slp,1);
  case 9:
    // "Composite video". Largely underspecified. No idea what the samples are here.
    yuv = true;
    PostError("found composite video element in DPX file %s. "
	      "DPX specifications are unsufficient for implementation",m_pcFileName);
    break;
  case 50:
    // This is BGR (not RGB)
    el->m_ucDepth      = 3;
    // Create three scan elements in the order B,G,R.
    new ScanElement(slp,2);
    new ScanElement(slp,1);
    new ScanElement(slp,0);
    break;
  case 51:
    // This is BGRA (not RGBA)
    el->m_ucDepth      = 3;
    el->m_ucAlphaDepth = 1;
    // Create three scan elements in the order B,G,R,A.
    new ScanElement(slp,2);
    new ScanElement(slp,1);
    new ScanElement(slp,0);
    new ScanElement(slp,MAX_UWORD);
    break;
  case 52:
    // This is ARGB
    el->m_ucDepth      = 3;
    el->m_ucAlphaDepth = 1;
    // Create three scan elements in the order A,R,G,B
    new ScanElement(slp,MAX_UWORD);
    new ScanElement(slp,0);
    new ScanElement(slp,1);
    new ScanElement(slp,2);
    break;
  case 100:
    // This is V210, CbYCrY repeated.
    el->m_ucDepth      = 3;
    el->m_ucSubX       = 2;
    yuv                = true;
    // Create three scan elements in the order Cb,Y,Cr,Y
    new ScanElement(slp,1);
    new ScanElement(slp,0);
    new ScanElement(slp,2);
    new ScanElement(slp,0);
    break;
  case 101:
    // This is CbYACrYA
    el->m_ucDepth      = 3;
    el->m_ucAlphaDepth = 1;
    el->m_ucSubX       = 2;
    yuv                = true;
    // Create scan elements in the order Cb,Y,A,Cr,Y,A
    new ScanElement(slp,1);
    new ScanElement(slp,0);
    new ScanElement(slp,MAX_UWORD);
    new ScanElement(slp,2);
    new ScanElement(slp,0);
    new ScanElement(slp,MAX_UWORD);
    break;
  case 102:
    // This is CbYCr repeated, non-subsampled.
    el->m_ucDepth      = 3;
    yuv                = true;
    // Create scan elements in the order Cb,Y,Cr
    new ScanElement(slp,1);
    new ScanElement(slp,0);
    new ScanElement(slp,2);
    break;
  case 103:
    // This is CbYCrA repeated, non-subsampled.
    el->m_ucDepth      = 3;
    el->m_ucAlphaDepth = 1;
    yuv                = true;
    new ScanElement(slp,1);
    new ScanElement(slp,0);
    new ScanElement(slp,2);
    new ScanElement(slp,MAX_UWORD);
    break;
  case 150:
  case 151:
  case 152:
  case 153:
  case 154:
  case 155:
  case 156:
    // This is a generic n-element image, with n = 2..8.
    el->m_ucDepth      = el->m_ucDescriptor - 150 + 2;
    for(i = 0;i < el->m_ucDepth;i++) {
      new ScanElement(slp,i);
    }
    break;
  default:
    PostError("found unspecified DPX element descriptor in file %s",m_pcFileName);
    break;
  }

  return yuv;
}
コード例 #27
0
/// SimpleDPX::ParseHeader
// Parse the file header of a DPX file
void SimpleDPX::ParseHeader(FILE *file,struct ImgSpecs &specs)
{
  ULONG hdr;
  char version[9];
  ULONG encryption;
  UWORD orientation;
  UWORD depth,alpha;
  ULONG width,height;
  UWORD i;
  struct ComponentLayout *cl;

  m_bLittleEndian = false;

  hdr = GetLong(file);

  if (hdr == MakeID('S','D','P','X')) {
    // This is big-endian.
    m_bLittleEndian = false;
  } else if (hdr == MakeID('X','P','D','S')) {
    m_bLittleEndian = true;
  } else {
    PostError("input file %s is not a valid DPX file",m_pcFileName);
  }

  m_ulDataOffset = GetLong(file);
  
  version[8] = 0;
  GetString(file,version,8);

  if (strcmp(version,"V1.0") && strcmp(version,"V2.0"))
    PostError("unsupported DPX version detected, only V1.0 and V2.0 are supported");

  SkipBytes(file,8); // file size and ditto key are not really needed.
  //
  // Read sizes of data structures.
  m_ulGenericSize  = GetLong(file);
  m_ulIndustrySize = GetLong(file);
  m_ulUserSize     = GetLong(file);
  //
  // Skip over the bytes we do not care about.
  SkipBytes(file,100+24+100+200+200);
  //
  // Read the encyrption key.
  encryption       = GetLong(file);
  if (encryption  != ULONG(~0UL))
    fprintf(stderr,"Warning! - DPX file %s signals encryption, output may be wrong.\n",m_pcFileName);
  //
  // Skip over the rest of the header. not needed.
  SkipBytes(file,104);
  
  //
  // Read the image orientation
  orientation      = GetWord(file);
  if (orientation >= 8)
    PostError("unknown orientation specified in DPX file %s, must be between 0 and 7",m_pcFileName);
  m_bFlipX  = (orientation & 1)?true:false;
  m_bFlipY  = (orientation & 2)?true:false;
  m_bFlipXY = (orientation & 4)?true:false;

  m_usElements     = GetWord(file);
  if (m_usElements == 0 || m_usElements > 8)
    PostError("number of image elements must be between 1 and 8 in DPX file %s",m_pcFileName);

  width  = GetLong(file);
  height = GetLong(file);
  if (m_bFlipXY) {
    m_ulHeight       = width;
    m_ulWidth        = height;
  } else {
    m_ulWidth        = width;
    m_ulHeight       = height;
  } 
  specs.ASCII        = ImgSpecs::No;
  specs.Interleaved  = (m_usElements == 1)?(ImgSpecs::Yes):(ImgSpecs::No);
  specs.YUVEncoded   = ImgSpecs::No; // changed possibly to Yes later on.
  specs.Palettized   = ImgSpecs::No;
  specs.LittleEndian = (m_bLittleEndian)?(ImgSpecs::Yes):(ImgSpecs::No);
  //
  // Image elements. All eight are always present, though only the first m_usElements contain
  // valid data.
  for(i = 0;i < 8;i++) {
    if (i < m_usElements) {
      m_Elements[i].m_ulWidth  = width;
      m_Elements[i].m_ulHeight = height;
      if (ParseElementHeader(file,m_Elements + i))
	specs.YUVEncoded   = ImgSpecs::Yes;
    } else {
      // Skip over elements we do not need
      SkipBytes(file,4*5 + 1*4 + 2*2 + 4*3 + 32);
    }
  }
  //
  // The rest is junk we do not need.
  //
  // Now compute the depth of the image.
  depth = 0;
  alpha = 0;
  for (i = 0;i < m_usElements;i++) {
    depth += m_Elements[i].m_ucDepth;
    alpha += m_Elements[i].m_ucAlphaDepth;
  }
  CreateComponents(m_ulWidth,m_ulHeight,depth + alpha);
  //
  // Now create the planes and allocate memory.
  cl = m_pComponent;
  for(i = 0;i < m_usElements;i++) {
    struct ImageElement *el = m_Elements + i;
    struct ScanElement  *sl = el->m_pScanPattern;
    while(sl) {
      struct ComponentLayout *cll; 
      UBYTE bytesperpixel      = (el->m_ucBitDepth + 7) >> 3;
      UBYTE subx               = el->m_ucSubX;
      UBYTE suby               = el->m_ucSubY;
      UWORD k                  = sl->m_usTargetChannel;
      //
      // If flipXY is set, then X and Y change their role, so flip them now.
      if (m_bFlipXY) {
	subx = el->m_ucSubY;
	suby = el->m_ucSubX;
      }
      //
      // LUMA and alpha is always encoded without subsampling.
      if (k == 0 || k == 3) {
	subx = suby = 1;
      }
      //
      // Is this an alpha component or not?
      if (k == MAX_UWORD) {
	cll   = cl + el->m_ucDepth;
	k     = el->m_ucDepth;
      } else {
	cll   = cl + k;
      }
      cll->m_ucBits            = m_Elements[i].m_ucBitDepth;
      cll->m_bSigned           = m_Elements[i].m_bSigned;
      cll->m_bFloat            = m_Elements[i].m_bFloat;
      cll->m_ucSubX            = subx;
      cll->m_ucSubY            = suby;
      cll->m_ulWidth           = (m_ulWidth  + subx - 1) / subx;
      cll->m_ulHeight          = (m_ulHeight + suby - 1) / suby;
      cll->m_ulBytesPerPixel   = bytesperpixel;
      cll->m_ulBytesPerRow     = cll->m_ulWidth * bytesperpixel;
      // Check whether we have already data for this channel. If not, allocate now.
      // As a channel may appear multiple times in one scan pattern, make sure to
      // allocate only once.
      if (el->m_pData[k] == NULL) {
	el->m_pData[k] = new UBYTE[cll->m_ulWidth * bytesperpixel * cll->m_ulHeight];
	cll->m_pPtr    = el->m_pData[k];
	sl->m_bFirst   = true;
      }
      sl->m_pData      = cll->m_pPtr;
      sl->m_pComponent = cll;
      sl = sl->m_pNext;
    }
    // Adjust the components.
    cl += el->m_ucDepth + el->m_ucAlphaDepth;
  }
}
コード例 #28
0
/// SimpleDPX::ParseElementHeader
// Parse a single element header from the given file.
bool SimpleDPX::ParseElementHeader(FILE *file,struct ImageElement *el)
{
  ULONG sign;
  UBYTE xfer,color;
  UWORD packing,encoding;
  bool yuv = false;
  //
  // Read an element.
  sign = GetLong(file);
  switch(sign) {
  case 0:
    el->m_bSigned = false;
    break;
  case 1:
    el->m_bSigned = true;
    break;
  default:
    PostError("found invalid signedness indicator in DPX file %s, must be either 1 or 0",m_pcFileName);
    break;
  }
  // Next four are luma scaling attributes we do not need to support.
  SkipBytes(file,4+4+4+4);
  //
  el->m_ucDescriptor = GetByte(file);
  //
  // Read the transfer characteristics. Not that we do anything about it.
  xfer = GetByte(file);
  if (xfer > 12)
    PostError("found unspecified DPX transfer characteristics in file %s",m_pcFileName);
  //
  // Read the colorimetric specification. Nothing we can make use of.
  color = GetByte(file);
  if (color > 10)
    PostError("found invalid colorimetric specification in DPX file %s",m_pcFileName);
  //
  el->m_ucBitDepth = GetByte(file);
  // Get the packing information. 0 is full packing,
  // 1 is with packing bits at the LSB side, 2 is with packing bits at
  // the MSB side.
  packing          = GetWord(file);
  if (packing > 2)
    PostError("found invalid DPX padding specification in file %s",m_pcFileName);
  //
  switch(el->m_ucBitDepth) {
  case 8:
  case 16:
    // These are all integer bit depths DPX allows. No padding, no packing.
    break;
  case 1:
    // 11 bit elements are packed to 32 bit LONGs
    // No padding bits.
    el->m_ucPackElements = 32;
    break;
  case 10:
    // 10 bit elements are packed to 32 bit LONGs
    // Padding is possible.
    switch(packing) {
    case 1:
      el->m_ucLSBPaddingBits = 2;
      break;
    case 2:
      el->m_ucMSBPaddingBits = 2;
      break;
    }
    el->m_ucPackElements = 3;
    break;
  case 12:
    // 12 bit elements are packed to 32 bit LONGs.
    // Three elements are packed into one 32 bit word.
    switch(packing) {
    case 1:
      el->m_ucLSBPaddingBits = 4;
      break;
    case 2:
      el->m_ucMSBPaddingBits = 4;
      break;
    }
    el->m_ucPackElements = 1;
    break;
  case 32:
  case 64:
    el->m_bFloat     = true;
    break;
  default:
    PostError("found invalid DPX bit depth in file %s",m_pcFileName);
    break;
  }
  //
  yuv = BuildScanPattern(el);
  //
  // Get the encoding information.
  encoding = GetWord(file);
  switch(encoding) {
  case 0:
    // no encoding.
    break;
  case 1:
    // RLE encoding.
    el->m_bRLE = true;
    // No idea what RLE and FLOAT is supposed to mean. How is the run length
    // encoded?
    if (el->m_bFloat)
      PostError("RLE encoding and floating point samples as found in file %s "
		"are undocumented in the DPX specs and not supported",m_pcFileName);
    break;
  default:
    PostError("found invalid DPX encoding specification in file %s",m_pcFileName);
    break;
  }
  //
  // Get the offset to the data.
  el->m_ulOffset = GetLong(file);
  //
  // Read end of line/end of frame padding.
  el->m_ulEndOfLinePadding  = GetLong(file);
  // Read end of frame padding.
  el->m_ulEndOfFramePadding = GetLong(file);
  //
  // Skip the 32 bytes description.
  SkipBytes(file,32);
  //
  return yuv;
}
コード例 #29
0
ファイル: PolyHook.cpp プロジェクト: johndpope/PolyHook
bool PLH::IATHook::FindIATFunc(const char* LibraryName,const char* FuncName, PIMAGE_THUNK_DATA* pFuncThunkOut,const char* Module)
{
	bool UseModuleName = true;
	if (Module == NULL || Module[0] == '\0')
		UseModuleName = false;

	HINSTANCE hInst = GetModuleHandleA(UseModuleName ? Module:NULL);
	if (!hInst)
	{
		PostError(RuntimeError(RuntimeError::Severity::UnRecoverable, "PolyHook IATHook:Failed to find Module"));
		return false;
	}

	ULONG Sz;
	PIMAGE_IMPORT_DESCRIPTOR pImports = (PIMAGE_IMPORT_DESCRIPTOR)
		ImageDirectoryEntryToDataEx(hInst, TRUE, IMAGE_DIRECTORY_ENTRY_IMPORT, &Sz, nullptr);

	for (int i = 0; pImports[i].Characteristics != 0; i++)
	{
		char* _ModuleName = (char*)ResolveRVA(hInst, pImports[i].Name);
		if (_stricmp(_ModuleName, LibraryName) != 0)
			continue;

		//Original holds the API Names
		PIMAGE_THUNK_DATA pOriginalThunk = (PIMAGE_THUNK_DATA)
			ResolveRVA(hInst, pImports->OriginalFirstThunk);

		//FirstThunk is overwritten by loader with API addresses, we change this
		PIMAGE_THUNK_DATA pThunk = (PIMAGE_THUNK_DATA)
			ResolveRVA(hInst, pImports->FirstThunk);
		
		if (!pOriginalThunk)
		{
			PostError(RuntimeError(RuntimeError::Severity::Critical, "PolyHook IATHook:PE Files without OriginalFirstThunk are unsupported"));
			return false;
		}

		//Table is null terminated, increment both tables
		for (; pOriginalThunk->u1.Function != NULL; pOriginalThunk++,pThunk++)
		{
			if (IMAGE_SNAP_BY_ORDINAL(pOriginalThunk->u1.Ordinal))
			{
				XTrace("Import By Ordinal:[Ordinal:%d]\n",IMAGE_ORDINAL(pOriginalThunk->u1.Ordinal));
				continue;
			}

			PIMAGE_IMPORT_BY_NAME pImport = (PIMAGE_IMPORT_BY_NAME)
				ResolveRVA(hInst, pOriginalThunk->u1.AddressOfData);

			XTrace("Import By Name: [Ordinal:%d] [Name:%s]\n", IMAGE_ORDINAL(pOriginalThunk->u1.Ordinal),pImport->Name);

			//Check the name of API given by OriginalFirthThunk
			if (_stricmp(FuncName, pImport->Name) != 0)
				continue;
			
			/*Name matched in OriginalFirstThunk, return FirstThunk
			so we can changed it's address*/
			*pFuncThunkOut = pThunk;
			return true;
		}
	}
	PostError(RuntimeError(RuntimeError::Severity::UnRecoverable, "PolyHook IATHook:Failed to find import"));
	return false;
}
コード例 #30
0
static Boolean NextIndSpec(SeqSpec *indSpec, SeqSpec *thisSpec)

{
	char *cPos, line[256];
	int i;

	static SeqSpec tempSpec = {NULL,NULL,NULL,NULL,0,0,0,UNDEF};

	static char options[5][80], currIndFName[256];
	static int depth;
	static FILE *file[5];

/*
**  Is this the same indirect command file or a new one?  If so,
**  copy the filename to list at the zero level. Open the file and
**  see if it exists. Scan it for ".." to see there are any header comments
**  if ".." cannot be found start back at the top.  Read the first line
**  of the file by jumping to the "NextLine" label.  This seem a little
**  convoluted but remeber that this peice of code get executed once, from
**  then on it's a nice little dance between the "NextLine" and "NextSeqSpec"
**  labels. Read the comments, it does make sence.
*/

	if ( strcmp(currIndFName, indSpec->file) != 0 ) {
	  depth = 0;
	  if ( indSpec->file) strcpy(currIndFName, indSpec->file);
	  if ( indSpec->options) strcpy(options[depth],indSpec->options);
	  if ( (file[depth] = fopen(&indSpec->file[1], "r")) == NULL )
	    return(0);
	  while ( fgets(line, 255, file[depth]) )
	    if ( StrIndex("..", line) ) break;
	  if ( feof(file[depth]) ) rewind(file[depth]);
	  goto NextLine;
	}

/*
** At this point a Spec is either from a User file or a database.
*/

NextSeqSpec:

	if ( tempSpec.isUser ) {
	  if ( NextUserSpec(&tempSpec, thisSpec) )
	    return(1);
	} else {
	  if ( NextDBSpec(&tempSpec, thisSpec) )
	    return(1);
	}
/*
** Get a line from the indirect file(s), goto NextSeqSpec until it
** the current spec exhausts, i.e. returns false.  At which point you will
** fall through to here in order to read the next line. 
*/

NextLine:
	while ( depth >= 0 ) {
	  while ( fgets(line, 255, file[depth]) ) {
	    if ( (cPos = strchr(line, ' ')) ) *cPos = '\0';  /* First token */
	    if ( (cPos = strchr(line, '!')) ) *cPos = '\0';  /* Uncomment   */
	    if ( (cPos = strchr(line, '\n')) )*cPos = '\0';  /* String-ize  */
	    if ( line[0] == '\0' ) continue;               /* Blank line  */
	    if ( line[0] == '@' ) {                        /* Another FOSS*/
	      if ( depth < 5 ) {
	        depth++;
	        if ( (cPos = strchr(line,'/')) ) {
	          strcpy(options[depth],cPos);
	          *cPos = '\0';
	        }
	        if ( (file[depth] = fopen(&line[1], "r")) ) {
	          while ( fgets(line, 255, file[depth]) )
	            if ( StrIndex("..", line) ) break;
	          if ( feof(file[depth]) ) rewind(file[depth]);
	        } else {
	          depth--;
	        }
	      } else {
	        PostError(2,"SeqSpec lists are too deeply nested!!");
	      }
	    } else {                         /* A Sequence Spec              */
	      for ( i=depth; i>=0; i-- )     /* Append the options from every*/
	        strcat(line, options[i]);    /*   FOSS file which came before*/
	      MakeSeqSpec(&tempSpec, line);  /* Assign the SeqSpec structure */
	      goto NextSeqSpec;              /* Dispatch and run down.        */
	    }
	  }
	  fclose(file[depth]);
	  depth--;
	}
/*
**  Fall through to here when all of the Sequence Specification from all
**  of the FOSS files are finished.
*/
	currIndFName[0] = '\0';
	return(0);
}