TAO/utils/logWalker/GIOP_Buffer.cpp

   1 #include "GIOP_Buffer.h"
   2 #include "ace/OS_NS_string.h"
   3 #include "ace/Log_Msg.h"
   4
   5 static const char *size_leadin_1_5 = "GIOP v1."; //"x msg, ";
   6 static size_t leadin_len_1_5 = 15;
   7 static const char *size_leadin_1_6 = "GIOP message v1."; //2, ";
   8 static size_t leadin_len_1_6 = 19;
   9
  10
  11 const char *GIOP_Buffer::size_leadin = 0;
  12 size_t GIOP_Buffer::leadin_len = 0;
  13 const size_t GIOP_Buffer::giop_header_len = 12;
  14
  15 void
  16 GIOP_Buffer::init_leadin (int version)
  17 {
  18   if (size_leadin == 0)
  19     {
  20       if (version == 150)
  21         {
  22           size_leadin = size_leadin_1_5;
  23           leadin_len = leadin_len_1_5;
  24         }
  25       else
  26         {
  27           size_leadin = size_leadin_1_6;
  28           leadin_len = leadin_len_1_6;
  29         }
  30     }
  31 }
  32
  33 // GIOP 1.2 header: 12 bytes
  34 // Magic: 4
  35 // ver:   2
  36 // flags: 1 // bo
  37 // type:  1 // req/repl/lf/excp
  38 // len:   4
  39 //
  40 // Request 1.2 header:
  41 // req_id: 4
  42 // flags:  1
  43 // RESVD:  3
  44 // Address disposition: 4
  45 // target: <4 len, + len> [0-3 pad]
  46 // opname: <4 len, + len>
  47
  48 // GIOP 1.0 header: 12 bytes
  49 // Magic: 4
  50 // ver:   2
  51 // byte_order: 1
  52 // type:  1 // req/repl/lf/excp
  53 // len:   4
  54 //
  55 // Request 1.0 header:
  56 /*
  57 struct RequestHeader_1_0 { // Renamed from RequestHeader
  58     IOP::ServiceContextList      service_context;
  59     unsigned long                request_id;
  60     boolean                      response_expected;
  61     sequence <octet>             object_key;
  62     string                       operation;
  63     CORBA::OctetSeq              requesting_principal;
  64 };
  65 */
  66 // service_context: 4(count)+contexts.
  67 //   context id: 4
  68 //   content blob: 4(len) + len octets + (0-3)pad
  69 // request_id: 4
  70 // respexp:  1
  71 // RESVD:  3
  72 // Address disposition: 4
  73 // target: <4 len, + len> [0-3 pad]
  74 // opname: <4 len, + len>
  75
  76 /*
  77 struct ReplyHeader_1_0 { // Renamed from ReplyHeader
  78          IOP::ServiceContextList      service_context;
  79          unsigned long                request_id;
  80          ReplyStatusType_1_0          reply_status;
  81     };
  82     // GIOP 1.1
  83     typedef ReplyHeader_1_0 ReplyHeader_1_1;
  84     // Same Header contents for 1.0 and 1.1
  85 #else
  86     // GIOP 1.2, 1.3
  87     enum ReplyStatusType_1_2 {
  88          NO_EXCEPTION,
  89          USER_EXCEPTION,
  90          SYSTEM_EXCEPTION,
  91          LOCATION_FORWARD,
  92          LOCATION_FORWARD_PERM,// new value for 1.2
  93          NEEDS_ADDRESSING_MODE // new value for 1.2
  94     };
  95     struct ReplyHeader_1_2 {
  96          unsigned long                request_id;
  97          ReplyStatusType_1_2          reply_status;
  98          IOP::ServiceContextList      service_context;
  99     };
 100
 101  */
 102
 103
 104 //static const size_t target_offset_12 = GIOP_Buffer::giop_header_len + 12;
 105
 106 // 12 = req_id + flags + RESVD + addr disp.
 107
 108 GIOP_Buffer::GIOP_Buffer()
 109   : cdr_ (0),
 110     preamble_(),
 111     log_offset_(0),
 112     thr_(0),
 113     time_(),
 114     expected_req_id_(0),
 115     expected_size_(0),
 116     expected_type_(0),
 117     buffer_size_(0),
 118     wr_pos_ (0),
 119     octets_ (0),
 120     owner_ (0),
 121     buffer_lost_ (false),
 122     sending_(false),
 123     oid_ (0),
 124     oid_len_ (0),
 125     opname_ (0),
 126     req_id_ (0),
 127     resp_exp_ (0),
 128     reply_status_ (0),
 129     ver_minor_ (0),
 130     msg_size_ (0),
 131     num_contexts_ (0),
 132     header_parsed_ (false),
 133     payload_start_ (0),
 134     payload_size_ (0)
 135 {
 136 }
 137
 138 GIOP_Buffer::GIOP_Buffer(const char *text,
 139                          size_t offset,
 140                          Thread *thread,
 141                          Invocation *owner)
 142   : cdr_ (0),
 143     preamble_(text),
 144     log_offset_(offset),
 145     thr_(thread),
 146     time_(ACE_Time_Value::zero),
 147     expected_req_id_(0),
 148     expected_size_(0),
 149     expected_type_(0),
 150     buffer_size_(0),
 151     wr_pos_ (0),
 152     octets_ (0),
 153     owner_ (owner),
 154     buffer_lost_ (false),
 155     sending_(false),
 156     oid_ (0),
 157     oid_len_ (0),
 158     opname_ (0),
 159     req_id_ (0),
 160     resp_exp_ (0),
 161     reply_status_ (0),
 162     ver_minor_ (0),
 163     msg_size_ (0),
 164     num_contexts_ (0),
 165     header_parsed_ (false),
 166     payload_start_ (0),
 167     payload_size_ (0)
 168 {
 169   const char *size_str = ACE_OS::strstr(text, size_leadin);
 170   if (size_str != 0)
 171     {
 172       size_str += leadin_len; //ACE_OS::strlen (size_leadin);
 173       //      size_str += 3;
 174       this->expected_size_ = ACE_OS::strtol(size_str, 0, 10);
 175       const char *id = ACE_OS::strchr(size_str, '[') + 1;
 176       this->expected_req_id_ = ACE_OS::strtol(id, 0, 10);
 177     }
 178   this->sending_ = ACE_OS::strstr(text,"send") ? 0 : 1;
 179   this->expected_type_ = ACE_OS::strstr(text,"Request") ? 0 : 1;
 180 }
 181
 182 void
 183 GIOP_Buffer::owner (Invocation *owner)
 184 {
 185   this->owner_ = owner;
 186 }
 187
 188 Invocation *
 189 GIOP_Buffer::owner ()
 190 {
 191   return this->owner_;
 192 }
 193
 194 void
 195 GIOP_Buffer::init_buf (const char *text, size_t offset)
 196 {
 197   // GIOP message -  HEXDUMP
 198   this->log_offset_ = offset;
 199   const char * size_str = ACE_OS::strstr (text,"HEXDUMP ") + 8;
 200   this->buffer_size_ = ACE_OS::strtol (size_str, 0, 10);
 201   this->payload_size_ = this->buffer_size_ - 12;
 202   size_str =  ACE_OS::strstr (text,"showing first ");
 203   if (size_str != 0)
 204     {
 205       size_str += 14;
 206       this->buffer_size_ = ACE_OS::strtol (size_str, 0, 10);
 207     }
 208   if (this->octets_ != 0)
 209     {
 210       delete [] this->octets_;
 211     }
 212   this->octets_ = new char [this->buffer_size_];
 213   ACE_OS::memset (this->octets_, 0, this->buffer_size_);
 214   this->wr_pos_ = this->octets_;
 215 }
 216
 217 GIOP_Buffer::~GIOP_Buffer()
 218 {
 219   delete [] this->octets_;
 220 }
 221
 222 int
 223 GIOP_Buffer::add_octets (const char *text, size_t offset)
 224 {
 225   if (this->octets_ == 0)
 226     {
 227       this->init_buf(text, offset);
 228       return 0;
 229     }
 230
 231   const char *c = text;
 232   char *err;
 233   for (int count = 0;
 234        count < 16 && this->cur_size() < this->buffer_size_;
 235        count++)
 236     {
 237       if (count == 8)
 238         ++c;
 239       int o = ::strtol(c, &err, 16);
 240       if (err == c || *err == 0)
 241         return -1;
 242       *this->wr_pos_++ = o;
 243       c = err+1;
 244     }
 245   size_t cs = this->cur_size();
 246   int rtn = 0;
 247   if (!this->header_parsed_)
 248     {
 249       this->header_parsed_ = this->parse_header();
 250       if (this->header_parsed_ )
 251         rtn = 1;
 252     }
 253   if (cs == this->buffer_size_)
 254     {
 255       char vmaj = this->octets_[4];
 256       char order = this->octets_[6];
 257
 258       delete this->cdr_;
 259       this->cdr_ = new ACE_InputCDR (this->octets_,
 260                                      this->cur_size(),
 261                                      order, vmaj, this->ver_minor_);
 262       this->cdr_->skip_bytes (this->payload_start_ - this->octets_);
 263       rtn = -1;
 264     }
 265   return rtn;
 266 }
 267
 268 bool
 269 GIOP_Buffer::sending () const
 270 {
 271   return this->sending_;
 272 }
 273
 274 bool
 275 GIOP_Buffer::is_full () const
 276 {
 277   return this->buffer_size_ > 0 && this->cur_size() == this->buffer_size_;
 278 }
 279
 280 char
 281 GIOP_Buffer::type () const
 282 {
 283   if (this->octets_ == 0)
 284     return 127;
 285   return this->octets_[7];
 286 }
 287
 288 char
 289 GIOP_Buffer::expected_type () const
 290 {
 291   return this->expected_type_;
 292 }
 293
 294 char
 295 GIOP_Buffer::minor_version () const
 296 {
 297   return this->ver_minor_;
 298 }
 299
 300 size_t
 301 GIOP_Buffer::reply_status () const
 302 {
 303   return this->reply_status_;
 304 }
 305
 306 size_t
 307 GIOP_Buffer::num_contexts () const
 308 {
 309   return this->num_contexts_;
 310 }
 311
 312 bool
 313 GIOP_Buffer::is_oneway ()
 314 {
 315   if (this->octets_ == 0)
 316     {
 317       return false;
 318     }
 319
 320   if (!this->header_parsed_)
 321     this->header_parsed_ = this->parse_header();
 322
 323   return (resp_exp_ &1) == 0;
 324 }
 325
 326 size_t
 327 GIOP_Buffer::log_posn () const
 328 {
 329   return this->log_offset_;
 330 }
 331
 332 Thread *
 333 GIOP_Buffer::thread ()
 334 {
 335   return this->thr_;
 336 }
 337
 338 const ACE_Time_Value &
 339 GIOP_Buffer::time () const
 340 {
 341   return this->time_;
 342 }
 343
 344 void
 345 GIOP_Buffer::time (const ACE_Time_Value &t)
 346 {
 347   this->time_ = t;
 348 }
 349
 350 const ACE_CString &
 351 GIOP_Buffer::preamble () const
 352 {
 353   return this->preamble_;
 354 }
 355
 356 size_t
 357 GIOP_Buffer::expected_size () const
 358 {
 359   return this->expected_size_;
 360 }
 361
 362 size_t
 363 GIOP_Buffer::msg_size ()
 364 {
 365   if (this->cur_size() < 12)
 366     return 0;
 367   if (!this->header_parsed_)
 368     this->header_parsed_ = this->parse_header();
 369   return (size_leadin == size_leadin_1_5) ? this->payload_size_ : this->msg_size_;
 370 }
 371
 372 size_t
 373 GIOP_Buffer::expected_req_id () const
 374 {
 375   return this->expected_req_id_;
 376 }
 377
 378 size_t
 379 GIOP_Buffer::actual_req_id ()
 380 {
 381   if (this->octets_ == 0)
 382     return 0;
 383
 384   if (!this->header_parsed_)
 385     this->header_parsed_ = this->parse_header();
 386
 387   return this->req_id_;
 388 }
 389
 390 size_t
 391 GIOP_Buffer::cur_size () const
 392 {
 393   return this->wr_pos_ - this->octets_;
 394 }
 395
 396 bool
 397 GIOP_Buffer::parse_svc_contexts ()
 398 {
 399   ACE_CDR::ULong temp;
 400   ACE_CDR::ULong num_svc_cont;
 401   if ( !(*this->cdr_ >> num_svc_cont))
 402     return false;
 403   this->num_contexts_ = static_cast<size_t>(num_svc_cont);
 404   while (num_svc_cont > 0)
 405     {
 406       if (!(*this->cdr_ >> temp))  // tag really
 407         return false;
 408       if (!(*this->cdr_ >> temp))
 409         return false;
 410       if ((this->cur_size() == this->buffer_size_) && (this->cdr_->length() < temp))
 411         {
 412           return this->cdr_->skip_bytes (this->cdr_->length());
 413         }
 414       if (!this->cdr_->skip_bytes(temp))
 415         {
 416           return this->cur_size() == this->buffer_size_;
 417         }
 418       --num_svc_cont;
 419     }
 420   return true;
 421 }
 422
 423 bool
 424 GIOP_Buffer::parse_header ()
 425 {
 426   if (this->octets_ == 0 || this->cur_size() < 12)
 427     {
 428       return false;
 429     }
 430
 431   char vmaj = this->octets_[4];
 432   this->ver_minor_ = this->octets_[5];
 433   char order = this->octets_[6];
 434
 435   char mtype = this->octets_[7];
 436   if (mtype > 1) // not a request or reply
 437     {
 438       return false;
 439     }
 440   delete this->cdr_;
 441   this->cdr_ = new ACE_InputCDR (this->octets_,
 442                                  this->cur_size(),
 443                                  order, vmaj, this->ver_minor_);
 444   this->cdr_->skip_bytes (8);
 445   this->payload_start_ = this->cdr_->rd_ptr();
 446   ACE_CDR::ULong len_ulong;
 447   if (!(*this->cdr_ >> len_ulong))
 448       return false;
 449   this->msg_size_ = len_ulong;
 450
 451   if (this->ver_minor_ < 2)
 452     {
 453       if (!this->parse_svc_contexts())
 454         {
 455           return false;
 456         }
 457     }
 458
 459   if (!(*this->cdr_ >> len_ulong))
 460     {
 461       return false;
 462     }
 463   this->req_id_ = static_cast<size_t>(len_ulong);
 464
 465   switch (mtype) {
 466   case 0: //Request
 467     if (!(*this->cdr_ >> this->resp_exp_))
 468       {
 469         return false;
 470       }
 471     if (this->ver_minor_ > 1 &&
 472         !(*this->cdr_ >> len_ulong)) // address disposition
 473       {
 474         return false;
 475       }
 476     if (!(*this->cdr_ >> len_ulong))
 477       {
 478         return false;
 479       }
 480     this->oid_len_ = static_cast<size_t>(len_ulong);
 481     this->oid_ = this->cdr_->rd_ptr();
 482     if (!this->cdr_->skip_bytes(len_ulong))
 483       {
 484         return false;
 485       }
 486     if (!(*this->cdr_ >> len_ulong))
 487       {
 488         return false;
 489       }
 490     this->opname_ = this->cdr_->rd_ptr();
 491     if (!this->cdr_->skip_bytes(len_ulong))
 492       {
 493         return false;
 494       }
 495     break;
 496   case 1: //Reply
 497     if (!(*this->cdr_ >> len_ulong))
 498       {
 499         return false;
 500       }
 501     this->reply_status_ = static_cast<size_t>(len_ulong);
 502     break;
 503   default:
 504     return true;
 505   }
 506   if (this->ver_minor_ > 1)
 507     {
 508       if (!this->parse_svc_contexts())
 509         return false;
 510     }
 511   this->cdr_->align_read_ptr (8);
 512   this->payload_start_ = this->cdr_->rd_ptr();
 513   return true;
 514 }
 515
 516 const char *
 517 GIOP_Buffer::target_oid (size_t &len)
 518 {
 519   if (this->octets_ == 0)
 520     {
 521       return 0;
 522     }
 523
 524   if (!this->header_parsed_)
 525     this->header_parsed_ = this->parse_header();
 526
 527   if (this->oid_ == 0)
 528     return 0;
 529
 530   len = this->oid_len_;
 531   return this->oid_;
 532 }
 533
 534 const char *
 535 GIOP_Buffer::operation ()
 536 {
 537   if (octets_ == 0)
 538     return 0;
 539
 540   if (!this->header_parsed_)
 541     this->header_parsed_ = this->parse_header();
 542
 543   return this->opname_;
 544 }
 545
 546 ACE_InputCDR &
 547 GIOP_Buffer::payload ()
 548 {
 549   if (octets_ != 0 && !this->header_parsed_)
 550     this->header_parsed_ = this->parse_header();
 551   return *this->cdr_;
 552 }
 553
 554 bool
 555 GIOP_Buffer::has_octets () const
 556 {
 557   return (octets_ != 0);
 558 }
 559
 560 bool
 561 GIOP_Buffer::validate ()
 562 {
 563   return
 564     this->expected_req_id_ == this->actual_req_id() &&
 565     this->expected_type_ == this->type() &&
 566     this->expected_size_ == this->msg_size();
 567 }
 568
 569 bool
 570 GIOP_Buffer::matches (GIOP_Buffer *other) const
 571 {
 572   if (other->header_parsed_)
 573     {
 574       return this->expected_req_id_ == other->actual_req_id() &&
 575         this->expected_type_ == other->type() &&
 576         (this->expected_size_ == other->msg_size() ||
 577          this->expected_size_ == other->msg_size() + 4);
 578     }
 579   return this->expected_req_id_ == other->expected_req_id() &&
 580     this->expected_type_ == other->expected_type() &&
 581     this->sending_ == other->sending() &&
 582     this->expected_size_ == other->expected_size();
 583 }
 584
 585 void
 586 GIOP_Buffer::reset ()
 587 {
 588   this->octets_ = 0;
 589   this->wr_pos_ = 0;
 590   this->buffer_size_ = 0;
 591   this->payload_size_ = 0;
 592   this->buffer_lost_ = true;
 593   this->header_parsed_ = false;
 594   this->opname_ = 0;
 595 }
 596
 597 void
 598 GIOP_Buffer::transfer_from (GIOP_Buffer *other)
 599 {
 600   delete this->octets_;
 601   this->octets_ = other->octets_;
 602   this->wr_pos_ = other->wr_pos_;
 603   this->buffer_size_ = other->buffer_size_;
 604   this->payload_size_ = other->payload_size_;
 605   this->header_parsed_ = false;
 606   other->reset();
 607 }
 608
 609 void
 610 GIOP_Buffer::swap (GIOP_Buffer *other)
 611 {
 612   char *tmp_octets = this->octets_;
 613   char *tmp_wr_pos = this->wr_pos_;
 614   size_t tmp_bsize = this->buffer_size_;
 615   size_t tmp_psize = this->payload_size_;
 616
 617   this->octets_ = other->octets_;
 618   this->wr_pos_ = other->wr_pos_;
 619   this->buffer_size_ = other->buffer_size_;
 620   this->payload_size_ = other->payload_size_;
 621
 622   other->octets_ = tmp_octets;
 623   other->wr_pos_ = tmp_wr_pos;
 624   other->buffer_size_ = tmp_bsize;
 625   other->payload_size_= tmp_psize;
 626 }