/* =============================================================================
* checkTables
* -- some simple checks (not comprehensive)
* -- dependent on tasks generated for clients in initializeClients()
* =============================================================================
*/
void
checkTables (manager_t* managerPtr)
{
long i;
long numRelation = (long)global_params[PARAM_RELATIONS];
MAP_T* customerTablePtr = managerPtr->customerTablePtr;
MAP_T* tables[] = {
managerPtr->carTablePtr,
managerPtr->flightTablePtr,
managerPtr->roomTablePtr,
};
long numTable = sizeof(tables) / sizeof(tables[0]);
bool_t (*manager_add[])(manager_t*, long, long, long) = {
&manager_addCar_seq,
&manager_addFlight_seq,
&manager_addRoom_seq
};
long t;
printf("Checking tables... ");
fflush(stdout);
/* Check for unique customer IDs */
long percentQuery = (long)global_params[PARAM_QUERIES];
long queryRange = (long)((double)percentQuery / 100.0 * (double)numRelation + 0.5);
long maxCustomerId = queryRange + 1;
for (i = 1; i <= maxCustomerId; i++) {
if (MAP_FIND(customerTablePtr, i)) {
if (MAP_REMOVE(customerTablePtr, i)) {
assert(!MAP_FIND(customerTablePtr, i));
}
}
}
/* Check reservation tables for consistency and unique ids */
for (t = 0; t < numTable; t++) {
MAP_T* tablePtr = tables[t];
for (i = 1; i <= numRelation; i++) {
if (MAP_FIND(tablePtr, i)) {
assert(manager_add[t](managerPtr, i, 0, 0)); /* validate entry */
if (MAP_REMOVE(tablePtr, i)) {
assert(!MAP_REMOVE(tablePtr, i));
}
}
}
}
puts("done.");
fflush(stdout);
}
static bool
addReservation_seq (MAP_T* tablePtr, long id, long num, long price)
{
reservation_t* reservationPtr;
bool status;
reservationPtr = (reservation_t*)MAP_FIND(tablePtr, id);
if (reservationPtr == NULL) {
/* Create new reservation */
if (num < 1 || price < 0) {
return false;
}
reservationPtr = reservation_alloc_seq(id, num, price);
assert(reservationPtr != NULL);
status = MAP_INSERT(tablePtr, id, reservationPtr);
assert(status);
} else {
/* Update existing reservation */
if (!reservation_addToTotal_seq(reservationPtr, num)) {
return false;
}
if (reservationPtr->numTotal == 0) {
status = MAP_REMOVE(tablePtr, id);
assert(status);
} else {
reservation_updatePrice_seq(reservationPtr, price);
}
}
return true;
}
/* =============================================================================
* decoder_process
* =============================================================================
*/
int_error_t
decoder_process (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*)MAP_FIND(fragmentedMapPtr, (void*)flowId);
if (fragmentListPtr == NULL) {
fragmentListPtr = list_alloc(&decoder_comparator);
assert(fragmentListPtr);
status = list_insert(fragmentListPtr, (void*)packetPtr);
assert(status);
status = MAP_INSERT(fragmentedMapPtr,
(void*)flowId,
(void*)fragmentListPtr);
assert(status);
} else {
list_iter_t it;
list_iter_reset(&it, fragmentListPtr);
assert(list_iter_hasNext(&it, fragmentListPtr));
packet_t* firstFragmentPtr =
(packet_t*)list_iter_next(&it, fragmentListPtr);
long expectedNumFragment = firstFragmentPtr->numFragment;
if (numFragment != expectedNumFragment) {
status = MAP_REMOVE(fragmentedMapPtr, (void*)flowId);
assert(status);
return ERROR_NUMFRAGMENT;
}
status = list_insert(fragmentListPtr, (void*)packetPtr);
assert(status);
/*
* If we have all the fragments we can reassemble them
*/
if (list_getSize(fragmentListPtr) == numFragment) {
long numByte = 0;
long i = 0;
list_iter_reset(&it, fragmentListPtr);
while (list_iter_hasNext(&it, fragmentListPtr)) {
packet_t* fragmentPtr =
(packet_t*)list_iter_next(&it, fragmentListPtr);
assert(fragmentPtr->flowId == flowId);
if (fragmentPtr->fragmentId != i) {
status = MAP_REMOVE(fragmentedMapPtr, (void*)flowId);
assert(status);
return ERROR_INCOMPLETE; /* should be sequential */
}
numByte += fragmentPtr->length;
i++;
}
char* data = (char*)SEQ_MALLOC(numByte + 1);
assert(data);
data[numByte] = '\0';
char* dst = data;
list_iter_reset(&it, fragmentListPtr);
while (list_iter_hasNext(&it, fragmentListPtr)) {
packet_t* fragmentPtr =
(packet_t*)list_iter_next(&it, fragmentListPtr);
memcpy(dst, (void*)fragmentPtr->data, fragmentPtr->length);
dst += fragmentPtr->length;
}
assert(dst == data + numByte);
decoded_t* decodedPtr = (decoded_t*)SEQ_MALLOC(sizeof(decoded_t));
assert(decodedPtr);
decodedPtr->flowId = flowId;
decodedPtr->data = data;
queue_t* decodedQueuePtr = decoderPtr->decodedQueuePtr;
status = queue_push(decodedQueuePtr, (void*)decodedPtr);
assert(status);
list_free(fragmentListPtr);
status = MAP_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*)SEQ_MALLOC(length + 1);
assert(data);
data[length] = '\0';
memcpy(data, (void*)packetPtr->data, length);
decoded_t* decodedPtr = (decoded_t*)SEQ_MALLOC(sizeof(decoded_t));
assert(decodedPtr);
decodedPtr->flowId = flowId;
decodedPtr->data = data;
queue_t* decodedQueuePtr = decoderPtr->decodedQueuePtr;
status = queue_push(decodedQueuePtr, (void*)decodedPtr);
assert(status);
}
return ERROR_NONE;
}
