---

http.c

Go to the documentation of this file.

/***************************************************************************
                                  http.c
                             -------------------
    begin                : Fri Nov 23 2001
    copyright            : (C) 2001-2002 by Christian Hoenig & Gunter Ohrner
    email                : pdepp@CustomCDROM.de
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program 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.                                   *
 *                                                                         *
 ***************************************************************************/

#include "common.h"

#include <ctype.h>
#include <errno.h>
// logger.h includes stdio.h for us. Even more importantly it includes stdarg.h
// BEFORE including stdio.h which avoids tons of warnings on Solaris... :-(
#include <stdlib.h>
#include <string.h>
#ifdef TM_IN_SYS_TIME
# include <sys/time.h>
#else
# include <time.h>
#endif
#include <unistd.h>

#include "logger.h"
#include "http.h"

#include "buffer.h"
#include "bufplist.h"
#include "conftable.h"
#include "conn_handler.h"
#include "misc.h"
#include "reqhandler_file.h"
#include "xmalloc.h"


int reply_server_name;


enum Method     {MUNKNOWN, GET, HEAD, POST};
enum HttpVer    {VUNKNOWN, V09, V10, V11};
enum Encoding   {EUNKNOWN, IDENTITY, GZIP, COMPRESS};
enum Connection {CUNKNOWN, CLOSE, KEEPALIVE};


struct Uri
{
  char* server; 
  int port;     
  char* path;   
  int valid;    
};

struct HttpRequestHdr
{
  enum Method     mthd;             
  enum HttpVer    ver;              
  struct Uri      uri;              

  enum Encoding   content_encoding; 
  time_t          if_mod_since;     
  char*           from;            
  char*           usr_agent;       
  struct Uri      referer;          
  enum Connection connection;       
  //NOT IMPLEMENTED
  //char*         authorisation;   ///< credentials
};



struct HttpProtHandler
{
  ConnHandler       parent;         
  ReqHandlerFile    rh_file;        
  int               status;         
  int               entity_available; 
                                    // we cannot use status to determine this as
                                    // we will have an error message to send
                                    // in case of an error if we can find one.
  BufpList          hdr_list;       

  // line buffer state
  struct Buffer line_buf;           
  ssize_t last_cr_pos;              
  int newline;                      

  struct HttpRequestHdr req_hdr;    
  int header_read;                  
  int method_read;                  

  int header_sent;                  

  int data_pending;                 
  int error;                        
};


// some internal functions:
int          htRecvLine(HttpProtHandler this, const char* str);
int          copyRequestLine(HttpProtHandler this, struct Buffer* buf);
int          htMthdParse(HttpProtHandler this, const char* str);
int          htAddData(struct HttpRequestHdr* hdr, const char* str);
struct Uri   resolvURI(const char* str);
const char*  getStatusAsText(HttpProtHandler this);
int          buildBasicHeader(HttpProtHandler this);
int          buildEntityHeader(HttpProtHandler this);
int          appendHdrField(BufpList hdr_list, char* prefix, char* data);
int          err2Status(int err);


// pre-initialize constant values 
int htModulePreInit()
{
  if (strcmp(getEntryDefl(CONFENTRY_KEY_REPLYSERVERNAME,
                          STD_CONFENTRY_VAL_REPLYSERVERNAME),
                          CONFENTRY_VAL_TRUE) == 0)
  {
    reply_server_name = true;
  }

  return 0;
}

// clean up
int htModuleTerminate()
{
  return 0;
}


// initialize protocol handler
HttpProtHandler htInit(ConnHandler parent)
{
  HttpProtHandler this = (HttpProtHandler) pd_malloc(sizeof(struct HttpProtHandler));
  memset(this, 0, sizeof(struct HttpProtHandler));
  this->parent = parent;
  //set status initially to OK
  this->status = 200;
  this->entity_available = false;
  this->hdr_list = bufpListInit();
  
  this->line_buf = bufInit((char*) pd_malloc(256), 256, 0);

  return this;
}


// receive a block of data
int htReceive(HttpProtHandler this, struct Buffer buf)
{
  if (this->header_read == false) // parse http header
  {
    while (copyRequestLine(this, &buf) == 0        // read complete line?
           && this->error == E_SUCCESS             // no error occured?
           && this->header_read == false)          // still in header?
    {
      // there is some header data
      htRecvLine(this, this->line_buf.data);
      this->line_buf.pos = 0;
    }
    // if still in header, reset receive buffer
    if (this->header_read == false)
      this->last_cr_pos -= buf.len;
    else
    {
    }
  }

  return (this->error == E_SUCCESS) ? 0 : -1;
}


// process a request to send some data
int htSend(HttpProtHandler this, struct Buffer** buf)
{
  if (this->header_sent != true)
  { // send our data first

    *buf = bufpListGetPayload(this->hdr_list);
    bufpListNext(this->hdr_list);

    // is the header completely send?
    if (bufpListIsTail(this->hdr_list) == true)
    {
      this->header_sent = true;
      // If we have no entity to send we must keep our data_pending true
      // to reenter this function and signal that we're finished.
      this->data_pending = (this->entity_available) ? false : true;
    }
  }
  else
  {   // send our children's data
    if (this->req_hdr.mthd == HEAD)
    {
      pd_free((*buf)->data);
      (*buf)->data = NULL;
    }
    else if (rhfIsDataPending(this->rh_file) == true)
      rhfSend(this->rh_file, buf);
  }
  return 0;
}


// process some data, that's a NOOP in this request handler
int htProcess(HttpProtHandler this)
{
  // i have nothing to do, but give my child the chance to do smth
  if (this->rh_file == NULL)
    return 0;
  else
    return rhfProcess(this->rh_file);
}


// tell the connection handler if there is any data waiting to be sent,
int htIsDataPending(HttpProtHandler this)
{
  return (this->data_pending
          || ((this->rh_file != NULL) ? rhfIsDataPending(this->rh_file) : 0));
}


// destroy object and free all allocated ressources
int htTerminate(HttpProtHandler this)
{
  if (this == NULL) return -1;
  //terminate the underlying handler
  rhfTerminate(this->rh_file);

  //free items of hdr_list
  bufpListFirst(this->hdr_list);
  while(!bufpListIsTail(this->hdr_list))
  {
    struct Buffer* buf = bufpListGetPayload(this->hdr_list);
    pd_free(buf->data);
    pd_free(buf);
    bufpListDelete(this->hdr_list);
  }
  bufpListTerminate(this->hdr_list);

  //free all allocated memory
  pd_free(this->line_buf.data);
  pd_free(this->req_hdr.uri.server);
  pd_free(this->req_hdr.uri.path);
  pd_free(this->req_hdr.from);
  pd_free(this->req_hdr.usr_agent);
  pd_free(this->req_hdr.referer.server);
  pd_free(this->req_hdr.referer.path);

  //kill myself ... good bye
  pd_free(this);

  return 0;
}

// return the last error noticed
int htGetError(HttpProtHandler this)
{
  return this->error;
}


//internal procedures:

int htRecvLine(HttpProtHandler this, const char* line)
{
  // If we cannot find a customized-error-message file we fall back to a hardcoded
  // which we will store here.
  char* err_msg_data = NULL;

  //do we have to process the header?
  if (this->header_read == false)
  {
    //check if empty line is found (= end of header)
    if (*line == '\0')
      this->header_read = true;
    else
    {
      //is the method line read? else we can add additional lines of the request
      if (this->method_read == false)
      {
        memset(&this->req_hdr, 0, sizeof(struct HttpRequestHdr));
        if (htMthdParse(this, line) >= 0)
        {
          //no error occured and we are done
          this->method_read = true;
          // is this a HTTP/0.9 call?
          if (this->req_hdr.ver == V09)
            this->header_read = true;
        }
      }
      else
        //read more information:
        htAddData(&this->req_hdr, line);
    }
  }

  //the header is read completely, so we can start handling the file
  if (this->header_read == true)
  {
    // rh_file not existing?
    if(this->rh_file == NULL)
    {
      //we can only process GET and HEAD (if prot ver > 0.9 !) here
      if (this->req_hdr.mthd == GET
          || (this->req_hdr.mthd == HEAD && this->req_hdr.ver != V09))
      {
        int err;
        // we init the file and check if an error occured...
        this->rh_file = rhfInit(this, this->req_hdr.uri.path, true);

        if ((err = rhfGetError(this->rh_file)) == E_SUCCESS)
        {
          // everything went ok
          this->entity_available = true;
        } else
          // Error! We find out, what happened.
          this->status = err2Status(err);

        //check for If-Modified-Since
        if (this->status == 200 && this->req_hdr.if_mod_since != 0)
        {
          if (difftime(this->req_hdr.if_mod_since, rhfGetModTime(this->rh_file)) >= 0)
            //Not Modified
            this->status = 304;
        }
        
      }
      else
      { //the method could not be handled yet (mthd != GET, HEAD)
        if (this->req_hdr.mthd == MUNKNOWN
            || (this->req_hdr.mthd == HEAD && this->req_hdr.ver == V09))
            //a bad request!
          this->status = 400;
        else
          //unknown
          this->status = 501;
      }

      // we can not handle the file if not all OK, so we answer with an error!
      if (this->status != 200)
      {
        char errfile[9]; // "404.html"
        
        // rh_file is terminated, and we can init a new one containing the error
        if (this->rh_file != NULL)
          rhfTerminate(this->rh_file);
        snprintf(errfile, 9, "%d.html", this->status);
        this->rh_file = rhfInit(this, errfile, false);
        
        if (rhfGetError(this->rh_file) != E_SUCCESS)
        {
          char errmsg[] = "<html>"
                          "<head><title>Error %d while processing request</title></head>"
                          "<body>Error %d occured while processing your request.</body>"
                          "</html>";
          err_msg_data = (char*) pd_malloc(strlen(errmsg)+3);
          sprintf(err_msg_data, errmsg, this->status, this->status);
          // There is no body that could be used to create an entity header. :-(
          this->entity_available = false;
        }
        else
        {
          // we change the method to GET, so that the error file is shown
          if (this->req_hdr.ver == V09)
            this->req_hdr.mthd = GET;
          this->entity_available = true;
        }
      }
    }

    // there is no header in V09 ;-)
    if (this->req_hdr.ver == V09 )
    {
      if (err_msg_data == NULL)
        this->header_sent = true;
    }
    else
    {
      //builds the basic header used in all answers
      buildBasicHeader(this);

      if (this->entity_available /* this->status == 200 */
          && (this->req_hdr.mthd == GET || this->req_hdr.mthd == HEAD))
      {
        buildEntityHeader(this);
      }

      if (err_msg_data == NULL)
      {
        // terminate header by adding "\r\n"
        appendHdrField(this->hdr_list, NULL, NULL);
      } else {
        // add our hard coded error message
        appendHdrField(this->hdr_list, "Content-Type", "text/html");
        appendHdrField(this->hdr_list, NULL, NULL);
//        if (this->req_hdr.mthd == GET)
//          appendHdrField(this->hdr_list, NULL, err_msg_data);
//        // Ok, there is no file that could be read...
//        this->req_hdr.mthd = HEAD;
//        pd_free(err_msg_data);
      }
//      // reset header line list
//      bufpListFirst(this->hdr_list);
    }

    // Do we have to send the hard coded error message?
    if (err_msg_data != NULL)
    {
      if (this->req_hdr.mthd == GET || this->req_hdr.ver == V09)
        appendHdrField(this->hdr_list, NULL, err_msg_data);
      // Ok, there is no file that could be read...
      this->req_hdr.mthd = HEAD;
      pd_free(err_msg_data);
    }

    // reset header line list
    bufpListFirst(this->hdr_list);

    //we have somthing for parent (the header!)
    this->data_pending = true;
  }
  return 0;
}


int copyRequestLine(HttpProtHandler this, struct Buffer* buf /*size_t recv_data_len*/)
{
  int real_newline = 0;
  size_t last_lf_pos;

  for (; buf->pos < buf->len; ++buf->pos)
  {
    char cur_chr = *(buf->data + buf->pos);
    // rest of the previous line?
    if (this->newline && cur_chr != ' ') break;
    switch(cur_chr)
    {
    case '\n':
      last_lf_pos = buf->pos;
      if (this->last_cr_pos == (ssize_t) buf->pos-1) this->newline = 1;
      break;
    case '\r':
      this->last_cr_pos = buf->pos;
      break;
    default:
      *(this->line_buf.data + this->line_buf.pos++) = cur_chr;
      // line buffer full?
      if (this->line_buf.pos == this->line_buf.len)
      {
        char* new_buf = pd_realloc(this->line_buf.data, this->line_buf.len+=1024);
        if (new_buf == NULL)
        {
          logerr(PROT_HANDLER, CRITICAL, ENOMEM, "out of memory");
          exit(EXIT_FAILURE);
        }
        this->line_buf.data = new_buf;
      }
    }
  }
//  If the end of recv_buf is NOT yet reached but this->newline is set,
//   we found the end of a logical line. An empty line is ALWAYS a
//   complete logical line itself.
  
  if (buf->pos != buf->len                // newline with trailing non-space
      || (this->line_buf.pos == 0  && this->newline == true) // empty line
      || (this->method_read == false && this->newline == true)) // first line read (method)
  {
    this->newline = false;
    real_newline = true;
  }
  else
    real_newline = false;

  // terminate line buffer after the end of a logical line
  if (real_newline) *(this->line_buf.data + this->line_buf.pos) = '\0';

  return real_newline ? 0 : -1;
}


#define MKHTTPRESPONSE_TIME_BUF_LEN 30

// 0 on success, -1 on failure
char* timetToStr(time_t t, struct Buffer* time_buf)
{
  size_t time_str_len;

  time_str_len = strftime(time_buf->data, time_buf->len,
                           "%a, %d %b %Y %H:%M:%S GMT", gmtime(&t));
  
  return (time_str_len == 0) ? "" : time_buf->data;
}

time_t strToTimet(const char* str)
{
  time_t time;
  struct tm t;
  int offset = 0;

  //init t
  memset(&t, 0, sizeof(struct tm));

  //"remove" leading spaces
  while (isspace((int) *(str+offset)))  offset++;

  //convert rfc1123 conform timestring
  if (strptime(str+offset, "%a, %d %b %Y %T GMT", &t) != NULL) ;
  //convert rfc850 conform timestring
  else if(strptime(str+offset, "%a, %d-%m-%Y %T GMT", &t) != NULL);
  //convert asctime conform timestring
  else if(strptime(str+offset, "%a %b %d %T %Y", &t) != NULL);
    else
    {
      logger(PROT_HANDLER, WARNING, "A time-string could not be handled (strptime)");
      return -1;
  }
  //convert tm to time_t
  if ((time = mktime(&t)) < 0)
  {
    logger(PROT_HANDLER, WARNING, "A time-string could not be handled (mktime)");
    return -1;
  }
  //since mktime converts t to localtime, i have to reconvert it to GMT
  //using the global variable timezone (not available on BSD, so we use the field tm_gmtoff)!
#ifdef HAVE_STRUCT_TM_GMTOFF
  // this one is a BSD extension but we like it :-)
  time += t.tm_gmtoff;
#else
  // this one is documented in the GNU man pages
  time -= timezone;
  // a detail which is NOT documented: timzone counts position west of GMT to have
  // positive offsets, exactly the opposite of what the BSD function does...
#endif
  
  return time;
}

int buildBasicHeader(HttpProtHandler this)
{
  struct Buffer* hdr_field;
  char time_buf[MKHTTPRESPONSE_TIME_BUF_LEN];
  const char* tmp_chr;
  struct Buffer* tmp_buf;
  time_t tmp_time = time(NULL);
  size_t len;

  // status line: HTTP/1.0 %d %s\r\n
  // HTTP/1.0 + Whitespaces + return code + text
  tmp_chr = getStatusAsText(this);
  len = 4 + 1 + 3 + 2 + 3 + strlen(tmp_chr) + 2 + 1;
  hdr_field = bufpInit((char*) pd_malloc(len), len-1, 0);
  snprintf(hdr_field->data, len, "HTTP/1.0 %d %s\r\n", this->status, tmp_chr);
  bufpListAppend(this->hdr_list, hdr_field);

  // Date: %s
  //         vv includes trailing 0 vv
  len = 6 + MKHTTPRESPONSE_TIME_BUF_LEN + 2;
  hdr_field = bufpInit((char*) pd_malloc(len), len-1, 0);
  tmp_buf = bufpInit(time_buf, MKHTTPRESPONSE_TIME_BUF_LEN, 0);
  snprintf(hdr_field->data, len, "Date: %s\r\n", timetToStr(tmp_time, tmp_buf));
  pd_free(tmp_buf);
  bufpListAppend(this->hdr_list, hdr_field);

  // Server: %s
  if (reply_server_name)
  {
    len = 6 + 2 + strlen(SERVERNAME_NSP) + 1 + strlen(SERVERVERSION_NSP) + 2 + 1;
    hdr_field = bufpInit((char*) pd_malloc(len), len-1, 0);
    snprintf(hdr_field->data, len, "Server: %s/%s\r\n", SERVERNAME_NSP, SERVERVERSION_NSP);
    bufpListAppend(this->hdr_list, hdr_field);
  }

  // Connection: close
  len = 17 + 2 + 1; //= strlen("Connection: close") + 2 + 1;
  hdr_field = bufpInit((char*) pd_malloc(len), len-1, 0);
  snprintf(hdr_field->data, len, "%s", "Connection: close\r\n");
  bufpListAppend(this->hdr_list, hdr_field);

  return 0;
}

int buildEntityHeader(HttpProtHandler this)
{
  //Allow: (...)
  struct Buffer buf;
  buf.data = (char*)rhfGetAllow(this->rh_file);
  appendHdrField(this->hdr_list, "Allow", buf.data);

  //Content-Type: (...)
  buf.data = (char*)rhfGetContentType(this->rh_file);
  if (buf.data != NULL)
    appendHdrField(this->hdr_list, "Content-Type", buf.data);

  //Content-Length: xx
  buf.data = (char*) pd_malloc(100);
  snprintf(buf.data, 100, "%u", rhfGetSourceSize(this->rh_file));
  appendHdrField(this->hdr_list, "Content-Length", buf.data);
  pd_free(buf.data);

  //Last-Modified: (...)
  buf.len = MKHTTPRESPONSE_TIME_BUF_LEN;
  buf.data = (char*) pd_malloc(buf.len);
  timetToStr(rhfGetModTime(this->rh_file), &buf);
  appendHdrField(this->hdr_list, "Last-Modified", buf.data);
  pd_free(buf.data);

  return 0;
}

int appendHdrField(BufpList hdr_list, char* prefix, char* data)
{
  struct Buffer* buf = (struct Buffer*) pd_malloc(sizeof(struct Buffer));
  size_t prefix_len;

  buf->pos = 0;
  if (prefix == NULL && data == NULL)
  {
    buf->len = 2;
    buf->data = (char*) pd_malloc(buf->len+1);
  }
  else if (data == NULL)
    return -1;
  else
  {
    if (prefix == NULL)
    {
      prefix_len = 0;
      buf->len = strlen(data) + 2;
      buf->data = (char*) pd_malloc(buf->len+1);
    } else {
      prefix_len = strlen(prefix);
      //                    ":<sp>"            "\r\n"
      buf->len = prefix_len + 2 + strlen(data) + 2;
      buf->data = (char*) pd_malloc(buf->len+1);
      strcpy(buf->data, prefix);
      //divide prefix and data by ": "
      buf->data[prefix_len++] = ':';
      buf->data[prefix_len++] = ' ';
    }
    strcpy(buf->data + prefix_len, data);
  }
  //delimit the line
  buf->data[buf->len - 2] = '\r';
  buf->data[buf->len - 1] = '\n';
  buf->data[buf->len - 0] = '\0';

  //append HdrFiled to the hdr_list
  bufpListAppend(hdr_list, buf);

  return 0;
}

int htMthdParse(HttpProtHandler this, const char* str)
{
  int beg = 0;
  int end = 0;
  int crlf = 0;

  //Parsing of header...
  //...first the method...
  if ((crlf = getNextValue(&beg, &end, end, str)) != 0)
    this->status = 400;
  else
  {
    //the only methods wo know as HTTP/1.0 - server
    if ((strncmp(str+beg, "GET", end-beg+1) == 0) && ((end-beg+1) == (int)strlen("GET")))
      this->req_hdr.mthd = GET;
    else if ((strncmp(str+beg, "HEAD", end-beg+1) == 0) && ((end-beg+1) == (int)strlen("HEAD")))
      this->req_hdr.mthd = HEAD;
    else if ((strncmp(str+beg, "POST", end-beg+1) == 0) && ((end-beg+1) == (int)strlen("POST")))
      this->req_hdr.mthd = POST;
    else
    {
      this->req_hdr.mthd = MUNKNOWN;
      //bad request
      this->status = 400;
    }
  }

  //...then URI...
  if((crlf = getNextValue(&beg, &end, end+1, str)) != 0)
    this->status = 400;
  else
  {
    char* tmp = pd_malloc(end-beg+2);

    strncpy(tmp, str+beg, end-beg+1);
    *(tmp+end-beg+1) = '\0';
    this->req_hdr.uri = resolvURI(tmp);

    pd_free(tmp);
  }

  //...and at last HTTP Version
  if((crlf = getNextValue(&beg, &end, end+1, str)) != 0)
      this->req_hdr.ver = V09;
  else
  {
    if (strncmp(str+beg,"HTTP/0.9",end-beg+1) == 0  && ((end-beg+1) == 8))
      this->req_hdr.ver = V09;
    else if (strncmp(str+beg,"HTTP/1.0",end-beg+1) == 0  && ((end-beg+1) == 8))
      this->req_hdr.ver = V10;
    else if (strncmp(str+beg,"HTTP/1.1",end-beg+1) == 0  && ((end-beg+1) == 8))
      this->req_hdr.ver = V11;
    else
      this->req_hdr.ver = VUNKNOWN;
  }
  return (this->status == 200) ? 0 : -1;
}

int htAddData(struct HttpRequestHdr* hdr, const char* str)
{
  char* pos = strchr(str, ':');
  char* datpos = pos+1;
  while(isspace((int) *datpos))
    datpos++;

  if (hdr == NULL) return -2;

  if (pos - str < (int)strlen(str))
  {
//    NOT IMPLEMENTED
//    if (strncmp(str,"Authorisation:",pos-str) == 0)
//    { }
//    else
    if (strncmp(str,"From:",pos-str) == 0)
    {
      hdr->from = (char*)pd_malloc(strlen(str)-(datpos-str)+1);
      strcpy(hdr->from, datpos);
    }
    else if (strncmp(str,"If-Modified-Since:",pos-str) == 0)
    {
      hdr->if_mod_since = strToTimet(pos+1);
    }
    else if (strncmp(str,"Referer:",pos-str) == 0)
    {
      hdr->referer = resolvURI(pos+1);
    }
    else if (strncmp(str,"User-Agent:",pos-str) == 0)
    {
      hdr->usr_agent = (char*)pd_malloc(strlen(str)-(datpos-str)+1);
      strcpy(hdr->usr_agent, datpos);
    }
    else if (strncmp(str,"Host:",pos-str) == 0)
    {
      struct Uri tmpuri;
      char* http = "http://";
      size_t len_http = 7; //= strlen("http://");
      char* tmp = pd_malloc(strlen(str)-(datpos-str)+len_http+1);

      strcpy(tmp, http);
      strcat(tmp, datpos);

      tmpuri = resolvURI(tmp);

      if (tmpuri.valid)
      {
        if (hdr->uri.server != NULL)
          pd_free(hdr->uri.server);
        hdr->uri.server = tmpuri.server;
        hdr->uri.port = tmpuri.port;
      }
      
      pd_free(tmpuri.path);
      pd_free(tmp);
    }
  }
  return 0;
}

const char* getStatusAsText(HttpProtHandler this)
{
  switch(this->status)
  {
  case(200): return "OK";
  case(201): return "Created";
  case(202): return "Accepted";
  case(204): return "No Content";
  case(301): return "Moved Permanently";
  case(302): return "Moved Temporarily";
  case(304): return "Not Modified";
  case(400): return "Bad Request";
  case(401): return "Unauthorized";
  case(403): return "Forbidden";
  case(404): return "Not Found";
  case(500): return "Internal Server Error";
  case(501): return "Not Implemented";
  case(502): return "Bad Gateway";
  case(503): return "Service Unavailable";
  default:   return "Unknown";
  }
}

struct Uri resolvURI(const char* pstr)
{
  struct Uri uri;
  size_t pos = 0;
  size_t len_http = 7; // = strlen("http://");

  //"remove" leading space
  int offset = 0;
  //temporary string!
  char* str = (char*)pd_malloc(strlen(pstr)+1);

  uri.valid = true;

  while (isspace((int) *(pstr+offset)))
    offset++;
  strcpy(str, pstr+offset);
  //and go on with temporary string "str"

  if (strncmp(str, "http://", len_http) == 0)
  { //absolute path found
    pos += len_http;
    //walk thru chars until a non valid one (domain) is found
    while ((isalnum((int) *(str+pos))
        || *(str+pos) == '.' || *(str+pos) == '_' || *(str+pos) == '-')
        && pos < strlen(str))
      pos++;

    if (pos == strlen(str))
    { // found the end, no url given, no port
      uri.path = pd_malloc(2);
      strcpy(uri.path, "/");
      uri.server = pd_malloc(strlen(str)-len_http);
      strcpy(uri.server, str+len_http);
      uri.port = 0;
    }
    else if (*(str+pos) == ':')
    { //found a port, check the following port
      size_t oldpos = pos++;

      //chk for port
      while(isdigit((int) *(str+pos)) && pos < strlen(str))
        pos++;

      if (pos == strlen(str))
      { // found the end, no url, but port
        uri.path = pd_malloc(2);
        strcpy(uri.path, "/");
        uri.server = pd_malloc(oldpos-len_http+1);
        strncpy(uri.server, str+len_http, oldpos-len_http);
        *(uri.server+oldpos-len_http-1+1) = '\0';
      }
      else
      { //found port, url and server
        uri.path = pd_malloc(strlen(str)-pos+1);
        strcpy(uri.path, str+pos);

        uri.server = pd_malloc(oldpos-len_http+1);
        strncpy(uri.server, str+len_http, oldpos-len_http);
        *(uri.server+oldpos-len_http-1+1) = '\0';
      }

      //only ':' without given port (-> stdport is used)
      if (pos == oldpos+1)
        uri.port = 0;
      else
      {   //get the port
        char* tmp = pd_malloc(pos - oldpos);

        strncpy(tmp, str+oldpos+1, pos-oldpos-1);
        *(tmp+pos-oldpos-1) = '\0';
        uri.port = atoi(tmp);
        pd_free(tmp);

        if (uri.port < 1 || uri.port > 65535)
          uri.port = 0;
      }
    }
    else
    { // found no port, but server and url
      uri.path = pd_malloc(strlen(str)-pos+1);
      strncpy(uri.path, str+pos, strlen(str)-pos);
      *(uri.path+strlen(str)-pos+1) = '\0';
      if (pos == len_http )
        uri.server = NULL;
      else
      {
        uri.server = pd_malloc(pos-len_http);
        strncpy(uri.server, str+len_http, pos-len_http);
        *(uri.server+pos-len_http) = '\0';
      }
      uri.port = 0;
    }
  }
  else
  { //relativepath
    uri.path = pd_malloc(strlen(str)+1);
    strcpy(uri.path, str);
    uri.server = NULL;
    uri.port = 0;
  }
  pd_free(str);
  return uri;
}

int err2Status(int err)
{
  switch (err)
  {   
    case(ENOENT):
    case(ENOTDIR):
      //file not found
      return 404;
    case(EACCES):
      //Acces Denied
      return 403;
    case(EIO):
    default:
      //internal server error
      return 500;
  }
}

---