diff options
Diffstat (limited to 'src/libnet_build_udld.c')
| -rw-r--r-- | src/libnet_build_udld.c | 307 |
1 files changed, 307 insertions, 0 deletions
diff --git a/src/libnet_build_udld.c b/src/libnet_build_udld.c new file mode 100644 index 0000000..731cffe --- /dev/null +++ b/src/libnet_build_udld.c @@ -0,0 +1,307 @@ +#include "common.h" + +#include <assert.h> + +static libnet_ptag_t +internal_build_udld_tlv(const uint16_t tlv_type, const uint8_t *value, +const uint8_t value_s, libnet_t * l, libnet_ptag_t ptag) +{ + struct libnet_udld_hdr hdr; + uint32_t n, h; + libnet_pblock_t *p; + + hdr.tlv__type = tlv_type; + hdr.tlv__length = LIBNET_UDLD_TLV_HDR_SIZE + value_s; + + uint32_t host_type_and_len = 0; + host_type_and_len |= (hdr.tlv__type << 16); + host_type_and_len |= (hdr.tlv__length); + uint32_t network_type_and_len = htonl(host_type_and_len); + + n = h = LIBNET_UDLD_TLV_HDR_SIZE + value_s; + + uint8_t pblock_type = 0; + uint8_t value_type = 0; + switch(tlv_type) + { + case LIBNET_UDLD_DEVICE_ID: + pblock_type = LIBNET_PBLOCK_UDLD_DEVICE_ID_H; + value_type = LIBNET_UDLD_VALUE_TYPE_ASCII; + break; + case LIBNET_UDLD_PORT_ID: + pblock_type = LIBNET_PBLOCK_UDLD_PORT_ID_H; + value_type = LIBNET_UDLD_VALUE_TYPE_ASCII; + break; + case LIBNET_UDLD_ECHO: + pblock_type = LIBNET_PBLOCK_UDLD_ECHO_H; + value_type = LIBNET_UDLD_VALUE_TYPE_ID_PAIRS; + break; + case LIBNET_UDLD_MESSAGE_INTERVAL: + pblock_type = LIBNET_PBLOCK_UDLD_MSG_INTERVAL_H; + value_type = LIBNET_UDLD_VALUE_TYPE_8_BIT_UINT; + break; + case LIBNET_UDLD_TIMEOUT_INTERVAL: + pblock_type = LIBNET_PBLOCK_UDLD_TMT_INTERVAL_H; + value_type = LIBNET_UDLD_VALUE_TYPE_8_BIT_UINT; + break; + case LIBNET_UDLD_DEVICE_NAME: + pblock_type = LIBNET_PBLOCK_UDLD_DEVICE_NAME_H; + value_type = LIBNET_UDLD_VALUE_TYPE_ASCII; + break; + case LIBNET_UDLD_SEQUENCE_NUMBER: + pblock_type = LIBNET_PBLOCK_UDLD_SEQ_NUMBER_H; + value_type = LIBNET_UDLD_VALUE_TYPE_32_BIT_UINT; + break; + default: + snprintf(l->err_buf, LIBNET_ERRBUF_SIZE, + "%s(): incorrect TLV type", __func__); + goto bad; + } + + /* + * Find the existing protocol block if a ptag is specified, or create + * a new one. + */ + p = libnet_pblock_probe(l, ptag, n, pblock_type); + if (p == NULL) + { + return (-1); + } + + if (libnet_pblock_append(l, p, &network_type_and_len, sizeof(network_type_and_len)) == -1) + { + goto bad; + } + + switch(value_type) + { + case LIBNET_UDLD_VALUE_TYPE_ASCII: + case LIBNET_UDLD_VALUE_TYPE_ID_PAIRS: + { + if (libnet_pblock_append(l, p, value, value_s) == -1) + { + goto bad; + } + break; + } + case LIBNET_UDLD_VALUE_TYPE_8_BIT_UINT: + { + if (libnet_pblock_append(l, p, value, sizeof(uint8_t)) == -1) + { + goto bad; + } + break; + } + case LIBNET_UDLD_VALUE_TYPE_32_BIT_UINT: + { + const uint32_t sequence_number = htonl(*(const uint32_t *)value); + if (libnet_pblock_append(l, p, &sequence_number, sizeof(uint32_t)) == -1) + { + goto bad; + } + break; + } + default: + { + snprintf(l->err_buf, LIBNET_ERRBUF_SIZE, + "%s(): incorrect value type", __func__); + goto bad; + } + } + + if (ptag) + { + return ptag; + } + + return libnet_pblock_update(l, p, h, pblock_type); + bad: + libnet_pblock_delete(l, p); + return (-1); +} + +LIBNET_API libnet_ptag_t +libnet_build_udld_hdr(uint8_t version, uint8_t opcode, uint8_t flags, uint8_t checksum, +const uint8_t *payload, uint32_t payload_s, libnet_t * l, libnet_ptag_t ptag) +{ + + struct libnet_udld_hdr udld_hdr; + libnet_pblock_t *p = NULL; + uint32_t n = 0; + uint32_t h = 0; + + if (l == NULL) + { + return (-1); + } + + n = LIBNET_UDLD_H + payload_s; + + /* + * Find the existing protocol block if a ptag is specified, or create + * a new one. + */ + p = libnet_pblock_probe(l, ptag, n, LIBNET_PBLOCK_UDLD_H); + if (p == NULL) + { + return (-1); + } + + memset(&udld_hdr, 0, sizeof(udld_hdr)); + udld_hdr.version_opcode |= (version << LIBNET_UDLD_PDU_VERSION_OFFSET); + udld_hdr.version_opcode |= (opcode); + udld_hdr.flags = flags; + udld_hdr.checksum = checksum; + + /* + * Appened the protocol unit to the list. + */ + n = libnet_pblock_append(l, p, (u_char *) & udld_hdr, LIBNET_UDLD_H); + if (n == -1) + { + goto bad; + } + + LIBNET_DO_PAYLOAD(l, p); + + if (checksum == 0 && l->injection_type != LIBNET_RAW4) + { + /* + * If checksum is zero, by default libnet will compute a checksum + * for the user. The programmer can override this by calling + * libnet_toggle_checksum(l, ptag, 1); + */ + libnet_pblock_setflags(p, LIBNET_PBLOCK_DO_CHECKSUM); + } + + return (ptag ? ptag : libnet_pblock_update(l, p, h, LIBNET_PBLOCK_UDLD_H)); + bad: + libnet_pblock_delete(l, p); + return (-1); +} + +LIBNET_API libnet_ptag_t +libnet_build_udld_device_id(const uint8_t *value, const uint8_t value_s, libnet_t * l, libnet_ptag_t ptag) +{ + if (l == NULL) + { + return (-1); + } + + if ((value && !value_s) || (!value && value_s)) + { + sprintf(l->err_buf, "%s(): value inconsistency\n", __FUNCTION__); + return (-1); + } + + return internal_build_udld_tlv(LIBNET_UDLD_DEVICE_ID, value, value_s, l, ptag); +} + +LIBNET_API libnet_ptag_t +libnet_build_udld_port_id(const uint8_t *value, const uint8_t value_s, libnet_t * l, libnet_ptag_t ptag) +{ + if (l == NULL) + { + return (-1); + } + + if ((value && !value_s) || (!value && value_s)) + { + sprintf(l->err_buf, "%s(): value inconsistency\n", __FUNCTION__); + return (-1); + } + + return internal_build_udld_tlv(LIBNET_UDLD_PORT_ID, value, value_s, l, ptag); +} + +LIBNET_API libnet_ptag_t +libnet_build_udld_echo(const uint8_t *value, const uint8_t value_s, libnet_t * l, libnet_ptag_t ptag) +{ + if (l == NULL) + { + return (-1); + } + + if ((value && !value_s) || (!value && value_s)) + { + sprintf(l->err_buf, "%s(): value inconsistency\n", __FUNCTION__); + return (-1); + } + + return internal_build_udld_tlv(LIBNET_UDLD_ECHO, value, value_s, l, ptag); +} + +LIBNET_API libnet_ptag_t +libnet_build_udld_message_interval(const uint8_t *value, libnet_t *l, +libnet_ptag_t ptag) +{ + if (l == NULL) + { + return (-1); + } + + assert(value && "value cannot be a NULL\n"); + if (value == NULL) + { + sprintf(l->err_buf, "%s(): value pointer cannot be a NULL\n", __FUNCTION__); + return (-1); + } + + return internal_build_udld_tlv(LIBNET_UDLD_MESSAGE_INTERVAL, value, sizeof(uint8_t), l, ptag); +} + +LIBNET_API libnet_ptag_t +libnet_build_udld_timeout_interval(const uint8_t *value, libnet_t *l, +libnet_ptag_t ptag) +{ + if (l == NULL) + { + return (-1); + } + + assert(value && "value cannot be a NULL\n"); + if (value == NULL) + { + sprintf(l->err_buf, "%s(): value pointer cannot be a NULL\n", __FUNCTION__); + return (-1); + } + + return internal_build_udld_tlv(LIBNET_UDLD_TIMEOUT_INTERVAL, (const uint8_t *)value, sizeof(uint8_t), l, ptag); +} + +LIBNET_API libnet_ptag_t +libnet_build_udld_device_name(const uint8_t *value, const uint8_t value_s, +libnet_t *l, libnet_ptag_t ptag) +{ + if (l == NULL) + { + return (-1); + } + + if ((value && !value_s) || (!value && value_s)) + { + sprintf(l->err_buf, "%s(): value inconsistency\n", __FUNCTION__); + return (-1); + } + + return internal_build_udld_tlv(LIBNET_UDLD_DEVICE_NAME, value, value_s, l, ptag); +} + +LIBNET_API libnet_ptag_t +libnet_build_udld_sequence_number(const uint8_t *value, libnet_t *l, +libnet_ptag_t ptag) +{ + if (l == NULL) + { + return (-1); + } + + assert(value != NULL && "value cannot be a NULL\n"); + if (value == NULL) + { + sprintf(l->err_buf, "%s(): value pointer cannot be a NULL\n", __FUNCTION__); + return (-1); + } + + return internal_build_udld_tlv(LIBNET_UDLD_SEQUENCE_NUMBER, value, sizeof(uint32_t), l, ptag); +} |