qinfo.cpp

Windows CE 6.0 Server 源码

// Parameters:
//    plAuthenticate         [out]
//    lAuthenticate          [in]
//
// Output:
//
// Notes:
//
HRESULT CMSMQQueueInfo::get_Authenticate(long *plAuthenticate)
{
    InitProps();
    *plAuthenticate = m_lAuthenticate;
    return NOERROR;
}


HRESULT CMSMQQueueInfo::put_Authenticate(long lAuthenticate)
{

	switch (lAuthenticate) {
    case MQ_AUTHENTICATE_NONE:
    case MQ_AUTHENTICATE:
    EnterCriticalSection(&m_CSlocal);
      m_lAuthenticate = lAuthenticate;
    LeaveCriticalSection(&m_CSlocal);
      return NOERROR;
    default:
      return CreateErrorHelper(
               MQ_ERROR_ILLEGAL_PROPERTY_VALUE,
               m_ObjectType);
    }
    
}


//=--------------------------------------------------------------------------=
// CMSMQQueueInfo::get/put_JournalQuota
//=--------------------------------------------------------------------------=
//
// Parameters:
//    plJournalQuota         [out]
//    lJournalQuota          [in]
//
// Output:
//
// Notes:
//
HRESULT CMSMQQueueInfo::get_JournalQuota(long *plJournalQuota)
{
    InitProps();
    *plJournalQuota = m_lJournalQuota;
    return NOERROR;
}


HRESULT CMSMQQueueInfo::put_JournalQuota(long lJournalQuota)
{
	EnterCriticalSection(&m_CSlocal);
    m_lJournalQuota = lJournalQuota;
    LeaveCriticalSection(&m_CSlocal);
    return NOERROR;
}


//=--------------------------------------------------------------------------=
// CMSMQQueueInfo::CreateQueueProps
//=--------------------------------------------------------------------------=
// Creates and updates an MQQUEUEPROPS struct.  Fills in struct with
//  this queue's properties.  Specifically: label, pathname, guid, servicetype.
//
// Parameters:
//  fUpdate           TRUE if they want to update struct with
//                     current datamembers
//  cProp
//  pqueueprops
//  isTransactional   TRUE if they want a transacted queue.
//  varlist of PROPIDs.
//
// Output:
//    HRESULT       - S_OK, E_OUTOFMEMORY
//
// Notes:
// uses variable length list of PROPID params
//
HRESULT CMSMQQueueInfo::CreateQueueProps(
    BOOL fUpdate,
    UINT cProp, 
    MQQUEUEPROPS *pqueueprops, 
    BOOL isTransactional,
    ...)
{
    UINT i;
    va_list marker;
    QUEUEPROPID queuepropid;
    HRESULT hresult = NOERROR;

    IfNullRet(pqueueprops->aPropID = new QUEUEPROPID[cProp]);
    IfNullFail(pqueueprops->aStatus = new HRESULT[cProp]);
    pqueueprops->aPropVar = new MQPROPVARIANT[cProp];
    if (pqueueprops->aPropVar == NULL) {
      IfFailGoTo(hresult = E_OUTOFMEMORY, Error2);
    }
    pqueueprops->cProp = cProp;

    // process variable list of PROPID params
    va_start(marker, isTransactional);
    for (i = 0; i < cProp; i++) {
      queuepropid = va_arg(marker, QUEUEPROPID);    
      pqueueprops->aPropID[i] = queuepropid;
      switch (queuepropid) {
      case PROPID_Q_INSTANCE:
        // This is an OUT param so we just use the current member 
        //  as a buffer.
        //
        ASSERT(m_pguidQueue, L"should always be non-null");
        if (fUpdate) {
          pqueueprops->aPropVar[i].vt = VT_CLSID;
          pqueueprops->aPropVar[i].puuid = m_pguidQueue;
        }
        else {
          pqueueprops->aPropVar[i].puuid = NULL;  
          pqueueprops->aPropVar[i].vt = VT_NULL;  
        }
        break;
      case PROPID_Q_TYPE:
        ASSERT(m_pguidServiceType, L"should always be non-null");
        if (fUpdate) {
          pqueueprops->aPropVar[i].vt = VT_CLSID;
          pqueueprops->aPropVar[i].puuid = m_pguidServiceType;
        }
        else {
          pqueueprops->aPropVar[i].puuid = NULL;  
          pqueueprops->aPropVar[i].vt = VT_NULL;
        }
        break;
      case PROPID_Q_LABEL:
        ASSERT(m_bstrLabel, L"should always be non-null");
        if (fUpdate) {
          pqueueprops->aPropVar[i].vt = VT_LPWSTR;
          pqueueprops->aPropVar[i].pwszVal = m_bstrLabel;
        }
        else {
          pqueueprops->aPropVar[i].pwszVal = NULL;  
          pqueueprops->aPropVar[i].vt = VT_NULL;
        }
        break;
      case PROPID_Q_PATHNAME:
        pqueueprops->aPropVar[i].vt = VT_LPWSTR;
        if (fUpdate) {
          if (m_bstrPathName) {
            pqueueprops->aPropVar[i].pwszVal = m_bstrPathName;
          }
          else {
            // no default: param is mandatory
            hresult = ERROR_INVALID_PARAMETER;
          }
        }
        else {
          pqueueprops->aPropVar[i].pwszVal = NULL;  
          pqueueprops->aPropVar[i].vt = VT_NULL;
        }
        break;
      case PROPID_Q_JOURNAL:
        pqueueprops->aPropVar[i].vt = VT_UI1;
        if (fUpdate) pqueueprops->aPropVar[i].bVal = (UCHAR)m_lJournal;
        break;
      case PROPID_Q_QUOTA:
        pqueueprops->aPropVar[i].vt = VT_UI4;
        if (fUpdate) pqueueprops->aPropVar[i].lVal = (ULONG)m_lQuota;
        break;
      case PROPID_Q_BASEPRIORITY:
        pqueueprops->aPropVar[i].vt = VT_I2;
        if (fUpdate) pqueueprops->aPropVar[i].iVal = (SHORT)m_lBasePriority;
        break;
      case PROPID_Q_PRIV_LEVEL:
        pqueueprops->aPropVar[i].vt = VT_UI4;
        if (fUpdate) pqueueprops->aPropVar[i].lVal = m_lPrivLevel;
        break;
      case PROPID_Q_AUTHENTICATE:
        pqueueprops->aPropVar[i].vt = VT_UI1;
        if (fUpdate) pqueueprops->aPropVar[i].bVal = (UCHAR)m_lAuthenticate;
        break;
      case PROPID_Q_TRANSACTION:
        pqueueprops->aPropVar[i].vt = VT_UI1;
        if (fUpdate) {
          pqueueprops->aPropVar[i].bVal = 
            (UCHAR)isTransactional ? MQ_TRANSACTIONAL : MQ_TRANSACTIONAL_NONE;
        }
        break;
      case PROPID_Q_CREATE_TIME:
        pqueueprops->aPropVar[i].vt = VT_I4;
        if (fUpdate) {
          // R/O
          // hresult = ERROR_INVALID_PARAMETER;
        }
        break;
      case PROPID_Q_MODIFY_TIME:
        pqueueprops->aPropVar[i].vt = VT_I4;
        if (fUpdate) {
          // R/O
          // hresult = ERROR_INVALID_PARAMETER;
        }
        break;
      case PROPID_Q_JOURNAL_QUOTA:
        pqueueprops->aPropVar[i].vt = VT_UI4;
        if (fUpdate) pqueueprops->aPropVar[i].lVal = m_lJournalQuota;
        break;
      default:
        ASSERT(0, L"unhandled queuepropid");
      } // switch
    } // for
    return hresult;

Error2:
    delete [] pqueueprops->aStatus;
    pqueueprops->aStatus = NULL;

Error:
    delete [] pqueueprops->aPropID;
    pqueueprops->aPropID = NULL;
    pqueueprops->cProp = 0;

    return hresult;
}


//=--------------------------------------------------------------------------=
// Helper: FreeFalconBuffers
//=--------------------------------------------------------------------------=
// Frees dynamic memory allocated by Falcon on behalf of an 
//  MQQUEUEPROPS struct.  
//
// Parameters:
//  pqueueprops
//
// Output:
//
// Notes:
//
void FreeFalconBuffers(MQQUEUEPROPS *pqueueprops)
{
    UINT cProp, i;
    QUEUEPROPID queuepropid;

    cProp = pqueueprops->cProp ;
    for (i = 0; i < cProp; i++) {
      queuepropid = pqueueprops->aPropID[i];
      switch (queuepropid) {
      case PROPID_Q_INSTANCE:
        MQFreeMemory(pqueueprops->aPropVar[i].puuid);
        break;
      case PROPID_Q_TYPE:
        MQFreeMemory(pqueueprops->aPropVar[i].puuid);
        break;
      case PROPID_Q_LABEL:
        MQFreeMemory(pqueueprops->aPropVar[i].pwszVal);
        break;
      case PROPID_Q_PATHNAME:
        MQFreeMemory(pqueueprops->aPropVar[i].pwszVal);
        break;
      } // switch
    } // for

}


//=--------------------------------------------------------------------------=
// CMSMQQueueInfo::FreeQueueProps
//=--------------------------------------------------------------------------=
// Frees dynamic memory allocated on behalf of an 
//  MQQUEUEPROPS struct.  
//
// Parameters:
//  pRestriction
//
// Output:
//
// Notes:
//
void CMSMQQueueInfo::FreeQueueProps(MQQUEUEPROPS *pqueueprops)
{
    // Note: all properties are owned by the MSMQQueueInfo.
    delete [] pqueueprops->aPropID;
    delete [] pqueueprops->aPropVar;
    delete [] pqueueprops->aStatus;
    return;
}


//=--------------------------------------------------------------------------=
// CMSMQQueueInfo::SetQueueProps
//=--------------------------------------------------------------------------=
// Sets queue's props from an MQQUEUEPROPS struct.  
//
// Parameters:
//  pqueueprops
//
// Output:
//    HRESULT       - S_OK, E_OUTOFMEMORY
//
// Notes:
//
HRESULT CMSMQQueueInfo::SetQueueProps(MQQUEUEPROPS *pqueueprops)
{
    UINT i;
    UINT cProp;
    QUEUEPROPID queuepropid;
    HRESULT hresult = NOERROR;


	EnterCriticalSection(&m_CSlocal);
    cProp = pqueueprops->cProp ;
    for (i = 0; i < cProp; i++) {
      queuepropid = pqueueprops->aPropID[i];
      
      // outcoming VT_NULL indicates that property was ignored
      //  so skip setting it...
      //
      if (pqueueprops->aPropVar[i].vt == VT_NULL) {
        continue;
      }
      switch (queuepropid) {
      case PROPID_Q_INSTANCE:
        *m_pguidQueue = *pqueueprops->aPropVar[i].puuid;
        break;
      case PROPID_Q_TYPE:
        *m_pguidServiceType = *pqueueprops->aPropVar[i].puuid;
        break;
      case PROPID_Q_LABEL:
        IfNullFail(SysReAllocString(&m_bstrLabel, 
                                    pqueueprops->aPropVar[i].pwszVal));
        break;
      case PROPID_Q_PATHNAME:
        IfNullFail(SysReAllocString(&m_bstrPathName, 
                                    pqueueprops->aPropVar[i].pwszVal));
        break;
      case PROPID_Q_JOURNAL:
        m_lJournal = (long)pqueueprops->aPropVar[i].bVal;
        break;
      case PROPID_Q_QUOTA:
        m_lQuota = pqueueprops->aPropVar[i].lVal;
        break;
      case PROPID_Q_BASEPRIORITY:
        m_lBasePriority = pqueueprops->aPropVar[i].iVal;
        break;
      case PROPID_Q_PRIV_LEVEL:
        m_lPrivLevel = (long)pqueueprops->aPropVar[i].lVal;
        break;
      case PROPID_Q_AUTHENTICATE:
        m_lAuthenticate = (long)pqueueprops->aPropVar[i].bVal;
        break;
      case PROPID_Q_CREATE_TIME:
        m_lCreateTime = pqueueprops->aPropVar[i].lVal;
        break;
      case PROPID_Q_MODIFY_TIME:
        m_lModifyTime = pqueueprops->aPropVar[i].lVal;
        break;
      case PROPID_Q_TRANSACTION:
        m_isTransactional = (BOOL)pqueueprops->aPropVar[i].bVal;
        break;
      case PROPID_Q_JOURNAL_QUOTA:
        m_lJournalQuota = pqueueprops->aPropVar[i].lVal;
        break;
      default:
        ASSERT(0, L"unhandled queuepropid");
      } // switch
    } // for
    // fall through...

Error:
	LeaveCriticalSection(&m_CSlocal);
    return hresult;
}


//=--------------------------------------------------------------------------=
// CMSMQQueueInfo::Init
//=--------------------------------------------------------------------------=
// Inits a new queue based on instance params (guidQueue etc.)
//
// Parameters:
//  bstrFormatName
//
// Output:
//    HRESULT       - S_OK, E_OUTOFMEMORY
//
// Notes:
//
HRESULT CMSMQQueueInfo::Init(
    BSTR bstrFormatName)
{
#if DEBUG
    if (m_bstrFormatName || bstrFormatName) {
      ASSERT(m_bstrFormatName != bstrFormatName, L"bad strings.");
    }
#endif // DEBUG
    //
    // 2026: put_FormatName validates formatname
    //
    return put_FormatName(bstrFormatName);
}

//
// HELPER: GetCurrentUserSid
//
#if 0 // No Security
BOOL GetCurrentUserSid(PSID psid)
{
    BYTE rgbTokenUserInfo[128];
    DWORD cbBuf;
    HANDLE hToken = NULL;

    if (!OpenThreadToken(
          GetCurrentThread(),
          TOKEN_QUERY,
          TRUE,   // OpenAsSelf
          &hToken)) {
      if (GetLastError() != ERROR_NO_TOKEN) {
        return FALSE;
      }
      else {
        if (!OpenProcessToken(
              GetCurrentProcess(),
              TOKEN_QUERY,
              &hToken)) {
          return FALSE;
        }
      }
    }
    ASSERT(hToken, L"no current token!");
    if (!GetTokenInformation(
          hToken,
          TokenUser,
          (VOID *)rgbTokenUserInfo,
          sizeof(rgbTokenUserInfo),
          &cbBuf)) {
      //
      // UNDONE: realloc token buffer if not big enough...
      //
      return FALSE;
    }
    TOKEN_USER *ptokenuser = (TOKEN_USER *)rgbTokenUserInfo;
    PSID psidUser = ptokenuser->User.Sid;

    if (!CopySid(GetLengthSid(psidUser), psid, psidUser)) {
      return FALSE;
    }
    return TRUE;
}


//
// HELPER: GetWorldReadableSecurityDescriptor
//
BOOL GetWorldReadableSecurityDescriptor(
    SECURITY_DESCRIPTOR *psd,
    BYTE **ppbBufDacl)
{
    BYTE rgbBufSidUser[128];
    PSID psidWorld = NULL, psidUser = (PSID)rgbBufSidUser;
    PACL pDacl = NULL;
    SID_IDENTIFIER_AUTHORITY WorldAuth = SECURITY_WORLD_SID_AUTHORITY;
    DWORD dwAclSize;
    BOOL fRet = TRUE;   // optimism!

    ASSERT(ppbBufDacl, L"bad param!");
    *ppbBufDacl = NULL;
    IfNullGo(AllocateAndInitializeSid(
                    &WorldAuth,
                    1,
                    SECURITY_WORLD_RID,
                    0,
                    0,
                    0,
                    0,
                    0,
                    0,
                    0,
                    &psidWorld));
    IfNullGo(GetCurrentUserSid(psidUser));
    //
    // Calculate the required size for the new DACL and allocate it.
    //
    dwAclSize = sizeof(ACL) + 
                  2 * (sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD)) +
                  GetLengthSid(psidUser) + 
                  GetLengthSid(psidWorld);
    IfNullGo(pDacl = (PACL)new BYTE[dwAclSize]);
    //
    // Initialize the ACL.
    //
    IfNullGo(InitializeAcl(pDacl, dwAclSize, ACL_REVISION));
    //
    // Add the ACEs to the DACL.
    //
    IfNullGo(AddAccessAllowedAce(pDacl, ACL_REVISION, MQSEC_QUEUE_GENERIC_ALL, psidUser));
    IfNullGo(AddAccessAllowedAce(
          pDacl, 
          ACL_REVISION, 
          MQSEC_QUEUE_GENERIC_WRITE | MQSEC_QUEUE_GENERIC_READ, 
          psidWorld));
    //
    // Initialize the security descriptor.
    //
    IfNullGo(InitializeSecurityDescriptor(psd, SECURITY_DESCRIPTOR_REVISION));
    //
    // Set the security descriptor's DACL.
    //
    IfNullGo(SetSecurityDescriptorDacl(psd, TRUE, pDacl, FALSE));
    //
    // setup out DACL
    //
    *ppbBufDacl = (BYTE *)pDacl;
    goto Done;

Error:
    fRet = FALSE;
    delete [] (BYTE *)pDacl;
    //
    // All done...
    //
Done:
    if (psidWorld) {
      FreeSid(psidWorld);
    }

    return fRet;
}
#endif

//=--------------------------------------------------------------------------=
// CMSMQQueueInfo::Create
//=--------------------------------------------------------------------------=