void command_handler	(	int *	tag,
		char *	address,
		int *	size
	)

Definition at line 829 of file feeserver.c.

References calculateChecksum(), checkCommand(), createBenchmark(), createLogMessage(), dis_update_service, fee_exit_handler(), findMemoryNode(), Memory::free(), freeMemoryNode(), getDeadband(), getIssueTimeout(), getLogLevel(), getUpdateRate(), initIssueStruct(), leaveCommandHandler(), Memory::malloc(), marshallHeader(), restartFeeServer(), setDeadband(), setIssueTimeout(), setLogLevel(), setUpdateRate(), sprintf(), threadIssue(), unlockIssueMutex(), and updateFeeServer().

Referenced by start().

                                                         {
        struct timeval now;
        struct timespec timeout;
        int retcode  = -1;
        int status = -1;
        pthread_t thread_handle;
        pthread_attr_t attr;
        IssueStruct issueParam;
        CommandHeader header;
        char* pHeaderStream = 0;
        MemoryNode* memNode = 0;
        bool useMM = false;

#ifdef __BENCHMARK
        char benchmsg[200];
        // make benchmark entry
        if ((size != 0 ) && (*size >= 4)) {
                benchmsg[sprintf(benchmsg,
                                "FeeServer CommandHandler (Received command) - Packet-ID: %d",
                                *address)] = 0;
                createBenchmark(benchmsg);
        } else {
                createBenchmark("FeeServer CommandHandler (Received command)");
        }
#endif

        // init struct
        initIssueStruct(&issueParam);

        issueParam.nRet = FEE_UNKNOWN_RETVAL;

        // check state (ERROR state is allowed for FeeServer commands, not CE)
        if ((state != RUNNING) && (state != ERROR_STATE)) {
                return;
        }

        // lock command mutex to save command &ACK data until it is send
        // and only one CE-Thread exists at one time
        status = pthread_mutex_lock(&command_mut);
        if (status != 0) {
#               ifdef __DEBUG
                printf("Lock command mutex error: %d\n", status);
                fflush(stdout);
#               endif
                createLogMessage(MSG_WARNING, "Unable to lock command mutex.", 0);
        }

        if ((tag == 0) || (address == 0) || (size == 0)) {
                leaveCommandHandler(0, FEE_NULLPOINTER, MSG_WARNING,
                                "Received null pointer of DIM framework in command handler.");
                return;
        }

        if (*size < HEADER_SIZE) {
                leaveCommandHandler(0, FEE_INVALID_PARAM, MSG_WARNING,
                                "FeeServer received corrupted command.");
                return;
        }

#       ifdef __DEBUG
        printf(" Cmnd - Size: %d\n", *size);
        fflush(stdout);
#       endif

        //-- storing the header information in struct --
        memcpy(&header.id, address, HEADER_SIZE_ID);
        memcpy(&header.errorCode, address + HEADER_OFFSET_ID, HEADER_SIZE_ERROR_CODE);
        memcpy(&header.flags, address + HEADER_OFFSET_ERROR_CODE, HEADER_SIZE_FLAGS);
        memcpy(&header.checksum, address + HEADER_OFFSET_FLAGS, HEADER_SIZE_CHECKSUM);

        // --------------------- Check Flags --------------------------
        if ((header.flags & HUFFMAN_FLAG) != 0) {
                //-- do Huffmann decoding if flag is set --
                // not implemented yet !!!
        }

        issueParam.size = *size - HEADER_SIZE;
        issueParam.command = (address + HEADER_SIZE);
        // !!! if Huffman decoding necessary, think about memory management ???

        if ((header.flags & CHECKSUM_FLAG) != 0) {
                //-- do checksum test if flag is set --
                if (!checkCommand(issueParam.command, issueParam.size, header.checksum)) {
                        // -- checksum failed - notification
                        leaveCommandHandler(header.id, FEE_CHECKSUM_FAILED, MSG_WARNING,
                                        "FeeServer received corrupted command data (checksum failed).");
                        return;
                }
        }

        // -- here start the Commands for the FeeServer itself --
        if ((header.flags & FEESERVER_UPDATE_FLAG) != 0) {
#ifdef ENABLE_MASTERMODE
                updateFeeServer(&issueParam);
#else
                createLogMessage(MSG_WARNING, "FeeServer is not authorized to execute shell programs, skip ...", 0);
#endif //ENABLE_MASTERMODE
                // this is only reached, if update has not been sucessful
                issueParam.nRet = FEE_FAILED;
                issueParam.size = 0;
        } else if ((header.flags & FEESERVER_RESTART_FLAG) != 0) {
                restartFeeServer();
        } else if ((header.flags & FEESERVER_REBOOT_FLAG) != 0) {
                createLogMessage(MSG_INFO, "Rebooting DCS board.", 0);
                system("reboot");
                exit(0);
        } else if ((header.flags & FEESERVER_SHUTDOWN_FLAG) != 0) {
                createLogMessage(MSG_INFO, "Shuting down DCS board.", 0);
                system("poweroff");
                exit(0);
        } else if ((header.flags & FEESERVER_EXIT_FLAG) != 0) {
                fee_exit_handler(0);
        } else if ((header.flags & FEESERVER_SET_DEADBAND_FLAG) != 0) {
                issueParam.nRet = setDeadband(&issueParam);
        } else if ((header.flags & FEESERVER_GET_DEADBAND_FLAG) != 0) {
                issueParam.nRet = getDeadband(&issueParam);
        } else if ((header.flags & FEESERVER_SET_ISSUE_TIMEOUT_FLAG) != 0) {
                issueParam.nRet = setIssueTimeout(&issueParam);
        } else if ((header.flags & FEESERVER_GET_ISSUE_TIMEOUT_FLAG) != 0) {
                issueParam.nRet = getIssueTimeout(&issueParam);
        } else if ((header.flags & FEESERVER_SET_UPDATERATE_FLAG) != 0) {
                issueParam.nRet = setUpdateRate(&issueParam);
        } else if ((header.flags & FEESERVER_GET_UPDATERATE_FLAG) != 0) {
                issueParam.nRet = getUpdateRate(&issueParam);
        } else if ((header.flags & FEESERVER_SET_LOGLEVEL_FLAG) != 0) {
                issueParam.nRet = setLogLevel(&issueParam);
        } else if ((header.flags & FEESERVER_GET_LOGLEVEL_FLAG) != 0) {
                issueParam.nRet = getLogLevel(&issueParam);
        } else {
                // commands for CE are not allowed in ERROR state
                if (state == ERROR_STATE) {
                        leaveCommandHandler(header.id, FEE_WRONG_STATE, MSG_ERROR,
                                        "FeeServer is in ERROR_STATE, ignoring command for CE!");
                        return;
                }

                // packet with no flags in header and no payload makes no sense
                if (issueParam.size == 0) {
                        leaveCommandHandler(header.id, FEE_INVALID_PARAM, MSG_WARNING,
                                        "FeeServer received empty command.");
                        return;
                }

                // lock mutex
                status = pthread_mutex_lock(&wait_mut);
                if (status != 0) {
                        leaveCommandHandler(header.id, FEE_THREAD_ERROR, MSG_ERROR,
                                        "Unable to lock condition mutex for watchdog.");
                        return;
                }

                status = pthread_attr_init(&attr);
                if (status != 0) {
                        unlockIssueMutex();
                        leaveCommandHandler(header.id, FEE_THREAD_ERROR, MSG_ERROR,
                                        "Unable to initialize issue thread.");
                        return;
                }

                status = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
                if (status != 0) {
                        unlockIssueMutex();
                        leaveCommandHandler(header.id, FEE_THREAD_ERROR, MSG_ERROR,
                                        "Unable to initialize issue thread.");
                        return;
                }

                status = pthread_create(&thread_handle, &attr, &threadIssue, (void*) &issueParam);
                if (status != 0) {
                        unlockIssueMutex();
                        leaveCommandHandler(header.id, FEE_THREAD_ERROR, MSG_ERROR,
                                        "Unable to create issue thread.");
                        return;
                }

                status = pthread_attr_destroy(&attr);
                if (status != 0) {
#                       ifdef __DEBUG
                        printf("Destroy attribute error: %d\n", status);
                        fflush(stdout);
#                       endif
                        createLogMessage(MSG_WARNING,
                                        "Unable to destroy thread attribute.", 0);
                }

                // timeout set in ms, see fee_defines.h for current value
                status = gettimeofday(&now, 0);
                if (status == 0) {
                        // issueTimeout is in milliseconds:
                        // get second-part with dividing by 1000
                        timeout.tv_sec = now.tv_sec + (int) (issueTimeout / 1000);
                        // get rest of division by 1000 (which is milliseconds)
                        // and make it nanoseconds
                        timeout.tv_nsec = (now.tv_usec * 1000) +
                                                                                ((issueTimeout % 1000) * 1000000);

                        // wait for finishing "issue" or timeout, if signal has been sent
                        // retcode is 0 !
                        // this is the main logic of the watchdog for the CE of the FeeServer
                        retcode = pthread_cond_timedwait(&cond, &wait_mut, &timeout);
#                       ifdef __DEBUG
                        printf("Retcode of CMND timedwait: %d\n", retcode);
                        fflush(stdout);
#                       endif

                        // check retcode to detect and handle Timeout
                        if (retcode == ETIMEDOUT) {
#                               ifdef __DEBUG
                                printf("ControlEngine watchdog detected TimeOut.\n");
                                fflush(stdout);
#                               endif
                                createLogMessage(MSG_WARNING,
                                                "ControlEngine watch dog noticed a time out for last command.", 0);

                                // kill not finished thread. no problem if this returns an error
                                pthread_cancel(thread_handle);
                                // setting errorCode to "a timout occured"
                                issueParam.nRet = FEE_TIMEOUT;
                                issueParam.size = 0;
                        } else if (retcode != 0) {
                                // "handling" of other error than timeout
#                               ifdef __DEBUG
                                printf("ControlEngine watchdog detected unknown error.\n");
                                fflush(stdout);
#                               endif
                                createLogMessage(MSG_WARNING,
                                                "ControlEngine watch dog received an unknown for last command.", 0);

                                // kill not finished thread. no problem if this returns an error
                                pthread_cancel(thread_handle);
                                // setting errorCode to "a thread error occured"
                                issueParam.nRet = FEE_THREAD_ERROR;
                                issueParam.size = 0;
                        }

                } else {
#                       ifdef __DEBUG
                        printf("Get time of day error: %d\n", status);
                        fflush(stdout);
#                       endif
                        createLogMessage(MSG_WARNING,
                                "Watchdog timer could not be initialized. Using non-reliable sleep instead.",
                                0);
                        // release mutex to avoid hang up in issueThread before signaling condition
                        unlockIssueMutex();
                        // watchdog with condition signal could not be used, because gettimeofday failed.
                        // sleeping instead for usual amount of time and trying to cancel thread aftterwards.
                        usleep(issueTimeout * 1000);
                        status = pthread_cancel(thread_handle);
                        // if thread did still exist something went wrong -> "timeout" (== 0)
                        if (status == 0) {
#                               ifdef __DEBUG
                                printf("TimeOut occured.\n");
#                               endif
                                createLogMessage(MSG_WARNING,
                                                "ControlEngine issue did not return in time.", 0);
                                issueParam.nRet = FEE_TIMEOUT;
                                issueParam.size = 0;
                        }
                }

                unlockIssueMutex();
        }
        //--- end of CE call area --------------------

        // ---------- start to compose result -----------------
#       ifdef __DEBUG
        printf("Issue-nRet: %d\n", issueParam.nRet);
        fflush(stdout);
#       endif
        // check return value of issue
        if ((issueParam.nRet < FEE_UNKNOWN_RETVAL) ||
                        (issueParam.nRet > FEE_MAX_RETVAL)) {
                issueParam.nRet = FEE_UNKNOWN_RETVAL;
                createLogMessage(MSG_DEBUG,
                                "ControlEngine [command] returned unkown RetVal.", 0);
        }

// start here with new memory management check for ACK
        // check if old ACK data is in MemoryNode list and free it
        if ((cmndACKSize > HEADER_SIZE) && (findMemoryNode(cmndACK + HEADER_SIZE) != 0)) {
                memNode = findMemoryNode(cmndACK + HEADER_SIZE);
                freeMemoryNode(memNode);
        } else { // free cmndACK in original way
                if (cmndACK != 0) {
                        free(cmndACK);
                        cmndACK = 0;
                }
        }

        // check if new result data is in MemoryNode list
        memNode = findMemoryNode(issueParam.result);
        if (memNode != 0) {
                cmndACK = memNode->ptr;
                useMM = true;
        } else {
                // create Acknowledge as return value of command
                // HEADER_SIZE bytes are added before result to insert the command
                // header before the result -> see CommandHeader in Client for details
                cmndACK = (char*) malloc(issueParam.size + HEADER_SIZE);
        }

        if (cmndACK == 0) {
                //no memory available!
#               ifdef __DEBUG
                printf("no memory available!\n");
                fflush(stdout);
#               endif
                createLogMessage(MSG_ERROR, "Insufficient memory for ACK.", 0);

                // no ACK because no memory!
                cmndACKSize = 0;
                status = pthread_mutex_unlock(&command_mut);
                if (status != 0) {
#                       ifdef __DEBUG
                        printf("Lock command mutex error: %d\n", status);
                        fflush(stdout);
#                       endif
                        createLogMessage(MSG_WARNING,
                                        "Error while trying to unlock command mutex.", 0);
                }
                return;
        }

#       ifdef __DEBUG
        if (issueParam.size > 0) {
//              printf("in cmnd-Handler -> issue result: ");
//              printData(issueParam.result, 0, issueParam.size);
//              fflush(stdout);
        }
#       endif

        // checks checksumflag and calculates it if necessary
        if ((header.flags & CHECKSUM_FLAG) != 0) {
                header.checksum = calculateChecksum((unsigned char*) issueParam.result,
                                        issueParam.size);
                // !!! Do (Huffman- ) encoding, if wished afterwards.
        } else {
                header.checksum = CHECKSUM_ZERO;
        }

        // keep the whole flags also for the result packet
        header.errorCode = (short) issueParam.nRet;
#       ifdef __DEBUG
        printf("ErrorCode in Header: %d\n", header.errorCode);
        fflush(stdout);
#       endif

        pHeaderStream = marshallHeader(&header);
        memcpy((void*) cmndACK, (void*) pHeaderStream, HEADER_SIZE);
        if (pHeaderStream != 0) {
                free(pHeaderStream);
        }

        if (useMM) {
          /*
#               ifdef __DEBUG
                printf("ACK channel used with MemoryManagement in FeeServer.\n");
                fflush(stdout);
                createLogMessage(MSG_DEBUG,
                                "ACK channel used with MemoryManagement in FeeServer.", 0);
#               endif
          */
        } else {
                memcpy(((void*) cmndACK + HEADER_SIZE), (void*) issueParam.result,
                                issueParam.size);
        }

        //store the size of the result globally
        cmndACKSize = issueParam.size + HEADER_SIZE;
        // propagate change of ACK(nowledge channel) to upper Layers
        dis_update_service(serviceACKID);

#       ifdef __DEBUG
        // -- see the cmndACK as a char - string
        printf("ACK \n");
//      printData(cmndACK, HEADER_SIZE, cmndACKSize);
        // -- see the cmndACK in a HEX view for the ALTRO
        //print_package(cmndACK + HEADER_SIZE);
#       endif

        if ((!useMM) && (issueParam.result != 0)) {
                free(issueParam.result);
        }
// end of new stuff for memory managment.

/*
        if (cmndACK != 0) {
                free(cmndACK);
                cmndACK = 0;
        }
        // create Acknowledge as return value of command
        // HEADER_SIZE bytes are added before result to insert the command
        // header before the result -> see CommandHeader in Client for details
        cmndACK = (char*) malloc(issueParam.size + HEADER_SIZE);
        if (cmndACK == 0) {
                //no memory available!
#               ifdef __DEBUG
                printf("no memory available!\n");
                fflush(stdout);
#               endif
                createLogMessage(MSG_ERROR, "Insufficient memory for ACK.", 0);

                // no ACK because no memory!
                cmndACKSize = 0;
                status = pthread_mutex_unlock(&command_mut);
                if (status != 0) {
#                       ifdef __DEBUG
                        printf("Lock command mutex error: %d\n", status);
                        fflush(stdout);
#                       endif
                        createLogMessage(MSG_WARNING,
                                        "Error while trying to unlock command mutex.", 0);
                }
                return;
        }

#       ifdef __DEBUG
        if (issueParam.size > 0) {
//              printf("in cmnd-Handler -> issue result: ");
//              printData(issueParam.result, 0, issueParam.size);
//              fflush(stdout);
        }
#       endif

        // checks checksumflag and calculates it if necessary
        if ((header.flags & CHECKSUM_FLAG) != 0) {
                header.checksum = calculateChecksum((unsigned char*) issueParam.result,
                                        issueParam.size);
                // !!! Do (Huffman- ) encoding, if wished afterwards.
        } else {
                header.checksum = CHECKSUM_ZERO;
        }

        // keep the whole flags also for the result packet
        header.errorCode = (short) issueParam.nRet;
#       ifdef __DEBUG
        printf("ErrorCode in Header: %d\n", header.errorCode);
        fflush(stdout);
#       endif

        pHeaderStream = marshallHeader(&header);
        memcpy((void*) cmndACK, (void*) pHeaderStream, HEADER_SIZE);
        if (pHeaderStream != 0) {
                free(pHeaderStream);
        }
        memcpy(((void*) cmndACK + HEADER_SIZE), (void*) issueParam.result,
                                issueParam.size);

        //store the size of the result globally
        cmndACKSize = issueParam.size + HEADER_SIZE;
        // propagate change of ACK(nowledge channel) to upper Layers
        dis_update_service(serviceACKID);

#       ifdef __DEBUG
        // -- see the cmndACK as a char - string
        printf("ACK \n");
//      printData(cmndACK, HEADER_SIZE, cmndACKSize);
        // -- see the cmndACK in a HEX view for the ALTRO
        //print_package(cmndACK + HEADER_SIZE);
#       endif

        if (issueParam.result != 0) {
                free(issueParam.result);
        }

*/


        // unlock command mutex, data has been sent
        status = pthread_mutex_unlock(&command_mut);
        if (status != 0) {
#               ifdef __DEBUG
                printf("Lock command mutex error: %d\n", status);
                fflush(stdout);
#               endif
                createLogMessage(MSG_WARNING,
                                "Error while trying to unlock command mutex.", 0);
        }
}

Here is the call graph for this function:

Here is the caller graph for this function: