---

ConnectionFactory.C

Go to the documentation of this file.

#include "ConnectionFactory.h"

string * attemptHeader(BufferedFile * file);
int server(int port); 

ConnectionFactory::ConnectionFactory(BufferedFileFactory * bf,int start) {
        init(bf,start,start+1,start+2,start+3);
}
ConnectionFactory::ConnectionFactory(BufferedFileFactory * bf,int inputPort,int outputPort,int filterPort,int configPort) {
        init(bf,inputPort,outputPort,filterPort,configPort);
}
//Might want to switch to BufferedFiles
bool ConnectionFactory::isThereANewConnection() {
        //tv.tv_sec = 0;
        //tv.tv_usec = 0; //0 milliseconds
        //conn_set = conn;
        //int currCount = select(maxfd+1, &conn_set, NULL, NULL, &tv);
        //return (currCount > 0);
        int newConnections = 0;
        //cerr << "InputBF: "<< inputBF->getFileHandle() << " " << (int)(inputBF) << "\n";
        if (inputBF->readReady()) {
                newConnections++;
        }
        if (outputBF->readReady()) {
                newConnections++;
        }
        if (filterBF->readReady()) {
                newConnections++;
        }
        if (configBF->readReady()) {
                newConnections++;
        }
        return (newConnections > 0);
}

#define MAXHEADERSIZE 4096

string * attemptHeader(BufferedFile * file) {
        char a[MAXHEADERSIZE+1];
        char * data = NULL;
        string work;
        string hStart = "<header>";
        string hClose = "</header>";
        int oldWait = file->getWait();
        string * buff = NULL;
        file->setWait(10000); //10 milliseconds
        //if (file->readReady()) {
        if (file->ready(BUFFER_READ)) {
                        int count = file->Read((char*)a,MAXHEADERSIZE);
                        if (count > 0) {
                                a[count] = '\0'; //Make a legal string
                                work = string(a);
                                int headerStart = work.find("<header>",0);
                                int headerEnd = work.find("</header>",0);
                                if (headerStart!= (int)string::npos && headerEnd != (int)string::npos && headerStart < headerEnd && headerEnd) {
                                        buff = new string(work.substr(headerStart,headerEnd + hClose.size()));
                                        headerEnd = headerEnd+hClose.size();
                                } else {
                                        headerStart = headerEnd = 0;
                                }
                                if (headerEnd < count) {
                                        data = new char[count-headerEnd];
                                        memcpy(data,(char*)a+(headerEnd),count-headerEnd);
                                        file->pushBack(data,count-headerEnd);
                                }
                        }
        }
        file->setWait(oldWait);
        return buff;
}
BufferedFile * ConnectionFactory::acceptAndGetFile(int fdin) {
        struct sockaddr_in clientname;
        int size = sizeof (struct sockaddr);
        int fd = accept(fdin, (struct sockaddr *) &clientname, &(socklen_t)size);
        cerr << "FileDescriptor: " << fd << "\n";
        return bf->getNewBufferedFile(fd);
}
int max(int a, int b) {
        if (a > b) {
                return a;
        }
        return b;
}

        //<header>
        //<name>Sample Program</name>
        //<interleaved>1</interleaved>
        //<rate>44100</rate>
        //<channels>2</channels>
        //<endian>little</endian>
        //<type>short</type>
        //<framesize>4<framesize>
        //</header>

//Connection<T>  *      ConnectionFactory::processConnection(
ConnectionWrap * ConnectionFactory::processConnection()  { //MUST HAVE CALL isThereANewConnection() before!
        BufferedFile * file = NULL;
        string * header = NULL;
        Connection<char> * charConn = NULL;
        Connection<short> * shortConn = NULL;
        Connection<float> * floatConn = NULL;
        Connection<double> * doubleConn = NULL;
        //if (FD_ISSET(configfd,&conn_set)) {
        if (configBF->readReady()) {
                        //file = acceptAndGetFile(configfd);
                        file = acceptAndGetFile(configBF->getFileHandle());
                        ConfigConnection * config = new ConfigConnection(file);
                        ConnectionWrap * wrap = new ConnectionWrap(config,CONFIGCONN);
                        return wrap;
        }
        bool input,output,filter;
        input = output = filter = false;
        string name="";
        //if (FD_ISSET(inputfd,&conn_set)) {
        if (inputBF->readReady()) {
                        file = acceptAndGetFile(inputfd);
                        input = true;
                        name+="input";
        //} else if (FD_ISSET(outputfd,&conn_set)) {
        } else if (outputBF->readReady()) {
                        file = acceptAndGetFile(outputfd);
                        output = true;
                        name+="ouput";
        //} else if (FD_ISSET(filterfd,&conn_set)) {
        } else if (filterBF->readReady()) {
                        file = acceptAndGetFile(filterfd);
                        filter = true;
                        name+="filter";
        } else {
                return NULL;
        }
        char number[12];
        snprintf(number,12,"%d",file->getFileHandle());
        name+=string(number);
        cerr << "FD: " << file->getFileHandle() << "\n";
        header = attemptHeader(file);
        string type = "short";
                if (header!=NULL) {
                        Message * msg = new Message(*header);
                        delete header;
                        TreeNode * node = msg->getTree();
                        try {
                                if (node->existChild("header")) {
                                        node = node->getChild("header");
                                        if (node->existChild("name")) {
                                                name = node->getChild("name")->getValue();
                                        }
                                        if (node->existChild("type")) {
                                                type = node->getChild("type")->getValue();
                                        }
                                }
                        } catch (string * err) {}
                        delete msg;
                }

        //Is there a better way?
        //Connection<T> * out = NULL;
        ConnectionWrap  * wrap = new ConnectionWrap();
        if (input) {
                file->setReadOnly();
        } else if (output) {
                file->setWriteOnly();
        }
        if (type == "short") {
                if (input)       { (shortConn) =  (Connection<short>*)(new InputConnection<short>(file,name)); shortConn->setType("short");}
                else if (output) { (shortConn) =  (Connection<short>*)(new OutputConnection<short>(file,name));shortConn->setType("short");}
                else if (filter) { (shortConn) =  (Connection<short>*)(new FilterConnection<short>(file,name));shortConn->setType("short");}
                //return new ConnectionWrap(shortConn,SHORTCONN);
                wrap->type = SHORTCONN; 
                wrap->conn.shortConn = shortConn;
        } else if (type == "byte") {
                if (input)       { (charConn) =  (Connection<char>*)(new InputConnection<short>(file,name)); charConn->setType("byte");}
                else if (output) { (charConn) =  (Connection<char>*)(new OutputConnection<short>(file,name));charConn->setType("byte");}
                else if (filter) { (charConn) =  (Connection<char>*)(new FilterConnection<short>(file,name));charConn->setType("byte");}
                //return new ConnectionWrap(charConn,CHARCONN);
                wrap->type = CHARCONN; 
                wrap->conn.charConn = charConn;
        } else if (type == "float") {
                if (input)       { (floatConn) =  (Connection<float>*)new InputConnection<short>(file,name); floatConn->setType("float");}
                else if (output) { (floatConn) =  (Connection<float>*)new OutputConnection<short>(file,name);floatConn->setType("float");}
                else if (filter) { (floatConn) =  (Connection<float>*)new FilterConnection<short>(file,name);floatConn->setType("float");}
                //return new ConnectionWrap(floatConn,FLOATCONN);
                wrap->type = FLOATCONN; 
                wrap->conn.floatConn = floatConn;
        } else if (type == "double") {
                if (input)       { (doubleConn) = (Connection<double>*) new InputConnection<short>(file,name); doubleConn->setType("double");}
                else if (output) { (doubleConn) = (Connection<double>*) new OutputConnection<short>(file,name);doubleConn->setType("double");}
                else if (filter) { (doubleConn) = (Connection<double>*) new FilterConnection<short>(file,name);doubleConn->setType("double");}
                //return new ConnectionWrap(doubleConn,DOUBLECONN);
                wrap->type = DOUBLECONN; 
                wrap->conn.doubleConn = doubleConn;
        }
        if (wrap == NULL || wrap->conn.voidStar == NULL) {
                return NULL;
        }
        return wrap;
}//Changed from interface

void ConnectionFactory::init(BufferedFileFactory * bff,int inputPort,int outputPort,int filterPort,int configPort) {
        if (inputPort) {
                inputfd  = server(inputPort);
        }
        if (outputPort) {
                outputfd = server(outputPort);
        }
        if (filterPort) {
                filterfd = server(filterPort);
        }
        if (configPort) {
                configfd = server(configPort);
        }
        //FD_ZERO (&conn);
        //FD_ZERO (&conn_set);
        //FD_SET (inputfd, &conn);
        //FD_SET (outputfd, &conn);
        //FD_SET (filterfd, &conn);
        //FD_SET (configfd, &conn);
        //maxfd = max(inputfd,max(outputfd,max(filterfd,configfd)));
        bf = bff;
        if (inputPort) {
                inputBF  = bf->getNewBufferedFile(inputfd);
                inputBF->setReadOnly();
        } else {
                inputBF  = new BufferedFile(-1);
        }
        if (outputPort) {
                outputBF = bf->getNewBufferedFile(outputfd);
                outputBF->setReadOnly();
        } else {
                outputBF = new BufferedFile(-1);
        }
        if (filterPort) {
                filterBF = bf->getNewBufferedFile(filterfd);
                filterBF->setReadOnly();
        } else {
                filterBF = new BufferedFile(-1);
        }
        if (configPort) {
                configBF = bf->getNewBufferedFile(configfd);
                configBF->setReadOnly();
        } else {
                configBF = new BufferedFile(-1);
        }
}

int server(int port) {
        int serverfd;
        struct sockaddr_in serveraddr;
        serverfd = socket(AF_INET,SOCK_STREAM,0);
        bzero(&serveraddr,sizeof(serveraddr));
        serveraddr.sin_family = AF_INET;
        serveraddr.sin_port = htons(port);
        serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
        bind(serverfd, (struct sockaddr *)&serveraddr,sizeof(serveraddr));
        listen(serverfd,30);
        fprintf(stderr,"Waiting for connection on port %d\n",port);
        return serverfd;
}
ConnectionFactory::~ConnectionFactory() {
        inputBF->Close();
        outputBF->Close();
        filterBF->Close();
        configBF->Close();
        delete inputBF;
        delete outputBF;
        delete filterBF;
        delete configBF;
}

---