---

nmlclean.cc

Go to the documentation of this file.

/* Program Name to print at startup. */
static char program_id[] = __FILE__ "version 1.2 compiled on" __DATE__;

#include "cms_cfg.hh"           /* CMS_CONFIG_LINELEN */
#include "nml.hh"               /* NML, NMLTYPE */
#include "nmlmsg.hh"            /* NMLmsg */
#include "cms.hh"               /* CMS  */
#include "linklist.hh"          /* RCS_LINKED_LIST */
#include "rcs_prnt.hh"          /* rcs_print_error() */

extern "C"
{
#include <stdio.h>              /* printf() */
#include <stdlib.h>             /* exit() */
#include <string.h>             /* strcmp(), strlen() */
}

enum LOCAL_CONNECT
{
  LC_NOT_ATTEMPTED = 0,
  LC_FAILED,
  LC_SUCCEEDED,
};

char LC_ARRAY[3][3] = { "NA", "F", "S" };

enum REMOTE_CONNECT
{
  RC_NOT_ATTEMPTED = 0,
  RC_FAILED,
  RC_SUCCEEDED,
};

char RC_ARRAY[3][3] = { "NA", "F", "S" };

#ifdef VXWORKS
extern "C" void nmlclean (char *config_file, char *host_name);

void
nmltest (char *config_file, char *host_name)
#else
int
main (int argc, char **argv)
#endif
{
  FILE *fp;
  LOCAL_CONNECT local_connect_status = LC_NOT_ATTEMPTED;
  REMOTE_CONNECT remote_connect_status = RC_NOT_ATTEMPTED;
  char proc_line[CMS_CONFIG_LINELEN];
  char line[CMS_CONFIG_LINELEN];
  int line_len, line_number = 0;
  char output_line[80];
  char buffer_name[CMS_CONFIG_LINELEN];
  char buffer_host[CMS_CONFIG_LINELEN];
  RCS_LINKED_LIST *output_list;
  puts (program_id);

  output_list = new RCS_LINKED_LIST;
  if (NULL == output_list)
    {
      printf ("Couldn`t malloc output list.\n");
      exit (-1);
    }

  set_rcs_print_destination (RCS_PRINT_TO_STDOUT);
#ifndef VXWORKS
  char config_file[80];
  char host_name[80];
  if (argc > 2)
    {
      /* Get host_name and config_file from command line */
      strcpy (config_file, argv[1]);
      strcpy (host_name, argv[2]);
    }
  else
    {
      /* Prompt user for config_file and host name */
      printf ("Configuration File? ");
      gets (config_file);

      printf ("Host Name? ");
      gets (host_name);
    }
#endif

  /* Open the configuration file. */
  if ((fp = fopen (config_file, "r")) == NULL)
    {
      rcs_print_error ("nmltest: can't open '%s'\n", config_file);
      exit (-1);
    }


  /* Read the configuration file line by line to find buffers. */
  while (!feof (fp))
    {
      NML *lc_nml = (NML *) NULL;
      NML *rc_nml = (NML *) NULL;

      if ((fgets (line, CMS_CONFIG_LINELEN, fp)) == NULL)
        {
          break;
        }

      line_number++;
      line_len = strlen (line);
      if (line_len > CMS_CONFIG_LINELEN)
        {
          rcs_print_error
            ("cms_cfg: Line length of line number %d in %s exceeds max length of %d",
             line_number, config_file, CMS_CONFIG_LINELEN);
        }

      if (line_len > 1)
        {
          if (line[line_len - 2] == '\\')
            {
              if (
                  (fgets
                   (line + line_len - 2, CMS_CONFIG_LINELEN - line_len,
                    fp)) == NULL)
                {
                  break;
                }
              line_number++;
            }
        }

      if (line[0] != 'B')
        {
          continue;
        }

      sscanf (line + 1, "%s %*s %s", buffer_name, buffer_host);

      /* Try to connect locally if the buffer host matches this one. */

      if (!strcmp (buffer_host, host_name))
        {
          printf ("\nAttempting to connect to %s locally . . .\n",
                  buffer_name);
          sprintf (proc_line, "P nmltest %s LOCAL %s R 0 5 0 0\n",
                   buffer_name, buffer_host);
          lc_nml = new NML (line, proc_line);
          if (NULL != lc_nml)
            {
              lc_nml->ignore_format_chain = 1;
              if (NULL != lc_nml->cms)
                {
                  lc_nml->cms->delete_totally = 1;
                  delete lc_nml;
                  lc_nml = (NML *) NULL;
                  local_connect_status = LC_SUCCEEDED;
                }
              else
                {
                  local_connect_status = LC_FAILED;
                }
            }
          else
            {
              local_connect_status = LC_FAILED;
            }
        }
      printf ("\nAttempting to connect to %s remotely . . .\n", buffer_name);
      sprintf (proc_line, "P nmltest %s REMOTE %s  R 0 5 0 0\n",
               buffer_name, host_name);
      rc_nml = new NML (line, proc_line);
      if (NULL != rc_nml)
        {
          rc_nml->ignore_format_chain = 1;
          if (NULL != rc_nml->cms)
            {
              rc_nml->cms->delete_totally = 1;
              delete rc_nml;
              rc_nml = (NML *) NULL;
              remote_connect_status = RC_SUCCEEDED;
            }
          else
            {
              remote_connect_status = RC_FAILED;
            }
        }
      else
        {
          remote_connect_status = RC_FAILED;
        }
      sprintf (output_line, "%s\t%s\t%s",
               buffer_name,
               LC_ARRAY[local_connect_status],
               RC_ARRAY[remote_connect_status]);
      output_list->store_at_tail (output_line, strlen (output_line) + 1, 1);
    }


  /* Print a nice header. */
  printf ("NMLCLEAN: terminology\n");
  printf
    ("LCS - Local Connect Status S(Success)|F(Fail)|NA(Not Attempted)\n");
  printf
    ("RCS - Remote Connect Status (What did you think RCS stood for?)\n");
  printf ("NMLTEST: Summary\n");
  printf ("BufferName\tLCS\tRCS\n");



  if (NULL != output_list)
    {
      char *next_line;
      next_line = (char *) output_list->get_head ();
      while (NULL != next_line)
        {
          puts (next_line);
          next_line = (char *) output_list->get_next ();
        }
      delete output_list;
    }

}

---