boum

void* fctThread (void *param)
{
    string containers[10];
    struct inputTruckRequestParameters inputTruckStruct;
    struct inputDoneRequestParameters inputDoneStruct;
    struct outputReadyRequestParameters outputReadyStruct;
    struct outputOneRequestParameters outputOneStruct;
    ostringstream oss;
    int socketSlot;
    int receivedRequest, i, numberOfContainers;
    bool quit = false;
    Socket *serviceSocketToManage;
    CMMPServer *cmmpServer;

    while (true) {
        LOCK(&mutexThread);
        while(actualClient == -1)
            COND_WAIT(&clientCond, &mutexThread);

        //The thread is now supposed to manage a client (listen to CMMP requests)
        serviceSocketToManage = clientSockets[actualClient];
        socketSlot = actualClient; //We keep the socketSlot index to release it later
        actualClient = -1;
        UNLOCK(&mutexThread);

        //Now listen to CMMP requests
        cmmpServer= new CMMPServer(serviceSocketToManage);

        while (!quit)
        {
            try {
                cmmpServer->listenRequest();
                receivedRequest = cmmpServer->getReceivedRequest();

                if (receivedRequest == LOGIN && !cmmpServer->isClientLogged())
                {
                    //replace that by a check in a CSV file
                    if (strcmp(cmmpServer->getLoginStruct().login, "quentin") == 0 && strcmp(cmmpServer->getLoginStruct().password, "wiipower") == 0){
                        cmmpServer->acceptRequest();
                        cmmpServer->setClientLogged(true);
                    }
                    else
                    {
                        cmmpServer->denyRequest("Bad credentials");
                        cmmpServer->setClientLogged(false);
                    }
                }
                else if(cmmpServer->isClientLogged())
                {
                    switch (receivedRequest)
                    {
                        case INPUTTRUCK :
                            inputTruckStruct = cmmpServer->getInputTruckStruct();
                            //Decide if respond to inputTruck or no (will be replaced with an exchange with SERveur traffic)
                            if (cmmpServer->freePlace(inputTruckStruct.numberOfContainers, inputTruckStruct.containerID, fileName))
                            {
                                //We need to send all containers and positions to the client
                                struct inputTruckContainer *containers = NULL;
                                struct positionStruct position;
                                containers = (struct inputTruckContainer*)malloc(inputTruckStruct.numberOfContainers * sizeof(struct inputTruckContainer));
                                if (containers == NULL) {
                                    //Error during malloc
                                    //Will close the client
                                    quit = true;
                                    break;
                                }

                                //GetPosition of container also modify the record (put on DESTINATED if necessary)
                                for (i=0; i<inputTruckStruct.numberOfContainers; i++) {
                                    position = cmmpServer->getPostionOfContainer(inputTruckStruct.containerID[i], fileName);
                                    containers[i].x = position.x;
                                    containers[i].y = position.y;
                                    strcpy(containers[i].containerID, inputTruckStruct.containerID[i]);
                                }
                                cmmpServer->replyToInputTruck(inputTruckStruct.numberOfContainers, containers);
                                cout<<"FICH-PARC after input truck request : "<<endl;
                                displayFICHPARC(fileName);

                                cmmpServer->listenRequest(); //Supposed to be INPUT-DONE...
                                inputDoneStruct = cmmpServer->getInputDoneStruct();
                                if (inputDoneStruct.answer == OK) {

                                    //If the weight is not too big, we can write "BUSY" flag into FICH-PARC
                                    if (inputDoneStruct.weight <= 100000) { //?? I don't know about that
                                        //Request accepted
                                        for (i=0; i<inputTruckStruct.numberOfContainers; i++) {
                                            cmmpServer->writeBusyFlag(containers[i].containerID, fileName);
                                        }
                                        cmmpServer->acceptRequest();

                                        cout<<"FICH-PARC after INPUT-DONE request : "<<endl;
                                        displayFICHPARC(fileName);
                                    }
                                    else
                                    {
                                        cmmpServer->denyRequest("Too heavy");
                                    }
                                }
                                else
                                {
                                    //The client sent KO in INPUT-DONE request
                                    free(containers);
                                    containers = NULL;
                                    cmmpServer->acceptRequest();
                                    quit = true;
                                }
                            }
                            else
                            {
                                cmmpServer->denyRequest("Not enough place for all those containers");
                            }
                            break;


                        case OUTPUTREADY:
                            outputReadyStruct = cmmpServer->getOutputReadyStruct();
                            numberOfContainers = cmmpServer->getContainersForDestination(containers, outputReadyStruct.destination, outputReadyStruct.capacity, fileName);

                            //Send back containers list
                            if (numberOfContainers == 0) {
                                cmmpServer->denyRequest("There's no container awaiting for that destination");
                            }
                            else
                            {
                                cmmpServer->replyToOutputReady(numberOfContainers, containers);
                                for (i=0; i<numberOfContainers; i++) {
                                    cout<<"Waiting for outputone : "<<i<<endl;
                                    cmmpServer->listenRequest(); //Listen to outputones
                                    cout<<"outputone received"<<endl;
                                    //Update fichParc
                                    outputOneStruct = cmmpServer->getOutputOneStruct();
                                    setFreeFlag(outputOneStruct.containerID, fileName);
                                }
                                cout<<"Waiting for output-done request"<<endl;
                                cmmpServer->listenRequest();
                                if (cmmpServer->getReceivedRequest() == INPUTDONE) {
                                    cmmpServer->acceptRequest();
                                }
                                cout<<"FICH-PARC after output-done : "<<endl;
                                displayFICHPARC(fileName);
                            }

                            break;

                        case LOGOUT:
                            quit = true;
                            break;
                        default:
                            break;
                    }
                }
            }
            catch (SocketException exp)
            {
                //Client failed, we should close the socket. And rollback operations ?
                std::cout<<exp.getExplanation()<<exp.getCode()<<std::endl;

                //Freeing socketSlot
                LOCK(&mutexThread);
                clientSockets[socketSlot] = NULL;
                UNLOCK(&mutexThread);

                delete cmmpServer;
                delete serviceSocketToManage;
                return NULL;

            }
        }

        //Freeing socketSlot
        LOCK(&mutexThread);
        clientSockets[socketSlot] = NULL;
        UNLOCK(&mutexThread);

        delete cmmpServer;
        delete serviceSocketToManage;
    }

    return NULL;
}