q931.cxx

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

        }
        else {
          len++; // Allow for protocol discriminator
          data[offset++] = (BYTE)discriminator;
          data[offset++] = (BYTE)(len >> 8);
          data[offset++] = (BYTE)len;
          len--; // Then put the length back again
          // We shall assume that the user-user field is an ITU protocol block (5)
          data[offset++] = 5;
        }

        memcpy(&data[offset], (const BYTE *)informationElements[discriminator], len);
        offset += len;
      }
      else
        data[offset++] = (BYTE)discriminator;
    }
  }

  return data.SetSize(offset);
}


static PString Q931IENameString(int number)
{
  switch (number) {
    case Q931::BearerCapabilityIE :
      return "Bearer-Capability";
    case Q931::CauseIE :
      return "Cause";
    case Q931::FacilityIE :
      return "Facility";
    case Q931::CallStateIE :
      return "Call-State";
    case Q931::DisplayIE :
      return "Display";
    case Q931::SignalIE :
      return "Signal";
    case Q931::CallingPartyNumberIE :
      return "Calling-Party-Number";
    case Q931::CalledPartyNumberIE :
      return "Called-Party-Number";
    case Q931::UserUserIE :
      return "User-User";
  }
  return psprintf("0x%02x", number);
}


void Q931::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n"
       << setw(indent+24) << "protocolDiscriminator = " << protocolDiscriminator << '\n'
       << setw(indent+16) << "callReference = " << callReference << '\n'
       << setw(indent+7)  << "from = " << (fromDestination ? "destination" : "originator") << '\n'
       << setw(indent+14) << "messageType = " << GetMessageTypeName() << '\n';

  for (unsigned discriminator = 0; discriminator < 256; discriminator++)
    if (informationElements.Contains(discriminator))
      strm << setw(indent+4)
           << "IE: " << Q931IENameString(discriminator) << " = {\n"
           << hex << setfill('0')
           << setprecision(indent+2) << informationElements[discriminator] << '\n'
           << dec << setfill(' ')
           << setw(indent+2) << "}\n";

  strm << setw(indent-1) << "}";
}


PString Q931::GetMessageTypeName() const
{
  switch (messageType) {
    case AlertingMsg :
      return "Alerting";
    case CallProceedingMsg :
      return "CallProceeding";
    case ConnectMsg :
      return "Connect";
    case ConnectAckMsg :
      return "ConnectAck";
    case ProgressMsg :
      return "Progress";
    case SetupMsg :
      return "Setup";
    case SetupAckMsg :
      return "SetupAck";
    case FacilityMsg :
      return "Facility";
    case ReleaseCompleteMsg :
      return "ReleaseComplete";
    case StatusEnquiryMsg :
      return "StatusEnquiry";
    case StatusMsg :
      return "Status";
    case NationalEscapeMsg :
      return "Escape";
    default :
      break;
  }

  return psprintf("<%u>", messageType);
}


void Q931::GenerateCallReference()
{
  static const char LastCallReference[] = "Last Call Reference";

  PConfig cfg("Globals");
  callReference = cfg.GetInteger(LastCallReference);

  if (callReference == 0)
    callReference = PRandom::Number();
  else
    callReference++;

  callReference &= 0x7fff;

  if (callReference == 0)
    callReference = 1;

  cfg.SetInteger(LastCallReference, callReference);
}


BOOL Q931::HasIE(InformationElementCodes ie) const
{
  return informationElements.Contains(POrdinalKey(ie));
}


PBYTEArray Q931::GetIE(InformationElementCodes ie) const
{
  if (informationElements.Contains(POrdinalKey(ie)))
    return informationElements[ie];

  return PBYTEArray();
}


void Q931::SetIE(InformationElementCodes ie, const PBYTEArray & userData)
{
  informationElements.SetAt(ie, new PBYTEArray(userData));
}


void Q931::SetCause(CauseValues value, unsigned standard, unsigned location)
{
  PBYTEArray data(2);
  data[0] = (BYTE)(((standard&3) << 4)|(location&15));
  data[1] = (BYTE)(0x80+value);
  SetIE(CauseIE, data);
}


Q931::CauseValues Q931::GetCause(unsigned * standard, unsigned * location) const
{
  if (!HasIE(CauseIE))
    return ErrorInCauseIE;

  PBYTEArray data = GetIE(CauseIE);
  if (data.GetSize() < 2)
    return ErrorInCauseIE;

  if (standard != NULL)
    *standard = data[0] >> 4;
  if (location != NULL)
    *location = data[0]&15;

  return (CauseValues)data[1];
}


void Q931::SetSignalInfo(SignalInfo value)
{
  PBYTEArray data(1);
  data[0] = (BYTE)value;
  SetIE(SignalIE, data);
}


Q931::SignalInfo Q931::GetSignalInfo() const
{
  if (!HasIE(SignalIE))
    return SignalErrorInIE;

  PBYTEArray data = GetIE(SignalIE);
  if (data.IsEmpty())
    return SignalErrorInIE;

  return (SignalInfo)data[0];
}


void Q931::SetDisplayName(const PString & name)
{
  PBYTEArray bytes((const BYTE *)(const char *)name, name.GetLength()+1);
  SetIE(DisplayIE, bytes);
}


PString Q931::GetDisplayName() const
{
  if (!HasIE(Q931::DisplayIE))
    return PString();

  PBYTEArray display = GetIE(Q931::DisplayIE);
  if (display.IsEmpty())
    return PString();

  return PString((const char *)(const BYTE *)display, display.GetSize());
}


void Q931::SetCallingPartyNumber(const PString & number,
                                 unsigned plan,
                                 unsigned type,
                                 int presentation,
                                 int screening)
{
  PINDEX len = number.GetLength();
  PBYTEArray bytes;
  if (presentation == -1 || screening == -1) {
    bytes.SetSize(len+1);
    bytes[0] = (BYTE)(0x80|((type&7)<<4)|(plan&15));
    memcpy(bytes.GetPointer()+1, (const char *)number, len);
  }
  else {
    bytes.SetSize(len+2);
    bytes[0] = (BYTE)(((type&7)<<4)|(plan&15));
    bytes[1] = (BYTE)(0x80|((presentation&3)<<5)|(screening&3));
    memcpy(bytes.GetPointer()+2, (const char *)number, len);
  }
  SetIE(CallingPartyNumberIE, bytes);
}


BOOL Q931::GetCallingPartyNumber(PString  & number,
                                 unsigned * plan,
                                 unsigned * type,
                                 unsigned * presentation,
                                 unsigned * screening,
                                 unsigned   defPresentation,
                                 unsigned   defScreening) const
{
  number = PString();

  if (!HasIE(CallingPartyNumberIE))
    return FALSE;

  PBYTEArray bytes = GetIE(CallingPartyNumberIE);
  if (bytes.IsEmpty())
    return FALSE;

  if (plan != NULL)
    *plan = bytes[0]&15;

  if (type != NULL)
    *type = (bytes[0]>>4)&7;

  PINDEX offset;
  if (bytes[0] & 0x80) {  // Octet 3a not provided, set defaults
    if (presentation != NULL)
      *presentation = defPresentation;

    if (screening != NULL)
      *screening = defScreening;

    offset = 1;
  }
  else {
    if (presentation != NULL)
      *presentation = (bytes[1]>>5)&3;

    if (screening != NULL)
      *screening = bytes[1]&3;

    offset = 2;
   }

  PINDEX len = bytes.GetSize()-offset;
  memcpy(number.GetPointer(len+1), &bytes[offset], len);

  return !number;
}


void Q931::SetCalledPartyNumber(const PString & number, unsigned plan, unsigned type)
{
  PINDEX len = number.GetLength();
  PBYTEArray bytes(len+1);
  bytes[0] = (BYTE)(0x80|((type&7)<<4)|(plan&15));
  memcpy(bytes.GetPointer()+1, (const char *)number, len);
  SetIE(CalledPartyNumberIE, bytes);
}


BOOL Q931::GetCalledPartyNumber(PString & number, unsigned * plan, unsigned * type) const
{
  number = PString();

  if (!HasIE(CalledPartyNumberIE))
    return FALSE;

  PBYTEArray bytes = GetIE(CalledPartyNumberIE);
  if (bytes.IsEmpty())
    return FALSE;

  if (plan != NULL)
    *plan = bytes[0]&15;

  if (type != NULL)
    *type = (bytes[0]>>4)&7;

  PINDEX len = bytes.GetSize()-1;
  memcpy(number.GetPointer(len+1), &bytes[1], len);

  return !number;
}


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