KR100436636B1 - 이동 인터넷 프로토콜 네트워크에서 외부 에이젼트 선택을관리하는 시스템 및 방법 - Google Patents

이동 인터넷 프로토콜 네트워크에서 외부 에이젼트 선택을관리하는 시스템 및 방법 Download PDF

Info

Publication number
KR100436636B1
KR100436636B1 KR10-2002-0033243A KR20020033243A KR100436636B1 KR 100436636 B1 KR100436636 B1 KR 100436636B1 KR 20020033243 A KR20020033243 A KR 20020033243A KR 100436636 B1 KR100436636 B1 KR 100436636B1
Authority
KR
South Korea
Prior art keywords
pdsn
mobile
ext
message
node
Prior art date
Application number
KR10-2002-0033243A
Other languages
English (en)
Other versions
KR20020095449A (ko
Inventor
그레고리케이. 루이스
프레드릭제이. 딕슨
아비섹 샤르마
잉천 수
Original Assignee
3콤 코포레이션
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Family has litigation
First worldwide family litigation filed litigation Critical https://patents.darts-ip.com/?family=25378910&utm_source=google_patent&utm_medium=platform_link&utm_campaign=public_patent_search&patent=KR100436636(B1) "Global patent litigation dataset” by Darts-ip is licensed under a Creative Commons Attribution 4.0 International License.
Application filed by 3콤 코포레이션 filed Critical 3콤 코포레이션
Publication of KR20020095449A publication Critical patent/KR20020095449A/ko
Application granted granted Critical
Publication of KR100436636B1 publication Critical patent/KR100436636B1/ko

Links

Classifications

    • H—ELECTRICITY
    • H04—ELECTRIC COMMUNICATION TECHNIQUE
    • H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
    • H04L12/00—Data switching networks
    • H04L12/28—Data switching networks characterised by path configuration, e.g. LAN [Local Area Networks] or WAN [Wide Area Networks]
    • H—ELECTRICITY
    • H04—ELECTRIC COMMUNICATION TECHNIQUE
    • H04W—WIRELESS COMMUNICATION NETWORKS
    • H04W48/00—Access restriction; Network selection; Access point selection
    • H04W48/17—Selecting a data network PoA [Point of Attachment]
    • H—ELECTRICITY
    • H04—ELECTRIC COMMUNICATION TECHNIQUE
    • H04W—WIRELESS COMMUNICATION NETWORKS
    • H04W48/00—Access restriction; Network selection; Access point selection
    • H—ELECTRICITY
    • H04—ELECTRIC COMMUNICATION TECHNIQUE
    • H04W—WIRELESS COMMUNICATION NETWORKS
    • H04W80/00—Wireless network protocols or protocol adaptations to wireless operation
    • H04W80/04—Network layer protocols, e.g. mobile IP [Internet Protocol]
    • H—ELECTRICITY
    • H04—ELECTRIC COMMUNICATION TECHNIQUE
    • H04W—WIRELESS COMMUNICATION NETWORKS
    • H04W8/00—Network data management
    • H04W8/02—Processing of mobility data, e.g. registration information at HLR [Home Location Register] or VLR [Visitor Location Register]; Transfer of mobility data, e.g. between HLR, VLR or external networks
    • H04W8/06—Registration at serving network Location Register, VLR or user mobility server

Landscapes

  • Engineering & Computer Science (AREA)
  • Computer Networks & Wireless Communication (AREA)
  • Signal Processing (AREA)
  • Computer Security & Cryptography (AREA)
  • Mobile Radio Communication Systems (AREA)
  • Data Exchanges In Wide-Area Networks (AREA)

Abstract

이동 클라이언트에 인터넷 프로토콜 통신 서비스를 제공하는 시스템 및 방법이 제시된다. 하나의 방법은 무선 노드의 서비스 영역내의 이동 클라이언트 탐지에 응답하여 무선 노드로부터 제어 노드로 등록 요청을 전송하는 것을 포함한다. 제어노드가 무선 노드로부터 상기 요청을 수신하면, 제어 노드는 통신 서비스를 이동 클라이언트에 제공하기 위해 외부 에이젼트를 결정한다. 일 실시예에서, 상기 제어노드는 이동 클라이언트 정보 레코드, 무선 노드 레코드, 및 무선 노드와 관련된 복수의 외부 에이젼트 레코드들에 기반하여 외부 에이젼트를 결정한다. 일 실시예에서, 상기 제어노드는 이동 클라이언트와 관련된 최종 서빙 외부 에이젼트를 선택한다. 대안적으로, 제어노드가 상기 최종 서비 외부 에이전트가 아닌 다른 외부 에이젼트를 선택하면, 상기 제어노드는 상기 최종 서빙 외부 에이젼트에 등록 갱신 메세지를 전송하여 상기 최종 서빙 외부 에이젼트가 상기 이동 클라이언트와 관련된 임의의 통신 세션을 종결시키도록 한다.

Description

이동 인터넷 프로토콜 네트워크에서 외부 에이젼트 선택을 관리하는 시스템 및 방법{SYSTEM AND METHOD FOR MANAGING FOREIGN AGENT SELECTIONS IN A MOBILE INTERNET PROTOCOL NETWORK}
본 발명은 이동 네트워크 프로토콜(IP) 네트워크에서의 통신과 관련된 것이다. 특히 본 발명은 이러한 네트워크에서 외부 에이젼트를 관리하는 중앙노드를 제공하는 것과 관련된다.
공중 패킷 교환 네트워크는 이동 호스트, 또는 하나의 네트워크에서 다른 네트워크로 접속 포인트를 변경시키는 라우터와 같은 이동 통신 장치(이동 노드)들 간의 트래픽 전달을 위해 사용될 수 있다. 이동 IP 데이타 네트워킹의 기본 구조는 www.itef.orf 에서 현재 제공되고 있는 Request for Comments(RFC) document RFC 2002(1996)(이하 "RFC 2002")를 포함하여 다수의 공표물들에서 설명되어 있고, 공지되어 있다. IP 데이타 네트워킹의 당업자는 이동 IP 데이타 네트워킹을 실제로 구현하는데 있어 이러한 문서 및 장치를 잘 이해할 것이다.
이동 IP 통신 네트워크에서, 이동 노드는 "외부(foreign) 에이젼트" 및 " 홈(home) 에이젼트" 라는 2개의 장치를 통해 IP 네트워크에서 타켓 호스트와 통신한다. 이러한 타입의 통신을 기술하는 이동 IP 네트워크의 일 예는 미국 출원 번호 09/354,659, 제목 "MOBILE INTERNET PROTOCOL(IP) NETWORKING WITH HOME AGENT AND/OR FOREIGN AGENT FUNCTIONS DISTRIBUTED AMONG MULTIPLE DEVICES" 에 제시되어 있고, 그 내용은 본 명세서에서 참조된다. 일반적으로, 외부 에이젼트의 기능은 이동 노드 방문 네트워크 상의 라우터에 통합된다. 외부 에이젼트는 이동 노드가 홈 에이젼트에 동록되는 동안 이동 노드에 대한 라우팅 서비스를 제공한다. 예를 들어, 외부 에이젼트가 이동 노드의 홈 에이젼트에 의해 터널(tunnel)된 데이타그램들을 이동 노드로 디-터널(de-tunnel) 및 전달한다.
일반적으로 홈 에이젼트는 이동 노드의 홈 네트워크상의 라우터에 통합된다.홈 에이젼트는 이동 노드에 대한 현재 위치 정보를 유지한다. 하나 또는 그 이상의 홈 에이젼트들이 다중 이동 노드들에 대해 동시에 호출을 처리하는 경우, 홈 에이젼트들은 본질적으로 가상 사설 네트워크 서비스와 유사한 서비스를 제공한다. 각 이동 노드는 일반적으로 개별 홈 네트워크와 관련되고 홈 에이젼트를 통한 홈 네트워크로부터 외부 에이젼트로의 라우팅 경로는 이동 노드에 대한 가상 사설 네트워크와 유사하다.
이동 IP는 이동 노드(이동 엔티티) 및 외부 에이젼트 사이의 링크 계층 접속을 요구한다. 그러나, 일부 시스템에서 이동 노드로부터의 링크 계층은 외부 에이젼트로부터 떨어진 지점에서 종료될 수 있다. 이러한 네트워크들은 일반적으로 제3세대 무선 네트워크로 언급된다. 도1은 제3 세대 무선 네트워크에서 사용되는 네트워크 구조를 보여주는 블록 다이아그램이다. 도1을 살펴보면, 이동 노드(10)는 3개 장치, 즉 무선 네트워크 노드(16), 패킷 데이타 서빙 노드(18), 및 홈 에이젼트 노드(24)를 통해 IP 네트워크(30) 상의 타겟 호스트(34)와 통신한다. 이동 노드(10)의 물리 계층은 무선 네트워크 노드(16)에서 종결되고, 외부 에이젼트의 기능성은 패킷 데이타 서빙 노드(18)에 존재한다. 일반적으로, 무선 네트워크 노드(16)는 이동 노드(10) 및 패킷 데이타 서빙 노드(18) 사이의 링크 계층 프로토콜 데이타를 중계하고, 패킷 데이타 서빙 노드(18)는 이동 노드(10)에 대한 링크 계층을 설정, 유지 및 종결한다. 예를 들어, 이동 노드(10)는 무선 접속 네트워크 상의 통신 링크를 통해 무선 네트워크 노드(16)에 링크될 수 있다.
패킷 데이타 서빙 노드(18)는 이동 노드가 홈 에이젼트(24)에 등록되는 동안이동노드(10)에 대한 라우팅 서비스를 제공한다. 패킷 데이타 서빙 노드(18)는 IP 네트워크(20)를 통해 홈 에이젼트 노드(24)로부터 터널된 데이타그램들을 이동 노드로 디-터널 및 전달한다. 패킷 데이타 서빙 노드(16) 및 홈 에이젼트(24) 사이에 교환된 통신 트래픽은 데이타 트래픽 및 제어 트래픽을 포함한다. 제어 트래픽은 등록 요청 또는 등록 응답 메세지를 포함한다. 데이타 트래픽이 이동 노드(10) 및 타겟 호스트(34) 사이에서 라우팅되는 동안 제어 트래픽은 홈 에이젼트(24) 및 패킷 데이타 서빙 노드(16)에서 종결된다. 타겟 호스트(34)는 IP 네트워크들(20 및 30)과 같은 임의의 네트워크들에 의해 홈 네트워크(26)와 접속될 수 있고, 홈 네트워크(26)에 직접 위치될 수도 있다. 대안적으로, 타겟 호스트(34)는 다른 타입의 패킷 교환 네트워크들에 의해 홈 네트워크와 접속될 수도 있다.
홈 에이젼트(24)는 이동 노드의 홈 네트워크(26) 상의 라우터에서 구현될 수 있다. 홈 에이젼트(24)는 외부 에이젼트 어드레스, 이동 홈 어드레스 및 홈 에이젼트 및 홈 노드 사이에서 공유되는 기밀키와 같은 이동 노드(10)에 대한 현재 위치 정보 데이타를 유지한다. 홈 에이젼트는 타겟 호스트(34)로부터 패킷 데이타 서빙 노드(18)로 데이타를 터널하고, 유사하게 반대방향으로의 터널링을 제공한다. 계층 2 터널링 프로토콜(L2TP) 터널과 같은 점대점 터널상의 추가적인 정보는 www.ietf.org 에서 현재 제공되는 RFC 2661에서 제공된다. 따라서 홈 에이젼트(24)는 일반적으로 이동 노드(10)에 대한 적어도 2개의 임무를 실행한다. 첫째, 홈 에이젼트(24)는 이동 노드(10)가 홈 네트워크(26) 접속이 인증되었는지 여부를 결정하기 위해 등록 및 인증 프로세스를 수행한다. 이는 예를 들어, 이동엔티티의 고유 번호 또는 제조 번호를 통해 이동 엔티티의 ID 및 패스워드 인증 검사 및 이동 엔티티 계좌가 현재 지불 가능한 지 여부를 검사하는 것을 포함한다. 홈 에이젼트 등록 및 인증 기능은 원격 인증 다이알 인 사용자 서비스(RADIUS) 서버와 같은 인증, 허가 및 회계 서버와 같은 제2 장치를 이용하여 수행될 수 있다. RADIUS 서버에 대한 추가적인 정보는 www.ietf.org 에서 제공되는 RFC-2138에서 제공된다. 당업자에게 알려지듯이, 등록 프로세스는 패킷 데이타 서빙 노드(18)로부터의 등록 요청 메세지의 수신 및 처리 그리고 패킷 데이타 서빙 노드(18)로의 등록 응답 메세지 전송을 포함한다.
홈 에이젼트(24)와 유사하게, 패킷 데이타 서빙 노드(18)는 이동 노드(10)에 대한 2개의 임무를 수행한다. 패킷 데이타 서빙 노드(18)는 홈 에이젼트(24)로 등록 요청 메세지 전송 및 홈 에이젼트(24)로 부터 수신된 등록 응답 메세지 처리를 포함하여, 이동 노드(10)에 대한 등록 및 세션 제어를 처리한다. 또한, 패킷 데이타 서빙 노드(18)는 타겟 호스트(34)로의 궁극적인 전송을 위해 홈 에이젼트(24)로 데이타 패킷 전송이라는 터널링 책임 및 이동 노드(10)로의 궁극적인 전달을 위한 홈 에이젼트(24)로부터의 데이타 디-터널링 책임을 갖는다. 게다가, 패킷 데이타 서빙 노드(18)는 이동 노드(10)에 대한 인증, 허가 및 회계 서비스를 제공한다. 홈 에이젼트 노드(24)와 유사하게, 패킷 데이타 서빙 노드는 RADIUS 서버와 같은 인증, 허가 및 회계 서버를 사용하여 인증, 허가 및 회계 기능을 수행한다.
무선 통신 링크를 통해 호출 셋업 지시를 무선 네트워크 노드(16)에 전송함으로써 이동 노드(10)는 무선 네트워크 노드(16)를 통해 통신 세션을 개시할 때,무선 네트워크 노드(16)는 패킷 데이타 서빙 노드(18)를 통해 등록 프로세스를 개시한다. 일반적으로, 무선 네트워크 노드(16)는 이동 노드(10)에 서비스들을 제공하는 다수의 패킷 데이타 서빙 노드로 구현된다. 선행기술에서, 무선 네트워크 노드(16)는 무선 네트워크 노드(16)와 동작하도록 구현된 임의의 패킷 데이타 서빙 노드들에 대한 상태 정보를 가지고 있지 않다. 따라서, 무선 네트워크 노드(16)가 이동 노드(10)에 대한 등록 프로세스를 개시할 때, 무선 네트워크 노드(16)는 이동 노드(10)에 대한 패킷 데이타 서빙 노드를 랜덤하게 선택한다. 이러한 시스템에서, 무선 네트워크 노드에 제공되는 일부 패킷 데이타 서빙 노드들은 다른 것들이 거의 사용되지 않는 동안 빠르게 오버로드될 수 있다. 게다가, 무선 네트워크 노드(16)가 등록 요청를 전송하는 다수의 연속적인 패킷 데이타 서빙 노드들이 오버로드되면, 이러한 패킷 데이타 서빙 노드는 무선 네트워크 노드(16)로부터의 등록 요청을 대부분 거절하고, 따라서 이동 노드(10)에 대한 서비스 지연을 초래하게 된다.
따라서, 기존의 IP 네트워크들과 관련된 문제들은 무선 네트워크 노드에 의한 비효율적인 패킷 데이터 서빙 노드의 선택과 관련된다. 예를 들어, 상기에서 언급한 바와 같이, 무선 네트워크 노드(16)가 이동 노드(10)에 대한 등록 프로세스를 개시할 때, 무선 네트워크 노드(16)는 이동 노드(10)에 서비스를 제공하기 위해 패킷 데이타 서빙 노드(18)를 랜덤하게 선택한다.
따라서, 이동 IP 네트워크에서 효율적으로 패킷 데이타 서빙 노드를 선택하는 방법 및 시스템에 대한 필요성이 존재한다.
도1은 공지된 이동 IP 네트워크 구조를 제시하는 블록 다이아그램이다.
도2는 본 발명의 실시예에 따른 이동 IP 네트워크 구조를 제시하는 블록 다이아그램이다.
도3은 본 발명의 일 실시예에 따른 외부 에이젼트 제어 노드에서의 외부 에이젼트 발견 프로세스의 예시적인 방법을 보여주는 흐름도이다.
도4는 하트비트 메세지를 사용하여 외부 에이젼트 제어노드에서 외부 에이젼트들을 발견하는 예시적인 메세지 흐름을 보여주는 본 발명의 일 실시예에 다른 메세지 시퀀스 시나리오를 보여주는 도이다.
도5는 본 발명의 일 실시예에 따라 외부 에이젼트로부터 외부 에이젼트 제어 노드로 전송된 메세지에 대한 하트비트 메시지 포맷의 예를 보여주는 블록 다이아그램이다.
도6은 본 발명의 일 실시예에 따라 외부 에이젼트 제어노드로부터 외부 에이젼트로 전송된 메세지에 대한 하트비트 메시지 포맷의 예를 보여주는 블록 다이아그램이다.
도7은 본 발명의 일 실시예에 따라 무선 네트워크 노드의 구현을 보여주는 흐름도이다.
도8A 및 8B는 본 발명의 일 실시예에 따라 외부 에이젼트 제어 노드에서 외부 에이젼트를 선택하는 방법을 보여주는 흐름도이다.
도9는 본 발명의 일 실시예에 따라 외부 에이젼트 제어노드에서 외부 에이젼트를 선택하는 메세지 흐름을 보여주는 메세지 시퀀스 시나리오에 관한 도이다.
도10A, 10B 및 10C는 본 발명의 일 실시예에 따라 외부 에이젼트와 관련된 이동 노드를 인증하는 방법를 보여주는 흐름도이다.
도11은 제어노드에서 선택된 외부 에이젼트를 통해 이동 노드의 최초 이동 인터넷 프로토콜 등록에 대한 메세지 흐름을 보여주는 메세지 시퀀스 시나리오와 관련된 도이다.
도12는 제어 노드에서 선택된 외부 에이젼트를 통해 이동 노드의 최초의 간단한 인터넷 프로토콜 등록에 대한 메세지 흐픔을 보여주는 메세지 시퀀스 시나리오에 관련된 도이다.
도13은 외부 에이젼트들 간의 이동 노드 핸드오프를 보여주는 메세지 시퀀스 시나리오에 관한 도이다.
IP 네트워크에서 패킷 데이타 서빙 노드 선택을 위한 시스템 및 방법이 제시된다.
인터넷 프로토콜 통신 서비스를 제공하는 방법에 대한 실시예는 이동 노드와 같은 클라이언트 장치와 관련된 통신 세션을 무선 노드와 같은 제1 네트워크 장치에서 탐지하고, 이러한 통신 세션 탐지에 응답하여 제1 네트워크 장치로부터 제어 네트워크 엔티티와 같은 제2 네트워크 장치로 등록 요청을 포함한 제1 메세지를 전송하는 것을 포함한다. 제2 네트워크 장치가 등록 요청을 수신하면, 제2 네트워크 장치는 클라이언트 장치에 네트워크 서비스를 제공하기 위해 배열된 제2 네트워크 장치의 네트워크 어드레스를 결정한다. 제3 네트워크 장치의 네트워크 어드레스 결정에 응답하여, 제2 네트워크 장치는 제3 네트워크 장치의 네트워크 어드레스를 포함하는 제1 응답 메세지를 제1 네트워크 장치로 전송한다. 제3 네트워크 장치가 제1 응답 메세지를 수신하면, 통신 세션이 클라이언트 네트워크 장치 및 제3 네트워크 장치 사이에서 설정된다.
일 실시예에서, 제2 네트워크 장치가 등록 요청을 메세지를 수신하면, 제2 네트워크 장치는 클라이언트 장치가 적어도 하나의 활성 통신 세션과 관련되는지 여부를 결정한다. 그러하다면, 제2 네트워크 장치는 클라이언트 장치에 통신 서비스를 제공하는 최종 네트워크 장치를 결정한다. 최종 네트워크 장치 결정에 응답하여, 제2 네트워크 장치는 최종 서빙 노드가 클라이언트 장치에 제공되는지 및 그것이 제1 네트워크 장치와 관련되는지 여부를 결정한다. 그러하다면, 제2 네트워크 장치는 최종 서빙 장치의 네트워크 어드레스를 제1 네트워크 장치에 전송하고, 최종 서빙 장치는 통신 서비스를 클라이언트 장치에 계속해서 제공한다. 최종 서빙 네트워크가 클라이언트 장치에 제공되지 않으면, 제2 네트워크 장치는 클라이언트 장치에 통신 서비스들을 제공하기 위해 새로운 네트워크 장치를 결정하고 새로운 네트워크 장치의 네트워크 어드레스를 등록 응답 메세지에서 제1 네트워크 장치로 전송한다. 또한, 제2 네트워크 장치는 갱신 메세지를 최종 서빙 네트워크에 전송하여 클라이언트 장치의 핸드오프에 관련하여 최종 서빙 네트워크 장치를 새로운 네트워크 장치에 통보한다. 갱신 메세지 수신에 응답하여, 최종 서빙 노드는 클라이언트 네트워크 장치와 관련된 임의의 통신 세션을 종결한다.
본 발명의 상기 내용 및 다른 양상과 장점들은 도면을 참조하여 실시예를 통해 상세히 기술될 것이다.
도2는 본 발명에 따라 이동 IP 네트워크에서 이동 노드들에 대한 외부 에이젼트들을 선택하는데 적합한 선호되는 네트워크 구조의 실시예를 보여주는 기능적 블록 다이아그램이다. 도2는 제3 세대 이동 IP 네트워크에서 일반적으로 사용되는 네트워크 엔티티이다; 그러나, 본 발명은 이러한 네트워크 구조로 제한되지 않으며, 여기서 기술된 방법 및 장치는 기존 또는 차후에 개발되는 이동 IP 시스템에서 외부 에이젼트 선택을 관리하는데 적용될 수 있음을 이해하여야 한다. 도2를 참조하면, 이동 노드(210)와 같은 클라이언트 장치는 타겟 호스트(34)와 같은 원격 클라이언트 장치와 IP 네트워크(30) 상에서 통신한다. 이동 노드(210)는 무선노드(216)와 같은 제1 네트워크 장치와 무선 접속(238)을 통해 무선 접속 네트워크에서 연결된다. 일 실시예에서, 무선 노드는 무선 네트워크 노드(RNN), 기지국 제어(BSC) 노드 또는 패킷 제어 노드(PCN) 등을 포함한다. 도1에서 제시되듯이, 무선 노드는 여기서 무선 네트워크 노드로 언급된다. 본 발명의 일 실시예에 따라, 무선 네트워크 노드(216)는 제2 네트워크 장치, 외부 에이젼트 제어 노드(FACN)(220) 및 복수의 패킷 데이타 서빙 노드(PDSN)들과 통신한다. FACN(220)은 이동 IP 등록을 위한 패킷 데이타 서빙 노드 선택과 같은 외부 에이젼트 선택을 관리한다. FACN(220)은 여기서 "제어노드", "외부 에이젼트 제어 노드" 로 언급되고, PDSN들은 "외부 에이젼트"로 언급된다.
FACN(220)은 무선 네트워크 노드(216)와 같은 무선 네트워크 노드들과 통신하기 위해 무선 노드 이동 IP 인터페이스(224)를 포함한다. 무선 네트워크 노드(216)가 이동 노드(210)로부터 호출 셋 업 요청을 탐지하면, 무선 네트워크 노드(216)는 무선 네트워크 노드 인터페이스(224) 상에서 FACN(220)으로부터 이동 등록 서비스를 요청한다. FACN(220)이 등록 요청을 수신하면, FACN(220)은 네트워크 서비스를 이동 노드(210)에 제공하기 위해 제3 네트워크 장치를 선택한다. 일 실시예에서, FACN(220)은 일련의 소정 기준을 사용하여 PDSN을 선택하고 선택된 PDSN 네트워크 어드레스를 무선 네트워크 노드(216)로 전송한다. 또한 FACN(220)은 PDSN(232,234,236)과 같은 PDSN 풀(pool)과 통신하기 위해 PDSN 인터페이스(230)를 포함한다. 도2에 제시된 실시예에서, FACN(220)은 PDSN 인터페이스(230)를 통해 FACN-관리 PDSN(232,234,236)과 통신한다. 이러한 PDSN(232,234,236)들은 현재 호출 로드 인자, 처리 유닛 로드 인자, 또는 메모리 로드 인자와 같은 자신의 용량 정보 능력을 PDSN 인터페이스(230)를 통해 제공한다.
특정 일 실시예에서, PDSN 인터페이스(230) 및 RNN 인터페이스(224)는 3Com Corporation of Santa Clara, California 로 부터 상업적으로 이용가능한 토탈 제어 엔터프라이즈 네트워크 허브에서 구현될 수 있다. 이러한 토탈 제어 프로덕트는 공통 버스에 의해 접속되는 다중 네트워크 인터페이스를 포함한다. 본 명세서에서 참조되는 USP 5,528,595, 제목 "MODEM INPUT/OUTPUT PROCESSING SIGNALING TECHIQUES" 를 참조하라. 그러나, 이러한 인터페이스들은 다른 하드웨어 및 소프트웨어 구현을 갖는 다른 장치들에서 구현될 수 있고, 토탈 제어 프로덕트 또는 등가물의 구현으로 제한되지 않는다.
일 실시예에서, FACN(220)은 관리되는 PDSN들의 용량 정보들을 사용하여 새로운 이동 노드 등록을 처리하기 위한 PDSN의 능력을 결정한다. 무선 네트워크 노드(216)가 FACN(220)을 통해 이동 노드(210)를 등록할 때, FACN(220)은 우선 현재 통신 서비스들을 이동 노드에 제공하는 PDSN에 이동 노드(210) 등록을 할당하고자 한다. 그러나, FACN이 이동 노드(210)에 대한 활성 히스토리를 갖지 않거나, 또는 현재 이동 노드(210)를 서빙하는 PDSN 이 무선 네트워크 노드(216)에 대해 이용가능하지 않거나 유효하지 않는 경우, 새로운 PDSN이 무선 네트워크 노드(216) 등록과 관련된 PDSN 풀로부터 선택된다.
도2를 다시 살펴보면, FACN(220)은 추가적으로 메모리 유닛(226)을 포함한다. 메모리 유닛(226)은 휘발성 메모리 유닛(226A) 및 비휘발성 메모리유닛(226B)을 포함한다. 일 실시예에서, FACN(220)이 무선 네트워크 노드 등록 요청 처리를 개시하기 전에, FACN(220)은 다수의 배치 레코드들 또는 비휘발성 메모리 유닛(226B)에 저장되거나 또는 대안적으로 시스템 관리자에 의해 배치 파일에 저장되는 테이블들로 구현된다. 비휘발성 레코드들이 배치 파일에 저장되는 실시예에서, 임의의 뒤이은 FACN 시동들은 배치 파일을 복원한다. FACN(220)의 배치는 명령 라인 인터페이스(CLI) 또는 단순한 네트워크 관리 프로토콜(SNMP) 인터페이스(228)를 통해 이루어질 수 있다. CLI/SNMP 인터페이스(228)는 배치 엔트리들을 추가, 삭제 및 변경하는 방식을 제공한다. 배치를 위한 접속을 제공하는 임의의 타입 인터페이스가 상기 인터페이스(226)에 대한 대안으로서 사용될 수 있다. 일 실시예에서, FACN(220)을 위한 하드웨어 플랫폼은 선 마이크로시스템 네트라 하드웨어 플랫폼을 포함하지만, 이로 제한되지는 않는다.
비휘발성 메모리(226B)내의 배치 테이블들 중 하나는 FACN(220), PDSN(232,234,236), 및 무선 네트워크 노드(216) 사이에서 제어 데이타를 교한하는 포트 번호들을 포함한다. 예를 들어, FACN(220)은 PDSN 및 무선 네트워크 노드(216)와 제어 데이타를 교환하는 사용자 데이타그램 프로토콜(UDP)를 사용한다. FACN(220)은 무선 네트워크 노드(216)와 데이타를 교환하기 위한 UDP 포트 번호(697)를 사용하도록 구현될 수 있다. FACN(220)은 추가로 제어 데이타를 PDSN들과 통신하기 위해 디폴트 UDP 포트들(15000,15001)를 사용하도록 구현될 수 있다. 그러나, 본 발명은 이러한 포트 번호들 사용으로 제한되지 않으며, FACN(220)은 무선 네트워크 노드 및 PDSN들과 제어 데이타를 통신하는 상이한 포트들을 사용할 수도 있음을 이해하여야 한다.
통신 시스템에서 네트워크 엔티티들 사이의 보안 통신은 종종 전송 엔티티를 인증하기 위해 네트워크 엔티티를 수신하는 것을 필요로한다. 네트워크 엔티티들 사이의 보안 통신의 일 예는 통신 네트워크 엔티티들에 의해 공유되는 디티탈 키들의 사용을 포함한다. 이러한 실시예에서, 전송 엔티티는 수신 엔티티에 메세지를 전송할 때, 전송 엔티티는 전송 엔티티 및 수신 엔티티 사이에서 공유되는 보안 키를 사용하여 메세지 요약 알고리즘을 통해 메세지를 런(run)한고 일반적으로 메세지 요약으로 언급되는 값을 발생시킨다. 이러한 메세지 요약은 상기 메세지와 함께 전송 엔티티에서 전송 엔티티가 신뢰된 엔티티인지 여부를 검증하기 위해 상기 메세지 요약을 사용하는 수신 엔티티로 전송된다. 이러한 실시예에서, 수신 엔티티에서 발생된 메세지 요약은 수신 메세지로부터 추출된 것과 매칭되면, 사용자는 신뢰된 엔티티이다. 엔티티들을 인증하는 상기 프로세스는 RFC-2002에 기술되어 있다. 그러나, 여기서 기술된 실시예들은 디지탈 키들의 사용으로 제한되지 않으며, 상이한 또는 등가의 인증 방법이 대안적으로 사용될 수 있다.
다시 도2를 살펴보면, 비휘발성 메모리 유닛(226B)은 바람직하게는 다수의 디지탈 기밀키들을 저장한다. 앞서 언급했듯이, PDSN들은 인증, 허가 및 회계(AAA) 서버(240)를 통해 이동 노드(210)를 인증한다. 따라서, 상기 키들 중 하나는 PDSN 및 AAA 서버상에서 사용되는 AAA-PDSN 보안 키, 예를 들면 접속-요청 또는 접속 수용 메세지를 포함하여 인증 프로세스 동안 2개의 엔티티들 사이에 교환되는 메세지들을 인증한다. AAA 서버(240)는 예를 들면 서비스 공급자 "FUNK"에의해 제공되는 Steel Belted RADIUS, Advanced Wireless Edition(SBR-AWE) 일 수 있다. 일 실시예에서, FACN(220)은 AAA 서버 및 FACN(220)과 관련된 PDSN들 사이에서의 사용을 위한 단일 AAA-PDSN 기밀키를 저장한다. 그러나, 예를 들어 소정 PDSN들 셋들이 하나 또는 그 이상의 AAA 서버들과 통신하기 위한 상이한 기밀키들과 관련되도록 하나 이상의 기밀키가 사용될 수 있다. 예를 들어, AAA-PDSN 기밀키 레코드는 상기 키에 할당된 AAA 서버의 IP 어드레스로 저장된 기밀키를 저장할 수 있다. 테이블 1은 예시적인 FAAA-PDSN 기밀키 레코드를 보여준다.
AAA IP 어드레스 기밀키
AAA의 IP 어드레스 IP 어드레스용 기밀키
테이블 1
유사하게, 비휘발성 메모리 유닛(226B)은 FACN-PDSN 및 무선 네트워크 노드-PDSN 기밀키들을 저장할 수 있다. 일 실시예에서, 하나의 글로벌 기밀키가 FACN(220) 및 FACN(220)과 관련된 모든 PDSN 사이에서의 사용을 위해 정의될 수 있다. 테이블 2는 예시적인 FACN-PDSN 기밀키 기록을 보여준다.
보안 파라미터 인덱스 기밀키
보안 파라미터 인덱스 PDSN/FACN 용 기밀키
테이블 2
유사하게, 무선 네트워크 노드(216) 및 PDSN들은 동일한 기밀키를 사용할 수 있다. 테이블 3은 예시적인 무선 네트워크 노드-PDSN 기밀키 레코드를 보여준다.
보안 파라미터 인덱스 기밀키
보안 파라미터 인덱스 PDSN/무선 네트워크 노드용 기밀키
테이블 3
게다가, 일 실시예에 따라, FACN(220) 시스템 오퍼레이터는 FACN(220)이 서비스할 다수의 PDSN IP 어드레스를 그룹화하고 각 그룹에 텍스트 설명을 할당하여 FACN(220) 상에 관리되는 각 PDSN이 적어도 하나의 그룹에 할당되도록 할 수 있다. 그러나, 본 발명은 시스템 오퍼레이터에 의한 PDSN들의 그룹화로 제한되지 않으며, PDSN들은 FACN(220)에 리포트할 때 디폴트 그룹과 같은 하나 또는 그 이상의 그룹들로 자동적으로 그룹화될 수 있고, 이는 하기에서 상술된다. 테이블 4는 PDSN들을 그룹화하는 레코드 예를 보여주고, 여기서 시스템 오퍼레이터에 의해 특정되는 PDSN의 IP 어드레스는 소정 그룹 번호 또는 그룹 식별자에 할당된다.
PDSN 그룹 # PDSN 그룹 설명 PDSN IP 어드레스 리스트
그룹 번호/그룹 ID 그룹 설명 PDSN IP 어드레스
테이블 4
또한, 처음 FACN 시동시에, 오퍼레이터는 FACN(220)이 서비스할 일련의 무선 네트워크 노드 IP 어드레스들을 배치하는 옵션을 갖는다. 일 실시예에서, 무선 네트워크 노드 레코드는 무선 네트워크 노드 요청들을 서비스하기 위해 선택되는 PDSN 그룹 리스트를 정의할 수 있다. 예를 들어, 오퍼레이터가 적어도 하나의 PDSN 그룹을 무선 네트워크 노드에 할당하지 못하면, 무선 네트워크 노드는 처음으로 FACN(220)을 통해 등록을 시도할 때 디폴트 PDSN 그룹에 할당된다. 테이블 5는 비휘발성 메모리 유닛(226B)에서 예시적인 무선 네트워크 노드-PDSN 그룹 할당 레코드를 예시하고, 여기서 무선 네트워크 노드 IP 어드레스는 하나 또는 그 이상의 PDSN 그룹들에 할당된다.
무선 네트워크 노드 IP 어드레스 PDSN 그룹 리스트
무선 네트워크 노드의 IP 어드레스 PDSN 그룹 번호들 리스트/무선 네트워크 노드용 그룹 ID 들
테이블 5
또한, FACN(220)은 FACN(220)의 동작 단계동안 발생된 다수의 휘발성 레코드들을 유지할 수 있다. 예를 들어, 이러한 레코드들은 휘발성 메모리 유닛(226A) 상에 저장될 수 있다. FACN(220)은 휘발성 PDSN 프로파일 레코드들 및 휘발성 이동 노드 레코드들을 유지할 수 있다. FACN(220)은 PDSN들이 네트워크에서 그들의 존재를 리포트할 때 PDSN 프로파일 레코드들을 발생시킨다. PDSN 프로파일 레코드들은 PDSN들이 비활성이 되거나 또는 새로운 PDSN들이 네트워크에 추가될 때 동적으로 변경된다. 본 발명의 실시예에 따라, PDSN들은 그들의 로드 상태 정보를 주기적 메세지(이하 하트비트 메시지로 언급됨)를 통해 제공하도록 배열된다. 각 PDSN 은 예를 들어, 그 처리 로드 인자, 호출 로드 인자, 및/또는 메모리 로드 인자를 FACN(220)에 주기적으로 전송하도록 배치된다. 예를 들어, PDSN의 처리 로드 인자는 PDSN의 처리 용량과 관련되고, 호출 로드 인자는 PDSN이 현재 서빙하고 있는 호출들의 수와 관련되고, 메모리 로드 인자는 PDSN에서 제공되거나 또는 사용되는 메모리 자원과 관련된다. 본 발명의 일 실시예에 따라, FACN(220)은 PDSN이 더이상 선택을 위해 제공될 수 없는 시기를 정의하는 다수의 임계 레벨들을 가지고 CLI/SNMP 인터페이스(226)를 통해 배치된다. 예를 들어, 호출 밸런스 임계치는 PDSN이 임의의 호출 밸런싱 매커니즘과 독립적으로 새로운 호출을 서비스할 수 있도록 선택되는 호출 레벨을 정의한다. 일 실시예에서, FACN(220)은 예를 들면 100% 처리 로드, 100% 메모리 로드, 및 4000 호출 로드 레벨과 같은 디폴트 임계치 레벨들로 자동적으로 구현될 수 있다. 일 실시예에서, FACN(220)은 다양한 PDSN들 사이에서 변화하는 다수의 임계치들로 구현될 수 있다.
PDSN이 소정의 연속적인 주기들 동안 하트비트 메세지를 전송하지 못하면, FACN(220)은 이용불가능한 PDSN을 식별한다. 다른 임계치와 같이, 이러한 번호는 바람직하게는 "상실 하트비트 카운트" 변수와 같이 PDSN 엔트리에 배열된다. 또한, 각 PDSN 프로파일 레코드는 FACN(220)이 연속적인 하트비트 메세지를 예상하는 시간 간격을 정의하는 존속기간 타이머를 포함한다. 테이블 6은 FACN(220) 연산 단계동안 각 PDSN에 대해 FACN(220) 에서 발생될 수 있는 PDSN 프로파일 레코드의 예를 보여준다.
PDSN 상태 상실된 하트비트 카운트 존속기간 타이머 로드 인자
PDSN IP 어드레스 활성/비활성 상실된 하트비트 메세지의 수 하트비트 메세지 타이머 처리/메모리/호출로딩
테이블 6
또한, FACN(220)은 FACN-관리 PDSN을 통해 사용자 등록시에 FACN(220) 상에서 발생되는 이동 노드 레코드들내의 이동 사용자 정보 데이타를 유지한다. 이동 노드가 FACN-관리 PDSN들 하나를 통해 등록할 때마다, 등록 PDSN은 AAA 프로파일 및 이동 세션 정보와 같은 이동 노드 데이타를 FACN(220)에 전송하여, 이동 노드에 대해 어떠한 레코드도 현재 존재하지 않는 경우에는 FACN(220)은 새로운 이동 사용자 프로파일 레코드를 발생시키고, 이러한 레코드가 이미 존재하는 경우에는, FACN(220)은 이러한 이동 사용자와 관련된 현재 존재하는 레코드를 갱신한다. 또한, 이러한 레코드가 이미 존재하지만 갱신을 전송하는 PDSN이 아닌 다른 PDSN에 대한 레코드가 존재한다면, "PDSN 핸드오프" 가 발생하고, 즉 이동 노드는 하나의 무선 노드에서 원래의 서빙 PDSN과 관련되지 않은 새로운 무선 노드로 이동하며,원래의 PDSN이 이용가능하지 않는 다른 이유는 예를 들면, 그 호출 로드가 초과되거나 또는 하트 비트 메세지를 더 이상 전송하지 못하는 경우이다. 본 발명의 일 실시예에 따라, FACN(220)이 핸드오프를 탐지하면, FACN(220)은 AAA 프로파일 및 이동 세션 정보와 관련된 이전 PDSN에 갱신 메세지를 전송한다. 이러한 메세지를 수신하면, 이전 PDSN은 이동 노드와 관련된 이전 무선 노드와의 통신 링크를 종결한다.
이동 사용자 프로파일 레코드는 이동 전화 번호 또는 국제 이동 가입자 식별(IMSI), 이동 접속 식별자(이동 노드-ID), 네트워크 어드레스 식별자(NAI)에 의해 인덱스되는 하나 또는 그 이상의 세션들, 또는 NAI 사용자 프로파일을 포함할 수 있다. 테이블 7은 이동 노드가 PDSN을 통해 등록할 때 PDSN으로부터 등록 정보를 수신하는 경우 FACN(220) 상에서 발생될 수 있는 예시적인 이동 노드 프로파일 레코드를 보여준다.
IMSI/이동노드 ID 이동세션 NAI PDSN IP 어드레스 이동 세션 상태 이동 프로파일
이동전황기 번호 및 접속 ID 이동 세션 NAI(user@domain) 최종 PDSN의 IP 어드레스 활성 또는 휴지 이동세션의 AAA 프로파일
테이블 7
본 발명은 도2에 제시된 시스템의 사용으로 제한되지 않음을 이해하여야 한다. 보다 많거나 적은 또는 상이한 컴포넌트, 접속, 인터페이스들이 사용될 수 있다. 예를 들어, 선행 단락에서 기술된 휘발성 및 비휘발성 레코드들이 FACN(220)에 위치하는 하나 또는 그 이상의 데이타베이스에 저장되거나 또는 FACN(220)와 통신하는 네트워크 서버의 휘발성 또는 비 휘발성 미디어에 저장될 수 있다. 또한,무선 노드는 상기 무선 네트워크 노드로 제한되지 않으며, 예를들어 기지국 제어기(BSC) 노드 또는 패킷 제어 함수(PCF) 노드와 같은 상이한 타입의 무선 노드들이 사용될 수 있다. 또한, 여기서 제시된 배치들은 단지 예시적 목적에 지나지 않으며, 당업자는 인터페이스 및 함수들과 같이 다른 배치들 및 다른 엘리먼트들이 공지 여부와 관계없이 사용될 수 있고, 일부 엘리먼트들은 생략될 수 있음을 잘 이해할 것이다. 또한, 대부분의 통신 에플리케이션처럼, 당업자는 여기서 제시된 많은 엘리머트들이 개별 컴포넌트 또는 다른 컴포넌트들과의 결합 도는 임의의 적절함 컴비네이션 및 위치에서 펌웨어 또는 소프트웨어로서 구현될 수 있는 기능적 엔티티임을 잘 이해할 것이다.
도3은 PDSN 발견 프로세스와 같은 외부 에이젼트 발견 프로세스에 대한 방법(300)을 보여주는 흐름도이다. 일 실시예에 따라, 외부 에이젼트 발견 프로세스는 외부 에이젼트 및 FACN(220)과 같은 제어 노드 사이의 네트워크 프로토콜을 사용하여 구현된다. 외부 에이젼트가 동작을 개시할 때, 외부 에이젼트는 초기화 제어 메세지를 제어 노드에 전송하여 이동 노드 등록 요청을 처리할 수 있는 능력을 전달한다. 도3을 살펴보면, 단계(302)에서, 제어 노드는 외부 에이젼트로부터 초기화 제어 메세지를 수신한다. 이러한 초기화 제어 메세지에 응답하여, 제어 노드는 기밀키 데이타를 포함하는 초기화 제어 응답 메세지를 발생시킨다. 예를 들어, 기밀키 데이타는 외부 에이젼트가 무선 네트워크 노드와 통신할 때 사용되는 제1 기밀키 및 외부 에이젼트가 소정 AAA 네트워크 서버와 통신할 때 사용되는 제2 기밀키를 포함한다. 단계(304)에서, 제어노드는 초기화 제어 응답 메세지를 외부에이젼트로 전송한다. 또한, 단계(306)에서, 제어노드는 동적으로 외부 에이젼트 프로파일 레코드를 발생시키고 외부 에이젼트를 비활성 외부 에이젼트로 마킹한다. 일 실시예에서, 동적인 외부 에이젼트 프로파일 엔트리는 휘발성 레코드를 저장하기위해 배치된 메모리에 저장된다. 그러나, 상이한 실시예로 가능하다. 예를 들어, 제어노드는 하나 또는 그 이상의 데이타베이스에 휘발성 레코드들을 저장하도록 구현될 수 있다.
제어노드로부터 초기화 제어 응답 메세지 수신에 응답하여, 외부 에이젼트는 제어노드로의 주기적 제어 메시지 전송이라는 정상적인 동작을 시작한다. 예시적인 실시예에 따라, 외부 에이젼트로부터 주기적으로 전송된 제어 메세지들은 외부 에이젼트가 활성임을 표시하고 호출 로드 인자, 처리 로드 인자, 및/또는 호출,처리 및 현재 외부 에이젼트에 의해 사용되는 메모리 자원과 관련된 메모리 로드 인자와 같은 외부 에이젼트와 관련된 로드 데이타를 포함한다. 단계(308)에서, 제어노드는 제2 제어 메세지가 외부 에이젼트로부터 수신되었는지 여부를 결정한다. 제2 메세지가 수신되지 않으면, 상기 방법(300)은 종결되고, 외부 에이젼트 프로파일 레코드내의 외부 에이젼트 비활성 상태는 변경되지 않는다. 제2 제어 메세지가 제어노드에 의해 수신되면, 단계(310)에서, 제어 노드는 외부 에이젼트 레코드 내의 외부 에이젼트 비활성 상태를 활성 상태로 변경한다. 또한, 제2 제어 메세지가 외부 에이젼트와 관련된 로드 인자들을 포함하면, 단계(312)에서 제어 노드는 외부 에이젼트 프로파일 레코드내의 로드 인자들을 저장한다. 또한, 제어 노드는 응답 확인 메세지를 제어노드에 전송하여 그 활성 상태 및 제2 메세지 수신을 표시한다.
상기 방법(300)에서, 제어 노드는 FACN(220)이고, 외부 에이젼트는 PDSN(232)이다. 그러나, 상기 방법은 임의의 특정 하드웨어 또는 소프트웨어로 제한되지 않으며 보다 적거나 많은 또는 상이한 또는 등가의 네트워크 장치들이 사용될 수 있음을 이해하여야한다.
예시적인 실시예에 따라, 제어 노드, FACN(220), 및 관련된 외부 에이젼트들, PDSN들은 외부 에이젼트 이용가능성, 제어노드 이용 가능성 및 외부 에이젼트 로드 인자를 전달하기 위해 하트비트 메세지 매커니즘을 사용한다. 도4는 외부 에이젼트 및 제어노드 사이에서 사용될 수 있는 하트비트-메세지 방식을 보여주는 메세지 시퀀스 시나리오(400)의 예이다. PDSN(232)과 같은 외부 에이젼트는 FACN(220)과 같은 제어노드와 하트비트 초기화(INIT) 메세지(402)를 통해 통신을 개시한다. 하트비트 INIT 메세지(402) 수신에 응답하여, 제어노드는 무선 네트워크 노드(216) 및 소정 AAA 서버와의 통신을 위해 외부 에이젼트에서 사용될 기밀키들을 포함하여 하트비트 INIT 확인 메세지(404)를 발생시키고, 이러한 메세지(404)를 외부 에이젼트에 전송한다. 뒤이어, 외부 에이젼트는 그 처리, 메모리 및 호출 로드 인자 또는 외부 에이젼트가 이용가능하지 않음을 표시하는 상태 오버라이드(override) 파라미터를 포함하는 주기적 하트비트 메세지(406)를 제어노드에 전송한다. 선호되는 실시예에 따라, 하트비트 메세지는 본질적으로 주기적이다. 제어 노드는 하트비트 확인 메세지(408)를 통해 각각의 주기적 하트비트 메세지에 응답한다. 일 실시예에서, 하트비트 확인 메세지(408)는 AAA 서버 및 무선네트워크 노드키들과 관련된 독자적인 키 태그 식별자를 포함한다. 제어노드는 외부 에이젼트에 제공되는 키들을 갱신하고, 하나 또는 그 이상의 키들이 갱신되면, 제어노드는 하트비트 확인 메세지의 새로운 키 태그 식별자를 정의한다. 외부 에이젼트가 새로운 키 태그 식별자를 수신하면, 외부 에이젼트는 하트비트 INIT 메세지를 통해 새로운 키들을 요청한다.
일 실시예에 따르면, 주기적 하트비트 메세지는 외부 에이젼트의 활동을 표시하고 외부 에이젼트의 로드 인자들을 포함한다. 선행 단락에서 언급한 바와 같이, 소정수의 하트비트 메세지들이 상실되거나 또는 소정수의 주기적 하트비트 메세지들이 제어 노드 상에서 인증에 실패하는 경우 제어노드는 외부 에이젼트를 활성 외부 에이젼트로부터 제거하도록 구현된다. 다른 실시예에 따르면, 하트비트 INIT 및 주기적 하트비트 메세지들과 같이, 하트비트 메세지들은 하트비트 인터벌을 포함하여 제어노드가 이전 하트비트 메세지에서 외부 에이젼트에 의해 규정된 하트비트 인터벌 끝에 앞서 외부 에이젼트로부터 다음 하트비트 메세지 수신을 기대할 수 있도록 한다.
도5는 하트비트 INIT 메세지(402) 및 주기적 하트비트 메세지(406)의 선호되는 포맷과 같이, 하트비트 메세지들의 선호되는 포맷(500)을 보여주는 블록 다이아그램이다. 이러한 메세지 포맷(500)은 다수의 필드를 포함한다: IP 헤더(502), UDP 헤더(504), 메세지 타입 필드(506), 예비 필드(508), 길이 필드(510), 하트비트 인터벌 필드(512), 예비 필드(514), PDSN 어드레스 필드(516), 및 복수의 서브 필드. IP 헤더(502)는 IP 헤더 포맷을 갖는다. 이러한 실시예에서, IP 헤더의 기착지 필드는 제어노드의 IP 어드레스를 포함하고 소스 어드레스 필드는 도2의 PDSN(232)과 같은 소스 외부 에이젼트의 IP 어드레스를 포함한다. 또한, 일 실시예에서, UDP 헤더 포맷(504)은 예를 들어 UDP 헤더의 포맷을 갖는다. 하트비트 메세지에 대한 대안적 포맷들이 사용될 수 있다. 예를 들어, 하트비트 메세지들은 도5에 제시된 것보다 작은 또는 많은 필드 및/또는 서브필드들을 포함할 수 있고 필드 및/또는 서브필드들의 배열이 변경될 수도 있다.
타입 필드(506)는 PDSN 하트비트 또는 PDSN 주기적 하트비트와 같은 하트비트 메세지 타입을 정의한다. 테이블 8은 2개의 메세지들에 대한 메세지 타입 값들의 예를 보여준다. 다른 타입값들이 대안적으로 사용될 수 있다.
타입 설명
0×02 PDSN INIT 하트비트
0×01 PDSN 주기적 하트비트
테이블 8
또한, 예비 필드(508 및 514)는 장래 사용을 위해 여백으로 남겨지거나 또는 대안적으로 제거된다. 길이 필드(510)는 메세지 길이를 정의하고, 하트비트 인터벌(512)은 제어노드가 다음 하트비트 메세지를 수신하는 시간 간격을 정의한다. 외부 에이젼트 어드레스 필드(516)는 예를 들어 메세지를 전송하는 외부 에이젼트의 IP 어드레스를 포함한다.
복수의 서브 필드들은 전송 외부 에이젼트의 로드 인자들을 포함한다. 도5에 제시된 메세지 포맷에서는, 3개의 서브타입 로드 필드들이 존재한다: 호출 로드 필드(518), 처리 사용 필드(524), 및 메모리 사용 필드(536). 그리고 그 각각은길이 필드(520,526,538), 필드(518,524,536)에서 정의된 현재 로드 인자 변수를 정의하는 값 필드(522,528,534)를 갖는다. 테이블 9는 서브타입 필드들(518,524,536)에 대해 사용되는 예시적인 값들을 보여준다. 그러나, 호출 로드, 처리 사용, 및 메모리 사용 필드들에 대한 상이한 값들이 사용될 수 있다. 또한 보다 많거나, 적거나, 상이한 또는 등가의 외부 에이젼트 용량 변수들이 사용될 수 있다.
서브타입 설명
0×12 외부 에이젼트 호출 로드
0×52 외부 에이젼트 CPU 사용
0×32 외부 에이젼트 메모리 사용
테이블 9
또한, 도5의 메세지 포맷은 외부 에이젼트에서 사용되는 인증 모드 식별자, 인증 필드의 길이를 포함하는 길이 필드(538), 보안 파라미터 인덱스(SPI) 필드(540,542) 및 인증 필드(544)를 구비한 인증 타입 필드(536)를 포함한다.
도6은 도4에 제시된 FACN 하트비트 ACK 메세지(404) 또는 FACN 주기적 하트비트 ACK 메세지(408)와 같이, 외부 에이젼트로부터 하트비트 메세지 수신에 응답하여 제어노드로부터 전송된 하트비트 메세지에 대한 메세지 포맷(600)의 예를 보여준다. 도6에 제시된 메세지 포맷은 도5의 그것과 유사하고, IP 헤더 필드(602), UDP 헤더 필드(604), 메세지 타입 필드(606), 예비 필드(608), 길이 필드(610), 및 PDSN 어드레스 필드(612)를 포함한다. 도5에 제시된 메세지 포맷(500)과 같이, 메세지 포맷(600)은 단지 선호되는 실시예일 뿐이고 대안적 포맷이 사용 가능하다. 예를 들어, 하트비트 메세지들은 도6에 제시된 필드 및/또는 서브필드들 보다 많거나 적은 필드 및/또는 서브필드들을 포함할 수 있고, 그 배치가 변경될 수도 있다.
도6에서, IP 헤더 필드(602)는 FACN(220)의 IP 어드레스를 구비한 소스 어드레스 필드 및 기착지 PDSN의 IP 어드레스를 구비한 기착지 어드레스를 포함한다. 또한, 메세지 타입 필드는 FACN(220)에 의해 발생된 하트비트 메세지의 타입을 식별한다. 테이블 10은 하트비트 INIT ACK 메세지 및 주기적 ACK 메세지 타입을 정의하는데 사용될 수 있는 예시적인 타입값을 보여준다.
타입 설명
0×12 FACN으로부터의 하트비트 INIT ACK
0×11 FACN으로부터의 주기적 하트비트 ACK
테이블 10
이러한 메세지 포맷(600)은 또한 키 태그 값 필드(614), 예비 필드(616), 서브타입 PDSN-무선 네트워크 노드 키 필드(618), 서브타입 키 필드와 관련된 길이 필드(620), SPI 필드(622), 및 기밀(secret) 필드(624)를 포함한다. 키 태그 값 필드(614)는 AAA 및 FACN(220)에 저장된 무선 네트워크 노드 키들에 대한 순차적인 키 태그 식별자를 포함한다. 순차적인 키 태그 식별자는 하나 또는 둘 모두에 대한 키들이 변경될 때마다 FACN(220)상에서 수정될 수 있다. FACN(220)으로부터 하트비트 ACK 메세지를 수신하는 PDSN이 수신 메세지에서 규정된 키 태그 식별자가 PDSN 상에 지역적으로 저장된 키 태그 식별자와 상이하다는 것을 탐지하는 경우, PDSN은 FACN(220)이 그 키를 새롭게하도록 하트비트 INIT 메세지를 전송한다. 서브타입 PDSN 무선 네트워크 노드 키 필드(618)는 기밀 필드(624)내의 기밀키 타입을 식별한다. 도6에 제시된 실시예에 따라, 서브타입 PDSN 무선 네트워크 노드 키필드(618)는 기밀키 필드(624)에 포함된 PDSN-무선 네트워크 노드와 관련된 식별자를 포함한다.
또한, 상기 메세지는 서브타입 PDSN-AAA 키 필드(626), 길이 필드(628), AAA IP 어드레스 필드(630), 기밀 필드(632), 인증 타입 필드(634), 길이 필드(636), SPI 필드(638), 및 SPI 인증자 필드(640)를 포함한다. 서브타입 PDSN-AAA 키 필드(626)는 PDSN 및 AAA 서버 사이에서 사용되는 AAA 키를 기밀 필드(632)가 포함하는지를 식별한다. 일 실시예에서, IP 어드레스와 같은 AAA 서버의 네트워크 어드레스는 AAA IP 어드레스 필드(630)에서 규정된다. [ 인증 타입, SPI 및 SPI 인증자 필드에서 무엇이 정의되는가?] 테이블 11은 서브 타입 필드들(618,626)에서 사용되는 예시적인 타입값들을 보여준다. 그러나, 상이한 값들이 사용가능하다.
서브타입 설명
0×41 PDSN-무선 네트워크 노드 키
0×51 PDSN-AAA 키
테이블11
도7은 선호되는 실시예에 따라 무선 네트워크 노드 동작을 위한 방법(700)을 보여주는 흐름도이다. 단계(702)에서, 무선 네트워크 노드는 선호되는 외부 에이젼트 네트워크 어드레스로서 제어노드의 네트워크 어드레스를 통해 구현된다. 이러한 실시예에서, 무선 네트워크 노드가 그 서비스 영역에서 이동 노드를 탐지하면, 무선 네트워크 노드는 임의의 다른 외부 에이젼트를 통해 이동노드 등록을 시도하기에 앞서 제어노드에 질의한다. 무선 네트워크 노드는 무선 네트워크 노드 서비스 영역에서 이동 노드들을 서빙하는데 이용가능한 외부 에이젼트들의 네트워크 주소들을 가지고 구현된다. 단계(704)에서, 무선 네트워크 노드는 새로운 이동 노드가 그 서비스 영역에서 탐지되었는지를 결정한다. 무선 네트워크 노드가 그 서비스 영역내에서 새로운 이동 노드를 탐지하면, 단계(706)에서 무선 네트워크 노드는 제어노드의 네트워크 어드레스로 등록 요청을 전송한다. 그렇지 않으면, 상기 방법은 단계(704)로 리턴된다.
단계(708)에서, 무선 네트워크 노드는 제어노드로부터 등록 응답 메세지를 수신한다. 선호되는 실시예에 따라, 등록 응답 메세지는 제어노드에서 선택된 외부 에이젼트의 네트워크 어드레스를 포함한다. 이러한 선택은 도8A 및 8B에 기재된 다수의 선택 기준에 따라 이루어진다. 대안적으로, 무선 네트워크 노드가 제어노드상에서 인증 프로세스를 실패하면, 등록 응답 메세지는 리젝션 코드를 포함한다. 이러한 실시예에서, 무선 네트워크 노드는 무선 네트워크가 구현되는 외부 에이젼트들 중 하나에 등록 요청 메세지를 전송한다.
단계(710)에서, 무선 네트워크 노드는 제어노드로부터 등록 응답 메세지에 규정된 외부 에이젼트 노드로 등록 요청 메세지를 전송한다. 등록 요청 메세지는 예를 들면 이동 식별자 또는 이동 노드와 관련된 홈 에이젼트의 네트워크 어드레스와 같은 이동 노드의 데이타를 포함한다. 단계(712)에서, 무선 네트워크 노드는 외부 에이젼트로부터 등록 응답 메세지를 수신한다. 무선 네트워크 노드에서 수신된 등록 응답 메세지는 등록 확인 파라미터 또는 등록 리젝션 파라미터를 포함한다. 등록 응답 메세지가 등록 확인 파라미터를 포함하면, 이동 노드는 점대점 통신 링크와 같이 외부 에이젼트와의 통신 링크 설정을 개시한다. 등록 응답메세지가 등록 리젝션 파라미터를 포함하면, 무선 네트워크 노드는 외부 에이젼트 노드를 통해 등록을 재시도하고 또는 대안적으로 다른 외부 에이젼트를 통해 등록한다.
도7에 제시된 방법(700)에서, 이동 노드는 도2에 제시된 이동 노드(210)를 포함하고, 무선 네트워크 노드는 무선 네트워크 노드(216)를 포함하고, 외부 에이젼트 제어노드는 FACN(220)을 포함하며, 외부 에이젼트는 PDSN(232)을 포함한다. 그러나, 예시적인 상기 방법은 이러한 장치들로 제한되지 않으며 보다 적거나 많은 또는 상이한 장치들이 도7에 제시된 단계들을 수행할 수 있는 한 대안적으로 사용될 수 있다.
선행 단락에서 언급한 바와 같이, 제어노드의 기능들 중 하나는 무선 네트워크 노드의 이동 클라이언트 등록 요청를 서비스하는 외부 에이젼트를 선택하는 것이다. 제어노드가 무선 네트워크 노드(216)로부터 등록 요청 메세지를 수신할 때, 제어노드는 전형적인 외부 에이젼트가 정상적으로 수행하는 것처럼 등록 요청을 처리하지 않는다. 대신, 이동 클라이언트 등록을 서비스할 수 있는 도2에 제시된 PDSN(232,234,236) 중 하나와 같이 외부 에이젼트를 선택한다. 제어노드는 이동 클라이언트 등록을 서비스하기에 적합한 외부 에이젼트를 결정하기 위해 임의의 적절한 선택 알고리즘을 사용할 수 있다.
도8A 및 8B는 이동 클라이언트의 등록 요청을 서비스하는 외부 에이젼트를 선택하기 위해 제어노드 상에서 제어될 수 있는 방법(800)을 보여주는 흐름도이다. 단계(802)에서, 제어노드는 무선 네트워크 노드의 서비스 영역내의 이동 노드 탐지에 응답하여 무선 네트워크 노드로부터 등록 요청 메세지를 수신한다. 이러한 등록 요청 메세지는 이동노드의 홈 에이젼트 데이타, 무선 네트워크 노드의 데이타, 및 이동 노드 등록을 위한 요청과 같은 이동 노드 정보를 포함한다. 일 실시예에서, 등록 요청 메세지는 RFC 2002에 기술된 메세지 포맷을 가질 수 있다; 그러나 상이한 메세지 포맷들도 대안적으로 사용가능하다.
단계(804)에서, 제어노드는 등록 요청 메세지 수신시에 무선 네트워크 노드를 인증한다. 무선 네트워크 노드의 성공적인 인증시, 단계(806)에서, 제어노드는 이동 노드와 관련된 적어도 하나의 세션이 활성인지 여부를 결정한다. 이를 위해, 제어노드는 이동노드와 관련된 사용자 정보가 제어노드 상에서 이용가능한지 여부를 결정한다. 일 실시예에서, 제어노드는 그 이동 사용자 정보 레코드를 검색하여 등록 요청 메세지에 규정된 이동 사용자에 대한 기록이 존재하는지 여부를 결정한다. 일 실시예에서, 이동 사용자 정보 레코드들은 테이블7에 기재된 다른 파라미터들 중 외부 에이젼트-이동 사용자 바이딩(binding) 정보를 포함한다. 선호되는 실시예에 따라, 외부 에이젼트 이동 사용자 정보는 이동 노드가 새로운 외부 에이젼트에 할당될 때마다 제어노드에서 갱신된다. 따라서, 이동 노드의 상태가 활성이면, 상기 레코드내의 외부 에이젼트는 현재 이동노드를 서빙하는 외부 에이젼트에 해당된다.
일 실시예에서, 제어노드가 이용가능한 이동 사용자 정보 레코드를 가지면, 제어 노드는 우선 현재 이동노드를 서빙하는 외부 에이젼트 선택을 시도한다. 단계(808)에서, 제어노드는 이동 사용자 정보 레코드를 사용하여 이동노드와 관련된외부 에이젼트를 결정한다. 단계(810)에서, 제어노드는 이동노드와 관련된 외부 에이젼트가 이동 노드 등록 요청을 서비스하는데 이용가능한지를 결정한다. 이를 위해, 제어노드는 외부 에이젼트와 관련된 정보 레코드를 불러내 외부 에이젼트의 로드 인자들을 결정한다. 일 실시예에 따라, 이러한 로드 인자들은 외부 에이젼트와 관련된 메모리 로드 인자, 프로세싱 로드 인자 및 호출 로드 인지를 포함한다. 제어노드는 외부 에이젼트에 대한 메모리 사용, 프로세싱 사용 또는 호출 로드에 대한 최대 한계를 정의하는 각각의 로드 인자에 대한 임계 레벨을 가지고 구현된다. 그리고 나서 제어노드는 외부 에이젼트의 로드 인자들이 임계 레벨을 초과하는지 여부를 결정함으로써 외부 에이젼트의 이용가능성을 검증한다.
외부 에이젼트가 이동 노드의 등록 요청을 서비스하는 것이 이용가능하면, 단계(802)에서 제어노드는 단계(808)에서 결정된 특정 외부 에이젼트가 무선 네트워크 노드에 대한 유효한 외부 에이젼트인지 여부를 결정한다. 이를 위해, 제어노드는 무선 네트워크 노드와 관련된 외부 에이젼트들 그룹을 정의하는 무선 네트워크 노드 정보 레코드를 검색한다. 평가된 외부 에이젼트가 무선 네트워크 노드에 대한 유효한 외부 에이젼트들 중 하나이면, 단계(814)에서 제어노드는 IP 어드레스와 같이 무선 네트워크 노드 요청을 서비스하기 위해 선택된 외부 에이젼트의 네트워크 어드레스를 포함하는 등록 응답 메세지를 발생시킨다.
그러나, 이동 노드가 비활성이거나(단계 806), 또는 외부 에이젼트가 이용가능하지 않거나(단계 810), 또는 무선 네트워크 노드용으로 유효하지 않다고 제어노드가 결정하면 제어노드는 무선 네트워크 노드 요청을 서빙하는 외부 에이젼트를결정하기 위해 검색 선택 알고리즘을 적용한다. 선호되는 실시예에 따라, 제어노드는 무선 네트워크 노드와 관련된 하나 또는 그 이상의 외부 에이젼트 그룹들에 검색 선택 알고리즘을 적용한다. 각 무선 네트워크 노드에 대한 외부 에이젼트 구현은 예를 들면 무선 네트워크 노드 및 외부 에이젼트들 사이의 지리적 근접성, 방향 요구조건(즉, 동에서 서) 또는 무선 네트워크 노드 및 외부 에이젼트 사이의 최단 네트워크 경로를 포함하는 다수의 특정 기준들에 따라 이루어 질 수 있다. 일 실시예에서, 무선 네트워크 노드는 다수의 외부 에이젼트 그룹들과 관련될 수 있고 , 각 그룹은 다수의 외부 에이젼트들을 포함한다. 이러한 실시예에서, 무선 네트워크 노드 요청을 서빙하는 외부 에이젼트를 선택하는 선택 알고리즘은 정의된 순서대로 무선 네트워크 노드와 관련된 각각의 외부 에이젼트 그룹에 적용되어 정의된 순서로 각각의 검사된 외부 에이젼트 그룹내의 각 외부 에이젼트를 검색한다. 예시적인 실시예에 따라, 외부 에이젼트 로드 인자들을 평가하기 위해 사용되는 검색 선택 알고리즘은 처음에 외부 에이젼트들을 구현된 호출 밸런싱 임계치까지 로드하고, 그리고 나서 로드 밸런싱을 사용하여 아래에서 상술되는 바와 같이 외부 에이젼트를 결정한다.
따라서, 이동 클라이언트가 비활성이거나(단계 806), 외부 에이젼트가 이용가능하지 않거나(단계 810), 또는 등록 무선 네트워크 노드에 대해 유효하지 않다고(단계 812) 제어노드가 결정하면, 상기 방법(800)은 단계(816)에서 계속되고, 여기서 제어노드는 무선 네트워크 노드와 관련된 적어도 하나의 외부 에이젼트 그룹을 결정한다. 단계(818)에서, 제어노드는 각 그룹의 외부 에이젼트들이 소정 호출밸런스 임계치까지 프론트 로드(front-load)되었는지 여부를 결정한다. 제어노드가 적어도 하나의 외부 에이젼트가 소정 호출 밸런스 임계치보다 낮은 호출 로드를 갖는다고 결정하면, 제어노드는 바람직하게는 무선 네트워크 노드의 등록 요청을 서비스할 제1 외부에이젼트를 선택한다. 단계(820)에서, 제어노드는 IP 어드레스와 같이 호출 밸런스 임계치보다 낮은 호출 로드를 갖는 외부 에이젼트의 네트워크 어드레스를 포함하는 등록 응답 메세지를 발생시킨다.
무선 네트워크 노드의 외부 에이젼트 그룹들과 관련된 모든 외부 에이젼트들이 이미 소정 호출 밸런스 임계치 로드로 프론트 로드되었다면, 제어노드는 무선 네트워크 노드에 대한 외부 에이젼트를 선택하기 위해 로드 밸런싱 방식을 적용한다. 그러나, 본 발명은 소정 호출 밸런싱 임계치 로드까지의 외부 에이젼트의 프론트 로딩으로 제한되지 않으면, 상이한 실시예들이 가능하다. 로드-밸런싱 방식은 무선 네트워크 노드와 관련된 외부 에이젼트들의 로드 인자들에 기반한다. 단계(822)에서, 제어노드는 로드 밸런싱 방식을 적용하여 무선 네트워크 노드의 등록 요청을 서비스할 외부 에이젼트를 결정한다. 제어노드는 각 외부 에이젼트와 관련된 로드 인자들을 사용하여 외부 에이젼트를 결정한다. 일 실시예에서, 제어노드는 최소의 호출을 갖는 외부 에이젼트를 선택하지만, 다른 실시예들도 가능하다. 예를 들어, 외부 에이젼트는 가장 높은 처리용량 또는 가장 많은 메모리 이용가능성에 기반하여 선택될 수도 있다. 대안적인 검색 선택 알고리즘들도 사용가능하다. 예를 들어, 외부 에이젼트는 프론트 로딩없는 로드 밸런싱 기술을 사용하여 선택될 수 있다. 추가적인 예로서, 검색 선택 알고리즘이 임의의 정의된순서없이 외부 에이젼트들에 적용될 수 있다. 이러한 설명을 바탕으로 당업자는 이러한 그리고 다른 대안들을 잘 이해할 수 있을 것이다.
단계(824)에서, 제어노드는 등록 응답 메세지를 발생시켜 이를 무선 네트워크 노드에 전송한다. 등록 응답 메세지는 IP 어드레스와 같이 로드-밸런싱 방법을 사용하여 결정된 외부 에이젼트의 네트워크 어드레스를 포함한다.
도8A 및 8B에서 기술된 방법(800)에서, 이동노드는 이동노드(210)을 포함하고, 무선 네트워크 노드는 무선 네트워크 노드(216)를 포함하며, 외부 에이젼트 제어노드는 FACN(220)을 포함하고, 외부 에이젼트는 PDSN(232,234,236)을 포함한다. 그러나, 상기 방법(800)은 이러한 장치들로 제한되지 않으며, 도8A 및 8B에서 기재된 단계를 수행할 수 있는 장치들이기만 하면 보다 적거나 많은 또는 상이한 장치들이 대안적으로 사용될 수 있다.
도9는 외부 에이젼트 선택 방법을 보여주는 메세지 시퀀스 시나리오(900)의 블록 다이아그램이다. 상기 블록 다이아그램은 이동노드(210), 무선 네트워크 노드(216), FACN(220), 및 PDSN(232)를 포함한다. 이동노드(210)가 무선 네트워크 노드의 서비스 노드로 로밍(roam)할 때, 이동노드(210)는 서비스 개시(SO) 메세지(902)를 무선 네트워크 노드(216)로 전송하고, 무선 네트워크 노드(216)는 기지국 개시(BS) 확인 지시 메세지(904)로 응답한다. 이동노드(210)에서 BS 확인 메세지(904)를 수신하면, 이동노드(210) 및 무선 네트워크 노드(216)는 참조번호(906)에 의해 제시된 터널 통신 링크와 같은 통신 링크를 설정한다.
무선 노드(210) 및 무선 네트워크 노드(216) 사이에 통신 링크를 설정시, 무선 네트워크 노드(216)는 등록 요청 메세지(908)를 FACN(220)에 전송한다. 도9에 제시된 바와 같이, 등록 요청 메세지(908)는 메세지와 관련된 존속기간(lifetime)을 정의하는 존속기간 파라미터 및 사용자 프로파일 파라미터를 정의하는 이동 노드-홈 에이젼트 연장(extension)을 포함한다. FACN(220)이 등록 요청 메세지(908)을 수신하면, FACN(220)은 예를 들어 로드 및/또는 처리 인자들, 블록(910)에 제시된 국제 이동 가입자 식별 및 최종 서빙 PDSN 매핑에 따라 이동 노드(210)에 대한 PDSN을 선택한다. FACN(220)이 등록 요청을 서비스할 PDSN을 선택하면, FACN(220)은 등록 응답 메세지(912)를 발생시켜 이를 무선 네트워크 노드(216)로 전송한다. 본 발명의 일 실시예에 따르면, FACN(220)은 외부 에이젼트 기능을 제공하지 않고, 그 대신 도8A 및 8B에 제시된 소정 기준을 사용하여 PDSN들을 선택한다. 따라서, 등록 응답 메세지(912)는 어떠한 적절한 에이젼트도 인증되지 않음을 표시하는 등록 리젝션 코드(136)를 포함하고, IP 어드레스와 같이 FACN(220)에 의해 선택된 PDSN의 네트워크 어드레스를 포함한다(이 경우, PDSN(232)의 IP 어드레스).
무선 네트워크 노드(216)가 선택된 PDSN의 네트워크 어드레스를 포함하는 등록 응답 메세지(912)를 수신하면, 무선 네트워크 노드(216)는 등록 요청 메세지(914)를 응답 메세지에서 특정된 PDSN으로 전송한다. 도9에 제시된 실시예에 따르면, 무선 네트워크 노드(216)는 존속기간 파라미터 및 이동 노드-홈 에이젼트 연장을 포함하는 등록 요청 메세지(914)를 PDSN(232)으로 전송한다. PDSN(232)에 의한 이동노드(210)의 인증시, PDSN(232)은 등록 응답 메세지(916)를 무선 네트워크 노드(216)로 전송한다. 무선 네트워크 노드(216)가 PDSN(232)으로부터 등록수용 응답을 포함하는 등록 응답 메세지(916)를 수신하면, 이동노드(210)는 점대점 통신 링크와 같은 통신 링크를 PDSN(232)과 918에서 제시된 바와 같이 설정한다. 통신 링크 설정시, 이동노드(210)는 PDSN(232)을 통해 등록되고, 이동노드(210)는 PDSN(232)을 통해 타겟 호스트로 사용자 데이타 전송을 개시한다.
이동노드(210)가 PDSN(232)과 통신 링크를 설정하고 등록 요청 메세지(914)를 PDSN(232)으로 전송할 때, PDSN(232)은 상기 요청을 인증한다. 예시적인 실시예에 따르면, FACN(220)은 예를 들어 테이블 7에 제시된 바와 같이 이전 등록에서 성공적으로 인증된 데이타 레코드를 유지한다. 이동 클라이언트가 등록되고, 이동 클라이언트가 FACN 데이타베이스에 캐쉬(cache)되지 않을 때마다, 이동 클라이언트가 등록되는 PDSN은 AAA 프로파일 정보를 FACN(220)으로 전송한다. 또한, 일 실시예에 따라, 이동 클라이언트가 인증되고 활성 상태를 가지면, FACN(220)은 캐쉬된 AAA 프로파일 정보를 이동노드(210)를 서빙하는 PDSN으로 제공하여 PDSN이 AAA 인증을 스킵하도록 한다.
도10A, 10B 및 10C는 본 발명의 일 실시예에 따라 외부 에이젼트를 통한 이동노드 제1 등록을 위한 방법(1000)을 보여주는 흐름도이다. 도10A를 살펴보면, 무선 네트워크 노드가 새로운 이동노드를 탐지하고 제어노드에서 선택된 외부 에이젼트와 성공적으로 등록되면, 단계(1002)에서 통신 링크가 이동노드 및 제어노드에 의해 특정된 외부 에이젼트 사이에서 설정된다. 예를 들어, 이동노드는 외부 에이젼트와 점대점 통신 링크를 설정할 수 있다. 단계(1004)에서, 이동노드는 외부 에이젼트로 등록 요청 메세지를 전송한다. 예시적인 실시예에 따르면, 외부 에이젼트는 외부 에이젼트에서 서비스되는 이동노드와 관련된 이동 세션 리스트를 포함하는 방문객 리스트 레코드들을 저장한다. 외부 에이젼트상의 방문객 리스트 레코드의 이동 세션들은 외부 에이젼트에 의해 서비스되는 이동노드들과 관련되고, 따라서 이전에 인증되었다. 단계(1006)에서, 외부 에이젼트는 등록 이동노드에 대해 방문객 리스트 레코드가 존재하는지 여부를 결정한다. 외부 에이젼트가 그 로컬 방문객 리스트 레코드에 이동노드를 가지고 있다면, 상기 방법(1000)은 단계(1030)에서 게속된다. 외부 에이젼트 제어노드가 방문객 리스트 레코드에 이동노드를 가지고 있지 않다면, 외부 에이젼트는 인증 데이타 요청을 포함하는 방문객 리스트 등록 요청을 제어노드로 전송한다.
제어노드가 외부 에이젼트로부터 방문객 리스트 등록 요청을 수신하면, 단계(1010)에서 제어노드는 이동노드가 이미 인증되어 제어노드가 이동 노드에 대한 인증 데이타를 포함하고 있는지 여부를 결정한다. 이를 위해, 제어노드를 이동 노드 사용자와 관련된 데이타를 포함하는 이동 사용자 레코드을 검색한다. 또한, 이동 사용자 데이타베이스 레코드를 사용하여 제어노드는 이동노드의 활동 상태를 결정한다. 일 실시예에서, 제어노드는 이동노드가 활성 세션 상태를 갖는지 여부를 결정한다. 이동 노드에 대한 인증 데이타가 이용가능하지 않거나, 레코드 내의 이동 사용자 세션이 비활성으로 정의된다고 제어노드가 결정하면, 제어노드는 방문객 리스트 등록 요청을 리젝트하고 단계(1016)에서 인증 데이타 리젝션 파라미터를 포함하는 방문객 리스트 응답 메세지를 외부 에이젼트로 전송한다.
외부 에이젼트가 인증 데이타 리젝션 파라미터를 포함하는 응답 메세지를 수신하면, 외부 에이젼트는 다른 수단을 사용하여 이동노드의 클라이언트를 인증한다. 일 실시예에 따르면, 단계(1018)에서 외부 에이젼트는 이동 노드를 인증하기 위해 인증 네트워크 서버에 질의한다. 다음으로, 단계(1020)에서, 이동 노드 클라이언트가 성공적으로 인증되었는지를 외부 에이젼트가 결정한다. 제어노드가 인증을 실패하면, 상기 방법(1000)은 종료된다. 이동노드에 대한 인증 프로세스가 성공적이면, 단계(1022)에서, 외부 에이젼트는 이동노드의 인증 데이타를 포함하는 등록 갱신 메세지를 제어노드로 전송한다. 제어노드가 등록 갱신 메세지를 수신하면, 단계(1024)에서, 제어노드는 이동노드의 수신된 인증 데이타를 통해 새로운 이동 사용자 레코드를 갱신 또는 발생시킨다. 제어노드는 이동노드의 인증데이타를 포함하는 등록 갱신 메세지를 수신할 수 있고, 이러한 메세지는 등록 이동노드에 대한 원래의 갱신 메세지를 원래 전송한 것과 다른 외부 에이젼트를 표시하여 외부 에이젼트 핸드오프를 지시한다. 단계(1026)에서, 갱신 메세지내의 외부 에이젼트가 이전에 인증된 외부 에이젼트와 동일한지 여부를 제어노드가 결정한다. 외부 에이젼트가 다르면, 단계(1028)에서, 제어노드는 등록 갱신 메세지를 이전에 이동노드를 서빙하던 외부 에이젼트로 전송한다. 이전의 서빙 외부 에이젼트는 이동노드가 새로운 외부 에이젼트를 통해 등록되었음을 표시하는 등록 갱신 메세지를 제어노드로부터 수신하면, 단계(1030)에서 이전의 서빙 외부 에이젼트는 이전에 이동노드를 서비스하던 무선노드와의 통신링크를 종료한다. 외부 에이젼트 핸드오프는 다양한 이유, 예를 들면 이동노드가 이전 서빙 외부 에이젼트와의 통신을 위해 정의되지 않은 무선노드로 로밍하거나 이전 서빙 외부 에이젼트가 그 로드 임계치들 중 하나를 초과하는 경우에 이루어진다. 외부 에이젼트 핸드오프는 도13에서 상술될 것이다.
단계(1010)로 돌아가면, 제어노드는 이동노드 사용자에 대한 인증 데이타가 이용가능하고 이동 사용자 레코드내에 규정된 이동노드 상태가 활성이라고 결정하면, 제어노드는 인증데이타를 외부 에이젼트로 반환하여 외부 에이젼트가 인증 처리를 스킵하도록 한다. 이러한 실시예에서, 단계(1012)에서, 제어노드는 이동노드와 관련된 인증 데이타를 포함하는 방문객 리스트 등록 응답 메세지를 외부 에이젼트로 전송한다. 단계(1014)에서, 외부 에이젼트는 제어노드로부터 방문객 리스트 응답 메세지를 수신한다.
외부 에이젼트가 이동노드에 대한 인증 데이타를 가지면, 단계(1032)에서 외부 에이젼트는 이동노드의 홈이젼트를 통해 등록된다. 일 실시예에서, 홈 에이젼트를 통한 이러한 등록 처리는 외부 에이젼트로부터 홈 에이젼트로 등록 요청 메세지를 전송하고 홈 에이젼트로부터 외부 에이젼트에서 등록 응답 메세지를 수신하는 것을 포함한다. 외부 에이젼트가 홈 에이젼트를 통해 성공적으로 등록되면, 단계(1034)에서 외부 에이젼트는 이동노드에 등록 응답 메세지를 전송한다. 이동노드가 외부 에이젼트로부터 등록 응답 메세지를 수신하면, 이동노드는 외부 에이젼트 및 홈 에이젼트를 통해 타겟 호스트로의 데이타 통신을 개시한다.
도10A,10B 및 10C에 제시된 방법(1000)에서, 이동노드는 이동노드(210)을 포함하고, 외부 에이젼트 제어노드는 FACN(220)을 포함하며, 홈 에이젼트는 홈 에이젼트(24)를 포함하고, 인증 서버는 RADIUS 서버를 포함하고, 외부 에이젼트는PDSN(232,234,236)을 포함한다. 그러나 본 방법은 이러한 장치들로 제한되지 않으며, 보다 적거나 많은 또는 상이한 장치들이 사용될 수 있다.
도11은 이동노드에 네트워크 서비스를 제공하기 위해 제어노드에 의해 선택된 외부 에이젼트와의 첫번째 이동노드 등록을 보여주는 메세지 시퀀스 시나리오(110)의 블록 다이아그램이다. 상기 블록 다이아그램은 이동노드(210), 무선 네트워크 노드(216), FACN(220), PDSN(232), HA(24) 및 AAA 서버(240)를 포함한다. 도11의 예시적인 메세지 시퀀스 시나리오는 이동노드(210)가 PDSN(232)과의 PPP 통신 링크를 설정하는 실시예를 보여준다. FACN(220)이 이동노드(210)를 서비스할 PDSN(232)을 선택할 때, 이동노드(210)는 PDSN(232)과의 PPP 통신 링크를 협상하고 에이젼트 발견 프로세스를 개시하며, 이는 각각 1104 및 1106에서 제시된다. PPP 통신 링크 설정시, 이동노드(210)는 PDSN(232)으로 등록 요청 메세지(1108)를 전송한다. 선호되는 실시예에 따라, 등록 요청(존속기간) 메세지(1108)는 RFC 2002에 따른 메세지 포맷을 가질 수 있다. 그러나 상이한 또는 등가의 메세지 포맷들이 대안적으로 사용될 수 있다.
PDSN(232)이 등록 요청 메세지(1108)를 수신하고 PDSN(232)이 그 로컬 방문객 리스트에 이동노드를 가지고 있지 않으면, PDSN(232)은 FACN(220)이 이동노드의 인증 데이타를 가지고 있는지를 결정하기 위해 방문객 등록 요청 메세지(1110)를 전송한다. 일 실시예에서, 등록 요청 메세지(1110)는 예를 들어 세션 특정 파라미터, 이동노드 NAI 파라미터 및 인증 파라미터들을 정의하는 다수의 연장(extension) 필드들을 포함한다. 이러한 세션 특정 연장들은 이동노드(210)및 PDSN(232) 사이의 통신 세션과 관련된 정보를 포함하고, 이동노드 NAI 연장은 이동노드(210) 및 PDSN(232) 사이에서 사용되는 사용자 프로파일과 관련된 정보를 포함하며, 인증 연장은 PDSN-FACN 기밀키를 사용하여 PDSN(232) 상에서 계산되는 인증자 값을 포함한다. 그러나 보다 적거나 많은 또는 등가의 연장 필드들이 대안적으로 사용될 수 있다.
FACN(220)이 등록 요청 메세지(1110)을 수신하면, FACN(220)은 FACN(220)이 이동노드(210)에 대한 인증 데이타를 저장하였는지를 결정한다. 도11에 제시된 실시예에 따르면, 블록(1112)에 제시된 바와 같이 FACN(220)은 이동노드(210)와 관련된 이전 인증 상태를 가지고 있지 않다. FACN(220)이 이동노드(210)의 인증 데이타를 가지고 있지 않기 때문에, FACN(220)은 방문객 리스트 등록 요청을 리젝트하고 방문객 리스트 등록 리젝트 응답 메세지(1114)를 PDSN(232)에 전송한다. 방문객 리스트 등록 리젝트 응답 메세지(1114)는 PSDN(232)에 요청 상태에 대해 알려주는 다수의 파라미터들을 포함할 수 있다. 예를 들어, 이동노드(210)의 인증 데이타가 FACN(220)상에서 이용가능하면, 방문객 리스트 응답 메세지 인증 데이타 이용가능 파라미터를 포함하고, 인증 데이타 요청이 FACN(220)에서 거절되면, 방문객 리스트 등록 응답 메세지는 인증 데이타를 PDSN(232)에 제공할 수 없는 이유를 포함한다. 예를 들어, FACN(220)은 외부 에이젼트 인증 프로세스 파라미터, 등록 식별 미스매치 파라미터, 불량하게 형성된 요청 파라미터, 또는 인증 데이타 이용불가능 파라미터와 같은 실패를 규정한다.
PDSN(232)이 방문객 리스트 등록 리젝트 응답 메세지(1114)를 수신하면,PDSN(232)은 1116에서 제시된 바와 같이 이동노드(210)의 요구되는 인증 데이타에 대해 AAA 네트워크 서버(1102)에 질의한다. 일단 이동노드(210)가 인증되면, PDSN(232)은 홈 에이젼트(24)를 통해 등록된다. 일 실시예에서, 홈 에이젼트(24)를 통한 등록 프로세스는 PDSN(232)으로부터 홈 에이젼트(24)로 등록 요청 메세지(1118)를 전송하는 단계 및 홈 에이젼트(24)로부터 PDSN(232)에서 등록 응답 수용 메세지를 수신하는 단계를 포함한다. 홈 에이젼트(24)를 통한 성공적인 등록시, PDSN(232)은 등록 응답 수용 메세지(1122)를 이동노드(210)로 전송하여, 이동노드(210)에 대한 등록 프로세스를 완료한다.
일 실시예에 따르면, 이동노드(210)가 일단 홈 에이젼트(24)를 통해 인증 및 등록되면, PDSN(232)은 FACN(220)에 방문객 리스트 갱신을 통지한다. 이를 위해, PDSN(232)은 AAA 서버(1102)를 사용하여 PDSN(232)에 의해 결정된 AAA 프로파일을 포함하는 방문객 리스트 등록 갱신 메세지(1124)를 전송한다. 방문객 리스트 등록 요청 메세지(1110)와 관련하여 논의된 연장 필드뿐만 아니라, 방문객 리스트 등록 갱신 메세지(1124)는 이동노드(210)의 AAA 프로파일을 포함하는 다수의 연장 필드들을 가지고 있다. 일 실시예에서, 연장 필드들은 2 옥텟(octet)의 길이를 갖는다.
FACN(220)이 방문객 리스트 등록 갱신 메세지(1122)를 PDSN(232)으로부터 수신하면, FACN(220)은 이동노드(210)의 이동 사용자 레코드를 갱신한다. 또한, 상기 메세지(1122) 수신에 응답하여, FACN(220)은 PDSN(232)에 방문객 리스트 등록 확인 메세지(1126)를 전송하여 도11에 제시된 메세지 시퀀스 시나리오를 종결시킨다. 이동노드(210)의 성공적인 등록시, 이동노드(210)는 양방향성 패킷 데이타 호출-업 블록(1128)에 의해 제시된바와 같이 원격 엔티티와의 데이타 통신을 개시한다.
도11에 제시된 메세지 시퀀스는 이동 IP 최초 등록 프로세스와 관련된다. 그러나, 선호되는 실시예들은 이동 IP로 제한되지 않으며, 이동노드가 단순한 IP 세션을 설정할 때에도 동일하게 적용될 수 있다. 도12는 제어노드에 의해 선택된 외부 에이젼트와의 최초 간단한 IP 등록을 제시하는 메세지 시퀀스 시나리오(1200)의 블록 다이아그램이다. 상기 블록 다이아그램은 도2에 제시된 이동노드(210), 무선 네트워크 노드(216), FACN(220), PDSN(232) 및 AAA 서버(240)를 포함한다. 도9에 제시된 바와 같이, FACN(220)이 이동노드(210)를 서비스할 PDSN(232)을 선택하고, 무선 네트워크 노드(216)가 PDSN(232)를 통해 등록될 때, 이동노드(210)는 PDSN(232)과의 통신 링크를 설정한다. 도12에 제시된 실시예에 따르면, 이동노드(210)는 링크 제어 프로토콜(LCP) 협상 방법(1204)을 사용하여 PDSN(232)과의 통신링크를 설정한다. 또한 이동노드(210)는 패스워드 인증 프로토콜(PAP)/챌린지 핸드세이크 인증 프로토콜(CHAP) 요청 메세지와 같은 접속 요청 메세지를 PDSN(232)으로 전송한다. PAP/CHAP 요청 메세지(1206)는 등록 요청 및 이동노드(210)와 관련된 정보 데이타를 포함한다. PDSN(232)이 PAP/CHAP 요청 메세지(1206)를 수신하고, 그 로컬 방문객 리스트에 이동노드를 가지고 있지 않으면, PDSN(232)은 방문객 리스트 등록 요청 메세지(1208)를 FACN(220)으로 전송하여 FACN(220)이 이동노드(210)의 인증 데이타를 가지고 있는지를 결정한다. 방문객리스트 등록 요청 메세지(1208)는 바람직하게는 세션 특정 파라미터, 이동노드 NAI 파라미터 및 PDSN(232) 인증 파라미터를 포함하는 다수의 연장 필드들을 포함한다.
FACN(220)이 방문객 리스트 등록 요청 메세지(1208)를 수신하면, FACN(220)은 FACN(220)이 이동노드(220)에 대한 인증 데이타를 저장하고 있는지를 결정한다. 블록(1210)에서 도12에 제시된 실시예에 따르면, FACN(220)은 이동노드(210)와 관련된 인증 데이타를 가지고 있지 않다. FACN(220)은 PDSN(232)의 이전 인증 데이타를 가지고 있지 않기 때문에, FACN(220)은 방문객 리스트 등록 요청을 리젝트하고 방문객 리스트 등록 리젝트 응답 메세지(1212)를 PDSN(232)으로 전송한다. 도11의 방문객 리스트 등록 리젝트 응답 메세지(1114)와 유사한 방식으로, 방문객 리스트 등록 리젝트 응답 메세지(1212)는 인증 데이타 이용불가능 파라미터와 같은 리젝션 이유 파라미터를 포함할 수 있다. PDSN(232)이 FACN(220)으로부터 방문객 리스트 등록 리젝트 응답 메세지(1212)를 수신하면, PDSN(232)은 블록(1214)에서 제시된 바와 같이 이동노드(210)의 인증 데이타에 대해 AAA 서버(1102)에 질의한다. PDSN(232)이 일단 AAA 서버(1102)로부터 이동노드(210)의 인증 데이타를 수신하면, PDSN(232)은 이동노드(210)와의 PAP/CHAP 협상(1216)을 개시하여 이동노드(210) 및 PDSN(232) 사이에 통신링크를 설정한다.
일 실시예에 따르면, PDSN(232)이 이동노드(210)를 인증할 때, PDSN(232)은 이동노드(210)의 인증 데이타를 FACN(220)에 전송하여 FACN(220)이 PDSN(232)로부터 수신된 인증 데이타를 통해 이동노드(210)의 기존 이동 사용자 레코드를 갱신하거나 또는 이동노드(210)에 대한 새로운 이동 사용자 레코드를 발생시키도록 한다.도12에 제시된 실시예에서, PDSN(232)은 이동노드(210)의 인증 데이타를 포함하는 방문객 리스트 등록 갱신 메세지(1218)를 FACN(220)으로 전송한다. FACN(220)이 이동노드(210)의 인증 데이타를 수신하고 수신된 데이타를 이동노드(210)의 사용자 정보 레코드에 캐쉬하면, FACN(220)은 방문객 리스트 등록 확인 메세지(1220)를 PDSN(232)으로 전송하여 도12에 제시된 메세지 시퀀스 시나리오를 종결한다. PDSN(232)을 통한 성공적인 이동노드(210)의 등록시, 이동노드(210)는 IP 통신 링크상에서 데이타 통신을 개시한다.
이동노드(210)가 새로운 무선 네트워크 노드에 대해 정의된 PDSN 그룹들내의 최종 서빙 PDSN을 포함하지 않는 새로운 무선 네트워크 노드로 로밍하는 경우, FACN(220)은 이동노드(210)를 서비스할 새로운 PDSN을 선택한다. 이러한 시나리오는 이동 IP 통신 세션 또는 IP 통신 세션과 같은 통신 세션이 이동노드(210)에 현재 서비스를 제공하지 않는 PDSN으로 핸드오프되도록 한다. 이러한 시나리오는 "PDSN 핸드오프" 로 언급된다. FACN(220)은 PDSN들 및 FACN(220) 사이에 교환될 수 있는 일련의 갱신 메세지들을 통해 PDSN 핸드오프를 지원한다. 도13은 일 실시에에 따라 PDSN 핸드오프를 보여주는 메세지 시퀀스 시나리오(1300)의 블록 다이아그램이다. 상기 블록 다이아그램은 이동노드(210), 무선 네트워크 노드(216A), FACN(220), PDSN(232)과 같은 이전 PDSN, PDSN(234)과 같은 새로운 PDSN, 및 이동 노드(210)의 홈 에이젼트(24)를 포함한다. 무선 네트워크 노드(216A)의 서비스 영역으로의 로밍에 앞서, PDSN(232)은 블록(1302)에 제시된 바와 같이 이동노드(210)에 네트워크 서비스를 제공한다. 이동노드(210)가 무선 네트워크 노드(216A)의 새로운 서비스 영역으로 로밍할 때, 무선 네트워크 노드(216A)는 이동노드(210)에 통신 서비스를 제공하는 외부 에이젼트를 결정하기 위해 FACN(220)에 등록 요청 메세지(1304)를 전송한다. 등록 요청 메세지(1304)는 세션 특정 파라미터 및 이동노드(210)에 대한 식별 데이타와 같은 이동노드(210)와 관련된 다수의 파라미터들을 포함한다. 도13에 제시된 실시예에 따르면, PDSN(232)은 무선 네트워크 노드(216A)와 관련된 임의의 PDSN 그룹들에 포함되어 있지 않기 때문에, FACN(220)이 등록 요청 메세지(1304)를 수신하면, FACN(220)은 새로운 PDSN, PDSN(234)를 선택하여 이동노드(210)에 서비스를 제공한다. 이동노드(210)에 대한 PDSN(234) 선택시, FACN(220)은 등록 리젝트 파라미터를 포함하는 등록 응답 메세지(1306)를 전송하고(FACN(220)이 이동노드(210)에 대한 등록 서비스 제공을 리젝트하기 때문에), PDSN(234)의 네트워크 어드레스를 포함한다.
무선 네트워크 노드(216A)가 PDSN(234) 어드레스를 통해 FACN으로부터 등록 응답 메세지를 수신할 때, 무선 네트워크 노드(216A)는 블록(1308)에서 제시되듯이 PDSN(234)에 대한 PPP 통신 링크 상에서 RP 터널과 같은 통신 링크를 설정한다. 다음으로, 이동노드(210)는 등록 요청 메세지(1310)를 FACN(220)상에서 선택된 새로운 PDSN(234)으로 전송한다. 이동노드(210)가 새로운 PDSN(234)으로 핸드오프되기 때문에, PDSN(234)은 그 로컬 방문객 리스트에 이동노드(210)와 관련된 이동세션을 가지고 있지 않다. 따라서, 새로운 PDSN(234)은 이동노드(210)의 인증 데이타를 가지고 있지 않기 때문에, 새로운 PDSN(234)은 FACN(220)이 이동노드(210)의 인증 데이타를 가지고 있는지 여부를 결정하기 위해 FACN(220)에 방문객 리스트 등록 요청 메세지(1312)를 전송한다. 도13에 제시된 실시예에 따르면, 이동노드(210)는 다른 무선 네트워크 노드의 서비스 영역으로부터 무선 네트워크 노드(216A)의 서비스 영역으로 로밍하고, 따라서 이동노드(210)는 이전에 성공적으로 인증되었고 FACN(220)은 이전 등록으로부터 이동노드(210)의 인증 데이타를 가지고 있으며, 이는 블록(1314)에 제시된다. 또한, FACN(220)이 이동노드가 활성이라고 결정하면, FACN(220)은 방문객 리스트 등록 응답 메세지(1316)에서 이동노드(210)의 인증 데이타를 반환한다. 일 실시예에서, 방문객 리스트 등록 응답 메세지(1316)는 이동노드(210)의 인증 데이타를 포함하여 다수의 연장 필드를 가진다.
FACN(220)이 새로운 PDSN(234)에 인증 데이타를 제공하면, 새로운 PDSN(234)은 AAA 프로세스를 스킵하고 홈 에이젼트(24)를 통해 바로 등록된다. 따라서, 새로운 PDSN(234)이 방문객 리스트 등록 응답 메세지(1316)에서 인증 데이타를 수신하면, 새로운 PDSN(234)은 이동 IP 재등록 요청 처리를 위해 홈 에이젼트(24)와 통신한다. 이러한 새로운 PDSN(234) 및 홈 에이젼트 사이의 재등록 프로세스는 홈 에이젼트(24)로의 등록 요청 메세지(1318) 전송 및 홈 에이젼트(24)로부터 등록 응답 수용 메세시(1320) 수신을 포함하여 등록 프로세스를 완성한다.
새로운 PDSN(234)이 홈 에이젼트(24)를 통해 성공적으로 등록되면, 새로운 PDSN(234)은 등록 응답 메세지(1322)를 이동노드(210)에 전송하여 등록 처리 완료를 지시한다. 또한, 본 발명의 일 실시예에 따르면, 새로운 PDSN(234)은 등록 갱신 메세지를 FACN(220)에 전송한다. 그러나, 새로운 PDSN(234)은 이동노드(210)를인증하기 위해 AAA 서버를 사용하지 않고, 대신 FACN(220)으로부터 이동노드(210)의 인증 데이타를 수신하였기 때문에, 새로운 PDSN(234)에서 발생된 등록 갱신 메세지(1324)는 FACN(220)으로부터 수신된 인증 데이타를 포함할 필요가 없다. 일 실시예에서, 새로운 PDSN(234)이 등록 갱신 메세지(1324)를 FACN(220)으로 전송하면, 등록 갱신 메세지(1324)는 세션 특정 연장, 이동 노드 NAI 연장, 및 외부 에이젼트-홈 에이젼트 인증 연장을 포함하는 다수의 연장 필드들을 포함한다.
FACN(220)이 이동노드(210)의 인증 데이타 없이 등록 갱신 메세지(1324)를 수신하면, FACN(220)은 이동노드(210)에 대한 그 저장된 인증 프로파일을 갱신하지 않는다. 대신, FACN(220)은 그 메세지에 규정된 통신 세션을 활성세션으로 마킹하고 등록 확인 메세지(1326)를 FACN(220)으로 전송한다. 또한, 예시적인 실시예에 따르면, FACN(220)은 이전 이동세션 상태가 로밍에 앞서 활성이였는지, 그리고 엔트리내의 최종 방문 PDSN의 IP 어드레스가 등록 갱신 메세지(1324)에서 규정된 것과 상이한지 여부를 결정하기 위해 이동노드(210)와 관련된 이동 사용자 레코드를 사용한다. 도13에 제시된 실시예에 따르면, 이동노드(210)는 새로운 PDSN(234)으로 핸드오프되고, 따라서 새로운 PDSN(234)의 IP 어드레스는 최종 서빙 PDSN(이전 PDSN(232))의 IP 어드레스와 상이하다. 이러한 실시예에서, FACN(220)은 최종 서빙 PDSN(232)에 이동노드(210)의 이동세션이 더 이상 활성이 아님을 지시하는 연장을 포함하는 등록 갱신 메세지(1328)를 전송한다. 이전 PDSN(232)이 FACN(220)으로부터 등록 갱신 메세지(1328)를 수신하면, PDSN(232)은 소멸 세션과 관련된 존속기간 타이머를 기다림이 없이 등록 갱신 메세지(1328)에 규정된 이동 세션에 대한RP 터널을 클리어 업한다. 이전 PDSN(232)이 등록 갱신 메세지(1328)를 수신하면, 이전 PDSN(232)은 FACN(220)에 등록 확인 메세지(1330)을 전송하여 통신 세션이 비활성화 되었음을 지시한다. 홈 에이젼트(24)를 통한 PDSN(234)의 성공적인 재등록시, 이동노드(210)는 블록(1330)에 제시된 바와 같이, 새로운 PDSN(234)을 외부 에이젼트로 사용하여 데이타 통신을 계속한다.
여기서 제시된 프로그램, 프로세스, 방법 및 시스템을 특정 타입의 컴퓨터 또는 네트워크(하드웨어 또는 소프트웨어)와 관련되거나 이들로 제한되지 않는다. IP 네트워킹을 지원하는 다양한 타입의 일반적인 또는 특정된 컴퓨터 시스템들이 본 발명의 영역하에서 사용될 수 있다.
본 발명에서 제시된 실시예들은 단지 예시일뿐 다양한 변형이 가능함을 당업자는 잘 이해할 것이다. 예를 들어, 플로우 다이아그램의 단계들이 연속적으로 취해질 수 있고, 보다 많거나 적은 단계들 및 엘리먼트들이 사용될 수 있다. 선호되는 실시예들의 다양한 엘리먼트들이 소프트웨어에서 구현되지만, 다른 실시예에서 하드웨어 또는 펌웨어를 통해서 구현될 수도 있다.
본 발명을 통해 이동 IP 네트워크에서 효율적으로 패킷 데이타 서빙 노드를 선택할 수 있게된다.
*본 발명은 컴퓨터 프로그램 리스팅을 포함하고, 이는 저작권에 의해 보호된다.
/* Copyright 1999-2000 3Com Corporation. All Rights Reserved. */
/* $Id: mip.c,v 1.25 2001/04/16 17:34:48 fdickson Exp $ */
/******************************************************************************
*
* Filename: mip.c
*
* Description: This file contains functions processing MIP messages.
*
* Author:
*
******************************************************************************/
/* 03/10/01 SEC MR 4709 - By a configuration option, allow an RNN
key to use less than 16 bytes. A potential zero byte will
terminate the length used for autentication. */
/* 03/10/01 SEC MR 4723 - Return the high order ident field sent
on a Registraion Request, unless a Replay Attack. */
/* 03/10/01 SEC MR 4667 - Add a CLI command that allows logging of RNN MIP
messages to the FACN, possibly qualified by an IMSI. */
/* 05/15/01 SEC MR 5267 - RNN Reg Req buffer modified on
CLI log_mip_mobile command */
/*
* Include Files
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/fcntl.h>
#include <signal.h>
#include <errno.h>
#include <sys/time.h>
#include "facn.h"
#include "avl.h"
#include "mip_msgs.h"
#include "facn_log.h"
#include "facn_config.h"
#include "db_rnn.h"
#include "db_mobile.h"
#include "db_pdsn.h"
#include "facn_common.h"
#include "facn_stats.h"
#include "db_proto.h"
/* Defines */
/* Change to reflect RFC 2002 - section 5.6.1 */
#define RNN_KEY_SIZE (!(config_ptr->variable_key_length)||\f1
config_ptr->rnn_key[MD5_KEY_LENGTH-1]?\f1
MD5_KEY_LENGTH:\f1
strlen(config_ptr->rnn_key))
/* #define RNN_KEY_SIZE MD5_KEY_LENGTH */
/* Globals */
/* Externs */
extern UCHAR *facn_auth(UCHAR *digest,UCHAR *msg, UINT32 msg_len,UCHAR *key,UINT32 key_len);
extern UINT32 Facn_checkReplay( mip_ident_t *new, mip_ident_t *saved);
extern void facn_log(int pri, char *msg, ...);
extern UINT32 get_timestamp();
extern facn_config_t *config_ptr;
extern facn_stats_t *stats_ptr;
extern db_avltree_t *rnn_db_ptr;
extern pdsn_group_t pdsn_group[];
extern facn_socket_t sock[];
extern db_avltree_t *pdsn_db_ptr;
extern UINT32 cli_mip_logging;
extern UCHAR cli_log_imsi[];
extern int cli_log_imsi_len;
/*
* Prototypes
*/
/******************************************************************************
*
* UINT32 process_reg_ext(
* I mip_reg_req_t *msg,
* I UINT32 len,
* O UCHAR *tmp_mobile_addr)
* This function gets the extentions contained in the
* RP mobile registration message. tmp_mobile_addr contains the
* concatenation of mn_id + mn_connection_id.
* Returns 0 on success.
*
******************************************************************************/
UINT32
process_reg_ext(mip_reg_req_t *msg,UINT32 len,UCHAR *tmp_mobile_addr,
int *tmp_mobile_addr_len)
UCHAR *start, *end;
mip_ext_t *ext;
mip_sess_spec_ext_t *ss_ext;
mip_mbl_home_auth_ext_t *mh_ext;
UCHAR check_buf[MD5_KEY_LENGTH];
UINT32 ext_len, i, msg_len, tmp_spi;
UINT16 vse_len;
mip_crit_vos_t *vse_ext;
UINT32 found_addr = 0;
UINT32 authenticated = 0;
UINT32 result = 0;
int rnn_key_size = RNN_KEY_SIZE;
start = (UCHAR *)((mip_reg_req_t *)msg)->ext;
end = (UCHAR *)((UINT32)(msg) + len);
while ((start < end) (result == 0))
ext = (mip_ext_t *)start;
switch(ext->type)
case MIP_EXT_ONE_BYTE_PADDING:
ext_len = sizeof(mip_onebyte_pad_ext_t);
break;
case MIP_EXT_CRIT_VEND_ORG_SPEC:
vse_ext = (mip_crit_vos_t *)start;
memcpy((UCHAR *)vse_len, (UCHAR *)vse_ext->length, 2);
vse_len = ntohs(vse_len);
ext_len = vse_len + CVSE_OFFSET;
break;
default:
ext_len = ext->len + sizeof(mip_ext_t);
break;
switch(ext->type)
case MIP_EXT_NORM_VEND_ORG_SPEC:
case MIP_EXT_CRIT_VEND_ORG_SPEC:
case MIP_EXT_MOBILE_FOREIGN_AUTH:
case MIP_EXT_FOREIGN_HOME_AUTH:
break;
case MIP_EXT_MOBILE_HOME_AUTH:
mh_ext = (mip_mbl_home_auth_ext_t *) ext;
/* Check that length of mh_ext->auth[] == rnn_key_size */
if ( (mh_ext->len - 4 ) != rnn_key_size )
facn_log(LOG_ERR, "RP Authentication Failed Incorrect Length %d",
mh_ext->len - 4 );
result = MIP_CODE_MOBILE_NODE_FAILED_AUTH;
stats_ptr->rnn_fail_key++;
break;
/* check the received RNN SPI against our configuration */
memcpy((UCHAR *)tmp_spi, (UCHAR *)mh_ext->spi, 4);
tmp_spi = ntohl(tmp_spi);
if ( tmp_spi != config_ptr->rnn_key_spi )
facn_log(LOG_ERR, "RP Authentication Failed Incorrect RNN SPI %d", tmp_spi);
result = MIP_CODE_MOBILE_NODE_FAILED_AUTH;
/* 12/04/00 SEC MR 4266 - If an RNN fails authetication
due to a bad key/SPI, show if the error is due to a
bad key or a bad SPI. */
stats_ptr->rnn_fail_spi++;
break;
msg_len = (start - (UCHAR *)msg + sizeof(mip_mbl_home_auth_ext_t));
facn_auth((UCHAR *)check_buf, /* digest */
(UCHAR *)msg, /* message */
msg_len,
config_ptr->rnn_key, /* key */
rnn_key_size /* key len */
);
for (i = 0; i < rnn_key_size; i++)
if ((UINT8)mh_ext->auth[i] != (UINT8)check_buf[i])
facn_log(LOG_ERR, "RP Authentication Failed");
result = MIP_CODE_MOBILE_NODE_FAILED_AUTH;
stats_ptr->rnn_fail_key++;
break;
authenticated = 1;
break;
case MIP_EXT_SESS_SPEC:
ss_ext = (mip_sess_spec_ext_t *) ext;
/* Validate mn_id_type and mn_id_length */
if (ss_ext->mn_id_type != MIP_MN_ID_TYPE) /* type IMSI */
facn_log(LOG_ERR, "Incorrect mn_id_type %d != 6 (IMSI)", ss_ext->mn_id_type);
result = MIP_CODE_POORLY_FORMED_REQUEST;
stats_ptr->rnn_fail_req++;
break;
/* add check for max / min imsi length (use 2 for min) */
if ((ss_ext->mn_id_len > MIP_MN_ID_LENGTH) ||
(ss_ext->mn_id_len < 2))
facn_log(LOG_ERR, "Incorrect mn_id_len %d > %d ",
ss_ext->mn_id_len,
MIP_MN_ID_LENGTH);
result = MIP_CODE_POORLY_FORMED_REQUEST;
stats_ptr->rnn_fail_req++;
break;
/* Copy the Mobile Address (zero fill) and Connection ID */
for (i = 0; i < MIP_MN_ID_LENGTH; i++)
if (i < ss_ext->mn_id_len)
*(tmp_mobile_addr + i) = ss_ext->mn_id[i];
else
*(tmp_mobile_addr + i) = 0;
*tmp_mobile_addr_len = ss_ext->mn_id_len;
memcpy(tmp_mobile_addr + MIP_MN_ID_LENGTH, (UCHAR *)ss_ext->mn_connection_id, MOBILE_CONNECT_ID_SIZE);
found_addr = 1;
break;
default:
break;
start += ext_len;
if (result == 0)
if (start > end)
facn_log(LOG_ERR,"Incorrect Extension Format");
result = MIP_CODE_POORLY_FORMED_REQUEST;
stats_ptr->rnn_fail_req++;
else
if (found_addr != 1 || authenticated != 1)
facn_log(LOG_ERR,"|=formed RP rqst addr %d auth %d",
found_addr, authenticated);
result = MIP_CODE_POORLY_FORMED_REQUEST;
stats_ptr->rnn_fail_req++;
return(result);
/******************************************************************************
*
* UINT32 select_pdsn( I rnn_data_t *rnn_ptr,
* I UCHAR *tmp_mobile_addr,
* I mip_ident_t *ident,
* O UINT32 *result)
*
* Selects the pdsn for this mobile based on the current rnn's configuration
* association with pdsns, and the status of those pdsns.
* If the `result' is 0, it returns selected pdsn as a unsigned integer, else
* the return is undefined.
*
******************************************************************************/
UINT32
select_pdsn(rnn_data_t *rnn_ptr, UCHAR *tmp_mobile_addr,mip_ident_t *ident,UINT32 *result, int tmp_mobile_addr_len)
mobile_data_t *mobile_ptr;
pdsn_data_t *pdsn_ptr;
pdsn_data_t *backup_pdsn_ptr;
UINT32 group_id;
UINT32 selected_pdsn = 0;
UINT32 backup_pdsn = 0;
UINT32 backup_group = 0;
UINT32 backup_load = 0;
UINT32 ret = 1;
UCHAR *ptr;
int i,j;
/* before we go through this, check the ID field for time drift only */
if (Facn_checkReplay(ident, NULL) == 1)
*result = MIP_CODE_REG_IDENT_MISMATCH;
facn_log(LOG_INFO, "*** RNN Registration request ID time drift");
stats_ptr->rnn_fail_id++;
return(NULL);
ptr = tmp_mobile_addr;
/* find the mobile */
mobile_ptr = (mobile_data_t *) db_mobile_lookup(tmp_mobile_addr,
tmp_mobile_addr_len);
if (mobile_ptr != NULL)
/* Check for a replay attack */
if (Facn_checkReplay(ident, mobile_ptr->rp_ident) == 1 )
*result = MIP_CODE_REG_IDENT_MISMATCH;
// mobile_ptr->rp_ident.low_order = ntohl(ident->low_order);
facn_log(LOG_INFO, "*** RNN Registration request ID mismatch");
stats_ptr->rnn_fail_id++;
ret = 0;
else
/* ident ok - store it */
mobile_ptr->rp_ident.low_order = ntohl(ident->low_order);
mobile_ptr->rp_ident.high_order = ntohl(ident->high_order);
/* check to see if this call already active on a PDSN */
//printf("ACT %d, LAST %x",mobile_ptr->active_sessions,mobile_ptr->last_pdsn);
if ((mobile_ptr->active_sessions) (mobile_ptr->last_pdsn))
pdsn_ptr = (pdsn_data_t *)db_pdsn_lookup(mobile_ptr->last_pdsn);
//printf("PDSN_PTR %x, RNN_PTR %x",pdsn_ptr,rnn_ptr);
if (pdsn_ptr != NULL)
/* make sure the PDSN can handle the call - note here we
look for <= to call threshold since this call is
already there (as opposed to < when assigning a new call) */
/* 10/12/00 fix to SEC MR 1011-2, add check for PDSN unavail */
//printf("S %d, CL %d, CPU %d, MEM %d",pdsn_ptr->status,pdsn_ptr->call_load,pdsn_ptr->cpu_usage,pdsn_ptr->mem_usage);
if((pdsn_ptr->status == ACTIVE)
(!pdsn_ptr->misc_unavail)
(pdsn_ptr->call_load <= config_ptr->call_load_threshold)
(pdsn_ptr->cpu_usage < config_ptr->cpu_usage_threshold)
(pdsn_ptr->mem_usage < config_ptr->memory_threshold))
/* scan the RNN record to get the list of valid
PDSN groups */
if (rnn_ptr)
/* see if this PDSN is valid for this RNN */
for (i=0;(i<MAX_GRPS_PER_RNN) (rnn_ptr->pdsn_grp[i] != -1); i++)
/* check the PDSNs in this group */
group_id = rnn_ptr->pdsn_grp[i];
for(j=0;(j<config_ptr->max_pdsns_per_grp) (pdsn_group[group_id].pdsn_id[j]);j++)
//printf("LAST_PDSN %x %x, NEXT_IN_GRP %x",mobile_ptr->last_pdsn,pdsn_ptr->pdsn_id,pdsn_group[group_id].pdsn_id[j]);
if (pdsn_group[group_id].pdsn_id[j] ==pdsn_ptr->pdsn_id)
/* found the pdsn in one of this RNN's valid groups */
selected_pdsn = pdsn_ptr->pdsn_id;
stats_ptr->rnn_succ_reg++;
facn_log(LOG_DEBUG, "Using last pdsn %x.",mobile_ptr->last_pdsn);
//printf("1 %x thresh=%d, this=%d", pdsn_ptr->pdsn_id, config_ptr->call_load_threshold, pdsn_ptr->call_load);
break;
if (selected_pdsn)
break;
else
/* if no RNN record, return "administratively
prohibited" (shouldn't happen) */
*result = MIP_CODE_ADMINISTRATIVELY_PROHIBITED;
stats_ptr->rnn_fail_reg++;
ret = 0;
facn_log(LOG_ERR,"No RNN record found.");
else
facn_log(LOG_DEBUG,
"Last PDSN inactive or over threshold %x.",
mobile_ptr->last_pdsn);
else
facn_log(LOG_DEBUG,
"Last PDSN (%x) for Mobile %x not found in the database.",
mobile_ptr->last_pdsn,
mobile_ptr->mobile_id);
else
facn_log(LOG_DEBUG,
"No last PDSN or no active sessions for Mobile %x.",
mobile_ptr->mobile_id);
/*
* if no PDSN yet selected and there was no error select the PDSN now
*/
if ((!selected_pdsn) ret)
/* scan the RNN record to get the list of valid PDSN groups */
if (rnn_ptr)
/* find a suitable PDSN in one of this RNN's valid groups */
/* first look for one that has less than the call balance threshold,
and settle for one that simply passes all tests if not,
and has the least call load of the valid PDSNs */
for (i=0;(i<MAX_GRPS_PER_RNN) (rnn_ptr->pdsn_grp[i] != -1); i++)
/* check the PDSNs in this group */
group_id = rnn_ptr->pdsn_grp[i];
for(j=0;(j<config_ptr->max_pdsns_per_grp) (pdsn_group[group_id].pdsn_id[j]);j++)
pdsn_ptr = (pdsn_data_t *)db_pdsn_lookup(pdsn_group[group_id].pdsn_id[j]);
if (pdsn_ptr != NULL)
/* 10/12/00 fix to SEC MR 1011-2, add check for PDSN unavail */
if((pdsn_ptr->status == ACTIVE)
(!pdsn_ptr->misc_unavail)
(pdsn_ptr->call_load <
config_ptr->call_load_threshold )
(pdsn_ptr->call_load <
config_ptr->call_balanced_threshold)
(pdsn_ptr->cpu_usage <
config_ptr->cpu_usage_threshold )
(pdsn_ptr->mem_usage < config_ptr->memory_threshold ))
/* found a pdsn in one of this RNN's valid groups */
//printf("2 %x thresh=%d, this=%d", pdsn_ptr->pdsn_id, config_ptr->call_balanced_threshold, pdsn_ptr->call_load);
selected_pdsn = pdsn_ptr->pdsn_id;
pdsn_ptr->call_load++;
stats_ptr->rnn_succ_reg++;
facn_log(LOG_DEBUG,
"Found a preferred pdsn %x in group %d load %d.",
selected_pdsn,pdsn_group[group_id].group_id,
pdsn_ptr->call_load);
break;
else
/* if this PDSN meets the thresholds,
check for new backup */
/* 10/12/00 fix to SEC MR 1011-2, add check for PDSN unavail */
if((pdsn_ptr->status == ACTIVE)
(!pdsn_ptr->misc_unavail)
(pdsn_ptr->call_load <
config_ptr->call_load_threshold)
(pdsn_ptr->cpu_usage <
config_ptr->cpu_usage_threshold)
(pdsn_ptr->mem_usage <
config_ptr->memory_threshold))
/* found a pdsn in one of this RNN's valid groups
that meets thresholds - if no backup pdsn yet
or this call load < backup, set new backup */
if ((!backup_pdsn) ||
(pdsn_ptr->call_load < backup_load))
backup_pdsn_ptr = pdsn_ptr;
backup_pdsn = pdsn_ptr->pdsn_id;
backup_group = pdsn_group[group_id].group_id;
backup_load = pdsn_ptr->call_load;
if (selected_pdsn)
break;
/* see if we have a preferred or backup pdsn */
if (!selected_pdsn backup_pdsn)
//printf("3 %x thresh=%d, this=%d", backup_pdsn,config_ptr->call_load_threshold,backup_load);
selected_pdsn = backup_pdsn;
backup_pdsn_ptr->call_load++;
stats_ptr->rnn_succ_reg++;
facn_log(LOG_DEBUG,
"Found a suitable pdsn %x in group %d load %d.",
selected_pdsn,backup_group,backup_load);
/* if we couldn't find a suitable PDSN, return "insufficient
resources" */
if (!selected_pdsn)
util_send_trap(PDSN_SELECTION_FAIL_TRAP, rnn_ptr->rnn_id);
facn_log(LOG_ERR,"No available PDSN for RNN (in Hex) %x",
rnn_ptr->rnn_id);
*result = MIP_CODE_INSUFFICIENT_RESOURCES;
stats_ptr->rnn_fail_reg++;
else
/* if no RNN record, return "administratively prohibited"
(shouldn't happen) */
*result = MIP_CODE_ADMINISTRATIVELY_PROHIBITED;
stats_ptr->rnn_fail_reg++;
facn_log(LOG_ERR,"No RNN record.");
return(selected_pdsn);
/******************************************************************************
*
* UCHAR * find_extension(UCHAR type, UCHAR * start, UCHAR *end)
* Searches from start to end in a list of extensions to find type.
* On success, return != NULL
*
******************************************************************************/
UCHAR *
find_extension(UCHAR type, UCHAR * start, UCHAR *end)
mip_ext_t *c_ext;
UINT32 c_ext_len;
UINT16 vse_len;
mip_crit_vos_t *vse_ext;
while (start < end)
c_ext = (mip_ext_t *)start;
/*
* Determine the size of the extension
*/
switch(c_ext->type)
case MIP_EXT_ONE_BYTE_PADDING:
c_ext_len = sizeof(mip_onebyte_pad_ext_t);
break;
case MIP_EXT_CRIT_VEND_ORG_SPEC:
vse_ext = (mip_crit_vos_t *)start;
memcpy((UCHAR *)vse_len, (UCHAR *)vse_ext->length, 2);
vse_len = ntohs(vse_len);
c_ext_len = vse_len + CVSE_OFFSET;
break;
default:
c_ext_len = c_ext->len + sizeof(mip_ext_t);
break;
if (c_ext->type == type)
break;
start += c_ext_len;
if (start < end)
return(start);
else
return(NULL);
/*****************************************************************************
*
* send_reg_reply() - This function sends the registration reply back to the
* requesting PDSN.
*
* Parameters:
* I *recv_msg - The received MIP registration message.
* I len - Length of the message.
* I pdsn_id -
* I code -
* I *from - socket data
*
* Return Values:
* -1 - Failed to send the reply.
* 0 - Succesfully sent the reply.
*
****************************************************************************/
INT32
send_reg_reply(mip_reg_req_t *recv_msg,UINT32 len, UINT32 pdsn_id,UINT32 code, struct sockaddr_in *from)
UCHAR *p;
UINT32 send_len, ext_size;
UCHAR *start, *end;
struct sockaddr_in dest;
mip_reg_req_t *req;
mip_reg_reply_t *reply;
mip_mbl_home_auth_ext_t *mn_ext;
UCHAR send_msg[3000];
UINT32 spi;
int rnn_key_size = RNN_KEY_SIZE;
/* Setup Destination Address */
dest.sin_family = AF_INET;
dest.sin_port = from->sin_port;
dest.sin_addr.s_addr = from->sin_addr.s_addr;
req = (mip_reg_req_t *) recv_msg;
reply = (mip_reg_reply_t *) send_msg;
reply->type = MIP_TYPE_REG_REPLY;
reply->home_agent_addr = htonl(pdsn_id);
// reply->home_addr = req->care_of_addr;
reply->home_addr = 0;
reply->ident = req->ident;
/* MR4726 - Change to reflect RFC 2002 - section 5.6.1 */
if( code == MIP_CODE_REG_IDENT_MISMATCH )
reply->ident.high_order = htonl(get_timestamp());
if (code == 0)
reply->code = MIP_CODE_FACN_ASSIGN_PDSN_TO_RNN;
/* use Minimum of config_ptr->reg_lifetime and req->lifetime */
/* req->lifetime already in network order */
if ( ntohs(req->lifetime) > config_ptr->reg_lifetime)
reply->lifetime = htons(config_ptr->reg_lifetime);
else
/* req->lifetime already in network order */
reply->lifetime = req->lifetime;
else
reply->code = code;
reply->lifetime = 0;
/* copy the extensions */
start = (UCHAR *)((mip_reg_req_t *)req)->ext;
end = (UCHAR *)((UINT32)(recv_msg) + len);
ext_size = (UINT32)(end - start);
//facn_log(LOG_DEBUG,"send_reg_reply(): start = %x, end = %x, ext_size = %x",start,end,ext_size);
send_len = sizeof(mip_reg_reply_t) + ext_size;
if ( (send_len + sizeof(mip_mbl_home_auth_ext_t) + rnn_key_size) > sizeof(send_msg) )
facn_log(LOG_ERR, "send_len of mip reg reply (%d) > sizeof send_msg (%d)",
send_len,
sizeof(send_msg));
return (-1);
memcpy(reply->ext, req->ext, ext_size);
#ifdef REPLY_CVSE // send the CVSE back in the reply if defined (generally not)
/* Re-Compute the Authenticator */
p = find_extension(MIP_EXT_MOBILE_HOME_AUTH,reply->ext,reply->ext+ext_size);
if (p != NULL)
mn_ext = (mip_mbl_home_auth_ext_t *)p;
else
/* add authenticator to the end of the message */
p = reply->ext + ext_size;
mn_ext = (mip_mbl_home_auth_ext_t *)p;
send_len += sizeof( mip_mbl_home_auth_ext_t) + rnn_key_size;
#else
/* find the CVSE ext and put the new auth over it */
p = find_extension(MIP_EXT_CRIT_VEND_ORG_SPEC,reply->ext,reply->ext+ext_size);
if (p == NULL)
/* no CVSE, find the old auth ext and put the new auth over it */
p = find_extension(MIP_EXT_MOBILE_HOME_AUTH,reply->ext,reply->ext+ext_size);
if (p == NULL)
/* couldn't find CVSE or auth ext, add new auth to msg end */
p = reply->ext + ext_size;
/*
* Setup MobileHomeAuthenticationExtension
*/
mn_ext = (mip_mbl_home_auth_ext_t *)p;
mn_ext->type = MIP_EXT_MOBILE_HOME_AUTH;
mn_ext->len = sizeof (mip_mbl_home_auth_ext_t) +
rnn_key_size - 2; /* lengths do not include the type and length */
spi = config_ptr->rnn_key_spi;
spi = htonl(spi);
memcpy (mn_ext->spi, (UCHAR *)spi, 4);
send_len = p + sizeof(mip_mbl_home_auth_ext_t) + rnn_key_size - send_msg;
#endif
facn_auth((UCHAR *)mn_ext->auth,
(UCHAR *)send_msg,
(UINT32)mn_ext->auth - (UINT32)send_msg,
config_ptr->rnn_key,
rnn_key_size
);
/* If CLI logging of MIP messages, see if this message should be logged */
if( cli_mip_logging )
util_log_mip_msgs( send_msg, send_len, dest,
MIP_TYPE, MIP_TO );
mip_print_msgs(send_msg, send_len, dest, MIP_TYPE, MIP_TO);
/* Send the message through the Facn Registration Socket */
if ( sendto(sock[MIP_PORT].sockfd,
send_msg,
send_len,
0,
(struct sockaddr *)dest,
sizeof(struct sockaddr_in)
) < 0 )
facn_log(LOG_ERR, "Reg Request Sendto Call Error");
return (-1);
return (0);
/****************************************************************************
*
* process_reg_req() - This function handles MIP registration requests which
* are received from the RNN.
*
* Args: I *recv_mesg - message from RNN
* I len - length of the message
* I *from - socket data
*
* Return Values: -1 - error processing the message
* 0 - no error
*
****************************************************************************/
INT32
process_reg_req(mip_reg_req_t *recv_mesg, UINT32 len, struct sockaddr_in *from)
UINT32 care_of_addr, home_agent_addr, result = 0;
UINT32 pdsn_id = 0;
mip_reg_req_t *req;
rnn_data_t *rnn_ptr;
UCHAR tmp_mobile_addr[MOBILE_ID_SIZE];
int tmp_mobile_addr_len;
req = recv_mesg;
home_agent_addr = ntohl(req->home_agent_addr);
care_of_addr = ntohl(req->care_of_addr);
facn_log(LOG_DEBUG, "RNN MIP_TYPE_REG_REQUEST care of addr = %x",
care_of_addr);
/* Process Extensions */
result = process_reg_ext(recv_mesg,len,(UCHAR *)tmp_mobile_addr,
tmp_mobile_addr_len);
if (result == 0)
/* Try to add the RNN to the database. */
if (care_of_addr != 0 )
/* if there is no RNN record yet, send RNN discovery trap */
rnn_ptr = (rnn_data_t *)db_rnn_lookup(care_of_addr);
if (rnn_ptr == NULL)
util_send_trap(RNN_DISCOVERY_TRAP, care_of_addr);
rnn_ptr = (rnn_data_t *)db_rnn_add(care_of_addr);
if (rnn_ptr == NULL)
facn_log(LOG_ERR,"RNN %x database addition failed.",care_of_addr);
//return(-1);
else
facn_log(LOG_ERR, "Invalid care of address (rnn ip addr) 0x%x == 0 ", care_of_addr);
result = MIP_CODE_POORLY_FORMED_REQUEST;
stats_ptr->rnn_fail_req++;
/* PDSN Selection */
if (result == 0)
facn_log(LOG_DEBUG,"*** process_reg_ext returned length = %d",
tmp_mobile_addr_len);
pdsn_id = select_pdsn(rnn_ptr,(UCHAR *)tmp_mobile_addr,req->ident,
result, tmp_mobile_addr_len);
#if 0
/* Ignore Replay Attacks and retrys for already processed messages. */
if (result != MIP_CODE_REG_IDENT_MISMATCH)
send_reg_reply(recv_mesg,len,pdsn_id,result,from);
else
facn_log(LOG_INFO,"Replay Attack, Mobile Id = %x",tmp_mobile_addr);
return(-1);
#else
send_reg_reply(recv_mesg,len,pdsn_id,result,from);
#endif
return(0);
/******************************************************************************
*
* mip_process_msg() - This functions processes the MIP messages received
* through the registration port.
*
* Parameters - I *mesg - received message
* I len - length of the message
* I *from - socket data
*
* Return Value: None
*
******************************************************************************/
void
mip_process_msg(UCHAR *mesg,UINT32 len,struct sockaddr_in *from)
mip_reg_t *packet;
packet = (mip_reg_t *)mesg;
/* If CLI logging of MIP messages, see if this message should be logged*/
if( cli_mip_logging )
util_log_mip_msgs( mesg, len, from, MIP_TYPE, MIP_FROM );
mip_print_msgs(mesg, len, from, MIP_TYPE, MIP_FROM);
switch(packet->type)
case MIP_TYPE_REG_REQUEST:
process_reg_req((mip_reg_req_t *)mesg,len,from);
break;
case MIP_TYPE_REG_UPDATE:
break;
case MIP_TYPE_REG_REPLY:
default:
facn_log(LOG_ERR, "Received unknown MIP packet type = %d",packet->type);
break;
/* $Log: mip.c,v $
/* Revision 1.25 2001/04/16 17:34:48 fdickson
/* Added RNN in error display.
/*
/* Revision 1.24 2001/03/09 23:49:34 fdickson
/* Allow an option for variable length keys (MR4709), return the high order received ident field (MR4723), and add logging of mip messages (sent to the CLI) (MR4667).
/*
/* Revision 1.23 2001/01/23 22:35:48 fdickson
/* Modified LOG_DEBUG messages.
/*
/* Revision 1.22 2000/12/04 23:09:46 fdickson
/* SEC MR 4266 - If an RNN fails authetication due to a bad key/SPI, show if the error is due to a bad key or a bad SPI.
/*
/* Revision 1.21 2000/10/30 20:25:52 glewis
/* add check for min imsi len
/*
/* Revision 1.20 2000/10/12 20:50:23 glewis
/* add check for pdsn unavailable code when doing pdsn selection
/*
/* Revision 1.19 2000/09/28 22:31:11 fdickson
/* Added IMSI length to routines that call lookup, delete, or insert of mobile reco
/* rds.
/*
/* Revision 1.18 2000/09/22 22:40:58 glewis
/* check for MIP ID time drift before proceeding with msg parsing, also send
/* reply with error if ID mismatch
/*
/* Revision 1.17 2000/08/17 23:09:15 glewis
/* added some (commented out) printfs, fixed some formatting
/*
/* Revision 1.16 2000/08/16 00:14:36 glewis
/* add checking for RNN key spi
/*
/* Revision 1.15 2000/08/15 18:23:28 glewis
/* when assigning the previous PDSN on an RNN handoff, check for <= call
/* threshold (instead of <) since the call is already there
/*
/* Revision 1.14 2000/08/15 16:49:16 fdickson
/* Added load balancing threshold to PDSN selection.
/*
/* Revision 1.13 2000/07/17 18:12:31 glewis
/* changed PDSN selection algorithm
/*
/* Revision 1.12 2000/06/10 00:21:59 glewis
/* change reg reply to exclude the received CVSE, put mip msg print back in
/*
/* Revision 1.11 2000/06/06 23:50:37 fdickson
/* Passed a value with a trap call.
/*
/* Revision 1.10 2000/06/05 17:04:41 glewis
/* fix bug in processing extensions, use define intead of "3", zero home addr
/* in rp reg reply, enhance error msg
/*
/* Revision 1.9 2000/05/31 20:18:21 glewis
/* add support for PDSN_SELECTION_FAIL_TRAP and RNN_DISCOVERY_TRAP
/*
/* Revision 1.8 2000/05/25 21:29:28 pwl
/* code review clean up
/*
/* Revision 1.7 2000/05/05 18:47:41 glewis
/* save low order if replay attack to be consistent with visitor code
/* (if not we will change in all 3 places)
/*
/* Revision 1.6 2000/05/03 21:34:49 pwl
/* changed replay checking and ident initializing
/*
/* Revision 1.5 2000/05/03 17:55:58 glewis
/* change to handle imsi length of less than 8
/*
/* Revision 1.4 2000/05/02 19:24:56 glewis
/* add handling of critical VSE in RP reg rqst, add simple load balancing to
/* PDSN selection, fix selection to break properly if preferred PDSN found and
/* to search proper PDSN groups
/*
/* Revision 1.3 2000/04/26 00:05:35 glewis
/* changed log of RP reg errs to LOG_ERR
/*
/* Revision 1.2 2000/04/14 22:57:55 glewis
/* bump RNN registration statistics
/*
/* Revision 1.1 2000/04/12 17:35:35 obrien
/* Initial Revision
/* */
/* Copyright 1999-2000 3Com Corporation. All Rights Reserved. */
/* $Id: visitor.c,v 1.35 2001/05/01 17:38:52 glewis Exp $ */
/******************************************************************************
*
* Filename: visitor.c
*
* Description: This file contains functions for processing the Visitor
* List messages.
*
* Author:
*
******************************************************************************/
/* MR history */
/* 04/27/01 SEC MR 5153 - Do not return cache data on a PDSN Registration
Request, unless the mobile session is ACTIVE. */
/* Include Files */
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <signal.h>
#include <syslog.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include "facn.h"
#include "avl.h"
#include "mip_msgs.h"
#include "facn_log.h"
#include "facn_config.h"
#include "db_rnn.h"
#include "db_mobile.h"
#include "db_pdsn.h"
#include "db_proto.h"
#include "facn_common.h"
#include "facn_stats.h"
/* Defines */
/* Externs */
extern nai_data_t * db_mobile_add_nai(mobile_data_t *mobile_ptr, char *nai_ptr, UINT32 nai_len);
extern nai_data_t *db_mobile_find_nai(mobile_data_t *mobile_ptr, UCHAR *nai_ptr, UINT32 nai_len);
extern INT32 db_delete_thru_nai( nai_data_t *nai_ptr );
extern INT32 db_delete_multi_nai( int count );
extern UINT32 mip_print_msgs(UCHAR *recv_msg, UINT32 length, struct sockaddr_in *from, int type, int direction);
extern void print_hex( int priv, UCHAR *msg, UINT32 len );
extern UCHAR *facn_auth(UCHAR *digest,UCHAR *msg, UINT32 msg_len,UCHAR *key,UINT32 key_len);
extern UINT32 Facn_checkReplay( mip_ident_t *new, mip_ident_t *saved);
extern UINT32 Co_TimeOut(void(*func)(), UINT32 arg, UINT32 ticks);
extern void facn_log(int pri, char *msg, ...);
extern facn_socket_t sock[];
extern facn_config_t *config_ptr;
extern facn_stats_t *stats_ptr;
extern UINT32 cli_mip_logging;
//#define SIM 1
/* Functions */
UINT32
getTimestamp()
struct timeval tv;
long seconds;
gettimeofday(tv, NULL);
seconds = tv.tv_sec + UNIX_NTP_DIFF;
return (seconds);
/******************************************************************************
*
* UCHAR * vl_find_ext( I UCHAR type,
I UCHAR * start,
I UCHAR *end)
*
* Looks for extension type from start to end.
* On success, returns ptr to start of extension.
*
******************************************************************************/
UCHAR *
vl_find_ext(UCHAR type, UCHAR * start, UCHAR *end)
mip_ext_t *c_ext;
UINT32 c_ext_len;
UINT16 vse_len;
mip_crit_vos_t *vse_ext;
while (start < end)
c_ext = (mip_ext_t *)start;
/*
* Determine the size of the extension
*/
switch(c_ext->type)
case MIP_EXT_ONE_BYTE_PADDING:
c_ext_len = sizeof(mip_onebyte_pad_ext_t);
break;
case MIP_EXT_CRIT_VEND_ORG_SPEC:
vse_ext = (mip_crit_vos_t *)start;
memcpy((UCHAR *)vse_len, (UCHAR *)vse_ext->length, 2);
vse_len = ntohs(vse_len);
c_ext_len = vse_len + CVSE_OFFSET;
break;
default:
c_ext_len = c_ext->len + sizeof(mip_ext_t);
break;
if (c_ext->type == type)
break;
start += c_ext_len;
if (start < end)
return(start);
else
return(NULL);
/******************************************************************************
*
* UCHAR * vl_get_cached_data( I UCHAR *ptr,
* O UCHAR *cached_data,
* O UINT32 *cached_data_len,
* UINT32 ext_size)
*
*
******************************************************************************/
UCHAR *
vl_get_cached_data( UCHAR *ptr,UCHAR *cached_data,UINT32 *cached_data_len,UINT32 ext_size)
mip_crit_vos_t *vse_ext;
UINT16 vse_len;
UINT16 vendor_type;
UINT32 net_order32;
UCHAR *ext_start;
UCHAR *p;
UINT32 i;
p = ptr;
i = 0;
ext_start = ptr;
while ( p != NULL p < ext_start + ext_size )
i ++;
p = vl_find_ext( MIP_EXT_CRIT_VEND_ORG_SPEC,
p, /* start */
ext_start + ext_size); /* end */
if (p != NULL)
vse_ext = (mip_crit_vos_t *)p;
memcpy((UCHAR *)net_order32, vse_ext->vendor_id, 4);
memcpy((UCHAR *)vse_len, (UCHAR *)vse_ext->length, 2);
vse_len = ntohs(vse_len);
memcpy((UCHAR *)vendor_type, (UCHAR *)vse_ext->vendor_type, 2);
vendor_type = ntohs(vendor_type);
if (net_order32 == htonl(MIP_VENDOR_3COM))
if (vendor_type == MIP_EXT_3COM_CACHED_DATA)
*cached_data_len = vse_len + CVSE_OFFSET - sizeof(mip_crit_vos_t);
/* NOTE: Since cached_data_len is a UINT, even though it
may be assigned a negitive value, if negitive (an error
from the PDSN), it will test as though it were a very
large number. Therefore, the next test will catch an
error of a negative value for cached_data_len. */
if (*cached_data_len > MAX_CACHE_LEN)
facn_log(LOG_ERR, "cached_data_len (%d) >MAX_CACHE_LEN (%d)",
*cached_data_len, MAX_CACHE_LEN);
*cached_data_len = 0;
p = NULL;
break;
if (*cached_data_len > 0)
memcpy(cached_data, vse_ext->opaque_data, *cached_data_len);
break;
p = p + vse_len + CVSE_OFFSET;
/* End of While */
return p;
/******************************************************************************
*
* Function:
* void send_pdsn_update(pdsn_update_t *ptr)
* On success, returns 0
*
******************************************************************************/
void
send_pdsn_update(pdsn_update_t *ptr)
UCHAR send_msg[1024];
UCHAR *p;
UINT32 send_len, pad_len, spi;
struct sockaddr_in dest;
mip_reg_update_t *update;
mip_mbl_home_auth_ext_t *mn_ext;
mip_sess_spec_ext_t *ss_ext;
mip_nai_ext_t *nai_ext;
mobile_data_t *mobile_ptr;
UINT32 pdsn_id;
UINT32 port;
UCHAR *mn_id;
UINT32 mn_id_len;
UCHAR *nai;
UCHAR nai_len;
static UINT32 update_counter;
pdsn_id = ptr->pdsn_id;
mn_id = ptr->mbl_id;
nai = ptr->nai;
mn_id_len = ptr->mbl_len;
nai_len = ptr->nai_len;
/* Get the Mobile and NAI records. */
mobile_ptr = (mobile_data_t *)db_mobile_lookup(ptr->mbl_id, mn_id_len);
/* nai_ptr = */
/* If the retries counter is -1, don't send another update message. */
if (ptr->retries == -1)
ptr->retries = 0;
free(ptr);
if (mobile_ptr)
mobile_ptr->pdsn_update = NULL;
return;
ptr->retries--; // Decrement the retry counter.
/* Setup Destination Address */
dest.sin_family = AF_INET;
port = config_ptr->vl_port;
dest.sin_port = htons(port);
dest.sin_addr.s_addr = htonl(pdsn_id);
#ifdef SIM
dest.sin_port = ptr->from.sin_port;
dest.sin_addr.s_addr = ptr->from.sin_addr.s_addr;
#endif
update = (mip_reg_update_t *) send_msg;
update->type = MIP_TYPE_REG_UPDATE;
update->reserved[0] = 0;
update->reserved[1] = 0;
update->reserved[2] = 0;
update->home_addr = 0;
update->home_agent_addr = htonl(pdsn_id);
update->ident.high_order = htonl(getTimestamp());
update_counter++;
update->ident.low_order = htonl(update_counter);
/* Setup Session Specific Extension */
p = (UCHAR *)update->ext;
ss_ext = (mip_sess_spec_ext_t *)update->ext;
ss_ext->type = MIP_EXT_SESS_SPEC;
ss_ext->len = ((sizeof(mip_sess_spec_ext_t) + mn_id_len - 2));
ss_ext->proto_type = MIP_PPP_PROTOCOL_TYPE;
ss_ext->reserved = 0;
memcpy(ss_ext->mn_id,mn_id,mn_id_len);
memcpy((ss_ext->mn_connection_id),(ptr->mbl_id + MIP_MN_ID_LENGTH),MOBILE_CONNECT_ID_SIZE);
ss_ext->mn_id_len = mn_id_len;
ss_ext->mn_id_type = MIP_MN_ID_TYPE;
pad_len = (sizeof(mip_reg_update_t) + sizeof(mip_sess_spec_ext_t) + mn_id_len) % 4;
p = (UCHAR *)ss_ext;
p += sizeof(mip_sess_spec_ext_t) + mn_id_len;
if (pad_len > 0)
memset(p,0,pad_len);
p += pad_len;
/* Setup NAI Extension */
nai_ext = (mip_nai_ext_t *)p;
nai_ext->type = MIP_EXT_MOBILE_NODE_NAI;
nai_ext->length = sizeof(mip_nai_ext_t) + nai_len - 2;
memcpy((UCHAR *)nai_ext->data, nai, nai_len);
pad_len = (sizeof(mip_nai_ext_t) + nai_len) % 4;
p = (UCHAR *)nai_ext;
p += sizeof(mip_nai_ext_t) + nai_len;
if (pad_len > 0)
memset(p,0,pad_len);
p += pad_len;
mn_ext = (mip_mbl_home_auth_ext_t *)p;
mn_ext->type = MIP_EXT_FOREIGN_HOME_AUTH;
mn_ext->len = sizeof (mip_mbl_home_auth_ext_t) +
MD5_KEY_LENGTH - 2; /* lengths do not include the type and length */
spi = config_ptr->pdsn_key_spi;
spi = htonl(spi);
memcpy (mn_ext->spi, (UCHAR *)spi, 4);
send_len = p + sizeof(mip_mbl_home_auth_ext_t) + MD5_KEY_LENGTH - send_msg;
facn_auth((UCHAR *)mn_ext->auth, /* digest */
send_msg, /* message */
send_len - MD5_KEY_LENGTH, /* message length - MD5 KEY*/
config_ptr->pdsn_key, /* key */
MD5_KEY_LENGTH /* key length */ );
/* If CLI logging of PDSN messages, see if this message should be logged */
if( ( cli_mip_logging == MIP_ALL ) ||
( cli_mip_logging == MIP_ALL_IMSI ) )
util_log_mip_msgs( send_msg, send_len, dest, VL_TYPE, MIP_TO );
mip_print_msgs((UCHAR *)send_msg, send_len, dest, VL_TYPE, MIP_TO);
if ( sendto(sock[VL_PORT].sockfd,
send_msg,
send_len,
0,
(struct sockaddr *)dest,
sizeof(struct sockaddr_in)) < 0 )
facn_log(LOG_ERR, "VL Reg Update Sendto Call Error: %s",
strerror(errno));
return;
/* Only schedule another update message if the retry count is not zero. */
if (ptr->retries)
facn_log(LOG_DEBUG,
">>> Scheduling another update message retries=%d, PDSN=%x",
ptr->retries, pdsn_id);
Co_TimeOut(send_pdsn_update,(UINT32)ptr,config_ptr->reg_update_retry * 100);
else
facn_log(LOG_DEBUG,">>> Not scheduling another update message, retry limit reached.");
free(ptr);
if (mobile_ptr)
mobile_ptr->pdsn_update = NULL;
return;
/******************************************************************************
*
* Function:
* INT32 vl_send_visitor_reply( I UCHAR *recv_msg,
* I UINT32 length,
* I UINT32 pdsn_id,
* I UCHAR *cached_data,
* I UINT32 cached_data_len,
* I UINT32 code,
* I struct sockaddr_in *from)
* On Success returns 0;
*
******************************************************************************/
INT32
vl_send_visitor_reply( UCHAR *recv_msg,UINT32 length,UINT32 pdsn_id,UCHAR *cached_data,UINT32 cached_data_len,UINT32 code,struct sockaddr_in *from)
UCHAR *p;
UINT32 spi, sendLength, padLength, ext_size, net_order32;
UINT16 vse_len, vendor_type;
struct sockaddr_in dest;
mip_reg_req_t* request;
mip_reg_reply_t* reply;
mip_mbl_home_auth_ext_t *mn_ext;
mip_crit_vos_t *vse_ext;
UCHAR sendMsg[3000];
#if 0
struct in_addr ip_addr;
UCHAR buffer[20];
#endif
/* Setup Destination Address */
dest.sin_family = AF_INET;
dest.sin_port = from->sin_port;
dest.sin_addr.s_addr = from->sin_addr.s_addr;
#if 0
memset(buffer,0,sizeof(buffer));
IP_STRING(ip_addr,ntohl(from->sin_addr.s_addr),buffer);
facn_log(LOG_DEBUG,"IP Address = %s Port = %d",buffer,from->sin_port);
#endif
request = (mip_reg_req_t *) recv_msg;
reply = (mip_reg_reply_t *) sendMsg;
reply->type = MIP_TYPE_REG_REPLY;
reply->home_agent_addr = htonl(pdsn_id);
reply->home_addr = request->care_of_addr;
reply->ident = request->ident;
reply->ident.high_order = htonl( getTimestamp() );
reply->code = code;
reply->lifetime = 0;
/* Copy the extensions. */
ext_size = (UINT32) (recv_msg + length) - (UINT32) (request->ext);
sendLength = sizeof(mip_reg_reply_t) + ext_size;
if ( (sendLength + sizeof(mip_mbl_home_auth_ext_t) + MD5_KEY_LENGTH) > sizeof(sendMsg))
facn_log(LOG_ERR, "sendLength of vl reg reply (%d) > sizeof sendMsg (%d)",
sendLength,
sizeof(sendMsg));
return (-1);
memcpy(reply->ext, request->ext, ext_size);
/*
* Add the Visitor List Cached Data Extension where the
* the old Mobile Foreign Authenticator is..
*/
p = vl_find_ext( MIP_EXT_FOREIGN_HOME_AUTH,
reply->ext, /* start */
reply->ext + ext_size); /* end */
if (p != NULL)
if (code == MIP_CODE_CDATA_AVAIL)
/*
* Setup VSE with 3COM Cached Data
*/
vse_ext = (mip_crit_vos_t *)p;
vse_ext->type = MIP_EXT_CRIT_VEND_ORG_SPEC;
net_order32 = htonl(MIP_VENDOR_3COM);
memcpy(vse_ext->vendor_id, (UCHAR *)net_order32, 4);
vendor_type = htons(MIP_EXT_3COM_CACHED_DATA);
memcpy(vse_ext->vendor_type, (UCHAR *)vendor_type, 2);
/*
* The vse Length field is not byte aligned...
* (can't count on any byte alignment for any field v1.0.4)
*/
vse_len = sizeof(mip_crit_vos_t) +
cached_data_len - CVSE_OFFSET;
vse_len = htons(vse_len);
memcpy((UCHAR *)vse_ext->length, (UCHAR *)vse_len, 2);
/*
* Copy the cached data
*/
memcpy(vse_ext->opaque_data, cached_data, cached_data_len);
/*
* Add pads if necessary, Note! the type and length field are 3 bytes in size
* rather then 2.
*/
vse_len = ntohs(vse_len);
padLength = (vse_len + CVSE_OFFSET) % 4;
p = (UCHAR *)vse_ext;
p += vse_len + CVSE_OFFSET;
if (padLength > 0)
memset(p, 0, padLength);
p += padLength;
else
facn_log(LOG_DEBUG,"Cached Data not available.");
else
/*
* Did not find an authenticator lets add one
* to the end of the message
*/
p = reply->ext + ext_size;
/*
* Adjust sendLength
*/
sendLength = (UINT32)p + sizeof(mip_mbl_home_auth_ext_t)
+ MD5_KEY_LENGTH - (UINT32)sendMsg;
/*
* Add the Mobile Foreign Authentication Extension
*/
mn_ext = (mip_mbl_home_auth_ext_t *)p;
mn_ext->type = MIP_EXT_FOREIGN_HOME_AUTH;
mn_ext->len = sizeof (mip_mbl_home_auth_ext_t) +
MD5_KEY_LENGTH - 2; /* lengths do not include the type and length */
spi = config_ptr->pdsn_key_spi;
spi = htonl(spi);
memcpy (mn_ext->spi, (UCHAR *)spi, 4);
/*
* Re-Compute the Authenticator
*/
facn_auth(
(UCHAR *)mn_ext->auth, /* digest */
sendMsg, /* message */
sendLength - MD5_KEY_LENGTH, /* message length - MD5 KEY*/
config_ptr->pdsn_key, /* key */
MD5_KEY_LENGTH /* key length */ );
/*
* Check Flag to see if we should print the whole message.
*/
/* If CLI logging of PDSN messages, see if this message should be logged */
if( ( cli_mip_logging == MIP_ALL ) ||
( cli_mip_logging == MIP_ALL_IMSI ) )
util_log_mip_msgs( sendMsg, sendLength, dest, VL_TYPE, MIP_TO );
mip_print_msgs((UCHAR *)sendMsg, sendLength, dest, VL_TYPE, MIP_TO);
/*
* Send the message through the Visitor List Socket
*/
if ( sendto(
sock[VL_PORT].sockfd, /* socketFd */
sendMsg, /* message */
sendLength, /* message len */
0, /* flags */
(struct sockaddr *)dest,/* to address */
sizeof(struct sockaddr_in) /* to address length*/
) < 0 )
facn_log(LOG_ERR, "VL Reply Sendto Call Error: [%s]",
strerror(errno));
return (-1);
return (0);
/******************************************************************************
*
* Function:
* INT32 vl_send_visitor_ack( I UCHAR *recv_msg,
* I UINT32 length,
* I UINT32 pdsn_id,
* I UINT32 status,
* I struct sockaddr_in *from)
*
******************************************************************************/
INT32
vl_send_visitor_ack( UCHAR *recv_msg,UINT32 length,UINT32 pdsn_id,UINT32 status,struct sockaddr_in *from)
UCHAR *p;
UINT32 send_len, ext_size;
struct sockaddr_in dest;
mip_reg_update_t* update;
mip_reg_ack_t* ack;
mip_mbl_home_auth_ext_t *mn_ext;
UCHAR send_msg[3000];
/* Setup Destination Address */
dest.sin_family = AF_INET;
dest.sin_port = from->sin_port;
dest.sin_addr.s_addr = from->sin_addr.s_addr;
/*
* Setup Registration Acknowledgement Fields
* For the simulator one of these needs to
* carry the PDSN address (For now use the care_of_addr)
*/
update = (mip_reg_update_t *) recv_msg;
ack = (mip_reg_ack_t *) send_msg;
ack->type = MIP_TYPE_REG_ACK;
ack->home_addr = 0 ;
ack->care_of_addr = htonl(pdsn_id);
ack->ident.low_order = update->ident.low_order;
ack->ident.high_order = htonl( getTimestamp() );
ack->status = status;
/*
* Copy the ext..
*/
ext_size = (UINT32) (recv_msg + length) - (UINT32) (update->ext);
send_len = sizeof(mip_reg_ack_t) + ext_size;
if ( (send_len + sizeof(mip_mbl_home_auth_ext_t) + MD5_KEY_LENGTH ) > sizeof(send_msg) )
facn_log(LOG_ERR, "send_len of ack (%d) > sizeof send_msg (%d)",
send_len,
sizeof(send_msg));
return (-1);
memcpy(ack->ext, update->ext, ext_size);
p = vl_find_ext( MIP_EXT_FOREIGN_HOME_AUTH,
ack->ext, /* start */
ack->ext + ext_size); /* end */
if (p != NULL)
mn_ext = (mip_mbl_home_auth_ext_t *) p;
else
/*
* Did not find an authenticator lets add one
* to the end of the message
*/
p = ack->ext + ext_size;
mn_ext = (mip_mbl_home_auth_ext_t *) p;
/* Adjust send_len */
send_len = (UINT32)p + sizeof(mip_mbl_home_auth_ext_t)
+ MD5_KEY_LENGTH - (UINT32)send_msg;
facn_auth((UCHAR *)mn_ext->auth,send_msg,send_len - MD5_KEY_LENGTH,config_ptr->pdsn_key,MD5_KEY_LENGTH);
/* If CLI logging of PDSN messages, see if this message should be logged */
if( ( cli_mip_logging == MIP_ALL ) ||
( cli_mip_logging == MIP_ALL_IMSI ) )
util_log_mip_msgs( send_msg, send_len, dest, VL_TYPE, MIP_TO );
mip_print_msgs(send_msg, send_len, dest, VL_TYPE, MIP_TO);
/*
* Send the message through the Visitor List Socket
*/
if ( sendto(sock[VL_PORT].sockfd,
send_msg, /* message */
send_len, /* message len */
0, /* flags */
(struct sockaddr *)dest,/* to address */
sizeof(struct sockaddr_in) /* to address length*/
) < 0 )
facn_log(LOG_ERR, "VL Acknowledge Sendto Call Error: [%s]",
strerror(errno));
return (-1);
return (0);
/******************************************************************************
*
* Function:
* void vl_process_reg_ext(
* UCHAR *recv_msg,
* UCHAR *ext_start,
* UINT32 length,
* UCHAR *tmp_mobile_addr,
* UINT32 *tmp_mobile_addr_len,
* UCHAR *tmp_nai,
* UINT32 *tmp_nai_len,
* UINT32 *result)
*
******************************************************************************/
void
vl_process_reg_ext(UCHAR *recv_msg,UCHAR *ext_start,UINT32 length,UCHAR *tmp_mobile_addr,UINT32 *tmp_mobile_addr_len,UCHAR *tmp_nai,UINT32 *tmp_nai_len,UINT32 *result)
mip_ext_t *c_ext;
UCHAR *start;
UCHAR *end;
UCHAR checkBuf[MD5_KEY_LENGTH];
UINT32 c_ext_len, i, found_addr, found_nai, authenticated, tmp_spi;
UINT16 vse_len;
mip_nai_ext_t *naiExt;
mip_sess_spec_ext_t * ss_ext;
mip_mbl_home_auth_ext_t *mn_ext;
mip_crit_vos_t *vse_ext;
found_addr = authenticated = found_nai = 0;
start = (UCHAR *) ext_start;
end = recv_msg + length;
*result = 0;
while ((start < end) (*result == 0))
c_ext = (mip_ext_t *)start;
switch(c_ext->type)
case MIP_EXT_ONE_BYTE_PADDING:
c_ext_len = sizeof(mip_onebyte_pad_ext_t);
break;
case MIP_EXT_CRIT_VEND_ORG_SPEC:
vse_ext = (mip_crit_vos_t *)start;
memcpy((UCHAR *)vse_len, (UCHAR *)vse_ext->length, 2);
vse_len = ntohs(vse_len);
c_ext_len = vse_len + CVSE_OFFSET;
break;
default:
c_ext_len = c_ext->len + sizeof(mip_ext_t);
break;
switch(c_ext->type)
case MIP_EXT_ONE_BYTE_PADDING:
case MIP_EXT_NORM_VEND_ORG_SPEC:
case MIP_EXT_CRIT_VEND_ORG_SPEC:
case MIP_EXT_MOBILE_HOME_AUTH:
case MIP_EXT_MOBILE_FOREIGN_AUTH:
break;
case MIP_EXT_FOREIGN_HOME_AUTH:
mn_ext = (mip_mbl_home_auth_ext_t *) c_ext;
/* check the received PDSN SPI against our configuration */
memcpy((UCHAR *)tmp_spi, (UCHAR *)mn_ext->spi, 4);
tmp_spi = ntohl(tmp_spi);
if ( tmp_spi != config_ptr->pdsn_key_spi )
facn_log(LOG_ERR, "FA Authentication Failed Incorrect PDSN SPI %d", tmp_spi);
*result = MIP_CODE_FOREIGN_AGENT_FAILED_AUTH;
break;
facn_auth(
(UCHAR *)checkBuf, /* digest */
recv_msg, /* message */
start - recv_msg + sizeof(mip_mbl_home_auth_ext_t),
config_ptr->pdsn_key, /* key */
MD5_KEY_LENGTH /* key length */ );
/* Check that length of mn_ext->auth[] == MD5_KEY_LENGTH */
if ( (mn_ext->len - 4 ) != MD5_KEY_LENGTH )
facn_log(LOG_ERR, "FA Authentication Failed Incorrect Length %d",
mn_ext->len - 4 );
*result = MIP_CODE_FOREIGN_AGENT_FAILED_AUTH;
break;
for (i = 0; i < MD5_KEY_LENGTH; i++)
authenticated = 1;
if ((UINT8)mn_ext->auth[i] != (UINT8)checkBuf[i])
authenticated = 0;
facn_log(LOG_ERR,"FA Failed Authentication");
*result = MIP_CODE_FOREIGN_AGENT_FAILED_AUTH;
break;
break;
case MIP_EXT_SESS_SPEC:
ss_ext = (mip_sess_spec_ext_t * ) c_ext;
/* Validate mn_id_type and mn_id_length */
if (ss_ext->mn_id_type != MIP_MN_ID_TYPE) /* type IMSI */
facn_log(LOG_ERR, "Incorrect mn_id_type %d != %d(IMSI)",
ss_ext->mn_id_type,
MIP_MN_ID_TYPE);
*result = MIP_CODE_POORLY_FORMED_REQUEST;
break;
/* add check for max / min imsi length (use 2 for min) */
if ((ss_ext->mn_id_len > MIP_MN_ID_LENGTH) ||
(ss_ext->mn_id_len < 2))
facn_log(LOG_ERR, "Incorrect mn_id_len %d > %d ",
ss_ext->mn_id_len,
MIP_MN_ID_LENGTH);
*result = MIP_CODE_POORLY_FORMED_REQUEST;
break;
/* Copy the Mobile Address (zero fill) and Connection ID */
for (i = 0; i < MIP_MN_ID_LENGTH; i++)
if (i < ss_ext->mn_id_len)
*(tmp_mobile_addr + i) = ss_ext->mn_id[i];
else
*(tmp_mobile_addr + i) = 0;
memcpy(tmp_mobile_addr + MIP_MN_ID_LENGTH, (UCHAR *)ss_ext->mn_connection_id, MOBILE_CONNECT_ID_SIZE);
*tmp_mobile_addr_len = ss_ext->mn_id_len;
found_addr = 1;
break;
case MIP_EXT_MOBILE_NODE_NAI:
naiExt = (mip_nai_ext_t *) c_ext;
/* validate nai length */
if (naiExt->length > MAX_NAI_LEN)
facn_log(LOG_ERR, "Incorrect nai ext len (%d) > %d ",
naiExt->length,
MAX_NAI_LEN);
*result = MIP_CODE_POORLY_FORMED_REQUEST;
break;
for (i = 0; i < MAX_NAI_LEN i < naiExt->length; i++)
*(tmp_nai + i) = naiExt->data[i];
*tmp_nai_len = naiExt->length;
found_nai = 1;
break;
default:
break;
start += c_ext_len;
if (*result == 0)
if (start > end)
facn_log(LOG_ERR,"|=VL Extension Format start > end");
*result = MIP_CODE_POORLY_FORMED_REQUEST;
if (found_addr != 1 || authenticated != 1 || found_nai != 1 )
facn_log(LOG_ERR,"|=formed request addr %d auth %d nai %d",
found_addr, authenticated, found_nai);
*result = MIP_CODE_POORLY_FORMED_REQUEST;
if (found_addr != 1 || authenticated != 1 || found_nai != 1 )
facn_log(LOG_ERR,"|=formed request addr %d auth %d nai %d",
found_addr, authenticated, found_nai);
*result = MIP_CODE_POORLY_FORMED_REQUEST;
return;
/******************************************************************************
*
* Function:
* INT32 vl_reg_req( I mip_reg_t *recv_msg,
* I UINT32 length,
* I struct sockaddr_in *from)
*
******************************************************************************/
INT32
vl_reg_req(mip_reg_t *recv_msg,UINT32 length,struct sockaddr_in *from)
UINT32 result = 0;
UINT32 care_of_addr;
UINT32 home_agent_addr;
UINT32 pdsn_id;
UINT32 mobile_id_len, tmp_nai_len;
UINT32 low_order, high_order, seconds;
mip_reg_req_t *request;
UCHAR mobile_id[MOBILE_ID_SIZE];
UCHAR tmp_nai[MAX_NAI_LEN];
mobile_data_t *mobile;
nai_data_t *nai;
int del_cnt;
memset(mobile_id,0,MOBILE_ID_SIZE); // clear out mobile_id buffer
memset(tmp_nai,0,MAX_NAI_LEN);
request = (mip_reg_req_t*) recv_msg;
/* Get the various addresses. */
home_agent_addr = ntohl(request->home_agent_addr);
care_of_addr = ntohl(request->care_of_addr);
pdsn_id = care_of_addr;
facn_log(LOG_DEBUG,"Recv'd MIP_TYPE_REG_REQUEST for PDSN %x", pdsn_id );
/* before we go through this, check the time drift in the ID field */
if ( Facn_checkReplay(request->ident, NULL) == 1 )
facn_log(LOG_INFO, "*** VL Registration request ID time drift");
result = MIP_REPLY_REG_IDENT_MISMATCH;
else
/* Get the extensions. */
vl_process_reg_ext((UCHAR *)recv_msg,
(UCHAR *)request->ext,
length,
(UCHAR *)mobile_id,
mobile_id_len,
(UCHAR *)tmp_nai,
tmp_nai_len,
result);
if (result != 0)
facn_log( LOG_ERR, "Formed VL Reg Extensions (%d)", result);
else
stats_ptr->pdsn_req_rcv++;
mobile = (mobile_data_t *)db_mobile_lookup(mobile_id, mobile_id_len);
if (mobile != NULL)
/* Get the NAI Data */
facn_log(LOG_DEBUG,"NAI: %s",tmp_nai);
nai = (nai_data_t *)db_mobile_find_nai((mobile_data_t *)mobile,tmp_nai,tmp_nai_len);
facn_log(LOG_DEBUG,"nai = %x",nai);
/* if nai, check to see make sure nai hasn't aged too long */
if (nai ((seconds = getTimestamp()) < (nai->timestamp +config_ptr->mobile_aging_timer)))
/* Check for a registration request replay attack. */
low_order = ntohl(request->ident.low_order);
high_order = ntohl(request->ident.high_order);
if ( Facn_checkReplay(request->ident, nai->vl_ident) == 1 )
facn_log(LOG_INFO, "*** VL Registration request ID mismatch");
// nai->vl_ident.low_order = low_order;
result = MIP_REPLY_REG_IDENT_MISMATCH;
else
nai->vl_ident.low_order = low_order;
nai->vl_ident.high_order = high_order;
if ((nai->cached_data_len == 0) || (nai->status != ACTIVE))
result = MIP_CODE_CDATA_NOT_AVAIL;
stats_ptr->pdsn_fail_cdata++;
else
if(nai)
del_cnt = db_delete_thru_nai(nai);
facn_log(LOG_DEBUG,">>> NAI data %d aged beyond limit. <<<",del_cnt);
else
facn_log(LOG_DEBUG,">>> NAI data not found. <<<");
result = MIP_CODE_CDATA_NOT_AVAIL;
stats_ptr->pdsn_fail_cdata++;
else
if (config_ptr->debug >= LOG_DEBUG)
print_hex(LOG_DEBUG,mobile_id, MIP_MN_ID_LENGTH);
facn_log(LOG_DEBUG, "Could not find mobile in the database.");
result = MIP_CODE_CDATA_NOT_AVAIL;
stats_ptr->pdsn_fail_cdata++;
if ( result == 0 )
result = MIP_CODE_CDATA_AVAIL;
stats_ptr->pdsn_valid_cdata++;
facn_log(LOG_DEBUG, "Send a Visitor Reply (%d)", result);
vl_send_visitor_reply((UCHAR *)recv_msg,
length,
pdsn_id,
nai->cached_data,
nai->cached_data_len,
result,
from);
else
// if (result != MIP_REPLY_REG_IDENT_MISMATCH)
//
vl_send_visitor_reply((UCHAR *) recv_msg,
length,
pdsn_id,
NULL,
0,
result,
from);
//
return 0;
/******************************************************************************
*
* Function:
* vl_reg_update( I UCHAR *recv_msg,
* I UINT32 length,
* I struct sockaddr_in *from)
*
******************************************************************************/
INT32
vl_reg_update(UCHAR *recv_msg,
UINT32 length,
struct sockaddr_in *from)
UCHAR *p;
UCHAR tmp_mobile_addr[MOBILE_ID_SIZE];
UCHAR tmp_nai[MAX_NAI_LEN];
UCHAR cached_data[MAX_CACHE_LEN];
UINT32 tmp_mobile_addr_len, tmp_nai_len, cached_data_len;
UINT32 ext_size, pdsn_id, status, result;
mip_ident_t ident;
mip_reg_update_t* update;
mobile_data_t *mobile;
nai_data_t *nai;
UCHAR *cache_ptr;
pdsn_update_t *pdsn_update;
memset(tmp_nai, 0, MAX_NAI_LEN);
memset(tmp_mobile_addr, 0, MOBILE_ID_SIZE);
update = (mip_reg_update_t*) recv_msg;
/* Grab the pdsn_id from the Update */
pdsn_id = ntohl(update->home_agent_addr);
ident.low_order = ntohl(update->ident.low_order);
ident.high_order = ntohl(update->ident.high_order);
facn_log(LOG_DEBUG,"Recv'd MIP_TYPE_REG_UPDATE for PDSN %x", pdsn_id);
/* before we go through this, check the time drift in the ID field */
if ( Facn_checkReplay(update->ident, NULL) == 1 )
facn_log(LOG_INFO, "*** VL Registration update ID time drift");
result = MIP_REPLY_REG_IDENT_MISMATCH;
else
/*
* Authenticate and Grab the Mobile Address from the update
*/
vl_process_reg_ext( (UCHAR *) recv_msg,
(UCHAR *) update->ext,
length,
(UCHAR *)tmp_mobile_addr,
tmp_mobile_addr_len,
(UCHAR *)tmp_nai,
tmp_nai_len,
result);
if (result != 0)
facn_log( LOG_ERR, "Formed VL Update Extensions (%d)", result);
else
stats_ptr->pdsn_upd_rcvd++;
/*
* Initialize cached_data_len
* Grab DataCache if it is there
*/
cached_data_len = 0;
ext_size = (UINT32) (recv_msg + length) -
(UINT32) (update->ext);
p = (UCHAR *) update->ext;
cache_ptr = vl_get_cached_data( p,
cached_data,
cached_data_len,
ext_size);
/* if there was no 3COM VSE extension, this is a std reg update -
mark the session inactive and dec the active sessions count */
if (!cache_ptr)
mobile = (mobile_data_t *)db_mobile_lookup(tmp_mobile_addr,
tmp_mobile_addr_len);
if (mobile != NULL)
nai = (nai_data_t *)db_mobile_find_nai((mobile_data_t *)mobile,tmp_nai,tmp_nai_len);
if (nai)
facn_log( LOG_DEBUG,
"Update Received - no cache, mobile NAI found - last PDSN=%x",
mobile->last_pdsn);
/* found the nai - if active, mark inactive and dec the active cnt */
if (pdsn_id == mobile->last_pdsn)
if (nai->status == ACTIVE)
--mobile->active_sessions;
nai->status = INACTIVE;
else
facn_log( LOG_DEBUG,
"Update Received - no cache, mobile but no NAI found - last PDSN=%x",
mobile->last_pdsn);
else
facn_log( LOG_DEBUG,
"Update Received - no cache, no mobile found");
else
/*
* Add a mobile entry if not found.
*/
facn_log( LOG_DEBUG,"Update Received -cache length = %d",
cached_data_len);
mobile = (mobile_data_t *)db_mobile_add(tmp_mobile_addr,
tmp_mobile_addr_len);
if (mobile != NULL)
/* update the imsi length in the mobile record */
mobile->imsi_len = tmp_mobile_addr_len;
facn_log(LOG_DEBUG,"NAI: %s",tmp_nai);
/* if over max nai count, delete the oldest n entries */
if (stats_ptr->nai_count >= config_ptr->max_nai_count)
db_delete_multi_nai( NAI_CACHE_DELETE_CNT );
facn_log(LOG_INFO,">>> Reached max NAI cnt - %d deleted. <<<",NAI_CACHE_DELETE_CNT);
nai = (nai_data_t *)db_mobile_add_nai((mobile_data_t *)mobile,tmp_nai,tmp_nai_len);
if (nai)
/*
* Check the low_order ident to make sure we have
* not already received this message.
* Again this should be more robust making sure via NTP that
* the message was sent in the last couple of seconds..
*/
if ( Facn_checkReplay(update->ident, nai->vl_ident) == 1 )
facn_log(LOG_INFO, "*** VL Registration update ID mismatch");
facn_log(LOG_DEBUG,
"VL Reg update mismatch - updt high/low=%x/%x, nai high/low=%x/%x",
update->ident.high_order,update->ident.low_order,
nai->vl_ident.high_order,nai->vl_ident.low_order );
// nai->vl_ident.low_order = ident.low_order;
result = MIP_REPLY_REG_IDENT_MISMATCH;
else
nai->vl_ident.low_order = ident.low_order;
nai->vl_ident.high_order = ident.high_order;
if ( cached_data_len > 0 )
memcpy(nai->cached_data, cached_data, cached_data_len);
nai->cached_data_len = cached_data_len;
facn_log( LOG_DEBUG,
"Update Received - cache, mobile NAI found - last PDSN=%x",
mobile->last_pdsn);
mobile->update_pdsn = mobile->last_pdsn;
mobile->last_pdsn = pdsn_id;
/* 10/9/00 add session active check when determining if
we need to send a reg update to old pdsn */
if ( (nai->status == ACTIVE) mobile->update_pdsn(pdsn_id != mobile->update_pdsn) )
stats_ptr->pdsn_upd_sent++;
/*
* Only allocate the memory if there is not already
* active update message.
*/
if (mobile->pdsn_update == NULL)
pdsn_update = malloc(sizeof(pdsn_update_t));
mobile->pdsn_update = pdsn_update;
else
pdsn_update = mobile->pdsn_update;
/* save the PDSN addr to send the update to */
pdsn_update->pdsn_id = mobile->update_pdsn;
/* in case this is the sim, fill in the from
*
* The sockaddr_in structure needs to be copied
* into the pdsn_update structure when testing
* with the FACN simulator since we need to send
* the update message back to the system that the
* simulator is running on.
*/
memcpy((pdsn_update->from),from,sizeof(struct sockaddr_in));
memcpy((pdsn_update->mbl_id),tmp_mobile_addr,MOBILE_ID_SIZE);
pdsn_update->mbl_len = tmp_mobile_addr_len;
memcpy((pdsn_update->nai),tmp_nai,MAX_NAI_LEN);
pdsn_update->nai_len = tmp_nai_len;
facn_log(LOG_DEBUG,
"Sending update to old PDSN ox-%x",
pdsn_update->pdsn_id);
/* start a new timer if one not already running */
if (pdsn_update->retries == 0)
Co_TimeOut(send_pdsn_update, (UINT32)pdsn_update,1);
pdsn_update->retries = config_ptr->reg_update_retry_num;
else
if( nai->status == ACTIVE )
facn_log(LOG_DEBUG,
"Sending update to PDSN %x (ACTIVE NAI) since last PDSN = this PDSN ",
mobile->update_pdsn);
else
facn_log(LOG_DEBUG,
"Sending update to PDSN %x (INACTIVE NAI)",
mobile->update_pdsn);
facn_log(LOG_DEBUG,
"last PDSN=ox-%x, message pdsn=%x",
mobile->update_pdsn, pdsn_id);
/* if this session is moving from inactive to active,
bump the active session count in the main record */
if (nai->status == INACTIVE)
mobile->active_sessions++;
nai->status = ACTIVE;
else
facn_log( LOG_ERR,
"Update Received - couldn't add NAI");
else
facn_log( LOG_ERR,
"Update Received - couldn't add mobile");
/*
* Send a Registration acknowledge message back to the PDSN or FACN
*/
if (result != 0)
facn_log( LOG_DEBUG, "VL Update Response error=%d", result);
status = result;
else
status = MIP_CODE_ACCEPTED;
vl_send_visitor_ack( recv_msg,
length,
pdsn_id,
status,
from);
return (0);
/******************************************************************************
*
* Function:
* vl_reg_ack( I mip_reg_t *recv_msg,
* I UINT32 length,
* I struct sockaddr_in *from)
*
******************************************************************************/
INT32
vl_reg_ack(mip_reg_t *recv_msg,UINT32 length,struct sockaddr_in *from)
UINT32 pdsn_id;
UINT32 status;
UINT32 result;
UCHAR tmp_mobile_addr[MOBILE_ID_SIZE];
UCHAR tmp_nai[MAX_NAI_LEN];
UINT32 tmp_mobile_addr_len, tmp_nai_len;
mip_ident_t ident;
mip_reg_ack_t* ack;
mobile_data_t *mobile_ptr;
pdsn_update_t *pdsn_update;
result = 0;
ack = (mip_reg_ack_t *) recv_msg;
status = ack->status;
pdsn_id = ntohl(ack->care_of_addr);
ident.low_order = ntohl(ack->ident.low_order);
ident.high_order = ntohl(ack->ident.high_order);
facn_log(LOG_DEBUG,"Recv'd MIP_TYPE_REG_ACK for PDSN %x", pdsn_id);
/*
* Authenticate and Grab the Mobile Address from the acknowledgement
*/
vl_process_reg_ext( (UCHAR *) recv_msg,
(UCHAR *) ack->ext,
length,
(UCHAR *)tmp_mobile_addr,
tmp_mobile_addr_len,
(UCHAR *)tmp_nai,
tmp_nai_len,
result);
if (result == 0 )
result = status;
/* Find the mobile in the database. */
mobile_ptr = (mobile_data_t *)db_mobile_lookup(tmp_mobile_addr,
tmp_mobile_addr_len);
if (mobile_ptr)
facn_log(LOG_DEBUG,"Mobile found, setting update retries to -1");
pdsn_update = mobile_ptr->pdsn_update;
if (pdsn_update) /* pdsn_id == pdsn_update->pdsn_id */
pdsn_update->retries = -1;
else
facn_log(LOG_DEBUG,"Did not find the mobile ptr to update record, can't cancel retry attempts");
else
facn_log(LOG_DEBUG,"Did not find the mobile, can't cancel retry attempts");
else
facn_log( LOG_ERR, "Formed Acknowledgement Extensions (%d)", result);
return 0;
/******************************************************************************
*
* Function:
* INT32 vl_process_msg( I mip_reg_t *msg,
* I UINT32 length,
* I struct sockaddr_in *from)
*
******************************************************************************/
INT32
vl_process_msg(mip_reg_t *msg,UINT32 length,struct sockaddr_in *from)
/* If CLI logging of VL MIP messages, see if this message should be logged*/
if( ( cli_mip_logging == MIP_ALL ) ||
( cli_mip_logging == MIP_ALL_IMSI ) )
util_log_mip_msgs( msg, length, from, VL_TYPE, MIP_FROM );
mip_print_msgs((UCHAR *)msg, length, from, VL_TYPE, MIP_FROM);
switch(msg->type)
case MIP_TYPE_REG_REQUEST:
vl_reg_req(msg,length,from);
break;
case MIP_TYPE_REG_UPDATE:
vl_reg_update((UCHAR *)msg,length,from);
break;
case MIP_TYPE_REG_ACK:
vl_reg_ack(msg,length,from);
break;
default:
facn_log(LOG_ERR, "Received unknown VL pkt type = %d", msg->type);
return(-1);
return 0;
/* $Log: visitor.c,v $
/* Revision 1.35 2001/05/01 17:38:52 glewis
/* Changed pdsn_fail_auth to pdsn_fail_cdata and pdsn_valid_auth to
/* pdsn_valid_cdata on statistics. Also changed to not return cache if a
/* session is not active.
/*
/* Revision 1.33 2001/03/09 23:56:20 fdickson
/* Fixed a possible negitive cache data length from the PDSN, added mip logging features, and added extra data in some debug logging messages.
/*
/* Revision 1.31 2001/01/23 22:35:50 fdickson
/* Modified LOG_DEBUG messages.
/*
/* Revision 1.30 2000/12/14 19:18:40 fdickson
/* Changed per code review. Removed returning of bad result on registration update received when records (mobile or NAI) not added.
/*
/* Revision 1.29 2000/12/04 23:08:04 fdickson
/* Added facn_log LOG_DEBUG and LOG_ERR messages for RNN registration updates.
/*
/* Revision 1.28 2000/10/30 20:26:32 glewis
/* add check for min imsi len
/*
/* Revision 1.27 2000/10/12 20:49:37 glewis
/* only send reg update to previous pdsn if the session was active
/*
/* Revision 1.26 2000/09/28 22:31:12 fdickson
/* Added IMSI length to routines that call lookup, delete, or insert of mobile reco
/* rds.
/*
/* Revision 1.25 2000/09/22 22:43:15 glewis
/* check MIP ID time drift, send reply with error if ID mismatch, don't save
/* low order in database if invalid ID, identify specific msg in facn_logs
/*
/* Revision 1.24 2000/09/21 20:23:41 glewis
/* change ID mismatch facn_log
/*
/* Revision 1.23 2000/09/14 00:44:26 glewis
/* add check for PDSN SPI
/*
/* Revision 1.22 2000/09/07 19:57:56 fdickson
/* Added logging level to print_hex routine.
/*
/* Revision 1.21 2000/08/25 22:51:03 glewis
/* set mn_id_type in update sent to pdsn
/*
/* Revision 1.20 2000/07/19 20:12:32 glewis
/* add protection in case vse->vendor_type isn't word aligned
/*
/* Revision 1.19 2000/06/10 00:15:59 glewis
/* put back in mip_print calls
/*
/* Revision 1.18 2000/06/05 17:07:27 glewis
/* use CVSE_OFFSET define (4) instead of hardcoded 3, fix bug (parens needed in
/* if test) when looking at reg extensions
/*
/* Revision 1.17 2000/05/31 20:13:13 glewis
/* change session specific extension protocol type to ppp per latest RP spec
/*
/* Revision 1.16 2000/05/25 21:29:28 pwl
/* code review clean up
/*
/* Revision 1.15 2000/05/05 18:45:55 glewis
/* add new replay attack check to reg update processing
/*
/* Revision 1.14 2000/05/05 16:43:04 glewis
/* add support for aging timer and max nai cache
/*
/* Revision 1.13 2000/05/03 21:34:50 pwl
/* changed replay checking and ident initializing
/*
/* Revision 1.12 2000/05/03 17:55:22 glewis
/* change to handle imsi length less than 8
/*
/* Revision 1.11 2000/05/02 20:47:23 fdickson
/* Modified logging to the debug level. Misc sizing fixes.
/*
/* Revision 1.10 2000/05/02 19:26:31 glewis
/* add define for SIM to send handover updates back to source PDSN (instead
/* of the fake PDSN the SIM is emulating)
/*
/* Revision 1.9 2000/04/26 00:32:01 glewis
/* another reg update change
/*
/* Revision 1.8 2000/04/26 00:27:29 glewis
/* multiple changes related to the handling of sending reg updates to PDSNs and
/* associated retry logic
/*
/* Revision 1.7 2000/04/20 20:28:46 obrien
/* More modifications to support the update message to the PDSN. Note:
/* currently the code supports sending the update message back to the
/* simulator. To send the update message back to an actual PDSN the IP
/* address stored in the update_pdsn field of the mobile record has to be
/* used instead of the simulator's IP address.
/*
/* Revision 1.6 2000/04/15 00:07:18 obrien
/* Added temporary code that sends the reg update to the simulator.
/*
/* Revision 1.5 2000/04/14 23:49:58 obrien
/* Added the call to the routine that sends the reg update to the old PDSN.
/*
/* Revision 1.4 2000/04/14 23:34:15 obrien
/* Added code to send a registration update message to a mobile's old PDSN.
/*
/* Revision 1.3 2000/04/14 22:58:49 glewis
/* bump PDSN visitor list stats
/*
/* Revision 1.2 2000/04/14 05:08:34 glewis
/* ifdef out the updating of update_pdsn in the mobile record in vl_reg_req
/*
/* add processing for the registration update with no FAAA extension - set
/* the nai status inactive and adjust the mobile active session count
/*
/* for reg updates with FAAA extension (even if FAA data length is zero) set
/* the nai status active and adjust the mobile active session count, and
/* set the update_pdsn field to last_pdsn
/*
/* Revision 1.1 2000/04/12 17:37:07 obrien
/* Initial Revision
/* */
/* Copyright 1999-2000 3Com Corporation. All Rights Reserved. */
/* $Id: hb.c,v 1.15 2001/04/16 17:33:28 fdickson Exp $ */
/******************************************************************************
*
* Filename: facn_hb.c
*
* Description: This file contains functions processing heartbeat messages.
*
* Author:
*
******************************************************************************/
/******** History: */
/* 03/10/01 SEC MR 4667 - Add a CLI command that allows logging of RNN MIP
messages to the FACN, possibly qualified by an IMSI. */
/* Include Files */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/fcntl.h>
#include <signal.h>
#include <errno.h>
#include <sys/time.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include "facn.h"
#include "hb_msgs.h"
#include "facn_log.h"
#include "facn_common.h"
#include "facn_config.h"
#include "db_mobile.h"
#include "db_rnn.h"
#include "db_pdsn.h"
#include "hb_proto.h"
#include "util_msgs.h"
/* Defines */
/* Globals */
UCHAR hb_send_msg[1024];
/* Externs */
extern facn_socket_t sock[];
extern facn_config_t *config_ptr;
/******************************************************************************
*
* hb_find_ext() : Find the specified extension in the heartbeat message.
*
* Arguments : type - extention type to find
* msg - heartbeat message
* len - length of the message
*
* Return Values : Returns a pointer to the extension if it was found,
* otherwise returns NULL.
*
******************************************************************************/
UCHAR *
hb_find_ext(UCHAR type, hb_msg_t *msg, UINT32 len)
UCHAR *start, *end;
mip_ext_t *ext;
UINT32 ext_len, found = 0;
start = (UCHAR *)((hb_msg_t *)msg)->ext;
end = (UCHAR *)((UINT32)(msg) + len);
while (start < end)
ext = (mip_ext_t *)start;
if (ext->type == MIP_EXT_ONE_BYTE_PADDING)
start += 1;
continue;
else
ext_len = ext->len + sizeof(mip_ext_t);
if (ext->type == type)
found = 1;
break;
start += ext_len;
if (!found)
start = NULL;
return(start);
/******************************************************************************
*
* hb_auth() : Check the message's authentication
*
* Arguments : msg - heartbeat message
* len - length of the message
*
* Return Values : Returns 0 if authentication succeeded.
* Returns MIP_CODE_MOBILE_NODE_FAILED_AUTH if authentication
* failed.
* Returns MIP_CODE_POORLY_FORMED_REQUEST if the message was
* invalid.
*
******************************************************************************/
UINT32
hb_auth(hb_msg_t *msg, UINT32 len)
mip_ext_t *cur_ext;
mip_mbl_home_auth_ext_t *mh_ext;
UCHAR *start, *end;
UCHAR buffer[MD5_KEY_LENGTH];
UINT32 i, tmp_spi, msg_len, result = 0;
/* find the auth extension */
mh_ext = (mip_mbl_home_auth_ext_t *)hb_find_ext(MIP_EXT_FOREIGN_HOME_AUTH,msg,len);
if (mh_ext != NULL)
msg_len = ((UCHAR *)mh_ext - (UCHAR *)msg + sizeof(mip_mbl_home_auth_ext_t));
/* check the received PDSN SPI against our configuration */
memcpy((UCHAR *)tmp_spi, (UCHAR *)mh_ext->spi, 4);
tmp_spi = ntohl(tmp_spi);
if ( tmp_spi != config_ptr->pdsn_key_spi )
facn_log(LOG_ERR, "HB Authentication Failed - Incorrect PDSN SPI %d", tmp_spi);
result = MIP_CODE_FOREIGN_AGENT_FAILED_AUTH;
else
facn_auth((UCHAR *)buffer,msg,msg_len,config_ptr->pdsn_key,MD5_KEY_LENGTH);
for (i = 0; i < MD5_KEY_LENGTH; i++)
if ((UINT8)mh_ext->auth[i] != (UINT8)buffer[i])
facn_log(LOG_ERR, "HB Authentication Failed");
result = MIP_CODE_FOREIGN_AGENT_FAILED_AUTH;
break;
else
result = MIP_CODE_POORLY_FORMED_REQUEST;
return(result);
/******************************************************************************
*
* add_auth_ext() : Adds the authentication extention to the heartbeat
* message before it is sent to the PDSN.
*
* Arguments : msg - heartbeat message
* ext - authentication extension
*
* Return Values : Returns the size of the message.
*
******************************************************************************/
UINT32
add_auth_ext(UCHAR *msg,mip_mbl_home_auth_ext_t *mn_ext)
UINT32 msg_len, spi;
mn_ext->type = MIP_EXT_FOREIGN_HOME_AUTH;
mn_ext->len = sizeof(mip_mbl_home_auth_ext_t) + MD5_KEY_LENGTH - 2;
spi = config_ptr->pdsn_key_spi;
spi = htonl(spi);
memcpy (mn_ext->spi, (UCHAR *)spi, 4);
msg_len = (UCHAR *)mn_ext + sizeof(mip_mbl_home_auth_ext_t) + MD5_KEY_LENGTH - msg;
facn_auth(
(UCHAR *)mn_ext->auth, /* digest */
msg, /* message */
msg_len - MD5_KEY_LENGTH, /* message length - authenticator*/
config_ptr->pdsn_key, /* key */
MD5_KEY_LENGTH /* key length */ );
return((UINT32)((UCHAR *)mn_ext + sizeof(mip_mbl_home_auth_ext_t) + MD5_KEY_LENGTH - msg));
/******************************************************************************
*
* add_rnn_key_ext() : Adds the RNN Key extention to the heartbeat message
* before it is sent to the PDSN.
*
* Arguments : ext - pointer to the extension field of the message
*
* Return Values : Returns the size of the extension added.
*
******************************************************************************/
void
add_rnn_key_ext(UCHAR **p)
UINT32 msg_len, spi, i;
hb_ext_t *ext;
UCHAR *q;
ext = (hb_ext_t *)*p;
ext->type = HB_EXT_RNN_FACN_KEY;
ext->length = 4 + MD5_KEY_LENGTH;
spi = (UINT32)config_ptr->rnn_key_spi;
spi = htonl(spi);
memcpy (ext->data, (UCHAR *)spi, 4);
for (i = 0, q = ext->data + 4; i < MD5_KEY_LENGTH; i++)
*( q + i ) = *( config_ptr->rnn_key + i ) ^ *( config_ptr->pdsn_key + i );
*p += sizeof(hb_ext_t) + ext->length;
/******************************************************************************
*
* add_faaa_key_ext() : Adds the FAAA Key extention to the heartbeat message
* before it is sent to the PDSN.
*
* Arguments : ext - pointer to the extension field of the message
* faaa_index - index into the FAAA configuration parms
*
* Return Values : Returns the size of the extension added.
*
******************************************************************************/
void
add_faaa_key_ext(UCHAR **p, int faaa_index)
UINT32 msg_len, faaa_ip, i;
hb_ext_t *ext;
UCHAR *q;
ext = (hb_ext_t *)*p;
ext->type = HB_EXT_PDSN_FAAA_KEY;
ext->length = 4 + MD5_KEY_LENGTH;
faaa_ip = (UINT32)config_ptr->faaa_keys[faaa_index].ip_addr;
faaa_ip = htonl(faaa_ip);
memcpy (ext->data, (UCHAR *)faaa_ip, 4);
for (i = 0, q = ext->data + 4; i < MD5_KEY_LENGTH; i++)
*( q + i ) = *( config_ptr->faaa_keys[faaa_index].aaa_key + i ) ^
*( config_ptr->pdsn_key + i );
*p += sizeof(hb_ext_t) + ext->length;
/******************************************************************************
*
* hb_init_ack_msg() : Sends the Heartbeat Init Acknowledge message to the PDSN.
*
* Arguments : pdsn_id - PDSN IP Address
* from - socket information
*
* Return Values : Returns 0 if successfully, otherwise returns -1.
*
******************************************************************************/
UINT32
hb_init_ack_msg(UINT32 pdsn_id, struct sockaddr_in *from)
UCHAR msg[1024];
UCHAR *p;
UINT32 send_len;
UCHAR key[MD5_KEY_LENGTH];
struct sockaddr_in src, dest;
hb_ack_t *req;
int faaa_index;
//facn_log(LOG_DEBUG,"Sending HB Init Ack to %s, pdsn = %x",inet_ntoa(from_addr->sin_addr),pdsn_id);
/* Setup Destination Address */
dest.sin_family = from->sin_family;
dest.sin_port = from->sin_port;
dest.sin_addr.s_addr = from->sin_addr.s_addr;
/* Setup Heartbeat Init Ack Fields */
req = (hb_ack_t *) msg;
req->type = HB_TYPE_INIT_ACK;
req->lifetime = (UINT8)0; // actually a reserved field
req->pdsn_id = htonl(pdsn_id);
req->config_value = htons((UINT16)config_ptr->hb_config_value);
req->length = sizeof(hb_ack_t);
/* Setup Heartbeat Init Acknowledge Extensions */
p = (UCHAR*) req->ext;
add_rnn_key_ext(p); // Add the RNN Key extension.
/* Add the FAAA Key extensions */
for( faaa_index = 0; faaa_index < MAX_FAAA_KEYS; faaa_index++ )
if( !(config_ptr->faaa_keys[faaa_index].ip_addr) )
break;
add_faaa_key_ext(p, faaa_index);
/* Update length to include extensions. */
req->length = htons((UINT32)(p + sizeof(mip_mbl_home_auth_ext_t) + MD5_KEY_LENGTH - msg));
/* Add Authentication */
send_len = add_auth_ext(msg,(mip_mbl_home_auth_ext_t *)p);
hb_print_msgs( msg, send_len, dest );
/* Send the message through the Facn Heartbeat Socket. */
if (sendto(
sock[HB_PORT].sockfd, /* socketFd */
msg, /* message */
send_len, /* message len */
0, /* flags */
(struct sockaddr *)dest, /* to address */
sizeof(struct sockaddr_in) /* to address length*/
) < 0 )
facn_log(LOG_ERR,"HB INIT ACK sendto error");
return (-1);
return (0);
/******************************************************************************
*
* hb_ack_msg() : Sends the Heartbeat Acknowledge message to the PDSN.
*
* Arguments : pdsn_id - PDSN IP Address
* from - socket information
*
* Return Values : Returns 0 if successfully, otherwise returns -1.
*
******************************************************************************/
UINT32
hb_ack_msg(UINT32 pdsn_id, struct sockaddr_in *from)
UCHAR send_msg[1024];
UCHAR *p;
UINT32 send_len;
struct sockaddr_in src, dest;
hb_ack_t *req;
/* Setup Destination Address */
dest.sin_family = from->sin_family;
dest.sin_port = from->sin_port;
dest.sin_addr.s_addr = from->sin_addr.s_addr;
/* Setup Heartbeat Acknowledge Fields */
req = (hb_ack_t *) send_msg;
req->type = HB_TYPE_ACK;
req->lifetime = (UINT8)0; // actually a reserved field
req->pdsn_id = htonl(pdsn_id);
req->config_value = htons((UINT16)config_ptr->hb_config_value);
p = (UCHAR *)req->ext;
req->length = htons((UINT32)(p + sizeof(mip_mbl_home_auth_ext_t) + MD5_KEY_LENGTH - send_msg));
send_len = add_auth_ext(send_msg,(mip_mbl_home_auth_ext_t *)p);
hb_print_msgs( send_msg, send_len, dest );
/*
* Send the message through the Facn Heartbeat Socket
*/
if ( sendto(
sock[HB_PORT].sockfd, /* socketFd */
send_msg, /* message */
send_len, /* message len */
0, /* flags */
(struct sockaddr *)dest, /* to address */
sizeof(struct sockaddr_in) /* to address length*/
) < 0 )
facn_log(LOG_ERR,"HB ACK sendto call error");
return (-1);
return (0);
/******************************************************************************
*
* hb_msg() : Process the Heartbeat message received from the PDSN.
*
* Arguments : msg - Heartbeat message
* len - message length
* from - socket information
*
* Return Values : Returns 0 if successfully, otherwise returns -1.
*
******************************************************************************/
void
hb_msg(hb_msg_t *msg, UINT32 len, struct sockaddr_in *from)
hb_ext_t *ext;
UCHAR *ext_ptr;
UINT32 ext_len;
UINT32 c_length;
pdsn_data_t *pdsn_ptr = NULL;
struct timeval current_time;
UINT16 call_load = 0;
UINT16 cpu_usage = 0;
UINT16 mem_usage = 0;
UINT16 temp;
UINT32 pdsn_id;
UCHAR *start, *end;
int ret = 0;
ret = hb_auth(msg,len);
if (ret != 0)
facn_log(LOG_ERR,"HB INIT failed Authentication");
return;
gettimeofday(current_time, NULL);
pdsn_id = ntohl(msg->pdsn_id);
/* Get the extensions. */
start = (UCHAR *) msg->ext;
end = (UCHAR *) msg + ntohs(msg->length);
while (start < end)
ext = (hb_ext_t *)start;
ext_len = ext->length + sizeof(hb_ext_t);
switch(ext->type)
case HB_EXT_PDSN_CALL_LOAD:
if(ext->length == 2)
memcpy((UCHAR *)temp,ext->data, 2);
call_load = ntohs(temp);
else
facn_log(LOG_ERR,"Invalid Heartbeat extension length = %x",ext->length);
break;
case HB_EXT_PDSN_CPU_USAGE:
if(ext->length == 2)
memcpy((UCHAR *)temp,ext->data, 2);
cpu_usage = ntohs(temp);
else
facn_log(LOG_ERR,"Invalid Heartbeat extension length = %x",ext->length);
break;
case HB_EXT_PDSN_MEM_USAGE:
if(ext->length == 2)
memcpy((UCHAR *)temp,ext->data, 2);
mem_usage = ntohs(temp);
else
facn_log(LOG_ERR,"Invalid Heartbeat extension length = %x",ext->length);
break;
case MIP_EXT_FOREIGN_HOME_AUTH:
break;
default:
facn_log(LOG_DEBUG,"Invalid Extension");
break;
start += ext_len;
/* if the PDSN doesn't already exist, send the discovery trap */
pdsn_ptr = (pdsn_data_t *)db_pdsn_lookup(pdsn_id);
if (pdsn_ptr == NULL)
util_send_trap(PDSN_DISCOVERY_TRAP, pdsn_id);
facn_log(LOG_INFO,"PDSN %x DISCOVERED", pdsn_id);
/*
* Try to add the PDSN to the database. If it already exists,
* db_pdsn_add() will return a pointer to it.
*/
pdsn_ptr = (pdsn_data_t *)db_pdsn_add(pdsn_id);
if (pdsn_ptr == NULL)
facn_log(LOG_ERR,
"db_pdsn_add: Failed to add entry to the database");
return;
else
/* If the existing PDSN was inactive, generate a PDSN ACTIVE trap */
if( pdsn_ptr->status == INACTIVE )
util_send_trap(PDSN_ACTIVE_TRAP, pdsn_id);
facn_log(LOG_INFO,"PDSN %x marked ACTIVE", pdsn_id);
/* 10/12/00 fix to SEC MR 1011-2 - copy unavail code from hb msg to pdsn record */
pdsn_ptr->misc_unavail = msg->unavail;
pdsn_ptr->pdsn_id = pdsn_id;
pdsn_ptr->call_load = call_load;
pdsn_ptr->cpu_usage = cpu_usage;
pdsn_ptr->mem_usage = mem_usage;
pdsn_ptr->hb_interval = ntohs(msg->lifetime);
pdsn_ptr->missed_hb_cnt = 0;
pdsn_ptr->status = ACTIVE;
pdsn_ptr->last_hb.tv_sec = current_time.tv_sec;
pdsn_ptr->last_hb.tv_usec = current_time.tv_sec;
/*
* Search the Group Lists for the PDSN. If the PDSN is not found in any
* of the groups place it in the default list.
*/
ret = db_pdsn_group_find(pdsn_id);
if (!ret)
facn_log(LOG_INFO,"PDSN %x not found in any PDSN Group",pdsn_id);
if( !db_group_add_pdsn(0,pdsn_ptr->pdsn_id) )
facn_log(LOG_ERR,"New Heartbeating PDSN %d cannot be added togroup zero. The group is full.",
pdsn_id );
return;
hb_ack_msg(pdsn_ptr->pdsn_id,from); // Send HB ACK to PDSN.
/******************************************************************************
*
* hb_init_msg() : Process the Heartbeat Init message received from the PDSN.
*
* Arguments : msg - Heartbeat message
* len - message length
* from - socket information
*
* Return Values : Returns 0 if successfully, otherwise returns -1.
*
******************************************************************************/
UINT32
hb_init_msg(hb_msg_t *msg, UINT32 len, struct sockaddr_in *from)
pdsn_data_t *pdsn_ptr = NULL;
void *key;
struct timeval current_time;
UINT32 pdsn_id;
int ret = 0;
int new_pdsn = 0;
/* Check Authentication */
ret = hb_auth(msg,len);
if (ret != 0)
facn_log(LOG_ERR,"HB INIT failed Authentication");
return(-1);
gettimeofday(current_time, NULL);
pdsn_id = ntohl(msg->pdsn_id);
/* if the PDSN doesn't already exist, send the discovery trap */
pdsn_ptr = (pdsn_data_t *)db_pdsn_lookup(pdsn_id);
if (pdsn_ptr == NULL)
util_send_trap(PDSN_DISCOVERY_TRAP, pdsn_id);
new_pdsn = 1;
/* Add pdsn to the database if it is not already there. */
pdsn_ptr = (pdsn_data_t *)db_pdsn_add(pdsn_id);
if (pdsn_ptr == NULL)
facn_log(LOG_ERR,"db_pdsn_add: Failed to add entry to the database");
return;
/* if this PDSN has just been added to the database, initialize fields */
if (new_pdsn)
/* 10/12/00 fix to SEC MR 1011-2 - copy unavail code from hb msg to pdsn record */
pdsn_ptr->misc_unavail = msg->unavail;
pdsn_ptr->pdsn_id = pdsn_id;
pdsn_ptr->call_load = 0;
pdsn_ptr->cpu_usage = 0;
pdsn_ptr->mem_usage = 0;
pdsn_ptr->missed_hb_cnt = 0;
pdsn_ptr->last_hb.tv_sec = current_time.tv_sec;
pdsn_ptr->last_hb.tv_usec = current_time.tv_sec;
pdsn_ptr->status = INACTIVE;
/*
* Search the Group Lists for the PDSN. If the PDSN is not found in any
* of the groups place it in the default list.
*/
ret = db_pdsn_group_find(pdsn_id);
if (!ret)
facn_log(LOG_INFO,"PDSN %x not found in any PDSN Group",pdsn_id);
if( !db_group_add_pdsn(0,pdsn_ptr->pdsn_id) )
facn_log(LOG_ERR,"New Heartbeat Init PDSN %x cannot be added togroup
zero. The group is full.",
pdsn_id );
return;
hb_init_ack_msg(pdsn_id,from); // Send HB Init Ack message.
/******************************************************************************
*
* hb_proc_msg() : Process the Heartbeat message received from the PDSN.
*
* Arguments : msg - Heartbeat message
* len - message length
* from - socket information
*
******************************************************************************/
void
hb_proc_msg(hb_msg_t *msg,UINT32 len,struct sockaddr_in *from)
/* Process the msgs from the PDSN. */
hb_print_msgs(msg,len,from);
switch(msg->type)
case HB_TYPE_HB: /* heartbeat msg */
hb_msg(msg, len, from);
break;
case HB_TYPE_INIT: /* heartbeat init msg */
hb_init_msg(msg, len, from);
break;
default: /* invalid msg */
facn_log(LOG_ERR,"Received invalid msg from PDSN=%d",msg->pdsn_id);
break;
/* $Log: hb.c,v $
/* Revision 1.15 2001/04/16 17:33:28 fdickson
/* Changed error displays for some PDSNs fron %d to %x.
/*
/* Revision 1.14 2001/03/13 18:49:40 fdickson
/* Changed DEBUG to ERR when trying to add a PDSN to group 0 (no room).
/*
/* Revision 1.13 2001/03/09 23:27:53 fdickson
/* Added proper calls to log MIP send/rcv messages, and verified that PDSNs were added to group zero if necessary.
/*
/* Revision 1.12 2000/10/12 20:47:18 glewis
/* add check for pdsn unavailable code when selecting pdsn
/*
/* Revision 1.11 2000/09/14 00:44:12 glewis
/* add check for PDSN SPI
/*
/* Revision 1.10 2000/08/24 20:04:57 fdickson
/* Added PDSN Active SNMP trap call.
/*
/* Revision 1.9 2000/08/21 18:39:32 glewis
/* only init pdsn fields (including status to INACTIVE) if this hb_init
/* caused the record to be created (discovered)
/*
/* Revision 1.8 2000/08/15 21:22:45 fdickson
/* Fixed minor error is config name.
/*
/* Revision 1.7 2000/06/09 23:01:29 glewis
/* change log of hb auth failure to LOG_ERR
/*
/* Revision 1.6 2000/06/06 23:50:36 fdickson
/* Passed a value with a trap call.
/*
/* Revision 1.5 2000/06/05 16:59:24 glewis
/* identify hb in auth failed error msg
/*
/* Revision 1.4 2000/05/31 20:16:58 glewis
/* various cosmetic changes per code review, support for PDSN_DISCOVERY_TRAP
/*
/* Revision 1.3 2000/05/25 21:35:02 pwl
/* code review clean up
/*
/* Revision 1.2 2000/04/14 04:57:03 glewis
/* store the expected heartbeat interval from the lifetime field in the hb
/* message into the PDSN record
/*
/* Revision 1.1 2000/04/12 17:38:30 obrien
/* Initial Revision
/* */
/* Copyright 1999-2000 3Com Corporation. All Rights Reserved. */
/* $Id: md5c.c,v 1.1 2000/04/12 17:33:55 obrien Exp $ */
/* MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm
*/
/* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
rights reserved.
License to copy and use this software is granted provided that it
is identified as the "RSA Data Security, Inc. MD5 Message-Digest
Algorithm" in all material mentioning or referencing this software
or this function.
License is also granted to make and use derivative works provided
that such works are identified as "derived from the RSA Data
Security, Inc. MD5 Message-Digest Algorithm" in all material
mentioning or referencing the derived work.
RSA Data Security, Inc. makes no representations concerning either
the merchantability of this software or the suitability of this
software for any particular purpose. It is provided "as is"
without express or implied warranty of any kind.
These notices must be retained in any copies of any part of this
documentation and/or software.
*/
#include "md5_globals.h"
#include "md5.h"
/* Constants for MD5Transform routine.
*/
#define S11 7
#define S12 12
#define S13 17
#define S14 22
#define S21 5
#define S22 9
#define S23 14
#define S24 20
#define S31 4
#define S32 11
#define S33 16
#define S34 23
#define S41 6
#define S42 10
#define S43 15
#define S44 21
static void MD5Transform PROTO_LIST ((UINT4 [4], unsigned char [64]));
static void Encode PROTO_LIST
((unsigned char *, UINT4 *, unsigned int));
static void Decode PROTO_LIST
((UINT4 *, unsigned char *, unsigned int));
static void MD5_memcpy PROTO_LIST ((POINTER, POINTER, unsigned int));
static void MD5_memset PROTO_LIST ((POINTER, int, unsigned int));
static unsigned char PADDING[64] =
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
;
/* F, G, H and I are basic MD5 functions.
*/
#define F(x, y, z) (((x) (y)) | ((~x) (z)))
#define G(x, y, z) (((x) (z)) | ((y) (~z)))
#define H(x, y, z) ((x) ^ (y) ^ (z))
#define I(x, y, z) ((y) ^ ((x) | (~z)))
/* ROTATE_LEFT rotates x left n bits.
*/
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
/* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
Rotation is separate from addition to prevent recomputation.
*/
#define FF(a, b, c, d, x, s, ac) \f1
(a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \f1
(a) = ROTATE_LEFT ((a), (s)); \f1
(a) += (b); \f1
#define GG(a, b, c, d, x, s, ac) \f1
(a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \f1
(a) = ROTATE_LEFT ((a), (s)); \f1
(a) += (b); \f1
#define HH(a, b, c, d, x, s, ac) \f1
(a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \f1
(a) = ROTATE_LEFT ((a), (s)); \f1
(a) += (b); \f1
#define II(a, b, c, d, x, s, ac) \f1
(a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \f1
(a) = ROTATE_LEFT ((a), (s)); \f1
(a) += (b); \f1
/* MD5 initialization. Begins an MD5 operation, writing a new context.
*/
void MD5Init (context)
MD5_CTX *context; /* context */
context->count[0] = context->count[1] = 0;
/* Load magic initialization constants. */
context->state[0] = 0x67452301;
context->state[1] = 0xefcdab89;
context->state[2] = 0x98badcfe;
context->state[3] = 0x10325476;
/* MD5 block update operation. Continues an MD5 message-digest
operation, processing another message block, and updating the
context.
*/
void MD5Update (context, input, inputLen)
MD5_CTX *context; /* context */
unsigned char *input; /* input block */
unsigned int inputLen; /* length of input block */
unsigned int i, index, partLen;
/* Compute number of bytes mod 64 */
index = (unsigned int)((context->count[0] >> 3) 0x3F);
/* Update number of bits */
if ((context->count[0] += ((UINT4)inputLen << 3))
< ((UINT4)inputLen << 3))
context->count[1]++;
context->count[1] += ((UINT4)inputLen >> 29);
partLen = 64 - index;
/* Transform as many times as possible. */
if (inputLen >= partLen)
MD5_memcpy((POINTER)context->buffer[index], (POINTER)input, partLen);
MD5Transform (context->state, context->buffer);
for (i = partLen; i + 63 < inputLen; i += 64)
MD5Transform (context->state, input[i]);
index = 0;
else
i = 0;
/* Buffer remaining input */
MD5_memcpy((POINTER)context->buffer[index], (POINTER)input[i], inputLen-i);
/* MD5 finalization. Ends an MD5 message-digest operation, writing the
the message digest and zeroizing the context.
*/
void MD5Final (digest, context)
unsigned char digest[16]; /* message digest */
MD5_CTX *context; /* context */
unsigned char bits[8];
unsigned int index, padLen;
/* Save number of bits */
Encode (bits, context->count, 8);
/* Pad out to 56 mod 64. */
index = (unsigned int)((context->count[0] >> 3) 0x3f);
padLen = (index < 56) ? (56 - index) : (120 - index);
MD5Update (context, PADDING, padLen);
/* Append length (before padding) */
MD5Update (context, bits, 8);
/* Store state in digest */
Encode (digest, context->state, 16);
/* Zeroize sensitive information. */
MD5_memset ((POINTER)context, 0, sizeof (*context));
/* MD5 basic transformation. Transforms state based on block. */
static void MD5Transform (state, block)
UINT4 state[4];
unsigned char block[64];
UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
Decode (x, block, 64);
/* Round 1 */
FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
/* Round 2 */
GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */
GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
/* Round 3 */
HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
HH (b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */
HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
/* Round 4 */
II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
state[0] += a;
state[1] += b;
state[2] += c;
state[3] += d;
/* Zeroize sensitive information. */
MD5_memset ((POINTER)x, 0, sizeof (x));
/* Encodes input (UINT4) into output (unsigned char). Assumes len is
a multiple of 4.
*/
static void Encode (output, input, len)
unsigned char *output;
UINT4 *input;
unsigned int len;
unsigned int i, j;
for (i = 0, j = 0; j < len; i++, j += 4)
output[j] = (unsigned char)(input[i] 0xff);
output[j+1] = (unsigned char)((input[i] >> 8) 0xff);
output[j+2] = (unsigned char)((input[i] >> 16) 0xff);
output[j+3] = (unsigned char)((input[i] >> 24) 0xff);
/* Decodes input (unsigned char) into output (UINT4). Assumes len is
a multiple of 4.
*/
static void Decode (output, input, len)
UINT4 *output;
unsigned char *input;
unsigned int len;
unsigned int i, j;
for (i = 0, j = 0; j < len; i++, j += 4)
output[i] = ((UINT4)input[j]) | (((UINT4)input[j+1]) << 8) |
(((UINT4)input[j+2]) << 16) | (((UINT4)input[j+3]) << 24);
/* Note: Replace "for loop" with standard memcpy if possible.
*/
static void MD5_memcpy (output, input, len)
POINTER output;
POINTER input;
unsigned int len;
unsigned int i;
for (i = 0; i < len; i++)
output[i] = input[i];
/* Note: Replace "for loop" with standard memset if possible.
*/
static void MD5_memset (output, value, len)
POINTER output;
int value;
unsigned int len;
unsigned int i;
for (i = 0; i < len; i++)
((char *)output)[i] = (char)value;
/* $Log: md5c.c,v $
/* Revision 1.1 2000/04/12 17:33:55 obrien
/* Initial Revision
/* */
/* Copyright 1999-2000 3Com Corporation. All Rights Reserved. */
/* $Id: auth.c,v 1.8 2001/04/16 17:32:17 fdickson Exp $ */
/******************************************************************************
*
* Filename: auth.c
*
* Description: The file contains the authentication routines for the FACN.
*
* Author:
*
******************************************************************************/
/* Include Files */
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <signal.h>
#include <syslog.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <arpa/inet.h>
#include <netinet/in.h>
//#include <asm/types.h>
#include "hb_msgs.h"
#include "md5_globals.h"
#include "md5.h"
#include "facn_common.h"
#include "mip_msgs.h"
/*
* Functions
*/
UCHAR *
facn_auth(UCHAR *digest,UCHAR *msg,UINT32 msg_len,UCHAR *key,UINT32 key_len)
MD5_CTX context;
MD5Init(context);
MD5Update(context, key, key_len);
MD5Update(context, msg, msg_len);
MD5Update(context, key, key_len);
MD5Final(digest, context);
return digest;
/*********************************************************************
*
* UINT32 Facn_checkReplay(
* struct mipIdentification *new,
* struct mipIdentification *saved)
*
* Comments: checks to see if new message identification passes replay
* attack checking.
* Note: This routine expects the new message identification to be in
* network order.
*
* Returns 1 if the new message fails replay checking
*.
*********************************************************************
*/
UINT32
Facn_checkReplay(
mip_ident_t *new,
mip_ident_t *saved)
UINT32 low_order;
UINT32 high_order;
UINT32 seconds;
/*
* Convert new identification to host order
*/
low_order = ntohl(new->low_order);
high_order = ntohl(new->high_order);
/*
* Perform Replay Check (Add NTP check later...)
*/
/* better check time starting with V1.0.8 - get NTP time */
seconds = get_timestamp();
if ((high_order > (seconds + 255)) || (high_order < (seconds - 255)))
facn_log(LOG_INFO, "Facn_checkReplay error - high=%x,low=%x, secs=%x",
high_order,low_order, seconds );
return 1; /* message drift more than 255 seconds */
/* if saved is null, don't try to check against it and return ok */
if (!saved)
return 0;
if (high_order > saved->high_order)
return 0; /* message sent at a later second */
if ( low_order > saved->low_order high_order == saved->high_order )
return 0; /* message sent at the same second, but later */
/* patch to MR 4426 - don't do following checks (consistent with PDSN) */
// facn_log(LOG_DEBUG,
// "Facn_checkReplay error - high/low=%x/%x, saved high/low=%x/%x",
// high_order,low_order, saved->high_order,saved->low_order );
// return 1;
return 0;
/* end of MR 4426 patch */
/* $Log: auth.c,v $
/* Revision 1.8 2001/04/16 17:32:17 fdickson
/* Changed Facn_checkReplay error from LOG_DEBUG to LOG_INFO.
/*
/* Revision 1.7 2001/02/19 19:12:10 glewis
/* make ident field check consistent with PDSN - do time drift check only
/*
/* Revision 1.6 2001/01/23 22:35:47 fdickson
/* Modified LOG_DEBUG messages.
/*
/* Revision 1.5 2000/09/22 22:38:13 glewis
/* change replay check function to only check for time drift if no "saved"
/* ID passed in
/*
/* Revision 1.4 2000/09/21 20:24:29 glewis
/* check ID field against NTP time (within 255 seconds)
/*
/* Revision 1.3 2000/05/25 21:34:26 pwl
/* code review clean up
/*
/* Revision 1.2 2000/05/03 21:34:50 pwl
/* changed replay checking and ident initializing
/*
/* Revision 1.1 2000/04/12 17:27:53 obrien
/* Initial Revision
/* */

Claims (27)

  1. 통신 네트워크에서 인터넷 프로토콜 통신 서비스를 제공하는 방법에 있어서,
    제1 통신 네트워크 장치에서 클라이언트 장치와 관련된 통신 세션을 탐지하는 단계;
    제1 네트워크 장치로부터 제2 네트워크 장치로 등록 요청을 포함하는 제1 메세지를 전송하는 단계;
    클라이언트 장치와 관련된 통신 세션에 대해 통신 서비스를 제공하기 위해 제2 네트워크 장치에서 제3 네트워크 장치의 네트워크 어드레스를 결정하는 단계;
    제2 네트워크 장치로부터 제1 네트워크 장치로 제3 네트워크 장치의 네트워크 어드레스를 갖는 등록 응답 메세지를 포함하는 제1 응답 메세지를 전송하는 단계; 및
    제1 응답 메세지에서 규정된 제3 네트워크 장치 및 클라이언트 장치 사이에서 통신 세션을 설정하는 단계로서, 상기 제3 네트워크 장치는 클라이언트 네트워크 장치에 통신 서비스를 제공하기 위해 배열되는 단계를 포함하는 것을 특징으로 하는 인터넷 프로토콜 통신 서비스 제공 방법.
  2. 제1항에 있어서,
    상기 클라이언트 장치는 이동 인터넷 프로토콜 클라이언트 장치를 포함하고, 상기 제1 네트워크 장치는 무선 노드 엔티티를 포함하고, 상기 제2 네트워크 장치는 제어노드 엔티티를 포함하며, 상기 제3 네트워크 장치는 외부 에이젼트를 포함하는 것을 특징으로 하는 인터넷 프로토콜 통신 서비스 제공 방법.
  3. 제1항에 있어서,
    상기 인터넷 프로토콜 통신 서비스는 이동 인터넷 프로토콜 통신 서비스 또는 단순한 인터넷 프로토콜 통신 서비스를 포함하는 것을 특징으로 하는 인터넷 프로토콜 통신 서비스 제공 방법.
  4. 제1항에 있어서,
    제3 네트워크 장치의 네트워크 어드레스를 결정하는 단계는
    클라이언트 장치가 등록된 클라이언트 장치인지를 결정하는 단계; 그리고 그러하다면,
    클라이언트 장치 레코드를 검색하여 클라이언트 장치에 인터넷 프로토콜 통신 서비스를 제공하도록 배열된 네트워크 장치의 네트워크 어드레스를 결정하는 단계;
    클라이언트 장치들에 인터넷 프로토콜 통신 서비스를 제공하기 위해 적어도 하나의 네트워크 장치의 적어도 하나의 네트워크 어드레스를 포함하는 제1 네트워크 장치 배치 레코드를 검색하는 단계;
    제1 네트워크 장치 배치 레코드가 클라이언트 장치 레코드에 규정된 네트워크 장치의 네트워크 어드레스를 포함하는지 여부를 결정하는 단계; 그리고 그러하다면,
    클라이언트 장치 배치 레코드에 규정된 네트워크 장치의 네트워크 어드레스를 포함하는 제1 응답 메세지를 전송하는 단계를 포함하는 것을 특징으로 하는 인터넷 프로토콜 통신 서비스 제공 방법.
  5. 제4항에 있어서,
    클라이언트 장치가 등록된 네트워크 장치가 아니라면,
    인터넷 프로토콜 통신 서비스를 클라이언트 장치들에 제공하기 위해 적어도 하나의 네트워크 장치의 적어도 하나의 네트워크 어드레스를 포함하는 제1 네트워크 장치 배치 레코드를 검색하는 단계;
    인터넷 프로토콜 통신 서비스를 클라이언트 장치들에 제공하기 위해 배열된 적어도 하나의 네트워크 장치 각각에 대한 상태 정보 레코드를 검색하는 단계로서, 상기 상태 정보 레코드는 레코드내에 네트워크 장치와 관련된 적어도 하나의 로드 인자를 포함하는 단계; 및
    네트워크 장치와 관련된 적어도 하나의 로드 인자 및 적어도 하나의 로드 인자와 관련된 적어도 하나의 임계치값에 따라 인터넷 프로토콜 통신 서비스를 클라이언트 장치에 제공하기 위해 네트워크 장치의 네트워크 어드레스를 결정하는 단계를 포함하는 것을 특징으로 하는 인터넷 프로토콜 통신 서비스 제공 방법.
  6. 제5항에 있어서,
    상기 적어도 하나의 로드 인자는 호출 로드 인자, 처리 전력 로드 인자, 또는 메모리 로드 인자를 포함하는 것을 특징으로 하는 인터넷 프로토콜 통신 서비스 제공 방법.
  7. 제1항에 있어서,
    인터넷 프로토콜 통신 서비스를 클라이언트 장치들로 제공하기 위해 배열된 적어도 하나의 네트워크 장치로부터 적어도 하나의 상태 정보 메세지를 제2 네트워크 상에서 검색하는 단계로서, 상기 적어도 하나의 상태 정보 메세지는 적어도 하나의 상태 정보 메세지를 전송하는 네트워크 장치와 관련된 적어도 하나의 로드 인자를 포함하는 단계; 및
    적어도 하나의 네트워크 장치로부터 적어도 하나의 상태 정보 메세지를 수신시에 적어도 하나의 상태 정보 레코드를 발생시키는 단계를 추가로 포함하는 것을 특징으로 하는 인터넷 프로토콜 통신 서비스 제공 방법.
  8. 제7항에 있어서,
    적어도 하나의 상태 정보 메세지는 인터넷 프로토콜 통신 서비스를 클라이언트 장치들에 제공하기 위해 배열된 적어도 하나의 네트워크 장치로부터 주기적으로 수신되는 것을 특징으로 하는 인터넷 프로토콜 통신 서비스 제공 방법.
  9. 제1항에 있어서,
    인터넷 프로토콜 통신 서비스를 클라이언트 장치에 제공하기 위해 네트워크 장치로부터 제2 메세지를 수신하는 단계로서, 상기 제2 메세지는 클라이언트 장치의 인증 데이타에 대한 요청을 포함하는 단계;
    제2 네트워크 장치에서 클라이언트 장치 레코드를 검색하는 단계;
    클라이언트 장치 레코드가 클라이언트 장치의 인증 데이타를 포함하는지 여부를 결정하는 단계; 그리고 그러하다면,
    클라이언트 장치의 인증 데이타를 포함하는 제2 응답 메세지를 네트워크 장치에 전송하는 단계를 추가로 포함하는 것을 특징으로 하는 인터넷 프로토콜 통신 서비스 제공 방법.
  10. 제1항에 있어서,
    제2 네트워크 장치 상에서 제3 네트워크 장치로부터 제1 등록 갱신 메세지를 수신하는 단계;
    클라이언트 장치 레코드에 기반하여 제3 네트워크 장치가 클라이언트 장치에 최종적으로 서빙하는 네트워크 장치인지를 결정하는 단계; 그리고 그렇지 않다면,
    제2 네트워크 장치로부터 클라이언트 장치에 최종적으로 서빙하는 네트워크 장치로 제2 등록 갱신 메세지를 전송하는 단계; 및
    제어노드로부터 제2 등록 갱신 메세지 수신에 응답하여 클라이언트 장치에 최종적으로 서빙하는 네트워크 장치 상에서 클라이언트 장치와 관련된 통신 링크를 종결하는 단계를 추가로 포함하는 것을 특징으로 하는 인터넷 프로토콜 통신 서비스 제공 방법.
  11. 통신 네트워크에서 인터넷 프로토콜 통신 서비스를 제공하는 방법에 있어서,
    무선 노드 상에서 탐지된 이동 클라이언트를 외부 에이젼트를 통해 등록하기 위한 요청을 포함하는 등록 요청 메세지를 무선 노드로부터 제어노드 상에서 수신하는 단계;
    이동 클라이언트가 적어도 하나의 활성 통신 세션과 관련되는지를 결정하는 단계; 그리고 그러하다면,
    이동 클라이언트와 관련된 최종 서빙 외부 에이젼트를 결정하는 단계;
    최종 외부 에이젼트가 이용가능한지 그리고 무선 노드와 관련되는지를 결정하는 단계; 그리고 그러하다면,
    최종 서빙 외부 에이젼트의 네트워크 어드레스를 포함하는 등록 응답 메세지를 제어노드로부터 무선노드로 전송하는 단계를 포함하는 것을 특징으로 하는 인터넷 프로토콜 통신 서비스 제공 방법.
  12. 제11항에 있어서,
    최종 서빙 외부 에이젼트가 이용가능하지 않거나 또는 무선 노드와 관련되지 않는 경우, 제어노드 상에서 이동 클라이언트에 대한 새로운 외부 에이젼트를 결정하는 단계;
    새로운 외부 에이젼트의 네트워크 어드레스를 포함하는 등록 응답 메세지를제어노드로부터 무선노드로 전송하는 단계;
    제어노드로부터 최종 서빙 외부 에이젼트로 등록 갱신 메세지를 전송하는 단계;
    최종 서빙 외부 에이젼트 상에서 등록 갱신 메세지 수신에 응답하여 최종 서빙 외부 에이젼트 상에서 이동 클라이언트와 관련된 적어도 하나의 통신 세션을 종결하는 단계를 추가로 포함하는 것을 특징으로 하는 인터넷 프로토콜 통신 서비스 제공 방법.
  13. 제12항에 있어서,
    새로운 외부 에이젼트를 결정하는 단계는,
    복수의 외부 에이젼트들을 포함하는 무선 노드 레코드를 검색하는 단계;
    복수의 외부 에이젼트들 각각에 대한 상태 정보 레코드를 검색하는 단계로서, 상기 상태 정보 레코드는 각 상태 정보 레코드내에 외부 에이젼트와 관련된 적어도 하나의 로드 인자를 포함하는 단계; 및
    복수의 외부 에이젼트들 각각에 대한 각 상태 정보 레코드내에 적어도 하나의 로드 인자에 기반하여 새로운 외부 에이젼트를 결정하는 단계를 포함하는 것을 특징으로 하는 인터넷 프로토콜 통신 서비스 제공 방법.
  14. 제13항에 있어서,
    적어도 하나의 로드 인자는 호출 로드 인자, 처리 전력 로드 인자, 메모리사용 인자, 또는 총 호출 처리량 인자를 포함하는 것을 특징으로 하는 인터넷 프로토콜 통신 서비스 제공 방법.
  15. 제13항에 있어서,
    제어노드 상에서 복수의 외부 에이젼트들로부터 적어도 하나의 로드 인자를 수신하는 단계; 및
    제어노드 상에서 적어도 하나의 로드 인자 수신에 응답하여 복수의 외부 에이젼트들 각각에 대한 상태 정보 레코드를 발생시키는 단계를 추가로 포함하는 것을 특징으로 하는 인터넷 프로토콜 통신 서비스 제공 방법.
  16. 제11항에 있어서,
    이동 클라이언트는 이동 인터넷 프로토콜 클라이언트를 포함하고, 무선노드는 기지국 제어노드, 패킷 제어노드, 또는 무선 네트워크 노드를 포함하는 것을 특징으로 하는 인터넷 프로토콜 통신 서비스 제공 방법.
  17. 이동 클라이언트 장치들에 인터넷 프로토콜 통신 서비스를 제공하는 인터넷 프로토콜 워킹 장치에 있어서,
    중앙 처리 유닛;
    적어도 하나의 무선 노드와 통신하고, 무선 노드 상에서 이동 클라이언트와 관련된 통신 세션을 탐지할 때 무선노드로부터 등옥 요청 메세지를 수신하는 제1인터페이스;
    복수의 외부 에이젼트들을 포함하는 복수의 네트워크 장치와 통신하고, 복수의 외부 에이젼트들을 포함하는 복수의 네트워크 장치들로부터 로드 상태 정보 및 이동 클라이언트 정보 데이타를 수신하는 제2 인터페이스;
    이동 클라이언트 정보 데이타 및 로드 상태 정보 데이타를 저장하는 적어도 하나의 메모리 유닛;
    무선노드로부터 등록 요청 메세지 수신에 응답하여 무선노드로부터 등록 요청 메세지를 처리하고 복수의 외부 에이젼트들을 포함하는 복수의 네트워크 장치들 중 적어도 하나의 네트워크 어드레스를 포함하는 등록 응답 메세지를 발생시키기 위해 제1 지시들 셋을 포함하는 기계 판독 저장 매체를 포함하며,
    등록 응답 메세지에 규정된 네트워크 어드레스는 적어도 하나의 무선노드로부터 등록 요청 메세지 수신시에 외부 에이젼트들을 포함하는 네트워크 장치들을 선택하기 위해 제2 지시들 셋을 사용하여 결정되며, 상기 제2 지시들 셋은 적어도 하나의 메모리 유닛에 저장된 로드 상태 정보 데이타 및 클라이언트 장치 정보를 사용하기 위해 배열되는 것을 특징으로 하는 인터넷 프로토콜 워킹 장치.
  18. 제17항에 있어서,
    인터넷 프로토콜 통신 서비스는 이동 인터넷 프로토콜 통신 서비스 또는 간단한 인터넷 프로토콜 통신 서비스를 포함하는 것을 특징으로 하는 인터넷 프로토콜 워킹 장치.
  19. 제17항에 있어서,
    제1 인터페이스를 통해 인터넷 프로토콜 워킹 장치와 통신하는 적어도 하나의 무선노드는 기지국 제어기 노드, 패킷 제어 함수 노드 또는 무선 네트워크 노드를 포함하는 것을 특징으로 하는 인터넷 프로토콜 워킹 장치.
  20. 제17항에 있어서,
    제2 지시들 셋은 무선노드 상에서 탐지된 클라이언트 장치와 관련된 이동 세션 정보 데이타에 기반하여 등록 응답 메세지내의 네트워크 어드레스를 결정하기 위해서 사용되며, 이동 세션 정보 데이타는 클라이언트 장치에 인터넷 프로토콜 통신 서비스를 제공하기 위해 배열된 네트워크 장치의 네트워크 어드레스를 포함하는 것을 특징으로 하는 인터넷 프로토콜 워킹 장치.
  21. 제17항에 있어서,
    적어도 하나의 메모리 유닛은 적어도 하나의 로드 임계치 레벨을 추가로 포함하고, 제2 지시들 셋은 로드 상태 정보 데이타 및 적어도 하나의 임계치 레벨을 사용하여 등록 응답 메세지에 규정된 네트워크 어드레스를 결정하는 것을 특징으로 하는 인터넷 프로토콜 워킹 장치.
  22. 제21항에 있어서,
    적어도 하나의 메모리 유닛은 적어도 하나의 무선노드에 대해 적어도 하나의 배치 레코드를 추가로 포함하고, 적어도 하나의 배치 레코드는 적어도 하나의 배치 레코드내의 적어도 하나의 무선노드에 인터넷 프로토콜 통신 서비스를 제공하기 위해 배열된 외부 에이젼트들을 포함하는 적어도 하나의 네트워크 장치와 관련된 적어도 하나의 네트워크 어드레스를 포함하며, 제2 지시들 셋은 등록 요청 메세지와 관련된 무선노드의 배치 레코드, 적어도 하나의 임계치 레벨 및 무선 노드의 배치 레코드에 규정된 적어도 하나의 네트워크 장치의 로드 상태 정보 데이타를 사용하여 등록 응답 메세지에 규정된 네트워크 어드레스를 결정하는 것을 특징으로 하는 인터넷 프로토콜 워킹 장치.
  23. 제17항에 있어서,
    적어도 하나의 메모리 유닛에 저장된 이동 세션 정보 데이타는 클라이언트 장치들과 관련된 인증 데이타를 포함하는 것을 특징으로 하는 인터넷 프로토콜 워킹 장치.
  24. 제23항에 있어서,
    제2 지시들 셋을 사용하여 결정된 네트워크 장치로부터 클라이언트 장치의 인증 데이타에 대한 인증 데이타 요청을 포함하는 등록 요청 메세지를 처리하고 이동 세션 정보 데이타가 클라이언트 장치의 인증 데이타를 포함하는 경우 클라이언트 장치의 인증 데이타를 포함하는 등록 응답 메세지를 발생시키는 제3 지시들 셋을 추가로 포함하는 것을 특징으로 하는 인터넷 프로토콜 워킹 장치.
  25. 제17항에 있어서,
    제2 지시들 셋은 등록 응답 메세지에 규정된 네트워크 어드레스가 클라이언트 장치와 관련된 최종 서빙 네트워크 장치의 네트워크 어드레스와 관련되는지 여부를 결정하고, 등록 응답 메세지의 네트워크 장치가 최종 서빙 네트워크 장치의 네트워크 어드레스와 관련되지 않으면 최종 서빙 네트워크 장치에 등록 갱신 메세지를 전송하기 위해 배열되는 것을 특징으로 하는 인터넷 프로토콜 워킹 장치.
  26. 제25항에 있어서,
    등록 갱신 메세지는 최종 서빙 네트워크 장치에서 클라이언트 장치와 관련된 적어도 하나의 통신 세션을 종결하도록 하는 요청을 포함하는 것을 특징으로 하는 인터넷 프로토콜 워킹 장치.
  27. 제17항에 있어서,
    제1 인터페이스 및 제2 인터페이스는 소프트웨어 인터페이스 또는 하드웨어 인터페이스를 포함하는 것을 특징으로 하는 인터넷 프로토콜 워킹 장치.
KR10-2002-0033243A 2001-06-14 2002-06-14 이동 인터넷 프로토콜 네트워크에서 외부 에이젼트 선택을관리하는 시스템 및 방법 KR100436636B1 (ko)

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
US09/881,649 2001-06-14
US09/881,649 US7193985B1 (en) 2001-06-14 2001-06-14 System and method for managing foreign agent selections in a mobile internet protocol network

Publications (2)

Publication Number Publication Date
KR20020095449A KR20020095449A (ko) 2002-12-26
KR100436636B1 true KR100436636B1 (ko) 2004-06-22

Family

ID=25378910

Family Applications (1)

Application Number Title Priority Date Filing Date
KR10-2002-0033243A KR100436636B1 (ko) 2001-06-14 2002-06-14 이동 인터넷 프로토콜 네트워크에서 외부 에이젼트 선택을관리하는 시스템 및 방법

Country Status (5)

Country Link
US (2) US7193985B1 (ko)
JP (1) JP3754398B2 (ko)
KR (1) KR100436636B1 (ko)
CN (1) CN1392703A (ko)
HK (1) HK1052596A1 (ko)

Families Citing this family (57)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
DE60227848D1 (de) * 2001-03-14 2008-09-04 Nec Corp Verwaltungssystem für Mobile Endgeräte, Mobiles Endgerät und Programm
KR100442594B1 (ko) * 2001-09-11 2004-08-02 삼성전자주식회사 무선통신 시스템의 패킷 데이터 서비스 방법 및 장치
US8140845B2 (en) * 2001-09-13 2012-03-20 Alcatel Lucent Scheme for authentication and dynamic key exchange
CA2358083A1 (en) * 2001-09-28 2003-03-28 Bridgewater Systems Corporation A method for session accounting in a wireless data networks using authentication, authorization and accounting (aaa) protocols (such as ietf radius or diameter) where there is no session handoff communication between the network elements
WO2003040943A1 (en) * 2001-11-07 2003-05-15 Cyneta Networks Inc. Cell level congestion policy management
US20040003058A1 (en) * 2002-06-26 2004-01-01 Nokia, Inc. Integration of service registration and discovery in networks
US7466680B2 (en) * 2002-10-11 2008-12-16 Spyder Navigations L.L.C. Transport efficiency optimization for Mobile IPv6
WO2004098143A1 (en) * 2003-04-28 2004-11-11 Chantry Networks Inc. System and method for mobile unit session management across a wireless communication network
US7634558B1 (en) * 2003-09-22 2009-12-15 Sprint Spectrum L.P. Method and system for updating network presence records at a rate dependent on network load
US7675885B2 (en) * 2003-12-03 2010-03-09 Qualcomm Incorporated Methods and apparatus for CDMA2000/GPRS roaming
US20050143087A1 (en) * 2003-12-29 2005-06-30 Telefonaktiebolaget L M Ericsson (Publ) Dynamic selection of a packet data serving node
US7577836B2 (en) * 2004-01-16 2009-08-18 Verizon Business Global Llc Method and system for secured wireless data transmission to and from a remote device
US7228442B2 (en) * 2004-03-30 2007-06-05 The Boeing Company Method and systems for a radiation tolerant bus interface circuit
US8050176B2 (en) * 2004-03-30 2011-11-01 The Boeing Company Methods and systems for a data processing system having radiation tolerant bus
FI20040841A0 (fi) * 2004-06-17 2004-06-17 Nokia Corp Menetelmä tietoliikenteen valvomiseksi käyttäen verkkonoodiryhmää kommunikaatiojärjestelmässä
US7710964B2 (en) * 2004-06-22 2010-05-04 Nokia Corporation Discovering a network element in a communication system
US8903820B2 (en) * 2004-06-23 2014-12-02 Nokia Corporation Method, system and computer program to enable querying of resources in a certain context by definition of SIP even package
JP2006067480A (ja) * 2004-08-30 2006-03-09 Canon Inc ネットワークデバイス管理システム及びその制御方法、並びにプログラム
CN1283070C (zh) 2004-09-10 2006-11-01 华为技术有限公司 媒体网关监测媒体网关控制器状态的实现方法
US7620001B2 (en) * 2004-10-13 2009-11-17 Good Technology, Inc. Communication system and method with mobile devices
US7706522B2 (en) * 2004-12-13 2010-04-27 Cisco Technology, Inc. Method and system for communicating with an automatic call distributor system agent
US8411650B2 (en) * 2005-04-18 2013-04-02 Cisco Technology, Inc. Method and system for providing virtual private network services through a mobile IP home agent
US8331934B1 (en) 2005-06-09 2012-12-11 Microsoft Corporation Method and system for hard handoff in HRPD
DE202005021930U1 (de) 2005-08-01 2011-08-08 Corning Cable Systems Llc Faseroptische Auskoppelkabel und vorverbundene Baugruppen mit Toning-Teilen
CN100499545C (zh) 2005-08-19 2009-06-10 华为技术有限公司 一种移动因特网协议注册/去注册方法
CN101051899B (zh) * 2006-05-22 2011-05-04 华为技术有限公司 无线通信网络中生成移动ip密钥的方法及系统
JP4992308B2 (ja) 2006-06-14 2012-08-08 日本電気株式会社 通信システム、動作制御方法、位置管理サーバ及びプログラム
US8346265B2 (en) * 2006-06-20 2013-01-01 Alcatel Lucent Secure communication network user mobility apparatus and methods
US8320332B2 (en) * 2006-12-08 2012-11-27 Electronics And Telecommunications Research Institute IP handoff process method and system for connection of internet protocols between mobile agents in heterogeneous network
EP2109978B1 (en) * 2006-12-31 2018-04-18 Qualcomm Incorporated Communications methods, system and apparatus
US8411858B2 (en) * 2007-03-28 2013-04-02 Apple Inc. Dynamic foreign agent-home agent security association allocation for IP mobility systems
US20090086657A1 (en) * 2007-10-01 2009-04-02 Comsys Communication & Signal Processing Ltd. Hybrid automatic repeat request buffer flushing mechanism
JP5426538B2 (ja) 2008-05-01 2014-02-26 株式会社モリタ製作所 医療用ｘ線ｃｔ撮影装置、医療用ｘ線ｃｔ画像表示装置及びその表示方法
US8059557B1 (en) 2008-07-14 2011-11-15 Sprint Spectrum L.P. Method and system for access gateway selection
KR101711863B1 (ko) 2008-11-26 2017-03-13 캘거리 싸이언티픽 인코포레이티드 애플리케이션 프로그램의 상태에 대한 원격 액세스를 제공하기 위한 방법 및 시스템
US10055105B2 (en) 2009-02-03 2018-08-21 Calgary Scientific Inc. Method and system for enabling interaction with a plurality of applications using a single user interface
US8396490B2 (en) 2009-12-17 2013-03-12 Pokos Communications Corp Method and system for transmitting and receiving messages
CN102550006A (zh) * 2010-02-12 2012-07-04 莫维克网络公司 移动网络中的无线接入网络缓存
US8799480B2 (en) 2010-07-19 2014-08-05 Movik Networks Content pre-fetching and CDN assist methods in a wireless mobile network
US9741084B2 (en) 2011-01-04 2017-08-22 Calgary Scientific Inc. Method and system for providing remote access to data for display on a mobile device
US20120297009A1 (en) * 2011-05-18 2012-11-22 Oversi Networks Ltd. Method and system for cahing in mobile ran
EP2745467A4 (en) 2011-08-15 2015-10-14 Calgary Scient Inc METHOD FOR FLOW CONTROL AND RELIABLE COMMUNICATION IN A COMMUNITY ENVIRONMENT
CA2844871C (en) 2011-08-15 2021-02-02 Calgary Scientific Inc. Non-invasive remote access to an application program
JP6322140B2 (ja) 2011-09-30 2018-05-09 カルガリー サイエンティフィック インコーポレイテッド 協働遠隔アプリケーションの共用および注釈のための双方向デジタル表層を含む非連結アプリケーション拡張
AU2012342170B2 (en) 2011-11-23 2017-03-09 Calgary Scientific Inc. Methods and systems for collaborative remote application sharing and conferencing
WO2013128284A1 (en) 2012-03-02 2013-09-06 Calgary Scientific Inc. Remote control of an application using dynamic-linked library (dll) injection
US9729673B2 (en) 2012-06-21 2017-08-08 Calgary Scientific Inc. Method and system for providing synchronized views of multiple applications for display on a remote computing device
US9215689B2 (en) 2013-03-11 2015-12-15 Motorola Solutions, Inc. Method and apparatus for resolving call collisions in a digital conventional direct mode
US9370023B2 (en) 2013-03-11 2016-06-14 Motorola Solutions, Inc. Method and apparatus for resolving call collisions in a digital conventional direct mode
US9686205B2 (en) * 2013-11-29 2017-06-20 Calgary Scientific Inc. Method for providing a connection of a client to an unmanaged service in a client-server remote access system
US9350604B1 (en) 2014-03-28 2016-05-24 Sprint Spectrum L.P. Packet gateway assignment based on network connectivity
US9445256B1 (en) 2014-10-22 2016-09-13 Sprint Spectrum L.P. Binding update forwarding between packet gateways
US9936430B1 (en) 2016-03-07 2018-04-03 Sprint Spectrum L.P. Packet gateway reassignment
US10278123B2 (en) 2016-07-04 2019-04-30 Apple Inc. Network slice selection
CN107222338A (zh) * 2017-05-27 2017-09-29 信阳师范学院 一种物联网节点信息通信模型及通信方法
CN111448557A (zh) * 2017-07-31 2020-07-24 危机制止公司 利用网络节点传播信息
US10637956B1 (en) * 2019-10-01 2020-04-28 Metacluster It, Uab Smart proxy rotator

Citations (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
JP2000224233A (ja) * 1999-02-04 2000-08-11 Kdd Corp 移動体通信システム
WO2001006734A2 (en) * 1999-07-16 2001-01-25 3Com Corporation Mobile internet protocol (ip) networking with home agent and/or foreign agent functions distributed among multiple devices
KR20010030725A (ko) * 1997-09-25 2001-04-16 클라스 노린, 쿨트 헬스트룀 이동 통신 네트워크에서 선택 가능한 패킷 교환 및 회선교환 서비스 제공 방법 및 장치
JP2001144811A (ja) * 1999-11-17 2001-05-25 Sharp Corp モバイルｉｐにおける通信制御方式

Family Cites Families (7)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5528595A (en) 1974-06-09 1996-06-18 U.S. Robotics, Inc. Modem input/output signal processing techniques
IT1264602B1 (it) 1993-06-15 1996-10-04 Sits Soc It Telecom Siemens Elaboratore della segnalazione telefonica generata da misure tasmissive per sistemi radiomobili digitali
US6636489B1 (en) * 1997-11-03 2003-10-21 Bell South Wireless Data. L.P. Wireless management system and a method for an automated over-the-air managing process for wireless communication device
US6834050B1 (en) 2000-03-10 2004-12-21 Telefonaktiebolaget Lm Ericsson (Publ) Packet core function and method of selecting a packet data service node/foreign agent in a packet data network
US7075930B1 (en) 2000-04-11 2006-07-11 Telefonaktiebolaget Lm Ericsson (Publ) System and method for packet data servicing node (PDSN)initial assignment and reselection
US6771623B2 (en) * 2000-12-01 2004-08-03 Telefonaktiebolaget Lm Ericsson (Publ) Method for ensuring reliable mobile IP service
AU2003217301A1 (en) * 2002-02-04 2003-09-02 Flarion Technologies, Inc. A method for extending mobile ip and aaa to enable integrated support for local access and roaming access connectivity

Patent Citations (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
KR20010030725A (ko) * 1997-09-25 2001-04-16 클라스 노린, 쿨트 헬스트룀 이동 통신 네트워크에서 선택 가능한 패킷 교환 및 회선교환 서비스 제공 방법 및 장치
JP2000224233A (ja) * 1999-02-04 2000-08-11 Kdd Corp 移動体通信システム
WO2001006734A2 (en) * 1999-07-16 2001-01-25 3Com Corporation Mobile internet protocol (ip) networking with home agent and/or foreign agent functions distributed among multiple devices
JP2001144811A (ja) * 1999-11-17 2001-05-25 Sharp Corp モバイルｉｐにおける通信制御方式

Also Published As

Publication number Publication date
KR20020095449A (ko) 2002-12-26
CN1392703A (zh) 2003-01-22
US20070171886A1 (en) 2007-07-26
JP3754398B2 (ja) 2006-03-08
US7193985B1 (en) 2007-03-20
HK1052596A1 (zh) 2003-09-19
JP2003101572A (ja) 2003-04-04

Similar Documents

Publication Publication Date Title
KR100436636B1 (ko) 이동 인터넷 프로토콜 네트워크에서 외부 에이젼트 선택을관리하는 시스템 및 방법
US6956846B2 (en) System and method for foreign agent control node redundancy in a mobile internet protocol network
RU2368086C2 (ru) Способ, система и устройство для поддержки услуги hierarchical mobile ip
KR101102228B1 (ko) 모바일 노드 인증
FI105965B (fi) Autentikointi tietoliikenneverkosssa
EP1560397B1 (en) Endpoint address change in a packet network
US7079499B1 (en) Internet protocol mobility architecture framework
US6769000B1 (en) Unified directory services architecture for an IP mobility architecture framework
AU2003294330B2 (en) Methods and apparatus for dynamic session key generation and rekeying in mobile IP
KR101122999B1 (ko) 무선 통신 네트워크에서의 사용자 프로파일, 정책, 및 ｐｍｉｐ 키 분배
US20060185013A1 (en) Method, system and apparatus to support hierarchical mobile ip services
Hess et al. Performance evaluation of AAA/mobile IP authentication
WO2004062230A1 (en) Inter-proxy communication protocol for mobile ip
WO2008102061A1 (en) Fast update message authentication with key derivation in mobile ip systems
WO2005069559A1 (ja) 動的ネットワーク管理装置及び動的ネットワーク管理方法
AU7812600A (en) Internet protocol mobility architecture framework
Giovanardi et al. Optimization routing and security features for transparent mobile IP
Rikitake et al. T/TCP for DNS: A performance and security analysis
Wu Profile mapping with AAA server in wireless local area
Martinez Yelmo et al. An API for IPv6 Multihoming based on HBA and CGA
Dunmore et al. of Deliverable: Survey and evaluation of MIPv6 implementations
Kandirakis Route optimization for mobile IPV6 using the return routability procedure test bed implementation and security analysis
Dunmore et al. of Deliverable: Final MIPv6 Support Guide
Guide Mobile IP Commands
Braun AN API FOR IPV6 MULTIHOMING

Legal Events

Date Code Title Description
A201 Request for examination
E701 Decision to grant or registration of patent right
GRNT Written decision to grant
FPAY Annual fee payment

Payment date: 20070604

Year of fee payment: 4

LAPS Lapse due to unpaid annual fee