提交: 4 - bmpStation (svn)

bmpStation is server of BGP monitoring protocol.

Commit MetaInfo

• 修订版: 4 (tree)
• 时间: 2015-01-11 14:18:12
• 作者: yuki0220

Log Message

bmpAnalysis can understand update/withdrawn prefix

更改概述

• added: trunk/libbgp/getBGPmessages.c
• modified: trunk/libbgp/Makefile.am
• modified: trunk/libbgp/bgp.h
• modified: trunk/bmpStation/bmpStationLib.c
• modified: trunk/bmpStation/bmpRead.c
• modified: trunk/bmpAnalysis/bmpAnalysis.c
• modified: trunk/include/selfLib.h

差异

--- trunk/libbgp/getBGPmessages.c	(nonexistent)
+++ trunk/libbgp/getBGPmessages.c	(revision 4)
@@ -0,0 +1,338 @@
+/* 
+ * The MIT License
+ *
+ * Copyright (c) 2014 Yuki SAKAI
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+/*******************************************************************************
+ * include ********************************************************************/
+#if !defined(BGP_H__)
+#  include <bgp.h>
+#endif
+#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
+#if !defined(_SYS_ENDIAN_H) && !defined(_SYS_ENDIAN_H_)
+#  include <sys/endian.h>
+#endif
+#else
+#if !defined(_ENDIAN_H) && !defined(_ENDIAN_H_)
+#  include <endian.h>
+#endif
+#endif
+
+
+static int BGPUpdatePathAttributeMPreachNLRI   (u_int8_t *, ssize_t, BGPUpdateInfo *);
+static int BGPUpdatePathAttributeMPUnreachNLRI (u_int8_t *, ssize_t, BGPUpdateInfo *);
+/*%''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''%**
+ *: get BGP Messages process                                                 :**
+ *%,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,%*/
+#define DEBUG 1
+#if DEBUG == 1
+static void HEXoutput (u_int8_t *rdata, int len, int max)
+{
+  int i;
+  int outLen;
+  int counter = -16;
+  outLen = (len<max?len:max);
+
+  printf ("len: %d, output: %d\n", len, outLen);
+  for (i=0; i<outLen; i++) {
+    if ((i%16)==0) {counter += 16; printf ("0x%04X:", counter);}
+    if ((i%2)==0) {printf (" ");}
+    printf ("%02x", rdata[i]);
+    if ((i%16)==15) {printf ("\n");}
+  }
+  printf ("\n");
+}
+#endif
+
+/*******************************************************************************
+ * BGP messages ****************************************************************
+ *
+ ******************************************************************************/
+int BGPupdateMessages (u_int8_t *msg, ssize_t size, BGPUpdateInfo *bgpInfo)
+{
+  int i, ret;
+  ssize_t updateMsgLen, lenNLRI;
+  BGPCommonHeader *pBGPheader;
+  BGPUpdateLength *plenWdrawn, *plenPattr, lenWdrawn, lenPattr;
+  u_int8_t        *pProc, *pWdrawn, *pPattr, *pNLRI;
+  pBGPheader = (BGPCommonHeader *)msg;
+#if DEBUG == 1 && 0
+  HEXoutput ((u_int8_t *)msg, size, 256);
+#endif
+  if      (msg==NULL)                         {return -1;}
+  else if (size<sizeof (BGPCommonHeader)    ) {return -1;}
+  else if (size<be16toh (pBGPheader->length)) {return -1;}
+  else if (pBGPheader->type!=2)               {return  0;}
+  for (i=0; i<4; i++) {if (pBGPheader->Maker[i]!=0xffffffff) {return -1;}}
+
+  /*Get Area*******************************************************************/
+  updateMsgLen = be16toh (pBGPheader->length) - sizeof (BGPCommonHeader);
+  /* withdrawn area */
+  pWdrawn    = (u_int8_t *)(pBGPheader+1);
+  lenWdrawn  = be16toh (*((BGPUpdateLength *)pWdrawn));
+  pWdrawn   += sizeof (BGPUpdateLength);
+#if DEBUG == 1 && 0
+  printf ("withdrawn area: %d\n", lenWdrawn);
+  HEXoutput ((u_int8_t *)pWdrawn, lenWdrawn, 256);
+#endif
+
+  /* path attribute area */
+  pPattr     = (u_int8_t *)(pWdrawn + lenWdrawn);
+  lenPattr   = be16toh (*((BGPUpdateLength *)pPattr));
+  pPattr    += sizeof (BGPUpdateLength);
+#if DEBUG == 1 && 0
+  printf ("path attribute area: %d\n", lenPattr);
+  HEXoutput ((u_int8_t *)pPattr, lenPattr, 256);
+#endif
+
+  /* NLRI area */
+  pNLRI      = (u_int8_t *)(pPattr + lenPattr);
+  lenNLRI    = updateMsgLen - (sizeof (BGPUpdateLength) * 2 + lenWdrawn + lenPattr);
+#if DEBUG == 1 && 0
+  printf ("NLRI area: %d\n", lenNLRI);
+  HEXoutput ((u_int8_t *)pNLRI, lenNLRI, 256);
+#endif
+
+  /*Check**********************************************************************/
+  if      (lenWdrawn>0) {}
+  else if (lenPattr >0) {}
+  else if (lenNLRI  >0) {}
+  else                  {return -1;}
+  /*Get BGP Update Infomation**************************************************/
+  /* withdrawn */
+  if (lenWdrawn>0) {
+#if DEBUG == 1 && 0
+    printf ("wdrawn\n");
+#endif
+    bgpInfo->NLRIAFI = 1;
+    if (!BGPMessagesAddress (pWdrawn, lenWdrawn, &bgpInfo->withdrawnList, &bgpInfo->withdrawnNum)) {return -1;}
+  }
+
+  /* Path attribute */
+  if (lenPattr>0) {
+#if DEBUG == 1 && 0
+    printf ("Path attribute\n");
+#endif
+    ret = BGPUpdatePathAttribute (pPattr, lenPattr, bgpInfo);
+    if      (ret==0) {return 0;}
+    else if (ret< 0) {return -1;}
+  }
+
+  /* NLRI */
+  if (lenNLRI>0) {
+#if DEBUG == 1 && 0
+    printf ("NLRI\n");
+#endif
+    bgpInfo->NLRIAFI = 1;
+    if (!BGPMessagesAddress (pNLRI, lenNLRI, &bgpInfo->NLRIList, &bgpInfo->NLRINum)) {return -1;}
+  }
+
+  return 1;
+}
+
+
+/*******************************************************************************
+ * Path attribute process ******************************************************
+ *
+ ******************************************************************************/
+int BGPUpdatePathAttribute (u_int8_t *msg, ssize_t size, BGPUpdateInfo *bgpInfo)
+{
+  int      ret;
+  u_int8_t *pProc;
+  int      modlenPathAttr, lenAttr;
+  ssize_t  PathAttrLen, PAHlen;
+  BGPUpdatePathAttr *pPAttr;
+
+  if      (msg==NULL)                         {return -1;}
+  else if (size<sizeof (BGPUpdatePathAttr)+1) {return -1;}
+  pProc       = msg;
+  modlenPathAttr = size;
+  do {
+#if DEBUG == 1 && 0
+    printf ("modlenPathAttr: %d\n", modlenPathAttr);
+#endif
+    /* header processing */
+    PAHlen = sizeof (BGPUpdatePathAttr) + 1;
+    if (modlenPathAttr<PAHlen) {return -1;}
+    pPAttr = (BGPUpdatePathAttr *)pProc;
+    if ((pPAttr->attrFlag & 0x80)==0x80) {
+      /* optional path attribute proc */
+    }
+    if ((pPAttr->attrFlag & 0x40)==0x40) {
+      /* transitive path attribute proc */
+    }
+    if ((pPAttr->attrFlag & 0x20)==0x20) {
+      /* partial path attribute proc */
+    }
+    if ((pPAttr->attrFlag & 0x10)==0x10) {
+      PAHlen++;
+      if (modlenPathAttr<PAHlen) {return -1;}
+      lenAttr = be16toh (*(u_int16_t *)(pPAttr+1));
+    } else {
+      lenAttr = (int)*(u_int8_t *)(pPAttr+1);
+    }
+    if (modlenPathAttr < (PAHlen+lenAttr)) {return -1;}
+
+    
+#if DEBUG == 1 && 1
+    printf ("lenAttr: %d, PAHlen: %d\n", lenAttr, PAHlen);
+    HEXoutput ((u_int8_t *)pPAttr, (lenAttr + PAHlen), 256);
+#endif
+    /* data proc */
+    switch (pPAttr->attrType) {
+    case 0: /* reserved */
+      return -1;
+      break;
+#if 0
+    case 1: /* ORIGIN */
+      break;
+    case 2: /* AS_PATH */
+      break;
+    case 3: /* NEXT_HOP */
+      break;
+#endif
+    case 14: /* MP_REACH_NLRI */
+      ret = BGPUpdatePathAttributeMPreachNLRI ((pProc + PAHlen), lenAttr, bgpInfo);
+      break;
+    case 15: /* MP_UNREACH_NLRI */
+      ret = BGPUpdatePathAttributeMPUnreachNLRI ((pProc + PAHlen), lenAttr, bgpInfo);
+      break;
+    default:
+      ret = 1;
+      break;
+    }
+    if      (ret==0) {return 0;}
+    else if (ret< 0) {return -1;}
+    
+
+    /* end proc */
+    pProc += (PAHlen+lenAttr);
+    modlenPathAttr -= (PAHlen+lenAttr);
+  } while (modlenPathAttr>0);
+  if (modlenPathAttr<0) {return -1;}
+
+  return 1;
+}
+
+/*******************************************************************************
+ * Path attribute type 14: *****************************************************
+ *
+ ******************************************************************************/
+static int BGPUpdatePathAttributeMPreachNLRI (u_int8_t *msg, ssize_t size, BGPUpdateInfo *bgpInfo)
+{
+  int ret;
+  ssize_t len;
+  BGPUpdateMRNLRI *pt;
+  pt = (BGPUpdateMRNLRI *)msg;
+  bgpInfo->PANLRIAFI    = be16toh (pt->afi);
+  bgpInfo->PANLRIAFIsub = pt->safi;
+  len = (ssize_t)pt->len;
+  ret = BGPMessagesAddress ((u_int8_t *)(pt+1)+len+1, size - (sizeof (BGPUpdateMRNLRI) + len + 1), &bgpInfo->PANLRIList, &bgpInfo->PANLRINum);
+  if (ret==0 || ret <0) {
+    bgpInfo->PANLRIAFI    = 0;
+    bgpInfo->PANLRIAFIsub = 0;
+    return ret;
+  }
+
+  return 1;
+}
+
+/*******************************************************************************
+ * Path attribute type 15: *****************************************************
+ *
+ ******************************************************************************/
+static int BGPUpdatePathAttributeMPUnreachNLRI (u_int8_t *msg, ssize_t size, BGPUpdateInfo *bgpInfo)
+{
+  int ret;
+  BGPUpdateMRUnNLRI *pt;
+  pt = (BGPUpdateMRUnNLRI *)msg;
+  bgpInfo->PAwithdrawnAFI    = be16toh (pt->afi);
+  bgpInfo->PAwithdrawnAFIsub = pt->safi;
+  ret = BGPMessagesAddress ((u_int8_t *)(pt+1), size - sizeof (BGPUpdateMRUnNLRI), &bgpInfo->PAwithdrawnList, &bgpInfo->PAwithdrawnNum);
+  if (ret==0 || ret <0) {
+    bgpInfo->PAwithdrawnAFI    = 0;
+    bgpInfo->PAwithdrawnAFIsub = 0;
+    return ret;
+  }
+
+  return 1;
+}
+
+/*******************************************************************************
+ * BGP messages ****************************************************************
+ *
+ ******************************************************************************/
+void freeBGPupdateInfo (BGPUpdateInfo *bgpInfo)
+{
+  if (bgpInfo->withdrawnList  !=NULL) {free (bgpInfo->withdrawnList  );}
+  if (bgpInfo->PANLRIList     !=NULL) {free (bgpInfo->PANLRIList     );}
+  if (bgpInfo->PAwithdrawnList!=NULL) {free (bgpInfo->PAwithdrawnList);}
+  if (bgpInfo->NLRIList       !=NULL) {free (bgpInfo->NLRIList       );}
+}
+
+/*******************************************************************************
+ * get BGP target Address ******************************************************
+ *
+ ******************************************************************************/
+int BGPMessagesAddress (u_int8_t *area, ssize_t siz, struct NLRIInfo **List, int *num)
+{
+  struct NLRIInfo *pbuf, *pTmp;
+  u_int8_t *pProc;
+  ssize_t  modSiz, prefixSiz;
+
+  pbuf = *List;
+  if      (area==NULL) {return 0;}
+  else if (siz<2     ) {return 0;}
+  pProc  = area;
+  modSiz = siz;
+
+  do {
+    prefixSiz = ((int)*pProc)>>3;
+    if ((((int)*pProc) & 0x7)!=0) {prefixSiz++;}
+    if (modSiz<(prefixSiz+1)) {goto sizeError;}
+    pTmp = (struct NLRIInfo *)realloc (pbuf, ((*num)+1) * sizeof (struct NLRIInfo));
+    if (pTmp==NULL) {goto mallocError;}
+    pbuf = pTmp;
+
+    (void) memset ((pbuf+(*num)), 0, sizeof (struct NLRIInfo));
+    (void) memcpy (&(pbuf+(*num))->prefix, (pProc+1), prefixSiz);
+    (pbuf+(*num))->prefixLen = (int)*pProc;
+    (*num)++;
+    
+#if DEBUG == 1 && 0
+    printf ("prefixLen: %d, prefixSize: %d\n", (pbuf+(*num)-1)->prefixLen, prefixSiz);
+    HEXoutput ((u_int8_t *)pbuf, (*num) * sizeof (struct NLRIInfo), 256);
+#endif
+
+    pProc  += (prefixSiz + 1);
+    modSiz -= (prefixSiz + 1);
+  } while (modSiz>0);
+  if (modSiz<0) {goto sizeError;}
+  *List = pbuf;
+  return 1;
+
+ mallocError:
+ sizeError:
+  if (pbuf!=NULL) {free (pbuf);}
+  return 0;
+}

--- trunk/libbgp/Makefile.am	(revision 3)
+++ trunk/libbgp/Makefile.am	(revision 4)
@@ -1,6 +1,6 @@
 noinst_LIBRARIES  = libbgp.a
 include_HEADERS   = bgp.h
-libbgp_a_SOURCES  = bgp.h
+libbgp_a_SOURCES  = bgp.h getBGPmessages.c
 libbgp_a_SOURCES +=
 libbgp_a_SOURCES +=
 libbgp_a_SOURCES +=

--- trunk/libbgp/bgp.h	(revision 3)
+++ trunk/libbgp/bgp.h	(revision 4)
@@ -33,7 +33,11 @@
 #if !defined(_SYS_TIME_H) && !defined(_SYS_TIME_H_)
 #  include <sys/time.h>
 #endif
+#if !defined(_NETINET_IN_H) && !defined(_NETINET_IN_H_)
+#  include <netinet/in.h>
+#endif
 
+
 /*******************************************************************************
  * Define *********************************************************************/
 #define LIBBGP_MAXLENGTH        4096
@@ -78,6 +82,62 @@
 /*******************************************************************************
  * structure & typedef ********************************************************/
 /*+==========================================================================+**
+ *| BGP Info                                                                 |**
+ *+==========================================================================+*/
+/*******************************************************************************
+ * Union: address area ********************************************************/
+#ifndef UNION_ADDRAREA
+#  define UNION_ADDRAREA
+union addrarea {
+  struct in_addr  inet4;
+  struct in6_addr inet6;
+};
+#endif
+/*******************************************************************************
+ * struct: NLRI Info **********************************************************/
+#ifndef STRUCT_NLRIINFO
+#  define STRUCT_NLRIINFO
+struct NLRIInfo {
+  int            prefixLen;
+  union addrarea prefix;
+};
+#endif
+
+/*+==========================================================================+**
+ *| BGP Info                                                                 |**
+ *+==========================================================================+*/
+#ifndef STRUCT_BGP_UPDATE_INFO
+#  define STRUCT_BGP_UPDATE_INFO
+typedef struct {
+  /*****************************************************************************
+   * withdrawn Routes *********************************************************/
+  u_int16_t       withdrawnAFI; /* [IANA-AF]  "Address Family Numbers" */
+  int             withdrawnNum;
+  struct NLRIInfo *withdrawnList;
+
+  /*****************************************************************************
+   * pathAttribute ************************************************************/
+  /* type: 14, MP_REACH_NLRI */
+  u_int16_t       PANLRIAFI; /* [IANA-AF]  "Address Family Numbers" */
+  u_int8_t        PANLRIAFIsub;
+  union addrarea  PANLRINextHop;
+  int             PANLRINum;
+  struct NLRIInfo *PANLRIList;
+  /* type: 15, MP_UNREACH_NLRI */
+  u_int16_t       PAwithdrawnAFI; /* [IANA-AF]  "Address Family Numbers" */
+  u_int8_t        PAwithdrawnAFIsub;
+  int             PAwithdrawnNum;
+  struct NLRIInfo *PAwithdrawnList;
+
+  /*****************************************************************************
+   * NLRI *********************************************************************/  
+  u_int16_t       NLRIAFI; /* [IANA-AF]  "Address Family Numbers" */
+  int             NLRINum;
+  struct NLRIInfo *NLRIList;
+} BGPUpdateInfo;
+#endif
+
+/*+==========================================================================+**
  *| BGP Messages Header                                                      |**
  *+==========================================================================+*/
 /* BGP header common
@@ -134,6 +194,7 @@
  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  ******************************************************************************/
 typedef u_int16_t BGPUpdateLength; /* for withdrawn routes or total path attribute length */
+
 /* BGP update path attributes
  *  0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3 3
  *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
@@ -140,6 +201,9 @@
  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  * | Attr. flags   | Attr Type     | length(1 or 2 Byte)           |
  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * http://tools.ietf.org/html/rfc4271
+ * http://tools.ietf.org/html/rfc4760
+ * http://www.iana.org/assignments/bgp-parameters/bgp-parameters.xhtml
  ******************************************************************************/
 typedef struct {
   u_int8_t attrFlag;
@@ -163,4 +227,34 @@
 #define BGP_UPDATE_PATHATTR_TYPE_CLUSTER_LIST   10
 #endif
 
+/* Multiprotocol Reachable NLRI - MP_REACH_NLRI (Type Code 14):
+ *  0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3 3
+ *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * | Address Family Identifier     | SubsequentAFI | Length        |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * | Network Address of Next Hop (variable)                        |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * | Reserved      | NLRI (variable)                               |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * http://www.iana.org/assignments/bgp-parameters/bgp-parameters.xhtml
+ * http://tools.ietf.org/html/rfc4760
+ ******************************************************************************/
+typedef struct {
+  u_int16_t afi;
+  u_int8_t  safi;
+  u_int8_t  len;
+} __attribute__((__packed__)) BGPUpdateMRNLRI;
+typedef struct {
+  u_int16_t afi;
+  u_int8_t  safi;
+} __attribute__((__packed__)) BGPUpdateMRUnNLRI;
+
+
+/*******************************************************************************
+ * function *******************************************************************/
+/*=getBGPmessages.c===========================================================*/
+int  BGPupdateMessages (u_int8_t *, ssize_t, BGPUpdateInfo *);
+void freeBGPupdateInfo (BGPUpdateInfo *);
+
 #endif

--- trunk/bmpStation/bmpStationLib.c	(revision 3)
+++ trunk/bmpStation/bmpStationLib.c	(revision 4)
@@ -52,6 +52,9 @@
 #if !defined(_SYS_STAT_H_) && !defined(_SYS_STAT_H)
 #  include <sys/stat.h>
 #endif
+#if !defined(_UNISTD_H) && !defined(_UNISTD_H_)
+#  include <unistd.h>
+#endif
 
 
 /*%''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''%**
@@ -98,11 +101,6 @@
 
   return;
 
- free_data2:
-  umask (mode);
-  free (strLog);
-  return ;
-
  fin_va:
   va_end(ap);
  free_data:

--- trunk/bmpStation/bmpRead.c	(revision 3)
+++ trunk/bmpStation/bmpRead.c	(revision 4)
@@ -113,7 +113,6 @@
 
 /*******************************************************************************
  * functions ******************************************************************/
-static int getBMPLogInfo (BMPLogInfoSet *, u_int8_t *, ssize_t);
 
 
 /* old */
@@ -307,15 +306,7 @@
 /*%''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''%**
  *: get BMP data each version                                                :**
  *%,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,%*/
-/*******************************************************************************
- * get BMP log infomation *****************************************************/
-static int getBMPLogInfo (BMPLogInfoSet *BMPLogInfo, u_int8_t *rdata, ssize_t dlen)
-{
-  return 1;
-}
 
-
-
 /*******************************************************************************
  * BMP v1 data ****************************************************************/
 static int BMPv1Data (BMPLogInfoSet *BMPLogInfo, u_int8_t *rdata, ssize_t dlen)
@@ -653,7 +644,6 @@
 {
   int rsize;
   BMPMsgPeerDown  *BMPPeerDownHeader;
-  u_int8_t        *msgData;
   BGPCommonHeader *BGPHeader;
   char            peerAddr[MAXPATHLEN];
   rsize = sizeof (BMPMsgPeerDown);

--- trunk/bmpAnalysis/bmpAnalysis.c	(revision 3)
+++ trunk/bmpAnalysis/bmpAnalysis.c	(revision 4)
@@ -70,16 +70,18 @@
 #if !defined(_NETINET_IN_H) && !defined(_NETINET_IN_H_)
 #  include <netinet/in.h>
 #endif
+#if !defined(_ARPA_INET_H) && !defined(_ARPA_INET_H_)
+#  include <arpa/inet.h>
+#endif
+#if !defined(_SYS_TYPES_H) && !defined(_SYS_TYPES_H_)
+#  include <sys/types.h>
+#endif
 
 
 
 #if 0
-#include <sys/types.h>
-#include <arpa/inet.h>
 
-#if !defined(_SYS_TYPES_H) && !defined(_SYS_TYPES_H_)
-#  include <sys/types.h>
-#endif
+
 #if !defined(_SYS_SELECT_H) && !defined(_SYS_SELECT_H_)
 #  include <sys/select.h>
 #endif
@@ -166,7 +168,7 @@
     pmsgBondLast += rlen;
     pmsgBondRead = pmsgBondStore;
     datVal = pmsgBondLast-pmsgBondRead;
-    if (FLGISSET(lastParam.enaFlag, OPTENAFLGDEBUG) && FLGISSET(lastParam.flags, OPTFLGDEBUG)) {
+    if (FLGISSET(lastParam.enaFlag, OPTENAFLGDEBUG) && FLGISSET(lastParam.flags, OPTFLGDEBUG) && 0) {
       HEXoutput (pmsgBondStore, datVal, 256);
     }
     
@@ -244,44 +246,51 @@
   t = tv.tv_sec;
   date = localtime (&t);
   (void) memset (strBuf, 0, sizeof (strBuf));
-  strftime (strBuf, sizeof (strBuf), "%Y/%m/%d %H/%M/%S", date);
-  snprintf (str, siz, "%s.%03d", strBuf, tv.tv_usec/1000);
+  strftime (strBuf, sizeof (strBuf), "%Y/%m/%d %H:%M:%S", date);
+  snprintf (str, siz, "%s.%03ld", strBuf, tv.tv_usec/1000);
   
   return 1;
 }
 
+#if 0
 static int msgAddr (u_int8_t *data, char *str, ssize_t siz, int aft)
 {
+  union addrarea addr;
   int len, nb;
-  struct in6_addr sin6_addr;
   char addrTmp[64];
   len = (int)*data;
   nb = (len >>3);
   if ((len&0x7)!=0) {nb++;}
-  (void)memset ((char *)&sin6_addr, 0, sizeof (sin6_addr));
+  (void)memset ((char *)&addr, 0, sizeof (addr));
   (void)memset (addrTmp, 0, sizeof (addrTmp));
-  memcpy (&sin6_addr, (data+1), nb);
+  memcpy (&addr, (data+1), nb);
 
-  inet_ntop (aft, &sin6_addr, addrTmp, sizeof (addrTmp));
+  inet_ntop (aft, &addr, addrTmp, sizeof (addrTmp));
   snprintf (str, siz, "%s/%d", addrTmp, len);
 
   return nb+1;
 }
+#endif
 
 /*******************************************************************************
  * BMP Update Messages ********************************************************/
 static int bgpUpdateMessage (BMPLogInfoSet *pbmp, BGPCommonHeader *pbgp)
 {
-  BGPUpdateLength *plenWdrawn, *plenPattr, lenWdrawn, lenPattr;
+  int i;
+  BGPUpdateInfo   bgpInfo; 
   struct timeval rtrTime, rcvTime;
   char rtrStrTime[30], rcvStrTime[30];
-  int rtn;
-  u_int8_t *pproc;
-
   struct in_addr  *sin_addr;
   struct in6_addr *sin6_addr;
   char peerAddr[64];
   char updateAddr[64];
+#if 0
+  BGPUpdatePathAttr *pPAttr;
+  BGPUpdateLength *plenWdrawn, *plenPattr, lenWdrawn, lenPattr;
+  int palen;
+  int rtn, BGPLen;
+  u_int8_t *pproc;
+#endif
 
   (void)memset (rtrStrTime, 0, sizeof (rtrStrTime));
   (void)memset (rcvStrTime, 0, sizeof (rcvStrTime));
@@ -301,22 +310,111 @@
     inet_ntop (AF_INET, sin_addr, peerAddr, sizeof (peerAddr));
   }
 
-  
-  plenWdrawn = (BGPUpdateLength *)(pbgp+1);
-  lenWdrawn  = be16toh (*plenWdrawn);
-  plenPattr  = (void *)(plenWdrawn+1) + lenWdrawn;
-  lenPattr   = be16toh (*plenPattr);
-  if (FLGISSET(lastParam.enaFlag, OPTENAFLGDEBUG) && FLGISSET(lastParam.flags, OPTFLGDEBUG)) {
-    printf ("Withdrawn      length: %hu\n", lenWdrawn);
-    HEXoutput ((u_int8_t *)plenWdrawn, lenWdrawn+2, 256);
-    printf ("path attribute length: %hu\n", lenPattr);
-    HEXoutput ((u_int8_t *)plenPattr, lenPattr+2, 256);
+  (void) memset (&bgpInfo, 0, sizeof (BGPUpdateInfo));
+  BGPupdateMessages ((u_int8_t *)pbgp, be16toh (pbgp->length), &bgpInfo);
+
+  /* withdrawn */
+  for (i=0; i<bgpInfo.withdrawnNum; i++) {
+    (void) memset (updateAddr, 0, sizeof (updateAddr));
+    if (bgpInfo.withdrawnAFI==1) {
+      inet_ntop (AF_INET , &(bgpInfo.withdrawnList+i)->prefix, updateAddr, sizeof (updateAddr));
+    } else if (bgpInfo.withdrawnAFI==2) {
+      inet_ntop (AF_INET6, &(bgpInfo.withdrawnList+i)->prefix, updateAddr, sizeof (updateAddr));
+    }
+    if (bgpInfo.withdrawnAFI==1 || bgpInfo.withdrawnAFI==2) {
+      printf ("%s : %s peer: %s(%u), withdrawn %s/%d\n", rcvStrTime, rtrStrTime, peerAddr, be32toh (pbmp->peerAS), updateAddr, (bgpInfo.withdrawnList+i)->prefixLen);
+    }
   }
+  /* mp NLRI */
+  for (i=0; i<bgpInfo.PANLRINum; i++) {
+    (void) memset (updateAddr, 0, sizeof (updateAddr));
+    if (bgpInfo.PANLRIAFI==1) {
+      inet_ntop (AF_INET , &(bgpInfo.PANLRIList+i)->prefix, updateAddr, sizeof (updateAddr));
+    } else if (bgpInfo.PANLRIAFI==2) {
+      inet_ntop (AF_INET6, &(bgpInfo.PANLRIList+i)->prefix, updateAddr, sizeof (updateAddr));
+    }
+    if (bgpInfo.PANLRIAFI==1 || bgpInfo.PANLRIAFI==2) {
+      printf ("%s : %s peer: %s(%u), update %s/%d\n", rcvStrTime, rtrStrTime, peerAddr, be32toh (pbmp->peerAS), updateAddr, (bgpInfo.PANLRIList+i)->prefixLen);
+    }
+  }
+  /* MP withdrawn */
+  for (i=0; i<bgpInfo.PAwithdrawnNum; i++) {
+    (void) memset (updateAddr, 0, sizeof (updateAddr));
+    if (bgpInfo.PAwithdrawnAFI==1) {
+      inet_ntop (AF_INET , &(bgpInfo.PAwithdrawnList+i)->prefix, updateAddr, sizeof (updateAddr));
+    } else if (bgpInfo.PAwithdrawnAFI==2) {
+      inet_ntop (AF_INET6, &(bgpInfo.PAwithdrawnList+i)->prefix, updateAddr, sizeof (updateAddr));
+    }
+    if (bgpInfo.PAwithdrawnAFI==1 || bgpInfo.PAwithdrawnAFI==2) {
+      printf ("%s : %s peer: %s(%u), withdrawn %s/%d\n", rcvStrTime, rtrStrTime, peerAddr, be32toh (pbmp->peerAS), updateAddr, (bgpInfo.PAwithdrawnList+i)->prefixLen);
+    }
+  }
+  /* NLRI */
+  for (i=0; i<bgpInfo.NLRINum; i++) {
+    (void) memset (updateAddr, 0, sizeof (updateAddr));
+    if (bgpInfo.NLRIAFI==1) {
+      inet_ntop (AF_INET , &(bgpInfo.NLRIList+i)->prefix, updateAddr, sizeof (updateAddr));
+    } else if (bgpInfo.NLRIAFI==2) {
+      inet_ntop (AF_INET6, &(bgpInfo.NLRIList+i)->prefix, updateAddr, sizeof (updateAddr));
+    }
+    if (bgpInfo.NLRIAFI==1 || bgpInfo.NLRIAFI==2) {
+      printf ("%s : %s peer: %s(%u), update %s/%d\n", rcvStrTime, rtrStrTime, peerAddr, be32toh (pbmp->peerAS), updateAddr, (bgpInfo.NLRIList+i)->prefixLen);
+    }
+  }
 
+  
+
+  freeBGPupdateInfo (&bgpInfo);
+#if 0
 #if 1
-  if (lenWdrawn>0) {
-    pproc = (u_int8_t *)(plenWdrawn+1);
+  if (lenPattr>0) {
+    u_int8_t *pt;
+    int len;
+    pproc = (u_int8_t *)(plenPattr+1);
+    pPAttr = (BGPUpdatePathAttr *)pproc;
     do {
+      int PAHlen;
+      PAHlen = sizeof (BGPUpdatePathAttr);
+      if ((pPAttr->attrFlag & 0x80)==0x80) {
+	/* optional path attribute proc */
+      }
+      if ((pPAttr->attrFlag & 0x40)==0x40) {
+	/* transitive path attribute proc */
+      }
+      if ((pPAttr->attrFlag & 0x20)==0x20) {
+	/* partial path attribute proc */
+      }
+      if ((pPAttr->attrFlag & 0x10)==0x10) {
+	PAHlen += 2;
+	palen = be16toh (*(u_int16_t *)(pPAttr+1));
+      } else {
+	PAHlen++;
+	palen = (int)*(u_int8_t *)(pPAttr+1);
+      }
+      printf ("palen: %d, PAHlen: %d\n", palen, PAHlen);
+      HEXoutput ((u_int8_t *)pproc, (palen + PAHlen), 256);
+
+      switch (pPAttr->attrType) {
+      case 14: /* Multiprotocol Reachable NLRI */
+	pt = (u_int8_t *)(pPAttr+1);
+	len = 5 + *(pt+3);
+	break;
+      }
+
+      lenPattr -= palen + PAHlen;
+      pproc += palen + PAHlen;
+      pPAttr = (BGPUpdatePathAttr *)pproc;
+      printf ("lenPAttr: %d\n", lenPattr);
+    } while (lenPattr>0);
+    if (lenPattr<0) {return -1;}
+  }
+  if (BGPLen>0) {
+    if (FLGISSET(lastParam.enaFlag, OPTENAFLGDEBUG) && FLGISSET(lastParam.flags, OPTFLGDEBUG)) {
+      printf ("BGP Len: %d\n", BGPLen);
+      HEXoutput ((u_int8_t *)pproc, BGPLen, 256);
+    }
+
+    do {
       (void) memset (updateAddr, 0, sizeof (updateAddr));
       
       if (FLGISSET(pbmp->peerFlags, BMP_PEERFLG_VFLG_IPv6)) {
@@ -324,19 +422,15 @@
       } else {
 	rtn = msgAddr (pproc, updateAddr, sizeof (updateAddr), AF_INET);
       }
-      lenWdrawn -= rtn;
+      BGPLen -= rtn;
       pproc += rtn;
-      printf ("%s : %s peer: %s(%u), withdrawn %s  mod %d\n", rcvStrTime, rtrStrTime, peerAddr, be32toh (pbmp->peerAS), updateAddr, lenWdrawn);
-    } while (lenWdrawn>0);
-    if (lenWdrawn<0) {return -1;}
-  } 
-  else if (plenPattr>0) {
-    printf ("%s : %s peer: %s(%u), update \n", rcvStrTime, rtrStrTime, peerAddr, be32toh (pbmp->peerAS));
+      printf ("%s : %s peer: %s(%u), update %s  mod %d\n", rcvStrTime, rtrStrTime, peerAddr, be32toh (pbmp->peerAS), updateAddr, BGPLen);
+    } while (BGPLen>0);
+    if (BGPLen<0) {return -1;}
   }
-  else {
-    printf ("%s : %s peer: %s(%u), can't understand\n", rcvStrTime, rtrStrTime, peerAddr, be32toh (pbmp->peerAS));
-  }
+  
 #endif
+#endif
   
   return 1;
 }
@@ -350,7 +444,7 @@
   BGPCommonHeader *pbgpHeader;    /* pbgpHeader is BGP update message Point */
   pbmpLogHeader = (BMPLogInfoSet *)bData;
   pbgpHeader    = (BGPCommonHeader *)(pbmpLogHeader+1);
-  if (FLGISSET(lastParam.enaFlag, OPTENAFLGDEBUG) && FLGISSET(lastParam.flags, OPTFLGDEBUG)) {
+  if (FLGISSET(lastParam.enaFlag, OPTENAFLGDEBUG) && FLGISSET(lastParam.flags, OPTFLGDEBUG) && 0) {
     HEXoutput ((u_int8_t *)pbmpLogHeader, be32toh (pbmpLogHeader->msgLen), 256);
   }
 

--- trunk/include/selfLib.h	(revision 3)
+++ trunk/include/selfLib.h	(revision 4)
@@ -56,11 +56,6 @@
 
 /*******************************************************************************
  * Structure & union **********************************************************/
-/*=address area===============================================================*/
-union addrarea {
-  struct in_addr in4;
-  struct in6_addr in6;
-};
 
 /*******************************************************************************
  * Functions ******************************************************************/