General Information for Layout for Tests for IDRP in GateD


Physical Layouts


From 2 machines to 8 machines on the same subnet.  The PC version has 6 possible.
The Sun system has up to 8 machines.  

RD_PATH (ADVFT_RDPATH) Two-machine-tests


The 2-machine RD_PATH test include:

  • internal peers
    1. two internal peers
      1. two internal peers - null rdpath
      2. two internal peers - filters on RD_PATH allow any rdi
      3. two internal peers - filters on the RD_PATH for another routing domain
      4. two internal peers - filters on RD_PATH on another rdi
    2. Three internal
      1. three internal peers - null rdpath
      2. three internal peers - filters on RD_PATH allow any rdi
      3. three internal peers - filters on the RD_PATH for another routing domain
      4. three internal peers - filters on RD_PATH on another rdi
    3. four internal peers
    4. five internal peers
  • external peers
    1. two external peers
      1. two external peers - null rd path
      2. two external peers - any rd path
      3. two external peers - each other both RD_PATH
      4. two external peers - { | }
      5. two external peers - [ rdi1 rdi 2 ]

        for policy

        • none
        • all
        • some
        • none
    2. two external peers - 1st RD allowing the RD_PATH in, 2nd RD deny
    3. two external peers - 1 RD allowing RD_PATH switching to deny it
    4. two external peers - 1st RD allow to Deny, 2nd RD Deny to Allow

    Two internal peers with filter on the RDPATH for other domain

    
    
    	import proto idrp rdpath / rdi1 /
    		{
    		filter
    		}
    
    	where rdi1 - is the rd of the other machine
    
    	filter for test a:
    		ip all restrict;
    		osi all restrict;
    
    	filter for test b:
    		ip all;
    		osi all;
    		
    
    	filter for test c;
    		254.1; (route set 1)
    		ip all restrict;
    		osi all restrict;
    
    	filter for test d;
    		254.1 restrict;
    		ip all;
    		osi all;
     		
    
    

    two internal peers - filters on RD_PATH allow any rdi

    
    	import proto idrp rdpath /.*  /
    		{
    		policy;
    		};
    
    
    

    two internal peers - filter on RDPATH rejects another rdi

    
    	import proto idrp rdpath / .* rdi-2 .* /
    		{
    		policy;
    		};
    
    

    two external peers - allowing both RD_PATH

    
    
    	import proto idrp rdpath / rdi-1 /
    		{
    		policy;
    		}
    
    
    

    RD_PATH each others

    
    	import proto idrp rdpath / rdi1 /
    		{
    		policy;
    		}
    
    	machine 1 - rdi of machine 2
    

    two external peers - each other both RD_PATH

    
    	import proto idrp rdpath /.* rdi1/
    		{
    		policy;
    		} 
    

    two external - oring of two rdi (rdi1 or rdi2)

    
    	import proto idrp rdpath / { rdi1 | rdi2 } /
    		{
    		policy;
    		};		 
    

    two external peers - [ rdi1 rdi 2 ]

    
    	import proto idrp rdpath / [ rdi1 rdi2 ] /
    		{
    		policy;
    		};		 
    

    two external peers - 1st RD allowing the RD_PATH in, 2nd RD deny

    
    step 1:
    
    	import proto idrp rdpath / rdi1  /
    		{
    		ip all;
    		osi all;
    		}
    	import proto idrp rdpath / rdi2  /
    		restrict ;
    
    
    step 2:
    
    	import proto idrp rdpath / rdi1  /
    		restrict ;
    	
    	import proto idrp rdpath / rdi2  /
    		{
    		ip all;
    		osi all;
    		}
    
    

    RD_PATH (ADVFT_RDPATH) Three-machine-tests

    Three peer tests External

    	rdi1  rdi2
    	idrp--life
    	  \   /
    	  feeble		 
    	  rdi3 
    
    
    
    	feebe: idrp's routes only
     
     	import proto idrp rdpath / rdi1 rdi2 /
    		{
    		policy;
    		}	
    
    	restrict rest;
    
    1. Allow via one 1 path, deny others
      
       	import proto idrp rdpath / rdi1 rdi2 /
      		{
      		policy;
      		}
      
      	import proto idrp rdpath / .* /
      		restrict;
      
      	restrict rest  
      
      
    2. Allow via one 2 paths, deny others
      
      external mesh:
      
       	import proto idrp rdpath / rdi1 rdi2 /
      		{
      		policy;
      		}
      
      	import proto idrp rdpath / rd2 rd3  /
      		{
      		policy;
      		}
      
       	import proto idrp rdpath / .* /
      		restrict;
      
      
    3. Allow via one 3 paths, deny others
    4. Prefer 1 path over others (allow all)
    5. Prefer 1 path over others, allow only some