gkclient.cxx

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

  unsigned retries = endpoint.GetRasRequestRetries();
  while (retries-- > 0) {
    if (!request.Write(*transport))
      return FALSE;

    while (responseHandled.Wait(endpoint.GetRasRequestTimeout())) {
      switch (responseResult) {
        case ConfirmReceived :
          return TRUE;

        case RejectReceived :
          return FALSE;

        case RequestInProgress :
          responseResult = ConfirmReceived;
          // Keep waiting
      }
    }

    PTRACE(2, "RAS\tTimeout on request " << retries);
  }

  return FALSE;
}


BOOL H323Gatekeeper::CheckForResponse(unsigned reqTag, unsigned seqNum)
{
  if (requestTag != reqTag)
    return FALSE;

  if (seqNum == lastSequenceNumber)
    return TRUE;

  PTRACE(3, "RAS\tReceived incorrect sequence number, want "
         << lastSequenceNumber << ", got " << seqNum);
  return FALSE;
}


BOOL H323Gatekeeper::CheckForRejectResponse(unsigned reqTag,
                                            unsigned seqNum,
#if PTRACING
                                            const char * name,
#else
                                            const char *,
#endif
                                            const PASN_Choice & reason)
{
  if (!CheckForResponse(reqTag, seqNum))
    return FALSE;

  PTRACE(1, "RAS\t" << name << " rejected: " << reason.GetTagName());
  responseResult = RejectReceived;
  rejectReason = reason.GetTag();
  return TRUE;
}


BOOL H323Gatekeeper::OnReceiveRequestInProgress(const H225_RequestInProgress & rip)
{
  if (!CheckForResponse(requestTag, rip.m_requestSeqNum))
    return FALSE;

  responseResult = RequestInProgress;

  return TRUE;
}


BOOL H323Gatekeeper::Discover(const H323TransportAddress & address)
{
  H323RasPDU request;
  H225_GatekeeperRequest & grq = request.BuildGatekeeperRequest(++lastSequenceNumber);
  endpoint.SetEndpointTypeInfo(grq.m_endpointType);
  transport->SetUpTransportPDU(grq.m_rasAddress, TRUE);

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

  OnSendGatekeeperRequest(grq);

  discoveryComplete = FALSE;

  requestTag = request.GetTag();

  unsigned retries = endpoint.GetGatekeeperRequestRetries();
  while (!transport->DiscoverGatekeeper(*this, request, address)) {
    if (--retries == 0)
      return FALSE;
  }

  if (!discoveryComplete)
    return FALSE;

  if (transport->Connect())
    transport->AttachThread(new H225RasThread(endpoint, *this));

  return TRUE;
}


BOOL H323Gatekeeper::OnReceiveGatekeeperConfirm(const H225_GatekeeperConfirm & gcf)
{
  if (!CheckForResponse(H225_RasMessage::e_gatekeeperRequest, gcf.m_requestSeqNum))
    return FALSE;

  locatedAddress = gcf.m_rasAddress;
  PTRACE(2, "H225\tGatekeeper discovery found " << locatedAddress);

  if (!transport->SetRemoteAddress(locatedAddress)) {
    PTRACE(2, "H225\tInvalid gatekeeper discovery address: \"" << locatedAddress << '"');
  }

  discoveryComplete = TRUE;
  return TRUE;
}


BOOL H323Gatekeeper::RegistrationRequest(BOOL autoReg)
{
  autoReregister = autoReg;

  H323RasPDU request;
  H225_RegistrationRequest & rrq = request.BuildRegistrationRequest(++lastSequenceNumber);
  rrq.m_discoveryComplete = discoveryComplete;
  discoveryComplete = FALSE;

  rrq.m_rasAddress.SetSize(1);
  transport->SetUpTransportPDU(rrq.m_rasAddress[0], TRUE);

  const H323ListenerList & listeners = endpoint.GetListeners();
  if (listeners.IsEmpty()) {
    PTRACE(1, "RAS\tCannot register with Gatekeeper without a H323Listener!");
    return FALSE;
  }

  for (PINDEX i = 0; i < listeners.GetSize(); i++)
    listeners[i].SetUpTransportPDU(rrq.m_callSignalAddress, rrq.m_rasAddress[0]);

  endpoint.SetEndpointTypeInfo(rrq.m_terminalType);
  endpoint.SetVendorIdentifierInfo(rrq.m_endpointVendor);

  if (endpoint.IsTerminal()) {
    rrq.IncludeOptionalField(H225_RegistrationRequest::e_terminalAlias);
    rrq.m_terminalAlias.SetSize(1);
    H323SetAliasAddresses(endpoint.GetAliasNames(), rrq.m_terminalAlias);
  }

  if (!gatekeeperIdentifier) {
    rrq.IncludeOptionalField(H225_RegistrationRequest::e_gatekeeperIdentifier);
    rrq.m_gatekeeperIdentifier = gatekeeperIdentifier;
  }

  if (!endpointIdentifier.IsEmpty()) {
    rrq.IncludeOptionalField(H225_RegistrationRequest::e_endpointIdentifier);
    rrq.m_endpointIdentifier.SetValue(endpointIdentifier);
  }

  if (isRegistered) {
    rrq.IncludeOptionalField(H225_RegistrationRequest::e_keepAlive);
    rrq.m_keepAlive = TRUE;
  }

  OnSendRegistrationRequest(rrq);

  PWaitAndSignal mutex(makeRequestMutex);

  return MakeRequest(request);
}


BOOL H323Gatekeeper::OnReceiveRegistrationConfirm(const H225_RegistrationConfirm & rcf)
{
  if (!CheckForResponse(H225_RasMessage::e_registrationRequest, rcf.m_requestSeqNum))
    return FALSE;

  isRegistered = TRUE;

  gatekeeperIdentifier = rcf.m_gatekeeperIdentifier;
  rcf.m_endpointIdentifier.GetValue(endpointIdentifier);

  if (rcf.HasOptionalField(H225_RegistrationConfirm::e_timeToLive))
    timeToLive = PTimeInterval(0, rcf.m_timeToLive);
  else
    timeToLive.Stop();

  // At present only support first call signal address to GK
  if (rcf.m_callSignalAddress.GetSize() > 0)
    gkRouteAddress = rcf.m_callSignalAddress[0];

  pregrantMakeCall = pregrantAnswerCall = RequireARQ;
  if (rcf.HasOptionalField(H225_RegistrationConfirm::e_preGrantedARQ)) {
    if (rcf.m_preGrantedARQ.m_makeCall)
      pregrantMakeCall = rcf.m_preGrantedARQ.m_useGKCallSignalAddressToMakeCall
                                                      ? PreGkRoutedARQ : PregrantARQ;
    if (rcf.m_preGrantedARQ.m_answerCall)
      pregrantAnswerCall = rcf.m_preGrantedARQ.m_useGKCallSignalAddressToAnswer
                                                      ? PreGkRoutedARQ : PregrantARQ;
  }

  // Remove the endpoint aliases that the gatekeeper did not like and add the
  // ones that it really wants us to be.
  if (rcf.HasOptionalField(H225_RegistrationConfirm::e_terminalAlias)) {
    const PStringList & currentAliases = endpoint.GetAliasNames();
    PStringList aliasesToChange;
    PINDEX i, j;
    for (i = 0; i < currentAliases.GetSize(); i++) {
      for (j = 0; j < rcf.m_terminalAlias.GetSize(); j++) {
        if (currentAliases[i] == H323GetAliasAddressString(rcf.m_terminalAlias[j]))
          break;
      }
      if (j >= rcf.m_terminalAlias.GetSize())
        aliasesToChange.AppendString(currentAliases[i]);
    }
    for (i = 0; i < aliasesToChange.GetSize(); i++) {
      PTRACE(2, "H225\tGatekeeper removal of alias \"" << aliasesToChange[i] << '"');
      endpoint.RemoveAliasName(aliasesToChange[i]);
    }

    aliasesToChange.RemoveAll();

    for (i = 0; i < rcf.m_terminalAlias.GetSize(); i++) {
      PString alias = H323GetAliasAddressString(rcf.m_terminalAlias[i]);
      for (j = 0; j < currentAliases.GetSize(); j++) {
        if (alias == currentAliases[j])
          break;
      }
      if (j >= currentAliases.GetSize())
        aliasesToChange.AppendString(alias);
    }
    for (i = 0; i < aliasesToChange.GetSize(); i++) {
      if (!aliasesToChange[i].IsEmpty()) {
        PTRACE(2, "H225\tGatekeeper add of alias \"" << aliasesToChange[i] << '"');
        endpoint.AddAliasName(aliasesToChange[i]);
      }
    }
  }

  return TRUE;
}


void H323Gatekeeper::RegistrationTimeToLive(PTimer &, INT)
{
  PTRACE(3, "RAS\tTime To Live reregistration");

  RegistrationRequest(autoReregister);
}


BOOL H323Gatekeeper::UnregistrationRequest(int reason)
{
  H323RasPDU request;
  H225_UnregistrationRequest & urq = request.BuildUnregistrationRequest(++lastSequenceNumber);

  H225_TransportAddress rasAddress;
  transport->SetUpTransportPDU(rasAddress, TRUE);

  const H323ListenerList & listeners = endpoint.GetListeners();
  for (PINDEX i = 0; i < listeners.GetSize(); i++)
    listeners[i].SetUpTransportPDU(urq.m_callSignalAddress, rasAddress);

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

  if (!gatekeeperIdentifier) {
    urq.IncludeOptionalField(H225_UnregistrationRequest::e_gatekeeperIdentifier);
    urq.m_gatekeeperIdentifier = gatekeeperIdentifier;
  }

  if (!endpointIdentifier.IsEmpty()) {
    urq.IncludeOptionalField(H225_UnregistrationRequest::e_endpointIdentifier);
    urq.m_endpointIdentifier.SetValue(endpointIdentifier);
  }

  if (reason >= 0) {
    urq.IncludeOptionalField(H225_UnregistrationRequest::e_reason);
    urq.m_reason = reason;
  }

  OnSendUnregistrationRequest(urq);

  PWaitAndSignal mutex(makeRequestMutex);

  return MakeRequest(request);
}


BOOL H323Gatekeeper::OnReceiveUnregistrationConfirm(const H225_UnregistrationConfirm & ucf)
{
  if (!CheckForResponse(H225_RasMessage::e_unregistrationRequest, ucf.m_requestSeqNum))
    return FALSE;

  isRegistered = FALSE;
  timeToLive.Stop();

  return TRUE;
}


BOOL H323Gatekeeper::OnReceiveUnregistrationRequest(const H225_UnregistrationRequest & urq)
{
  PTRACE(2, "RAS\tUnregistration received");
  endpoint.ClearAllCalls(H323Connection::EndedByGatekeeper, FALSE);

  PTRACE(3, "RAS\tUnregistered, calls cleared");
  isRegistered = FALSE;
  timeToLive.Stop();

  H323RasPDU response;
  response.BuildUnregistrationConfirm(urq.m_requestSeqNum);
  if (!response.Write(*transport))
    return FALSE;

  if (autoReregister) {
    PTRACE(3, "RAS\tReregistering");
    RegistrationRequest(TRUE);
  }

  return TRUE;
}


BOOL H323Gatekeeper::LocationRequest(const PString & alias,
                                     H323TransportAddress & address)
{
  PStringList aliases;
  aliases.AppendString(alias);
  return LocationRequest(aliases, address);
}


BOOL H323Gatekeeper::LocationRequest(const PStringList & aliases,
                                     H323TransportAddress & address)
{
  H323RasPDU request;
  H225_LocationRequest & lrq = request.BuildLocationRequest(++lastSequenceNumber);