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