src/h4601.cxx

   1 // H4601.cxx: implementation of the H460 class.
   2 /*
   3  * Virteos H.460 Implementation for the OpenH323 Project.
   4  *
   5  * Virteos is a Trade Mark of ISVO (Asia) Pte Ltd.
   6  *
   7  * Copyright (c) 2004 ISVO (Asia) Pte Ltd. All Rights Reserved.
   8  *
   9  * The contents of this file are subject to the Mozilla Public License
  10  * Version 1.0 (the "License"); you may not use this file except in
  11  * compliance with the License. You may obtain a copy of the License at
  12  * http://www.mozilla.org/MPL/
  13  *
  14  * Software distributed under the License is distributed on an "AS IS"
  15  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  16  * the License for the specific language governing rights and limitations
  17  * under the License.
  18  *
  19  * The Original Code is derived from and used in conjunction with the
  20  * OpenH323 Project (www.openh323.org/)
  21  *
  22  * The Initial Developer of the Original Code is ISVO (Asia) Pte Ltd.
  23  *
  24  *
  25  * Contributor(s): ______________________________________.
  26  *
  27  * $Log$
  28  * Revision 1.17  2006/10/10 13:56:41  csoutheren
  29  * Fix problem with H.460 compilation
  30  *
  31  * Revision 1.16  2006/09/20 07:41:59  shorne
  32  * some more updates and fixes
  33  *
  34  * Revision 1.15  2006/08/10 04:05:03  csoutheren
  35  * Apply 1537305 - Fix compile problems on gcc 4.1
  36  * Thanks to Stanislav Brabec
  37  *
  38  * Revision 1.14  2006/07/01 05:31:03  shorne
  39  * added building featureset from generic data field
  40  *
  41  * Revision 1.13  2006/06/15 15:37:20  shorne
  42  * More updates
  43  *
  44  * Revision 1.12  2006/06/11 00:17:43  csoutheren
  45  * Added pragma for old gcc compilers
  46  *
  47  * Revision 1.11  2006/06/09 06:30:12  csoutheren
  48  * Remove compile warning and errors with gcc
  49  *
  50  * Revision 1.10  2006/06/08 13:26:16  shorne
  51  * Resyn Opal and OpenH323 versions
  52  *
  53  * Revision 1.9  2006/06/08 11:50:06  shorne
  54  * Fix for compiling under linux
  55  *
  56  * Revision 1.8  2006/05/30 17:20:46  shorne
  57  * revert part of last change and alter function call
  58  *
  59  * Revision 1.7  2006/05/30 11:16:52  hfriederich
  60  * Fix compiler errors and warning for gcc4
  61  *
  62  * Revision 1.6  2006/05/27 03:28:22  shorne
  63  * Added UnAllocated Message Type Fix compile error on Linux.
  64  *
  65  *
  66 */
  67
  68 #include <ptlib.h>
  69
  70 #ifdef __GNUC__
  71 #pragma implementation "h4601.h"
  72 #endif
  73
  74 #include <ptlib/pluginmgr.h>
  75 #include <h460.h>
  76 #include "h4601.h"
  77
  78 #include <h323.h>
  79
  80 OpalOID::OpalOID()
  81 {
  82
  83 }
  84
  85 OpalOID::OpalOID(const char * str )
  86 {
  87         SetValue(str);
  88 }
  89
  90 H460_FeatureID::H460_FeatureID()
  91 {
  92         SetTag(H225_GenericIdentifier::e_standard);
  93         PASN_Integer & val = *this;
  94         val.SetValue(0);
  95 }
  96
  97 H460_FeatureID::H460_FeatureID(unsigned ID)
  98 {
  99         SetTag(H225_GenericIdentifier::e_standard);
 100         PASN_Integer & val = *this;
 101         val.SetValue(ID);
 102 }
 103
 104 H460_FeatureID::H460_FeatureID(OpalOID ID)
 105 {
 106         SetTag(H225_GenericIdentifier::e_oid);
 107         PASN_ObjectId & val = *this;
 108         val = ID;
 109 }
 110
 111 H460_FeatureID::H460_FeatureID(PString ID)
 112 {
 113         SetTag(H225_GenericIdentifier::e_nonStandard);
 114         H225_GloballyUniqueID & val = *this;
 115         val.SetValue(ID);
 116 }
 117
 118 H460_FeatureID::H460_FeatureID(H225_GenericIdentifier ID)
 119 {
 120         SetTag(ID.GetTag());
 121         H225_GenericIdentifier & val = *this;
 122         val= ID;
 123 }
 124
 125 PObject * H460_FeatureID::Clone() const
 126 {
 127   return new H460_FeatureID(*this);
 128 }
 129
 130 PObject::Comparison H460_FeatureID::Compare(const PObject & obj) const
 131 {
 132   PAssert(PIsDescendant(&obj, H460_FeatureID), PInvalidCast);
 133
 134   const H460_FeatureID & id  = (const H460_FeatureID &)obj;
 135
 136   if (id.IDString() == IDString())
 137         return EqualTo;
 138   else
 139             return LessThan;
 140 }
 141
 142
 143 PINLINE H460_FeatureID & H460_FeatureID::operator=(unsigned ID)
 144 {
 145         SetTag(H225_GenericIdentifier::e_standard);
 146         PASN_Integer & val = *this;
 147         val.SetValue(ID);
 148         return *this;
 149 };
 150
 151 PINLINE H460_FeatureID & H460_FeatureID::operator=(OpalOID ID)
 152 {
 153         SetTag(H225_GenericIdentifier::e_oid);
 154         PASN_ObjectId & val = *this;
 155         val.SetValue(ID.AsString());
 156         return *this;
 157 };
 158
 159 PINLINE H460_FeatureID & H460_FeatureID::operator=(PString ID)
 160 {
 161         SetTag(H225_GenericIdentifier::e_nonStandard);
 162         H225_GloballyUniqueID & val = *this;
 163         val.SetValue(ID);
 164         return *this;
 165 };
 166
 167 PString H460_FeatureID::IDString() const
 168 {
 169         if (GetFeatureType() == H225_GenericIdentifier::e_standard) {
 170                     const PASN_Integer & jint = *this;
 171                         return "Std " + PString(jint);
 172         }
 173
 174         if (GetFeatureType() == H225_GenericIdentifier::e_oid) {
 175                 const PASN_ObjectId & obj = *this;
 176                         return "OID " + obj.AsString();
 177         }
 178
 179         if (GetFeatureType() == H225_GenericIdentifier::e_nonStandard) {
 180                     const H225_GloballyUniqueID & gui = *this;
 181                         return "NonStd " + gui.AsString();
 182         }
 183
 184         return PString("unknown");
 185 }
 186
 187 //////////////////////////////////////////////////////////////////////
 188 H460_FeatureContent::H460_FeatureContent()
 189 {
 190
 191 }
 192
 193 H460_FeatureContent::H460_FeatureContent(PASN_OctetString & param)
 194 {
 195         SetTag(H225_Content::e_raw);
 196         PASN_OctetString & val = *this;
 197         val.SetValue(param);
 198 }
 199
 200 H460_FeatureContent::H460_FeatureContent(const PString & param)
 201 {
 202         SetTag(H225_Content::e_text);
 203         PASN_IA5String & val = *this;
 204         val = param;
 205 }
 206
 207 H460_FeatureContent::H460_FeatureContent(PASN_BMPString & param)
 208 {
 209         SetTag(H225_Content::e_unicode);
 210         PASN_BMPString & val = *this;
 211         val.SetValue(param);
 212 }
 213
 214 H460_FeatureContent::H460_FeatureContent(BOOL param)
 215 {
 216         SetTag(H225_Content::e_bool);
 217         PASN_Boolean & val = *this;
 218         val.SetValue(param);
 219 }
 220
 221 H460_FeatureContent::H460_FeatureContent(unsigned param, unsigned len)
 222 {
 223
 224
 225         if (len == 8) {
 226           SetTag(H225_Content::e_number8);
 227           PASN_Integer & val = *this;
 228           val.SetConstraints(PASN_Object::FixedConstraint, 0, 255);
 229           val.SetValue(param);
 230         }
 231         else if (len == 16) {
 232           SetTag(H225_Content::e_number16);
 233           PASN_Integer & val = *this;
 234           val.SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
 235           val.SetValue(param);
 236         }
 237         else if (len == 32) {
 238           SetTag(H225_Content::e_number32);
 239           PASN_Integer & val = *this;
 240       val.SetConstraints(PASN_Object::FixedConstraint, 0, 4294967295U);
 241           val.SetValue(param);
 242         }
 243         else {
 244           SetTag(H225_Content::e_number8);
 245           PASN_Integer & val = *this;
 246       val.SetConstraints(PASN_Object::FixedConstraint, 0, 255);
 247           val.SetValue(param);
 248     }
 249 }
 250
 251 H460_FeatureContent::H460_FeatureContent(const H460_FeatureID & id)
 252 {
 253         SetTag(H225_Content::e_id);
 254         H225_GenericIdentifier & val = *this;
 255         val = id;
 256 }
 257
 258 H460_FeatureContent::H460_FeatureContent(const H225_AliasAddress & add)
 259 {
 260         SetTag(H225_Content::e_alias);
 261         H225_AliasAddress & val = *this;
 262         val = add;
 263 }
 264
 265 H460_FeatureContent::H460_FeatureContent(const PURL & add)
 266 {
 267
 268         H225_AliasAddress * alias = new H225_AliasAddress();
 269
 270         alias->SetTag(H225_AliasAddress::e_url_ID);
 271         PASN_IA5String & url = *alias;
 272         url = add.AsString();
 273
 274         SetTag(H225_Content::e_alias);
 275         H225_AliasAddress & val = *this;
 276         val = *alias;
 277 }
 278
 279 H460_FeatureContent::H460_FeatureContent(const H323TransportAddress & add)
 280 {
 281         SetTag(H225_Content::e_transport);
 282         H225_TransportAddress & val = *this;
 283         add.SetPDU(val);
 284 }
 285
 286 H460_FeatureContent::H460_FeatureContent(const H460_FeatureTable & table)
 287 {
 288         SetTag(H225_Content::e_compound);
 289         H225_ArrayOf_EnumeratedParameter & val = *this;
 290         val.SetConstraints(PASN_Object::FixedConstraint, 1, 512);
 291         val = table;
 292 }
 293
 294 H460_FeatureContent::H460_FeatureContent(H460_Feature * add)
 295 {
 296         SetTag(H225_Content::e_nested);
 297         H225_ArrayOf_GenericData & val = *this;
 298         val.SetConstraints(PASN_Object::FixedConstraint, 1, 16);
 299         val.Append(add);
 300         val.SetSize(val.GetSize()+1);
 301 }
 302
 303 H460_FeatureContent::H460_FeatureContent(const H225_Content & param)
 304 {
 305         OnReceivedPDU(param);
 306 }
 307
 308 /////////////////////////////////////////////////////////////////////
 309
 310 H460_FeatureParameter::H460_FeatureParameter()
 311 {
 312    m_id = H460_FeatureID(0);
 313 }
 314
 315 H460_FeatureParameter::H460_FeatureParameter(unsigned Identifier)
 316 {
 317    m_id = H460_FeatureID(Identifier);
 318 }
 319
 320 H460_FeatureParameter::H460_FeatureParameter(const PString & Identifier)
 321 {
 322    m_id = H460_FeatureID(Identifier);
 323 }
 324
 325 H460_FeatureParameter::H460_FeatureParameter(const OpalOID & Identifier)
 326 {
 327         m_id = H460_FeatureID(Identifier);
 328 }
 329
 330 H460_FeatureParameter::H460_FeatureParameter(const H225_EnumeratedParameter & param)
 331 {
 332         OnReceivedPDU(param);
 333 }
 334
 335 H460_FeatureParameter::H460_FeatureParameter(const H460_FeatureID & ID)
 336 {
 337    m_id = ID;
 338 }
 339
 340 H460_FeatureContent H460_FeatureParameter::operator=( const PASN_OctetString & value)
 341 {
 342         m_content = H460_FeatureContent(*value);
 343         SetTag(e_content);
 344         return m_content;
 345 }
 346
 347 H460_FeatureContent H460_FeatureParameter::operator=( const PString & value )
 348 {
 349
 350 // Check if url;
 351         PURL * url = new PURL();
 352         if (url->Parse(value,"http"))   // Parameter is an Http Address
 353                 m_content = H460_FeatureContent(*url);
 354
 355
 356         if (value.Find(":") != P_MAX_INDEX) {
 357                 PStringArray Cmd = value.Tokenise(":", FALSE);
 358
 359                 if (Cmd.GetSize() == 2) {       // Parameter is an Address
 360                         H323TransportAddress * add = new H323TransportAddress(Cmd[0],(short)Cmd[1].AsUnsigned());
 361                         m_content = H460_FeatureContent(*add);
 362                 }
 363         }
 364         SetTag(e_content);
 365         return m_content;
 366
 367 }
 368
 369 H460_FeatureContent  H460_FeatureParameter::operator=( const PASN_BMPString & value)
 370 {
 371         m_content = H460_FeatureContent(value);
 372         SetTag(e_content);
 373         return m_content;
 374 }
 375
 376 H460_FeatureContent  H460_FeatureParameter::operator=( const BOOL & value )
 377 {
 378         m_content = H460_FeatureContent(value);
 379         SetTag(e_content);
 380         return m_content;
 381 }
 382
 383 H460_FeatureContent  H460_FeatureParameter::operator=( const unsigned & value )
 384 {
 385
 386   if (value == 0)
 387          m_content = H460_FeatureContent(value,32);
 388   else if (value < 16)
 389          m_content = H460_FeatureContent(value,8);
 390   else if (value < 256)
 391          m_content = H460_FeatureContent(value,16);
 392   else
 393          m_content = H460_FeatureContent(value,32);
 394
 395   SetTag(e_content);
 396   return m_content;
 397 }
 398
 399 H460_FeatureContent  H460_FeatureParameter::operator=( const H460_FeatureID & value )
 400 {
 401         m_content = H460_FeatureContent(value);
 402         SetTag(e_content);
 403         return m_content;
 404 }
 405
 406 H460_FeatureContent  H460_FeatureParameter::operator=( const H225_AliasAddress & value )
 407 {
 408         m_content = H460_FeatureContent(value);
 409         SetTag(e_content);
 410         return m_content;
 411 }
 412
 413 H460_FeatureContent  H460_FeatureParameter::operator=( const H323TransportAddress & value )
 414 {
 415         m_content = H460_FeatureContent(value);
 416         SetTag(e_content);
 417         return m_content;
 418 }
 419
 420 H460_FeatureContent  H460_FeatureParameter::operator=( const H460_FeatureTable & value )
 421 {
 422         m_content = H460_FeatureContent(value);
 423         SetTag(e_content);
 424         return m_content;
 425 }
 426
 427 H460_FeatureContent  H460_FeatureParameter::operator=( H460_Feature * value )
 428 {
 429         m_content = H460_FeatureContent(value);
 430         SetTag(e_content);
 431         return m_content;
 432 }
 433
 434 H460_FeatureParameter::operator PASN_OctetString &()
 435 {
 436         PASN_OctetString & content = m_content;
 437         return content;
 438 };
 439
 440 H460_FeatureParameter::operator PString &()
 441 {
 442         PASN_IA5String & content = m_content;
 443         PString & con = *(new PString(content));
 444         return con;
 445 };
 446
 447 H460_FeatureParameter::operator PASN_BMPString &()
 448 {
 449         PASN_BMPString & content = m_content;
 450         return content;
 451 };
 452
 453 H460_FeatureParameter::operator BOOL ()
 454 {
 455         PASN_Boolean & content = m_content;
 456         BOOL con = content;
 457         return con;
 458 };
 459
 460 H460_FeatureParameter::operator unsigned()
 461 {
 462         PASN_Integer & content = m_content;
 463         return content;
 464 };
 465
 466 H460_FeatureParameter::operator H460_FeatureID &()
 467 {
 468         H225_GenericIdentifier & content = m_content;
 469         return (H460_FeatureID &)content;
 470 };
 471
 472 H460_FeatureParameter::operator H225_AliasAddress &()
 473 {
 474         H225_AliasAddress & content = m_content;
 475         return content;
 476 };
 477
 478 H460_FeatureParameter::operator H323TransportAddress &()
 479 {
 480         H225_TransportAddress & content = m_content;
 481         return (H323TransportAddress &)content;
 482
 483 };
 484
 485 H460_FeatureParameter::operator H225_ArrayOf_EnumeratedParameter &()
 486 {
 487         H225_ArrayOf_EnumeratedParameter & content = m_content;
 488         return content;
 489 };
 490
 491 H460_FeatureParameter::operator PURL &()
 492 {
 493         H225_AliasAddress & content = m_content;
 494
 495         if (content.GetTag() == H225_AliasAddress::e_url_ID) {
 496              PASN_IA5String & Surl = content;
 497                  PURL & url = *(new PURL(Surl));
 498                  return url;
 499         }
 500
 501         return *(new PURL());
 502 };
 503
 504 /////////////////////////////////////////////////////////////////////
 505
 506 H460_FeatureTable::H460_FeatureTable()
 507 {
 508 }
 509
 510 H460_FeatureTable::H460_FeatureTable(const H225_ArrayOf_EnumeratedParameter & Xparams)
 511 {
 512         OnReceivedPDU(Xparams);
 513 }
 514
 515 H460_FeatureParameter & H460_FeatureTable::AddParameter(H460_FeatureID & id, H460_FeatureContent & con)
 516 {
 517 PTRACE(6, "H460\tAdd ID: " << id  << " content " << con);
 518
 519       H460_FeatureParameter * Nparam = new H460_FeatureParameter(id);
 520           Nparam->addContent(con);
 521
 522           AddParameter(*Nparam);
 523
 524           return *Nparam;
 525 }
 526
 527 void H460_FeatureTable::AddParameter(H225_EnumeratedParameter & Xparam)
 528 {
 529     if ((GetSize() == 1) &&
 530                 (!((H225_EnumeratedParameter *)array.GetAt(0))->HasOptionalField(0)))
 531           array.SetAt(0, &Xparam);
 532         else
 533           Append(&Xparam);
 534 }
 535
 536 //void H460_FeatureTable::SetParameter(H460_FeatureParameter & Nparam, H225_EnumeratedParameter & Xparam) const
 537 //{
 538 //      Nparam.OnSendingPDU(Xparam);
 539 //}
 540
 541 H460_FeatureParameter & H460_FeatureTable::GetParameter(PINDEX id)
 542 {
 543         return (H460_FeatureParameter &)*array.GetAt(id);
 544 }
 545
 546 H460_FeatureParameter & H460_FeatureTable::GetParameter(const H460_FeatureID & id)
 547 {
 548
 549         PINDEX num = GetParameterIndex(id);
 550
 551         if (num < GetSize())
 552        return GetParameter(num);
 553     else
 554            return *(new H460_FeatureParameter());
 555 }
 556
 557
 558 PINDEX H460_FeatureTable::GetParameterIndex(const H460_FeatureID & id)
 559 {
 560         PINDEX i;
 561
 562         for (i = 0; i < GetSize(); i++) {
 563                 H460_FeatureParameter & fparam = (H460_FeatureParameter &)array[i];
 564                 H460_FeatureID param = fparam.ID();
 565                 if (param == id)
 566                         return i;
 567         }
 568
 569         return GetSize();
 570 }
 571
 572 BOOL H460_FeatureTable::HasParameter(const H460_FeatureID & id) {
 573
 574 PTRACE(6, "H460\tCheck has Parameter " << id);
 575
 576         if (GetParameterIndex(id) < GetSize())
 577                 return TRUE;
 578
 579         return FALSE;
 580
 581 }
 582
 583 void H460_FeatureTable::RemoveParameter(PINDEX id)
 584 {
 585         RemoveAt(id);
 586 }
 587
 588 void H460_FeatureTable::RemoveParameter(const H460_FeatureID & id)
 589 {
 590         PINDEX j = GetParameterIndex(id);
 591
 592         if (j < GetSize())
 593                 RemoveParameter(j);
 594
 595 }
 596
 597 void H460_FeatureTable::ReplaceParameter(const H460_FeatureID & id, H460_FeatureContent & con)
 598 {
 599
 600 PTRACE(6, "H460\tReplace ID: " << id  << " content " << con);
 601
 602         PINDEX j = GetParameterIndex(id);
 603
 604         if (j == GetSize())
 605                 return;
 606
 607 //      array.RemoveAt(j);
 608
 609     H460_FeatureParameter * Nparam = new H460_FeatureParameter(id);
 610         Nparam->addContent(con);
 611
 612         array.SetAt(j,Nparam);
 613 }
 614
 615
 616 BOOL H460_FeatureTable::ParameterIsUnique(const H460_FeatureID & id)
 617 {
 618         PINDEX i;
 619         PINDEX j =0;
 620
 621         for (i = 0; i < GetSize(); i++) {
 622                 H460_FeatureParameter & param = GetParameter(i);
 623
 624                 if (param.ID() == id) {
 625                         j++;
 626                 }
 627         }
 628         if (j <= 1)
 629            return TRUE;
 630         else
 631            return FALSE;
 632 }
 633
 634 H460_FeatureParameter & H460_FeatureTable::operator[](PINDEX id)
 635 {
 636         return GetParameter(id);
 637 }
 638
 639 /////////////////////////////////////////////////////////////////////
 640
 641 H460_Feature::H460_Feature()
 642    : CurrentTable((H460_FeatureTable*)&m_parameters)
 643 {
 644 //      IncludeOptionalField(e_parameters);
 645 //      CurrentTable = (H460_FeatureTable*)&m_parameters;
 646         ep = NULL;
 647         con = NULL;
 648         FeatureCategory = FeatureSupported;
 649 }
 650
 651 H460_Feature::H460_Feature(unsigned identifier)
 652    : CurrentTable((H460_FeatureTable*)&m_parameters)
 653 {
 654     SetFeatureID(H460_FeatureID(identifier));
 655 //      IncludeOptionalField(e_parameters);
 656 //      CurrentTable = (H460_FeatureTable*)&m_parameters;
 657         ep = NULL;
 658         con = NULL;
 659         FeatureCategory = FeatureSupported;
 660 }
 661
 662 H460_Feature::H460_Feature(PString identifier)
 663    : CurrentTable((H460_FeatureTable*)&m_parameters)
 664 {
 665     SetFeatureID(H460_FeatureID(identifier));
 666 //      IncludeOptionalField(e_parameters);
 667 //      CurrentTable = (H460_FeatureTable*)&m_parameters;
 668         ep = NULL;
 669         con = NULL;
 670         FeatureCategory = FeatureSupported;
 671 }
 672
 673 H460_Feature::H460_Feature(OpalOID identifier)
 674    : CurrentTable((H460_FeatureTable*)&m_parameters)
 675 {
 676     SetFeatureID(H460_FeatureID(identifier));
 677 //    IncludeOptionalField(e_parameters);
 678 //        CurrentTable = (H460_FeatureTable *)&m_parameters;
 679         ep = NULL;
 680         con = NULL;
 681         FeatureCategory = FeatureSupported;
 682 }
 683
 684
 685 H460_Feature::H460_Feature(const H225_FeatureDescriptor & descriptor)
 686 {
 687         CurrentTable = (H460_FeatureTable *)&m_parameters;
 688         OnReceivedPDU(descriptor);
 689         ep = NULL;
 690         con = NULL;
 691 }
 692
 693 PString H460_Feature::GetFeatureIDAsString()
 694 {
 695    return  ((H460_FeatureID)m_id).IDString();
 696 }
 697
 698 H460_FeatureParameter & H460_Feature::AddParameter(H460_FeatureID * id, H460_FeatureContent & con)
 699 {
 700         if (!HasOptionalField(e_parameters)) {
 701             IncludeOptionalField(e_parameters);
 702             CurrentTable = (H460_FeatureTable*)&m_parameters;
 703         }
 704         return CurrentTable->AddParameter(*id, con);
 705 }
 706
 707 void H460_Feature::AddParameter(H460_FeatureParameter * param)
 708 {
 709         if (!HasOptionalField(e_parameters)) {
 710             IncludeOptionalField(e_parameters);
 711             CurrentTable = (H460_FeatureTable*)&m_parameters;
 712         }
 713
 714         CurrentTable->AddParameter(*param);
 715 }
 716
 717 void H460_Feature::RemoveParameter(PINDEX id)
 718 {
 719         CurrentTable->RemoveParameter(id);
 720
 721         if (CurrentTable->ParameterCount() == 0) {
 722             RemoveOptionalField(e_parameters);
 723         }
 724 }
 725
 726 void H460_Feature::ReplaceParameter(H460_FeatureID id, H460_FeatureContent & con)
 727 {
 728         CurrentTable->ReplaceParameter(id,con);
 729 }
 730
 731 H460_FeatureParameter & H460_Feature::GetFeatureParameter(PINDEX id)
 732 {
 733         return CurrentTable->GetParameter(id);
 734 }
 735
 736 H460_FeatureParameter & H460_Feature::GetFeatureParameter(const H460_FeatureID & id)
 737 {
 738         return CurrentTable->GetParameter(id);
 739 }
 740
 741 BOOL H460_Feature::HasFeatureParameter(const H460_FeatureID & id)
 742 {
 743         return CurrentTable->HasParameter(id);
 744 }
 745
 746 BOOL H460_Feature::Contains(const H460_FeatureID & id)
 747 {
 748         PTRACE(6, "H460\tCheck for Parameter " << id);
 749
 750         if (HasOptionalField(e_parameters)) {
 751             H460_FeatureTable & Table = (H460_FeatureTable &)m_parameters;
 752                 if (Table.HasParameter(id))
 753                         return TRUE;
 754         }
 755
 756     return FALSE;
 757 }
 758
 759 H460_FeatureParameter & H460_Feature::Value(const H460_FeatureID & id)
 760 {
 761         if (HasOptionalField(e_parameters)) {
 762             H460_FeatureTable & Table = (H460_FeatureTable &)m_parameters;
 763                 if (Table.HasParameter(id))
 764                         return Table.GetParameter(id);
 765         }
 766
 767     return *(new H460_FeatureParameter());
 768 }
 769
 770 H460_FeatureParameter & H460_Feature::operator()(PINDEX id)
 771 {
 772         return CurrentTable->GetParameter(id);
 773 }
 774
 775 H460_FeatureParameter & H460_Feature::operator()(const H460_FeatureID & id)
 776 {
 777         return GetFeatureParameter(id);
 778 }
 779
 780 H460_FeatureTable & H460_Feature::GetCurrentTable()
 781 {
 782         return *CurrentTable;
 783 }
 784
 785 void H460_Feature::SetCurrentTable(H460_FeatureTable & table)
 786 {
 787         CurrentTable = &table;
 788 }
 789
 790 void H460_Feature::SetCurrentTable(H460_FeatureParameter & param)
 791 {
 792         H225_ArrayOf_EnumeratedParameter & table = param;
 793     SetCurrentTable((H460_FeatureTable &)table);
 794 }
 795
 796 void H460_Feature::SetDefaultTable()
 797 {
 798         CurrentTable = (H460_FeatureTable*)&m_parameters;
 799 }
 800
 801 void H460_Feature::AttachEndPoint(H323EndPoint * _ep)
 802 {
 803    ep = _ep;
 804 }
 805
 806 void H460_Feature::AttachConnection(H323Connection * _con)
 807 {
 808    con = _con;
 809 }
 810
 811 /////////////////////////////////////////////////////////////////////
 812
 813 static const char H460FeaturePluginBaseClass[] = "H460_Feature";
 814
 815 template <> H460_Feature * PDevicePluginFactory<H460_Feature>::Worker::Create(const PString & type) const
 816 {
 817   return H460_Feature::CreateFeature(type);
 818 }
 819
 820 PStringList H460_Feature::GetFeatureNames(PPluginManager * pluginMgr)
 821 {
 822   if (pluginMgr == NULL)
 823     pluginMgr = &PPluginManager::GetPluginManager();
 824
 825   return pluginMgr->GetPluginsProviding(H460FeaturePluginBaseClass);
 826 }
 827
 828 PStringList H460_Feature::GetFeatureFriendlyNames(const PString & feature, PPluginManager * pluginMgr)
 829 {
 830   if (pluginMgr == NULL)
 831     pluginMgr = &PPluginManager::GetPluginManager();
 832
 833   return pluginMgr->GetPluginsDeviceNames(feature, H460FeaturePluginBaseClass);
 834 }
 835
 836 H460_Feature * H460_Feature::CreateFeature(const PString & featurename, int pduType, PPluginManager * pluginMgr)
 837 {
 838   if (pluginMgr == NULL)
 839     pluginMgr = &PPluginManager::GetPluginManager();
 840
 841   return (H460_Feature *)pluginMgr->CreatePluginsDeviceByName(featurename, H460FeaturePluginBaseClass,pduType);
 842 }
 843
 844
 845 /////////////////////////////////////////////////////////////////////
 846
 847 H460_FeatureStd::H460_FeatureStd(unsigned Identifier)
 848         : H460_Feature(Identifier)
 849 {
 850 }
 851
 852 H460_FeatureParameter & H460_FeatureStd::Add(unsigned id, H460_FeatureContent & con)
 853 {
 854     return AddParameter(new H460_FeatureID(id),con);
 855 }
 856
 857 void H460_FeatureStd::Remove(unsigned id)
 858 {
 859         RemoveParameter(H460_FeatureID(id));
 860 }
 861
 862 void H460_FeatureStd::Replace(unsigned id, H460_FeatureContent & con)
 863 {
 864         ReplaceParameter(H460_FeatureID(id),con);
 865 }
 866
 867 BOOL H460_FeatureStd::HasParameter(unsigned id)
 868 {
 869         return HasFeatureParameter(H460_FeatureID(id));
 870 }
 871
 872 H460_FeatureParameter & H460_FeatureStd::GetParameter(unsigned id)
 873 {
 874         return GetFeatureParameter(H460_FeatureID(id));
 875 }
 876
 877
 878 /////////////////////////////////////////////////////////////////////
 879
 880 H460_FeatureNonStd::H460_FeatureNonStd(PString Identifier)
 881         : H460_Feature(Identifier)
 882 {
 883 }
 884
 885 H460_FeatureParameter & H460_FeatureNonStd::Add(PString id, H460_FeatureContent & con)
 886 {
 887         return AddParameter(new H460_FeatureID(id),con);
 888 }
 889
 890 void H460_FeatureNonStd::Remove(PString id)
 891 {
 892         RemoveParameter(H460_FeatureID(id));
 893 }
 894
 895 void H460_FeatureNonStd::Replace(PString id, H460_FeatureContent & con)
 896 {
 897         ReplaceParameter(H460_FeatureID(id),con);
 898 }
 899
 900 BOOL H460_FeatureNonStd::HasParameter(PString id)
 901 {
 902         return HasFeatureParameter(H460_FeatureID(id));
 903 }
 904
 905 H460_FeatureParameter & H460_FeatureNonStd::operator[](PString id)
 906 {
 907         return GetFeatureParameter(H460_FeatureID(id));
 908 }
 909
 910 /////////////////////////////////////////////////////////////////////
 911
 912 H460_FeatureOID::H460_FeatureOID(OpalOID Identifier)
 913         : H460_Feature(Identifier)
 914 {
 915 }
 916
 917 H460_FeatureParameter & H460_FeatureOID::Add(const PString & id, H460_FeatureContent & con)
 918 {
 919         PString val = GetBase() + "." + id;
 920         return AddParameter(new H460_FeatureID(OpalOID(val)),con);
 921 }
 922
 923 void H460_FeatureOID::Remove(const PString & id)
 924 {
 925         PString val = GetBase() + "." + id;
 926         RemoveParameter(H460_FeatureID(OpalOID(val)));
 927 }
 928
 929 void H460_FeatureOID::Replace(const PString & id, H460_FeatureContent & con)
 930 {
 931         PString val = GetBase() + "." + id;
 932         ReplaceParameter(H460_FeatureID(OpalOID(val)),con);
 933 }
 934
 935
 936 BOOL H460_FeatureOID::HasParameter(OpalOID id)
 937 {
 938         return HasFeatureParameter(H460_FeatureID(id));
 939 }
 940
 941
 942 H460_FeatureParameter & H460_FeatureOID::operator[](OpalOID id)
 943 {
 944         PString val = GetBase() + "." + id.AsString();
 945         return GetFeatureParameter(H460_FeatureID(OpalOID(val)));
 946 }
 947
 948 BOOL H460_FeatureOID::Contains(const PString & id)
 949 {
 950         PString val = GetBase() + "." + id;
 951         return  H460_Feature::Contains(OpalOID(val));
 952 }
 953
 954 H460_FeatureParameter & H460_FeatureOID::Value(const PString & id)
 955 {
 956         PString val = GetBase() + "." + id;
 957         return  H460_Feature::Value(OpalOID(val));
 958 }
 959
 960 PString H460_FeatureOID::GetBase()
 961 {
 962         OpalOID id = (H460_FeatureID)m_id;
 963     return id.AsString();
 964 }
 965
 966 /////////////////////////////////////////////////////////////////////
 967 H460_FeatureSet::H460_FeatureSet()
 968 {
 969         ep = NULL;
 970         baseSet = NULL;
 971 }
 972
 973 H460_FeatureSet::H460_FeatureSet(H460_FeatureSet * _base)
 974 {
 975         Features.DisallowDeleteObjects();   // Derived FeatureSets should not delete Objects.
 976         AttachBaseFeatureSet(_base);
 977         AttachEndPoint(_base->GetEndPoint());
 978 }
 979
 980 H460_FeatureSet::H460_FeatureSet(const H225_FeatureSet & fs)
 981 {
 982         Features.DisallowDeleteObjects();   // Built FeatureSet should not delete Objects.
 983         ep = NULL;
 984         baseSet = NULL;
 985         CreateFeatureSet(fs);
 986 }
 987
 988 H460_FeatureSet::H460_FeatureSet(const H225_ArrayOf_GenericData & generic)
 989 {
 990         Features.DisallowDeleteObjects();   // Built FeatureSet should not delete Objects.
 991         ep = NULL;
 992         baseSet = NULL;
 993
 994     for (PINDEX i=0; i < generic.GetSize(); i++) {
 995            AddFeature((H460_Feature *)&generic[i]);
 996         }
 997 }
 998
 999 BOOL H460_FeatureSet::ProcessFirstPDU(const H225_FeatureSet & fs)
1000 {
1001
1002 PTRACE(6,"H460\tCreate Common FeatureSet");
1003
1004     H460_FeatureSet remote = H460_FeatureSet(fs);
1005
1006  /// Remove the features the remote does not support.
1007         for (PINDEX i=0; i < Features.GetSize(); i++) {
1008             H460_Feature & feat = Features.GetDataAt(i);
1009                 H460_FeatureID id = feat.GetFeatureID();
1010                 if (!remote.HasFeature(id))
1011                          RemoveFeature(id);
1012                 else
1013                    PTRACE(4,"H460\tUse Common Feature " << id);
1014         }
1015
1016
1017         return TRUE;
1018 }
1019
1020 BOOL H460_FeatureSet::CreateFeatureSet(const H225_FeatureSet & fs)
1021 {
1022         PTRACE(6,"H460\tCreate FeatureSet from FeatureSet PDU");
1023
1024           if (fs.HasOptionalField(H225_FeatureSet::e_neededFeatures)) {
1025              const H225_ArrayOf_FeatureDescriptor & fsn = fs.m_neededFeatures;
1026                   for (PINDEX i=0; i < fsn.GetSize(); i++) {
1027                           AddFeature((H460_Feature *)&fsn[i]);
1028                   }
1029           }
1030
1031           if (fs.HasOptionalField(H225_FeatureSet::e_desiredFeatures)) {
1032             const H225_ArrayOf_FeatureDescriptor & fsd = fs.m_desiredFeatures;
1033                   for (PINDEX i=0; i < fsd.GetSize(); i++) {
1034                           AddFeature((H460_Feature *)&fsd[i]);
1035                   }
1036           }
1037
1038           if (fs.HasOptionalField(H225_FeatureSet::e_supportedFeatures)) {
1039             const H225_ArrayOf_FeatureDescriptor & fss = fs.m_supportedFeatures;
1040                   for (PINDEX i=0; i < fss.GetSize(); i++) {
1041                           AddFeature((H460_Feature *)&fss[i]);
1042                   }
1043           }
1044           return TRUE;
1045 }
1046
1047
1048 BOOL H460_FeatureSet::LoadFeatureSet(int inst, H323Connection * con)
1049 {
1050
1051   PStringList features = H460_Feature::GetFeatureNames();
1052
1053       for (PINDEX i = 0; i < features.GetSize(); i++) {
1054
1055         H460_FeatureID id;
1056         H460_Feature * feat = NULL;
1057         if (baseSet && baseSet->HasFeature(features[i])) {
1058             H460_Feature * tempfeat = baseSet->GetFeature(features[i]);
1059                       if ((tempfeat->GetPurpose() >= inst) && (tempfeat->GetPurpose() < inst*2))
1060                                   feat = tempfeat;
1061                 } else {
1062                 feat = H460_Feature::CreateFeature(features[i],inst);
1063                         if ((feat) && (ep))
1064                         feat->AttachEndPoint(ep);
1065                 }
1066
1067                 if (feat) {
1068                     if (con)
1069                         feat->AttachConnection(con);
1070
1071                AddFeature(feat);
1072                    PTRACE(4,"H460\tLoaded Feature " << features[i]);
1073                 }
1074           }
1075
1076   return TRUE;
1077 }
1078
1079 BOOL H460_FeatureSet::LoadFeature(const PString & featid)
1080 {
1081
1082         H460_Feature * newfeat = H460_Feature::CreateFeature(featid);
1083
1084         if (newfeat != NULL)
1085                 return AddFeature(newfeat);
1086         else
1087                 return FALSE;
1088 }
1089
1090 H460_FeatureSet & H460_FeatureSet::DeriveNewFeatureSet()
1091 {
1092         H460_FeatureSet * feat = new H460_FeatureSet(this) ;
1093         return *feat;
1094 }
1095
1096
1097 BOOL H460_FeatureSet::AddFeature(H460_Feature * Nfeat)
1098 {
1099
1100         PTRACE(4, "H460\tLoaded " << Nfeat->GetFeatureIDAsString());
1101
1102         return Features.SetAt(Nfeat->GetFeatureID(),Nfeat);
1103
1104 }
1105
1106 void H460_FeatureSet::RemoveFeature(H460_FeatureID id)
1107 {
1108   PStringStream info;
1109   info << "H460\t Removed ";
1110         switch (id.GetFeatureType()) {
1111            case H460_FeatureID::e_standard:
1112                         info << "Std Feature " << (unsigned)id << "\n";
1113                         break;
1114            case H460_FeatureID::e_oid:
1115                         info << "OID Feature " << (OpalOID)id << "\n";
1116                         break;
1117            case H460_FeatureID::e_nonStandard:
1118                         info << "NonStd Feature " << ((H225_GloballyUniqueID &)(id)).AsString() << "\n";
1119                         break;
1120         }
1121         PTRACE(4, info);
1122
1123         Features.RemoveAt(id);
1124 }
1125
1126
1127 #if PTRACING
1128 PString featureType(PINDEX id)
1129 {
1130         switch (id) {
1131         case 1: return "Needed";
1132         case 2: return "Desired";
1133         case 3: return "Supported";
1134         default: return "?";
1135         }
1136 }
1137 #endif
1138
1139 BOOL H460_FeatureSet::CreateFeatureSetPDU(H225_FeatureSet & fs, unsigned MessageID)
1140 {
1141         PTRACE(6,"H460\tCreate FeatureSet " << PTracePDU(MessageID) << " PDU");
1142
1143         BOOL buildPDU = FALSE;
1144
1145         for (PINDEX i = 0; i < Features.GetSize(); i++) {    // Iterate thro the features
1146            H460_Feature & feat = Features.GetDataAt(i);
1147         PTRACE(6,"H460\tExamining " << feat.GetFeatureIDAsString());
1148
1149                 PINDEX lastPos;
1150                 H225_FeatureDescriptor featdesc;
1151                 if (CreateFeaturePDU(feat,featdesc,MessageID)) {
1152
1153 #if PTRACING
1154                   PTRACE(6,"H460\tLoading Feature " << feat.GetFeatureIDAsString() << " as "
1155             << featureType(feat.FeatureCategory) << " feature to " << PTracePDU(MessageID)
1156                         << " PDU\n" << featdesc );
1157 #endif
1158
1159 /// For some completely silly reason the ITU decided to send/receive H460 Messages in two places,
1160 /// for some messages it is included in the messsage body FeatureSet (to Advertise it) and others
1161 /// in the genericData field (as actual information). Even though a Feature is generic data. It is beyond
1162 /// me to determine Why it is so. Anyway if a message is to be carried in the genericData field it is given
1163 /// the default category of supported.
1164
1165      PINDEX cat;
1166      switch (MessageID) {
1167         case H460_MessageType::e_gatekeeperRequest:
1168         case H460_MessageType::e_gatekeeperConfirm:
1169         case H460_MessageType::e_gatekeeperReject:
1170         case H460_MessageType::e_registrationRequest:
1171         case H460_MessageType::e_registrationConfirm:
1172         case H460_MessageType::e_registrationReject:
1173         case H460_MessageType::e_setup:
1174         case H460_MessageType::e_callProceeding:
1175             cat = feat.FeatureCategory;
1176             break;
1177         default:
1178             cat = H460_Feature::FeatureSupported;
1179          }
1180
1181           buildPDU = TRUE;
1182                    switch (cat) {                       // Add it to the correct feature list
1183                            case H460_Feature::FeatureNeeded:
1184
1185                                   if (featdesc.GetDataLength() > 0) {
1186                                         if (!fs.HasOptionalField(H225_FeatureSet::e_neededFeatures))
1187                                             fs.IncludeOptionalField(H225_FeatureSet::e_neededFeatures);
1188
1189                              H225_ArrayOf_FeatureDescriptor & fsn = fs.m_neededFeatures;
1190                                                         lastPos = fsn.GetSize();
1191                                                         fsn.SetSize(lastPos+1);
1192                                                         fsn[lastPos] = featdesc;
1193                                   }
1194                                  break;
1195
1196                            case H460_Feature::FeatureDesired:
1197
1198                                   if (featdesc.GetDataLength() > 0) {
1199                                         if (!fs.HasOptionalField(H225_FeatureSet::e_desiredFeatures))
1200                                           fs.IncludeOptionalField(H225_FeatureSet::e_desiredFeatures);
1201
1202                              H225_ArrayOf_FeatureDescriptor & fsd = fs.m_desiredFeatures;
1203                                                         lastPos = fsd.GetSize();
1204                                                         fsd.SetSize(lastPos+1);
1205                                                         fsd[lastPos] = featdesc;
1206                                   }
1207                                  break;
1208
1209                            case H460_Feature::FeatureSupported:
1210
1211                                   if (featdesc.GetDataLength() > 0) {
1212                                          if (!fs.HasOptionalField(H225_FeatureSet::e_supportedFeatures))
1213                                            fs.IncludeOptionalField(H225_FeatureSet::e_supportedFeatures);
1214
1215                                                  H225_ArrayOf_FeatureDescriptor & fss = fs.m_supportedFeatures;
1216                                                         lastPos = fss.GetSize();
1217                                                         fss.SetSize(lastPos+1);
1218                                                         fss[lastPos] = featdesc;
1219                                   }
1220                                  break;
1221                    }
1222                 }
1223         }
1224
1225         PTRACE(4,"H460\tFeatureSet for " << PTracePDU(MessageID) << " PDU\n" << fs);
1226
1227         return buildPDU;
1228 }
1229
1230 void H460_FeatureSet::ReadFeatureSetPDU(const H225_FeatureSet & fs, unsigned MessageID)
1231 {
1232
1233 PTRACE(6,"H460\tRead FeatureSet " << PTracePDU(MessageID) << " PDU");
1234
1235 // Generate Common Set of Features.
1236    switch (MessageID) {
1237          case H460_MessageType::e_gatekeeperRequest:
1238          case H460_MessageType::e_gatekeeperConfirm:
1239      case H460_MessageType::e_registrationRequest:
1240      case H460_MessageType::e_registrationConfirm:
1241          case H460_MessageType::e_setup:
1242          case H460_MessageType::e_callProceeding:
1243                  ProcessFirstPDU(fs);
1244                  break;
1245          default:
1246                  break;
1247    }
1248
1249           H460_FeatureID ID;
1250
1251           if (fs.HasOptionalField(H225_FeatureSet::e_neededFeatures)) {
1252             const H225_ArrayOf_FeatureDescriptor & fsn = fs.m_neededFeatures;
1253                   for (PINDEX i=0; i < fsn.GetSize(); i++) {
1254                           H225_FeatureDescriptor & fd = fsn[i];
1255                           ID = GetFeatureIDPDU(fd);
1256
1257                           if (HasFeature(ID))
1258                                         ReadFeaturePDU(Features[ID],fd,MessageID);
1259                   }
1260           }
1261
1262           if (fs.HasOptionalField(H225_FeatureSet::e_desiredFeatures)) {
1263             const H225_ArrayOf_FeatureDescriptor & fsd = fs.m_desiredFeatures;
1264                   for (PINDEX i=0; i < fsd.GetSize(); i++) {
1265                           H225_FeatureDescriptor & fd = fsd[i];
1266                           ID = GetFeatureIDPDU(fd);
1267
1268                           if (HasFeature(ID))
1269                                         ReadFeaturePDU(Features[ID],fd,MessageID);
1270                   }
1271           }
1272
1273           if (fs.HasOptionalField(H225_FeatureSet::e_supportedFeatures)) {
1274             const H225_ArrayOf_FeatureDescriptor & fss = fs.m_supportedFeatures;
1275                   for (PINDEX i=0; i < fss.GetSize(); i++) {
1276                           H225_FeatureDescriptor & fd = fss[i];
1277                           ID = GetFeatureIDPDU(fd);
1278
1279                           if (HasFeature(ID))
1280                                         ReadFeaturePDU(Features[ID],fd,MessageID);
1281                   }
1282           }
1283 }
1284
1285 H460_FeatureID H460_FeatureSet::GetFeatureIDPDU(H225_FeatureDescriptor & pdu)
1286 {
1287
1288         H460_FeatureID fid;
1289         H225_GenericIdentifier & id = pdu.m_id;
1290
1291           if ((id.GetTag() == H225_GenericIdentifier::e_standard)) {
1292                   PASN_Integer & sid = id;
1293                   unsigned iid = sid.GetValue();
1294                   fid = H460_FeatureID(iid);
1295           }
1296
1297           if ((id.GetTag() == H225_GenericIdentifier::e_oid)) {
1298                   PASN_ObjectId & oid = id;
1299                   OpalOID  & aid = (OpalOID &)oid;
1300                   fid = H460_FeatureID(aid);
1301
1302           }
1303
1304           if ((id.GetTag() == H225_GenericIdentifier::e_nonStandard)) {
1305                   H225_GloballyUniqueID & uns = id;
1306                   PString uid = uns.AsString();
1307                   fid = H460_FeatureID(uid);
1308           }
1309
1310     return fid;
1311 }
1312
1313 BOOL H460_FeatureSet::CreateFeaturePDU(H460_Feature & Feat, H225_FeatureDescriptor & pdu,unsigned MessageID)
1314 {
1315
1316 PTRACE(6,"H460\tEncoding " << PTracePDU(MessageID) << " PDU for " << Feat.GetFeatureIDAsString() );
1317
1318         switch (MessageID) {
1319       case H460_MessageType::e_gatekeeperRequest:
1320                         return Feat.OnSendGatekeeperRequest(pdu);
1321
1322       case H460_MessageType::e_gatekeeperConfirm:
1323                         return Feat.OnSendGatekeeperConfirm(pdu);
1324
1325       case H460_MessageType::e_gatekeeperReject:
1326                         return Feat.OnSendGatekeeperReject(pdu);
1327
1328       case H460_MessageType::e_registrationRequest:
1329                         return Feat.OnSendRegistrationRequest(pdu);
1330
1331       case H460_MessageType::e_registrationConfirm:
1332                         return Feat.OnSendRegistrationConfirm(pdu);
1333
1334       case H460_MessageType::e_registrationReject:
1335                         return Feat.OnSendRegistrationReject(pdu);
1336
1337       case H460_MessageType::e_admissionRequest:
1338                         return Feat.OnSendAdmissionRequest(pdu);
1339
1340       case H460_MessageType::e_admissionConfirm:
1341                         return Feat.OnSendAdmissionConfirm(pdu);
1342
1343       case H460_MessageType::e_admissionReject:
1344                         return Feat.OnSendAdmissionReject(pdu);
1345
1346       case H460_MessageType::e_locationRequest:
1347                         return Feat.OnSendLocationRequest(pdu);
1348
1349       case H460_MessageType::e_locationConfirm:
1350                         return Feat.OnSendLocationConfirm(pdu);
1351
1352       case H460_MessageType::e_locationReject:
1353                         return Feat.OnSendLocationReject(pdu);
1354
1355       case H460_MessageType::e_nonStandardMessage:
1356                         return Feat.OnSendNonStandardMessage(pdu);
1357
1358       case H460_MessageType::e_serviceControlIndication:
1359                         return Feat.OnSendServiceControlIndication(pdu);
1360
1361       case H460_MessageType::e_serviceControlResponse:
1362                         return Feat.OnSendServiceControlResponse(pdu);
1363 /*
1364           case H460_MessageType::e_Endpoint:
1365                 return Feat.OnSendEndpoint(pdu);
1366 */
1367           case H460_MessageType::e_setup:
1368                     return Feat.OnSendSetup_UUIE(pdu);
1369
1370           case H460_MessageType::e_alerting:
1371                     return Feat.OnSendAlerting_UUIE(pdu);
1372
1373           case H460_MessageType::e_callProceeding:
1374                     return Feat.OnSendCallProceeding_UUIE(pdu);
1375
1376           case H460_MessageType::e_connect:
1377                     return Feat.OnSendCallConnect_UUIE(pdu);
1378
1379           case H460_MessageType::e_facility:
1380                         return Feat.OnSendFacility_UUIE(pdu);
1381
1382           case H460_MessageType::e_releaseComplete:
1383                     return Feat.OnSendReleaseComplete_UUIE(pdu);
1384
1385           default:
1386                     return Feat.OnSendUnAllocatedPDU(pdu);
1387         }
1388
1389         return FALSE;
1390 }
1391
1392 void H460_FeatureSet::ReadFeaturePDU(H460_Feature & Feat, const H225_FeatureDescriptor & pdu,unsigned MessageID)
1393 {
1394
1395 PTRACE(6,"H460\tDecoding " << PTracePDU(MessageID) << " PDU for " << Feat.GetFeatureIDAsString() );
1396
1397         switch (MessageID) {
1398       case H460_MessageType::e_gatekeeperRequest:
1399                        Feat.OnReceiveGatekeeperRequest(pdu);
1400                            break;
1401
1402       case H460_MessageType::e_gatekeeperConfirm:
1403                        Feat.OnReceiveGatekeeperConfirm(pdu);
1404                            break;
1405       case H460_MessageType::e_gatekeeperReject:
1406                        Feat.OnReceiveGatekeeperReject(pdu);
1407                break;
1408       case H460_MessageType::e_registrationRequest:
1409                        Feat.OnReceiveRegistrationRequest(pdu);
1410                break;
1411       case H460_MessageType::e_registrationConfirm:
1412                        Feat.OnReceiveRegistrationConfirm(pdu);
1413                break;
1414       case H460_MessageType::e_registrationReject:
1415                        Feat.OnReceiveRegistrationReject(pdu);
1416                break;
1417       case H460_MessageType::e_admissionRequest:
1418                        Feat.OnReceiveAdmissionRequest(pdu);
1419                break;
1420       case H460_MessageType::e_admissionConfirm:
1421                        Feat.OnReceiveAdmissionConfirm(pdu);
1422                break;
1423       case H460_MessageType::e_admissionReject:
1424                        Feat.OnReceiveAdmissionReject(pdu);
1425                break;
1426       case H460_MessageType::e_locationRequest:
1427                        Feat.OnReceiveLocationRequest(pdu);
1428                break;
1429       case H460_MessageType::e_locationConfirm:
1430                        Feat.OnReceiveLocationConfirm(pdu);
1431                break;
1432       case H460_MessageType::e_locationReject:
1433                        Feat.OnReceiveLocationReject(pdu);
1434                break;
1435       case H460_MessageType::e_nonStandardMessage:
1436                        Feat.OnReceiveNonStandardMessage(pdu);
1437                break;
1438       case H460_MessageType::e_serviceControlIndication:
1439                        Feat.OnReceiveServiceControlIndication(pdu);
1440                break;
1441       case H460_MessageType::e_serviceControlResponse:
1442                        Feat.OnReceiveServiceControlResponse(pdu);
1443                break;
1444 //        case H460_MessageType::e_Endpoint:
1445 //              return Feat.OnReceiveEndpoint(pdu);
1446
1447           case H460_MessageType::e_setup:
1448                        Feat.OnReceiveSetup_UUIE(pdu);
1449                break;
1450           case H460_MessageType::e_alerting:
1451                        Feat.OnReceiveAlerting_UUIE(pdu);
1452                break;
1453           case H460_MessageType::e_callProceeding:
1454                        Feat.OnReceiveCallProceeding_UUIE(pdu);
1455                break;
1456           case H460_MessageType::e_connect:
1457                        Feat.OnReceiveCallConnect_UUIE(pdu);
1458                break;
1459           case H460_MessageType::e_facility:
1460                        Feat.OnReceiveFacility_UUIE(pdu);
1461                break;
1462           case H460_MessageType::e_releaseComplete :
1463                        Feat.OnReceiveReleaseComplete_UUIE(pdu);
1464                break;
1465       default:
1466                Feat.OnReceivedUnAllocatedPDU(pdu);
1467         }
1468 }
1469
1470 PString H460_FeatureSet::PTracePDU(PINDEX id) const
1471 {
1472         switch (id) {
1473                 case H460_MessageType::e_gatekeeperRequest : return "GK Request";
1474                 case H460_MessageType::e_gatekeeperConfirm : return "GK Confirm";
1475                 case H460_MessageType::e_gatekeeperReject : return "GK Reject";
1476                 case H460_MessageType::e_registrationRequest : return  "Reg Request";
1477                 case H460_MessageType::e_registrationConfirm : return  "Reg Confirm";
1478                 case H460_MessageType::e_registrationReject : return  "Reg Reject";
1479                 case H460_MessageType::e_admissionRequest : return "Adm Reqest";
1480                 case H460_MessageType::e_admissionConfirm : return "Adm Confirm";
1481                 case H460_MessageType::e_admissionReject : return  "Adm Reject";
1482                 case H460_MessageType::e_locationRequest : return  "Loc Request";
1483                 case H460_MessageType::e_locationConfirm : return "Loc Confirm";
1484                 case H460_MessageType::e_locationReject : return "Loc Reject";
1485                 case H460_MessageType::e_nonStandardMessage : return  "NonStd";
1486                 case H460_MessageType::e_serviceControlIndication :return "Ctrl Indication";
1487                 case H460_MessageType::e_serviceControlResponse :return "Ctrl Response";
1488 //              case H460_MessageType::e_Endpoint :return "Endpoint";
1489                 case H460_MessageType::e_setup :return "Setup";
1490                 case H460_MessageType::e_alerting :return "Alerting";
1491                 case H460_MessageType::e_callProceeding :return "CallProceed";
1492                 case H460_MessageType::e_connect :return "Connect";
1493                 case H460_MessageType::e_facility :return "Facility";
1494                 case H460_MessageType::e_releaseComplete : return "ReleaseComplete";
1495                 default: return "?";
1496         }
1497 }
1498
1499
1500 void H460_FeatureSet::ReceiveFeature(unsigned id, const H225_FeatureSet & Message)
1501 {
1502         ReadFeatureSetPDU(Message,id);
1503 }
1504
1505 BOOL H460_FeatureSet::SendFeature(unsigned id, H225_FeatureSet & Message)
1506 {
1507         return CreateFeatureSetPDU(Message,id);
1508 }
1509
1510 void H460_FeatureSet::AttachEndPoint(H323EndPoint * _ep)
1511 {
1512    PTRACE(4,"H460\tEndpoint Attached");
1513    ep = _ep;
1514 }
1515
1516 void H460_FeatureSet::AttachBaseFeatureSet(H460_FeatureSet * _baseSet)
1517 {
1518    baseSet = _baseSet;
1519 }
1520
1521 BOOL H460_FeatureSet::HasFeature(const H460_FeatureID & id)
1522 {
1523
1524         for (PINDEX i =0; i < Features.GetSize(); i++) {
1525            H460_Feature & feat = Features.GetDataAt(i);
1526                 if (feat.GetFeatureID() == id) {
1527                         return TRUE;
1528                 }
1529         }
1530         return FALSE;
1531 }
1532
1533 H460_Feature * H460_FeatureSet::GetFeature(const H460_FeatureID & id)
1534 {
1535         return &Features[id];
1536 }