ACE/apps/JAWS/server/Parse_Headers.cpp

   1 #include "ace/Log_Msg.h"
   2
   3 #include "Parse_Headers.h"
   4 #include "ace/OS_NS_string.h"
   5 #include "ace/OS_NS_strings.h"
   6 #include "ace/OS_NS_stdlib.h"
   7 #include "ace/OS_NS_ctype.h"
   8
   9 // Implementation of class Headers
  10
  11 Headers::Headers () : done_(0)
  12 {
  13 }
  14
  15 Headers::~Headers ()
  16 {
  17 }
  18
  19 void
  20 Headers::recognize (const char * const header)
  21 {
  22   (void)this->map_[header];
  23 }
  24
  25 void
  26 Headers::parse_header_line (char * const header_line)
  27 {
  28   char *ptr = header_line;
  29   char *buf = header_line;
  30   int offset = 1;
  31
  32   ptr = ACE_OS::strchr (header_line, '\n');
  33
  34   if (ptr > header_line && ptr[-1] == '\r')
  35     {
  36       ptr--;
  37       offset++;
  38     }
  39
  40   if (ptr == header_line)
  41     {
  42       this->done_ = 1;
  43       return;
  44     }
  45
  46   *ptr = '\0';
  47   ptr += offset;
  48
  49   char *value = 0;
  50   char *header = ACE_OS::strtok_r (buf, ":", &value);
  51
  52   ACE_DEBUG((LM_DEBUG, " (%t) Headers::parse_header_line [%s]\n",
  53              header ? header : "<empty>"));
  54
  55   if (header != 0 && this->map_.mapped (header))
  56     {
  57       while (ACE_OS::ace_isspace (*value))
  58         value++;
  59
  60       this->map_[header] = value;
  61
  62       ACE_DEBUG((LM_DEBUG, " (%t) Headers::parse_header_line <%s>\n",
  63                  value ? value : "<empty>"));
  64     }
  65
  66   // Write back the unused portion of the input.
  67   ACE_OS::memmove (header_line, ptr, ACE_OS::strlen(ptr) + 1);
  68 }
  69
  70 int
  71 Headers::complete_header_line (char *const header_line)
  72 {
  73   // Algorithm --
  74   // Scan for end of line marker.
  75   // If the next character is linear white space, then unfold the header.
  76   // Else, if the next character is printable, we have a complete header line.
  77   // Else, presumably the next character is '\0', so the header is incomplete.
  78
  79   // return -1 if end of line but not complete header line
  80   // return 0 if no end of line marker
  81   // return 1 if complete header line
  82
  83   char *ptr = header_line;
  84   int offset;
  85
  86   if (!this->end_of_line (ptr, offset))
  87     return 0;
  88
  89   if (ptr == header_line)
  90     {
  91       ACE_OS::memmove (ptr, ptr+offset, ACE_OS::strlen (ptr + offset) + 1);
  92       this->done_ = 1;
  93       ACE_DEBUG ((LM_DEBUG, "  (%t) no more headers\n"));
  94       return 0;
  95     }
  96
  97   do
  98     {
  99       switch (ptr[offset])
 100         {
 101         case ' ':
 102         case '\t':
 103           ACE_OS::memmove (ptr, ptr+offset, ACE_OS::strlen (ptr + offset) + 1);
 104           break;
 105
 106         case '\n':
 107         case '\r':
 108           return 1;
 109
 110         default:
 111           if (ACE_OS::ace_isalpha (ptr[offset]))
 112             return 1;
 113           else
 114             return -1;
 115         }
 116     }
 117   while (this->end_of_line (ptr, offset) != 0);
 118
 119   return 0;
 120 }
 121
 122 int
 123 Headers::end_of_headers () const
 124 {
 125   return this->done_;
 126 }
 127
 128 Headers_Map_Item &
 129 Headers::operator[] (const char * const header)
 130 {
 131   return this->map_[header];
 132 }
 133
 134 const Headers_Map_Item &
 135 Headers::operator[] (const char * const header) const
 136 {
 137   return this->map_[header];
 138 }
 139
 140 int
 141 Headers::end_of_line (char *&line, int &offset) const
 142 {
 143   char *old_line = line;
 144   char *ptr = ACE_OS::strchr (old_line, '\n');
 145
 146   if (ptr == 0)
 147     return 0;
 148
 149   line = ptr;
 150   offset = 1;
 151
 152   if (line > old_line
 153       && line[-1] == '\r')
 154     {
 155       line--;
 156       offset = 2;
 157     }
 158
 159   return 1;
 160 }
 161
 162
 163 // Implementation of class Headers_Map
 164
 165 Headers_Map::Headers_Map ()
 166   : num_headers_(0)
 167 {
 168 }
 169
 170 Headers_Map::~Headers_Map ()
 171 {
 172 }
 173
 174 Headers_Map_Item::Headers_Map_Item ()
 175   : header_(0),
 176     value_(0)
 177 {
 178 }
 179
 180 Headers_Map_Item::~Headers_Map_Item ()
 181 {
 182   ACE_OS::free ((void *) this->header_);
 183   ACE_OS::free ((void *) this->value_);
 184   this->header_ = this->value_ = 0;
 185 }
 186
 187 // Headers_Map_Item::operator const char * () const
 188 // {
 189 //   return this->value_ == 0 ? this->no_value_ : this->value_;
 190 // }
 191
 192 Headers_Map_Item &
 193 Headers_Map_Item::operator= (char * value)
 194 {
 195   ACE_OS::free ((void *) this->value_);
 196   this->value_ = ACE_OS::strdup (value);
 197   return *this;
 198 }
 199
 200 Headers_Map_Item &
 201 Headers_Map_Item::operator= (const char * value)
 202 {
 203   ACE_OS::free ((void *) this->value_);
 204   this->value_ = ACE_OS::strdup (value);
 205   return *this;
 206 }
 207
 208 Headers_Map_Item &
 209 Headers_Map_Item::operator= (const Headers_Map_Item & mi)
 210 {
 211   ACE_OS::free ((void *) this->value_);
 212   ACE_OS::free ((void *) this->header_);
 213   this->header_ = ACE_OS::strdup (mi.header_);
 214   this->value_ = (mi.value_ ? ACE_OS::strdup (mi.value_) : 0);
 215   return *this;
 216 }
 217
 218 const char *
 219 Headers_Map_Item::header () const
 220 {
 221   return this->header_;
 222 }
 223
 224 const char *
 225 Headers_Map_Item::value () const
 226 {
 227   return this->value_;
 228 }
 229
 230 Headers_Map_Item &
 231 Headers_Map::operator[] (const char * const header)
 232 {
 233   Headers_Map_Item *item_ptr;
 234
 235   item_ptr = this->find (header);
 236
 237   if (item_ptr == 0)
 238     item_ptr = this->place (header);
 239
 240   return *item_ptr;
 241 }
 242
 243 const Headers_Map_Item &
 244 Headers_Map::operator[] (const char * const header) const
 245 {
 246   Headers_Map_Item *item_ptr;
 247   Headers_Map *mutable_this = (Headers_Map *)this;
 248
 249   item_ptr = this->find (header);
 250
 251   if (item_ptr == 0)
 252     item_ptr = mutable_this->place (header);
 253
 254   return *item_ptr;
 255 }
 256
 257 int
 258 Headers_Map::mapped (const char * const header) const
 259 {
 260   int result = this->find (header) != 0;
 261
 262   return result;
 263 }
 264
 265 Headers_Map_Item *
 266 Headers_Map::find (const char * const header) const
 267 {
 268   Headers_Map *const mutable_this = (Headers_Map *) this;
 269
 270   mutable_this->garbage_.header_ = header;
 271 #if 0
 272   Headers_Map_Item *mi_ptr = (Headers_Map_Item *)
 273     ACE_OS::bsearch (&this->garbage_,
 274                      this->map_,
 275                      this->num_headers_,
 276                      sizeof (Headers_Map_Item),
 277                      Headers_Map::compare);
 278 #else
 279   int i = 0;
 280   int j = this->num_headers_;
 281
 282   while (i < j-1)
 283     {
 284       int k = (i+j)/2;
 285       if (Headers_Map::compare (&this->garbage_, this->map_+k) < 0)
 286         j = k;
 287       else
 288         i = k;
 289     }
 290
 291   Headers_Map_Item *mi_ptr = mutable_this->map_ + i;
 292   if (Headers_Map::compare (&this->garbage_, mi_ptr) != 0)
 293     mi_ptr = 0;
 294 #endif
 295
 296   mutable_this->garbage_.header_ = 0;
 297
 298   return mi_ptr;
 299 }
 300
 301 Headers_Map_Item *
 302 Headers_Map::place (const char *const header)
 303 {
 304   this->garbage_.header_ = ACE_OS::strdup (header);
 305
 306   int i = this->num_headers_++;
 307   ACE_OS::free ((void *) this->map_[i].header_);
 308   ACE_OS::free ((void *) this->map_[i].value_);
 309   this->map_[i].header_ = 0;
 310   this->map_[i].value_ = 0;
 311   Headers_Map_Item temp_item;
 312
 313   while (i > 0)
 314     {
 315       if (Headers_Map::compare (&this->garbage_,
 316                                 &this->map_[i - 1]) > 0)
 317         break;
 318
 319       this->map_[i].header_ = this->map_[i - 1].header_;
 320       this->map_[i].value_ = this->map_[i - 1].value_;
 321       this->map_[i - 1].header_ = 0;
 322       this->map_[i - 1].value_ = 0;
 323
 324       i--;
 325     }
 326
 327   this->map_[i].header_ = this->garbage_.header_;
 328   this->map_[i].value_ = this->garbage_.value_;
 329
 330   this->garbage_.header_ = 0;
 331
 332   return &this->map_[i];
 333 }
 334
 335 int
 336 Headers_Map::compare (const void *item1,
 337                       const void *item2)
 338 {
 339   Headers_Map_Item *a, *b;
 340   int result;
 341
 342   a = (Headers_Map_Item *) item1;
 343   b = (Headers_Map_Item *) item2;
 344
 345   if (a->header_ == 0 || b->header_ == 0)
 346     {
 347       if (a->header_ == 0 && b->header_ == 0)
 348         result = 0;
 349       else if (a->header_ == 0)
 350         result = 1;
 351       else
 352         result = -1;
 353     }
 354   else
 355     result = ACE_OS::strcasecmp (a->header_, b->header_);
 356
 357   return (result < 0) ? -1 : (result > 0);
 358 }