Convert "4 space tabs" to spaces;

Add editor modelines.

Change-Id: I360a557a1e9753c4ae7ab95213aa8d44000f7dfd
Reviewed-on: https://code.wireshark.org/review/1335
Reviewed-by: Bill Meier <wmeier@newsguy.com>

1 files changed, 105 insertions, 92 deletions

diff --git a/epan/packet_info.h b/epan/packet_info.h
index 23bae69f7b..2deb475980 100644
--- a/epan/packet_info.h
+++ b/epan/packet_info.h
@@ -37,96 +37,96 @@
  */
 
 /* Also defined in wiretap/wtap.h */
-#define P2P_DIR_UNKNOWN	-1
-#define P2P_DIR_SENT	0
-#define P2P_DIR_RECV	1
+#define P2P_DIR_UNKNOWN -1
+#define P2P_DIR_SENT    0
+#define P2P_DIR_RECV    1
 
 /* Link direction */
-#define LINK_DIR_UNKNOWN	-1
-#define P2P_DIR_UL	0
-#define P2P_DIR_DL	1
+#define LINK_DIR_UNKNOWN    -1
+#define P2P_DIR_UL  0
+#define P2P_DIR_DL  1
 
 typedef struct _packet_info {
-  const char *current_proto;		/**< name of protocol currently being dissected */
-  struct epan_column_info *cinfo;	/**< Column formatting information */
+  const char *current_proto;        /**< name of protocol currently being dissected */
+  struct epan_column_info *cinfo;   /**< Column formatting information */
   frame_data *fd;
   union wtap_pseudo_header *pseudo_header;
   struct wtap_pkthdr *phdr;
-  GSList *data_src;					/**< Frame data sources */
-  address dl_src;					/**< link-layer source address */
-  address dl_dst;					/**< link-layer destination address */
-  address net_src;					/**< network-layer source address */
-  address net_dst;					/**< network-layer destination address */
-  address src;						/**< source address (net if present, DL otherwise )*/
-  address dst;						/**< destination address (net if present, DL otherwise )*/
-  guint32 ipproto;					/**< IP protocol, if this is an IP packet */
-  circuit_type ctype;				/**< type of circuit, for protocols with a VC identifier */
-  guint32 circuit_id;				/**< circuit ID, for protocols with a VC identifier */
+  GSList *data_src;                 /**< Frame data sources */
+  address dl_src;                   /**< link-layer source address */
+  address dl_dst;                   /**< link-layer destination address */
+  address net_src;                  /**< network-layer source address */
+  address net_dst;                  /**< network-layer destination address */
+  address src;                      /**< source address (net if present, DL otherwise )*/
+  address dst;                      /**< destination address (net if present, DL otherwise )*/
+  guint32 ipproto;                  /**< IP protocol, if this is an IP packet */
+  circuit_type ctype;               /**< type of circuit, for protocols with a VC identifier */
+  guint32 circuit_id;               /**< circuit ID, for protocols with a VC identifier */
   const char *noreassembly_reason;  /**< reason why reassembly wasn't done, if any */
-  gboolean fragmented;				/**< TRUE if the protocol is only a fragment */
+  gboolean fragmented;              /**< TRUE if the protocol is only a fragment */
   struct {
-    guint32 in_error_pkt:1;			/**< TRUE if we're inside an {ICMP,CLNP,...} error packet */
-    guint32 in_gre_pkt:1;			/**< TRUE if we're encapsulated inside a GRE packet */
+    guint32 in_error_pkt:1;         /**< TRUE if we're inside an {ICMP,CLNP,...} error packet */
+    guint32 in_gre_pkt:1;           /**< TRUE if we're encapsulated inside a GRE packet */
   } flags;
-  port_type ptype;					/**< type of the following two port numbers */
-  guint32 srcport;					/**< source port */
-  guint32 destport;					/**< destination port */
-  guint32 match_uint;				/**< matched uint for calling subdissector from table */
-  const char *match_string;			/**< matched string for calling subdissector from table */
-  guint16 can_desegment;			/**< >0 if this segment could be desegmented.
-										 A dissector that can offer this API (e.g.
-										 TCP) sets can_desegment=2, then
-										 can_desegment is decremented by 1 each time
-										 we pass to the next subdissector. Thus only
-										 the dissector immediately above the
-										 protocol which sets the flag can use it*/
-  guint16 saved_can_desegment;		/**< Value of can_desegment before current
-										 dissector was called.  Supplied so that
-										 dissectors for proxy protocols such as
-										 SOCKS can restore it, allowing the
-										 dissectors that they call to use the
-										 TCP dissector's desegmentation (SOCKS
-										 just retransmits TCP segments once it's
-										 finished setting things up, so the TCP
-										 desegmentor can desegment its payload). */
-  int desegment_offset;				/**< offset to stuff needing desegmentation */
+  port_type ptype;                  /**< type of the following two port numbers */
+  guint32 srcport;                  /**< source port */
+  guint32 destport;                 /**< destination port */
+  guint32 match_uint;               /**< matched uint for calling subdissector from table */
+  const char *match_string;         /**< matched string for calling subdissector from table */
+  guint16 can_desegment;            /**< >0 if this segment could be desegmented.
+                                         A dissector that can offer this API (e.g.
+                                         TCP) sets can_desegment=2, then
+                                         can_desegment is decremented by 1 each time
+                                         we pass to the next subdissector. Thus only
+                                         the dissector immediately above the
+                                         protocol which sets the flag can use it*/
+  guint16 saved_can_desegment;      /**< Value of can_desegment before current
+                                         dissector was called.  Supplied so that
+                                         dissectors for proxy protocols such as
+                                         SOCKS can restore it, allowing the
+                                         dissectors that they call to use the
+                                         TCP dissector's desegmentation (SOCKS
+                                         just retransmits TCP segments once it's
+                                         finished setting things up, so the TCP
+                                         desegmentor can desegment its payload). */
+  int desegment_offset;             /**< offset to stuff needing desegmentation */
 #define DESEGMENT_ONE_MORE_SEGMENT 0x0fffffff
 #define DESEGMENT_UNTIL_FIN        0x0ffffffe
-  guint32 desegment_len;			/**< requested desegmentation additional length
-									   or
-									   DESEGMENT_ONE_MORE_SEGMENT:
-										 Desegment one more full segment
-										 (warning! only partially implemented)
-									   DESEGMENT_UNTIL_FIN:
-										 Desgment all data for this tcp session
-										 until the FIN segment.
-									*/
-  guint16 want_pdu_tracking;	/**< >0 if the subdissector has specified
-								   a value in 'bytes_until_next_pdu'.
-								   When a dissector detects that the next PDU
-								   will start beyond the start of the next
-								   segment, it can set this value to 2
-								   and 'bytes_until_next_pdu' to the number of
-								   bytes beyond the next segment where the
-								   next PDU starts.
-
-								   If the protocol dissector below this
-								   one is capable of PDU tracking it can
-								   use this hint to detect PDUs that starts
-								   unaligned to the segment boundaries.
-								   The TCP dissector is using this hint from
-								   (some) protocols to detect when a new PDU
-								   starts in the middle of a tcp segment.
-
-								   There is intelligence in the glue between
-								   dissector layers to make sure that this
-								   request is only passed down to the protocol
-								   immediately below the current one and not
-								   any further.
-								*/
+  guint32 desegment_len;            /**< requested desegmentation additional length
+                                       or
+                                       DESEGMENT_ONE_MORE_SEGMENT:
+                                         Desegment one more full segment
+                                         (warning! only partially implemented)
+                                       DESEGMENT_UNTIL_FIN:
+                                         Desgment all data for this tcp session
+                                         until the FIN segment.
+                                    */
+  guint16 want_pdu_tracking;    /**< >0 if the subdissector has specified
+                                   a value in 'bytes_until_next_pdu'.
+                                   When a dissector detects that the next PDU
+                                   will start beyond the start of the next
+                                   segment, it can set this value to 2
+                                   and 'bytes_until_next_pdu' to the number of
+                                   bytes beyond the next segment where the
+                                   next PDU starts.
+
+                                   If the protocol dissector below this
+                                   one is capable of PDU tracking it can
+                                   use this hint to detect PDUs that starts
+                                   unaligned to the segment boundaries.
+                                   The TCP dissector is using this hint from
+                                   (some) protocols to detect when a new PDU
+                                   starts in the middle of a tcp segment.
+
+                                   There is intelligence in the glue between
+                                   dissector layers to make sure that this
+                                   request is only passed down to the protocol
+                                   immediately below the current one and not
+                                   any further.
+                                */
   guint32 bytes_until_next_pdu;
 
-  int	  p2p_dir;              /**< Packet was captured as an
+  int     p2p_dir;              /**< Packet was captured as an
                                        outbound (P2P_DIR_SENT)
                                        inbound (P2P_DIR_RECV)
                                        unknown (P2P_DIR_UNKNOWN) */
@@ -141,37 +141,37 @@ typedef struct _packet_info {
      whether the data was modified by a man in the middle) but not sealed
      (i.e., the data itself wasn't encrypted).
   */
-#define DECRYPT_GSSAPI_NORMAL	1
-#define DECRYPT_GSSAPI_DCE	2
+#define DECRYPT_GSSAPI_NORMAL   1
+#define DECRYPT_GSSAPI_DCE  2
   guint16 decrypt_gssapi_tvb;
   tvbuff_t *gssapi_wrap_tvb;
   tvbuff_t *gssapi_encrypted_tvb;
   tvbuff_t *gssapi_decrypted_tvb;
   gboolean gssapi_data_encrypted;
 
-  void    *private_data;		/**< pointer to data passed from one dissector to another */
-  GHashTable *private_table;	/**< a hash table passed from one dissector to another */
+  void    *private_data;        /**< pointer to data passed from one dissector to another */
+  GHashTable *private_table;    /**< a hash table passed from one dissector to another */
 
-  wmem_list_t *layers; 		/**< layers of each protocol */
+  wmem_list_t *layers;      /**< layers of each protocol */
   guint8 curr_layer_num;       /**< The current "depth" or layer number in the current frame */
   guint16 link_number;
-  guint8  annex_a_used;			/**< used in packet-mtp2.c
-								 * defined in wtap.h
-								 * MTP2_ANNEX_A_NOT_USED      0
-								 * MTP2_ANNEX_A_USED          1
-								 * MTP2_ANNEX_A_USED_UNKNOWN  2
-								 */
-  guint16 profinet_type; 		/**< the type of PROFINET packet (0: not a PROFINET packet) */
+  guint8  annex_a_used;         /**< used in packet-mtp2.c
+                                 * defined in wtap.h
+                                 * MTP2_ANNEX_A_NOT_USED      0
+                                 * MTP2_ANNEX_A_USED          1
+                                 * MTP2_ANNEX_A_USED_UNKNOWN  2
+                                 */
+  guint16 profinet_type;        /**< the type of PROFINET packet (0: not a PROFINET packet) */
 
   struct _sccp_msg_info_t* sccp_info;
-  guint16 clnp_srcref;			/**< clnp/cotp source reference (can't use srcport, this would confuse tpkt) */
-  guint16 clnp_dstref;			/**< clnp/cotp destination reference (can't use dstport, this would confuse tpkt) */
+  guint16 clnp_srcref;          /**< clnp/cotp source reference (can't use srcport, this would confuse tpkt) */
+  guint16 clnp_dstref;          /**< clnp/cotp destination reference (can't use dstport, this would confuse tpkt) */
 
-  int link_dir;					/**< 3GPP messages are sometime different UP link(UL) or Downlink(DL) */
+  int link_dir;                 /**< 3GPP messages are sometime different UP link(UL) or Downlink(DL) */
 
   GSList* proto_data;          /**< Per packet proto data */
 
-  GSList* dependent_frames;		/**< A list of frames which this one depends on */
+  GSList* dependent_frames;     /**< A list of frames which this one depends on */
 
   GSList* frame_end_routines;
 
@@ -185,3 +185,16 @@ typedef struct _packet_info {
 /** @} */
 
 #endif /* __PACKET_INFO_H__ */
+
+/*
+ * Editor modelines
+ *
+ * Local Variables:
+ * c-basic-offset: 2
+ * tab-width: 8
+ * indent-tabs-mode: nil
+ * End:
+ *
+ * ex: set shiftwidth=2 tabstop=8 expandtab:
+ * :indentSize=2:tabSize=8:noTabs=true:
+ */