---

conn_handler.c

Go to the documentation of this file.

/***************************************************************************
                               conn_handler.c
                             -------------------
    begin                : Thu Nov 15 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 <stdlib.h>
#include <string.h>
#include <unistd.h>

// the following order is required!
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>


#include "conn_handler.h"

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


#ifndef MSG_NOSIGNAL
# define MSG_NOSIGNAL 0
#endif

/* prüfe of EAGAIN und/oder EWOULDBLOCK definiert sind und sorge dafür,
   dass sie es sind
 */
#ifdef EAGAIN
# ifndef EWOULDBLOCK
#  define EWOULDBLOCK EAGAIN
# endif
#else // EAGAIN not defined
# ifdef EWOULDBLOCK
#   define EAGAIN EWOULDBLOCK
# else
#   error Neither EAGAIN nor EWOULDBLOCK defined, aborting!
# endif
#endif

struct ConnHandler
{
  // miscellaneous ch data
  int socket;                     
  struct sockaddr_in client_addr; 
  /*socklen_t*/ int client_addr_len;      
  // Is this a fixed value or might it change for a given connection?
  //  size_t send_chunk_len;          ///< largest block of data which can be send atomically
  int error;                      
  time_t stamp;                   

  HttpProtHandler prot_handler;   

  // receive buffer state
  struct Buffer recv_buf;  

  // send buffer state
  struct Buffer* send_buf; 
};

// ****************************************************************************

static size_t recv_buf_size;

// initialise static values
int chModulePreInit()
{
  recv_buf_size = getEntryDeflL(CONFENTRY_KEY_RECVBUFFER, STD_CONFENTRY_VAL_RECVBUFFER);

  return 0;
}

// free all ressources allocated by the whole module
int chModuleTerminate()
{
  return 0;
}

// ****************************************************************************

// creates and returns a new ConnHandler object
ConnHandler chInit(int server_socket)
{
  ConnHandler this;

  this = (ConnHandler) pd_malloc(sizeof(struct ConnHandler));

  this->client_addr_len = sizeof(this->client_addr);
  if ((this->socket = accept(server_socket,
                             (struct sockaddr *) &this->client_addr,
                             &this->client_addr_len)) == -1)
  {
    logerr(CONN_HANDLER, NOTICE, errno,
           "could not accept connection");
    return NULL;
  }

  logger(CONN_HANDLER, NOTICE,
         "%d: connection to %s established",
         this->socket, inet_ntoa(this->client_addr.sin_addr));

  fcntl(this->socket, F_SETFL, O_NONBLOCK);

  logger(CONN_HANDLER, INFO,
         "%d: non-blocking mode set on socket", this->socket);

  this->error = E_SUCCESS;
  // we only have one kind of ProtHandler so we may as well initialize it here
  this->prot_handler = htInit(this);


  this->recv_buf = bufInit((char*) pd_malloc(recv_buf_size), recv_buf_size, 0);

  // set send_buf to a valid value != NULL
  this->send_buf = NULL;

  logger(CONN_HANDLER, NOTICE,
         "%d: connection initalised", this->socket);

  this->stamp = time(NULL);

  return this;
}

// returns a connection handlers communication socket descriptor
int chGetSocket(const ConnHandler this)
{
  return this->socket;
}

// return the last time where data was exchanged
time_t chGetStamp(const ConnHandler this)
{
  return this->stamp;
}

int readData(ConnHandler this)
{
  ssize_t recv_len;
  errno = 0;

  do {
    recv_len = recv(this->socket, this->recv_buf.data,
                    this->recv_buf.len, MSG_NOSIGNAL);
  } while (recv_len == -1 && errno == EINTR);

  if (recv_len != -1)
    this->stamp = time(NULL);
  else
  {
    switch(errno)
    {
#if EAGAIN != EWOULDBLOCK
      case EAGAIN:
#endif
      case EWOULDBLOCK:
        return 0;
      default:
        this->error = errno;
        // logerr(CONN_HANDLER, NOTICE, "connection to client broken", errno);
        return -1;
    }
  }
  return recv_len;
}

// handles a request waiting on the connection socket
int chReceive(ConnHandler this)
{
  struct Buffer tmp_buf = bufInit(this->recv_buf.data, 0, 0);

  if (this->socket == 0) return -1;

  logger(CONN_HANDLER, DEBUG,
         "%d: reading pending data", this->socket);

  tmp_buf.len = readData(this);

  if (tmp_buf.len > 0)
    htReceive(this->prot_handler, tmp_buf);
  else {
    // error reading data
    logerr(CONN_HANDLER, NOTICE, this->error,
           "%d: error reading pending data", this->socket);
    this->error = EPIPE;
  }

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

inline int byteInQueue(const ConnHandler this)
{
  return this->send_buf->len - this->send_buf->pos;
}

// is there any data waiting to be send?
int chIsDataPending(const ConnHandler this)
{
  if (this == NULL || this->send_buf == NULL)
    return false;
  return (byteInQueue(this) != 0);
}

int forwardSendToProtHandler(ConnHandler this)
{
  if (!chIsDataPending(this) && htIsDataPending(this->prot_handler))
  {
    // request ProtocolHandler to send new data
    if (htSend(this->prot_handler, &(this->send_buf)) == -1)
    {
      return -1; // critical error
    }

    // are we done?
    if (this->send_buf->data == NULL) return 1; // finished
  }

  return 0;
}

// sends some of the data currently in queue
int chSend(ConnHandler this)
{
  int data_sent;
  size_t data_left = byteInQueue(this);
  if (data_left == 0) return 0;

  do
  {
    errno = 0;
    
    logger(CONN_HANDLER, DEBUG,
           "%d: sending pending data", this->socket);

    data_sent = send(this->socket, this->send_buf->data + this->send_buf->pos,
                     data_left, MSG_NOSIGNAL);

    if (data_sent != -1)
      this->stamp = time(NULL);
    else
    {
      switch(errno)
      {
#if EAGAIN != EWOULDBLOCK
        case EAGAIN:
#endif
        case EWOULDBLOCK:
          data_left /= 2;
          break;
        default:
          this->error = errno;
          logerr(CONN_HANDLER, NOTICE, this->error,
                 "%d: error sending pending data", this->socket);
          return -1;
      }
    }
  } while(errno == EINTR || errno == EWOULDBLOCK || errno == EAGAIN);

  this->send_buf->pos += data_sent;

  // Still data left to send? Queue if yes.
  return forwardSendToProtHandler(this);
  // use correct exit status
}

// do additional data processing and allow the request handler
// to fill its alternative send buffer
int chProcess(ConnHandler this)
{
  // request new data to be queued if neccessary and available
  forwardSendToProtHandler(this);

  // allow ProtHandler to process data / fill an alternative send buffer
  return htProcess(this->prot_handler);
}

// return current error code
int chGetError(const ConnHandler this)
{
  return this->error;
}

// destruct connection handler
int chTerminate(ConnHandler this)
{
  if (this == NULL) return -1;

  logger(CONN_HANDLER, NOTICE,
         "%d: terminating connection", this->socket);

  htTerminate(this->prot_handler);

  shutdown(this->socket, 2);
  close(this->socket);

  pd_free(this->recv_buf.data);
  pd_free(this);

  return 0;
}

---