示例#1
0
int xDeviceStream::ReadInt32( void )
{
    if (IsClosed)
    {
        throw xException("Stream is closed. At: xDeviceStream::ReadInt32");
    }
    else if (Position() > Length() - sizeof(INT32))
    {
        throw xException("End of file reached.  At: xDeviceStream::ReadInt32");
    }

    // Get the size of the object
    int size = sizeof(int);

    // Create a new temporary buffer that will hold the bytes for the object
    BYTE temp[4];
    // Read the data
    Read((BYTE*)&temp, size);

    // Initialize our return value
    int Return = 0;

    /* Do a loop that starts out at size * 8 (for an Int32 that would be 24),
         * shift the data at index i by that value, OR that value.  Repeat after addition, subtraction and shit */
    for (int i = 0, j = (size * 8) - 8; i < size; i++, j -= 8)
    {
        Return |= (int)temp[i] << j;
    }

    return Return;
}
示例#2
0
UINT32 xMultiFileStream::ReadUInt32( void )
{
    if (IsClosed)
    {
        throw xException("Stream is closed. At: xMultiFileStream::ReadUInt32");
    }
    else if (Position() > Length() - sizeof(UINT32))
    {
        throw xException("End of file reached.  At: xMultiFileStream::ReadUInt32");
    }

    int size = sizeof(UINT32);

    BYTE temp[4];

    Read((BYTE*)&temp, size);

    UINT32 Return = 0;

    for (int i = 0, j = (size * 8) - 8; i < size; i++, j -= 8)
    {
        Return |= (UINT32)temp[i] << j;
    }

    return Return;
}
示例#3
0
UINT64 xDeviceStream::ReadUInt64( void )
{
    if (IsClosed)
    {
        throw xException("Stream is closed. At: xDeviceStream::ReadUInt64");
    }
    else if (Position() > Length() - sizeof(UINT64))
    {
        throw xException("End of file reached.  At: xDeviceStream::ReadUInt64");
    }

    int size = sizeof(UINT64);

    BYTE temp[8];
    Read(temp, size);

    UINT64 Return = 0;

    for (int i = 0, j = (size * 8) - 8; i < size; i++, j -= 8)
    {
        Return |= (UINT64)temp[i] << j;
    }

    return Return;
}
示例#4
0
void xDeviceStream::WriteByte( BYTE _Byte )
{
    if (IsClosed)
    {
        throw xException("Stream is closed. At: xDeviceStream::WriteByte");
    }
    else if (Position() + sizeof(BYTE) > Length())
    {
        throw xException("End of file reached.  At: xDeviceStream::WriteByte");
    }
    Write(&_Byte, 1);
}
示例#5
0
void xDeviceStream::WriteInt16( short _Int16 )
{
    if (IsClosed)
    {
        throw xException("Stream is closed. At: xDeviceStream::WriteInt16");
    }
    else if ((Position() + sizeof(short)) > Length())
    {
        throw xException("End of file reached.  At: xDeviceStream::WriteInt16");
    }
    DetermineAndDoEndianSwap((BYTE*)&_Int16, sizeof(short), sizeof(BYTE));
    Write((BYTE*)&_Int16, sizeof(short));
}
示例#6
0
void xMultiFileStream::WriteUInt32( UINT32 _UInt32 )
{
    if (IsClosed)
    {
        throw xException("Stream is closed. At: xMultiFileStream::WriteUInt32");
    }
    else if (Position() + sizeof(UINT32) > Length())
    {
        throw xException("End of file reached.  At: xMultiFileStream::WriteUInt32");
    }

    DetermineAndDoEndianSwap((BYTE*)&_UInt32, sizeof(UINT32), sizeof(BYTE));
    Write((BYTE*)&_UInt32, sizeof(UINT32));
}
示例#7
0
void xDeviceStream::WriteUInt64( UINT64 _UInt64 )
{
    if (IsClosed)
    {
        throw xException("Stream is closed. At: xDeviceStream::WriteUInt64");
    }
    else if ((Position() + sizeof(UINT64)) > Length())
    {
        throw xException("End of file reached.  At: xDeviceStream::WriteUInt64");
    }

    DetermineAndDoEndianSwap((BYTE*)&_UInt64, sizeof(UINT64), sizeof(BYTE));
    Write((BYTE*)&_UInt64, sizeof(UINT64));
}
示例#8
0
int xMultiFileStream::Read( BYTE* DestBuff, int Count )
{
    int Offset = 0;
    if (IsClosed)
    {
        throw xException("Stream is closed. At: xMultiFileStream::Read");
    }

    //SetPosition(Position());

    // Check to see if we can read straight from the current stream
    if (FileStreams.at(CurrentStream)->Position() + Count > FileStreams.at(CurrentStream)->Length())
    {
        // Balls, we can't. For each stream, loop for how much data we can read until we've read all of it
        while (Count > 0)
        {
            DWORD Read = FileStreams.at(CurrentStream)->Read(DestBuff + Offset, Count);
            Offset += Read;
            Count -= Read;
            SetPosition(Position() + Read);
        }
        DetermineAndDoArraySwap(DestBuff, Count, true);
        return Count;
    }
    else
    {
        // We can. Yay.
        DWORD Read = FileStreams.at(CurrentStream)->Read(DestBuff, Count);
        SetPosition(Position() + Read);
        DetermineAndDoArraySwap(DestBuff, Count, true);
        return Read;
    }
}
示例#9
0
BYTE xDeviceStream::ReadByte( void )
{
    if (IsClosed)
    {
        throw xException("Stream is closed. At: xDeviceStream::ReadByte");
    }
    else if (Position() > Length() - sizeof(BYTE))
    {
        throw xException("End of file reached.  At: xDeviceStream::ReadByte");
    }

    BYTE Return;
    Read(&Return, 1);

    return Return;
}
示例#10
0
std::string xDeviceStream::ReadCString( void )
{
    if (IsClosed)
    {
        throw xException("Stream is closed. At: xDeviceStream::ReadCString");
    }
    std::vector<char> temp;
    bool Null;
    do
    {
        char c = (char)ReadByte();
        temp.push_back(c);
        if (c == 0)
        {
            Null = true;
        }
    }
    while (!Null);

    char* tempString = new char[temp.size()];
    for (int i = 0; i < (int)temp.size(); i++)
    {
        tempString[i] = temp.at(i);
    }

    DetermineAndDoEndianSwap(tempString, temp.size() - 1, sizeof(char));

    std::string Return(tempString);

    delete[] tempString;
    return Return;
}
示例#11
0
xDeviceStream::xDeviceStream( TCHAR* DevicePath )
{
    // Set our variables
    _Length = 0;
    _Endian = Big;
    IsClosed = false;
    UserOffset = 0;
    LastReadOffset = -1;
    IsClosed = false;
#ifdef _WIN32
    memset(&Offset, 0, sizeof(OVERLAPPED));
#else
    memset(&LastReadData, 0, 0x200);
    Offset = 0;
#endif

#ifdef _WIN32
    // Attempt to get a handle to the device
    DeviceHandle = CreateFile(
                DevicePath,							// File name (device path)
                GENERIC_READ | GENERIC_WRITE,		// Read/write access
                FILE_SHARE_READ | FILE_SHARE_WRITE,	// Read/write share
                NULL,								// Not used
                OPEN_EXISTING,						// Open the existing device -- fails if it's f****d
                FILE_FLAG_NO_BUFFERING | FILE_FLAG_WRITE_THROUGH | FILE_ATTRIBUTE_DEVICE,	// Flags and attributes
                NULL);								// Ignored

    if (DeviceHandle == INVALID_HANDLE_VALUE)
    {
        throw xException("Could not open HANDLE for device");
    }
#endif
#if (defined __APPLE__ || defined __linux)
    // UNIX/LINUX/APPLE
    char Path[0x200] = {0};

    // Convert wchar_t string to standard ASCII string
    wcstombs(Path, DevicePath, wcslen(DevicePath));
    // Open the device
    Device = open(Path, O_RDWR);
    if (Device == -1)
    {
        throw xException("Error opening device");
    }
#endif

}
示例#12
0
short xDeviceStream::ReadInt16( void )
{
    if (IsClosed)
    {
        throw xException("Stream is closed. At: xDeviceStream::ReadInt16");
    }
    else if (Position() > Length() - sizeof(INT16))
    {
        throw xException("End of file reached.  At: xDeviceStream::ReadInt16");
    }

    BYTE temp[2];
    Read((BYTE*)&temp, 2);

    short Return = (short)temp[0] << 8 | temp[1];

    return Return;
}
示例#13
0
std::string xDeviceStream::ReadString( size_t Count )
{
    if (IsClosed)
    {
        throw xException("Stream is closed. At: xDeviceStream::ReadString");
    }
    if ((Position() + Count) > Length())
    {
        throw xException("Can not read beyond end of stream.  At: xDeviceStream::ReadString");
    }
    BYTE* Buffer = new BYTE[Count + 1];
    memset(Buffer, 0, Count + 1);

    Read(Buffer, Count);
    std::string ret((char*)Buffer);
    delete[] Buffer;

    return ret;
}
示例#14
0
std::wstring xMultiFileStream::ReadUnicodeString( size_t Count )
{
    if (IsClosed)
    {
        throw xException("Stream is closed. At: xMultiFileStream::ReadUnicodeString");
    }
    else if (Position() + Count > Length())
    {
        throw xException("Can not read beyond end of stream.  At: xMultiFileStream::ReadUnicodeString");
    }

    BYTE* Buffer = new BYTE[Count + 1];
    memset(Buffer, 0, Count + 1);

    Read(Buffer, Count + 1);

    std::wstring ret((TCHAR*)Buffer);

    delete[] Buffer;
    return ret;
}
示例#15
0
int xMultiFileStream::Write( BYTE* Buffer, int count )
{
    int offset;
    if (IsClosed)
    {
        throw xException("Stream is closed. At: xMultiFileStream::WriteBytes");
    }
    if (Position() + count > Length())
    {
        throw xException("Can not write beyond end of stream");
    }

    //SetPosition(Position());
    // Check to see if we can write straight to the current stream
    if (FileStreams.at(CurrentStream)->Position() + count > FileStreams.at(CurrentStream)->Length())
    {
        // Balls, we can't. For each stream, loop for how much data we can write until we've written all of it
        while (count > 0)
        {
            // The amount of data that can be written for the current stream
            DWORD AmountWeCanWrite = (DWORD)(FileStreams.at(CurrentStream)->Length() - FileStreams.at(CurrentStream)->Position());
            if (AmountWeCanWrite > (DWORD)count)
            {
                AmountWeCanWrite = count;
            }
            DWORD Written = FileStreams.at(CurrentStream)->Write(Buffer, offset, AmountWeCanWrite);
            offset += Written;
            count -= Written;
            SetPosition(Position() + Written);
        }
        return count;
    }
    else
    {
        // We can. Yay.
        DWORD Written = FileStreams.at(CurrentStream)->Write(Buffer, offset, count);
        SetPosition(Position() + Written);
        return Written;
    }
}
示例#16
0
	// Run a Pork command after starting interpreter
	void RunCmd(string module, string args)
	{
		PyObject *pCmdMod, *pCmdClassName, *pDict, *pCmdClass, *pCmdArgs;
		Py_Initialize();

		// Import the module (ex. kill.py)
		pCmdMod = PyImport_ImportModule(module.c_str());
		if(!pCmdMod)
			throw xException("Failed to import module '"+module+"'!");

		pDict = PyDict_New();

		// Build the class name from module
		pCmdClassName = PyDict_GetItemString(pDict, module.c_str());
		Py_XDECREF(pDict);

		// Call the command class
		if(PyCallable_Check(pCmdClassName))
		{
			pCmdArgs = Py_BuildValue("(s)",args.c_str());
			pCmdClass = PyObject_CallObject(pCmdClassName, pCmdArgs);
			Py_DECREF(pCmdArgs);
			Py_DECREF(pCmdClass);
			Py_DECREF(pCmdClassName);
		}
		else
		{
			Py_XDECREF(pCmdClassName);
			Py_XDECREF(pCmdMod);
			throw xException("Failed to get class '"+module+"'!");
		}

		// Once called, all neccassary callback functions
		// have been called, so we are effectively done.
		// So now time for cleanup.
		Py_DECREF(pCmdMod); // Done with module.
		Py_Finalize(); // Done with embedded python.

		return;
	}
示例#17
0
void xDeviceStream::SetPosition( INT64 Position )
{
    if (IsClosed)
    {
        throw xException("Stream is closed. At: xDeviceStream::SetPosition");
    }
    UserOffset = Position;
    Position = Helpers::DownToNearestSector(Position); // Round the position down to the nearest sector offset
#ifdef _WIN32
    Offset.Offset = (DWORD)Position;
    Offset.OffsetHigh = (DWORD)(Position >> 32);
#else
    Offset = Position;
    lseek(Device, Position, SEEK_SET);
#endif
}
示例#18
0
	// Import script to compile, and then get custom properties
	void CompileAndGetProps(string module)
	{
		PyObject *pCmdMod, *pDict, *pCmdClass, *pCmdArgs;
		Py_Initialize();

		// Import the module (ex. kill.py)
		pCmdMod = PyImport_ImportModule(module.c_str());
		if(!pCmdMod)
			throw xException("Failed to import module '"+module+"'!");

		// Get all properties for this module


		Py_DECREF(pCmdMod); // Done with module.
		Py_Finalize(); // Done with embedded python.

		return;
	}
示例#19
0
flength	FileWin::Seek( flength inOff, vuint16 inFrom )
{ 
#if FBL_LENGTH <= 32	
	flength dwNew = (flength) ::SetFilePointer( (HANDLE)mHandle, (vint32)inOff, NULL, (vuint32)inFrom );

	if( dwNew == flength(-1) )
		throw xException( (ERROR_TYPE) ::GetLastError() );

	return dwNew;
	
#else	
	LARGE_INTEGER li;
	li.QuadPart = (vint64) inOff;
	li.LowPart = ::SetFilePointer( (HANDLE)mHandle, (vint32) li.LowPart, &li.HighPart, (DWORD)inFrom );

	if( li.LowPart == 0xFFFFFFFF && GetLastError() != NO_ERROR )
		throw xOSFileError( (ERROR_TYPE) ::GetLastError() );

	return flength(li.QuadPart);
#endif	
}
示例#20
0
void xMultiFileStream::SetPosition( INT64 Position )
{
    // If the position is too large, throw an exception
    if (Position > Length())
    {
        throw xException("Can not seek beyond end of stream", ExStreamSetPosition );
    }
    UserOffset = Position;

    // Find out which stream we can use
    for (int i = 0; i < (int)FileStreams.size(); i++)
    {
        if (Position >= FileStreams.at(i)->Length() && i != FileStreams.size() - 1)
        {
            Position -= FileStreams.at(i)->Length();
        }
        else
        {
            CurrentStream = i;
            FileStreams.at(i)->SetPosition(Position);
            break;
        }
    }
}
void xList::Exchange(int index1, int index2) throw(xException)
{
  void * obj;
  if (FSorted)
    throw xException(DEBUGINFO,"Exchange in a sorted list not allowed");
}
示例#22
0
int xDeviceStream::Write( BYTE* Buffer, int count )
{
    if (IsClosed)
    {
        throw xException("Stream is closed. At: xDeviceStream::Write");
    }
#ifdef _WIN32
    else if (DeviceHandle == INVALID_HANDLE_VALUE)
    {
        throw xException("Error: INVALID_HANDLE_VALUE. At: xDeviceStream::Write");
    }
#endif
    //SetPosition(Position());
    // We can't write beyond the end of the stream
    if (Position() + count > Length())
    {
        // Change the count to whatever we CAN write
        //Count = (int)((Position() >= Length()) ? 0 : Length() - Position());
        throw xException("Can not write beyond end of stream! At xDeviceStream::Write");
    }

    if (count == 0)
    {
        return 0;
    }

    int BytesWeNeedToRead = (int)(Helpers::UpToNearestSector(Position() + count) - Position());

    DWORD BytesRead;
    BYTE* AllData = 0;
    // If the last time we cached data wasn't at this offset, and we're only writing to this sector
    if (LastReadOffset != RealPosition())
    {
        // Cache
#ifdef _WIN32
        ReadFile(
                    DeviceHandle,	// Device to read from
                    LastReadData,	// Output buffer
                    0x200,			// Read the last sector
                    &BytesRead,		// Pointer to the number of bytes read
                    &Offset);		// OVERLAPPED structure containing the offset to read from
#else
        read(Device, LastReadData, 0x200);
#endif
        LastReadOffset = RealPosition();
    }

    if (BytesWeNeedToRead > 0x200)
    {
        AllData = new BYTE[BytesWeNeedToRead];
        // Read the data
#ifdef _WIN32
        ReadFile(
                    DeviceHandle,
                    AllData,
                    BytesWeNeedToRead,
                    &BytesRead,
                    &Offset);
#else
        read(Device, AllData, BytesWeNeedToRead);
#endif

        // Write over the data in memory
        memcpy(AllData + Position() - RealPosition(), Buffer, count);

        // Copy the last part of the data to our cached stuff
        memcpy(LastReadData, AllData + BytesWeNeedToRead - (0x200), 0x200);

        DetermineAndDoArraySwap(AllData, BytesWeNeedToRead);

        // Write the data
#ifdef _WIN32
        WriteFile(
                    DeviceHandle,		// Device to read from
                    AllData,			// Data to write
                    BytesWeNeedToRead,	// Amount of data to write
                    &BytesRead,			// Pointer to number of bytes written (ignore that it says BytesRead)
                    &Offset);			// OVERLAPPED structure containing the offset to write from
#else
        write(Device, AllData, BytesWeNeedToRead);
#endif

        delete[] AllData;
    }
    else
    {
        memcpy(LastReadData + Position() - RealPosition(), Buffer, count);

        void* Data = DetermineAndDoEndianSwap(AllData, BytesWeNeedToRead, sizeof(BYTE), true);

        if (!Data)
        {
            // Write the data
#ifdef _WIN32
            WriteFile(
                        DeviceHandle,		// Device to read from
                        LastReadData,		// Data to write
                        BytesWeNeedToRead,	// Amount of data to write
                        &BytesRead,			// Pointer to number of bytes written (ignore that it says BytesRead)
                        &Offset);			// OVERLAPPED structure containing the offset to write from
#else
            write(Device, LastReadData, BytesWeNeedToRead);
#endif
        }
        else
        {
            // Write the data
#ifdef _WIN32
            WriteFile(
                        DeviceHandle,		// Device to read from
                        Data,				// Data to write
                        BytesWeNeedToRead,	// Amount of data to write
                        &BytesRead,			// Pointer to number of bytes written (ignore that it says BytesRead)
                        &Offset);			// OVERLAPPED structure containing the offset to write from
#else
            write(Device, Data, BytesWeNeedToRead);
#endif
        }
    }

    SetPosition(Position() + count);
    return count;
}
示例#23
0
int xDeviceStream::Read( BYTE* DestBuff, int Count )
{
    if (IsClosed)
    {
        throw xException("Stream is closed. At: xDeviceStream::Read");
    }
#ifdef _WIN32
    else if (DeviceHandle == INVALID_HANDLE_VALUE)
    {
        throw xException("Error: INVALID_HANDLE_VALUE. At: xDeviceStream::Read");
    }
#endif
    //SetPosition(Position());
    // We can't read beyond the end of the stream
    if (Position() + Count > Length())
    {
        // Change the count to whatever we CAN read
        Count = (int)((Position() >= Length()) ? 0 : Length() - Position());
    }

    if (Count == 0)
    {
        return 0;
    }

    BYTE MaxSectors = (BYTE)(Helpers::UpToNearestSector(Count + (Position() - RealPosition())) / 0x200); // This is the number of sectors we have to read
    int BytesToShaveOffBeginning = (int)(Position() - RealPosition());	// Number of bytes to remove from the beginning of the buffer
    int BytesToShaveOffEnd = (int)(Helpers::UpToNearestSector(Position() + Count) - (Position() + Count));
    int BytesThatAreInLastDataRead = 0x200 - BytesToShaveOffBeginning;


    int AllDataLength = BytesToShaveOffBeginning + Count + BytesToShaveOffEnd; /* This adds the BytesToShaveOffBeginning
                                                                                              * all of these cool things to form
                                                                                              * the total size that we'll be reading
                                                                                              * (AllDataLength / 0x200 should equal MaxSectors */
    if (MaxSectors != AllDataLength / 0x200)
    {
        throw xException("Assertion fail: MaxSectors != AllDataLength / 0x200.  At: xDeviceStream::Read");
    }

    BYTE* AllData = 0;
    DWORD BytesRead;

    // If the last time we cached data wasn't at this offset
    if (LastReadOffset != RealPosition())
    {
        // Cache
#ifdef _WIN32
        ReadFile(
                    DeviceHandle,	// Device to read from
                    LastReadData,	// Output buffer
                    0x200,			// Read the last sector
                    &BytesRead,		// Pointer to the number of bytes read
                    &Offset);		// OVERLAPPED structure containing the offset to read from
#else
        read(Device, LastReadData, 0x200);
#endif
        LastReadOffset = RealPosition();
    }

    if (BytesThatAreInLastDataRead <= Count)
    {
        SetPosition(Position() + BytesThatAreInLastDataRead);
    }
    else
    {
        SetPosition(Position() + Count);
    }

    if (MaxSectors > 1)
    {
        AllData = new BYTE[AllDataLength - 0x200];

        // Read for all sectors EXCEPT the last one
#ifdef _WIN32
        ReadFile(
                    DeviceHandle,	// Device to read from
                    AllData,		// Output buffer
                    AllDataLength - 0x200,	// Read the last sector
                    &BytesRead,		// Pointer to the number of bytes read
                    &Offset);		// OVERLAPPED structure containing the offset to read from
#else
        read(Device, AllData, AllDataLength - 0x200);
#endif

        SetPosition(Position() + (Count - BytesThatAreInLastDataRead));
    }
    int countRead = ((BytesThatAreInLastDataRead <= Count) ? BytesThatAreInLastDataRead : Count);
    memcpy(DestBuff, LastReadData + BytesToShaveOffBeginning, countRead);
    if (AllData)
    {
        memcpy(DestBuff + BytesThatAreInLastDataRead, AllData, Count - BytesThatAreInLastDataRead);
        // Cache
        memcpy(&LastReadData, AllData + AllDataLength - ((0x200 * 2)), 0x200);
        //LastReadOffset = RealPosition();
        delete[] AllData;
    }

    DetermineAndDoArraySwap(DestBuff, Count);

    return Count;
}