src/h225ras.cxx

   1 /*
   2  * H225_RAS.cxx
   3  *
   4  * H.225 RAS protocol handler
   5  *
   6  * Open H323 Library
   7  *
   8  * Copyright (c) 2001 Equivalence Pty. Ltd.
   9  *
  10  * The contents of this file are subject to the Mozilla Public License
  11  * Version 1.0 (the "License"); you may not use this file except in
  12  * compliance with the License. You may obtain a copy of the License at
  13  * http://www.mozilla.org/MPL/
  14  *
  15  * Software distributed under the License is distributed on an "AS IS"
  16  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  17  * the License for the specific language governing rights and limitations
  18  * under the License.
  19  *
  20  * The Original Code is Open H323 Library.
  21  *
  22  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
  23  *
  24  * Portions of this code were written with the assisance of funding from
  25  * iFace In, http://www.iface.com
  26  *
  27  * Contributor(s): ______________________________________.
  28  *
  29  * $Log$
  30  * Revision 1.60  2006/06/23 20:19:39  shorne
  31  * More H460 support
  32  *
  33  * Revision 1.59  2006/05/30 11:14:56  hfriederich
  34  * Switch from DISABLE_H460 to H323_H460
  35  *
  36  * Revision 1.58  2005/01/03 14:03:21  csoutheren
  37  * Added new configure options and ability to disable/enable modules
  38  *
  39  * Revision 1.57  2005/01/03 06:25:55  csoutheren
  40  * Added extensive support for disabling code modules at compile time
  41  *
  42  * Revision 1.56  2004/09/07 22:50:55  rjongbloed
  43  * Changed usage of template function as MSVC6 will not compile it.
  44  *
  45  * Revision 1.55  2004/09/03 01:06:10  csoutheren
  46  * Added initial hooks for H.460 GEF
  47  * Thanks to Simon Horne and ISVO (Asia) Pte Ltd. for this contribution
  48  *
  49  * Revision 1.54  2003/04/09 03:08:10  robertj
  50  * Fixed race condition in shutting down transactor (pure virtual call)
  51  *
  52  * Revision 1.53  2003/04/01 01:05:17  robertj
  53  * Split service control handlers from H.225 RAS header.
  54  *
  55  * Revision 1.52  2003/03/26 00:46:28  robertj
  56  * Had another go at making H323Transactor being able to be created
  57  *   without having a listener running.
  58  *
  59  * Revision 1.51  2003/03/21 05:25:47  robertj
  60  * Added setting of remote port in UDP transport constructor.
  61  *
  62  * Revision 1.50  2003/03/20 01:51:11  robertj
  63  * More abstraction of H.225 RAS and H.501 protocols transaction handling.
  64  *
  65  * Revision 1.49  2003/03/01 00:21:01  craigs
  66  * Fixed spelling mistake!
  67  *
  68  * Revision 1.48  2003/02/21 05:25:45  craigs
  69  * Abstracted out underlying transports for use with peerelements
  70  *
  71  * Revision 1.47  2003/02/10 04:18:55  robertj
  72  * Made RAS read loop more robust.
  73  *
  74  * Revision 1.46  2003/02/01 13:31:21  robertj
  75  * Changes to support CAT authentication in RAS.
  76  *
  77  * Revision 1.45  2002/12/18 06:24:52  robertj
  78  * Improved logging around the RAS poll function, on timeouts etc
  79  *
  80  * Revision 1.44  2002/12/13 02:52:19  robertj
  81  * Fixed failure to release mutex on call confirm/reject.
  82  *
  83  * Revision 1.43  2002/11/28 23:39:36  robertj
  84  * Fixed race condition for if RAS reply arrives very VERY quickly after
  85  *   sending packet. Introduced in previous change.
  86  *
  87  * Revision 1.42  2002/11/28 04:41:48  robertj
  88  * Added support for RAS ServiceControlIndication command.
  89  *
  90  * Revision 1.41  2002/11/28 02:13:28  robertj
  91  * Fixed copy and paste errors.
  92  *
  93  * Revision 1.40  2002/11/28 02:10:26  robertj
  94  * Changed order of function so OnSendXXX(pdu) can change the security
  95  *   credentials in descendant classes.
  96  *
  97  * Revision 1.39  2002/11/27 06:54:56  robertj
  98  * Added Service Control Session management as per Annex K/H.323 via RAS
  99  *   only at this stage.
 100  * Added H.248 ASN and very primitive infrastructure for linking into the
 101  *   Service Control Session management system.
 102  * Added basic infrastructure for Annex K/H.323 HTTP transport system.
 103  * Added Call Credit Service Control to display account balances.
 104  *
 105  * Revision 1.38  2002/11/21 22:26:20  robertj
 106  * Changed promiscuous mode to be three way. Fixes race condition in gkserver
 107  *   which can cause crashes or more PDUs to be sent to the wrong place.
 108  *
 109  * Revision 1.37  2002/11/21 07:21:49  robertj
 110  * Improvements to alternate gatekeeper client code, thanks Kevin Bouchard
 111  *
 112  * Revision 1.36  2002/11/11 08:13:40  robertj
 113  * Fixed GNU warning
 114  *
 115  * Revision 1.35  2002/11/11 07:20:12  robertj
 116  * Minor clean up of API for doing RAS requests suing authentication.
 117  *
 118  * Revision 1.34  2002/11/10 08:10:43  robertj
 119  * Moved constants for "well known" ports to better place (OPAL change).
 120  *
 121  * Revision 1.33  2002/10/17 02:10:55  robertj
 122  * Backed out previous change for including PDU tag, doesn't work!
 123  *
 124  * Revision 1.32  2002/10/16 03:46:05  robertj
 125  * Added PDU tag to cache look up key.
 126  *
 127  * Revision 1.31  2002/10/09 05:38:50  robertj
 128  * Fixed correct mutexing of response cache buffer.
 129  * Fixed correct setting of remote address when cached response transmitted.
 130  *
 131  * Revision 1.30  2002/09/19 09:16:01  robertj
 132  * Fixed problem with making (and assuring with multi-threading) IRQ and DRQ
 133  *   requests are sent to the correct endpoint address, thanks Martijn Roest.
 134  *
 135  * Revision 1.29  2002/08/29 06:58:37  robertj
 136  * Fixed (again) cached response age timeout adjusted to RIP time.
 137  *
 138  * Revision 1.28  2002/08/12 06:29:42  robertj
 139  * Fixed problem with cached responses being aged before the RIP time which
 140  *   made retries by client appear as "new" requests when they were not.
 141  *
 142  * Revision 1.27  2002/08/12 05:35:48  robertj
 143  * Changes to the RAS subsystem to support ability to make requests to client
 144  *   from gkserver without causing bottlenecks and race conditions.
 145  *
 146  * Revision 1.26  2002/08/05 10:03:47  robertj
 147  * Cosmetic changes to normalise the usage of pragma interface/implementation.
 148  *
 149  * Revision 1.25  2002/08/05 05:17:41  robertj
 150  * Fairly major modifications to support different authentication credentials
 151  *   in ARQ to the logged in ones on RRQ. For both client and server.
 152  * Various other H.235 authentication bugs and anomalies fixed on the way.
 153  *
 154  * Revision 1.24  2002/07/29 11:36:08  robertj
 155  * Fixed race condition if RIP is followed very quickly by actual response.
 156  *
 157  * Revision 1.23  2002/07/16 04:18:38  robertj
 158  * Fixed incorrect check for GRQ in reject processing, thanks Thien Nguyen
 159  *
 160  * Revision 1.22  2002/06/28 03:34:28  robertj
 161  * Fixed issues with address translation on gatekeeper RAS channel.
 162  *
 163  * Revision 1.21  2002/06/24 00:11:21  robertj
 164  * Clarified error message during GRQ authentication.
 165  *
 166  * Revision 1.20  2002/06/12 03:50:25  robertj
 167  * Added PrintOn function for trace output of RAS channel.
 168  *
 169  * Revision 1.19  2002/05/29 00:03:19  robertj
 170  * Fixed unsolicited IRR support in gk client and server,
 171  *   including support for IACK and INAK.
 172  *
 173  * Revision 1.18  2002/05/17 03:41:00  robertj
 174  * Fixed problems with H.235 authentication on RAS for server and client.
 175  *
 176  * Revision 1.17  2002/05/03 09:18:49  robertj
 177  * Added automatic retransmission of RAS responses to retried requests.
 178  *
 179  * Revision 1.16  2002/03/10 19:34:13  robertj
 180  * Added random starting point for sequence numbers, thanks Chris Purvis
 181  *
 182  * Revision 1.15  2002/01/29 02:38:31  robertj
 183  * Fixed nasty race condition when getting RIP, end up with wrong timeout.
 184  * Improved tracing (included sequence numbers)
 185  *
 186  * Revision 1.14  2002/01/24 01:02:04  robertj
 187  * Removed trace when authenticator not used, implied error when wasn't one.
 188  *
 189  * Revision 1.13  2001/10/09 12:03:30  robertj
 190  * Fixed uninitialised variable for H.235 authentication checking.
 191  *
 192  * Revision 1.12  2001/10/09 08:04:59  robertj
 193  * Fixed unregistration so still unregisters if gk goes offline, thanks Chris Purvis
 194  *
 195  * Revision 1.11  2001/09/18 10:36:57  robertj
 196  * Allowed multiple overlapping requests in RAS channel.
 197  *
 198  * Revision 1.10  2001/09/12 07:48:05  robertj
 199  * Fixed various problems with tracing.
 200  *
 201  * Revision 1.9  2001/09/12 03:12:38  robertj
 202  * Added ability to disable the checking of RAS responses against
 203  *   security authenticators.
 204  * Fixed bug in having multiple authentications if have a retry.
 205  *
 206  * Revision 1.8  2001/08/10 11:03:52  robertj
 207  * Major changes to H.235 support in RAS to support server.
 208  *
 209  * Revision 1.7  2001/08/06 07:44:55  robertj
 210  * Fixed problems with building without SSL
 211  *
 212  * Revision 1.6  2001/08/06 03:18:38  robertj
 213  * Fission of h323.h to h323ep.h & h323con.h, h323.h now just includes files.
 214  * Improved access to H.235 secure RAS functionality.
 215  * Changes to H.323 secure RAS contexts to help use with gk server.
 216  *
 217  * Revision 1.5  2001/08/03 05:56:04  robertj
 218  * Fixed RAS read of UDP when get ICMP error for host unreachabe.
 219  *
 220  * Revision 1.4  2001/06/25 01:06:40  robertj
 221  * Fixed resolution of RAS timeout so not rounded down to second.
 222  *
 223  * Revision 1.3  2001/06/22 00:21:10  robertj
 224  * Fixed bug in H.225 RAS protocol with 16 versus 32 bit sequence numbers.
 225  *
 226  * Revision 1.2  2001/06/18 07:44:21  craigs
 227  * Made to compile with h225ras.cxx under Linux
 228  *
 229  * Revision 1.1  2001/06/18 06:23:50  robertj
 230  * Split raw H.225 RAS protocol out of gatekeeper client class.
 231  *
 232  */
 233
 234 #include <ptlib.h>
 235
 236 #ifdef __GNUC__
 237 #pragma implementation "h225ras.h"
 238 #endif
 239
 240 #include "h323.h"
 241
 242 #include "h225ras.h"
 243
 244 #include "h323ep.h"
 245 #include "h323pdu.h"
 246 #include "h235auth.h"
 247
 248 #ifdef H323_H460
 249 #include "h460.h"
 250 #endif
 251
 252 #define new PNEW
 253
 254
 255 /////////////////////////////////////////////////////////////////////////////
 256
 257 H225_RAS::H225_RAS(H323EndPoint & ep, H323Transport * trans)
 258   : H323Transactor(ep, trans, DefaultRasUdpPort, DefaultRasUdpPort)
 259 {
 260 }
 261
 262
 263 H225_RAS::~H225_RAS()
 264 {
 265   StopChannel();
 266 }
 267
 268
 269 void H225_RAS::PrintOn(ostream & strm) const
 270 {
 271   if (gatekeeperIdentifier.IsEmpty())
 272     strm << "H225-RAS@";
 273   else
 274     strm << gatekeeperIdentifier << '@';
 275   H323Transactor::PrintOn(strm);
 276 }
 277
 278
 279 H323TransactionPDU * H225_RAS::CreateTransactionPDU() const
 280 {
 281   return new H323RasPDU;
 282 }
 283
 284
 285 BOOL H225_RAS::HandleTransaction(const PASN_Object & rawPDU)
 286 {
 287   const H323RasPDU & pdu = (const H323RasPDU &)rawPDU;
 288
 289   switch (pdu.GetTag()) {
 290     case H225_RasMessage::e_gatekeeperRequest :
 291       if (SendCachedResponse(pdu))
 292         return FALSE;
 293       OnReceiveGatekeeperRequest(pdu, pdu);
 294       break;
 295
 296     case H225_RasMessage::e_gatekeeperConfirm :
 297       return OnReceiveGatekeeperConfirm(pdu, pdu);
 298
 299     case H225_RasMessage::e_gatekeeperReject :
 300       return OnReceiveGatekeeperReject(pdu, pdu);
 301
 302     case H225_RasMessage::e_registrationRequest :
 303       if (SendCachedResponse(pdu))
 304         return FALSE;
 305       OnReceiveRegistrationRequest(pdu, pdu);
 306       break;
 307
 308     case H225_RasMessage::e_registrationConfirm :
 309       return OnReceiveRegistrationConfirm(pdu, pdu);
 310
 311     case H225_RasMessage::e_registrationReject :
 312       return OnReceiveRegistrationReject(pdu, pdu);
 313
 314     case H225_RasMessage::e_unregistrationRequest :
 315       if (SendCachedResponse(pdu))
 316         return FALSE;
 317       OnReceiveUnregistrationRequest(pdu, pdu);
 318       break;
 319
 320     case H225_RasMessage::e_unregistrationConfirm :
 321       return OnReceiveUnregistrationConfirm(pdu, pdu);
 322
 323     case H225_RasMessage::e_unregistrationReject :
 324       return OnReceiveUnregistrationReject(pdu, pdu);
 325
 326     case H225_RasMessage::e_admissionRequest :
 327       if (SendCachedResponse(pdu))
 328         return FALSE;
 329       OnReceiveAdmissionRequest(pdu, pdu);
 330       break;
 331
 332     case H225_RasMessage::e_admissionConfirm :
 333       return OnReceiveAdmissionConfirm(pdu, pdu);
 334
 335     case H225_RasMessage::e_admissionReject :
 336       return OnReceiveAdmissionReject(pdu, pdu);
 337
 338     case H225_RasMessage::e_bandwidthRequest :
 339       if (SendCachedResponse(pdu))
 340         return FALSE;
 341       OnReceiveBandwidthRequest(pdu, pdu);
 342       break;
 343
 344     case H225_RasMessage::e_bandwidthConfirm :
 345       return OnReceiveBandwidthConfirm(pdu, pdu);
 346
 347     case H225_RasMessage::e_bandwidthReject :
 348       return OnReceiveBandwidthReject(pdu, pdu);
 349
 350     case H225_RasMessage::e_disengageRequest :
 351       if (SendCachedResponse(pdu))
 352         return FALSE;
 353       OnReceiveDisengageRequest(pdu, pdu);
 354       break;
 355
 356     case H225_RasMessage::e_disengageConfirm :
 357       return OnReceiveDisengageConfirm(pdu, pdu);
 358
 359     case H225_RasMessage::e_disengageReject :
 360       return OnReceiveDisengageReject(pdu, pdu);
 361
 362     case H225_RasMessage::e_locationRequest :
 363       if (SendCachedResponse(pdu))
 364         return FALSE;
 365       OnReceiveLocationRequest(pdu, pdu);
 366       break;
 367
 368     case H225_RasMessage::e_locationConfirm :
 369       return OnReceiveLocationConfirm(pdu, pdu);
 370
 371     case H225_RasMessage::e_locationReject :
 372       return OnReceiveLocationReject(pdu, pdu);
 373
 374     case H225_RasMessage::e_infoRequest :
 375       if (SendCachedResponse(pdu))
 376         return FALSE;
 377       OnReceiveInfoRequest(pdu, pdu);
 378       break;
 379
 380     case H225_RasMessage::e_infoRequestResponse :
 381       return OnReceiveInfoRequestResponse(pdu, pdu);
 382
 383     case H225_RasMessage::e_nonStandardMessage :
 384       OnReceiveNonStandardMessage(pdu, pdu);
 385       break;
 386
 387     case H225_RasMessage::e_unknownMessageResponse :
 388       OnReceiveUnknownMessageResponse(pdu, pdu);
 389       break;
 390
 391     case H225_RasMessage::e_requestInProgress :
 392       return OnReceiveRequestInProgress(pdu, pdu);
 393
 394     case H225_RasMessage::e_resourcesAvailableIndicate :
 395       if (SendCachedResponse(pdu))
 396         return FALSE;
 397       OnReceiveResourcesAvailableIndicate(pdu, pdu);
 398       break;
 399
 400     case H225_RasMessage::e_resourcesAvailableConfirm :
 401       return OnReceiveResourcesAvailableConfirm(pdu, pdu);
 402
 403     case H225_RasMessage::e_infoRequestAck :
 404       return OnReceiveInfoRequestAck(pdu, pdu);
 405
 406     case H225_RasMessage::e_infoRequestNak :
 407       return OnReceiveInfoRequestNak(pdu, pdu);
 408
 409 #ifdef H323_H248
 410     case H225_RasMessage::e_serviceControlIndication :
 411       if (SendCachedResponse(pdu))
 412         return FALSE;
 413       OnReceiveServiceControlIndication(pdu, pdu);
 414       break;
 415
 416     case H225_RasMessage::e_serviceControlResponse :
 417       return OnReceiveServiceControlResponse(pdu, pdu);
 418 #endif
 419
 420     default :
 421       OnReceiveUnknown(pdu);
 422   }
 423
 424   return FALSE;
 425 }
 426
 427
 428 void H225_RAS::OnSendingPDU(PASN_Object & rawPDU)
 429 {
 430   H323RasPDU & pdu = (H323RasPDU &)rawPDU;
 431
 432   switch (pdu.GetTag()) {
 433     case H225_RasMessage::e_gatekeeperRequest :
 434       OnSendGatekeeperRequest(pdu, pdu);
 435       break;
 436
 437     case H225_RasMessage::e_gatekeeperConfirm :
 438       OnSendGatekeeperConfirm(pdu, pdu);
 439       break;
 440
 441     case H225_RasMessage::e_gatekeeperReject :
 442       OnSendGatekeeperReject(pdu, pdu);
 443       break;
 444
 445     case H225_RasMessage::e_registrationRequest :
 446       OnSendRegistrationRequest(pdu, pdu);
 447       break;
 448
 449     case H225_RasMessage::e_registrationConfirm :
 450       OnSendRegistrationConfirm(pdu, pdu);
 451       break;
 452
 453     case H225_RasMessage::e_registrationReject :
 454       OnSendRegistrationReject(pdu, pdu);
 455       break;
 456
 457     case H225_RasMessage::e_unregistrationRequest :
 458       OnSendUnregistrationRequest(pdu, pdu);
 459       break;
 460
 461     case H225_RasMessage::e_unregistrationConfirm :
 462       OnSendUnregistrationConfirm(pdu, pdu);
 463       break;
 464
 465     case H225_RasMessage::e_unregistrationReject :
 466       OnSendUnregistrationReject(pdu, pdu);
 467       break;
 468
 469     case H225_RasMessage::e_admissionRequest :
 470       OnSendAdmissionRequest(pdu, pdu);
 471       break;
 472
 473     case H225_RasMessage::e_admissionConfirm :
 474       OnSendAdmissionConfirm(pdu, pdu);
 475       break;
 476
 477     case H225_RasMessage::e_admissionReject :
 478       OnSendAdmissionReject(pdu, pdu);
 479       break;
 480
 481     case H225_RasMessage::e_bandwidthRequest :
 482       OnSendBandwidthRequest(pdu, pdu);
 483       break;
 484
 485     case H225_RasMessage::e_bandwidthConfirm :
 486       OnSendBandwidthConfirm(pdu, pdu);
 487       break;
 488
 489     case H225_RasMessage::e_bandwidthReject :
 490       OnSendBandwidthReject(pdu, pdu);
 491       break;
 492
 493     case H225_RasMessage::e_disengageRequest :
 494       OnSendDisengageRequest(pdu, pdu);
 495       break;
 496
 497     case H225_RasMessage::e_disengageConfirm :
 498       OnSendDisengageConfirm(pdu, pdu);
 499       break;
 500
 501     case H225_RasMessage::e_disengageReject :
 502       OnSendDisengageReject(pdu, pdu);
 503       break;
 504
 505     case H225_RasMessage::e_locationRequest :
 506       OnSendLocationRequest(pdu, pdu);
 507       break;
 508
 509     case H225_RasMessage::e_locationConfirm :
 510       OnSendLocationConfirm(pdu, pdu);
 511       break;
 512
 513     case H225_RasMessage::e_locationReject :
 514       OnSendLocationReject(pdu, pdu);
 515       break;
 516
 517     case H225_RasMessage::e_infoRequest :
 518       OnSendInfoRequest(pdu, pdu);
 519       break;
 520
 521     case H225_RasMessage::e_infoRequestResponse :
 522       OnSendInfoRequestResponse(pdu, pdu);
 523       break;
 524
 525     case H225_RasMessage::e_nonStandardMessage :
 526       OnSendNonStandardMessage(pdu, pdu);
 527       break;
 528
 529     case H225_RasMessage::e_unknownMessageResponse :
 530       OnSendUnknownMessageResponse(pdu, pdu);
 531       break;
 532
 533     case H225_RasMessage::e_requestInProgress :
 534       OnSendRequestInProgress(pdu, pdu);
 535       break;
 536
 537     case H225_RasMessage::e_resourcesAvailableIndicate :
 538       OnSendResourcesAvailableIndicate(pdu, pdu);
 539       break;
 540
 541     case H225_RasMessage::e_resourcesAvailableConfirm :
 542       OnSendResourcesAvailableConfirm(pdu, pdu);
 543       break;
 544
 545     case H225_RasMessage::e_infoRequestAck :
 546       OnSendInfoRequestAck(pdu, pdu);
 547       break;
 548
 549     case H225_RasMessage::e_infoRequestNak :
 550       OnSendInfoRequestNak(pdu, pdu);
 551       break;
 552
 553 #ifdef H323_H248
 554     case H225_RasMessage::e_serviceControlIndication :
 555       OnSendServiceControlIndication(pdu, pdu);
 556       break;
 557
 558     case H225_RasMessage::e_serviceControlResponse :
 559       OnSendServiceControlResponse(pdu, pdu);
 560       break;
 561 #endif
 562
 563     default :
 564       break;
 565   }
 566 }
 567
 568
 569 BOOL H225_RAS::OnReceiveRequestInProgress(const H323RasPDU & pdu, const H225_RequestInProgress & rip)
 570 {
 571   if (!HandleRequestInProgress(pdu, rip.m_delay))
 572     return FALSE;
 573
 574   return OnReceiveRequestInProgress(rip);
 575 }
 576
 577
 578 BOOL H225_RAS::OnReceiveRequestInProgress(const H225_RequestInProgress & /*rip*/)
 579 {
 580   return TRUE;
 581 }
 582
 583
 584 template <typename PDUType>
 585 static void SendFeatureSet(const H225_RAS * ras, unsigned code, PDUType & pdu)
 586 {
 587
 588  H225_FeatureSet fs;
 589     if (!ras->OnSendFeatureSet(code,fs))
 590                 return;
 591
 592      switch (code) {
 593         case H460_MessageType::e_gatekeeperRequest:
 594         case H460_MessageType::e_gatekeeperConfirm:
 595         case H460_MessageType::e_gatekeeperReject:
 596         case H460_MessageType::e_registrationRequest:
 597         case H460_MessageType::e_registrationConfirm:
 598         case H460_MessageType::e_registrationReject:
 599         case H460_MessageType::e_setup:
 600         case H460_MessageType::e_callProceeding:
 601             pdu.IncludeOptionalField(PDUType::e_featureSet);
 602                         pdu.m_featureSet = fs;
 603             break;
 604         default:
 605                   if (fs.HasOptionalField(H225_FeatureSet::e_supportedFeatures)) {
 606                         pdu.IncludeOptionalField(PDUType::e_genericData);
 607
 608                         H225_ArrayOf_FeatureDescriptor & fsn = fs.m_supportedFeatures;
 609                     H225_ArrayOf_GenericData & data = pdu.m_genericData;
 610
 611                         for (PINDEX i=0; i < fsn.GetSize(); i++) {
 612                                  PINDEX lastPos = data.GetSize();
 613                                  data.SetSize(lastPos+1);
 614                                  data[lastPos] = fsn[i];
 615                         }
 616                   }
 617                   break;
 618          }
 619 }
 620
 621
 622 void H225_RAS::OnSendGatekeeperRequest(H323RasPDU &, H225_GatekeeperRequest & grq)
 623 {
 624   if (!gatekeeperIdentifier) {
 625     grq.IncludeOptionalField(H225_GatekeeperRequest::e_gatekeeperIdentifier);
 626     grq.m_gatekeeperIdentifier = gatekeeperIdentifier;
 627   }
 628
 629 #ifdef H323_H460
 630   SendFeatureSet<H225_GatekeeperRequest>(this, H460_MessageType::e_gatekeeperRequest, grq);
 631 #endif
 632
 633   OnSendGatekeeperRequest(grq);
 634 }
 635
 636
 637 void H225_RAS::OnSendGatekeeperRequest(H225_GatekeeperRequest & /*grq*/)
 638 {
 639 }
 640
 641
 642 void H225_RAS::OnSendGatekeeperConfirm(H323RasPDU &, H225_GatekeeperConfirm & gcf)
 643 {
 644   if (!gatekeeperIdentifier) {
 645     gcf.IncludeOptionalField(H225_GatekeeperConfirm::e_gatekeeperIdentifier);
 646     gcf.m_gatekeeperIdentifier = gatekeeperIdentifier;
 647   }
 648
 649 #ifdef H323_H460
 650   SendFeatureSet<H225_GatekeeperConfirm>(this, H460_MessageType::e_gatekeeperConfirm, gcf);
 651 #endif
 652
 653   OnSendGatekeeperConfirm(gcf);
 654 }
 655
 656
 657 void H225_RAS::OnSendGatekeeperConfirm(H225_GatekeeperConfirm & /*gcf*/)
 658 {
 659 }
 660
 661
 662 void H225_RAS::OnSendGatekeeperReject(H323RasPDU &, H225_GatekeeperReject & grj)
 663 {
 664   if (!gatekeeperIdentifier) {
 665     grj.IncludeOptionalField(H225_GatekeeperReject::e_gatekeeperIdentifier);
 666     grj.m_gatekeeperIdentifier = gatekeeperIdentifier;
 667   }
 668
 669 #ifdef H323_H460
 670   SendFeatureSet<H225_GatekeeperReject>(this, H460_MessageType::e_gatekeeperReject, grj);
 671 #endif
 672
 673   OnSendGatekeeperReject(grj);
 674 }
 675
 676
 677 void H225_RAS::OnSendGatekeeperReject(H225_GatekeeperReject & /*grj*/)
 678 {
 679 }
 680
 681
 682 template <typename PDUType>
 683 static void ReceiveFeatureSet(const H225_RAS * ras, unsigned code, const PDUType & pdu)
 684 {
 685   if (pdu.HasOptionalField(PDUType::e_featureSet))
 686       ras->OnReceiveFeatureSet(code, pdu.m_featureSet);
 687
 688     if (pdu.HasOptionalField(PDUType::e_genericData)) {
 689         H225_FeatureSet fs;
 690             fs.IncludeOptionalField(H225_FeatureSet::e_supportedFeatures);
 691             H225_ArrayOf_FeatureDescriptor & fsn = fs.m_supportedFeatures;
 692                 const H225_ArrayOf_GenericData & data = pdu.m_genericData;
 693                 for (PINDEX i=0; i < data.GetSize(); i++) {
 694                          PINDEX lastPos = fsn.GetSize();
 695                          fsn.SetSize(lastPos+1);
 696                          fsn[lastPos] = (H225_FeatureDescriptor &)data[i];
 697                 }
 698         ras->OnReceiveFeatureSet(code, fs);
 699         }
 700 }
 701
 702
 703 BOOL H225_RAS::OnReceiveGatekeeperRequest(const H323RasPDU &, const H225_GatekeeperRequest & grq)
 704 {
 705 #ifdef H323_H460
 706   ReceiveFeatureSet<H225_GatekeeperRequest>(this, H460_MessageType::e_gatekeeperRequest, grq);
 707 #endif
 708
 709   return OnReceiveGatekeeperRequest(grq);
 710 }
 711
 712
 713 BOOL H225_RAS::OnReceiveGatekeeperRequest(const H225_GatekeeperRequest &)
 714 {
 715   return TRUE;
 716 }
 717
 718
 719 BOOL H225_RAS::OnReceiveGatekeeperConfirm(const H323RasPDU &, const H225_GatekeeperConfirm & gcf)
 720 {
 721   if (!CheckForResponse(H225_RasMessage::e_gatekeeperRequest, gcf.m_requestSeqNum))
 722     return FALSE;
 723
 724   if (gatekeeperIdentifier.IsEmpty())
 725     gatekeeperIdentifier = gcf.m_gatekeeperIdentifier;
 726   else {
 727     PString gkid = gcf.m_gatekeeperIdentifier;
 728     if (gatekeeperIdentifier *= gkid)
 729       gatekeeperIdentifier = gkid;
 730     else {
 731       PTRACE(2, "RAS\tReceived a GCF from " << gkid
 732              << " but wanted it from " << gatekeeperIdentifier);
 733       return FALSE;
 734     }
 735   }
 736
 737 #ifdef H323_H460
 738   ReceiveFeatureSet<H225_GatekeeperConfirm>(this, H460_MessageType::e_gatekeeperConfirm, gcf);
 739 #endif
 740
 741   return OnReceiveGatekeeperConfirm(gcf);
 742 }
 743
 744
 745 BOOL H225_RAS::OnReceiveGatekeeperConfirm(const H225_GatekeeperConfirm & /*gcf*/)
 746 {
 747   return TRUE;
 748 }
 749
 750
 751 BOOL H225_RAS::OnReceiveGatekeeperReject(const H323RasPDU &, const H225_GatekeeperReject & grj)
 752 {
 753   if (!CheckForResponse(H225_RasMessage::e_gatekeeperRequest, grj.m_requestSeqNum, &grj.m_rejectReason))
 754     return FALSE;
 755
 756 #ifdef H323_H460
 757   ReceiveFeatureSet<H225_GatekeeperReject>(this, H460_MessageType::e_gatekeeperReject, grj);
 758 #endif
 759
 760   return OnReceiveGatekeeperReject(grj);
 761 }
 762
 763
 764 BOOL H225_RAS::OnReceiveGatekeeperReject(const H225_GatekeeperReject & /*grj*/)
 765 {
 766   return TRUE;
 767 }
 768
 769
 770 void H225_RAS::OnSendRegistrationRequest(H323RasPDU & pdu, H225_RegistrationRequest & rrq)
 771 {
 772   OnSendRegistrationRequest(rrq);
 773
 774 #ifdef H323_H460
 775   SendFeatureSet<H225_RegistrationRequest>(this, H460_MessageType::e_registrationRequest, rrq);
 776 #endif
 777
 778   pdu.Prepare(rrq.m_tokens, H225_RegistrationRequest::e_tokens,
 779               rrq.m_cryptoTokens, H225_RegistrationRequest::e_cryptoTokens);
 780
 781 }
 782
 783
 784 void H225_RAS::OnSendRegistrationRequest(H225_RegistrationRequest & /*rrq*/)
 785 {
 786 }
 787
 788
 789 void H225_RAS::OnSendRegistrationConfirm(H323RasPDU & pdu, H225_RegistrationConfirm & rcf)
 790 {
 791   if (!gatekeeperIdentifier) {
 792     rcf.IncludeOptionalField(H225_RegistrationConfirm::e_gatekeeperIdentifier);
 793     rcf.m_gatekeeperIdentifier = gatekeeperIdentifier;
 794   }
 795
 796   OnSendRegistrationConfirm(rcf);
 797
 798 #ifdef H323_H460
 799   SendFeatureSet<H225_RegistrationConfirm>(this, H460_MessageType::e_registrationConfirm, rcf);
 800 #endif
 801
 802   pdu.Prepare(rcf.m_tokens, H225_RegistrationConfirm::e_tokens,
 803               rcf.m_cryptoTokens, H225_RegistrationConfirm::e_cryptoTokens);
 804
 805 }
 806
 807
 808 void H225_RAS::OnSendRegistrationConfirm(H225_RegistrationConfirm & /*rcf*/)
 809 {
 810 }
 811
 812
 813 void H225_RAS::OnSendRegistrationReject(H323RasPDU & pdu, H225_RegistrationReject & rrj)
 814 {
 815   if (!gatekeeperIdentifier) {
 816     rrj.IncludeOptionalField(H225_RegistrationReject::e_gatekeeperIdentifier);
 817     rrj.m_gatekeeperIdentifier = gatekeeperIdentifier;
 818   }
 819
 820   OnSendRegistrationReject(rrj);
 821
 822 #ifdef H323_H460
 823   SendFeatureSet<H225_RegistrationReject>(this, H460_MessageType::e_registrationReject, rrj);
 824 #endif
 825
 826   pdu.Prepare(rrj.m_tokens, H225_RegistrationReject::e_tokens,
 827               rrj.m_cryptoTokens, H225_RegistrationReject::e_cryptoTokens);
 828 }
 829
 830
 831 void H225_RAS::OnSendRegistrationReject(H225_RegistrationReject & /*rrj*/)
 832 {
 833 }
 834
 835
 836 BOOL H225_RAS::OnReceiveRegistrationRequest(const H323RasPDU &, const H225_RegistrationRequest & rrq)
 837 {
 838 #ifdef H323_H460
 839   ReceiveFeatureSet<H225_RegistrationRequest>(this, H460_MessageType::e_registrationRequest, rrq);
 840 #endif
 841
 842   return OnReceiveRegistrationRequest(rrq);
 843 }
 844
 845
 846 BOOL H225_RAS::OnReceiveRegistrationRequest(const H225_RegistrationRequest &)
 847 {
 848   return TRUE;
 849 }
 850
 851
 852 BOOL H225_RAS::OnReceiveRegistrationConfirm(const H323RasPDU & pdu, const H225_RegistrationConfirm & rcf)
 853 {
 854   if (!CheckForResponse(H225_RasMessage::e_registrationRequest, rcf.m_requestSeqNum))
 855     return FALSE;
 856
 857   if (lastRequest != NULL) {
 858     PString endpointIdentifier = rcf.m_endpointIdentifier;
 859     const H235Authenticators & authenticators = lastRequest->requestPDU.GetAuthenticators();
 860     for (PINDEX i = 0; i < authenticators.GetSize(); i++) {
 861       H235Authenticator & authenticator = authenticators[i];
 862       if (authenticator.UseGkAndEpIdentifiers())
 863         authenticator.SetLocalId(endpointIdentifier);
 864     }
 865   }
 866
 867   if (!CheckCryptoTokens(pdu,
 868                          rcf.m_tokens, H225_RegistrationConfirm::e_tokens,
 869                          rcf.m_cryptoTokens, H225_RegistrationConfirm::e_cryptoTokens))
 870     return FALSE;
 871
 872 #ifdef H323_H460
 873   ReceiveFeatureSet<H225_RegistrationConfirm>(this, H460_MessageType::e_registrationConfirm, rcf);
 874 #endif
 875
 876   return OnReceiveRegistrationConfirm(rcf);
 877 }
 878
 879
 880 BOOL H225_RAS::OnReceiveRegistrationConfirm(const H225_RegistrationConfirm & /*rcf*/)
 881 {
 882   return TRUE;
 883 }
 884
 885
 886 BOOL H225_RAS::OnReceiveRegistrationReject(const H323RasPDU & pdu, const H225_RegistrationReject & rrj)
 887 {
 888   if (!CheckForResponse(H225_RasMessage::e_registrationRequest, rrj.m_requestSeqNum, &rrj.m_rejectReason))
 889     return FALSE;
 890
 891   if (!CheckCryptoTokens(pdu,
 892                          rrj.m_tokens, H225_RegistrationReject::e_tokens,
 893                          rrj.m_cryptoTokens, H225_RegistrationReject::e_cryptoTokens))
 894     return FALSE;
 895
 896 #ifdef H323_H460
 897   ReceiveFeatureSet<H225_RegistrationReject>(this, H460_MessageType::e_registrationReject, rrj);
 898 #endif
 899
 900   return OnReceiveRegistrationReject(rrj);
 901 }
 902
 903
 904 BOOL H225_RAS::OnReceiveRegistrationReject(const H225_RegistrationReject & /*rrj*/)
 905 {
 906   return TRUE;
 907 }
 908
 909
 910 void H225_RAS::OnSendUnregistrationRequest(H323RasPDU & pdu, H225_UnregistrationRequest & urq)
 911 {
 912   OnSendUnregistrationRequest(urq);
 913   pdu.Prepare(urq.m_tokens, H225_UnregistrationRequest::e_tokens,
 914               urq.m_cryptoTokens, H225_UnregistrationRequest::e_cryptoTokens);
 915 }
 916
 917
 918 void H225_RAS::OnSendUnregistrationRequest(H225_UnregistrationRequest & /*urq*/)
 919 {
 920 }
 921
 922
 923 void H225_RAS::OnSendUnregistrationConfirm(H323RasPDU & pdu, H225_UnregistrationConfirm & ucf)
 924 {
 925   OnSendUnregistrationConfirm(ucf);
 926   pdu.Prepare(ucf.m_tokens, H225_UnregistrationConfirm::e_tokens,
 927               ucf.m_cryptoTokens, H225_UnregistrationConfirm::e_cryptoTokens);
 928 }
 929
 930
 931 void H225_RAS::OnSendUnregistrationConfirm(H225_UnregistrationConfirm & /*ucf*/)
 932 {
 933 }
 934
 935
 936 void H225_RAS::OnSendUnregistrationReject(H323RasPDU & pdu, H225_UnregistrationReject & urj)
 937 {
 938   OnSendUnregistrationReject(urj);
 939   pdu.Prepare(urj.m_tokens, H225_UnregistrationReject::e_tokens,
 940               urj.m_cryptoTokens, H225_UnregistrationReject::e_cryptoTokens);
 941 }
 942
 943
 944 void H225_RAS::OnSendUnregistrationReject(H225_UnregistrationReject & /*urj*/)
 945 {
 946 }
 947
 948
 949 BOOL H225_RAS::OnReceiveUnregistrationRequest(const H323RasPDU & pdu, const H225_UnregistrationRequest & urq)
 950 {
 951   if (!CheckCryptoTokens(pdu,
 952                          urq.m_tokens, H225_UnregistrationRequest::e_tokens,
 953                          urq.m_cryptoTokens, H225_UnregistrationRequest::e_cryptoTokens))
 954     return FALSE;
 955
 956   return OnReceiveUnregistrationRequest(urq);
 957 }
 958
 959
 960 BOOL H225_RAS::OnReceiveUnregistrationRequest(const H225_UnregistrationRequest & /*urq*/)
 961 {
 962   return TRUE;
 963 }
 964
 965
 966 BOOL H225_RAS::OnReceiveUnregistrationConfirm(const H323RasPDU & pdu, const H225_UnregistrationConfirm & ucf)
 967 {
 968   if (!CheckForResponse(H225_RasMessage::e_unregistrationRequest, ucf.m_requestSeqNum))
 969     return FALSE;
 970
 971   if (!CheckCryptoTokens(pdu,
 972                          ucf.m_tokens, H225_UnregistrationConfirm::e_tokens,
 973                          ucf.m_cryptoTokens, H225_UnregistrationConfirm::e_cryptoTokens))
 974     return FALSE;
 975
 976   return OnReceiveUnregistrationConfirm(ucf);
 977 }
 978
 979
 980 BOOL H225_RAS::OnReceiveUnregistrationConfirm(const H225_UnregistrationConfirm & /*ucf*/)
 981 {
 982   return TRUE;
 983 }
 984
 985
 986 BOOL H225_RAS::OnReceiveUnregistrationReject(const H323RasPDU & pdu, const H225_UnregistrationReject & urj)
 987 {
 988   if (!CheckForResponse(H225_RasMessage::e_unregistrationRequest, urj.m_requestSeqNum, &urj.m_rejectReason))
 989     return FALSE;
 990
 991   if (!CheckCryptoTokens(pdu,
 992                          urj.m_tokens, H225_UnregistrationReject::e_tokens,
 993                          urj.m_cryptoTokens, H225_UnregistrationReject::e_cryptoTokens))
 994     return FALSE;
 995
 996   return OnReceiveUnregistrationReject(urj);
 997 }
 998
 999
1000 BOOL H225_RAS::OnReceiveUnregistrationReject(const H225_UnregistrationReject & /*urj*/)
1001 {
1002   return TRUE;
1003 }
1004
1005
1006 void H225_RAS::OnSendAdmissionRequest(H323RasPDU & pdu, H225_AdmissionRequest & arq)
1007 {
1008   OnSendAdmissionRequest(arq);
1009
1010 #ifdef H323_H460
1011   SendFeatureSet<H225_AdmissionRequest>(this, H460_MessageType::e_admissionRequest, arq);
1012 #endif
1013
1014   pdu.Prepare(arq.m_tokens, H225_AdmissionRequest::e_tokens,
1015               arq.m_cryptoTokens, H225_AdmissionRequest::e_cryptoTokens);
1016 }
1017
1018
1019 void H225_RAS::OnSendAdmissionRequest(H225_AdmissionRequest & /*arq*/)
1020 {
1021 }
1022
1023
1024 void H225_RAS::OnSendAdmissionConfirm(H323RasPDU & pdu, H225_AdmissionConfirm & acf)
1025 {
1026   OnSendAdmissionConfirm(acf);
1027
1028 #ifdef H323_H460
1029   SendFeatureSet<H225_AdmissionConfirm>(this, H460_MessageType::e_admissionConfirm, acf);
1030 #endif
1031
1032   pdu.Prepare(acf.m_tokens, H225_AdmissionConfirm::e_tokens,
1033               acf.m_cryptoTokens, H225_AdmissionConfirm::e_cryptoTokens);
1034 }
1035
1036
1037 void H225_RAS::OnSendAdmissionConfirm(H225_AdmissionConfirm & /*acf*/)
1038 {
1039 }
1040
1041
1042 void H225_RAS::OnSendAdmissionReject(H323RasPDU & pdu, H225_AdmissionReject & arj)
1043 {
1044   OnSendAdmissionReject(arj);
1045
1046 #ifdef H323_H460
1047   SendFeatureSet<H225_AdmissionReject>(this, H460_MessageType::e_admissionReject, arj);
1048 #endif
1049
1050   pdu.Prepare(arj.m_tokens, H225_AdmissionReject::e_tokens,
1051               arj.m_cryptoTokens, H225_AdmissionReject::e_cryptoTokens);
1052 }
1053
1054
1055 void H225_RAS::OnSendAdmissionReject(H225_AdmissionReject & /*arj*/)
1056 {
1057 }
1058
1059
1060 BOOL H225_RAS::OnReceiveAdmissionRequest(const H323RasPDU & pdu, const H225_AdmissionRequest & arq)
1061 {
1062   if (!CheckCryptoTokens(pdu,
1063                          arq.m_tokens, H225_AdmissionRequest::e_tokens,
1064                          arq.m_cryptoTokens, H225_AdmissionRequest::e_cryptoTokens))
1065     return FALSE;
1066
1067 #ifdef H323_H460
1068   ReceiveFeatureSet<H225_AdmissionRequest>(this, H460_MessageType::e_admissionRequest, arq);
1069 #endif
1070
1071   return OnReceiveAdmissionRequest(arq);
1072 }
1073
1074
1075 BOOL H225_RAS::OnReceiveAdmissionRequest(const H225_AdmissionRequest & /*arq*/)
1076 {
1077   return TRUE;
1078 }
1079
1080
1081 BOOL H225_RAS::OnReceiveAdmissionConfirm(const H323RasPDU & pdu, const H225_AdmissionConfirm & acf)
1082 {
1083   if (!CheckForResponse(H225_RasMessage::e_admissionRequest, acf.m_requestSeqNum))
1084     return FALSE;
1085
1086   if (!CheckCryptoTokens(pdu,
1087                          acf.m_tokens, H225_AdmissionConfirm::e_tokens,
1088                          acf.m_cryptoTokens, H225_AdmissionConfirm::e_cryptoTokens))
1089     return FALSE;
1090
1091 #ifdef H323_H460
1092   ReceiveFeatureSet<H225_AdmissionConfirm>(this, H460_MessageType::e_admissionConfirm, acf);
1093 #endif
1094
1095   return OnReceiveAdmissionConfirm(acf);
1096 }
1097
1098
1099 BOOL H225_RAS::OnReceiveAdmissionConfirm(const H225_AdmissionConfirm & /*acf*/)
1100 {
1101   return TRUE;
1102 }
1103
1104
1105 BOOL H225_RAS::OnReceiveAdmissionReject(const H323RasPDU & pdu, const H225_AdmissionReject & arj)
1106 {
1107   if (!CheckForResponse(H225_RasMessage::e_admissionRequest, arj.m_requestSeqNum, &arj.m_rejectReason))
1108     return FALSE;
1109
1110   if (!CheckCryptoTokens(pdu,
1111                          arj.m_tokens, H225_AdmissionReject::e_tokens,
1112                          arj.m_cryptoTokens, H225_AdmissionReject::e_cryptoTokens))
1113     return FALSE;
1114
1115 #ifdef H323_H460
1116   ReceiveFeatureSet<H225_AdmissionReject>(this, H460_MessageType::e_admissionReject, arj);
1117 #endif
1118
1119   return OnReceiveAdmissionReject(arj);
1120 }
1121
1122
1123 BOOL H225_RAS::OnReceiveAdmissionReject(const H225_AdmissionReject & /*arj*/)
1124 {
1125   return TRUE;
1126 }
1127
1128
1129 void H225_RAS::OnSendBandwidthRequest(H323RasPDU & pdu, H225_BandwidthRequest & brq)
1130 {
1131   OnSendBandwidthRequest(brq);
1132   pdu.Prepare(brq.m_tokens, H225_BandwidthRequest::e_tokens,
1133               brq.m_cryptoTokens, H225_BandwidthRequest::e_cryptoTokens);
1134 }
1135
1136
1137 void H225_RAS::OnSendBandwidthRequest(H225_BandwidthRequest & /*brq*/)
1138 {
1139 }
1140
1141
1142 BOOL H225_RAS::OnReceiveBandwidthRequest(const H323RasPDU & pdu, const H225_BandwidthRequest & brq)
1143 {
1144   if (!CheckCryptoTokens(pdu,
1145                          brq.m_tokens, H225_BandwidthRequest::e_tokens,
1146                          brq.m_cryptoTokens, H225_BandwidthRequest::e_cryptoTokens))
1147     return FALSE;
1148
1149   return OnReceiveBandwidthRequest(brq);
1150 }
1151
1152
1153 BOOL H225_RAS::OnReceiveBandwidthRequest(const H225_BandwidthRequest & /*brq*/)
1154 {
1155   return TRUE;
1156 }
1157
1158
1159 void H225_RAS::OnSendBandwidthConfirm(H323RasPDU & pdu, H225_BandwidthConfirm & bcf)
1160 {
1161   OnSendBandwidthConfirm(bcf);
1162   pdu.Prepare(bcf.m_tokens, H225_BandwidthConfirm::e_tokens,
1163               bcf.m_cryptoTokens, H225_BandwidthConfirm::e_cryptoTokens);
1164 }
1165
1166
1167 void H225_RAS::OnSendBandwidthConfirm(H225_BandwidthConfirm & /*bcf*/)
1168 {
1169 }
1170
1171
1172 BOOL H225_RAS::OnReceiveBandwidthConfirm(const H323RasPDU & pdu, const H225_BandwidthConfirm & bcf)
1173 {
1174   if (!CheckForResponse(H225_RasMessage::e_bandwidthRequest, bcf.m_requestSeqNum))
1175     return FALSE;
1176
1177   if (!CheckCryptoTokens(pdu,
1178                          bcf.m_tokens, H225_BandwidthConfirm::e_tokens,
1179                          bcf.m_cryptoTokens, H225_BandwidthConfirm::e_cryptoTokens))
1180     return FALSE;
1181
1182   return OnReceiveBandwidthConfirm(bcf);
1183 }
1184
1185
1186 BOOL H225_RAS::OnReceiveBandwidthConfirm(const H225_BandwidthConfirm & /*bcf*/)
1187 {
1188   return TRUE;
1189 }
1190
1191
1192 void H225_RAS::OnSendBandwidthReject(H323RasPDU & pdu, H225_BandwidthReject & brj)
1193 {
1194   OnSendBandwidthReject(brj);
1195   pdu.Prepare(brj.m_tokens, H225_BandwidthReject::e_tokens,
1196               brj.m_cryptoTokens, H225_BandwidthReject::e_cryptoTokens);
1197 }
1198
1199
1200 void H225_RAS::OnSendBandwidthReject(H225_BandwidthReject & /*brj*/)
1201 {
1202 }
1203
1204
1205 BOOL H225_RAS::OnReceiveBandwidthReject(const H323RasPDU & pdu, const H225_BandwidthReject & brj)
1206 {
1207   if (!CheckForResponse(H225_RasMessage::e_bandwidthRequest, brj.m_requestSeqNum, &brj.m_rejectReason))
1208     return FALSE;
1209
1210   if (!CheckCryptoTokens(pdu,
1211                          brj.m_tokens, H225_BandwidthReject::e_tokens,
1212                          brj.m_cryptoTokens, H225_BandwidthReject::e_cryptoTokens))
1213     return FALSE;
1214
1215   return OnReceiveBandwidthReject(brj);
1216 }
1217
1218
1219 BOOL H225_RAS::OnReceiveBandwidthReject(const H225_BandwidthReject & /*brj*/)
1220 {
1221   return TRUE;
1222 }
1223
1224
1225 void H225_RAS::OnSendDisengageRequest(H323RasPDU & pdu, H225_DisengageRequest & drq)
1226 {
1227   OnSendDisengageRequest(drq);
1228   pdu.Prepare(drq.m_tokens, H225_DisengageRequest::e_tokens,
1229               drq.m_cryptoTokens, H225_DisengageRequest::e_cryptoTokens);
1230 }
1231
1232
1233 void H225_RAS::OnSendDisengageRequest(H225_DisengageRequest & /*drq*/)
1234 {
1235 }
1236
1237
1238 BOOL H225_RAS::OnReceiveDisengageRequest(const H323RasPDU & pdu, const H225_DisengageRequest & drq)
1239 {
1240   if (!CheckCryptoTokens(pdu,
1241                          drq.m_tokens, H225_DisengageRequest::e_tokens,
1242                          drq.m_cryptoTokens, H225_DisengageRequest::e_cryptoTokens))
1243     return FALSE;
1244
1245   return OnReceiveDisengageRequest(drq);
1246 }
1247
1248
1249 BOOL H225_RAS::OnReceiveDisengageRequest(const H225_DisengageRequest & /*drq*/)
1250 {
1251   return TRUE;
1252 }
1253
1254
1255 void H225_RAS::OnSendDisengageConfirm(H323RasPDU & pdu, H225_DisengageConfirm & dcf)
1256 {
1257   OnSendDisengageConfirm(dcf);
1258   pdu.Prepare(dcf.m_tokens, H225_DisengageConfirm::e_tokens,
1259               dcf.m_cryptoTokens, H225_DisengageConfirm::e_cryptoTokens);
1260 }
1261
1262
1263 void H225_RAS::OnSendDisengageConfirm(H225_DisengageConfirm & /*dcf*/)
1264 {
1265 }
1266
1267
1268 BOOL H225_RAS::OnReceiveDisengageConfirm(const H323RasPDU & pdu, const H225_DisengageConfirm & dcf)
1269 {
1270   if (!CheckForResponse(H225_RasMessage::e_disengageRequest, dcf.m_requestSeqNum))
1271     return FALSE;
1272
1273   if (!CheckCryptoTokens(pdu,
1274                          dcf.m_tokens, H225_DisengageConfirm::e_tokens,
1275                          dcf.m_cryptoTokens, H225_DisengageConfirm::e_cryptoTokens))
1276     return FALSE;
1277
1278   return OnReceiveDisengageConfirm(dcf);
1279 }
1280
1281
1282 BOOL H225_RAS::OnReceiveDisengageConfirm(const H225_DisengageConfirm & /*dcf*/)
1283 {
1284   return TRUE;
1285 }
1286
1287
1288 void H225_RAS::OnSendDisengageReject(H323RasPDU & pdu, H225_DisengageReject & drj)
1289 {
1290   OnSendDisengageReject(drj);
1291   pdu.Prepare(drj.m_tokens, H225_DisengageReject::e_tokens,
1292               drj.m_cryptoTokens, H225_DisengageReject::e_cryptoTokens);
1293 }
1294
1295
1296 void H225_RAS::OnSendDisengageReject(H225_DisengageReject & /*drj*/)
1297 {
1298 }
1299
1300
1301 BOOL H225_RAS::OnReceiveDisengageReject(const H323RasPDU & pdu, const H225_DisengageReject & drj)
1302 {
1303   if (!CheckForResponse(H225_RasMessage::e_disengageRequest, drj.m_requestSeqNum, &drj.m_rejectReason))
1304     return FALSE;
1305
1306   if (!CheckCryptoTokens(pdu,
1307                          drj.m_tokens, H225_DisengageReject::e_tokens,
1308                          drj.m_cryptoTokens, H225_DisengageReject::e_cryptoTokens))
1309     return FALSE;
1310
1311   return OnReceiveDisengageReject(drj);
1312 }
1313
1314
1315 BOOL H225_RAS::OnReceiveDisengageReject(const H225_DisengageReject & /*drj*/)
1316 {
1317   return TRUE;
1318 }
1319
1320
1321 void H225_RAS::OnSendLocationRequest(H323RasPDU & pdu, H225_LocationRequest & lrq)
1322 {
1323   OnSendLocationRequest(lrq);
1324
1325 #ifdef H323_H460
1326   SendFeatureSet<H225_LocationRequest>(this, H460_MessageType::e_locationRequest, lrq);
1327 #endif
1328
1329   pdu.Prepare(lrq.m_tokens, H225_LocationRequest::e_tokens,
1330               lrq.m_cryptoTokens, H225_LocationRequest::e_cryptoTokens);
1331 }
1332
1333
1334 void H225_RAS::OnSendLocationRequest(H225_LocationRequest & /*lrq*/)
1335 {
1336 }
1337
1338
1339 BOOL H225_RAS::OnReceiveLocationRequest(const H323RasPDU & pdu, const H225_LocationRequest & lrq)
1340 {
1341   if (!CheckCryptoTokens(pdu,
1342                          lrq.m_tokens, H225_LocationRequest::e_tokens,
1343                          lrq.m_cryptoTokens, H225_LocationRequest::e_cryptoTokens))
1344     return FALSE;
1345
1346 #ifdef H323_H460
1347   ReceiveFeatureSet<H225_LocationRequest>(this, H460_MessageType::e_locationRequest, lrq);
1348 #endif
1349
1350   return OnReceiveLocationRequest(lrq);
1351 }
1352
1353
1354 BOOL H225_RAS::OnReceiveLocationRequest(const H225_LocationRequest & /*lrq*/)
1355 {
1356   return TRUE;
1357 }
1358
1359
1360 void H225_RAS::OnSendLocationConfirm(H323RasPDU & pdu, H225_LocationConfirm & lcf)
1361 {
1362   OnSendLocationConfirm(lcf);
1363
1364 #ifdef H323_H460
1365   SendFeatureSet<H225_LocationConfirm>(this, H460_MessageType::e_locationConfirm, lcf);
1366 #endif
1367
1368   pdu.Prepare(lcf.m_tokens, H225_LocationRequest::e_tokens,
1369               lcf.m_cryptoTokens, H225_LocationRequest::e_cryptoTokens);
1370 }
1371
1372
1373 void H225_RAS::OnSendLocationConfirm(H225_LocationConfirm & /*lcf*/)
1374 {
1375 }
1376
1377
1378 BOOL H225_RAS::OnReceiveLocationConfirm(const H323RasPDU &, const H225_LocationConfirm & lcf)
1379 {
1380   if (!CheckForResponse(H225_RasMessage::e_locationRequest, lcf.m_requestSeqNum))
1381     return FALSE;
1382
1383   if (lastRequest->responseInfo != NULL) {
1384     H323TransportAddress & locatedAddress = *(H323TransportAddress *)lastRequest->responseInfo;
1385     locatedAddress = lcf.m_callSignalAddress;
1386   }
1387
1388 #ifdef H323_H460
1389   ReceiveFeatureSet<H225_LocationConfirm>(this, H460_MessageType::e_locationConfirm, lcf);
1390 #endif
1391
1392   return OnReceiveLocationConfirm(lcf);
1393 }
1394
1395
1396 BOOL H225_RAS::OnReceiveLocationConfirm(const H225_LocationConfirm & /*lcf*/)
1397 {
1398   return TRUE;
1399 }
1400
1401
1402 void H225_RAS::OnSendLocationReject(H323RasPDU & pdu, H225_LocationReject & lrj)
1403 {
1404   OnSendLocationReject(lrj);
1405
1406 #ifdef H323_H460
1407   SendFeatureSet<H225_LocationReject>(this, H460_MessageType::e_locationReject, lrj);
1408 #endif
1409
1410   pdu.Prepare(lrj.m_tokens, H225_LocationReject::e_tokens,
1411               lrj.m_cryptoTokens, H225_LocationReject::e_cryptoTokens);
1412 }
1413
1414
1415 void H225_RAS::OnSendLocationReject(H225_LocationReject & /*lrj*/)
1416 {
1417 }
1418
1419
1420 BOOL H225_RAS::OnReceiveLocationReject(const H323RasPDU & pdu, const H225_LocationReject & lrj)
1421 {
1422   if (!CheckForResponse(H225_RasMessage::e_locationRequest, lrj.m_requestSeqNum, &lrj.m_rejectReason))
1423     return FALSE;
1424
1425   if (!CheckCryptoTokens(pdu,
1426                          lrj.m_tokens, H225_LocationReject::e_tokens,
1427                          lrj.m_cryptoTokens, H225_LocationReject::e_cryptoTokens))
1428     return FALSE;
1429
1430 #ifdef H323_H460
1431   ReceiveFeatureSet<H225_LocationReject>(this, H460_MessageType::e_locationReject, lrj);
1432 #endif
1433
1434   return OnReceiveLocationReject(lrj);
1435 }
1436
1437
1438 BOOL H225_RAS::OnReceiveLocationReject(const H225_LocationReject & /*lrj*/)
1439 {
1440   return TRUE;
1441 }
1442
1443
1444 void H225_RAS::OnSendInfoRequest(H323RasPDU & pdu, H225_InfoRequest & irq)
1445 {
1446   OnSendInfoRequest(irq);
1447   pdu.Prepare(irq.m_tokens, H225_InfoRequest::e_tokens,
1448               irq.m_cryptoTokens, H225_InfoRequest::e_cryptoTokens);
1449 }
1450
1451
1452 void H225_RAS::OnSendInfoRequest(H225_InfoRequest & /*irq*/)
1453 {
1454 }
1455
1456
1457 BOOL H225_RAS::OnReceiveInfoRequest(const H323RasPDU & pdu, const H225_InfoRequest & irq)
1458 {
1459   if (!CheckCryptoTokens(pdu,
1460                          irq.m_tokens, H225_InfoRequest::e_tokens,
1461                          irq.m_cryptoTokens, H225_InfoRequest::e_cryptoTokens))
1462     return FALSE;
1463
1464   return OnReceiveInfoRequest(irq);
1465 }
1466
1467
1468 BOOL H225_RAS::OnReceiveInfoRequest(const H225_InfoRequest & /*irq*/)
1469 {
1470   return TRUE;
1471 }
1472
1473
1474 void H225_RAS::OnSendInfoRequestResponse(H323RasPDU & pdu, H225_InfoRequestResponse & irr)
1475 {
1476   OnSendInfoRequestResponse(irr);
1477   pdu.Prepare(irr.m_tokens, H225_InfoRequestResponse::e_tokens,
1478               irr.m_cryptoTokens, H225_InfoRequestResponse::e_cryptoTokens);
1479 }
1480
1481
1482 void H225_RAS::OnSendInfoRequestResponse(H225_InfoRequestResponse & /*irr*/)
1483 {
1484 }
1485
1486
1487 BOOL H225_RAS::OnReceiveInfoRequestResponse(const H323RasPDU & pdu, const H225_InfoRequestResponse & irr)
1488 {
1489   if (!CheckForResponse(H225_RasMessage::e_infoRequest, irr.m_requestSeqNum))
1490     return FALSE;
1491
1492   if (!CheckCryptoTokens(pdu,
1493                          irr.m_tokens, H225_InfoRequestResponse::e_tokens,
1494                          irr.m_cryptoTokens, H225_InfoRequestResponse::e_cryptoTokens))
1495     return FALSE;
1496
1497   return OnReceiveInfoRequestResponse(irr);
1498 }
1499
1500
1501 BOOL H225_RAS::OnReceiveInfoRequestResponse(const H225_InfoRequestResponse & /*irr*/)
1502 {
1503   return TRUE;
1504 }
1505
1506
1507 void H225_RAS::OnSendNonStandardMessage(H323RasPDU & pdu, H225_NonStandardMessage & nsm)
1508 {
1509   OnSendNonStandardMessage(nsm);
1510
1511 #ifdef H323_H460
1512   SendFeatureSet<H225_NonStandardMessage>(this, H460_MessageType::e_nonStandardMessage, nsm);
1513 #endif
1514
1515   pdu.Prepare(nsm.m_tokens, H225_InfoRequestResponse::e_tokens,
1516               nsm.m_cryptoTokens, H225_InfoRequestResponse::e_cryptoTokens);
1517 }
1518
1519
1520 void H225_RAS::OnSendNonStandardMessage(H225_NonStandardMessage & /*nsm*/)
1521 {
1522 }
1523
1524
1525 BOOL H225_RAS::OnReceiveNonStandardMessage(const H323RasPDU & pdu, const H225_NonStandardMessage & nsm)
1526 {
1527   if (!CheckCryptoTokens(pdu,
1528                          nsm.m_tokens, H225_NonStandardMessage::e_tokens,
1529                          nsm.m_cryptoTokens, H225_NonStandardMessage::e_cryptoTokens))
1530     return FALSE;
1531
1532 #ifdef H323_H460
1533   ReceiveFeatureSet<H225_NonStandardMessage>(this, H460_MessageType::e_nonStandardMessage, nsm);
1534 #endif
1535
1536   return OnReceiveNonStandardMessage(nsm);
1537 }
1538
1539
1540 BOOL H225_RAS::OnReceiveNonStandardMessage(const H225_NonStandardMessage & /*nsm*/)
1541 {
1542   return TRUE;
1543 }
1544
1545
1546 void H225_RAS::OnSendUnknownMessageResponse(H323RasPDU & pdu, H225_UnknownMessageResponse & umr)
1547 {
1548   OnSendUnknownMessageResponse(umr);
1549   pdu.Prepare(umr.m_tokens, H225_UnknownMessageResponse::e_tokens,
1550               umr.m_cryptoTokens, H225_UnknownMessageResponse::e_cryptoTokens);
1551 }
1552
1553
1554 void H225_RAS::OnSendUnknownMessageResponse(H225_UnknownMessageResponse & /*umr*/)
1555 {
1556 }
1557
1558
1559 BOOL H225_RAS::OnReceiveUnknownMessageResponse(const H323RasPDU & pdu, const H225_UnknownMessageResponse & umr)
1560 {
1561   if (!CheckCryptoTokens(pdu,
1562                          umr.m_tokens, H225_UnknownMessageResponse::e_tokens,
1563                          umr.m_cryptoTokens, H225_UnknownMessageResponse::e_cryptoTokens))
1564     return FALSE;
1565
1566   return OnReceiveUnknownMessageResponse(umr);
1567 }
1568
1569
1570 BOOL H225_RAS::OnReceiveUnknownMessageResponse(const H225_UnknownMessageResponse & /*umr*/)
1571 {
1572   return TRUE;
1573 }
1574
1575
1576 void H225_RAS::OnSendRequestInProgress(H323RasPDU & pdu, H225_RequestInProgress & rip)
1577 {
1578   OnSendRequestInProgress(rip);
1579   pdu.Prepare(rip.m_tokens, H225_RequestInProgress::e_tokens,
1580               rip.m_cryptoTokens, H225_RequestInProgress::e_cryptoTokens);
1581 }
1582
1583
1584 void H225_RAS::OnSendRequestInProgress(H225_RequestInProgress & /*rip*/)
1585 {
1586 }
1587
1588
1589 void H225_RAS::OnSendResourcesAvailableIndicate(H323RasPDU & pdu, H225_ResourcesAvailableIndicate & rai)
1590 {
1591   OnSendResourcesAvailableIndicate(rai);
1592   pdu.Prepare(rai.m_tokens, H225_ResourcesAvailableIndicate::e_tokens,
1593               rai.m_cryptoTokens, H225_ResourcesAvailableIndicate::e_cryptoTokens);
1594 }
1595
1596
1597 void H225_RAS::OnSendResourcesAvailableIndicate(H225_ResourcesAvailableIndicate & /*rai*/)
1598 {
1599 }
1600
1601
1602 BOOL H225_RAS::OnReceiveResourcesAvailableIndicate(const H323RasPDU & pdu, const H225_ResourcesAvailableIndicate & rai)
1603 {
1604   if (!CheckCryptoTokens(pdu,
1605                          rai.m_tokens, H225_ResourcesAvailableIndicate::e_tokens,
1606                          rai.m_cryptoTokens, H225_ResourcesAvailableIndicate::e_cryptoTokens))
1607     return FALSE;
1608
1609   return OnReceiveResourcesAvailableIndicate(rai);
1610 }
1611
1612
1613 BOOL H225_RAS::OnReceiveResourcesAvailableIndicate(const H225_ResourcesAvailableIndicate & /*rai*/)
1614 {
1615   return TRUE;
1616 }
1617
1618
1619 void H225_RAS::OnSendResourcesAvailableConfirm(H323RasPDU & pdu, H225_ResourcesAvailableConfirm & rac)
1620 {
1621   OnSendResourcesAvailableConfirm(rac);
1622   pdu.Prepare(rac.m_tokens, H225_ResourcesAvailableConfirm::e_tokens,
1623               rac.m_cryptoTokens, H225_ResourcesAvailableConfirm::e_cryptoTokens);
1624 }
1625
1626
1627 void H225_RAS::OnSendResourcesAvailableConfirm(H225_ResourcesAvailableConfirm & /*rac*/)
1628 {
1629 }
1630
1631
1632 BOOL H225_RAS::OnReceiveResourcesAvailableConfirm(const H323RasPDU & pdu, const H225_ResourcesAvailableConfirm & rac)
1633 {
1634   if (!CheckForResponse(H225_RasMessage::e_resourcesAvailableIndicate, rac.m_requestSeqNum))
1635     return FALSE;
1636
1637   if (!CheckCryptoTokens(pdu,
1638                          rac.m_tokens, H225_ResourcesAvailableConfirm::e_tokens,
1639                          rac.m_cryptoTokens, H225_ResourcesAvailableConfirm::e_cryptoTokens))
1640     return FALSE;
1641
1642   return OnReceiveResourcesAvailableConfirm(rac);
1643 }
1644
1645
1646 BOOL H225_RAS::OnReceiveResourcesAvailableConfirm(const H225_ResourcesAvailableConfirm & /*rac*/)
1647 {
1648   return TRUE;
1649 }
1650
1651 #ifdef H323_H248
1652
1653 void H225_RAS::OnSendServiceControlIndication(H323RasPDU & pdu, H225_ServiceControlIndication & sci)
1654 {
1655   OnSendServiceControlIndication(sci);
1656
1657 #ifdef H323_H460
1658   SendFeatureSet<H225_ServiceControlIndication>(this, H460_MessageType::e_serviceControlIndication, sci);
1659 #endif
1660
1661   pdu.Prepare(sci.m_tokens, H225_ServiceControlIndication::e_tokens,
1662               sci.m_cryptoTokens, H225_ServiceControlIndication::e_cryptoTokens);
1663 }
1664
1665
1666 void H225_RAS::OnSendServiceControlIndication(H225_ServiceControlIndication & /*sci*/)
1667 {
1668 }
1669
1670
1671 BOOL H225_RAS::OnReceiveServiceControlIndication(const H323RasPDU & pdu, const H225_ServiceControlIndication & sci)
1672 {
1673   if (!CheckCryptoTokens(pdu,
1674                          sci.m_tokens, H225_ServiceControlIndication::e_tokens,
1675                          sci.m_cryptoTokens, H225_ServiceControlIndication::e_cryptoTokens))
1676     return FALSE;
1677
1678 #ifdef H323_H460
1679   ReceiveFeatureSet<H225_ServiceControlIndication>(this, H460_MessageType::e_serviceControlIndication, sci);
1680 #endif
1681
1682   return OnReceiveServiceControlIndication(sci);
1683 }
1684
1685
1686 BOOL H225_RAS::OnReceiveServiceControlIndication(const H225_ServiceControlIndication & /*sci*/)
1687 {
1688   return TRUE;
1689 }
1690
1691
1692 void H225_RAS::OnSendServiceControlResponse(H323RasPDU & pdu, H225_ServiceControlResponse & scr)
1693 {
1694   OnSendServiceControlResponse(scr);
1695
1696 #ifdef H323_H460
1697   SendFeatureSet<H225_ServiceControlResponse>(this, H460_MessageType::e_serviceControlResponse, scr);
1698 #endif
1699
1700   pdu.Prepare(scr.m_tokens, H225_ResourcesAvailableConfirm::e_tokens,
1701               scr.m_cryptoTokens, H225_ResourcesAvailableConfirm::e_cryptoTokens);
1702 }
1703
1704
1705 void H225_RAS::OnSendServiceControlResponse(H225_ServiceControlResponse & /*scr*/)
1706 {
1707 }
1708
1709
1710 BOOL H225_RAS::OnReceiveServiceControlResponse(const H323RasPDU & pdu, const H225_ServiceControlResponse & scr)
1711 {
1712   if (!CheckForResponse(H225_RasMessage::e_serviceControlIndication, scr.m_requestSeqNum))
1713     return FALSE;
1714
1715   if (!CheckCryptoTokens(pdu,
1716                          scr.m_tokens, H225_ServiceControlResponse::e_tokens,
1717                          scr.m_cryptoTokens, H225_ServiceControlResponse::e_cryptoTokens))
1718     return FALSE;
1719
1720 #ifdef H323_H460
1721   ReceiveFeatureSet<H225_ServiceControlResponse>(this, H460_MessageType::e_serviceControlResponse, scr);
1722 #endif
1723
1724   return OnReceiveServiceControlResponse(scr);
1725 }
1726
1727
1728 BOOL H225_RAS::OnReceiveServiceControlResponse(const H225_ServiceControlResponse & /*scr*/)
1729 {
1730   return TRUE;
1731 }
1732
1733 #endif // H323_H248
1734
1735
1736 void H225_RAS::OnSendInfoRequestAck(H323RasPDU & pdu, H225_InfoRequestAck & iack)
1737 {
1738   OnSendInfoRequestAck(iack);
1739   pdu.Prepare(iack.m_tokens, H225_InfoRequestAck::e_tokens,
1740               iack.m_cryptoTokens, H225_InfoRequestAck::e_cryptoTokens);
1741 }
1742
1743
1744 void H225_RAS::OnSendInfoRequestAck(H225_InfoRequestAck & /*iack*/)
1745 {
1746 }
1747
1748
1749 BOOL H225_RAS::OnReceiveInfoRequestAck(const H323RasPDU & pdu, const H225_InfoRequestAck & iack)
1750 {
1751   if (!CheckForResponse(H225_RasMessage::e_infoRequestResponse, iack.m_requestSeqNum))
1752     return FALSE;
1753
1754   if (!CheckCryptoTokens(pdu,
1755                          iack.m_tokens, H225_InfoRequestAck::e_tokens,
1756                          iack.m_cryptoTokens, H225_InfoRequestAck::e_cryptoTokens))
1757     return FALSE;
1758
1759   return OnReceiveInfoRequestAck(iack);
1760 }
1761
1762
1763 BOOL H225_RAS::OnReceiveInfoRequestAck(const H225_InfoRequestAck & /*iack*/)
1764 {
1765   return TRUE;
1766 }
1767
1768
1769 void H225_RAS::OnSendInfoRequestNak(H323RasPDU & pdu, H225_InfoRequestNak & inak)
1770 {
1771   OnSendInfoRequestNak(inak);
1772   pdu.Prepare(inak.m_tokens, H225_InfoRequestAck::e_tokens,
1773               inak.m_cryptoTokens, H225_InfoRequestAck::e_cryptoTokens);
1774 }
1775
1776
1777 void H225_RAS::OnSendInfoRequestNak(H225_InfoRequestNak & /*inak*/)
1778 {
1779 }
1780
1781
1782 BOOL H225_RAS::OnReceiveInfoRequestNak(const H323RasPDU & pdu, const H225_InfoRequestNak & inak)
1783 {
1784   if (!CheckForResponse(H225_RasMessage::e_infoRequestResponse, inak.m_requestSeqNum, &inak.m_nakReason))
1785     return FALSE;
1786
1787   if (!CheckCryptoTokens(pdu,
1788                          inak.m_tokens, H225_InfoRequestNak::e_tokens,
1789                          inak.m_cryptoTokens, H225_InfoRequestNak::e_cryptoTokens))
1790     return FALSE;
1791
1792   return OnReceiveInfoRequestNak(inak);
1793 }
1794
1795
1796 BOOL H225_RAS::OnReceiveInfoRequestNak(const H225_InfoRequestNak & /*inak*/)
1797 {
1798   return TRUE;
1799 }
1800
1801
1802 BOOL H225_RAS::OnReceiveUnknown(const H323RasPDU &)
1803 {
1804   H323RasPDU response;
1805   response.BuildUnknownMessageResponse(0);
1806   return response.Write(*transport);
1807 }
1808
1809
1810 /////////////////////////////////////////////////////////////////////////////