#!/usr/bin/perl

open(FILEIN,"<$ARGV[0]");
open(FILEOUT,">>$ARGV[1]");

#$num=0;
print "$ARGV[0] $ARGV[1]\n";
binmode(FILEIN);
while(!eof(FILEIN))
{
	$pos=tell(FILEIN);
	#print "pos $pos\n";
	print "##############################\n";
	read(FILEIN,$ltm,4);
	$ltm=convtime($ltm);
	print "ltm $ltm\n";
	read(FILEIN,$type,2);
	$tp=convtype($type);
	print "type $tp\n";
	read(FILEIN,$subtype,2);
	$subtp=convtype($subtype);
	print "subtype $subtp\n";
	read(FILEIN,$temp,4);
	if($tp == 16 && $subtp == 0)
	{
		read(FILEIN,$sas,2);
		$sas=convtype($sas);
		print "source AS:$sas\n";
		read(FILEIN,$das,2);
		$da=convtype($das);
		print "destination as:$das\n";
		read(FILEIN,$interface,2);
		$interface=convtype($interface);
		print "interface index:$interface\n";
		read(FILEIN,$af,2);
		$af=convtype($af);
		print "address family:$af\n";
		exit;
		if($af == 1)
		{
			read(FILEIN,$sip,4);
			$sip=convaddr($sip);
			print "source ip:$sip\n";
			read(FILEIN,$dip,4);
			$dip=convaddr($dip);
			print "destination ip:$dip\n";
			read(FILEIN,$ostate,2);
			$ostate=convtype($ostate);
			print "old state:$ostate\n";
			read(FILEIN,$nstate,2);
			$nstate=convtype($nstate);
			print "new state:$nstate\n";
		}
		else
		{
			read(FILEIN,$sip,16);
			$sip=convaddr6($sip);
			print "source ip:$sip\n";
			read(FILEIN,$dip,16);
			$dip=convaddr6($dip);
			print "destination ip:$dip\n";
			read(FILEIN,$ostate,2);
			$ostate=convtype($ostate);
			print "old state:$ostate\n";
			read(FILEIN,$nstate,2);
			$nstate=convtype($nstate);
			print "new state:$nstate.\n";
		}
	}
	if($tp == 16 && $subtp == 1)
	{
		read(FILEIN,$sas,2);
		$sas=convtype($sas);
		print "source as :$sas\n";
		read(FILEIN,$das,2);
		$das=convtype($das);
		print "destination as:$das\n";
		read(FILEIN,$interface,2);
		$interface=convtype($interface);
		print "interface :$interface\n";
		read(FILEIN,$af,2);
		$af=convtype($af);
		print "addrress family: $af\n";
		if($af == 1)
		{
			read(FILEIN,$sip,4);
			$sip=convaddr($sip);
			print "source ip:$sip\n";
			read(FILEIN,$dip,4);
			$dip=convaddr($dip);
			print "destination ip:$dip\n";
			#process BGP packet.
			bgpmessage();
		}
		else
		{
			read(FILEIN,$sip,16);
			$sip=convaddr6($sip);
			print "source ip:$sip\n";
			read(FILEIN,$dip,16);
			$dip=convaddr6($dip);
			print "destination ip:$dip\n";
			#process BGP packet.
			bgpmessage6();
		}
	}

	if($tp == 16 && $subtp == 2)
	{
		read(FILEIN,$view,2);
		$view=convtype($view);
		print "view $view\n";
		read(FILEIN,$status,2);
		$status=convtype($status);
		print "status $status\n";
		read(FILEIN,$timelc,4);
		$timelc=convtime($timelc);
		print "time last change $timelc\n";
		read(FILEIN,$af,2);
		$af=convtype($af);
		print "Address Family $af\n";
		exit;
		if($af==1)
		{
			read(FILEIN,$safi,1);
			$safi=convbyte($safi);
			print "safi $safi\n";
			read(FILEIN,$nhl,1);
			$nhl=convbyte($nhl);
			print "next hop len $nhl\n";
			read(FILEIN,$nhaddr,4);
			$nhaddr=convaddr($nhaddr);
			print "next hop addr $nhaddr\n";
			read(FILEIN,$pfl,1);
			$pfl=convbyte($pfl);
			print "Prefix len: $pfl\n";
			read(FILEIN,$pfaddr,$pfl);
			$pfaddr=convprefix($pfaddr,$pfl);
			print "prefix addr:$pfaddr\n";
			read(FILEIN,$attrl,2);
			$attrl=convtype($attrl);
			print "Attribute length: $attrl\n";
			read(FILEIN,$bgpattr,$attrl);
			#BGP attrbiute process.
			#print "BGP attribute:$bgpattr\n";
					
		}
		else
		{
			read(FILEIN,$safi,1);
			$safi=convbyte($safi);
			print "safi:$safi\n";
			read(FILEIN,$nhl,1);
			$nhl=convbyte($nhl);
			print "nhl: $nhl\n";
			read(FILEIN,$nhaddr,16);
			$nhaddr=convaddr6($nhaddr);
			print "next hop addr:$nhaddr\n";
			read(FILEIN,$prl,1);
			$prl=convbyte($prl);
			print "Prefix length:$prf\n";
			read(FILEIN,$prfaddr,$prl);
			$prfaddr=convpref6($prfaddr,$prl);
			read(FILEIN,$attrl,2);
			$attrl=convtype($attrl);
			print "Attribute length:$attrl\n";
			read(FILEIN,$bgpattr,$attrl);
			#BGP attribute process.
			#oute BGP attribute.
		
		}		
	}
	#$num ++;
	#if($num>1)
	#{
	#	exit;
	#}	
}
close(FILEIN);
close(FILEOUT);
print "The end of file.\n";

sub convtype($)
{
	my ($tp)=@_;
	my  $subtype1,$subtype2,$tp1;
	$subtype1=unpack("c",substr($tp,0,1));
	if($subtype1<0) 
	{
		$subtype1 +=256;
	}
	$subtype2=unpack("c",substr($tp,1,1));
	if($subtype2<0)
	{
		$subtype2 +=256;
	}
	$tp1=$subtype1*256+$subtype2;
	return $tp1;
}

sub convbyte($)
{
	my ($byte)=@_;
	my $byte1;
	$byte1=unpack("c",$byte);
	if($byte1<0)
	{
		$byte1 +=256;
	}
	return $byte1;
}
sub convtime($)

{
	my ($ltm)=@_;
	my $tm1,$tm2,$tm3,$tm4,$lttm,$timelist;
	$tm1=unpack("c",substr($ltm,0,1));
	$tm2=unpack("c",substr($ltm,1,1));
	$tm3=unpack("c",substr($ltm,2,1));
	$tm4=unpack("c",substr($ltm,3,1));
	if($tm1<0)
	{
		$tm1 +=256;
	}
	if($tm2<0)
	{
		$tm2 +=256;
	}
	if($tm3<0)
	{
		$tm3 +=256;
	}
	if($tm4<0)
	{
		$tm4 +=256;
	}
	
	#print "$tm1 $tm2 $tm3 $tm4\n";
	$lttm=$tm1*256*256*256+$tm2*256*256+$tm3*256+$tm4;
	$timelist=localtime($lttm);
	return $timelist;
}
sub convaddr($)
{
	my ($addr)=@_;
	my $adr1,$adr2,$adr3,$adr4,$ipaddr;
	$adr1=unpack("c",substr($addr,0,1));
	$adr2=unpack("c",substr($addr,1,1));
	$adr3=unpack("c",substr($addr,2,1));
	$adr4=unpack("c",substr($addr,3,1));
	if($adr1<0)
	{
		$adr1 +=256;
	}
	if($adr2<0)
	{
		$adr2 +=256;
	}
	if($adr3 <0)
	{
		$adr3 +=256;
	}
	if($adr4 <0)
	{
		$adr4 +=256;
	}
	$ipaddr=sprintf("%d.%d.%d.%d",$adr1,$adr2,$adr3,$adr4);
	return $ipaddr;
}

sub convaddr6($)
{
	my ($addr)=@_;
	my $tm,$tm1,$tm2,$tm3,$tm4,$tm5,$tm6,$tm7,$tm8,$adr6;
	$tm=substr($addr,0,2);
	$tm1=convtype($tm);
	$tm=substr($addr,2,2);
	$tm2=convtype($tm);
	$tm=substr($addr,4,2);
	$tm3=convtype($tm);
	$tm=substr($addr,6,2);
	$tm4=convtype($tm);
	$tm=substr($addr,8,2);
	$tm5=convtype($tm);
	$tm=substr($addr,10,2);
	$tm6=convtype($tm);
	$tm=substr($addr,12,2);
	$tm7=convtype($tm);
	$tm=substr($addr,14,2);
	$tm8=convtype($tm);
	$addr6=sprintf("%x:%x:%x:%x:%x:%x:%x:%x",$tm1,$tm2,$tm3,$tm4,$tm5,$tm6,$tm7,$tm8);
	return $addr6;


}
sub convprefix($$)
{
	
	my($prfl,$prfaddr)=@_;
	my $addr,$adr,$i;
	$i =0;
	$addr="";
	while($prfl>0)
	{
		$adr=unpack("c",substr($prfaddr,$i,1));	
		if($adr<0)
		{
			$adr +=256;
		}
		if($i == 0)
		{
			$addr=sprintf("%d",$adr);
		}
		else
		{
			$addr=sprintf("%s.%d",$addr,$adr);
		}
		$i ++;
		$prfl --;
	}
	$addr=sprintf("%s/%d",$addr,$prfl);
	return $addr;
}

sub convprf6($$)
{
	my($addr,$prl)=@_;
	my $i;
	$i=0;
	#while($prl>0)
	#{
	#	$tm=substr($addr,$i,2);
	#
	return "to be program.\n";
}

sub bgpmessage6()
{
	my $marker,$bgplen,$bgptype,$bgpmsglen,$msgcont;
	read(FILEIN,$marker,16);
	read(FILEIN,$bgplen,2);
	$bgplen=convtype($bgplen);
	print "BGP message length:$bgplen\n";
	read(FILEIN,$bgptype,1);
	$bgptype=convbyte($bgptype);
	print "BGP message type:$bgptype\n";
	$bgpmsglen=$bgplen-19;
	read(FILEIN,$msgcont,$bgpmsglen);
	if($bgptype == 1)
	{
		bgpopenproc6($msgcont);
		exit;
	}
	if($bgptype == 2)
	{
		bgpupdateproc6($msgcont,$bgplen);
	}
	if($bgptype == 3)
	{
		bgpnotifproc6($msgcont);
	}
	if($bgptype == 4)
	{
		bgpkeepproc6($msgcont);
	}

	return;
}
sub bgpopenproc6($)
{
	print "Process open message.\n";
	return;

}
sub bgpupdateproc6($$)
{
	print "Process update message.\n";
	my ($content,$bgplen)=@_;
	my $unfeasiblelen,$withdrawn,$attrlen,$attr,$nlrilen,$nlri;
	$unfeasiblelen=substr($content,0,2);
	$unfeasiblelen=convtype($unfeasiblelen);
	print "Total unfeasible length:$unfeasiblelen\n";
	if($unfeasiblelen != 0)
	{
		$withdrawn=substr($content,2,$unfeasiblelen);
		withdrawnproc6($withdrawn);
	}
	$attrlen=substr($content,2+$unfeasiblelen,2);
	$attrlen=convtype($attrlen);
	print "Total path length:$attrlen\n";
	if($attrlen !=0)
	{
		$attr=substr($content,4+$unfeasiblelen,$attrlen);
		attrproc6($attr,$attrlen);
	}
	$nlrilen=$bgplen-23-$unfeasiblelen-$attrlen;
	print "Total nlri length:$nlrilen\n";
	if($nlrilen !=0)
	{
		$nlri=substr($content,4+$unfeasiblelen+$attrlen,$nlrilen);
		nlriproc6($nlri);
	}
	
	return;
}
sub bgpnotifproc6($)
{
	print "Process notification message.\n";
	return;
}
sub bgpkeepproc6($)
{
	print "Process keepalive message.\n";
	return;
}	
sub withdrawnproc6($)
{
	print "Process withdrawn domain.\n";
	my ($withdrawn) = @_;
	my $i,$len,$prflen,$prflenb,$onewithdraw;
	$len=length($withdrawn);
	$i=0;
	
	while($i<$len)
	{
		$prflen=substr($withdrawn,$i,1);
		$prflen=convbyte($prflen);
		if($prflen/8 == int($prflen/8))
		{
			$prflenb = $prflen/8;
		}
		else
		{
			$prflenb=int($prflen/8)+1;
		}
		$onewithdraw=substr($withdrawn,$i+1,$prflenb);
		$onewithdraw=convwithdrawn6($onewithdraw,$prflen);
		print "withdraw prefix:$onewithdraw\n";
		$i=$prflenb+1+$i;
	}
	return;
}


sub convwithdrawn6($$)
{
	my ($one,$len)=@_;
	my $lenc,$tail,$str0,$one,$prf;
	$lenc=16-$len;
	$tail="";
	while($lenc>0)
	{
		$str0=pack("c",0);
		$tail=$tail.$str0;
		$lenc --;
	}
	$one=$one.$tail;
	$prf=convaddr6($one);
	$prf=sprintf("%s/%d",$prf,$len);
	print "unfeasible prefix:$prf\n";
	return $prf;
}


sub attrproc6($$)
{
	my($attr,$attrlen)=@_;
	my $i,$attrflag,$attrtypecode,$attrflag,$attrl,$attrv;
	$i=0;
	while($i<$attrlen)
	{
		$attrflag=substr($attr,$i,1);
		$attrflag=convbyte($attrflag);
		print "Attribute flag:$attrflag\n";
		$attrtypecode=substr($attr,$i+1,1);
		$attrtypecode=convbyte($attrtypecode);
		print "Attribute type code:$attrtypecode\n";
		$attrflag=$attrflag & 0x10;
		if ($attrflag != 0)
		{
			$attrl=substr($attr,$i+2,2);
			$attrl=convtype($attrl);
			$i +=4;
		}
		else
		{
			$attrl=substr($attr,$i+2,1);
			$attrl=convbyte($attrl);
			$i +=3;
		}
		print "Attribute length:$attrl\n";
		$attrv=substr($attr,$i,$attrl);
		attrvalueproc6($attrv,$attrtypecode);
		$i +=$attrl;
	}
	return ;
}

sub attrvalueproc6($$)
{
	print "Attribute value process.\n";
	my ($attrv,$attrtypecode)=@_;
	my $i,$segtype,$seglen,$as;
	if($attrtypecode == 1)
	{
		$attrv=convbyte($attrv);
		print "attribute:orrigin:$attrv\n";
	
	}
	if($attrtypecode == 2)
	{	
		$segtype=substr($attrv,0,1);
		$segtype=convbyte($segtype);
		print "attribute:segment type:$segtype\n";
		$seglen=substr($attrv,1,1);
		$seglen=convbyte($seglen);
		print "attribute :segment length:$seglen\n";
		print "AS path:";
		for($i=0;$i<$seglen;$i++)
		{
			$as=substr($attrv,2+$i*2,2);
			$as=convtype($as);
			print "$as ";
		}
		print "\n";
	}
	if($attrtypecode == 3)
	{
		$nexthopip=convaddr($attrv);
		print "Next hop ip:$nexthopip.\n"
	}
	if($attrtypecode > 3)
	{ 	
		print "Can not identify type code.\n";
	}
	
	return ;
}			

sub nlriproc6($)
{
	print "Process network layer reachability information.\n";
	my ($nlri) = @_;
	my $len,$i,$prflen,$prflenb,$onenlri;
	$len=length($nlri);
	$i=0;
	
	while($i<$len)
	{
		$prflen=substr($nlri,$i,1);
		$prflen=convbyte($prflen);
		if($prflen/8 == int($prflen/8))
		{
			$prflenb=$prflen/8;
		}
		else
		{
			$prflenb=int($prflen/8)+1;
		}
		$onenlri=substr($nlri,$i+1,$prflenb);
		$onenlri=convnlri6($onenlri,$prflen);
		print "nlri prefix:$onenlri\n";
		$i=$prflenb+1+$i;
	}
	return;
}


sub convnlri6($$)
{
	my ($one,$len)=@_;
	my $lenc,$tail,$str0,$one,$prf,$lenb;
	if($len/8 == int($len/8))
	{
		$lenb=$len/8;
	}
	else
	{
		$lenb=int($len/8)+1;
	}
	$lenc=16-$lenb;
	$tail="";
	while($lenc>0)
	{
		$str0=pack("c",0);
		$tail=$tail.$str0;
		$lenc --;
	}
	$one=$one.$tail;
	$prf=convaddr6($one);
	$prf=sprintf("%s/%d",$prf,$len);
	print "nlri prefix:$prf\n";
	return $prf;
}






#BGP message process for IPv4.
sub bgpmessage()
{
	my $marker,$bgplen,$$bgptype,$bgpmsglen,$msgcont;
	read(FILEIN,$marker,16);
	read(FILEIN,$bgplen,2);
	$bgplen=convtype($bgplen);
	print "BGP message length:$bgplen\n";
	read(FILEIN,$bgptype,1);
	$bgptype=convbyte($bgptype);
	print "BGP message type:$bgptype\n";
	$bgpmsglen=$bgplen-19;
	read(FILEIN,$msgcont,$bgpmsglen);
	if($bgptype == 1)
	{
		bgpopenproc($msgcont);
		exit;
	}
	if($bgptype == 2)
	{
		bgpupdateproc($msgcont,$bgplen);
	}
	if($bgptype == 3)
	{
		bgpnotifproc($msgcont);
	}
	if($bgptype == 4)
	{
		bgpkeepproc($msgcont);
	}

	return;
}
sub bgpopenproc($)
{
	print "Process open message.\n";
	return;

}
sub bgpupdateproc($$)
{
	print "Process update message.\n";
	my ($content,$bgplen)=@_;
	my $unfeasiblelen,$withdrawn,$attrlen,$attr,$nlrilen,$nlri;
	$unfeasiblelen=substr($content,0,2);
	print "Total unfeasible length:$unfeasiblelen\n";
	$unfeasiblelen=convtype($unfeasiblelen);
	if($unfeasiblelen != 0)
	{
		$withdrawn=substr($content,2,$unfeasiblelen);
		withdrawnproc($withdrawn);
	}
	$attrlen=substr($content,2+$unfeasiblelen,2);
	$attrlen=convtype($attrlen);
	print "Total path attribute length:$attrlen\n";
	if($attrlen !=0)
	{
		$attr=substr($content,4+$unfeasiblelen,$attrlen);
		attrproc($attr,$attrlen);
	}
	$nlrilen=$bgplen-23-$unfeasiblelen-$attrlen;
	if($nlrilen !=0)
	{
		$nlri=substr($content,4+$unfeasiblelen+$attrlen,$nlrilen);
		nlriproc($nlri);
	}
	
	return;
}
sub bgpnotifproc($)
{
	print "Process notification message.\n";
	return;
}
sub bgpkeepproc($)
{
	print "Process keepalive message.\n";
	return;
}	
sub withdrawnproc($)
{
	print "Process withdrawn domain.\n";
	my ($withdrawn) = @_;
	my $len,$i,$prflen,$prflenb,$onewithdraw;
	$len=length($withdrawn);
	$i=0;
	
	while($i<$len)
	{
		$prflen=substr($withdrawn,$i,1);
		$prflen=convbyte($prflen);
		if($prflen/8 == int($prflen/8))
		{
			$prflenb=$prflen/8;
		}
		else
		{
			$prflenb=int($prflen/8)+1;
		}
		$onewithdraw=substr($withdrawn,$i+1,$prflenb);
		$onewithdraw=convwithdrawn($onewithdraw,$prflen);
		print "withdraw prefix:$onewithdraw\n";
		$i=$prflenb+1+$i;
	}
	return;
}


sub convwithdrawn($$)
{
	my ($one,$len)=@_;
	my $lenc,$tail,$str0,$one,$prf,$lenb;
	if($len/8 == int($len/8))
	{
		$lenb=int($len/8);
	}
	else
	{

		$lenb=int($len/8)+1;
	}
	$lenc=4-$lenb;
	print "$len $lenc $lenb\n";
	$tail="";
	while($lenc>0)
	{
		$str0=pack("c",0);
		$tail=$tail.$str0;
		$lenc --;
	}
	$one=$one.$tail;
	$prf=convaddr($one);
	$prf=sprintf("%s/%d",$prf,$len);
	print "unfeasible prefix:$prf\n";
	return $prf;
}


sub attrproc($$)
{
	my($attr,$attrlen)=@_;
	my $i,$attrflag,$attrtypecode,$attrl,$attrv;
	$i=0;
	while($i<$attrlen)
	{
		$attrflag=substr($attr,$i,1);
		$attrflag=convbyte($attrflag);
		print "Attribute flag:$attrflag\n";
		$attrtypecode=substr($attr,$i+1,1);
		$attrtypecode=convbyte($attrtypecode);
		print "Attribute type code:$attrtypecode\n";
		$attrflag=$attrflag & 16;
		if ($attrflag>0)
		{
			$attrl=substr($attr,$i+2,2);
			$attrl=convtype($attrl);
			$i=$i+4;
		}
		else
		{
			$attrl=substr($attr,$i+2,1);
			$attrl=convbyte($attrl);
			$i=$i+3;
		}
		print "Attribute length:$attrl\n";
		$attrv=substr($attr,$i,$attrl);
		attrvalueproc($attrv,$attrtypecode);
		$i=$i+$attrl;
	}
	return ;
}


sub nlriproc($)
{
	print "Process network layer reachability information.\n";
	my ($nlri) = @_;
	my $len,$i,$prflen,$prflenb,$onenlri;
	$len=length($nlri);
	$i=0;
	
	while($i<$len)
	{
		$prflen=substr($nlri,$i,1);
		$prflen=convbyte($prflen);
		if($prflen/8 == int($prflen/8))
		{
			$prflenb =$prflen/8;
		}
		else
		{
			$prflenb=int($prflen/8)+1;
		}
		$onenlri=substr($nlri,$i+1,$prflenb);
		$onenlri=convnlri($onenlri,$prflen);
		print "nlri prefix:$onenlri\n";
		$i=$prflenb+1+$i;
	}
	return;
}


sub convnlri($$)
{
	my ($one,$len)=@_;
	my $lenc,$tail,$str0,$one,$prf,$lenb;
	if($len/8 == int($len/8))
	{
		$lenb=$len/8;
	}
	else
	{
		$lenb=int($lenb/8)+1;
	}
	$lenc=4-$lenb;
	$tail="";
	while($lenc>0)
	{
		$str0=pack("c",0);
		$tail=$tail.$str0;
		$lenc --;
	}
	$one=$one.$tail;
	$prf=convaddr($one);
	$prf=sprintf("%s/%d",$prf,$len);
	#print "nlri prefix:$prf\n";
	return $prf;
}

sub attrvalueproc($$)
{
	print "Attribute value process.\n";
	my ($attrv,$attrtypecode)=@_;
	my $i,$segtype,$seglen,$as;
	if($attrtypecode == 1)
	{
		$attrv=convbyte($attrv);
		print "attribute:orrigin:$attrv\n";
	
	}
	if($attrtypecode == 2)
	{	
		$segtype=substr($attrv,0,1);
		$segtype=convbyte($segtype);
		print "attribute:segment type:$segtype\n";
		$seglen=substr($attrv,1,1);
		$seglen=convbyte($seglen);
		print "attribute :segment length:$seglen\n";
		print "AS path:";
		for($i=0;$i<$seglen;$i++)
		{
			$as=substr($attrv,2+$i*2,2);
			$as=convtype($as);
			print "$as ";
		}
		print "\n";
	}
	if($attrtypecode == 3)
	{
		$nexthopip=convaddr($attrv);
		print "Next hop ip:$nexthopip.\n"
	}
	if($attrtypecode > 3)
	{ 	
		print "Can not identify type code.\n";
	}

	
	return ;
}