X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;ds=sidebyside;f=lib%2Fofp-parse.c;h=c630ccd1a08ca63ed78f0d4795bbf3302ac94400;hb=6c0386119d614d5e26ca08cc3d8e527806b87ef9;hp=5321364b125412071d3f819086f4eb3dd8589e12;hpb=f0fd1a1772665ea57662281d9cccadb0f0146196;p=sliver-openvswitch.git

diff --git a/lib/ofp-parse.c b/lib/ofp-parse.c
index 5321364b1..c630ccd1a 100644
--- a/lib/ofp-parse.c
+++ b/lib/ofp-parse.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, 2011 Nicira Networks.
+ * Copyright (c) 2010, 2011, 2012 Nicira Networks.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -151,14 +151,13 @@ parse_output(struct ofpbuf *b, char *arg)
 {
     if (strchr(arg, '[')) {
         struct nx_action_output_reg *naor;
-        int ofs, n_bits;
-        uint32_t src;
+        struct mf_subfield src;
 
-        nxm_parse_field_bits(arg, &src, &ofs, &n_bits);
+        mf_parse_subfield(&src, arg);
 
         naor = ofputil_put_NXAST_OUTPUT_REG(b);
-        naor->ofs_nbits = nxm_encode_ofs_nbits(ofs, n_bits);
-        naor->src = htonl(src);
+        naor->ofs_nbits = nxm_encode_ofs_nbits(src.ofs, src.n_bits);
+        naor->src = htonl(src.field->nxm_header);
         naor->max_len = htons(UINT16_MAX);
     } else {
         put_output_action(b, str_to_u32(arg));
@@ -250,6 +249,66 @@ parse_note(struct ofpbuf *b, const char *arg)
     nan->len = htons(b->size - start_ofs);
 }
 
+static void
+parse_fin_timeout(struct ofpbuf *b, char *arg)
+{
+    struct nx_action_fin_timeout *naft;
+    char *key, *value;
+
+    naft = ofputil_put_NXAST_FIN_TIMEOUT(b);
+    while (ofputil_parse_key_value(&arg, &key, &value)) {
+        if (!strcmp(key, "idle_timeout")) {
+            naft->fin_idle_timeout = htons(str_to_u16(value, key));
+        } else if (!strcmp(key, "hard_timeout")) {
+            naft->fin_hard_timeout = htons(str_to_u16(value, key));
+        } else {
+            ovs_fatal(0, "invalid key '%s' in 'fin_timeout' argument", key);
+        }
+    }
+}
+
+static void
+parse_controller(struct ofpbuf *b, char *arg)
+{
+    enum ofp_packet_in_reason reason = OFPR_ACTION;
+    uint16_t controller_id = 0;
+    uint16_t max_len = UINT16_MAX;
+
+    if (!arg[0]) {
+        /* Use defaults. */
+    } else if (strspn(arg, "0123456789") == strlen(arg)) {
+        max_len = str_to_u16(arg, "max_len");
+    } else {
+        char *name, *value;
+
+        while (ofputil_parse_key_value(&arg, &name, &value)) {
+            if (!strcmp(name, "reason")) {
+                if (!ofputil_packet_in_reason_from_string(value, &reason)) {
+                    ovs_fatal(0, "unknown reason \"%s\"", value);
+                }
+            } else if (!strcmp(name, "max_len")) {
+                max_len = str_to_u16(value, "max_len");
+            } else if (!strcmp(name, "id")) {
+                controller_id = str_to_u16(value, "id");
+            } else {
+                ovs_fatal(0, "unknown key \"%s\" parsing controller action",
+                          name);
+            }
+        }
+    }
+
+    if (reason == OFPR_ACTION && controller_id == 0) {
+        put_output_action(b, OFPP_CONTROLLER)->max_len = htons(max_len);
+    } else {
+        struct nx_action_controller *nac;
+
+        nac = ofputil_put_NXAST_CONTROLLER(b);
+        nac->max_len = htons(max_len);
+        nac->reason = reason;
+        nac->controller_id = htons(controller_id);
+    }
+}
+
 static void
 parse_named_action(enum ofputil_action_code code, const struct flow *flow,
                    struct ofpbuf *b, char *arg)
@@ -368,6 +427,14 @@ parse_named_action(enum ofputil_action_code code, const struct flow *flow,
     case OFPUTIL_NXAST_DEC_TTL:
         ofputil_put_NXAST_DEC_TTL(b);
         break;
+
+    case OFPUTIL_NXAST_FIN_TIMEOUT:
+        parse_fin_timeout(b, arg);
+        break;
+
+    case OFPUTIL_NXAST_CONTROLLER:
+        parse_controller(b, arg);
+        break;
     }
 }
 
@@ -397,17 +464,6 @@ str_to_action(const struct flow *flow, char *str, struct ofpbuf *b)
                           "actions");
             }
             break;
-        } else if (!strcasecmp(act, "CONTROLLER")) {
-            struct ofp_action_output *oao;
-            oao = put_output_action(b, OFPP_CONTROLLER);
-
-            /* Unless a numeric argument is specified, we send the whole
-             * packet to the controller. */
-            if (arg[0] && (strspn(arg, "0123456789") == strlen(arg))) {
-               oao->max_len = htons(str_to_u32(arg));
-            } else {
-                oao->max_len = htons(UINT16_MAX);
-            }
         } else if (ofputil_port_from_string(act, &port)) {
             put_output_action(b, port);
         } else {
@@ -493,7 +549,8 @@ parse_ofp_str(struct ofputil_flow_mod *fm, int command, const char *str_,
         F_OUT_PORT = 1 << 0,
         F_ACTIONS = 1 << 1,
         F_TIMEOUT = 1 << 3,
-        F_PRIORITY = 1 << 4
+        F_PRIORITY = 1 << 4,
+        F_FLAGS = 1 << 5,
     } fields;
     char *string = xstrdup(str_);
     char *save_ptr = NULL;
@@ -506,7 +563,7 @@ parse_ofp_str(struct ofputil_flow_mod *fm, int command, const char *str_,
         break;
 
     case OFPFC_ADD:
-        fields = F_ACTIONS | F_TIMEOUT | F_PRIORITY;
+        fields = F_ACTIONS | F_TIMEOUT | F_PRIORITY | F_FLAGS;
         break;
 
     case OFPFC_DELETE:
@@ -518,11 +575,11 @@ parse_ofp_str(struct ofputil_flow_mod *fm, int command, const char *str_,
         break;
 
     case OFPFC_MODIFY:
-        fields = F_ACTIONS;
+        fields = F_ACTIONS | F_TIMEOUT | F_PRIORITY | F_FLAGS;
         break;
 
     case OFPFC_MODIFY_STRICT:
-        fields = F_ACTIONS | F_PRIORITY;
+        fields = F_ACTIONS | F_TIMEOUT | F_PRIORITY | F_FLAGS;
         break;
 
     default:
@@ -562,6 +619,10 @@ parse_ofp_str(struct ofputil_flow_mod *fm, int command, const char *str_,
             if (p->nw_proto) {
                 cls_rule_set_nw_proto(&fm->cr, p->nw_proto);
             }
+        } else if (fields & F_FLAGS && !strcmp(name, "send_flow_rem")) {
+            fm->flags |= OFPFF_SEND_FLOW_REM;
+        } else if (fields & F_FLAGS && !strcmp(name, "check_overlap")) {
+            fm->flags |= OFPFF_CHECK_OVERLAP;
         } else {
             char *value;
 
@@ -621,76 +682,68 @@ parse_ofp_str(struct ofputil_flow_mod *fm, int command, const char *str_,
     free(string);
 }
 
+/* Parses 's' as a set of OpenFlow actions and appends the actions to
+ * 'actions'.
+ *
+ * Prints an error on stderr and aborts the program if 's' syntax is
+ * invalid. */
+void
+parse_ofp_actions(const char *s_, struct ofpbuf *actions)
+{
+    char *s = xstrdup(s_);
+    str_to_action(NULL, s, actions);
+    free(s);
+}
+
 /* Parses 'string' as an OFPT_FLOW_MOD or NXT_FLOW_MOD with command 'command'
- * (one of OFPFC_*) and appends the parsed OpenFlow message to 'packets'.
- * '*cur_format' should initially contain the flow format currently configured
- * on the connection; this function will add a message to change the flow
- * format and update '*cur_format', if this is necessary to add the parsed
- * flow. */
+ * (one of OFPFC_*) into 'fm'. */
 void
-parse_ofp_flow_mod_str(struct list *packets, enum nx_flow_format *cur_format,
-                       bool *flow_mod_table_id, char *string, uint16_t command,
-                       bool verbose)
+parse_ofp_flow_mod_str(struct ofputil_flow_mod *fm, const char *string,
+                       uint16_t command, bool verbose)
 {
-    enum nx_flow_format min_format, next_format;
     struct cls_rule rule_copy;
-    struct ofpbuf *ofm;
-    struct ofputil_flow_mod fm;
 
-    parse_ofp_str(&fm, command, string, verbose);
-
-    min_format = ofputil_min_flow_format(&fm.cr);
-    if (command != OFPFC_ADD && fm.cookie_mask != htonll(0)) {
-        min_format = NXFF_NXM;
-    }
-    next_format = MAX(*cur_format, min_format);
-    if (next_format != *cur_format) {
-        struct ofpbuf *sff = ofputil_make_set_flow_format(next_format);
-        list_push_back(packets, &sff->list_node);
-        *cur_format = next_format;
-    }
+    parse_ofp_str(fm, command, string, verbose);
 
     /* Normalize a copy of the rule.  This ensures that non-normalized flows
      * get logged but doesn't affect what gets sent to the switch, so that the
      * switch can do whatever it likes with the flow. */
-    rule_copy = fm.cr;
-    ofputil_normalize_rule(&rule_copy, next_format);
-
-    if (fm.table_id != 0xff && !*flow_mod_table_id) {
-        struct ofpbuf *sff = ofputil_make_flow_mod_table_id(true);
-        list_push_back(packets, &sff->list_node);
-        *flow_mod_table_id = true;
-    }
-
-    ofm = ofputil_encode_flow_mod(&fm, *cur_format, *flow_mod_table_id);
-    list_push_back(packets, &ofm->list_node);
+    rule_copy = fm->cr;
+    ofputil_normalize_rule(&rule_copy);
 }
 
-/* Similar to parse_ofp_flow_mod_str(), except that the string is read from
- * 'stream' and the command is always OFPFC_ADD.  Returns false if end-of-file
- * is reached before reading a flow, otherwise true. */
-bool
-parse_ofp_flow_mod_file(struct list *packets,
-                        enum nx_flow_format *cur, bool *flow_mod_table_id,
-                        FILE *stream, uint16_t command)
+void
+parse_ofp_flow_mod_file(const char *file_name, uint16_t command,
+                        struct ofputil_flow_mod **fms, size_t *n_fms)
 {
+    size_t allocated_fms;
+    FILE *stream;
     struct ds s;
-    bool ok;
 
+    stream = !strcmp(file_name, "-") ? stdin : fopen(file_name, "r");
+    if (stream == NULL) {
+        ovs_fatal(errno, "%s: open", file_name);
+    }
+
+    allocated_fms = *n_fms;
     ds_init(&s);
-    ok = ds_get_preprocessed_line(&s, stream) == 0;
-    if (ok) {
-        parse_ofp_flow_mod_str(packets, cur, flow_mod_table_id,
-                               ds_cstr(&s), command, true);
+    while (!ds_get_preprocessed_line(&s, stream)) {
+        if (*n_fms >= allocated_fms) {
+            *fms = x2nrealloc(*fms, &allocated_fms, sizeof **fms);
+        }
+        parse_ofp_flow_mod_str(&(*fms)[*n_fms], ds_cstr(&s), command, false);
+        *n_fms += 1;
     }
     ds_destroy(&s);
 
-    return ok;
+    if (stream != stdin) {
+        fclose(stream);
+    }
 }
 
 void
 parse_ofp_flow_stats_request_str(struct ofputil_flow_stats_request *fsr,
-                                 bool aggregate, char *string)
+                                 bool aggregate, const char *string)
 {
     struct ofputil_flow_mod fm;