datapath-windows/ovsext/Flow.c

   1 /*
   2  * Copyright (c) 2014 VMware, 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 "precomp.h"
  18 #include "NetProto.h"
  19 #include "Util.h"
  20 #include "Jhash.h"
  21 #include "Flow.h"
  22 #include "PacketParser.h"
  23 #include "Datapath.h"
  24
  25 #ifdef OVS_DBG_MOD
  26 #undef OVS_DBG_MOD
  27 #endif
  28 #define OVS_DBG_MOD OVS_DBG_FLOW
  29 #include "Debug.h"
  30
  31 #pragma warning( push )
  32 #pragma warning( disable:4127 )
  33
  34 extern PNDIS_SPIN_LOCK gOvsCtrlLock;
  35 extern POVS_SWITCH_CONTEXT gOvsSwitchContext;
  36 extern UINT64 ovsTimeIncrementPerTick;
  37
  38 static NTSTATUS ReportFlowInfo(OvsFlow *flow, UINT32 getFlags,
  39                                OvsFlowInfo *info);
  40 static NTSTATUS HandleFlowPut(OvsFlowPut *put,
  41                                   OVS_DATAPATH *datapath,
  42                                   struct OvsFlowStats *stats);
  43 static NTSTATUS OvsPrepareFlow(OvsFlow **flow, const OvsFlowPut *put,
  44                                UINT64 hash);
  45 static VOID RemoveFlow(OVS_DATAPATH *datapath, OvsFlow **flow);
  46 static VOID DeleteAllFlows(OVS_DATAPATH *datapath);
  47 static NTSTATUS AddFlow(OVS_DATAPATH *datapath, OvsFlow *flow);
  48 static VOID FreeFlow(OvsFlow *flow);
  49 static VOID __inline *GetStartAddrNBL(const NET_BUFFER_LIST *_pNB);
  50 static NTSTATUS _MapNlToFlowPut(POVS_MESSAGE msgIn, PNL_ATTR keyAttr,
  51                                 PNL_ATTR actionAttr,
  52                                 PNL_ATTR flowAttrClear,
  53                                 OvsFlowPut *mappedFlow);
  54 static VOID _MapKeyAttrToFlowPut(PNL_ATTR *keyAttrs,
  55                                  PNL_ATTR *tunnelAttrs,
  56                                  OvsFlowKey *destKey);
  57
  58 static VOID _MapTunAttrToFlowPut(PNL_ATTR *keyAttrs,
  59                                  PNL_ATTR *tunnelAttrs,
  60                                  OvsFlowKey *destKey);
  61 static VOID _MapNlToFlowPutFlags(PGENL_MSG_HDR genlMsgHdr,
  62                                  PNL_ATTR flowAttrClear,
  63                                  OvsFlowPut *mappedFlow);
  64
  65 static NTSTATUS _FlowNlGetCmdHandler(POVS_USER_PARAMS_CONTEXT usrParamsCtx,
  66                                      UINT32 *replyLen);
  67 static NTSTATUS _FlowNlDumpCmdHandler(POVS_USER_PARAMS_CONTEXT usrParamsCtx,
  68                                       UINT32 *replyLen);
  69 static NTSTATUS _MapFlowInfoToNl(PNL_BUFFER nlBuf,
  70                                  OvsFlowInfo *flowInfo);
  71 static NTSTATUS _MapFlowStatsToNlStats(PNL_BUFFER nlBuf,
  72                                        OvsFlowStats *flowStats);
  73 static NTSTATUS _MapFlowActionToNlAction(PNL_BUFFER nlBuf,
  74                                          uint32_t actionsLen,
  75                                          PNL_ATTR actions);
  76
  77 static NTSTATUS _MapFlowIpv4KeyToNlKey(PNL_BUFFER nlBuf,
  78                                        IpKey *ipv4FlowPutKey);
  79 static NTSTATUS _MapFlowIpv6KeyToNlKey(PNL_BUFFER nlBuf,
  80                                        Ipv6Key *ipv6FlowPutKey,
  81                                        Icmp6Key *ipv6FlowPutIcmpKey);
  82 static NTSTATUS _MapFlowArpKeyToNlKey(PNL_BUFFER nlBuf,
  83                                       ArpKey *arpFlowPutKey);
  84
  85 static NTSTATUS OvsDoDumpFlows(OvsFlowDumpInput *dumpInput,
  86                                OvsFlowDumpOutput *dumpOutput,
  87                                UINT32 *replyLen);
  88
  89
  90 #define OVS_FLOW_TABLE_SIZE 2048
  91 #define OVS_FLOW_TABLE_MASK (OVS_FLOW_TABLE_SIZE -1)
  92 #define HASH_BUCKET(hash) ((hash) & OVS_FLOW_TABLE_MASK)
  93
  94 /* Flow family related netlink policies */
  95
  96 /* For Parsing attributes in FLOW_* commands */
  97 const NL_POLICY nlFlowPolicy[] = {
  98     [OVS_FLOW_ATTR_KEY] = {.type = NL_A_NESTED, .optional = FALSE},
  99     [OVS_FLOW_ATTR_MASK] = {.type = NL_A_NESTED, .optional = TRUE},
 100     [OVS_FLOW_ATTR_ACTIONS] = {.type = NL_A_NESTED, .optional = TRUE},
 101     [OVS_FLOW_ATTR_STATS] = {.type = NL_A_UNSPEC,
 102                              .minLen = sizeof(struct ovs_flow_stats),
 103                              .maxLen = sizeof(struct ovs_flow_stats),
 104                              .optional = TRUE},
 105     [OVS_FLOW_ATTR_TCP_FLAGS] = {NL_A_U8, .optional = TRUE},
 106     [OVS_FLOW_ATTR_USED] = {NL_A_U64, .optional = TRUE}
 107 };
 108
 109 /* For Parsing nested OVS_FLOW_ATTR_KEY attributes.
 110  * Some of the attributes like OVS_KEY_ATTR_RECIRC_ID
 111  * & OVS_KEY_ATTR_MPLS are not supported yet. */
 112
 113 const NL_POLICY nlFlowKeyPolicy[] = {
 114     [OVS_KEY_ATTR_ENCAP] = {.type = NL_A_VAR_LEN, .optional = TRUE},
 115     [OVS_KEY_ATTR_PRIORITY] = {.type = NL_A_UNSPEC, .minLen = 4,
 116                                .maxLen = 4, .optional = TRUE},
 117     [OVS_KEY_ATTR_IN_PORT] = {.type = NL_A_UNSPEC, .minLen = 4,
 118                               .maxLen = 4, .optional = FALSE},
 119     [OVS_KEY_ATTR_ETHERNET] = {.type = NL_A_UNSPEC,
 120                                .minLen = sizeof(struct ovs_key_ethernet),
 121                                .maxLen = sizeof(struct ovs_key_ethernet),
 122                                .optional = TRUE},
 123     [OVS_KEY_ATTR_VLAN] = {.type = NL_A_UNSPEC, .minLen = 2,
 124                            .maxLen = 2, .optional = TRUE},
 125     [OVS_KEY_ATTR_ETHERTYPE] = {.type = NL_A_UNSPEC, .minLen = 2,
 126                                 .maxLen = 2, .optional = TRUE},
 127     [OVS_KEY_ATTR_IPV4] = {.type = NL_A_UNSPEC,
 128                            .minLen = sizeof(struct ovs_key_ipv4),
 129                            .maxLen = sizeof(struct ovs_key_ipv4),
 130                            .optional = TRUE},
 131     [OVS_KEY_ATTR_IPV6] = {.type = NL_A_UNSPEC,
 132                            .minLen = sizeof(struct ovs_key_ipv6),
 133                            .maxLen = sizeof(struct ovs_key_ipv6),
 134                            .optional = TRUE},
 135     [OVS_KEY_ATTR_TCP] = {.type = NL_A_UNSPEC,
 136                           .minLen = sizeof(struct ovs_key_tcp),
 137                           .maxLen = sizeof(struct ovs_key_tcp),
 138                           .optional = TRUE},
 139     [OVS_KEY_ATTR_UDP] = {.type = NL_A_UNSPEC,
 140                           .minLen = sizeof(struct ovs_key_udp),
 141                           .maxLen = sizeof(struct ovs_key_udp),
 142                           .optional = TRUE},
 143     [OVS_KEY_ATTR_ICMP] = {.type = NL_A_UNSPEC,
 144                            .minLen = sizeof(struct ovs_key_icmp),
 145                            .maxLen = sizeof(struct ovs_key_icmp),
 146                            .optional = TRUE},
 147     [OVS_KEY_ATTR_ICMPV6] = {.type = NL_A_UNSPEC,
 148                              .minLen = sizeof(struct ovs_key_icmpv6),
 149                              .maxLen = sizeof(struct ovs_key_icmpv6),
 150                              .optional = TRUE},
 151     [OVS_KEY_ATTR_ARP] = {.type = NL_A_UNSPEC,
 152                           .minLen = sizeof(struct ovs_key_arp),
 153                           .maxLen = sizeof(struct ovs_key_arp),
 154                           .optional = TRUE},
 155     [OVS_KEY_ATTR_ND] = {.type = NL_A_UNSPEC,
 156                          .minLen = sizeof(struct ovs_key_nd),
 157                          .maxLen = sizeof(struct ovs_key_nd),
 158                          .optional = TRUE},
 159     [OVS_KEY_ATTR_SKB_MARK] = {.type = NL_A_UNSPEC, .minLen = 4,
 160                                .maxLen = 4, .optional = TRUE},
 161     [OVS_KEY_ATTR_TUNNEL] = {.type = NL_A_VAR_LEN, .optional = TRUE},
 162     [OVS_KEY_ATTR_SCTP] = {.type = NL_A_UNSPEC,
 163                            .minLen = sizeof(struct ovs_key_sctp),
 164                            .maxLen = sizeof(struct ovs_key_sctp),
 165                            .optional = TRUE},
 166     [OVS_KEY_ATTR_TCP_FLAGS] = {.type = NL_A_UNSPEC,
 167                                 .minLen = 2, .maxLen = 2,
 168                                 .optional = TRUE},
 169     [OVS_KEY_ATTR_DP_HASH] = {.type = NL_A_UNSPEC, .minLen = 4,
 170                               .maxLen = 4, .optional = TRUE},
 171     [OVS_KEY_ATTR_RECIRC_ID] = {.type = NL_A_UNSPEC, .minLen = 4,
 172                                 .maxLen = 4, .optional = TRUE},
 173     [OVS_KEY_ATTR_MPLS] = {.type = NL_A_VAR_LEN, .optional = TRUE}
 174 };
 175
 176 /* For Parsing nested OVS_KEY_ATTR_TUNNEL attributes */
 177 const NL_POLICY nlFlowTunnelKeyPolicy[] = {
 178     [OVS_TUNNEL_KEY_ATTR_ID] = {.type = NL_A_UNSPEC, .minLen = 8,
 179                                 .maxLen = 8, .optional = TRUE},
 180     [OVS_TUNNEL_KEY_ATTR_IPV4_SRC] = {.type = NL_A_UNSPEC, .minLen = 4,
 181                                       .maxLen = 4, .optional = TRUE},
 182     [OVS_TUNNEL_KEY_ATTR_IPV4_DST] = {.type = NL_A_UNSPEC, .minLen = 4 ,
 183                                       .maxLen = 4, .optional = FALSE},
 184     [OVS_TUNNEL_KEY_ATTR_TOS] = {.type = NL_A_UNSPEC, .minLen = 1,
 185                                  .maxLen = 1, .optional = TRUE},
 186     [OVS_TUNNEL_KEY_ATTR_TTL] = {.type = NL_A_UNSPEC, .minLen = 1,
 187                                  .maxLen = 1, .optional = TRUE},
 188     [OVS_TUNNEL_KEY_ATTR_DONT_FRAGMENT] = {.type = NL_A_UNSPEC, .minLen = 0,
 189                                            .maxLen = 0, .optional = TRUE},
 190     [OVS_TUNNEL_KEY_ATTR_CSUM] = {.type = NL_A_UNSPEC, .minLen = 0,
 191                                   .maxLen = 0, .optional = TRUE},
 192     [OVS_TUNNEL_KEY_ATTR_OAM] = {.type = NL_A_UNSPEC, .minLen = 0,
 193                                  .maxLen = 0, .optional = TRUE},
 194     [OVS_TUNNEL_KEY_ATTR_GENEVE_OPTS] = {.type = NL_A_VAR_LEN,
 195                                          .optional = TRUE}
 196 };
 197
 198 /* For Parsing nested OVS_FLOW_ATTR_ACTIONS attributes */
 199 const NL_POLICY nlFlowActionPolicy[] = {
 200     [OVS_ACTION_ATTR_OUTPUT] = {.type = NL_A_UNSPEC, .minLen = sizeof(UINT32),
 201                                 .maxLen = sizeof(UINT32), .optional = TRUE},
 202     [OVS_ACTION_ATTR_USERSPACE] = {.type = NL_A_VAR_LEN, .optional = TRUE},
 203     [OVS_ACTION_ATTR_PUSH_VLAN] = {.type = NL_A_UNSPEC,
 204                                    .minLen =
 205                                    sizeof(struct ovs_action_push_vlan),
 206                                    .maxLen =
 207                                    sizeof(struct ovs_action_push_vlan),
 208                                    .optional = TRUE},
 209     [OVS_ACTION_ATTR_POP_VLAN] = {.type = NL_A_UNSPEC, .optional = TRUE},
 210     [OVS_ACTION_ATTR_PUSH_MPLS] = {.type = NL_A_UNSPEC,
 211                                    .minLen =
 212                                    sizeof(struct ovs_action_push_mpls),
 213                                    .maxLen =
 214                                    sizeof(struct ovs_action_push_mpls),
 215                                    .optional = TRUE},
 216     [OVS_ACTION_ATTR_POP_MPLS] = {.type = NL_A_UNSPEC,
 217                                   .minLen = sizeof(UINT16),
 218                                   .maxLen = sizeof(UINT16),
 219                                   .optional = TRUE},
 220     [OVS_ACTION_ATTR_RECIRC] = {.type = NL_A_UNSPEC,
 221                                 .minLen = sizeof(UINT32),
 222                                 .maxLen = sizeof(UINT32),
 223                                 .optional = TRUE},
 224     [OVS_ACTION_ATTR_HASH] = {.type = NL_A_UNSPEC,
 225                               .minLen = sizeof(struct ovs_action_hash),
 226                               .maxLen = sizeof(struct ovs_action_hash),
 227                               .optional = TRUE},
 228     [OVS_ACTION_ATTR_SET] = {.type = NL_A_VAR_LEN, .optional = TRUE},
 229     [OVS_ACTION_ATTR_SAMPLE] = {.type = NL_A_VAR_LEN, .optional = TRUE}
 230 };
 231
 232 /*
 233  *----------------------------------------------------------------------------
 234  * Netlink interface for flow commands.
 235  *----------------------------------------------------------------------------
 236  */
 237
 238 /*
 239  *----------------------------------------------------------------------------
 240  *  OvsFlowNewCmdHandler --
 241  *    Handler for OVS_FLOW_CMD_NEW/SET/DEL command.
 242  *    It also handles FLUSH case (DEL w/o any key in input)
 243  *----------------------------------------------------------------------------
 244  */
 245 NTSTATUS
 246 OvsFlowNlCmdHandler(POVS_USER_PARAMS_CONTEXT usrParamsCtx,
 247                     UINT32 *replyLen)
 248 {
 249     NTSTATUS rc = STATUS_SUCCESS;
 250     POVS_MESSAGE msgIn = (POVS_MESSAGE)usrParamsCtx->inputBuffer;
 251     POVS_MESSAGE msgOut = (POVS_MESSAGE)usrParamsCtx->outputBuffer;
 252     PNL_MSG_HDR nlMsgHdr = &(msgIn->nlMsg);
 253     PGENL_MSG_HDR genlMsgHdr = &(msgIn->genlMsg);
 254     POVS_HDR ovsHdr = &(msgIn->ovsHdr);
 255     PNL_ATTR nlAttrs[__OVS_FLOW_ATTR_MAX];
 256     UINT32 attrOffset = NLMSG_HDRLEN + GENL_HDRLEN + OVS_HDRLEN;
 257     OvsFlowPut mappedFlow;
 258     OvsFlowStats stats;
 259     struct ovs_flow_stats replyStats;
 260     NL_ERROR nlError = NL_ERROR_SUCCESS;
 261
 262     NL_BUFFER nlBuf;
 263
 264     RtlZeroMemory(&mappedFlow, sizeof(OvsFlowPut));
 265     RtlZeroMemory(&stats, sizeof(stats));
 266     RtlZeroMemory(&replyStats, sizeof(replyStats));
 267
 268     if (!(usrParamsCtx->outputBuffer)) {
 269         /* No output buffer */
 270         rc = STATUS_INVALID_BUFFER_SIZE;
 271         goto done;
 272     }
 273
 274     /* Get all the top level Flow attributes */
 275     if ((NlAttrParse(nlMsgHdr, attrOffset, NlMsgAttrsLen(nlMsgHdr),
 276                      nlFlowPolicy, nlAttrs, ARRAY_SIZE(nlAttrs)))
 277                      != TRUE) {
 278         OVS_LOG_ERROR("Attr Parsing failed for msg: %p",
 279                        nlMsgHdr);
 280         rc = STATUS_INVALID_PARAMETER;
 281         goto done;
 282     }
 283
 284     /* FLOW_DEL command w/o any key input is a flush case. */
 285     if ((genlMsgHdr->cmd == OVS_FLOW_CMD_DEL) &&
 286         (!(nlAttrs[OVS_FLOW_ATTR_KEY]))) {
 287
 288         rc = OvsFlushFlowIoctl(ovsHdr->dp_ifindex);
 289
 290        if (rc == STATUS_SUCCESS) {
 291             /* XXX: refactor this code. */
 292             /* So far so good. Prepare the reply for userspace */
 293             NlBufInit(&nlBuf, usrParamsCtx->outputBuffer,
 294                       usrParamsCtx->outputLength);
 295
 296             /* Prepare nl Msg headers */
 297             rc = NlFillOvsMsg(&nlBuf, nlMsgHdr->nlmsgType, 0,
 298                               nlMsgHdr->nlmsgSeq, nlMsgHdr->nlmsgPid,
 299                               genlMsgHdr->cmd, OVS_FLOW_VERSION,
 300                               ovsHdr->dp_ifindex);
 301
 302             if (rc == STATUS_SUCCESS) {
 303                 *replyLen = msgOut->nlMsg.nlmsgLen;
 304             }
 305        }
 306
 307        goto done;
 308     }
 309
 310     if ((rc = _MapNlToFlowPut(msgIn, nlAttrs[OVS_FLOW_ATTR_KEY],
 311          nlAttrs[OVS_FLOW_ATTR_ACTIONS], nlAttrs[OVS_FLOW_ATTR_CLEAR],
 312          &mappedFlow))
 313         != STATUS_SUCCESS) {
 314         OVS_LOG_ERROR("Conversion to OvsFlowPut failed");
 315         goto done;
 316     }
 317
 318     rc = OvsPutFlowIoctl(&mappedFlow, sizeof (struct OvsFlowPut),
 319                          &stats);
 320     if (rc != STATUS_SUCCESS) {
 321         OVS_LOG_ERROR("OvsFlowPut failed.");
 322         goto done;
 323     }
 324
 325     replyStats.n_packets = stats.packetCount;
 326     replyStats.n_bytes = stats.byteCount;
 327
 328     /* So far so good. Prepare the reply for userspace */
 329     NlBufInit(&nlBuf, usrParamsCtx->outputBuffer,
 330               usrParamsCtx->outputLength);
 331
 332     /* Prepare nl Msg headers */
 333     rc = NlFillOvsMsg(&nlBuf, nlMsgHdr->nlmsgType, 0,
 334                       nlMsgHdr->nlmsgSeq, nlMsgHdr->nlmsgPid,
 335                       genlMsgHdr->cmd, OVS_FLOW_VERSION,
 336                       ovsHdr->dp_ifindex);
 337
 338     if (rc != STATUS_SUCCESS) {
 339         goto done;
 340     }
 341
 342     /* Append OVS_FLOW_ATTR_STATS attribute */
 343     if (!NlMsgPutTailUnspec(&nlBuf, OVS_FLOW_ATTR_STATS,
 344         (PCHAR)(&replyStats), sizeof(replyStats))) {
 345         OVS_LOG_ERROR("Adding OVS_FLOW_ATTR_STATS attribute failed.");
 346         rc = STATUS_INVALID_BUFFER_SIZE;
 347         goto done;
 348     }
 349
 350     msgOut->nlMsg.nlmsgLen = NLMSG_ALIGN(NlBufSize(&nlBuf));
 351     *replyLen = msgOut->nlMsg.nlmsgLen;
 352
 353 done:
 354
 355     if (nlError != NL_ERROR_SUCCESS) {
 356         POVS_MESSAGE_ERROR msgError = (POVS_MESSAGE_ERROR)
 357                                        usrParamsCtx->outputBuffer;
 358         BuildErrorMsg(msgIn, msgError, nlError);
 359         *replyLen = msgError->nlMsg.nlmsgLen;
 360         rc = STATUS_SUCCESS;
 361     }
 362
 363     return rc;
 364 }
 365
 366 /*
 367  *----------------------------------------------------------------------------
 368  *  OvsFlowNlGetCmdHandler --
 369  *    Handler for OVS_FLOW_CMD_GET/DUMP commands.
 370  *----------------------------------------------------------------------------
 371  */
 372 NTSTATUS
 373 OvsFlowNlGetCmdHandler(POVS_USER_PARAMS_CONTEXT usrParamsCtx,
 374                        UINT32 *replyLen)
 375 {
 376     NTSTATUS status = STATUS_SUCCESS;
 377     NL_ERROR nlError = NL_ERROR_SUCCESS;
 378     POVS_MESSAGE msgIn = (POVS_MESSAGE)usrParamsCtx->inputBuffer;
 379
 380     if (usrParamsCtx->devOp == OVS_TRANSACTION_DEV_OP) {
 381         status = _FlowNlGetCmdHandler(usrParamsCtx, replyLen);
 382
 383         /* No trasanctional errors as of now.
 384          * If we have something then we need to convert rc to
 385          * nlError. */
 386         if ((nlError != NL_ERROR_SUCCESS) &&
 387             (usrParamsCtx->outputBuffer)) {
 388             POVS_MESSAGE_ERROR msgError = (POVS_MESSAGE_ERROR)
 389                                            usrParamsCtx->outputBuffer;
 390             BuildErrorMsg(msgIn, msgError, nlError);
 391             *replyLen = msgError->nlMsg.nlmsgLen;
 392             status = STATUS_SUCCESS;
 393             goto done;
 394         }
 395     } else {
 396         status = _FlowNlDumpCmdHandler(usrParamsCtx, replyLen);
 397     }
 398
 399 done:
 400     return status;
 401 }
 402
 403 /*
 404  *----------------------------------------------------------------------------
 405  *  _FlowNlGetCmdHandler --
 406  *    Handler for OVS_FLOW_CMD_GET command.
 407  *----------------------------------------------------------------------------
 408  */
 409 NTSTATUS
 410 _FlowNlGetCmdHandler(POVS_USER_PARAMS_CONTEXT usrParamsCtx,
 411                      UINT32 *replyLen)
 412 {
 413     NTSTATUS rc = STATUS_SUCCESS;
 414     POVS_OPEN_INSTANCE instance = (POVS_OPEN_INSTANCE)
 415                                   (usrParamsCtx->ovsInstance);
 416     POVS_MESSAGE msgIn = (POVS_MESSAGE)usrParamsCtx->inputBuffer;
 417     PNL_MSG_HDR nlMsgHdr = &(msgIn->nlMsg);
 418     POVS_HDR ovsHdr = &(msgIn->ovsHdr);
 419     PNL_MSG_HDR nlMsgOutHdr = NULL;
 420     UINT32 attrOffset = NLMSG_HDRLEN + GENL_HDRLEN + OVS_HDRLEN;
 421     PNL_ATTR nlAttrs[__OVS_FLOW_ATTR_MAX];
 422
 423     OvsFlowGetInput getInput;
 424     OvsFlowGetOutput getOutput;
 425     NL_BUFFER nlBuf;
 426     PNL_ATTR keyAttrs[__OVS_KEY_ATTR_MAX];
 427     PNL_ATTR tunnelAttrs[__OVS_TUNNEL_KEY_ATTR_MAX];
 428
 429     NlBufInit(&nlBuf, usrParamsCtx->outputBuffer,
 430               usrParamsCtx->outputLength);
 431     RtlZeroMemory(&getInput, sizeof(OvsFlowGetInput));
 432     RtlZeroMemory(&getOutput, sizeof(OvsFlowGetOutput));
 433     UINT32 keyAttrOffset = 0;
 434     UINT32 tunnelKeyAttrOffset = 0;
 435
 436     if (usrParamsCtx->inputLength > usrParamsCtx->outputLength) {
 437         /* Should not be the case.
 438          * We'll be copying the flow keys back from
 439          * input buffer to output buffer. */
 440         rc = STATUS_INVALID_PARAMETER;
 441         OVS_LOG_ERROR("inputLength: %d GREATER THEN outputLength: %d",
 442                       usrParamsCtx->inputLength, usrParamsCtx->outputLength);
 443         goto done;
 444     }
 445
 446     /* Get all the top level Flow attributes */
 447     if ((NlAttrParse(nlMsgHdr, attrOffset, NlMsgAttrsLen(nlMsgHdr),
 448                      nlFlowPolicy, nlAttrs, ARRAY_SIZE(nlAttrs)))
 449                      != TRUE) {
 450         OVS_LOG_ERROR("Attr Parsing failed for msg: %p",
 451                        nlMsgHdr);
 452         rc = STATUS_INVALID_PARAMETER;
 453         goto done;
 454     }
 455
 456     keyAttrOffset = (UINT32)((PCHAR) nlAttrs[OVS_FLOW_ATTR_KEY] -
 457                     (PCHAR)nlMsgHdr);
 458
 459     /* Get flow keys attributes */
 460     if ((NlAttrParseNested(nlMsgHdr, keyAttrOffset,
 461                            NlAttrLen(nlAttrs[OVS_FLOW_ATTR_KEY]),
 462                            nlFlowKeyPolicy, keyAttrs, ARRAY_SIZE(keyAttrs)))
 463                            != TRUE) {
 464         OVS_LOG_ERROR("Key Attr Parsing failed for msg: %p",
 465                        nlMsgHdr);
 466         rc = STATUS_INVALID_PARAMETER;
 467         goto done;
 468     }
 469
 470     if (keyAttrs[OVS_KEY_ATTR_TUNNEL]) {
 471         tunnelKeyAttrOffset = (UINT32)((PCHAR)
 472                               (keyAttrs[OVS_KEY_ATTR_TUNNEL])
 473                               - (PCHAR)nlMsgHdr);
 474
 475         /* Get tunnel keys attributes */
 476         if ((NlAttrParseNested(nlMsgHdr, tunnelKeyAttrOffset,
 477                                NlAttrLen(keyAttrs[OVS_KEY_ATTR_TUNNEL]),
 478                                nlFlowTunnelKeyPolicy,
 479                                tunnelAttrs, ARRAY_SIZE(tunnelAttrs)))
 480                                != TRUE) {
 481             OVS_LOG_ERROR("Tunnel key Attr Parsing failed for msg: %p",
 482                            nlMsgHdr);
 483             rc = STATUS_INVALID_PARAMETER;
 484             goto done;
 485         }
 486     }
 487
 488     _MapKeyAttrToFlowPut(keyAttrs, tunnelAttrs,
 489                          &(getInput.key));
 490
 491     getInput.dpNo = ovsHdr->dp_ifindex;
 492     getInput.getFlags = FLOW_GET_STATS | FLOW_GET_ACTIONS;
 493
 494     /* 4th argument is a no op.
 495      * We are keeping this argument to be compatible
 496      * with our dpif-windows based interface. */
 497     rc = OvsGetFlowIoctl(&getInput, &getOutput);
 498     if (rc != STATUS_SUCCESS) {
 499         OVS_LOG_ERROR("OvsGetFlowIoctl failed.");
 500         goto done;
 501     }
 502
 503     /* Lets prepare the reply. */
 504     nlMsgOutHdr = (PNL_MSG_HDR)(NlBufAt(&nlBuf, 0, 0));
 505
 506     /* Input already has all the attributes for the flow key.
 507      * Lets copy the values back. */
 508     RtlCopyMemory(usrParamsCtx->outputBuffer, usrParamsCtx->inputBuffer,
 509                   usrParamsCtx->inputLength);
 510
 511     rc = _MapFlowStatsToNlStats(&nlBuf, &((getOutput.info).stats));
 512     if (rc != STATUS_SUCCESS) {
 513         OVS_LOG_ERROR("_OvsFlowMapFlowKeyToNlStats failed.");
 514         goto done;
 515     }
 516
 517     rc = _MapFlowActionToNlAction(&nlBuf, ((getOutput.info).actionsLen),
 518                                   getOutput.info.actions);
 519     if (rc != STATUS_SUCCESS) {
 520         OVS_LOG_ERROR("_MapFlowActionToNlAction failed.");
 521         goto done;
 522     }
 523
 524     NlMsgSetSize(nlMsgOutHdr, NlBufSize(&nlBuf));
 525     NlMsgAlignSize(nlMsgOutHdr);
 526     *replyLen += NlMsgSize(nlMsgOutHdr);
 527
 528 done:
 529     return rc;
 530 }
 531
 532 /*
 533  *----------------------------------------------------------------------------
 534  *  _FlowNlDumpCmdHandler --
 535  *    Handler for OVS_FLOW_CMD_DUMP command.
 536  *----------------------------------------------------------------------------
 537  */
 538 NTSTATUS
 539 _FlowNlDumpCmdHandler(POVS_USER_PARAMS_CONTEXT usrParamsCtx,
 540                       UINT32 *replyLen)
 541 {
 542     NTSTATUS rc = STATUS_SUCCESS;
 543     UINT32  temp = 0;   /* To keep compiler happy for calling OvsDoDumpFlows */
 544
 545     POVS_OPEN_INSTANCE instance = (POVS_OPEN_INSTANCE)
 546                                   (usrParamsCtx->ovsInstance);
 547
 548     if (usrParamsCtx->devOp == OVS_WRITE_DEV_OP) {
 549         /* Dump Start */
 550         OvsSetupDumpStart(usrParamsCtx);
 551         goto done;
 552     }
 553
 554     POVS_MESSAGE msgIn = instance->dumpState.ovsMsg;
 555     PNL_MSG_HDR nlMsgHdr = &(msgIn->nlMsg);
 556     PGENL_MSG_HDR genlMsgHdr = &(msgIn->genlMsg);
 557     POVS_HDR ovsHdr = &(msgIn->ovsHdr);
 558     PNL_MSG_HDR nlMsgOutHdr = NULL;
 559     UINT32 hdrOffset = 0;
 560
 561     /* Get Next */
 562     OvsFlowDumpOutput dumpOutput;
 563     OvsFlowDumpInput dumpInput;
 564     NL_BUFFER nlBuf;
 565
 566     NlBufInit(&nlBuf, usrParamsCtx->outputBuffer,
 567               usrParamsCtx->outputLength);
 568
 569     ASSERT(usrParamsCtx->devOp == OVS_READ_DEV_OP);
 570     ASSERT(usrParamsCtx->outputLength);
 571
 572     RtlZeroMemory(&dumpInput, sizeof(OvsFlowDumpInput));
 573     RtlZeroMemory(&dumpOutput, sizeof(OvsFlowDumpOutput));
 574
 575     dumpInput.dpNo = ovsHdr->dp_ifindex;
 576     dumpInput.getFlags = FLOW_GET_KEY | FLOW_GET_STATS | FLOW_GET_ACTIONS;
 577
 578     /* Lets provide as many flows to userspace as possible. */
 579     do {
 580         dumpInput.position[0] = instance->dumpState.index[0];
 581         dumpInput.position[1] = instance->dumpState.index[1];
 582
 583         rc = OvsDoDumpFlows(&dumpInput, &dumpOutput, &temp);
 584         if (rc != STATUS_SUCCESS) {
 585             OVS_LOG_ERROR("OvsDoDumpFlows failed with rc: %d", rc);
 586             break;
 587         }
 588
 589         /* Done with Dump, send NLMSG_DONE */
 590         if (!(dumpOutput.n)) {
 591             OVS_LOG_INFO("Dump Done");
 592
 593             nlMsgOutHdr = (PNL_MSG_HDR)(NlBufAt(&nlBuf, NlBufSize(&nlBuf), 0));
 594             rc = NlFillNlHdr(&nlBuf, NLMSG_DONE, NLM_F_MULTI,
 595                              nlMsgHdr->nlmsgSeq, nlMsgHdr->nlmsgPid);
 596
 597             if (rc != STATUS_SUCCESS) {
 598                 OVS_LOG_ERROR("Unable to prepare DUMP_DONE reply.");
 599                 break;
 600             }
 601
 602             NlMsgAlignSize(nlMsgOutHdr);
 603             *replyLen += NlMsgSize(nlMsgOutHdr);
 604
 605             FreeUserDumpState(instance);
 606             break;
 607         } else {
 608
 609             hdrOffset = NlBufSize(&nlBuf);
 610             nlMsgOutHdr = (PNL_MSG_HDR)(NlBufAt(&nlBuf, hdrOffset, 0));
 611
 612             /* Netlink header */
 613             rc = NlFillOvsMsg(&nlBuf, nlMsgHdr->nlmsgType, NLM_F_MULTI,
 614                               nlMsgHdr->nlmsgSeq, nlMsgHdr->nlmsgPid,
 615                               genlMsgHdr->cmd, genlMsgHdr->version,
 616                               ovsHdr->dp_ifindex);
 617
 618             if (rc != STATUS_SUCCESS) {
 619                 /* Reset rc to success so that we can
 620                  * send already added messages to user space. */
 621                 rc = STATUS_SUCCESS;
 622                 break;
 623             }
 624
 625             /* Time to add attributes */
 626             rc = _MapFlowInfoToNl(&nlBuf, &(dumpOutput.flow));
 627             if (rc != STATUS_SUCCESS) {
 628                 /* Adding the attribute failed, we are out of
 629                    space in the buffer, remove the appended OVS header */
 630                 NlMsgSetSize(nlMsgOutHdr,
 631                              NlMsgSize(nlMsgOutHdr) -
 632                              sizeof(struct _OVS_MESSAGE));
 633
 634                 /* Reset rc to success so that we can
 635                  * send already added messages to user space. */
 636                 rc = STATUS_SUCCESS;
 637                 break;
 638             }
 639
 640             NlMsgSetSize(nlMsgOutHdr, NlBufSize(&nlBuf) - hdrOffset);
 641             NlMsgAlignSize(nlMsgOutHdr);
 642             *replyLen += NlMsgSize(nlMsgOutHdr);
 643             instance->dumpState.index[0] = dumpOutput.position[0];
 644             instance->dumpState.index[1] = dumpOutput.position[1];
 645         }
 646     } while(TRUE);
 647
 648 done:
 649     return rc;
 650 }
 651
 652 /*
 653  *----------------------------------------------------------------------------
 654  *  _MapFlowInfoToNl --
 655  *    Maps OvsFlowInfo to Netlink attributes.
 656  *----------------------------------------------------------------------------
 657  */
 658 static NTSTATUS
 659 _MapFlowInfoToNl(PNL_BUFFER nlBuf, OvsFlowInfo *flowInfo)
 660 {
 661     NTSTATUS rc = STATUS_SUCCESS;
 662
 663     rc = MapFlowKeyToNlKey(nlBuf, &(flowInfo->key), OVS_FLOW_ATTR_KEY,
 664                            OVS_KEY_ATTR_TUNNEL);
 665     if (rc != STATUS_SUCCESS) {
 666         goto done;
 667     }
 668
 669     rc = _MapFlowStatsToNlStats(nlBuf, &(flowInfo->stats));
 670     if (rc != STATUS_SUCCESS) {
 671         goto done;
 672     }
 673
 674     rc = _MapFlowActionToNlAction(nlBuf, flowInfo->actionsLen,
 675                                   flowInfo->actions);
 676     if (rc != STATUS_SUCCESS) {
 677         goto done;
 678     }
 679
 680 done:
 681     return rc;
 682 }
 683
 684 /*
 685  *----------------------------------------------------------------------------
 686  *  _MapFlowStatsToNlStats --
 687  *    Maps OvsFlowStats to OVS_FLOW_ATTR_STATS attribute.
 688  *----------------------------------------------------------------------------
 689  */
 690 static NTSTATUS
 691 _MapFlowStatsToNlStats(PNL_BUFFER nlBuf, OvsFlowStats *flowStats)
 692 {
 693     NTSTATUS rc = STATUS_SUCCESS;
 694     struct ovs_flow_stats replyStats;
 695
 696     replyStats.n_packets = flowStats->packetCount;
 697     replyStats.n_bytes = flowStats->byteCount;
 698
 699     if (!NlMsgPutTailU64(nlBuf, OVS_FLOW_ATTR_USED, flowStats->used)) {
 700         rc = STATUS_INVALID_BUFFER_SIZE;
 701         goto done;
 702     }
 703
 704     if (!NlMsgPutTailUnspec(nlBuf, OVS_FLOW_ATTR_STATS,
 705                            (PCHAR)(&replyStats),
 706                            sizeof(struct ovs_flow_stats))) {
 707         rc = STATUS_INVALID_BUFFER_SIZE;
 708         goto done;
 709     }
 710
 711     if (!NlMsgPutTailU8(nlBuf, OVS_FLOW_ATTR_TCP_FLAGS, flowStats->tcpFlags)) {
 712         rc = STATUS_INVALID_BUFFER_SIZE;
 713         goto done;
 714     }
 715
 716 done:
 717     return rc;
 718 }
 719
 720 /*
 721  *----------------------------------------------------------------------------
 722  *  _MapFlowActionToNlAction --
 723  *    Maps flow actions to OVS_FLOW_ATTR_ACTION attribute.
 724  *----------------------------------------------------------------------------
 725  */
 726 static NTSTATUS
 727 _MapFlowActionToNlAction(PNL_BUFFER nlBuf, uint32_t actionsLen,
 728                          PNL_ATTR actions)
 729 {
 730     NTSTATUS rc = STATUS_SUCCESS;
 731     UINT32 offset = 0;
 732
 733     offset = NlMsgStartNested(nlBuf, OVS_FLOW_ATTR_ACTIONS);
 734     if (!offset) {
 735         /* Starting the nested attribute failed. */
 736         rc = STATUS_INVALID_BUFFER_SIZE;
 737         goto error_nested_start;
 738     }
 739
 740     if (!NlBufCopyAtTail(nlBuf, (PCHAR)actions, actionsLen)) {
 741         /* Adding a nested attribute failed. */
 742         rc = STATUS_INVALID_BUFFER_SIZE;
 743         goto done;
 744     }
 745
 746 done:
 747     NlMsgEndNested(nlBuf, offset);
 748 error_nested_start:
 749     return rc;
 750
 751 }
 752
 753 /*
 754  *----------------------------------------------------------------------------
 755  *  MapFlowKeyToNlKey --
 756  *   Maps OvsFlowKey to OVS_FLOW_ATTR_KEY attribute.
 757  *----------------------------------------------------------------------------
 758  */
 759 NTSTATUS
 760 MapFlowKeyToNlKey(PNL_BUFFER nlBuf,
 761                   OvsFlowKey *flowKey,
 762                   UINT16 keyType,
 763                   UINT16 tunKeyType)
 764 {
 765     NTSTATUS rc = STATUS_SUCCESS;
 766     struct ovs_key_ethernet ethKey;
 767     UINT32 offset = 0;
 768
 769     offset = NlMsgStartNested(nlBuf, keyType);
 770     if (!offset) {
 771         /* Starting the nested attribute failed. */
 772         rc = STATUS_UNSUCCESSFUL;
 773         goto error_nested_start;
 774     }
 775
 776     /* Ethernet header */
 777     RtlCopyMemory(&(ethKey.eth_src), flowKey->l2.dlSrc, ETH_ADDR_LEN);
 778     RtlCopyMemory(&(ethKey.eth_dst), flowKey->l2.dlDst, ETH_ADDR_LEN);
 779
 780     if (!NlMsgPutTailUnspec(nlBuf, OVS_KEY_ATTR_ETHERNET,
 781                            (PCHAR)(&ethKey),
 782                            sizeof(struct ovs_key_ethernet))) {
 783         rc = STATUS_UNSUCCESSFUL;
 784         goto done;
 785     }
 786
 787     if (!NlMsgPutTailU32(nlBuf, OVS_KEY_ATTR_IN_PORT,
 788                          flowKey->l2.inPort)) {
 789         rc = STATUS_UNSUCCESSFUL;
 790         goto done;
 791     }
 792
 793     if (!NlMsgPutTailU16(nlBuf, OVS_KEY_ATTR_ETHERTYPE,
 794                          flowKey->l2.dlType)) {
 795         rc = STATUS_UNSUCCESSFUL;
 796         goto done;
 797     }
 798
 799     if (flowKey->l2.vlanTci) {
 800         if (!NlMsgPutTailU16(nlBuf, OVS_KEY_ATTR_VLAN,
 801                              flowKey->l2.vlanTci)) {
 802             rc = STATUS_UNSUCCESSFUL;
 803             goto done;
 804         }
 805     }
 806
 807     /* ==== L3 + L4 ==== */
 808     switch (ntohs(flowKey->l2.dlType)) {
 809         case ETH_TYPE_IPV4: {
 810         IpKey *ipv4FlowPutKey = &(flowKey->ipKey);
 811         rc = _MapFlowIpv4KeyToNlKey(nlBuf, ipv4FlowPutKey);
 812         break;
 813         }
 814
 815         case ETH_TYPE_IPV6: {
 816         Ipv6Key *ipv6FlowPutKey = &(flowKey->ipv6Key);
 817         Icmp6Key *icmpv6FlowPutKey = &(flowKey->icmp6Key);
 818         rc = _MapFlowIpv6KeyToNlKey(nlBuf, ipv6FlowPutKey,
 819                                     icmpv6FlowPutKey);
 820         break;
 821         }
 822
 823         case ETH_TYPE_ARP:
 824         case ETH_TYPE_RARP: {
 825         ArpKey *arpFlowPutKey = &(flowKey->arpKey);
 826         rc = _MapFlowArpKeyToNlKey(nlBuf, arpFlowPutKey);
 827         break;
 828         }
 829
 830         default:
 831         break;
 832     }
 833
 834     if (rc != STATUS_SUCCESS) {
 835         goto done;
 836     }
 837
 838     if (flowKey->tunKey.dst) {
 839         rc = MapFlowTunKeyToNlKey(nlBuf, &(flowKey->tunKey),
 840                                   tunKeyType);
 841         if (rc != STATUS_SUCCESS) {
 842             goto done;
 843         }
 844     }
 845
 846 done:
 847     NlMsgEndNested(nlBuf, offset);
 848 error_nested_start:
 849     return rc;
 850 }
 851
 852 /*
 853  *----------------------------------------------------------------------------
 854  *  MapFlowTunKeyToNlKey --
 855  *   Maps OvsIPv4TunnelKey to OVS_TUNNEL_KEY_ATTR_ID attribute.
 856  *----------------------------------------------------------------------------
 857  */
 858 NTSTATUS
 859 MapFlowTunKeyToNlKey(PNL_BUFFER nlBuf,
 860                      OvsIPv4TunnelKey *tunKey,
 861                      UINT16 tunKeyType)
 862 {
 863     NTSTATUS rc = STATUS_SUCCESS;
 864     UINT32 offset = 0;
 865
 866     offset = NlMsgStartNested(nlBuf, tunKeyType);
 867     if (!offset) {
 868         /* Starting the nested attribute failed. */
 869         rc = STATUS_UNSUCCESSFUL;
 870         goto error_nested_start;
 871     }
 872
 873     if (!NlMsgPutTailU64(nlBuf, OVS_TUNNEL_KEY_ATTR_ID,
 874                          tunKey->tunnelId)) {
 875         rc = STATUS_UNSUCCESSFUL;
 876         goto done;
 877     }
 878
 879     if (!NlMsgPutTailU32(nlBuf, OVS_TUNNEL_KEY_ATTR_IPV4_DST,
 880                          tunKey->dst)) {
 881         rc = STATUS_UNSUCCESSFUL;
 882         goto done;
 883     }
 884
 885     if (!NlMsgPutTailU32(nlBuf, OVS_TUNNEL_KEY_ATTR_IPV4_SRC,
 886                          tunKey->src)) {
 887         rc = STATUS_UNSUCCESSFUL;
 888         goto done;
 889     }
 890
 891     if (!NlMsgPutTailU8(nlBuf, OVS_TUNNEL_KEY_ATTR_TOS,
 892                         tunKey->tos)) {
 893         rc = STATUS_UNSUCCESSFUL;
 894         goto done;
 895     }
 896
 897     if (!NlMsgPutTailU8(nlBuf, OVS_TUNNEL_KEY_ATTR_TTL,
 898                          tunKey->ttl)) {
 899         rc = STATUS_UNSUCCESSFUL;
 900         goto done;
 901     }
 902
 903 done:
 904     NlMsgEndNested(nlBuf, offset);
 905 error_nested_start:
 906     return rc;
 907 }
 908
 909 /*
 910  *----------------------------------------------------------------------------
 911  *  _MapFlowTunKeyToNlKey --
 912  *    Maps OvsIPv4FlowPutKey to OVS_KEY_ATTR_IPV4 attribute.
 913  *----------------------------------------------------------------------------
 914  */
 915 static NTSTATUS
 916 _MapFlowIpv4KeyToNlKey(PNL_BUFFER nlBuf, IpKey *ipv4FlowPutKey)
 917 {
 918     NTSTATUS rc = STATUS_SUCCESS;
 919     struct ovs_key_ipv4 ipv4Key;
 920
 921     ipv4Key.ipv4_src = ipv4FlowPutKey->nwSrc;
 922     ipv4Key.ipv4_dst = ipv4FlowPutKey->nwDst;
 923     ipv4Key.ipv4_proto = ipv4FlowPutKey->nwProto;
 924     ipv4Key.ipv4_tos = ipv4FlowPutKey->nwTos;
 925     ipv4Key.ipv4_ttl = ipv4FlowPutKey->nwTtl;
 926     ipv4Key.ipv4_frag = ipv4FlowPutKey->nwFrag;
 927
 928     if (!NlMsgPutTailUnspec(nlBuf, OVS_KEY_ATTR_IPV4,
 929                            (PCHAR)(&ipv4Key),
 930                            sizeof(struct ovs_key_ipv4))) {
 931         rc = STATUS_UNSUCCESSFUL;
 932         goto done;
 933     }
 934
 935     switch (ipv4Key.ipv4_proto) {
 936         case IPPROTO_TCP: {
 937             struct ovs_key_tcp tcpKey;
 938             tcpKey.tcp_src = ipv4FlowPutKey->l4.tpSrc;
 939             tcpKey.tcp_dst = ipv4FlowPutKey->l4.tpDst;
 940             if (!NlMsgPutTailUnspec(nlBuf, OVS_KEY_ATTR_TCP,
 941                                    (PCHAR)(&tcpKey),
 942                                    sizeof(tcpKey))) {
 943                 rc = STATUS_UNSUCCESSFUL;
 944                 goto done;
 945             }
 946             break;
 947         }
 948
 949         case IPPROTO_UDP: {
 950             struct ovs_key_udp udpKey;
 951             udpKey.udp_src = ipv4FlowPutKey->l4.tpSrc;
 952             udpKey.udp_dst = ipv4FlowPutKey->l4.tpDst;
 953             if (!NlMsgPutTailUnspec(nlBuf, OVS_KEY_ATTR_UDP,
 954                                    (PCHAR)(&udpKey),
 955                                    sizeof(udpKey))) {
 956                 rc = STATUS_UNSUCCESSFUL;
 957                 goto done;
 958             }
 959             break;
 960         }
 961
 962         case IPPROTO_SCTP: {
 963             struct ovs_key_sctp sctpKey;
 964             sctpKey.sctp_src = ipv4FlowPutKey->l4.tpSrc;
 965             sctpKey.sctp_dst = ipv4FlowPutKey->l4.tpDst;
 966             if (!NlMsgPutTailUnspec(nlBuf, OVS_KEY_ATTR_SCTP,
 967                                    (PCHAR)(&sctpKey),
 968                                    sizeof(sctpKey))) {
 969                 rc = STATUS_UNSUCCESSFUL;
 970                 goto done;
 971             }
 972             break;
 973         }
 974
 975         case IPPROTO_ICMP: {
 976             struct ovs_key_icmp icmpKey;
 977             /* XXX: revisit to see if htons is needed */
 978             icmpKey.icmp_type = (__u8)(ipv4FlowPutKey->l4.tpSrc);
 979             icmpKey.icmp_code = (__u8)(ipv4FlowPutKey->l4.tpDst);
 980
 981             if (!NlMsgPutTailUnspec(nlBuf, OVS_KEY_ATTR_ICMP,
 982                                    (PCHAR)(&icmpKey),
 983                                    sizeof(icmpKey))) {
 984                 rc = STATUS_UNSUCCESSFUL;
 985                 goto done;
 986             }
 987             break;
 988         }
 989
 990         default:
 991             break;
 992     }
 993
 994 done:
 995     return rc;
 996 }
 997
 998 /*
 999  *----------------------------------------------------------------------------
1000  *  _MapFlowIpv6KeyToNlKey --
1001  *    Maps _MapFlowIpv6KeyToNlKey to OVS_KEY_ATTR_IPV6 attribute.
1002  *----------------------------------------------------------------------------
1003  */
1004 static NTSTATUS
1005 _MapFlowIpv6KeyToNlKey(PNL_BUFFER nlBuf, Ipv6Key *ipv6FlowPutKey,
1006                        Icmp6Key *icmpv6FlowPutKey)
1007 {
1008     NTSTATUS rc = STATUS_SUCCESS;
1009     struct ovs_key_ipv6 ipv6Key;
1010
1011     RtlCopyMemory(&(ipv6Key.ipv6_src), &ipv6FlowPutKey->ipv6Src,
1012                   sizeof ipv6Key.ipv6_src);
1013     RtlCopyMemory(&(ipv6Key.ipv6_dst), &ipv6FlowPutKey->ipv6Dst,
1014                   sizeof ipv6Key.ipv6_dst);
1015
1016     ipv6Key.ipv6_label = ipv6FlowPutKey->ipv6Label;
1017     ipv6Key.ipv6_proto = ipv6FlowPutKey->nwProto;
1018     ipv6Key.ipv6_tclass = ipv6FlowPutKey->nwTos;
1019     ipv6Key.ipv6_hlimit = ipv6FlowPutKey->nwTtl;
1020     ipv6Key.ipv6_frag = ipv6FlowPutKey->nwFrag;
1021
1022     if (!NlMsgPutTailUnspec(nlBuf, OVS_KEY_ATTR_IPV6,
1023                            (PCHAR)(&ipv6Key),
1024                            sizeof(ipv6Key))) {
1025         rc = STATUS_UNSUCCESSFUL;
1026         goto done;
1027     }
1028
1029     switch (ipv6Key.ipv6_proto) {
1030         case IPPROTO_TCP: {
1031             struct ovs_key_tcp tcpKey;
1032             tcpKey.tcp_src = ipv6FlowPutKey->l4.tpSrc;
1033             tcpKey.tcp_dst = ipv6FlowPutKey->l4.tpDst;
1034             if (!NlMsgPutTailUnspec(nlBuf, OVS_KEY_ATTR_TCP,
1035                                    (PCHAR)(&tcpKey),
1036                                    sizeof(tcpKey))) {
1037                 rc = STATUS_UNSUCCESSFUL;
1038                 goto done;
1039             }
1040             break;
1041         }
1042
1043         case IPPROTO_UDP: {
1044             struct ovs_key_udp udpKey;
1045             udpKey.udp_src = ipv6FlowPutKey->l4.tpSrc;
1046             udpKey.udp_dst = ipv6FlowPutKey->l4.tpDst;
1047             if (!NlMsgPutTailUnspec(nlBuf, OVS_KEY_ATTR_UDP,
1048                                    (PCHAR)(&udpKey),
1049                                    sizeof(udpKey))) {
1050                 rc = STATUS_UNSUCCESSFUL;
1051                 goto done;
1052             }
1053             break;
1054         }
1055
1056         case IPPROTO_SCTP: {
1057             struct ovs_key_sctp sctpKey;
1058             sctpKey.sctp_src = ipv6FlowPutKey->l4.tpSrc;
1059             sctpKey.sctp_dst = ipv6FlowPutKey->l4.tpDst;
1060             if (!NlMsgPutTailUnspec(nlBuf, OVS_KEY_ATTR_SCTP,
1061                                    (PCHAR)(&sctpKey),
1062                                    sizeof(sctpKey))) {
1063                 rc = STATUS_UNSUCCESSFUL;
1064                 goto done;
1065             }
1066             break;
1067         }
1068
1069         case IPPROTO_ICMPV6: {
1070             struct ovs_key_icmpv6 icmpV6Key;
1071             struct ovs_key_nd ndKey;
1072
1073             /* XXX: revisit to see if htons is needed */
1074             icmpV6Key.icmpv6_type = (__u8)(icmpv6FlowPutKey->l4.tpSrc);
1075             icmpV6Key.icmpv6_code = (__u8)(icmpv6FlowPutKey->l4.tpDst);
1076
1077             if (!NlMsgPutTailUnspec(nlBuf, OVS_KEY_ATTR_ICMPV6,
1078                                    (PCHAR)(&icmpV6Key),
1079                                    sizeof(icmpV6Key))) {
1080                 rc = STATUS_UNSUCCESSFUL;
1081                 goto done;
1082             }
1083
1084             RtlCopyMemory(&(ndKey.nd_target), &icmpv6FlowPutKey->ndTarget,
1085                           sizeof(icmpv6FlowPutKey->ndTarget));
1086             RtlCopyMemory(&(ndKey.nd_sll), &icmpv6FlowPutKey->arpSha,
1087                           ETH_ADDR_LEN);
1088             RtlCopyMemory(&(ndKey.nd_tll), &icmpv6FlowPutKey->arpTha,
1089                           ETH_ADDR_LEN);
1090             if (!NlMsgPutTailUnspec(nlBuf, OVS_KEY_ATTR_ND,
1091                                    (PCHAR)(&ndKey),
1092                                    sizeof(ndKey))) {
1093                 rc = STATUS_UNSUCCESSFUL;
1094                 goto done;
1095             }
1096
1097             break;
1098         }
1099
1100         default:
1101             break;
1102     }
1103
1104 done:
1105     return rc;
1106 }
1107
1108 /*
1109  *----------------------------------------------------------------------------
1110  *  _MapFlowArpKeyToNlKey --
1111  *    Maps _MapFlowArpKeyToNlKey to OVS_KEY_ATTR_ARP attribute.
1112  *----------------------------------------------------------------------------
1113  */
1114 static NTSTATUS
1115 _MapFlowArpKeyToNlKey(PNL_BUFFER nlBuf, ArpKey *arpFlowPutKey)
1116 {
1117     NTSTATUS rc = STATUS_SUCCESS;
1118     struct ovs_key_arp arpKey;
1119
1120     arpKey.arp_sip = arpFlowPutKey->nwSrc;
1121     arpKey.arp_tip = arpFlowPutKey->nwDst;
1122
1123     RtlCopyMemory(&(arpKey.arp_sha), arpFlowPutKey->arpSha, ETH_ADDR_LEN);
1124     RtlCopyMemory(&(arpKey.arp_tha), arpFlowPutKey->arpTha, ETH_ADDR_LEN);
1125
1126     /*
1127      * Flow_Extract() stores 'nwProto' in host order for ARP since 'nwProto' is
1128      * 1 byte field and the ARP opcode is 2 bytes, and all of the kernel code
1129      * understand this while looking at an ARP key.
1130      * While we pass up the ARP key to userspace, convert from host order to
1131      * network order. Likewise, when processing an ARP key from userspace,
1132      * convert from network order to host order.
1133      *
1134      * It is important to note that the flow table stores the ARP opcode field
1135      * in host order.
1136      */
1137     arpKey.arp_op = htons(arpFlowPutKey->nwProto);
1138
1139     if (!NlMsgPutTailUnspec(nlBuf, OVS_KEY_ATTR_ARP,
1140                            (PCHAR)(&arpKey),
1141                            sizeof(arpKey))) {
1142         rc = STATUS_UNSUCCESSFUL;
1143         goto done;
1144     }
1145
1146 done:
1147     return rc;
1148 }
1149
1150 /*
1151  *----------------------------------------------------------------------------
1152  *  _MapNlToFlowPut --
1153  *    Maps input netlink message to OvsFlowPut.
1154  *----------------------------------------------------------------------------
1155  */
1156 static NTSTATUS
1157 _MapNlToFlowPut(POVS_MESSAGE msgIn, PNL_ATTR keyAttr,
1158                 PNL_ATTR actionAttr, PNL_ATTR flowAttrClear,
1159                 OvsFlowPut *mappedFlow)
1160 {
1161     NTSTATUS rc = STATUS_SUCCESS;
1162     PNL_MSG_HDR nlMsgHdr = &(msgIn->nlMsg);
1163     PGENL_MSG_HDR genlMsgHdr = &(msgIn->genlMsg);
1164     POVS_HDR ovsHdr = &(msgIn->ovsHdr);
1165
1166     UINT32 keyAttrOffset = (UINT32)((PCHAR)keyAttr - (PCHAR)nlMsgHdr);
1167     UINT32 tunnelKeyAttrOffset;
1168
1169     PNL_ATTR keyAttrs[__OVS_KEY_ATTR_MAX] = {NULL};
1170     PNL_ATTR tunnelAttrs[__OVS_TUNNEL_KEY_ATTR_MAX] = {NULL};
1171
1172     /* Get flow keys attributes */
1173     if ((NlAttrParseNested(nlMsgHdr, keyAttrOffset, NlAttrLen(keyAttr),
1174                            nlFlowKeyPolicy, keyAttrs, ARRAY_SIZE(keyAttrs)))
1175                            != TRUE) {
1176         OVS_LOG_ERROR("Key Attr Parsing failed for msg: %p",
1177                        nlMsgHdr);
1178         rc = STATUS_INVALID_PARAMETER;
1179         goto done;
1180     }
1181
1182     if (keyAttrs[OVS_KEY_ATTR_TUNNEL]) {
1183         tunnelKeyAttrOffset = (UINT32)((PCHAR)
1184                               (keyAttrs[OVS_KEY_ATTR_TUNNEL])
1185                               - (PCHAR)nlMsgHdr);
1186
1187         /* Get tunnel keys attributes */
1188         if ((NlAttrParseNested(nlMsgHdr, tunnelKeyAttrOffset,
1189                                NlAttrLen(keyAttrs[OVS_KEY_ATTR_TUNNEL]),
1190                                nlFlowTunnelKeyPolicy,
1191                                tunnelAttrs, ARRAY_SIZE(tunnelAttrs)))
1192                                != TRUE) {
1193             OVS_LOG_ERROR("Tunnel key Attr Parsing failed for msg: %p",
1194                            nlMsgHdr);
1195             rc = STATUS_INVALID_PARAMETER;
1196             goto done;
1197         }
1198     }
1199
1200     _MapKeyAttrToFlowPut(keyAttrs, tunnelAttrs,
1201                          &(mappedFlow->key));
1202
1203     /* Map the action */
1204     if (actionAttr) {
1205         mappedFlow->actionsLen = NlAttrGetSize(actionAttr);
1206         mappedFlow->actions = NlAttrGet(actionAttr);
1207     }
1208
1209     mappedFlow->dpNo = ovsHdr->dp_ifindex;
1210
1211     _MapNlToFlowPutFlags(genlMsgHdr, flowAttrClear,
1212                                 mappedFlow);
1213
1214 done:
1215     return rc;
1216 }
1217
1218 /*
1219  *----------------------------------------------------------------------------
1220  *  _MapNlToFlowPutFlags --
1221  *    Maps netlink message to OvsFlowPut->flags.
1222  *----------------------------------------------------------------------------
1223  */
1224 static VOID
1225 _MapNlToFlowPutFlags(PGENL_MSG_HDR genlMsgHdr,
1226                      PNL_ATTR flowAttrClear, OvsFlowPut *mappedFlow)
1227 {
1228     uint32_t flags = 0;
1229
1230     switch (genlMsgHdr->cmd) {
1231     case OVS_FLOW_CMD_NEW:
1232          flags |= OVSWIN_FLOW_PUT_CREATE;
1233          break;
1234     case OVS_FLOW_CMD_DEL:
1235          flags |= OVSWIN_FLOW_PUT_DELETE;
1236          break;
1237     case OVS_FLOW_CMD_SET:
1238          flags |= OVSWIN_FLOW_PUT_MODIFY;
1239          break;
1240     default:
1241          ASSERT(0);
1242     }
1243
1244     if (flowAttrClear) {
1245         flags |= OVSWIN_FLOW_PUT_CLEAR;
1246     }
1247
1248     mappedFlow->flags = flags;
1249 }
1250
1251 /*
1252  *----------------------------------------------------------------------------
1253  *  _MapKeyAttrToFlowPut --
1254  *    Converts FLOW_KEY attribute to OvsFlowPut->key.
1255  *----------------------------------------------------------------------------
1256  */
1257 static VOID
1258 _MapKeyAttrToFlowPut(PNL_ATTR *keyAttrs,
1259                      PNL_ATTR *tunnelAttrs,
1260                      OvsFlowKey *destKey)
1261 {
1262     _MapTunAttrToFlowPut(keyAttrs, tunnelAttrs, destKey);
1263
1264     /* ===== L2 headers ===== */
1265     destKey->l2.inPort = NlAttrGetU32(keyAttrs[OVS_KEY_ATTR_IN_PORT]);
1266
1267     if (keyAttrs[OVS_KEY_ATTR_ETHERNET]) {
1268         const struct ovs_key_ethernet *eth_key;
1269         eth_key = NlAttrGet(keyAttrs[OVS_KEY_ATTR_ETHERNET]);
1270         RtlCopyMemory(destKey->l2.dlSrc, eth_key->eth_src, ETH_ADDR_LEN);
1271         RtlCopyMemory(destKey->l2.dlDst, eth_key->eth_dst, ETH_ADDR_LEN);
1272     }
1273
1274     /* TODO: Ideally ETHERTYPE should not be optional.
1275      * But during vswitchd bootup we are seeing FLOW_ADD
1276      * requests with no ETHERTYPE attributes.
1277      * Need to verify this. */
1278     if (keyAttrs[OVS_KEY_ATTR_ETHERTYPE]) {
1279         destKey->l2.dlType = (NlAttrGetU16(keyAttrs
1280                                         [OVS_KEY_ATTR_ETHERTYPE]));
1281     }
1282
1283     if (keyAttrs[OVS_KEY_ATTR_VLAN]) {
1284         destKey->l2.vlanTci = NlAttrGetU16(keyAttrs[OVS_KEY_ATTR_VLAN]);
1285     }
1286
1287     /* ==== L3 + L4. ==== */
1288     destKey->l2.keyLen = OVS_WIN_TUNNEL_KEY_SIZE + OVS_L2_KEY_SIZE
1289                          - destKey->l2.offset;
1290
1291     switch (ntohs(destKey->l2.dlType)) {
1292     case ETH_TYPE_IPV4: {
1293
1294         if (keyAttrs[OVS_KEY_ATTR_IPV4]) {
1295             const struct ovs_key_ipv4 *ipv4Key;
1296
1297             ipv4Key = NlAttrGet(keyAttrs[OVS_KEY_ATTR_IPV4]);
1298             IpKey *ipv4FlowPutKey = &(destKey->ipKey);
1299             ipv4FlowPutKey->nwSrc = ipv4Key->ipv4_src;
1300             ipv4FlowPutKey->nwDst = ipv4Key->ipv4_dst;
1301             ipv4FlowPutKey->nwProto = ipv4Key->ipv4_proto;
1302             ipv4FlowPutKey->nwTos = ipv4Key->ipv4_tos;
1303             ipv4FlowPutKey->nwTtl = ipv4Key->ipv4_ttl;
1304             ipv4FlowPutKey->nwFrag = ipv4Key->ipv4_frag;
1305
1306             if (keyAttrs[OVS_KEY_ATTR_TCP]) {
1307                 const struct ovs_key_tcp *tcpKey;
1308                 tcpKey = NlAttrGet(keyAttrs[OVS_KEY_ATTR_TCP]);
1309                 ipv4FlowPutKey->l4.tpSrc = tcpKey->tcp_src;
1310                 ipv4FlowPutKey->l4.tpDst = tcpKey->tcp_dst;
1311             }
1312
1313             if (keyAttrs[OVS_KEY_ATTR_UDP]) {
1314                 const struct ovs_key_udp *udpKey;
1315                 udpKey = NlAttrGet(keyAttrs[OVS_KEY_ATTR_UDP]);
1316                 ipv4FlowPutKey->l4.tpSrc = udpKey->udp_src;
1317                 ipv4FlowPutKey->l4.tpDst = udpKey->udp_dst;
1318             }
1319
1320             if (keyAttrs[OVS_KEY_ATTR_SCTP]) {
1321                 const struct ovs_key_sctp *sctpKey;
1322                 sctpKey = NlAttrGet(keyAttrs[OVS_KEY_ATTR_SCTP]);
1323                 ipv4FlowPutKey->l4.tpSrc = sctpKey->sctp_src;
1324                 ipv4FlowPutKey->l4.tpDst = sctpKey->sctp_dst;
1325             }
1326
1327             destKey->l2.keyLen += OVS_IP_KEY_SIZE;
1328         }
1329         break;
1330     }
1331     case ETH_TYPE_IPV6: {
1332
1333         if (keyAttrs[OVS_KEY_ATTR_IPV6]) {
1334             const struct ovs_key_ipv6 *ipv6Key;
1335
1336             ipv6Key = NlAttrGet(keyAttrs[OVS_KEY_ATTR_IPV6]);
1337             Ipv6Key *ipv6FlowPutKey = &(destKey->ipv6Key);
1338
1339             RtlCopyMemory(&ipv6FlowPutKey->ipv6Src, ipv6Key->ipv6_src,
1340                           sizeof ipv6Key->ipv6_src);
1341             RtlCopyMemory(&ipv6FlowPutKey->ipv6Dst, ipv6Key->ipv6_dst,
1342                           sizeof ipv6Key->ipv6_dst);
1343
1344             ipv6FlowPutKey->ipv6Label = ipv6Key->ipv6_label;
1345             ipv6FlowPutKey->nwProto  = ipv6Key->ipv6_proto;
1346             ipv6FlowPutKey->nwTos = ipv6Key->ipv6_tclass;
1347             ipv6FlowPutKey->nwTtl = ipv6Key->ipv6_hlimit;
1348             ipv6FlowPutKey->nwFrag = ipv6Key->ipv6_frag;
1349
1350             if (keyAttrs[OVS_KEY_ATTR_TCP]) {
1351                 const struct ovs_key_tcp *tcpKey;
1352                 tcpKey = NlAttrGet(keyAttrs[OVS_KEY_ATTR_TCP]);
1353                 ipv6FlowPutKey->l4.tpSrc = tcpKey->tcp_src;
1354                 ipv6FlowPutKey->l4.tpDst = tcpKey->tcp_dst;
1355             }
1356
1357             if (keyAttrs[OVS_KEY_ATTR_UDP]) {
1358                 const struct ovs_key_udp *udpKey;
1359                 udpKey = NlAttrGet(keyAttrs[OVS_KEY_ATTR_UDP]);
1360                 ipv6FlowPutKey->l4.tpSrc = udpKey->udp_src;
1361                 ipv6FlowPutKey->l4.tpDst = udpKey->udp_dst;
1362             }
1363
1364             if (keyAttrs[OVS_KEY_ATTR_SCTP]) {
1365                 const struct ovs_key_sctp *sctpKey;
1366                 sctpKey = NlAttrGet(keyAttrs[OVS_KEY_ATTR_SCTP]);
1367                 ipv6FlowPutKey->l4.tpSrc = sctpKey->sctp_src;
1368                 ipv6FlowPutKey->l4.tpDst = sctpKey->sctp_dst;
1369             }
1370
1371             if (keyAttrs[OVS_KEY_ATTR_ICMPV6]) {
1372                 const struct ovs_key_icmpv6 *icmpv6Key;
1373
1374                 Icmp6Key *icmp6FlowPutKey= &(destKey->icmp6Key);
1375
1376                 icmpv6Key = NlAttrGet(keyAttrs[OVS_KEY_ATTR_ICMPV6]);
1377
1378                 icmp6FlowPutKey->l4.tpSrc = icmpv6Key->icmpv6_type;
1379                 icmp6FlowPutKey->l4.tpDst = icmpv6Key->icmpv6_code;
1380
1381                 if (keyAttrs[OVS_KEY_ATTR_ND]) {
1382                     const struct ovs_key_nd *ndKey;
1383
1384                     ndKey = NlAttrGet(keyAttrs[OVS_KEY_ATTR_ND]);
1385                     RtlCopyMemory(&icmp6FlowPutKey->ndTarget,
1386                                   ndKey->nd_target, sizeof (icmp6FlowPutKey->ndTarget));
1387                     RtlCopyMemory(icmp6FlowPutKey->arpSha,
1388                                   ndKey->nd_sll, ETH_ADDR_LEN);
1389                     RtlCopyMemory(icmp6FlowPutKey->arpTha,
1390                                   ndKey->nd_tll, ETH_ADDR_LEN);
1391                 }
1392
1393                 destKey->l2.keyLen += OVS_ICMPV6_KEY_SIZE;
1394
1395             } else {
1396
1397                 destKey->l2.keyLen += OVS_IPV6_KEY_SIZE;
1398             }
1399
1400             ipv6FlowPutKey->pad = 0;
1401         }
1402         break;
1403     }
1404     case ETH_TYPE_ARP:
1405     case ETH_TYPE_RARP: {
1406
1407         if (keyAttrs[OVS_KEY_ATTR_ARP]) {
1408             ArpKey *arpFlowPutKey = &destKey->arpKey;
1409             const struct ovs_key_arp *arpKey;
1410
1411             arpKey = NlAttrGet(keyAttrs[OVS_KEY_ATTR_ARP]);
1412
1413             arpFlowPutKey->nwSrc = arpKey->arp_sip;
1414             arpFlowPutKey->nwDst = arpKey->arp_tip;
1415
1416             RtlCopyMemory(arpFlowPutKey->arpSha, arpKey->arp_sha, ETH_ADDR_LEN);
1417             RtlCopyMemory(arpFlowPutKey->arpTha, arpKey->arp_tha, ETH_ADDR_LEN);
1418             /* Kernel datapath assumes 'arpFlowPutKey->nwProto' to be in host
1419              * order. */
1420             arpFlowPutKey->nwProto = (UINT8)ntohs((arpKey->arp_op));
1421             arpFlowPutKey->pad[0] = 0;
1422             arpFlowPutKey->pad[1] = 0;
1423             arpFlowPutKey->pad[2] = 0;
1424             destKey->l2.keyLen += OVS_ARP_KEY_SIZE;
1425             break;
1426         }
1427     }
1428     }
1429 }
1430
1431 /*
1432  *----------------------------------------------------------------------------
1433  *  _MapTunAttrToFlowPut --
1434  *    Converts FLOW_TUNNEL_KEY attribute to OvsFlowKey->tunKey.
1435  *----------------------------------------------------------------------------
1436  */
1437 static VOID
1438 _MapTunAttrToFlowPut(PNL_ATTR *keyAttrs,
1439                      PNL_ATTR *tunAttrs,
1440                      OvsFlowKey *destKey)
1441 {
1442     if (keyAttrs[OVS_KEY_ATTR_TUNNEL]) {
1443
1444         if (tunAttrs[OVS_TUNNEL_KEY_ATTR_ID]) {
1445             destKey->tunKey.tunnelId = NlAttrGetU64
1446                                        (tunAttrs[OVS_TUNNEL_KEY_ATTR_ID]);
1447             destKey->tunKey.flags |= OVS_TNL_F_KEY;
1448         }
1449
1450         if (tunAttrs[OVS_TUNNEL_KEY_ATTR_IPV4_DST]) {
1451         destKey->tunKey.dst = NlAttrGetU32
1452                               (tunAttrs[OVS_TUNNEL_KEY_ATTR_IPV4_DST]);
1453         }
1454
1455         if (tunAttrs[OVS_TUNNEL_KEY_ATTR_IPV4_SRC]) {
1456         destKey->tunKey.src = NlAttrGetU32
1457                               (tunAttrs[OVS_TUNNEL_KEY_ATTR_IPV4_SRC]);
1458         }
1459
1460         if (tunAttrs[OVS_TUNNEL_KEY_ATTR_DONT_FRAGMENT]) {
1461             destKey->tunKey.flags |= OVS_TNL_F_DONT_FRAGMENT;
1462         }
1463
1464         if (tunAttrs[OVS_TUNNEL_KEY_ATTR_CSUM]) {
1465             destKey->tunKey.flags |= OVS_TNL_F_CSUM;
1466         }
1467
1468         if (tunAttrs[OVS_TUNNEL_KEY_ATTR_TOS]) {
1469         destKey->tunKey.tos = NlAttrGetU8
1470                               (tunAttrs[OVS_TUNNEL_KEY_ATTR_TOS]);
1471         }
1472
1473         if (tunAttrs[OVS_TUNNEL_KEY_ATTR_TTL]) {
1474         destKey->tunKey.ttl = NlAttrGetU8
1475                               (tunAttrs[OVS_TUNNEL_KEY_ATTR_TTL]);
1476         }
1477
1478         destKey->tunKey.pad = 0;
1479         destKey->l2.offset = 0;
1480     } else {
1481         destKey->tunKey.attr[0] = 0;
1482         destKey->tunKey.attr[1] = 0;
1483         destKey->tunKey.attr[2] = 0;
1484         destKey->l2.offset = sizeof destKey->tunKey;
1485     }
1486 }
1487
1488 /*
1489  *----------------------------------------------------------------------------
1490  * OvsDeleteFlowTable --
1491  * Results:
1492  *    NDIS_STATUS_SUCCESS always.
1493  *----------------------------------------------------------------------------
1494  */
1495 NDIS_STATUS
1496 OvsDeleteFlowTable(OVS_DATAPATH *datapath)
1497 {
1498     if (datapath == NULL || datapath->flowTable == NULL) {
1499         return NDIS_STATUS_SUCCESS;
1500     }
1501
1502     DeleteAllFlows(datapath);
1503     OvsFreeMemory(datapath->flowTable);
1504     datapath->flowTable = NULL;
1505     NdisFreeRWLock(datapath->lock);
1506
1507     return NDIS_STATUS_SUCCESS;
1508 }
1509
1510 /*
1511  *----------------------------------------------------------------------------
1512  * OvsAllocateFlowTable --
1513  * Results:
1514  *    NDIS_STATUS_SUCCESS on success.
1515  *    NDIS_STATUS_RESOURCES if memory couldn't be allocated
1516  *----------------------------------------------------------------------------
1517  */
1518 NDIS_STATUS
1519 OvsAllocateFlowTable(OVS_DATAPATH *datapath,
1520                      POVS_SWITCH_CONTEXT switchContext)
1521 {
1522     PLIST_ENTRY bucket;
1523     int i;
1524
1525     datapath->flowTable = OvsAllocateMemory(OVS_FLOW_TABLE_SIZE *
1526                                             sizeof (LIST_ENTRY));
1527     if (!datapath->flowTable) {
1528         return NDIS_STATUS_RESOURCES;
1529     }
1530     for (i = 0; i < OVS_FLOW_TABLE_SIZE; i++) {
1531         bucket = &(datapath->flowTable[i]);
1532         InitializeListHead(bucket);
1533     }
1534     datapath->lock = NdisAllocateRWLock(switchContext->NdisFilterHandle);
1535
1536     return NDIS_STATUS_SUCCESS;
1537 }
1538
1539
1540 /*
1541  *----------------------------------------------------------------------------
1542  *  GetStartAddrNBL --
1543  *    Get the virtual address of the frame.
1544  *
1545  *  Results:
1546  *    Virtual address of the frame.
1547  *----------------------------------------------------------------------------
1548  */
1549 static __inline VOID *
1550 GetStartAddrNBL(const NET_BUFFER_LIST *_pNB)
1551 {
1552     PMDL curMdl;
1553     PUINT8 curBuffer;
1554     PEthHdr curHeader;
1555
1556     ASSERT(_pNB);
1557
1558     // Ethernet Header is a guaranteed safe access.
1559     curMdl = (NET_BUFFER_LIST_FIRST_NB(_pNB))->CurrentMdl;
1560     curBuffer =  MmGetSystemAddressForMdlSafe(curMdl, LowPagePriority);
1561     if (!curBuffer) {
1562         return NULL;
1563     }
1564
1565     curHeader = (PEthHdr)
1566     (curBuffer + (NET_BUFFER_LIST_FIRST_NB(_pNB))->CurrentMdlOffset);
1567
1568     return (VOID *) curHeader;
1569 }
1570
1571 VOID
1572 OvsFlowUsed(OvsFlow *flow,
1573             const NET_BUFFER_LIST *packet,
1574             const POVS_PACKET_HDR_INFO layers)
1575 {
1576     LARGE_INTEGER tickCount;
1577
1578     KeQueryTickCount(&tickCount);
1579     flow->used = tickCount.QuadPart * ovsTimeIncrementPerTick;
1580     flow->packetCount++;
1581     flow->byteCount += OvsPacketLenNBL(packet);
1582     flow->tcpFlags |= OvsGetTcpFlags(packet, &flow->key, layers);
1583 }
1584
1585
1586 VOID
1587 DeleteAllFlows(OVS_DATAPATH *datapath)
1588 {
1589     INT i;
1590     PLIST_ENTRY bucket;
1591
1592     for (i = 0; i < OVS_FLOW_TABLE_SIZE; i++) {
1593         PLIST_ENTRY next;
1594         bucket = &(datapath->flowTable[i]);
1595         while (!IsListEmpty(bucket)) {
1596             OvsFlow *flow;
1597             next = bucket->Flink;
1598             flow = CONTAINING_RECORD(next, OvsFlow, ListEntry);
1599             RemoveFlow(datapath, &flow);
1600         }
1601     }
1602 }
1603
1604 /*
1605  *----------------------------------------------------------------------------
1606  * Initializes 'flow' members from 'packet', 'skb_priority', 'tun_id', and
1607  * 'ofp_in_port'.
1608  *
1609  * Initializes 'packet' header pointers as follows:
1610  *
1611  *    - packet->l2 to the start of the Ethernet header.
1612  *
1613  *    - packet->l3 to just past the Ethernet header, or just past the
1614  *      vlan_header if one is present, to the first byte of the payload of the
1615  *      Ethernet frame.
1616  *
1617  *    - packet->l4 to just past the IPv4 header, if one is present and has a
1618  *      correct length, and otherwise NULL.
1619  *
1620  *    - packet->l7 to just past the TCP or UDP or ICMP header, if one is
1621  *      present and has a correct length, and otherwise NULL.
1622  *
1623  * Returns NDIS_STATUS_SUCCESS normally.  Fails only if packet data cannot be accessed
1624  * (e.g. if Pkt_CopyBytesOut() returns an error).
1625  *----------------------------------------------------------------------------
1626  */
1627 NDIS_STATUS
1628 OvsExtractFlow(const NET_BUFFER_LIST *packet,
1629                UINT32 inPort,
1630                OvsFlowKey *flow,
1631                POVS_PACKET_HDR_INFO layers,
1632                OvsIPv4TunnelKey *tunKey)
1633 {
1634     struct Eth_Header *eth;
1635     UINT8 offset = 0;
1636     PVOID vlanTagValue;
1637
1638     layers->value = 0;
1639
1640     if (tunKey) {
1641         ASSERT(tunKey->dst != 0);
1642         RtlMoveMemory(&flow->tunKey, tunKey, sizeof flow->tunKey);
1643         flow->l2.offset = 0;
1644     } else {
1645         flow->tunKey.dst = 0;
1646         flow->l2.offset = OVS_WIN_TUNNEL_KEY_SIZE;
1647     }
1648
1649     flow->l2.inPort = inPort;
1650
1651     if ( OvsPacketLenNBL(packet) < ETH_HEADER_LEN_DIX) {
1652         flow->l2.keyLen = OVS_WIN_TUNNEL_KEY_SIZE + 8 - flow->l2.offset;
1653         return NDIS_STATUS_SUCCESS;
1654     }
1655
1656     /* Link layer. */
1657     eth = (Eth_Header *)GetStartAddrNBL((NET_BUFFER_LIST *)packet);
1658     memcpy(flow->l2.dlSrc, eth->src, ETH_ADDR_LENGTH);
1659     memcpy(flow->l2.dlDst, eth->dst, ETH_ADDR_LENGTH);
1660
1661     /*
1662      * vlan_tci.
1663      */
1664     vlanTagValue = NET_BUFFER_LIST_INFO(packet, Ieee8021QNetBufferListInfo);
1665     if (vlanTagValue) {
1666         PNDIS_NET_BUFFER_LIST_8021Q_INFO vlanTag =
1667             (PNDIS_NET_BUFFER_LIST_8021Q_INFO)(PVOID *)&vlanTagValue;
1668         flow->l2.vlanTci = htons(vlanTag->TagHeader.VlanId | OVSWIN_VLAN_CFI |
1669                                  (vlanTag->TagHeader.UserPriority << 13));
1670     } else {
1671         if (eth->dix.typeNBO == ETH_TYPE_802_1PQ_NBO) {
1672             Eth_802_1pq_Tag *tag= (Eth_802_1pq_Tag *)&eth->dix.typeNBO;
1673             flow->l2.vlanTci = ((UINT16)tag->priority << 13) |
1674                                OVSWIN_VLAN_CFI |
1675                                ((UINT16)tag->vidHi << 8)  | tag->vidLo;
1676             offset = sizeof (Eth_802_1pq_Tag);
1677         } else {
1678             flow->l2.vlanTci = 0;
1679         }
1680         /*
1681         * XXX
1682         * Please note after this point, src mac and dst mac should
1683         * not be accessed through eth
1684         */
1685         eth = (Eth_Header *)((UINT8 *)eth + offset);
1686     }
1687
1688     /*
1689      * dl_type.
1690      *
1691      * XXX assume that at least the first
1692      * 12 bytes of received packets are mapped.  This code has the stronger
1693      * assumption that at least the first 22 bytes of 'packet' is mapped (if my
1694      * arithmetic is right).
1695      */
1696     if (ETH_TYPENOT8023(eth->dix.typeNBO)) {
1697         flow->l2.dlType = eth->dix.typeNBO;
1698         layers->l3Offset = ETH_HEADER_LEN_DIX + offset;
1699     } else if (OvsPacketLenNBL(packet)  >= ETH_HEADER_LEN_802_3 &&
1700               eth->e802_3.llc.dsap == 0xaa &&
1701               eth->e802_3.llc.ssap == 0xaa &&
1702               eth->e802_3.llc.control == ETH_LLC_CONTROL_UFRAME &&
1703               eth->e802_3.snap.snapOrg[0] == 0x00 &&
1704               eth->e802_3.snap.snapOrg[1] == 0x00 &&
1705               eth->e802_3.snap.snapOrg[2] == 0x00) {
1706         flow->l2.dlType = eth->e802_3.snap.snapType.typeNBO;
1707         layers->l3Offset = ETH_HEADER_LEN_802_3 + offset;
1708     } else {
1709         flow->l2.dlType = htons(OVSWIN_DL_TYPE_NONE);
1710         layers->l3Offset = ETH_HEADER_LEN_DIX + offset;
1711     }
1712
1713     flow->l2.keyLen = OVS_WIN_TUNNEL_KEY_SIZE + OVS_L2_KEY_SIZE - flow->l2.offset;
1714     /* Network layer. */
1715     if (flow->l2.dlType == htons(ETH_TYPE_IPV4)) {
1716         struct IPHdr ip_storage;
1717         const struct IPHdr *nh;
1718         IpKey *ipKey = &flow->ipKey;
1719
1720         flow->l2.keyLen += OVS_IP_KEY_SIZE;
1721         layers->isIPv4 = 1;
1722         nh = OvsGetIp(packet, layers->l3Offset, &ip_storage);
1723         if (nh) {
1724             layers->l4Offset = layers->l3Offset + nh->ihl * 4;
1725
1726             ipKey->nwSrc = nh->saddr;
1727             ipKey->nwDst = nh->daddr;
1728             ipKey->nwProto = nh->protocol;
1729
1730             ipKey->nwTos = nh->tos;
1731             if (nh->frag_off & htons(IP_MF | IP_OFFSET)) {
1732                 ipKey->nwFrag = OVSWIN_NW_FRAG_ANY;
1733                 if (nh->frag_off & htons(IP_OFFSET)) {
1734                     ipKey->nwFrag |= OVSWIN_NW_FRAG_LATER;
1735                 }
1736             } else {
1737                 ipKey->nwFrag = 0;
1738             }
1739
1740             ipKey->nwTtl = nh->ttl;
1741             ipKey->l4.tpSrc = 0;
1742             ipKey->l4.tpDst = 0;
1743
1744             if (!(nh->frag_off & htons(IP_OFFSET))) {
1745                 if (ipKey->nwProto == SOCKET_IPPROTO_TCP) {
1746                     OvsParseTcp(packet, &ipKey->l4, layers);
1747                 } else if (ipKey->nwProto == SOCKET_IPPROTO_UDP) {
1748                     OvsParseUdp(packet, &ipKey->l4, layers);
1749                 } else if (ipKey->nwProto == SOCKET_IPPROTO_ICMP) {
1750                     ICMPHdr icmpStorage;
1751                     const ICMPHdr *icmp;
1752
1753                     icmp = OvsGetIcmp(packet, layers->l4Offset, &icmpStorage);
1754                     if (icmp) {
1755                         ipKey->l4.tpSrc = htons(icmp->type);
1756                         ipKey->l4.tpDst = htons(icmp->code);
1757                         layers->l7Offset = layers->l4Offset + sizeof *icmp;
1758                     }
1759                 }
1760             }
1761         } else {
1762             ((UINT64 *)ipKey)[0] = 0;
1763             ((UINT64 *)ipKey)[1] = 0;
1764         }
1765     } else if (flow->l2.dlType == htons(ETH_TYPE_IPV6)) {
1766         NDIS_STATUS status;
1767         flow->l2.keyLen += OVS_IPV6_KEY_SIZE;
1768         status = OvsParseIPv6(packet, flow, layers);
1769         if (status != NDIS_STATUS_SUCCESS) {
1770             memset(&flow->ipv6Key, 0, sizeof (Ipv6Key));
1771             return status;
1772         }
1773         layers->isIPv6 = 1;
1774         flow->ipv6Key.l4.tpSrc = 0;
1775         flow->ipv6Key.l4.tpDst = 0;
1776         flow->ipv6Key.pad = 0;
1777
1778         if (flow->ipv6Key.nwProto == SOCKET_IPPROTO_TCP) {
1779             OvsParseTcp(packet, &(flow->ipv6Key.l4), layers);
1780         } else if (flow->ipv6Key.nwProto == SOCKET_IPPROTO_UDP) {
1781             OvsParseUdp(packet, &(flow->ipv6Key.l4), layers);
1782         } else if (flow->ipv6Key.nwProto == SOCKET_IPPROTO_ICMPV6) {
1783             OvsParseIcmpV6(packet, flow, layers);
1784             flow->l2.keyLen += (OVS_ICMPV6_KEY_SIZE - OVS_IPV6_KEY_SIZE);
1785         }
1786     } else if (flow->l2.dlType == htons(ETH_TYPE_ARP)) {
1787         EtherArp arpStorage;
1788         const EtherArp *arp;
1789         ArpKey *arpKey = &flow->arpKey;
1790         ((UINT64 *)arpKey)[0] = 0;
1791         ((UINT64 *)arpKey)[1] = 0;
1792         ((UINT64 *)arpKey)[2] = 0;
1793         flow->l2.keyLen += OVS_ARP_KEY_SIZE;
1794         arp = OvsGetArp(packet, layers->l3Offset, &arpStorage);
1795         if (arp && arp->ea_hdr.ar_hrd == htons(1) &&
1796             arp->ea_hdr.ar_pro == htons(ETH_TYPE_IPV4) &&
1797             arp->ea_hdr.ar_hln == ETH_ADDR_LENGTH &&
1798             arp->ea_hdr.ar_pln == 4) {
1799             /* We only match on the lower 8 bits of the opcode. */
1800             if (ntohs(arp->ea_hdr.ar_op) <= 0xff) {
1801                 arpKey->nwProto = (UINT8)ntohs(arp->ea_hdr.ar_op);
1802             }
1803             if (arpKey->nwProto == ARPOP_REQUEST
1804                 || arpKey->nwProto == ARPOP_REPLY) {
1805                 memcpy(&arpKey->nwSrc, arp->arp_spa, 4);
1806                 memcpy(&arpKey->nwDst, arp->arp_tpa, 4);
1807                 memcpy(arpKey->arpSha, arp->arp_sha, ETH_ADDR_LENGTH);
1808                 memcpy(arpKey->arpTha, arp->arp_tha, ETH_ADDR_LENGTH);
1809             }
1810         }
1811     }
1812
1813     return NDIS_STATUS_SUCCESS;
1814 }
1815
1816 __inline BOOLEAN
1817 FlowEqual(UINT64 *src, UINT64 *dst, UINT32 size)
1818 {
1819     UINT32 i;
1820     ASSERT((size & 0x7) == 0);
1821     ASSERT(((UINT64)src & 0x7) == 0);
1822     ASSERT(((UINT64)dst & 0x7) == 0);
1823     for (i = 0; i < (size >> 3); i++) {
1824         if (src[i] != dst[i]) {
1825             return FALSE;
1826         }
1827     }
1828     return TRUE;
1829 }
1830
1831
1832 /*
1833  * ----------------------------------------------------------------------------
1834  * AddFlow --
1835  *    Add a flow to flow table.
1836  *
1837  * Results:
1838  *   NDIS_STATUS_SUCCESS if no same flow in the flow table.
1839  * ----------------------------------------------------------------------------
1840  */
1841 NTSTATUS
1842 AddFlow(OVS_DATAPATH *datapath, OvsFlow *flow)
1843 {
1844     PLIST_ENTRY head;
1845
1846     if (OvsLookupFlow(datapath, &flow->key, &flow->hash, TRUE) != NULL) {
1847         return STATUS_INVALID_HANDLE;
1848     }
1849
1850     head = &(datapath->flowTable[HASH_BUCKET(flow->hash)]);
1851     /*
1852      * We need fence here to make sure flow's nextPtr is updated before
1853      * head->nextPtr is updated.
1854      */
1855     KeMemoryBarrier();
1856
1857     //KeAcquireSpinLock(&FilterDeviceExtension->NblQueueLock, &oldIrql);
1858     InsertTailList(head, &flow->ListEntry);
1859     //KeReleaseSpinLock(&FilterDeviceExtension->NblQueueLock, oldIrql);
1860
1861     datapath->nFlows++;
1862
1863     return STATUS_SUCCESS;
1864 }
1865
1866
1867 /* ----------------------------------------------------------------------------
1868  * RemoveFlow --
1869  *   Remove a flow from flow table, and added to wait list
1870  * ----------------------------------------------------------------------------
1871  */
1872 VOID
1873 RemoveFlow(OVS_DATAPATH *datapath,
1874            OvsFlow **flow)
1875 {
1876     OvsFlow *f = *flow;
1877     *flow = NULL;
1878     UNREFERENCED_PARAMETER(datapath);
1879
1880     ASSERT(datapath->nFlows);
1881     datapath->nFlows--;
1882     // Remove the flow  from queue
1883     RemoveEntryList(&f->ListEntry);
1884     FreeFlow(f);
1885 }
1886
1887
1888 /*
1889  * ----------------------------------------------------------------------------
1890  * OvsLookupFlow --
1891  *
1892  *    Find flow from flow table based on flow key.
1893  *    Caller should either hold portset handle or should
1894  *    have a flowRef in datapath or Acquired datapath.
1895  *
1896  * Results:
1897  *    Flow pointer if lookup successful.
1898  *    NULL if not exists.
1899  * ----------------------------------------------------------------------------
1900  */
1901 OvsFlow *
1902 OvsLookupFlow(OVS_DATAPATH *datapath,
1903               const OvsFlowKey *key,
1904               UINT64 *hash,
1905               BOOLEAN hashValid)
1906 {
1907     PLIST_ENTRY link, head;
1908     UINT16 offset = key->l2.offset;
1909     UINT16 size = key->l2.keyLen;
1910     UINT8 *start;
1911
1912     ASSERT(key->tunKey.dst || offset == sizeof (OvsIPv4TunnelKey));
1913     ASSERT(!key->tunKey.dst || offset == 0);
1914
1915     start = (UINT8 *)key + offset;
1916
1917     if (!hashValid) {
1918         *hash = OvsJhashBytes(start, size, 0);
1919     }
1920
1921     head = &datapath->flowTable[HASH_BUCKET(*hash)];
1922     link  = head->Flink;
1923     while (link != head) {
1924         OvsFlow *flow = CONTAINING_RECORD(link, OvsFlow, ListEntry);
1925
1926         if (flow->hash == *hash &&
1927             flow->key.l2.val == key->l2.val &&
1928             FlowEqual((UINT64 *)((uint8 *)&flow->key + offset),
1929                          (UINT64 *)start, size)) {
1930             return flow;
1931         }
1932         link = link->Flink;
1933     }
1934     return NULL;
1935 }
1936
1937
1938 /*
1939  * ----------------------------------------------------------------------------
1940  * OvsHashFlow --
1941  *    Calculate the hash for the given flow key.
1942  * ----------------------------------------------------------------------------
1943  */
1944 UINT64
1945 OvsHashFlow(const OvsFlowKey *key)
1946 {
1947     UINT16 offset = key->l2.offset;
1948     UINT16 size = key->l2.keyLen;
1949     UINT8 *start;
1950
1951     ASSERT(key->tunKey.dst || offset == sizeof (OvsIPv4TunnelKey));
1952     ASSERT(!key->tunKey.dst || offset == 0);
1953     start = (UINT8 *)key + offset;
1954     return OvsJhashBytes(start, size, 0);
1955 }
1956
1957
1958 /*
1959  * ----------------------------------------------------------------------------
1960  * FreeFlow --
1961  *    Free a flow and its actions.
1962  * ----------------------------------------------------------------------------
1963  */
1964 VOID
1965 FreeFlow(OvsFlow *flow)
1966 {
1967     ASSERT(flow);
1968     OvsFreeMemory(flow);
1969 }
1970
1971 NTSTATUS
1972 OvsDoDumpFlows(OvsFlowDumpInput *dumpInput,
1973                OvsFlowDumpOutput *dumpOutput,
1974                UINT32 *replyLen)
1975 {
1976     UINT32 dpNo;
1977     OVS_DATAPATH *datapath = NULL;
1978     OvsFlow *flow;
1979     PLIST_ENTRY node, head;
1980     UINT32 column = 0;
1981     UINT32 rowIndex, columnIndex;
1982     LOCK_STATE_EX dpLockState;
1983     NTSTATUS status = STATUS_SUCCESS;
1984     BOOLEAN findNextNonEmpty = FALSE;
1985
1986     dpNo = dumpInput->dpNo;
1987     NdisAcquireSpinLock(gOvsCtrlLock);
1988     if (gOvsSwitchContext->dpNo != dpNo) {
1989         status = STATUS_INVALID_PARAMETER;
1990         goto unlock;
1991     }
1992
1993     rowIndex = dumpInput->position[0];
1994     if (rowIndex >= OVS_FLOW_TABLE_SIZE) {
1995         dumpOutput->n = 0;
1996         *replyLen = sizeof(*dumpOutput);
1997         goto unlock;
1998     }
1999
2000     columnIndex = dumpInput->position[1];
2001
2002     datapath = &gOvsSwitchContext->datapath;
2003     ASSERT(datapath);
2004     ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
2005     OvsAcquireDatapathRead(datapath, &dpLockState, TRUE);
2006
2007     head = &datapath->flowTable[rowIndex];
2008     node = head->Flink;
2009
2010     while (column < columnIndex) {
2011         if (node == head) {
2012             break;
2013         }
2014         node = node->Flink;
2015         column++;
2016     }
2017
2018     if (node == head) {
2019         findNextNonEmpty = TRUE;
2020         columnIndex = 0;
2021     }
2022
2023     if (findNextNonEmpty) {
2024         while (head == node) {
2025             if (++rowIndex >= OVS_FLOW_TABLE_SIZE) {
2026                 dumpOutput->n = 0;
2027                 goto dp_unlock;
2028             }
2029             head = &datapath->flowTable[rowIndex];
2030             node = head->Flink;
2031         }
2032     }
2033
2034     ASSERT(node != head);
2035     ASSERT(rowIndex < OVS_FLOW_TABLE_SIZE);
2036
2037     flow = CONTAINING_RECORD(node, OvsFlow, ListEntry);
2038     status = ReportFlowInfo(flow, dumpInput->getFlags, &dumpOutput->flow);
2039
2040     if (status == STATUS_BUFFER_TOO_SMALL) {
2041         dumpOutput->n = sizeof(OvsFlowDumpOutput) + flow->actionsLen;
2042         *replyLen = sizeof(*dumpOutput);
2043     } else {
2044         dumpOutput->n = 1; //one flow reported.
2045         *replyLen = sizeof(*dumpOutput) + dumpOutput->flow.actionsLen;
2046     }
2047
2048     dumpOutput->position[0] = rowIndex;
2049     dumpOutput->position[1] = ++columnIndex;
2050
2051 dp_unlock:
2052     OvsReleaseDatapath(datapath, &dpLockState);
2053
2054 unlock:
2055     NdisReleaseSpinLock(gOvsCtrlLock);
2056     return status;
2057 }
2058
2059 NTSTATUS
2060 OvsDumpFlowIoctl(PVOID inputBuffer,
2061                  UINT32 inputLength,
2062                  PVOID outputBuffer,
2063                  UINT32 outputLength,
2064                  UINT32 *replyLen)
2065 {
2066     OvsFlowDumpOutput *dumpOutput = (OvsFlowDumpOutput *)outputBuffer;
2067     OvsFlowDumpInput *dumpInput = (OvsFlowDumpInput *)inputBuffer;
2068
2069     if (inputBuffer == NULL || outputBuffer == NULL) {
2070         return STATUS_INVALID_PARAMETER;
2071     }
2072
2073     if ((inputLength != sizeof(OvsFlowDumpInput))
2074         || (outputLength != sizeof *dumpOutput + dumpInput->actionsLen)) {
2075         return STATUS_INFO_LENGTH_MISMATCH;
2076     }
2077
2078     return OvsDoDumpFlows(dumpInput, dumpOutput, replyLen);
2079 }
2080
2081 static NTSTATUS
2082 ReportFlowInfo(OvsFlow *flow,
2083                UINT32 getFlags,
2084                OvsFlowInfo *info)
2085 {
2086     NTSTATUS status = STATUS_SUCCESS;
2087
2088     if (getFlags & FLOW_GET_KEY) {
2089         // always copy the tunnel key part
2090         RtlCopyMemory(&info->key, &flow->key,
2091                             flow->key.l2.keyLen + flow->key.l2.offset);
2092     }
2093
2094     if (getFlags & FLOW_GET_STATS) {
2095         OvsFlowStats *stats = &info->stats;
2096         stats->packetCount = flow->packetCount;
2097         stats->byteCount = flow->byteCount;
2098         stats->used = (UINT32)flow->used;
2099         stats->tcpFlags = flow->tcpFlags;
2100     }
2101
2102     if (getFlags & FLOW_GET_ACTIONS) {
2103         if (flow->actionsLen == 0) {
2104             info->actionsLen = 0;
2105         } else {
2106             info->actions = flow->actions;
2107             info->actionsLen = flow->actionsLen;
2108         }
2109     }
2110
2111     return status;
2112 }
2113
2114 NTSTATUS
2115 OvsPutFlowIoctl(PVOID inputBuffer,
2116                 UINT32 inputLength,
2117                 struct OvsFlowStats *stats)
2118 {
2119     NTSTATUS status = STATUS_SUCCESS;
2120     OVS_DATAPATH *datapath = NULL;
2121     ULONG actionsLen;
2122     OvsFlowPut *put;
2123     UINT32 dpNo;
2124     LOCK_STATE_EX dpLockState;
2125
2126     if ((inputLength < sizeof(OvsFlowPut)) || (inputBuffer == NULL)) {
2127         return STATUS_INFO_LENGTH_MISMATCH;
2128     }
2129
2130     put = (OvsFlowPut *)inputBuffer;
2131     if (put->actionsLen > 0) {
2132         actionsLen = put->actionsLen;
2133     } else {
2134         actionsLen = 0;
2135     }
2136
2137     dpNo = put->dpNo;
2138     NdisAcquireSpinLock(gOvsCtrlLock);
2139     if (gOvsSwitchContext->dpNo != dpNo) {
2140         status = STATUS_INVALID_PARAMETER;
2141         goto unlock;
2142     }
2143
2144     datapath = &gOvsSwitchContext->datapath;
2145     ASSERT(datapath);
2146     ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
2147     OvsAcquireDatapathWrite(datapath, &dpLockState, TRUE);
2148     status = HandleFlowPut(put, datapath, stats);
2149     OvsReleaseDatapath(datapath, &dpLockState);
2150
2151 unlock:
2152     NdisReleaseSpinLock(gOvsCtrlLock);
2153     return status;
2154 }
2155
2156
2157 /* Handles flow add, modify as well as delete */
2158 static NTSTATUS
2159 HandleFlowPut(OvsFlowPut *put,
2160               OVS_DATAPATH *datapath,
2161               struct OvsFlowStats *stats)
2162 {
2163     BOOLEAN   mayCreate, mayModify, mayDelete;
2164     OvsFlow   *KernelFlow;
2165     UINT64    hash;
2166     NTSTATUS  status = STATUS_SUCCESS;
2167
2168     mayCreate = (put->flags & OVSWIN_FLOW_PUT_CREATE) != 0;
2169     mayModify = (put->flags & OVSWIN_FLOW_PUT_MODIFY) != 0;
2170     mayDelete = (put->flags & OVSWIN_FLOW_PUT_DELETE) != 0;
2171
2172     if ((mayCreate || mayModify) == mayDelete) {
2173         return STATUS_INVALID_PARAMETER;
2174     }
2175
2176     KernelFlow = OvsLookupFlow(datapath, &put->key, &hash, FALSE);
2177     if (!KernelFlow) {
2178         if (!mayCreate) {
2179             return STATUS_INVALID_PARAMETER;
2180         }
2181
2182         status = OvsPrepareFlow(&KernelFlow, put, hash);
2183         if (status != STATUS_SUCCESS) {
2184             FreeFlow(KernelFlow);
2185             return STATUS_UNSUCCESSFUL;
2186         }
2187
2188         status = AddFlow(datapath, KernelFlow);
2189         if (status != STATUS_SUCCESS) {
2190             FreeFlow(KernelFlow);
2191             return STATUS_UNSUCCESSFUL;
2192         }
2193
2194         /* Validate the flow addition */
2195         {
2196             UINT64 newHash;
2197             OvsFlow *flow = OvsLookupFlow(datapath, &put->key, &newHash,
2198                                                                     FALSE);
2199             ASSERT(flow);
2200             ASSERT(newHash == hash);
2201             if (!flow || newHash != hash) {
2202                 return STATUS_UNSUCCESSFUL;
2203             }
2204         }
2205     } else {
2206         stats->packetCount = KernelFlow->packetCount;
2207         stats->byteCount = KernelFlow->byteCount;
2208         stats->tcpFlags = KernelFlow->tcpFlags;
2209         stats->used = (UINT32)KernelFlow->used;
2210
2211         if (mayModify) {
2212             OvsFlow *newFlow;
2213             status = OvsPrepareFlow(&newFlow, put, hash);
2214             if (status != STATUS_SUCCESS) {
2215                 return STATUS_UNSUCCESSFUL;
2216             }
2217
2218             KernelFlow = OvsLookupFlow(datapath, &put->key, &hash, TRUE);
2219             if (KernelFlow)  {
2220                 if ((put->flags & OVSWIN_FLOW_PUT_CLEAR) == 0) {
2221                     newFlow->packetCount = KernelFlow->packetCount;
2222                     newFlow->byteCount = KernelFlow->byteCount;
2223                     newFlow->tcpFlags = KernelFlow->tcpFlags;
2224                 }
2225                 RemoveFlow(datapath, &KernelFlow);
2226             }  else  {
2227                 if ((put->flags & OVSWIN_FLOW_PUT_CLEAR) == 0)  {
2228                     newFlow->packetCount = stats->packetCount;
2229                     newFlow->byteCount = stats->byteCount;
2230                     newFlow->tcpFlags = stats->tcpFlags;
2231                 }
2232             }
2233             status = AddFlow(datapath, newFlow);
2234             ASSERT(status == STATUS_SUCCESS);
2235
2236             /* Validate the flow addition */
2237             {
2238                 UINT64 newHash;
2239                 OvsFlow *testflow = OvsLookupFlow(datapath, &put->key,
2240                                                             &newHash, FALSE);
2241                 ASSERT(testflow);
2242                 ASSERT(newHash == hash);
2243                 if (!testflow || newHash != hash) {
2244                     FreeFlow(newFlow);
2245                     return STATUS_UNSUCCESSFUL;
2246                 }
2247             }
2248         } else {
2249             if (mayDelete) {
2250                 if (KernelFlow) {
2251                     RemoveFlow(datapath, &KernelFlow);
2252                 }
2253             } else {
2254                 /* Return success if an identical flow already exists. */
2255                 /* XXX: should we return EEXIST in a netlink error? */
2256                 return STATUS_SUCCESS;
2257             }
2258         }
2259     }
2260     return STATUS_SUCCESS;
2261 }
2262
2263 static NTSTATUS
2264 OvsPrepareFlow(OvsFlow **flow,
2265                const OvsFlowPut *put,
2266                UINT64 hash)
2267 {
2268     OvsFlow     *localFlow = *flow;
2269     NTSTATUS status = STATUS_SUCCESS;
2270
2271     do {
2272         *flow = localFlow =
2273             OvsAllocateMemory(sizeof(OvsFlow) + put->actionsLen);
2274         if (localFlow == NULL) {
2275             status = STATUS_NO_MEMORY;
2276             break;
2277         }
2278
2279         localFlow->key = put->key;
2280         localFlow->actionsLen = put->actionsLen;
2281         if (put->actionsLen) {
2282             NdisMoveMemory((PUCHAR)localFlow->actions, put->actions,
2283                                        put->actionsLen);
2284         }
2285         localFlow->userActionsLen = 0;  // 0 indicate no conversion is made
2286         localFlow->used = 0;
2287         localFlow->packetCount = 0;
2288         localFlow->byteCount = 0;
2289         localFlow->tcpFlags = 0;
2290         localFlow->hash = hash;
2291     } while(FALSE);
2292
2293     return status;
2294 }
2295
2296 NTSTATUS
2297 OvsGetFlowIoctl(PVOID inputBuffer,
2298                 PVOID outputBuffer)
2299 {
2300     NTSTATUS status = STATUS_SUCCESS;
2301     OVS_DATAPATH *datapath = NULL;
2302     OvsFlow *flow;
2303     UINT32 getFlags, getActionsLen;
2304     OvsFlowGetInput *getInput;
2305     OvsFlowGetOutput *getOutput;
2306     UINT64 hash;
2307     UINT32 dpNo;
2308     LOCK_STATE_EX dpLockState;
2309
2310     getInput = (OvsFlowGetInput *) inputBuffer;
2311     getFlags = getInput->getFlags;
2312     getActionsLen = getInput->actionsLen;
2313
2314     if (outputBuffer == NULL) {
2315         return STATUS_INFO_LENGTH_MISMATCH;
2316     }
2317
2318     dpNo = getInput->dpNo;
2319     NdisAcquireSpinLock(gOvsCtrlLock);
2320     if (gOvsSwitchContext->dpNo != dpNo) {
2321         status = STATUS_INVALID_PARAMETER;
2322         goto unlock;
2323     }
2324
2325     datapath = &gOvsSwitchContext->datapath;
2326     ASSERT(datapath);
2327     ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
2328     OvsAcquireDatapathRead(datapath, &dpLockState, TRUE);
2329     flow = OvsLookupFlow(datapath, &getInput->key, &hash, FALSE);
2330     if (!flow) {
2331         status = STATUS_INVALID_PARAMETER;
2332         goto dp_unlock;
2333     }
2334
2335     getOutput = (OvsFlowGetOutput *)outputBuffer;
2336     ReportFlowInfo(flow, getFlags, &getOutput->info);
2337
2338 dp_unlock:
2339     OvsReleaseDatapath(datapath, &dpLockState);
2340 unlock:
2341     NdisReleaseSpinLock(gOvsCtrlLock);
2342     return status;
2343 }
2344
2345 NTSTATUS
2346 OvsFlushFlowIoctl(UINT32 dpNo)
2347 {
2348     NTSTATUS status = STATUS_SUCCESS;
2349     OVS_DATAPATH *datapath = NULL;
2350     LOCK_STATE_EX dpLockState;
2351
2352     NdisAcquireSpinLock(gOvsCtrlLock);
2353     if (gOvsSwitchContext->dpNo != dpNo) {
2354         status = STATUS_INVALID_PARAMETER;
2355         goto unlock;
2356     }
2357
2358     datapath = &gOvsSwitchContext->datapath;
2359     ASSERT(datapath);
2360     ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
2361     OvsAcquireDatapathWrite(datapath, &dpLockState, TRUE);
2362     DeleteAllFlows(datapath);
2363     OvsReleaseDatapath(datapath, &dpLockState);
2364
2365 unlock:
2366     NdisReleaseSpinLock(gOvsCtrlLock);
2367     return status;
2368 }
2369
2370 UINT32
2371 OvsFlowKeyAttrSize(void)
2372 {
2373     return NlAttrTotalSize(4)   /* OVS_KEY_ATTR_PRIORITY */
2374          + NlAttrTotalSize(0)   /* OVS_KEY_ATTR_TUNNEL */
2375          + OvsTunKeyAttrSize()
2376          + NlAttrTotalSize(4)   /* OVS_KEY_ATTR_IN_PORT */
2377          + NlAttrTotalSize(4)   /* OVS_KEY_ATTR_SKB_MARK */
2378          + NlAttrTotalSize(4)   /* OVS_KEY_ATTR_DP_HASH */
2379          + NlAttrTotalSize(4)   /* OVS_KEY_ATTR_RECIRC_ID */
2380          + NlAttrTotalSize(12)  /* OVS_KEY_ATTR_ETHERNET */
2381          + NlAttrTotalSize(2)   /* OVS_KEY_ATTR_ETHERTYPE */
2382          + NlAttrTotalSize(4)   /* OVS_KEY_ATTR_VLAN */
2383          + NlAttrTotalSize(0)   /* OVS_KEY_ATTR_ENCAP */
2384          + NlAttrTotalSize(2)   /* OVS_KEY_ATTR_ETHERTYPE */
2385          + NlAttrTotalSize(40)  /* OVS_KEY_ATTR_IPV6 */
2386          + NlAttrTotalSize(2)   /* OVS_KEY_ATTR_ICMPV6 */
2387          + NlAttrTotalSize(28); /* OVS_KEY_ATTR_ND */
2388 }
2389
2390 UINT32
2391 OvsTunKeyAttrSize(void)
2392 {
2393     /* Whenever adding new OVS_TUNNEL_KEY_ FIELDS, we should consider
2394      * updating this function.
2395      */
2396     return NlAttrTotalSize(8)    /* OVS_TUNNEL_KEY_ATTR_ID */
2397          + NlAttrTotalSize(4)    /* OVS_TUNNEL_KEY_ATTR_IPV4_SRC */
2398          + NlAttrTotalSize(4)    /* OVS_TUNNEL_KEY_ATTR_IPV4_DST */
2399          + NlAttrTotalSize(1)    /* OVS_TUNNEL_KEY_ATTR_TOS */
2400          + NlAttrTotalSize(1)    /* OVS_TUNNEL_KEY_ATTR_TTL */
2401          + NlAttrTotalSize(0)    /* OVS_TUNNEL_KEY_ATTR_DONT_FRAGMENT */
2402          + NlAttrTotalSize(0)    /* OVS_TUNNEL_KEY_ATTR_CSUM */
2403          + NlAttrTotalSize(0)    /* OVS_TUNNEL_KEY_ATTR_OAM */
2404          + NlAttrTotalSize(256)  /* OVS_TUNNEL_KEY_ATTR_GENEVE_OPTS */
2405          + NlAttrTotalSize(2)    /* OVS_TUNNEL_KEY_ATTR_TP_SRC */
2406          + NlAttrTotalSize(2);   /* OVS_TUNNEL_KEY_ATTR_TP_DST */
2407 }
2408
2409 #pragma warning( pop )