lib/learn.c

   1 /*
   2  * Copyright (c) 2011, 2012 Nicira Networks.
   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
  19 #include "learn.h"
  20
  21 #include "byte-order.h"
  22 #include "dynamic-string.h"
  23 #include "meta-flow.h"
  24 #include "nx-match.h"
  25 #include "ofp-errors.h"
  26 #include "ofp-util.h"
  27 #include "ofpbuf.h"
  28 #include "openflow/openflow.h"
  29 #include "unaligned.h"
  30
  31 static ovs_be16
  32 get_be16(const void **pp)
  33 {
  34     const ovs_be16 *p = *pp;
  35     ovs_be16 value = *p;
  36     *pp = p + 1;
  37     return value;
  38 }
  39
  40 static ovs_be32
  41 get_be32(const void **pp)
  42 {
  43     const ovs_be32 *p = *pp;
  44     ovs_be32 value = get_unaligned_be32(p);
  45     *pp = p + 1;
  46     return value;
  47 }
  48
  49 static uint64_t
  50 get_bits(int n_bits, const void **p)
  51 {
  52     int n_segs = DIV_ROUND_UP(n_bits, 16);
  53     uint64_t value;
  54
  55     value = 0;
  56     while (n_segs-- > 0) {
  57         value = (value << 16) | ntohs(get_be16(p));
  58     }
  59     return value;
  60 }
  61
  62 static void
  63 get_subfield(int n_bits, const void **p, struct mf_subfield *sf)
  64 {
  65     sf->field = mf_from_nxm_header(ntohl(get_be32(p)));
  66     sf->ofs = ntohs(get_be16(p));
  67     sf->n_bits = n_bits;
  68 }
  69
  70 static unsigned int
  71 learn_min_len(uint16_t header)
  72 {
  73     int n_bits = header & NX_LEARN_N_BITS_MASK;
  74     int src_type = header & NX_LEARN_SRC_MASK;
  75     int dst_type = header & NX_LEARN_DST_MASK;
  76     unsigned int min_len;
  77
  78     min_len = 0;
  79     if (src_type == NX_LEARN_SRC_FIELD) {
  80         min_len += sizeof(ovs_be32); /* src_field */
  81         min_len += sizeof(ovs_be16); /* src_ofs */
  82     } else {
  83         min_len += DIV_ROUND_UP(n_bits, 16);
  84     }
  85     if (dst_type == NX_LEARN_DST_MATCH ||
  86         dst_type == NX_LEARN_DST_LOAD) {
  87         min_len += sizeof(ovs_be32); /* dst_field */
  88         min_len += sizeof(ovs_be16); /* dst_ofs */
  89     }
  90     return min_len;
  91 }
  92
  93 static enum ofperr
  94 learn_check_header(uint16_t header, size_t len)
  95 {
  96     int src_type = header & NX_LEARN_SRC_MASK;
  97     int dst_type = header & NX_LEARN_DST_MASK;
  98
  99     /* Check for valid src and dst type combination. */
 100     if (dst_type == NX_LEARN_DST_MATCH ||
 101         dst_type == NX_LEARN_DST_LOAD ||
 102         (dst_type == NX_LEARN_DST_OUTPUT &&
 103          src_type == NX_LEARN_SRC_FIELD)) {
 104         /* OK. */
 105     } else {
 106         return OFPERR_OFPBAC_BAD_ARGUMENT;
 107     }
 108
 109     /* Check that the arguments don't overrun the end of the action. */
 110     if (len < learn_min_len(header)) {
 111         return OFPERR_OFPBAC_BAD_LEN;
 112     }
 113
 114     return 0;
 115 }
 116
 117 /* Checks that 'learn' (which must be at least 'sizeof *learn' bytes long) is a
 118  * valid action on 'flow'. */
 119 enum ofperr
 120 learn_check(const struct nx_action_learn *learn, const struct flow *flow)
 121 {
 122     struct cls_rule rule;
 123     const void *p, *end;
 124
 125     cls_rule_init_catchall(&rule, 0);
 126
 127     if (learn->flags & ~htons(OFPFF_SEND_FLOW_REM)
 128         || learn->pad
 129         || learn->table_id == 0xff) {
 130         return OFPERR_OFPBAC_BAD_ARGUMENT;
 131     }
 132
 133     end = (char *) learn + ntohs(learn->len);
 134     for (p = learn + 1; p != end; ) {
 135         uint16_t header = ntohs(get_be16(&p));
 136         int n_bits = header & NX_LEARN_N_BITS_MASK;
 137         int src_type = header & NX_LEARN_SRC_MASK;
 138         int dst_type = header & NX_LEARN_DST_MASK;
 139
 140         enum ofperr error;
 141         uint64_t value;
 142
 143         if (!header) {
 144             break;
 145         }
 146
 147         error = learn_check_header(header, (char *) end - (char *) p);
 148         if (error) {
 149             return error;
 150         }
 151
 152         /* Check the source. */
 153         if (src_type == NX_LEARN_SRC_FIELD) {
 154             struct mf_subfield src;
 155
 156             get_subfield(n_bits, &p, &src);
 157             error = mf_check_src(&src, flow);
 158             if (error) {
 159                 return error;
 160             }
 161             value = 0;
 162         } else {
 163             value = get_bits(n_bits, &p);
 164         }
 165
 166         /* Check the destination. */
 167         if (dst_type == NX_LEARN_DST_MATCH || dst_type == NX_LEARN_DST_LOAD) {
 168             struct mf_subfield dst;
 169
 170             get_subfield(n_bits, &p, &dst);
 171             error = (dst_type == NX_LEARN_DST_LOAD
 172                      ? mf_check_dst(&dst, &rule.flow)
 173                      : mf_check_src(&dst, &rule.flow));
 174             if (error) {
 175                 return error;
 176             }
 177
 178             if (dst_type == NX_LEARN_DST_MATCH
 179                 && src_type == NX_LEARN_SRC_IMMEDIATE) {
 180                 if (n_bits <= 64) {
 181                     mf_set_subfield(&dst, value, &rule);
 182                 } else {
 183                     /* We're only setting subfields to allow us to check
 184                      * prerequisites.  No prerequisite depends on the value of
 185                      * a field that is wider than 64 bits.  So just skip
 186                      * setting it entirely. */
 187                     BUILD_ASSERT_DECL(FLOW_WC_SEQ == 10);
 188                 }
 189             }
 190         }
 191     }
 192     if (!is_all_zeros(p, (char *) end - (char *) p)) {
 193         return OFPERR_OFPBAC_BAD_ARGUMENT;
 194     }
 195
 196     return 0;
 197 }
 198
 199 void
 200 learn_execute(const struct nx_action_learn *learn, const struct flow *flow,
 201               struct ofputil_flow_mod *fm)
 202 {
 203     const void *p, *end;
 204     struct ofpbuf actions;
 205
 206     cls_rule_init_catchall(&fm->cr, ntohs(learn->priority));
 207     fm->cookie = learn->cookie;
 208     fm->cookie_mask = htonll(UINT64_MAX);
 209     fm->table_id = learn->table_id;
 210     fm->command = OFPFC_MODIFY_STRICT;
 211     fm->idle_timeout = ntohs(learn->idle_timeout);
 212     fm->hard_timeout = ntohs(learn->hard_timeout);
 213     fm->buffer_id = UINT32_MAX;
 214     fm->out_port = OFPP_NONE;
 215     fm->flags = ntohs(learn->flags) & OFPFF_SEND_FLOW_REM;
 216     fm->actions = NULL;
 217     fm->n_actions = 0;
 218
 219     ofpbuf_init(&actions, 64);
 220
 221     if (learn->fin_idle_timeout || learn->fin_hard_timeout) {
 222         struct nx_action_fin_timeout *naft;
 223
 224         naft = ofputil_put_NXAST_FIN_TIMEOUT(&actions);
 225         naft->fin_idle_timeout = learn->fin_idle_timeout;
 226         naft->fin_hard_timeout = learn->fin_hard_timeout;
 227     }
 228
 229     for (p = learn + 1, end = (char *) learn + ntohs(learn->len); p != end; ) {
 230         uint16_t header = ntohs(get_be16(&p));
 231         int n_bits = header & NX_LEARN_N_BITS_MASK;
 232         int src_type = header & NX_LEARN_SRC_MASK;
 233         int dst_type = header & NX_LEARN_DST_MASK;
 234         union mf_subvalue value;
 235
 236         struct mf_subfield dst;
 237         int chunk, ofs;
 238
 239         if (!header) {
 240             break;
 241         }
 242
 243         if (src_type == NX_LEARN_SRC_FIELD) {
 244             struct mf_subfield src;
 245
 246             get_subfield(n_bits, &p, &src);
 247             mf_read_subfield(&src, flow, &value);
 248         } else {
 249             int p_bytes = 2 * DIV_ROUND_UP(n_bits, 16);
 250
 251             memset(&value, 0, sizeof value);
 252             bitwise_copy(p, p_bytes, 0,
 253                          &value, sizeof value, 0,
 254                          n_bits);
 255             p = (const uint8_t *) p + p_bytes;
 256         }
 257
 258         switch (dst_type) {
 259         case NX_LEARN_DST_MATCH:
 260             get_subfield(n_bits, &p, &dst);
 261             mf_write_subfield(&dst, &value, &fm->cr);
 262             break;
 263
 264         case NX_LEARN_DST_LOAD:
 265             get_subfield(n_bits, &p, &dst);
 266             for (ofs = 0; ofs < n_bits; ofs += chunk) {
 267                 struct nx_action_reg_load *load;
 268
 269                 chunk = MIN(n_bits - ofs, 64);
 270
 271                 load = ofputil_put_NXAST_REG_LOAD(&actions);
 272                 load->ofs_nbits = nxm_encode_ofs_nbits(dst.ofs + ofs, chunk);
 273                 load->dst = htonl(dst.field->nxm_header);
 274                 bitwise_copy(&value, sizeof value, ofs,
 275                              &load->value, sizeof load->value, 0,
 276                              chunk);
 277             }
 278             break;
 279
 280         case NX_LEARN_DST_OUTPUT:
 281             if (n_bits <= 16 || is_all_zeros(value.u8, sizeof value - 2)) {
 282                 ofputil_put_OFPAT10_OUTPUT(&actions)->port = value.be16[7];
 283             }
 284             break;
 285         }
 286     }
 287
 288     fm->actions = ofpbuf_steal_data(&actions);
 289     fm->n_actions = actions.size / sizeof(struct ofp_action_header);
 290 }
 291
 292 static void
 293 put_be16(struct ofpbuf *b, ovs_be16 x)
 294 {
 295     ofpbuf_put(b, &x, sizeof x);
 296 }
 297
 298 static void
 299 put_be32(struct ofpbuf *b, ovs_be32 x)
 300 {
 301     ofpbuf_put(b, &x, sizeof x);
 302 }
 303
 304 static void
 305 put_u16(struct ofpbuf *b, uint16_t x)
 306 {
 307     put_be16(b, htons(x));
 308 }
 309
 310 static void
 311 put_u32(struct ofpbuf *b, uint32_t x)
 312 {
 313     put_be32(b, htonl(x));
 314 }
 315
 316 struct learn_spec {
 317     int n_bits;
 318
 319     int src_type;
 320     struct mf_subfield src;
 321     union mf_subvalue src_imm;
 322
 323     int dst_type;
 324     struct mf_subfield dst;
 325 };
 326
 327 static void
 328 learn_parse_load_immediate(const char *s, struct learn_spec *spec)
 329 {
 330     const char *full_s = s;
 331     const char *arrow = strstr(s, "->");
 332     struct mf_subfield dst;
 333     union mf_subvalue imm;
 334
 335     memset(&imm, 0, sizeof imm);
 336     if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X') && arrow) {
 337         const char *in = arrow - 1;
 338         uint8_t *out = imm.u8 + sizeof imm.u8 - 1;
 339         int n = arrow - (s + 2);
 340         int i;
 341
 342         for (i = 0; i < n; i++) {
 343             int hexit = hexit_value(in[-i]);
 344             if (hexit < 0) {
 345                 ovs_fatal(0, "%s: bad hex digit in value", full_s);
 346             }
 347             out[-(i / 2)] |= i % 2 ? hexit << 4 : hexit;
 348         }
 349         s = arrow;
 350     } else {
 351         imm.be64[1] = htonll(strtoull(s, (char **) &s, 0));
 352     }
 353
 354     if (strncmp(s, "->", 2)) {
 355         ovs_fatal(0, "%s: missing `->' following value", full_s);
 356     }
 357     s += 2;
 358
 359     s = mf_parse_subfield(&dst, s);
 360     if (*s != '\0') {
 361         ovs_fatal(0, "%s: trailing garbage following destination", full_s);
 362     }
 363
 364     if (!bitwise_is_all_zeros(&imm, sizeof imm, dst.n_bits,
 365                               (8 * sizeof imm) - dst.n_bits)) {
 366         ovs_fatal(0, "%s: value does not fit into %u bits",
 367                   full_s, dst.n_bits);
 368     }
 369
 370     spec->n_bits = dst.n_bits;
 371     spec->src_type = NX_LEARN_SRC_IMMEDIATE;
 372     spec->src_imm = imm;
 373     spec->dst_type = NX_LEARN_DST_LOAD;
 374     spec->dst = dst;
 375 }
 376
 377 static void
 378 learn_parse_spec(const char *orig, char *name, char *value,
 379                  struct learn_spec *spec)
 380 {
 381     memset(spec, 0, sizeof *spec);
 382     if (mf_from_name(name)) {
 383         const struct mf_field *dst = mf_from_name(name);
 384         union mf_value imm;
 385         char *error;
 386
 387         error = mf_parse_value(dst, value, &imm);
 388         if (error) {
 389             ovs_fatal(0, "%s", error);
 390         }
 391
 392         spec->n_bits = dst->n_bits;
 393         spec->src_type = NX_LEARN_SRC_IMMEDIATE;
 394         memset(&spec->src_imm, 0, sizeof spec->src_imm);
 395         memcpy(&spec->src_imm.u8[sizeof spec->src_imm - dst->n_bytes],
 396                &imm, dst->n_bytes);
 397         spec->dst_type = NX_LEARN_DST_MATCH;
 398         spec->dst.field = dst;
 399         spec->dst.ofs = 0;
 400         spec->dst.n_bits = dst->n_bits;
 401     } else if (strchr(name, '[')) {
 402         /* Parse destination and check prerequisites. */
 403         if (mf_parse_subfield(&spec->dst, name)[0] != '\0') {
 404             ovs_fatal(0, "%s: syntax error after NXM field name `%s'",
 405                       orig, name);
 406         }
 407
 408         /* Parse source and check prerequisites. */
 409         if (value[0] != '\0') {
 410             if (mf_parse_subfield(&spec->src, value)[0] != '\0') {
 411                 ovs_fatal(0, "%s: syntax error after NXM field name `%s'",
 412                           orig, value);
 413             }
 414             if (spec->src.n_bits != spec->dst.n_bits) {
 415                 ovs_fatal(0, "%s: bit widths of %s (%u) and %s (%u) differ",
 416                           orig, name, spec->src.n_bits, value,
 417                           spec->dst.n_bits);
 418             }
 419         } else {
 420             spec->src = spec->dst;
 421         }
 422
 423         spec->n_bits = spec->src.n_bits;
 424         spec->src_type = NX_LEARN_SRC_FIELD;
 425         spec->dst_type = NX_LEARN_DST_MATCH;
 426     } else if (!strcmp(name, "load")) {
 427         if (value[strcspn(value, "[-")] == '-') {
 428             learn_parse_load_immediate(value, spec);
 429         } else {
 430             struct nx_action_reg_move move;
 431
 432             nxm_parse_reg_move(&move, value);
 433
 434             spec->n_bits = ntohs(move.n_bits);
 435             spec->src_type = NX_LEARN_SRC_FIELD;
 436             nxm_decode_discrete(&spec->src,
 437                                 move.src, move.src_ofs, move.n_bits);
 438             spec->dst_type = NX_LEARN_DST_LOAD;
 439             nxm_decode_discrete(&spec->dst,
 440                                 move.dst, move.dst_ofs, move.n_bits);
 441         }
 442     } else if (!strcmp(name, "output")) {
 443         if (mf_parse_subfield(&spec->src, value)[0] != '\0') {
 444             ovs_fatal(0, "%s: syntax error after NXM field name `%s'",
 445                       orig, name);
 446         }
 447
 448         spec->n_bits = spec->src.n_bits;
 449         spec->src_type = NX_LEARN_SRC_FIELD;
 450         spec->dst_type = NX_LEARN_DST_OUTPUT;
 451     } else {
 452         ovs_fatal(0, "%s: unknown keyword %s", orig, name);
 453     }
 454 }
 455
 456 /* Parses 'arg' as a set of arguments to the "learn" action and appends a
 457  * matching NXAST_LEARN action to 'b'.  The format parsed is described in
 458  * ovs-ofctl(8).
 459  *
 460  * Prints an error on stderr and aborts the program if 'arg' syntax is invalid.
 461  *
 462  * If 'flow' is nonnull, then it should be the flow from a cls_rule that is
 463  * the matching rule for the learning action.  This helps to better validate
 464  * the action's arguments.
 465  *
 466  * Modifies 'arg'. */
 467 void
 468 learn_parse(struct ofpbuf *b, char *arg, const struct flow *flow)
 469 {
 470     char *orig = xstrdup(arg);
 471     char *name, *value;
 472     enum ofperr error;
 473     size_t learn_ofs;
 474     size_t len;
 475
 476     struct nx_action_learn *learn;
 477     struct cls_rule rule;
 478
 479     learn_ofs = b->size;
 480     learn = ofputil_put_NXAST_LEARN(b);
 481     learn->idle_timeout = htons(OFP_FLOW_PERMANENT);
 482     learn->hard_timeout = htons(OFP_FLOW_PERMANENT);
 483     learn->priority = htons(OFP_DEFAULT_PRIORITY);
 484     learn->cookie = htonll(0);
 485     learn->flags = htons(0);
 486     learn->table_id = 1;
 487
 488     cls_rule_init_catchall(&rule, 0);
 489     while (ofputil_parse_key_value(&arg, &name, &value)) {
 490         learn = ofpbuf_at_assert(b, learn_ofs, sizeof *learn);
 491         if (!strcmp(name, "table")) {
 492             learn->table_id = atoi(value);
 493             if (learn->table_id == 255) {
 494                 ovs_fatal(0, "%s: table id 255 not valid for `learn' action",
 495                           orig);
 496             }
 497         } else if (!strcmp(name, "priority")) {
 498             learn->priority = htons(atoi(value));
 499         } else if (!strcmp(name, "idle_timeout")) {
 500             learn->idle_timeout = htons(atoi(value));
 501         } else if (!strcmp(name, "hard_timeout")) {
 502             learn->hard_timeout = htons(atoi(value));
 503         } else if (!strcmp(name, "fin_idle_timeout")) {
 504             learn->fin_idle_timeout = htons(atoi(value));
 505         } else if (!strcmp(name, "fin_hard_timeout")) {
 506             learn->fin_hard_timeout = htons(atoi(value));
 507         } else if (!strcmp(name, "cookie")) {
 508             learn->cookie = htonll(strtoull(value, NULL, 0));
 509         } else {
 510             struct learn_spec spec;
 511
 512             learn_parse_spec(orig, name, value, &spec);
 513
 514             /* Check prerequisites. */
 515             if (spec.src_type == NX_LEARN_SRC_FIELD
 516                 && flow && !mf_are_prereqs_ok(spec.src.field, flow)) {
 517                 ovs_fatal(0, "%s: cannot specify source field %s because "
 518                           "prerequisites are not satisfied",
 519                           orig, spec.src.field->name);
 520             }
 521             if ((spec.dst_type == NX_LEARN_DST_MATCH
 522                  || spec.dst_type == NX_LEARN_DST_LOAD)
 523                 && !mf_are_prereqs_ok(spec.dst.field, &rule.flow)) {
 524                 ovs_fatal(0, "%s: cannot specify destination field %s because "
 525                           "prerequisites are not satisfied",
 526                           orig, spec.dst.field->name);
 527             }
 528
 529             /* Update 'rule' to allow for satisfying destination
 530              * prerequisites. */
 531             if (spec.src_type == NX_LEARN_SRC_IMMEDIATE
 532                 && spec.dst_type == NX_LEARN_DST_MATCH) {
 533                 mf_write_subfield(&spec.dst, &spec.src_imm, &rule);
 534             }
 535
 536             /* Output the flow_mod_spec. */
 537             put_u16(b, spec.n_bits | spec.src_type | spec.dst_type);
 538             if (spec.src_type == NX_LEARN_SRC_IMMEDIATE) {
 539                 int n_bytes = DIV_ROUND_UP(spec.n_bits, 16) * 2;
 540                 int ofs = sizeof spec.src_imm - n_bytes;
 541                 ofpbuf_put(b, &spec.src_imm.u8[ofs], n_bytes);
 542             } else {
 543                 put_u32(b, spec.src.field->nxm_header);
 544                 put_u16(b, spec.src.ofs);
 545             }
 546             if (spec.dst_type == NX_LEARN_DST_MATCH ||
 547                 spec.dst_type == NX_LEARN_DST_LOAD) {
 548                 put_u32(b, spec.dst.field->nxm_header);
 549                 put_u16(b, spec.dst.ofs);
 550             } else {
 551                 assert(spec.dst_type == NX_LEARN_DST_OUTPUT);
 552             }
 553         }
 554     }
 555
 556     put_u16(b, 0);
 557
 558     len = b->size - learn_ofs;
 559     if (len % 8) {
 560         ofpbuf_put_zeros(b, 8 - len % 8);
 561     }
 562
 563     learn = ofpbuf_at_assert(b, learn_ofs, sizeof *learn);
 564     learn->len = htons(b->size - learn_ofs);
 565
 566     /* In theory the above should have caught any errors, but... */
 567     if (flow) {
 568         error = learn_check(learn, flow);
 569         if (error) {
 570             ovs_fatal(0, "%s: %s", orig, ofperr_to_string(error));
 571         }
 572     }
 573     free(orig);
 574 }
 575
 576 void
 577 learn_format(const struct nx_action_learn *learn, struct ds *s)
 578 {
 579     struct cls_rule rule;
 580     const void *p, *end;
 581
 582     cls_rule_init_catchall(&rule, 0);
 583
 584     ds_put_format(s, "learn(table=%"PRIu8, learn->table_id);
 585     if (learn->idle_timeout != htons(OFP_FLOW_PERMANENT)) {
 586         ds_put_format(s, ",idle_timeout=%"PRIu16, ntohs(learn->idle_timeout));
 587     }
 588     if (learn->hard_timeout != htons(OFP_FLOW_PERMANENT)) {
 589         ds_put_format(s, ",hard_timeout=%"PRIu16, ntohs(learn->hard_timeout));
 590     }
 591     if (learn->fin_idle_timeout) {
 592         ds_put_format(s, ",fin_idle_timeout=%"PRIu16,
 593                       ntohs(learn->fin_idle_timeout));
 594     }
 595     if (learn->fin_hard_timeout) {
 596         ds_put_format(s, ",fin_hard_timeout=%"PRIu16,
 597                       ntohs(learn->fin_hard_timeout));
 598     }
 599     if (learn->priority != htons(OFP_DEFAULT_PRIORITY)) {
 600         ds_put_format(s, ",priority=%"PRIu16, ntohs(learn->priority));
 601     }
 602     if (learn->flags & htons(OFPFF_SEND_FLOW_REM)) {
 603         ds_put_cstr(s, ",OFPFF_SEND_FLOW_REM");
 604     }
 605     if (learn->flags & htons(~OFPFF_SEND_FLOW_REM)) {
 606         ds_put_format(s, ",***flags=%"PRIu16"***",
 607                       ntohs(learn->flags) & ~OFPFF_SEND_FLOW_REM);
 608     }
 609     if (learn->cookie != htonll(0)) {
 610         ds_put_format(s, ",cookie=0x%"PRIx64, ntohll(learn->cookie));
 611     }
 612     if (learn->pad != 0) {
 613         ds_put_cstr(s, ",***nonzero pad***");
 614     }
 615
 616     end = (char *) learn + ntohs(learn->len);
 617     for (p = learn + 1; p != end; ) {
 618         uint16_t header = ntohs(get_be16(&p));
 619         int n_bits = header & NX_LEARN_N_BITS_MASK;
 620
 621         int src_type = header & NX_LEARN_SRC_MASK;
 622         struct mf_subfield src;
 623         const uint8_t *src_value;
 624         int src_value_bytes;
 625
 626         int dst_type = header & NX_LEARN_DST_MASK;
 627         struct mf_subfield dst;
 628
 629         enum ofperr error;
 630         int i;
 631
 632         if (!header) {
 633             break;
 634         }
 635
 636         error = learn_check_header(header, (char *) end - (char *) p);
 637         if (error == OFPERR_OFPBAC_BAD_ARGUMENT) {
 638             ds_put_format(s, ",***bad flow_mod_spec header %"PRIx16"***)",
 639                           header);
 640             return;
 641         } else if (error == OFPERR_OFPBAC_BAD_LEN) {
 642             ds_put_format(s, ",***flow_mod_spec at offset %td is %u bytes "
 643                           "long but only %td bytes are left***)",
 644                           (char *) p - (char *) (learn + 1) - 2,
 645                           learn_min_len(header) + 2,
 646                           (char *) end - (char *) p + 2);
 647             return;
 648         }
 649         assert(!error);
 650
 651         /* Get the source. */
 652         if (src_type == NX_LEARN_SRC_FIELD) {
 653             get_subfield(n_bits, &p, &src);
 654             src_value_bytes = 0;
 655             src_value = NULL;
 656         } else {
 657             src.field = NULL;
 658             src.ofs = 0;
 659             src.n_bits = 0;
 660             src_value_bytes = 2 * DIV_ROUND_UP(n_bits, 16);
 661             src_value = p;
 662             p = (const void *) ((const uint8_t *) p + src_value_bytes);
 663         }
 664
 665         /* Get the destination. */
 666         if (dst_type == NX_LEARN_DST_MATCH || dst_type == NX_LEARN_DST_LOAD) {
 667             get_subfield(n_bits, &p, &dst);
 668         } else {
 669             dst.field = NULL;
 670             dst.ofs = 0;
 671             dst.n_bits = 0;
 672         }
 673
 674         ds_put_char(s, ',');
 675
 676         switch (src_type | dst_type) {
 677         case NX_LEARN_SRC_IMMEDIATE | NX_LEARN_DST_MATCH:
 678             if (dst.field && dst.ofs == 0 && n_bits == dst.field->n_bits) {
 679                 union mf_value value;
 680                 uint8_t *bytes = (uint8_t *) &value;
 681
 682                 if (src_value_bytes > dst.field->n_bytes) {
 683                     /* The destination field is an odd number of bytes, which
 684                      * got rounded up to a multiple of 2 to be put into the
 685                      * learning action.  Skip over the leading byte, which
 686                      * should be zero anyway.  Otherwise the memcpy() below
 687                      * will overrun the start of 'value'. */
 688                     int diff = src_value_bytes - dst.field->n_bytes;
 689                     src_value += diff;
 690                     src_value_bytes -= diff;
 691                 }
 692
 693                 memset(&value, 0, sizeof value);
 694                 memcpy(&bytes[dst.field->n_bytes - src_value_bytes],
 695                        src_value, src_value_bytes);
 696                 ds_put_format(s, "%s=", dst.field->name);
 697                 mf_format(dst.field, &value, NULL, s);
 698             } else {
 699                 mf_format_subfield(&dst, s);
 700                 ds_put_cstr(s, "=0x");
 701                 for (i = 0; i < src_value_bytes; i++) {
 702                     ds_put_format(s, "%02"PRIx8, src_value[i]);
 703                 }
 704             }
 705             break;
 706
 707         case NX_LEARN_SRC_FIELD | NX_LEARN_DST_MATCH:
 708             mf_format_subfield(&dst, s);
 709             if (src.field != dst.field || src.ofs != dst.ofs) {
 710                 ds_put_char(s, '=');
 711                 mf_format_subfield(&src, s);
 712             }
 713             break;
 714
 715         case NX_LEARN_SRC_IMMEDIATE | NX_LEARN_DST_LOAD:
 716             ds_put_cstr(s, "load:0x");
 717             for (i = 0; i < src_value_bytes; i++) {
 718                 ds_put_format(s, "%02"PRIx8, src_value[i]);
 719             }
 720             ds_put_cstr(s, "->");
 721             mf_format_subfield(&dst, s);
 722             break;
 723
 724         case NX_LEARN_SRC_FIELD | NX_LEARN_DST_LOAD:
 725             ds_put_cstr(s, "load:");
 726             mf_format_subfield(&src, s);
 727             ds_put_cstr(s, "->");
 728             mf_format_subfield(&dst, s);
 729             break;
 730
 731         case NX_LEARN_SRC_FIELD | NX_LEARN_DST_OUTPUT:
 732             ds_put_cstr(s, "output:");
 733             mf_format_subfield(&src, s);
 734             break;
 735         }
 736     }
 737     if (!is_all_zeros(p, (char *) end - (char *) p)) {
 738         ds_put_cstr(s, ",***nonzero trailer***");
 739     }
 740     ds_put_char(s, ')');
 741 }