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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

Url.cpp

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title: Url.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 "Url.hpp"
#include <cstring>
#include <cstdio>
#include "debug.hpp"
#include <assert.h>

#ifndef WINCE
#include <errno.h>
#endif

#include "global.hpp"

#ifndef WIN32
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#else
#include <winsock2.h>
#include <ws2tcpip.h>
#ifndef WINCE
#include <direct.h>
#include <Wspiapi.h>
#endif
#endif

#ifndef NI_MAXHOST
        #define NI_MAXHOST      1025
#endif



Url::Url(const char* url)
{
        serverName=NULL;
        path=NULL;
        protocol=NULL;
        port=0;
        this->url=NULL;

        dprintf_full("Url::Url parsing XXX%sXXX\n",url);
        if(url) {
                const char*     pServerStart=url;
                if(url[0]=='/' || 
                                (strlen(url)>1 && url[1]==':') ||
                                strncmp(url,"file",4)==0 ||
                                strncmp(url,"FILE",4)==0) {
                                        handleLocalFile(url);
                                        return;
                                }

                pServerStart=strstr(pServerStart,"://");
                if(pServerStart) {
                        protocol=new char[pServerStart-url+1];
                        strncpy(protocol,url,pServerStart-url);
                        protocol[pServerStart-url]='\0';
                        toLowerString(protocol);
                        pServerStart+=3;// skip the ://
                }
                else {
                        handleLocalFile(url);
                        return;
                }
                        
                
                const char* pPortStart=pServerStart;
                pPortStart=strchr(pPortStart,':');
                if(pPortStart) {
                        // we have a port
                        // now extract the server name
                        serverName=new char[pPortStart-pServerStart+1];
                        strncpy(serverName,pServerStart,pPortStart-pServerStart);
                        serverName[pPortStart-pServerStart]='\0';
                        
                        pPortStart++; // go after the :
                        
                        if(1!=sscanf(pPortStart,"%i",&port)) {
                                port=-1; //invalid port
                                pPortStart=pServerStart;
                        }       
                        // search for a path after the (optional) port
                        if(!strchr(pPortStart,'/')) {
                                goto resolve;
                        }
                }

                else {
                        pPortStart=pServerStart;
                }
                        
                // to get the servername find a / 
                // if none -> there is no path
                pPortStart=strchr(pServerStart,'/');
                if(!pPortStart && !serverName) {
                        // we have no path
                        serverName=new char[strlen(pServerStart)+1];
                        strcpy(serverName,pServerStart);
                }       else {
                        // we have a path
                        // is it a trivial one -> just one / at end
                        if(strlen(pPortStart)==1  && !serverName) {
                                serverName=new char[strlen(pServerStart)];
                                // remove the /
                                strncpy(serverName,pServerStart,strlen(pServerStart)-1);
                                serverName[strlen(pServerStart)-1]='\0';
                        }       else {
                                if( !serverName ) {
                                        serverName=new char[pPortStart-pServerStart+1];
                                        strncpy(serverName,pServerStart,pPortStart-pServerStart);
                                        serverName[pPortStart-pServerStart]='\0';
                                }
                                // now get the path
                                
                                path=new char[strlen(pPortStart)+1];
                                
                                strcpy(path,pPortStart);
                                // remove \n or spaces from end
                                char* pPath=path+strlen(path)-1;
                                while( (*pPath)==' ' || (*pPath)=='\n' || (*pPath)=='\r') {
                                        *pPath='\0';
                                        pPath--;
                                }
                                if(pPath <= path) {
                                        delete[] path;
                                        path=NULL;
                                }
                        }
                }               

resolve:
        
                /* 
                //depricated gethostbyname+gethostbyaddr
                struct hostent *ipAddr;
                struct in_addr *in_a;
                
                if(serverName) {
                        dprintf_full("Url::Url resolving hostname for #%s#\n",serverName);
                        
                        if ( (ipAddr = gethostbyname(serverName)) == NULL) {
                                dprintf_err("Url::Url gethostbyname of server #%s# failed\n",serverName);
                        } else {
                                dprintf_full("Url::Url resolving hostbyaddr for #%s#\n",serverName);                    
                                in_a = (struct in_addr *) ipAddr->h_addr;
                                if ( (ipAddr = gethostbyaddr((char *) &in_a->s_addr, sizeof(unsigned long),AF_INET)) == NULL) {
                                        dprintf_err("Url::Url gethostbyaddr of server #%s# failed\n",serverName);
                                } else { //set FQDN
                                        delete[] serverName;
                                        serverName = new char[NI_MAXHOST];
                                        strcpy(serverName,ipAddr->h_name);
                                        dprintf_full("Url::constructor real server name: #%s#\n",serverName);
                                }
                        }
                }
                */


                if(serverName) {
                        dprintf_full("Url::Url resolving hostname for #%s#\n",serverName);
                        struct addrinfo ai, *res_ai = NULL;
                        int ret =0;
                        
                        memset(&ai,0,sizeof(struct addrinfo));
                        ai.ai_flags = AI_CANONNAME;
                        ai.ai_family = PF_UNSPEC;
                        ai.ai_socktype = 0;
                        ai.ai_protocol = 0;
                        if ((ret = getaddrinfo(serverName, NULL, &ai, &res_ai)) < 0)
                                {
                                        dprintf_err("ERROR %s\n",gai_strerror(ret));
                                        ::exit(1);
                                }
                        //used for wince (there is no canonname)
                        if (res_ai->ai_canonname != NULL) {
                                delete[] serverName;
                                serverName = new char[strlen(res_ai->ai_canonname)+1];
                                strcpy(serverName, res_ai->ai_canonname);
                        }
                        freeaddrinfo(res_ai);
                        dprintf_full("Url::constructor real server name: #%s#\n",serverName);
                }
                makeUrl();
                
        } //if (url)
}
                
Url::~Url() {
        if(serverName) delete[] serverName;
        if(path) delete[] path;
        if(protocol) delete[] protocol;
        if(url) delete[] url;
};

int Url::getPort() const {
        return port;
}

void Url::setPort(int port) {
        this->port = port;
        makeUrl();
}

const char* Url::getPath() const {
        return path;
};

const char* Url::getFileName() const {
        const char *c;
        if ( !path )
                return NULL;
                
        if ((c=strrchr(path,'/')) == NULL)
                return NULL;
        else {
                if(c==(path+strlen(path)-1)) { // last char is a /
                        return NULL; // no filename present
                }
                if(c[0]=='\\' || c[0]=='/') // absolute Linux&Windows path
                        return c+1;
        }
                return NULL;
};

const char* Url::getServerName() const {
        return serverName;
};      

const char* Url::getProtocol() const {
        return protocol;
};

bool Url::hasPort() const {
        return port>0;
}

bool Url::hasServerName() const {
        return serverName!=NULL;
};

bool Url::hasPath() const {
        return path!=NULL;
};

bool Url::hasProtocol() const {
        return protocol!=NULL;
};

const char* Url::toString() const
{
        return url;
};

void Url::makeUrl() 
{
        int len=20;// max size of itoa(int)+"://"+optional '/' and ":"
        if(!serverName)
                return;
        if(url)
                delete url;
        
        if(protocol && hasPort() && hasPath()) {
                len+=strlen(protocol)+strlen(serverName)+strlen(path);
                url=new char[len];
                len=snprintf(url,len,"%s://%s:%i%s",protocol,serverName,port,path);
        }
        else if(protocol && hasPort() && !hasPath()) {
                len+=strlen(protocol)+strlen(serverName);
                url=new char[len];
                len=snprintf(url,len,"%s://%s:%i/",protocol,serverName,port);
        }
        else if(protocol && !hasPort() && hasPath()) {
                len+=strlen(protocol)+strlen(serverName)+strlen(path);
                url=new char[len];
                if(path[1]==':' && isalpha(path[0]))
                        len=snprintf(url,len,"%s://%s/%s",protocol,serverName,path);
                else
                        len=snprintf(url,len,"%s://%s%s",protocol,serverName,path);
        }
        else if(protocol && !hasPort() && !hasPath()) {
                len+=strlen(protocol)+strlen(serverName);
                url=new char[len];
                len=snprintf(url,512,"%s://%s/",protocol,serverName);
        }
        else if(!protocol && !hasPort() && hasPath()) {
                len+=strlen(path);
                url=new char[len];
                len=snprintf(url,len,"%s",path);
        }
        else
                len=-1;

        if(len<0) {
                dprintf_err("Url::toString: string overflow\n");
                dprintf_small("%s",url);
                delete url;url=NULL;
        }

        dprintf_full("Url::makeUrl %s\n",url);
}


char* Url::transformUrlToLocalFile(const Url* uri)
{
        assert(uri);

        const char* url=uri->toString();
        if(!url)
                return NULL;

        char* nUrl=new char[strlen(url)+1];
        
        for(uint i=0;i<strlen(url);i++) {
                if(isalnum(url[i]) || url[i]=='.')
                        nUrl[i]=url[i];
                else
                        nUrl[i]='_';
        }
        nUrl[strlen(url)]='\0';
        dprintf_full("Url::transformUrl %s to LocalFile %s\r\n",url,nUrl);
        return nUrl;
};
char* Url::transformPathToLocalFile(const Url* uri)
{
        assert(uri);
        const char* url=uri->getPath();
        if(!url)
                return NULL;
        uint i=0;
        if(!isalnum(url[i]))
                url++;

        char* nUrl=new char[strlen(url)+1];

        for(i=0;i<strlen(url);i++) {
                if(isalnum(url[i]) || url[i]=='.')
                        nUrl[i]=url[i];
                else
                        nUrl[i]='_';
        }
        nUrl[strlen(url)]='\0';
        dprintf_full("Url::transformPath %s to LocalFile %s\r\n",url,nUrl);
        return nUrl;
}

bool Url::convertUrlToSocket(const char* serverName, const int port,
        struct sockaddr_in *server,int &outSocket)
{
        if(!serverName)
                return false;
        assert(server);
        if(server==NULL) {
                dprintf_err("Url::convertUrlToSocket: NULL param passed for server\n");
                return false;
        }
        outSocket=::socket(AF_INET,SOCK_STREAM,0);
        
        if(outSocket<0) {
                dprintf_full("Url::convertUrlToSocket: Couldn't create socket for server %s\r\n",serverName);
#ifdef WINCE
                dprintf_full("Url::convertUrlToSocket:: error numer: %d\n", WSAGetLastError());
#endif
                return false;
        }
        struct hostent *ipAddr;
        ipAddr=gethostbyname(serverName);
        if(!ipAddr) {
                dprintf_err("Url::convertUrlToSocket: DNS resolution failed for serverName %s\r\n",serverName);
                return false;
        }
        else {
                dprintf_full("Url::convertUrlToSocket: DNS returned %s for serverName %s\r\n",
                                                                 inet_ntoa( *((struct in_addr*)ipAddr->h_addr)),serverName);
        }

        server->sin_port=htons(port);
        server->sin_addr.s_addr=inet_addr(ipAddr->h_addr);
        //memset(&(server->sin_zero),0,8);
        server->sin_family=AF_INET;
        memcpy((char *)&server->sin_addr, ipAddr->h_addr, ipAddr->h_length);


        if (::connect(outSocket,(struct sockaddr *)(server),sizeof(struct sockaddr)) != 0) {
#ifdef WINCE
                dprintf_full("Url::convertUrlToSocket: Connect Failed for server %s Errno %i\r\n",
                                                                 serverName,WSAGetLastError());
#else
                dprintf_full("Url::convertUrlToSocket: Connect Failed for server %s Errno %i\r\n",
                                                                 serverName,errno); fflush(stdout);

                perror("connect");
#endif

                return false;
        }
        return true;
};
bool Url::isEqual(const Url* uri,bool ignoreServerName) const
{
        if(hasPath() && uri->hasPath() &&
                getServerName() && uri->getServerName()) {
                bool ret=true;
                ret= (strcmp(uri->getPath(),getPath())==0);
                if(!ignoreServerName)
                        ret&=(strcmp(getServerName(),uri->getServerName())==0);
                return ret;
        }

        return false;
};

void Url::toLowerString(char* str)
{
        if(str) {
                for(uint i=0;i<strlen(str);i++) {
                        str[i]=(char)tolower(str[i]);
                }
        }
}

void Url::handleLocalFile(const char* &url)
{
        // valid input: file:// | /dummy/vid.mp4 | e:/ | E:backslash | dummy/test.mp4
        //resolves relative paths to absolute ones
        //also cuts off trailing (back)slash eg. /dummy/vid.mp4/
        
        if(!url)
                return;

        const char* pPathBegin=url;
        pPathBegin=strchr(pPathBegin,'/');
        if(!pPathBegin) {
                pPathBegin=strchr(url,'\\');
        }
        if(!pPathBegin)
                pPathBegin=url;
        // e:/ or e:backslash
        if(pPathBegin && pPathBegin-url==2 && pPathBegin[-1]==':' && isalpha(pPathBegin[-2]))
                pPathBegin-=2;
        // file://
        else if(strncmp(url,"FILE://",7)==0 || strncmp(url,"file://",7)==0)
                pPathBegin=url+7;
        else {
                // else pPathBegin==url for /dummy.mp4 and dummy/test.mp4
                // check for relative path
                if(url[0]=='/' || url[0]=='\\')
                        pPathBegin=url; // probably redundant but better make sure
                else { // invalid relative path, so make absolute path....
                        char *cwd = new char[MAX_STR_LEN];
                        cwd[0] = 0;
#ifndef WIN32
                        assert(getcwd(cwd,MAX_STR_LEN - strlen(url) - 2 )); //if NULL, there was not enough buffer!
#else
#ifdef WINCE
                        GetModuleFileName(NULL, (unsigned short*)cwd, MAX_STR_LEN);
#else
                        assert(_getcwd(cwd,MAX_STR_LEN - strlen(url) - 2 )); //if NULL, there was not enough buffer!
#endif
#endif
                        strcat(cwd,"/");
                        strcat(cwd,url);
                        dprintf_full("Url::handleLocalFile: make absolute file path #%s#\n",cwd);
                        pPathBegin=cwd;
                }
        }
        // protocol is always file
        protocol=new char[5];
        strcpy(protocol,"file");
        // now detect the path end
        const char* pPathEnd=pPathBegin+strlen(pPathBegin);

        
        if(pPathBegin && pPathEnd && pPathEnd-pPathBegin>1) {
                //we have a path
                path=new char[pPathEnd-pPathBegin+2];
                strncpy(path,pPathBegin,pPathEnd-pPathBegin+1);
                path[pPathEnd-pPathBegin+1]='\0';

                // we have a local file, thus we correct all '\' to '/' in the path
                for(uint i=0;i<strlen(path);i++) {
                        if(path[i]=='\\')
                                path[i]='/';
                }
                if ( (path[strlen(path)-1] == '/') ||
                                 (path[strlen(path)-1] == '\\')) //cut off trailing (back)slash
                        path[strlen(path)-1] = '\0';

        }
        serverName=new char[10];
        //strcpy(serverName,"localhost");
        strcpy(serverName,"");
        makeUrl();
}


void Url::doTest()
{
        Url u1("file://e:/test.mp4");
        assert(u1.toString());
        assert(strcmp(u1.getPath(),"e:/test.mp4")==0);
        printf("FileName of %s is %s\n",u1.toString(),u1.getFileName());
        assert(strcmp(u1.getFileName(),"test.mp4")==0);

        Url u2("FILE://e:\\test.mp4");
        assert(u2.toString());
        assert(strcmp(u2.getPath(),"e:/test.mp4")==0);
        assert(strcmp(u2.getFileName(),"test.mp4")==0);

        Url u3("file://e:/dummy/dir/test.mp4");
        assert(u3.toString());
        Url u4("FILE://e:\\dummy\\dir\\test.mp4");
        assert(u4.toString());
        Url u5("test.mp4");
        assert(u5.toString()==NULL);
        Url u6("/test.mp4");
        assert(u6.toString());
        printf("%s\n",u1.toString());
        printf("%s\n",u2.toString());
        printf("%s\n",u3.toString());
        printf("%s\n",u4.toString());
        printf("%s\n",u5.toString());
        printf("%s\n",u6.toString());

        assert(strcmp(u1.toString(),u2.toString())==0);
        assert(strcmp(u3.toString(),u4.toString())==0);
}

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