ofproto/bundles.c

   1 /*
   2  * Copyright (c) 2013, 2014 Alexandru Copot <alex.mihai.c@gmail.com>, with support from IXIA.
   3  * Copyright (c) 2013, 2014 Daniel Baluta <dbaluta@ixiacom.com>
   4  * Copyright (c) 2014, 2015, 2016 Nicira, Inc.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at:
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19 #include <config.h>
  20
  21 #include "bundles.h"
  22 #include "coverage.h"
  23 #include "fail-open.h"
  24 #include "in-band.h"
  25 #include "odp-util.h"
  26 #include "ofproto-provider.h"
  27 #include "openvswitch/ofp-actions.h"
  28 #include "openvswitch/ofp-msgs.h"
  29 #include "openvswitch/ofpbuf.h"
  30 #include "openvswitch/vconn.h"
  31 #include "openvswitch/vlog.h"
  32 #include "pinsched.h"
  33 #include "openvswitch/poll-loop.h"
  34 #include "openvswitch/rconn.h"
  35 #include "openvswitch/shash.h"
  36 #include "simap.h"
  37 #include "stream.h"
  38 #include "timeval.h"
  39
  40 VLOG_DEFINE_THIS_MODULE(bundles);
  41
  42 static struct ofp_bundle *
  43 ofp_bundle_create(uint32_t id, uint16_t flags, const struct ofp_header *oh)
  44 {
  45     struct ofp_bundle *bundle;
  46
  47     bundle = xmalloc(sizeof(*bundle));
  48
  49     bundle->used = time_msec();
  50     bundle->id = id;
  51     bundle->flags = flags;
  52     bundle->state = BS_OPEN;
  53     bundle->msg = xmemdup(oh, ntohs(oh->length));
  54
  55     ovs_list_init(&bundle->msg_list);
  56
  57     return bundle;
  58 }
  59
  60 void
  61 ofp_bundle_remove__(struct ofconn *ofconn, struct ofp_bundle *bundle)
  62 {
  63     struct ofp_bundle_entry *msg;
  64
  65     LIST_FOR_EACH_POP (msg, node, &bundle->msg_list) {
  66         ofp_bundle_entry_free(msg);
  67     }
  68
  69     ofconn_remove_bundle(ofconn, bundle);
  70     free(bundle->msg);
  71     free(bundle);
  72 }
  73
  74 enum ofperr
  75 ofp_bundle_open(struct ofconn *ofconn, uint32_t id, uint16_t flags,
  76                 const struct ofp_header *oh)
  77 {
  78     struct ofp_bundle *bundle;
  79
  80     bundle = ofconn_get_bundle(ofconn, id);
  81
  82     if (bundle) {
  83         VLOG_INFO("Bundle %x already exists.", id);
  84         ofp_bundle_remove__(ofconn, bundle);
  85
  86         return OFPERR_OFPBFC_BAD_ID;
  87     }
  88
  89     bundle = ofp_bundle_create(id, flags, oh);
  90     ofconn_insert_bundle(ofconn, bundle);
  91
  92     return 0;
  93 }
  94
  95 enum ofperr
  96 ofp_bundle_close(struct ofconn *ofconn, uint32_t id, uint16_t flags)
  97 {
  98     struct ofp_bundle *bundle;
  99
 100     bundle = ofconn_get_bundle(ofconn, id);
 101
 102     if (!bundle) {
 103         return OFPERR_OFPBFC_BAD_ID;
 104     }
 105
 106     if (bundle->state == BS_CLOSED) {
 107         ofp_bundle_remove__(ofconn, bundle);
 108         return OFPERR_OFPBFC_BUNDLE_CLOSED;
 109     }
 110
 111     if (bundle->flags != flags) {
 112         ofp_bundle_remove__(ofconn, bundle);
 113         return OFPERR_OFPBFC_BAD_FLAGS;
 114     }
 115
 116     bundle->used = time_msec();
 117     bundle->state = BS_CLOSED;
 118     return 0;
 119 }
 120
 121 enum ofperr
 122 ofp_bundle_discard(struct ofconn *ofconn, uint32_t id)
 123 {
 124     struct ofp_bundle *bundle;
 125
 126     bundle = ofconn_get_bundle(ofconn, id);
 127
 128     if (!bundle) {
 129         return OFPERR_OFPBFC_BAD_ID;
 130     }
 131
 132     ofp_bundle_remove__(ofconn, bundle);
 133     return 0;
 134 }
 135
 136 enum ofperr
 137 ofp_bundle_add_message(struct ofconn *ofconn, uint32_t id, uint16_t flags,
 138                        struct ofp_bundle_entry *bmsg,
 139                        const struct ofp_header *oh)
 140 {
 141     struct ofp_bundle *bundle;
 142
 143     bundle = ofconn_get_bundle(ofconn, id);
 144
 145     if (!bundle) {
 146         bundle = ofp_bundle_create(id, flags, oh);
 147         ofconn_insert_bundle(ofconn, bundle);
 148     } else if (bundle->state == BS_CLOSED) {
 149         ofp_bundle_remove__(ofconn, bundle);
 150         return OFPERR_OFPBFC_BUNDLE_CLOSED;
 151     } else if (flags != bundle->flags) {
 152         ofp_bundle_remove__(ofconn, bundle);
 153         return OFPERR_OFPBFC_BAD_FLAGS;
 154     }
 155
 156     bundle->used = time_msec();
 157     ovs_list_push_back(&bundle->msg_list, &bmsg->node);
 158     return 0;
 159 }