---

server.c

Go to the documentation of this file.

/***************************************************************************
                                  server.c
                             -------------------
    begin                : Sun Nov 4 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>

// sys/types.h is a prerequisite for netinet/in.h on BSD
#include <sys/types.h>
// sys/socket.h is a prerequisite for netinet/in.h on BSD and MacOS X
#include <sys/socket.h>
#include <netinet/in.h>

#include <pwd.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <sys/time.h>
#include <unistd.h>
#include <grp.h>

#include "server.h"

#include "conftable.h"
#include "conn_handler.h"
#include "connhandlerlist.h"
#include "logger.h"
#include "signal_handler.h"
#include "xmalloc.h"

int changeUserGroupID();



fd_set sock_recv_set;
fd_set sock_send_set;
fd_set sock_recv_ready_set, sock_send_ready_set;

ConnHandlerList ch_list;


int newServerSocket(unsigned short int port_num) {
  int server_sock;
  struct sockaddr_in local_addr;

  if ((server_sock = socket(PF_INET, SOCK_STREAM, 0)) == 0)
    return -1;

  local_addr.sin_family = AF_INET;
  local_addr.sin_port = htons((unsigned short) port_num);
  local_addr.sin_addr.s_addr = INADDR_ANY;

  if (bind(server_sock, (struct sockaddr *) &local_addr,
           sizeof(local_addr)) != 0)
    return -1;

  if (listen(server_sock, 10) != 0)
    return -1;

  return server_sock;
}

int svCloseConnection(ConnHandler ch)
{
  int socket = chGetSocket(ch);
  if (FD_ISSET(socket, &sock_recv_set)) FD_CLR(socket, &sock_recv_set);
  if (FD_ISSET(socket, &sock_recv_ready_set)) FD_CLR(socket, &sock_recv_ready_set);
  if (FD_ISSET(socket, &sock_send_set)) FD_CLR(socket, &sock_send_set);
  if (FD_ISSET(socket, &sock_send_ready_set)) FD_CLR(socket, &sock_send_ready_set);

  chTerminate(ch);
  logger(PDEPP_CORE, NOTICE, "client connection closed");
  return 0;
}

int svMain(const int port)
{
  int server_sock, sock_max, conn_count;
  time_t conn_timeout = getEntryDeflI(CONFENTRY_KEY_CONNTIMEOUT, STD_CONFENTRY_VAL_CONNTIMEOUT);
  int conn_maxcount = getEntryDeflI(CONFENTRY_KEY_CONNMAXCOUNT, STD_CONFENTRY_VAL_CONNMAXCOUNT);

  int err, sock_num, conn_sock;

  running = true;
  
  if (port < 1 || port > 65535)
  {
    logger(PDEPP_CORE, CRITICAL, "svMain: Invalid port range!");
    return -1;
  }

  logger(PDEPP_CORE, NOTICE, "server starting...");

  if (conn_maxcount > FD_SETSIZE)
  {
    logger(PDEPP_CORE, ERROR, "configured maximum number of concurrent connections is too high, "
                              "maxmimum number supported on this platform is %u", FD_SETSIZE);
    conn_maxcount = FD_SETSIZE;
  }
  
  server_sock = newServerSocket(port);
  if (server_sock < 0)
  {
    logerr(PDEPP_CORE, CRITICAL, errno,
           "svMain: could not initialize server socket");
    return -1;
  }

  logger(PDEPP_CORE, NOTICE, "server initialized");

  //degrade the user if whished
  if (changeUserGroupID() < 0)
    return -1;

  printf("server running at port %d\n", port);

  FD_ZERO(&sock_recv_set);
  FD_SET(server_sock, &sock_recv_set);

  FD_ZERO(&sock_send_set);

  ch_list = chListInit();

  sock_max = server_sock;
  conn_count = 1;

  while (running)
  {
//    int sock_num;

    sock_recv_ready_set = sock_recv_set;
    sock_send_ready_set = sock_send_set;

    errno = 0;

    sock_num = select(sock_max+1, &sock_recv_ready_set, &sock_send_ready_set, NULL, NULL);

    if (sock_num == -1)
      switch(errno)
      {
#ifndef NDEBUG
      case EINVAL:
      case EBADF:
        logerr(PDEPP_CORE, CRITICAL, errno,
               "svMain: internaol server error during select");
        abort();
#endif
      case EINTR: // interrupted by signal, silently retry
        // logger(PDEPP_CORE, CRITICAL,
        //        "svMain: interrupted by signal %s, retrying", strsignal(caught_signal));
        continue;
      case ENOMEM:
        logerr(PDEPP_CORE, CRITICAL, errno,
               "svMain: select ran out of memory");
        return -1;
      default:
        logerr(PDEPP_CORE, WARNING, errno,
               "svMain: select failed, retrying");
        continue;
        // return -1;
      }
#ifndef NDEBUG
    else
      if (sock_num == 0) // timeout, cannot currently happen
      {
        logerr(PDEPP_CORE, CRITICAL, errno, "svMain: select returned 0!!!");
        continue; // retry anyway!
      }
#endif

    FD_ZERO(&sock_send_set);

    if (FD_ISSET(server_sock, &sock_recv_ready_set))
    {
      ConnHandler new_ch;

      new_ch = chInit(server_sock);
      if (new_ch != NULL)
      {
        int new_sock = chGetSocket(new_ch);
        if(conn_count < conn_maxcount) {
          FD_SET(new_sock, &sock_recv_set);
          chListAppend(ch_list, new_ch);
          sock_max = (new_sock > sock_max) ? new_sock : sock_max;
          ++conn_count;
        } else {
          // too many connections, reject
          chTerminate(new_ch);
          logger(PDEPP_CORE, WARNING, "rejected client: too many connections");
        }
      }
    }
    
    chListFirst(ch_list);
    while (!chListIsTail(ch_list))
    {
//      int err = 0;
      ConnHandler ch = chListGetPayload(ch_list);
      err = 0;
      /*int*/ conn_sock = chGetSocket(ch);

      if (FD_ISSET(conn_sock, &sock_recv_ready_set))
        err = chReceive(ch);
      if (err == 0)
        err = chProcess(ch);
      if (err == 0 && FD_ISSET(conn_sock, &sock_send_ready_set))
        err = chSend(ch);

      if ((time(NULL) - chGetStamp(ch)) > conn_timeout)
      {
        logger(PDEPP_CORE, WARNING, "%u: client connection timed out", conn_sock);
        err = -1;
      }

      // socket still active?
      if (err == 0)
        if (chIsDataPending(ch))
          FD_SET(conn_sock, &sock_send_set);

      if (err != 0)
      {
        if (err != 1)
          logerr(PDEPP_CORE, NOTICE, chGetError(ch), "client connection error");
        svCloseConnection(ch);
        chListDelete(ch_list);
        --conn_count;
      } else
        chListNext(ch_list);
    }
  }
  
  // this is the beginning of the end of pdepp !!!
  // here the first things are cleared and freed, after (int)running is set to false by a signal

  if (caught_signal != 0)
  {
#ifdef HAVE_STRSIGNAL
    logger(PDEPP_CORE, CRITICAL,
           "caught signal \"%s\", server terminating", strsignal(caught_signal));
#else
    logger(PDEPP_CORE, CRITICAL,
           "caught signal %d, server terminating", caught_signal);
#endif
  }

  // we first free and clear the connHandler list...
  chListFirst(ch_list);
  while(!chListIsTail(ch_list))
  {
    chTerminate(chListGetPayload(ch_list));
    chListDelete(ch_list);
  }
  chListTerminate(ch_list);

  // ...then return
  return 0;
}


int changeUserGroupID()
{
  uid_t euid = geteuid();
  const char* new_user  = getEntryDefl(CONFENTRY_KEY_USER, STD_CONFENTRY_VAL_USER);
  const char* new_group = getEntryDefl(CONFENTRY_KEY_GROUP, STD_CONFENTRY_VAL_GROUP);
  struct passwd* pswd;
  struct group*  grp;
  
  //dont wonna change!
  if (strcmp(new_user, STD_CONFENTRY_VAL_USER) == 0
      && strcmp(new_group, STD_CONFENTRY_VAL_GROUP) == 0)
    return 0;
    
  //need to be root (== 0) to make the change
  if (euid != 0)
  {
    logger(PDEPP_CORE, CRITICAL, "Error changing user: You need to be root (check user/group settings in configfile)");
    return -1;
  }

  //convert the new_xx strings to numerical data to get the new_xxx pid/gid
  pswd = getpwnam(new_user);
  grp  = getgrnam(new_group);
  
  if (pswd == NULL)
  {
    logger(PDEPP_CORE, CRITICAL, "Error: Invalid user \"%s\" given!", new_user);
    return -1;
  }
  if (grp == NULL)
  {
    logger(PDEPP_CORE, CRITICAL, "Error: Invalid group \"%s\" given!", new_group);
    return -1;
  }
  
  //reset errno
  errno = 0;

  if (setgid(grp->gr_gid) < 0)
  {
    logger(PDEPP_CORE, CRITICAL,
           "Error: Could not change to given group \"%s\"!", new_group);
    return -1;
  }
  else if (setuid(pswd->pw_uid) < 0)
  {
    logger(PDEPP_CORE, CRITICAL,
           "Error: Could not change to given user \"%s\"!", new_user);
    return -1;
  }
  else
  {
    logger(PDEPP_CORE, INFO,
           "Successfully changed to user \"%s\" and group \"%s\"!"
           , new_user, new_group);
  }

  return 0;
}

---