ACE/ace/Capabilities.cpp

   1 #include "ace/Capabilities.h"
   2 #include "ace/OS_NS_ctype.h"
   3 #include "ace/OS_Memory.h"
   4 #include "ace/OS_NS_string.h"
   5
   6 #if !defined (__ACE_INLINE__)
   7 #include "ace/Capabilities.inl"
   8 #endif /* !__ACE_INLINE__ */
   9
  10 #include "ace/OS_NS_stdio.h"
  11
  12 #define ACE_ESC ((ACE_TCHAR)0x1b)
  13
  14 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  15
  16 ACE_Capabilities::ACE_Capabilities ()
  17   : caps_ ()
  18 {
  19 }
  20
  21 ACE_Capabilities::~ACE_Capabilities ()
  22 {
  23   this->resetcaps ();
  24 }
  25
  26 const ACE_TCHAR *
  27 ACE_Capabilities::parse (const ACE_TCHAR *buf, ACE_TString &cap)
  28 {
  29   while (*buf != ACE_TEXT ('\0') && *buf != ACE_TEXT (','))
  30     {
  31       if (*buf == ACE_TEXT ('\\'))
  32         {
  33           ++buf;
  34           if (*buf == ACE_TEXT ('E') || *buf == ACE_TEXT ('e'))
  35             {
  36               cap += ACE_ESC;
  37               ++buf;
  38               continue;
  39             }
  40           else if (*buf == ACE_TEXT ('r'))
  41             {
  42               cap += ACE_TEXT ('\r');
  43               ++buf;
  44               continue;
  45             }
  46           else if (*buf == ACE_TEXT ('n'))
  47             {
  48               cap += ACE_TEXT ('\n');
  49               ++buf;
  50               continue;
  51             }
  52           else if (*buf == ACE_TEXT ('t'))
  53             {
  54               cap += ACE_TEXT ('\t');
  55               ++buf;
  56               continue;
  57             }
  58           else if (*buf == ACE_TEXT ('\\'))
  59             {
  60               cap += *buf++;
  61               continue;
  62             }
  63           if (ACE_OS::ace_isdigit(*buf))
  64             {
  65               // @@ UNICODE Does this work with unicode?
  66               int oc = 0;
  67               for (int i = 0;
  68                    i < 3 && *buf && ACE_OS::ace_isdigit (*buf);
  69                    i++)
  70                 oc = oc * 8 + (*buf++ - ACE_TEXT ('0'));
  71
  72               cap += (ACE_TCHAR) oc;
  73               continue;
  74             }
  75         }
  76       cap += *buf++;
  77     }
  78   return buf;
  79 }
  80
  81 const ACE_TCHAR *
  82 ACE_Capabilities::parse (const ACE_TCHAR *buf, int &cap)
  83 {
  84   int n = 0;
  85
  86   while (*buf && ACE_OS::ace_isdigit (*buf))
  87     n = n * 10 + (*buf++ - ACE_TEXT ('0'));
  88
  89   cap = n;
  90
  91   return buf;
  92 }
  93
  94 void
  95 ACE_Capabilities::resetcaps ()
  96 {
  97   for (CAPABILITIES_MAP::ITERATOR iter (this->caps_);
  98        !iter.done ();
  99        iter.advance ())
 100     {
 101       CAPABILITIES_MAP::ENTRY *entry = 0;
 102       iter.next (entry);
 103       delete entry->int_id_;
 104     }
 105
 106   this->caps_.close ();
 107   this->caps_.open ();
 108 }
 109
 110 int
 111 ACE_Capabilities::fillent (const ACE_TCHAR *buf)
 112 {
 113   this->resetcaps ();
 114   while (*buf)
 115     {
 116       ACE_TString s;
 117       int n;
 118       ACE_TString name;
 119       ACE_CapEntry *ce;
 120
 121       // Skip blanks
 122       while (*buf && ACE_OS::ace_isspace(*buf)) buf++;
 123       // If we get end of line return
 124
 125       if (*buf == ACE_TEXT ('\0'))
 126         break;
 127
 128       if (*buf == ACE_TEXT ('#'))
 129         {
 130           while (*buf && *buf != ACE_TEXT ('\n'))
 131             buf++;
 132           if (*buf == ACE_TEXT ('\n'))
 133             buf++;
 134           continue;
 135         }
 136       while(*buf && *buf != ACE_TEXT ('=')
 137             && *buf!= ACE_TEXT ('#')
 138             && *buf != ACE_TEXT (','))
 139         name += *buf++;
 140
 141       // If name is null.
 142       switch (*buf)
 143         {
 144         case ACE_TEXT ('='):
 145           // String property
 146           buf = this->parse (buf + 1, s);
 147           ACE_NEW_RETURN (ce,
 148                           ACE_StringCapEntry (s),
 149                           -1);
 150           if (this->caps_.bind (name, ce) == -1)
 151             {
 152               delete ce;
 153               return -1;
 154             }
 155           break;
 156         case ACE_TEXT ('#'):
 157           // Integer property
 158           buf = this->parse (buf + 1, n);
 159           ACE_NEW_RETURN (ce,
 160                           ACE_IntCapEntry (n),
 161                           -1);
 162           if (this->caps_.bind (name, ce) == -1)
 163             {
 164               delete ce;
 165               return -1;
 166             }
 167           break;
 168         case ACE_TEXT (','):
 169           // Boolean
 170           ACE_NEW_RETURN (ce,
 171                           ACE_BoolCapEntry (1),
 172                           -1);
 173           if (this->caps_.bind (name, ce) == -1)
 174             {
 175               delete ce;
 176               return -1;
 177             }
 178           break;
 179         default:
 180           return 0;
 181         }
 182
 183       if (*buf++ != ACE_TEXT (','))
 184         return -1;
 185     }
 186
 187   return 0;
 188 }
 189
 190 int
 191 ACE_Capabilities::is_entry (const ACE_TCHAR *name, const ACE_TCHAR *line)
 192 {
 193   for (;;)
 194     {
 195       // Skip blanks or irrelevant characters
 196       while (*line && ACE_OS::ace_isspace(*line))
 197         ++line;
 198
 199       // End of line reached
 200       if (*line == ACE_TEXT ('\0'))
 201         break;
 202
 203       // Build the entry name
 204       ACE_TString nextname;
 205       while (*line && *line != ACE_TEXT ('|') && *line != ACE_TEXT (','))
 206         nextname += *line++;
 207
 208       // We have found the required entry?
 209       if (ACE_OS::strcmp (nextname.c_str (), name) == 0)
 210         return 1;
 211
 212       // Skip puntuaction char if neccesary.
 213       if (*line == ACE_TEXT ('|') || *line == ACE_TEXT (','))
 214         ++line;
 215       else
 216         {
 217           ACELIB_DEBUG ((LM_DEBUG,
 218                       ACE_TEXT ("Invalid entry\n")));
 219           break;
 220         }
 221     }
 222   return 0;
 223 }
 224
 225 int
 226 ACE_Capabilities::getline (FILE *fp, ACE_TString &line)
 227 {
 228   int ch;
 229
 230   line.set (0, 0);
 231
 232   while ((ch = ACE_OS::fgetc (fp)) != EOF && ch != ACE_TEXT ('\n'))
 233     line += (ACE_TCHAR) ch;
 234
 235   if (ch == EOF && line.length () == 0)
 236     return -1;
 237   else
 238     return 0;
 239 }
 240
 241 int
 242 ACE_Capabilities::getval (const ACE_TCHAR *keyname, ACE_TString &val)
 243 {
 244   ACE_CapEntry* cap = 0;
 245   if (this->caps_.find (keyname, cap) == -1)
 246     return -1;
 247
 248   ACE_StringCapEntry *scap =
 249     dynamic_cast<ACE_StringCapEntry *> (cap);
 250   if (scap == 0)
 251     return -1;
 252
 253   val = scap->getval ();
 254   return 0;
 255 }
 256
 257 int
 258 ACE_Capabilities::getval (const ACE_TCHAR *keyname, int &val)
 259 {
 260   ACE_CapEntry *cap = 0;
 261   if (this->caps_.find (keyname, cap) == -1)
 262     return -1;
 263
 264   ACE_IntCapEntry *icap =
 265     dynamic_cast<ACE_IntCapEntry *> (cap);
 266   if (icap != 0)
 267     {
 268       val = icap->getval ();
 269       return 0;
 270     }
 271
 272   ACE_BoolCapEntry *bcap =
 273     dynamic_cast<ACE_BoolCapEntry *> (cap);
 274
 275   if (bcap == 0)
 276     return -1;
 277
 278   val = bcap->getval ();
 279   return 0;
 280 }
 281
 282 static int
 283 is_empty (const ACE_TCHAR *line)
 284 {
 285   while (*line && ACE_OS::ace_isspace (*line))
 286     ++line;
 287
 288   return *line == ACE_TEXT ('\0') || *line == ACE_TEXT ('#');
 289 }
 290
 291 static int
 292 is_line (const ACE_TCHAR *line)
 293 {
 294   while (*line && ACE_OS::ace_isspace (*line))
 295     ++line;
 296
 297   return *line != ACE_TEXT ('\0');
 298 }
 299
 300 int
 301 ACE_Capabilities::getent (const ACE_TCHAR *fname, const ACE_TCHAR *name)
 302 {
 303   FILE *fp = ACE_OS::fopen (fname, ACE_TEXT ("r"));
 304
 305   if (fp == 0)
 306     ACELIB_ERROR_RETURN ((LM_ERROR,
 307                        ACE_TEXT ("Can't open %s file\n"),
 308                        fname),
 309                       -1);
 310
 311   int done;
 312   ACE_TString line;
 313
 314   while (0 == (done = (this->getline (fp, line) == -1))
 315          && is_empty (line.c_str ()))
 316     continue;
 317
 318   while (!done)
 319     {
 320       ACE_TString newline;
 321       ACE_TString description;
 322
 323       while (0 == (done = (this->getline (fp, newline) == -1)))
 324         if (is_line (newline.c_str ()))
 325           description += newline;
 326         else
 327           break;
 328
 329       if (this->is_entry (name, line.c_str()))
 330         {
 331           ACE_OS::fclose (fp);
 332           return this->fillent (description.c_str ());
 333         }
 334
 335       line = newline;
 336       while (!done && is_empty (line.c_str ()))
 337         done = this->getline (fp, line) == -1;
 338     }
 339
 340   ACE_OS::fclose (fp);
 341   return -1;
 342 }
 343
 344 ACE_ALLOC_HOOK_DEFINE(ACE_StringCapEntry)
 345 ACE_ALLOC_HOOK_DEFINE(ACE_IntCapEntry)
 346 ACE_ALLOC_HOOK_DEFINE(ACE_BoolCapEntry)
 347
 348 ACE_END_VERSIONED_NAMESPACE_DECL