Пример #1
0
def build_ofclasses(version):
    blacklist = ["of_action", "of_action_header", "of_header", "of_queue_prop",
                 "of_queue_prop_header", "of_experimenter", "of_action_experimenter",
                 "of_oxm", "of_oxm_header", "of_oxm_experimenter_header",
                 "of_hello_elem", "of_hello_elem_header"]
    ofclasses = []
    for cls in of_g.standard_class_order:
        if version not in of_g.unified[cls] or cls in blacklist:
            continue
        unified_class = util.lookup_unified_class(cls, version)

        # Name for the generated Python class
        if utils.class_is_action(cls):
            pyname = cls[10:]
        elif utils.class_is_oxm(cls):
            pyname = cls[7:]
        else:
            pyname = cls[3:]

        type_values = get_type_values(cls, version)
        members = []

        length_member = None
        type_members = []
        pad_count = 0

        for member in unified_class['members']:
            if member['name'] in ['length', 'len']:
                length_member = LengthMember(name=member['name'],
                                             offset=member['offset'],
                                             oftype=oftype.OFType(member['m_type'], version))
            elif member['name'] in type_values:
                type_members.append(TypeMember(name=member['name'],
                                               offset=member['offset'],
                                               oftype=oftype.OFType(member['m_type'], version),
                                               value=type_values[member['name']]))
            else:
                # HACK ensure member names are unique
                if member['name'].startswith("pad"):
                    if pad_count == 0:
                        m_name = 'pad'
                    else:
                        m_name = "pad%d" % pad_count
                    pad_count += 1
                else:
                    m_name = member['name']
                members.append(Member(name=m_name,
                                      oftype=oftype.OFType(member['m_type'], version),
                                      offset=member['offset'],
                                      skip=member['name'] in of_g.skip_members))

        ofclasses.append(
            OFClass(name=cls,
                    pyname=pyname,
                    members=members,
                    length_member=length_member,
                    type_members=type_members,
                    min_length=of_g.base_length[(cls, version)],
                    is_fixed_length=(cls, version) in of_g.is_fixed_length))
    return ofclasses
Пример #2
0
def build_ofclasses(version):
    blacklist = ["of_action", "of_action_header", "of_header", "of_queue_prop",
                 "of_queue_prop_header", "of_experimenter", "of_action_experimenter",
                 "of_oxm", "of_oxm_header", "of_oxm_experimenter_header",
                 "of_hello_elem", "of_hello_elem_header"]
    ofclasses = []
    for cls in of_g.standard_class_order:
        if type_maps.class_is_virtual(cls):
            continue
        if version not in of_g.unified[cls] or cls in blacklist:
            continue
        unified_class = util.lookup_unified_class(cls, version)

        # Name for the generated Python class
        if utils.class_is_action(cls):
            pyname = cls[10:]
        elif utils.class_is_oxm(cls):
            pyname = cls[7:]
        elif utils.class_is_meter_band(cls):
            pyname = cls[14:]
        elif utils.class_is_instruction(cls):
            pyname = cls[15:]
        else:
            pyname = cls[3:]

        type_values = get_type_values(cls, version)
        members = []
        type_members = []

        pad_count = 0

        for member in unified_class['members']:
            if member['name'] in ['length', 'len']:
                members.append(LengthMember(name=member['name'],
                                            oftype=oftype.OFType(member['m_type'], version)))
            elif (cls, version, member['name']) in field_length_members:
                field_name = field_length_members[(cls, version, member['name'])]
                members.append(FieldLengthMember(name=member['name'],
                                                 oftype=oftype.OFType(member['m_type'], version),
                                                 field_name=field_name))
            elif member['name'] in type_values:
                members.append(TypeMember(name=member['name'],
                                          oftype=oftype.OFType(member['m_type'], version),
                                          value=type_values[member['name']]))
                type_members.append(members[-1])
            elif member['name'].startswith("pad"):
                # HACK this should be moved to the frontend
                pad_oftype = oftype.OFType(member['m_type'], version)
                length = struct.calcsize("!" + pad_oftype._pack_fmt())
                if pad_oftype.is_array: length *= pad_oftype.array_length
                members.append(PadMember(length=length))
            else:
                members.append(Member(name=member['name'],
                                      oftype=oftype.OFType(member['m_type'], version)))

        ofclasses.append(
            OFClass(name=cls,
                    pyname=pyname,
                    members=members,
                    type_members=type_members,
                    min_length=of_g.base_length[(cls, version)],
                    is_fixed_length=(cls, version) in of_g.is_fixed_length))
    return ofclasses
Пример #3
0
def build_ofclasses(version):
    blacklist = [
        "of_action",
        "of_action_header",
        "of_header",
        "of_queue_prop",
        "of_queue_prop_header",
        "of_experimenter",
        "of_action_experimenter",
    ]
    ofclasses = []
    for cls in of_g.standard_class_order:
        if version not in of_g.unified[cls] or cls in blacklist:
            continue
        unified_class = util.lookup_unified_class(cls, version)

        # Name for the generated Python class
        if utils.class_is_action(cls):
            pyname = cls[10:]
        else:
            pyname = cls[3:]

        type_values = get_type_values(cls, version)
        members = []

        length_member = None
        type_members = []

        for member in unified_class["members"]:
            if member["name"] in ["length", "len"]:
                length_member = LengthMember(
                    name=member["name"], offset=member["offset"], oftype=oftype.OFType(member["m_type"], version)
                )
            elif member["name"] in type_values:
                type_members.append(
                    TypeMember(
                        name=member["name"],
                        offset=member["offset"],
                        oftype=oftype.OFType(member["m_type"], version),
                        value=type_values[member["name"]],
                    )
                )
            else:
                # HACK ensure member names are unique
                if member["name"] == "pad" and [x for x in members if x.name == "pad"]:
                    m_name = "pad2"
                else:
                    m_name = member["name"]
                members.append(
                    Member(
                        name=m_name,
                        oftype=oftype.OFType(member["m_type"], version),
                        offset=member["offset"],
                        skip=member["name"] in of_g.skip_members,
                    )
                )

        ofclasses.append(
            OFClass(
                name=cls,
                pyname=pyname,
                members=members,
                length_member=length_member,
                type_members=type_members,
                min_length=of_g.base_length[(cls, version)],
                is_fixed_length=(cls, version) in of_g.is_fixed_length,
            )
        )
    return ofclasses