root/trunk/src/renetcolSender.c

/*
 * File: renetcolSender.c
 * 
 * Authors: ANDREU Francois-Xavier 
 *
 * Copyright (C) 2005-2011 GIP RENATER 
 */

/*  This file is part of renetcol. 
 *
 *  renetcol 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.
 *
 *  renetcol 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 renetcol; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include "renetcolSender.h"

key_t myKey = 0;
int myQueue = 0;
msgType myMsg;
long type;
RulesPtr rulesListPtr;
char *keyId;
char *remoteHost;
int i=0;
int j=0;
unsigned char *myText;
unsigned char buffer2[2];
unsigned char buffer4[4];
unsigned short nb=0;
unsigned short typeMsg = 0;
RulesPtr tmp = NULL;

/*
 *   subsstr
 *   
 *   substitute '_' char in a string with ' '
 */
char *subsstr(char *chin)
{
    int i;
    for (i = 0; i < strlen(chin); i++) {
        if (chin[i] == '_') {
            chin[i] = ' ';
        }
    }
    return chin;
}

/*
 * todo
 */
int
todo(int sock, char *host)
{
  char buffer[256];
  int length;
  FILE *ruleFile;
  FILE *tmpFile;
  char port[6];
/*  char value[44]; */
  char filters[249];
/*  char operator[2]; */
  char lines[1024][256]; /* FIXME : here perhaps use a constante like MAX_FILTERS *3 */
  char line[256];
  char lineCopy[256];
  char strTok[1];
  char strName[100];
  int cpt = 0;
  int i = 0;
  int ruleToDelete = 0;
  static char * fields;

  while (1){
    length = read(sock, buffer, 256);
    if (length < 0){
      syslog(LOG_ERR, " read : %s", strerror(errno));
      close(sock);
      return 1;
    }
    if (length == 0)
      break;
    buffer[length] = '\0';
    if (strncmp("DELETE", buffer, 6)==0){
      /* DELETE ALL RULES FROM A REMOTE CLIENT */
      if (!(ruleFile = fopen(RULES_FILE, "r"))) {
        syslog (LOG_ERR, "error during %s opening\n", RULES_FILE);
        close(sock);
        exit(1);
      } else {
        while ( fgets(line, 256, ruleFile) != 0) {
          strncpy(lineCopy, line, 256);
          if (strncmp("N", lineCopy, 1) == 0){
            ruleToDelete = 0;
            if (sscanf(lineCopy, "%1s %s\n",
                       strTok,
                       strName) != 0) {
              if (strncmp(strName, host, strlen(host)) == 0){
                ruleToDelete = 1;
              } else {
                strncpy(lines[cpt], line, strlen(line));
              }
            } else {
              close(sock);
              return 1;
            }
          } else {
            if (ruleToDelete==0) {
              strncpy(lines[cpt], lineCopy, strlen(lineCopy));
            }
          }
          cpt++;
        } /* while end */
        fclose(ruleFile);
        if (!(tmpFile = fopen(FILE_TEMPO, "w"))) {
          syslog (LOG_ERR, "error during %s opening", FILE_TEMPO);
          close(sock);
          return 1;
        } else {
          for (i=0; i<cpt; i++){
            fprintf(tmpFile, "%s", lines[i]);
          }
          fclose(tmpFile);
          if (remove(RULES_FILE)!=0){
            syslog(LOG_ERR, "rules.txt remove pb: %s", strerror(errno));
            close(sock);
            return 1;
          }
          if (rename(FILE_TEMPO, RULES_FILE)!=0){
            syslog(LOG_ERR, "rename file pb: %s", strerror(errno));
            close(sock);
            return 1;
          }
        }
      }
    } else {
      /* NEW RULE */
      if (sscanf(buffer, "%s %s\n",
                port, 
                filters) == 0) { 
syslog (LOG_ERR, "reception de : %s, %s et %s", buffer, port, filters);
        syslog (LOG_ERR, "error in rule syntax: %s", filters);
        close(sock);
        return 1;
      }
syslog (LOG_ERR, "filters : %s", filters);
      subsstr(filters);
syslog (LOG_ERR, "filters modifies : %s", filters);
      if (!(ruleFile = fopen(RULES_FILE, "a"))) {
        syslog (LOG_ERR, "error during %s opening", RULES_FILE);
        close(sock);
        return 1;
      } else {
        fprintf(ruleFile, "N %s\n", host);
        fprintf(ruleFile, "O socket %s %s\n", host, port);
        fprintf(ruleFile, "%s\n", filters); 
        fclose(ruleFile);
      }
    }
  }
  close(sock);
  return 0;
}

/*
 * tcpServer
 */
int
tcpServer ()
{
  struct addrinfo index, *result;
  struct sockaddr_storage listenAddress;
  socklen_t listenAddressLen;
  int listenSock;
  int returnCode;
  pid_t renetcolPID = 0;
  FILE *pidFile;
  unsigned pid;
  char line[256];
  int status;

  memset(&index, 0, sizeof index);
  index.ai_flags = AI_PASSIVE;
  index.ai_family = AF_UNSPEC;
  index.ai_socktype = SOCK_STREAM;
  index.ai_protocol = IPPROTO_TCP;
  returnCode = getaddrinfo(NULL, RECEPT_PORT, &index, &result);
  if (returnCode != 0) {
    syslog(LOG_ERR, "getaddrinfo : %s", strerror(errno));
    return -1;
  }
  listenAddressLen = result->ai_addrlen;
  memcpy(&listenAddress, result->ai_addr, (size_t) listenAddressLen);   
  listenSock = socket(result->ai_family, result->ai_socktype,
                      result->ai_protocol);
  if ( listenSock < 0) {
    syslog(LOG_ERR, "socket : %s", strerror(errno));
    freeaddrinfo(result);
    return -1;
  }
  freeaddrinfo(result);
  
  {
    int on = 1;
    setsockopt(listenSock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof on);
  }
  if (bind(listenSock, (struct sockaddr *) &listenAddress,
           listenAddressLen) < 0 ||
      listen(listenSock, 8) < 0) {
    syslog(LOG_ERR, "bind or listen : %s", strerror(errno));
    return -1;
  }
  for (;;) {            
    int clientSock;
    struct sockaddr_storage clientAddress;
    socklen_t clientAddressLen;
    char host[NI_MAXHOST];
    
    memset(&clientAddress, 0, sizeof clientAddress);
    clientAddressLen = (socklen_t) sizeof clientAddress;
    
    if ((clientSock = 
         accept(listenSock, (struct sockaddr *)
                &clientAddress,
                &clientAddressLen)) < 0) {
      continue;
    }
    if (clientAddress.ss_family != AF_INET &&
        clientAddress.ss_family != AF_INET6) {
      close(clientSock);
      continue;
    }
    if (getnameinfo((struct sockaddr *) &clientAddress,
                    clientAddressLen, host, sizeof host,
                    NULL, (size_t) 0, NI_NUMERICHOST) == 0) {
      syslog(LOG_INFO, 
             "New connection from %s", host);
    }
    remoteHost = host;
    switch (fork ()) {
    case 0 :
      close (listenSock);
      todo(clientSock, remoteHost);
      if (!(pidFile = fopen("/var/run/renetcol.pid", "r"))) {
        syslog (LOG_ERR, "error during /var/run/renetcol.pid opening : %s\n",
                strerror(errno));
        exit(1);
      } else {
        fgets(line, 256, pidFile);
        if (sscanf(line, "%u", &pid)==0)
          syslog(LOG_ERR,"sscanf : %s", strerror(errno));
        renetcolPID = pid;
      }
      fclose(pidFile);
      if (renetcolPID==0){
        syslog(LOG_INFO, "PID null");
      }else{
        if (kill(renetcolPID, SIGUSR1)<0)
          syslog(LOG_ERR, "I can't send SIGUSR1 to renetcol process : %s",
                 strerror(errno));
      }
      exit (0);
    case -1 :
      syslog (LOG_ERR, "fork : %s", strerror(errno));
      return (-1);
    default :
      close (clientSock);
      if (waitpid( -1, &status, WNOHANG)==-1){
        syslog(LOG_ERR, "waitpid : %s", strerror(errno));
        exit(1);
      }
    }
  }
  return (0);
}

/*
 *
 */
void initConfSender(){
  RulesPtr tmp = NULL;

  tmp = rulesListPtr;
  for ( ; tmp; tmp=tmp->next) {
    rulesListPtr = delRule(tmp, rulesListPtr);
  }
  rulesListPtr = NULL;
  rulesListPtr = getRules(rulesListPtr, RULES_FILE);
  tmp = rulesListPtr;
  for ( ; tmp; tmp=tmp->next) {
    if (tmp->type != 2) {
      rulesListPtr = delRule(tmp, rulesListPtr);
    }
  }
  tmp = NULL;
}

/* 
 * Main
 * ----
 */
int 
main (int argc, char *argv[])
{
  int s=0;
  unsigned short rulesID = 0;
  FILE *pidFile;
  pid_t renetcolPID = 0;

  if ( argc != 3) {
    fprintf (stderr,
             "%s: Usage: %s <key> <msg type>\n exp: %s renetcol 1 \n", 
             argv[0], argv[0], argv[0]);
    exit(1);
  }
  if (sscanf (argv[2], "%ld", &type) != 1){
    fprintf(stderr, "renetcolSender: Error, Invalid message type in command\n");
    exit(1);
  }  

  openlog(argv[0], LOG_PID, LOG_USER);
  keyId = (char *) malloc((strlen(argv[1])+1) * sizeof(char));
  strcpy (keyId, argv[1]);
  rulesListPtr = NULL;
  rulesListPtr = getRules(rulesListPtr, RULES_FILE);
  /* we delete rules which are not type socket */
  tmp = rulesListPtr;
  for ( ; tmp; tmp=tmp->next) {
    if (tmp->type != 2) {
      rulesListPtr = delRule(tmp, rulesListPtr);
    }
  }
  tmp = NULL;
  /* get IPC messages queue */
  if ((myKey = ftok(keyId, 0))== -1){
    syslog(LOG_ERR, "ftok : %s", strerror(errno));
    exit(1);
  }
  if ((myQueue = msgget(myKey, 0)) == -1){
    syslog(LOG_ERR, "msgget : %s", strerror(errno));
    exit(1);
  }

/*   chdir ("/"); */
  fprintf(stderr, "renetcolSender: I become a deamon, next messages via syslogd. Bye.\n");
  if (fork () != 0)
    exit (0);
  if (setsid() == -1){
    exit(4);
  }
/*   for (i = 0; i < FOPEN_MAX; i ++) */
/*     close (i); */
  
  /* launch a TCP server to listen remote clients */
  switch (fork ()) {
  case 0 : /* son */
    tcpServer();
  case -1 :
    syslog (LOG_ERR, "fork : %s", strerror(errno));
    return (-1);
  default : /* father */
    break;
  }
  /* loop on the message queue */
  while (1) {
    i=0;
    myText = msgRcv(myQueue, &myMsg, type);
    buffer2[0]= *(myText+i); i++;
    buffer2[1]= *(myText+i); i++;
    typeMsg = *((unsigned short *)&buffer2);
    if (1==typeMsg){
      /* we send the template definition to all the known destination */
      tmp = rulesListPtr;
      for ( ; tmp; tmp=tmp->next) {
        s = sendMessage(tmp->host->sockId, myText, sizeof(myMsg.text),
                        tmp->host->hostAddressPtr);
      }
    } else if (11==*((unsigned short*)&buffer2)){ 
      buffer2[0]= *(myText+i); i++;
      buffer2[1]= *(myText+i); i++;
      rulesID = *((unsigned short *)&buffer2);
      /* here we send the flow to the correct remote client */
      tmp = rulesListPtr;
      for ( ; tmp; tmp=tmp->next) { /* FIXME while */
        if (tmp->id == rulesID){
          s = sendMessage(tmp->host->sockId, myText, sizeof(myMsg.text),
                          tmp->host->hostAddressPtr);
        }
      }
    } else if (12==*((unsigned short*)&buffer2)){ 
      buffer4[0]= *(myText+i); i++;
      buffer4[1]= *(myText+i); i++;
      buffer4[2]= *(myText+i); i++;
      buffer4[3]= *(myText+i); i++;
      renetcolPID = *((pid_t *)&buffer4);
      if (!(pidFile = fopen("/var/run/renetcol.pid", "w"))) {
        syslog (LOG_ERR, "error during /var/run/renetcol.pid opening : %s\n",
                strerror(errno));
        exit(1);
      } else {
        if (fprintf(pidFile, "%u", renetcolPID)==0)
          syslog(LOG_ERR,"fprintf : %s", strerror(errno));
      }
      fclose(pidFile);
    } else if (13==*((unsigned short*)&buffer2)){ 
      initConfSender();
    } else {
      syslog(LOG_INFO, "Msg type undefined ??");
    }
    i=0;
  }
  return(0);
}