root/vtcross/branches/wrodgers/src/service_management_layer/ServiceManagementLayer_works_lin_srv.cpp @ 277

/* Virginia Tech Cognitive Radio Open Source Systems
 * Virginia Tech, 2009
 *
 * LICENSE INFORMATION GOES HERE
 */

/* Inter-component communication handled by sockets and FD's.  
 * Server support has been completely implemented and tested.
 *
 * Services are stored in a SQLite DB by the ID of the CE that registered them.  Service
 * support has been completely implemented and tested.
 *
 * Missions are loaded from an XML file, connected with services provided by components,
 * and run.  See the documentation for the "PerformActiveMission" below for important 
 * info.  Mission support has been completely implemented but mostly untested
 * (except for the XML parsing, which has been fully tested).
 *
 * It is important that in the XML configuration file, inputs and outputs are listed
 * in the order that they appear.  See the documentation for the "PerformActiveMission"
 * method for more information.
 *
 * 
 */

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <cstring>
#include <stdint.h>

#include "../../trunk/src/include/vtcross/common.h"

#include "../../trunk/src/include/vtcross/components.h"
#include "../../trunk/src/include/vtcross/containers.h"
#include "../../trunk/src/include/vtcross/debug.h"
#include "../../trunk/src/include/vtcross/error.h"
#include "../../trunk/src/include/vtcross/socketcomm.h"


#include <cstdlib>
#include <cstring>
#include <stdint.h>
#include <math.h>

#include <arpa/inet.h>
#include <iostream>
#include <netinet/in.h>
#include <netdb.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/wait.h>

#include "../../trunk/src/include/tinyxml/tinyxml.h"
#include "../../trunk/src/include/tinyxml/tinystr.h"
#include "sqlite3.h"
//#include "sqlite3ext.h"

typedef struct services_s * services_DB;

struct services_s {
    char filename[64];
    char tablename[64];
    char command[2048];
    sqlite3 *db; 
    unsigned int num_columns;
};

services_DB _services_DB;
const char *_SML_Config;

int callback(void *notUsed, int argc, char **argv, char **azColName){
    int i;
    for(i=0; i<argc; i++){
        printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
    }
    printf("\n");
    return 0;
}



ServiceManagementLayer::ServiceManagementLayer()
{
    LOG("Creating Service Management Layer.\n");
    shellSocketFD = -1;
    numberOfCognitiveEngines = 0;
    CE_Present = false;
    cogEngSrv = 1;
}


ServiceManagementLayer::~ServiceManagementLayer()
{
    char *errorMsg;
    strcpy(_services_DB->command, "drop table ");
    strcat(_services_DB->command, _services_DB->tablename);
    int rc = sqlite3_exec(_services_DB->db, _services_DB->command, callback, 0, &errorMsg);
    if( rc!=SQLITE_OK && rc!=101 )
        fprintf(stderr, "SQL error: %s\n", errorMsg);
    strcpy(_services_DB->command, "vacuum");
    rc = sqlite3_exec(_services_DB->db, _services_DB->command, callback, 0, &errorMsg);
    if( rc!=SQLITE_OK && rc!=101 )
        fprintf(stderr, "SQL error: %s\n", errorMsg);
    free(_services_DB);
}


ServiceManagementLayer::ServiceManagementLayer(const char* SML_Config, \
        const char* serverName, const char* serverPort)
{
    LOG("Creating Service Management Layer.\n");
    _SML_Config = SML_Config;

    ConnectToShell(serverName, serverPort);
    CE_List = (CE_Reg *) malloc(10*sizeof(struct CE_Reg));
    CE_List = new CE_Reg[10];

    miss = new Mission[10];
    for(int i = 0; i < 10; i++)
        miss[i].services = new Service[20];

    Current_ID = 0;

    LoadConfiguration(SML_Config, miss);
    CreateServicesDB();
}

//VERIFIED May 26
void
ServiceManagementLayer::CreateServicesDB()
{
    _services_DB = (services_DB) malloc(sizeof(struct services_s));
    char *errorMsg;

    // create database

    // copy filename
    unsigned int i=0;
    strcpy(_services_DB->filename, "Services_Table");

    // execute create database command
    // database handle
    //_services_DB->db = NULL;
    sqlite3_open(_services_DB->filename, &(_services_DB->db));
    char* cols[] = {(char *)"ID_Num", (char *)"Service_Name"};

    // create table

    // copy tablename
    strcpy(_services_DB->tablename, "Services");

    // number of columns in the table
    _services_DB->num_columns = 2;

    // generate command
    strcpy(_services_DB->command, "CREATE TABLE ");
    strcat(_services_DB->command, _services_DB->tablename);
    strcat(_services_DB->command, "(");
    //strcat(_services_DB->command, "SRVID INTEGER PRIMARY KEY, ");
    strcat(_services_DB->command, cols[0]);
    strcat(_services_DB->command, " INT, ");
    strcat(_services_DB->command, cols[1]);
    strcat(_services_DB->command, " TEXT");
    strcat(_services_DB->command, ");");

    // execute create table command
  sqlite3_stmt *ppStmt;  /* OUT: Statement handle */
  const char *pzTail;     /* OUT: Pointer to unused portion of zSql */

    int rc = sqlite3_prepare_v2(_services_DB->db, _services_DB->command, 128, &ppStmt, &pzTail);
    if( rc!=SQLITE_OK && rc!=101 )
        printf("SQL error(1): %d\n", rc);
    rc = sqlite3_step(ppStmt);
    if( rc!=SQLITE_OK && rc!=101 )
        printf("SQL error(2): %d\n", rc);
}


void 
ServiceManagementLayer::SendComponentType()
{
    SendMessage(shellSocketFD, "response_sml");
    LOG("SML responded to GetRemoteComponentType query.\n");
}


void 
ServiceManagementLayer::ConnectToShell(const char* serverName, \
        const char* serverPort)
{
    shellSocketFD = ClientSocket(serverName, serverPort);
    
    //Set the shell socket to non-block mode
    /*int oldflags = fcntl (shellSocketFD, F_GETFL, 0);
    oldflags |= O_NONBLOCK;
    fcntl (shellSocketFD, F_SETFL, oldflags);*/

    RegisterComponent();
}

void
ServiceManagementLayer::MessageHandler(int32_t ID)
{
    char buffer[256];   
    memset(buffer, 0, 256);  
    int32_t _FD; 
    //printf("ID= %d\n", ID); 
    
    if(ID != -1)
        _FD = CE_List[ID].FD;
    else 
        _FD = shellSocketFD;

    //printf("FD=%d, shellFD=%d", _FD, shellSocketFD);
    ssize_t msgLength = recv(_FD, buffer, 256, MSG_PEEK);
    if(msgLength == 0){
        //printf("Error reading from socket.\n");
        //sleep(5);     
        return;
    }


    size_t i;
    for(i = 0; i < 256; i++) {
        if(strcmp(&buffer[i], "\0") == 0)
            break;
    }
    // Read the message into msgBuffer
    recv(_FD, buffer, i + 1, 0);
    //printf("********* %s **********\n", buffer);
    // TODO
    // If we send integer op codes rather than strings, this process will be
    // MUCH faster since instead of donig string compares we can simply
    // switch on the integer value...
    /*if(strcmp(buffer, "register_service") == 0) {
        if(strcmp(buffer, "policy_geo") == 0) {
        }
        else if(strcmp(buffer, "policy_time") == 0) {
        }
        else if(strcmp(buffer, "policy_spectrum") == 0) {
        }
        else if(strcmp(buffer, "policy_spacial") == 0) {
        }
    }
    else if(strcmp(buffer, "deregister_service") == 0) {
        if(strcmp(buffer, "policy_geo") == 0) {
        }
        else if(strcmp(buffer, "policy_time") == 0) {
        }
        else if(strcmp(buffer, "policy_spectrum") == 0) {
        }
        else if(strcmp(buffer, "policy_spacial") == 0) {
        }
    }*/
    if(strcmp(buffer, "query_component_type") == 0) {
        SendComponentType();
    }
    else if(strcmp(buffer, "reset_sml") == 0) {
        Reset();
    }
    else if(strcmp(buffer, "shutdown_sml") == 0) {
        Shutdown();
    }
    else if(strcmp(buffer, "register_engine_cognitive") == 0) {
        RegisterCognitiveEngine(ID);
    }
    else if(strcmp(buffer, "register_service") == 0) {
        ReceiveServices(ID);
    }
    else if(strcmp(buffer, "send_component_type") == 0) {
        SendComponentType();
    }
    else if(strcmp(buffer, "list_services") == 0) {
        ListServices();
    }
    else if(strcmp(buffer, "set_active_mission") == 0) {
        SetActiveMission();
    }
    else if(strcmp(buffer, "request_optimization") == 0) {
        PerformActiveMission();
    }
}



void 
ServiceManagementLayer::Shutdown()
{
    DeregisterComponent();
}


void 
ServiceManagementLayer::Reset()
{
    DeregisterComponent();
    LoadConfiguration(_SML_Config, miss);
}


void 
ServiceManagementLayer::RegisterComponent()
{
    SendMessage(shellSocketFD, "register_sml");
    LOG("ServiceManagementLayer:: Registration message sent.\n");
}


void 
ServiceManagementLayer::DeregisterComponent()
{
    SendMessage(shellSocketFD, "deregister_sml");
    LOG("ServiceManagementLayer:: Deregistration message sent.\n");

    shutdown(shellSocketFD, 2);
    close(shellSocketFD);
    shellSocketFD = -1;
    LOG("ServiceManagementLayer:: Shell socket closed.\n");
}

/* Streams config data directly from the shell to the CE, and checks
 * for an "ack" message from the CE after every sent message 
 * to know when to stop communication.
 */
void 
ServiceManagementLayer::TransferRadioConfiguration(int32_t ID)
{
    struct timeval selTimeout;
    fd_set sockSet;
    int32_t rc = 0;
    char buffer[256];
    //Send data until the CE sends an ACK message back
    while(rc==0){
        memset(buffer, 0, 256);
        //Receive data from Shell
        ReadMessage(shellSocketFD, buffer);
        //Send data to CE
        SendMessage(CE_List[ID].FD, buffer);
        FD_ZERO(&sockSet);
        FD_SET(CE_List[ID].FD, &sockSet);
        selTimeout.tv_sec = 0;
        selTimeout.tv_usec = 0;
        //Check if there is a message on the CE socket ready to be processed
        rc=select(CE_List[ID].FD + 1, &sockSet, NULL, NULL, &selTimeout);
    }
    memset(buffer, 0, 256);
    ReadMessage(CE_List[ID].FD, buffer);
    SendMessage(shellSocketFD, buffer);
}

//Simmilar to TransferRadioConfig, just with Experience data
void 
ServiceManagementLayer::TransferExperience(int32_t ID)
{
    struct timeval selTimeout;
    fd_set sockSet;
    int32_t rc = 0;
    char buffer[256];
    //Send data until the CE sends an ACK message back
    while(rc==0){
        memset(buffer, 0, 256);
        //Receive data from Shell
        ReadMessage(shellSocketFD, buffer);
        //Send data to CE
        SendMessage(CE_List[ID].FD, buffer);
        FD_ZERO(&sockSet);
        FD_SET(CE_List[ID].FD, &sockSet);
        selTimeout.tv_sec = 0;
        selTimeout.tv_usec = 0;
        //Check if there is a message on the CE socket ready to be processed
        rc = select(CE_List[ID].FD + 1, &sockSet, NULL, NULL, &selTimeout);
    }
    memset(buffer, 0, 256);
    ReadMessage(CE_List[ID].FD, buffer);
    SendMessage(shellSocketFD, buffer);
}

//VERIFIED May 26
void 
ServiceManagementLayer::ReceiveServices(int32_t ID)
{
    char buffer[256];
    memset(buffer, 0, 256);
    ReadMessage(CE_List[ID].FD, buffer);
    char* cols[] = {(char *)"ID_Num", (char *)"Service_Name"};
    
    // generate command
    //printf("%s\n", _services_DB->command);
    strcpy(_services_DB->command, "insert into ");
    strcat(_services_DB->command, _services_DB->tablename); 
    strcat(_services_DB->command, " (");
    strcat(_services_DB->command, cols[0]);
    strcat(_services_DB->command, ", ");
    strcat(_services_DB->command, cols[1]);
    strcat(_services_DB->command, ") ");
    strcat(_services_DB->command, " values(");
    sprintf(_services_DB->command, "%s%d", _services_DB->command, ID);
    strcat(_services_DB->command, ", '");
    strcat(_services_DB->command, buffer);
    strcat(_services_DB->command, "');");
    
    //printf("search command: %s\n", _services_DB->command);
    // execute add command
    char *errorMsg;
    int rc = sqlite3_exec(_services_DB->db, _services_DB->command, callback, 0, &errorMsg);
    if( rc!=SQLITE_OK && rc!=101 )
        fprintf(stderr, "SQL error: %s\n", errorMsg);
    printf("SML: Registering service '%s' from component number '%d'\n", buffer, ID);

}

//This method associates the services that components provide with the services that are requested in the mission
//Each service in the mission is given the ID and FD of a component that has registered to provide that service 
//Deregistration is okay until this method is called without a reload, but if deregistration occurs after this
// method is called it needs to be called again even if other engines also provide the services

//Verified May 29
void 
ServiceManagementLayer::SetActiveMission()
{
    char buffer[256];
    memset(buffer, 0, 256);
    ReadMessage(shellSocketFD, buffer);
    int32_t missID = atoi(buffer);
    for(activeMission = 0; activeMission < 10; activeMission++)
    {
        if(miss[activeMission].missionID == missID)
            break;
    }
    for(int i = 0; i < miss[activeMission].numServices; i++)
    {
        strcpy(_services_DB->command, "select ");
        strcat(_services_DB->command, _services_DB->tablename);
        strcat(_services_DB->command, ".* from ");
        strcat(_services_DB->command, _services_DB->tablename);
        strcat(_services_DB->command, " where Service_Name==");
        sprintf(_services_DB->command, "%s'%s';", _services_DB->command, miss[activeMission].services[i].name.c_str());
        

        sqlite3_stmt * pStatement;
        int rc = sqlite3_prepare_v2(_services_DB->db, _services_DB->command, -1, &pStatement, NULL);
        if (rc == SQLITE_OK){ 
            if (sqlite3_step(pStatement) == SQLITE_ROW)
                 miss[activeMission].services[i].componentID =  sqlite3_column_int(pStatement, 0); 
            else {
                    printf("services_DB:: Mission requires service not provided by any connected component.\n");
                    rc=31337;
            }
        } else {
            printf("services_DB:: Error executing SQL statement. rc = %i\n%s\n",rc,_services_DB->command);
        }

        sqlite3_finalize(pStatement);
        miss[activeMission].services[i].socketFD = CE_List[miss[activeMission].services[i].componentID].FD;
    }
    printf("\nhere ---%d, %d---\n", miss[activeMission].services[0].componentID, miss[activeMission].services[1].componentID);
}

//This is a helper method for the "PerformActiveMission" function
//It takes the ID's of a source and a destination and does a raw transfer between them
//It knows when to stop when an "ack" signal returns from the destination component
//An ID of "-1" coresponds to the shell
void
ServiceManagementLayer::TransactData(int32_t sourceID, int32_t destID)
{
    printf("transact occuring between %d and %d\n", sourceID, destID);
    int32_t FD_src, FD_dest;
    struct timeval selTimeout;
    if(sourceID==-1)
        FD_src=shellSocketFD;
    else
        FD_src=CE_List[sourceID].FD;
    if(destID==-1)
        FD_dest=shellSocketFD;
    else
        FD_dest=CE_List[destID].FD;

    int32_t rc = 0;
    fd_set sockSet;
    char buffer[256];
    //Send data until the CE sends an ACK message back
    while(rc==0){
        memset(buffer, 0, 256);
        //Receive data from Shell
        printf("reading data from %d\n", FD_src);
        ReadMessage(FD_src, buffer);
        //Send data to CE
        printf("sending data to %d\n", FD_dest);
        SendMessage(FD_dest, buffer);
        FD_ZERO(&sockSet);
        FD_SET(FD_dest, &sockSet);
        selTimeout.tv_sec = 0;
        selTimeout.tv_usec = 50;
        //Check if there is a message on the CE socket ready to be processed
        rc=select(FD_dest + 1, &sockSet, NULL, NULL, &selTimeout);
    }
    memset(buffer, 0, 256);
    ReadMessage(FD_dest, buffer);
    printf("done transact data %s\n", buffer);
}

// Rules for active missions (currently)
// -Three inputs/outputs per service and per mission
// -Inputs simply define a path, so multiple variables can be transmitted over the same input
// -Each component that takes input is responsible for sending an "ack" signal when transmission is complete
//   -Transmission will continue until the "ack" signal is recieved
// -Any input from shell to a CE must be the first input
// -CE-CE inputs must be listed in the order the ouptuts are generated
// -No ability to store data locally at this time, so all CE's must be ready to receive data as soon as it is sent
// -Shell should be ready for output in order that it is generated
// -If/While supported and nesting too (except nested while loops)
// -Conditions must be boolean flags
// -Flags are set by putting either the character string "true" or "false" on the buffer

// This function works by first sending the inputs from the shell to the appropriate components
// The first service should begin immeadiately, as should any others who have all of their input paramaters
// When they complete, the output path is found and the data is transfered as it becomes available
// Presumably at this point the second function has all of it's paramaters, so it begins to compute, and the cycle repeats
// If the generated output is an overall output, it is sent on to the shell
// "if" and "while" statements are handled by setting up a faux service that has a true input, a false input, and a boolean flag
// If the true input is non-NULL and the flag is true, the statements execute
// Likewise, if the false input is non-NULL and the flag is false, the statements execute
// These flags are set during execution any time one of these faux services' inputs appear in an output statement  
// 
void
ServiceManagementLayer::PerformActiveMission()
{
    int i = 0;
    char *buffer;
    if(!miss[activeMission].input[0].empty()){
        printf("mission input 1 not empty\n");
        for(int j = 0; j < miss[activeMission].numServices; j++)
        {
            if(miss[activeMission].services[j].input[0].compare(miss[activeMission].input[0]) == 0){
                if(miss[activeMission].services[j].num_conds > 0){
                    memset(buffer, 0, 256);
                    ReadMessage(shellSocketFD, buffer);
                    if(strcmp(buffer, "false")==0)
                        miss[activeMission].services[j].cond_flag=false;
                    else
                        miss[activeMission].services[j].cond_flag=true;
                    break;
                }
                SendMessage(miss[activeMission].services[j].socketFD, "request_optimization_service");
                SendMessage(miss[activeMission].services[j].socketFD, miss[activeMission].services[j].name.c_str());
                TransactData(-1, miss[activeMission].services[j].componentID);
            }   
        }
    }
    if(!miss[activeMission].input[1].empty()){
        for(int j = 0; j < miss[activeMission].numServices; j++)
        {
            if(miss[activeMission].services[j].input[1].compare(miss[activeMission].input[0]) == 0){
                if(miss[activeMission].services[j].num_conds > 0){
                    memset(buffer, 0, 256);
                    ReadMessage(shellSocketFD, buffer);
                    if(strcmp(buffer, "false")==0)
                        miss[activeMission].services[j].cond_flag=false;
                    else
                        miss[activeMission].services[j].cond_flag=true;
                    break;
                }
                SendMessage(miss[activeMission].services[j].socketFD, "request_optimization_service");
                SendMessage(miss[activeMission].services[j].socketFD, miss[activeMission].services[j].name.c_str());
                TransactData(-1, miss[activeMission].services[j].componentID);
            }   
            if(miss[activeMission].services[j].input[1].compare(miss[activeMission].input[1]) == 0)
                TransactData(-1, miss[activeMission].services[j].componentID);  
        }
    }
    if(!miss[activeMission].input[2].empty()){
        for(int j = 0; j < miss[activeMission].numServices; j++)
        {
            if(miss[activeMission].services[j].input[2].compare(miss[activeMission].input[0]) == 0){
                if(miss[activeMission].services[j].num_conds > 0){
                    memset(buffer, 0, 256);
                    ReadMessage(shellSocketFD, buffer);
                    if(strcmp(buffer, "false")==0)
                        miss[activeMission].services[j].cond_flag=false;
                    else
                        miss[activeMission].services[j].cond_flag=true;
                    break;
                }
                SendMessage(miss[activeMission].services[j].socketFD, "request_optimization_service");
                SendMessage(miss[activeMission].services[j].socketFD, miss[activeMission].services[j].name.c_str());
                TransactData(-1, miss[activeMission].services[j].componentID);
            }   
            if(miss[activeMission].services[j].input[2].compare(miss[activeMission].input[1]) == 0)
                TransactData(-1, miss[activeMission].services[j].componentID);
            if(miss[activeMission].services[j].input[2].compare(miss[activeMission].input[2]) == 0)
                TransactData(-1, miss[activeMission].services[j].componentID);  
        }
    }
    while(i != miss[activeMission].numServices)
    {   
        if(strcmp(miss[activeMission].services[i].name.c_str(), "while")==0)
        {
            int32_t stmt_i = i;
            i+=miss[activeMission].services[stmt_i].num_conds;
            while((miss[activeMission].services[stmt_i].cond_flag && !miss[activeMission].services[stmt_i].input[0].empty()) ||\
                  (!miss[activeMission].services[stmt_i].cond_flag && !miss[activeMission].services[stmt_i].input[1].empty())){
                for(int32_t k=stmt_i+1; k <= stmt_i+miss[activeMission].services[stmt_i].num_conds; k++){
                    if(strcmp(miss[activeMission].services[i].name.c_str(), "if")==0){
                        int32_t stmt_k = k;
                        if((miss[activeMission].services[stmt_k].cond_flag && !miss[activeMission].services[stmt_k].input[0].empty()) ||\
                           (!miss[activeMission].services[stmt_k].cond_flag && !miss[activeMission].services[stmt_k].input[1].empty())){
                            for(int n = stmt_k+1; n <= stmt_k+miss[activeMission].services[stmt_k].num_conds; n++){
                                for(int m = 0; m < 3; m++){
                                    for(int j = 0; j < 3; j++){
                                        if(miss[activeMission].services[k].output[m].compare(miss[activeMission].output[j])==0){
                                            TransactData(miss[activeMission].services[k].componentID, -1);
                                            break;
                                        }
                                    }
                                    for(int j = 0; j < miss[activeMission].numServices; j++){
                                        if(miss[activeMission].services[k].output[m].compare(miss[activeMission].services[j].input[0]) == 0){
                                            if(miss[activeMission].services[j].num_conds > 0){
                                                memset(buffer, 0, 256);
                                                ReadMessage(miss[activeMission].services[k].socketFD, buffer);
                                                if(strcmp(buffer, "false")==0)
                                                    miss[activeMission].services[j].cond_flag=false;
                                                else
                                                    miss[activeMission].services[j].cond_flag=true;
                                                break;
                                            }
                                            SendMessage(miss[activeMission].services[j].socketFD, "request_optimization_service");
                                            SendMessage(miss[activeMission].services[j].socketFD, miss[activeMission].services[j].name.c_str());
                                            TransactData(miss[activeMission].services[k].componentID, miss[activeMission].services[j].componentID);
                                            break;      
                                        }       
                                        if(miss[activeMission].services[k].output[m].compare(miss[activeMission].services[j].input[1]) == 0){
                                            if(miss[activeMission].services[j].num_conds > 0){
                                                memset(buffer, 0, 256);
                                                ReadMessage(miss[activeMission].services[k].socketFD, buffer);
                                                if(strcmp(buffer, "false")==0)
                                                    miss[activeMission].services[j].cond_flag=false;
                                                else
                                                    miss[activeMission].services[j].cond_flag=true;
                                                break;
                                            }
                                            TransactData(miss[activeMission].services[k].componentID, miss[activeMission].services[j].componentID);
                                            break;      
                                        }       
                                        if(miss[activeMission].services[k].output[m].compare(miss[activeMission].services[j].input[2]) == 0){
                                            TransactData(miss[activeMission].services[k].componentID, miss[activeMission].services[j].componentID);
                                            break;      
                                        }
                                    }   
                                }
                            }
                        }
                    }
                    else{
                        for(int m = 0; m < 3; m++)
                        {
                            for(int j = 0; j < 3; j++){
                                if(miss[activeMission].services[k].output[m].compare(miss[activeMission].output[j])==0){
                                    TransactData(miss[activeMission].services[k].componentID, -1);
                                    break;
                                }
                            }
                            for(int j = 0; j < miss[activeMission].numServices; j++){
                                if(miss[activeMission].services[k].output[m].compare(miss[activeMission].services[j].input[0]) == 0){
                                    if(miss[activeMission].services[j].num_conds > 0){
                                                memset(buffer, 0, 256);
                                        ReadMessage(miss[activeMission].services[k].socketFD, buffer);
                                        if(strcmp(buffer, "false")==0)
                                            miss[activeMission].services[j].cond_flag=false;
                                        else
                                            miss[activeMission].services[j].cond_flag=true;
                                        break;
                                    }
                                    SendMessage(miss[activeMission].services[j].socketFD, "request_optimization_service");
                                    SendMessage(miss[activeMission].services[j].socketFD, miss[activeMission].services[j].name.c_str());
                                    TransactData(miss[activeMission].services[k].componentID, miss[activeMission].services[j].componentID);
                                    break;      
                                }       
                                if(miss[activeMission].services[k].output[m].compare(miss[activeMission].services[j].input[1]) == 0){
                                    if(miss[activeMission].services[j].num_conds > 0){
                                                memset(buffer, 0, 256);
                                        ReadMessage(miss[activeMission].services[k].socketFD, buffer);
                                        if(strcmp(buffer, "false")==0)
                                            miss[activeMission].services[j].cond_flag=false;
                                        else
                                            miss[activeMission].services[j].cond_flag=true;
                                        break;
                                    }
                                    TransactData(miss[activeMission].services[k].componentID, miss[activeMission].services[j].componentID);
                                    break;      
                                }       
                                if(miss[activeMission].services[k].output[m].compare(miss[activeMission].services[j].input[2]) == 0){
                                    TransactData(miss[activeMission].services[k].componentID, miss[activeMission].services[j].componentID);
                                    break;      
                                }
                            }   
                        }
                    }
                }
            }
        }
        else if(strcmp(miss[activeMission].services[i].name.c_str(), "if")==0)
        {
            int32_t stmt_i = i;
            i+=miss[activeMission].services[stmt_i].num_conds;
            if((miss[activeMission].services[stmt_i].cond_flag && !miss[activeMission].services[stmt_i].input[0].empty()) ||\
                  (!miss[activeMission].services[stmt_i].cond_flag && !miss[activeMission].services[stmt_i].input[1].empty())){
                for(int32_t k=stmt_i+1; k <= stmt_i+miss[activeMission].services[stmt_i].num_conds; k++){
                    if(strcmp(miss[activeMission].services[i].name.c_str(), "if")==0){
                        int32_t stmt_k = k;
                        if((miss[activeMission].services[stmt_k].cond_flag && !miss[activeMission].services[stmt_k].input[0].empty()) ||\
                           (!miss[activeMission].services[stmt_k].cond_flag && !miss[activeMission].services[stmt_k].input[1].empty())){
                            for(int n = stmt_k+1; n <= stmt_k+miss[activeMission].services[stmt_k].num_conds; n++){
                                for(int m = 0; m < 3; m++)
                                {
                                    for(int j = 0; j < 3; j++){
                                        if(miss[activeMission].services[k].output[m].compare(miss[activeMission].output[j])==0){
                                            TransactData(miss[activeMission].services[k].componentID, -1);
                                            break;
                                        }
                                    }
                                    for(int j = 0; j < miss[activeMission].numServices; j++){
                                        if(miss[activeMission].services[k].output[m].compare(miss[activeMission].services[j].input[0]) == 0){
                                            if(miss[activeMission].services[j].num_conds > 0){
                                                memset(buffer, 0, 256);
                                                ReadMessage(miss[activeMission].services[k].socketFD, buffer);
                                                if(strcmp(buffer, "false")==0)
                                                    miss[activeMission].services[j].cond_flag=false;
                                                else
                                                    miss[activeMission].services[j].cond_flag=true;
                                                break;
                                            }
                                            SendMessage(miss[activeMission].services[j].socketFD, "request_optimization_service");
                                            SendMessage(miss[activeMission].services[j].socketFD, miss[activeMission].services[j].name.c_str());
                                            TransactData(miss[activeMission].services[k].componentID, miss[activeMission].services[j].componentID);
                                            break;      
                                        }       
                                        if(miss[activeMission].services[k].output[m].compare(miss[activeMission].services[j].input[1]) == 0){
                                            if(miss[activeMission].services[j].num_conds > 0){
                                                memset(buffer, 0, 256);
                                                ReadMessage(miss[activeMission].services[k].socketFD, buffer);
                                                if(strcmp(buffer, "false")==0)
                                                    miss[activeMission].services[j].cond_flag=false;
                                                else
                                                    miss[activeMission].services[j].cond_flag=true;
                                                break;
                                            }
                                            TransactData(miss[activeMission].services[k].componentID, miss[activeMission].services[j].componentID);
                                            break;      
                                        }       
                                        if(miss[activeMission].services[k].output[m].compare(miss[activeMission].services[j].input[2]) == 0){
                                            TransactData(miss[activeMission].services[k].componentID, miss[activeMission].services[j].componentID);
                                            break;      
                                        }
                                    }   
                                }
                            }
                        }
                    }
                    else{
                        for(int m = 0; m < 3; m++)
                        {
                            for(int j = 0; j < 3; j++){
                                if(miss[activeMission].services[k].output[m].compare(miss[activeMission].output[j])==0){
                                    TransactData(miss[activeMission].services[k].componentID, -1);
                                    break;
                                }
                            }
                            for(int j = 0; j < miss[activeMission].numServices; j++){
                                if(miss[activeMission].services[k].output[m].compare(miss[activeMission].services[j].input[0]) == 0){
                                    if(miss[activeMission].services[j].num_conds > 0){
                                        ReadMessage(miss[activeMission].services[k].socketFD, buffer);
                                        if(strcmp(buffer, "false")==0)
                                            miss[activeMission].services[j].cond_flag=false;
                                        else
                                            miss[activeMission].services[j].cond_flag=true;
                                        break;
                                    }
                                    SendMessage(miss[activeMission].services[j].socketFD, "request_optimization_service");
                                    SendMessage(miss[activeMission].services[j].socketFD, miss[activeMission].services[j].name.c_str());
                                    TransactData(miss[activeMission].services[k].componentID, miss[activeMission].services[j].componentID);
                                    break;      
                                }       
                                if(miss[activeMission].services[k].output[m].compare(miss[activeMission].services[j].input[1]) == 0){
                                    if(miss[activeMission].services[j].num_conds > 0){
                                        ReadMessage(miss[activeMission].services[k].socketFD, buffer);
                                        if(strcmp(buffer, "false")==0)
                                            miss[activeMission].services[j].cond_flag=false;
                                        else
                                            miss[activeMission].services[j].cond_flag=true;
                                        break;
                                    }
                                    TransactData(miss[activeMission].services[k].componentID, miss[activeMission].services[j].componentID);
                                    break;      
                                }       
                                if(miss[activeMission].services[k].output[m].compare(miss[activeMission].services[j].input[2]) == 0){
                                    TransactData(miss[activeMission].services[k].componentID, miss[activeMission].services[j].componentID);
                                    break;      
                                }
                            }   
                        }
                    }
                }
            }
        }
        else{
            for(int m = 0; m < 3; m++)
            {
                printf("\ninside SAM\n");
                for(int j = 0; j < 3; j++){
                    if(miss[activeMission].services[i].output[m].compare(miss[activeMission].output[j])==0 && \
                       !miss[activeMission].services[i].output[j].empty()){
                        printf("i=%d, m=%d, j=%d\n", i, m, j);
                        TransactData(miss[activeMission].services[i].componentID, -1);
                        break;
                    }
                }
                for(int j = 0; j < miss[activeMission].numServices; j++){
                    if(miss[activeMission].services[i].output[m].compare(miss[activeMission].services[j].input[0]) == 0 && \
                       !miss[activeMission].services[i].output[m].empty()){
                        if(miss[activeMission].services[j].num_conds > 0){
                            ReadMessage(miss[activeMission].services[i].socketFD, buffer);
                            if(strcmp(buffer, "false")==0)
                                miss[activeMission].services[j].cond_flag=false;
                            else
                                miss[activeMission].services[j].cond_flag=true;
                            break;
                        }
                        SendMessage(miss[activeMission].services[j].socketFD, "request_optimization_service");
                        SendMessage(miss[activeMission].services[j].socketFD, miss[activeMission].services[j].name.c_str());
                        TransactData(miss[activeMission].services[i].componentID, miss[activeMission].services[j].componentID);
                        break;  
                    }   
                    if(miss[activeMission].services[i].output[m].compare(miss[activeMission].services[j].input[1]) == 0 && \
                       !miss[activeMission].services[i].output[m].empty()){
                        if(miss[activeMission].services[j].num_conds > 0){
                            ReadMessage(miss[activeMission].services[i].socketFD, buffer);
                            if(strcmp(buffer, "false")==0)
                                miss[activeMission].services[j].cond_flag=false;
                            else
                                miss[activeMission].services[j].cond_flag=true;
                            break;
                        }
                        TransactData(miss[activeMission].services[i].componentID, miss[activeMission].services[j].componentID);
                        break;  
                    }   
                    if(miss[activeMission].services[i].output[m].compare(miss[activeMission].services[j].input[2]) == 0 && \
                       !miss[activeMission].services[i].output[m].empty()){
                        TransactData(miss[activeMission].services[i].componentID, miss[activeMission].services[j].componentID);
                        break;  
                    }
                }       
            }
        }
        i++;
    }
}


//Verified May 26
void 
ServiceManagementLayer::ListServices()
{
    // generate commandi
    strcpy(_services_DB->command, "select ");
    strcat(_services_DB->command, _services_DB->tablename);
    strcat(_services_DB->command, ".* from ");
    strcat(_services_DB->command, _services_DB->tablename);
    strcat(_services_DB->command, ";");

    // execute print (select all)  command    
    char *errorMsg;
    int rc = sqlite3_exec(_services_DB->db, _services_DB->command, callback, 0, &errorMsg);
    if( rc!=SQLITE_OK && rc!=101 )
        fprintf(stderr, "SQL error: %s\n", errorMsg);
    printf("database %s, table %s:\n", _services_DB->filename, _services_DB->tablename);
}


void 
ServiceManagementLayer::ReloadConfiguration()
{
    LOG("ServiceManagementLayer:: Reloading Configuration.\n");
    free(miss);
    miss = new Mission[10];
    for(int i = 0; i < 10; i++)
        miss[i].services = new Service[20];
    LoadConfiguration(_SML_Config, miss);
}

//IMPORTANT - See formatting instructions for correct parsing of data
//Can currently handle 3 inputs and 3 outputs per service, but easily expandable
//Also, can handle one layer of nested conditional statements, but could
//be expanded to meet additional needs.  Only support now is for straight bool flags,
//but support could be added for more complex conditionals later.

//Components assigned to mission during "set active mission" stage so that
//components can still continue to register after the configuration is loaded

//Verified May 26
void 
ServiceManagementLayer::LoadConfiguration(const char *SML_Config, Mission* &mList)
{
    TiXmlElement *pMission;
    TiXmlElement *pService;
    TiXmlElement *pChild0, *pChild1, *pChild2, *pChild3;
    TiXmlHandle hRoot(0);
    //printf("ServiceManagementLayer:: Loading Configuration.\n");
    TiXmlDocument doc(".");
    doc.LoadFile(SML_Config);
    bool loadOkay = doc.LoadFile();
    if(!loadOkay)
        printf("Loading SML configuration failed: %s\n", SML_Config);

    TiXmlHandle hDoc(&doc);
    
    pMission = hDoc.FirstChildElement().Element();

    if(!pMission) 
        printf("No valid root!");

    hRoot = TiXmlHandle(pMission);
    pService = pMission->FirstChildElement();
    int32_t mission_num = 0;
    //Iterate through the missions
    for(pChild0 = pMission->FirstChildElement(); pChild0 ; \
        pChild0 = pChild0->NextSiblingElement()) 
    {
        int32_t service_num = 0;
        uint16_t cond_array[] = {0, 0};
        //printf("mission_num = %d\n", mission_num);
        memset(cond_array, 0, 2);
        
        for(pChild1  = pChild0->FirstChildElement(); pChild1; \
            pChild1  = pChild1->NextSiblingElement()) 
        {
            int32_t conditional_0 = service_num;
            for(pChild2 = pChild1->FirstChildElement(); \
                pChild2; pChild2 = pChild2->NextSiblingElement())
            {
                service_num++;
                int32_t conditional_1 = service_num;
                for(pChild3 = pChild2->FirstChildElement(); \
                    pChild3; pChild3 = pChild3 ->NextSiblingElement())
                {
                    service_num++;
                    mList[mission_num].services[service_num].name = pChild3->Attribute("name");
                    if(pChild3->Attribute("input1"))
                        mList[mission_num].services[service_num].input[0] = pChild3->Attribute("input1");
                    if(pChild3->Attribute("input2"))
                        mList[mission_num].services[service_num].input[1] = pChild3->Attribute("input2");
                    if(pChild3->Attribute("input3"))
                        mList[mission_num].services[service_num].input[2] = pChild3->Attribute("input3");
                    if(pChild3->Attribute("output1"))
                        mList[mission_num].services[service_num].output[0] = pChild3->Attribute("output1");
                    if(pChild3->Attribute("output2"))
                        mList[mission_num].services[service_num].output[1] = pChild3->Attribute("output2");
                    if(pChild3->Attribute("output3"))
                        mList[mission_num].services[service_num].output[2] = pChild3->Attribute("output3");
                    cond_array[1]++;
                }

                if(conditional_1 != service_num){
                    mList[mission_num].services[conditional_1].name = pChild2->Value();
                    if(pChild2->Attribute("input_t"))
                        mList[mission_num].services[service_num].input[0] = pChild2->Attribute("input_t");
                    if(pChild2->Attribute("input_f"))
                        mList[mission_num].services[service_num].input[1] = pChild2->Attribute("input_f");
                }
                else{
                    mList[mission_num].services[conditional_1].name = pChild2->Attribute("name");
                    if(pChild2->Attribute("input1"))
                        mList[mission_num].services[service_num].input[0] = pChild2->Attribute("input1");
                    if(pChild2->Attribute("input2"))
                        mList[mission_num].services[service_num].input[1] = pChild2->Attribute("input2");
                    if(pChild2->Attribute("input3"))
                        mList[mission_num].services[service_num].input[2] = pChild2->Attribute("input3");
                    if(pChild2->Attribute("output1"))
                        mList[mission_num].services[service_num].output[0] = pChild2->Attribute("output1");
                    if(pChild2->Attribute("output2"))
                        mList[mission_num].services[service_num].output[1] = pChild2->Attribute("output2");
                    if(pChild2->Attribute("output3"))
                        mList[mission_num].services[service_num].output[2] = pChild2->Attribute("output3");
                }

                mList[mission_num].services[conditional_1].num_conds = cond_array[1];
                cond_array[1] = 0;
                cond_array[0]++;
            }
            if(conditional_0 != service_num)
                mList[mission_num].services[conditional_0].name = pChild1->Value();
                    if(pChild1->Attribute("input_t"))
                        mList[mission_num].services[service_num].input[0] = pChild1->Attribute("input_t");
                    if(pChild1->Attribute("input_f"))
                        mList[mission_num].services[service_num].input[1] = pChild1->Attribute("input_f");
            else{
                mList[mission_num].services[conditional_0].name = pChild1->Attribute("name");
                if(pChild1->Attribute("input1"))
                    mList[mission_num].services[service_num].input[0] = pChild1->Attribute("input1");
                if(pChild1->Attribute("input2"))
                    mList[mission_num].services[service_num].input[1] = pChild1->Attribute("input2");
                if(pChild1->Attribute("input3"))
                    mList[mission_num].services[service_num].input[2] = pChild1->Attribute("input3");
                if(pChild1->Attribute("output1"))
                    mList[mission_num].services[service_num].output[0] = pChild1->Attribute("output1");
                if(pChild1->Attribute("output2"))
                    mList[mission_num].services[service_num].output[1] = pChild1->Attribute("output2");
                if(pChild1->Attribute("output3"))
                    mList[mission_num].services[service_num].output[2] = pChild1->Attribute("output3");
            }

            mList[mission_num].services[conditional_0].num_conds = cond_array[0];
            //printf("hello\n");
            printf("input1=%s, outpu1=%s\n", mList[mission_num].services[service_num].input[0].c_str(), mList[mission_num].services[service_num].output[0].c_str());
            cond_array[0] = 0;
            service_num++;
        }
        mList[mission_num].numServices = service_num;
        mList[mission_num].name = pChild0->Attribute("name");
        mList[mission_num].missionID = atoi(pChild0->Attribute("id"));
        if(pChild0->Attribute("input1"))
            mList[mission_num].input[0] = pChild0->Attribute("input1");
        if(pChild0->Attribute("input2"))
            mList[mission_num].input[1] = pChild0->Attribute("input2");
        if(pChild0->Attribute("input3"))
            mList[mission_num].input[2] = pChild0->Attribute("input3");
        if(pChild0->Attribute("output1"))
            mList[mission_num].output[0] = pChild0->Attribute("output1");
        if(pChild0->Attribute("output2"))
            mList[mission_num].output[1] = pChild0->Attribute("output2");
        if(pChild0->Attribute("output3"))
            mList[mission_num].output[2] = pChild0->Attribute("output3");
        printf("input1=%s, outpu1=%s\n", mList[mission_num].input[0].c_str(), mList[mission_num].output[0].c_str());
        mission_num++;
    }
}

//Verified w/o Transfers May 26
void
ServiceManagementLayer::RegisterCognitiveEngine(int32_t ID)
{
    SendMessage(shellSocketFD, "register_engine_cognitive");
    LOG("ServiceManagementLayer:: CE registration message forwarded to shell.\n");

    //printf("ServiceManagementLayer:: CE registration message forwarded to shell.\n");

    //TransferRadioConfiguration(ID);
    //TransferExperience(ID);

    numberOfCognitiveEngines++;
    CE_Present = true;
}

void 
ServiceManagementLayer::DeregisterServices(int32_t ID)
{
    char str_buffer[64];
    strcpy(_services_DB->command, "delete ");
    strcat(_services_DB->command, _services_DB->tablename);
    strcat(_services_DB->command, ".* from ");
    strcat(_services_DB->command, _services_DB->tablename);
    strcat(_services_DB->command, " where ");
    strcat(_services_DB->command, "ID_Num");
    strcat(_services_DB->command, "==");
    sprintf(str_buffer, "%d;", ID);
    strcat(_services_DB->command, str_buffer);
    sqlite3_exec(_services_DB->db, _services_DB->command, NULL, 0, NULL);
}


void 
ServiceManagementLayer::DeregisterCognitiveEngine(int32_t ID)
{
    LOG("ServiceManagementLayer:: CE deregistration message forwarded to shell.\n");

    numberOfCognitiveEngines--;
    if(numberOfCognitiveEngines == 0)
        CE_Present = false;

    SendMessage(shellSocketFD, "deregister_engine_cognitive");
    char buffer[256];
    memset(buffer, 0, 256);
    ReadMessage(shellSocketFD, buffer);
    SendMessage(CE_List[ID].FD, buffer);
    if(strcmp("deregister_ack", buffer) != 0) {
        ERROR(1, "SML:: Failed to close CE socket\n");
    }
    CE_List[ID].FD = -1;
    CE_List[ID].ID_num = -1;

    LOG("Cognitive Radio Shell:: Socket closed.\n");
}


//VERIFIED May 21
void
ServiceManagementLayer::StartSMLServer()
{
    struct timeval selTimeout;
    int32_t running = 1;
    int32_t port, rc, new_sd = 1;
    int32_t desc_ready = 1;
    int32_t timeout = 10;
                //If there is, call the MessageHandler with the Shell_Msg code of -1
    fd_set sockSet, shellSet;

    cogEngSrv = CreateTCPServerSocket(2032);
    int32_t maxDescriptor = cogEngSrv;

    if(InitializeTCPServerPort(cogEngSrv) == -1)
        ERROR(1,"Error initializing primary port\n");


    /*int FD = ClientSocket("127.0.0.1", "2013"); 
    SendMessage(FD, "register_engine_cognitive");   
    SendMessage(FD, "register_service");
    SendMessage(FD, "test_srv"); 
    SendMessage(FD, "list_services");
    int FD2 = ClientSocket("127.0.0.1", "2013"); 
    SendMessage(FD2, "register_engine_cognitive");   
    SendMessage(FD2, "register_service");
    SendMessage(FD2, "test_srv1"); 
    SendMessage(FD2, "list_services");*/
     //SendMessage(shellSocketFD, "list_services");*/
    //printf("num = %d, %d, %d\n", one, two, three);
    

    int i = 10000000;
    while (i>0) {
        i--;
        /* Zero socket descriptor vector and set for server sockets */
        /* This must be reset every time select() is called */
        FD_ZERO(&sockSet);
        FD_SET(cogEngSrv, &sockSet);
        for(int k = 0; k < Current_ID; k++)
            FD_SET(CE_List[k].FD, &sockSet);
            //printf("k=%d, CID=%d\n", k, CE_List[k].FD);

        /* Timeout specification */
        /* This must be reset every time select() is called */
        selTimeout.tv_sec = 0;       /* timeout (secs.) */
        selTimeout.tv_usec = 0;            /* 0 microseconds */
        //Changed both to zero so that select will check messages from the shell instead of blocking
        //when there is no command from the CE's to be processed

        //Check if there is a message on the socket waiting to be read
        rc = select(maxDescriptor + 1, &sockSet, NULL, NULL, &selTimeout); 
        //printf("rc=%d\n", rc);
        if(rc == 0){
            //LOG("No echo requests for %i secs...Server still alive\n", timeout);
        
            FD_ZERO(&shellSet);
            FD_SET(shellSocketFD, &shellSet);
            selTimeout.tv_sec = 0;
            selTimeout.tv_usec = 0;
            //Check if there is a message on the shell socket ready to be processed
            int rc2 = select(shellSocketFD + 1, &shellSet, NULL, NULL, &selTimeout);
            //printf("rc2=%d\n", rc2);
                //If there is, call the MessageHandler with the Shell_Msg code of -1
            if(FD_ISSET(shellSocketFD, &shellSet)){
                //printf("shell_msg, %d\n", rc2);
                MessageHandler(-1);}
        }
        else { 
            desc_ready = rc;
            for(port = 0; port <= maxDescriptor && desc_ready > 0; port++) {
                if(FD_ISSET(port, &sockSet)) {
                    desc_ready -= 1;

                    //Check if request is new or on an existing open descriptor
                    if(port == cogEngSrv) { 
        //printf("here1\n");
                       // do {
                            new_sd = AcceptTCPConnection(port);
                         
                            //printf("sd = %d\n", new_sd);
                            if(new_sd < 0) 
                                break;
                            //Set not to block
                            /*int oldflags = fcntl (new_sd, F_GETFL, 0);
                            oldflags |= O_NONBLOCK;
                            fcntl (new_sd, F_SETFL, oldflags);*/

                           
                            CE_List[Current_ID].FD = new_sd;
                            CE_List[Current_ID].ID_num = Current_ID;
                            MessageHandler(Current_ID);
                            Current_ID++;
        
                            FD_SET(new_sd,&sockSet);
                            if(new_sd > maxDescriptor) 
                                maxDescriptor = new_sd;
                            //LOG("New incoming connection - %i\n\n",new_sd);
                       // } while(new_sd != -1);
                    } 
                    else {
                        //printf("here2\n");
                        //LOG("Request on already open descriptor.\n\n");
                        for(int16_t z = 0; z < Current_ID; z++)
                        {
                                if(CE_List[z].FD == port){
                                        //printf("z=%d\n", z);
                                        MessageHandler(z);}
                        }
                    }
                }
            }
        }
    }        

    /* Close sockets */
    close(cogEngSrv);

    //delete &cogEngSrv;
    return;
}