1023 lines
23 KiB
C++
1023 lines
23 KiB
C++
/* ----------------------------------------------------------------------
|
|
|
|
Module: ULS.DLL (Service Provider)
|
|
File: splmtg.cpp
|
|
Content: This file contains the local meeting object.
|
|
History:
|
|
10/15/96 Chu, Lon-Chan [lonchanc]
|
|
Created.
|
|
|
|
Copyright (c) Microsoft Corporation 1996-1997
|
|
|
|
---------------------------------------------------------------------- */
|
|
|
|
#include "ulsp.h"
|
|
#include "spinc.h"
|
|
|
|
#ifdef ENABLE_MEETING_PLACE
|
|
|
|
// Array of constant strings for user object's attribute names
|
|
//
|
|
const TCHAR *c_apszMtgStdAttrNames[COUNT_ENUM_MTGATTR] =
|
|
{
|
|
TEXT ("CN"), // Meeting ID
|
|
TEXT ("ConfType"), // Meeting Type
|
|
TEXT ("ConfMemberType"), // Attendee Type
|
|
TEXT ("ConfDesc"), // Description
|
|
TEXT ("ConfHostName"), // Host Name
|
|
TEXT ("ConfHostAddress"), // IP Address
|
|
|
|
TEXT ("ConfMemberList"), // Members
|
|
TEXT ("ssecurity"),
|
|
TEXT ("sttl"),
|
|
|
|
TEXT ("objectClass"),
|
|
TEXT ("o"),
|
|
TEXT ("c"),
|
|
};
|
|
|
|
|
|
const TCHAR c_szMtgDefC[] = TEXT ("us");
|
|
|
|
|
|
/* ---------- public methods ----------- */
|
|
|
|
|
|
SP_CMeeting::
|
|
SP_CMeeting ( DWORD dwContext )
|
|
:
|
|
m_cRefs (0), // Reference count
|
|
m_uSignature (MTGOBJ_SIGNATURE), // Mtg object's signature
|
|
m_pszMtgName (NULL), // Clean the meeting name
|
|
m_pszDN (NULL), // Clean DN
|
|
m_pszRefreshFilter (NULL), // Clean up the refresh search filter
|
|
m_dwIPAddress (0), // Clean local IP address
|
|
m_uTTL (ILS_DEF_REFRESH_MINUTE) // Reset time to live value (min)
|
|
{
|
|
m_dwContext = dwContext;
|
|
|
|
// Clean up attached server info structure
|
|
//
|
|
::ZeroMemory (&m_ServerInfo, sizeof (m_ServerInfo));
|
|
|
|
// Clean up the scratch buffer for caching pointers to attribute values
|
|
//
|
|
::ZeroMemory (&m_MtgInfo, sizeof (m_MtgInfo));
|
|
|
|
// Indicate this user is not registered yet
|
|
//
|
|
SetRegNone ();
|
|
}
|
|
|
|
|
|
SP_CMeeting::
|
|
~SP_CMeeting ( VOID )
|
|
{
|
|
// Invalidate the user object's signature
|
|
//
|
|
m_uSignature = (ULONG) -1;
|
|
|
|
// Free server info structure
|
|
//
|
|
::IlsFreeServerInfo (&m_ServerInfo);
|
|
|
|
// Free meeting name
|
|
//
|
|
MemFree (m_pszMtgName);
|
|
|
|
// Free DN
|
|
//
|
|
MemFree (m_pszDN);
|
|
|
|
// Free the refresh search filter
|
|
//
|
|
MemFree (m_pszRefreshFilter);
|
|
|
|
// Release the previous prefix for extended attribute names
|
|
//
|
|
::IlsReleaseAnyAttrsPrefix (&(m_MtgInfo.AnyAttrs));
|
|
}
|
|
|
|
|
|
ULONG
|
|
SP_CMeeting::
|
|
AddRef ( VOID )
|
|
{
|
|
::InterlockedIncrement (&m_cRefs);
|
|
return m_cRefs;
|
|
}
|
|
|
|
|
|
ULONG
|
|
SP_CMeeting::
|
|
Release ( VOID )
|
|
{
|
|
MyAssert (m_cRefs != 0);
|
|
::InterlockedDecrement (&m_cRefs);
|
|
|
|
ULONG cRefs = m_cRefs;
|
|
if (cRefs == 0)
|
|
delete this;
|
|
|
|
return cRefs;
|
|
}
|
|
|
|
|
|
HRESULT SP_CMeeting::
|
|
Register (
|
|
ULONG uRespID,
|
|
SERVER_INFO *pServerInfo,
|
|
LDAP_MEETINFO *pInfo )
|
|
{
|
|
MyAssert (pInfo != NULL);
|
|
MyAssert (MyIsGoodString (pServerInfo->pszServerName));
|
|
|
|
// Cache the server info
|
|
//
|
|
HRESULT hr = ::IlsCopyServerInfo (&m_ServerInfo, pServerInfo);
|
|
if (hr != S_OK)
|
|
return hr;
|
|
|
|
// Cache the meeting info
|
|
// lonchanc: CacheInfo() is not a method in the meeting object
|
|
// because we pass in meeting name in SetMeetingInfo()
|
|
// rather than meeting object handle.
|
|
//
|
|
hr = ::MtgCacheInfo (pInfo, &m_MtgInfo);
|
|
if (hr != S_OK)
|
|
return hr;
|
|
|
|
// If the application sets an IP address,
|
|
// then we will use what the app provides,
|
|
// otherwise, we will get the IP address via winsock.
|
|
//
|
|
if (pInfo->uOffsetHostIPAddress == INVALID_OFFSET)
|
|
{
|
|
// Get local IP address
|
|
//
|
|
m_dwIPAddress = 0;
|
|
hr = ::GetLocalIPAddress (&m_dwIPAddress);
|
|
if (hr != S_OK)
|
|
return hr;
|
|
|
|
// Create IP address string
|
|
//
|
|
m_MtgInfo.apszStdAttrValues[ENUM_MTGATTR_IP_ADDRESS] = &m_MtgInfo.szIPAddress[0];
|
|
::GetLongString (m_dwIPAddress, &m_MtgInfo.szIPAddress[0]);
|
|
}
|
|
|
|
// Create client signature string
|
|
//
|
|
m_MtgInfo.apszStdAttrValues[ENUM_MTGATTR_CLIENT_SIG] = &m_MtgInfo.szClientSig[0];
|
|
::GetLongString (g_dwClientSig, &m_MtgInfo.szClientSig[0]);
|
|
|
|
// Create TTL string
|
|
//
|
|
m_MtgInfo.apszStdAttrValues[ENUM_MTGATTR_TTL] = &m_MtgInfo.szTTL[0];
|
|
::GetLongString (m_uTTL, &m_MtgInfo.szTTL[0]);
|
|
|
|
// Ideally, o= and c= should be read in from registiry
|
|
// but for now, we simply hard code it
|
|
//
|
|
m_MtgInfo.apszStdAttrValues[ENUM_MTGATTR_OBJECT_CLASS] = (TCHAR *) &c_szRTConf[0];
|
|
m_MtgInfo.apszStdAttrValues[ENUM_MTGATTR_O] = (TCHAR *) &c_szDefO[0];
|
|
m_MtgInfo.apszStdAttrValues[ENUM_MTGATTR_C] = (TCHAR *) &c_szMtgDefC[0];
|
|
|
|
// Duplicate the mtg name
|
|
//
|
|
m_pszMtgName = My_strdup (m_MtgInfo.apszStdAttrValues[ENUM_MTGATTR_CN]);
|
|
if (m_pszMtgName == NULL)
|
|
return ILS_E_MEMORY;
|
|
|
|
// Build DN
|
|
//
|
|
m_pszDN = ::IlsBuildDN (m_ServerInfo.pszBaseDN,
|
|
m_MtgInfo.apszStdAttrValues[ENUM_MTGATTR_C],
|
|
m_MtgInfo.apszStdAttrValues[ENUM_MTGATTR_O],
|
|
m_MtgInfo.apszStdAttrValues[ENUM_MTGATTR_CN],
|
|
m_MtgInfo.apszStdAttrValues[ENUM_MTGATTR_OBJECT_CLASS]);
|
|
if (m_pszDN == NULL)
|
|
return ILS_E_MEMORY;
|
|
|
|
// Build refreh filter
|
|
//
|
|
m_pszRefreshFilter = ::MtgCreateRefreshFilter (m_pszMtgName);
|
|
if (m_pszRefreshFilter == NULL)
|
|
return ILS_E_MEMORY;
|
|
|
|
// Build modify array for ldap_add()
|
|
//
|
|
LDAPMod **ppMod = NULL;
|
|
hr = CreateRegModArr (&ppMod);
|
|
if (hr != S_OK)
|
|
return hr;
|
|
MyAssert (ppMod != NULL);
|
|
|
|
// so far, we are done with local preparation
|
|
//
|
|
|
|
// Get the connection object
|
|
//
|
|
SP_CSession *pSession = NULL;
|
|
LDAP *ld;
|
|
ULONG uMsgID = (ULONG) -1;
|
|
hr = g_pSessionContainer->GetSession (&pSession, &m_ServerInfo);
|
|
if (hr == S_OK)
|
|
{
|
|
MyAssert (pSession != NULL);
|
|
|
|
// Get the ldap session
|
|
//
|
|
ld = pSession->GetLd ();
|
|
MyAssert (ld != NULL);
|
|
|
|
// Send the data over the wire
|
|
//
|
|
uMsgID = ldap_add (ld, m_pszDN, ppMod);
|
|
if (uMsgID == -1)
|
|
{
|
|
hr = ::LdapError2Hresult (ld->ld_errno);
|
|
}
|
|
|
|
}
|
|
|
|
// Free modify array
|
|
//
|
|
MemFree (ppMod);
|
|
|
|
// Report failure if so
|
|
//
|
|
if (hr != S_OK)
|
|
goto MyExit;
|
|
|
|
// Construct a pending info
|
|
//
|
|
RESP_INFO ri;
|
|
::FillDefRespInfo (&ri, uRespID, ld, uMsgID, INVALID_MSG_ID);
|
|
ri.uNotifyMsg = WM_ILS_REGISTER_MEETING;
|
|
ri.hObject = (HANDLE) this;
|
|
|
|
// Remember the pending result
|
|
//
|
|
hr = g_pRespQueue->EnterRequest (pSession, &ri);
|
|
if (hr != S_OK)
|
|
{
|
|
MyAssert (FALSE);
|
|
goto MyExit;
|
|
}
|
|
|
|
MyExit:
|
|
|
|
if (hr != S_OK)
|
|
{
|
|
if (uMsgID != (ULONG) -1)
|
|
::ldap_abandon (ld, uMsgID);
|
|
|
|
if (pSession != NULL)
|
|
pSession->Disconnect ();
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT SP_CMeeting::
|
|
UnRegister ( ULONG uRespID )
|
|
{
|
|
MyAssert (MyIsGoodString (m_pszDN));
|
|
|
|
// Make sure that there is not refresh scheduled for this object
|
|
//
|
|
if (g_pRefreshScheduler != NULL)
|
|
{
|
|
g_pRefreshScheduler->RemoveMtgObject (this);
|
|
}
|
|
else
|
|
{
|
|
MyAssert (FALSE);
|
|
}
|
|
|
|
// If it is not registered on the server,
|
|
// the simply report success
|
|
//
|
|
if (! IsRegRemotely ())
|
|
{
|
|
SetRegNone ();
|
|
::PostMessage (g_hWndNotify, WM_ILS_UNREGISTER_MEETING, uRespID, S_OK);
|
|
return S_OK;
|
|
}
|
|
|
|
// Indicate that we are not registered at all
|
|
//
|
|
SetRegNone ();
|
|
|
|
// Get the session object
|
|
//
|
|
SP_CSession *pSession = NULL;
|
|
LDAP *ld;
|
|
ULONG uMsgID = (ULONG) -1;
|
|
HRESULT hr = g_pSessionContainer->GetSession (&pSession, &m_ServerInfo);
|
|
if (hr == S_OK)
|
|
{
|
|
// Get the ldap session
|
|
//
|
|
MyAssert (pSession != NULL);
|
|
ld = pSession->GetLd ();
|
|
MyAssert (ld != NULL);
|
|
|
|
// Send the data over the wire
|
|
//
|
|
MyAssert (MyIsGoodString (m_pszDN));
|
|
uMsgID = ::ldap_delete (ld, m_pszDN);
|
|
if (uMsgID == -1)
|
|
{
|
|
hr = ::LdapError2Hresult (ld->ld_errno);
|
|
}
|
|
}
|
|
|
|
// Report failure if so
|
|
//
|
|
if (hr != S_OK)
|
|
goto MyExit;
|
|
|
|
// Construct a pending info
|
|
//
|
|
RESP_INFO ri;
|
|
::FillDefRespInfo (&ri, uRespID, ld, uMsgID, INVALID_MSG_ID);
|
|
ri.uNotifyMsg = WM_ILS_UNREGISTER_MEETING;
|
|
|
|
// Remember the pending request
|
|
//
|
|
hr = g_pRespQueue->EnterRequest (pSession, &ri);
|
|
if (hr != S_OK)
|
|
{
|
|
MyAssert (FALSE);
|
|
goto MyExit;
|
|
}
|
|
|
|
MyExit:
|
|
|
|
if (hr != S_OK)
|
|
{
|
|
if (uMsgID != (ULONG) -1)
|
|
::ldap_abandon (ld, uMsgID);
|
|
|
|
if (pSession != NULL)
|
|
pSession->Disconnect ();
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT SP_CMeeting::
|
|
UpdateIPAddress ( VOID )
|
|
{
|
|
MyAssert (MyIsGoodString (m_pszDN));
|
|
|
|
// Update cached ip address
|
|
//
|
|
HRESULT hr = ::GetLocalIPAddress (&m_dwIPAddress);
|
|
if (hr != S_OK)
|
|
return hr;
|
|
|
|
// Update the ip address string
|
|
//
|
|
::GetLongString (m_dwIPAddress, &m_MtgInfo.szIPAddress[0]);
|
|
|
|
// Update IP address in the server
|
|
//
|
|
return ::IlsUpdateIPAddress ( &m_ServerInfo,
|
|
m_pszDN,
|
|
STR_MTG_IP_ADDR,
|
|
&m_MtgInfo.szIPAddress[0],
|
|
ISBU_MODOP_MODIFY_USER,
|
|
MtgGetPrefixCount (),
|
|
MtgGetPrefixString ());
|
|
}
|
|
|
|
|
|
/* ---------- protected methods ----------- */
|
|
|
|
|
|
HRESULT SP_CMeeting::
|
|
SendRefreshMsg ( VOID )
|
|
{
|
|
MyAssert (m_pszRefreshFilter != NULL);
|
|
|
|
// Get local IP address
|
|
//
|
|
DWORD dwIPAddress = 0;
|
|
HRESULT hr = ::GetLocalIPAddress (&dwIPAddress);
|
|
if (hr != S_OK)
|
|
{
|
|
MyDebugMsg ((ZONE_KA, "KA(Mtg): cannot get my ip address\r\n"));
|
|
|
|
// Indicate that I am not connected to the server anymore
|
|
//
|
|
SetRegLocally ();
|
|
|
|
// Second, notify this app of the network being down
|
|
//
|
|
::PostMessage (g_hWndNotify, WM_ILS_MEETING_NETWORK_DOWN,
|
|
(WPARAM) this, (LPARAM) m_dwContext);
|
|
|
|
// Report error
|
|
//
|
|
return ILS_E_NETWORK_DOWN;
|
|
}
|
|
|
|
// If dwIPAddress is 0, then we are not on the network any more
|
|
// start relogon process
|
|
//
|
|
if (dwIPAddress == 0)
|
|
{
|
|
MyDebugMsg ((ZONE_KA, "KA(Mtg): ip-addr=0, network down.\r\n"));
|
|
|
|
// Indicate that I am not connected to the server anymore
|
|
//
|
|
SetRegLocally ();
|
|
|
|
// Second, notify this app of the network being down
|
|
//
|
|
::PostMessage (g_hWndNotify, WM_ILS_MEETING_NETWORK_DOWN,
|
|
(WPARAM) this, (LPARAM) m_dwContext);
|
|
|
|
// Report error
|
|
//
|
|
return ILS_E_NETWORK_DOWN;
|
|
}
|
|
else
|
|
// If dwIPAddress and m_dwIPAddress, alert
|
|
//
|
|
if (dwIPAddress != m_dwIPAddress)
|
|
{
|
|
UpdateIPAddress ();
|
|
}
|
|
|
|
// Send a refresh message to the server and parse the new TTL value
|
|
//
|
|
hr = ::IlsSendRefreshMsg ( &m_ServerInfo,
|
|
STR_DEF_MTG_BASE_DN,
|
|
STR_MTG_TTL,
|
|
m_pszRefreshFilter,
|
|
&m_uTTL);
|
|
if (hr == ILS_E_NEED_RELOGON)
|
|
{
|
|
SetRegLocally ();
|
|
::PostMessage (g_hWndNotify, WM_ILS_MEETING_NEED_RELOGON,
|
|
(WPARAM) this, (LPARAM) m_dwContext);
|
|
}
|
|
else
|
|
if (hr == ILS_E_NETWORK_DOWN)
|
|
{
|
|
SetRegLocally ();
|
|
::PostMessage (g_hWndNotify, WM_ILS_MEETING_NETWORK_DOWN,
|
|
(WPARAM) this, (LPARAM) m_dwContext);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/* ---------- private methods ----------- */
|
|
|
|
|
|
HRESULT SP_CMeeting::
|
|
CreateRegModArr ( LDAPMod ***pppMod )
|
|
{
|
|
MyAssert (pppMod != NULL);
|
|
|
|
// Calculate the modify array size
|
|
//
|
|
ULONG cStdAttrs = COUNT_ENUM_MTGATTR;
|
|
ULONG cAnyAttrs = m_MtgInfo.AnyAttrs.cAttrsToAdd;
|
|
ULONG cTotal = cStdAttrs + cAnyAttrs;
|
|
ULONG cbMod = ::IlsCalcModifyListSize (cTotal);
|
|
|
|
// Allocate modify list
|
|
//
|
|
*pppMod = (LDAPMod **) MemAlloc (cbMod);
|
|
if (*pppMod == NULL)
|
|
return ILS_E_MEMORY;
|
|
|
|
// Lay out the modify array
|
|
//
|
|
LDAPMod **apMod = *pppMod;
|
|
LDAPMod *pMod;
|
|
TCHAR *pszName, *pszValue;
|
|
pszName = m_MtgInfo.AnyAttrs.pszAttrsToAdd;
|
|
for (ULONG i = 0; i < cTotal; i++)
|
|
{
|
|
pMod = ::IlsGetModifyListMod (pppMod, cTotal, i);
|
|
pMod->mod_op = LDAP_MOD_ADD;
|
|
apMod[i] = pMod;
|
|
|
|
if (i < cStdAttrs)
|
|
{
|
|
// Put standard attributes
|
|
//
|
|
::MtgFillModArrAttr (pMod, &m_MtgInfo, i);
|
|
}
|
|
else
|
|
{
|
|
// Put extended attributes
|
|
//
|
|
pszValue = pszName + lstrlen (pszName) + 1;
|
|
::IlsFillModifyListItem (pMod, pszName, pszValue);
|
|
pszName = pszValue + lstrlen (pszValue) + 1;
|
|
}
|
|
}
|
|
|
|
// Put null to terminate modify list
|
|
//
|
|
apMod[cTotal] = NULL;
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
|
|
/* ---------- helper functions ----------- */
|
|
|
|
|
|
HRESULT
|
|
MtgSetAttrs (
|
|
SERVER_INFO *pServerInfo,
|
|
TCHAR *pszMtgName,
|
|
LDAP_MEETINFO *pInfo,
|
|
ULONG uRespID )
|
|
{
|
|
MyAssert (pServerInfo != NULL);
|
|
MyAssert (MyIsGoodString (pszMtgName));
|
|
MyAssert (pInfo != NULL);
|
|
|
|
// Cannot change lMeetingPlaceType, lAttendeeType, and MeetingID
|
|
//
|
|
if (pInfo->lMeetingPlaceType != INVALID_MEETING_TYPE ||
|
|
pInfo->lAttendeeType != INVALID_ATTENDEE_TYPE ||
|
|
pInfo->uOffsetMeetingPlaceID != INVALID_OFFSET)
|
|
{
|
|
return ILS_E_PARAMETER;
|
|
}
|
|
|
|
// Initialize locals
|
|
//
|
|
TCHAR *pszDN = NULL;
|
|
LDAPMod **ppMod = NULL;
|
|
SP_CSession *pSession = NULL;
|
|
ULONG uMsgID = (ULONG) -1;
|
|
|
|
MTG_INFO MtgInfo;
|
|
ZeroMemory (&MtgInfo, sizeof (MtgInfo));
|
|
|
|
// Cache the meeting info
|
|
//
|
|
HRESULT hr = MtgCacheInfo (pInfo, &MtgInfo);
|
|
if (hr != S_OK)
|
|
goto MyExit;
|
|
|
|
// Build DN for meeting
|
|
//
|
|
pszDN = IlsBuildDN (pServerInfo->pszBaseDN,
|
|
(TCHAR *) &c_szMtgDefC[0],
|
|
(TCHAR *) &c_szDefO[0],
|
|
pszMtgName,
|
|
(TCHAR *) &c_szRTConf[0]);
|
|
if (pszDN == NULL)
|
|
{
|
|
hr = ILS_E_MEMORY;
|
|
goto MyExit;
|
|
}
|
|
|
|
// Build modify array for ldap_modify()
|
|
//
|
|
hr = MtgCreateSetAttrsModArr (&ppMod, &MtgInfo);
|
|
if (hr != S_OK)
|
|
goto MyExit;
|
|
MyAssert (ppMod != NULL);
|
|
|
|
// Get the session object
|
|
//
|
|
LDAP *ld;
|
|
hr = g_pSessionContainer->GetSession (&pSession, pServerInfo);
|
|
if (hr == S_OK)
|
|
{
|
|
MyAssert (pSession != NULL);
|
|
|
|
// Get the ldap session
|
|
//
|
|
ld = pSession->GetLd ();
|
|
MyAssert (ld != NULL);
|
|
|
|
// Send the data over the wire
|
|
//
|
|
uMsgID = ldap_modify (ld, pszDN, ppMod);
|
|
if (uMsgID == (ULONG) -1)
|
|
{
|
|
hr = ::LdapError2Hresult (ld->ld_errno);
|
|
}
|
|
}
|
|
|
|
// Report failure if so
|
|
//
|
|
if (hr != S_OK)
|
|
goto MyExit;
|
|
|
|
// Construct pending info
|
|
//
|
|
RESP_INFO ri;
|
|
FillDefRespInfo (&ri, uRespID, ld, uMsgID, INVALID_MSG_ID);
|
|
ri.uNotifyMsg = WM_ILS_SET_MEETING_INFO;
|
|
|
|
// Remember the pending request
|
|
//
|
|
hr = g_pRespQueue->EnterRequest (pSession, &ri);
|
|
if (hr != S_OK)
|
|
{
|
|
MyAssert (FALSE);
|
|
goto MyExit;
|
|
}
|
|
|
|
MyExit:
|
|
|
|
MemFree (pszDN);
|
|
MemFree (ppMod);
|
|
IlsReleaseAnyAttrsPrefix (&(MtgInfo.AnyAttrs));
|
|
|
|
if (hr != S_OK)
|
|
{
|
|
if (uMsgID != (ULONG) -1)
|
|
::ldap_abandon (ld, uMsgID);
|
|
|
|
if (pSession != NULL)
|
|
pSession->Disconnect ();
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
VOID
|
|
MtgFillModArrAttr (
|
|
LDAPMod *pMod,
|
|
MTG_INFO *pMtgInfo,
|
|
INT nIndex )
|
|
{
|
|
MyAssert (pMod != NULL);
|
|
MyAssert (pMtgInfo != NULL);
|
|
MyAssert (0 <= nIndex && nIndex <= COUNT_ENUM_MTGATTR);
|
|
|
|
IlsFillModifyListItem ( pMod,
|
|
(TCHAR *) c_apszMtgStdAttrNames[nIndex],
|
|
pMtgInfo->apszStdAttrValues[nIndex]);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
MtgCreateSetAttrsModArr (
|
|
LDAPMod ***pppMod,
|
|
MTG_INFO *pMtgInfo )
|
|
{
|
|
MyAssert (pppMod != NULL);
|
|
|
|
HRESULT hr;
|
|
DWORD dwFlags = pMtgInfo->dwFlags;
|
|
ULONG cTotal = pMtgInfo->AnyAttrs.cAttrsToAdd +
|
|
pMtgInfo->AnyAttrs.cAttrsToModify +
|
|
pMtgInfo->AnyAttrs.cAttrsToRemove;
|
|
|
|
// Lay out the modify array for modifying standard/extended attributes
|
|
//
|
|
hr = IlsFillDefStdAttrsModArr (pppMod,
|
|
dwFlags,
|
|
COUNT_ENUM_MTGINFO,
|
|
&cTotal,
|
|
ISBU_MODOP_MODIFY_USER,
|
|
MtgGetPrefixCount (),
|
|
MtgGetPrefixString ());
|
|
if (hr != S_OK)
|
|
return hr;
|
|
|
|
// Start to fill standard attributes
|
|
//
|
|
ULONG i = MtgGetPrefixCount ();
|
|
LDAPMod **apMod = *pppMod;
|
|
|
|
if (dwFlags & MTGOBJ_F_NAME)
|
|
MtgFillModArrAttr (apMod[i++], pMtgInfo, ENUM_MTGATTR_CN);
|
|
|
|
if (dwFlags & MTGOBJ_F_MTG_TYPE)
|
|
MtgFillModArrAttr (apMod[i++], pMtgInfo, ENUM_MTGATTR_MTG_TYPE);
|
|
|
|
if (dwFlags & MTGOBJ_F_MEMBER_TYPE)
|
|
MtgFillModArrAttr (apMod[i++], pMtgInfo, ENUM_MTGATTR_MEMBER_TYPE);
|
|
|
|
if (dwFlags & MTGOBJ_F_DESCRIPTION)
|
|
MtgFillModArrAttr (apMod[i++], pMtgInfo, ENUM_MTGATTR_DESCRIPTION);
|
|
|
|
if (dwFlags & MTGOBJ_F_HOST_NAME)
|
|
MtgFillModArrAttr (apMod[i++], pMtgInfo, ENUM_MTGATTR_HOST_NAME);
|
|
|
|
if (dwFlags & MTGOBJ_F_IP_ADDRESS)
|
|
MtgFillModArrAttr (apMod[i++], pMtgInfo, ENUM_MTGATTR_IP_ADDRESS);
|
|
|
|
// Start to fill extended attributes
|
|
//
|
|
::IlsFillModifyListForAnyAttrs (apMod, &i, &(pMtgInfo->AnyAttrs));
|
|
|
|
MyAssert (i == cTotal);
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
MtgCacheInfo (
|
|
LDAP_MEETINFO *pInfo,
|
|
MTG_INFO *pMtgInfo )
|
|
{
|
|
MyAssert (pInfo != NULL);
|
|
MyAssert (pMtgInfo != NULL);
|
|
|
|
// Release the previous prefix for extended attribute names
|
|
//
|
|
IlsReleaseAnyAttrsPrefix (&(pMtgInfo->AnyAttrs));
|
|
|
|
// Clean up the buffer
|
|
//
|
|
ZeroMemory (pMtgInfo, sizeof (*pMtgInfo));
|
|
|
|
// Start to cache mtg standard attributes
|
|
//
|
|
|
|
if (pInfo->lMeetingPlaceType != INVALID_MEETING_TYPE)
|
|
{
|
|
GetLongString (pInfo->lMeetingPlaceType, &(pMtgInfo->szMtgType[0]));
|
|
pMtgInfo->apszStdAttrValues[ENUM_MTGATTR_MTG_TYPE] = &(pMtgInfo->szMtgType[0]);
|
|
pMtgInfo->dwFlags |= MTGOBJ_F_MTG_TYPE;
|
|
}
|
|
|
|
if (pInfo->lAttendeeType != INVALID_ATTENDEE_TYPE)
|
|
{
|
|
GetLongString (pInfo->lAttendeeType, &(pMtgInfo->szMemberType[0]));
|
|
pMtgInfo->apszStdAttrValues[ENUM_MTGATTR_MEMBER_TYPE] = &(pMtgInfo->szMemberType[0]);
|
|
pMtgInfo->dwFlags |= MTGOBJ_F_MEMBER_TYPE;
|
|
}
|
|
|
|
if (pInfo->uOffsetMeetingPlaceID != INVALID_OFFSET)
|
|
{
|
|
pMtgInfo->apszStdAttrValues[ENUM_MTGATTR_CN] =
|
|
(TCHAR *) (((BYTE *) pInfo) + pInfo->uOffsetMeetingPlaceID);
|
|
pMtgInfo->dwFlags |= MTGOBJ_F_NAME;
|
|
}
|
|
|
|
if (pInfo->uOffsetDescription != INVALID_OFFSET)
|
|
{
|
|
pMtgInfo->apszStdAttrValues[ENUM_MTGATTR_DESCRIPTION] =
|
|
(TCHAR *) (((BYTE *) pInfo) + pInfo->uOffsetDescription);
|
|
pMtgInfo->dwFlags |= MTGOBJ_F_DESCRIPTION;
|
|
}
|
|
|
|
if (pInfo->uOffsetHostName != INVALID_OFFSET)
|
|
{
|
|
pMtgInfo->apszStdAttrValues[ENUM_MTGATTR_HOST_NAME] =
|
|
(TCHAR *) (((BYTE *) pInfo) + pInfo->uOffsetHostName);
|
|
pMtgInfo->dwFlags |= MTGOBJ_F_HOST_NAME;
|
|
}
|
|
|
|
if (pInfo->uOffsetHostIPAddress != INVALID_OFFSET)
|
|
{
|
|
pMtgInfo->apszStdAttrValues[ENUM_MTGATTR_IP_ADDRESS] =
|
|
(TCHAR *) (((BYTE *) pInfo) + pInfo->uOffsetHostIPAddress);
|
|
pMtgInfo->dwFlags |= MTGOBJ_F_IP_ADDRESS;
|
|
}
|
|
|
|
// Start to cache mtg extended attributes
|
|
//
|
|
|
|
if (pInfo->uOffsetAttrsToAdd != INVALID_OFFSET &&
|
|
pInfo->cAttrsToAdd != 0)
|
|
{
|
|
pMtgInfo->AnyAttrs.cAttrsToAdd = pInfo->cAttrsToAdd;
|
|
pMtgInfo->AnyAttrs.pszAttrsToAdd =
|
|
(TCHAR *) (((BYTE *) pInfo) + pInfo->uOffsetAttrsToAdd);
|
|
}
|
|
|
|
if (pInfo->uOffsetAttrsToModify != INVALID_OFFSET &&
|
|
pInfo->cAttrsToModify != 0)
|
|
{
|
|
pMtgInfo->AnyAttrs.cAttrsToModify = pInfo->cAttrsToModify;
|
|
pMtgInfo->AnyAttrs.pszAttrsToModify =
|
|
(TCHAR *) (((BYTE *) pInfo) + pInfo->uOffsetAttrsToModify);
|
|
}
|
|
|
|
if (pInfo->uOffsetAttrsToRemove != INVALID_OFFSET &&
|
|
pInfo->cAttrsToRemove != 0)
|
|
{
|
|
pMtgInfo->AnyAttrs.cAttrsToRemove = pInfo->cAttrsToRemove;
|
|
pMtgInfo->AnyAttrs.pszAttrsToRemove =
|
|
(TCHAR *) (((BYTE *) pInfo) + pInfo->uOffsetAttrsToRemove);
|
|
}
|
|
|
|
// Create prefix for extended attribute names
|
|
//
|
|
return IlsCreateAnyAttrsPrefix (&(pMtgInfo->AnyAttrs));
|
|
}
|
|
|
|
|
|
HRESULT
|
|
MtgUpdateMembers (
|
|
ULONG uNotifyMsg,
|
|
SERVER_INFO *pServerInfo,
|
|
TCHAR *pszMtgName,
|
|
ULONG cMembers,
|
|
TCHAR *pszMemberNames,
|
|
ULONG uRespID )
|
|
{
|
|
MyAssert ( uNotifyMsg == WM_ILS_ADD_ATTENDEE ||
|
|
uNotifyMsg == WM_ILS_REMOVE_ATTENDEE);
|
|
|
|
MyAssert (pServerInfo != NULL);
|
|
MyAssert (MyIsGoodString (pszMtgName));
|
|
MyAssert (MyIsGoodString (pszMemberNames));
|
|
|
|
// Initialize locals
|
|
//
|
|
HRESULT hr = S_OK;
|
|
TCHAR *pszDN = NULL;
|
|
LDAPMod **ppMod = NULL;
|
|
SP_CSession *pSession = NULL;
|
|
ULONG uMsgID = (ULONG) -1;
|
|
|
|
// Build DN for meeting
|
|
//
|
|
pszDN = IlsBuildDN (pServerInfo->pszBaseDN,
|
|
(TCHAR *) &c_szMtgDefC[0],
|
|
(TCHAR *) &c_szDefO[0],
|
|
pszMtgName,
|
|
(TCHAR *) &c_szRTConf[0]);
|
|
if (pszDN == NULL)
|
|
return ILS_E_MEMORY;
|
|
|
|
// Build modify array for ldap_modify()
|
|
//
|
|
hr = MtgCreateUpdateMemberModArr ( uNotifyMsg,
|
|
&ppMod,
|
|
cMembers,
|
|
pszMemberNames);
|
|
if (hr != S_OK)
|
|
goto MyExit;
|
|
MyAssert (ppMod != NULL);
|
|
|
|
// Get the session object
|
|
//
|
|
LDAP *ld;
|
|
hr = g_pSessionContainer->GetSession (&pSession, pServerInfo);
|
|
if (hr == S_OK)
|
|
{
|
|
MyAssert (pSession != NULL);
|
|
|
|
// Get the ldap session
|
|
//
|
|
ld = pSession->GetLd ();
|
|
MyAssert (ld != NULL);
|
|
|
|
// Send the data over the wire
|
|
//
|
|
uMsgID = ldap_modify (ld, pszDN, ppMod);
|
|
if (uMsgID == (ULONG) -1)
|
|
{
|
|
hr = ::LdapError2Hresult (ld->ld_errno);
|
|
}
|
|
}
|
|
|
|
// Report failure if so
|
|
//
|
|
if (hr != S_OK)
|
|
goto MyExit;
|
|
|
|
// Construct pending info
|
|
//
|
|
RESP_INFO ri;
|
|
FillDefRespInfo (&ri, uRespID, ld, uMsgID, INVALID_MSG_ID);
|
|
ri.uNotifyMsg = uNotifyMsg;
|
|
|
|
// Remember the pending request
|
|
//
|
|
hr = g_pRespQueue->EnterRequest (pSession, &ri);
|
|
if (hr != S_OK)
|
|
{
|
|
MyAssert (FALSE);
|
|
goto MyExit;
|
|
}
|
|
|
|
MyExit:
|
|
|
|
MemFree (pszDN);
|
|
MemFree (ppMod);
|
|
|
|
if (hr != S_OK)
|
|
{
|
|
if (uMsgID != (ULONG) -1)
|
|
::ldap_abandon (ld, uMsgID);
|
|
|
|
if (pSession != NULL)
|
|
pSession->Disconnect ();
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
MtgCreateUpdateMemberModArr (
|
|
ULONG uNotifyMsg,
|
|
LDAPMod ***pppMod,
|
|
ULONG cMembers,
|
|
TCHAR *pszMemberNames )
|
|
{
|
|
MyAssert (pppMod != NULL);
|
|
MyAssert (pszMemberNames != NULL);
|
|
|
|
// Get meeting object prefix
|
|
//
|
|
ULONG cPrefix = MtgGetPrefixCount ();
|
|
TCHAR *pszPrefix = MtgGetPrefixString ();
|
|
|
|
// The total number of attributes is the number of prefix attributes
|
|
// plus the very only ConfMemberList
|
|
//
|
|
ULONG cStdAttrs = 1;
|
|
ULONG cTotal = cPrefix + cStdAttrs;
|
|
|
|
// Calculate the modify array's total size
|
|
//
|
|
ULONG cbMod = IlsCalcModifyListSize (cTotal);
|
|
|
|
// Add up for multi-valued attribute
|
|
//
|
|
cbMod += cStdAttrs * (cMembers - 1) * sizeof (TCHAR *);
|
|
|
|
// Allocate the modify array
|
|
//
|
|
LDAPMod **apMod = *pppMod = (LDAPMod **) MemAlloc (cbMod);
|
|
if (apMod == NULL)
|
|
return ILS_E_MEMORY;
|
|
|
|
// Fill in the modify list
|
|
//
|
|
LDAPMod *pMod;
|
|
BYTE *pbData = (BYTE *) apMod + (cTotal + 1) * sizeof (LDAPMod *);
|
|
ULONG uDispPrefix = sizeof (LDAPMod) + 2 * sizeof (TCHAR *);
|
|
ULONG uDispStdAttrs = sizeof (LDAPMod) + (cMembers + 1) * sizeof (TCHAR *);
|
|
for (ULONG uOffset = 0, i = 0; i < cTotal; i++)
|
|
{
|
|
// Locate the modify structure
|
|
//
|
|
pMod = (LDAPMod *) (pbData + uOffset);
|
|
apMod[i] = pMod;
|
|
pMod->mod_values = (TCHAR **) (pMod + 1);
|
|
|
|
// Fill in the modify structure
|
|
//
|
|
if (i < cPrefix)
|
|
{
|
|
pMod->mod_op = LDAP_MOD_REPLACE;
|
|
pMod->mod_type = pszPrefix;
|
|
pszPrefix += lstrlen (pszPrefix) + 1;
|
|
*(pMod->mod_values) = pszPrefix;
|
|
pszPrefix += lstrlen (pszPrefix) + 1;
|
|
}
|
|
else
|
|
{
|
|
// Fill in attribute name
|
|
//
|
|
pMod->mod_op = (uNotifyMsg == WM_ILS_ADD_ATTENDEE) ?
|
|
LDAP_MOD_ADD : LDAP_MOD_DELETE;
|
|
pMod->mod_type = (TCHAR *) c_apszMtgStdAttrNames[ENUM_MTGATTR_MEMBERS];
|
|
|
|
// Fill in multi-valued modify array
|
|
//
|
|
for (ULONG j = 0; j < cMembers; j++)
|
|
{
|
|
(pMod->mod_values)[j++] = pszMemberNames;
|
|
pszMemberNames += lstrlen (pszMemberNames) + 1;
|
|
}
|
|
}
|
|
|
|
// Calculate the modify structure's offset relative to the array's end
|
|
//
|
|
uOffset += (i < cPrefix) ? uDispPrefix : uDispStdAttrs;
|
|
}
|
|
|
|
// Fix up the first and the last ones
|
|
//
|
|
IlsFixUpModOp (apMod[0], LDAP_MOD_REPLACE, ISBU_MODOP_MODIFY_APP);
|
|
apMod[cTotal] = NULL;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
#endif // ENABLE_MEETING_PLACE
|
|
|