def mod_group_entry(dp, group, cmd):
    group_type = str(group.get("type", "ALL"))
    t = UTIL.ofp_group_type_from_user(group_type)
    group_type = t if t != group_type else None
    if group_type is None:
        LOG.error("Unknown group type: %s", group.get("type"))

    group_id = UTIL.ofp_group_from_user(group.get("group_id", 0))

    buckets = []
    for bucket in group.get("buckets", []):
        weight = int(bucket.get("weight", 0))
        watch_port = int(bucket.get("watch_port", dp.ofproto.OFPP_ANY))
        watch_group = int(bucket.get("watch_group", dp.ofproto.OFPG_ANY))
        actions = []
        for dic in bucket.get("actions", []):
            action = to_action(dp, dic)
            if action is not None:
                actions.append(action)
        b = dp.ofproto_parser.OFPBucket(weight, watch_port, watch_group, actions)
        buckets.append(b)

    group_mod = dp.ofproto_parser.OFPGroupMod(dp, cmd, group_type, group_id, buckets)

    ofctl_utils.send_msg(dp, group_mod, LOG)

def mod_port_behavior(dp, port_config):
    ofp = dp.ofproto
    parser = dp.ofproto_parser
    port_no = UTIL.ofp_port_from_user(port_config.get("port_no", 0))
    hw_addr = str(port_config.get("hw_addr"))
    config = int(port_config.get("config", 0))
    mask = int(port_config.get("mask", 0))
    properties = port_config.get("properties")

    prop = []
    for p in properties:
        type_ = UTIL.ofp_port_mod_prop_type_from_user(p["type"])
        length = None
        if type_ == ofp.OFPPDPT_ETHERNET:
            advertise = UTIL.ofp_port_features_from_user(p["advertise"])
            m = parser.OFPPortModPropEthernet(type_, length, advertise)
        elif type_ == ofp.OFPPDPT_OPTICAL:
            m = parser.OFPPortModPropOptical(
                type_, length, p["configure"], p["freq_lmda"], p["fl_offset"], p["grid_span"], p["tx_pwr"]
            )
        elif type_ == ofp.OFPPDPT_EXPERIMENTER:
            m = parser.OFPPortModPropExperimenter(type_, length, p["experimenter"], p["exp_type"], p["data"])
        else:
            LOG.error("Unknown port desc prop type: %s", type_)
            continue
        prop.append(m)

    port_mod = dp.ofproto_parser.OFPPortMod(dp, port_no, hw_addr, config, mask, prop)

    ofctl_utils.send_msg(dp, port_mod, LOG)

def mod_flow_entry(dp, flow, cmd):
    cookie = int(flow.get("cookie", 0))
    cookie_mask = int(flow.get("cookie_mask", 0))
    table_id = UTIL.ofp_table_from_user(flow.get("table_id", 0))
    idle_timeout = int(flow.get("idle_timeout", 0))
    hard_timeout = int(flow.get("hard_timeout", 0))
    priority = int(flow.get("priority", 0))
    buffer_id = UTIL.ofp_buffer_from_user(flow.get("buffer_id", dp.ofproto.OFP_NO_BUFFER))
    out_port = UTIL.ofp_port_from_user(flow.get("out_port", dp.ofproto.OFPP_ANY))
    out_group = UTIL.ofp_group_from_user(flow.get("out_group", dp.ofproto.OFPG_ANY))
    importance = int(flow.get("importance", 0))
    flags = int(flow.get("flags", 0))
    match = to_match(dp, flow.get("match", {}))
    inst = to_instructions(dp, flow.get("instructions", []))

    flow_mod = dp.ofproto_parser.OFPFlowMod(
        dp,
        cookie,
        cookie_mask,
        table_id,
        cmd,
        idle_timeout,
        hard_timeout,
        priority,
        buffer_id,
        out_port,
        out_group,
        importance,
        flags,
        match,
        inst,
    )

    ofctl_utils.send_msg(dp, flow_mod, LOG)

def mod_group_entry(dp, group, cmd):

    type_convert = {'ALL': dp.ofproto.OFPGT_ALL,
                    'SELECT': dp.ofproto.OFPGT_SELECT,
                    'INDIRECT': dp.ofproto.OFPGT_INDIRECT,
                    'FF': dp.ofproto.OFPGT_FF}

    type_ = type_convert.get(group.get('type', 'ALL'))
    if type_ is None:
        LOG.error('Unknown group type: %s', group.get('type'))

    group_id = UTIL.ofp_group_from_user(group.get('group_id', 0))

    buckets = []
    for bucket in group.get('buckets', []):
        weight = int(bucket.get('weight', 0))
        watch_port = int(bucket.get('watch_port', dp.ofproto.OFPP_ANY))
        watch_group = int(bucket.get('watch_group', dp.ofproto.OFPG_ANY))
        actions = []
        for dic in bucket.get('actions', []):
            action = to_action(dp, dic)
            if action is not None:
                actions.append(action)
        buckets.append(dp.ofproto_parser.OFPBucket(
            weight, watch_port, watch_group, actions))

    group_mod = dp.ofproto_parser.OFPGroupMod(
        dp, cmd, type_, group_id, buckets)

    ofctl_utils.send_msg(dp, group_mod, LOG)

def mod_port_behavior(dp, port_config):
    ofp = dp.ofproto
    parser = dp.ofproto_parser
    port_no = UTIL.ofp_port_from_user(port_config.get('port_no', 0))
    hw_addr = str(port_config.get('hw_addr'))
    config = int(port_config.get('config', 0))
    mask = int(port_config.get('mask', 0))
    properties = port_config.get('properties')

    prop = []
    for p in properties:
        type_ = UTIL.ofp_port_mod_prop_type_from_user(p['type'])
        length = None
        if type_ == ofp.OFPPDPT_ETHERNET:
            advertise = UTIL.ofp_port_features_from_user(p['advertise'])
            prop.append(
                parser.OFPPortModPropEthernet(type_, length, advertise))
        elif type_ == ofp.OFPPDPT_OPTICAL:
            prop.append(
                parser.OFPPortModPropOptical(
                    type_, length, p['configure'], p['freq_lmda'],
                    p['fl_offset'], p['grid_span'], p['tx_pwr']))
        elif type_ == ofp.OFPPDPT_EXPERIMENTER:
            prop.append(
                parser.OFPPortModPropExperimenter(
                    type_, length, p['experimenter'], p['exp_type'],
                    p['data']))
        else:
            LOG.error('Unknown port desc prop type: %s', type_)

    port_mod = dp.ofproto_parser.OFPPortMod(
        dp, port_no, hw_addr, config, mask, prop)

    ofctl_utils.send_msg(dp, port_mod, LOG)

def mod_group_entry(dp, group, cmd):
    group_type = str(group.get('type', 'ALL'))
    t = UTIL.ofp_group_type_from_user(group_type)
    group_type = t if t != group_type else None
    if group_type is None:
        LOG.error('Unknown group type: %s', group.get('type'))

    group_id = UTIL.ofp_group_from_user(group.get('group_id', 0))

    buckets = []
    for bucket in group.get('buckets', []):
        weight = int(bucket.get('weight', 0))
        watch_port = int(bucket.get('watch_port', dp.ofproto.OFPP_ANY))
        watch_group = int(bucket.get('watch_group', dp.ofproto.OFPG_ANY))
        actions = []
        for dic in bucket.get('actions', []):
            action = to_action(dp, dic)
            if action is not None:
                actions.append(action)
        buckets.append(dp.ofproto_parser.OFPBucket(
            weight, watch_port, watch_group, actions))

    group_mod = dp.ofproto_parser.OFPGroupMod(
        dp, cmd, group_type, group_id, buckets)

    ofctl_utils.send_msg(dp, group_mod, LOG)

def delete_flow_entry(dp):
    match = dp.ofproto_parser.OFPMatch(
        dp.ofproto.OFPFW_ALL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)

    flow_mod = dp.ofproto_parser.OFPFlowMod(
        datapath=dp, match=match, cookie=0,
        command=dp.ofproto.OFPFC_DELETE)

    ofctl_utils.send_msg(dp, flow_mod, LOG)

def mod_port_behavior(dp, port_config):
    port_no = UTIL.ofp_port_from_user(port_config.get('port_no', 0))
    hw_addr = str(port_config.get('hw_addr'))
    config = int(port_config.get('config', 0))
    mask = int(port_config.get('mask', 0))
    advertise = int(port_config.get('advertise'))

    port_mod = dp.ofproto_parser.OFPPortMod(
        dp, port_no, hw_addr, config, mask, advertise)

    ofctl_utils.send_msg(dp, port_mod, LOG)

def mod_meter_entry(dp, meter, cmd):

    flags_convert = {'KBPS': dp.ofproto.OFPMF_KBPS,
                     'PKTPS': dp.ofproto.OFPMF_PKTPS,
                     'BURST': dp.ofproto.OFPMF_BURST,
                     'STATS': dp.ofproto.OFPMF_STATS}

    flags = 0
    if 'flags' in meter:
        meter_flags = meter['flags']
        if not isinstance(meter_flags, list):
            meter_flags = [meter_flags]
        for flag in meter_flags:
            if flag not in flags_convert:
                LOG.error('Unknown meter flag: %s', flag)
                continue
            flags |= flags_convert.get(flag)

    meter_id = UTIL.ofp_meter_from_user(meter.get('meter_id', 0))

    bands = []
    for band in meter.get('bands', []):
        band_type = band.get('type')
        rate = int(band.get('rate', 0))
        burst_size = int(band.get('burst_size', 0))
        if band_type == 'DROP':
            bands.append(
                dp.ofproto_parser.OFPMeterBandDrop(rate, burst_size))
        elif band_type == 'DSCP_REMARK':
            prec_level = int(band.get('prec_level', 0))
            bands.append(
                dp.ofproto_parser.OFPMeterBandDscpRemark(
                    rate, burst_size, prec_level))
        elif band_type == 'EXPERIMENTER':
            experimenter = int(band.get('experimenter', 0))
            bands.append(
                dp.ofproto_parser.OFPMeterBandExperimenter(
                    rate, burst_size, experimenter))
        else:
            LOG.error('Unknown band type: %s', band_type)

    meter_mod = dp.ofproto_parser.OFPMeterMod(
        dp, cmd, flags, meter_id, bands)

    ofctl_utils.send_msg(dp, meter_mod, LOG)

def mod_meter_entry(dp, meter, cmd):
    flags = 0
    if 'flags' in meter:
        meter_flags = meter['flags']
        if not isinstance(meter_flags, list):
            meter_flags = [meter_flags]
        for flag in meter_flags:
            t = UTIL.ofp_meter_flags_from_user(flag)
            f = t if t != flag else None
            if f is None:
                LOG.error('Unknown meter flag: %s', flag)
                continue
            flags |= f

    meter_id = UTIL.ofp_meter_from_user(meter.get('meter_id', 0))

    bands = []
    for band in meter.get('bands', []):
        band_type = band.get('type')
        rate = str_to_int(band.get('rate', 0))
        burst_size = str_to_int(band.get('burst_size', 0))
        if band_type == 'DROP':
            bands.append(
                dp.ofproto_parser.OFPMeterBandDrop(rate, burst_size))
        elif band_type == 'DSCP_REMARK':
            prec_level = str_to_int(band.get('prec_level', 0))
            bands.append(
                dp.ofproto_parser.OFPMeterBandDscpRemark(
                    rate, burst_size, prec_level))
        elif band_type == 'EXPERIMENTER':
            experimenter = str_to_int(band.get('experimenter', 0))
            bands.append(
                dp.ofproto_parser.OFPMeterBandExperimenter(
                    rate, burst_size, experimenter))
        else:
            LOG.error('Unknown band type: %s', band_type)

    meter_mod = dp.ofproto_parser.OFPMeterMod(
        dp, cmd, flags, meter_id, bands)

    ofctl_utils.send_msg(dp, meter_mod, LOG)

def mod_flow_entry(dp, flow, cmd):
    cookie = int(flow.get('cookie', 0))
    cookie_mask = int(flow.get('cookie_mask', 0))
    table_id = UTIL.ofp_table_from_user(flow.get('table_id', 0))
    idle_timeout = int(flow.get('idle_timeout', 0))
    hard_timeout = int(flow.get('hard_timeout', 0))
    priority = int(flow.get('priority', 0))
    buffer_id = UTIL.ofp_buffer_from_user(
        flow.get('buffer_id', dp.ofproto.OFP_NO_BUFFER))
    out_port = UTIL.ofp_port_from_user(
        flow.get('out_port', dp.ofproto.OFPP_ANY))
    out_group = UTIL.ofp_group_from_user(
        flow.get('out_group', dp.ofproto.OFPG_ANY))
    flags = int(flow.get('flags', 0))
    match = to_match(dp, flow.get('match', {}))
    inst = to_actions(dp, flow.get('actions', []))

    flow_mod = dp.ofproto_parser.OFPFlowMod(
        dp, cookie, cookie_mask, table_id, cmd, idle_timeout,
        hard_timeout, priority, buffer_id, out_port, out_group,
        flags, match, inst)

    ofctl_utils.send_msg(dp, flow_mod, LOG)

def mod_flow_entry(dp, flow, cmd):
    cookie = int(flow.get('cookie', 0))
    priority = int(flow.get('priority',
                            dp.ofproto.OFP_DEFAULT_PRIORITY))
    buffer_id = UTIL.ofp_buffer_from_user(
        flow.get('buffer_id', dp.ofproto.OFP_NO_BUFFER))
    out_port = UTIL.ofp_port_from_user(
        flow.get('out_port', dp.ofproto.OFPP_NONE))
    flags = int(flow.get('flags', 0))
    idle_timeout = int(flow.get('idle_timeout', 0))
    hard_timeout = int(flow.get('hard_timeout', 0))
    actions = to_actions(dp, flow.get('actions', []))
    match = to_match(dp, flow.get('match', {}))

    flow_mod = dp.ofproto_parser.OFPFlowMod(
        datapath=dp, match=match, cookie=cookie,
        command=cmd, idle_timeout=idle_timeout,
        hard_timeout=hard_timeout, priority=priority,
        buffer_id=buffer_id, out_port=out_port,
        flags=flags,
        actions=actions)

    ofctl_utils.send_msg(dp, flow_mod, LOG)

def mod_meter_entry(dp, meter, cmd):
    flags = 0
    if "flags" in meter:
        meter_flags = meter["flags"]
        if not isinstance(meter_flags, list):
            meter_flags = [meter_flags]
        for flag in meter_flags:
            t = UTIL.ofp_meter_flags_from_user(flag)
            f = t if t != flag else None
            if f is None:
                LOG.error("Unknown meter flag: %s", flag)
                continue
            flags |= f

    meter_id = UTIL.ofp_meter_from_user(meter.get("meter_id", 0))

    bands = []
    for band in meter.get("bands", []):
        band_type = band.get("type")
        rate = int(band.get("rate", 0))
        burst_size = int(band.get("burst_size", 0))
        if band_type == "DROP":
            b = dp.ofproto_parser.OFPMeterBandDrop(rate, burst_size)
        elif band_type == "DSCP_REMARK":
            prec_level = int(band.get("prec_level", 0))
            b = dp.ofproto_parser.OFPMeterBandDscpRemark(rate, burst_size, prec_level)
        elif band_type == "EXPERIMENTER":
            experimenter = int(band.get("experimenter", 0))
            b = dp.ofproto_parser.OFPMeterBandExperimenter(rate, burst_size, experimenter)
        else:
            LOG.error("Unknown band type: %s", band_type)
            continue
        bands.append(b)

    meter_mod = dp.ofproto_parser.OFPMeterMod(dp, cmd, flags, meter_id, bands)

    ofctl_utils.send_msg(dp, meter_mod, LOG)

def mod_group_entry(dp, group, cmd):
    ofp = dp.ofproto
    parser = dp.ofproto_parser

    group_type = str(group.get('type', 'ALL'))
    t = UTIL.ofp_group_type_from_user(group_type)
    group_type = t if t != group_type else None
    if group_type is None:
        LOG.error('Unknown group type: %s', group.get('type'))

    group_id = UTIL.ofp_group_from_user(group.get('group_id', 0))
    command_bucket_id = int(group.get('command_bucket_id', 0))

    # Note:
    # The list of group property types that are currently defined
    # are only OFPGPT_EXPERIMENTER(Experimenter defined).
    properties = []

    buckets = []
    for bucket in group.get('buckets', []):

        # get bucket_id in buckets
        bucket_id = int(bucket.get('bucket_id', 0))

        # get actions in buckets
        bucket_actions = []
        for dic in bucket.get('actions', []):
            action = to_action(dp, dic)
            if action is not None:
                bucket_actions.append(action)

        # get properties in buckets
        bucket_properties = []
        for p in bucket.get('properties', []):
            group_bp_type = str(p.get('type', 'WEIGHT'))
            t = UTIL.ofp_group_bucket_prop_type_from_user(group_bp_type)
            group_bp_type = t if t != group_bp_type else ofp.OFPGBPT_WEIGHT

            if group_bp_type == ofp.OFPGBPT_WEIGHT:
                weight = int(p.get('weight', 0))
                bucket_properties.append(
                    parser.OFPGroupBucketPropWeight(
                        type_=group_bp_type, weight=weight))
            elif group_bp_type == ofp.OFPGBPT_WATCH_PORT:
                watch_port = int(p.get('watch', dp.ofproto.OFPP_ANY))
                bucket_properties.append(
                    parser.OFPGroupBucketPropWatch(
                        type_=group_bp_type, watch=watch_port))
            elif group_bp_type == ofp.OFPGBPT_WATCH_GROUP:
                watch_group = int(p.get('watch', dp.ofproto.OFPG_ANY))
                bucket_properties.append(
                    parser.OFPGroupBucketPropWatch(
                        type_=group_bp_type, watch=watch_group))
            elif group_bp_type == ofp.OFPGBPT_EXPERIMENTER:
                experimenter = p.get('experimenter', 0)
                exp_type = p.get('exp_type', 0)
                data_type = p.get('data_type', 'ascii')
                if data_type not in ['ascii', 'base64']:
                    LOG.error('Unknown data type: %s', data_type)
                data = p.get('data', '')
                if data_type == 'base64':
                    data = base64.b64decode(data)
                bucket_properties.append(
                    parser.OFPGroupBucketPropExperimenter(
                        type_=group_bp_type, experimenter=experimenter,
                        exp_type=exp_type, data=data))
            else:
                LOG.error('Unknown group bucket prop type: %s', p['type'])

        # create bucket
        bucket = parser.OFPBucket(bucket_id=bucket_id,
                                  actions=bucket_actions,
                                  properties=bucket_properties)
        buckets.append(bucket)

    group_mod = parser.OFPGroupMod(dp, cmd, group_type, group_id,
                                   command_bucket_id, buckets,
                                   properties)

    ofctl_utils.send_msg(dp, group_mod, LOG)

def set_role(dp, role):
    r = UTIL.ofp_role_from_user(role.get('role', dp.ofproto.OFPCR_ROLE_EQUAL))
    role_request = dp.ofproto_parser.OFPRoleRequest(dp, r, 0)
    ofctl_utils.send_msg(dp, role_request, LOG)