---

reqhandler_file.c

Go to the documentation of this file.

/***************************************************************************
                              reqhandler_file.c
                             -------------------
    begin                : Sun Nov 25 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 <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

#include "reqhandler_file.h"

#include "buffer.h"
#include "conftable.h"
#include "http.h"
#include "logger.h"
#include "mime.h"
#include "misc.h"
#include "xmalloc.h"


#define ALLOW "GET HEAD"


// the struct containing all necessary information (on file-level) for a file transfer
struct ReqHandlerFile
{
  HttpProtHandler parent; 
  //no right neighbour

  char *abs_path;       
  int source;           
  int status;           
  size_t src_size;      
  time_t mod_time;      
  char *extension;      
  
  char *allow;          

  //the data buffer 
  struct Buffer buf;    
  int data_pending;     
  int error;            
};


//internal funktions
int getAbsPath(char **abs_path, const char *path);
int getSrcInfo(ReqHandlerFile this);



// "global" variables with constant values
static size_t send_buf_size;

static const char * doc_root;
static size_t doc_root_len;

static const char * index_file;
static size_t index_file_len;

// pre-initialize constant values 
int rhfModulePreInit()
{
  // use user-defineable buffer size (if undefined use CONFENTRY_VAL_BUFSIZE)
  send_buf_size = getEntryDeflUI(CONFENTRY_KEY_SENDBUFFER, STD_CONFENTRY_VAL_SENDBUFFER);

  doc_root = getEntry(CONFENTRY_KEY_ROOTDIR);
  doc_root_len = strlen(doc_root);

  index_file = getEntryDefl(CONFENTRY_KEY_INDEXHTML, STD_CONFENTRY_VAL_INDEXHTML);
  index_file_len = strlen(index_file);

  return 0;
}

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




ReqHandlerFile rhfInit(HttpProtHandler parent, const char *path_buf, int change_path)
{
  ReqHandlerFile this = (ReqHandlerFile) pd_malloc(sizeof(struct ReqHandlerFile));
  
  memset(this, 0, sizeof(struct ReqHandlerFile));
  this->parent = parent;
  this->source = -1;
  this->allow = ALLOW;

  // if change_path == true, the path is converted into an asolute path, otherwise not
  if (change_path)
  {
    if (getAbsPath(&this->abs_path, path_buf) == -1)
      this->error = errno;
  }
  else
  {
    char* new_buf = (char*) pd_malloc(strlen(path_buf)+1);
    strcpy(new_buf, path_buf);
    this->abs_path = new_buf;
  }

  if (getSrcInfo(this) == 0)
  {
    this->source = open(this->abs_path, O_RDONLY);
    if (this->source == -1)
    {
      logerr(REQUEST_HANDLER, ERROR, errno, "could not open requested file");
      this->error = errno;
    }
    else
    {
      // make buffer size of file if bufsize is larger, else take the default size
      if (this->src_size < send_buf_size)
      {
        /* Allocate data send buffer. If file size is zero, allocate
           at least one byte so EFence doesn't complain              */
        this->buf.data = (char*) pd_malloc(MAX(this->src_size, 1));
        this->buf.len  = this->src_size;
      }
      else
      {
        this->buf.data = (char*) pd_malloc(send_buf_size);
        this->buf.len  = send_buf_size;
      }
      this->buf.pos  = 0;
      this->data_pending = true;
    }
  }
  else if (this->error == 0)
    this->error = errno;

  return this;
}

int rhfReceive(__attribute__ ((unused)) ReqHandlerFile this,
               __attribute__ ((unused)) struct Buffer *buf /*recv_buf*/)
{
  return 0;
}

int rhfSend(ReqHandlerFile this, struct Buffer **buf)
{
  int cnt = 0; //amount of data read
  do {
    cnt = read(this->source, this->buf.data, this->buf.len);
  } while (cnt == -1 && errno == EINTR);
  
  this->buf.len = cnt;
  this->buf.pos = 0;
  if (cnt <= 0)
  {
    int errno_bak = errno;
    //nothing could be read anymore...
    pd_free(this->buf.data);
    this->buf.data = NULL;
    this->data_pending = false;
    //...but did an error occure or are we at the end of file?
    if (cnt != 0)
    {
      logerr(REQUEST_HANDLER, ERROR, errno_bak, "data could not be read");
      this->error = errno;
      return -1;
    }
  }
  else
    this->data_pending = true;

  *buf = &this->buf;
  
  //maybe
  //return this->buf.len;
  return 0;
}

int rhfProcess( __attribute__ ((unused))ReqHandlerFile this)
{
  return 0;
}

int rhfIsDataPending(ReqHandlerFile this)
{
  return (this->data_pending);
}

int rhfTerminate(ReqHandlerFile this)
{
  if (this == NULL) return -1;

  pd_free(this->buf.data);
  this->buf.data = NULL;
  pd_free(this->abs_path);

  if (this->source > 0)
    close(this->source);

  // kill myself...
  pd_free(this);
  return 0;
}

int rhfGetError(ReqHandlerFile this)
{
  return this->error;
}


//some non-standard public functions:

size_t rhfGetSourceSize(ReqHandlerFile this)
{
  return this->src_size;
}

time_t rhfGetModTime(ReqHandlerFile this)
{
  return this->mod_time;
}

const char *rhfGetAllow(ReqHandlerFile this)
{
  return this->allow;
}


const char* rhfGetContentType(ReqHandlerFile this)
{
  //convert fileextension to mime-type and return
  return mimeLookup(this->extension);
}

//internal procedures:

int getAbsPath(char** abs_path, const char* path)
{
  char *dir;
  int ret_val = 0;

  if (doc_root == NULL || path == NULL)
  {
    errno = EBADF;
    return -1;
  }
  
  // concatenate rootpath and filepath
  dir = (char*) pd_malloc(doc_root_len + strlen(path)+1);
  strcpy(dir, doc_root);
  strcpy(dir + doc_root_len, path);


  *abs_path = (char*)pd_malloc(PATH_MAX+1);
  if (realpath(dir,*abs_path) != NULL)
  {
    struct stat buf;
    if (stat(*abs_path, &buf) == 0)
    {
      if (S_ISDIR(buf.st_mode))
      {// yes, we handle a directory and have to set a file
        char *tmp;
        struct stat tbuf;
        size_t abs_path_len = strlen(*abs_path);

        // strcat(*abs_path, "/");
        (*abs_path)[abs_path_len++] = '/';
        (*abs_path)[abs_path_len] = '\0';
          
        tmp = (char*)pd_malloc(abs_path_len + index_file_len + 1);

        strcpy(tmp, *abs_path);
        // strcat(tmp, index_file);
        strcpy(tmp + abs_path_len, index_file);

        errno = 0;
        
        if (stat(tmp, &tbuf) != 0)
        {// something went wrong ... free all and get outta here
          pd_free(dir);
          pd_free(tmp);
          pd_free(*abs_path); *abs_path = NULL;
          return -1;
        }
        pd_free(*abs_path);
        *abs_path = tmp;
      }
    }
    else
      //stat failed
      return -1;

    //check if we are still in valid dir-scope
    if (strncmp(*abs_path, doc_root, doc_root_len) == 0)
      ret_val = 0;
    else
    {
      pd_free(dir);
      pd_free(*abs_path); *abs_path = NULL;
      errno = EACCES;
      return -1;
    }
  }
  else
  {//realpath errored
    //save errno for later use:
    int errno_orig = errno;
    pd_free(dir);
    pd_free(*abs_path); *abs_path = NULL;
    errno = errno_orig;
    return -1;
  }

  pd_free(dir);
  return ret_val; 
}


int getSrcInfo(ReqHandlerFile this)
{
  struct stat buf;
  int len;
  int cnt;
  
  //init ext to the whole path:
  this->extension = this->abs_path;
  
  if (this->abs_path == NULL) return -1;
  
  len = strlen(this->abs_path);
    
  if (stat(this->abs_path, &buf) == 0)
  {
    this->src_size = buf.st_size;
    this->mod_time = buf.st_mtime;
  }
  else
  {
    this->src_size = 0;
    this->mod_time = 0;
    return -1;
  }
  
  //set the pointer to the file extension
  //find fileextension devided by '.', if / ist last, the filename is taken
  for (cnt = 0; cnt < len; ++cnt)
    if (this->abs_path[cnt] == '.' || this->abs_path[cnt] == '/')
      this->extension = this->abs_path+cnt;

  //doesnt make sence, if the last char is a '.' or '/'
  if (this->extension > this->abs_path + len - 2)
    this->extension = this->abs_path;
  else
    //set the pointer to the char behind the '.' or '/'
    ++this->extension;
  
  return 0;
}

---