ACE/apps/JAWS2/JAWS/Parse_Headers.cpp

   1 #include "JAWS/Parse_Headers.h"
   2 #include "ace/OS_NS_string.h"
   3 #include "ace/Log_Msg.h"
   4
   5 #define ACCESSOR(T,C,x) \
   6 T C :: x () const { return this-> x##_; }\
   7 void C :: x (T t) { this-> x##_ = t; }
   8
   9 int
  10 JAWS_Parse_Headers::parse_headers (JAWS_Header_Info *info,
  11                                    ACE_Message_Block &mb)
  12 {
  13   for (;;)
  14     {
  15       if (mb.rd_ptr () == mb.wr_ptr ())
  16           break;
  17
  18       char *p = mb.rd_ptr ();
  19
  20       if (info->end_of_line ()
  21           && (*p != ' ' && *p != '\t'))
  22         {
  23           int r = this->parse_header_name (info, mb);
  24           if (r == 1)
  25             return info->end_of_headers ();
  26           continue;
  27         }
  28       else
  29         {
  30           int r = this->parse_header_value (info, mb);
  31           if (r == 1)
  32             {
  33               if (info->end_of_headers ())
  34                 return 1;
  35               break;
  36             }
  37           continue;
  38         }
  39     }
  40
  41   // If we arrive here, it means either there is nothing more to read,
  42   // or parse_header_value ran into difficulties (like maybe the
  43   // header value was too long).
  44
  45   if (mb.rd_ptr () != mb.base ())
  46     {
  47       mb.crunch ();
  48       return 0;
  49     }
  50   else if (mb.length () < mb.size ())
  51     {
  52       return 0;
  53     }
  54   else if (mb.length () == mb.size ())
  55     {
  56       // This is one of those cases that should rarely ever happen.
  57       // If we get here, the header type name is over 8K long.  We
  58       // flag this as a bad thing.
  59
  60       // In HTTP/1.1, I have to remember that a bad request means the
  61       // connection needs to be closed and the client has to
  62       // reinitiate the connection.
  63
  64       info->status (JAWS_Header_Info::STATUS_CODE_TOO_LONG);
  65       return 1;
  66     }
  67   else if (mb.length () > mb.size ())
  68     {
  69       ACE_DEBUG ((LM_DEBUG, "JAWS_Parse_Headers: buffer overrun!!\n"));
  70       info->status (JAWS_Header_Info::STATUS_CODE_TOO_LONG);
  71       return 1;
  72     }
  73
  74   ACE_DEBUG ((LM_DEBUG, "JAWS_Parse_Headers -- shouldn't be here!\n"));
  75   return 1;
  76 }
  77
  78 char *
  79 JAWS_Parse_Headers::skipset (const char *set, char *start, char *end)
  80 {
  81   char *p = start;
  82   while (p < end)
  83     {
  84       if (ACE_OS::strchr (set, *p) != 0)
  85         break;
  86       p++;
  87     }
  88   return p;
  89 }
  90
  91 char *
  92 JAWS_Parse_Headers::skipcset (const char *set, char *start, char *end)
  93 {
  94   char *p = start;
  95   while (p < end)
  96     {
  97       if (ACE_OS::strchr (set, *p) == 0)
  98         break;
  99       p++;
 100     }
 101   return p;
 102 }
 103
 104 int
 105 JAWS_Parse_Headers::parse_header_name (JAWS_Header_Info *info,
 106                                        ACE_Message_Block &mb)
 107 {
 108   char *p = mb.rd_ptr ();
 109   char *q;
 110
 111   q = this->skipset (":\n", p, mb.wr_ptr ());
 112   if (q == mb.wr_ptr ())
 113     {
 114       // no more progress can be made until we find a ':'
 115       return 1;
 116     }
 117   if (*q != '\n' && q == p)
 118     {
 119       // Ignore empty header type names
 120       info->finish_last_header_value ();
 121       info->create_next_header_value (0);
 122       info->end_of_line (0);
 123       mb.rd_ptr (q+1);
 124       return 0;
 125     }
 126   if (*q == '\n')
 127     {
 128       // ignore this line
 129       mb.rd_ptr (q+1);
 130       if (q == p || ((q-1) == p && q[-1] == '\r'))
 131         {
 132           // blank line means end of headers
 133           info->finish_last_header_value ();
 134           info->create_next_header_value (0);
 135           info->end_of_headers (1);
 136           if (mb.rd_ptr () == mb.wr_ptr ())
 137             mb.crunch ();
 138           return 1;
 139         }
 140
 141       // not a blank line, but no ':', so ignore it
 142       info->finish_last_header_value ();
 143       info->create_next_header_value (0);
 144       return 0;
 145     }
 146
 147   // otherwise, we have a header type name!
 148   *q = '\0';
 149   info->create_next_header_value (p);
 150   info->end_of_line (0);
 151
 152   mb.rd_ptr (q+1);
 153   return 0;
 154 }
 155
 156 int
 157 JAWS_Parse_Headers::parse_header_value (JAWS_Header_Info *info,
 158                                         ACE_Message_Block &mb)
 159 {
 160   // break --> return 1;
 161   // continue --> return 0;
 162
 163   char *q = mb.rd_ptr ();
 164
 165   if (info->last_header_data () == 0)
 166     {
 167       // Ignoring this header (it is too long or something).
 168
 169       q = this->skipset ("\n", mb.rd_ptr (), mb.wr_ptr ());
 170       if (q == mb.wr_ptr ())
 171         {
 172           info->end_of_line (0);
 173           mb.rd_ptr (q);
 174
 175           // Move the rd_ptr back one character if the last thing we
 176           // see is a carriage return.  Assert: wr_ptr > rd_ptr.
 177           if (q[-1] == '\r')
 178             mb.rd_ptr (q-1);
 179
 180           return 1;
 181         }
 182
 183       if (*q == '\0')
 184         {
 185           // We are in the middle of binary data.  Get out!
 186           mb.rd_ptr (q);
 187           info->end_of_line (1);
 188           info->end_of_headers (1);
 189           return 1;
 190         }
 191
 192       // Move past the newline, set the end of line flag
 193       if (*q == '\n')
 194         {
 195           info->end_of_line (1);
 196           q++;
 197         }
 198       mb.rd_ptr (q);
 199
 200       return 0;
 201     }
 202   else
 203     {
 204       if (info->end_of_line ())
 205         {
 206           // Skip over leading linear white space
 207           q = this->skipcset (" \t", mb.rd_ptr (), mb.wr_ptr ());
 208           if (q == mb.wr_ptr ())
 209             {
 210               // need more input
 211               info->end_of_line (1);
 212               mb.rd_ptr (q-1);
 213               return 1;
 214             }
 215
 216           if (*q != '\n')
 217             info->append_last_header_value (' ');
 218         }
 219
 220       // Append to last header value character by character
 221       while (q < mb.wr_ptr ())
 222         {
 223           if (*q == '\n')
 224             break;
 225           info->append_last_header_value (*q);
 226           q++;
 227         }
 228
 229       // Need more input
 230       if (q == mb.wr_ptr ())
 231         {
 232           mb.rd_ptr (q);
 233           info->end_of_line (0);
 234           return 1;
 235         }
 236
 237       // Reached a newline
 238       if (*q == '\n')
 239         {
 240           // Reduce by one character if line discipline is "\r\n"
 241           if (info->append_last_header_value () == '\r')
 242             info->reduce_last_header_value ();
 243
 244           // Move past newline, set end of line flag
 245           mb.rd_ptr (q+1);
 246           info->end_of_line (1);
 247
 248           return 0;
 249         }
 250     }
 251
 252   // NOT REACHED
 253   return 1;
 254 }
 255
 256
 257 JAWS_Header_Info::JAWS_Header_Info ()
 258   : end_of_headers_ (0),
 259     end_of_line_ (1),
 260     last_header_data_ (0),
 261     last_header_length_ (0),
 262     status_ (0)
 263 {
 264 }
 265
 266 JAWS_Header_Info::~JAWS_Header_Info ()
 267 {
 268   JAWS_Header_Table_Iterator iter (this->table_);
 269   JAWS_Header_Data *data_ptr;
 270
 271   for (iter.first (); !iter.done (); iter.advance ())
 272     {
 273       data_ptr = iter.next ();
 274       if (data_ptr)
 275         delete data_ptr;
 276     }
 277 }
 278
 279 void
 280 JAWS_Header_Info::dump ()
 281 {
 282   JAWS_Header_Table_Iterator iter (this->table_);
 283
 284   ACE_DEBUG ((LM_DEBUG, "== BEGIN HEADER INFO DUMP ==\n"));
 285   for (iter.first (); ! iter.done (); iter.advance ())
 286     {
 287       JAWS_Header_Data *data;
 288       data = iter.next ();
 289       if (data != 0)
 290         ACE_DEBUG ((LM_DEBUG,
 291                     "%s -- %s\n",
 292                     data->header_name (), data->header_value ()));
 293       else
 294         ACE_DEBUG ((LM_DEBUG, "NULL ENTRY\n"));
 295     }
 296   ACE_DEBUG ((LM_DEBUG, "== END HEADER INFO DUMP ==\n"));
 297 }
 298
 299 JAWS_Headers *
 300 JAWS_Header_Info::table ()
 301 {
 302   return &(this->table_);
 303 }
 304
 305 void
 306 JAWS_Header_Info::append_last_header_value (char c)
 307 {
 308   if (this->last_header_data_ == 0)
 309     return;
 310
 311   if (this->last_header_length_ == 0 && (c == ' ' || c == '\t'))
 312     return;
 313
 314   if (this->last_header_length_ < MAX_HEADER_LENGTH-1)
 315     {
 316       this->header_buf_[this->last_header_length_] = c;
 317       this->last_header_length_++;
 318       this->header_buf_[this->last_header_length_] = '\0';
 319     }
 320
 321 }
 322
 323 int
 324 JAWS_Header_Info::append_last_header_value ()
 325 {
 326   if (this->last_header_data_ == 0 || this->last_header_length_ == 0)
 327     return -1;
 328
 329   return this->header_buf_[this->last_header_length_-1];
 330 }
 331
 332 void
 333 JAWS_Header_Info::append_last_header_value (const char *begin, const char *end)
 334 {
 335   if (this->last_header_data_ == 0)
 336     return;
 337
 338   while (this->last_header_length_ < MAX_HEADER_LENGTH-1)
 339     {
 340       if (begin == end)
 341         break;
 342
 343       this->header_buf_[this->last_header_length_] = *begin;
 344       this->last_header_length_++;
 345       begin++;
 346     }
 347
 348   this->header_buf_[this->last_header_length_] = '\0';
 349 }
 350
 351 void
 352 JAWS_Header_Info::reduce_last_header_value ()
 353 {
 354   if (this->last_header_data_ == 0) return;
 355
 356   if (this->last_header_length_ > 0)
 357     {
 358       this->last_header_length_--;
 359       this->header_buf_[this->last_header_length_] = '\0';
 360     }
 361 }
 362
 363 void
 364 JAWS_Header_Info::create_next_header_value (char *ht)
 365 {
 366   if (ht == 0)
 367     {
 368       // discard last header data
 369
 370       delete this->last_header_data_;
 371       this->last_header_data_ = 0;
 372       this->last_header_length (0);
 373       return;
 374     }
 375
 376   this->finish_last_header_value ();
 377
 378   if (this->status () == JAWS_Header_Info::STATUS_CODE_OK)
 379     {
 380       // create a new last_header_data_ node
 381
 382       this->last_header_data_ = new JAWS_Header_Data (ht, 0);
 383       // The above performs a strdup.
 384
 385       if (this->last_header_data_ == 0 || this->last_header_name () == 0)
 386         {
 387           this->status (JAWS_Header_Info::STATUS_CODE_NO_MEMORY);
 388           delete this->last_header_data_;
 389           this->last_header_data_ = 0;
 390         }
 391       this->last_header_length (0);
 392       this->header_buf_[0] = '\0';
 393     }
 394 }
 395
 396 void
 397 JAWS_Header_Info::finish_last_header_value ()
 398 {
 399   if (this->last_header_data_ != 0)
 400     {
 401       // prepare to insert last header data into the table.
 402
 403       this->last_header_data_->header_value (this->header_buf ());
 404       // The above performs a strdup.
 405
 406       if (this->status () == JAWS_Header_Info::STATUS_CODE_OK)
 407         this->table_.insert (this->last_header_data_);
 408       else
 409         delete this->last_header_data_;
 410       this->last_header_data_ = 0;
 411     }
 412 }
 413
 414 char *
 415 JAWS_Header_Info::header_buf ()
 416 {
 417   return this->header_buf_;
 418 }
 419
 420 const char *
 421 JAWS_Header_Info::last_header_name () const
 422 {
 423   return this->last_header_data_ ? this->last_header_data_->header_name () : 0;
 424 }
 425
 426 const JAWS_Header_Data *
 427 JAWS_Header_Info::last_header_data () const
 428 {
 429   return this->last_header_data_;
 430 }
 431
 432 ACCESSOR(int,JAWS_Header_Info,last_header_length)
 433 ACCESSOR(int,JAWS_Header_Info,end_of_line)
 434 ACCESSOR(int,JAWS_Header_Info,end_of_headers)
 435 ACCESSOR(int,JAWS_Header_Info,status)
 436