msg.cpp

Windows CE 6.0 Server 源码

    pmsgprops->aPropVar = NULL;
    pmsgprops->aStatus = NULL;
    if (wantDestQueue) {
      cPropOut++;      // PROPID_M_DEST_QUEUE
      cPropOut++;      // PROPID_M_DEST_QUEUE_LEN
    }
    if (wantBody) {
      cPropOut++;      // PROPID_M_BODY
      cPropOut++;      // PROPID_M_BODY_SIZE
    }
    pmsgprops->cProp = cPropOut;
    IfNullRet(pmsgprops->aPropID = new MSGPROPID[cPropOut]);
    IfNullFail(pmsgprops->aPropVar = new MQPROPVARIANT[cPropOut]);
    IfNullFail(pmsgprops->aStatus = new HRESULT[cPropOut]);
    for (i = 0; i < cPropOld; i++) {
      pmsgprops->aPropID[i] = rgproprec[i].m_propid;
      pmsgprops->aPropVar[i].vt = rgproprec[i].m_vt;
      
    }
    if (wantDestQueue) {
      pmsgprops->aPropID[cPropOld] = propid = PROPID_M_DEST_QUEUE;
      pmsgprops->aPropVar[cPropOld++].vt = VtOfPropIdRgproprec(
                                             propid,
                                             g_rgmsgproprecOptional,
                                             g_cPropRecOptional);
      pmsgprops->aPropID[cPropOld] = propid = PROPID_M_DEST_QUEUE_LEN;
      pmsgprops->aPropVar[cPropOld++].vt = VtOfPropIdRgproprec(
                                             propid,
                                             g_rgmsgproprecOptional,
                                             g_cPropRecOptional);
    }
    if (wantBody) {
      pmsgprops->aPropID[cPropOld] = propid = PROPID_M_BODY;
      pmsgprops->aPropVar[cPropOld++].vt = VtOfPropIdRgproprec(
                                             propid,
                                             g_rgmsgproprecOptional,
                                             g_cPropRecOptional);
      pmsgprops->aPropID[cPropOld] = propid = PROPID_M_BODY_SIZE;
      pmsgprops->aPropVar[cPropOld++].vt = VtOfPropIdRgproprec(
                                             propid,
                                             g_rgmsgproprecOptional,
                                             g_cPropRecOptional);
    }
    ASSERT(cPropOld == cPropOut, L"property count mismatch.");
    *pcPropOut = cPropOut;
    // fall through...

Error:
    return hresult;
}


//=--------------------------------------------------------------------------=
// CMSMQMessage::Create
//=--------------------------------------------------------------------------=
// creates a new MSMQMessage object.
//
// Parameters:
//    IUnknown *        - [in] controlling unkonwn
//
// Output:
//    IUnknown *        - new object.
//
// Notes:
//
IUnknown *CMSMQMessage::Create
(
    IUnknown *pUnkOuter
)
{
    // make sure we return the private unknown so that we support aggegation
    // correctly!
    //
    CMSMQMessage *pNew = new CMSMQMessage(pUnkOuter);
    return pNew ? pNew->PrivateUnknown() : NULL;
}

//=--------------------------------------------------------------------------=
// CMSMQMessage::CMSMQMessage
//=--------------------------------------------------------------------------=
// create the object and initialize the refcount
//
// Parameters:
//    IUnknown *    - [in] controlling unknown
//
// Notes:
//
#pragma warning(disable:4355)  // using 'this' in constructor
CMSMQMessage::CMSMQMessage
(
    IUnknown *pUnkOuter
)
: CAutomationObject(pUnkOuter, OBJECT_TYPE_OBJMQMESSAGE, (void *)this)
{

    // TODO: initialize anything here
    //
    m_lClass = -1;      // illegal value...
    m_lDelivery = DEFAULT_M_DELIVERY;
    m_lPriority = DEFAULT_M_PRIORITY;
    m_lJournal = DEFAULT_M_JOURNAL;
    m_pqinfoResponse = NULL;
    m_lAppSpecific = DEFAULT_M_APPSPECIFIC;
    m_pbBody = NULL;
    m_vtBody = VT_ARRAY | VT_UI1; // default: safearray of bytes
    m_hMem = NULL;
    m_cbBody = 0;
    m_pqinfoAdmin = NULL;
    m_rgbMsgId = NULL;
    m_cbMsgId = 0;
    m_rgbCorrelationId = NULL;
    m_cbCorrelationId = 0;
    m_lAck = DEFAULT_M_ACKNOWLEDGE;
    m_pwszLabel = new WCHAR[MQ_MAX_MSG_LABEL_LEN + 1];
    memset(m_pwszLabel, 0, sizeof(WCHAR));
    m_cchLabel = 0;           // empty
    m_lTrace = MQMSG_TRACE_NONE;
    m_rgbSenderId = NULL;
    m_cbSenderId = 0;
    m_lSenderIdType = DEFAULT_M_SENDERID_TYPE;
    m_rgbSenderCert = NULL;
    m_cbSenderCert = 0;
    m_lPrivLevel = DEFAULT_M_PRIV_LEVEL;
    m_lAuthLevel = DEFAULT_M_AUTH_LEVEL;
    m_fAuthenticated = FALSE;
    m_lHashAlg = CALG_MD5;
    m_lEncryptAlg = CALG_RC2;
    m_lMaxTimeToReachQueue = -1;
    m_lMaxTimeToReceive = -1;
    m_lSentTime = -1;
    m_lArrivedTime = -1;
    m_pqinfoDest = NULL;
    m_pwszDestQueue  = new WCHAR[FORMAT_NAME_INIT_BUFFER];
    memset(m_pwszDestQueue, 0, sizeof(WCHAR));
    m_cchDestQueue = 0;            // empty
    m_pwszRespQueue  = new WCHAR[FORMAT_NAME_INIT_BUFFER];
    memset(m_pwszRespQueue, 0, sizeof(WCHAR));
    m_cchRespQueue = 0;            // empty
    m_pwszAdminQueue  = new WCHAR[FORMAT_NAME_INIT_BUFFER];
    memset(m_pwszAdminQueue, 0, sizeof(WCHAR));
    m_cchAdminQueue = 0;            // empty
    m_lSecurityContext = 0;   // ignored...
    m_pguidSrcMachine = new GUID(GUID_NULL);
}
#pragma warning(default:4355)  // using 'this' in constructor

//=--------------------------------------------------------------------------=
// CMSMQMessage::CMSMQMessage
//=--------------------------------------------------------------------------=
// "We all labour against our own cure, for death is the cure of all diseases"
//    - Sir Thomas Browne (1605 - 82)
//
// Notes:
//
CMSMQMessage::~CMSMQMessage ()
{
    // TODO: clean up anything here.
    GLOBALFREE(m_hMem);
    m_cbBody = 0;
    delete [] m_rgbMsgId;
    delete [] m_rgbCorrelationId;
    delete [] m_pwszLabel;
    m_cchLabel = (UINT)-1; // uninitialized
    delete [] m_rgbSenderId;
    delete [] m_rgbSenderCert;
    RELEASE(m_pqinfoResponse);
    RELEASE(m_pqinfoAdmin);
    RELEASE(m_pqinfoDest);
    delete [] m_pwszDestQueue;
    m_cchDestQueue = (UINT)-1; // uninitialized
    delete [] m_pwszRespQueue;
    m_cchRespQueue = (UINT)-1; // uninitialized
    delete [] m_pwszAdminQueue;
    m_cchAdminQueue = (UINT)-1; // uninitialized
    delete m_pguidSrcMachine;
}

//=--------------------------------------------------------------------------=
// CMSMQMessage::InternalQueryInterface
//=--------------------------------------------------------------------------=
// the controlling unknown will call this for us in the case where they're
// looking for a specific interface.
//
// Parameters:
//    REFIID        - [in]  interface they want
//    void **       - [out] where they want to put the resulting object ptr.
//
// Output:
//    HRESULT       - S_OK, E_NOINTERFACE
//
// Notes:
//
HRESULT CMSMQMessage::InternalQueryInterface
(
    REFIID riid,
    void **ppvObjOut
)
{
    CHECK_POINTER(ppvObjOut);

    // we support IMSMQMessage and ISupportErrorInfo
    //
    if (DO_GUIDS_MATCH(riid, IID_IMSMQMessage)) {
        *ppvObjOut = (void *)(IMSMQMessage *)this;
        AddRef();
        return S_OK;
    } else if (DO_GUIDS_MATCH(riid, IID_ISupportErrorInfo)) {
        *ppvObjOut = (void *)(ISupportErrorInfo *)this;
        AddRef();
        return S_OK;
    }

    // call the super-class version and see if it can oblige.
    //
    return CAutomationObject::InternalQueryInterface(riid, ppvObjOut);
}



// TODO: implement your interface methods and property exchange functions
//       here.
//

//=--------------------------------------------------------------------------=
// CMSMQMessage::get_Class
//=--------------------------------------------------------------------------=
// Gets message class of message
//
// Parameters:
//    plClass - [out] message's class
//
// Output:
//
// Notes:
//
HRESULT CMSMQMessage::get_Class(long FAR* plClass)
{
    *plClass = m_lClass;
    return NOERROR;
}


//=--------------------------------------------------------------------------=
// CMSMQMessage::get_Delivery
//=--------------------------------------------------------------------------=
// Gets message's delivery option
//
// Parameters:
//    pdelivery - [in] message's delivery option
//
// Output:
//
// Notes:
//
HRESULT CMSMQMessage::get_Delivery(long FAR* plDelivery)
{
    *plDelivery = m_lDelivery;
    return NOERROR;
}

//=--------------------------------------------------------------------------=
// CMSMQMessage::put_Delivery
//=--------------------------------------------------------------------------=
// Sets delivery option for message
//
// Parameters:
//    delivery - [in] message's delivery option
//
// Output:
//
// Notes:
//
HRESULT CMSMQMessage::put_Delivery(long lDelivery)
{
    switch (lDelivery) {
    case MQMSG_DELIVERY_EXPRESS:
    case MQMSG_DELIVERY_RECOVERABLE:
EnterCriticalSection(&m_CSlocal);
      m_lDelivery = lDelivery;
LeaveCriticalSection(&m_CSlocal);
      return NOERROR;
    default:
      return CreateErrorHelper(MQ_ERROR_ILLEGAL_PROPERTY_VALUE, m_ObjectType);
    }
}


//=--------------------------------------------------------------------------=
// CMSMQMessage::get_HashAlgorithm
//=--------------------------------------------------------------------------=
// Gets message's hash algorithm
//
// Parameters:
//    plHashAlg - [in] message's hash alg
//
// Output:
//
// Notes:
//
HRESULT CMSMQMessage::get_HashAlgorithm(long FAR* plHashAlg)
{
    *plHashAlg = m_lHashAlg;
    return NOERROR;
}

//=--------------------------------------------------------------------------=
// CMSMQMessage::put_HashAlgorithm
//=--------------------------------------------------------------------------=
// Sets message's hash alg
//
// Parameters:
//    lHashAlg - [in] message's hash alg
//
// Output:
//
// Notes:
//
HRESULT CMSMQMessage::put_HashAlgorithm(long lHashAlg)
{

EnterCriticalSection(&m_CSlocal);
    m_lHashAlg = lHashAlg;
LeaveCriticalSection(&m_CSlocal);
    return NOERROR;
}


//=--------------------------------------------------------------------------=
// CMSMQMessage::get_EncryptAlgorithm
//=--------------------------------------------------------------------------=
// Gets message's encryption algorithm
//
// Parameters:
//    plEncryptAlg - [in] message's encryption alg
//
// Output:
//
// Notes:
//
HRESULT CMSMQMessage::get_EncryptAlgorithm(long FAR* plEncryptAlg)
{
    *plEncryptAlg = m_lEncryptAlg;
    return NOERROR;
}

//=--------------------------------------------------------------------------=
// CMSMQMessage::put_EncryptAlgorithm
//=--------------------------------------------------------------------------=
// Sets message's encryption alg
//
// Parameters:
//    lEncryptAlg - [in] message's crypt alg
//
// Output:
//
// Notes:
//
HRESULT CMSMQMessage::put_EncryptAlgorithm(long lEncryptAlg)
{

EnterCriticalSection(&m_CSlocal);
    m_lEncryptAlg = lEncryptAlg;
LeaveCriticalSection(&m_CSlocal);
    return NOERROR;
}


//=--------------------------------------------------------------------------=
// CMSMQMessage::get_SenderIdType
//=--------------------------------------------------------------------------=
// Gets message's sender id type
//
// Parameters:
//    plSenderIdType - [in] message's sender id type
//
// Output:
//
// Notes:
//
HRESULT CMSMQMessage::get_SenderIdType(long FAR* plSenderIdType)
{
    *plSenderIdType = m_lSenderIdType;
    return NOERROR;
}

//=--------------------------------------------------------------------------=
// CMSMQMessage::put_SenderIdType
//=--------------------------------------------------------------------------=
// Sets sender id type for message
//
// Parameters:
//    lSenderIdType - [in] message's sender id type
//
// Output:
//
// Notes:
//
HRESULT CMSMQMessage::put_SenderIdType(long lSenderIdType)
{
    switch (lSenderIdType) {
    case MQMSG_SENDERID_TYPE_NONE:
    case MQMSG_SENDERID_TYPE_SID:
   	  EnterCriticalSection(&m_CSlocal);
      	m_lSenderIdType = lSenderIdType;
      LeaveCriticalSection(&m_CSlocal);
      return NOERROR;
    default:
      return CreateErrorHelper(
               MQ_ERROR_ILLEGAL_PROPERTY_VALUE,
               m_ObjectType);
    }
}


//=--------------------------------------------------------------------------=
// CMSMQMessage::get_PrivLevel
//=--------------------------------------------------------------------------=
// Gets message's privlevel
//
// Parameters:
//    plPrivLevel - [in] message's privlevel
//
// Output:
//
// Notes:
//
HRESULT CMSMQMessage::get_PrivLevel(long FAR* plPrivLevel)
{
    *plPrivLevel = m_lPrivLevel;
    return NOERROR;
}

//=--------------------------------------------------------------------------=
// CMSMQMessage::put_PrivLevel
//=--------------------------------------------------------------------------=
// Sets privlevel for message
//
// Parameters:
//    lPrivLevel - [in] message's sender id type
//
// Output:
//
// Notes:
//
HRESULT CMSMQMessage::put_PrivLevel(long lPrivLevel)
{
    switch (lPrivLevel) {
    case MQMSG_PRIV_LEVEL_NONE:
    case MQMSG_PRIV_LEVEL_BODY:
      EnterCriticalSection(&m_CSlocal);
      	m_lPrivLevel = lPrivLevel;
      LeaveCriticalSection(&m_CSlocal);
      return NOERROR;
    default:
      return CreateErrorHelper(
               MQ_ERROR_ILLEGAL_PROPERTY_VALUE,
               m_ObjectType);
    }
}


//=--------------------------------------------------------------------------=
// CMSMQMessage::get_AuthLevel
//=--------------------------------------------------------------------------=
// Gets message's authlevel
//
// Parameters:
//    plAuthLevel - [in] message's authlevel
//
// Output:
//
// Notes:
//
HRESULT CMSMQMessage::get_AuthLevel(long FAR* plAuthLevel)
{
    *plAuthLevel = m_lAuthLevel;
    return NOERROR;
}