src/http_request.cpp

   1 /*
   2  * @file  http_request.cpp
   3  * @brief module of HTTP Request
   4  * @brief HTTP Request parser
   5  *
   6  * Copyright (C) 2009  NTT COMWARE Corporation.
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  21  * 02110-1301 USA
  22  *
  23  **********************************************************************/
  24
  25 #include "http_request.h"
  26
  27 /*!
  28  * HTTP Request constructor.
  29  */
  30 http_request::http_request()
  31 {
  32     /*-------- DEBUG LOG --------*/
  33     if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_PACKET_EDIT_HTTP)) {
  34         LOGGER_PUT_LOG_DEBUG(LOG_CAT_PACKET_EDIT_HTTP, 20,
  35         "in/out_function : Constructor http_request::http_request(void)");
  36     }
  37     /*------ DEBUG LOG END ------*/
  38 }
  39
  40 /*!
  41  * HTTP Request constructor.
  42  * Parse HTTP request header.
  43  *
  44  * @param[in]   header  full http request header string
  45  */
  46 http_request::http_request(std::string header)
  47 {
  48     /*-------- DEBUG LOG --------*/
  49     if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_PACKET_EDIT_HTTP)) {
  50         LOGGER_PUT_LOG_DEBUG(LOG_CAT_PACKET_EDIT_HTTP, 21,
  51         "in/out_function : Constructor http_request::http_request(std::string header) : "
  52         "header(%s)", header.c_str());
  53     }
  54     /*------ DEBUG LOG END ------*/
  55     this->parse(header);
  56 }
  57
  58 /*!
  59  * HTTP Request destructor.
  60  */
  61 http_request::~http_request()
  62 {
  63     /*-------- DEBUG LOG --------*/
  64     if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_PACKET_EDIT_HTTP)) {
  65         LOGGER_PUT_LOG_DEBUG(LOG_CAT_PACKET_EDIT_HTTP, 22,
  66         "in/out_function : Destructor http_request::~http_request(void)");
  67     }
  68     /*------ DEBUG LOG END ------*/
  69 }
  70
  71 /*!
  72  * Get method function.
  73  *
  74  * @return    method
  75  */
  76 std::string http_request::method() const
  77 {
  78     /*-------- DEBUG LOG --------*/
  79     if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_PACKET_EDIT_HTTP)) {
  80         LOGGER_PUT_LOG_DEBUG(LOG_CAT_PACKET_EDIT_HTTP, 23,
  81         "in_function : std::string http_request::method(void)");
  82         LOGGER_PUT_LOG_DEBUG(LOG_CAT_PACKET_EDIT_HTTP, 24,
  83         "out_function : std::string http_request::method(void) : "
  84         "return(%s)", this->_method.c_str());
  85     }
  86     /*------ DEBUG LOG END ------*/
  87
  88     return this->_method;
  89 }
  90
  91 /*!
  92  * Set method function.
  93  * Set new method and return old method.
  94  *
  95  * @param[in]   method  new method
  96  * @return  old method
  97  */
  98 std::string http_request::method(std::string _method)
  99 {
 100     /*-------- DEBUG LOG --------*/
 101     if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_PACKET_EDIT_HTTP)) {
 102         LOGGER_PUT_LOG_DEBUG(LOG_CAT_PACKET_EDIT_HTTP, 25,
 103         "in_function : std::string http_request::method(std::string _method) : "
 104         "_method(%s)", _method.c_str());
 105     }
 106     /*------ DEBUG LOG END ------*/
 107
 108     std::string ret = this->_method;
 109     this->_method = _method;
 110     this->modified = true;
 111
 112     /*-------- DEBUG LOG --------*/
 113     if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_PACKET_EDIT_HTTP)) {
 114         LOGGER_PUT_LOG_DEBUG(LOG_CAT_PACKET_EDIT_HTTP, 26,
 115         "out_function : std::string http_request::method(std::string _method) : "
 116         "return(%s)", ret.c_str());
 117     }
 118     /*------ DEBUG LOG END ------*/
 119
 120     return ret;
 121 }
 122
 123 /*!
 124  * Get request URI function.
 125  *
 126  * @return    request URI
 127  */
 128 std::string http_request::request_uri() const
 129 {
 130     /*-------- DEBUG LOG --------*/
 131     if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_PACKET_EDIT_HTTP)) {
 132         LOGGER_PUT_LOG_DEBUG(LOG_CAT_PACKET_EDIT_HTTP, 27,
 133         "in_function : std::string http_request::request_uri(void)");
 134         LOGGER_PUT_LOG_DEBUG(LOG_CAT_PACKET_EDIT_HTTP, 28,
 135         "out_function : std::string http_request::request_uri(void) : "
 136         "return(%s)", this->_request_uri.c_str());
 137     }
 138     /*------ DEBUG LOG END ------*/
 139
 140     return this->_request_uri;
 141 }
 142
 143 /*!
 144  * Set request URI function.
 145  * Set new request URI and return old request URI.
 146  *
 147  * @param[in]   _request_uri    new request URI
 148  * @return  old request URI
 149  */
 150 std::string http_request::request_uri(std::string _request_uri)
 151 {
 152     /*-------- DEBUG LOG --------*/
 153     if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_PACKET_EDIT_HTTP)) {
 154         LOGGER_PUT_LOG_DEBUG(LOG_CAT_PACKET_EDIT_HTTP, 29,
 155         "in_function : std::string http_request::request_uri(std::string _request_uri) : "
 156         "_request_uri(%s)", _request_uri.c_str());
 157     }
 158     /*------ DEBUG LOG END ------*/
 159
 160     std::string ret = this->_request_uri;
 161     this->_request_uri = _request_uri;
 162     this->modified = true;
 163
 164     /*-------- DEBUG LOG --------*/
 165     if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_PACKET_EDIT_HTTP)) {
 166         LOGGER_PUT_LOG_DEBUG(LOG_CAT_PACKET_EDIT_HTTP, 30,
 167         "out_function : std::string http_request::_request_uri(std::string _request_uri) : "
 168         "return(%s)", ret.c_str());
 169     }
 170     /*------ DEBUG LOG END ------*/
 171
 172     return ret;
 173 }
 174
 175 /*!
 176  * Get HTTP version function.
 177  *
 178  * @return    HTTP version
 179  */
 180 std::string http_request::http_version() const
 181 {
 182     /*-------- DEBUG LOG --------*/
 183     if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_PACKET_EDIT_HTTP)) {
 184         LOGGER_PUT_LOG_DEBUG(LOG_CAT_PACKET_EDIT_HTTP, 31,
 185         "in_function : std::string http_request::http_version(void)");
 186         LOGGER_PUT_LOG_DEBUG(LOG_CAT_PACKET_EDIT_HTTP, 32,
 187         "out_function : std::string http_request::http_version(void) : "
 188         "return(%s)", this->_http_version.c_str());
 189     }
 190     /*------ DEBUG LOG END ------*/
 191
 192     return this->_http_version;
 193 }
 194
 195 /*!
 196  * Set HTTP version function.
 197  * Set new HTTP version and return old HTTP version.
 198  *
 199  * @param[in]   _http_version   new HTTP version
 200  * @return  old HTTP version
 201  */
 202 std::string http_request::http_version(std::string _http_version)
 203 {
 204     /*-------- DEBUG LOG --------*/
 205     if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_PACKET_EDIT_HTTP)) {
 206         LOGGER_PUT_LOG_DEBUG(LOG_CAT_PACKET_EDIT_HTTP, 33,
 207         "in_function : std::string http_request::http_version(std::string _http_version) : "
 208         "_http_version(%s)", _http_version.c_str());
 209     }
 210     /*------ DEBUG LOG END ------*/
 211
 212     std::string ret = this->_http_version;
 213     this->_http_version = _http_version;
 214     this->modified = true;
 215
 216     /*-------- DEBUG LOG --------*/
 217     if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_PACKET_EDIT_HTTP)) {
 218         LOGGER_PUT_LOG_DEBUG(LOG_CAT_PACKET_EDIT_HTTP, 34,
 219         "out_function : std::string http_request::http_version(std::string _http_version) : "
 220         "return(%s)", ret.c_str());
 221     }
 222     /*------ DEBUG LOG END ------*/
 223
 224     return ret;
 225 }
 226
 227 /*!
 228  * Get request line function.
 229  *
 230  * @return    request line
 231  */
 232 std::string http_request::request_line() const
 233 {
 234     /*-------- DEBUG LOG --------*/
 235     if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_PACKET_EDIT_HTTP)) {
 236         LOGGER_PUT_LOG_DEBUG(LOG_CAT_PACKET_EDIT_HTTP, 35,
 237         "in_function : std::string http_request::request_line(void)");
 238     }
 239     /*------ DEBUG LOG END ------*/
 240
 241     std::string ret = this->method() + " " + this->request_uri() + " " + this->http_version() + "\r\n";
 242
 243     /*-------- DEBUG LOG --------*/
 244     if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_PACKET_EDIT_HTTP)) {
 245         LOGGER_PUT_LOG_DEBUG(LOG_CAT_PACKET_EDIT_HTTP, 36,
 246         "out_function : std::string http_request::request_line(void) : "
 247         "return(%s)", ret.c_str());
 248     }
 249     /*------ DEBUG LOG END ------*/
 250
 251     return ret;
 252 }
 253
 254 /*!
 255  * Get full HTTP request function.
 256  *
 257  * @return    HTTP request
 258  */
 259 std::string http_request::as_string()
 260 {
 261     /*-------- DEBUG LOG --------*/
 262     if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_PACKET_EDIT_HTTP)) {
 263         LOGGER_PUT_LOG_DEBUG(LOG_CAT_PACKET_EDIT_HTTP, 37,
 264         "in_function : std::string http_request::as_string(void)");
 265     }
 266     /*------ DEBUG LOG END ------*/
 267
 268     if (this->modified)
 269         this->rebuild();
 270
 271     /*-------- DEBUG LOG --------*/
 272     if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_PACKET_EDIT_HTTP)) {
 273         LOGGER_PUT_LOG_DEBUG(LOG_CAT_PACKET_EDIT_HTTP, 38,
 274         "out_function : std::string http_request::as_string(void) : "
 275         "return(%s)", this->raw_message.c_str());
 276     }
 277     /*------ DEBUG LOG END ------*/
 278
 279     return this->raw_message;
 280 }
 281
 282 /*!
 283  * Parse HTTP request header function.
 284  *
 285  * @param[in]   request     full HTTP request header
 286  */
 287 void http_request::parse(std::string request)
 288 {
 289     /*-------- DEBUG LOG --------*/
 290     if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_PACKET_EDIT_HTTP)) {
 291         LOGGER_PUT_LOG_DEBUG(LOG_CAT_PACKET_EDIT_HTTP, 39,
 292         "in_function : void http_request::parse(std::string request) : "
 293         "request(%s)", request.c_str());
 294     }
 295     /*------ DEBUG LOG END ------*/
 296
 297     // save raw request
 298     this->raw_message = request;
 299
 300     // parse request
 301     HTTP_REQUEST_POSITION pos = REQUEST_METHOD;
 302
 303     /*
 304      * RFC2616
 305      *  OCTET       : 8bit data
 306      *  CHAR        : US-ASCII(0-127)
 307      *  UPALPHA     : A-Z
 308      *  LOALPHA     : a-z
 309      *  ALPHA       : UPALPHA | LOALPHA
 310      *  DIGIT       : 0-9
 311      *  HEXDIG      : A-F | a-f | DIGIT
 312      *  SP          : SPace(32)
 313      *  HT          : Horizontal Tab(9)
 314      *  CR          : Carriage Return(13)
 315      *  LF          : Line Feed(10)
 316      *  CTL         : ConTLol char(0-31,127)
 317      *  LWS         : [CRLF] 1*(SP|HT)
 318      *  separators  : ()<>@,;:\"/[]?={} and SP, HT
 319      *  token       : 1*(CHAR not CTL, separators)
 320      */
 321     std::string::iterator ptr = request.begin();
 322     std::string::iterator end = request.end();
 323     std::string::iterator start = ptr;
 324     std::pair<std::string, std::string> field_pair;
 325     try {
 326         while (ptr != end) {
 327             switch(pos) {
 328             /*
 329              * REQUEST-LINE :
 330              *      METHOD SP REQUEST-URI SP HTTP-VERSION CRLF
 331              */
 332             /*
 333              * METHOD : token
 334              */
 335             case REQUEST_METHOD:
 336                 if (*ptr == ' ') { // METHOD end with SP
 337                     this->_method.assign(start, ptr);
 338                     pos = REQUEST_METHOD_SP;
 339                 } else if (!isalpha(*ptr) && !isdigit(*ptr)) { // XXX not enough
 340                     LOGGER_PUT_LOG_ERROR(LOG_CAT_PACKET_EDIT_HTTP, 10,
 341                     "Parse error: Invalid request method.(%c)", *ptr);
 342                     throw -1;
 343                 }
 344                 break;
 345             /*
 346              * REQUEST-URI : * | absolute-URI | path-absolute | authority
 347              *
 348              * RFC3986
 349              *  absolute-URI    : scheme ":" hier-part [ "?" query ]
 350              *  path-absolute   : "/" [ segment-nz *( "/" segment ) ]
 351              *  authority       : [ userinfo "@" ] host [ ":" port ]
 352              *  scheme          : ALPHA *( ALPHA | DIGIT | "+" | "-" | "." )
 353              *  hier-part       : "//" authority path-abempty
 354              *                  / path-absolute
 355              *                  / path-rootless
 356              *                  / path-empty
 357              *  query           : *( pchar | "/" | "?" )
 358              *  path-abempty    : *( "/" segment )
 359              *  path-rootless   : segment-nz *( "/" segment )
 360              *  path-empty      : no char
 361              *  segment-nz      : 1*pchar
 362              *  segment         : *pchar
 363              *  userinfo        : *( unreserved | pct-encoded | sub-delims | ":" )
 364              *  host            : IP-literal | IPv4address | reg-name
 365              *  port            : *DIGIT
 366              *  unreserved      : ALPHA | DIGIT | "-" | "." | "_" | "~"
 367              *  pct-encoded     : "%" HEXDIG HEXDIG
 368              *  sub-delims      : !$&'()*+,;=
 369              *  pchar           : unreserved | pct-encoded | subdelims | ":" | "@"
 370              *  IP-literal      : "[" ( IPv6address | IPvFuture ) "]"
 371              *  IPvFuture       : "v" 1*HEXDIG "." 1*( unreserved | sub-delims | ":" )
 372              *  IPv6address     :                            6( h16 ":" ) ls32
 373              *                  /                       "::" 5( h16 ":" ) ls32
 374              *                  / [               h16 ] "::" 4( h16 ":" ) ls32
 375              *                  / [ *1( h16 ":" ) h16 ] "::" 3( h16 ":" ) ls32
 376              *                  / [ *2( h16 ":" ) h16 ] "::" 2( h16 ":" ) ls32
 377              *                  / [ *3( h16 ":" ) h16 ] "::"    h16 ":"   ls32
 378              *                  / [ *4( h16 ":" ) h16 ] "::"              ls32
 379              *                  / [ *5( h16 ":" ) h16 ] "::"              h16
 380              *                  / [ *6( h16 ":" ) h16 ] "::"
 381              *  h16             : 1*4HEXDIG
 382              *  ls32            : ( h16 ":" h16 ) | IPv4address
 383              *  IPv4address     : dec-octet "." dec-octet "." dec-octet "." dec-octet
 384              *  dec-octet       : 0-255
 385              *  reg-name        : *( unreserved | pct-encoded | sub-delims )
 386              */
 387             case REQUEST_METHOD_SP:
 388                 // Request-URI start
 389                 // XXX not enough?
 390                 if (*ptr == '/' || isalpha(*ptr) || isdigit(*ptr) || *ptr == '-' ||
 391                     *ptr == '.' || *ptr == '_' || *ptr == '~' || *ptr == ':' ||
 392                     *ptr == '@' || *ptr == '!' || *ptr == '$' || *ptr == '&' ||
 393                     *ptr == '(' || *ptr == ')' || *ptr == '*' || *ptr == '+' ||
 394                     *ptr == ',' || *ptr == ';' || *ptr == '=' || *ptr == '%') {
 395                     pos = REQUEST_REQUEST_URI;
 396                     start = ptr;
 397                 } else {
 398                     LOGGER_PUT_LOG_ERROR(LOG_CAT_PACKET_EDIT_HTTP, 11,
 399                     "Parse error: Invalid request-uri.(%c)", *ptr);
 400                     throw -1;
 401                 }
 402                 break;
 403
 404             case REQUEST_REQUEST_URI:
 405                 if (*ptr == ' ') { // Request-URI end with SP
 406                     this->_request_uri.assign(start, ptr);
 407                     pos = REQUEST_REQUEST_URI_SP;
 408                 } else if (!isalpha(*ptr) && !isdigit(*ptr) && *ptr != '/' && // XXX not enough?
 409                     *ptr != '.' && *ptr != '=' && *ptr != '%' && *ptr != '?' &&
 410                     *ptr != '&' && *ptr != '+' && *ptr != '~' && *ptr != ',' &&
 411                     *ptr != '@' && *ptr != '!' && *ptr != '$' && *ptr != '-' &&
 412                     *ptr != '(' && *ptr != ')' && *ptr != '*' && *ptr != '_' &&
 413                     *ptr != ':' && *ptr != ';') {
 414                     LOGGER_PUT_LOG_ERROR(LOG_CAT_PACKET_EDIT_HTTP, 12,
 415                     "Parse error: Invalid request-uri.(%c)", *ptr);
 416                     throw -1;
 417                 }
 418                 break;
 419
 420             /*
 421              * HTTP-VERSION     : "HTTP" "/" 1*DIGIT "." 1*DIGIT
 422              */
 423             case REQUEST_REQUEST_URI_SP:
 424                 // HTTP-VERSION start
 425                 if (*ptr == 'H') {
 426                     pos = REQUEST_HTTP_VERSION_H;
 427                     start = ptr;
 428                 } else {
 429                     LOGGER_PUT_LOG_ERROR(LOG_CAT_PACKET_EDIT_HTTP, 13,
 430                     "Parse error: Invalid http-version.(%c)", *ptr);
 431                     throw -1;
 432                 }
 433                 break;
 434
 435             case REQUEST_HTTP_VERSION_H:
 436                 // HTTP-VERSION next
 437                 if (*ptr == 'T') {
 438                     pos = REQUEST_HTTP_VERSION_T1;
 439                 } else {
 440                     LOGGER_PUT_LOG_ERROR(LOG_CAT_PACKET_EDIT_HTTP, 14,
 441                     "Parse error: Invalid http-version.(%c)", *ptr);
 442                     throw -1;
 443                 }
 444                 break;
 445
 446             case REQUEST_HTTP_VERSION_T1:
 447                 // HTTP-VERSION next
 448                 if (*ptr == 'T') {
 449                     pos = REQUEST_HTTP_VERSION_T2;
 450                 } else {
 451                     LOGGER_PUT_LOG_ERROR(LOG_CAT_PACKET_EDIT_HTTP, 15,
 452                     "Parse error: Invalid http-version.(%c)", *ptr);
 453                     throw -1;
 454                 }
 455                 break;
 456
 457             case REQUEST_HTTP_VERSION_T2:
 458                 // HTTP-VERSION next
 459                 if (*ptr == 'P') {
 460                     pos = REQUEST_HTTP_VERSION_P;
 461                 } else {
 462                     LOGGER_PUT_LOG_ERROR(LOG_CAT_PACKET_EDIT_HTTP, 16,
 463                     "Parse error: Invalid http-version.(%c)", *ptr);
 464                     throw -1;
 465                 }
 466                 break;
 467
 468             case REQUEST_HTTP_VERSION_P:
 469                 // HTTP-VERSION next
 470                 if (*ptr == '/') {
 471                     pos = REQUEST_HTTP_VERSION_SLASH;
 472                 } else {
 473                     LOGGER_PUT_LOG_ERROR(LOG_CAT_PACKET_EDIT_HTTP, 17,
 474                     "Parse error: Invalid http-version.(%c)", *ptr);
 475                     throw -1;
 476                 }
 477                 break;
 478
 479             case REQUEST_HTTP_VERSION_SLASH:
 480                 // HTTP-VERSION Mejor number
 481                 if (isdigit(*ptr)) {
 482                     pos = REQUEST_HTTP_VERSION_MAJOR;
 483                 } else {
 484                     LOGGER_PUT_LOG_ERROR(LOG_CAT_PACKET_EDIT_HTTP, 18,
 485                     "Parse error: Invalid http-version.(%c)", *ptr);
 486                     throw -1;
 487                 }
 488                 break;
 489
 490             case REQUEST_HTTP_VERSION_MAJOR:
 491                 // HTTP-VERSION next dot
 492                 if (*ptr == '.') {
 493                     pos = REQUEST_HTTP_VERSION_DOT;
 494                 } else if (!isdigit(*ptr)) {
 495                     LOGGER_PUT_LOG_ERROR(LOG_CAT_PACKET_EDIT_HTTP, 19,
 496                     "Parse error: Invalid http-version.(%c)", *ptr);
 497                     throw -1;
 498                 }
 499                 break;
 500
 501             case REQUEST_HTTP_VERSION_DOT:
 502                 // HTTP-VERSION Minor number
 503                 if (isdigit(*ptr)) {
 504                     pos = REQUEST_HTTP_VERSION_MINOR;
 505                 } else {
 506                     LOGGER_PUT_LOG_ERROR(LOG_CAT_PACKET_EDIT_HTTP, 20,
 507                     "Parse error: Invalid http-version.(%c)", *ptr);
 508                     throw -1;
 509                 }
 510                 break;
 511
 512             case REQUEST_HTTP_VERSION_MINOR:
 513                 // HTTP-VERSION end with CR
 514                 if (*ptr == '\r') {
 515                     pos = REQUEST_CR;
 516                     this->_http_version.assign(start, ptr);
 517                 } else if (!isdigit(*ptr)) {
 518                     LOGGER_PUT_LOG_ERROR(LOG_CAT_PACKET_EDIT_HTTP, 21,
 519                     "Parse error: Invalid http-version.(%c)", *ptr);
 520                     throw -1;
 521                 }
 522                 break;
 523
 524             case REQUEST_CR:
 525                 // LF only
 526                 if (*ptr == '\n') {
 527                     pos = REQUEST_LF;
 528                     http_message::parse(std::string(ptr + 1, end));
 529                 } else {
 530                     LOGGER_PUT_LOG_ERROR(LOG_CAT_PACKET_EDIT_HTTP, 22,
 531                     "Parse error: No LF.(%c)", *ptr);
 532                     throw -1;
 533                 }
 534                 break;
 535             }
 536             if (pos == REQUEST_LF)
 537                 break;
 538             ptr++;
 539         }
 540     }
 541     catch (...) {
 542         LOGGER_PUT_LOG_ERROR(LOG_CAT_PACKET_EDIT_HTTP, 23,
 543         "Exception occured by parsing HTTP request.");
 544     }
 545
 546     /*-------- DEBUG LOG --------*/
 547     if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_PACKET_EDIT_HTTP)) {
 548         LOGGER_PUT_LOG_DEBUG(LOG_CAT_PACKET_EDIT_HTTP, 40,
 549         "out_function : void http_request::parse(std::string request)");
 550     }
 551     /*------ DEBUG LOG END ------*/
 552 }
 553
 554 /*!
 555  * Rebuild HTTP request header function.
 556  */
 557 void http_request::rebuild()
 558 {
 559     /*-------- DEBUG LOG --------*/
 560     if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_PACKET_EDIT_HTTP)) {
 561         LOGGER_PUT_LOG_DEBUG(LOG_CAT_PACKET_EDIT_HTTP, 41,
 562         "in_function : void http_request::rebuild()");
 563     }
 564     /*------ DEBUG LOG END ------*/
 565
 566     this->raw_message = this->request_line();
 567     http_message::rebuild();
 568
 569     /*-------- DEBUG LOG --------*/
 570     if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_PACKET_EDIT_HTTP)) {
 571         LOGGER_PUT_LOG_DEBUG(LOG_CAT_PACKET_EDIT_HTTP, 42,
 572         "out_function : void http_request::rebuild()");
 573     }
 574     /*------ DEBUG LOG END ------*/
 575 }