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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

HttpServer.cpp

/***********************************************************************
*                                                                      *
* ViTooKi                                                              *
*                                                                      *
* title: HttpServer.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:                                                   *
*                                                                      *
*                                                                      *
*                                                                      *
***********************************************************************/

/***********************************************************************
* Author: Klaus Schoeffmann                                            *
*         original code by Michael Kropfberger (from Mohican :)        *
************************************************************************/


#include "HttpServer.hpp"


#ifdef WIN32
//dummy implementations
HttpServer::HttpServer(int port, const char *rootdir, const char *cgidir){}
HttpServer::~HttpServer(){}
void HttpServer::stop(){}
char *HttpServer::findExtension(char *uri,char *ext){ return NULL; }
int HttpServer::runCGI(int sock, char *uri, int method, char *body, int body_len){ return -1; }
int HttpServer::sendResource(int sock, char *uri){ return -1; }
void HttpServer::run(){}
#else

/***********************************************************************/
HttpServer::HttpServer(int port, const char *rootdir, const char *cgidir) {
  this->port = port;
  this->rootdir = new char[strlen(rootdir)];
  strcpy(this->rootdir, rootdir);
  this->cgidir = new char[strlen(cgidir)];
  strcpy(this->cgidir, cgidir);
  
  this->shouldBeActive = true;
}


/***********************************************************************/
HttpServer::~HttpServer() {
  stop();
  delete this->rootdir;
  delete this->cgidir;
}


/***********************************************************************/
void HttpServer::stop() {
  this->shouldBeActive = false;
  
  int MAXWAITTIME = 10; //wait a maximum of 10 seconds for mohican to exit!
  struct timeval startTime, currTime;
  gettimeofday(&startTime, NULL);
  
  while (this->active == true) {
    msleep(1);
    gettimeofday(&currTime, NULL);
    if ((currTime.tv_sec - startTime.tv_sec) > MAXWAITTIME) {
      dprintf_full("\nterminating mohican unfriendly");
      close(sock);
      this->active = false;
    }
  }
}


/***********************************************************************/
char *HttpServer::findExtension(char *uri,char *ext) {
  char *u, *e;
  
  u= uri + strlen(uri);
  e= ext + strlen(ext);
  while  ((u-- > uri) && (e-- > ext))
    if (*u != *e)
      return NULL;
  
  return u;
}


/***********************************************************************/
int HttpServer::runCGI(int sock, char *uri, int method, char *body, int body_len) {
  char cgi[MAX_LEN];
  char *query;
  int fdin[2];
  int fdout[2];
  char buf[MAX_LEN];
  int len;
  
  //make script a local ./cgi-bin/bla.sh path (or do a chroot, which might be even better)
  strcpy(cgi,".");
  strcat(cgi, uri);
  
  query=strstr(cgi,"?"); //if no ? is found, NULL is returned!
  //extract the middle part of URI, which is the real script name
  if (query) {
    *query='\0'; //cut off query from cgi-script string
    query++;
  }
  
  dprintf_full("HttpServer::runCGI: script is #%s# query is #%s# body is #%s#, len %i\n",
               cgi, query, body, body_len);
  
  pipe(fdin);
  pipe(fdout);
  
  if (fork() == 0) { //child
    close(fdin[1]); //close writing fd of fdin
    close(fdout[0]); //close reading fd of fdout
    dup2(fdin[0],0); //duplicate stdin fd
    dup2(fdout[1],1); //duplicate stdout fd
    setenv("REQUEST_METHOD",method==METHOD_GET?"GET":"POST",1); // set method GET or POST
    if (query) //GET
      setenv("QUERY_STRING",query,1);
    else {  //POST
      setenv("QUERY_STRING","",1); //set empty
      sprintf(buf,"%i",body_len);
      setenv("CONTENT_LENGTH",buf,1);
    }
    //execl(cgi,cgi,NULL);
    execl(cgi,cgi,NULL);
    //normally never reached
    dprintf_err("HttpServer::runCGI: could not exec %s, errno %i\n",cgi,errno);
    _exit(0);
  }
  
  
  close(fdin[0]); //close reading fd of fdin
  close(fdout[1]); //close writing fd of fdout
  
  //pass POST data
  if (!query){
    write(fdin[1], body, body_len);
    write(fdin[1], "\r\n", 2);
  }
  
  // send "HTTP/1.0 200 OK"
  sprintf(buf,"%s %s\r\n", VERSION,OK);
  write(sock,buf,strlen(buf));
  
  //pass CGI output to client
  while((len=read(fdout[0],buf,MAX_LEN)) != 0) {
    buf[len]='\0';
    //printf("[%i] script says: #%s#",getpid(),buf);
    write(sock,buf,len);
  }
  close(fdout[0]);
  close(fdin[1]);
  close(sock);
  
  return 0;
}



/***********************************************************************/
int HttpServer::sendResource(int sock, char *uri) {
  char cmd[MAX_LEN];
  char buf[MAX_LEN];
  char line[MAX_LEN];
  HttpMimeType type;
  FILE *f;
        long len;
        if (uri[strlen(uri)-1] == '/')
          sprintf(uri,"%s%s",uri,DEFAULT_PAGE);
        
        // make URI absolute to server root
        sprintf(line,"%s/%s",rootdir,uri);
        strcpy(uri,line);
        
        cmd[0]='\0';
        if ( (f = fopen(uri,"r")) == NULL) {
          /* file not found or not accessible */
          dprintf_full("NOT FOUND %s: 404!!!!\n",uri);
          sprintf(line,"%s %s\r\n", VERSION,NOT_FOUND);
          strcat(cmd,line);
          sprintf(uri,"%s/%s",rootdir,ERR404_PAGE);
          if ( (f = fopen(uri,"r")) == NULL) {
            printf("%s",uri);
            perror("");
            return -1;
          }
        } else {
          /* transferring real data */
          sprintf(cmd,"%s %s\r\n", VERSION,OK);
        }
        
        /* calc payload size */
        fseek(f,0,SEEK_END);
        len=ftell(f);
        fseek(f,0,SEEK_SET);
        sprintf(line,"Content-Length: %li\r\n",len);
        strcat(cmd,line);
        
        /* find out Mime type */
        type=mime_unknown;
        if (findExtension(uri,"html") > 0)
          type=mime_html;
        else
        if (findExtension(uri,"txt") > 0)
          type=mime_html;
        else
          if (findExtension(uri,"gif") > 0)
            type=mime_gif;
          else
            if (findExtension(uri,"jpg") > 0)
              type=mime_jpg;
                        else
                                if (findExtension(uri,"mp4") > 0)
                                        type=mime_mp4;
                                else
                                        if (findExtension(uri,"vit") > 0)
                                                type=mime_vit;
                                        else
                                                if (findExtension(uri,"ogg") > 0)
                                                        type=mime_ogg;
                                                else
                                                        if (findExtension(uri,"mkv") > 0)
                                                                type=mime_mkv;
        
        
        sprintf(line,"Content-Type: %s\r\n\r\n",HttpMimeTypeStrings[type]);
        strcat(cmd,line);
        
        //send the header
        if (send(sock,cmd,strlen(cmd),0) < 0) {
          perror("send");
          return -1;
        }
        
        
        //send the payload
        while(!feof(f)) {
          if ((len=fread(buf,1,sizeof(buf),f))<0) {
            perror("data fread");
            return -1;
          }
          if (send(sock,buf,len,0) < 0) {
            perror("data send");
            return -1;
          }
        }
        
        fclose(f);
        return 0;
}


/***********************************************************************/
void HttpServer::run() {
  struct sockaddr_in sin;
  socklen_t len;
  int actlen;
  char buf[MAX_LEN];
  char cmd[MAX_LEN];
  char uri[MAX_LEN];
  int new_sock;
  int method; //either GET or POST
  int isCGI  =  0;
  
  active = true;
  
  if ((sock = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
    perror("init socket");
    _exit(1);
  }
  
  /* local port */
  bzero((char *)&sin, sizeof(sin));
  sin.sin_family = AF_INET;
  sin.sin_addr.s_addr = INADDR_ANY;
  sin.sin_port = htons(port);
  if (bind(sock, (struct sockaddr *)&sin, sizeof(sin)) < 0) {
    perror("init bind");
    _exit(1);
  }
  
  if (listen(sock,0) < 0) {
    perror("listen");
    _exit(1);
  }
  
  fd_set rfds;
  struct timeval tv;
  
  /* big server loop */
  dprintf_full("HttpServer: mohican lives :) ... accepting connections on port %i...\n", port);
  while(this->shouldBeActive) {
    len=sizeof(sin);
    
    FD_ZERO(&rfds);
    FD_SET(sock, &rfds);
    tv.tv_sec = 0;
    tv.tv_usec = 50000;
    int retval = select(sock+1, &rfds, NULL, NULL, &tv);
    if (retval == -1) {
      perror("select");
      _exit(1);
    } else if (retval && FD_ISSET(sock, &rfds)) {
      
      if ((new_sock = accept(sock, (struct sockaddr*)&sin,&len)) < 0) {
        perror("accept");
        _exit(1);
      }
      
      if (fork() ==0) { // child
        /* recv full client request */
        len = 0;
        do {
          if ((actlen=recv(new_sock, buf+len, sizeof(buf)-len,0)) < 0) {
            perror("recv");
            _exit(1);
          }
          len += actlen;
        } while ( (strstr(buf,"\r\n\r\n") == NULL) || (len >= sizeof(buf)));
        
        if (len < sizeof(buf))
          buf[len]='\0';
        else
          buf[sizeof(buf)-1]='\0';
        
        if (strncmp(buf,"GET",3) == 0) {
          method=METHOD_GET;
        } else  if (strncmp(buf,"POST",4) == 0) {
          method=METHOD_POST;
        } else {
          sprintf(cmd,"%s %s\r\n\r\n",VERSION,NOT_IMPL);
          if (send(new_sock,cmd,strlen(cmd),0) < 0) {
            perror("send");
            _exit(1);
          }
        }
        
        if (strstr(buf,"HTTP/1.") != NULL) {
          sscanf(buf,"%*s %s HTTP/1.",uri);
        } else
          strcpy(uri,DEFAULT_PAGE);
        
        char *tmp1 = strstr(buf, cgidir);
        char *tmp2 = strstr(buf, "HTTP/1.");
        //not enough: (cgidir could be included in "Referer:")
        //if (strstr(buf,cgidir) != NULL)
        if (tmp1 != NULL && tmp2 != NULL && tmp1 < tmp2)
          isCGI=1;
        else
          isCGI=0;

        //access logging
        const time_t t = time(NULL);
        struct tm *date = localtime(&t);
        char dc[MAX_STR_LEN];
        //FIXME: to be apache-log conformant, the month shouldnt be a number, but Jan/Feb/Mar/...
        sprintf(dc,"%02i/%02i/%04i:%02i:%02i:%02i +%04li",date->tm_mday,date->tm_mon+1,date->tm_year+1900,
                    date->tm_hour, date->tm_min, date->tm_sec,
                date->tm_gmtoff/60/60*100);
        dprintf_full("HttpServer  ACCESS_LOG: %s - - [%s] \"GET %s HTTP/1.1\"\n",inet_ntoa(sin.sin_addr),dc,uri);
        
        if (isCGI) {
          //cut off headers, keep body
          char *body = strstr(buf,"\r\n\r\n")+4;
          int body_len = len - (body-buf);
          if (runCGI(new_sock,uri,method,body, body_len) != 0)
            dprintf_err("HttpServer::run: some error occured when executing CGI-Script... \n");
        } else
          if (method==METHOD_GET) {
            if (sendResource(new_sock,uri) != 0)
              dprintf_err("HttpServer::run: some error occured when sending content... \n");
          } else {
            dprintf_err("HttpServer::run: Unknown Method or POST on non-CGI-File!! \n");
          }
        
        close(new_sock);
        _exit(0);
      } //fork child
      
      //parent
      close(new_sock);
    }
  } //server while
  close(sock);
  active = false;
}
#endif

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