717 lines
20 KiB
C++
Executable File
717 lines
20 KiB
C++
Executable File
/*===========================================================================
|
|
FILE:
|
|
QDLBuffers.h
|
|
|
|
DESCRIPTION:
|
|
QDL protocol related structures and affliated methods
|
|
|
|
PUBLIC CLASSES AND METHODS:
|
|
sQDLRawHelloReq
|
|
sQDLRawHelloRsp
|
|
sQDLRawErrorRsp
|
|
sQDLRawOpenUnframedReq
|
|
sQDLRawOpenUnframedRsp
|
|
sQDLRawWriteUnframedReq
|
|
sQDLRawWriteUnframedRsp
|
|
sQDLRawDoneRsp
|
|
sQDLRawGetImagePrefRsp
|
|
sQDLRawImageID
|
|
|
|
sQDLHello
|
|
sQDLError
|
|
sQDLOpenUnframed
|
|
sQDLWriteUnframed
|
|
sQDLDone
|
|
sQDLGetImagePref
|
|
|
|
Copyright (c) 2011, Code Aurora Forum. All rights reserved.
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions are met:
|
|
* Redistributions of source code must retain the above copyright
|
|
notice, this list of conditions and the following disclaimer.
|
|
* Redistributions in binary form must reproduce the above copyright
|
|
notice, this list of conditions and the following disclaimer in the
|
|
documentation and/or other materials provided with the distribution.
|
|
* Neither the name of Code Aurora Forum nor
|
|
the names of its contributors may be used to endorse or promote
|
|
products derived from this software without specific prior written
|
|
permission.
|
|
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
|
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
POSSIBILITY OF SUCH DAMAGE.
|
|
===========================================================================*/
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Pragmas
|
|
//---------------------------------------------------------------------------
|
|
#pragma once
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Include Files
|
|
//---------------------------------------------------------------------------
|
|
#include "ProtocolBuffer.h"
|
|
#include "QDLEnum.h"
|
|
|
|
#include <list>
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Pragmas (pack structs)
|
|
//---------------------------------------------------------------------------
|
|
#pragma pack( push, 1 )
|
|
|
|
/*=========================================================================*/
|
|
// Struct sQDLRawHelloReq
|
|
// Struct to represent a QDL hello request (raw)
|
|
/*=========================================================================*/
|
|
struct sQDLRawHelloReq
|
|
{
|
|
public:
|
|
BYTE mCommandCode;
|
|
BYTE mMagicNumber[32];
|
|
BYTE mMaxVersion;
|
|
BYTE mMinVersion;
|
|
BYTE mFeatures;
|
|
};
|
|
|
|
/*=========================================================================*/
|
|
// Struct sQDLRawHelloRsp
|
|
// Struct to represent a QDL hello response (raw)
|
|
/*=========================================================================*/
|
|
struct sQDLRawHelloRsp
|
|
{
|
|
public:
|
|
BYTE mCommandCode;
|
|
BYTE mMagicNumber[24];
|
|
DWORD mReserved1;
|
|
WORD mBootMajorVersion;
|
|
WORD mBootMinorVersion;
|
|
BYTE mMaxVersion;
|
|
BYTE mMinVersion;
|
|
DWORD mReserved2;
|
|
DWORD mReserved3;
|
|
BYTE mReserved4;
|
|
WORD mReserved5;
|
|
WORD mReserved6;
|
|
BYTE mFeatures;
|
|
};
|
|
|
|
/*=========================================================================*/
|
|
// Struct sQDLRawErrorRsp
|
|
// Struct to represent a QDL error response (raw)
|
|
/*=========================================================================*/
|
|
struct sQDLRawErrorRsp
|
|
{
|
|
public:
|
|
BYTE mCommandCode;
|
|
DWORD mErrorCode;
|
|
BYTE mErrorText;
|
|
};
|
|
|
|
/*=========================================================================*/
|
|
// Struct sQDLRawOpenUnframedReq
|
|
// Struct to represent a QDL open unframed image write request (raw)
|
|
/*=========================================================================*/
|
|
struct sQDLRawOpenUnframedReq
|
|
{
|
|
public:
|
|
BYTE mCommandCode;
|
|
BYTE mImageType;
|
|
DWORD mImageLength;
|
|
BYTE mWindowSize;
|
|
DWORD mUnframedChunkSize;
|
|
WORD mReserved1;
|
|
};
|
|
|
|
/*=========================================================================*/
|
|
// Struct sQDLRawOpenUnframedRsp
|
|
// Struct to represent a QDL open unframed image write response (raw)
|
|
/*=========================================================================*/
|
|
struct sQDLRawOpenUnframedRsp
|
|
{
|
|
public:
|
|
BYTE mCommandCode;
|
|
WORD mStatus;
|
|
BYTE mWindowSize;
|
|
DWORD mUnframedChunkSize;
|
|
};
|
|
|
|
/*=========================================================================*/
|
|
// Struct sQDLRawWriteUnframedReq
|
|
// Struct to represent a QDL unframed image write request (raw)
|
|
/*=========================================================================*/
|
|
struct sQDLRawWriteUnframedReq
|
|
{
|
|
public:
|
|
BYTE mCommandCode;
|
|
WORD mSequenceNumber;
|
|
DWORD mReserved;
|
|
DWORD mUnframedChunkSize;
|
|
WORD mCRC;
|
|
};
|
|
|
|
/*=========================================================================*/
|
|
// Struct sQDLRawWriteUnframedRsp
|
|
// Struct to represent a QDL unframed image write response (raw)
|
|
/*=========================================================================*/
|
|
struct sQDLRawWriteUnframedRsp
|
|
{
|
|
public:
|
|
BYTE mCommandCode;
|
|
WORD mSequenceNumber;
|
|
DWORD mReserved;
|
|
WORD mStatus;
|
|
};
|
|
|
|
/*=========================================================================*/
|
|
// Struct sQDLRawDoneRsp
|
|
// Struct to represent a QDL session done response (raw)
|
|
/*=========================================================================*/
|
|
struct sQDLRawDoneRsp
|
|
{
|
|
public:
|
|
BYTE mCommandCode;
|
|
WORD mStatus;
|
|
BYTE mImageType;
|
|
BYTE mErrorText;
|
|
};
|
|
|
|
/*=========================================================================*/
|
|
// Struct sQDLRawGetImagePrefRsp
|
|
// Struct to represent a QDL get image preference response (raw)
|
|
/*=========================================================================*/
|
|
struct sQDLRawGetImagePrefRsp
|
|
{
|
|
public:
|
|
BYTE mCommandCode;
|
|
BYTE mEntries;
|
|
|
|
// Array of sQDLRawImageID follows (sized by mEntries)
|
|
};
|
|
|
|
/*=========================================================================*/
|
|
// Struct sQDLRawImageID
|
|
// Struct to represent a QDL image ID (raw)
|
|
/*=========================================================================*/
|
|
struct sQDLRawImageID
|
|
{
|
|
public:
|
|
BYTE mImageType;
|
|
BYTE mImageID[16];
|
|
};
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Pragmas
|
|
//---------------------------------------------------------------------------
|
|
#pragma pack( pop )
|
|
|
|
|
|
/*=========================================================================*/
|
|
// Struct sQDLHello
|
|
// Struct to represent a QDL hello request/response (shared buffer)
|
|
/*=========================================================================*/
|
|
struct sQDLHello : public sProtocolBuffer
|
|
{
|
|
public:
|
|
// Constructor
|
|
sQDLHello( sSharedBuffer * pBuffer );
|
|
|
|
// Destructor
|
|
virtual ~sQDLHello();
|
|
|
|
// (Inline) Is this a request?
|
|
bool IsRequest() const
|
|
{
|
|
bool bRequest = false;
|
|
if (IsValid() == true)
|
|
{
|
|
const BYTE * pBuf = GetBuffer();
|
|
bRequest = (pBuf[0] == (BYTE)eQDL_CMD_HELLO_REQ);
|
|
}
|
|
|
|
return bRequest;
|
|
};
|
|
|
|
// (Inline) Is this a response?
|
|
bool IsResponse() const
|
|
{
|
|
bool bResponse = false;
|
|
if (IsValid() == true)
|
|
{
|
|
const BYTE * pBuf = GetBuffer();
|
|
bResponse = (pBuf[0] == (BYTE)eQDL_CMD_HELLO_RSP);
|
|
}
|
|
|
|
return bResponse;
|
|
};
|
|
|
|
// (Inline) Return raw request
|
|
const sQDLRawHelloReq * GetRequest() const
|
|
{
|
|
const sQDLRawHelloReq * pReq = 0;
|
|
if (IsRequest() == true)
|
|
{
|
|
pReq = (const sQDLRawHelloReq *)GetBuffer();
|
|
}
|
|
|
|
return pReq;
|
|
};
|
|
|
|
// (Inline) Return raw response
|
|
const sQDLRawHelloRsp * GetResponse() const
|
|
{
|
|
const sQDLRawHelloRsp * pRsp = 0;
|
|
if (IsResponse() == true)
|
|
{
|
|
pRsp = (const sQDLRawHelloRsp *)GetBuffer();
|
|
}
|
|
|
|
return pRsp;
|
|
};
|
|
|
|
// Extract boot downloader version info from the response
|
|
bool GetBootVersionInfo(
|
|
ULONG & major,
|
|
ULONG & minor ) const;
|
|
|
|
// Build a hello request
|
|
static sSharedBuffer * BuildHelloReq( bool bBARMode = false );
|
|
|
|
protected:
|
|
// Is this hello request/response packet valid?
|
|
virtual bool Validate();
|
|
|
|
private:
|
|
// Prevent 'upcopying'
|
|
sQDLHello( const sProtocolBuffer & );
|
|
sQDLHello & operator = ( const sProtocolBuffer & );
|
|
};
|
|
|
|
/*=========================================================================*/
|
|
// Struct sQDLError
|
|
// Struct to represent a QDL error response (shared buffer)
|
|
/*=========================================================================*/
|
|
struct sQDLError : public sProtocolBuffer
|
|
{
|
|
public:
|
|
// Constructor
|
|
sQDLError( sSharedBuffer * pBuffer );
|
|
|
|
// Destructor
|
|
virtual ~sQDLError();
|
|
|
|
// (Inline) Return raw response
|
|
const sQDLRawErrorRsp * GetResponse() const
|
|
{
|
|
const sQDLRawErrorRsp * pRsp = 0;
|
|
if (IsValid() == true)
|
|
{
|
|
pRsp = (const sQDLRawErrorRsp *)GetBuffer();
|
|
}
|
|
|
|
return pRsp;
|
|
};
|
|
|
|
// (Inline) Return the (validated) error code
|
|
eQDLError GetErrorCode() const
|
|
{
|
|
eQDLError err = eQDL_ERROR_ENUM_BEGIN;
|
|
|
|
const sQDLRawErrorRsp * pRsp = GetResponse();
|
|
if (pRsp != 0)
|
|
{
|
|
err = (eQDLError)pRsp->mErrorCode;
|
|
}
|
|
|
|
return err;
|
|
};
|
|
|
|
// (Inline) Return the error text string
|
|
LPCSTR GetError() const
|
|
{
|
|
LPCSTR pErr = 0;
|
|
|
|
const sQDLRawErrorRsp * pRsp = GetResponse();
|
|
if (pRsp != 0)
|
|
{
|
|
pErr = (LPCSTR)&pRsp->mErrorText;
|
|
}
|
|
|
|
return pErr;
|
|
};
|
|
|
|
protected:
|
|
// Is this session done request/response packet valid?
|
|
virtual bool Validate();
|
|
|
|
private:
|
|
// Prevent 'upcopying'
|
|
sQDLError( const sProtocolBuffer & );
|
|
sQDLError & operator = ( const sProtocolBuffer & );
|
|
};
|
|
|
|
/*=========================================================================*/
|
|
// Struct sQDLOpenUnframed
|
|
// Struct to represent a QDL open image for unframed write
|
|
// request/response (shared buffer)
|
|
/*=========================================================================*/
|
|
struct sQDLOpenUnframed : public sProtocolBuffer
|
|
{
|
|
public:
|
|
// Constructor
|
|
sQDLOpenUnframed( sSharedBuffer * pBuffer );
|
|
|
|
// Destructor
|
|
virtual ~sQDLOpenUnframed();
|
|
|
|
// (Inline) Is this a request?
|
|
bool IsRequest() const
|
|
{
|
|
bool bRequest = false;
|
|
if (IsValid() == true)
|
|
{
|
|
const BYTE * pBuf = GetBuffer();
|
|
bRequest = (pBuf[0] == (BYTE)eQDL_CMD_OPEN_UNFRAMED_REQ);
|
|
}
|
|
|
|
return bRequest;
|
|
};
|
|
|
|
// (Inline) Is this a response?
|
|
bool IsResponse() const
|
|
{
|
|
bool bResponse = false;
|
|
if (IsValid() == true)
|
|
{
|
|
const BYTE * pBuf = GetBuffer();
|
|
bResponse = (pBuf[0] == (BYTE)eQDL_CMD_OPEN_UNFRAMED_RSP);
|
|
}
|
|
|
|
return bResponse;
|
|
};
|
|
|
|
// (Inline) Return raw request
|
|
const sQDLRawOpenUnframedReq * GetRequest() const
|
|
{
|
|
const sQDLRawOpenUnframedReq * pReq = 0;
|
|
if (IsRequest() == true)
|
|
{
|
|
pReq = (const sQDLRawOpenUnframedReq *)GetBuffer();
|
|
}
|
|
|
|
return pReq;
|
|
};
|
|
|
|
// (Inline) Return raw response
|
|
const sQDLRawOpenUnframedRsp * GetResponse() const
|
|
{
|
|
const sQDLRawOpenUnframedRsp * pRsp = 0;
|
|
if (IsResponse() == true)
|
|
{
|
|
pRsp = (const sQDLRawOpenUnframedRsp *)GetBuffer();
|
|
}
|
|
|
|
return pRsp;
|
|
};
|
|
|
|
// (Inline) Does the response indicate success?
|
|
bool IsSuccess() const
|
|
{
|
|
bool bSuccess = false;
|
|
|
|
const sQDLRawOpenUnframedRsp * pRsp = GetResponse();
|
|
if (pRsp != 0)
|
|
{
|
|
bSuccess = (pRsp->mStatus == eQDL_OPEN_STATUS_SUCCESS);
|
|
}
|
|
|
|
return bSuccess;
|
|
};
|
|
|
|
// Extract supported chunk size from the response
|
|
bool GetChunkSize( ULONG & chunkSize ) const;
|
|
|
|
// Build an open image for unframed write request
|
|
static sSharedBuffer * BuildOpenUnframedReq(
|
|
eQDLImageType imageType,
|
|
ULONG imageSize,
|
|
ULONG chunkSize );
|
|
|
|
protected:
|
|
// Is this open unframed request/response packet valid?
|
|
virtual bool Validate();
|
|
|
|
private:
|
|
// Prevent 'upcopying'
|
|
sQDLOpenUnframed( const sProtocolBuffer & );
|
|
sQDLOpenUnframed & operator = ( const sProtocolBuffer & );
|
|
};
|
|
|
|
/*=========================================================================*/
|
|
// Struct sQDLWriteUnframed
|
|
// Struct to represent a QDL unframed write of an image
|
|
// request/response (shared buffer)
|
|
/*=========================================================================*/
|
|
struct sQDLWriteUnframed : public sProtocolBuffer
|
|
{
|
|
public:
|
|
// Constructor
|
|
sQDLWriteUnframed( sSharedBuffer * pBuffer );
|
|
|
|
// Destructor
|
|
virtual ~sQDLWriteUnframed();
|
|
|
|
// (Inline) Is this a request?
|
|
bool IsRequest() const
|
|
{
|
|
bool bRequest = false;
|
|
if (IsValid() == true)
|
|
{
|
|
const BYTE * pBuf = GetBuffer();
|
|
bRequest = (pBuf[0] == (BYTE)eQDL_CMD_WRITE_UNFRAMED_REQ);
|
|
}
|
|
|
|
return bRequest;
|
|
};
|
|
|
|
// (Inline) Is this a response?
|
|
bool IsResponse() const
|
|
{
|
|
bool bResponse = false;
|
|
if (IsValid() == true)
|
|
{
|
|
const BYTE * pBuf = GetBuffer();
|
|
bResponse = (pBuf[0] == (BYTE)eQDL_CMD_WRITE_UNFRAMED_RSP);
|
|
}
|
|
|
|
return bResponse;
|
|
};
|
|
|
|
// (Inline) Return raw request
|
|
const sQDLRawWriteUnframedReq * GetRequest() const
|
|
{
|
|
const sQDLRawWriteUnframedReq * pReq = 0;
|
|
if (IsRequest() == true)
|
|
{
|
|
pReq = (const sQDLRawWriteUnframedReq *)GetBuffer();
|
|
}
|
|
|
|
return pReq;
|
|
};
|
|
|
|
// (Inline) Return raw response
|
|
const sQDLRawWriteUnframedRsp * GetResponse() const
|
|
{
|
|
const sQDLRawWriteUnframedRsp * pRsp = 0;
|
|
if (IsResponse() == true)
|
|
{
|
|
pRsp = (const sQDLRawWriteUnframedRsp *)GetBuffer();
|
|
}
|
|
|
|
return pRsp;
|
|
};
|
|
|
|
// (Inline) Does the response indicate success?
|
|
bool IsSuccess() const
|
|
{
|
|
bool bSuccess = false;
|
|
|
|
const sQDLRawWriteUnframedRsp * pRsp = GetResponse();
|
|
if (pRsp != 0)
|
|
{
|
|
bSuccess = (pRsp->mStatus == eQDL_WRITE_STATUS_SUCCESS);
|
|
}
|
|
|
|
return bSuccess;
|
|
};
|
|
|
|
// Extract sequence number from the response
|
|
bool GetSequenceNumber( ULONG & sequenceNumber ) const;
|
|
|
|
// Build an unframed write request
|
|
static sSharedBuffer * BuildWriteUnframedReq(
|
|
USHORT sequenceNumber,
|
|
ULONG chunkSize );
|
|
|
|
// Build unframed write requests for the specified parameters
|
|
static std::list <sSharedBuffer *> BuildWriteUnframedReqs(
|
|
ULONG chunkSize,
|
|
ULONG totalSize );
|
|
|
|
protected:
|
|
// Is this open unframed request/response packet valid?
|
|
virtual bool Validate();
|
|
|
|
private:
|
|
// Prevent 'upcopying'
|
|
sQDLWriteUnframed( const sProtocolBuffer & );
|
|
sQDLWriteUnframed & operator = ( const sProtocolBuffer & );
|
|
};
|
|
|
|
/*=========================================================================*/
|
|
// Struct sQDLDone
|
|
// Struct to represent a QDL session done request/response (shared buffer)
|
|
/*=========================================================================*/
|
|
struct sQDLDone : public sProtocolBuffer
|
|
{
|
|
public:
|
|
// Constructor
|
|
sQDLDone( sSharedBuffer * pBuffer );
|
|
|
|
// Destructor
|
|
virtual ~sQDLDone();
|
|
|
|
// (Inline) Is this a request?
|
|
bool IsRequest() const
|
|
{
|
|
bool bRequest = false;
|
|
if (IsValid() == true)
|
|
{
|
|
const BYTE * pBuf = GetBuffer();
|
|
bRequest = (pBuf[0] == (BYTE)eQDL_CMD_SESSION_DONE_REQ);
|
|
}
|
|
|
|
return bRequest;
|
|
};
|
|
|
|
// (Inline) Is this a response?
|
|
bool IsResponse() const
|
|
{
|
|
bool bResponse = false;
|
|
if (IsValid() == true)
|
|
{
|
|
const BYTE * pBuf = GetBuffer();
|
|
bResponse = (pBuf[0] == (BYTE)eQDL_CMD_SESSION_DONE_RSP);
|
|
}
|
|
|
|
return bResponse;
|
|
};
|
|
|
|
// (Inline) Return raw response
|
|
const sQDLRawDoneRsp * GetResponse() const
|
|
{
|
|
const sQDLRawDoneRsp * pRsp = 0;
|
|
if (IsResponse() == true)
|
|
{
|
|
pRsp = (const sQDLRawDoneRsp *)GetBuffer();
|
|
}
|
|
|
|
return pRsp;
|
|
};
|
|
|
|
// (Inline) Does the response indicate success?
|
|
bool IsSuccess() const
|
|
{
|
|
bool bSuccess = false;
|
|
|
|
const sQDLRawDoneRsp * pRsp = GetResponse();
|
|
if (pRsp != 0)
|
|
{
|
|
bSuccess = (pRsp->mStatus == eQDL_DONE_STATUS_SUCCESS);
|
|
}
|
|
|
|
return bSuccess;
|
|
};
|
|
|
|
// (Inline) Return the error text string
|
|
LPCSTR GetError() const
|
|
{
|
|
LPCSTR pErr = 0;
|
|
|
|
const sQDLRawDoneRsp * pRsp = GetResponse();
|
|
if (pRsp != 0)
|
|
{
|
|
if (pRsp->mStatus != eQDL_DONE_STATUS_SUCCESS)
|
|
{
|
|
pErr = (LPCSTR)&pRsp->mErrorText;
|
|
}
|
|
}
|
|
|
|
return pErr;
|
|
};
|
|
|
|
protected:
|
|
// Is this session done request/response packet valid?
|
|
virtual bool Validate();
|
|
|
|
private:
|
|
// Prevent 'upcopying'
|
|
sQDLDone( const sProtocolBuffer & );
|
|
sQDLDone & operator = ( const sProtocolBuffer & );
|
|
};
|
|
|
|
/*=========================================================================*/
|
|
// Struct sQDLGetImagePref
|
|
// Struct to represent a QDL get image preference
|
|
// request/response (shared buffer)
|
|
/*=========================================================================*/
|
|
struct sQDLGetImagePref : public sProtocolBuffer
|
|
{
|
|
public:
|
|
// Constructor
|
|
sQDLGetImagePref( sSharedBuffer * pBuffer );
|
|
|
|
// Destructor
|
|
virtual ~sQDLGetImagePref();
|
|
|
|
// (Inline) Is this a request?
|
|
bool IsRequest() const
|
|
{
|
|
bool bRequest = false;
|
|
if (IsValid() == true)
|
|
{
|
|
const BYTE * pBuf = GetBuffer();
|
|
bRequest = (pBuf[0] == (BYTE)eQDL_CMD_GET_IMAGE_PREF_REQ);
|
|
}
|
|
|
|
return bRequest;
|
|
};
|
|
|
|
// (Inline) Is this a response?
|
|
bool IsResponse() const
|
|
{
|
|
bool bResponse = false;
|
|
if (IsValid() == true)
|
|
{
|
|
const BYTE * pBuf = GetBuffer();
|
|
bResponse = (pBuf[0] == (BYTE)eQDL_CMD_GET_IMAGE_PREF_RSP);
|
|
}
|
|
|
|
return bResponse;
|
|
};
|
|
|
|
// (Inline) Return raw response
|
|
const sQDLRawGetImagePrefRsp * GetResponse() const
|
|
{
|
|
const sQDLRawGetImagePrefRsp * pRsp = 0;
|
|
if (IsResponse() == true)
|
|
{
|
|
pRsp = (const sQDLRawGetImagePrefRsp *)GetBuffer();
|
|
}
|
|
|
|
return pRsp;
|
|
};
|
|
|
|
// Return image IDs
|
|
std::list <sQDLRawImageID> GetImageIDs() const;
|
|
|
|
protected:
|
|
// Is this get image preference request/response packet valid?
|
|
virtual bool Validate();
|
|
|
|
private:
|
|
// Prevent 'upcopying'
|
|
sQDLGetImagePref( const sProtocolBuffer & );
|
|
sQDLGetImagePref & operator = ( const sProtocolBuffer & );
|
|
};
|