src/h224/h224.cxx

   1 /*
   2  * h224.cxx
   3  *
   4  * H.224 implementation for the OpenH323 Project.
   5  *
   6  * Copyright (c) 2006 Network for Educational Technology, ETH Zurich.
   7  * Written by Hannes Friederich.
   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  * Contributor(s): ______________________________________.
  20  *
  21  * $Log$
  22  * Revision 1.3  2006/05/01 10:29:50  csoutheren
  23  * Added pragams for gcc < 4
  24  *
  25  * Revision 1.2  2006/04/24 12:53:50  rjongbloed
  26  * Port of H.224 Far End Camera Control to DevStudio/Windows
  27  *
  28  * Revision 1.1  2006/04/20 16:48:17  hfriederich
  29  * Initial version of H.224/H.281 implementation.
  30  *
  31  */
  32
  33 #include <ptlib.h>
  34
  35 #ifdef __GNUC__
  36 #pragma implementation "h224.h"
  37 #pragma implementation "h224handler.h"
  38 #endif
  39
  40 #include <h224/h224.h>
  41 #include <h224/h224handler.h>
  42 #include <h323/h323con.h>
  43
  44
  45 H224_Frame::H224_Frame(PINDEX size)
  46 : Q922_Frame(H224_HEADER_SIZE + size)
  47 {
  48   SetHighPriority(FALSE);
  49
  50   SetControlFieldOctet(0x03);
  51
  52   BYTE *data = GetInformationFieldPtr();
  53
  54   // setting destination & source terminal address to BROADCAST
  55   data[0] = 0;
  56   data[1] = 0;
  57   data[2] = 0;
  58   data[3] = 0;
  59
  60   // setting Client ID to CME
  61   data[4] = 0;
  62
  63   // setting ES / BS / C1 / C0 / Segment number to zero
  64   data[5] = 0;
  65 }
  66
  67 H224_Frame::~H224_Frame()
  68 {
  69 }
  70
  71 void H224_Frame::SetHighPriority(BOOL flag)
  72 {
  73   SetHighOrderAddressOctet(0x00);
  74
  75   if(flag) {
  76     SetLowOrderAddressOctet(0x71);
  77   } else {
  78     SetLowOrderAddressOctet(0x061);
  79   }
  80 }
  81
  82 WORD H224_Frame::GetDestinationTerminalAddress() const
  83 {
  84   BYTE *data = GetInformationFieldPtr();
  85   return (WORD)((data[0] << 8) | data[1]);
  86 }
  87
  88 void H224_Frame::SetDestinationTerminalAddress(WORD address)
  89 {
  90   BYTE *data = GetInformationFieldPtr();
  91   data[0] = (BYTE)(address >> 8);
  92   data[1] = (BYTE) address;
  93 }
  94
  95 WORD H224_Frame::GetSourceTerminalAddress() const
  96 {
  97   BYTE *data = GetInformationFieldPtr();
  98   return (WORD)((data[2] << 8) | data[3]);
  99 }
 100
 101 void H224_Frame::SetSourceTerminalAddress(WORD address)
 102 {
 103   BYTE *data = GetInformationFieldPtr();
 104   data[2] = (BYTE)(address >> 8);
 105   data[3] = (BYTE) address;
 106 }
 107
 108 BYTE H224_Frame::GetClientID() const
 109 {
 110   BYTE *data = GetInformationFieldPtr();
 111
 112   return data[4] & 0x7f;
 113 }
 114
 115 void H224_Frame::SetClientID(BYTE clientID)
 116 {
 117   // At the moment, only H.281 (client ID 0x01)
 118   // is supported
 119   PAssert(clientID <= 0x01, "Invalid client ID");
 120
 121   BYTE *data = GetInformationFieldPtr();
 122
 123   data[4] = clientID;
 124 }
 125
 126 BOOL H224_Frame::GetBS() const
 127 {
 128   BYTE *data = GetInformationFieldPtr();
 129
 130   return (data[5] & 0x80) != 0;
 131 }
 132
 133 void H224_Frame::SetBS(BOOL flag)
 134 {
 135   BYTE *data = GetInformationFieldPtr();
 136
 137   if(flag) {
 138     data[5] |= 0x80;
 139   }     else {
 140     data[5] &= 0x7f;
 141   }
 142 }
 143
 144 BOOL H224_Frame::GetES() const
 145 {
 146   BYTE *data = GetInformationFieldPtr();
 147
 148   return (data[5] & 0x40) != 0;
 149 }
 150
 151 void H224_Frame::SetES(BOOL flag)
 152 {
 153   BYTE *data = GetInformationFieldPtr();
 154
 155   if(flag) {
 156     data[5] |= 0x40;
 157   } else {
 158     data[5] &= 0xbf;
 159   }
 160 }
 161
 162 BOOL H224_Frame::GetC1() const
 163 {
 164   BYTE *data = GetInformationFieldPtr();
 165
 166   return (data[5] & 0x20) != 0;
 167 }
 168
 169 void H224_Frame::SetC1(BOOL flag)
 170 {
 171   BYTE *data = GetInformationFieldPtr();
 172
 173   if(flag) {
 174     data[5] |= 0x20;
 175   } else {
 176     data[5] &= 0xdf;
 177   }
 178 }
 179
 180 BOOL H224_Frame::GetC0() const
 181 {
 182   BYTE *data = GetInformationFieldPtr();
 183
 184   return (data[5] & 0x10) != 0;
 185 }
 186
 187 void H224_Frame::SetC0(BOOL flag)
 188 {
 189   BYTE *data = GetInformationFieldPtr();
 190
 191   if(flag) {
 192     data[5] |= 0x10;
 193   }     else {
 194     data[5] &= 0xef;
 195   }
 196 }
 197
 198 BYTE H224_Frame::GetSegmentNumber() const
 199 {
 200   BYTE *data = GetInformationFieldPtr();
 201
 202   return (data[5] & 0x0f);
 203 }
 204
 205 void H224_Frame::SetSegmentNumber(BYTE segmentNumber)
 206 {
 207   BYTE *data = GetInformationFieldPtr();
 208
 209   data[5] &= 0xf0;
 210   data[5] |= (segmentNumber & 0x0f);
 211 }
 212
 213 BOOL H224_Frame::Decode(const BYTE *data,
 214                                                 PINDEX size)
 215 {
 216   BOOL result = Q922_Frame::Decode(data, size);
 217
 218   if(result == FALSE) {
 219         return FALSE;
 220   }
 221
 222   // doing some validity check for H.224 frames
 223   BYTE highOrderAddressOctet = GetHighOrderAddressOctet();
 224   BYTE lowOrderAddressOctet = GetLowOrderAddressOctet();
 225   BYTE controlFieldOctet = GetControlFieldOctet();
 226
 227   if((highOrderAddressOctet != 0x00) ||
 228      (!(lowOrderAddressOctet == 0x61 || lowOrderAddressOctet == 0x71)) ||
 229      (controlFieldOctet != 0x03) ||
 230      (GetClientID() > 0x02))
 231   {
 232           return FALSE;
 233   }
 234
 235   return TRUE;
 236 }
 237
 238 ////////////////////////////////////
 239
 240 OpalH224Handler::OpalH224Handler(OpalConnection & connection,
 241                                                                  unsigned sessionID)
 242 : transmitMutex()
 243 {
 244   session = connection.UseSession(connection.GetTransport(),
 245                                                               sessionID);
 246
 247   h281Handler = connection.CreateH281ProtocolHandler(*this);
 248   receiverThread = NULL;
 249
 250 }
 251
 252 OpalH224Handler::~OpalH224Handler()
 253 {
 254   delete h281Handler;
 255 }
 256
 257 void OpalH224Handler::StartTransmit()
 258 {
 259   PWaitAndSignal m(transmitMutex);
 260
 261   if(canTransmit == TRUE) {
 262     return;
 263   }
 264
 265   canTransmit = TRUE;
 266
 267   transmitFrame = new RTP_DataFrame(300);
 268
 269   // Use payload code 100 as this seems to be common to other implementations
 270   transmitFrame->SetPayloadType((RTP_DataFrame::PayloadTypes)100);
 271   transmitBitIndex = 7;
 272   transmitStartTime = new PTime();
 273
 274   SendClientList();
 275   SendExtraCapabilities();
 276 }
 277
 278 void OpalH224Handler::StopTransmit()
 279 {
 280   PWaitAndSignal m(transmitMutex);
 281
 282   delete transmitStartTime;
 283   transmitStartTime = NULL;
 284
 285   canTransmit = FALSE;
 286 }
 287
 288 void OpalH224Handler::StartReceive()
 289 {
 290   if(receiverThread != NULL) {
 291     PTRACE(5, "H.224 handler is already receiving");
 292     return;
 293   }
 294
 295   receiverThread = CreateH224ReceiverThread();
 296   receiverThread->Resume();
 297 }
 298
 299 void OpalH224Handler::StopReceive()
 300 {
 301   if(receiverThread != NULL) {
 302     receiverThread->Close();
 303   }
 304 }
 305
 306 BOOL OpalH224Handler::SendClientList()
 307 {
 308   PWaitAndSignal m(transmitMutex);
 309
 310   if(canTransmit == FALSE) {
 311     return FALSE;
 312   }
 313
 314   H224_Frame h224Frame = H224_Frame(4);
 315   h224Frame.SetHighPriority(TRUE);
 316   h224Frame.SetDestinationTerminalAddress(H224_BROADCAST);
 317   h224Frame.SetSourceTerminalAddress(H224_BROADCAST);
 318
 319   // CME frame
 320   h224Frame.SetClientID(0x00);
 321
 322   // Begin and end of sequence
 323   h224Frame.SetBS(TRUE);
 324   h224Frame.SetES(TRUE);
 325   h224Frame.SetC1(FALSE);
 326   h224Frame.SetC0(FALSE);
 327   h224Frame.SetSegmentNumber(0);
 328
 329   BYTE *ptr = h224Frame.GetClientDataPtr();
 330
 331   ptr[0] = 0x01; // Client list code
 332   ptr[1] = 0x00; // Message code
 333   ptr[2] = 0x01; // one client
 334   ptr[3] = (0x80 | H281_CLIENT_ID); // H.281 with etra capabilities
 335
 336   TransmitFrame(h224Frame);
 337
 338   return TRUE;
 339 }
 340
 341 BOOL OpalH224Handler::SendExtraCapabilities()
 342 {
 343   PWaitAndSignal m(transmitMutex);
 344
 345   if(canTransmit == FALSE) {
 346     return FALSE;
 347   }
 348
 349   h281Handler->SendExtraCapabilities();
 350
 351   return TRUE;
 352 }
 353
 354 BOOL OpalH224Handler::SendClientListCommand()
 355 {
 356   PWaitAndSignal m(transmitMutex);
 357
 358   if(canTransmit == FALSE) {
 359     return FALSE;
 360   }
 361
 362   H224_Frame h224Frame = H224_Frame(2);
 363   h224Frame.SetHighPriority(TRUE);
 364   h224Frame.SetDestinationTerminalAddress(H224_BROADCAST);
 365   h224Frame.SetSourceTerminalAddress(H224_BROADCAST);
 366
 367   // CME frame
 368   h224Frame.SetClientID(0x00);
 369
 370   // Begin and end of sequence
 371   h224Frame.SetBS(TRUE);
 372   h224Frame.SetES(TRUE);
 373   h224Frame.SetC1(FALSE);
 374   h224Frame.SetC0(FALSE);
 375   h224Frame.SetSegmentNumber(0);
 376
 377   BYTE *ptr = h224Frame.GetClientDataPtr();
 378
 379   ptr[0] = 0x01; // Client list code
 380   ptr[1] = 0xff; // Command code
 381
 382   TransmitFrame(h224Frame);
 383
 384   return TRUE;
 385 }
 386
 387 BOOL OpalH224Handler::SendExtraCapabilitiesCommand(BYTE clientID)
 388 {
 389   PWaitAndSignal m(transmitMutex);
 390
 391   if(canTransmit == FALSE) {
 392     return FALSE;
 393   }
 394
 395   if(clientID != H281_CLIENT_ID) {
 396     return FALSE;
 397   }
 398
 399   H224_Frame h224Frame = H224_Frame(4);
 400   h224Frame.SetHighPriority(TRUE);
 401   h224Frame.SetDestinationTerminalAddress(H224_BROADCAST);
 402   h224Frame.SetSourceTerminalAddress(H224_BROADCAST);
 403
 404   // CME frame
 405   h224Frame.SetClientID(0x00);
 406
 407   // Begin and end of sequence
 408   h224Frame.SetBS(TRUE);
 409   h224Frame.SetES(TRUE);
 410   h224Frame.SetC1(FALSE);
 411   h224Frame.SetC0(FALSE);
 412   h224Frame.SetSegmentNumber(0);
 413
 414   BYTE *ptr = h224Frame.GetClientDataPtr();
 415
 416   ptr[0] = 0x01; // Client list code
 417   ptr[1] = 0xFF; // Response code
 418   ptr[2] = (0x80 | clientID); // clientID with extra capabilities
 419
 420   TransmitFrame(h224Frame);
 421
 422   return TRUE;
 423 }
 424
 425 BOOL OpalH224Handler::SendExtraCapabilitiesMessage(BYTE clientID,
 426                                                                                                    BYTE *data, PINDEX length)
 427 {
 428   PWaitAndSignal m(transmitMutex);
 429
 430   // only H.281 supported at the moment
 431   if(clientID != H281_CLIENT_ID) {
 432
 433     return FALSE;
 434   }
 435
 436   if(canTransmit == FALSE) {
 437     return FALSE;
 438   }
 439
 440   H224_Frame h224Frame = H224_Frame(length+3);
 441   h224Frame.SetHighPriority(TRUE);
 442   h224Frame.SetDestinationTerminalAddress(H224_BROADCAST);
 443   h224Frame.SetSourceTerminalAddress(H224_BROADCAST);
 444
 445   // use clientID zero to indicate a CME frame
 446   h224Frame.SetClientID(0x00);
 447
 448   // Begin and end of sequence, rest is zero
 449   h224Frame.SetBS(TRUE);
 450   h224Frame.SetES(TRUE);
 451   h224Frame.SetC1(FALSE);
 452   h224Frame.SetC0(FALSE);
 453   h224Frame.SetSegmentNumber(0);
 454
 455   BYTE *ptr = h224Frame.GetClientDataPtr();
 456
 457   ptr[0] = 0x02; // Extra Capabilities code
 458   ptr[1] = 0x00; // Response Code
 459   ptr[2] = (0x80 | clientID); // EX CAPS and ClientID
 460
 461   memcpy(ptr+3, data, length);
 462
 463   TransmitFrame(h224Frame);
 464
 465   return TRUE;
 466 }
 467
 468 BOOL OpalH224Handler::TransmitClientFrame(BYTE clientID, H224_Frame & frame)
 469 {
 470   PWaitAndSignal m(transmitMutex);
 471
 472   // only H.281 is supported at the moment
 473   if(clientID != H281_CLIENT_ID) {
 474     return FALSE;
 475   }
 476
 477   frame.SetClientID(clientID);
 478
 479   TransmitFrame(frame);
 480
 481   return TRUE;
 482 }
 483
 484 BOOL OpalH224Handler::OnReceivedFrame(H224_Frame & frame)
 485 {
 486   if(frame.GetDestinationTerminalAddress() != H224_BROADCAST) {
 487     // only broadcast frames are handled at the moment
 488         PTRACE(3, "Received H.224 frame with non-broadcast address");
 489     return TRUE;
 490   }
 491   BYTE clientID = frame.GetClientID();
 492
 493   if(clientID == 0x00) {
 494     return OnReceivedCMEMessage(frame);
 495   }
 496
 497   if(clientID == H281_CLIENT_ID)        {
 498     h281Handler->OnReceivedMessage((const H281_Frame &)frame);
 499   }
 500
 501   return TRUE;
 502 }
 503
 504 BOOL OpalH224Handler::OnReceivedCMEMessage(H224_Frame & frame)
 505 {
 506   BYTE *data = frame.GetClientDataPtr();
 507
 508   if(data[0] == 0x01) { // Client list code
 509
 510     if(data[1] == 0x00) { // Message
 511       return OnReceivedClientList(frame);
 512
 513     } else if(data[1] == 0xff) { // Command
 514       return OnReceivedClientListCommand();
 515     }
 516
 517   } else if(data[0] == 0x02) { // Extra Capabilities code
 518
 519     if(data[1] == 0x00) { // Message
 520       return OnReceivedExtraCapabilities(frame);
 521
 522     } else if(data[1] == 0xff) {// Command
 523       return OnReceivedExtraCapabilitiesCommand();
 524     }
 525   }
 526
 527   // incorrect frames are simply ignored
 528   return TRUE;
 529 }
 530
 531 BOOL OpalH224Handler::OnReceivedClientList(H224_Frame & frame)
 532 {
 533   BYTE *data = frame.GetClientDataPtr();
 534
 535   BYTE numberOfClients = data[2];
 536
 537   PINDEX i = 3;
 538
 539   BOOL remoteHasH281 = FALSE;
 540
 541   while(numberOfClients > 0) {
 542
 543         BYTE clientID = (data[i] & 0x7f);
 544
 545         if(clientID == H281_CLIENT_ID) {
 546           remoteHasH281 = TRUE;
 547           i++;
 548         } else if(clientID == 0x7e) { // extended client ID
 549       i += 2;
 550     } else if(clientID == 0x7f) { // non-standard client ID
 551       i += 6;
 552     } else { // other standard client ID such as T.140
 553       i++;
 554     }
 555     numberOfClients--;
 556   }
 557
 558   h281Handler->SetRemoteHasH281(remoteHasH281);
 559
 560   return TRUE;
 561 }
 562
 563 BOOL OpalH224Handler::OnReceivedClientListCommand()
 564 {
 565   SendClientList();
 566   return TRUE;
 567 }
 568
 569 BOOL OpalH224Handler::OnReceivedExtraCapabilities(H224_Frame & frame)
 570 {
 571   BYTE *data = frame.GetClientDataPtr();
 572
 573   BYTE clientID = (data[2] & 0x7f);
 574
 575   if(clientID == H281_CLIENT_ID) {
 576     PINDEX size = frame.GetClientDataSize() - 3;
 577     h281Handler->OnReceivedExtraCapabilities((data + 3), size);
 578   }
 579
 580   return TRUE;
 581 }
 582
 583 BOOL OpalH224Handler::OnReceivedExtraCapabilitiesCommand()
 584 {
 585   SendExtraCapabilities();
 586   return TRUE;
 587 }
 588
 589 OpalH224ReceiverThread * OpalH224Handler::CreateH224ReceiverThread()
 590 {
 591   return new OpalH224ReceiverThread(this, *session);
 592 }
 593
 594 void OpalH224Handler::TransmitFrame(H224_Frame & frame)
 595 {
 596   PINDEX size = frame.GetEncodedSize();
 597
 598   if(!frame.Encode(transmitFrame->GetPayloadPtr(), size, transmitBitIndex)) {
 599     PTRACE(3, "Failed to encode H.224 frame");
 600     return;
 601   }
 602
 603   // determining correct timestamp
 604   PTime currentTime = PTime();
 605   PTimeInterval timePassed = currentTime - *transmitStartTime;
 606   transmitFrame->SetTimestamp((DWORD)timePassed.GetMilliSeconds() * 8);
 607
 608   transmitFrame->SetPayloadSize(size);
 609   transmitFrame->SetMarker(TRUE);
 610
 611   if(!session->WriteData(*transmitFrame)) {
 612     PTRACE(3, "Failed to write encoded H.224 frame");
 613   }
 614 }
 615
 616 ////////////////////////////////////
 617
 618 OpalH224ReceiverThread::OpalH224ReceiverThread(OpalH224Handler *theH224Handler, RTP_Session & session)
 619 : PThread(10000, NoAutoDeleteThread, HighestPriority, "H.224 Receiver Thread"),
 620   rtpSession(session)
 621 {
 622   h224Handler = theH224Handler;
 623   timestamp = 0;
 624   terminate = FALSE;
 625 }
 626
 627 OpalH224ReceiverThread::~OpalH224ReceiverThread()
 628 {
 629 }
 630
 631 void OpalH224ReceiverThread::Main()
 632 {
 633   RTP_DataFrame packet = RTP_DataFrame(300);
 634   H224_Frame h224Frame = H224_Frame();
 635
 636   for (;;) {
 637
 638     inUse.Wait();
 639
 640     if(!rtpSession.ReadBufferedData(timestamp, packet)) {
 641       inUse.Signal();
 642       return;
 643     }
 644
 645     timestamp = packet.GetTimestamp();
 646
 647     if(h224Frame.Decode(packet.GetPayloadPtr(), packet.GetPayloadSize())) {
 648       BOOL result = h224Handler->OnReceivedFrame(h224Frame);
 649
 650       if(result == FALSE) {
 651         // FALSE indicates a serious problem, therefore the thread is closed
 652         return;
 653       }
 654     } else {
 655           PTRACE(3, "Decoding of H.224 frame failed");
 656     }
 657
 658     inUse.Signal();
 659
 660     if(terminate == TRUE) {
 661       return;
 662     }
 663   }
 664 }
 665
 666 void OpalH224ReceiverThread::Close()
 667 {
 668   rtpSession.Close(TRUE);
 669
 670   inUse.Wait();
 671
 672   terminate = TRUE;
 673
 674   inUse.Signal();
 675
 676   PAssert(WaitForTermination(10000), "H224 receiver thread not terminated");
 677 }