gkclient.cxx

mgcp协议源代码。支持多种编码：g711

  H323SetAliasAddresses(aliases, lrq.m_destinationInfo);

  if (!endpointIdentifier.IsEmpty()) {
    lrq.IncludeOptionalField(H225_LocationRequest::e_endpointIdentifier);
    lrq.m_endpointIdentifier.SetValue(endpointIdentifier);
  }

  OnSendLocationRequest(lrq);

  PWaitAndSignal mutex(makeRequestMutex);

  if (!MakeRequest(request))
    return FALSE;

  address = locatedAddress;

  return TRUE;
}


BOOL H323Gatekeeper::OnReceiveLocationConfirm(const H225_LocationConfirm & lcf)
{
  if (!CheckForResponse(H225_RasMessage::e_locationRequest, lcf.m_requestSeqNum))
    return FALSE;

  locatedAddress = lcf.m_callSignalAddress;

  return TRUE;
}


BOOL H323Gatekeeper::AdmissionRequest(H323Connection & connection)
{
  H323TransportAddress address;
  return AdmissionRequest(connection, address);
}


BOOL H323Gatekeeper::AdmissionRequest(H323Connection & connection,
                                      H323TransportAddress & address)
{
  BOOL answeringCall = connection.HadAnsweredCall();

  switch (answeringCall ? pregrantAnswerCall : pregrantMakeCall) {
    case RequireARQ :
      break;
    case PregrantARQ :
      return TRUE;
    case PreGkRoutedARQ :
      if (gkRouteAddress.IsEmpty())
        return FALSE;
      address = gkRouteAddress;
      return TRUE;
  }

  H323RasPDU request;
  H225_AdmissionRequest & arq = request.BuildAdmissionRequest(++lastSequenceNumber);

  arq.m_callType.SetTag(H225_CallType::e_pointToPoint);
  arq.m_endpointIdentifier.SetValue(endpointIdentifier);
  arq.m_answerCall = answeringCall;

  arq.m_srcInfo.SetSize(1);
  if (answeringCall)
    H323SetAliasAddress(connection.GetRemotePartyName(), arq.m_srcInfo[0]);
  else {
    H323SetAliasAddresses(endpoint.GetAliasNames(), arq.m_srcInfo);
    arq.IncludeOptionalField(H225_AdmissionRequest::e_destinationInfo);
    arq.m_destinationInfo.SetSize(1);
    H323SetAliasAddress(connection.GetRemotePartyName(), arq.m_destinationInfo[0]);
  }

  const H323Transport * signallingChannel = connection.GetSignallingChannel();
  arq.IncludeOptionalField(H225_AdmissionRequest::e_srcCallSignalAddress);
  if (answeringCall) {
    signallingChannel->SetUpTransportPDU(arq.m_srcCallSignalAddress, FALSE);
    arq.IncludeOptionalField(H225_AdmissionRequest::e_destCallSignalAddress);
    signallingChannel->SetUpTransportPDU(arq.m_destCallSignalAddress, TRUE);
  }
  else {
    transport->SetUpTransportPDU(arq.m_srcCallSignalAddress, TRUE);
    if (!address) {
      arq.IncludeOptionalField(H225_AdmissionRequest::e_destCallSignalAddress);
      address.SetPDU(arq.m_destCallSignalAddress);
    }
  }

  arq.m_bandWidth = connection.GetBandwidthAvailable();
  arq.m_callReferenceValue = connection.GetCallReference();
  arq.m_conferenceID = connection.GetConferenceIdentifier();
  arq.m_callIdentifier.m_guid = connection.GetCallIdentifier();

  OnSendAdmissionRequest(arq);

  PWaitAndSignal mutex(makeRequestMutex);

  locatedAddress = PString();

  if (!MakeRequest(request))
    return FALSE;

  connection.SetBandwidthAvailable(allocatedBandwidth);
  address = locatedAddress;

  return TRUE;
}


BOOL H323Gatekeeper::OnReceiveAdmissionConfirm(const H225_AdmissionConfirm & acf)
{
  if (!CheckForResponse(H225_RasMessage::e_admissionRequest, acf.m_requestSeqNum))
    return FALSE;

  locatedAddress = acf.m_destCallSignalAddress;
  allocatedBandwidth = acf.m_bandWidth;

  return TRUE;
}


BOOL H323Gatekeeper::DisengageRequest(const H323Connection & connection, unsigned reason)
{
  H323RasPDU request;
  H225_DisengageRequest & drq = request.BuildDisengageRequest(++lastSequenceNumber);

  drq.m_endpointIdentifier.SetValue(endpointIdentifier);
  drq.m_conferenceID = connection.GetConferenceIdentifier();
  drq.m_callReferenceValue = connection.GetCallReference();
  drq.m_callIdentifier.m_guid = connection.GetCallIdentifier();
  drq.m_disengageReason.SetTag(reason);
  drq.m_answeredCall = connection.HadAnsweredCall();

  if (!gatekeeperIdentifier) {
    drq.IncludeOptionalField(H225_DisengageRequest::e_gatekeeperIdentifier);
    drq.m_gatekeeperIdentifier = gatekeeperIdentifier;
  }

  OnSendDisengageRequest(drq);

  PWaitAndSignal mutex(makeRequestMutex);

  return MakeRequest(request);
}


BOOL H323Gatekeeper::OnReceiveDisengageConfirm(const H225_DisengageConfirm & dcf)
{
  return CheckForResponse(H225_RasMessage::e_disengageRequest, dcf.m_requestSeqNum);
}


BOOL H323Gatekeeper::OnReceiveDisengageRequest(const H225_DisengageRequest & drq)
{
  H323GloballyUniqueID id = drq.m_callIdentifier.m_guid;
  endpoint.ClearCall(id.AsString(), H323Connection::EndedByGatekeeper);

  H323RasPDU response;
  response.BuildDisengageConfirm(drq.m_requestSeqNum);
  return response.Write(*transport);
}


BOOL H323Gatekeeper::BandwidthRequest(H323Connection & connection,
                                      unsigned requestedBandwidth)
{
  H323RasPDU request;
  H225_BandwidthRequest & brq = request.BuildBandwidthRequest(++lastSequenceNumber);

  brq.m_endpointIdentifier.SetValue(endpointIdentifier);
  brq.m_conferenceID = connection.GetConferenceIdentifier();
  brq.m_callReferenceValue = connection.GetCallReference();
  brq.m_callIdentifier.m_guid = connection.GetCallIdentifier();
  brq.m_bandWidth = requestedBandwidth;

  OnSendBandwidthRequest(brq);

  PWaitAndSignal mutex(makeRequestMutex);

  if (!MakeRequest(request))
    return FALSE;

  connection.SetBandwidthAvailable(allocatedBandwidth);

  return TRUE;
}


BOOL H323Gatekeeper::OnReceiveBandwidthConfirm(const H225_BandwidthConfirm & bcf)
{
  if (!CheckForResponse(H225_RasMessage::e_bandwidthRequest, bcf.m_requestSeqNum))
    return FALSE;

  allocatedBandwidth = bcf.m_bandWidth;

  return TRUE;
}


BOOL H323Gatekeeper::OnReceiveBandwidthRequest(const H225_BandwidthRequest & brq)
{
  H323GloballyUniqueID id = brq.m_callIdentifier.m_guid;
  H323Connection * connection = endpoint.FindConnectionWithLock(id.AsString());

  H323RasPDU response;
  if (connection == NULL)
    response.BuildBandwidthReject(brq.m_requestSeqNum,
                                  H225_BandRejectReason::e_invalidConferenceID);
  else {
    if (connection->SetBandwidthAvailable(brq.m_bandWidth))
      response.BuildBandwidthConfirm(brq.m_requestSeqNum, brq.m_bandWidth);
    else
      response.BuildBandwidthReject(brq.m_requestSeqNum,
                                    H225_BandRejectReason::e_insufficientResources);
    connection->Unlock();
  }

  return response.Write(*transport);
}


BOOL H323Gatekeeper::InfoRequestResponse(const H323Connection * connection,
                                         unsigned seqNum)
{
  H323RasPDU response;
  H225_InfoRequestResponse & irr = response.BuildInfoRequestResponse(seqNum);

  endpoint.SetEndpointTypeInfo(irr.m_endpointType);
  irr.m_endpointIdentifier.SetValue(endpointIdentifier);
  transport->SetUpTransportPDU(irr.m_rasAddress, TRUE);
  const H323ListenerList & listeners = endpoint.GetListeners();
  for (PINDEX i = 0; i < listeners.GetSize(); i++)
    listeners[i].SetUpTransportPDU(irr.m_callSignalAddress, irr.m_rasAddress);

  if (endpoint.IsTerminal()) {
    irr.IncludeOptionalField(H225_InfoRequestResponse::e_endpointAlias);
    irr.m_endpointAlias.SetSize(1);
    H323SetAliasAddresses(endpoint.GetAliasNames(), irr.m_endpointAlias);
  }

  if (connection != NULL) {
    irr.m_perCallInfo.SetSize(1);
    H225_InfoRequestResponse_perCallInfo_subtype & info = irr.m_perCallInfo[0];
    info.m_callReferenceValue = connection->GetCallReference();
    info.m_callIdentifier.m_guid = connection->GetCallIdentifier();
    info.m_conferenceID = connection->GetConferenceIdentifier();
    H323_RTP_Session * session = connection->GetSessionCallbacks(RTP_Session::DefaultAudioSessionID);
    if (session != NULL) {
      info.IncludeOptionalField(H225_InfoRequestResponse_perCallInfo_subtype::e_audio);
      info.m_audio.SetSize(1);
      session->OnSendRasInfo(info.m_audio[0]);
    }
    session = connection->GetSessionCallbacks(RTP_Session::DefaultVideoSessionID);
    if (session != NULL) {
      info.IncludeOptionalField(H225_InfoRequestResponse_perCallInfo_subtype::e_video);
      info.m_video.SetSize(1);
      session->OnSendRasInfo(info.m_video[0]);
    }
    const H323Transport & controlChannel = connection->GetControlChannel();
    controlChannel.SetUpTransportPDU(info.m_h245.m_recvAddress, TRUE);
    controlChannel.SetUpTransportPDU(info.m_h245.m_sendAddress, FALSE);
    info.m_callType.SetTag(H225_CallType::e_pointToPoint);
    info.m_bandWidth = connection->GetBandwidthUsed();
    info.m_callModel.SetTag(H225_CallModel::e_direct);
  }

  return response.Write(*transport);
}


BOOL H323Gatekeeper::OnReceiveInfoRequest(const H225_InfoRequest & irq)
{
  H323GloballyUniqueID id = irq.m_callIdentifier.m_guid;
  H323Connection * connection = endpoint.FindConnectionWithLock(id.AsString());

  InfoRequestResponse(connection, irq.m_requestSeqNum);
  if (connection != NULL)
    connection->Unlock();

  return TRUE;
}


#define DEFINE_GATEKEEPER_PROTOCOL_SEND(name) \
  void H323Gatekeeper::OnSend##name(H225_##name &) { }

#define DEFINE_GATEKEEPER_PROTOCOL_REQUEST(name) \
  DEFINE_GATEKEEPER_PROTOCOL_SEND(name) \
  BOOL H323Gatekeeper::OnReceive##name(const H225_##name &) { return FALSE; }

#define DEFINE_GATEKEEPER_PROTOCOL_REJECT(name, req) \
  DEFINE_GATEKEEPER_PROTOCOL_SEND(name) \
  BOOL H323Gatekeeper::OnReceive##name(const H225_##name & pdu) { \
    return CheckForRejectResponse(H225_RasMessage::e_##req, pdu.m_requestSeqNum, #name, pdu.m_rejectReason); \
  }

#define DEFINE_GATEKEEPER_PROTOCOL_CONFIRM(name, req) \
  DEFINE_GATEKEEPER_PROTOCOL_SEND(name) \
  BOOL H323Gatekeeper::OnReceive##name(const H225_##name & pdu) { \
    return CheckForResponse(H225_RasMessage::e_##req, pdu.m_requestSeqNum); \
  }


DEFINE_GATEKEEPER_PROTOCOL_REQUEST(GatekeeperRequest);
DEFINE_GATEKEEPER_PROTOCOL_SEND(GatekeeperConfirm);
DEFINE_GATEKEEPER_PROTOCOL_REJECT(GatekeeperReject, gatekeeperRequest);
DEFINE_GATEKEEPER_PROTOCOL_REQUEST(RegistrationRequest);
DEFINE_GATEKEEPER_PROTOCOL_SEND(RegistrationConfirm);
DEFINE_GATEKEEPER_PROTOCOL_REJECT(RegistrationReject, registrationRequest);
DEFINE_GATEKEEPER_PROTOCOL_SEND(UnregistrationRequest);
DEFINE_GATEKEEPER_PROTOCOL_SEND(UnregistrationConfirm);
DEFINE_GATEKEEPER_PROTOCOL_REJECT(UnregistrationReject, unregistrationRequest);
DEFINE_GATEKEEPER_PROTOCOL_REQUEST(AdmissionRequest);
DEFINE_GATEKEEPER_PROTOCOL_SEND(AdmissionConfirm);
DEFINE_GATEKEEPER_PROTOCOL_REJECT(AdmissionReject, admissionRequest);
DEFINE_GATEKEEPER_PROTOCOL_SEND(BandwidthRequest);
DEFINE_GATEKEEPER_PROTOCOL_SEND(BandwidthConfirm);
DEFINE_GATEKEEPER_PROTOCOL_REJECT(BandwidthReject, bandwidthRequest);
DEFINE_GATEKEEPER_PROTOCOL_SEND(DisengageRequest);
DEFINE_GATEKEEPER_PROTOCOL_SEND(DisengageConfirm);
DEFINE_GATEKEEPER_PROTOCOL_REJECT(DisengageReject, disengageRequest);
DEFINE_GATEKEEPER_PROTOCOL_REQUEST(LocationRequest);
DEFINE_GATEKEEPER_PROTOCOL_SEND(LocationConfirm);
DEFINE_GATEKEEPER_PROTOCOL_REJECT(LocationReject, locationRequest);
DEFINE_GATEKEEPER_PROTOCOL_SEND(InfoRequest);
DEFINE_GATEKEEPER_PROTOCOL_CONFIRM(InfoRequestResponse, infoRequest);
DEFINE_GATEKEEPER_PROTOCOL_REQUEST(NonStandardMessage);
DEFINE_GATEKEEPER_PROTOCOL_REQUEST(UnknownMessageResponse);
DEFINE_GATEKEEPER_PROTOCOL_SEND(RequestInProgress);
DEFINE_GATEKEEPER_PROTOCOL_REQUEST(ResourcesAvailableIndicate);
DEFINE_GATEKEEPER_PROTOCOL_CONFIRM(ResourcesAvailableConfirm, resourcesAvailableIndicate);
DEFINE_GATEKEEPER_PROTOCOL_CONFIRM(InfoRequestAck, infoRequest);
DEFINE_GATEKEEPER_PROTOCOL_CONFIRM(InfoRequestNak, infoRequest);


void H323Gatekeeper::OnReceiveUnkown(const H323RasPDU &)
{
  H323RasPDU response;
  response.BuildUnknownMessageResponse(0);
  response.Write(*transport);
}

    
/////////////////////////////////////////////////////////////////////////////