Convert tabs to spaces to fix indentation issues.

diff --git a/switch/datapath.c b/switch/datapath.c
index 521150b..b569b77 100644 (file)
--- a/switch/datapath.c
+++ b/switch/datapath.c
@@ -548,16 +548,16 @@ static void *
 alloc_openflow_buffer(struct datapath *dp, size_t openflow_len, uint8_t type,
                       const struct sender *sender, struct buffer **bufferp)
 {
-       struct buffer *buffer;
-       struct ofp_header *oh;
-
-       buffer = *bufferp = buffer_new(openflow_len);
-       oh = buffer_put_uninit(buffer, openflow_len);
-       oh->version = OFP_VERSION;
-       oh->type = type;
-       oh->length = 0;             /* Filled in by send_openflow_buffer(). */
-       oh->xid = sender ? sender->xid : 0;
-       return oh;
+    struct buffer *buffer;
+    struct ofp_header *oh;
+
+    buffer = *bufferp = buffer_new(openflow_len);
+    oh = buffer_put_uninit(buffer, openflow_len);
+    oh->version = OFP_VERSION;
+    oh->type = type;
+    oh->length = 0;             /* Filled in by send_openflow_buffer(). */
+    oh->xid = sender ? sender->xid : 0;
+    return oh;
 }
 
 static int
@@ -711,23 +711,23 @@ static void
 fill_flow_stats(struct ofp_flow_stats *ofs, struct sw_flow *flow,
                 int table_idx, time_t now)
 {
-       ofs->match.wildcards = htons(flow->key.wildcards);
-       ofs->match.in_port   = flow->key.flow.in_port;
-       memcpy(ofs->match.dl_src, flow->key.flow.dl_src, ETH_ADDR_LEN);
-       memcpy(ofs->match.dl_dst, flow->key.flow.dl_dst, ETH_ADDR_LEN);
-       ofs->match.dl_vlan   = flow->key.flow.dl_vlan;
-       ofs->match.dl_type   = flow->key.flow.dl_type;
-       ofs->match.nw_src    = flow->key.flow.nw_src;
-       ofs->match.nw_dst    = flow->key.flow.nw_dst;
-       ofs->match.nw_proto  = flow->key.flow.nw_proto;
-       memset(ofs->match.pad, 0, sizeof ofs->match.pad);
-       ofs->match.tp_src    = flow->key.flow.tp_src;
-       ofs->match.tp_dst    = flow->key.flow.tp_dst;
-       ofs->duration        = htonl(now - flow->created);
-       ofs->packet_count    = htonll(flow->packet_count);
-       ofs->byte_count      = htonll(flow->byte_count);
-       ofs->priority        = htons(flow->priority);
-       ofs->table_id        = table_idx;
+    ofs->match.wildcards = htons(flow->key.wildcards);
+    ofs->match.in_port   = flow->key.flow.in_port;
+    memcpy(ofs->match.dl_src, flow->key.flow.dl_src, ETH_ADDR_LEN);
+    memcpy(ofs->match.dl_dst, flow->key.flow.dl_dst, ETH_ADDR_LEN);
+    ofs->match.dl_vlan   = flow->key.flow.dl_vlan;
+    ofs->match.dl_type   = flow->key.flow.dl_type;
+    ofs->match.nw_src    = flow->key.flow.nw_src;
+    ofs->match.nw_dst    = flow->key.flow.nw_dst;
+    ofs->match.nw_proto  = flow->key.flow.nw_proto;
+    memset(ofs->match.pad, 0, sizeof ofs->match.pad);
+    ofs->match.tp_src    = flow->key.flow.tp_src;
+    ofs->match.tp_dst    = flow->key.flow.tp_dst;
+    ofs->duration        = htonl(now - flow->created);
+    ofs->packet_count    = htonll(flow->packet_count);
+    ofs->byte_count      = htonll(flow->byte_count);
+    ofs->priority        = htons(flow->priority);
+    ofs->table_id        = table_idx;
     memset(ofs->pad, 0, sizeof ofs->pad);
 }
 
@@ -967,9 +967,9 @@ recv_get_config_request(struct datapath *dp, const struct sender *sender,
                                 sender, &buffer);
 
     assert(sizeof *osc == sizeof dp->config);
-       memcpy(((char *)osc) + sizeof osc->header,
-              ((char *)&dp->config) + sizeof dp->config.header,
-              sizeof dp->config - sizeof dp->config.header);
+    memcpy(((char *)osc) + sizeof osc->header,
+           ((char *)&dp->config) + sizeof dp->config.header,
+           sizeof dp->config - sizeof dp->config.header);
 
     return send_openflow_buffer(dp, buffer, sender);
 }
@@ -1123,176 +1123,176 @@ recv_flow(struct datapath *dp, const struct sender *sender UNUSED,
 }
 
 struct flow_stats_state {
-       int table_idx;
-       struct sw_table_position position;
-       struct ofp_flow_stats_request rq;
+    int table_idx;
+    struct sw_table_position position;
+    struct ofp_flow_stats_request rq;
     time_t now;
 
     struct buffer *buffer;
-       int n_flows, max_flows;
+    int n_flows, max_flows;
 };
 
 static int flow_stats_init(struct datapath *dp, const void *body, int body_len,
                            void **state)
 {
-       const struct ofp_flow_stats_request *fsr = body;
-       struct flow_stats_state *s = xmalloc(sizeof *s);
-       s->table_idx = fsr->table_id == 0xff ? 0 : fsr->table_id;
-       memset(&s->position, 0, sizeof s->position);
-       s->rq = *fsr;
-       *state = s;
-       return 0;
+    const struct ofp_flow_stats_request *fsr = body;
+    struct flow_stats_state *s = xmalloc(sizeof *s);
+    s->table_idx = fsr->table_id == 0xff ? 0 : fsr->table_id;
+    memset(&s->position, 0, sizeof s->position);
+    s->rq = *fsr;
+    *state = s;
+    return 0;
 }
 
 static int flow_stats_dump_callback(struct sw_flow *flow, void *private)
 {
-       struct flow_stats_state *s = private;
+    struct flow_stats_state *s = private;
     struct ofp_flow_stats *ofs = buffer_put_uninit(s->buffer, sizeof *ofs);
-       fill_flow_stats(ofs, flow, s->table_idx, s->now);
-       return ++s->n_flows >= s->max_flows;
+    fill_flow_stats(ofs, flow, s->table_idx, s->now);
+    return ++s->n_flows >= s->max_flows;
 }
 
 static int flow_stats_dump(struct datapath *dp, void *state,
                            struct buffer *buffer)
 {
-       struct flow_stats_state *s = state;
-       struct ofp_flow_stats *ofs;
-       struct sw_flow_key match_key;
+    struct flow_stats_state *s = state;
+    struct ofp_flow_stats *ofs;
+    struct sw_flow_key match_key;
 
-       s->max_flows = 4096 / sizeof *ofs;
-       if (!s->max_flows)
-               return -ENOMEM;
+    s->max_flows = 4096 / sizeof *ofs;
+    if (!s->max_flows)
+        return -ENOMEM;
 
-       flow_extract_match(&match_key, &s->rq.match);
+    flow_extract_match(&match_key, &s->rq.match);
     s->buffer = buffer;
-       s->n_flows = 0;
+    s->n_flows = 0;
     s->now = time(0);
-       while (s->table_idx < dp->chain->n_tables
-              && (s->rq.table_id == 0xff || s->rq.table_id == s->table_idx))
-       {
-               struct sw_table *table = dp->chain->tables[s->table_idx];
+    while (s->table_idx < dp->chain->n_tables
+           && (s->rq.table_id == 0xff || s->rq.table_id == s->table_idx))
+    {
+        struct sw_table *table = dp->chain->tables[s->table_idx];
 
-               if (table->iterate(table, &match_key, &s->position,
+        if (table->iterate(table, &match_key, &s->position,
                            flow_stats_dump_callback, s))
-                       break;
+            break;
 
-               s->table_idx++;
-               memset(&s->position, 0, sizeof s->position);
-       }
-       return s->n_flows >= s->max_flows;
+        s->table_idx++;
+        memset(&s->position, 0, sizeof s->position);
+    }
+    return s->n_flows >= s->max_flows;
 }
 
 static void flow_stats_done(void *state)
 {
-       free(state);
+    free(state);
 }
 
 static int table_stats_dump(struct datapath *dp, void *state,
                             struct buffer *buffer)
 {
-       int i;
-       for (i = 0; i < dp->chain->n_tables; i++) {
+    int i;
+    for (i = 0; i < dp->chain->n_tables; i++) {
         struct ofp_table_stats *ots = buffer_put_uninit(buffer, sizeof *ots);
-               struct sw_table_stats stats;
-               dp->chain->tables[i]->stats(dp->chain->tables[i], &stats);
-               strncpy(ots->name, stats.name, sizeof ots->name);
-               ots->table_id = i;
-               memset(ots->pad, 0, sizeof ots->pad);
-               ots->max_entries = htonl(stats.max_flows);
-               ots->active_count = htonl(stats.n_flows);
-               ots->matched_count = htonll(0); /* FIXME */
-       }
-       return 0;
+        struct sw_table_stats stats;
+        dp->chain->tables[i]->stats(dp->chain->tables[i], &stats);
+        strncpy(ots->name, stats.name, sizeof ots->name);
+        ots->table_id = i;
+        memset(ots->pad, 0, sizeof ots->pad);
+        ots->max_entries = htonl(stats.max_flows);
+        ots->active_count = htonl(stats.n_flows);
+        ots->matched_count = htonll(0); /* FIXME */
+    }
+    return 0;
 }
 
 struct port_stats_state {
-       int port;
+    int port;
 };
 
 static int port_stats_init(struct datapath *dp, const void *body, int body_len,
-                          void **state)
+               void **state)
 {
-       struct port_stats_state *s = xmalloc(sizeof *s);
-       s->port = 0;
-       *state = s;
-       return 0;
+    struct port_stats_state *s = xmalloc(sizeof *s);
+    s->port = 0;
+    *state = s;
+    return 0;
 }
 
 static int port_stats_dump(struct datapath *dp, void *state,
                            struct buffer *buffer)
 {
-       struct port_stats_state *s = state;
-       int i;
+    struct port_stats_state *s = state;
+    int i;
 
-       for (i = s->port; i < OFPP_MAX; i++) {
-               struct sw_port *p = &dp->ports[i];
+    for (i = s->port; i < OFPP_MAX; i++) {
+        struct sw_port *p = &dp->ports[i];
         struct ofp_port_stats *ops;
-               if (!p->netdev) {
-                       continue;
+        if (!p->netdev) {
+            continue;
         }
         ops = buffer_put_uninit(buffer, sizeof *ops);
-               ops->port_no = htons(port_no(dp, p));
-               memset(ops->pad, 0, sizeof ops->pad);
-               ops->rx_count = htonll(p->rx_count);
-               ops->tx_count = htonll(p->tx_count);
-               ops->drop_count = htonll(p->drop_count);
-               ops++;
-       }
-       s->port = i;
-       return 0;
+        ops->port_no = htons(port_no(dp, p));
+        memset(ops->pad, 0, sizeof ops->pad);
+        ops->rx_count = htonll(p->rx_count);
+        ops->tx_count = htonll(p->tx_count);
+        ops->drop_count = htonll(p->drop_count);
+        ops++;
+    }
+    s->port = i;
+    return 0;
 }
 
 static void port_stats_done(void *state)
 {
-       free(state);
+    free(state);
 }
 
 struct stats_type {
-       /* Minimum and maximum acceptable number of bytes in body member of
-        * struct ofp_stats_request. */
-       size_t min_body, max_body;
-
-       /* Prepares to dump some kind of statistics on 'dp'.  'body' and
-        * 'body_len' are the 'body' member of the struct ofp_stats_request.
-        * Returns zero if successful, otherwise a negative error code.
-        * May initialize '*state' to state information.  May be null if no
-        * initialization is required.*/
-       int (*init)(struct datapath *dp, const void *body, int body_len,
-                   void **state);
-
-       /* Appends statistics for 'dp' to 'buffer', which initially contains a
+    /* Minimum and maximum acceptable number of bytes in body member of
+     * struct ofp_stats_request. */
+    size_t min_body, max_body;
+
+    /* Prepares to dump some kind of statistics on 'dp'.  'body' and
+     * 'body_len' are the 'body' member of the struct ofp_stats_request.
+     * Returns zero if successful, otherwise a negative error code.
+     * May initialize '*state' to state information.  May be null if no
+     * initialization is required.*/
+    int (*init)(struct datapath *dp, const void *body, int body_len,
+            void **state);
+
+    /* Appends statistics for 'dp' to 'buffer', which initially contains a
      * struct ofp_stats_reply.  On success, it should return 1 if it should be
      * called again later with another buffer, 0 if it is done, or a negative
      * errno value on failure. */
-       int (*dump)(struct datapath *dp, void *state, struct buffer *buffer);
+    int (*dump)(struct datapath *dp, void *state, struct buffer *buffer);
 
-       /* Cleans any state created by the init or dump functions.  May be null
-        * if no cleanup is required. */
-       void (*done)(void *state);
+    /* Cleans any state created by the init or dump functions.  May be null
+     * if no cleanup is required. */
+    void (*done)(void *state);
 };
 
 static const struct stats_type stats[] = {
-       [OFPST_FLOW] = {
-               sizeof(struct ofp_flow_stats_request),
-               sizeof(struct ofp_flow_stats_request),
-               flow_stats_init,
-               flow_stats_dump,
-               flow_stats_done
-       },
-       [OFPST_TABLE] = {
-               0,
-               0,
-               NULL,
-               table_stats_dump,
-               NULL
-       },
-       [OFPST_PORT] = {
-               0,
-               0,
-               port_stats_init,
-               port_stats_dump,
-               port_stats_done
-       },
+    [OFPST_FLOW] = {
+        sizeof(struct ofp_flow_stats_request),
+        sizeof(struct ofp_flow_stats_request),
+        flow_stats_init,
+        flow_stats_dump,
+        flow_stats_done
+    },
+    [OFPST_TABLE] = {
+        0,
+        0,
+        NULL,
+        table_stats_dump,
+        NULL
+    },
+    [OFPST_PORT] = {
+        0,
+        0,
+        port_stats_init,
+        port_stats_dump,
+        port_stats_done
+    },
 };
 
 struct stats_dump_cb {
@@ -1307,36 +1307,36 @@ static int
 stats_dump(struct datapath *dp, void *cb_)
 {
     struct stats_dump_cb *cb = cb_;
-       struct ofp_stats_reply *osr;
+    struct ofp_stats_reply *osr;
     struct buffer *buffer;
-       int err;
+    int err;
 
     if (cb->done) {
         return 0;
-       }
+    }
 
-       osr = alloc_openflow_buffer(dp, sizeof *osr, OFPT_STATS_REPLY, &cb->sender,
+    osr = alloc_openflow_buffer(dp, sizeof *osr, OFPT_STATS_REPLY, &cb->sender,
                                 &buffer);
-       osr->type = htons(cb->s - stats);
-       osr->flags = 0;
+    osr->type = htons(cb->s - stats);
+    osr->flags = 0;
 
-       err = cb->s->dump(dp, cb->state, buffer);
-       if (err >= 0) {
+    err = cb->s->dump(dp, cb->state, buffer);
+    if (err >= 0) {
         int err2;
-               if (!err) {
-                       cb->done = true;
+        if (!err) {
+            cb->done = true;
         } else {
             /* Buffer might have been reallocated, so find our data again. */
             osr = buffer_at_assert(buffer, 0, sizeof *osr);
-                       osr->flags = ntohs(OFPSF_REPLY_MORE);
+            osr->flags = ntohs(OFPSF_REPLY_MORE);
         }
         err2 = send_openflow_buffer(dp, buffer, &cb->sender);
         if (err2) {
             err = err2;
         }
-       }
+    }
 
-       return err;
+    return err;
 }
 
 static void
@@ -1344,11 +1344,11 @@ stats_done(void *cb_)
 {
     struct stats_dump_cb *cb = cb_;
     if (cb) {
-               if (cb->s->done) {
-                       cb->s->done(cb->state);
+        if (cb->s->done) {
+            cb->s->done(cb->state);
         }
         free(cb);
-       }
+    }
 }
 
 static int
@@ -1436,10 +1436,10 @@ fwd_control_input(struct datapath *dp, const struct sender *sender,
             sizeof (struct ofp_port_mod),
             recv_port_mod,
         },
-               [OFPT_STATS_REQUEST] = {
-                       sizeof (struct ofp_stats_request),
-                       recv_stats_request,
-               },
+        [OFPT_STATS_REQUEST] = {
+            sizeof (struct ofp_stats_request),
+            recv_stats_request,
+        },
     };
 
     const struct openflow_packet *pkt;

diff --git a/switch/table.h b/switch/table.h
index c86380a..5ce7f3b 100644 (file)
--- a/switch/table.h
+++ b/switch/table.h
@@ -55,7 +55,7 @@ struct sw_table_stats {
  * The contents are private to the table implementation, except that a position
  * initialized to all-zero-bits represents the start of a table. */
 struct sw_table_position {
-       unsigned long private[4];
+    unsigned long private[4];
 };
 
 /* A single table of flows.  */
@@ -89,23 +89,23 @@ struct sw_table {
     /* Destroys 'table', which must not have any users. */
     void (*destroy)(struct sw_table *table);
 
-       /* Iterates through the flow entries in 'table', passing each one
-        * matches 'key' to 'callback'.  The callback function should return 0
-        * to continue iteration or a nonzero error code to stop.  The iterator
-        * function returns either 0 if the table iteration completed or the
-        * value returned by the callback function otherwise.
-        *
-        * The iteration starts at 'position', which may be initialized to
-        * all-zero-bits to iterate from the beginning of the table.  If the
-        * iteration terminates due to an error from the callback function,
-        * 'position' is updated to a value that can be passed back to the
-        * iterator function to resume iteration later with the following
-        * flow. */
-       int (*iterate)(struct sw_table *table,
-                      const struct sw_flow_key *key,
-                      struct sw_table_position *position,
-                      int (*callback)(struct sw_flow *flow, void *private),
-                      void *private);
+    /* Iterates through the flow entries in 'table', passing each one
+     * matches 'key' to 'callback'.  The callback function should return 0
+     * to continue iteration or a nonzero error code to stop.  The iterator
+     * function returns either 0 if the table iteration completed or the
+     * value returned by the callback function otherwise.
+     *
+     * The iteration starts at 'position', which may be initialized to
+     * all-zero-bits to iterate from the beginning of the table.  If the
+     * iteration terminates due to an error from the callback function,
+     * 'position' is updated to a value that can be passed back to the
+     * iterator function to resume iteration later with the following
+     * flow. */
+    int (*iterate)(struct sw_table *table,
+               const struct sw_flow_key *key,
+               struct sw_table_position *position,
+               int (*callback)(struct sw_flow *flow, void *private),
+               void *private);
 
     /* Dumps statistics for 'table' into 'stats'. */
     void (*stats)(struct sw_table *table, struct sw_table_stats *stats);