965 lines
27 KiB
C++
965 lines
27 KiB
C++
#include "precomp.h"
|
|
#include "fsdiag.h"
|
|
DEBUG_FILEZONE(ZONE_T120_GCCNC);
|
|
|
|
/*
|
|
* userdata.cpp
|
|
*
|
|
* Copyright (c) 1995 by DataBeam Corporation, Lexington, KY
|
|
*
|
|
* Abstract:
|
|
* This is the implementation file for the class CUserDataListContainer. CUserDataListContainer
|
|
* objects are used to maintain user data elements. A user data element
|
|
* consists of an Object Key and an optional octet string. The Object
|
|
* Key data is maintained internally by this class by using an
|
|
* CObjectKeyContainer container. The optional octet string data is maintained
|
|
* internally through the use of a Rogue Wave string container.
|
|
*
|
|
* Protected Instance Variables:
|
|
* m_UserDataItemList
|
|
* List of structures used to hold the user data internally.
|
|
* m_pSetOfUserDataPDU
|
|
* Storage for the "PDU" form of the user data.
|
|
* m_cbDataSize
|
|
* Variable holding the size of the memory which will be required to
|
|
* hold any data referenced by the "API" GCCUserData structure.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*
|
|
* Author:
|
|
* jbo
|
|
*/
|
|
|
|
#include "userdata.h"
|
|
#include "clists.h"
|
|
|
|
USER_DATA::~USER_DATA(void)
|
|
{
|
|
if (NULL != key)
|
|
{
|
|
key->Release();
|
|
}
|
|
delete poszOctetString;
|
|
}
|
|
|
|
/*
|
|
* CUserDataListContainer()
|
|
*
|
|
* Public Function Description
|
|
* This CUserDataListContainer constructor is used to create a CUserDataListContainer object
|
|
* from "API" data. The constructor immediately copies the user data
|
|
* passed in as a list of "GCCUserData" structures into it's internal form
|
|
* where a Rogue Wave container holds the data in the form of
|
|
* USER_DATA structures.
|
|
*/
|
|
CUserDataListContainer::
|
|
CUserDataListContainer(UINT cMembers, PGCCUserData *user_data_list, PGCCError pRetCode)
|
|
:
|
|
CRefCount(MAKE_STAMP_ID('U','r','D','L')),
|
|
m_UserDataItemList(DESIRED_MAX_USER_DATA_ITEMS),
|
|
m_cbDataSize(0),
|
|
m_pSetOfUserDataPDU(NULL)
|
|
{
|
|
/*
|
|
* Copy the user data into the internal structures.
|
|
*/
|
|
*pRetCode = CopyUserDataList(cMembers, user_data_list);
|
|
}
|
|
|
|
/*
|
|
* CUserDataListContainer()
|
|
*
|
|
* Public Function Description
|
|
* This CUserDataListContainer constructor is used to create a CUserDataListContainer object
|
|
* from data passed in as a "PDU" SetOfUserData structure. The user
|
|
* data is copied into it's internal form where a Rogue Wave container
|
|
* holds the data in the form of USER_DATA structures.
|
|
*/
|
|
CUserDataListContainer::
|
|
CUserDataListContainer(PSetOfUserData set_of_user_data, PGCCError pRetCode)
|
|
:
|
|
CRefCount(MAKE_STAMP_ID('U','r','D','L')),
|
|
m_UserDataItemList(DESIRED_MAX_USER_DATA_ITEMS),
|
|
m_cbDataSize(0),
|
|
m_pSetOfUserDataPDU(NULL)
|
|
{
|
|
/*
|
|
* Copy the user data into the internal structures.
|
|
*/
|
|
*pRetCode = UnPackUserDataFromPDU(set_of_user_data);
|
|
}
|
|
|
|
/*
|
|
* CUserDataListContainer()
|
|
*
|
|
* Public Function Description
|
|
* This CUserDataListContainer copy constructor is used to create a CUserDataListContainer
|
|
* object from another CUserDataListContainer object. The constructor immediately
|
|
* copies the user data passed in into it's internal form where a Rogue
|
|
* Wave list holds the data in the form of USER_DATA structures.
|
|
*/
|
|
CUserDataListContainer::
|
|
CUserDataListContainer(CUserDataListContainer *user_data_list, PGCCError pRetCode)
|
|
:
|
|
CRefCount(MAKE_STAMP_ID('U','r','D','L')),
|
|
m_UserDataItemList(DESIRED_MAX_USER_DATA_ITEMS),
|
|
m_cbDataSize(0),
|
|
m_pSetOfUserDataPDU(NULL)
|
|
{
|
|
GCCError rc;
|
|
USER_DATA *user_data_info_ptr;
|
|
USER_DATA *lpUsrDataInfo;
|
|
|
|
/*
|
|
* Set up an iterator for the internal list of "info" structures in the
|
|
* CUserDataListContainer object to be copied.
|
|
*/
|
|
user_data_list->m_UserDataItemList.Reset();
|
|
|
|
/*
|
|
* Copy each USER_DATA structure contained in the CUserDataListContainer object to
|
|
* be copied.
|
|
*/
|
|
while (NULL != (lpUsrDataInfo = user_data_list->m_UserDataItemList.Iterate()))
|
|
{
|
|
/*
|
|
* Create a new USER_DATA structure to hold each element of the new
|
|
* CUserDataListContainer object. Report an error if creation of this structure
|
|
* fails.
|
|
*/
|
|
DBG_SAVE_FILE_LINE
|
|
user_data_info_ptr = new USER_DATA;
|
|
if (user_data_info_ptr != NULL)
|
|
{
|
|
user_data_info_ptr->poszOctetString = NULL;
|
|
|
|
/*
|
|
* Go ahead and insert the pointer to the USER_DATA structure
|
|
* into the internal Rogue Wave list.
|
|
*/
|
|
m_UserDataItemList.Append(user_data_info_ptr);
|
|
|
|
/*
|
|
* Create a new CObjectKeyContainer object to hold the "key" using the
|
|
* copy constructor for the CObjectKeyContainer class. Check to be sure
|
|
* construction of the object is successful. Note that validation
|
|
* of the object key data is not done here since this would be done
|
|
* when the original CUserDataListContainer object was created.
|
|
*/
|
|
DBG_SAVE_FILE_LINE
|
|
user_data_info_ptr->key = new CObjectKeyContainer(lpUsrDataInfo->key, &rc);
|
|
if ((NULL != user_data_info_ptr->key) && (GCC_NO_ERROR == rc))
|
|
{
|
|
/*
|
|
* If an octet string exists, create a new Rogue Wave string to hold
|
|
* the octet string portion of the "key" and copy the octet string
|
|
* from the old CUserDataListContainer object into the new USER_DATA
|
|
* structure.
|
|
*/
|
|
if (lpUsrDataInfo->poszOctetString != NULL)
|
|
{
|
|
if (NULL == (user_data_info_ptr->poszOctetString =
|
|
::My_strdupO(lpUsrDataInfo->poszOctetString)))
|
|
{
|
|
ERROR_OUT(("UserData::UserData: can't create octet string"));
|
|
rc = GCC_ALLOCATION_FAILURE;
|
|
goto MyExit;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ASSERT(NULL == user_data_info_ptr->poszOctetString);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERROR_OUT(("UserData::UserData: Error creating new ObjectKeyData"));
|
|
rc = GCC_ALLOCATION_FAILURE;
|
|
goto MyExit;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERROR_OUT(("UserData::UserData: can't create USER_DATA"));
|
|
rc = GCC_ALLOCATION_FAILURE;
|
|
goto MyExit;
|
|
}
|
|
}
|
|
|
|
rc = GCC_NO_ERROR;
|
|
|
|
MyExit:
|
|
|
|
*pRetCode = rc;
|
|
}
|
|
|
|
/*
|
|
* ~CUserDataListContainer()
|
|
*
|
|
* Public Function Description
|
|
* This is the destructor for the CUserDataListContainer class. It is used to
|
|
* clean up any memory allocated during the life of this object.
|
|
*/
|
|
CUserDataListContainer::
|
|
~CUserDataListContainer(void)
|
|
{
|
|
/*
|
|
* Free any PDU data which may have not been freed.
|
|
*/
|
|
if (m_pSetOfUserDataPDU)
|
|
{
|
|
FreeUserDataListPDU();
|
|
}
|
|
|
|
/*
|
|
* Set up an iterator to use for iterating through the internal Rogue
|
|
* Wave list of USER_DATA structures.
|
|
*/
|
|
USER_DATA *pUserDataItem;
|
|
m_UserDataItemList.Reset();
|
|
while (NULL != (pUserDataItem = m_UserDataItemList.Iterate()))
|
|
{
|
|
/*
|
|
* Delete any memory being referenced in the USER_DATA structure.
|
|
*/
|
|
delete pUserDataItem;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* LockUserDataList ()
|
|
*
|
|
* Public Function Description:
|
|
* This routine locks the user data list and determines the amount of
|
|
* memory referenced by the "API" user data list structures.
|
|
*/
|
|
UINT CUserDataListContainer::
|
|
LockUserDataList(void)
|
|
{
|
|
/*
|
|
* If this is the first time this routine is called, determine the size of
|
|
* the memory required to hold the data. Otherwise, just increment the
|
|
* lock count.
|
|
*/
|
|
if (Lock() == 1)
|
|
{
|
|
USER_DATA *lpUsrDataInfo;
|
|
/*
|
|
* Set aside memory to hold the pointers to the GCCUserData structures
|
|
* as well as the structures themselves. The "sizeof" the structure
|
|
* must be rounded to an even four-byte boundary.
|
|
*/
|
|
m_cbDataSize = m_UserDataItemList.GetCount() *
|
|
(sizeof(PGCCUserData) + ROUNDTOBOUNDARY(sizeof(GCCUserData)) );
|
|
|
|
m_UserDataItemList.Reset();
|
|
while (NULL != (lpUsrDataInfo = m_UserDataItemList.Iterate()))
|
|
{
|
|
/*
|
|
* Lock the data for the object keys, adding the amount of memory
|
|
* necessary to hold the object key data to the total memory size.
|
|
*/
|
|
m_cbDataSize += lpUsrDataInfo->key->LockObjectKeyData();
|
|
|
|
/*
|
|
* Check to see if this user data element contains the optional
|
|
* user data octet string. Add the space to hold it if it exists.
|
|
*/
|
|
if (lpUsrDataInfo->poszOctetString != NULL)
|
|
{
|
|
/*
|
|
* Since the user data structure contains a pointer to a
|
|
* OSTR structure, we must add the amount of memory
|
|
* needed to hold the structure as well as the string data.
|
|
*/
|
|
m_cbDataSize += ROUNDTOBOUNDARY(sizeof(OSTR));
|
|
|
|
/*
|
|
* The data referenced by the octet string is just the byte
|
|
* length of the octet string.
|
|
*/
|
|
m_cbDataSize += ROUNDTOBOUNDARY(lpUsrDataInfo->poszOctetString->length);
|
|
}
|
|
}
|
|
}
|
|
|
|
return m_cbDataSize;
|
|
}
|
|
|
|
/*
|
|
* GetUserDataList ()
|
|
*
|
|
* Public Function Description:
|
|
* This routine retrieves user data elements contained in the user data
|
|
* object and returns them in the "API" form of a list of pointers to
|
|
* "GCCUserData" structures. The number of user data elements contained
|
|
* in this object is also returned.
|
|
*/
|
|
UINT CUserDataListContainer::
|
|
GetUserDataList(USHORT *number_of_members, PGCCUserData **user_data_list, LPBYTE memory)
|
|
{
|
|
UINT cbDataSizeToRet = 0;
|
|
UINT data_length = 0;
|
|
Int user_data_counter = 0;
|
|
PGCCUserData user_data_ptr;
|
|
|
|
/*
|
|
* If the user data has been locked, fill in the output parameters and
|
|
* the data referenced by the pointers. Otherwise, report that the object
|
|
* has yet to be locked into the "API" form.
|
|
*/
|
|
if (GetLockCount() > 0)
|
|
{
|
|
USER_DATA *lpUsrDataInfo;
|
|
/*
|
|
* Fill in the output length parameter which indicates how much data
|
|
* referenced outside the structure will be written.
|
|
*/
|
|
cbDataSizeToRet = m_cbDataSize;
|
|
|
|
/*
|
|
* Fill in the number of user data entities and save a pointer to the
|
|
* memory location passed in. This is where the pointers to the
|
|
* GCCUserData structures will be written. The actual structures will
|
|
* be written into memory immediately following the list of pointers.
|
|
*/
|
|
*number_of_members = (USHORT) m_UserDataItemList.GetCount();
|
|
|
|
*user_data_list = (PGCCUserData *)memory;
|
|
|
|
/*
|
|
* Save the amount of memory needed to hold the list of pointers
|
|
* as well as the actual user data structures.
|
|
*/
|
|
data_length = m_UserDataItemList.GetCount() * sizeof(PGCCUserData);
|
|
|
|
/*
|
|
* Move the memory pointer past the list of user data pointers. This
|
|
* is where the first user data structure will be written.
|
|
*/
|
|
memory += data_length;
|
|
|
|
/*
|
|
* Iterate through the internal list of USER_DATA structures,
|
|
* building "API" GCCUserData structures in memory.
|
|
*/
|
|
m_UserDataItemList.Reset();
|
|
while (NULL != (lpUsrDataInfo = m_UserDataItemList.Iterate()))
|
|
{
|
|
/*
|
|
* Save the pointer to the user data structure in the list
|
|
* of pointers.
|
|
*/
|
|
user_data_ptr = (PGCCUserData)memory;
|
|
(*user_data_list)[user_data_counter++] = user_data_ptr;
|
|
|
|
/*
|
|
* Move the memory pointer past the user data structure. This is
|
|
* where the object key data and octet string data will be written.
|
|
*/
|
|
memory += ROUNDTOBOUNDARY(sizeof(GCCUserData));
|
|
|
|
/*
|
|
* Fill in the user data structure starting with the object key.
|
|
*/
|
|
data_length = lpUsrDataInfo->key->GetGCCObjectKeyData(&user_data_ptr->key, memory);
|
|
|
|
/*
|
|
* Move the memory pointer past the object key data. This is
|
|
* where the octet string structure will be written, if it exists.
|
|
* If the octet string does exist, save the memory pointer in the
|
|
* user data structure's octet string pointer and fill in the
|
|
* elements of the octet string structure. Otherwise, set the
|
|
* octet string pointer to NULL.
|
|
*/
|
|
memory += data_length;
|
|
|
|
if (lpUsrDataInfo->poszOctetString == NULL)
|
|
{
|
|
user_data_ptr->octet_string = NULL;
|
|
}
|
|
else
|
|
{
|
|
user_data_ptr->octet_string = (LPOSTR) memory;
|
|
|
|
/*
|
|
* Move the memory pointer past the octet string structure.
|
|
* This is where the actual string data for the octet string
|
|
* will be written.
|
|
*/
|
|
memory += ROUNDTOBOUNDARY(sizeof(OSTR));
|
|
|
|
/*
|
|
* Write the octet string data into memory and set the octet
|
|
* string structure pointer and length.
|
|
*/
|
|
user_data_ptr->octet_string->length =
|
|
lpUsrDataInfo->poszOctetString->length;
|
|
user_data_ptr->octet_string->value = (LPBYTE)memory;
|
|
|
|
/*
|
|
* Now copy the octet string data from the internal Rogue Wave
|
|
* string into the object key structure held in memory.
|
|
*/
|
|
::CopyMemory(memory, lpUsrDataInfo->poszOctetString->value,
|
|
lpUsrDataInfo->poszOctetString->length);
|
|
|
|
/*
|
|
* Move the memory pointer past the octet string data.
|
|
*/
|
|
memory += ROUNDTOBOUNDARY(user_data_ptr->octet_string->length);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
*user_data_list = NULL;
|
|
*number_of_members = 0;
|
|
ERROR_OUT(("CUserDataListContainer::GetUserDataList: Error Data Not Locked"));
|
|
}
|
|
|
|
return cbDataSizeToRet;
|
|
}
|
|
|
|
/*
|
|
* UnLockUserDataList ()
|
|
*
|
|
* Public Function Description:
|
|
* This routine is used to "unlock" the "API" data for this object. This
|
|
* results in the lock count for this object being decremented. When the
|
|
* lock count transitions from 1 to 0, a check is made to determine
|
|
* whether the object has been freed through a call to
|
|
* FreeUserDataList. If so, the object will automatically delete
|
|
* itself.
|
|
*/
|
|
void CUserDataListContainer::
|
|
UnLockUserDataList(void)
|
|
{
|
|
USER_DATA *user_data_info_ptr;
|
|
|
|
if (Unlock(FALSE) == 0)
|
|
{
|
|
/*
|
|
* Unlock any memory locked for the CObjectKeyContainer objects in the
|
|
* internal USER_DATA structures.
|
|
*/
|
|
m_UserDataItemList.Reset();
|
|
while (NULL != (user_data_info_ptr = m_UserDataItemList.Iterate()))
|
|
{
|
|
/*
|
|
* Unlock any CObjectKeyContainer memory being referenced in the
|
|
* USER_DATA structure.
|
|
*/
|
|
if (user_data_info_ptr->key != NULL)
|
|
{
|
|
user_data_info_ptr->key->UnLockObjectKeyData ();
|
|
}
|
|
}
|
|
}
|
|
|
|
// we have to call Release() because we used Unlock(FALSE)
|
|
Release();
|
|
}
|
|
|
|
/*
|
|
* GetUserDataPDU ()
|
|
*
|
|
* Public Function Description:
|
|
* This routine converts the user data from it's internal form of a list
|
|
* of USER_DATA structures into the "PDU" form which can be passed in
|
|
* to the ASN.1 encoder. A pointer to a "PDU" "SetOfUserData" structure is
|
|
* returned.
|
|
*/
|
|
GCCError CUserDataListContainer::
|
|
GetUserDataPDU(PSetOfUserData *set_of_user_data)
|
|
{
|
|
GCCError rc = GCC_NO_ERROR;
|
|
PSetOfUserData new_pdu_user_data_ptr;
|
|
PSetOfUserData old_pdu_user_data_ptr = NULL;
|
|
|
|
/*
|
|
* If this is the first time that PDU data has been requested then we must
|
|
* fill in the internal PDU structure and copy it into the structure pointed
|
|
* to by the output parameter. On subsequent calls to "GetPDU" we can just
|
|
* copy the internal PDU structure into the structure pointed to by the
|
|
* output parameter.
|
|
*/
|
|
if (NULL == m_pSetOfUserDataPDU)
|
|
{
|
|
USER_DATA *lpUsrDataInfo;
|
|
|
|
/*
|
|
* Iterate through the list of USER_DATA structures, converting
|
|
* each into "PDU" form and saving the pointers in the linked list of
|
|
* "SetsOfUserData".
|
|
*/
|
|
m_UserDataItemList.Reset();
|
|
while (NULL != (lpUsrDataInfo = m_UserDataItemList.Iterate()))
|
|
{
|
|
DBG_SAVE_FILE_LINE
|
|
new_pdu_user_data_ptr = new SetOfUserData;
|
|
|
|
/*
|
|
* If an allocation failure occurs, call the routine which will
|
|
* iterate through the list freeing any data which had been
|
|
* allocated.
|
|
*/
|
|
if (new_pdu_user_data_ptr == NULL)
|
|
{
|
|
ERROR_OUT(("CUserDataListContainer::GetUserDataPDU: Allocation error, cleaning up"));
|
|
rc = GCC_ALLOCATION_FAILURE;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Ensure everything is clean.
|
|
//
|
|
::ZeroMemory(new_pdu_user_data_ptr, sizeof(SetOfUserData));
|
|
|
|
/*
|
|
* The first time through, set the PDU structure pointer equal
|
|
* to the first SetOfUserData created. On subsequent loops, set
|
|
* the structure's "next" pointer equal to the new structure.
|
|
*/
|
|
if (m_pSetOfUserDataPDU == NULL)
|
|
{
|
|
m_pSetOfUserDataPDU = new_pdu_user_data_ptr;
|
|
}
|
|
else
|
|
{
|
|
old_pdu_user_data_ptr->next = new_pdu_user_data_ptr;
|
|
}
|
|
|
|
old_pdu_user_data_ptr = new_pdu_user_data_ptr;
|
|
|
|
/*
|
|
* Initialize the new "next" pointer to NULL and convert the
|
|
* user data element.
|
|
*/
|
|
new_pdu_user_data_ptr->next = NULL;
|
|
|
|
if (ConvertUserDataInfoToPDUUserData(lpUsrDataInfo, new_pdu_user_data_ptr) != GCC_NO_ERROR)
|
|
{
|
|
ERROR_OUT(("UserData::GetUserDataPDU: can't convert USER_DATA to PDU"));
|
|
rc = GCC_ALLOCATION_FAILURE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (GCC_NO_ERROR != rc)
|
|
{
|
|
FreeUserDataListPDU();
|
|
ASSERT(NULL == m_pSetOfUserDataPDU);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Copy the internal PDU structure into the structure pointed to by the
|
|
* output parameter.
|
|
*/
|
|
*set_of_user_data = m_pSetOfUserDataPDU;
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
* FreeUserDataListPDU ()
|
|
*
|
|
* Public Function Description:
|
|
* This routine frees any data which was allocated as a result of a call
|
|
* to "GetUserDataPDU" which was called in order to build up a "PDU"
|
|
* structure holding the user data.
|
|
*/
|
|
void CUserDataListContainer::
|
|
FreeUserDataListPDU(void)
|
|
{
|
|
PSetOfUserData pdu_user_data_set;
|
|
PSetOfUserData next_pdu_user_data_set;
|
|
USER_DATA *lpUsrDataInfo;
|
|
|
|
/*
|
|
* Check to make sure "PDU" data has been allocated for this object.
|
|
*/
|
|
if (NULL != m_pSetOfUserDataPDU)
|
|
{
|
|
pdu_user_data_set = m_pSetOfUserDataPDU;
|
|
m_pSetOfUserDataPDU = NULL; // so no one can use it now.
|
|
|
|
/*
|
|
* Loop through the list, freeing the user data associated with
|
|
* each structure contained in the list.
|
|
*/
|
|
while (pdu_user_data_set != NULL)
|
|
{
|
|
next_pdu_user_data_set = pdu_user_data_set->next;
|
|
delete pdu_user_data_set;
|
|
pdu_user_data_set = next_pdu_user_data_set;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TRACE_OUT(("CUserDataListContainer::FreeUserDataListPDU: Error PDU data not allocated"));
|
|
}
|
|
|
|
/*
|
|
* Iterate through the internal list, telling each CObjectKeyContainer object
|
|
* to free any PDU data which it has allocated.
|
|
*/
|
|
m_UserDataItemList.Reset();
|
|
while (NULL != (lpUsrDataInfo = m_UserDataItemList.Iterate()))
|
|
{
|
|
if (lpUsrDataInfo->key != NULL)
|
|
{
|
|
lpUsrDataInfo->key->FreeObjectKeyDataPDU();
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* GCCError CopyUserDataList ( UINT number_of_members,
|
|
* PGCCUserData * user_data_list)
|
|
*
|
|
* Private member function of CUserDataListContainer.
|
|
*
|
|
* Function Description:
|
|
* This routine copies the user data passed in as "API" data into it's
|
|
* internal form where the Rogue Wave m_UserDataItemList holds the data
|
|
* in the form of USER_DATA structures.
|
|
*
|
|
* Formal Parameters:
|
|
* number_of_members (i) The number of elements in the user data list.
|
|
* user_datalist (i) The list holding the user data to store.
|
|
*
|
|
* Return Value:
|
|
* GCC_NO_ERROR - No error.
|
|
* GCC_ALLOCATION_FAILURE - Error creating an object using the
|
|
* "new" operator.
|
|
* GCC_BAD_USER_DATA - The user data passed in contained
|
|
* an invalid object key.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
GCCError CUserDataListContainer::
|
|
CopyUserDataList(UINT number_of_members, PGCCUserData *user_data_list)
|
|
{
|
|
GCCError rc = GCC_NO_ERROR;
|
|
USER_DATA *user_data_info_ptr;
|
|
UINT i;
|
|
LPOSTR octet_string_ptr;
|
|
|
|
/*
|
|
* Return an error if no user data is passed in.
|
|
*/
|
|
if (number_of_members == 0)
|
|
return (GCC_BAD_USER_DATA);
|
|
|
|
for (i = 0; i < number_of_members; i++)
|
|
{
|
|
/*
|
|
* Create a new "info" structure to hold the user data internally.
|
|
*/
|
|
DBG_SAVE_FILE_LINE
|
|
user_data_info_ptr = new USER_DATA;
|
|
if (user_data_info_ptr != NULL)
|
|
{
|
|
user_data_info_ptr->poszOctetString = NULL;
|
|
|
|
/*
|
|
* Create a new CObjectKeyContainer object which will be used to store
|
|
* the "key" portion of the object data internally.
|
|
*/
|
|
DBG_SAVE_FILE_LINE
|
|
user_data_info_ptr->key = new CObjectKeyContainer(&user_data_list[i]->key, &rc);
|
|
if (user_data_info_ptr->key == NULL)
|
|
{
|
|
ERROR_OUT(("UserData::CopyUserDataList: Error creating new CObjectKeyContainer"));
|
|
rc = GCC_ALLOCATION_FAILURE;
|
|
goto MyExit;
|
|
}
|
|
else if (rc != GCC_NO_ERROR)
|
|
{
|
|
ERROR_OUT(("UserData::CopyUserDataList: Error creating new CObjectKeyContainer - bad data"));
|
|
goto MyExit;
|
|
}
|
|
|
|
/*
|
|
* Store the optional user data octet string in the list.
|
|
*/
|
|
octet_string_ptr = user_data_list[i]->octet_string;
|
|
|
|
if ((octet_string_ptr != NULL) && (rc == GCC_NO_ERROR))
|
|
{
|
|
/*
|
|
* Create a new Rogue Wave string container to hold the
|
|
* octet string.
|
|
*/
|
|
if (NULL == (user_data_info_ptr->poszOctetString = ::My_strdupO2(
|
|
octet_string_ptr->value,
|
|
octet_string_ptr->length)))
|
|
{
|
|
ERROR_OUT(("UserData::CopyUserDataList: can't create octet string"));
|
|
rc = GCC_ALLOCATION_FAILURE;
|
|
goto MyExit;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ASSERT(NULL == user_data_info_ptr->poszOctetString);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERROR_OUT(("UserData::CopyUserDataList: can't create USER_DATA"));
|
|
rc = GCC_ALLOCATION_FAILURE;
|
|
goto MyExit;
|
|
}
|
|
|
|
/*
|
|
* Insert the pointer to the USER_DATA structure into the Rogue Wave list.
|
|
*/
|
|
m_UserDataItemList.Append(user_data_info_ptr);
|
|
}
|
|
|
|
MyExit:
|
|
|
|
if (GCC_NO_ERROR != rc)
|
|
{
|
|
delete user_data_info_ptr;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
* GCCError UnPackUserDataFromPDU (PSetOfUserData set_of_user_data)
|
|
*
|
|
* Private member function of CUserDataListContainer.
|
|
*
|
|
* Function Description:
|
|
* This routine unpacks the user data from the "PDU" form into the
|
|
* internal form which is maintained as a Rogue Wave list of USER_DATA
|
|
* structures.
|
|
*
|
|
* Formal Parameters:
|
|
* set_of_user_data (i) The "PDU" user data list to copy.
|
|
*
|
|
* Return Value:
|
|
* GCC_NO_ERROR - No error.
|
|
* GCC_ALLOCATION_FAILURE - Error creating an object using the
|
|
* "new" operator.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
GCCError CUserDataListContainer::
|
|
UnPackUserDataFromPDU(PSetOfUserData set_of_user_data)
|
|
{
|
|
PSetOfUserData pUserData;
|
|
GCCError rc = GCC_NO_ERROR;
|
|
|
|
for (pUserData = set_of_user_data; NULL != pUserData; pUserData = pUserData->next)
|
|
{
|
|
/*
|
|
* Convert the user data elements into the internal format which
|
|
* is a USER_DATA structure and insert the pointers to the
|
|
* USER_DATA structures into the m_UserDataItemList.
|
|
*/
|
|
if (ConvertPDUDataToInternal(pUserData) != GCC_NO_ERROR)
|
|
{
|
|
ERROR_OUT(("CUserDataListContainer::UnPackUserDataFromPDU: Error converting PDU data to internal"));
|
|
rc = GCC_ALLOCATION_FAILURE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
* GCCError ConvertPDUDataToInternal ( PSetOfUserData user_data_ptr)
|
|
*
|
|
* Private member function of CUserDataListContainer.
|
|
*
|
|
* Function Description:
|
|
* This routine converts an individual user data element from the "PDU"
|
|
* structure form into the internal form which is a USER_DATA
|
|
* structure.
|
|
*
|
|
* Formal Parameters:
|
|
* user_data_ptr (i) The "PDU" user data list to copy.
|
|
*
|
|
* Return Value:
|
|
* GCC_NO_ERROR - No error.
|
|
* GCC_ALLOCATION_FAILURE - Error creating an object using the
|
|
* "new" operator.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
GCCError CUserDataListContainer::
|
|
ConvertPDUDataToInternal(PSetOfUserData user_data_ptr)
|
|
{
|
|
USER_DATA *user_data_info_ptr;
|
|
GCCError rc = GCC_NO_ERROR;
|
|
|
|
DBG_SAVE_FILE_LINE
|
|
user_data_info_ptr = new USER_DATA;
|
|
if (user_data_info_ptr != NULL)
|
|
{
|
|
user_data_info_ptr->poszOctetString = NULL;
|
|
|
|
/*
|
|
* Create a new CObjectKeyContainer object which will be used to store the
|
|
* "key" portion of the user data internally. If an error occurs
|
|
* constructing the key report it. Otherwise, check for any user data
|
|
* which may need to be stored. Note that any error in creating the
|
|
* CObjectKeyContainer object is reported as an allocation failure. An error
|
|
* could occur if a bad object key was received as PDU data but this
|
|
* would have originated from some other provider since we validate all
|
|
* object keys created locally. We therefore report it as an allocation
|
|
* failure.
|
|
*/
|
|
DBG_SAVE_FILE_LINE
|
|
user_data_info_ptr->key = new CObjectKeyContainer(&user_data_ptr->user_data_element.key, &rc);
|
|
if ((user_data_info_ptr->key == NULL) || (rc != GCC_NO_ERROR))
|
|
{
|
|
ERROR_OUT(("UserData::ConvertPDUDataToInternal: Error creating new CObjectKeyContainer"));
|
|
rc = GCC_ALLOCATION_FAILURE;
|
|
goto MyExit;
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* The object key was successfully saved so store any actual user
|
|
* data in the list if it is present.
|
|
*/
|
|
if (user_data_ptr->user_data_element.bit_mask & USER_DATA_FIELD_PRESENT)
|
|
{
|
|
if (NULL == (user_data_info_ptr->poszOctetString = ::My_strdupO2(
|
|
user_data_ptr->user_data_element.user_data_field.value,
|
|
user_data_ptr->user_data_element.user_data_field.length)))
|
|
{
|
|
ERROR_OUT(("UserData::ConvertPDUDataToInternal: can't create octet string"));
|
|
rc = GCC_ALLOCATION_FAILURE;
|
|
goto MyExit;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ASSERT(NULL == user_data_info_ptr->poszOctetString);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Initialize the structure pointers to NULL and insert the pointer
|
|
* to the USER_DATA structure into the Rogue Wave list.
|
|
*/
|
|
m_UserDataItemList.Append(user_data_info_ptr);
|
|
}
|
|
else
|
|
{
|
|
ERROR_OUT(("UserData::ConvertPDUDataToInternal: can't create USER_DATA"));
|
|
rc = GCC_ALLOCATION_FAILURE;
|
|
// goto MyExit;
|
|
}
|
|
|
|
MyExit:
|
|
|
|
if (GCC_NO_ERROR != rc)
|
|
{
|
|
delete user_data_info_ptr;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
* GCCError ConvertUserDataInfoToPDUUserData (
|
|
* USER_DATA *user_data_info_ptr,
|
|
* PSetOfUserData pdu_user_data_ptr)
|
|
*
|
|
* Private member function of CUserDataListContainer.
|
|
*
|
|
* Function Description:
|
|
* This routine converts the user data from the internal form which is a
|
|
* USER_DATA structure into the "PDU" structure form "SetOfUserData".
|
|
*
|
|
* Formal Parameters:
|
|
* user_data_info_ptr (i) The internal user data structure to convert.
|
|
* pdu_user_data_ptr (o) The structure to hold the PDU data after
|
|
* conversion.
|
|
*
|
|
* Return Value:
|
|
* GCC_NO_ERROR - No error.
|
|
* GCC_ALLOCATION_FAILURE - Error creating an object using the
|
|
* "new" operator.
|
|
* GCC_INVALID_PARAMETER - The internal key pointer was
|
|
* corrupted.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
GCCError CUserDataListContainer::
|
|
ConvertUserDataInfoToPDUUserData(USER_DATA *user_data_info_ptr, PSetOfUserData pdu_user_data_ptr)
|
|
{
|
|
GCCError rc = GCC_NO_ERROR;
|
|
|
|
/*
|
|
* Initialize the user data bit mask to zero.
|
|
*/
|
|
pdu_user_data_ptr->user_data_element.bit_mask = 0;
|
|
|
|
/*
|
|
* Fill in the octet string pointer and length if the octet string
|
|
* exists. Set the bit mask indicating that the string exists.
|
|
*/
|
|
if (user_data_info_ptr->poszOctetString != NULL)
|
|
{
|
|
pdu_user_data_ptr->user_data_element.user_data_field.value =
|
|
user_data_info_ptr->poszOctetString->value;
|
|
pdu_user_data_ptr->user_data_element.user_data_field.length =
|
|
user_data_info_ptr->poszOctetString->length;
|
|
|
|
pdu_user_data_ptr->user_data_element.bit_mask |= USER_DATA_FIELD_PRESENT;
|
|
}
|
|
|
|
/*
|
|
* Fill in the object key data.
|
|
*/
|
|
if (user_data_info_ptr->key != NULL)
|
|
{
|
|
/*
|
|
* Retrieve the "PDU" object key data from the internal CObjectKeyContainer
|
|
* object.
|
|
*/
|
|
if (user_data_info_ptr->key->GetObjectKeyDataPDU (
|
|
&pdu_user_data_ptr->user_data_element.key) != GCC_NO_ERROR)
|
|
{
|
|
rc = GCC_ALLOCATION_FAILURE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERROR_OUT(("UserData::ConvertUserDataInfoToPDUUserData: no valid UserDataInfo key"));
|
|
rc = GCC_INVALID_PARAMETER;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|