ngcbCMD.hpp

Go to the documentation of this file.

#ifndef ngcbCMD_H
#define ngcbCMD_H
 
 
#ifndef __cplusplus
#error This is a C++ include file and cannot be used from plain C
#endif
 
#include <ngc/core/ngcb.h>

#define ngcbCMD_LIST_SIZE 256
 
/*
 * Global command flags
 */
#define ngcbCMD_UPDATE    0x00000001 //< command requires system update
#define ngcbCMD_PROTECTED 0x00000002 //< protected command
#define ngcbCMD_PROTECT   0x00000004 //< enforce command protection
#define ngcbCMD_INTERNAL  0x00000008 //< internal use only
#define ngcbCMD_DISCARDED 0x00000010 //< command is declared dsicarded
 
/*
 * Special component identifiers
 */
#define ngcbCMD_ID_IVLD    -1   //< id invalid
#define ngcbCMD_ID_NOT_SET -2   //< id not set

class ngcb_cmd_handle_t 
{
public:
  int flags;

  void *udata;

  int done;

  int fd;
           
  ngcb_cmd_handle_t() {
    param_[0] = '\0';
    filter_[0] = '\0';
    flags = 0x0;
    udata = NULL;
    done = 0;
    fd = -1; // not set
    id_ = ngcbCMD_ID_NOT_SET; // not set
  }

  virtual ~ngcb_cmd_handle_t() {}

  int Id() {return (id_);}
           
  int Id(const char *filter) {
    if ((id_ != ngcbCMD_ID_NOT_SET) && (strcmp(filter, filter_) == 0))
      {
      /*
       * The id is already stored - even if it was invalid
       */
      return (id_);
      }
    else if ((strlen(param_) > 0) && (strlen(filter) < sizeof(filter_)))
      {
      char s[1024];
      char format[64];
      int n;
      strcpy(format, " ");
      strcat(format, filter);
      strcat(format, " %d %1023[^\n]");
      s[0] = '\0';
      n = sscanf(param_, format, &id_, s);
      if (n > 0)
    {
    if (n < 2) param_[0] = '\0'; // there are no further parameters
    else strcpy(param_, s);      // copy back with filter discarded
    if (id_ < 0) id_ = ngcbCMD_ID_IVLD; // id is invalid but present
    }
      else
    {
    id_ = ngcbCMD_ID_NOT_SET;
    }
      }
    else
      {
      /*
       * Parameter string is empty or filter is too large
       */
      id_ = ngcbCMD_ID_NOT_SET;
      }
    return (id_);
  }
           
  int Param(const char *p, const char *filter=NULL) {
    if (p != NULL)
      {
      if (strlen(p) > 0)
    {
    if (filter == NULL)
      {
      id_ = ngcbCMD_ID_NOT_SET;
      str2str(param_, p, sizeof(param_) - 1);
      }
    else if (strlen(filter) < sizeof(filter_)) 
      {
      int n;
      char format[64];
      strcpy(format, " ");
      strcat(format, filter);
      strcat(format, " %d %1023[^\n]");
      strcpy(filter_, filter);
      n = sscanf(p, format, &id_, param_);
      if (n > 0)
        {
        if (n < 2) param_[0] = '\0'; // no further parameters
        if (id_ < 0)
          {
          /*
           * Invalid component id. If an id has been specified then 
           * it must be valid!
           */
          id_ = ngcbCMD_ID_IVLD; return (-1); 
          }
        }
      else
        {
        /*
         * No id has been specified. We forward the parameter buffer 
         * as it is.
         */
        id_ = ngcbCMD_ID_NOT_SET;
        str2str(param_, p, sizeof(param_) - 1);
        }
      }
    else
      {
      id_ = ngcbCMD_ID_NOT_SET;
      str2str(param_, p, sizeof(param_) - 1);
      }
    }
      else
    {
    /*
     * Empty parameter buffer
     */
    id_ = ngcbCMD_ID_NOT_SET; param_[0] = '\0';
    }
      }
    else
      {
      /*
       * No parameter buffer
       */
      id_ = ngcbCMD_ID_NOT_SET; param_[0] = '\0';
      }
 
    return (0);
  }

  char *Param() {return (param_);}

  int Get(const char *filter, char *s) {
    return (ngcbF2S(param_, filter, s));
  }

  int Get(const char *filter, double *v) {
    return (ngcbF2Double(param_, filter, v));
  }

  int Get(const char *filter) {
    return (ngcbF2Int(param_, filter));
  }

  unsigned int GetX(const char *filter) {
    return (ngcbF2UInt(param_, filter));
  }
 
protected:
private:
  char param_[1024];

  int id_;

  char filter_[32];
};

class ngcbCMD_SRV
{
public:
  ngcbCMD_SRV();  

  virtual ~ngcbCMD_SRV();  

  void AssignPassword(const char *fileName);

  const char *PW();

  int LogIn(const char *s);
  
  void LogOut();
  
  int LoggedIn();

  void Lock();

  void Unlock();
  
  int Locked();
  
  void Encrypt(char *s, const char *key = NULL);
 
protected:
  int KeyVal(const char *key, float *value);

  int KeyVal(const char *key, double *value);

  int KeyVal(const char *key, int *value);

  int KeyVal(const char *key, unsigned int *value);

  int KeyValHex(const char *key, int *value);

  int KeyValHex(const char *key, unsigned int *value);

  int KeyValFmt(const char *key, int *value);

  int KeyValFmt(const char *key, unsigned int *value);

  int KeyValFrac(const char *key, unsigned int n, uint64_t *v1, uint64_t *v2);

  int KeyIdx(char *key, const char *mask);
  
  void DiscardDetIdx(char *key);

  void StringReset(char *s, size_t size = 256);
 
private:
  int login_;

  int locked_;

  char pw_[64];  

  void LogIn_(); 
};

typedef int (ngcbCMD_SRV::*ngcb_function_t)(ngcb_cmd_handle_t *handle, 
                        char *reply);

class ngcb_cmd_t {
public:
  ngcb_function_t function;

  char syntax[256];

  char help[1024]; 

  int flags;

  void *udata;
  
  bool operator<(const ngcb_cmd_t &other) const {
    return (strcmp(Cmd(), other.Cmd()) < 0);
  }

  explicit ngcb_cmd_t(const char *name) {
    str2str(cmd_, name, sizeof(cmd_) - 1);
    function = NULL;
    syntax[0] = '\0'; 
    help[0] = '\0'; 
    flags = 0x0; 
    udata = NULL;
  }

  virtual ~ngcb_cmd_t() {}

  static bool Compare(const ngcb_cmd_t *a, const ngcb_cmd_t *b) {
    return (*a < *b);
  }

  const char *Cmd() const {return (cmd_);}

  void Syntax(const char *s) {
    if (s == NULL) sprintf(syntax, "%s (...)", Cmd());
    else if (strlen(s) == 0) sprintf(syntax, "%s", Cmd());
    else str2str(syntax, s, sizeof(syntax) - 1);
  }

  void Help(const char *s) {
    if (s == NULL) strcpy(help, "No help available!");
    else str2str(help, s, sizeof(help) - 1);
  }
 
protected:
private:
  char cmd_[64];   
};

class ngcbCMD_LIST 
{
public:
  explicit ngcbCMD_LIST(ngcbCMD_SRV *server);

  virtual ~ngcbCMD_LIST();

  int Add(const char *cmd, ngcb_function_t function, int flags, 
      const char *syntax, const char *help, void *udata, char *erms);

  void Delete(const char *cmd);

  void Sort();

  int Execute(const char *cmd, ngcb_cmd_handle_t *handle, char *reply);

  int Help(const char *args, char *reply);

  int Defined(const char *cmd);

  void Close();

  void Open();

  int Status();
 
protected:
 
private:
  ngcbCMD_SRV *server_;

  ngcb_cmd_t *list_[ngcbCMD_LIST_SIZE];

  size_t size_;                           

  int status_;
};
 
 
#endif