Java 类org.projectfloodlight.openflow.protocol.action.OFActionSetNwSrc 实例源码

/**
 * Parse set_nw_src actions.
 * The key and delimiter for the action should be omitted, and only the
 * data should be presented to this decoder.
 * 
 * TODO should consider using IPv4AddressWithMask's built-in parser....
 * 
 * @param actionToDecode; The action as a string to decode
 * @param version; The OF version to create the action for
 * @param log
 * @return
 */
private static OFActionSetNwSrc decode_set_src_ip(String actionToDecode, OFVersion version, Logger log) {
    Matcher n = Pattern.compile("(?:(\\d+)\\.(\\d+)\\.(\\d+)\\.(\\d+))").matcher(actionToDecode);
    if (n.matches()) {
        IPv4Address ipaddr = IPv4Address.of(get_ip_addr(n, actionToDecode, log));
        OFActionSetNwSrc.Builder ab = OFFactories.getFactory(version).actions().buildSetNwSrc();
        ab.setNwAddr(ipaddr);
        log.debug("action {}", ab.build());
        return ab.build();
    }
    else {
        log.debug("Invalid action: '{}'", actionToDecode);
        return null;
    }
}

/**
 * Parse set_nw_src actions.
 * The key and delimiter for the action should be omitted, and only the
 * data should be presented to this decoder.
 * 
 * TODO should consider using IPv4AddressWithMask's built-in parser....
 * 
 * @param actionToDecode; The action as a string to decode
 * @param version; The OF version to create the action for
 * @param log
 * @return
 */
private static OFActionSetNwSrc decode_set_src_ip(String actionToDecode, OFVersion version, Logger log) {
    Matcher n = Pattern.compile("(?:(\\d+)\\.(\\d+)\\.(\\d+)\\.(\\d+))").matcher(actionToDecode);
    if (n.matches()) {
        IPv4Address ipaddr = IPv4Address.of(get_ip_addr(n, actionToDecode, log));
        OFActionSetNwSrc.Builder ab = OFFactories.getFactory(version).actions().buildSetNwSrc();
        ab.setNwAddr(ipaddr);
        log.debug("action {}", ab.build());
        return ab.build();
    }
    else {
        log.debug("Invalid action: '{}'", actionToDecode);
        return null;
    }
}

/**
 * Parse set_nw_src actions.
 * The key and delimiter for the action should be omitted, and only the
 * data should be presented to this decoder.
 * 
 * TODO should consider using IPv4AddressWithMask's built-in parser....
 * 
 * @param actionToDecode; The action as a string to decode
 * @param version; The OF version to create the action for
 * @param log
 * @return
 */
private static OFActionSetNwSrc decode_set_src_ip(String actionToDecode, OFVersion version, Logger log) {
    Matcher n = Pattern.compile("(?:(\\d+)\\.(\\d+)\\.(\\d+)\\.(\\d+))").matcher(actionToDecode);
    if (n.matches()) {
        IPv4Address ipaddr = IPv4Address.of(get_ip_addr(n, actionToDecode, log));
        OFActionSetNwSrc.Builder ab = OFFactories.getFactory(version).actions().buildSetNwSrc();
        ab.setNwAddr(ipaddr);
        log.debug("action {}", ab.build());
        return ab.build();
    }
    else {
        log.debug("Invalid action: '{}'", actionToDecode);
        return null;
    }
}

/**
 * Parse set_nw_src actions.
 * The key and delimiter for the action should be omitted, and only the
 * data should be presented to this decoder.
 * 
 * TODO should consider using IPv4AddressWithMask's built-in parser....
 * 
 * @param actionToDecode; The action as a string to decode
 * @param version; The OF version to create the action for
 * @param log
 * @return
 */
private static OFActionSetNwSrc decode_set_src_ip(String actionToDecode, OFVersion version, Logger log) {
    Matcher n = Pattern.compile("(?:(\\d+)\\.(\\d+)\\.(\\d+)\\.(\\d+))").matcher(actionToDecode);
    if (n.matches()) {
        IPv4Address ipaddr = IPv4Address.of(get_ip_addr(n, actionToDecode, log));
        OFActionSetNwSrc.Builder ab = OFFactories.getFactory(version).actions().buildSetNwSrc();
        ab.setNwAddr(ipaddr);
        log.debug("action {}", ab.build());
        return ab.build();
    }
    else {
        log.debug("Invalid action: '{}'", actionToDecode);
        return null;
    }
}

/**
 * Parse set_nw_src actions.
 * The key and delimiter for the action should be omitted, and only the
 * data should be presented to this decoder.
 * 
 * TODO should consider using IPv4AddressWithMask's built-in parser....
 * 
 * @param actionToDecode; The action as a string to decode
 * @param version; The OF version to create the action for
 * @param log
 * @return
 */
private static OFActionSetNwSrc decode_set_src_ip(String actionToDecode, OFVersion version, Logger log) {
    Matcher n = Pattern.compile("(?:(\\d+)\\.(\\d+)\\.(\\d+)\\.(\\d+))").matcher(actionToDecode);
    if (n.matches()) {
        IPv4Address ipaddr = IPv4Address.of(get_ip_addr(n, actionToDecode, log));
        OFActionSetNwSrc.Builder ab = OFFactories.getFactory(version).actions().buildSetNwSrc();
        ab.setNwAddr(ipaddr);
        log.debug("action {}", ab.build());
        return ab.build();
    }
    else {
        log.debug("Invalid action: '{}'", actionToDecode);
        return null;
    }
}

/**
 * Parse set_nw_src actions.
 * The key and delimiter for the action should be omitted, and only the
 * data should be presented to this decoder.
 *
 * TODO should consider using IPv4AddressWithMask's built-in parser....
 *
 * @param actionToDecode; The action as a string to decode
 * @param version; The OF version to create the action for
 * @param log
 * @return
 */
private static OFActionSetNwSrc decode_set_src_ip(String actionToDecode, OFVersion version, Logger log) {
    Matcher n = Pattern.compile("(?:(\\d+)\\.(\\d+)\\.(\\d+)\\.(\\d+))").matcher(actionToDecode);
    if (n.matches()) {
        IPv4Address ipaddr = IPv4Address.of(get_ip_addr(n, actionToDecode, log));
        OFActionSetNwSrc.Builder ab = OFFactories.getFactory(version).actions().buildSetNwSrc();
        ab.setNwAddr(ipaddr);
        log.debug("action {}", ab.build());
        return ab.build();
    }
    else {
        log.debug("Invalid action: '{}'", actionToDecode);
        return null;
    }
}

/**
 * Parse set_nw_src actions.
 * The key and delimiter for the action should be omitted, and only the
 * data should be presented to this decoder.
 * 
 * TODO should consider using IPv4AddressWithMask's built-in parser....
 * 
 * @param actionToDecode; The action as a string to decode
 * @param version; The OF version to create the action for
 * @param log
 * @return
 */
private static OFActionSetNwSrc decode_set_src_ip(String actionToDecode, OFVersion version, Logger log) {
    Matcher n = Pattern.compile("(?:(\\d+)\\.(\\d+)\\.(\\d+)\\.(\\d+))").matcher(actionToDecode);
    if (n.matches()) {
        IPv4Address ipaddr = IPv4Address.of(get_ip_addr(n, actionToDecode, log));
        OFActionSetNwSrc.Builder ab = OFFactories.getFactory(version).actions().buildSetNwSrc();
        ab.setNwAddr(ipaddr);
        log.debug("action {}", ab.build());
        return ab.build();
    }
    else {
        log.debug("Invalid action: '{}'", actionToDecode);
        return null;
    }
}

/**
 * Parse set_nw_src actions.
 * The key and delimiter for the action should be omitted, and only the
 * data should be presented to this decoder.
 * 
 * TODO should consider using IPv4AddressWithMask's built-in parser....
 * 
 * @param actionToDecode; The action as a string to decode
 * @param version; The OF version to create the action for
 * @param log
 * @return
 */
private static OFActionSetNwSrc decode_set_src_ip(String actionToDecode, OFVersion version, Logger log) {
    Matcher n = Pattern.compile("(?:(\\d+)\\.(\\d+)\\.(\\d+)\\.(\\d+))").matcher(actionToDecode);
    if (n.matches()) {
        IPv4Address ipaddr = IPv4Address.of(get_ip_addr(n, actionToDecode, log));
        OFActionSetNwSrc.Builder ab = OFFactories.getFactory(version).actions().buildSetNwSrc();
        ab.setNwAddr(ipaddr);
        log.debug("action {}", ab.build());
        return ab.build();
    }
    else {
        log.debug("Invalid action: '{}'", actionToDecode);
        return null;
    }
}

/**
 * Parse set_nw_src actions.
 * The key and delimiter for the action should be omitted, and only the
 * data should be presented to this decoder.
 * 
 * TODO should consider using IPv4AddressWithMask's built-in parser....
 * 
 * @param actionToDecode; The action as a string to decode
 * @param version; The OF version to create the action for
 * @param log
 * @return
 */
private static OFActionSetNwSrc decode_set_src_ip(String actionToDecode, OFVersion version, Logger log) {
    Matcher n = Pattern.compile("(?:(\\d+)\\.(\\d+)\\.(\\d+)\\.(\\d+))").matcher(actionToDecode);
    if (n.matches()) {
        IPv4Address ipaddr = IPv4Address.of(get_ip_addr(n, actionToDecode, log));
        OFActionSetNwSrc.Builder ab = OFFactories.getFactory(version).actions().buildSetNwSrc();
        ab.setNwAddr(ipaddr);
        log.debug("action {}", ab.build());
        return ab.build();
    }
    else {
        log.debug("Invalid action: '{}'", actionToDecode);
        return null;
    }
}

/**
 * Parse set_nw_src actions.
 * The key and delimiter for the action should be omitted, and only the
 * data should be presented to this decoder.
 * 
 * TODO should consider using IPv4AddressWithMask's built-in parser....
 * 
 * @param actionToDecode; The action as a string to decode
 * @param version; The OF version to create the action for
 * @param log
 * @return
 */
private static OFActionSetNwSrc decode_set_src_ip(String actionToDecode, OFVersion version, Logger log) {
    Matcher n = Pattern.compile("(?:(\\d+)\\.(\\d+)\\.(\\d+)\\.(\\d+))").matcher(actionToDecode);
    if (n.matches()) {
        IPv4Address ipaddr = IPv4Address.of(get_ip_addr(n, actionToDecode, log));
        OFActionSetNwSrc.Builder ab = OFFactories.getFactory(version).actions().buildSetNwSrc();
        ab.setNwAddr(ipaddr);
        log.debug("action {}", ab.build());
        return ab.build();
    }
    else {
        log.debug("Invalid action: '{}'", actionToDecode);
        return null;
    }
}

/**
 * Parse set_nw_src actions.
 * The key and delimiter for the action should be omitted, and only the
 * data should be presented to this decoder.
 * 
 * TODO should consider using IPv4AddressWithMask's built-in parser....
 * 
 * @param actionToDecode; The action as a string to decode
 * @param version; The OF version to create the action for
 * @param log
 * @return
 */
private static OFActionSetNwSrc decode_set_src_ip(String actionToDecode, OFVersion version, Logger log) {
    Matcher n = Pattern.compile("(?:(\\d+)\\.(\\d+)\\.(\\d+)\\.(\\d+))").matcher(actionToDecode);
    if (n.matches()) {
        IPv4Address ipaddr = IPv4Address.of(get_ip_addr(n, actionToDecode, log));
        OFActionSetNwSrc.Builder ab = OFFactories.getFactory(version).actions().buildSetNwSrc();
        ab.setNwAddr(ipaddr);
        log.debug("action {}", ab.build());
        return ab.build();
    }
    else {
        log.debug("Invalid action: '{}'", actionToDecode);
        return null;
    }
}

public FlowAlias(OFFlowMod flowmod){
    this.ofm = flowmod;
    this.aliasList = new ArrayList<>();
    this.fra = FlowRuleAction.DROP;
    this.lastConflictAlias = null;

    Match match = flowmod.getMatch();
    Match.Builder mb = match.createBuilder();
    List<OFAction> actions = flowmod.getActions();

    //initialize alias with match filed
    Alias alias = new Alias(match);

    //add alias to list
    this.aliasList.add(alias);

    //update alias based on actions
    for (OFAction act : actions){       
        switch (act.getType()){
            case SET_DL_SRC:
                OFActionSetDlSrc setDLSRC = (OFActionSetDlSrc)act; 
                mb.setExact(MatchField.ETH_SRC, setDLSRC.getDlAddr());
                break;
            case SET_DL_DST:
                OFActionSetDlDst setDLDST = (OFActionSetDlDst)act;
                mb.setExact(MatchField.ETH_DST, setDLDST.getDlAddr());
                break;
            case SET_NW_SRC:
                OFActionSetNwSrc setNWSRC = (OFActionSetNwSrc)act;
                mb.setExact(MatchField.IPV4_SRC,setNWSRC.getNwAddr());
                break;
            case SET_NW_DST:
                OFActionSetNwDst setNWDST = (OFActionSetNwDst)act;
                mb.setExact(MatchField.IPV4_DST,setNWDST.getNwAddr());
                break;
            case SET_TP_SRC:
                OFActionSetTpSrc setTPSRC = (OFActionSetTpSrc)act;
                mb.setExact(MatchField.TCP_SRC, setTPSRC.getTpPort());
                break;
            case SET_TP_DST:
                OFActionSetTpDst setTPDST = (OFActionSetTpDst)act;
                mb.setExact(MatchField.TCP_SRC, setTPDST.getTpPort());
                break;

            case ENQUEUE:
            case OUTPUT:
                OFActionOutput output = (OFActionOutput)act;
                alias.setPort(output.getPort());
                this.fra = FlowRuleAction.FORWARD;
            break;

        }
    }
    //save modified action
    alias.setMatch(mb.build());

    //add updated alias to the list
    this.aliasList.add(alias);
}

@Override
public void switchAdded(DatapathId switchId) {
    IOFSwitch sw = switchService.getSwitch(switchId);

    if (sw == null) {
        return;
    }

    // install conflicting forwarding rules and security rules for testing security kernel


    // forward rules
    Match.Builder matchFwd = sw.getOFFactory().buildMatch();
    matchFwd.setExact(MatchField.IPV4_SRC, IPv4Address.of("10.0.0.3"));
    matchFwd.setExact(MatchField.ETH_TYPE, EthType.IPv4);

    OFFlowAdd.Builder forwardflow = sw.getOFFactory().buildFlowAdd();
    ArrayList<OFAction> forwardfActionList = new ArrayList<OFAction>();

    OFActionOutput.Builder forwardaction = sw.getOFFactory().actions()
            .buildOutput();
    forwardaction.setPort(OFPort.of(2));
    OFActionSetNwSrc.Builder secaction = sw.getOFFactory().actions()
            .buildSetNwSrc();
    secaction.setNwAddr(IPv4Address.of("10.0.0.1"));

    forwardfActionList.add(forwardaction.build());
    forwardfActionList.add(secaction.build());

    forwardflow.setBufferId(OFBufferId.NO_BUFFER);
    forwardflow.setHardTimeout(0);
    forwardflow.setIdleTimeout(0);
    forwardflow.setOutPort(OFPort.CONTROLLER);
    forwardflow.setActions(forwardfActionList);
    forwardflow.setMatch(matchFwd.build());
    forwardflow.setPriority(200);

    // security rules
    OFFlowAdd.Builder securityFlow = sw.getOFFactory().buildFlowAdd();
    ArrayList<OFAction> securityActionList = new ArrayList<OFAction>();
    OFActionOutput.Builder securitydaction = sw.getOFFactory().actions()
            .buildOutput();

    Match.Builder matchSec = sw.getOFFactory().buildMatch();
    matchSec.setExact(MatchField.IPV4_SRC, IPv4Address.of("10.0.0.1"));
    matchSec.setExact(MatchField.ETH_TYPE, EthType.IPv4);

    securityFlow.setBufferId(OFBufferId.NO_BUFFER);
    securityFlow.setHardTimeout(0);
    securityFlow.setIdleTimeout(0);
    securityFlow.setOutPort(OFPort.CONTROLLER);
    securityFlow.setActions(securityActionList);
    securityFlow.setMatch(matchSec.build());
    securityFlow.setPriority(300);

    sw.write(securityFlow.build());
    sw.write(forwardflow.build());

}