Home    News    Components    Get ViTooKi    Documentation    Community    Developers    @sf.net  

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

Session.cpp

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title:       Session.cpp                                                   *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 * ITEC institute of the University of Klagenfurt (Austria)             *
 * http://www.itec.uni-klu.ac.at                                        *
 *                                                                      *
 *                                                                      *
 * For more information visit the ViTooKi homepage:                     *
 * http://ViTooKi.sourceforge.net                                       *
 * vitooki-user@lists.sourceforge.net                                   *
 * vitooki-devel@lists.sourceforge.net                                  *
 *                                                                      *
 * This file is part of ViTooKi, a free video toolkit.                  *
 * ViTooKi is free software; you can redistribute it and/or             *
 * modify it under the terms of the GNU General Public License          *
 * as published by the Free Software Foundation; either version 2       *
 * of the License, or (at your option) any later version.               *
 *                                                                      *
 * This program is distributed in the hope that it will be useful,      *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of       *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the         *
 * GNU General Public License for more details.                         *
 *                                                                      *
 * You should have received a copy of the GNU General Public License    *
 * along with this program; if not, write to the Free Software          *
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,               *
 * MA  02111-1307, USA.                                                 *
 *                                                                      *
 ***********************************************************************/

 /***********************************************************************
 *                                                                      *
 *  REVISION HISTORY:                                                   *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 ***********************************************************************/

#include "Session.hpp"
#include "ContainerInfo.hpp"
#include "Adaptor.hpp"
#include "RTSP.hpp"
#include "DataChannel.hpp"

#include "../io/Rtp.hpp"
#include "../metadata/TerminalCapabilities.hpp"

Session::Session()
{
        globalTimer=NULL;
        gtRefCount=NULL;
        gtSharedAdapt=NULL;

        sessionControlChannel=-1;
        state=SESSION_ERR;
        termCap=NULL;
        userPref=NULL;
        mp4Stream=NULL;
        suggestedAdaptor=NULL;
        client=NULL;
        prot=NULL;
        
        url=NULL;
        serverID=NULL;
        canAdmitRequest=false;;
};

Session::~Session() {
}

bool Session::sendResponse(const char *str,int bytes)
{
        assert(str && bytes>0);

        if(!str || bytes<=0)
                return false;

        int n=0;
        int total=0;
        bool ret=false;

        dprintf_full("Session::sendResponse: Writing %i bytes: X%sX\r\n",bytes,str);

        while(bytes>0) {
#ifdef WIN32
                n=send(sessionControlChannel,str+total, bytes,0);
#else
                n=send(sessionControlChannel,str+total, bytes,MSG_NOSIGNAL);
#endif
                if(n==-1)
                        break;
                bytes-=n;
                total+=n;
        }
        if(bytes==0)
                ret=true;
        dprintf_full("Session::sendResponse exit, sending %s\r\n",ret?"was ok":"FAILED!");
        return ret;
};

int Session::readRequest(char* str, const int MAX_BYTES)
{
        assert(str && MAX_BYTES>0);

        if(!str || MAX_BYTES<=0)
                return -1;

        int n=0;
        int total=0;
        memset(str,0,MAX_BYTES);

        do {
                // n == 0 if connection closed
                // n < 0 if error
                n=recv(sessionControlChannel, str+total, MAX_BYTES-1-total,0);
                dprintf_full("Session::readRequest: partial %i total %i\r\n",n,total);
                dprintf_full("Session::readRequest:X%sX\r\n",str+total);
                if(n<=0)
                        break;
                total+=n;
        }
        while(n>0 && !(total>3 && str[total-4]=='\r' && str[total-3]=='\n' && 
                                str[total-2]=='\r' && str[total-1]=='\n'));
        
        dprintf_full("Session::readRequest: %i\r\n",total);fflush(stdout);
        return total;
};

void Session::setTerminalCapabilities(TerminalCapabilities* tc) {
                termCap=tc;
};

const TerminalCapabilities* Session::getTerminalCapabilities() const {
                return termCap;
};

int Session::getControlSocket() const {
        return sessionControlChannel;
};

ContainerInfo* Session::getContainerInfo() const {
        return mp4Stream;
};

bool Session::setRtxInfoForES(u32 esId, rtx_info* rtx)
{
        const ESInfo* es=this->mp4Stream->getES(esId);
        if(!es) {
                dprintf("ClientSession::setRtxInfoForES: invalid esId as input\r\n");
                return false;
        }

        rtx_group* grp=new rtx_group(ACK,3000);
        grp->es=es;
        grp->rtx=rtx;
        rtx->mId=rtxInfo.size()+1;
        grp->midESInfo=esId;
        rtxInfo.push_back(grp);
        return true;
};


rtx_group* Session::getRtxGroup(u32 esId)
{
        
        for(    list<rtx_group*>::iterator li=rtxInfo.begin();
        li!=rtxInfo.end(); li++) {
                if(esId==(*li)->es->getStreamId())
                        return *li;
        }
        return NULL;

}

list < rtx_group* >* Session::getAllRtxGroups() {
        return &rtxInfo;
};

KnownProtocols Session::determineProtocol(const char *request)
{
        if (strstr(request, "RTSP/1.0")) {
                assert(!prot);
                prot = new RTSP();
                return PROTO_RTSP;
        }
        if (strstr(request, "HTTP/1.")) {
                assert(!prot);
                //   prot=new HTTP();
                return PROTO_HTTP;
        }
        return PROTO_UNKNOWN;
}

void Session::setDataChannel(DataChannel * dc)
{
    channels.push_back(dc);
};


DataChannel *Session::getDataChannel(int esId)
{
        list < DataChannel * >::const_iterator dcI;
        if (!channels.empty()) {
                dcI = channels.begin();
                while (dcI != channels.end()) {
                        if ((*dcI)->getESInfo()->getStreamId() == (u32) esId) {
                                return (*dcI);
                        }
                        dcI++;
                }
        }
        return NULL;
};

const list < DataChannel * >& Session::getDataChannels() const {
        return channels;
};

Adaptor* Session::getSuggestedAdaptor() { 
        if(suggestedAdaptor) 
                return suggestedAdaptor->clone(); 
        return NULL;
};

const sockaddr_in* Session::getDataSinkInfo() const {
        return client;
};

const Url* Session::getUrl() const {
        return url;
};

© ViTooKi 2003 :: [Lite version] Created with Doxygen