Diameter Protocol Examples¶

// Request authentication vectors from HSS
const airRequest = {
  sessionId: `mme.example.com;${Date.now()}`,
  originHost: 'mme.example.com',
  originRealm: 'example.com',
  destinationRealm: 'hss.example.com',
  userName: '123450000000001', // IMSI
  visitedPLMNId: '234-15',
  authSessionState: 1, // NO_STATE_MAINTAINED
  requestedEUTRANAuthInfo: {
    numberOfRequestedVectors: 1,
    immediateResponsePreferred: true
  }
};

const response = await client.diameter.s6a.sendAIR(airRequest);
console.log('Auth vectors:', response.authenticationInfo.eUtranVector);

// Update subscriber location in HSS
const ulrRequest = {
  sessionId: `mme.example.com;${Date.now()}`,
  originHost: 'mme.example.com',
  originRealm: 'example.com',
  destinationRealm: 'hss.example.com',
  userName: '123450000000001', // IMSI
  ratType: 'EUTRAN',
  ulrFlags: 2, // Skip Subscriber Data
  visitedPLMNId: '234-15',
  authSessionState: 1
};

const response = await client.diameter.s6a.sendULR(ulrRequest);

// Initial credit control request
const ccrRequest = {
  sessionId: `pgw.example.com;${Date.now()}`,
  originHost: 'pgw.example.com',
  originRealm: 'example.com',
  destinationRealm: 'ocs.example.com',
  authApplicationId: 4, // Credit Control
  ccRequestType: 'INITIAL_REQUEST',
  ccRequestNumber: 0,
  subscriptionId: [
    {
      subscriptionIdType: 'END_USER_IMSI',
      subscriptionIdData: '123450000000001'
    },
    {
      subscriptionIdType: 'END_USER_E164',
      subscriptionIdData: '447700900123'
    }
  ],
  serviceInformation: {
    psInformation: {
      sgsnAddress: '10.0.0.1',
      pdpAddress: '192.168.1.1',
      calledStationId: 'internet.example.com',
      sgsnMccMnc: '234-15'
    }
  }
};

const response = await client.diameter.gy.sendCCR(ccrRequest);

// Voice call charging request
const roRequest = {
  sessionId: `ims.example.com;${Date.now()}`,
  originHost: 'ims.example.com',
  originRealm: 'example.com',
  destinationRealm: 'ocs.example.com',
  authApplicationId: 4,
  serviceContextId: 'voice@3gpp.org',
  ccRequestType: 'INITIAL_REQUEST',
  ccRequestNumber: 0,
  eventTimestamp: new Date(),
  subscriptionId: [
    {
      subscriptionIdType: 'END_USER_E164',
      subscriptionIdData: '447700900123'
    }
  ],
  serviceInformation: {
    imsInformation: {
      callingPartyAddress: 'sip:+447700900123@example.com',
      calledPartyAddress: 'sip:+447700900456@example.com',
      roleOfNode: 'ORIGINATING_ROLE',
      nodeFunction: 'S-CSCF'
    }
  },
  multipleServicesIndicator: 1,
  requestedAction: 'DIRECT_DEBITING'
};

const response = await client.diameter.ro.sendCCR(roRequest);

// Policy control request
const gxRequest = {
  sessionId: `pgw.example.com;${Date.now()}`,
  originHost: 'pgw.example.com',
  originRealm: 'example.com',
  destinationRealm: 'pcrf.example.com',
  authApplicationId: 16777238, // 3GPP Gx
  ccRequestType: 'INITIAL_REQUEST',
  ccRequestNumber: 0,
  subscriptionId: [
    {
      subscriptionIdType: 'END_USER_IMSI',
      subscriptionIdData: '123450000000001'
    }
  ],
  supportedFeatures: [
    {
      vendorId: 10415,
      featureListId: 1,
      featureList: 1
    }
  ],
  networkRequestSupport: 1,
  bearerOperation: 'ESTABLISHMENT',
  ipCanType: 'THREEGPP_GPRS',
  ratType: 'EUTRAN',
  defaultEpsBearerQos: {
    qosClassIdentifier: 9,
    allocationRetentionPriority: {
      priorityLevel: 8,
      preEmptionCapability: 1,
      preEmptionVulnerability: 0
    }
  }
};

const response = await client.diameter.gx.sendCCR(gxRequest);

// Cancel location in MME
const clrRequest = {
  sessionId: `hss.example.com;${Date.now()}`,
  originHost: 'hss.example.com',
  originRealm: 'example.com',
  destinationHost: 'mme.example.com',
  destinationRealm: 'example.com',
  authSessionState: 1,
  userName: '123450000000001',
  cancellationType: 'MME_UPDATE_PROCEDURE'
};

await client.diameter.s6a.sendCLR(clrRequest);

// Configure supported features
const capabilityConfig = {
  originHost: 'mme.example.com',
  originRealm: 'example.com',
  vendorId: 10415, // 3GPP
  productName: 'TelcoAPI-Diameter',
  firmwareRevision: 1,
  applications: [
    {
      authApplicationId: 16777251, // S6a
      vendorSpecificApplicationId: {
        vendorId: 10415,
        authApplicationId: 16777251
      }
    }
  ],
  supportedVendorIds: [10415]
};

await client.diameter.configureCapabilities(capabilityConfig);

// Configure peer load balancing
const loadBalancingConfig = {
  mode: 'round-robin',
  peers: [
    {
      host: 'hss1.example.com',
      port: 3868,
      connectOnDemand: true,
      watchdog: {
        interval: 30000,
        timeout: 10000
      }
    },
    {
      host: 'hss2.example.com',
      port: 3868,
      connectOnDemand: true,
      watchdog: {
        interval: 30000,
        timeout: 10000
      }
    }
  ],
  failover: {
    enabled: true,
    retryCount: 3,
    retryTimeout: 5000
  }
};

await client.diameter.configureLoadBalancing(loadBalancingConfig);

// Enable detailed message tracing
client.diameter.on('message', (msg) => {
  console.log({
    timestamp: new Date().toISOString(),
    direction: msg.direction,
    command: msg.command,
    applicationId: msg.applicationId,
    hopByHopId: msg.hopByHopId,
    endToEndId: msg.endToEndId,
    avps: msg.avps
  });
});

// Monitor performance metrics
client.diameter.on('metrics', (metrics) => {
  console.log({
    timestamp: new Date().toISOString(),
    activeConnections: metrics.activeConnections,
    requestsPerSecond: metrics.requestsPerSecond,
    averageResponseTime: metrics.averageResponseTime,
    failureRate: metrics.failureRate,
    peerStatus: metrics.peerStatus
  });
});

// Monitor peer status
client.diameter.on('peerStatus', (status) => {
  console.log({
    timestamp: new Date().toISOString(),
    peer: status.peer,
    state: status.state,
    lastStateChange: status.lastStateChange,
    connectedDuration: status.connectedDuration
  });
});