Стандартный шлюз Cisco с управлением по telnet, учитывающий периоды действия диапазонов

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
import bitel.billing.common.module.ipn.CiscoRuleOptions;
import bitel.billing.common.module.ipn.IPNContractStatus;
import bitel.billing.server.ipn.GateWorker;
import bitel.billing.server.ipn.UserStatus;
import bitel.billing.server.ipn.bean.AclOptions;
import ru.bitel.bgbilling.modules.ipn.server.bean.command.GateCommandUtil;
import bitel.billing.server.util.DefaultServerSetup;
import ru.bitel.common.Utils;
//import bitel.billing.server.util.ServerUtils;
import bitel.billing.server.util.telnet.TelnetSession;
import ru.bitel.bgbilling.modules.ipn.common.bean.AddressRangeManager;
import ru.bitel.bgbilling.modules.ipn.common.bean.AddressRange;
import ru.bitel.bgbilling.modules.ipn.server.bean.command.LoopPattern;
import bitel.billing.common.IPUtils;
import bitel.billing.server.contract.bean.ContractStatusManager;
import bitel.billing.common.KernelConst;
import bitel.billing.server.contract.bean.ContractStatus;
 
void doSync()
{
	host = gate.getHost();
	port = gate.getPort();
	gid = gate.getId();
 
	gateSetup = new DefaultServerSetup( gate.getConfig(), "\r\n" );        
 
	login = gateSetup.get( "login", "bgbilling" );
	pswd = gate.getKeyword();
 
	if( log.isDebugEnabled() )
	{
		log.debug( gid + " gate: " + host + ":" + port + " login: " + login + " pswd: " + pswd );
	}
 
	//SSHSession session = null;
	session = null;
 
 
	try
	{
 
		session = new TelnetSession( host, port );
 
		session.setEndString( ":" );
		//session.setEndString( ":" );
		System.out.println( "before connect" ); 		
		session.connect();
		System.out.println( "after connect" ); 			
		System.out.println( session.doCommand( login ) );
		session.setEndString( "#" );
		//session.setEndString( ":" );
		session.doCommand( pswd );
 
		session.doCommand( "terminal length 0" );
 
		result = new StringBuffer();
 
 
		list = ( session.doCommand( "show access-list" ) );
		result.append( list );
 
		if( log.isDebugEnabled() )
		{
			log.debug( gid +" AccessList taking.." );
			log.debug( result );
		}
 
		// код ACL - стуктура с описанием 
		aclMap = AclOptions.getAclMapById( gateSetup );
 
		// имя ACL - стуктура с описанием
		aclByNameMap = new HashMap();
		for( AclOptions option : aclMap.values() )
		{
			aclByNameMap.put( option.name, option );
		}            
 
		result.append( session.doCommand( "configure terminal" ) );
 
		//  проход по ACL списку с отметкой какие договора открыты            
		markOpenFromRules( list, aclByNameMap );            
 
		// подготовка списка корректирующих команд
		buildCommandsLists( aclMap );
 
 
		for( AclOptions options : aclMap.values() )
		{
			if( options.commands.size() > 0 )
			{
				//  TODO: extended или нет - надо смотреть в конфиге 
				result.append( session.doCommand( "ip access-list extended " + options.name ) );
 
				if( log.isDebugEnabled() )
				{
					log.debug( gid + " ACL " + options.name  );
                    }
 
                    for( String command : options.commands )
                    {
                        if( log.isDebugEnabled() )
                        {
                            log.debug( gid + " " + command  );
                        }
                        result.append( session.doCommand( command ) );
                    }                      
                }
            }
 
			//выход из configure 
			result.append( session.doCommand( "exit" ) );
			session.doCommandAsync( "exit" );	
 
 
            if (log.isDebugEnabled())
            {
            	log.debug( "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" );
            	log.debug( result.toString() );
            	log.debug( "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" );
            }
 
            // пауза пока считает команду exit
            Thread.sleep( 100 );
        }
        catch ( Exception e )
        {
        	throw new RuntimeException ( e );
        }
        finally
        {
            if( session != null )
            {
                session.disconnect();
            }
        }
    }
 
    buildCommandsLists( aclMap )
    {
		ContractStatusManager man = new ContractStatusManager( con );
 
        for( status : statusList )
        {
            ruleOptions = CiscoRuleOptions.extractParams( status.rule.getRuleText() );
            options = aclMap.get( ruleOptions.aclId );
 
			String ruleText = status.rule.getRuleText();
 
			log.debug( "ruleText = " + ruleText );
			//во  такой вот хитрый способо распарсить
			int pos = ruleText.indexOf( CiscoRuleOptions.START_PARAMS );
			if ( pos < 0 )
			{
				pos = ruleText.length();
			}
			//ещем только в первйо части , иначе там опять попадается симовол ";" и косяк выходит
			List loops = GateCommandUtil.getAddresLoops( ruleText.substring( 0, pos ) );
 
 
			List goodList = new ArrayList(); 
			List badList = new ArrayList();				
 
			classifyIp(  loops, status.contractId, goodList, badList);
 
			ContractStatus contractStatus = man.getStatus( status.contractId, new java.util.Date() );
 
 
            // флаг того то правило есть на шлюзе
            flag = false;
 
			log.debug( "contractStatus =" +  (contractStatus == null ? "contractStatus" : contractStatus.getStatus() ) );
			log.debug( "status.status=" + status.status );
 
            // правило для этого договора есть на шлюзе
            if ( options.openRulesFrom.containsKey( ruleOptions.fromPos ) )
            {
                log.debug( "contains" );
				//  если правило есть а юзер заблокирован - удаляем правило
                if ( status.status > 0 || ( contractStatus != null && contractStatus.getStatus() > 0 ) )
                {
					if( options != null )
                    {
                       log.debug( "delete rule" );
						rules = options.openRulesFrom.get( ruleOptions.fromPos );
 
                        if( rules != null )
                        {
                            for( int rule : rules )
                            {
                                options.commands.add( "no " + rule );
                            }                                
                        }
                    }                    
                }                       
 
                flag = true;
                options.openRulesFrom.remove( ruleOptions.fromPos );
            }
 			log.debug( "cond=" + ( !flag &&  status.status == IPNContractStatus.STATUS_OPEN && ( contractStatus == null || contractStatus.getStatus() == 0 ) ) );
            // правила нет, а юзер открыт - добавляем правило
            if ( !flag && 
                status.status == IPNContractStatus.STATUS_OPEN && ( contractStatus == null || contractStatus.getStatus() == 0 ) )
            {
                rule = CiscoRuleOptions.clearFromParams( status.rule.getRuleText() );
 
                acl = aclMap.get( ruleOptions.aclId );
                if( acl != null )
                {
                    //  типизированное правило
                    if( status.ruleType != null )
                    {                                   			                    	
 						ruleText = GateCommandUtil.getRule( status.gateType, status.ruleType );    
    					rule =GateCommandUtil.generateRule( ruleText, null, status.ruleType, goodList );
                    }                
 
                    int rulePos = ruleOptions.fromPos;
 
 
 
 
                    StringTokenizer st = new StringTokenizer( rule, "\r\n" );
                    while( st.hasMoreTokens() )
                    {
                        String line = st.nextToken().trim();
                        acl.commands.add( (rulePos++) + " " + line );
                    }
                }
            }            
        }
    }
 
    markOpenFromRules( String result, aclByNameMap )
    {
        gid = gate.getId();
		 line = null;            
        currentAclOptions = null;        
 
        st = new StringTokenizer( result, "\r\n" );
 
		 accessPattern = Pattern.compile( "access list\\s+([\\w\\-]+)" );
        rulePattern = Pattern.compile( "^(\\d+)\\s+((permit)|(deny))" );
 
        while( st.hasMoreTokens() )
        {
            line = st.nextToken().trim();
 
            m = accessPattern.matcher( line );
            if( m.find() )
            {
                currentAcl = m.group( 1 );
                currentAclOptions = aclByNameMap.get( currentAcl );
 
                if( log.isDebugEnabled() )
                {
                    log.debug( gid + " ACL " + currentAcl + " not in billing control.." );
                }
 
                continue;
            }
 
            if( currentAclOptions == null )
            {
                continue;
            }
 
            m = rulePattern.matcher( line );
            if( m.find() )
            {
                rule = Utils.parseInt( m.group( 1 ) );
                if( rule < currentAclOptions.fromPos || 
                    rule > currentAclOptions.toPos )
                {
                    if( log.isDebugEnabled() )
                    {
                        log.debug( gid + " Skip rule " + line );
                    }
                }
                else
                {
                    ruleFrom = 
                        ((rule - currentAclOptions.fromPos) / currentAclOptions.onContact) * currentAclOptions.onContact 
                        + currentAclOptions.fromPos;
                    rules = currentAclOptions.openRulesFrom.get( ruleFrom );
                    if( rules == null )
                    {
                        rules = new HashSet();
                        currentAclOptions.openRulesFrom.put( ruleFrom, rules );                        
                    }
 
                    rules.add( rule );
 
                    if( log.isDebugEnabled() )
                    {
                        log.debug( gid + " Contact open from rule: " + ruleFrom );
                    }
                }
            }
        }
    }
 
 
/*
удаляем те ip, которые сейчас не действуют	
*/
void classifyIp(  List loops, int cid, List goodList, List badList )
{		
	///обнуляем		
	AddressRangeManager man = new AddressRangeManager( con, mid );
   	addressList = man.getContractAddressRange( cid, new GregorianCalendar(), -1 );
 
	for ( int i = 0; i < loops.size(); i++  )
	{
		LoopPattern pattern = loops.get( i );
 
		LoopPattern goodPatern = new  LoopPattern();
		goodPatern.setLoopPatern( pattern.getLoopPatern() );
		goodPatern.setReplacements( pattern.getReplacements() );		
		goodList.add( goodPatern ) ;
 
		LoopPattern badPatern = new  LoopPattern();
		badPatern.setLoopPatern( pattern.getLoopPatern() );
		badPatern.setReplacements( pattern.getReplacements() );		
		badList.add( badPatern ) ;
 
 
		for ( List list : pattern.getObjects() )
		{	
			String address = list.get( 0 );			
 
			boolean found = false; 
			long laddress = IPUtils.convertStringIPtoLong( address );
			AddressRange foundRange = null;
 
			for ( AddressRange range : addressList )
			{
				//адрес
				if ( i == 0 && range.getAddr1()  <= laddress 	&& range.getAddr2() >= laddress )
				{
					found = true;
					break;
				}
 
				//сеть
				if ( i == 1 && range.getAddr1() == 		laddress )
				{
					found = true;
					break;
				}
			}
 
			if ( found )
			{					
				//log.info( "is good" );
				goodPatern.getObjects().add( list );
			}
			else
			{
				//log.info( "is bad" );
				badPatern.getObjects().add( list );
			}	
 
		}
	}
}