---

server.c

Go to the documentation of this file.

/*
 * FER - LSS - PPMPS
 * Fakultet elektrotehnike i računarstva (http://www.fer.hr/)
 * Unska 3, 10000 Zagreb, Hrvatska
 * 
 * (c) 2001 FER, Zagreb. Sva prava pridržana.
 * (c) 2001 LSS. Sva prava pridržana.
 */


/* test mode is default mode upon server startup */
#define TEST_MODE

#ifndef __SERVER
#include <server.h>
#endif

/* help message */
const char *help =
"ADC-ZESOI server v" VERSION ".\n"
"Usage:\n"
" server [options]\n"
"Options are:\n"
" -h --help      Prints this help message.\n"
#ifdef TEST_MODE
" -t --test      Test mode - server creates random data (default).\n"
"    --notest    Test mode disabled. Can't be used together with -t.\n"
#else
" -t --test      Test mode - server creates random data.\n"
"    --notest    Test mode disabled (default). Can't be used together with -t.\n"
#endif
" -p <port>, --port=<port>   Sets port to <port>. If ommited default port\n"
"                for ADC-ZESOI protocol (port 7777) is used.\n"
" -a --auth      Requires authentification. Default is no\n"
"                authentfication required (option -n).\n"
" -n --noauth    Disable authentification (default). Can't be\n"
"                used together with -a.\n"
"    --nullok    Allow access for passwordless accounts.\n"
"    --maxretries=<retries>   Sets maximum number of login attempts to\n"
"                given number. Default value is 3 login attempts.\n"
" -v --version   Show version number.\n";

int main(int argc, char *argv[])
{
  char *buffer; /* temporary buffer */
  char *hostname; /* hostname (automaticaly determined) */
  int sockfd; /* socket handle */
  int new_fd; /* connection handle */
  int argno; /* used for argument processing */
  char *p1, *p2; /* used for argument processing */
  unsigned long int port_param; /* used for argument processing */
  unsigned long int retries_param; /* used for argument processing */
  short authorisation; /* authorisation flag */
  short test_mode; /* test mode flag */
  unsigned short int port; /* default port */
  struct sockaddr_in my_addr;
  struct sockaddr_in their_addr;
  struct hostent *hostdata;
  socklen_t sin_size, kpl_size;
  int kpl_value;
  pid_t pid; /* process ID number */
  command_t status; /* current server status */
  command_t command; /* status change caused by current command */

  /* open socket */
  sockfd = socket(AF_INET, SOCK_STREAM, 0);
  if (-1 == sockfd)
    {
      perror("ADC-ZESOI: Socket");
      exit(EXIT_FAILURE);
    }

  /* set defaults */
  port = PORT;
  global_max_login_no = MAX_LOGIN;
  global_null_ok = FALSE;
  authorisation = AUTHNOTPROCESSED;
  test_mode = MODENOTPROCESSED;
  global_stream_pid = -1;
  kpl_value = 1;
  kpl_size = sizeof(int);

  /* set signal handlers */
  signal(SIGCHLD, cleanallchildren);

  /* parse parameters */
  for(argno=1; argno<argc; argno++)
    {
      if ('-' == argv[argno][0])
        {
          /* process argument */
          if ('-' == argv[argno][1])
            {
              /**** long command argument ************************************/
              if (0 == strcmp(argv[argno]+2, "test"))
                {
                  if (MODENOTPROCESSED != test_mode)
                    {
                      goto conflicting_parameter;
                    }
                  test_mode = MODEPROCESSED;
                  global_test_mode = TRUE;
                }
              else if (0 == strcmp(argv[argno]+2, "notest"))
                {
                  if (MODENOTPROCESSED != test_mode)
                    {
                      goto conflicting_parameter;
                    }
                  test_mode = MODEPROCESSED;
                  global_test_mode = FALSE;
                }
              else if (0 == strcmp(argv[argno]+2, "help"))
                {
                  fprintf(stdout, "%s", help);
                  exit(EXIT_SUCCESS);
                }
              else if (0 == strcmp(argv[argno]+2, "auth"))
                {
                  if (AUTHNOTPROCESSED != authorisation)
                    {
                      goto conflicting_parameter;
                    }
                  authorisation = AUTH;
                }
              else if (0 == strcmp(argv[argno]+2, "noauth"))
                {
                  if (AUTHNOTPROCESSED != authorisation)
                    {
                      goto conflicting_parameter;
                    }
                  authorisation = NOAUTH;
                }
              else if (0 == strcmp(argv[argno]+2, "nullok"))
                {
                  global_null_ok = TRUE;
                }
              else if (0 == strcmp(argv[argno]+2, "version"))
                {
                  fprintf(stdout, "ADC-ZESOI server version: " VERSION "\n");
                  exit(EXIT_SUCCESS);
                }
              else if( (strlen(argv[argno]+2) > 10) &&
                       (0 == strncmp(argv[argno]+2, "maxretries=", 11)) )
                {
                  errno = 0;
                  p1 = argv[argno] + 13;
                  retries_param = strtoul(p1, &p2, 0);
                  if ( (ERANGE == errno) ||
                       (p2 == p1) ||
                       (UINT_MAX < retries_param) ||
                       (0 == retries_param) )
                    {
                      fprintf(stderr, "Invalid number of retries, using default value (3).\n");
                    }
                  else
                    {
                      global_max_login_no = (unsigned int)retries_param;
                    }
                }
              else if ( (strlen(argv[argno]+2) > 4) &&
                        (0 == strncmp(argv[argno]+2, "port=", 5)) )
                {
                  errno = 0;
                  p1 = argv[argno] + 7;
                  port_param = strtoul(p1, &p2, 0);
                  if ( (ERANGE == errno) ||
                       (p2 == p1) ||
                       (USHRT_MAX < port_param) )
                    {
                      fprintf(stderr, "Invalid port number, using default value (port 7777).\n");
                    }
                  else
                    {
                      port = (unsigned short int)port_param;
                    }
                }
              else
                {
                  /* unkonwn parameter */
                  goto invalid_parameter;
                }
            }
          else if('\0' != argv[argno][1])
            {
              /**** short command argument ***********************************/
              if ('\0' != argv[argno][2])
                {
                  /* more than one letter */
                  goto invalid_parameter;
                }
              switch (argv[argno][1])
                {
                case 't':
                  if (MODENOTPROCESSED != test_mode)
                    {
                      goto conflicting_parameter;
                    }
                  test_mode = MODEPROCESSED;
                  global_test_mode = TRUE;
                  break;

                case 'p':
                  if (argno+1 == argc)
                    {
                      goto invalid_parameter;
                    }
                  argno += 1;
                  errno = 0;
                  p1 = argv[argno];
                  port_param = strtol(p1, &p2, 0);
                  if ( (ERANGE == errno) ||
                       (p2 == p1) ||
                       (USHRT_MAX < port_param) )
                    {
                      fprintf(stderr, "Invalid port number, using default value (port 7777).\n");
                    }
                  else
                    {
                      port = (unsigned short int)port_param;
                    }
                  break;

                case 'a':
                  if (AUTHNOTPROCESSED != authorisation)
                    {
                      goto conflicting_parameter;
                    }
                  authorisation = AUTH;
                  break;

                case 'n':
                  if (AUTHNOTPROCESSED != authorisation)
                    {
                      goto conflicting_parameter;
                    }
                  authorisation = NOAUTH;
                  break;

                case 'v':
                  fprintf(stdout, "ADC-ZESOI server version: " VERSION "\n");
                  exit(EXIT_SUCCESS);
                  break;

                case 'h':
                  fprintf(stdout, "%s", help);
                  exit(EXIT_SUCCESS);
                  break;

                default:
                invalid_parameter:
                  fprintf(stderr, "Invalid option %s.\n%s", argv[argno], help);
                  exit(EXIT_FAILURE);
                conflicting_parameter:
                  fprintf(stderr, "Conflicting option %s.\n%s", argv[argno], help);
                  exit(EXIT_FAILURE);
                }
              /* switch */
            }
          else
            {
              /* only - without command letter */
              goto invalid_parameter;
            }
        }
      else
        {
          /* error - invalid parameter */
          goto invalid_parameter;
        }
    }
  /* for */

  /* set defaults */
  if (AUTHNOTPROCESSED == authorisation)
    {
      authorisation = NOAUTH;
    }
  my_addr.sin_family = AF_INET;
  my_addr.sin_port = htons(port);
  my_addr.sin_addr.s_addr = INADDR_ANY;
  bzero(&(my_addr.sin_zero), 8);
#ifdef DEBUG
  fprintf(stderr, "ADC-ZESOI: Port set to %hd.\n", port);
#endif

  /* check UID */
  if (ROOT_UID != geteuid())
    {
      /* can't preform authentification - force test mode */
      authorisation = NOAUTH;
      global_test_mode = TRUE;
      fprintf(stderr, "Server is not setuid root.\n"
              "Test mode is forced and authentification disabled.\n");
    }

  /* bind socket and start listening */
  if (-1 == bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)))
    {
      perror("ADC-ZESOI: Bind");
      exit(EXIT_FAILURE);
    }
  if (-1 == listen(sockfd, BACKLOG))
    {
      perror("ADC-ZESOI: Listen");
      exit(EXIT_FAILURE);
    }

  /* determine host name */
  hostdata = gethostbyname("localhost");
  if (NULL == hostdata)
    {
      hostname = (char *)malloc(10*sizeof(char));
      strcpy(hostname, "localhost");
    }
  else
    {
      hostname = hostdata->h_name;
    }
#ifdef DEBUG
  fprintf(stderr, "ADC-ZESOI: Hostname set to %s.\n", hostname);
#endif

  /* main loop */
  while (TRUE)
    {
      /* wait for connection */
      sin_size = sizeof(struct sockaddr_in);
      new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size);
      if (-1 == new_fd)
        {
          perror("ADC-ZESOI: Accept");
          continue;
        }
#ifdef DEBUG
      fprintf(stderr, "ADC-ZESOI: Got connection from %s.\n", inet_ntoa(their_addr.sin_addr));
#endif

      /* set signal handlers */
      global_fd = new_fd;
      signal(SIGPIPE, lostconnection);

      /* fork */
      pid = fork();
      global_pid = pid;
      if (0 == pid)
        {
          /* this is the child process */

          /* print welcome message */
          buffer = (void *)malloc( ( strlen(ok_message[MN_WELCOME])
                                     + strlen(hostname) + 2 )
                                   * sizeof(char) );
          if (NULL == buffer)
            {
              close(new_fd);
              exit(EXIT_FAILURE);
            }
          sprintf(buffer, ok_message[MN_WELCOME], hostname);
          if (-1 == send(new_fd, buffer, strlen(buffer), 0)) perror("ADC-ZESOI: Send");
          free(buffer);

          /* set defaults */
          status.command_no = CN_NO_COMMAND;
          status.error_code = EC_NO_ERROR;
          status.help_code = CN_NO_COMMAND;
          status.no_of_samples = DEFAULT_NO_SAMPLES;
          status.channel = DEFAULT_CHANNEL;
          status.resolution = DEFAULT_RESOLUTION;
          status.authorised = authorisation;
          status.stream = FALSE;
          status.exit = FALSE;
          status.username[0] = '\0';
          status.password[0] = '\0';

          /* command loop */
          while (FALSE == status.exit)
            {
              /* read command */
              buffer = readcommand(new_fd);
              if (NULL == buffer) break;
#ifdef DEBUG
              fprintf(stderr, "ADC-ZESOI: Received %d bytes.\n", strlen(buffer));
#endif

              /* parse command */
              command = parsecommand(buffer, status);
#ifdef DEBUG
              fprintf(stderr, "ADC-ZESOI: Command number: %d Error code: %d\n",
                      command.command_no, command.error_code);
#endif

              /* execute command */
              status = executecommand(command, status, new_fd);

              /* clean up */
              free(buffer);
            }

          /* print goodbye message */
          buffer = (void *)malloc( ( strlen(ok_message[MN_GOODBYE])
                                     + strlen(hostname) + 2 )
                                   * sizeof(char) );
          if (NULL == buffer)
            {
              close(new_fd);
              exit(EXIT_FAILURE);
            }
          sprintf(buffer, ok_message[MN_GOODBYE], hostname);
          if (-1 == send(new_fd, buffer, strlen(buffer), 0)) perror("ADC-ZESOI: Send");
          free(buffer);
          close(new_fd);
          exit(EXIT_SUCCESS);
        }
      else if (-1 == pid)
        {
          perror("ADC-ZESOI: Fork");
        }
      else
        {
          /* this is the parent process */
#ifdef DEBUG
          fprintf(stderr, "ADC-ZESOI: Started child process %d.\n", pid);
#endif
        }
      close(new_fd);
    }
}
/* main */





char*
readcommand(int fd)
{
  char *buffer, *new_buffer;
  size_t m;
  ssize_t n;

  m = 1;
  new_buffer = buffer = (char *)malloc((m*BUFFER_SIZE + 1)*sizeof(char));
  if (NULL == buffer) return buffer;
  while( (n = read(fd, (void *)new_buffer, BUFFER_SIZE)) )
    {
      if (-1 == n)
        {
          free(buffer);
#ifdef DEBUG
          perror("ADC-ZESOI: Read");
#endif
          return NULL;
        }
      else if (n < BUFFER_SIZE)
        {
          break;
        }
      else
        {
          m += 1;
          new_buffer = (char *)realloc((void *)buffer, (m*BUFFER_SIZE+1)*sizeof(char));
          if (NULL == new_buffer) break;
          buffer = new_buffer;
          new_buffer = buffer + ((m - 1) * BUFFER_SIZE);
        }
    }
  buffer[(m - 1) * BUFFER_SIZE + n] = 0;

  return buffer;
}
/* readcommand */





command_t
parsecommand (const char *input, command_t status)
{
  command_t c;
  char *i, *j;
  char *temp;
  int n;
  int command_no, channel, no_of_samples;

  /* copy status to new command */
  c.command_no = CN_ERROR;
  c.error_code = EC_PARSE_FAILURE;
  c.help_code = CN_NO_COMMAND;
  c.no_of_samples = status.no_of_samples;
  c.channel = status.channel;
  c.authorised = status.authorised;
  c.stream = FALSE;
  c.exit = FALSE;
  c.resolution = status.resolution;
  strcpy(c.username, status.username);
  strcpy(c.password, status.password);

  /* preprocess input data */
  temp = (char *)malloc((strlen(input) + 1)*sizeof(char));
  if ((NULL == temp)) return c;
  n = 0;
  while(0 != *(input + n)) *(temp + n++) = toupper( *(input + n) );
  *(temp + n) = 0;

  /* tokenize input data - find first token */
  i = strtok(temp, DELIMITERS);
#ifdef DEBUG
  fprintf(stderr, "ADC-ZESOI: First token is: %s.\n", i);
#endif


  /* identify command */
  if (NULL == i)
    {
      command_no = MAX_CN_NO;
    }
  else
    {
      for (command_no=0; command_no<MAX_CN_NO; command_no++)
        {
          if(0 == strcmp(command[command_no],i)) break;
        }
    }

  /* parse if identified */
  j = strtok(NULL, DELIMITERS);
  switch (command_no)
    {

    case CN_USER:
      /**** command USER *********************************************/
      c.command_no = command_no;
      if (NOAUTH == c.authorised)
        {
          c.error_code = EC_USER_NO_AUTHORISATION_REQUIRED;
          break;
        }
      if (NULL == j)
        {
          c.error_code = EC_USER_NO_NAME;
          break;
        }
      i = strtok(NULL, DELIMITERS);
      if(NULL != i)
        {
          c.error_code = EC_USER_ERROR; 
        }
      else if(strlen(j) > MAX_LENGTH)
        {
          c.error_code = EC_USER_OVERRUN;
        }
      else
        {
          strcpy(temp, input);
          j = strtok(temp, DELIMITERS);
          j = strtok(NULL, DELIMITERS);
          strcpy(c.username, j);
          c.error_code = EC_NO_ERROR;
        }
      break;

    case CN_PASS:
      /**** command PASS *********************************************/
      c.command_no = command_no;
      if (NOAUTH == c.authorised)
        {
          c.error_code = EC_PASS_NO_AUTHORISATION_REQUIRED;
          break;
        }
      else if (AUTHORISED == c.authorised)
        {
          c.error_code = EC_PASS_ALREADY_AUTHORISED;
          break;
        }
      if (NULL == j)
        {
          if (FALSE == global_null_ok)
            {
              c.error_code = EC_PASS_NO_PASS;
              break;
            }
          c.error_code = EC_NO_ERROR;
          c.password[0] = '\0';
          break;
        }
      i = strtok(NULL, DELIMITERS);
      if(NULL != i)
        {
          c.error_code = EC_PASS_ERROR;
        }
      else if(strlen(j) > MAX_LENGTH)
        {
          c.error_code = EC_PASS_OVERRUN;
        }
      else if(strlen(c.username) == 0)
        {
          c.error_code = EC_PASS_NO_USER_NAME;
        }
      else
        {
          strcpy(temp, input);
          j = strtok(temp, DELIMITERS);
          j = strtok(NULL, DELIMITERS);
          strcpy(c.password, j);
          c.error_code = EC_NO_ERROR;
        }
      break;

    case CN_SET:
      /**** command SET **********************************************/
      c.command_no = command_no;
      if ( (NOTAUTHORISED == c.authorised) ||
           (AUTH == c.authorised) )
        {
          c.error_code = EC_SET_UNAUTHORISED;
          break;
        }
      if (NULL == j)
        {
          c.error_code = EC_SET_NO_CHANNEL; 
          break;
        }
      i = strtok(NULL, DELIMITERS);
      if(NULL != i)
        {
          c.error_code = EC_SET_ERROR;
          break;
        }
      channel = atoi(j);
      if ((channel < MIN_CHANNEL) || (channel > MAX_CHANNEL))
        {
          c.error_code = EC_SET_INVALID;
          break;
        }
      c.channel = channel;
      c.error_code = EC_NO_ERROR;
      break;

    case CN_GET:
      /**** command GET **********************************************/
      c.command_no = command_no;
      if ( (NOTAUTHORISED == c.authorised) ||
           (AUTH == c.authorised) )
        {
          c.error_code = EC_GET_UNAUTHORISED;
          break;
        }
      if (NULL == j)
        {
          c.error_code = EC_GET_NO_ARGUMENT; 
          break;
        }
      i = strtok(NULL, DELIMITERS);
      if(NULL != i)
        {
          c.error_code = EC_GET_ERROR;
          break;
        }
      if (0 == strcmp(j, GET_STREAM_ARGUMENT))
        {
          c.no_of_samples = DATA_STREAM;
        }
      else
        {
          no_of_samples = atoi(j);
          if (no_of_samples <= 0)
            {
              c.error_code = EC_GET_INVALID_NO_OF_SAMPLES;
              break;
            }
          c.no_of_samples = no_of_samples;
        }
      c.error_code = EC_NO_ERROR;
      break;

    case CN_RESOLUTION:
      /**** command RESOLUTION ***************************************/
      c.command_no = command_no;
      if ( (NOTAUTHORISED == c.authorised) ||
           (AUTH == c.authorised) )
        {
          c.error_code = EC_RESOLUTION_UNAUTHORISED;
          break;
        }
      if (NULL == j)
        {
          c.error_code = EC_RESOLUTION_NO_ARGUMENT;
          break;
        }
      i = strtok(NULL, DELIMITERS);
      if(NULL != i)
        {
          c.error_code = EC_RESOLUTION_ERROR;
          break;
        }
      if ( (0 == strcmp(j, RESOLUTION_HIGH)) ||
           (0 == strcmp(j, RESOLUTION_H)) )
        {
          c.resolution = 'H';
        }
      else if ( (0 == strcmp(j, RESOLUTION_MEDIUM)) ||
                (0 == strcmp(j, RESOLUTION_M)) )
        {
          c.resolution = 'M';
        }
      else if ( (0 == strcmp(j, RESOLUTION_LOW)) ||
                (0 == strcmp(j, RESOLUTION_L)) )
        {
          c.resolution = 'L';
        }
      else
        {
          c.error_code = EC_RESOLUTION_INVALID;
          break;
        }
      c.error_code = EC_NO_ERROR;
      break;

    case CN_START:
      /**** command START ********************************************/
      c.command_no = command_no;
      if ( (NOTAUTHORISED == c.authorised) ||
           (AUTH == c.authorised) )
        {
          c.error_code = EC_START_UNAUTHORISED;
        }
      else
        {
          c.error_code = EC_NO_ERROR;
        }
      break;

    case CN_STOP:
      /**** command STOP *********************************************/
      c.command_no = command_no;
      if (DATA_STREAM != c.no_of_samples)
        {
          c.error_code = EC_STOP_NO_STREAM;
        }
      else if ( (NOTAUTHORISED == c.authorised) ||
                (AUTH == c.authorised) )
        {
          c.error_code = EC_STOP_UNAUTHORISED;
        }
      else
        {
          c.error_code = EC_NO_ERROR;
        }
      break;

    case CN_HELP:
      /**** command HELP *********************************************/
      c.command_no = command_no;
      if (NULL == j)
        {
          c.error_code = EC_NO_ERROR;
          c.help_code = MAX_CN_NO;
          break;
        }
      i = strtok(NULL, DELIMITERS);
      if(NULL != i)
        {
          c.error_code = EC_HELP_INVALID_COMMAND;
          c.help_code = CN_NO_COMMAND;
          break;
        }
      for (command_no=0; command_no<MAX_CN_NO; command_no++)
        {
          if(0 == strcmp(command[command_no],j)) break;
        }
      if (command_no == MAX_CN_NO)
        {
          c.error_code = EC_HELP_INVALID_COMMAND;
          c.help_code = CN_NO_COMMAND;
          break;
        }
      c.error_code = EC_NO_ERROR;
      c.help_code = command_no;
      break;

    case CN_BYE:
    case CN_EXIT:
    case CN_QUIT:
      /**** commands BYE, EXIT, QUIT *********************************/
      c.command_no = command_no;
      c.error_code = EC_NO_ERROR;
      c.exit = TRUE;
      break;

    case MAX_CN_NO:
    default:
      /**** unknown command ******************************************/
      c.command_no = CN_ERROR;
      c.error_code = EC_UNKNOWN_COMMAND;
    }

  /* cleanup */
  free(temp);

  return c;
}
/* parsecommand */





command_t
executecommand (command_t c, command_t status, int fd)
{
  static unsigned int login_counter; /* login attempt counter */
  char *hostname; /* hostname (automaticaly determined) */
  struct hostent *hostdata;
  char *buffer, *p1, *p2, *p3; /* buffers and pointers */
  long size; /* size of password file */
  FILE *passwd; /* password file */
  size_t length; /* username length */
  int acquire_status; /* result of data acquisition */
  int i;
  pid_t pid;

  if ( (TRUE == status.stream) &&
       (CN_STOP != c.command_no) )
    {
      /* stream is active (server is sending samples) */
      /* and command is not STOP */

      /*******************************************************/
      /* SIMPLY IGNORE THIS SITUATION - User has requested a */
      /* data stream and has issued  an invalid command or a */
      /* command different than STOP. As data stream can not */
      /* be interrupted, simply do nothing.                  */
      /*******************************************************/
#ifdef DEBUG
      fprintf(stderr, "ADC-ZESOI: WARNING: Stream is acitve and command isn't STOP.\n");
#endif

    }
  else if (c.error_code >= 0)
    {
      /* parse error - print error message */
      if (-1 == send(fd, error_message[c.error_code],
                     strlen(error_message[c.error_code]), 0))
        {
          perror("ADC-ZESOI: Send");
        }
    }
  else
    {
      /* execute command */
      switch (c.command_no)
        {
          
        case CN_USER:
          /**** command USER *********************************************/
          strcpy(status.username, c.username);

          /* reset status */
          status.authorised = NOTAUTHORISED;
          login_counter = 0;

          /* print OK message */
          buffer = (void *)malloc( ( strlen(ok_message[MN_USER])
                                     + strlen(c.username) + 2 )
                                   * sizeof(char) );
          if (NULL == buffer)
            {
              exit(EXIT_FAILURE);
            }
          sprintf(buffer, ok_message[MN_USER], c.username);
          if (-1 == send(fd, buffer, strlen(buffer), 0)) perror("ADC-ZESOI: Send");
          free(buffer);
          break;
          
        case CN_PASS:
          /**** command PASS *********************************************/
          strcpy(status.password, c.password);

          /* assume passwords are shadowed */
          passwd = fopen("/etc/shadow","rt");
          if (NULL == passwd)
            {
              perror("ADC-ZESOI: /etc/shadow");
              /* passwords aren't shadowed */
              passwd = fopen("/etc/passwd","rt");
              if (NULL == passwd)
                {
                  perror("ADC-ZESOI: /etc/passwd");
                  break;
                }
            }
#ifdef DEBUG
          fprintf(stderr, "ADC-ZESOI: Password file opened.\n");
#endif

          /* load passwords into temporary buffer */
          fseek(passwd, 0, SEEK_END);
          size = ftell(passwd);
          rewind(passwd);
          buffer = (char *)malloc( (size+1)*sizeof(char) );
          if (NULL == buffer)
            {
              perror("ADC-ZESOI: Authentification failed");
              fclose(passwd);
              break;
            }
          fread(buffer, size, sizeof(char), passwd);
          buffer[size] = '\0';
          fclose(passwd);

          /* locate user */
          length = strlen(status.username);
          p1 = strtok(buffer, "\n\x0A\x0D");
          do
            {
              if (0 == strncmp(p1, status.username, length))
                {
                  /* user found */
                  /* extract password field delimited with : */
                  p2 = strstr(p1, ":") + 1;
                  p3 = strstr(p2, ":");
                  p3[0] = '\0';

                  /* check for paswordless accounts */
                  if (('\0' == p2[0]) && (FALSE == global_null_ok))
                    {
                      if (-1 == send(fd, error_message[EC_PASS_PASSWORDLESS],
                                     strlen(error_message[EC_PASS_PASSWORDLESS]), 0) )
                        {
                          perror("ADC-ZESOI: Send");
                        }

                      /* clean up */
                      memset(buffer, 0, size*sizeof(char));
                      free(buffer);
                      break;
                    }

                  /* account locked */
                  if (0 == strncmp(p2, "!", 1))
                    {
                      /* clean up */
                      memset(buffer, 0, size*sizeof(char));
                      free(buffer);

                      if (-1 == send(fd, error_message[EC_PASS_LOCKED],
                                     strlen(error_message[EC_PASS_LOCKED]), 0) )
                        {
                          perror("ADC-ZESOI: Send");
                        }

                      break;
                    }

                  /* special account - deny access */
                  if (0 == strncmp(p2, "*", 1))
                    {
                      /* clean up */
                      memset(buffer, 0, size*sizeof(char));
                      free(buffer);

                      /* print error message */
                      buffer = (void *)malloc( (strlen(error_message[EC_PASS_DENIED]) +
                                                strlen(status.username) + 1) * sizeof(char) );
                      if (NULL == buffer)
                        {
                          exit(EXIT_FAILURE);
                        }
                      sprintf(buffer, error_message[EC_PASS_DENIED], status.username);
                      if (-1 == send(fd, buffer, strlen(buffer), 0)) 
                        {
                          perror("ADC-ZESOI: Send");
                        }
                      free(buffer);
                      break;
                    }

                  if (0 == strcmp(p2, crypt(status.password, p2)))
                    {
                      /* authorisation successful */
                      status.authorised = AUTHORISED;

                      /* clean up */
                      memset(status.password, 0, strlen(status.password));
                      memset(buffer, 0, size*sizeof(char));
                      free(buffer);

                      /* print OK message */
                      buffer = (void *)malloc( (strlen(ok_message[MN_PASS]) +
                                                strlen(status.username) + 1) * sizeof(char) );
                      if (NULL == buffer)
                        {
                          exit(EXIT_FAILURE);
                        }
                      sprintf(buffer, ok_message[MN_PASS], status.username);
                      if (-1 == send(fd, buffer, strlen(buffer), 0)) 
                        {
                          perror("ADC-ZESOI: Send");
                        }
                      free(buffer);
                      break;
                    }
                  else
                    {
                      /* authorisation failed */
                      /* increase login attempt counter and sleep for some time */
                      login_counter += 1;
                      sleep(LOGIN_SLEEP_TIME);

                      if (-1 == send(fd, error_message[EC_PASS_INCORRECT],
                                     strlen(error_message[EC_PASS_INCORRECT]), 0) )
                        {
                          perror("ADC-ZESOI: Send");
                        }

                      /* terminate connection if maximum login count is reached */
                      if (login_counter >= global_max_login_no)
                        {
                          if (-1 == send(fd, error_message[EC_PASS_DISCONNECTED],
                                         strlen(error_message[EC_PASS_DISCONNECTED]), 0) )
                            {
                              perror("ADC-ZESOI: Send");
                            }

                          /* print goodbye message */
                          hostdata = gethostbyname("localhost");
                          if (NULL == hostdata)
                            {
                              hostname = (char *)malloc(10*sizeof(char));
                              strcpy(hostname, "localhost");
                            }
                          else
                            {
                              hostname = hostdata->h_name;
                            }
                          buffer = (void *)malloc( ( strlen(ok_message[MN_GOODBYE])
                                                     + strlen(hostname) + 2 )
                                                   * sizeof(char) );
                          if (NULL == buffer)
                            {
                              close(fd);
                              exit(EXIT_FAILURE);
                            }
                          sprintf(buffer, ok_message[MN_GOODBYE], hostname);
                          if (-1 == send(fd, buffer, strlen(buffer), 0)) perror("ADC-ZESOI: Send");
                          free(buffer);
#ifdef DEBUG
                          fprintf(stderr, "ADC-ZESOI: Terminating connection - maximum number of login attempts.\n");
#endif
                          exit(EXIT_SUCCESS);
                        }

                      /* clean up */
                      memset(buffer, 0, size*sizeof(char));
                      free(buffer);

                      break;
                    }
                }
              p1 = strtok(NULL, "\n\x0A\x0D");
            }
          while (p1 != NULL);

          if (NULL == p1)
            {
              /* user not found */
              if (-1 == send(fd, error_message[EC_USER_UNKNOWN],
                             strlen(error_message[EC_USER_UNKNOWN]), 0) )
                {
                  perror("ADC-ZESOI: Send");
                }

              /* cleanup */
              memset(buffer, 0, size*sizeof(char));
              free(buffer);
            }
          break;
          
        case CN_SET:
          /**** command SET **********************************************/
          status.channel = c.channel;
          buffer = (void *)malloc( ( strlen(ok_message[MN_SET])
                                     + 10 )
                                   * sizeof(char) );
          if (NULL == buffer)
            {
              exit(EXIT_FAILURE);
            }
          sprintf(buffer, ok_message[MN_SET], c.channel);
          if (-1 == send(fd, buffer, strlen(buffer), 0)) perror("ADC-ZESOI: Send");
          free(buffer);
          break;

        case CN_GET:
          /**** command GET **********************************************/
          if (DATA_STREAM == c.no_of_samples)
            {
              status.no_of_samples = DATA_STREAM;
              if (-1 == send(fd, ok_message[MN_GET_STREAM],
                             strlen(ok_message[MN_GET_STREAM]), 0) )
                {
                  perror("ADC-ZESOI: Send");
                }
            }
          else
            {
              status.no_of_samples = c.no_of_samples;
              buffer = (void *)malloc( ( strlen(ok_message[MN_GET_SAMPLES])
                                         + 25 )
                                       * sizeof(char) );
              if (NULL == buffer)
                {
                  exit(EXIT_FAILURE);
                }
              sprintf(buffer, ok_message[MN_GET_SAMPLES], c.no_of_samples);
              if (-1 == send(fd, buffer, strlen(buffer), 0)) perror("ADC-ZESOI: Send");
              free(buffer);
            }
          break;

        case CN_RESOLUTION:
          /**** command RESOLUTION ***************************************/
          status.resolution = c.resolution;
          buffer = (void *)malloc( ( strlen(ok_message[MN_RESOLUTION])
                                     + 2 )
                                   * sizeof(char) );
          if (NULL == buffer)
            {
              exit(EXIT_FAILURE);
            }
          sprintf(buffer, ok_message[MN_RESOLUTION], c.resolution);
          if (-1 == send(fd, buffer, strlen(buffer), 0)) perror("ADC-ZESOI: Send");
          free(buffer);
          break;

        case CN_START:
          /**** command START ********************************************/
          if (DATA_STREAM == status.no_of_samples)
            {
              /* sending data stream */
              status.stream = TRUE;

              /* set signal handler */
              signal(SIGTERM, stopstream);

              /* fork */
              pid = fork();
              global_stream_pid = pid;
              if (0 == pid)
                {
                  /* this is a child process */
                  if (-1 == send(fd, ok_message[MN_START_STREAM],
                                 strlen(ok_message[MN_START_STREAM]), 0) )
                    {
                      perror("ADC-ZESOI: Send stream");
                    }

                  /* print stream information data */
                  /* test mode information */
                  if (TRUE == global_test_mode)
                    {
                      if (-1 == send(fd, ok_message[MN_START_TEST_STREAM],
                                     strlen(ok_message[MN_START_TEST_STREAM]), 0))
                        {
                          perror("ADC-ZESOI: Send stream");
                        }
                    }
                  /* stream resolution */
                  buffer = (void *)malloc( ( strlen(ok_message[MN_START_RESOLUTION])
                                             + 2 )
                                           * sizeof(char) );
                  if (NULL == buffer)
                    {
                      exit(EXIT_FAILURE);
                    }
                  sprintf(buffer, ok_message[MN_START_RESOLUTION], status.resolution);
                  if (-1 == send(fd, buffer, strlen(buffer), 0))
                    {
                      perror("ADC-ZESOI: Send stream");
                    }
                  free(buffer);

                  /* allocate buffer for sending */
                  if (TRUE == global_test_mode)
                    {
                      buffer = (void *)malloc(80 * sizeof(char));
                      if (NULL == buffer)
                        {
                          exit(EXIT_FAILURE);
                        }
                    }
                  /* send until SIGTERM is received */
                  while (TRUE)
                    {
                      if (TRUE == global_test_mode)
                        {
                          /* sending random data values for testing purposes */
                          sprintf(buffer, "%f\n", (double)rand()/RAND_MAX);
                          if (-1 == send(fd, buffer, strlen(buffer), 0))
                            {
                              perror("ADC-ZESOI: Send stream");
                            }
#ifdef SLEEP
                          sleep(1);
#endif
                        }
                      else
                        {
                          /* send STREAM_CHUNK samples at the time */
                          acquire_status = acquireandsendsamples(fd, STREAM_CHUNK,
                                                                 status.channel, status.resolution);
                          if (ACQUIRE_FAILURE == acquire_status)
                            {
                              fprintf(stderr, "ADC-ZESOI: Data acquisition error.\n");
                            }
                        }
                    }
                }
              else if (-1 == pid)
                {
                  perror("ADC-ZESOI: Fork:");
                }
            }
          else
            {
              /* sending samples */
              buffer = (void *)malloc( ( strlen(ok_message[MN_START_SAMPLES])
                                         + 20 )
                                       * sizeof(char) );
              if (NULL==buffer)
                {
                  exit(EXIT_FAILURE);
                }
              sprintf(buffer, ok_message[MN_START_SAMPLES], status.no_of_samples);
              if (-1 == send(fd, buffer, strlen(buffer), 0))
                {
                  perror("ADC-ZESOI: Send samples");
                }
              free(buffer);

              /* print stream information data */
              /* test mode information */
              if (TRUE == global_test_mode)
                {
                  buffer = (void *)malloc( ( strlen(ok_message[MN_START_TEST_SAMPLES])
                                             + 20 )
                                           * sizeof(char) );
                  if (NULL == buffer)
                    {
                      exit(EXIT_FAILURE);
                    }
                  sprintf(buffer, ok_message[MN_START_TEST_SAMPLES],status.no_of_samples);
                  if (-1 == send(fd, buffer, strlen(buffer), 0))
                    {
                      perror("ADC-ZESOI: Send samples");
                    }
                }
              /* samples resolution */
              buffer = (void *)malloc( ( strlen(ok_message[MN_START_RESOLUTION])
                                         + 2 )
                                       * sizeof(char) );
              if (NULL == buffer)
                {
                  exit(EXIT_FAILURE);
                }
              sprintf(buffer, ok_message[MN_START_RESOLUTION], status.resolution);
              if (-1 == send(fd, buffer, strlen(buffer), 0))
                {
                  perror("ADC-ZESOI: Send stream");
                }
              free(buffer);

              /* send samples */
              if (TRUE == global_test_mode)
                {
                  /* allocate buffer for sending */
                  buffer = (void *)malloc(80 * sizeof(char));
                  if (NULL == buffer)
                    {
                      exit(EXIT_FAILURE);
                    }
                  /* sending random data values for testing purposes */
                  for (i=0; i<status.no_of_samples; i++)
                    {
                      sprintf(buffer, "%f\n", (double)rand()/RAND_MAX);
                      if (-1 == send(fd, buffer, strlen(buffer), 0))
                        {
                          perror("ADC-ZESOI: Send samples");
                        }
#ifdef SLEEP
                      sleep(1);
#endif
                    }
                  free(buffer);
                }
              else
                {
                  /* sending samples */
                  acquire_status = acquireandsendsamples(fd, status.no_of_samples,
                                                          status.channel, status.resolution);
                  if (ACQUIRE_FAILURE == acquire_status)
                    {
                      fprintf(stderr, "ADC-ZESOI: Data acquisition error.\n");
                    }
                }

              /* transfer completed */
              if (-1 == send(fd, ok_message[MN_TRANSFER_COMPLETED],
                             strlen(ok_message[MN_TRANSFER_COMPLETED]), 0))
                {
                  perror("ADC-ZESOI: Start");
                }
            }
          break;

        case CN_STOP:
          /**** command STOP *********************************************/
          status.stream = FALSE;
          if (0 < global_stream_pid)
            {
              if (-1 == kill(global_stream_pid, SIGTERM)) perror("ADC-ZESOI: Stop stream");
              global_stream_pid = -1;
            }
          if (-1 == send(fd, ok_message[MN_TRANSFER_COMPLETED],
                         strlen(ok_message[MN_TRANSFER_COMPLETED]), 0))
            {
              perror("ADC-ZESOI: Stop");
            }
          if (-1 == send(fd, ok_message[MN_STOP],
                         strlen(ok_message[MN_STOP]), 0))
            {
              perror("ADC-ZESOI: Stop");
            }
          break;

        case CN_HELP:
          /**** command HELP *********************************************/
          if (-1 == send(fd, help_message[c.help_code],
                         strlen(help_message[c.help_code]), 0))
            {
              perror("ADC-ZESOI: Send");
            }
          break;

        case CN_BYE:
        case CN_EXIT:
        case CN_QUIT:
          /**** commands BYE, EXIT, QUIT *********************************/
          status.exit = c.exit;
          break;

        case MAX_CN_NO:
        default:
          /**** unknown command ******************************************/
        }
    }

  return status;
}
/* executecommand */




void lostconnection (int sig)
{
  if (0 == global_pid)
    {
      /* this is a chils process */
      close(global_fd);
#ifdef DEBUG
      fprintf(stderr, "ADC-ZESOI: WARNING: Client has terminated connection.\n");
#endif
      exit(EXIT_SUCCESS);
    }
}
/* lostconnection */




int
acquireandsendsamples (int fd, int no_of_samples, int channel, char resolution)
{
  FILE *input; /* input channel */
  float *data; /* temporary data storage */
  char buffer[80+1]; /* sending buffer */
  int step;
  int i;

  /* set skip and no_of_samples */
  if (0 >= no_of_samples)
    {
      return ACQUIRE_FAILURE;
    }
  switch (resolution)
    {
    case RESOLUTION_MC:
      step = MEDIUM_RESOLUTION_STEP;
      break;
    case RESOLUTION_LC:
      step = LOW_RESOLUTION_STEP;
      break;
    default:
      step = HIGH_RESOLUTION_STEP;
      break;
    }
  no_of_samples *= step;

  /* open requested channel */
  switch (channel)
    {
    case 2:
      input = fopen("/dev/AD_ulaz_2", "rb");
      break;
    case 3:
      input = fopen("/dev/AD_ulaz_3", "rb");
      break;
    case 4:
      input = fopen("/dev/AD_ulaz_4", "rb");
      break;
    case 5:
      input = fopen("/dev/AD_ulaz_5", "rb");
      break;
    case 6:
      input = fopen("/dev/AD_ulaz_6", "rb");
      break;
    case 7:
      input = fopen("/dev/AD_ulaz_7", "rb");
      break;
    case 8:
      input = fopen("/dev/AD_ulaz_8", "rb");
      break;
    default:
      input = fopen("/dev/AD_ulaz_1", "rb");
      break;
    }
  if (NULL == input)
    {
      return ACQUIRE_FAILURE;
    }
  data = (float *)malloc(no_of_samples*sizeof(float));
  if (NULL == data)
    {
      fclose(input);
      return ACQUIRE_FAILURE;
    }
  fread(data, no_of_samples, sizeof(float), input);
  fclose(input);

  /* send samples */
  for (i=0; i<no_of_samples; i+=step)
    {
      sprintf(buffer, "%f\n", (double)data[i]);
      if (-1 == send(fd, buffer, strlen(buffer), 0))
        {
          perror("ADC-ZESOI: Sending samples form acquire");
        }
    }

  /* clean up */
  free(data);

  return ACQUIRE_SUCCESS;
}
/* acquireandsendsamples */




void
stopstream (int sig)
{
  if (0 == global_stream_pid)
    {
      /* this is a child process */
      close(global_fd);
#ifdef DEBUG
      fprintf(stderr, "ADC-ZESOI: Stopping data stream.\n");
#endif
      exit(EXIT_SUCCESS);
    }
  else
    {
      /* parent has received SIGTERM */
      if (0 < global_stream_pid)
        {
          /* child is still sending - kill it */
          if (-1 == kill(global_stream_pid, SIGTERM)) perror("ADC-ZESOI: Stop stream");
          global_stream_pid = -1;
        }
    }
}
/* stopstream */




void
cleanallchildren (int sig)
{
  /* clean up all child processes */
  while(waitpid(-1, NULL, WNOHANG) > 0);
}
/* cleanallchildren */

---