Код C, работа с сокетами (forward data)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/epoll.h>
#include <errno.h>
#include <arpa/inet.h>
#include <assert.h>
 
/*
 * Клиент может подключаться к любому сетевому адаптеру,
 * который есть на машине, на которой работает данный сервер
*/
 
#define MAXEVENTS 500000
//for conf file
#define MAX_CONFIG_VARIABLE_LEN 20
#define CONFIG_LINE_BUFFER_SIZE 100
#define MAX_IP_SERVER_LEN 256
#define BUFLEN 16384
 
#define CLIENT_SOCKET_ERROR -5
#define CLIENT_RESOLVE_ERROR -6
#define CLIENT_CONNECT_ERROR -7
#define TRUE        1
#define EPOLL_QUEUE_LEN 256
 
void forward_data(int source_sock, int destination_sock);
static int forwardData (int fd);
 
 
int forwardSockets[EPOLL_QUEUE_LEN];
int internalSockets[EPOLL_QUEUE_LEN];
 
struct timeval read_timeout; //Таймаут для чтения
 
char in_buf[255]; //Буфер для хранения ответов сервера - балансировщика
unsigned char out_buf_1[255]; //То, что отправляем серверу, который хранит значения заггруженносчт серверов фермы
char buf_for_serv_ferm[BUFLEN];
char buf_for_client_from_server_ferm[BUFLEN];
 
char *remote_host;
 
int clientSocket;
int servFermSocket;
int dataForClientSocket;
int remote_sock;
int client_sock;
int forwardSD;
 
int error_write;
int error_read;
int error_close_socket;
 
//strcmp - сравнение строк
char char_ip_addr[20];
char char_cpu_load[5];
char char_mem_load[5];
 
int int_cpu_load;
int int_mem_load;
int int_cpu_mem_load;
 
struct sockaddr_in serverAddr; //Удаленный сервер балансировщик (для получения ip свободного сервера)
struct sockaddr_in localaddr; // Эта машина
 
struct sockaddr_in nodeServerAddr;
 
struct sockaddr_in for_browser_client;
 
int int_index_0, int_index_1, int_index_2, int_index_3; //Для хранения индексов элементов массива
char *index_0, *index_1, *index_2, *index_3; //Для адресов, с которых начинать или которыми заканчивать (для парсинга пришедшего массива)
 
//---------------------------------------------------------Читаем конфиг---------------------------------------------------------------------------
 
........
    printf("SERVER_IP = %s\n", server_ip);
    printf("SERVER_PORT = %d\n", server_port);
    printf("CLIENT_IP = %s\n", client_ip);
    printf("CLIENT_PORT = %d\n", client_port);
    fclose(fp);
//-------------------------------------------------------------------------------------------------------------------------------------------------
 
 
static int
make_socket_non_blocking (int sfd)
{
  int flags, s;
 
  flags = fcntl (sfd, F_GETFL, 0);
  if (flags == -1)
    {
      perror ("fcntl");
      return -1;
    }
 
  flags |= O_NONBLOCK;
  s = fcntl (sfd, F_SETFL, flags);
  if (s == -1)
    {
      perror ("fcntl");
      return -1;
    }
 
  return 0;
}
 
static int
create_and_bind (char *port)
{
  struct addrinfo hints;
  struct addrinfo *result, *rp;
  int s, sfd;
 
  memset (&hints, 0, sizeof (struct addrinfo));
  hints.ai_family = AF_UNSPEC;     /* Return IPv4 and IPv6 choices */
  hints.ai_socktype = SOCK_STREAM; /* We want a TCP socket */
  hints.ai_flags = AI_PASSIVE;     /* All interfaces */
 
  s = getaddrinfo (NULL, port, &hints, &result);
  if (s != 0)
    {
      fprintf (stderr, "getaddrinfo: %s\n", gai_strerror (s));
      return -1;
    }
 
  for (rp = result; rp != NULL; rp = rp->ai_next)
    {
      sfd = socket (rp->ai_family, rp->ai_socktype, rp->ai_protocol);
      if (sfd == -1)
        continue;
 
      s = bind (sfd, rp->ai_addr, rp->ai_addrlen);
      if (s == 0)
        {
          /* We managed to bind successfully! */
          break;
        }
 
      close (sfd);
    }
 
  if (rp == NULL)
    {
      fprintf (stderr, "Could not bind\n");
      return -1;
    }
 
  freeaddrinfo (result);
 
  return sfd;
}
 
int
main (int argc, char *argv[])
{
  int sfd, s;
  int efd;
  struct epoll_event event;
  struct epoll_event *events;
 
  struct  sockaddr_in server_fwd;
  struct  hostent *hp;
 
  read_config_file("config.conf"); //Чтение конфигурационного файла
 
  //Сокет клиента (эта машина)
  localaddr.sin_family = AF_INET;
  localaddr.sin_addr.s_addr = inet_addr(client_ip);
  localaddr.sin_port = client_port;
 
  //Сервер - блансировщи
  serverAddr.sin_family = AF_INET;
  serverAddr.sin_port = htons(server_port);
  serverAddr.sin_addr.s_addr = inet_addr(server_ip);
 
  if (argc != 2)
    {
      fprintf (stderr, "Usage: %s [port]\n", argv[0]);
      exit (EXIT_FAILURE);
    }
 
  sfd = create_and_bind (argv[1]);
  if (sfd == -1)
    abort ();
 
  s = make_socket_non_blocking (sfd);
  if (s == -1)
    abort ();
 
  s = listen (sfd, SOMAXCONN);
  if (s == -1)
    {
      perror ("listen");
      abort ();
    }
 
  efd = epoll_create1 (0); //создаёт структуру данных, с которой в дальнейшем идёт работа
  if (efd == -1)
    {
      perror ("epoll_create");
      abort ();
    }
 
  event.data.fd = sfd;
  event.events = EPOLLIN | EPOLLET;
  s = epoll_ctl (efd, EPOLL_CTL_ADD, sfd, &event); //Добавление файлового дескриптора к наблюдению
  if (s == -1)
    {
      perror ("epoll_ctl");
      abort ();
    }
 
  /* Buffer where events are returned */
  events = calloc (MAXEVENTS, sizeof event);
 
  /* The event loop */
  while (1)
    {
      int n, i;
 
      n = epoll_wait (efd, events, MAXEVENTS, -1);
      for (i = 0; i < n; i++)
    {
          //int infd;
 
          /*if((events[i].events & EPOLLERR))
          {printf("(events[i].events & EPOLLERR)\n");continue;}
          else if(events[i].events & EPOLLHUP)
          {printf("events[i].events & EPOLLHUP)\n");continue;}
          else if(!(events[i].events & EPOLLIN))
          {printf("!(events[i].events & EPOLLIN)\n");continue;}*/
 
          //--------------------------------------------------------------------------------------
          if ((events[i].events & EPOLLERR) ||
              (events[i].events & EPOLLHUP) ||
              (!(events[i].events & EPOLLIN)))
        {              
              // An error has occured on this fd, or the socket is not
              //   ready for reading (why were we notified then?)
          fprintf (stderr, "epoll error\n");
 
          int error = 0;
          socklen_t errlen = sizeof(error);
          if (getsockopt(events[i].data.fd, SOL_SOCKET, SO_ERROR, (void *)&error, &errlen) == 0)
          {
              printf("error = %s\n", strerror(error));
          }
 
          close (events[i].data.fd);
          continue;
        }
         //--------------------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------------------
      if (sfd == events[i].data.fd) // Готов слушающий дескриптор (sfd)
        {
          printf("1 ------------- sfd = %d\n 1 ------------------- events[i].data.fd = %d\n", sfd, events[i].data.fd);
              /* We have a notification on the listening socket, which
                 means one or more incoming connections. */
              //while (1)
                //{
                  struct sockaddr in_addr;
                  socklen_t in_len;
                  int infd;
                  char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];
 
                  in_len = sizeof in_addr;
                  infd = accept (sfd, &in_addr, &in_len); //Дескриптор подключившегося клиента
                  if (infd == -1)
                    {
                      if ((errno == EAGAIN) ||
                          (errno == EWOULDBLOCK))
                        {
                          /* We have processed all incoming
                             connections. */
                          break;
                        }
                      else
                        {
                          perror ("accept");
                          break;
                        }
                    }
 
                  s = getnameinfo (&in_addr, in_len, //in_addr - адрес клиента
                                   hbuf, sizeof hbuf,
                                   sbuf, sizeof sbuf,
                                   NI_NUMERICHOST | NI_NUMERICSERV);
                  if (s == 0)
                    {
                      printf("Accepted connection on descriptor %d "
                             "(host=%s, port=%s)\n", infd, hbuf, sbuf);
                    }
 
                  /* Make the incoming socket non-blocking and add it to the
                     list of fds to monitor. */
                  //Добавление клиентского дескриптора в массив ожидания
                  s = make_socket_non_blocking (infd);
                  if (s == -1)
                    abort ();
 
                  event.data.fd = infd;
                  event.events = EPOLLIN | EPOLLET;
                  s = epoll_ctl (efd, EPOLL_CTL_ADD, infd, &event);
                  if (s == -1)
                    {
                      perror ("epoll_ctl");
                      abort ();
                    }
                //}
              //Клиентский дескриптор готов
 
 
 
 
                  //--------------------------------------------Получаем IP наименее загруженного сервера фермы---------------------------
                //Создаем сокет clientSocket, делаем запрос на сервер с информацией о загруженности серверов фермы, читаем ответ в in_buf..........
                  while (error_read <= 0)
                  {
                     error_read = read(clientSocket, in_buf, sizeof(in_buf));
                     printf(".");
                  }
                  error_close_socket = close(clientSocket);
                  if (error_close_socket < 0)
                    {
                      printf("*** ERROR - close() failed \n");
                      exit(-1);
                    }
                  //------------------------------------------------------------------------------------------------------------------------------------------------------
 
                  //-----------------------------------------Отправляем данные клиента на сервер фермы-------------------------------------
                  remote_host = in_buf;
 
                  printf("Trying to create forward socket\n");
                  if ((forwardSD = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
                      perror("Cannot create forward socket.");
                      exit(1);
                  }
 
                  printf("Binding...\n");
                  bzero((char *)&server_fwd, sizeof(struct sockaddr_in));
                  server_fwd.sin_family = AF_INET;
                  server_fwd.sin_port = htons(80);
                  //host = "192.168.0.10";
                  if ((hp = gethostbyname(remote_host)) == NULL) {
                      printf("Failed to get host name");
                  }
                  bcopy(hp->h_addr, (char *)&server_fwd.sin_addr, hp->h_length);
 
                  printf("Connecting to interal machine.\n");
                  printf("Server Forward Port: %d\n", ntohs(server_fwd.sin_port));
                  printf("Server Forward IP: %s\n", inet_ntoa(server_fwd.sin_addr));
 
                  // Connecting to interal machine
                  if (connect (forwardSD, (struct sockaddr *)&server_fwd, sizeof(server_fwd)) == -1) {
                      perror("connect failed");
                      exit(1);
                  }
 
                  // Add the new socket descriptor to the epoll loop
                  event.data.fd = forwardSD;
                  if (epoll_ctl (efd, EPOLL_CTL_ADD, forwardSD, &event) == -1) //epoll_fd = efd
                  {
                      printf ("epoll_ctl");
                  }
                  printf ("Connected: Server: %s\n", hp->h_name);
                  forwardSockets[infd] = forwardSD; //fd_new - новое соеинение (клиент), forwardSD - сокет для транспортировки
                  internalSockets[forwardSD] = infd; // fd_new = infd
 
                  continue;
            }
            if (!forwardData(events[i].data.fd))
            {
      // epoll will remove the fd from its set
      // automatically when the fd is closed
                printf("CLOSE EVENTS[i].DATA.FD\n");
                close (events[i].data.fd);
            }
        }
    }
 
  free (events);
  close (sfd);
 
  return EXIT_SUCCESS;
}
 
/* Forward data between sockets */
static int forwardData (int fd)
{
    //source_sock - fd
    //destination_sock - forwardData
 
    ssize_t n;
 
    int forwardData;
    if(forwardSockets[fd] != 0){
        forwardData = forwardSockets[fd];
    }
    if(internalSockets[fd] != 0){
        forwardData = internalSockets[fd];
    }
 
    char buffer[BUFLEN];
    memset(buffer, 0, sizeof(buffer));
    while ((n = recv(fd, buffer, BUFLEN, 0)) > 0) { // read data from input socket
                        printf("OK\n");
                        printf("n = %zd\n", n);
                        printf("buffer = %s", buffer);
        send(forwardData, buffer, n, 0); // send data to output socket
 
        return TRUE;
    }
 
    printf("------------------buf-------------------------\n");
    printf("------------------end buf---------------------\n");
    /*if (n < 0) {
        exit(-9);
    }*/
 
    //shutdown(forwardData, SHUT_RDWR); // stop other processes from using socket
    //close(forwardData);
 
    //shutdown(fd, SHUT_RDWR); // stop other processes from using socket
    //close(fd);
 
    return TRUE;
 
    printf ("I kill fd\n");
}

forwardSockets[infd] = forwardSD;

static int forwardData (int fd)
{
    ssize_t n;
    char buffer[BUFLEN];
    int forwardData;
     
    printf("recv read from: %d\n", fd);
    if(forwardSockets[fd] != 0)
        {
            forwardData = forwardSockets[fd];
            printf("forwardSockets: %d\n", forwardData);
        }
    if(internalSockets[fd] != 0)
        {
            forwardData = internalSockets[fd];
            printf("internalSockets: %d\n", forwardData);
        }
 
    memset(buffer, 0, sizeof(buffer));
    if ((n = recv(fd, buffer, BUFLEN, 0)) < 0)            // проверим, есть ли что почитать
        perror("recv");
    printf("OK\n");
    printf("n = %zd\n", n);
    printf("buffer = %s", buffer);
    if ((send(forwardData, buffer, n, 0)) < 0)            // убедимся, что EPIPE приходит отсюда
        perror("send");
    
    return TRUE;
}

if (!forwardData(events[i].data.fd))

if (forwardData(events[i].data.fd) == 0)