ofl_err ofl_structs_queue_stats_unpack(struct ofp_queue_stats *src, size_t *len, struct ofl_queue_stats **dst) { struct ofl_queue_stats *p; if (*len < sizeof(struct ofp_queue_stats)) { OFL_LOG_WARN(LOG_MODULE, "Received queue stats has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN); } if (ntohl(src->port_no) == 0 || ntohl(src->port_no) > OFPP_MAX) { if (OFL_LOG_IS_WARN_ENABLED(LOG_MODULE)) { char *ps = ofl_port_to_string(ntohl(src->port_no)); OFL_LOG_WARN(LOG_MODULE, "Received queue stats has invalid port_id (%s).", ps); free(ps); } return ofl_error(OFPET_BAD_ACTION, OFPBRC_BAD_LEN); } *len -= sizeof(struct ofp_queue_stats); p = (struct ofl_queue_stats *)malloc(sizeof(struct ofl_queue_stats)); p->port_no = ntohl(src->port_no); p->queue_id = ntohl(src->queue_id); p->tx_bytes = ntoh64(src->tx_bytes); p->tx_packets = ntoh64(src->tx_packets); p->tx_errors = ntoh64(src->tx_errors); p->duration_sec = ntohl(src->duration_sec); p->duration_nsec = ntohl(src->duration_nsec); *dst = p; return 0; }
ofl_err ofl_structs_queue_stats_unpack(struct ofp_queue_stats *src, size_t *len, struct ofl_queue_stats **dst, char *errbuf) { struct ofl_queue_stats *p; if (*len < sizeof(struct ofp_queue_stats)) { if (errbuf != NULL) { snprintf(errbuf, OFL_ERRBUF_SIZE, "Received queue stats has invalid length (%zu).", *len); } return ofl_error(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN); } if (ntohl(src->port_no) == 0 || ntohl(src->port_no) > OFPP_MAX) { if (errbuf != NULL) { char *ps = ofl_port_to_string(ntohl(src->port_no)); snprintf(errbuf, OFL_ERRBUF_SIZE, "Received queue stats has invalid port_id (%s).", ps); free(ps); } return ofl_error(OFPET_BAD_ACTION, OFPBRC_BAD_LEN); } *len -= sizeof(struct ofp_queue_stats); p = (struct ofl_queue_stats *)malloc(sizeof(struct ofl_queue_stats)); p->port_no = ntohl(src->port_no); p->queue_id = ntohl(src->queue_id); p->tx_bytes = ntoh64(src->tx_bytes); p->tx_packets = ntoh64(src->tx_packets); p->tx_errors = ntoh64(src->tx_errors); *dst = p; return 0; }
static ofl_err ofl_msg_unpack_port_mod(struct ofp_header *src, size_t *len, struct ofl_msg_header **msg, char *errbuf) { struct ofp_port_mod *sm; struct ofl_msg_port_mod *dm; if (*len < sizeof(struct ofp_port_mod)) { if (errbuf != NULL) { snprintf(errbuf, OFL_ERRBUF_SIZE, "Received PORT_MOD has invalid length (%zu).", *len); } return ofl_error(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN); } sm = (struct ofp_port_mod *)src; if (ntohl(sm->port_no) == 0 || ntohl(sm->port_no) > OFPP_MAX) { if (errbuf != NULL) { char *ps = ofl_port_to_string(ntohl(sm->port_no)); snprintf(errbuf, OFL_ERRBUF_SIZE, "Received PORT_MOD message has invalid in_port (%s).", ps); free(ps); } return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_ARGUMENT); } *len -= sizeof(struct ofp_port_mod); dm = (struct ofl_msg_port_mod *)malloc(sizeof(struct ofl_msg_port_mod)); dm->port_no = ntohl(sm->port_no); memcpy(dm->hw_addr, sm->hw_addr, OFP_ETH_ALEN); dm->config = ntohl(sm->config); dm->mask = ntohl(sm->mask); dm->advertise = ntohl(sm->advertise); *msg = (struct ofl_msg_header *)dm; return 0; }
static ofl_err ofl_msg_unpack_packet_in(struct ofp_header *src, size_t *len, struct ofl_msg_header **msg, char *errbuf) { struct ofp_packet_in *sp; struct ofl_msg_packet_in *dp; if (*len < sizeof(struct ofp_packet_in)) { if (errbuf != NULL) { snprintf(errbuf, OFL_ERRBUF_SIZE, "Received PACKET_IN message has invalid length (%zu).", *len); } return ofl_error(OFPET_BAD_ACTION, OFPBRC_BAD_LEN); } sp = (struct ofp_packet_in *)src; if (ntohl(sp->in_port) == 0 || (ntohl(sp->in_port) > OFPP_MAX && ntohl(sp->in_port) != OFPP_LOCAL)) { if (errbuf != NULL) { char *ps = ofl_port_to_string(ntohl(sp->in_port)); snprintf(errbuf, OFL_ERRBUF_SIZE, "Received PACKET_IN message has invalid in_port (%s).", ps); free(ps); } return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_ARGUMENT); } if (sp->table_id == 0xff) { if (errbuf != NULL) { char *ts = ofl_table_to_string(sp->table_id); snprintf(errbuf, OFL_ERRBUF_SIZE, "Received PACKET_IN has invalid table_id (%s).", ts); free(ts); } return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_ARGUMENT); } *len -= sizeof(struct ofp_packet_in); dp = (struct ofl_msg_packet_in *)malloc(sizeof(struct ofl_msg_packet_in)); dp->buffer_id = ntohl(sp->buffer_id); dp->in_port = ntohl(sp->in_port); dp->in_phy_port = ntohl(sp->in_phy_port); dp->total_len = ntohs(sp->total_len); dp->reason = (enum ofp_packet_in_reason)sp->reason; dp->table_id = sp->table_id; dp->data_length = *len; dp->data = *len > 0 ? (uint8_t *)memcpy(malloc(*len), sp->data, *len) : NULL; *len = 0; *msg = (struct ofl_msg_header *)dp; return 0; }
ofl_err ofl_structs_port_stats_unpack(struct ofp_port_stats *src, size_t *len, struct ofl_port_stats **dst, char *errbuf) { struct ofl_port_stats *p; if (*len < sizeof(struct ofp_port_stats)) { if (errbuf != NULL) { snprintf(errbuf, OFL_ERRBUF_SIZE, "Received port stats has invalid length (%zu).", *len); } return ofl_error(OFPET_BAD_ACTION, OFPBRC_BAD_LEN); } if (ntohl(src->port_no) == 0 || (ntohl(src->port_no) > OFPP_MAX && ntohl(src->port_no) != OFPP_LOCAL)) { if (errbuf != NULL) { char *ps = ofl_port_to_string(ntohl(src->port_no)); snprintf(errbuf, OFL_ERRBUF_SIZE, "Received port stats has invalid port_id (%s).", ps); free(ps); } return ofl_error(OFPET_BAD_ACTION, OFPBRC_BAD_LEN); } *len -= sizeof(struct ofp_port_stats); p = (struct ofl_port_stats *)malloc(sizeof(struct ofl_port_stats)); p->port_no = ntohl(src->port_no); p->rx_packets = ntoh64(src->rx_packets); p->tx_packets = ntoh64(src->tx_packets); p->rx_bytes = ntoh64(src->rx_bytes); p->tx_bytes = ntoh64(src->tx_bytes); p->rx_dropped = ntoh64(src->rx_dropped); p->tx_dropped = ntoh64(src->tx_dropped); p->rx_errors = ntoh64(src->rx_errors); p->tx_errors = ntoh64(src->tx_errors); p->rx_frame_err = ntoh64(src->rx_frame_err); p->rx_over_err = ntoh64(src->rx_over_err); p->rx_crc_err = ntoh64(src->rx_crc_err); p->collisions = ntoh64(src->collisions); *dst = p; return 0; }
ofl_err ofl_structs_port_unpack(struct ofp_port *src, size_t *len, struct ofl_port **dst, char *errbuf) { struct ofl_port *p; if (*len < sizeof(struct ofp_port)) { if (errbuf != NULL) { snprintf(errbuf, OFL_ERRBUF_SIZE, "Received port has invalid length (%zu).", *len); } return ofl_error(OFPET_BAD_ACTION, OFPBRC_BAD_LEN); } if (ntohl(src->port_no) == 0 || (ntohl(src->port_no) > OFPP_MAX && ntohl(src->port_no) != OFPP_LOCAL)) { if (errbuf != NULL) { char *ps = ofl_port_to_string(ntohl(src->port_no)); snprintf(errbuf, OFL_ERRBUF_SIZE, "Received port has invalid port_id (%s).", ps); free(ps); } return ofl_error(OFPET_BAD_ACTION, OFPBRC_BAD_LEN); } *len -= sizeof(struct ofp_port); p = (struct ofl_port *)malloc(sizeof(struct ofl_port)); p->port_no = ntohl(src->port_no); memcpy(p->hw_addr, src->hw_addr, ETH_ADDR_LEN); p->name = strcpy((char *)malloc(strlen(src->name) + 1), src->name); p->config = ntohl(src->config); p->state = ntohl(src->state); p->curr = ntohl(src->curr); p->advertised = ntohl(src->advertised); p->supported = ntohl(src->supported); p->peer = ntohl(src->peer); p->curr_speed = ntohl(src->curr_speed); p->max_speed = ntohl(src->max_speed); *dst = p; return 0; }
ofl_err ofl_structs_port_stats_unpack(struct ofp_port_stats *src, size_t *len, struct ofl_port_stats **dst) { struct ofl_port_stats *p; if (*len < sizeof(struct ofp_port_stats)) { OFL_LOG_WARN(LOG_MODULE, "Received port stats has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBRC_BAD_LEN); } if (ntohl(src->port_no) == 0 || (ntohl(src->port_no) > OFPP_MAX && ntohl(src->port_no) != OFPP_LOCAL)) { if (OFL_LOG_IS_WARN_ENABLED(LOG_MODULE)) { char *ps = ofl_port_to_string(ntohl(src->port_no)); OFL_LOG_WARN(LOG_MODULE, "Received port stats has invalid port_id (%s).", ps); free(ps); } return ofl_error(OFPET_BAD_ACTION, OFPBRC_BAD_LEN); } *len -= sizeof(struct ofp_port_stats); p = (struct ofl_port_stats *)malloc(sizeof(struct ofl_port_stats)); p->port_no = ntohl(src->port_no); p->rx_packets = ntoh64(src->rx_packets); p->tx_packets = ntoh64(src->tx_packets); p->rx_bytes = ntoh64(src->rx_bytes); p->tx_bytes = ntoh64(src->tx_bytes); p->rx_dropped = ntoh64(src->rx_dropped); p->tx_dropped = ntoh64(src->tx_dropped); p->rx_errors = ntoh64(src->rx_errors); p->tx_errors = ntoh64(src->tx_errors); p->rx_frame_err = ntoh64(src->rx_frame_err); p->rx_over_err = ntoh64(src->rx_over_err); p->rx_crc_err = ntoh64(src->rx_crc_err); p->collisions = ntoh64(src->collisions); p->duration_sec = ntohl(src->duration_sec); p->duration_nsec = ntohl(src->duration_nsec); *dst = p; return 0; }
ofl_err ofl_actions_unpack(struct ofp_action_header *src, size_t *len, struct ofl_action_header **dst, struct ofl_exp *exp) { if (*len < sizeof(struct ofp_action_header)) { OFL_LOG_WARN(LOG_MODULE, "Received action is too short (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } if (*len < ntohs(src->len)) { OFL_LOG_WARN(LOG_MODULE, "Received action has invalid length (set to %u, but only %zu received).", ntohs(src->len), *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } if ((ntohs(src->len) % 8) != 0) { OFL_LOG_WARN(LOG_MODULE, "Received action length is not a multiple of 64 bits (%u).", ntohs(src->len)); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } switch (ntohs(src->type)) { case OFPAT_OUTPUT: { struct ofp_action_output *sa; struct ofl_action_output *da; if (*len < sizeof(struct ofp_action_output)) { OFL_LOG_WARN(LOG_MODULE, "Received OUTPUT action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } sa = (struct ofp_action_output *)src; if (ntohl(sa->port) == 0 || (ntohl(sa->port) > OFPP_MAX && ntohl(sa->port) < OFPP_IN_PORT) || ntohl(sa->port) == OFPP_ANY) { if (OFL_LOG_IS_WARN_ENABLED(LOG_MODULE)) { char *ps = ofl_port_to_string(ntohl(sa->port)); OFL_LOG_WARN(LOG_MODULE, "Received OUTPUT action has invalid port (%s).", ps); free(ps); } return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_OUT_PORT); } da = (struct ofl_action_output *)malloc(sizeof(struct ofl_action_output)); da->port = ntohl(sa->port); da->max_len = ntohs(sa->max_len); *len -= sizeof(struct ofp_action_output); *dst = (struct ofl_action_header *)da; break; } case OFPAT_COPY_TTL_OUT: { //ofp_action_header length was already checked *len -= sizeof(struct ofp_action_header); *dst = (struct ofl_action_header *)malloc(sizeof(struct ofl_action_header)); break; } case OFPAT_COPY_TTL_IN: { //ofp_action_header length was already checked *len -= sizeof(struct ofp_action_header); *dst = (struct ofl_action_header *)malloc(sizeof(struct ofl_action_header)); break; } case OFPAT_SET_MPLS_TTL: { struct ofp_action_mpls_ttl *sa; struct ofl_action_mpls_ttl *da; if (*len < sizeof(struct ofp_action_mpls_ttl)) { OFL_LOG_WARN(LOG_MODULE, "Received SET_MPLS_TTL action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } sa = (struct ofp_action_mpls_ttl *)src; da = (struct ofl_action_mpls_ttl *)malloc(sizeof(struct ofl_action_mpls_ttl)); da->mpls_ttl = sa->mpls_ttl; *len -= sizeof(struct ofp_action_mpls_ttl); *dst = (struct ofl_action_header *)da; break; } case OFPAT_DEC_MPLS_TTL: { //ofp_action_header length was already checked *len -= sizeof(struct ofp_action_mpls_ttl); *dst = (struct ofl_action_header *)malloc(sizeof(struct ofl_action_header)); break; } case OFPAT_PUSH_VLAN: case OFPAT_PUSH_PBB: case OFPAT_PUSH_MPLS: { struct ofp_action_push *sa; struct ofl_action_push *da; if (*len < sizeof(struct ofp_action_push)) { OFL_LOG_WARN(LOG_MODULE, "Received PUSH_VLAN/MPLS/PBB action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } sa = (struct ofp_action_push *)src; if (((ntohs(src->type) == OFPAT_PUSH_VLAN) && (ntohs(sa->ethertype) != ETH_TYPE_VLAN && ntohs(sa->ethertype) != ETH_TYPE_VLAN_PBB)) || ((ntohs(src->type) == OFPAT_PUSH_MPLS) && (ntohs(sa->ethertype) != ETH_TYPE_MPLS && ntohs(sa->ethertype) != ETH_TYPE_MPLS_MCAST)) || ((ntohs(src->type) == OFPAT_PUSH_PBB) && (ntohs(sa->ethertype) != ETH_TYPE_PBB))) { OFL_LOG_WARN(LOG_MODULE, "Received PUSH_VLAN/MPLS/PBB has invalid eth type. (%u)", ntohs(sa->ethertype)); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_ARGUMENT); } da = (struct ofl_action_push *)malloc(sizeof(struct ofl_action_push)); da->ethertype = ntohs(sa->ethertype); *len -= sizeof(struct ofp_action_push); *dst = (struct ofl_action_header *)da; break; } case OFPAT_POP_VLAN: case OFPAT_POP_PBB: { //ofp_action_header length was already checked *len -= sizeof(struct ofp_action_header); *dst = (struct ofl_action_header *)malloc(sizeof(struct ofl_action_header)); break; } case OFPAT_POP_MPLS: { struct ofp_action_pop_mpls *sa; struct ofl_action_pop_mpls *da; if (*len < sizeof(struct ofp_action_pop_mpls)) { OFL_LOG_WARN(LOG_MODULE, "Received POP_MPLS action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } sa = (struct ofp_action_pop_mpls *)src; da = (struct ofl_action_pop_mpls *)malloc(sizeof(struct ofl_action_pop_mpls)); da->ethertype = ntohs(sa->ethertype); *len -= sizeof(struct ofp_action_pop_mpls); *dst = (struct ofl_action_header *)da; break; } case OFPAT_SET_QUEUE: { struct ofp_action_set_queue *sa; struct ofl_action_set_queue *da; if (*len < sizeof(struct ofp_action_set_queue)) { OFL_LOG_WARN(LOG_MODULE, "Received SET_QUEUE action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } sa = (struct ofp_action_set_queue *)src; da = (struct ofl_action_set_queue *)malloc(sizeof(struct ofl_action_set_queue)); da->queue_id = ntohl(sa->queue_id); *len -= sizeof(struct ofp_action_set_queue); *dst = (struct ofl_action_header *)da; break; } case OFPAT_GROUP: { struct ofp_action_group *sa; struct ofl_action_group *da; if (*len < sizeof(struct ofp_action_group)) { OFL_LOG_WARN(LOG_MODULE, "Received GROUP action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } sa = (struct ofp_action_group *)src; if (ntohl(sa->group_id) > OFPG_MAX) { if (OFL_LOG_IS_WARN_ENABLED(LOG_MODULE)) { char *gs = ofl_group_to_string(ntohl(sa->group_id)); OFL_LOG_WARN(LOG_MODULE, "Received GROUP action has invalid group id (%s).", gs); free(gs); } return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_OUT_GROUP); } da = (struct ofl_action_group *)malloc(sizeof(struct ofl_action_group)); da->group_id = ntohl(sa->group_id); *len -= sizeof(struct ofp_action_group); *dst = (struct ofl_action_header *)da; break; } case OFPAT_SET_NW_TTL: { struct ofp_action_nw_ttl *sa; struct ofl_action_set_nw_ttl *da; if (*len < sizeof(struct ofp_action_nw_ttl)) { OFL_LOG_WARN(LOG_MODULE, "Received SET_NW_TTL action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } sa = (struct ofp_action_nw_ttl *)src; da = (struct ofl_action_set_nw_ttl *)malloc(sizeof(struct ofl_action_set_nw_ttl)); da->nw_ttl = sa->nw_ttl; *len -= sizeof(struct ofp_action_nw_ttl); *dst = (struct ofl_action_header *)da; break; } case OFPAT_DEC_NW_TTL: { //ofp_action_header length was already checked *len -= sizeof(struct ofp_action_header); *dst = (struct ofl_action_header *)malloc(sizeof(struct ofl_action_header)); break; } case OFPAT_SET_FIELD: { struct ofp_action_set_field *sa; struct ofl_action_set_field *da; uint8_t *value; sa = (struct ofp_action_set_field*) src; da = (struct ofl_action_set_field *)malloc(sizeof(struct ofl_action_set_field)); da->field = (struct ofl_match_tlv*) malloc(sizeof(struct ofl_match_tlv)); memcpy(&da->field->header,sa->field,4); da->field->header = ntohl(da->field->header); value = (uint8_t *) src + sizeof (struct ofp_action_set_field); da->field->value = malloc(OXM_LENGTH(da->field->header)); /*TODO: need to check if other fields are valid */ if(da->field->header == OXM_OF_IN_PORT || da->field->header == OXM_OF_IN_PHY_PORT || da->field->header == OXM_OF_METADATA || da->field->header == OXM_OF_IPV6_EXTHDR){ return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_SET_TYPE); } switch(OXM_LENGTH(da->field->header)){ case 1: case 6: case 16: memcpy(da->field->value , value, OXM_LENGTH(da->field->header)); break; case 2:{ uint16_t v = ntohs(*((uint16_t*) value)); memcpy(da->field->value , &v, OXM_LENGTH(da->field->header)); break; } case 4:{ uint32_t v; uint8_t field = OXM_FIELD(da->field->header); if( field != 11 && field != 12 && field != 22 && field != 23) v = htonl(*((uint32_t*) value)); else v = *((uint32_t*) value); memcpy(da->field->value , &v, OXM_LENGTH(da->field->header)); break; } case 8:{ uint64_t v = hton64(*((uint64_t*) value)); memcpy(da->field->value , &v, OXM_LENGTH(da->field->header)); break; } } *len -= ROUND_UP(ntohs(src->len),8); *dst = (struct ofl_action_header *)da; break; } case OFPAT_EXPERIMENTER: { ofl_err error; if (*len < sizeof(struct ofp_action_experimenter_header)) { OFL_LOG_WARN(LOG_MODULE, "Received EXPERIMENTER action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } if (exp == NULL || exp->act == NULL || exp->act->unpack == NULL) { OFL_LOG_WARN(LOG_MODULE, "Received EXPERIMENTER action, but no callback is given."); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_EXPERIMENTER); } error = exp->act->unpack(src, len, dst); if (error) { return error; } break; } default: { OFL_LOG_WARN(LOG_MODULE, "Received unknown action type (%u).", ntohs(src->type)); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_TYPE); } } (*dst)->type = (enum ofp_action_type)ntohs(src->type); return 0; }
ofl_err ofl_actions_unpack(struct ofp_action_header *src, size_t *len, struct ofl_action_header **dst, struct ofl_exp *exp) { if (*len < sizeof(struct ofp_action_header)) { OFL_LOG_WARN(LOG_MODULE, "Received action is too short (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } if (*len < ntohs(src->len)) { OFL_LOG_WARN(LOG_MODULE, "Received action has invalid length (set to %u, but only %zu received).", ntohs(src->len), *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } if ((ntohs(src->len) % 8) != 0) { OFL_LOG_WARN(LOG_MODULE, "Received action length is not a multiple of 64 bits (%u).", ntohs(src->len)); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } switch (ntohs(src->type)) { case OFPAT_OUTPUT: { struct ofp_action_output *sa; struct ofl_action_output *da; if (*len < sizeof(struct ofp_action_output)) { OFL_LOG_WARN(LOG_MODULE, "Received OUTPUT action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } sa = (struct ofp_action_output *)src; if (ntohl(sa->port) == 0 || (ntohl(sa->port) > OFPP_MAX && ntohl(sa->port) < OFPP_IN_PORT) || ntohl(sa->port) == OFPP_ANY) { if (OFL_LOG_IS_WARN_ENABLED(LOG_MODULE)) { char *ps = ofl_port_to_string(ntohl(sa->port)); OFL_LOG_WARN(LOG_MODULE, "Received OUTPUT action has invalid port (%s).", ps); free(ps); } return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_OUT_PORT); } da = (struct ofl_action_output *)malloc(sizeof(struct ofl_action_output)); da->port = ntohl(sa->port); da->max_len = ntohs(sa->max_len); *len -= sizeof(struct ofp_action_output); *dst = (struct ofl_action_header *)da; break; } case OFPAT_SET_VLAN_VID: { struct ofp_action_vlan_vid *sa; struct ofl_action_vlan_vid *da; if (*len < sizeof(struct ofp_action_vlan_vid)) { OFL_LOG_WARN(LOG_MODULE, "Received SET_VLAN_VID action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } sa = (struct ofp_action_vlan_vid *)src; if (ntohs(sa->vlan_vid) > VLAN_VID_MAX) { if (OFL_LOG_IS_WARN_ENABLED(LOG_MODULE)) { char *vs = ofl_vlan_vid_to_string(ntohs(sa->vlan_vid)); OFL_LOG_WARN(LOG_MODULE, "Received SET_VLAN_VID action has invalid vid (%s).", vs); free(vs); } return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_ARGUMENT); } da = (struct ofl_action_vlan_vid *)malloc(sizeof(struct ofl_action_vlan_vid)); da->vlan_vid = ntohs(sa->vlan_vid); *len -= sizeof(struct ofp_action_vlan_vid); *dst = (struct ofl_action_header *)da; break; } case OFPAT_SET_VLAN_PCP: { struct ofp_action_vlan_pcp *sa; struct ofl_action_vlan_pcp *da; if (*len < sizeof(struct ofp_action_vlan_pcp)) { OFL_LOG_WARN(LOG_MODULE, "Received SET_VLAN_PCP action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } sa = (struct ofp_action_vlan_pcp *)src; if (sa->vlan_pcp > VLAN_PCP_MAX) { OFL_LOG_WARN(LOG_MODULE, "Received SET_VLAN_PCP action has invalid pcp (%u).", sa->vlan_pcp); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_ARGUMENT); } da = (struct ofl_action_vlan_pcp *)malloc(sizeof(struct ofl_action_vlan_pcp)); da->vlan_pcp = sa->vlan_pcp; *len -= sizeof(struct ofp_action_vlan_pcp); *dst = (struct ofl_action_header *)da; break; } case OFPAT_SET_DL_SRC: case OFPAT_SET_DL_DST: { struct ofp_action_dl_addr *sa; struct ofl_action_dl_addr *da; if (*len < sizeof(struct ofp_action_dl_addr)) { OFL_LOG_WARN(LOG_MODULE, "Received SET_DL_SRC/DST action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } sa = (struct ofp_action_dl_addr *)src; da = (struct ofl_action_dl_addr *)malloc(sizeof(struct ofl_action_dl_addr)); memcpy(&(da->dl_addr), &(sa->dl_addr), OFP_ETH_ALEN); *len -= sizeof(struct ofp_action_dl_addr); *dst = (struct ofl_action_header *)da; break; } case OFPAT_SET_NW_SRC: case OFPAT_SET_NW_DST: { struct ofp_action_nw_addr *sa; struct ofl_action_nw_addr *da; if (*len < sizeof(struct ofp_action_nw_addr)) { OFL_LOG_WARN(LOG_MODULE, "Received SET_NW_SRC/DST action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } sa = (struct ofp_action_nw_addr *)src; da = (struct ofl_action_nw_addr *)malloc(sizeof(struct ofl_action_nw_addr)); da->nw_addr = sa->nw_addr; *len -= sizeof(struct ofp_action_nw_addr); *dst = (struct ofl_action_header *)da; break; } case OFPAT_SET_NW_TOS: { struct ofp_action_nw_tos *sa; struct ofl_action_nw_tos *da; if (*len < sizeof(struct ofp_action_nw_tos)) { OFL_LOG_WARN(LOG_MODULE, "Received SET_NW_TOS action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } sa = (struct ofp_action_nw_tos *)src; if (sa->nw_tos > IP_DSCP_MASK) { OFL_LOG_WARN(LOG_MODULE, "Received SET_NW_TOS action has invalid tos value (%u).", sa->nw_tos); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_ARGUMENT); } da = (struct ofl_action_nw_tos *)malloc(sizeof(struct ofl_action_nw_tos)); da->nw_tos = sa->nw_tos; *len -= sizeof(struct ofp_action_nw_tos); *dst = (struct ofl_action_header *)da; break; } case OFPAT_SET_NW_ECN: { struct ofp_action_nw_ecn *sa; struct ofl_action_nw_ecn *da; if (*len < sizeof(struct ofp_action_nw_ecn)) { OFL_LOG_WARN(LOG_MODULE, "Received SET_NW_ECN action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } sa = (struct ofp_action_nw_ecn *)src; if (sa->nw_ecn > IP_ECN_MASK) { OFL_LOG_WARN(LOG_MODULE, "Received SET_NW_ECN action has invalid ecn value (%u).", sa->nw_ecn); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_ARGUMENT); } da = (struct ofl_action_nw_ecn *)malloc(sizeof(struct ofl_action_nw_ecn)); da->nw_ecn = sa->nw_ecn; *len -= sizeof(struct ofp_action_nw_ecn); *dst = (struct ofl_action_header *)da; break; } case OFPAT_SET_TP_SRC: case OFPAT_SET_TP_DST: { struct ofp_action_tp_port *sa; struct ofl_action_tp_port *da; if (*len < sizeof(struct ofp_action_tp_port)) { OFL_LOG_WARN(LOG_MODULE, "Received SET_TP_SRC/DST action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } sa = (struct ofp_action_tp_port *)src; da = (struct ofl_action_tp_port *)malloc(sizeof(struct ofl_action_tp_port)); da->tp_port = ntohs(sa->tp_port); *len -= sizeof(struct ofp_action_tp_port); *dst = (struct ofl_action_header *)da; break; } case OFPAT_COPY_TTL_OUT: { //ofp_action_header length was already checked *len -= sizeof(struct ofp_action_header); *dst = (struct ofl_action_header *)malloc(sizeof(struct ofl_action_header)); break; } case OFPAT_COPY_TTL_IN: { //ofp_action_header length was already checked *len -= sizeof(struct ofp_action_header); *dst = (struct ofl_action_header *)malloc(sizeof(struct ofl_action_header)); break; } case OFPAT_SET_MPLS_LABEL: { struct ofp_action_mpls_label *sa; struct ofl_action_mpls_label *da; if (*len < sizeof(struct ofp_action_mpls_label)) { OFL_LOG_WARN(LOG_MODULE, "Received SET_MPLS_LABEL action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } sa = (struct ofp_action_mpls_label *)src; if (ntohl(sa->mpls_label) > MPLS_LABEL_MAX) { OFL_LOG_WARN(LOG_MODULE, "Received SET_MPLS_LABEL action has invalid label value (%u).", ntohl(sa->mpls_label)); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_ARGUMENT); } da = (struct ofl_action_mpls_label *)malloc(sizeof(struct ofl_action_mpls_label)); da->mpls_label = ntohl(sa->mpls_label); *len -= sizeof(struct ofp_action_mpls_label); *dst = (struct ofl_action_header *)da; break; } case OFPAT_SET_MPLS_TC: { struct ofp_action_mpls_tc *sa; struct ofl_action_mpls_tc *da; if (*len < sizeof(struct ofp_action_mpls_tc)) { OFL_LOG_WARN(LOG_MODULE, "Received SET_MPLS_TC action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } sa = (struct ofp_action_mpls_tc *)src; if (sa->mpls_tc > MPLS_TC_MAX) { OFL_LOG_WARN(LOG_MODULE, "Received SET_MPLS_TC action has invalid tc value (%u).", sa->mpls_tc); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_ARGUMENT); } da = (struct ofl_action_mpls_tc *)malloc(sizeof(struct ofl_action_mpls_tc)); da->mpls_tc = sa->mpls_tc; *len -= sizeof(struct ofp_action_mpls_tc); *dst = (struct ofl_action_header *)da; break; } case OFPAT_SET_MPLS_TTL: { struct ofp_action_mpls_ttl *sa; struct ofl_action_mpls_ttl *da; if (*len < sizeof(struct ofp_action_mpls_ttl)) { OFL_LOG_WARN(LOG_MODULE, "Received SET_MPLS_TTL action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } sa = (struct ofp_action_mpls_ttl *)src; da = (struct ofl_action_mpls_ttl *)malloc(sizeof(struct ofl_action_mpls_ttl)); da->mpls_ttl = sa->mpls_ttl; *len -= sizeof(struct ofp_action_mpls_ttl); *dst = (struct ofl_action_header *)da; break; } case OFPAT_DEC_MPLS_TTL: { //ofp_action_header length was already checked *len -= sizeof(struct ofp_action_mpls_ttl); *dst = (struct ofl_action_header *)malloc(sizeof(struct ofl_action_header)); break; } case OFPAT_PUSH_VLAN: case OFPAT_PUSH_MPLS: { struct ofp_action_push *sa; struct ofl_action_push *da; if (*len < sizeof(struct ofp_action_push)) { OFL_LOG_WARN(LOG_MODULE, "Received PUSH_VLAN/MPLS action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } sa = (struct ofp_action_push *)src; if (((ntohs(src->type) == OFPAT_PUSH_VLAN) && (ntohs(sa->ethertype) != ETH_TYPE_VLAN && ntohs(sa->ethertype) != ETH_TYPE_VLAN_PBB)) || ((ntohs(src->type) == OFPAT_PUSH_MPLS) && (ntohs(sa->ethertype) != ETH_TYPE_MPLS && ntohs(sa->ethertype) != ETH_TYPE_MPLS_MCAST))) { OFL_LOG_WARN(LOG_MODULE, "Received PUSH_VLAN/MPLS has invalid eth type. (%u)", ntohs(sa->ethertype)); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_ARGUMENT); } da = (struct ofl_action_push *)malloc(sizeof(struct ofl_action_push)); da->ethertype = ntohs(sa->ethertype); *len -= sizeof(struct ofp_action_push); *dst = (struct ofl_action_header *)da; break; } case OFPAT_POP_VLAN: { //ofp_action_header length was already checked *len -= sizeof(struct ofp_action_header); *dst = (struct ofl_action_header *)malloc(sizeof(struct ofl_action_header)); break; } case OFPAT_POP_MPLS: { struct ofp_action_pop_mpls *sa; struct ofl_action_pop_mpls *da; if (*len < sizeof(struct ofp_action_pop_mpls)) { OFL_LOG_WARN(LOG_MODULE, "Received POP_MPLS action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } sa = (struct ofp_action_pop_mpls *)src; da = (struct ofl_action_pop_mpls *)malloc(sizeof(struct ofl_action_pop_mpls)); da->ethertype = ntohs(sa->ethertype); *len -= sizeof(struct ofp_action_pop_mpls); *dst = (struct ofl_action_header *)da; break; } case OFPAT_SET_QUEUE: { struct ofp_action_set_queue *sa; struct ofl_action_set_queue *da; if (*len < sizeof(struct ofp_action_set_queue)) { OFL_LOG_WARN(LOG_MODULE, "Received SET_QUEUE action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } sa = (struct ofp_action_set_queue *)src; da = (struct ofl_action_set_queue *)malloc(sizeof(struct ofl_action_set_queue)); da->queue_id = ntohl(sa->queue_id); *len -= sizeof(struct ofp_action_set_queue); *dst = (struct ofl_action_header *)da; break; } case OFPAT_GROUP: { struct ofp_action_group *sa; struct ofl_action_group *da; if (*len < sizeof(struct ofp_action_group)) { OFL_LOG_WARN(LOG_MODULE, "Received GROUP action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } sa = (struct ofp_action_group *)src; if (ntohl(sa->group_id) > OFPG_MAX) { if (OFL_LOG_IS_WARN_ENABLED(LOG_MODULE)) { char *gs = ofl_group_to_string(ntohl(sa->group_id)); OFL_LOG_WARN(LOG_MODULE, "Received GROUP action has invalid group id (%s).", gs); free(gs); } return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_ARGUMENT); } da = (struct ofl_action_group *)malloc(sizeof(struct ofl_action_group)); da->group_id = ntohl(sa->group_id); *len -= sizeof(struct ofp_action_group); *dst = (struct ofl_action_header *)da; break; } case OFPAT_SET_NW_TTL: { struct ofp_action_nw_ttl *sa; struct ofl_action_set_nw_ttl *da; if (*len < sizeof(struct ofp_action_nw_ttl)) { OFL_LOG_WARN(LOG_MODULE, "Received SET_NW_TTL action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } sa = (struct ofp_action_nw_ttl *)src; da = (struct ofl_action_set_nw_ttl *)malloc(sizeof(struct ofl_action_set_nw_ttl)); da->nw_ttl = ntohs(sa->nw_ttl); *len -= sizeof(struct ofp_action_nw_ttl); *dst = (struct ofl_action_header *)da; break; } case OFPAT_DEC_NW_TTL: { //ofp_action_header length was already checked *len -= sizeof(struct ofp_action_header); *dst = (struct ofl_action_header *)malloc(sizeof(struct ofl_action_header)); break; } case OFPAT_EXPERIMENTER: { ofl_err error; if (*len < sizeof(struct ofp_action_experimenter_header)) { OFL_LOG_WARN(LOG_MODULE, "Received EXPERIMENTER action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } if (exp == NULL || exp->act == NULL || exp->act->unpack == NULL) { OFL_LOG_WARN(LOG_MODULE, "Received EXPERIMENTER action, but no callback is given."); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_EXPERIMENTER); } error = exp->act->unpack(src, len, dst); if (error) { return error; } break; } default: { OFL_LOG_WARN(LOG_MODULE, "Received unknown action type (%u).", ntohs(src->type)); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_TYPE); } } (*dst)->type = (enum ofp_action_type)ntohs(src->type); return 0; }
static ofl_err ofl_msg_unpack_packet_out(struct ofp_header *src, size_t *len, struct ofl_msg_header **msg, struct ofl_exp *exp, char *errbuf) { struct ofp_packet_out *sp; struct ofl_msg_packet_out *dp; struct ofp_action_header *act; uint8_t *data; ofl_err error; size_t i, actions_num; if (*len < sizeof(struct ofp_packet_out)) { if (errbuf != NULL) { snprintf(errbuf, OFL_ERRBUF_SIZE, "Received PACKET_OUT message has invalid length (%zu).", *len); } return ofl_error(OFPET_BAD_ACTION, OFPBRC_BAD_LEN); } sp = (struct ofp_packet_out *)src; if (ntohl(sp->in_port) == 0 || (ntohl(sp->in_port) > OFPP_MAX && ntohl(sp->in_port) != OFPP_CONTROLLER)) { if (errbuf != NULL) { char *ps = ofl_port_to_string(ntohl(sp->in_port)); snprintf(errbuf, OFL_ERRBUF_SIZE, "Received PACKET_OUT message with invalid in_port (%s).", ps); free(ps); } return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_ARGUMENT); } if (ntohl(sp->buffer_id) != 0xffffffff && *len != sizeof(struct ofp_packet_out) + ntohs(sp->actions_len)) { if (errbuf != NULL) { char *bs = ofl_buffer_to_string(ntohl(sp->buffer_id)); snprintf(errbuf, OFL_ERRBUF_SIZE, "Received PACKET_OUT message with data and buffer_id (%s).", bs); free(bs); } return ofl_error(OFPET_BAD_ACTION, OFPBRC_BAD_LEN); } *len -= sizeof(struct ofp_packet_out); dp = (struct ofl_msg_packet_out *)malloc(sizeof(struct ofl_msg_packet_out)); dp->buffer_id = ntohl(sp->buffer_id); dp->in_port = ntohl(sp->in_port); if (*len < ntohs(sp->actions_len)) { if (errbuf != NULL) { snprintf(errbuf, OFL_ERRBUF_SIZE, "Received PACKET_OUT message has invalid action length (%zu).", *len); } free(dp); return ofl_error(OFPET_BAD_ACTION, OFPBRC_BAD_LEN); } error = ofl_utils_count_ofp_actions(&(sp->actions), ntohs(sp->actions_len), &actions_num, errbuf); if (error) { free(dp); return error; } dp->actions_num = actions_num; dp->actions = (struct ofl_action_header **)malloc(dp->actions_num * sizeof(struct ofp_action_header *)); // TODO Zoltan: Output actions can contain OFPP_TABLE act = sp->actions; for (i = 0; i < dp->actions_num; i++) { error = ofl_actions_unpack(act, len, &(dp->actions[i]), exp, errbuf); if (error) { OFL_UTILS_FREE_ARR_FUN3(dp->actions, i, ofl_actions_free, exp, errbuf); free(dp); } act = (struct ofp_action_header *)((uint8_t *)act + ntohs(act->len)); } data = ((uint8_t *)sp->actions) + ntohs(sp->actions_len); dp->data_length = *len; dp->data = *len > 0 ? (uint8_t *)memcpy(malloc(*len), data, *len) : NULL; *len = 0; *msg = (struct ofl_msg_header *)dp; return 0; }