X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fofp-errors.c;h=f2a9e8cb5f413b4aac908b898c794361704779a4;hb=a39c3ff9f586d3416976d3c3bd095fa81d73efa0;hp=028475e114ba14c2f0b7c930ee16b78b4d2c62c7;hpb=90bf1e0732ac9b11dd51ca856b635cac1f0269c1;p=sliver-openvswitch.git diff --git a/lib/ofp-errors.c b/lib/ofp-errors.c index 028475e11..f2a9e8cb5 100644 --- a/lib/ofp-errors.c +++ b/lib/ofp-errors.c @@ -3,6 +3,7 @@ #include #include "byte-order.h" #include "dynamic-string.h" +#include "ofp-msgs.h" #include "ofp-util.h" #include "ofpbuf.h" #include "openflow/openflow.h" @@ -20,68 +21,46 @@ struct pair { * 'version' (one of the possible values of struct ofp_header's 'version' * member). Returns NULL if the version isn't defined or isn't understood by * OVS. */ -const struct ofperr_domain * -ofperr_domain_from_version(uint8_t version) +static const struct ofperr_domain * +ofperr_domain_from_version(enum ofp_version version) { - return (version == ofperr_of10.version ? &ofperr_of10 - : version == ofperr_of11.version ? &ofperr_of11 - : NULL); -} - -/* Returns true if 'error' is a valid OFPERR_* value, false otherwise. */ -bool -ofperr_is_valid(enum ofperr error) -{ - return error >= OFPERR_OFS && error < OFPERR_OFS + OFPERR_N_ERRORS; -} - -/* Returns true if 'error' is a valid OFPERR_* value that designates a whole - * category of errors instead of a particular error, e.g. if it is an - * OFPERR_OFPET_* value, and false otherwise. */ -bool -ofperr_is_category(enum ofperr error) -{ - return (ofperr_is_valid(error) - && ofperr_of10.errors[error - OFPERR_OFS].code == -1 - && ofperr_of11.errors[error - OFPERR_OFS].code == -1); + switch (version) { + case OFP10_VERSION: + return &ofperr_of10; + case OFP11_VERSION: + return &ofperr_of11; + case OFP12_VERSION: + return &ofperr_of12; + case OFP13_VERSION: + return &ofperr_of13; + default: + return NULL; + } } -/* Returns true if 'error' is a valid OFPERR_* value that is a Nicira - * extension, e.g. if it is an OFPERR_NX* value, and false otherwise. */ -bool -ofperr_is_nx_extension(enum ofperr error) +/* Returns the name (e.g. "OpenFlow 1.0") of OpenFlow version 'version'. */ +const char * +ofperr_domain_get_name(enum ofp_version version) { - return (ofperr_is_valid(error) - && (ofperr_of10.errors[error - OFPERR_OFS].code >= 0x100 || - ofperr_of11.errors[error - OFPERR_OFS].code >= 0x100)); + const struct ofperr_domain *domain = ofperr_domain_from_version(version); + return domain ? domain->name : NULL; } -/* Returns true if 'error' can be encoded as an OpenFlow error message in - * 'domain', false otherwise. - * - * A given error may not be encodable in some domains because each OpenFlow - * version tends to introduce new errors and retire some old ones. */ +/* Returns true if 'error' is a valid OFPERR_* value, false otherwise. */ bool -ofperr_is_encodable(enum ofperr error, const struct ofperr_domain *domain) +ofperr_is_valid(enum ofperr error) { - return (ofperr_is_valid(error) - && domain->errors[error - OFPERR_OFS].code >= 0); + return error >= OFPERR_OFS && error < OFPERR_OFS + OFPERR_N_ERRORS; } /* Returns the OFPERR_* value that corresponds to 'type' and 'code' within - * 'domain', or 0 if no such OFPERR_* value exists. */ + * 'version', or 0 if either no such OFPERR_* value exists or 'version' is + * unknown. */ enum ofperr -ofperr_decode(const struct ofperr_domain *domain, uint16_t type, uint16_t code) +ofperr_decode(enum ofp_version version, uint16_t type, uint16_t code) { - return domain->decode(type, code); -} - -/* Returns the OFPERR_* value that corresponds to the category 'type' within - * 'domain', or 0 if no such OFPERR_* value exists. */ -enum ofperr -ofperr_decode_type(const struct ofperr_domain *domain, uint16_t type) -{ - return domain->decode_type(type); + const struct ofperr_domain *domain = ofperr_domain_from_version(version); + return domain ? domain->decode(type, code) : 0; } /* Returns the name of 'error', e.g. "OFPBRC_BAD_TYPE" if 'error' is @@ -97,6 +76,24 @@ ofperr_get_name(enum ofperr error) : ""); } +/* Returns the OFPERR_* value that corresponds for 'name', 0 if none exists. + * For example, returns OFPERR_OFPHFC_INCOMPATIBLE if 'name' is + * "OFPHFC_INCOMPATIBLE". + * + * This is probably useful only for debugging and testing. */ +enum ofperr +ofperr_from_name(const char *name) +{ + int i; + + for (i = 0; i < OFPERR_N_ERRORS; i++) { + if (!strcmp(name, error_names[i])) { + return i + OFPERR_OFS; + } + } + return 0; +} + /* Returns an extended description name of 'error', e.g. "ofp_header.type not * supported." if 'error' is OFPBRC_BAD_TYPE, or "" if 'error' is not * a valid OFPERR_* value. */ @@ -108,61 +105,71 @@ ofperr_get_description(enum ofperr error) : ""); } +static const struct pair * +ofperr_get_pair__(enum ofperr error, const struct ofperr_domain *domain) +{ + size_t ofs = error - OFPERR_OFS; + + ovs_assert(ofperr_is_valid(error)); + return &domain->errors[ofs]; +} + static struct ofpbuf * -ofperr_encode_msg__(enum ofperr error, const struct ofperr_domain *domain, +ofperr_encode_msg__(enum ofperr error, enum ofp_version ofp_version, ovs_be32 xid, const void *data, size_t data_len) { + static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5); + const struct ofperr_domain *domain; struct ofp_error_msg *oem; const struct pair *pair; struct ofpbuf *buf; - size_t ofs; + /* Get the error domain for 'ofp_version', or fall back to OF1.0. */ + domain = ofperr_domain_from_version(ofp_version); if (!domain) { - return NULL; + VLOG_ERR_RL(&rl, "cannot encode error for unknown OpenFlow " + "version 0x%02x", ofp_version); + domain = &ofperr_of10; } - if (!ofperr_is_encodable(error, domain)) { - static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5); - - if (!ofperr_is_valid(error)) { - /* 'error' seems likely to be a system errno value. */ - VLOG_WARN_RL(&rl, "invalid OpenFlow error code %d (%s)", - error, strerror(error)); - } else { - const char *s = ofperr_get_name(error); - if (ofperr_is_category(error)) { - VLOG_WARN_RL(&rl, "cannot encode error category (%s)", s); - } else { - VLOG_WARN_RL(&rl, "cannot encode %s for %s", s, domain->name); - } - } - - return NULL; + /* Make sure 'error' is valid in 'domain', or use a fallback error. */ + if (!ofperr_is_valid(error)) { + /* 'error' seems likely to be a system errno value. */ + VLOG_ERR_RL(&rl, "invalid OpenFlow error code %d (%s)", + error, strerror(error)); + error = OFPERR_NXBRC_UNENCODABLE_ERROR; + } else if (domain->errors[error - OFPERR_OFS].code < 0) { + VLOG_ERR_RL(&rl, "cannot encode %s for %s", + ofperr_get_name(error), domain->name); + error = OFPERR_NXBRC_UNENCODABLE_ERROR; } - ofs = error - OFPERR_OFS; - pair = &domain->errors[ofs]; - if (!ofperr_is_nx_extension(error)) { - oem = make_openflow_xid(data_len + sizeof *oem, OFPT_ERROR, xid, &buf); + pair = ofperr_get_pair__(error, domain); + if (pair->code < 0x100) { + buf = ofpraw_alloc_xid(OFPRAW_OFPT_ERROR, domain->version, xid, + sizeof *oem + data_len); + + oem = ofpbuf_put_uninit(buf, sizeof *oem); oem->type = htons(pair->type); oem->code = htons(pair->code); } else { struct nx_vendor_error *nve; - oem = make_openflow_xid(data_len + sizeof *oem + sizeof *nve, - OFPT_ERROR, xid, &buf); + buf = ofpraw_alloc_xid(OFPRAW_OFPT_ERROR, domain->version, xid, + sizeof *oem + sizeof *nve + data_len); + + oem = ofpbuf_put_uninit(buf, sizeof *oem); oem->type = htons(NXET_VENDOR); oem->code = htons(NXVC_VENDOR_ERROR); - nve = (struct nx_vendor_error *) oem->data; + nve = ofpbuf_put_uninit(buf, sizeof *nve); nve->vendor = htonl(NX_VENDOR_ID); nve->type = htons(pair->type); nve->code = htons(pair->code); } - oem->header.version = domain->version; - buf->size -= data_len; ofpbuf_put(buf, data, data_len); + ofpmsg_update_length(buf); return buf; } @@ -175,76 +182,83 @@ ofperr_encode_msg__(enum ofperr error, const struct ofperr_domain *domain, * The error reply will contain an initial subsequence of 'oh', up to * 'oh->length' or 64 bytes, whichever is shorter. * - * Returns NULL if 'error' is not an OpenFlow error code or if 'error' cannot - * be encoded as OpenFlow version 'oh->version'. - * * This function isn't appropriate for encoding OFPET_HELLO_FAILED error * messages. Use ofperr_encode_hello() instead. */ struct ofpbuf * ofperr_encode_reply(enum ofperr error, const struct ofp_header *oh) { - const struct ofperr_domain *domain; uint16_t len = ntohs(oh->length); - domain = ofperr_domain_from_version(oh->version); - return ofperr_encode_msg__(error, domain, oh->xid, oh, MIN(len, 64)); + return ofperr_encode_msg__(error, oh->version, oh->xid, oh, MIN(len, 64)); } /* Creates and returns an OpenFlow message of type OFPT_ERROR that conveys the * given 'error', in the error domain 'domain'. The error message will include * the additional null-terminated text string 's'. * - * If 'domain' is NULL, uses the OpenFlow 1.0 error domain. OFPET_HELLO_FAILED - * error messages are supposed to be backward-compatible, so in theory this - * should work. - * - * Returns NULL if 'error' is not an OpenFlow error code or if 'error' cannot - * be encoded in 'domain'. */ + * If 'version' is an unknown version then OFP10_VERSION is used. + * OFPET_HELLO_FAILED error messages are supposed to be backward-compatible, + * so in theory this should work. */ struct ofpbuf * -ofperr_encode_hello(enum ofperr error, const struct ofperr_domain *domain, +ofperr_encode_hello(enum ofperr error, enum ofp_version ofp_version, const char *s) { - if (!domain) { - domain = &ofperr_of10; - } - return ofperr_encode_msg__(error, domain, htonl(0), s, strlen(s)); + return ofperr_encode_msg__(error, ofp_version, htonl(0), s, strlen(s)); } -/* Tries to decodes 'oh', which should be an OpenFlow OFPT_ERROR message. +/* Returns the value that would go into an OFPT_ERROR message's 'type' for + * encoding 'error' in 'domain'. Returns -1 if 'error' is not encodable in + * 'version' or 'version' is unknown. + * + * 'error' must be a valid OFPERR_* code, as checked by ofperr_is_valid(). */ +int +ofperr_get_type(enum ofperr error, enum ofp_version version) +{ + const struct ofperr_domain *domain = ofperr_domain_from_version(version); + return domain ? ofperr_get_pair__(error, domain)->type : -1; +} + +/* Returns the value that would go into an OFPT_ERROR message's 'code' for + * encoding 'error' in 'domain'. Returns -1 if 'error' is not encodable in + * 'version', 'version' is unknown or if 'error' represents a category + * rather than a specific error. + * + * + * 'error' must be a valid OFPERR_* code, as checked by ofperr_is_valid(). */ +int +ofperr_get_code(enum ofperr error, enum ofp_version version) +{ + const struct ofperr_domain *domain = ofperr_domain_from_version(version); + return domain ? ofperr_get_pair__(error, domain)->code : -1; +} + +/* Tries to decode 'oh', which should be an OpenFlow OFPT_ERROR message. * Returns an OFPERR_* constant on success, 0 on failure. * - * If 'payload_ofs' is nonnull, on success '*payload_ofs' is set to the offset - * to the payload starting from 'oh' and on failure it is set to 0. */ + * If 'payload' is nonnull, on success '*payload' is initialized to the + * error's payload, and on failure it is cleared. */ enum ofperr -ofperr_decode_msg(const struct ofp_header *oh, size_t *payload_ofs) +ofperr_decode_msg(const struct ofp_header *oh, struct ofpbuf *payload) { static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5); - const struct ofperr_domain *domain; const struct ofp_error_msg *oem; + enum ofpraw raw; uint16_t type, code; enum ofperr error; struct ofpbuf b; - if (payload_ofs) { - *payload_ofs = 0; + if (payload) { + memset(payload, 0, sizeof *payload); } /* Pull off the error message. */ ofpbuf_use_const(&b, oh, ntohs(oh->length)); - oem = ofpbuf_try_pull(&b, sizeof *oem); - if (!oem) { - return 0; - } - - /* Check message type and version. */ - if (oh->type != OFPT_ERROR) { - return 0; - } - domain = ofperr_domain_from_version(oh->version); - if (!domain) { + error = ofpraw_pull(&raw, &b); + if (error) { return 0; } + oem = ofpbuf_pull(&b, sizeof *oem); /* Get the error type and code. */ type = ntohs(oem->type); @@ -264,14 +278,10 @@ ofperr_decode_msg(const struct ofp_header *oh, size_t *payload_ofs) code = ntohs(nve->code); } - /* Translate the error type and code into an ofperr. - * If we don't know the error type and code, at least try for the type. */ - error = ofperr_decode(domain, type, code); - if (!error) { - error = ofperr_decode_type(domain, type); - } - if (error && payload_ofs) { - *payload_ofs = (uint8_t *) b.data - (uint8_t *) oh; + /* Translate the error type and code into an ofperr. */ + error = ofperr_decode(oh->version, type, code); + if (error && payload) { + ofpbuf_use_const(payload, b.data, b.size); } return error; }