X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fofp-errors.c;h=bd4e43a4ed93d99e60a0ecaf4326531cb5292394;hb=d73728e6bc30c8e6b393699ef78eb7919b1c68c5;hp=028475e114ba14c2f0b7c930ee16b78b4d2c62c7;hpb=90bf1e0732ac9b11dd51ca856b635cac1f0269c1;p=sliver-openvswitch.git diff --git a/lib/ofp-errors.c b/lib/ofp-errors.c index 028475e11..bd4e43a4e 100644 --- a/lib/ofp-errors.c +++ b/lib/ofp-errors.c @@ -1,8 +1,25 @@ +/* + * Copyright (c) 2012, 2013, 2014 Nicira, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + #include #include "ofp-errors.h" #include #include "byte-order.h" #include "dynamic-string.h" +#include "ofp-msgs.h" #include "ofp-util.h" #include "ofpbuf.h" #include "openflow/openflow.h" @@ -10,7 +27,8 @@ VLOG_DEFINE_THIS_MODULE(ofp_errors); -struct pair { +struct triplet { + uint32_t vendor; int type, code; }; @@ -20,68 +38,49 @@ 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) -{ - 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) +static const struct ofperr_domain * +ofperr_domain_from_version(enum ofp_version version) { - 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; + case OFP14_VERSION: + return &ofperr_of14; + 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. */ -enum ofperr -ofperr_decode(const struct ofperr_domain *domain, uint16_t type, uint16_t code) + * 'version', or 0 if either no such OFPERR_* value exists or 'version' is + * unknown. */ +static enum ofperr +ofperr_decode(enum ofp_version version, + uint32_t vendor, 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(vendor, type, code) : 0; } /* Returns the name of 'error', e.g. "OFPBRC_BAD_TYPE" if 'error' is @@ -97,6 +96,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 +125,81 @@ ofperr_get_description(enum ofperr error) : ""); } +static const struct triplet * +ofperr_get_triplet__(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; + const struct triplet *triplet; 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, ovs_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); - oem->type = htons(pair->type); - oem->code = htons(pair->code); - } else { + triplet = ofperr_get_triplet__(error, domain); + if (!triplet->vendor) { + buf = ofpraw_alloc_xid(OFPRAW_OFPT_ERROR, domain->version, xid, + sizeof *oem + data_len); + + oem = ofpbuf_put_uninit(buf, sizeof *oem); + oem->type = htons(triplet->type); + oem->code = htons(triplet->code); + } else if (ofp_version <= OFP11_VERSION) { 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->vendor = htonl(NX_VENDOR_ID); - nve->type = htons(pair->type); - nve->code = htons(pair->code); + nve = ofpbuf_put_uninit(buf, sizeof *nve); + nve->vendor = htonl(triplet->vendor); + nve->type = htons(triplet->type); + nve->code = htons(triplet->code); + } else { + ovs_be32 vendor = htonl(triplet->vendor); + + buf = ofpraw_alloc_xid(OFPRAW_OFPT_ERROR, domain->version, xid, + sizeof *oem + sizeof(uint32_t) + data_len); + + oem = ofpbuf_put_uninit(buf, sizeof *oem); + oem->type = htons(OFPET12_EXPERIMENTER); + oem->code = htons(triplet->type); + ofpbuf_put(buf, &vendor, sizeof vendor); } - oem->header.version = domain->version; - buf->size -= data_len; ofpbuf_put(buf, data, data_len); + ofpmsg_update_length(buf); return buf; } @@ -175,78 +212,94 @@ 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. +int +ofperr_get_vendor(enum ofperr error, enum ofp_version version) +{ + const struct ofperr_domain *domain = ofperr_domain_from_version(version); + return domain ? ofperr_get_triplet__(error, domain)->vendor : -1; +} + +/* 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_triplet__(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_triplet__(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 with a copy of + * the error's payload (copying is required because the payload is not properly + * aligned). The caller must free the payload (with ofpbuf_uninit()) when it + * is no longer needed. On failure, '*payload' 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; + uint32_t vendor; 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. */ + vendor = 0; type = ntohs(oem->type); code = ntohs(oem->code); if (type == NXET_VENDOR && code == NXVC_VENDOR_ERROR) { @@ -255,33 +308,37 @@ ofperr_decode_msg(const struct ofp_header *oh, size_t *payload_ofs) return 0; } - if (nve->vendor != htonl(NX_VENDOR_ID)) { - VLOG_WARN_RL(&rl, "error contains unknown vendor ID %#"PRIx32, - ntohl(nve->vendor)); - return 0; - } + vendor = ntohl(nve->vendor); type = ntohs(nve->type); code = ntohs(nve->code); - } + } else if (type == OFPET12_EXPERIMENTER) { + const ovs_be32 *vendorp = ofpbuf_try_pull(&b, sizeof *vendorp); + if (!vendorp) { + return 0; + } - /* 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); + vendor = ntohl(*vendorp); + type = code; + code = 0; } - 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, vendor, type, code); + if (error && payload) { + ofpbuf_init(payload, ofpbuf_size(&b)); + ofpbuf_push(payload, ofpbuf_data(&b), ofpbuf_size(&b)); } return error; } /* If 'error' is a valid OFPERR_* value, returns its name * (e.g. "OFPBRC_BAD_TYPE" for OFPBRC_BAD_TYPE). Otherwise, assumes that - * 'error' is a positive errno value and returns what strerror() produces for - * 'error'. */ + * 'error' is a positive errno value and returns what ovs_strerror() produces + * for 'error'. */ const char * ofperr_to_string(enum ofperr error) { - return ofperr_is_valid(error) ? ofperr_get_name(error) : strerror(error); + return (ofperr_is_valid(error) + ? ofperr_get_name(error) + : ovs_strerror(error)); }