]>
Commit | Line | Data |
---|---|---|
1 | /* | |
2 | * Copyright (c) 2008-2017 Nicira, Inc. | |
3 | * | |
4 | * Licensed under the Apache License, Version 2.0 (the "License"); | |
5 | * you may not use this file except in compliance with the License. | |
6 | * You may obtain a copy of the License at: | |
7 | * | |
8 | * http://www.apache.org/licenses/LICENSE-2.0 | |
9 | * | |
10 | * Unless required by applicable law or agreed to in writing, software | |
11 | * distributed under the License is distributed on an "AS IS" BASIS, | |
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
13 | * See the License for the specific language governing permissions and | |
14 | * limitations under the License. | |
15 | */ | |
16 | ||
17 | #include <config.h> | |
18 | #include "openvswitch/ofp-group.h" | |
19 | #include <errno.h> | |
20 | #include "byte-order.h" | |
21 | #include "id-pool.h" | |
22 | #include "nx-match.h" | |
23 | #include "openvswitch/ofp-actions.h" | |
24 | #include "openvswitch/dynamic-string.h" | |
25 | #include "openvswitch/ofp-msgs.h" | |
26 | #include "openvswitch/ofp-parse.h" | |
27 | #include "openvswitch/ofp-port.h" | |
28 | #include "openvswitch/ofp-print.h" | |
29 | #include "openvswitch/ofp-prop.h" | |
30 | #include "openvswitch/ofpbuf.h" | |
31 | #include "openvswitch/vlog.h" | |
32 | #include "util.h" | |
33 | ||
34 | VLOG_DEFINE_THIS_MODULE(ofp_group); | |
35 | ||
36 | static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5); | |
37 | ||
38 | /* Stores the group id represented by 's' into '*group_idp'. 's' may be an | |
39 | * integer or, for reserved group IDs, the standard OpenFlow name for the group | |
40 | * (either "ANY" or "ALL"). | |
41 | * | |
42 | * Returns true if successful, false if 's' is not a valid OpenFlow group ID or | |
43 | * name. */ | |
44 | bool | |
45 | ofputil_group_from_string(const char *s, uint32_t *group_idp) | |
46 | { | |
47 | if (!strcasecmp(s, "any")) { | |
48 | *group_idp = OFPG_ANY; | |
49 | } else if (!strcasecmp(s, "all")) { | |
50 | *group_idp = OFPG_ALL; | |
51 | } else if (!str_to_uint(s, 10, group_idp)) { | |
52 | VLOG_WARN("%s is not a valid group ID. (Valid group IDs are " | |
53 | "32-bit nonnegative integers or the keywords ANY or " | |
54 | "ALL.)", s); | |
55 | return false; | |
56 | } | |
57 | ||
58 | return true; | |
59 | } | |
60 | ||
61 | /* Appends to 's' a string representation of the OpenFlow group ID 'group_id'. | |
62 | * Most groups' string representation is just the number, but for special | |
63 | * groups, e.g. OFPG_ALL, it is the name, e.g. "ALL". */ | |
64 | void | |
65 | ofputil_format_group(uint32_t group_id, struct ds *s) | |
66 | { | |
67 | char name[MAX_GROUP_NAME_LEN]; | |
68 | ||
69 | ofputil_group_to_string(group_id, name, sizeof name); | |
70 | ds_put_cstr(s, name); | |
71 | } | |
72 | ||
73 | ||
74 | /* Puts in the 'bufsize' byte in 'namebuf' a null-terminated string | |
75 | * representation of OpenFlow group ID 'group_id'. Most group are represented | |
76 | * as just their number, but special groups, e.g. OFPG_ALL, are represented | |
77 | * by name, e.g. "ALL". */ | |
78 | void | |
79 | ofputil_group_to_string(uint32_t group_id, | |
80 | char namebuf[MAX_GROUP_NAME_LEN + 1], size_t bufsize) | |
81 | { | |
82 | switch (group_id) { | |
83 | case OFPG_ALL: | |
84 | ovs_strlcpy(namebuf, "ALL", bufsize); | |
85 | break; | |
86 | ||
87 | case OFPG_ANY: | |
88 | ovs_strlcpy(namebuf, "ANY", bufsize); | |
89 | break; | |
90 | ||
91 | default: | |
92 | snprintf(namebuf, bufsize, "%"PRIu32, group_id); | |
93 | break; | |
94 | } | |
95 | } | |
96 | \f | |
97 | /* Frees all of the "struct ofputil_bucket"s in the 'buckets' list. */ | |
98 | void | |
99 | ofputil_bucket_list_destroy(struct ovs_list *buckets) | |
100 | { | |
101 | struct ofputil_bucket *bucket; | |
102 | ||
103 | LIST_FOR_EACH_POP (bucket, list_node, buckets) { | |
104 | free(bucket->ofpacts); | |
105 | free(bucket); | |
106 | } | |
107 | } | |
108 | ||
109 | /* Clones 'bucket' and its ofpacts data */ | |
110 | static struct ofputil_bucket * | |
111 | ofputil_bucket_clone_data(const struct ofputil_bucket *bucket) | |
112 | { | |
113 | struct ofputil_bucket *new; | |
114 | ||
115 | new = xmemdup(bucket, sizeof *bucket); | |
116 | new->ofpacts = xmemdup(bucket->ofpacts, bucket->ofpacts_len); | |
117 | ||
118 | return new; | |
119 | } | |
120 | ||
121 | /* Clones each of the buckets in the list 'src' appending them | |
122 | * in turn to 'dest' which should be an initialised list. | |
123 | * An exception is that if the pointer value of a bucket in 'src' | |
124 | * matches 'skip' then it is not cloned or appended to 'dest'. | |
125 | * This allows all of 'src' or 'all of 'src' except 'skip' to | |
126 | * be cloned and appended to 'dest'. */ | |
127 | void | |
128 | ofputil_bucket_clone_list(struct ovs_list *dest, const struct ovs_list *src, | |
129 | const struct ofputil_bucket *skip) | |
130 | { | |
131 | struct ofputil_bucket *bucket; | |
132 | ||
133 | LIST_FOR_EACH (bucket, list_node, src) { | |
134 | struct ofputil_bucket *new_bucket; | |
135 | ||
136 | if (bucket == skip) { | |
137 | continue; | |
138 | } | |
139 | ||
140 | new_bucket = ofputil_bucket_clone_data(bucket); | |
141 | ovs_list_push_back(dest, &new_bucket->list_node); | |
142 | } | |
143 | } | |
144 | ||
145 | /* Find a bucket in the list 'buckets' whose bucket id is 'bucket_id' | |
146 | * Returns the first bucket found or NULL if no buckets are found. */ | |
147 | struct ofputil_bucket * | |
148 | ofputil_bucket_find(const struct ovs_list *buckets, uint32_t bucket_id) | |
149 | { | |
150 | struct ofputil_bucket *bucket; | |
151 | ||
152 | if (bucket_id > OFPG15_BUCKET_MAX) { | |
153 | return NULL; | |
154 | } | |
155 | ||
156 | LIST_FOR_EACH (bucket, list_node, buckets) { | |
157 | if (bucket->bucket_id == bucket_id) { | |
158 | return bucket; | |
159 | } | |
160 | } | |
161 | ||
162 | return NULL; | |
163 | } | |
164 | ||
165 | /* Returns true if more than one bucket in the list 'buckets' | |
166 | * have the same bucket id. Returns false otherwise. */ | |
167 | bool | |
168 | ofputil_bucket_check_duplicate_id(const struct ovs_list *buckets) | |
169 | { | |
170 | struct ofputil_bucket *i, *j; | |
171 | ||
172 | LIST_FOR_EACH (i, list_node, buckets) { | |
173 | LIST_FOR_EACH_REVERSE (j, list_node, buckets) { | |
174 | if (i == j) { | |
175 | break; | |
176 | } | |
177 | if (i->bucket_id == j->bucket_id) { | |
178 | return true; | |
179 | } | |
180 | } | |
181 | } | |
182 | ||
183 | return false; | |
184 | } | |
185 | ||
186 | /* Returns the bucket at the front of the list 'buckets'. | |
187 | * Undefined if 'buckets is empty. */ | |
188 | struct ofputil_bucket * | |
189 | ofputil_bucket_list_front(const struct ovs_list *buckets) | |
190 | { | |
191 | static struct ofputil_bucket *bucket; | |
192 | ||
193 | ASSIGN_CONTAINER(bucket, ovs_list_front(buckets), list_node); | |
194 | ||
195 | return bucket; | |
196 | } | |
197 | ||
198 | /* Returns the bucket at the back of the list 'buckets'. | |
199 | * Undefined if 'buckets is empty. */ | |
200 | struct ofputil_bucket * | |
201 | ofputil_bucket_list_back(const struct ovs_list *buckets) | |
202 | { | |
203 | static struct ofputil_bucket *bucket; | |
204 | ||
205 | ASSIGN_CONTAINER(bucket, ovs_list_back(buckets), list_node); | |
206 | ||
207 | return bucket; | |
208 | } | |
209 | ||
210 | /* Returns an OpenFlow group stats request for OpenFlow version 'ofp_version', | |
211 | * that requests stats for group 'group_id'. (Use OFPG_ALL to request stats | |
212 | * for all groups.) | |
213 | * | |
214 | * Group statistics include packet and byte counts for each group. */ | |
215 | struct ofpbuf * | |
216 | ofputil_encode_group_stats_request(enum ofp_version ofp_version, | |
217 | uint32_t group_id) | |
218 | { | |
219 | struct ofpbuf *msg = ofpraw_alloc((ofp_version == OFP10_VERSION | |
220 | ? OFPRAW_NXST_GROUP_REQUEST | |
221 | : OFPRAW_OFPST11_GROUP_REQUEST), | |
222 | ofp_version, 0); | |
223 | struct ofp11_group_stats_request *req = ofpbuf_put_zeros(msg, sizeof *req); | |
224 | req->group_id = htonl(group_id); | |
225 | ||
226 | return msg; | |
227 | } | |
228 | ||
229 | void | |
230 | ofputil_uninit_group_desc(struct ofputil_group_desc *gd) | |
231 | { | |
232 | ofputil_bucket_list_destroy(&gd->buckets); | |
233 | ofputil_group_properties_destroy(&gd->props); | |
234 | } | |
235 | ||
236 | /* Decodes the OpenFlow group description request in 'oh', returning the group | |
237 | * whose description is requested, or OFPG_ALL if stats for all groups was | |
238 | * requested. */ | |
239 | uint32_t | |
240 | ofputil_decode_group_desc_request(const struct ofp_header *oh) | |
241 | { | |
242 | struct ofpbuf request = ofpbuf_const_initializer(oh, ntohs(oh->length)); | |
243 | enum ofpraw raw = ofpraw_pull_assert(&request); | |
244 | if (raw == OFPRAW_OFPST11_GROUP_DESC_REQUEST) { | |
245 | return OFPG_ALL; | |
246 | } else if (raw == OFPRAW_NXST_GROUP_DESC_REQUEST || | |
247 | raw == OFPRAW_OFPST15_GROUP_DESC_REQUEST) { | |
248 | ovs_be32 *group_id = ofpbuf_pull(&request, sizeof *group_id); | |
249 | return ntohl(*group_id); | |
250 | } else { | |
251 | OVS_NOT_REACHED(); | |
252 | } | |
253 | } | |
254 | ||
255 | /* Returns an OpenFlow group description request for OpenFlow version | |
256 | * 'ofp_version', that requests stats for group 'group_id'. Use OFPG_ALL to | |
257 | * request stats for all groups (OpenFlow 1.4 and earlier always request all | |
258 | * groups). | |
259 | * | |
260 | * Group descriptions include the bucket and action configuration for each | |
261 | * group. */ | |
262 | struct ofpbuf * | |
263 | ofputil_encode_group_desc_request(enum ofp_version ofp_version, | |
264 | uint32_t group_id) | |
265 | { | |
266 | struct ofpbuf *request; | |
267 | ||
268 | switch (ofp_version) { | |
269 | case OFP11_VERSION: | |
270 | case OFP12_VERSION: | |
271 | case OFP13_VERSION: | |
272 | case OFP14_VERSION: | |
273 | request = ofpraw_alloc(OFPRAW_OFPST11_GROUP_DESC_REQUEST, | |
274 | ofp_version, 0); | |
275 | break; | |
276 | case OFP10_VERSION: | |
277 | case OFP15_VERSION: | |
278 | case OFP16_VERSION: { | |
279 | struct ofp15_group_desc_request *req; | |
280 | request = ofpraw_alloc((ofp_version == OFP10_VERSION | |
281 | ? OFPRAW_NXST_GROUP_DESC_REQUEST | |
282 | : OFPRAW_OFPST15_GROUP_DESC_REQUEST), | |
283 | ofp_version, 0); | |
284 | req = ofpbuf_put_zeros(request, sizeof *req); | |
285 | req->group_id = htonl(group_id); | |
286 | break; | |
287 | } | |
288 | default: | |
289 | OVS_NOT_REACHED(); | |
290 | } | |
291 | ||
292 | return request; | |
293 | } | |
294 | ||
295 | ||
296 | enum ofperr | |
297 | ofputil_group_desc_request_format(struct ds *string, | |
298 | const struct ofp_header *oh) | |
299 | { | |
300 | uint32_t group_id = ofputil_decode_group_desc_request(oh); | |
301 | ds_put_cstr(string, " group_id="); | |
302 | ofputil_format_group(group_id, string); | |
303 | ||
304 | return 0; | |
305 | } | |
306 | ||
307 | static void | |
308 | ofputil_group_bucket_counters_to_ofp11(const struct ofputil_group_stats *gs, | |
309 | struct ofp11_bucket_counter bucket_cnts[]) | |
310 | { | |
311 | int i; | |
312 | ||
313 | for (i = 0; i < gs->n_buckets; i++) { | |
314 | bucket_cnts[i].packet_count = htonll(gs->bucket_stats[i].packet_count); | |
315 | bucket_cnts[i].byte_count = htonll(gs->bucket_stats[i].byte_count); | |
316 | } | |
317 | } | |
318 | ||
319 | static void | |
320 | ofputil_group_stats_to_ofp11(const struct ofputil_group_stats *gs, | |
321 | struct ofp11_group_stats *gs11, size_t length, | |
322 | struct ofp11_bucket_counter bucket_cnts[]) | |
323 | { | |
324 | memset(gs11, 0, sizeof *gs11); | |
325 | gs11->length = htons(length); | |
326 | gs11->group_id = htonl(gs->group_id); | |
327 | gs11->ref_count = htonl(gs->ref_count); | |
328 | gs11->packet_count = htonll(gs->packet_count); | |
329 | gs11->byte_count = htonll(gs->byte_count); | |
330 | ofputil_group_bucket_counters_to_ofp11(gs, bucket_cnts); | |
331 | } | |
332 | ||
333 | static void | |
334 | ofputil_group_stats_to_ofp13(const struct ofputil_group_stats *gs, | |
335 | struct ofp13_group_stats *gs13, size_t length, | |
336 | struct ofp11_bucket_counter bucket_cnts[]) | |
337 | { | |
338 | ofputil_group_stats_to_ofp11(gs, &gs13->gs, length, bucket_cnts); | |
339 | gs13->duration_sec = htonl(gs->duration_sec); | |
340 | gs13->duration_nsec = htonl(gs->duration_nsec); | |
341 | ||
342 | } | |
343 | ||
344 | /* Encodes 'gs' properly for the format of the list of group statistics | |
345 | * replies already begun in 'replies' and appends it to the list. 'replies' | |
346 | * must have originally been initialized with ofpmp_init(). */ | |
347 | void | |
348 | ofputil_append_group_stats(struct ovs_list *replies, | |
349 | const struct ofputil_group_stats *gs) | |
350 | { | |
351 | size_t bucket_counter_size; | |
352 | struct ofp11_bucket_counter *bucket_counters; | |
353 | size_t length; | |
354 | ||
355 | bucket_counter_size = gs->n_buckets * sizeof(struct ofp11_bucket_counter); | |
356 | ||
357 | switch (ofpmp_version(replies)) { | |
358 | case OFP11_VERSION: | |
359 | case OFP12_VERSION:{ | |
360 | struct ofp11_group_stats *gs11; | |
361 | ||
362 | length = sizeof *gs11 + bucket_counter_size; | |
363 | gs11 = ofpmp_append(replies, length); | |
364 | bucket_counters = (struct ofp11_bucket_counter *)(gs11 + 1); | |
365 | ofputil_group_stats_to_ofp11(gs, gs11, length, bucket_counters); | |
366 | break; | |
367 | } | |
368 | ||
369 | case OFP10_VERSION: | |
370 | case OFP13_VERSION: | |
371 | case OFP14_VERSION: | |
372 | case OFP15_VERSION: | |
373 | case OFP16_VERSION: { | |
374 | struct ofp13_group_stats *gs13; | |
375 | ||
376 | length = sizeof *gs13 + bucket_counter_size; | |
377 | gs13 = ofpmp_append(replies, length); | |
378 | bucket_counters = (struct ofp11_bucket_counter *)(gs13 + 1); | |
379 | ofputil_group_stats_to_ofp13(gs, gs13, length, bucket_counters); | |
380 | break; | |
381 | } | |
382 | ||
383 | default: | |
384 | OVS_NOT_REACHED(); | |
385 | } | |
386 | } | |
387 | ||
388 | /* Returns an OpenFlow group features request for OpenFlow version | |
389 | * 'ofp_version'. */ | |
390 | struct ofpbuf * | |
391 | ofputil_encode_group_features_request(enum ofp_version ofp_version) | |
392 | { | |
393 | return ofpraw_alloc((ofp_version < OFP12_VERSION | |
394 | ? OFPRAW_NXST_GROUP_FEATURES_REQUEST | |
395 | : OFPRAW_OFPST12_GROUP_FEATURES_REQUEST), | |
396 | ofp_version, 0); | |
397 | } | |
398 | ||
399 | /* Returns a OpenFlow message that encodes 'features' properly as a reply to | |
400 | * group features request 'request'. */ | |
401 | struct ofpbuf * | |
402 | ofputil_encode_group_features_reply( | |
403 | const struct ofputil_group_features *features, | |
404 | const struct ofp_header *request) | |
405 | { | |
406 | struct ofpbuf *reply = ofpraw_alloc_stats_reply(request, 0); | |
407 | struct ofp12_group_features_stats *ogf | |
408 | = ofpbuf_put_zeros(reply, sizeof *ogf); | |
409 | ogf->types = htonl(features->types); | |
410 | ogf->capabilities = htonl(features->capabilities); | |
411 | for (int i = 0; i < OFPGT12_N_TYPES; i++) { | |
412 | ogf->max_groups[i] = htonl(features->max_groups[i]); | |
413 | ogf->actions[i] = ofpact_bitmap_to_openflow(features->ofpacts[i], | |
414 | request->version); | |
415 | } | |
416 | ||
417 | return reply; | |
418 | } | |
419 | ||
420 | /* Decodes group features reply 'oh' into 'features'. */ | |
421 | void | |
422 | ofputil_decode_group_features_reply(const struct ofp_header *oh, | |
423 | struct ofputil_group_features *features) | |
424 | { | |
425 | const struct ofp12_group_features_stats *ogf = ofpmsg_body(oh); | |
426 | int i; | |
427 | ||
428 | features->types = ntohl(ogf->types); | |
429 | features->capabilities = ntohl(ogf->capabilities); | |
430 | for (i = 0; i < OFPGT12_N_TYPES; i++) { | |
431 | features->max_groups[i] = ntohl(ogf->max_groups[i]); | |
432 | features->ofpacts[i] = ofpact_bitmap_from_openflow( | |
433 | ogf->actions[i], oh->version); | |
434 | } | |
435 | } | |
436 | ||
437 | static const char * | |
438 | group_type_to_string(enum ofp11_group_type type) | |
439 | { | |
440 | switch (type) { | |
441 | case OFPGT11_ALL: return "all"; | |
442 | case OFPGT11_SELECT: return "select"; | |
443 | case OFPGT11_INDIRECT: return "indirect"; | |
444 | case OFPGT11_FF: return "fast failover"; | |
445 | default: OVS_NOT_REACHED(); | |
446 | } | |
447 | } | |
448 | ||
449 | enum ofperr | |
450 | ofputil_group_features_format(struct ds *string, const struct ofp_header *oh) | |
451 | { | |
452 | struct ofputil_group_features features; | |
453 | int i; | |
454 | ||
455 | ofputil_decode_group_features_reply(oh, &features); | |
456 | ||
457 | ds_put_format(string, "\n Group table:\n"); | |
458 | ds_put_format(string, " Types: 0x%"PRIx32"\n", features.types); | |
459 | ds_put_format(string, " Capabilities: 0x%"PRIx32"\n", | |
460 | features.capabilities); | |
461 | ||
462 | for (i = 0; i < OFPGT12_N_TYPES; i++) { | |
463 | if (features.types & (1u << i)) { | |
464 | ds_put_format(string, " %s group:\n", group_type_to_string(i)); | |
465 | ds_put_format(string, " max_groups=%#"PRIx32"\n", | |
466 | features.max_groups[i]); | |
467 | ds_put_format(string, " actions: "); | |
468 | ofpact_bitmap_format(features.ofpacts[i], string); | |
469 | ds_put_char(string, '\n'); | |
470 | } | |
471 | } | |
472 | ||
473 | return 0; | |
474 | } | |
475 | ||
476 | /* Parse a group status request message into a 32 bit OpenFlow 1.1 | |
477 | * group ID and stores the latter in '*group_id'. | |
478 | * Returns 0 if successful, otherwise an OFPERR_* number. */ | |
479 | enum ofperr | |
480 | ofputil_decode_group_stats_request(const struct ofp_header *request, | |
481 | uint32_t *group_id) | |
482 | { | |
483 | const struct ofp11_group_stats_request *gsr11 = ofpmsg_body(request); | |
484 | *group_id = ntohl(gsr11->group_id); | |
485 | return 0; | |
486 | } | |
487 | ||
488 | /* Converts a group stats reply in 'msg' into an abstract ofputil_group_stats | |
489 | * in 'gs'. Assigns freshly allocated memory to gs->bucket_stats for the | |
490 | * caller to eventually free. | |
491 | * | |
492 | * Multiple group stats replies can be packed into a single OpenFlow message. | |
493 | * Calling this function multiple times for a single 'msg' iterates through the | |
494 | * replies. The caller must initially leave 'msg''s layer pointers null and | |
495 | * not modify them between calls. | |
496 | * | |
497 | * Returns 0 if successful, EOF if no replies were left in this 'msg', | |
498 | * otherwise a positive errno value. */ | |
499 | int | |
500 | ofputil_decode_group_stats_reply(struct ofpbuf *msg, | |
501 | struct ofputil_group_stats *gs) | |
502 | { | |
503 | struct ofp11_bucket_counter *obc; | |
504 | struct ofp11_group_stats *ogs11; | |
505 | enum ofpraw raw; | |
506 | enum ofperr error; | |
507 | size_t base_len; | |
508 | size_t length; | |
509 | size_t i; | |
510 | ||
511 | gs->bucket_stats = NULL; | |
512 | error = (msg->header ? ofpraw_decode(&raw, msg->header) | |
513 | : ofpraw_pull(&raw, msg)); | |
514 | if (error) { | |
515 | return error; | |
516 | } | |
517 | ||
518 | if (!msg->size) { | |
519 | return EOF; | |
520 | } | |
521 | ||
522 | if (raw == OFPRAW_OFPST11_GROUP_REPLY) { | |
523 | base_len = sizeof *ogs11; | |
524 | ogs11 = ofpbuf_try_pull(msg, sizeof *ogs11); | |
525 | gs->duration_sec = gs->duration_nsec = UINT32_MAX; | |
526 | } else if (raw == OFPRAW_NXST_GROUP_REPLY || | |
527 | raw == OFPRAW_OFPST13_GROUP_REPLY) { | |
528 | struct ofp13_group_stats *ogs13; | |
529 | ||
530 | base_len = sizeof *ogs13; | |
531 | ogs13 = ofpbuf_try_pull(msg, sizeof *ogs13); | |
532 | if (ogs13) { | |
533 | ogs11 = &ogs13->gs; | |
534 | gs->duration_sec = ntohl(ogs13->duration_sec); | |
535 | gs->duration_nsec = ntohl(ogs13->duration_nsec); | |
536 | } else { | |
537 | ogs11 = NULL; | |
538 | } | |
539 | } else { | |
540 | OVS_NOT_REACHED(); | |
541 | } | |
542 | ||
543 | if (!ogs11) { | |
544 | VLOG_WARN_RL(&rl, "%s reply has %"PRIu32" leftover bytes at end", | |
545 | ofpraw_get_name(raw), msg->size); | |
546 | return OFPERR_OFPBRC_BAD_LEN; | |
547 | } | |
548 | length = ntohs(ogs11->length); | |
549 | if (length < sizeof base_len) { | |
550 | VLOG_WARN_RL(&rl, "%s reply claims invalid length %"PRIuSIZE, | |
551 | ofpraw_get_name(raw), length); | |
552 | return OFPERR_OFPBRC_BAD_LEN; | |
553 | } | |
554 | ||
555 | gs->group_id = ntohl(ogs11->group_id); | |
556 | gs->ref_count = ntohl(ogs11->ref_count); | |
557 | gs->packet_count = ntohll(ogs11->packet_count); | |
558 | gs->byte_count = ntohll(ogs11->byte_count); | |
559 | ||
560 | gs->n_buckets = (length - base_len) / sizeof *obc; | |
561 | obc = ofpbuf_try_pull(msg, gs->n_buckets * sizeof *obc); | |
562 | if (!obc) { | |
563 | VLOG_WARN_RL(&rl, "%s reply has %"PRIu32" leftover bytes at end", | |
564 | ofpraw_get_name(raw), msg->size); | |
565 | return OFPERR_OFPBRC_BAD_LEN; | |
566 | } | |
567 | ||
568 | gs->bucket_stats = xmalloc(gs->n_buckets * sizeof *gs->bucket_stats); | |
569 | for (i = 0; i < gs->n_buckets; i++) { | |
570 | gs->bucket_stats[i].packet_count = ntohll(obc[i].packet_count); | |
571 | gs->bucket_stats[i].byte_count = ntohll(obc[i].byte_count); | |
572 | } | |
573 | ||
574 | return 0; | |
575 | } | |
576 | ||
577 | ||
578 | enum ofperr | |
579 | ofputil_group_stats_request_format(struct ds *string, | |
580 | const struct ofp_header *oh) | |
581 | { | |
582 | enum ofperr error; | |
583 | uint32_t group_id; | |
584 | ||
585 | error = ofputil_decode_group_stats_request(oh, &group_id); | |
586 | if (error) { | |
587 | return error; | |
588 | } | |
589 | ||
590 | ds_put_cstr(string, " group_id="); | |
591 | ofputil_format_group(group_id, string); | |
592 | return 0; | |
593 | } | |
594 | ||
595 | enum ofperr | |
596 | ofputil_group_stats_format(struct ds *s, const struct ofp_header *oh) | |
597 | { | |
598 | struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length)); | |
599 | for (;;) { | |
600 | struct ofputil_group_stats gs; | |
601 | int retval; | |
602 | ||
603 | retval = ofputil_decode_group_stats_reply(&b, &gs); | |
604 | if (retval) { | |
605 | if (retval != EOF) { | |
606 | ds_put_cstr(s, " ***parse error***"); | |
607 | return retval; | |
608 | } | |
609 | break; | |
610 | } | |
611 | ||
612 | ds_put_char(s, '\n'); | |
613 | ||
614 | ds_put_char(s, ' '); | |
615 | ds_put_format(s, "group_id=%"PRIu32",", gs.group_id); | |
616 | ||
617 | if (gs.duration_sec != UINT32_MAX) { | |
618 | ds_put_cstr(s, "duration="); | |
619 | ofp_print_duration(s, gs.duration_sec, gs.duration_nsec); | |
620 | ds_put_char(s, ','); | |
621 | } | |
622 | ds_put_format(s, "ref_count=%"PRIu32",", gs.ref_count); | |
623 | ds_put_format(s, "packet_count=%"PRIu64",", gs.packet_count); | |
624 | ds_put_format(s, "byte_count=%"PRIu64"", gs.byte_count); | |
625 | ||
626 | for (uint32_t bucket_i = 0; bucket_i < gs.n_buckets; bucket_i++) { | |
627 | if (gs.bucket_stats[bucket_i].packet_count != UINT64_MAX) { | |
628 | ds_put_format(s, ",bucket%"PRIu32":", bucket_i); | |
629 | ds_put_format(s, "packet_count=%"PRIu64",", gs.bucket_stats[bucket_i].packet_count); | |
630 | ds_put_format(s, "byte_count=%"PRIu64"", gs.bucket_stats[bucket_i].byte_count); | |
631 | } | |
632 | } | |
633 | ||
634 | free(gs.bucket_stats); | |
635 | } | |
636 | return 0; | |
637 | } | |
638 | ||
639 | static char * OVS_WARN_UNUSED_RESULT | |
640 | parse_bucket_str(struct ofputil_bucket *bucket, char *str_, | |
641 | const struct ofputil_port_map *port_map, | |
642 | const struct ofputil_table_map *table_map, | |
643 | uint8_t group_type, enum ofputil_protocol *usable_protocols) | |
644 | { | |
645 | char *pos, *key, *value; | |
646 | struct ofpbuf ofpacts; | |
647 | struct ds actions; | |
648 | char *error; | |
649 | ||
650 | bucket->weight = group_type == OFPGT11_SELECT ? 1 : 0; | |
651 | bucket->bucket_id = OFPG15_BUCKET_ALL; | |
652 | bucket->watch_port = OFPP_ANY; | |
653 | bucket->watch_group = OFPG_ANY; | |
654 | ||
655 | ds_init(&actions); | |
656 | ||
657 | pos = str_; | |
658 | error = NULL; | |
659 | while (ofputil_parse_key_value(&pos, &key, &value)) { | |
660 | if (!strcasecmp(key, "weight")) { | |
661 | error = str_to_u16(value, "weight", &bucket->weight); | |
662 | } else if (!strcasecmp(key, "watch_port")) { | |
663 | if (!ofputil_port_from_string(value, port_map, &bucket->watch_port) | |
664 | || (ofp_to_u16(bucket->watch_port) >= ofp_to_u16(OFPP_MAX) | |
665 | && bucket->watch_port != OFPP_ANY)) { | |
666 | error = xasprintf("%s: invalid watch_port", value); | |
667 | } | |
668 | } else if (!strcasecmp(key, "watch_group")) { | |
669 | error = str_to_u32(value, &bucket->watch_group); | |
670 | if (!error && bucket->watch_group > OFPG_MAX) { | |
671 | error = xasprintf("invalid watch_group id %"PRIu32, | |
672 | bucket->watch_group); | |
673 | } | |
674 | } else if (!strcasecmp(key, "bucket_id")) { | |
675 | error = str_to_u32(value, &bucket->bucket_id); | |
676 | if (!error && bucket->bucket_id > OFPG15_BUCKET_MAX) { | |
677 | error = xasprintf("invalid bucket_id id %"PRIu32, | |
678 | bucket->bucket_id); | |
679 | } | |
680 | *usable_protocols &= OFPUTIL_P_OF10_ANY | OFPUTIL_P_OF15_UP; | |
681 | } else if (!strcasecmp(key, "action") || !strcasecmp(key, "actions")) { | |
682 | ds_put_format(&actions, "%s,", value); | |
683 | } else { | |
684 | ds_put_format(&actions, "%s(%s),", key, value); | |
685 | } | |
686 | ||
687 | if (error) { | |
688 | ds_destroy(&actions); | |
689 | return error; | |
690 | } | |
691 | } | |
692 | ||
693 | if (!actions.length) { | |
694 | return xstrdup("bucket must specify actions"); | |
695 | } | |
696 | if (group_type == OFPGT11_FF && !ofputil_bucket_has_liveness(bucket)) { | |
697 | return xstrdup("fast failover bucket requires watch_port or " | |
698 | "watch_group"); | |
699 | } | |
700 | ds_chomp(&actions, ','); | |
701 | ||
702 | ofpbuf_init(&ofpacts, 0); | |
703 | struct ofpact_parse_params pp = { | |
704 | .port_map = port_map, | |
705 | .table_map = table_map, | |
706 | .ofpacts = &ofpacts, | |
707 | .usable_protocols = usable_protocols, | |
708 | }; | |
709 | error = ofpacts_parse_actions(ds_cstr(&actions), &pp); | |
710 | ds_destroy(&actions); | |
711 | if (error) { | |
712 | ofpbuf_uninit(&ofpacts); | |
713 | return error; | |
714 | } | |
715 | bucket->ofpacts = ofpacts.data; | |
716 | bucket->ofpacts_len = ofpacts.size; | |
717 | ||
718 | return NULL; | |
719 | } | |
720 | ||
721 | static char * OVS_WARN_UNUSED_RESULT | |
722 | parse_select_group_field(char *s, const struct ofputil_port_map *port_map, | |
723 | struct field_array *fa, | |
724 | enum ofputil_protocol *usable_protocols) | |
725 | { | |
726 | char *name, *value_str; | |
727 | ||
728 | while (ofputil_parse_key_value(&s, &name, &value_str)) { | |
729 | const struct mf_field *mf = mf_from_name(name); | |
730 | ||
731 | if (mf) { | |
732 | char *error; | |
733 | union mf_value value; | |
734 | ||
735 | if (bitmap_is_set(fa->used.bm, mf->id)) { | |
736 | return xasprintf("%s: duplicate field", name); | |
737 | } | |
738 | ||
739 | if (*value_str) { | |
740 | error = mf_parse_value(mf, value_str, port_map, &value); | |
741 | if (error) { | |
742 | return error; | |
743 | } | |
744 | ||
745 | /* The mask cannot be all-zeros */ | |
746 | if (!mf_is_tun_metadata(mf) && | |
747 | is_all_zeros(&value, mf->n_bytes)) { | |
748 | return xasprintf("%s: values are wildcards here " | |
749 | "and must not be all-zeros", s); | |
750 | } | |
751 | ||
752 | /* The values parsed are masks for fields used | |
753 | * by the selection method */ | |
754 | if (!mf_is_mask_valid(mf, &value)) { | |
755 | return xasprintf("%s: invalid mask for field %s", | |
756 | value_str, mf->name); | |
757 | } | |
758 | } else { | |
759 | memset(&value, 0xff, mf->n_bytes); | |
760 | } | |
761 | ||
762 | field_array_set(mf->id, &value, fa); | |
763 | ||
764 | if (is_all_ones(&value, mf->n_bytes)) { | |
765 | *usable_protocols &= mf->usable_protocols_exact; | |
766 | } else if (mf->usable_protocols_bitwise == mf->usable_protocols_cidr | |
767 | || ip_is_cidr(value.be32)) { | |
768 | *usable_protocols &= mf->usable_protocols_cidr; | |
769 | } else { | |
770 | *usable_protocols &= mf->usable_protocols_bitwise; | |
771 | } | |
772 | } else { | |
773 | return xasprintf("%s: unknown field %s", s, name); | |
774 | } | |
775 | } | |
776 | ||
777 | return NULL; | |
778 | } | |
779 | ||
780 | static char * OVS_WARN_UNUSED_RESULT | |
781 | parse_ofp_group_mod_str__(struct ofputil_group_mod *gm, int command, | |
782 | char *string, | |
783 | const struct ofputil_port_map *port_map, | |
784 | const struct ofputil_table_map *table_map, | |
785 | enum ofputil_protocol *usable_protocols) | |
786 | { | |
787 | enum { | |
788 | F_GROUP_TYPE = 1 << 0, | |
789 | F_BUCKETS = 1 << 1, | |
790 | F_COMMAND_BUCKET_ID = 1 << 2, | |
791 | F_COMMAND_BUCKET_ID_ALL = 1 << 3, | |
792 | } fields; | |
793 | bool had_type = false; | |
794 | bool had_command_bucket_id = false; | |
795 | struct ofputil_bucket *bucket; | |
796 | char *error = NULL; | |
797 | ||
798 | *usable_protocols = OFPUTIL_P_ANY; | |
799 | ||
800 | if (command == -2) { | |
801 | size_t len; | |
802 | ||
803 | string += strspn(string, " \t\r\n"); /* Skip white space. */ | |
804 | len = strcspn(string, ", \t\r\n"); /* Get length of the first token. */ | |
805 | ||
806 | if (!strncmp(string, "add", len)) { | |
807 | command = OFPGC11_ADD; | |
808 | } else if (!strncmp(string, "delete", len)) { | |
809 | command = OFPGC11_DELETE; | |
810 | } else if (!strncmp(string, "modify", len)) { | |
811 | command = OFPGC11_MODIFY; | |
812 | } else if (!strncmp(string, "add_or_mod", len)) { | |
813 | command = OFPGC11_ADD_OR_MOD; | |
814 | } else if (!strncmp(string, "insert_bucket", len)) { | |
815 | command = OFPGC15_INSERT_BUCKET; | |
816 | } else if (!strncmp(string, "remove_bucket", len)) { | |
817 | command = OFPGC15_REMOVE_BUCKET; | |
818 | } else { | |
819 | len = 0; | |
820 | command = OFPGC11_ADD; | |
821 | } | |
822 | string += len; | |
823 | } | |
824 | ||
825 | switch (command) { | |
826 | case OFPGC11_ADD: | |
827 | fields = F_GROUP_TYPE | F_BUCKETS; | |
828 | break; | |
829 | ||
830 | case OFPGC11_DELETE: | |
831 | fields = 0; | |
832 | break; | |
833 | ||
834 | case OFPGC11_MODIFY: | |
835 | fields = F_GROUP_TYPE | F_BUCKETS; | |
836 | break; | |
837 | ||
838 | case OFPGC11_ADD_OR_MOD: | |
839 | fields = F_GROUP_TYPE | F_BUCKETS; | |
840 | break; | |
841 | ||
842 | case OFPGC15_INSERT_BUCKET: | |
843 | fields = F_BUCKETS | F_COMMAND_BUCKET_ID; | |
844 | *usable_protocols &= OFPUTIL_P_OF10_ANY | OFPUTIL_P_OF15_UP; | |
845 | break; | |
846 | ||
847 | case OFPGC15_REMOVE_BUCKET: | |
848 | fields = F_COMMAND_BUCKET_ID | F_COMMAND_BUCKET_ID_ALL; | |
849 | *usable_protocols &= OFPUTIL_P_OF10_ANY | OFPUTIL_P_OF15_UP; | |
850 | break; | |
851 | ||
852 | default: | |
853 | OVS_NOT_REACHED(); | |
854 | } | |
855 | ||
856 | memset(gm, 0, sizeof *gm); | |
857 | gm->command = command; | |
858 | gm->group_id = OFPG_ANY; | |
859 | gm->command_bucket_id = OFPG15_BUCKET_ALL; | |
860 | ovs_list_init(&gm->buckets); | |
861 | if (command == OFPGC11_DELETE && string[0] == '\0') { | |
862 | gm->group_id = OFPG_ALL; | |
863 | return NULL; | |
864 | } | |
865 | ||
866 | /* Strip the buckets off the end of 'string', if there are any, saving a | |
867 | * pointer for later. We want to parse the buckets last because the bucket | |
868 | * type influences bucket defaults. */ | |
869 | char *bkt_str = strstr(string, "bucket="); | |
870 | if (bkt_str) { | |
871 | if (!(fields & F_BUCKETS)) { | |
872 | error = xstrdup("bucket is not needed"); | |
873 | goto out; | |
874 | } | |
875 | *bkt_str = '\0'; | |
876 | } | |
877 | ||
878 | /* Parse everything before the buckets. */ | |
879 | char *pos = string; | |
880 | char *name, *value; | |
881 | while (ofputil_parse_key_value(&pos, &name, &value)) { | |
882 | if (!strcmp(name, "command_bucket_id")) { | |
883 | if (!(fields & F_COMMAND_BUCKET_ID)) { | |
884 | error = xstrdup("command bucket id is not needed"); | |
885 | goto out; | |
886 | } | |
887 | if (!strcmp(value, "all")) { | |
888 | gm->command_bucket_id = OFPG15_BUCKET_ALL; | |
889 | } else if (!strcmp(value, "first")) { | |
890 | gm->command_bucket_id = OFPG15_BUCKET_FIRST; | |
891 | } else if (!strcmp(value, "last")) { | |
892 | gm->command_bucket_id = OFPG15_BUCKET_LAST; | |
893 | } else { | |
894 | error = str_to_u32(value, &gm->command_bucket_id); | |
895 | if (error) { | |
896 | goto out; | |
897 | } | |
898 | if (gm->command_bucket_id > OFPG15_BUCKET_MAX | |
899 | && (gm->command_bucket_id != OFPG15_BUCKET_FIRST | |
900 | && gm->command_bucket_id != OFPG15_BUCKET_LAST | |
901 | && gm->command_bucket_id != OFPG15_BUCKET_ALL)) { | |
902 | error = xasprintf("invalid command bucket id %"PRIu32, | |
903 | gm->command_bucket_id); | |
904 | goto out; | |
905 | } | |
906 | } | |
907 | if (gm->command_bucket_id == OFPG15_BUCKET_ALL | |
908 | && !(fields & F_COMMAND_BUCKET_ID_ALL)) { | |
909 | error = xstrdup("command_bucket_id=all is not permitted"); | |
910 | goto out; | |
911 | } | |
912 | had_command_bucket_id = true; | |
913 | } else if (!strcmp(name, "group_id")) { | |
914 | if(!strcmp(value, "all")) { | |
915 | gm->group_id = OFPG_ALL; | |
916 | } else { | |
917 | error = str_to_u32(value, &gm->group_id); | |
918 | if (error) { | |
919 | goto out; | |
920 | } | |
921 | if (gm->group_id != OFPG_ALL && gm->group_id > OFPG_MAX) { | |
922 | error = xasprintf("invalid group id %"PRIu32, | |
923 | gm->group_id); | |
924 | goto out; | |
925 | } | |
926 | } | |
927 | } else if (!strcmp(name, "type")){ | |
928 | if (!(fields & F_GROUP_TYPE)) { | |
929 | error = xstrdup("type is not needed"); | |
930 | goto out; | |
931 | } | |
932 | if (!strcmp(value, "all")) { | |
933 | gm->type = OFPGT11_ALL; | |
934 | } else if (!strcmp(value, "select")) { | |
935 | gm->type = OFPGT11_SELECT; | |
936 | } else if (!strcmp(value, "indirect")) { | |
937 | gm->type = OFPGT11_INDIRECT; | |
938 | } else if (!strcmp(value, "ff") || | |
939 | !strcmp(value, "fast_failover")) { | |
940 | gm->type = OFPGT11_FF; | |
941 | } else { | |
942 | error = xasprintf("invalid group type %s", value); | |
943 | goto out; | |
944 | } | |
945 | had_type = true; | |
946 | } else if (!strcmp(name, "selection_method")) { | |
947 | if (!(fields & F_GROUP_TYPE)) { | |
948 | error = xstrdup("selection method is not needed"); | |
949 | goto out; | |
950 | } | |
951 | if (strlen(value) >= NTR_MAX_SELECTION_METHOD_LEN) { | |
952 | error = xasprintf("selection method is longer than %u" | |
953 | " bytes long", | |
954 | NTR_MAX_SELECTION_METHOD_LEN - 1); | |
955 | goto out; | |
956 | } | |
957 | memset(gm->props.selection_method, '\0', | |
958 | NTR_MAX_SELECTION_METHOD_LEN); | |
959 | strcpy(gm->props.selection_method, value); | |
960 | *usable_protocols &= OFPUTIL_P_OF10_ANY | OFPUTIL_P_OF15_UP; | |
961 | } else if (!strcmp(name, "selection_method_param")) { | |
962 | if (!(fields & F_GROUP_TYPE)) { | |
963 | error = xstrdup("selection method param is not needed"); | |
964 | goto out; | |
965 | } | |
966 | error = str_to_u64(value, &gm->props.selection_method_param); | |
967 | if (error) { | |
968 | goto out; | |
969 | } | |
970 | *usable_protocols &= OFPUTIL_P_OF10_ANY | OFPUTIL_P_OF15_UP; | |
971 | } else if (!strcmp(name, "fields")) { | |
972 | if (!(fields & F_GROUP_TYPE)) { | |
973 | error = xstrdup("fields are not needed"); | |
974 | goto out; | |
975 | } | |
976 | error = parse_select_group_field(value, port_map, | |
977 | &gm->props.fields, | |
978 | usable_protocols); | |
979 | if (error) { | |
980 | goto out; | |
981 | } | |
982 | *usable_protocols &= OFPUTIL_P_OF10_ANY | OFPUTIL_P_OF15_UP; | |
983 | } else { | |
984 | error = xasprintf("unknown keyword %s", name); | |
985 | goto out; | |
986 | } | |
987 | } | |
988 | if (gm->group_id == OFPG_ANY) { | |
989 | error = xstrdup("must specify a group_id"); | |
990 | goto out; | |
991 | } | |
992 | if (fields & F_GROUP_TYPE && !had_type) { | |
993 | error = xstrdup("must specify a type"); | |
994 | goto out; | |
995 | } | |
996 | ||
997 | /* Exclude fields for non "hash" selection method. */ | |
998 | if (strcmp(gm->props.selection_method, "hash") && | |
999 | gm->props.fields.values_size) { | |
1000 | error = xstrdup("fields may only be specified with " | |
1001 | "\"selection_method=hash\""); | |
1002 | goto out; | |
1003 | } | |
1004 | /* Exclude selection_method_param if no selection_method is given. */ | |
1005 | if (gm->props.selection_method[0] == 0 | |
1006 | && gm->props.selection_method_param != 0) { | |
1007 | error = xstrdup("selection_method_param is only allowed with " | |
1008 | "\"selection_method\""); | |
1009 | goto out; | |
1010 | } | |
1011 | if (fields & F_COMMAND_BUCKET_ID) { | |
1012 | if (!(fields & F_COMMAND_BUCKET_ID_ALL || had_command_bucket_id)) { | |
1013 | error = xstrdup("must specify a command bucket id"); | |
1014 | goto out; | |
1015 | } | |
1016 | } else if (had_command_bucket_id) { | |
1017 | error = xstrdup("command bucket id is not needed"); | |
1018 | goto out; | |
1019 | } | |
1020 | ||
1021 | /* Now parse the buckets, if any. */ | |
1022 | while (bkt_str) { | |
1023 | char *next_bkt_str; | |
1024 | ||
1025 | bkt_str = strchr(bkt_str + 1, '='); | |
1026 | if (!bkt_str) { | |
1027 | error = xstrdup("must specify bucket content"); | |
1028 | goto out; | |
1029 | } | |
1030 | bkt_str++; | |
1031 | ||
1032 | next_bkt_str = strstr(bkt_str, "bucket="); | |
1033 | if (next_bkt_str) { | |
1034 | *next_bkt_str = '\0'; | |
1035 | } | |
1036 | ||
1037 | bucket = xzalloc(sizeof(struct ofputil_bucket)); | |
1038 | error = parse_bucket_str(bucket, bkt_str, port_map, table_map, | |
1039 | gm->type, usable_protocols); | |
1040 | if (error) { | |
1041 | free(bucket); | |
1042 | goto out; | |
1043 | } | |
1044 | ovs_list_push_back(&gm->buckets, &bucket->list_node); | |
1045 | ||
1046 | if (gm->type != OFPGT11_SELECT && bucket->weight) { | |
1047 | error = xstrdup("Only select groups can have bucket weights."); | |
1048 | goto out; | |
1049 | } | |
1050 | ||
1051 | bkt_str = next_bkt_str; | |
1052 | } | |
1053 | if (gm->type == OFPGT11_INDIRECT && !ovs_list_is_short(&gm->buckets)) { | |
1054 | error = xstrdup("Indirect groups can have at most one bucket."); | |
1055 | goto out; | |
1056 | } | |
1057 | ||
1058 | return NULL; | |
1059 | out: | |
1060 | ofputil_uninit_group_mod(gm); | |
1061 | return error; | |
1062 | } | |
1063 | ||
1064 | /* If 'command' is given as -2, each line may start with a command name ("add", | |
1065 | * "modify", "add_or_mod", "delete", "insert_bucket", or "remove_bucket"). A | |
1066 | * missing command name is treated as "add". | |
1067 | */ | |
1068 | char * OVS_WARN_UNUSED_RESULT | |
1069 | parse_ofp_group_mod_str(struct ofputil_group_mod *gm, int command, | |
1070 | const char *str_, | |
1071 | const struct ofputil_port_map *port_map, | |
1072 | const struct ofputil_table_map *table_map, | |
1073 | enum ofputil_protocol *usable_protocols) | |
1074 | { | |
1075 | char *string = xstrdup(str_); | |
1076 | char *error = parse_ofp_group_mod_str__(gm, command, string, port_map, | |
1077 | table_map, usable_protocols); | |
1078 | free(string); | |
1079 | return error; | |
1080 | } | |
1081 | ||
1082 | /* If 'command' is given as -2, each line may start with a command name ("add", | |
1083 | * "modify", "add_or_mod", "delete", "insert_bucket", or "remove_bucket"). A | |
1084 | * missing command name is treated as "add". | |
1085 | */ | |
1086 | char * OVS_WARN_UNUSED_RESULT | |
1087 | parse_ofp_group_mod_file(const char *file_name, | |
1088 | const struct ofputil_port_map *port_map, | |
1089 | const struct ofputil_table_map *table_map, | |
1090 | int command, | |
1091 | struct ofputil_group_mod **gms, size_t *n_gms, | |
1092 | enum ofputil_protocol *usable_protocols) | |
1093 | { | |
1094 | size_t allocated_gms; | |
1095 | int line_number; | |
1096 | FILE *stream; | |
1097 | struct ds s; | |
1098 | ||
1099 | *gms = NULL; | |
1100 | *n_gms = 0; | |
1101 | ||
1102 | stream = !strcmp(file_name, "-") ? stdin : fopen(file_name, "r"); | |
1103 | if (stream == NULL) { | |
1104 | return xasprintf("%s: open failed (%s)", | |
1105 | file_name, ovs_strerror(errno)); | |
1106 | } | |
1107 | ||
1108 | allocated_gms = *n_gms; | |
1109 | ds_init(&s); | |
1110 | line_number = 0; | |
1111 | *usable_protocols = OFPUTIL_P_ANY; | |
1112 | while (!ds_get_preprocessed_line(&s, stream, &line_number)) { | |
1113 | enum ofputil_protocol usable; | |
1114 | char *error; | |
1115 | ||
1116 | if (*n_gms >= allocated_gms) { | |
1117 | struct ofputil_group_mod *new_gms; | |
1118 | size_t i; | |
1119 | ||
1120 | new_gms = x2nrealloc(*gms, &allocated_gms, sizeof **gms); | |
1121 | for (i = 0; i < *n_gms; i++) { | |
1122 | ovs_list_moved(&new_gms[i].buckets, &(*gms)[i].buckets); | |
1123 | } | |
1124 | *gms = new_gms; | |
1125 | } | |
1126 | error = parse_ofp_group_mod_str(&(*gms)[*n_gms], command, ds_cstr(&s), | |
1127 | port_map, table_map, &usable); | |
1128 | if (error) { | |
1129 | size_t i; | |
1130 | ||
1131 | for (i = 0; i < *n_gms; i++) { | |
1132 | ofputil_uninit_group_mod(&(*gms)[i]); | |
1133 | } | |
1134 | free(*gms); | |
1135 | *gms = NULL; | |
1136 | *n_gms = 0; | |
1137 | ||
1138 | ds_destroy(&s); | |
1139 | if (stream != stdin) { | |
1140 | fclose(stream); | |
1141 | } | |
1142 | ||
1143 | char *ret = xasprintf("%s:%d: %s", file_name, line_number, error); | |
1144 | free(error); | |
1145 | return ret; | |
1146 | } | |
1147 | *usable_protocols &= usable; | |
1148 | *n_gms += 1; | |
1149 | } | |
1150 | ||
1151 | ds_destroy(&s); | |
1152 | if (stream != stdin) { | |
1153 | fclose(stream); | |
1154 | } | |
1155 | return NULL; | |
1156 | } | |
1157 | \f | |
1158 | static void | |
1159 | ofputil_put_ofp11_bucket(const struct ofputil_bucket *bucket, | |
1160 | struct ofpbuf *openflow, enum ofp_version ofp_version) | |
1161 | { | |
1162 | struct ofp11_bucket *ob; | |
1163 | size_t start; | |
1164 | ||
1165 | start = openflow->size; | |
1166 | ofpbuf_put_zeros(openflow, sizeof *ob); | |
1167 | ofpacts_put_openflow_actions(bucket->ofpacts, bucket->ofpacts_len, | |
1168 | openflow, ofp_version); | |
1169 | ob = ofpbuf_at_assert(openflow, start, sizeof *ob); | |
1170 | ob->len = htons(openflow->size - start); | |
1171 | ob->weight = htons(bucket->weight); | |
1172 | ob->watch_port = ofputil_port_to_ofp11(bucket->watch_port); | |
1173 | ob->watch_group = htonl(bucket->watch_group); | |
1174 | } | |
1175 | ||
1176 | static void | |
1177 | ofputil_put_ofp15_bucket(const struct ofputil_bucket *bucket, | |
1178 | uint32_t bucket_id, enum ofp11_group_type group_type, | |
1179 | struct ofpbuf *openflow, enum ofp_version ofp_version) | |
1180 | { | |
1181 | struct ofp15_bucket *ob; | |
1182 | size_t start, actions_start, actions_len; | |
1183 | ||
1184 | start = openflow->size; | |
1185 | ofpbuf_put_zeros(openflow, sizeof *ob); | |
1186 | ||
1187 | actions_start = openflow->size; | |
1188 | ofpacts_put_openflow_actions(bucket->ofpacts, bucket->ofpacts_len, | |
1189 | openflow, ofp_version); | |
1190 | actions_len = openflow->size - actions_start; | |
1191 | ||
1192 | if (group_type == OFPGT11_SELECT) { | |
1193 | ofpprop_put_u16(openflow, OFPGBPT15_WEIGHT, bucket->weight); | |
1194 | } | |
1195 | if (bucket->watch_port != OFPP_ANY) { | |
1196 | ofpprop_put_be32(openflow, OFPGBPT15_WATCH_PORT, | |
1197 | ofputil_port_to_ofp11(bucket->watch_port)); | |
1198 | } | |
1199 | if (bucket->watch_group != OFPG_ANY) { | |
1200 | ofpprop_put_u32(openflow, OFPGBPT15_WATCH_GROUP, bucket->watch_group); | |
1201 | } | |
1202 | ||
1203 | ob = ofpbuf_at_assert(openflow, start, sizeof *ob); | |
1204 | ob->len = htons(openflow->size - start); | |
1205 | ob->action_array_len = htons(actions_len); | |
1206 | ob->bucket_id = htonl(bucket_id); | |
1207 | } | |
1208 | ||
1209 | static void | |
1210 | ofputil_put_group_prop_ntr_selection_method(enum ofp_version ofp_version, | |
1211 | const struct ofputil_group_props *gp, | |
1212 | struct ofpbuf *openflow) | |
1213 | { | |
1214 | struct ntr_group_prop_selection_method *prop; | |
1215 | size_t start; | |
1216 | ||
1217 | start = openflow->size; | |
1218 | ofpbuf_put_zeros(openflow, sizeof *prop); | |
1219 | oxm_put_field_array(openflow, &gp->fields, ofp_version); | |
1220 | prop = ofpbuf_at_assert(openflow, start, sizeof *prop); | |
1221 | prop->type = htons(OFPGPT15_EXPERIMENTER); | |
1222 | prop->experimenter = htonl(NTR_VENDOR_ID); | |
1223 | prop->exp_type = htonl(NTRT_SELECTION_METHOD); | |
1224 | strcpy(prop->selection_method, gp->selection_method); | |
1225 | prop->selection_method_param = htonll(gp->selection_method_param); | |
1226 | ofpprop_end(openflow, start); | |
1227 | } | |
1228 | ||
1229 | static void | |
1230 | ofputil_append_ofp11_group_desc_reply(const struct ofputil_group_desc *gds, | |
1231 | const struct ovs_list *buckets, | |
1232 | struct ovs_list *replies, | |
1233 | enum ofp_version version) | |
1234 | { | |
1235 | struct ofpbuf *reply = ofpbuf_from_list(ovs_list_back(replies)); | |
1236 | struct ofp11_group_desc_stats *ogds; | |
1237 | struct ofputil_bucket *bucket; | |
1238 | size_t start_ogds; | |
1239 | ||
1240 | start_ogds = reply->size; | |
1241 | ofpbuf_put_zeros(reply, sizeof *ogds); | |
1242 | LIST_FOR_EACH (bucket, list_node, buckets) { | |
1243 | ofputil_put_ofp11_bucket(bucket, reply, version); | |
1244 | } | |
1245 | ogds = ofpbuf_at_assert(reply, start_ogds, sizeof *ogds); | |
1246 | ogds->length = htons(reply->size - start_ogds); | |
1247 | ogds->type = gds->type; | |
1248 | ogds->group_id = htonl(gds->group_id); | |
1249 | ||
1250 | ofpmp_postappend(replies, start_ogds); | |
1251 | } | |
1252 | ||
1253 | static void | |
1254 | ofputil_append_ofp15_group_desc_reply(const struct ofputil_group_desc *gds, | |
1255 | const struct ovs_list *buckets, | |
1256 | struct ovs_list *replies, | |
1257 | enum ofp_version version) | |
1258 | { | |
1259 | struct ofpbuf *reply = ofpbuf_from_list(ovs_list_back(replies)); | |
1260 | struct ofp15_group_desc_stats *ogds; | |
1261 | struct ofputil_bucket *bucket; | |
1262 | size_t start_ogds, start_buckets; | |
1263 | ||
1264 | start_ogds = reply->size; | |
1265 | ofpbuf_put_zeros(reply, sizeof *ogds); | |
1266 | start_buckets = reply->size; | |
1267 | LIST_FOR_EACH (bucket, list_node, buckets) { | |
1268 | ofputil_put_ofp15_bucket(bucket, bucket->bucket_id, | |
1269 | gds->type, reply, version); | |
1270 | } | |
1271 | ogds = ofpbuf_at_assert(reply, start_ogds, sizeof *ogds); | |
1272 | ogds->type = gds->type; | |
1273 | ogds->group_id = htonl(gds->group_id); | |
1274 | ogds->bucket_list_len = htons(reply->size - start_buckets); | |
1275 | ||
1276 | /* Add group properties */ | |
1277 | if (gds->props.selection_method[0]) { | |
1278 | ofputil_put_group_prop_ntr_selection_method(version, &gds->props, | |
1279 | reply); | |
1280 | } | |
1281 | ogds = ofpbuf_at_assert(reply, start_ogds, sizeof *ogds); | |
1282 | ogds->length = htons(reply->size - start_ogds); | |
1283 | ||
1284 | ofpmp_postappend(replies, start_ogds); | |
1285 | } | |
1286 | ||
1287 | /* Appends a group stats reply that contains the data in 'gds' to those already | |
1288 | * present in the list of ofpbufs in 'replies'. 'replies' should have been | |
1289 | * initialized with ofpmp_init(). */ | |
1290 | void | |
1291 | ofputil_append_group_desc_reply(const struct ofputil_group_desc *gds, | |
1292 | const struct ovs_list *buckets, | |
1293 | struct ovs_list *replies) | |
1294 | { | |
1295 | enum ofp_version version = ofpmp_version(replies); | |
1296 | ||
1297 | switch (version) | |
1298 | { | |
1299 | case OFP11_VERSION: | |
1300 | case OFP12_VERSION: | |
1301 | case OFP13_VERSION: | |
1302 | case OFP14_VERSION: | |
1303 | ofputil_append_ofp11_group_desc_reply(gds, buckets, replies, version); | |
1304 | break; | |
1305 | ||
1306 | case OFP10_VERSION: | |
1307 | case OFP15_VERSION: | |
1308 | case OFP16_VERSION: | |
1309 | ofputil_append_ofp15_group_desc_reply(gds, buckets, replies, version); | |
1310 | break; | |
1311 | ||
1312 | default: | |
1313 | OVS_NOT_REACHED(); | |
1314 | } | |
1315 | } | |
1316 | ||
1317 | static enum ofperr | |
1318 | ofputil_pull_ofp11_buckets(struct ofpbuf *msg, size_t buckets_length, | |
1319 | enum ofp_version version, struct ovs_list *buckets) | |
1320 | { | |
1321 | struct ofp11_bucket *ob; | |
1322 | uint32_t bucket_id = 0; | |
1323 | ||
1324 | ovs_list_init(buckets); | |
1325 | while (buckets_length > 0) { | |
1326 | struct ofputil_bucket *bucket; | |
1327 | struct ofpbuf ofpacts; | |
1328 | enum ofperr error; | |
1329 | size_t ob_len; | |
1330 | ||
1331 | ob = (buckets_length >= sizeof *ob | |
1332 | ? ofpbuf_try_pull(msg, sizeof *ob) | |
1333 | : NULL); | |
1334 | if (!ob) { | |
1335 | VLOG_WARN_RL(&rl, "buckets end with %"PRIuSIZE" leftover bytes", | |
1336 | buckets_length); | |
1337 | ofputil_bucket_list_destroy(buckets); | |
1338 | return OFPERR_OFPGMFC_BAD_BUCKET; | |
1339 | } | |
1340 | ||
1341 | ob_len = ntohs(ob->len); | |
1342 | if (ob_len < sizeof *ob) { | |
1343 | VLOG_WARN_RL(&rl, "OpenFlow message bucket length " | |
1344 | "%"PRIuSIZE" is not valid", ob_len); | |
1345 | ofputil_bucket_list_destroy(buckets); | |
1346 | return OFPERR_OFPGMFC_BAD_BUCKET; | |
1347 | } else if (ob_len > buckets_length) { | |
1348 | VLOG_WARN_RL(&rl, "OpenFlow message bucket length %"PRIuSIZE" " | |
1349 | "exceeds remaining buckets data size %"PRIuSIZE, | |
1350 | ob_len, buckets_length); | |
1351 | ofputil_bucket_list_destroy(buckets); | |
1352 | return OFPERR_OFPGMFC_BAD_BUCKET; | |
1353 | } | |
1354 | buckets_length -= ob_len; | |
1355 | ||
1356 | ofpbuf_init(&ofpacts, 0); | |
1357 | error = ofpacts_pull_openflow_actions(msg, ob_len - sizeof *ob, | |
1358 | version, NULL, NULL, &ofpacts); | |
1359 | if (error) { | |
1360 | ofpbuf_uninit(&ofpacts); | |
1361 | ofputil_bucket_list_destroy(buckets); | |
1362 | return error; | |
1363 | } | |
1364 | ||
1365 | bucket = xzalloc(sizeof *bucket); | |
1366 | bucket->weight = ntohs(ob->weight); | |
1367 | error = ofputil_port_from_ofp11(ob->watch_port, &bucket->watch_port); | |
1368 | if (error) { | |
1369 | ofpbuf_uninit(&ofpacts); | |
1370 | ofputil_bucket_list_destroy(buckets); | |
1371 | free(bucket); | |
1372 | return OFPERR_OFPGMFC_BAD_WATCH; | |
1373 | } | |
1374 | bucket->watch_group = ntohl(ob->watch_group); | |
1375 | bucket->bucket_id = bucket_id++; | |
1376 | ||
1377 | bucket->ofpacts = ofpbuf_steal_data(&ofpacts); | |
1378 | bucket->ofpacts_len = ofpacts.size; | |
1379 | ovs_list_push_back(buckets, &bucket->list_node); | |
1380 | } | |
1381 | ||
1382 | return 0; | |
1383 | } | |
1384 | ||
1385 | static enum ofperr | |
1386 | ofputil_pull_ofp15_buckets(struct ofpbuf *msg, size_t buckets_length, | |
1387 | enum ofp_version version, uint8_t group_type, | |
1388 | struct ovs_list *buckets) | |
1389 | { | |
1390 | ovs_list_init(buckets); | |
1391 | while (buckets_length > 0) { | |
1392 | struct ofputil_bucket *bucket = NULL; | |
1393 | struct ofpbuf ofpacts; | |
1394 | enum ofperr err = OFPERR_OFPGMFC_BAD_BUCKET; | |
1395 | size_t ob_len, actions_len, properties_len; | |
1396 | ovs_be32 watch_port = ofputil_port_to_ofp11(OFPP_ANY); | |
1397 | ovs_be32 watch_group = htonl(OFPG_ANY); | |
1398 | ovs_be16 weight = htons(group_type == OFPGT11_SELECT ? 1 : 0); | |
1399 | ||
1400 | ofpbuf_init(&ofpacts, 0); | |
1401 | ||
1402 | struct ofp15_bucket *ob = ofpbuf_try_pull(msg, sizeof *ob); | |
1403 | if (!ob) { | |
1404 | VLOG_WARN_RL(&rl, "buckets end with %"PRIuSIZE | |
1405 | " leftover bytes", buckets_length); | |
1406 | goto err; | |
1407 | } | |
1408 | ||
1409 | ob_len = ntohs(ob->len); | |
1410 | actions_len = ntohs(ob->action_array_len); | |
1411 | ||
1412 | if (ob_len < sizeof *ob) { | |
1413 | VLOG_WARN_RL(&rl, "OpenFlow message bucket length " | |
1414 | "%"PRIuSIZE" is not valid", ob_len); | |
1415 | goto err; | |
1416 | } else if (ob_len > buckets_length) { | |
1417 | VLOG_WARN_RL(&rl, "OpenFlow message bucket length " | |
1418 | "%"PRIuSIZE" exceeds remaining buckets data size %" | |
1419 | PRIuSIZE, ob_len, buckets_length); | |
1420 | goto err; | |
1421 | } else if (actions_len > ob_len - sizeof *ob) { | |
1422 | VLOG_WARN_RL(&rl, "OpenFlow message bucket actions " | |
1423 | "length %"PRIuSIZE" exceeds remaining bucket " | |
1424 | "data size %"PRIuSIZE, actions_len, | |
1425 | ob_len - sizeof *ob); | |
1426 | goto err; | |
1427 | } | |
1428 | buckets_length -= ob_len; | |
1429 | ||
1430 | err = ofpacts_pull_openflow_actions(msg, actions_len, version, | |
1431 | NULL, NULL, &ofpacts); | |
1432 | if (err) { | |
1433 | goto err; | |
1434 | } | |
1435 | ||
1436 | properties_len = ob_len - sizeof *ob - actions_len; | |
1437 | struct ofpbuf properties = ofpbuf_const_initializer( | |
1438 | ofpbuf_pull(msg, properties_len), properties_len); | |
1439 | while (properties.size > 0) { | |
1440 | struct ofpbuf payload; | |
1441 | uint64_t type; | |
1442 | ||
1443 | err = ofpprop_pull(&properties, &payload, &type); | |
1444 | if (err) { | |
1445 | goto err; | |
1446 | } | |
1447 | ||
1448 | switch (type) { | |
1449 | case OFPGBPT15_WEIGHT: | |
1450 | err = ofpprop_parse_be16(&payload, &weight); | |
1451 | break; | |
1452 | ||
1453 | case OFPGBPT15_WATCH_PORT: | |
1454 | err = ofpprop_parse_be32(&payload, &watch_port); | |
1455 | break; | |
1456 | ||
1457 | case OFPGBPT15_WATCH_GROUP: | |
1458 | err = ofpprop_parse_be32(&payload, &watch_group); | |
1459 | break; | |
1460 | ||
1461 | default: | |
1462 | err = OFPPROP_UNKNOWN(false, "group bucket", type); | |
1463 | break; | |
1464 | } | |
1465 | ||
1466 | if (err) { | |
1467 | goto err; | |
1468 | } | |
1469 | } | |
1470 | ||
1471 | bucket = xzalloc(sizeof *bucket); | |
1472 | ||
1473 | bucket->weight = ntohs(weight); | |
1474 | err = ofputil_port_from_ofp11(watch_port, &bucket->watch_port); | |
1475 | if (err) { | |
1476 | err = OFPERR_OFPGMFC_BAD_WATCH; | |
1477 | goto err; | |
1478 | } | |
1479 | bucket->watch_group = ntohl(watch_group); | |
1480 | bucket->bucket_id = ntohl(ob->bucket_id); | |
1481 | if (bucket->bucket_id > OFPG15_BUCKET_MAX) { | |
1482 | VLOG_WARN_RL(&rl, "bucket id (%u) is out of range", | |
1483 | bucket->bucket_id); | |
1484 | err = OFPERR_OFPGMFC_BAD_BUCKET; | |
1485 | goto err; | |
1486 | } | |
1487 | ||
1488 | bucket->ofpacts = ofpbuf_steal_data(&ofpacts); | |
1489 | bucket->ofpacts_len = ofpacts.size; | |
1490 | ovs_list_push_back(buckets, &bucket->list_node); | |
1491 | ||
1492 | continue; | |
1493 | ||
1494 | err: | |
1495 | free(bucket); | |
1496 | ofpbuf_uninit(&ofpacts); | |
1497 | ofputil_bucket_list_destroy(buckets); | |
1498 | return err; | |
1499 | } | |
1500 | ||
1501 | if (ofputil_bucket_check_duplicate_id(buckets)) { | |
1502 | VLOG_WARN_RL(&rl, "Duplicate bucket id"); | |
1503 | ofputil_bucket_list_destroy(buckets); | |
1504 | return OFPERR_OFPGMFC_BAD_BUCKET; | |
1505 | } | |
1506 | ||
1507 | return 0; | |
1508 | } | |
1509 | ||
1510 | static void | |
1511 | ofputil_init_group_properties(struct ofputil_group_props *gp) | |
1512 | { | |
1513 | memset(gp, 0, sizeof *gp); | |
1514 | } | |
1515 | ||
1516 | void | |
1517 | ofputil_group_properties_copy(struct ofputil_group_props *to, | |
1518 | const struct ofputil_group_props *from) | |
1519 | { | |
1520 | *to = *from; | |
1521 | to->fields.values = xmemdup(from->fields.values, from->fields.values_size); | |
1522 | } | |
1523 | ||
1524 | void | |
1525 | ofputil_group_properties_destroy(struct ofputil_group_props *gp) | |
1526 | { | |
1527 | free(gp->fields.values); | |
1528 | } | |
1529 | ||
1530 | static enum ofperr | |
1531 | parse_group_prop_ntr_selection_method(struct ofpbuf *payload, | |
1532 | enum ofp11_group_type group_type, | |
1533 | enum ofp15_group_mod_command group_cmd, | |
1534 | struct ofputil_group_props *gp) | |
1535 | { | |
1536 | struct ntr_group_prop_selection_method *prop = payload->data; | |
1537 | size_t fields_len, method_len; | |
1538 | enum ofperr error; | |
1539 | ||
1540 | switch (group_type) { | |
1541 | case OFPGT11_SELECT: | |
1542 | break; | |
1543 | case OFPGT11_ALL: | |
1544 | case OFPGT11_INDIRECT: | |
1545 | case OFPGT11_FF: | |
1546 | OFPPROP_LOG(&rl, false, "ntr selection method property is " | |
1547 | "only allowed for select groups"); | |
1548 | return OFPERR_OFPBPC_BAD_VALUE; | |
1549 | default: | |
1550 | OVS_NOT_REACHED(); | |
1551 | } | |
1552 | ||
1553 | switch (group_cmd) { | |
1554 | case OFPGC15_ADD: | |
1555 | case OFPGC15_MODIFY: | |
1556 | case OFPGC15_ADD_OR_MOD: | |
1557 | break; | |
1558 | case OFPGC15_DELETE: | |
1559 | case OFPGC15_INSERT_BUCKET: | |
1560 | case OFPGC15_REMOVE_BUCKET: | |
1561 | OFPPROP_LOG(&rl, false, "ntr selection method property is " | |
1562 | "only allowed for add and delete group modifications"); | |
1563 | return OFPERR_OFPBPC_BAD_VALUE; | |
1564 | default: | |
1565 | OVS_NOT_REACHED(); | |
1566 | } | |
1567 | ||
1568 | if (payload->size < sizeof *prop) { | |
1569 | OFPPROP_LOG(&rl, false, "ntr selection method property " | |
1570 | "length %u is not valid", payload->size); | |
1571 | return OFPERR_OFPBPC_BAD_LEN; | |
1572 | } | |
1573 | ||
1574 | method_len = strnlen(prop->selection_method, NTR_MAX_SELECTION_METHOD_LEN); | |
1575 | ||
1576 | if (method_len == NTR_MAX_SELECTION_METHOD_LEN) { | |
1577 | OFPPROP_LOG(&rl, false, | |
1578 | "ntr selection method is not null terminated"); | |
1579 | return OFPERR_OFPBPC_BAD_VALUE; | |
1580 | } | |
1581 | ||
1582 | if (strcmp("hash", prop->selection_method) | |
1583 | && strcmp("dp_hash", prop->selection_method)) { | |
1584 | OFPPROP_LOG(&rl, false, | |
1585 | "ntr selection method '%s' is not supported", | |
1586 | prop->selection_method); | |
1587 | return OFPERR_OFPBPC_BAD_VALUE; | |
1588 | } | |
1589 | /* 'method_len' is now non-zero. */ | |
1590 | ||
1591 | strcpy(gp->selection_method, prop->selection_method); | |
1592 | gp->selection_method_param = ntohll(prop->selection_method_param); | |
1593 | ||
1594 | ofpbuf_pull(payload, sizeof *prop); | |
1595 | ||
1596 | fields_len = ntohs(prop->length) - sizeof *prop; | |
1597 | if (fields_len && strcmp("hash", gp->selection_method)) { | |
1598 | OFPPROP_LOG(&rl, false, "ntr selection method %s " | |
1599 | "does not support fields", gp->selection_method); | |
1600 | return OFPERR_OFPBPC_BAD_VALUE; | |
1601 | } | |
1602 | ||
1603 | if (fields_len > 0) { | |
1604 | error = oxm_pull_field_array(payload->data, fields_len, | |
1605 | &gp->fields); | |
1606 | if (error) { | |
1607 | OFPPROP_LOG(&rl, false, | |
1608 | "ntr selection method fields are invalid"); | |
1609 | return error; | |
1610 | } | |
1611 | } else { | |
1612 | /* Selection_method "hash: w/o fields means default hash method. */ | |
1613 | gp->fields.values_size = 0; | |
1614 | } | |
1615 | ||
1616 | return 0; | |
1617 | } | |
1618 | ||
1619 | static enum ofperr | |
1620 | parse_ofp15_group_properties(struct ofpbuf *msg, | |
1621 | enum ofp11_group_type group_type, | |
1622 | enum ofp15_group_mod_command group_cmd, | |
1623 | struct ofputil_group_props *gp, | |
1624 | size_t properties_len) | |
1625 | { | |
1626 | struct ofpbuf properties = ofpbuf_const_initializer( | |
1627 | ofpbuf_pull(msg, properties_len), properties_len); | |
1628 | while (properties.size > 0) { | |
1629 | struct ofpbuf payload; | |
1630 | enum ofperr error; | |
1631 | uint64_t type; | |
1632 | ||
1633 | error = ofpprop_pull(&properties, &payload, &type); | |
1634 | if (error) { | |
1635 | return error; | |
1636 | } | |
1637 | ||
1638 | switch (type) { | |
1639 | case OFPPROP_EXP(NTR_VENDOR_ID, NTRT_SELECTION_METHOD): | |
1640 | case OFPPROP_EXP(NTR_COMPAT_VENDOR_ID, NTRT_SELECTION_METHOD): | |
1641 | error = parse_group_prop_ntr_selection_method(&payload, group_type, | |
1642 | group_cmd, gp); | |
1643 | break; | |
1644 | ||
1645 | default: | |
1646 | error = OFPPROP_UNKNOWN(false, "group", type); | |
1647 | break; | |
1648 | } | |
1649 | ||
1650 | if (error) { | |
1651 | return error; | |
1652 | } | |
1653 | } | |
1654 | ||
1655 | return 0; | |
1656 | } | |
1657 | ||
1658 | static int | |
1659 | ofputil_decode_ofp11_group_desc_reply(struct ofputil_group_desc *gd, | |
1660 | struct ofpbuf *msg, | |
1661 | enum ofp_version version) | |
1662 | { | |
1663 | struct ofp11_group_desc_stats *ogds; | |
1664 | size_t length; | |
1665 | ||
1666 | if (!msg->header) { | |
1667 | ofpraw_pull_assert(msg); | |
1668 | } | |
1669 | ||
1670 | if (!msg->size) { | |
1671 | return EOF; | |
1672 | } | |
1673 | ||
1674 | ogds = ofpbuf_try_pull(msg, sizeof *ogds); | |
1675 | if (!ogds) { | |
1676 | VLOG_WARN_RL(&rl, "OFPST11_GROUP_DESC reply has %"PRIu32" " | |
1677 | "leftover bytes at end", msg->size); | |
1678 | return OFPERR_OFPBRC_BAD_LEN; | |
1679 | } | |
1680 | gd->type = ogds->type; | |
1681 | gd->group_id = ntohl(ogds->group_id); | |
1682 | ||
1683 | length = ntohs(ogds->length); | |
1684 | if (length < sizeof *ogds || length - sizeof *ogds > msg->size) { | |
1685 | VLOG_WARN_RL(&rl, "OFPST11_GROUP_DESC reply claims invalid " | |
1686 | "length %"PRIuSIZE, length); | |
1687 | return OFPERR_OFPBRC_BAD_LEN; | |
1688 | } | |
1689 | ||
1690 | return ofputil_pull_ofp11_buckets(msg, length - sizeof *ogds, version, | |
1691 | &gd->buckets); | |
1692 | } | |
1693 | ||
1694 | static int | |
1695 | ofputil_decode_ofp15_group_desc_reply(struct ofputil_group_desc *gd, | |
1696 | struct ofpbuf *msg, | |
1697 | enum ofp_version version) | |
1698 | { | |
1699 | struct ofp15_group_desc_stats *ogds; | |
1700 | uint16_t length, bucket_list_len; | |
1701 | int error; | |
1702 | ||
1703 | if (!msg->header) { | |
1704 | ofpraw_pull_assert(msg); | |
1705 | } | |
1706 | ||
1707 | if (!msg->size) { | |
1708 | return EOF; | |
1709 | } | |
1710 | ||
1711 | ogds = ofpbuf_try_pull(msg, sizeof *ogds); | |
1712 | if (!ogds) { | |
1713 | VLOG_WARN_RL(&rl, "OFPST11_GROUP_DESC reply has %"PRIu32" " | |
1714 | "leftover bytes at end", msg->size); | |
1715 | return OFPERR_OFPBRC_BAD_LEN; | |
1716 | } | |
1717 | gd->type = ogds->type; | |
1718 | gd->group_id = ntohl(ogds->group_id); | |
1719 | ||
1720 | length = ntohs(ogds->length); | |
1721 | if (length < sizeof *ogds || length - sizeof *ogds > msg->size) { | |
1722 | VLOG_WARN_RL(&rl, "OFPST11_GROUP_DESC reply claims invalid " | |
1723 | "length %u", length); | |
1724 | return OFPERR_OFPBRC_BAD_LEN; | |
1725 | } | |
1726 | ||
1727 | bucket_list_len = ntohs(ogds->bucket_list_len); | |
1728 | if (length < bucket_list_len + sizeof *ogds) { | |
1729 | VLOG_WARN_RL(&rl, "OFPST11_GROUP_DESC reply claims invalid " | |
1730 | "bucket list length %u", bucket_list_len); | |
1731 | return OFPERR_OFPBRC_BAD_LEN; | |
1732 | } | |
1733 | error = ofputil_pull_ofp15_buckets(msg, bucket_list_len, version, gd->type, | |
1734 | &gd->buckets); | |
1735 | if (error) { | |
1736 | return error; | |
1737 | } | |
1738 | ||
1739 | /* By definition group desc messages don't have a group mod command. | |
1740 | * However, parse_group_prop_ntr_selection_method() checks to make sure | |
1741 | * that the command is OFPGC15_ADD or OFPGC15_DELETE to guard | |
1742 | * against group mod messages with other commands supplying | |
1743 | * a NTR selection method group experimenter property. | |
1744 | * Such properties are valid for group desc replies so | |
1745 | * claim that the group mod command is OFPGC15_ADD to | |
1746 | * satisfy the check in parse_group_prop_ntr_selection_method() */ | |
1747 | error = parse_ofp15_group_properties( | |
1748 | msg, gd->type, OFPGC15_ADD, &gd->props, | |
1749 | length - sizeof *ogds - bucket_list_len); | |
1750 | if (error) { | |
1751 | ofputil_bucket_list_destroy(&gd->buckets); | |
1752 | } | |
1753 | return error; | |
1754 | } | |
1755 | ||
1756 | /* Converts a group description reply in 'msg' into an abstract | |
1757 | * ofputil_group_desc in 'gd'. | |
1758 | * | |
1759 | * Multiple group description replies can be packed into a single OpenFlow | |
1760 | * message. Calling this function multiple times for a single 'msg' iterates | |
1761 | * through the replies. The caller must initially leave 'msg''s layer pointers | |
1762 | * null and not modify them between calls. | |
1763 | * | |
1764 | * Returns 0 if successful, EOF if no replies were left in this 'msg', | |
1765 | * otherwise a positive errno value. */ | |
1766 | int | |
1767 | ofputil_decode_group_desc_reply(struct ofputil_group_desc *gd, | |
1768 | struct ofpbuf *msg, enum ofp_version version) | |
1769 | { | |
1770 | ofputil_init_group_properties(&gd->props); | |
1771 | ||
1772 | switch (version) | |
1773 | { | |
1774 | case OFP11_VERSION: | |
1775 | case OFP12_VERSION: | |
1776 | case OFP13_VERSION: | |
1777 | case OFP14_VERSION: | |
1778 | return ofputil_decode_ofp11_group_desc_reply(gd, msg, version); | |
1779 | ||
1780 | case OFP10_VERSION: | |
1781 | case OFP15_VERSION: | |
1782 | case OFP16_VERSION: | |
1783 | return ofputil_decode_ofp15_group_desc_reply(gd, msg, version); | |
1784 | ||
1785 | default: | |
1786 | OVS_NOT_REACHED(); | |
1787 | } | |
1788 | } | |
1789 | ||
1790 | static void | |
1791 | ofp_print_bucket_id(struct ds *s, const char *label, uint32_t bucket_id, | |
1792 | enum ofp_version ofp_version) | |
1793 | { | |
1794 | if (ofp_version > OFP10_VERSION && ofp_version < OFP15_VERSION) { | |
1795 | return; | |
1796 | } | |
1797 | ||
1798 | ds_put_cstr(s, label); | |
1799 | ||
1800 | switch (bucket_id) { | |
1801 | case OFPG15_BUCKET_FIRST: | |
1802 | ds_put_cstr(s, "first"); | |
1803 | break; | |
1804 | case OFPG15_BUCKET_LAST: | |
1805 | ds_put_cstr(s, "last"); | |
1806 | break; | |
1807 | case OFPG15_BUCKET_ALL: | |
1808 | ds_put_cstr(s, "all"); | |
1809 | break; | |
1810 | default: | |
1811 | ds_put_format(s, "%"PRIu32, bucket_id); | |
1812 | break; | |
1813 | } | |
1814 | ||
1815 | ds_put_char(s, ','); | |
1816 | } | |
1817 | ||
1818 | static void | |
1819 | ofp_print_group(struct ds *s, uint32_t group_id, uint8_t type, | |
1820 | const struct ovs_list *p_buckets, | |
1821 | const struct ofputil_group_props *props, | |
1822 | enum ofp_version ofp_version, bool suppress_type, | |
1823 | const struct ofputil_port_map *port_map, | |
1824 | const struct ofputil_table_map *table_map) | |
1825 | { | |
1826 | struct ofputil_bucket *bucket; | |
1827 | ||
1828 | ds_put_format(s, "group_id=%"PRIu32, group_id); | |
1829 | ||
1830 | if (!suppress_type) { | |
1831 | static const char *type_str[] = { "all", "select", "indirect", | |
1832 | "ff", "unknown" }; | |
1833 | ds_put_format(s, ",type=%s", type_str[type > 4 ? 4 : type]); | |
1834 | } | |
1835 | ||
1836 | if (props->selection_method[0]) { | |
1837 | ds_put_format(s, ",selection_method=%s", props->selection_method); | |
1838 | if (props->selection_method_param) { | |
1839 | ds_put_format(s, ",selection_method_param=%"PRIu64, | |
1840 | props->selection_method_param); | |
1841 | } | |
1842 | ||
1843 | size_t n = bitmap_count1(props->fields.used.bm, MFF_N_IDS); | |
1844 | if (n == 1) { | |
1845 | ds_put_cstr(s, ",fields="); | |
1846 | oxm_format_field_array(s, &props->fields); | |
1847 | } else if (n > 1) { | |
1848 | ds_put_cstr(s, ",fields("); | |
1849 | oxm_format_field_array(s, &props->fields); | |
1850 | ds_put_char(s, ')'); | |
1851 | } | |
1852 | } | |
1853 | ||
1854 | if (!p_buckets) { | |
1855 | return; | |
1856 | } | |
1857 | ||
1858 | ds_put_char(s, ','); | |
1859 | ||
1860 | LIST_FOR_EACH (bucket, list_node, p_buckets) { | |
1861 | ds_put_cstr(s, "bucket="); | |
1862 | ||
1863 | ofp_print_bucket_id(s, "bucket_id:", bucket->bucket_id, ofp_version); | |
1864 | if (bucket->weight != (type == OFPGT11_SELECT ? 1 : 0)) { | |
1865 | ds_put_format(s, "weight:%"PRIu16",", bucket->weight); | |
1866 | } | |
1867 | if (bucket->watch_port != OFPP_NONE) { | |
1868 | ds_put_cstr(s, "watch_port:"); | |
1869 | ofputil_format_port(bucket->watch_port, port_map, s); | |
1870 | ds_put_char(s, ','); | |
1871 | } | |
1872 | if (bucket->watch_group != OFPG_ANY) { | |
1873 | ds_put_format(s, "watch_group:%"PRIu32",", bucket->watch_group); | |
1874 | } | |
1875 | ||
1876 | ds_put_cstr(s, "actions="); | |
1877 | struct ofpact_format_params fp = { | |
1878 | .port_map = port_map, | |
1879 | .table_map = table_map, | |
1880 | .s = s, | |
1881 | }; | |
1882 | ofpacts_format(bucket->ofpacts, bucket->ofpacts_len, &fp); | |
1883 | ds_put_char(s, ','); | |
1884 | } | |
1885 | ||
1886 | ds_chomp(s, ','); | |
1887 | } | |
1888 | ||
1889 | enum ofperr | |
1890 | ofputil_group_desc_format(struct ds *s, const struct ofp_header *oh, | |
1891 | const struct ofputil_port_map *port_map, | |
1892 | const struct ofputil_table_map *table_map) | |
1893 | { | |
1894 | struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length)); | |
1895 | for (;;) { | |
1896 | struct ofputil_group_desc gd; | |
1897 | int retval; | |
1898 | ||
1899 | retval = ofputil_decode_group_desc_reply(&gd, &b, oh->version); | |
1900 | if (retval) { | |
1901 | return retval != EOF ? retval : 0; | |
1902 | } | |
1903 | ||
1904 | ds_put_char(s, '\n'); | |
1905 | ds_put_char(s, ' '); | |
1906 | ofp_print_group(s, gd.group_id, gd.type, &gd.buckets, &gd.props, | |
1907 | oh->version, false, port_map, table_map); | |
1908 | ofputil_uninit_group_desc(&gd); | |
1909 | } | |
1910 | } | |
1911 | ||
1912 | void | |
1913 | ofputil_uninit_group_mod(struct ofputil_group_mod *gm) | |
1914 | { | |
1915 | ofputil_bucket_list_destroy(&gm->buckets); | |
1916 | ofputil_group_properties_destroy(&gm->props); | |
1917 | } | |
1918 | ||
1919 | static struct ofpbuf * | |
1920 | ofputil_encode_ofp11_group_mod(enum ofp_version ofp_version, | |
1921 | const struct ofputil_group_mod *gm) | |
1922 | { | |
1923 | struct ofpbuf *b; | |
1924 | struct ofp11_group_mod *ogm; | |
1925 | size_t start_ogm; | |
1926 | struct ofputil_bucket *bucket; | |
1927 | ||
1928 | b = ofpraw_alloc(OFPRAW_OFPT11_GROUP_MOD, ofp_version, 0); | |
1929 | start_ogm = b->size; | |
1930 | ofpbuf_put_zeros(b, sizeof *ogm); | |
1931 | ||
1932 | LIST_FOR_EACH (bucket, list_node, &gm->buckets) { | |
1933 | ofputil_put_ofp11_bucket(bucket, b, ofp_version); | |
1934 | } | |
1935 | ogm = ofpbuf_at_assert(b, start_ogm, sizeof *ogm); | |
1936 | ogm->command = htons(gm->command); | |
1937 | ogm->type = gm->type; | |
1938 | ogm->group_id = htonl(gm->group_id); | |
1939 | ||
1940 | return b; | |
1941 | } | |
1942 | ||
1943 | static struct ofpbuf * | |
1944 | ofputil_encode_ofp15_group_mod(enum ofp_version ofp_version, | |
1945 | const struct ofputil_group_mod *gm) | |
1946 | { | |
1947 | struct ofpbuf *b; | |
1948 | struct ofp15_group_mod *ogm; | |
1949 | size_t start_ogm; | |
1950 | struct ofputil_bucket *bucket; | |
1951 | struct id_pool *bucket_ids = NULL; | |
1952 | ||
1953 | b = ofpraw_alloc((ofp_version == OFP10_VERSION | |
1954 | ? OFPRAW_NXT_GROUP_MOD | |
1955 | : OFPRAW_OFPT15_GROUP_MOD), ofp_version, 0); | |
1956 | start_ogm = b->size; | |
1957 | ofpbuf_put_zeros(b, sizeof *ogm); | |
1958 | ||
1959 | LIST_FOR_EACH (bucket, list_node, &gm->buckets) { | |
1960 | uint32_t bucket_id; | |
1961 | ||
1962 | /* Generate a bucket id if none was supplied */ | |
1963 | if (bucket->bucket_id > OFPG15_BUCKET_MAX) { | |
1964 | if (!bucket_ids) { | |
1965 | const struct ofputil_bucket *bkt; | |
1966 | ||
1967 | bucket_ids = id_pool_create(0, OFPG15_BUCKET_MAX + 1); | |
1968 | ||
1969 | /* Mark all bucket_ids that are present in gm | |
1970 | * as used in the pool. */ | |
1971 | LIST_FOR_EACH_REVERSE (bkt, list_node, &gm->buckets) { | |
1972 | if (bkt == bucket) { | |
1973 | break; | |
1974 | } | |
1975 | if (bkt->bucket_id <= OFPG15_BUCKET_MAX) { | |
1976 | id_pool_add(bucket_ids, bkt->bucket_id); | |
1977 | } | |
1978 | } | |
1979 | } | |
1980 | ||
1981 | if (!id_pool_alloc_id(bucket_ids, &bucket_id)) { | |
1982 | OVS_NOT_REACHED(); | |
1983 | } | |
1984 | } else { | |
1985 | bucket_id = bucket->bucket_id; | |
1986 | } | |
1987 | ||
1988 | ofputil_put_ofp15_bucket(bucket, bucket_id, gm->type, b, ofp_version); | |
1989 | } | |
1990 | ogm = ofpbuf_at_assert(b, start_ogm, sizeof *ogm); | |
1991 | ogm->command = htons(gm->command); | |
1992 | ogm->type = gm->type; | |
1993 | ogm->group_id = htonl(gm->group_id); | |
1994 | ogm->command_bucket_id = htonl(gm->command_bucket_id); | |
1995 | ogm->bucket_array_len = htons(b->size - start_ogm - sizeof *ogm); | |
1996 | ||
1997 | /* Add group properties */ | |
1998 | if (gm->props.selection_method[0]) { | |
1999 | ofputil_put_group_prop_ntr_selection_method(ofp_version, &gm->props, b); | |
2000 | } | |
2001 | ||
2002 | id_pool_destroy(bucket_ids); | |
2003 | return b; | |
2004 | } | |
2005 | ||
2006 | static void | |
2007 | bad_group_cmd(enum ofp15_group_mod_command cmd) | |
2008 | { | |
2009 | const char *opt_version; | |
2010 | const char *version; | |
2011 | const char *cmd_str; | |
2012 | ||
2013 | switch (cmd) { | |
2014 | case OFPGC15_ADD: | |
2015 | case OFPGC15_MODIFY: | |
2016 | case OFPGC15_ADD_OR_MOD: | |
2017 | case OFPGC15_DELETE: | |
2018 | version = "1.1"; | |
2019 | opt_version = "11"; | |
2020 | break; | |
2021 | ||
2022 | case OFPGC15_INSERT_BUCKET: | |
2023 | case OFPGC15_REMOVE_BUCKET: | |
2024 | version = "1.5"; | |
2025 | opt_version = "15"; | |
2026 | break; | |
2027 | ||
2028 | default: | |
2029 | OVS_NOT_REACHED(); | |
2030 | } | |
2031 | ||
2032 | switch (cmd) { | |
2033 | case OFPGC15_ADD: | |
2034 | cmd_str = "add-group"; | |
2035 | break; | |
2036 | ||
2037 | case OFPGC15_MODIFY: | |
2038 | case OFPGC15_ADD_OR_MOD: | |
2039 | cmd_str = "mod-group"; | |
2040 | break; | |
2041 | ||
2042 | case OFPGC15_DELETE: | |
2043 | cmd_str = "del-group"; | |
2044 | break; | |
2045 | ||
2046 | case OFPGC15_INSERT_BUCKET: | |
2047 | cmd_str = "insert-bucket"; | |
2048 | break; | |
2049 | ||
2050 | case OFPGC15_REMOVE_BUCKET: | |
2051 | cmd_str = "remove-bucket"; | |
2052 | break; | |
2053 | ||
2054 | default: | |
2055 | OVS_NOT_REACHED(); | |
2056 | } | |
2057 | ||
2058 | ovs_fatal(0, "%s needs OpenFlow %s or later (\'-O OpenFlow%s\')", | |
2059 | cmd_str, version, opt_version); | |
2060 | ||
2061 | } | |
2062 | ||
2063 | /* Converts abstract group mod 'gm' into a message for OpenFlow version | |
2064 | * 'ofp_version' and returns the message. */ | |
2065 | struct ofpbuf * | |
2066 | ofputil_encode_group_mod(enum ofp_version ofp_version, | |
2067 | const struct ofputil_group_mod *gm) | |
2068 | { | |
2069 | ||
2070 | switch (ofp_version) { | |
2071 | case OFP11_VERSION: | |
2072 | case OFP12_VERSION: | |
2073 | case OFP13_VERSION: | |
2074 | case OFP14_VERSION: | |
2075 | if (gm->command > OFPGC11_DELETE && gm->command != OFPGC11_ADD_OR_MOD) { | |
2076 | bad_group_cmd(gm->command); | |
2077 | } | |
2078 | return ofputil_encode_ofp11_group_mod(ofp_version, gm); | |
2079 | ||
2080 | case OFP10_VERSION: | |
2081 | case OFP15_VERSION: | |
2082 | case OFP16_VERSION: | |
2083 | return ofputil_encode_ofp15_group_mod(ofp_version, gm); | |
2084 | ||
2085 | default: | |
2086 | OVS_NOT_REACHED(); | |
2087 | } | |
2088 | } | |
2089 | ||
2090 | static enum ofperr | |
2091 | ofputil_pull_ofp11_group_mod(struct ofpbuf *msg, enum ofp_version ofp_version, | |
2092 | struct ofputil_group_mod *gm) | |
2093 | { | |
2094 | const struct ofp11_group_mod *ogm; | |
2095 | enum ofperr error; | |
2096 | ||
2097 | ogm = ofpbuf_pull(msg, sizeof *ogm); | |
2098 | gm->command = ntohs(ogm->command); | |
2099 | gm->type = ogm->type; | |
2100 | gm->group_id = ntohl(ogm->group_id); | |
2101 | gm->command_bucket_id = OFPG15_BUCKET_ALL; | |
2102 | ||
2103 | error = ofputil_pull_ofp11_buckets(msg, msg->size, ofp_version, | |
2104 | &gm->buckets); | |
2105 | ||
2106 | /* OF1.3.5+ prescribes an error when an OFPGC_DELETE includes buckets. */ | |
2107 | if (!error | |
2108 | && ofp_version >= OFP13_VERSION | |
2109 | && gm->command == OFPGC11_DELETE | |
2110 | && !ovs_list_is_empty(&gm->buckets)) { | |
2111 | error = OFPERR_OFPGMFC_INVALID_GROUP; | |
2112 | ofputil_bucket_list_destroy(&gm->buckets); | |
2113 | } | |
2114 | ||
2115 | return error; | |
2116 | } | |
2117 | ||
2118 | static enum ofperr | |
2119 | ofputil_pull_ofp15_group_mod(struct ofpbuf *msg, enum ofp_version ofp_version, | |
2120 | struct ofputil_group_mod *gm) | |
2121 | { | |
2122 | const struct ofp15_group_mod *ogm; | |
2123 | uint16_t bucket_list_len; | |
2124 | enum ofperr error = OFPERR_OFPGMFC_BAD_BUCKET; | |
2125 | ||
2126 | ogm = ofpbuf_pull(msg, sizeof *ogm); | |
2127 | gm->command = ntohs(ogm->command); | |
2128 | gm->type = ogm->type; | |
2129 | gm->group_id = ntohl(ogm->group_id); | |
2130 | ||
2131 | gm->command_bucket_id = ntohl(ogm->command_bucket_id); | |
2132 | switch (gm->command) { | |
2133 | case OFPGC15_REMOVE_BUCKET: | |
2134 | if (gm->command_bucket_id == OFPG15_BUCKET_ALL) { | |
2135 | error = 0; | |
2136 | } | |
2137 | /* Fall through */ | |
2138 | case OFPGC15_INSERT_BUCKET: | |
2139 | if (gm->command_bucket_id <= OFPG15_BUCKET_MAX || | |
2140 | gm->command_bucket_id == OFPG15_BUCKET_FIRST | |
2141 | || gm->command_bucket_id == OFPG15_BUCKET_LAST) { | |
2142 | error = 0; | |
2143 | } | |
2144 | break; | |
2145 | ||
2146 | case OFPGC11_ADD: | |
2147 | case OFPGC11_MODIFY: | |
2148 | case OFPGC11_ADD_OR_MOD: | |
2149 | case OFPGC11_DELETE: | |
2150 | default: | |
2151 | if (gm->command_bucket_id == OFPG15_BUCKET_ALL) { | |
2152 | error = 0; | |
2153 | } | |
2154 | break; | |
2155 | } | |
2156 | if (error) { | |
2157 | VLOG_WARN_RL(&rl, | |
2158 | "group command bucket id (%u) is out of range", | |
2159 | gm->command_bucket_id); | |
2160 | return OFPERR_OFPGMFC_BAD_BUCKET; | |
2161 | } | |
2162 | ||
2163 | bucket_list_len = ntohs(ogm->bucket_array_len); | |
2164 | if (bucket_list_len > msg->size) { | |
2165 | return OFPERR_OFPBRC_BAD_LEN; | |
2166 | } | |
2167 | error = ofputil_pull_ofp15_buckets(msg, bucket_list_len, ofp_version, | |
2168 | gm->type, &gm->buckets); | |
2169 | if (error) { | |
2170 | return error; | |
2171 | } | |
2172 | ||
2173 | error = parse_ofp15_group_properties(msg, gm->type, gm->command, | |
2174 | &gm->props, msg->size); | |
2175 | if (error) { | |
2176 | ofputil_bucket_list_destroy(&gm->buckets); | |
2177 | } | |
2178 | return error; | |
2179 | } | |
2180 | ||
2181 | static enum ofperr | |
2182 | ofputil_check_group_mod(const struct ofputil_group_mod *gm) | |
2183 | { | |
2184 | switch (gm->type) { | |
2185 | case OFPGT11_INDIRECT: | |
2186 | if (gm->command != OFPGC11_DELETE | |
2187 | && !ovs_list_is_singleton(&gm->buckets) ) { | |
2188 | return OFPERR_OFPGMFC_INVALID_GROUP; | |
2189 | } | |
2190 | break; | |
2191 | case OFPGT11_ALL: | |
2192 | case OFPGT11_SELECT: | |
2193 | case OFPGT11_FF: | |
2194 | break; | |
2195 | default: | |
2196 | return OFPERR_OFPGMFC_BAD_TYPE; | |
2197 | } | |
2198 | ||
2199 | switch (gm->command) { | |
2200 | case OFPGC11_ADD: | |
2201 | case OFPGC11_MODIFY: | |
2202 | case OFPGC11_ADD_OR_MOD: | |
2203 | case OFPGC11_DELETE: | |
2204 | case OFPGC15_INSERT_BUCKET: | |
2205 | break; | |
2206 | case OFPGC15_REMOVE_BUCKET: | |
2207 | if (!ovs_list_is_empty(&gm->buckets)) { | |
2208 | return OFPERR_OFPGMFC_BAD_BUCKET; | |
2209 | } | |
2210 | break; | |
2211 | default: | |
2212 | return OFPERR_OFPGMFC_BAD_COMMAND; | |
2213 | } | |
2214 | ||
2215 | struct ofputil_bucket *bucket; | |
2216 | LIST_FOR_EACH (bucket, list_node, &gm->buckets) { | |
2217 | if (bucket->weight && gm->type != OFPGT11_SELECT) { | |
2218 | return OFPERR_OFPGMFC_INVALID_GROUP; | |
2219 | } | |
2220 | ||
2221 | switch (gm->type) { | |
2222 | case OFPGT11_ALL: | |
2223 | case OFPGT11_INDIRECT: | |
2224 | if (ofputil_bucket_has_liveness(bucket)) { | |
2225 | return OFPERR_OFPGMFC_WATCH_UNSUPPORTED; | |
2226 | } | |
2227 | break; | |
2228 | case OFPGT11_SELECT: | |
2229 | break; | |
2230 | case OFPGT11_FF: | |
2231 | if (!ofputil_bucket_has_liveness(bucket)) { | |
2232 | return OFPERR_OFPGMFC_INVALID_GROUP; | |
2233 | } | |
2234 | break; | |
2235 | default: | |
2236 | /* Returning BAD TYPE to be consistent | |
2237 | * though gm->type has been checked already. */ | |
2238 | return OFPERR_OFPGMFC_BAD_TYPE; | |
2239 | } | |
2240 | } | |
2241 | ||
2242 | return 0; | |
2243 | } | |
2244 | ||
2245 | /* Converts OpenFlow group mod message 'oh' into an abstract group mod in | |
2246 | * 'gm'. Returns 0 if successful, otherwise an OpenFlow error code. */ | |
2247 | enum ofperr | |
2248 | ofputil_decode_group_mod(const struct ofp_header *oh, | |
2249 | struct ofputil_group_mod *gm) | |
2250 | { | |
2251 | ofputil_init_group_properties(&gm->props); | |
2252 | ||
2253 | enum ofp_version ofp_version = oh->version; | |
2254 | struct ofpbuf msg = ofpbuf_const_initializer(oh, ntohs(oh->length)); | |
2255 | ofpraw_pull_assert(&msg); | |
2256 | ||
2257 | enum ofperr err; | |
2258 | switch (ofp_version) { | |
2259 | case OFP11_VERSION: | |
2260 | case OFP12_VERSION: | |
2261 | case OFP13_VERSION: | |
2262 | case OFP14_VERSION: | |
2263 | err = ofputil_pull_ofp11_group_mod(&msg, ofp_version, gm); | |
2264 | break; | |
2265 | ||
2266 | case OFP10_VERSION: | |
2267 | case OFP15_VERSION: | |
2268 | case OFP16_VERSION: | |
2269 | err = ofputil_pull_ofp15_group_mod(&msg, ofp_version, gm); | |
2270 | break; | |
2271 | ||
2272 | default: | |
2273 | OVS_NOT_REACHED(); | |
2274 | } | |
2275 | if (err) { | |
2276 | return err; | |
2277 | } | |
2278 | ||
2279 | err = ofputil_check_group_mod(gm); | |
2280 | if (err) { | |
2281 | ofputil_uninit_group_mod(gm); | |
2282 | } | |
2283 | return err; | |
2284 | } | |
2285 | ||
2286 | void | |
2287 | ofputil_group_mod_format__(struct ds *s, enum ofp_version ofp_version, | |
2288 | const struct ofputil_group_mod *gm, | |
2289 | const struct ofputil_port_map *port_map, | |
2290 | const struct ofputil_table_map *table_map) | |
2291 | { | |
2292 | bool bucket_command = false; | |
2293 | ||
2294 | ds_put_char(s, '\n'); | |
2295 | ||
2296 | ds_put_char(s, ' '); | |
2297 | switch (gm->command) { | |
2298 | case OFPGC11_ADD: | |
2299 | ds_put_cstr(s, "ADD"); | |
2300 | break; | |
2301 | ||
2302 | case OFPGC11_MODIFY: | |
2303 | ds_put_cstr(s, "MOD"); | |
2304 | break; | |
2305 | ||
2306 | case OFPGC11_ADD_OR_MOD: | |
2307 | ds_put_cstr(s, "ADD_OR_MOD"); | |
2308 | break; | |
2309 | ||
2310 | case OFPGC11_DELETE: | |
2311 | ds_put_cstr(s, "DEL"); | |
2312 | break; | |
2313 | ||
2314 | case OFPGC15_INSERT_BUCKET: | |
2315 | ds_put_cstr(s, "INSERT_BUCKET"); | |
2316 | bucket_command = true; | |
2317 | break; | |
2318 | ||
2319 | case OFPGC15_REMOVE_BUCKET: | |
2320 | ds_put_cstr(s, "REMOVE_BUCKET"); | |
2321 | bucket_command = true; | |
2322 | break; | |
2323 | ||
2324 | default: | |
2325 | ds_put_format(s, "cmd:%"PRIu16"", gm->command); | |
2326 | } | |
2327 | ds_put_char(s, ' '); | |
2328 | ||
2329 | if (bucket_command) { | |
2330 | ofp_print_bucket_id(s, "command_bucket_id:", | |
2331 | gm->command_bucket_id, ofp_version); | |
2332 | } | |
2333 | ||
2334 | ofp_print_group(s, gm->group_id, gm->type, &gm->buckets, &gm->props, | |
2335 | ofp_version, bucket_command, port_map, table_map); | |
2336 | } | |
2337 | ||
2338 | enum ofperr | |
2339 | ofputil_group_mod_format(struct ds *s, const struct ofp_header *oh, | |
2340 | const struct ofputil_port_map *port_map, | |
2341 | const struct ofputil_table_map *table_map) | |
2342 | { | |
2343 | struct ofputil_group_mod gm; | |
2344 | int error; | |
2345 | ||
2346 | error = ofputil_decode_group_mod(oh, &gm); | |
2347 | if (error) { | |
2348 | return error; | |
2349 | } | |
2350 | ofputil_group_mod_format__(s, oh->version, &gm, port_map, table_map); | |
2351 | ofputil_uninit_group_mod(&gm); | |
2352 | return 0; | |
2353 | } |