def gen_type_to_object_id(out, type_str, prefix, template, value_array, max_val):
"""
Generate C maps from various message class groups to object ids
For each version, create an array mapping the type info to the
object ID. Then define an array containing those pointers.
"""
# Create unified arrays and get length
arr_len = type_maps.type_array_len(value_array, max_val)
all_ars = []
for version, val_dict in value_array.items(): # Per version dict
ar = type_maps.dict_to_array(val_dict, max_val, type_maps.invalid_type)
all_ars.append(ar)
len_name = "%s_ITEM_COUNT" % prefix
for i, ar in enumerate(all_ars):
version = i + 1
out.write("static const of_object_id_t\nof_%s_v%d[%s] = {\n" % (type_str, version, len_name))
for i in range(arr_len):
comma = ""
if i < arr_len - 1: # Avoid ultimate comma
comma = ","
# Per-version length check
if i < len(ar):
v = ar[i]
else:
v = type_maps.invalid_type
if v == type_maps.invalid_type:
out.write(" %-30s /* %d (Invalid) */\n" % ("OF_OBJECT_INVALID" + comma, i))
else:
name = (template % v.upper()) + comma
out.write(" %-30s /* %d */\n" % (name, i))
out.write("};\n")
out.write(
"""
/**
* Maps from %(c_name)s wire type values to LOCI object ids
*
* Indexed by wire version which is 1-based.
*/
const of_object_id_t *const of_%(name)s[OF_VERSION_ARRAY_MAX] = {
NULL,
"""
% dict(name=type_str, c_name=prefix.lower())
)
for version in of_g.of_version_range:
out.write(" of_%(name)s_v%(version)d,\n" % dict(name=type_str, version=version))
out.write(
"""
};
"""
% dict(name=type_str, u_name=type_str.upper(), max_val=max_val, c_name=prefix.lower())
)
def gen_type_to_object_id(out, type_str, prefix, template,
value_array, max_val):
"""
Generate C maps from various message class groups to object ids
For each version, create an array mapping the type info to the
object ID. Then define an array containing those pointers.
"""
# Create unified arrays and get length
arr_len = type_maps.type_array_len(value_array, max_val)
all_ars = []
for version, val_dict in value_array.items(): # Per version dict
ar = type_maps.dict_to_array(val_dict, max_val, type_maps.invalid_type)
all_ars.append(ar)
len_name = "%s_ITEM_COUNT" % prefix
for i, ar in enumerate(all_ars):
version = i + 1
out.write("static const of_object_id_t\nof_%s_v%d[%s] = {\n" %
(type_str, version, len_name))
for i in range(arr_len):
comma = ""
if i < arr_len - 1: # Avoid ultimate comma
comma = ","
# Per-version length check
if i < len(ar):
v = ar[i]
else:
v = type_maps.invalid_type
if v == type_maps.invalid_type:
out.write(" %-30s /* %d (Invalid) */\n" %
("OF_OBJECT_INVALID" + comma, i))
else:
name = (template % v.upper()) + comma
out.write(" %-30s /* %d */\n" % (name, i))
out.write("};\n")
out.write("""
/**
* Maps from %(c_name)s wire type values to LOCI object ids
*
* Indexed by wire version which is 1-based.
*/
const of_object_id_t *const of_%(name)s[OF_VERSION_ARRAY_MAX] = {
NULL,
""" % dict(name=type_str, c_name=prefix.lower()))
for version in of_g.of_version_range:
out.write(" of_%(name)s_v%(version)d,\n" % dict(name=type_str,
version=version))
out.write("""
};
""" % dict(name=type_str, u_name=type_str.upper(),
max_val=max_val, c_name=prefix.lower()))
def gen_type_to_obj_map_functions(out):
"""
Generate the templated type map functions
@param out The file handle to write to
"""
################################################################
# Generate all type-to-object-ID maps in a common way
################################################################
map_template = """
/**
* %(name)s wire type to object ID array.
* Treat as private; use function accessor below
*/
extern const of_object_id_t *const of_%(name)s_type_to_id[OF_VERSION_ARRAY_MAX];
#define OF_%(u_name)s_ITEM_COUNT %(ar_len)d\n
/**
* Map an %(name)s wire value to an OF object
* @param %(name)s The %(name)s type wire value
* @param version The version associated with the check
* @return The %(name)s OF object type
* @return OF_OBJECT_INVALID if type does not map to an object
*
*/
of_object_id_t
of_%(name)s_to_object_id(int %(name)s, of_version_t version)
{
if (!OF_VERSION_OKAY(version)) {
return OF_OBJECT_INVALID;
}
if (%(name)s < 0 || %(name)s >= OF_%(u_name)s_ITEM_COUNT) {
return OF_OBJECT_INVALID;
}
return of_%(name)s_type_to_id[version][%(name)s];
}
"""
map_with_experimenter_template = """
/**
* %(name)s wire type to object ID array.
* Treat as private; use function accessor below
*/
extern const of_object_id_t *const of_%(name)s_type_to_id[OF_VERSION_ARRAY_MAX];
#define OF_%(u_name)s_ITEM_COUNT %(ar_len)d\n
/**
* Map an %(name)s wire value to an OF object
* @param %(name)s The %(name)s type wire value
* @param version The version associated with the check
* @return The %(name)s OF object type
* @return OF_OBJECT_INVALID if type does not map to an object
*
*/
of_object_id_t
of_%(name)s_to_object_id(int %(name)s, of_version_t version)
{
if (!OF_VERSION_OKAY(version)) {
return OF_OBJECT_INVALID;
}
if (%(name)s == OF_EXPERIMENTER_TYPE) {
return OF_%(u_name)s_EXPERIMENTER;
}
if (%(name)s < 0 || %(name)s >= OF_%(u_name)s_ITEM_COUNT) {
return OF_OBJECT_INVALID;
}
return of_%(name)s_type_to_id[version][%(name)s];
}
"""
table_features_prop_template = """
/**
* %(name)s wire type to object ID array.
* Treat as private; use function accessor below
*/
extern const of_object_id_t *const of_%(name)s_type_to_id[OF_VERSION_ARRAY_MAX];
#define OF_%(u_name)s_ITEM_COUNT %(ar_len)d\n
/**
* Map an %(name)s wire value to an OF object
* @param %(name)s The %(name)s type wire value
* @param version The version associated with the check
* @return The %(name)s OF object type
* @return OF_OBJECT_INVALID if type does not map to an object
*
*/
of_object_id_t
of_%(name)s_to_object_id(int %(name)s, of_version_t version)
{
if (!OF_VERSION_OKAY(version)) {
return OF_OBJECT_INVALID;
}
if (%(name)s == 0xfffe) {
return OF_%(u_name)s_EXPERIMENTER;
}
if (%(name)s == 0xffff) {
return OF_%(u_name)s_EXPERIMENTER_MISS;
}
if (%(name)s < 0 || %(name)s >= OF_%(u_name)s_ITEM_COUNT) {
return OF_OBJECT_INVALID;
}
return of_%(name)s_type_to_id[version][%(name)s];
}
"""
stats_template = """
/**
* %(name)s wire type to object ID array.
* Treat as private; use function accessor below
*/
extern const of_object_id_t *const of_%(name)s_type_to_id[OF_VERSION_ARRAY_MAX];
#define OF_%(u_name)s_ITEM_COUNT %(ar_len)d\n
/**
* Map an %(name)s wire value to an OF object
* @param %(name)s The %(name)s type wire value
* @param version The version associated with the check
* @return The %(name)s OF object type
* @return OF_OBJECT_INVALID if type does not map to an object
*
*/
of_object_id_t
of_%(name)s_to_object_id(int %(name)s, of_version_t version)
{
if (!OF_VERSION_OKAY(version)) {
return OF_OBJECT_INVALID;
}
if (%(name)s == OF_EXPERIMENTER_TYPE) {
return OF_EXPERIMENTER_%(u_name)s;
}
if (%(name)s < 0 || %(name)s >= OF_%(u_name)s_ITEM_COUNT) {
return OF_OBJECT_INVALID;
}
return of_%(name)s_type_to_id[version][%(name)s];
}
"""
error_msg_template = """
/**
* %(name)s wire type to object ID array.
* Treat as private; use function accessor below
*/
extern const of_object_id_t *const of_%(name)s_type_to_id[OF_VERSION_ARRAY_MAX];
#define OF_%(u_name)s_ITEM_COUNT %(ar_len)d\n
/**
* Map an %(name)s wire value to an OF object
* @param %(name)s The %(name)s type wire value
* @param version The version associated with the check
* @return The %(name)s OF object type
* @return OF_OBJECT_INVALID if type does not map to an object
*
*/
of_object_id_t
of_error_msg_to_object_id(uint16_t %(name)s, of_version_t version)
{
if (!OF_VERSION_OKAY(version)) {
return OF_OBJECT_INVALID;
}
if (%(name)s == OF_EXPERIMENTER_TYPE) {
return OF_EXPERIMENTER_ERROR_MSG;
}
if (%(name)s < 0 || %(name)s >= OF_%(u_name)s_ITEM_COUNT) {
return OF_OBJECT_INVALID;
}
return of_%(name)s_type_to_id[version][%(name)s];
}
"""
# Experimenter mapping functions
# Currently we support very few candidates, so we just do a
# list of if/elses
experimenter_function = """
/**
* @brief Map a message known to be an exp msg to the proper object
*
* Assume that the message is a vendor/experimenter message. Determine
* the specific object type for the message.
* @param msg An OF message object (uint8_t *)
* @param length The number of bytes in the message (for error checking)
* @param version Version of message
* @returns object ID of specific type if recognized or OF_EXPERIMENTER if not
*
* @todo put OF_EXPERIMENTER_<name> in loci_base.h
*/
of_object_id_t
of_message_experimenter_to_object_id(of_message_t msg, of_version_t version) {
uint32_t experimenter_id;
uint32_t subtype;
/* Extract experimenter and subtype value; look for match from type maps */
experimenter_id = of_message_experimenter_id_get(msg);
subtype = of_message_experimenter_subtype_get(msg);
/* Do a simple if/else search for the ver, experimenter and subtype */
"""
first = True
for version, experimenter_lists in type_maps.extension_message_subtype.items():
for exp, subtypes in experimenter_lists.items():
experimenter_function += """
if ((experimenter_id == OF_EXPERIMENTER_ID_%(exp_name)s) &&
(version == %(ver_name)s)) {
""" % dict(exp_name=exp.upper(), ver_name=of_g.wire_ver_map[version])
for ext_msg, subtype in subtypes.items():
experimenter_function += """
if (subtype == %(subtype)s) {
return %(ext_msg)s;
}
""" % dict(subtype=subtype, ext_msg=ext_msg.upper())
experimenter_function += """
}
"""
experimenter_function += """
return OF_EXPERIMENTER;
}
"""
# Message need different handling
msg_template = """
/**
* %(name)s wire type to object ID array.
* Treat as private; use function accessor below
*/
extern const of_object_id_t *const of_%(name)s_type_to_id[OF_VERSION_ARRAY_MAX];
#define OF_%(u_name)s_ITEM_COUNT %(ar_len)d\n
/**
* Extract the type info from the message and determine its object type
* @param msg An OF message object (uint8_t *)
* @param length The number of bytes in the message (for error checking)
* @returns object ID or OF_OBJECT_INVALID if parse error
*/
of_object_id_t
of_message_to_object_id(of_message_t msg, int length) {
uint8_t type;
of_version_t ver;
of_object_id_t obj_id;
uint16_t stats_type;
uint16_t err_type;
uint8_t flow_mod_cmd;
uint32_t experimenter, subtype;
uint16_t group_mod_cmd;
if (length < OF_MESSAGE_MIN_LENGTH) {
return OF_OBJECT_INVALID;
}
type = of_message_type_get(msg);
ver = of_message_version_get(msg);
if (!OF_VERSION_OKAY(ver)) {
return OF_OBJECT_INVALID;
}
if (type >= OF_MESSAGE_ITEM_COUNT) {
return OF_OBJECT_INVALID;
}
obj_id = of_message_type_to_id[ver][type];
/* Remap to specific message if known */
if (obj_id == OF_EXPERIMENTER) {
if (length < OF_MESSAGE_EXPERIMENTER_MIN_LENGTH) {
return OF_OBJECT_INVALID;
}
return of_message_experimenter_to_object_id(msg, ver);
}
/* Remap to add/delete/strict version */
if (obj_id == OF_FLOW_MOD) {
if (length < OF_MESSAGE_MIN_FLOW_MOD_LENGTH(ver)) {
return OF_OBJECT_INVALID;
}
flow_mod_cmd = of_message_flow_mod_command_get(msg, ver);
obj_id = of_flow_mod_to_object_id(flow_mod_cmd, ver);
}
if ((obj_id == OF_STATS_REQUEST) || (obj_id == OF_STATS_REPLY)) {
if (length < OF_MESSAGE_MIN_STATS_LENGTH) {
return OF_OBJECT_INVALID;
}
stats_type = of_message_stats_type_get(msg);
if (stats_type == OF_STATS_TYPE_EXPERIMENTER) {
if (length < OF_MESSAGE_STATS_EXPERIMENTER_MIN_LENGTH) {
return OF_OBJECT_INVALID;
}
experimenter = of_message_stats_experimenter_id_get(msg);
subtype = of_message_stats_experimenter_subtype_get(msg);
if (obj_id == OF_STATS_REQUEST) {
obj_id = of_experimenter_stats_request_to_object_id(experimenter, subtype, ver);
} else {
obj_id = of_experimenter_stats_reply_to_object_id(experimenter, subtype, ver);
}
} else {
if (obj_id == OF_STATS_REQUEST) {
obj_id = of_stats_request_to_object_id(stats_type, ver);
} else {
obj_id = of_stats_reply_to_object_id(stats_type, ver);
}
}
}
if (obj_id == OF_ERROR_MSG) {
if (length < OF_MESSAGE_MIN_ERROR_LENGTH) {
return OF_OBJECT_INVALID;
}
err_type = of_message_error_type_get(msg);
obj_id = of_error_msg_to_object_id(err_type, ver);
}
if (obj_id == OF_GROUP_MOD) {
if (length < OF_MESSAGE_MIN_GROUP_MOD_LENGTH) {
return OF_OBJECT_INVALID;
}
group_mod_cmd = of_message_group_mod_command_get(msg);
obj_id = of_group_mod_to_object_id(group_mod_cmd, ver);
}
return obj_id;
}
"""
oxm_template = """
/**
* oxm wire type to object ID array.
* Treat as private; use function accessor below
*/
extern const of_object_id_t *const of_oxm_type_to_id[OF_VERSION_ARRAY_MAX];
#define OF_OXM_ITEM_COUNT %(ar_len)d\n
/**
* Map an oxm wire value to an OF object
* @param oxm The oxm type wire value
* @param version The version associated with the check
* @return The oxm OF object type
* @return OF_OBJECT_INVALID if type does not map to an object
*
*/
of_object_id_t
of_oxm_to_object_id(uint32_t type_len, of_version_t version)
{
if (!OF_VERSION_OKAY(version)) {
return OF_OBJECT_INVALID;
}
uint16_t class = (type_len >> 16) & 0xffff;
uint8_t masked_type = (type_len >> 8) & 0xff;
if (class == 0x8000) {
if (masked_type < 0 || masked_type >= OF_OXM_ITEM_COUNT) {
return OF_OBJECT_INVALID;
}
return of_oxm_type_to_id[version][masked_type];
} else if (class == 0x0003) {
switch (masked_type) {
case 0x00: return OF_OXM_BSN_IN_PORTS_128;
case 0x01: return OF_OXM_BSN_IN_PORTS_128_MASKED;
case 0x02: return OF_OXM_BSN_LAG_ID;
case 0x03: return OF_OXM_BSN_LAG_ID_MASKED;
case 0x04: return OF_OXM_BSN_VRF;
case 0x05: return OF_OXM_BSN_VRF_MASKED;
case 0x06: return OF_OXM_BSN_GLOBAL_VRF_ALLOWED;
case 0x07: return OF_OXM_BSN_GLOBAL_VRF_ALLOWED_MASKED;
case 0x08: return OF_OXM_BSN_L3_INTERFACE_CLASS_ID;
case 0x09: return OF_OXM_BSN_L3_INTERFACE_CLASS_ID_MASKED;
case 0x0a: return OF_OXM_BSN_L3_SRC_CLASS_ID;
case 0x0b: return OF_OXM_BSN_L3_SRC_CLASS_ID_MASKED;
case 0x0c: return OF_OXM_BSN_L3_DST_CLASS_ID;
case 0x0d: return OF_OXM_BSN_L3_DST_CLASS_ID_MASKED;
default: return OF_OBJECT_INVALID;
}
} else {
return OF_OBJECT_INVALID;
}
}
"""
# Action types array gen
ar_len = type_maps.type_array_len(type_maps.action_types, max_type_value)
out.write(map_with_experimenter_template %
dict(name="action", u_name="ACTION", ar_len=ar_len))
# Action ID types array gen
ar_len = type_maps.type_array_len(type_maps.action_id_types, max_type_value)
out.write(map_with_experimenter_template %
dict(name="action_id", u_name="ACTION_ID", ar_len=ar_len))
# Instruction types array gen
ar_len = type_maps.type_array_len(type_maps.instruction_types,
max_type_value)
out.write(map_with_experimenter_template %
dict(name="instruction", u_name="INSTRUCTION", ar_len=ar_len))
# Instruction ID types array gen
ar_len = type_maps.type_array_len(type_maps.instruction_id_types, max_type_value)
out.write(map_with_experimenter_template %
dict(name="instruction_id", u_name="INSTRUCTION_ID", ar_len=ar_len))
# Queue prop types array gen
ar_len = type_maps.type_array_len(type_maps.queue_prop_types,
max_type_value)
out.write(map_with_experimenter_template %
dict(name="queue_prop", u_name="QUEUE_PROP", ar_len=ar_len))
# Table feature prop types array gen
ar_len = type_maps.type_array_len(type_maps.table_feature_prop_types,
max_type_value)
out.write(table_features_prop_template %
dict(name="table_feature_prop", u_name="TABLE_FEATURE_PROP",
ar_len=ar_len))
# Meter band types array gen
ar_len = type_maps.type_array_len(type_maps.meter_band_types,
max_type_value)
out.write(map_with_experimenter_template %
dict(name="meter_band", u_name="METER_BAND", ar_len=ar_len))
# Hello elem types array gen
ar_len = type_maps.type_array_len(type_maps.hello_elem_types,
max_type_value)
out.write(map_template %
dict(name="hello_elem", u_name="HELLO_ELEM", ar_len=ar_len))
# Stats types array gen
ar_len = type_maps.type_array_len(type_maps.stats_types,
max_type_value)
out.write(stats_template %
dict(name="stats_reply", u_name="STATS_REPLY", ar_len=ar_len))
out.write(stats_template %
dict(name="stats_request", u_name="STATS_REQUEST",
ar_len=ar_len))
ar_len = type_maps.type_array_len(type_maps.error_types,
max_type_value)
out.write(error_msg_template %
dict(name="error_msg", u_name="ERROR_MSG", ar_len=ar_len))
# out.write(error_msg_function)
ar_len = type_maps.type_array_len(type_maps.flow_mod_types, max_type_value)
out.write(map_template %
dict(name="flow_mod", u_name="FLOW_MOD", ar_len=ar_len))
ar_len = type_maps.type_array_len(type_maps.group_mod_types,
max_type_value)
out.write(map_template %
dict(name="group_mod", u_name="GROUP_MOD", ar_len=ar_len))
# OXM
ar_len = type_maps.type_array_len(type_maps.oxm_types, max_type_value)
out.write("""
/* NOTE: We could optimize the OXM and only generate OF 1.2 versions. */
""")
out.write(oxm_template % dict(ar_len=ar_len))
# Messages
out.write(experimenter_function)
# Must follow stats reply/request
ar_len = type_maps.type_array_len(type_maps.message_types, max_type_value)
out.write(msg_template %
dict(name="message", u_name="MESSAGE", ar_len=ar_len))
# BSN TLV elem types array gen
ar_len = type_maps.type_array_len(type_maps.bsn_tlv_types,
max_type_value)
out.write(map_template %
dict(name="bsn_tlv", u_name="BSN_TLV", ar_len=ar_len))
def gen_type_to_obj_map_functions(out):
"""
Generate the templated type map functions
@param out The file handle to write to
"""
################################################################
# Generate all type-to-object-ID maps in a common way
################################################################
map_template = """
/**
* %(name)s wire type to object ID array.
* Treat as private; use function accessor below
*/
extern const of_object_id_t *const of_%(name)s_type_to_id[OF_VERSION_ARRAY_MAX];
#define OF_%(u_name)s_ITEM_COUNT %(ar_len)d\n
/**
* Map an %(name)s wire value to an OF object
* @param %(name)s The %(name)s type wire value
* @param version The version associated with the check
* @return The %(name)s OF object type
* @return OF_OBJECT_INVALID if type does not map to an object
*
*/
of_object_id_t
of_%(name)s_to_object_id(int %(name)s, of_version_t version)
{
if (!OF_VERSION_OKAY(version)) {
return OF_OBJECT_INVALID;
}
if (%(name)s < 0 || %(name)s >= OF_%(u_name)s_ITEM_COUNT) {
return OF_OBJECT_INVALID;
}
return of_%(name)s_type_to_id[version][%(name)s];
}
"""
map_with_experimenter_template = """
/**
* %(name)s wire type to object ID array.
* Treat as private; use function accessor below
*/
extern const of_object_id_t *const of_%(name)s_type_to_id[OF_VERSION_ARRAY_MAX];
#define OF_%(u_name)s_ITEM_COUNT %(ar_len)d\n
/**
* Map an %(name)s wire value to an OF object
* @param %(name)s The %(name)s type wire value
* @param version The version associated with the check
* @return The %(name)s OF object type
* @return OF_OBJECT_INVALID if type does not map to an object
*
*/
of_object_id_t
of_%(name)s_to_object_id(int %(name)s, of_version_t version)
{
if (!OF_VERSION_OKAY(version)) {
return OF_OBJECT_INVALID;
}
if (%(name)s == OF_EXPERIMENTER_TYPE) {
return OF_%(u_name)s_EXPERIMENTER;
}
if (%(name)s < 0 || %(name)s >= OF_%(u_name)s_ITEM_COUNT) {
return OF_OBJECT_INVALID;
}
return of_%(name)s_type_to_id[version][%(name)s];
}
"""
table_features_prop_template = """
/**
* %(name)s wire type to object ID array.
* Treat as private; use function accessor below
*/
extern const of_object_id_t *const of_%(name)s_type_to_id[OF_VERSION_ARRAY_MAX];
#define OF_%(u_name)s_ITEM_COUNT %(ar_len)d\n
/**
* Map an %(name)s wire value to an OF object
* @param %(name)s The %(name)s type wire value
* @param version The version associated with the check
* @return The %(name)s OF object type
* @return OF_OBJECT_INVALID if type does not map to an object
*
*/
of_object_id_t
of_%(name)s_to_object_id(int %(name)s, of_version_t version)
{
if (!OF_VERSION_OKAY(version)) {
return OF_OBJECT_INVALID;
}
if (%(name)s == 0xfffe) {
return OF_%(u_name)s_EXPERIMENTER;
}
if (%(name)s == 0xffff) {
return OF_%(u_name)s_EXPERIMENTER_MISS;
}
if (%(name)s < 0 || %(name)s >= OF_%(u_name)s_ITEM_COUNT) {
return OF_OBJECT_INVALID;
}
return of_%(name)s_type_to_id[version][%(name)s];
}
"""
stats_template = """
/**
* %(name)s wire type to object ID array.
* Treat as private; use function accessor below
*/
extern const of_object_id_t *const of_%(name)s_type_to_id[OF_VERSION_ARRAY_MAX];
#define OF_%(u_name)s_ITEM_COUNT %(ar_len)d\n
/**
* Map an %(name)s wire value to an OF object
* @param %(name)s The %(name)s type wire value
* @param version The version associated with the check
* @return The %(name)s OF object type
* @return OF_OBJECT_INVALID if type does not map to an object
*
*/
of_object_id_t
of_%(name)s_to_object_id(int %(name)s, of_version_t version)
{
if (!OF_VERSION_OKAY(version)) {
return OF_OBJECT_INVALID;
}
if (%(name)s == OF_EXPERIMENTER_TYPE) {
return OF_EXPERIMENTER_%(u_name)s;
}
if (%(name)s < 0 || %(name)s >= OF_%(u_name)s_ITEM_COUNT) {
return OF_OBJECT_INVALID;
}
return of_%(name)s_type_to_id[version][%(name)s];
}
"""
error_msg_template = """
/**
* %(name)s wire type to object ID array.
* Treat as private; use function accessor below
*/
extern const of_object_id_t *const of_%(name)s_type_to_id[OF_VERSION_ARRAY_MAX];
#define OF_%(u_name)s_ITEM_COUNT %(ar_len)d\n
/**
* Map an %(name)s wire value to an OF object
* @param %(name)s The %(name)s type wire value
* @param version The version associated with the check
* @return The %(name)s OF object type
* @return OF_OBJECT_INVALID if type does not map to an object
*
*/
of_object_id_t
of_error_msg_to_object_id(uint16_t %(name)s, of_version_t version)
{
if (!OF_VERSION_OKAY(version)) {
return OF_OBJECT_INVALID;
}
if (%(name)s == OF_EXPERIMENTER_TYPE) {
return OF_EXPERIMENTER_ERROR_MSG;
}
if (%(name)s < 0 || %(name)s >= OF_%(u_name)s_ITEM_COUNT) {
return OF_OBJECT_INVALID;
}
return of_%(name)s_type_to_id[version][%(name)s];
}
"""
# Experimenter mapping functions
# Currently we support very few candidates, so we just do a
# list of if/elses
experimenter_function = """
/**
* @brief Map a message known to be an exp msg to the proper object
*
* Assume that the message is a vendor/experimenter message. Determine
* the specific object type for the message.
* @param msg An OF message object (uint8_t *)
* @param length The number of bytes in the message (for error checking)
* @param version Version of message
* @returns object ID of specific type if recognized or OF_EXPERIMENTER if not
*
* @todo put OF_EXPERIMENTER_<name> in loci_base.h
*/
of_object_id_t
of_message_experimenter_to_object_id(of_message_t msg, of_version_t version) {
uint32_t experimenter_id;
uint32_t subtype;
/* Extract experimenter and subtype value; look for match from type maps */
experimenter_id = of_message_experimenter_id_get(msg);
subtype = of_message_experimenter_subtype_get(msg);
/* Do a simple if/else search for the ver, experimenter and subtype */
"""
for version, experimenter_lists in type_maps.extension_message_subtype.items():
for exp, subtypes in experimenter_lists.items():
experimenter_function += """
if ((experimenter_id == OF_EXPERIMENTER_ID_%(exp_name)s) &&
(version == %(ver_name)s)) {
""" % dict(exp_name=exp.upper(), ver_name=of_g.wire_ver_map[version])
for ext_msg, subtype in subtypes.items():
experimenter_function += """
if (subtype == %(subtype)s) {
return %(ext_msg)s;
}
""" % dict(subtype=subtype, ext_msg=ext_msg.upper())
experimenter_function += """
}
"""
experimenter_function += """
return OF_EXPERIMENTER;
}
"""
# Message need different handling
msg_template = """
/**
* %(name)s wire type to object ID array.
* Treat as private; use function accessor below
*/
extern const of_object_id_t *const of_%(name)s_type_to_id[OF_VERSION_ARRAY_MAX];
#define OF_%(u_name)s_ITEM_COUNT %(ar_len)d\n
/**
* Extract the type info from the message and determine its object type
* @param msg An OF message object (uint8_t *)
* @param length The number of bytes in the message (for error checking)
* @returns object ID or OF_OBJECT_INVALID if parse error
*/
of_object_id_t
of_message_to_object_id(of_message_t msg, int length) {
uint8_t type;
of_version_t ver;
of_object_id_t obj_id;
uint16_t stats_type;
uint16_t err_type;
uint8_t flow_mod_cmd;
uint32_t experimenter, subtype;
uint16_t group_mod_cmd;
if (length < OF_MESSAGE_MIN_LENGTH) {
return OF_OBJECT_INVALID;
}
type = of_message_type_get(msg);
ver = of_message_version_get(msg);
if (!OF_VERSION_OKAY(ver)) {
return OF_OBJECT_INVALID;
}
if (type >= OF_MESSAGE_ITEM_COUNT) {
return OF_OBJECT_INVALID;
}
obj_id = of_message_type_to_id[ver][type];
/* Remap to specific message if known */
if (obj_id == OF_EXPERIMENTER) {
if (length < OF_MESSAGE_EXPERIMENTER_MIN_LENGTH) {
return OF_OBJECT_INVALID;
}
return of_message_experimenter_to_object_id(msg, ver);
}
/* Remap to add/delete/strict version */
if (obj_id == OF_FLOW_MOD) {
if (length < OF_MESSAGE_MIN_FLOW_MOD_LENGTH(ver)) {
return OF_OBJECT_INVALID;
}
flow_mod_cmd = of_message_flow_mod_command_get(msg, ver);
obj_id = of_flow_mod_to_object_id(flow_mod_cmd, ver);
}
if ((obj_id == OF_STATS_REQUEST) || (obj_id == OF_STATS_REPLY)) {
if (length < OF_MESSAGE_MIN_STATS_LENGTH) {
return OF_OBJECT_INVALID;
}
stats_type = of_message_stats_type_get(msg);
if (stats_type == OF_STATS_TYPE_EXPERIMENTER) {
if (length < OF_MESSAGE_STATS_EXPERIMENTER_MIN_LENGTH) {
return OF_OBJECT_INVALID;
}
experimenter = of_message_stats_experimenter_id_get(msg);
subtype = of_message_stats_experimenter_subtype_get(msg);
if (obj_id == OF_STATS_REQUEST) {
obj_id = of_experimenter_stats_request_to_object_id(experimenter, subtype, ver);
} else {
obj_id = of_experimenter_stats_reply_to_object_id(experimenter, subtype, ver);
}
} else {
if (obj_id == OF_STATS_REQUEST) {
obj_id = of_stats_request_to_object_id(stats_type, ver);
} else {
obj_id = of_stats_reply_to_object_id(stats_type, ver);
}
}
}
if (obj_id == OF_ERROR_MSG) {
if (length < OF_MESSAGE_MIN_ERROR_LENGTH) {
return OF_OBJECT_INVALID;
}
err_type = of_message_error_type_get(msg);
obj_id = of_error_msg_to_object_id(err_type, ver);
}
if (obj_id == OF_GROUP_MOD) {
if (length < OF_MESSAGE_MIN_GROUP_MOD_LENGTH) {
return OF_OBJECT_INVALID;
}
group_mod_cmd = of_message_group_mod_command_get(msg);
obj_id = of_group_mod_to_object_id(group_mod_cmd, ver);
}
return obj_id;
}
"""
oxm_template = """
/**
* oxm wire type to object ID array.
* Treat as private; use function accessor below
*/
extern const of_object_id_t *const of_oxm_type_to_id[OF_VERSION_ARRAY_MAX];
#define OF_OXM_ITEM_COUNT %(ar_len)d\n
/**
* Map an oxm wire value to an OF object
* @param oxm The oxm type wire value
* @param version The version associated with the check
* @return The oxm OF object type
* @return OF_OBJECT_INVALID if type does not map to an object
*
*/
of_object_id_t
of_oxm_to_object_id(uint32_t type_len, of_version_t version)
{
if (!OF_VERSION_OKAY(version)) {
return OF_OBJECT_INVALID;
}
uint16_t class = (type_len >> 16) & 0xffff;
uint8_t masked_type = (type_len >> 8) & 0xff;
if (class == 0x8000) {
if (masked_type < 0 || masked_type >= OF_OXM_ITEM_COUNT) {
return OF_OBJECT_INVALID;
}
return of_oxm_type_to_id[version][masked_type];
} else if (class == 0x0003) {
switch (masked_type) {
case 0x00: return OF_OXM_BSN_IN_PORTS_128;
case 0x01: return OF_OXM_BSN_IN_PORTS_128_MASKED;
case 0x02: return OF_OXM_BSN_LAG_ID;
case 0x03: return OF_OXM_BSN_LAG_ID_MASKED;
case 0x04: return OF_OXM_BSN_VRF;
case 0x05: return OF_OXM_BSN_VRF_MASKED;
case 0x06: return OF_OXM_BSN_GLOBAL_VRF_ALLOWED;
case 0x07: return OF_OXM_BSN_GLOBAL_VRF_ALLOWED_MASKED;
case 0x08: return OF_OXM_BSN_L3_INTERFACE_CLASS_ID;
case 0x09: return OF_OXM_BSN_L3_INTERFACE_CLASS_ID_MASKED;
case 0x0a: return OF_OXM_BSN_L3_SRC_CLASS_ID;
case 0x0b: return OF_OXM_BSN_L3_SRC_CLASS_ID_MASKED;
case 0x0c: return OF_OXM_BSN_L3_DST_CLASS_ID;
case 0x0d: return OF_OXM_BSN_L3_DST_CLASS_ID_MASKED;
case 0x10: return OF_OXM_BSN_UDF0;
case 0x11: return OF_OXM_BSN_UDF0_MASKED;
case 0x12: return OF_OXM_BSN_UDF1;
case 0x13: return OF_OXM_BSN_UDF1_MASKED;
case 0x14: return OF_OXM_BSN_UDF2;
case 0x15: return OF_OXM_BSN_UDF2_MASKED;
case 0x16: return OF_OXM_BSN_UDF3;
case 0x17: return OF_OXM_BSN_UDF3_MASKED;
case 0x18: return OF_OXM_BSN_UDF4;
case 0x19: return OF_OXM_BSN_UDF4_MASKED;
case 0x1a: return OF_OXM_BSN_UDF5;
case 0x1b: return OF_OXM_BSN_UDF5_MASKED;
case 0x1c: return OF_OXM_BSN_UDF6;
case 0x1d: return OF_OXM_BSN_UDF6_MASKED;
case 0x1e: return OF_OXM_BSN_UDF7;
case 0x1f: return OF_OXM_BSN_UDF7_MASKED;
default: return OF_OBJECT_INVALID;
}
} else {
return OF_OBJECT_INVALID;
}
}
"""
# Action types array gen
ar_len = type_maps.type_array_len(type_maps.action_types, max_type_value)
out.write(map_with_experimenter_template %
dict(name="action", u_name="ACTION", ar_len=ar_len))
# Action ID types array gen
ar_len = type_maps.type_array_len(type_maps.action_id_types, max_type_value)
out.write(map_with_experimenter_template %
dict(name="action_id", u_name="ACTION_ID", ar_len=ar_len))
# Instruction types array gen
ar_len = type_maps.type_array_len(type_maps.instruction_types,
max_type_value)
out.write(map_with_experimenter_template %
dict(name="instruction", u_name="INSTRUCTION", ar_len=ar_len))
# Instruction ID types array gen
ar_len = type_maps.type_array_len(type_maps.instruction_id_types, max_type_value)
out.write(map_with_experimenter_template %
dict(name="instruction_id", u_name="INSTRUCTION_ID", ar_len=ar_len))
# Queue prop types array gen
ar_len = type_maps.type_array_len(type_maps.queue_prop_types,
max_type_value)
out.write(map_with_experimenter_template %
dict(name="queue_prop", u_name="QUEUE_PROP", ar_len=ar_len))
# Table feature prop types array gen
ar_len = type_maps.type_array_len(type_maps.table_feature_prop_types,
max_type_value)
out.write(table_features_prop_template %
dict(name="table_feature_prop", u_name="TABLE_FEATURE_PROP",
ar_len=ar_len))
# Meter band types array gen
ar_len = type_maps.type_array_len(type_maps.meter_band_types,
max_type_value)
out.write(map_with_experimenter_template %
dict(name="meter_band", u_name="METER_BAND", ar_len=ar_len))
# Hello elem types array gen
ar_len = type_maps.type_array_len(type_maps.hello_elem_types,
max_type_value)
out.write(map_template %
dict(name="hello_elem", u_name="HELLO_ELEM", ar_len=ar_len))
# Stats types array gen
ar_len = type_maps.type_array_len(type_maps.stats_types,
max_type_value)
out.write(stats_template %
dict(name="stats_reply", u_name="STATS_REPLY", ar_len=ar_len))
out.write(stats_template %
dict(name="stats_request", u_name="STATS_REQUEST",
ar_len=ar_len))
ar_len = type_maps.type_array_len(type_maps.error_types,
max_type_value)
out.write(error_msg_template %
dict(name="error_msg", u_name="ERROR_MSG", ar_len=ar_len))
# out.write(error_msg_function)
ar_len = type_maps.type_array_len(type_maps.flow_mod_types, max_type_value)
out.write(map_template %
dict(name="flow_mod", u_name="FLOW_MOD", ar_len=ar_len))
ar_len = type_maps.type_array_len(type_maps.group_mod_types,
max_type_value)
out.write(map_template %
dict(name="group_mod", u_name="GROUP_MOD", ar_len=ar_len))
# OXM
ar_len = type_maps.type_array_len(type_maps.oxm_types, max_type_value)
out.write("""
/* NOTE: We could optimize the OXM and only generate OF 1.2 versions. */
""")
out.write(oxm_template % dict(ar_len=ar_len))
# Messages
out.write(experimenter_function)
# Must follow stats reply/request
ar_len = type_maps.type_array_len(type_maps.message_types, max_type_value)
out.write(msg_template %
dict(name="message", u_name="MESSAGE", ar_len=ar_len))
# BSN TLV elem types array gen
ar_len = type_maps.type_array_len(type_maps.bsn_tlv_types,
max_type_value)
out.write(map_template %
dict(name="bsn_tlv", u_name="BSN_TLV", ar_len=ar_len))
