region_t*
TMregion_alloc (TM_ARGDECL_ALONE)
{
region_t* regionPtr;
regionPtr = (region_t*)TM_MALLOC(sizeof(region_t));
if (regionPtr) {
regionPtr->expandQueuePtr = TMQUEUE_ALLOC(-1);
assert(regionPtr->expandQueuePtr);
regionPtr->beforeListPtr = TMLIST_ALLOC(®ion_elementlistcompare);
assert(regionPtr->beforeListPtr);
regionPtr->borderListPtr = TMLIST_ALLOC(®ion_listcompareedge);
assert(regionPtr->borderListPtr);
regionPtr->badVectorPtr = PVECTOR_ALLOC(1);
assert(regionPtr->badVectorPtr);
}
return regionPtr;
}
/* =============================================================================
* customer_alloc
* =============================================================================
*/
__attribute__((transaction_safe)) customer_t*
customer_alloc (long id)
{
customer_t* customerPtr;
customerPtr = (customer_t*)malloc(sizeof(customer_t));
customerPtr->id = id;
customerPtr->reservationInfoListPtr = TMLIST_ALLOC(&compareReservationInfo);
return customerPtr;
}
/* =============================================================================
* customer_alloc
* =============================================================================
*/
customer_t*
customer_alloc (TM_ARGDECL long id)
{
customer_t* customerPtr;
customerPtr = (customer_t*)TM_MALLOC(sizeof(customer_t));
assert(customerPtr != NULL);
customerPtr->id = id;
customerPtr->reservationInfoListPtr = TMLIST_ALLOC(&customer_comparereservationinfo);
assert(customerPtr->reservationInfoListPtr != NULL);
return customerPtr;
}
/* =============================================================================
* TMelement_alloc
*
* Contains a copy of input arg 'coordinates'
* =============================================================================
*/
element_t*
TMelement_alloc (TM_ARGDECL coordinate_t* coordinates, long numCoordinate)
{
element_t* elementPtr = NULL;
elementPtr = (element_t*)TM_MALLOC(sizeof(element_t));
if (elementPtr) {
long i;
for (i = 0; i < numCoordinate; i++) {
elementPtr->coordinates[i] = coordinates[i];
}
elementPtr->numCoordinate = numCoordinate;
minimizeCoordinates(elementPtr);
checkAngles(elementPtr);
calculateCircumCircle(elementPtr);
initEdges(elementPtr, coordinates, numCoordinate);
elementPtr->neighborListPtr = TMLIST_ALLOC(&element_listcompare);
assert(elementPtr->neighborListPtr);
elementPtr->isGarbage = false;
elementPtr->isReferenced = false;
}
return elementPtr;
}
/* =============================================================================
* TMdecoder_process
* =============================================================================
*/
int_error_t
TMdecoder_process (TM_ARGDECL decoder_t* decoderPtr, char* bytes, long numByte)
{
bool_t status;
/*
* Basic error checking
*/
if (numByte < (long)PACKET_HEADER_LENGTH) {
return ERROR_SHORT;
}
packet_t* packetPtr = (packet_t*)bytes;
long flowId = packetPtr->flowId;
long fragmentId = packetPtr->fragmentId;
long numFragment = packetPtr->numFragment;
long length = packetPtr->length;
if (flowId < 0) {
return ERROR_FLOWID;
}
if ((fragmentId < 0) || (fragmentId >= numFragment)) {
return ERROR_FRAGMENTID;
}
if (length < 0) {
return ERROR_LENGTH;
}
#if 0
/*
* With the above checks, this one is redundant
*/
if (numFragment < 1) {
return ERROR_NUMFRAGMENT;
}
#endif
/*
* Add to fragmented map for reassembling
*/
if (numFragment > 1) {
MAP_T* fragmentedMapPtr = decoderPtr->fragmentedMapPtr;
list_t* fragmentListPtr =
(list_t*)TMMAP_FIND(fragmentedMapPtr, (void*)flowId);
if (fragmentListPtr == NULL) {
fragmentListPtr = TMLIST_ALLOC(&decoder_comparator);
assert(fragmentListPtr);
status = TMLIST_INSERT(fragmentListPtr, (void*)packetPtr);
assert(status);
status = TMMAP_INSERT(fragmentedMapPtr,
(void*)flowId,
(void*)fragmentListPtr);
assert(status);
} else {
list_iter_t it;
TMLIST_ITER_RESET(&it, fragmentListPtr);
assert(TMLIST_ITER_HASNEXT(&it, fragmentListPtr));
packet_t* firstFragmentPtr =
(packet_t*)TMLIST_ITER_NEXT(&it, fragmentListPtr);
long expectedNumFragment = firstFragmentPtr->numFragment;
if (numFragment != expectedNumFragment) {
status = TMMAP_REMOVE(fragmentedMapPtr, (void*)flowId);
assert(status);
return ERROR_NUMFRAGMENT;
}
status = TMLIST_INSERT(fragmentListPtr, (void*)packetPtr);
assert(status);
/*
* If we have all the fragments we can reassemble them
*/
if (TMLIST_GETSIZE(fragmentListPtr) == numFragment) {
long numByte = 0;
long i = 0;
TMLIST_ITER_RESET(&it, fragmentListPtr);
while (TMLIST_ITER_HASNEXT(&it, fragmentListPtr)) {
packet_t* fragmentPtr =
(packet_t*)TMLIST_ITER_NEXT(&it, fragmentListPtr);
if(fragmentPtr->flowId != flowId)
printf("fragflow %lx floId %lx\n", fragmentPtr->flowId, flowId);
assert(fragmentPtr->flowId == flowId);
if (fragmentPtr->fragmentId != i) {
status = TMMAP_REMOVE(fragmentedMapPtr, (void*)flowId);
assert(status);
return ERROR_INCOMPLETE; /* should be sequential */
}
numByte += fragmentPtr->length;
i++;
}
char* data = (char*)TM_MALLOC(numByte + 1);
assert(data);
data[numByte] = '\0';
char* dst = data;
TMLIST_ITER_RESET(&it, fragmentListPtr);
while (TMLIST_ITER_HASNEXT(&it, fragmentListPtr)) {
packet_t* fragmentPtr =
(packet_t*)TMLIST_ITER_NEXT(&it, fragmentListPtr);
memcpy(dst, (void*)fragmentPtr->data, fragmentPtr->length);
dst += fragmentPtr->length;
}
assert(dst == data + numByte);
decoded_t* decodedPtr = (decoded_t*)TM_MALLOC(sizeof(decoded_t));
assert(decodedPtr);
decodedPtr->flowId = flowId;
decodedPtr->data = data;
queue_t* decodedQueuePtr = decoderPtr->decodedQueuePtr;
status = TMQUEUE_PUSH(decodedQueuePtr, (void*)decodedPtr);
assert(status);
TMLIST_FREE(fragmentListPtr);
status = TMMAP_REMOVE(fragmentedMapPtr, (void*)flowId);
assert(status);
}
}
} else {
/*
* This is the only fragment, so it is ready
*/
if (fragmentId != 0) {
return ERROR_FRAGMENTID;
}
char* data = (char*)TM_MALLOC(length + 1);
assert(data);
data[length] = '\0';
memcpy(data, (void*)packetPtr->data, length);
decoded_t* decodedPtr = (decoded_t*)TM_MALLOC(sizeof(decoded_t));
assert(decodedPtr);
decodedPtr->flowId = flowId;
decodedPtr->data = data;
queue_t* decodedQueuePtr = decoderPtr->decodedQueuePtr;
status = TMQUEUE_PUSH(decodedQueuePtr, (void*)decodedPtr);
assert(status);
}
return ERROR_NONE;
}
