EPSIAE » eneraptor

/*

 * hci_comm_listener.c

 *

 * 2011, Aleksander Besir (alex.besir@gmail.com)

 *

 */

#include "hci_comm.h"

#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include "../mxml/mxml.h"

#include "hciChanged.h"

// Global variables from startup/main.c

    extern pthread_mutex_t mtx;

    extern int hciChanged;

int listenTo(unsigned short int portNum) {

    // Holders

    char *attrVal;

    char *name;

    int responseLength;

        // Buffer

        char *requestBuffer = malloc(HCI_COMM_REQUEST_BUFFER_SIZE * sizeof(char));

        if(requestBuffer == NULL) {

                printf("HCI comm error: Cannot allocate buffer.\n");

                return HCI_COMM_ERR_BUF_ALOC_FAIL;

        }

        char *responseBuffer = malloc(HCI_COMM_RESPONSE_BUFFER_SIZE * sizeof(char));

        if(responseBuffer == NULL) {

                printf("HCI comm error: Cannot allocate buffer.\n");

                return HCI_COMM_ERR_BUF_ALOC_FAIL;

        }

        char *lineBuffer = malloc(HCI_COMM_LINE_BUFFER_SIZE * sizeof(char));

        if(lineBuffer == NULL) {

                printf("HCI comm error: Cannot allocate buffer.\n");

                return HCI_COMM_ERR_BUF_ALOC_FAIL;

        }

        // Socket holder

        int socketHolder = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);

        if(socketHolder < 0) {

                fprintf(stderr,"HCI comm error: Cannot create a new socket.\n");

                return HCI_COMM_ERR_NEW_SOCKET_FAIL;

        }

        // Socket address holder

        struct sockaddr_in socketAddressHolder;

        memset(&socketAddressHolder, 0, sizeof(socketAddressHolder));

        socketAddressHolder.sin_family      = AF_INET;

            socketAddressHolder.sin_port        = htons(portNum);

            socketAddressHolder.sin_addr.s_addr = INADDR_ANY;

        // Bind socket to port

        int bindingResult = bind(socketHolder,(struct sockaddr *)&socketAddressHolder, sizeof(socketAddressHolder));

        if(bindingResult == -1) {

                fprintf(stderr,"HCI comm error: Cannot bind socket to port %d.\n",portNum);

                close(socketHolder);

                return HCI_COMM_ERR_BIND_FAIL;

        }

        // Listen to port

        int listenResult = listen(socketHolder, 10);

        if(listenResult == -1) {

                printf("HCI comm error: Cannot listen to port %d.\n",portNum);

                close(socketHolder);

                return HCI_COMM_ERR_LISTEN_FAIL;

        }

        // Infinite listening

        while(1) {

        memset(responseBuffer,'\0',HCI_COMM_RESPONSE_BUFFER_SIZE);

        memset(requestBuffer,'\0',HCI_COMM_REQUEST_BUFFER_SIZE);

        memset(lineBuffer,'\0',HCI_COMM_LINE_BUFFER_SIZE);

        responseLength = 0;

            printf("[hci_comm_listener] Waiting for new connection...\n");

                // Accept request

                int connectionHolder = accept(socketHolder,NULL,NULL);

                if(connectionHolder < 0) {

                        printf("HCI comm error: Error accepting request.\n");

            shutdown(connectionHolder,SHUT_RDWR);

            close(connectionHolder);

            continue;

                }

                printf("[hci_comm_listener] New connection accepted\n");

                // Read request

                int readResult = read(connectionHolder,requestBuffer,HCI_COMM_REQUEST_BUFFER_SIZE);

                printf("[hci_comm_listener] Recieved request: %s \n",requestBuffer);

                if(readResult < 0) {

                        printf("HCI comm error: Error reading request.\n");

            strcpy(responseBuffer,"<logic-response type=\"error\">Could not read request!</logic-response>");

            responseLength = strlen(responseBuffer);

            write(connectionHolder,responseBuffer,responseLength);

            shutdown(connectionHolder,SHUT_RDWR);

            close(connectionHolder);

            continue;

                }

        // Parse request

        mxml_node_t *tree;

        tree = mxmlLoadString(NULL, requestBuffer, MXML_NO_CALLBACK);

        if(tree == NULL) {

            printf("[hci_comm_listener] Error parsing request!\n");

            strcpy(responseBuffer,"<logic-response type=\"error\">Could not parse request!</logic-response>");

            responseLength = strlen(responseBuffer);

            write(connectionHolder,responseBuffer,responseLength);

            shutdown(connectionHolder,SHUT_RDWR);

            close(connectionHolder);

            continue;

        }

        printf("[hci_comm_listener] Request parsed\n");

                // Create a response

                printf("[hci_comm_listener] Creating response\n");

                mxml_node_t *node;

        node = mxmlFindElement(tree, tree, "hci-request", NULL, NULL, MXML_DESCEND);

        if(node == NULL) {

            printf("[hci_comm_listener] Request invalid! Sending error to client\n");

            strcpy(responseBuffer,"<logic-response type=\"error\">Invalid request!</logic-response>");

            responseLength = strlen(responseBuffer);

            write(connectionHolder,responseBuffer,responseLength);

            shutdown(connectionHolder,SHUT_RDWR);

            close(connectionHolder);

            continue;

        }

        printf("[hci_comm_listener] Main request node found\n");

        printf("[hci_comm_listener] %d\n",node);

        attrVal = (char *)malloc(sizeof(node->value.element.attrs->value)*strlen(mxmlElementGetAttr(node, "type")));

        attrVal = mxmlElementGetAttr(node,"type");

        printf("[hci_comm_listener] Got type\n");

        if(strcmp(attrVal,"checkConnection") == 0) {

            printf("[hci_comm_listener] checkConnection request\n");

            strcpy(responseBuffer,"");

            strcat(responseBuffer,"<logic-response type=\"checkConnection\"><data>");

            mxml_node_t *child = node->child;

            child = child->child;

            strcat(responseBuffer,child->value.text.string);

            strcat(responseBuffer,"</data></logic-response>");

            printf("[hci_comm_listener] Response formed: %s\n",responseBuffer);

            responseLength = strlen(responseBuffer);

            printf("[hci_comm_listener] Response length formed: %d\n",responseLength);

        } else if(strcmp(attrVal,"getConfig") == 0) {

            printf("[hci_comm_listener] getConfig request\n");

            // TODO

        } else if(strcmp(attrVal,"setConfig") == 0) {

            printf("[hci_comm_listener] setConfig request\n");

            // TODO

        } else if(strcmp(attrVal,"getScenarios") == 0) {

            printf("[hci_comm_listener] getScenarios request\n");

            FILE *fp;

            if(fp = fopen("./scenariotree.xml", "r")) {

                printf("[hci_comm_listener] File opened\n");

                strcat(responseBuffer,"<logic-response type=\"getScenarios\">");

                while(fgets(lineBuffer,HCI_COMM_LINE_BUFFER_SIZE,fp)) {

                    strcat(responseBuffer,lineBuffer);

                }

                strcat(responseBuffer,"</logic-response>");

                responseLength = strlen(responseBuffer);

                fclose(fp);

            } else {

                 printf("[hci_comm_listener] Error: Can't open file scenariotree.xml\n");

                 strcpy(responseBuffer,"<logic-response type=\"error\">Could not read file!</logic-response>");

                 responseLength = strlen(responseBuffer);

            }

        } else if(strcmp(attrVal,"setScenarios") == 0) {

            printf("[hci_comm_listener] setScenarios request\n");

            // Prepare new content for scenariotree.xml

            strncpy(lineBuffer,requestBuffer+54,strlen(requestBuffer)-(54+14+2));

            strcpy(requestBuffer,"<?xml version=\"1.0\"?>");

            strcat(requestBuffer,lineBuffer);

            FILE *fp;

            if(fp = fopen("./scenariotree.xml", "w")) {

                fputs(requestBuffer,fp);

                fclose(fp);

                pthread_mutex_lock(&mtx);

                hciChanged = HCI_CHANGED_SCENARIOS;

                pthread_mutex_unlock(&mtx);

                strcpy(responseBuffer,"<logic-response type=\"setScenarios\"></logic-response>");

                responseLength = strlen(responseBuffer);

            } else {

                printf("[hci_comm_listener] Error: Can't open file scenariotree.xml for writing\n");

                strcpy(responseBuffer,"<logic-response type=\"error\">Could not write file!</logic-response>");

                responseLength = strlen(responseBuffer);

            }

        } else if(strcmp(attrVal,"executeAction") == 0) {

            printf("[hci_comm_listener] executeAction request\n");

            // TODO

        } else {

            strcpy(responseBuffer,"<logic-response type=\"error\">Invalid request!</logic-response>");

            responseLength = 62;

        }

                // Check if logic wants to terminate the infinite loop

                if(responseLength == HCI_COMM_TERMINATE) {

                        break;

                }

                // Send response

                int writeResult = write(connectionHolder,responseBuffer,responseLength);

                printf("[hci_comm_listener] Written response to client\n");

                if(writeResult < 0) {

                        printf("HCI comm error: Error writting response.\n");

                }

                // Close connection

                free(attrVal);

                shutdown(connectionHolder,SHUT_RDWR);

                close(connectionHolder);

                printf("[hci_comm_listener] Connection closed\n");

        }

        // Terminate

        close(socketHolder);

        free(requestBuffer);

        requestBuffer = NULL;

        return HCI_COMM_TERMINATED_BY_LOGIC;

}