Whitespace cleanups.

Change-Id: I92f983b2e04defab30eb31c14c484b9f0f582413
Reviewed-on: https://code.wireshark.org/review/4513
Reviewed-by: Guy Harris <guy@alum.mit.edu>

1 files changed, 340 insertions, 340 deletions

diff --git a/wiretap/nettl.c b/wiretap/nettl.c
index 7e6d1ec97d..89cd82a883 100644
--- a/wiretap/nettl.c
+++ b/wiretap/nettl.c
@@ -239,35 +239,35 @@ int nettl_open(wtap *wth, int *err, gchar **err_info)
         case NETTL_SUBSYS_EISA_FDDI :
         case NETTL_SUBSYS_PCI_FDDI :
         case NETTL_SUBSYS_HSC_FDDI :
-		wth->file_encap = WTAP_ENCAP_NETTL_FDDI;
-		break;
+                wth->file_encap = WTAP_ENCAP_NETTL_FDDI;
+                break;
         case NETTL_SUBSYS_TOKEN :
         case NETTL_SUBSYS_PCI_TR :
-		wth->file_encap = WTAP_ENCAP_NETTL_TOKEN_RING;
-		break;
+                wth->file_encap = WTAP_ENCAP_NETTL_TOKEN_RING;
+                break;
         case NETTL_SUBSYS_NS_LS_IP :
         case NETTL_SUBSYS_NS_LS_LOOPBACK :
         case NETTL_SUBSYS_NS_LS_TCP :
         case NETTL_SUBSYS_NS_LS_UDP :
         case NETTL_SUBSYS_NS_LS_IPV6 :
-		wth->file_encap = WTAP_ENCAP_NETTL_RAW_IP;
-		break;
+                wth->file_encap = WTAP_ENCAP_NETTL_RAW_IP;
+                break;
         case NETTL_SUBSYS_NS_LS_ICMP :
-		wth->file_encap = WTAP_ENCAP_NETTL_RAW_ICMP;
-		break;
+                wth->file_encap = WTAP_ENCAP_NETTL_RAW_ICMP;
+                break;
         case NETTL_SUBSYS_NS_LS_ICMPV6 :
-		wth->file_encap = WTAP_ENCAP_NETTL_RAW_ICMPV6;
-		break;
+                wth->file_encap = WTAP_ENCAP_NETTL_RAW_ICMPV6;
+                break;
         case NETTL_SUBSYS_NS_LS_TELNET :
-		wth->file_encap = WTAP_ENCAP_NETTL_RAW_TELNET;
-		break;
-	default:
-		/* If this assumption is bad, the read will catch it */
-		wth->file_encap = WTAP_ENCAP_NETTL_ETHERNET;
+                wth->file_encap = WTAP_ENCAP_NETTL_RAW_TELNET;
+                break;
+        default:
+                /* If this assumption is bad, the read will catch it */
+                wth->file_encap = WTAP_ENCAP_NETTL_ETHERNET;
     }
 
     if (file_seek(wth->fh, FILE_HDR_SIZE, SEEK_SET, err) == -1) {
-	return -1;
+        return -1;
     }
     wth->file_tsprec = WTAP_TSPREC_USEC;
 
@@ -282,8 +282,8 @@ static gboolean nettl_read(wtap *wth, int *err, gchar **err_info,
     *data_offset = file_tell(wth->fh);
     if (!nettl_read_rec(wth, wth->fh, &wth->phdr, wth->frame_buffer,
         err, err_info)) {
-	/* Read error or EOF */
-	return FALSE;
+        /* Read error or EOF */
+        return FALSE;
     }
 
     /*
@@ -295,10 +295,10 @@ static gboolean nettl_read(wtap *wth, int *err, gchar **err_info,
      * have a single encapsulation for all packets in the file.
      */
     if (wth->file_encap == WTAP_ENCAP_UNKNOWN)
-	wth->file_encap = wth->phdr.pkt_encap;
+        wth->file_encap = wth->phdr.pkt_encap;
     else {
-	if (wth->file_encap != wth->phdr.pkt_encap)
-	    wth->file_encap = WTAP_ENCAP_PER_PACKET;
+        if (wth->file_encap != wth->phdr.pkt_encap)
+            wth->file_encap = WTAP_ENCAP_PER_PACKET;
     }
 
     return TRUE;
@@ -306,26 +306,26 @@ static gboolean nettl_read(wtap *wth, int *err, gchar **err_info,
 
 static gboolean
 nettl_seek_read(wtap *wth, gint64 seek_off, struct wtap_pkthdr *phdr,
-		Buffer *buf, int *err, gchar **err_info)
+                Buffer *buf, int *err, gchar **err_info)
 {
     if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
-	return FALSE;
+        return FALSE;
 
     /* Read record. */
     if (!nettl_read_rec(wth, wth->random_fh, phdr, buf, err, err_info)) {
-	/* Read error or EOF */
-	if (*err == 0) {
-	    /* EOF means "short read" in random-access mode */
-	    *err = WTAP_ERR_SHORT_READ;
-	}
-	return FALSE;
+        /* Read error or EOF */
+        if (*err == 0) {
+            /* EOF means "short read" in random-access mode */
+            *err = WTAP_ERR_SHORT_READ;
+        }
+        return FALSE;
     }
     return TRUE;
 }
 
 static gboolean
 nettl_read_rec(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf,
-		int *err, gchar **err_info)
+                int *err, gchar **err_info)
 {
     union wtap_pseudo_header *pseudo_header = &phdr->pseudo_header;
     nettl_t *nettl = (nettl_t *)wth->priv;
@@ -344,21 +344,21 @@ nettl_read_rec(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf,
     errno = WTAP_ERR_CANT_READ;
     if (!wtap_read_bytes_or_eof(fh, &rec_hdr.hdr_len, sizeof rec_hdr.hdr_len,
                           err, err_info))
-	return FALSE;
+        return FALSE;
     hdr_len = g_ntohs(rec_hdr.hdr_len);
     if (hdr_len < NETTL_REC_HDR_LEN) {
-    	*err = WTAP_ERR_BAD_FILE;
-	*err_info = g_strdup_printf("nettl: record header length %u too short",
-	    hdr_len);
-	return FALSE;
+        *err = WTAP_ERR_BAD_FILE;
+        *err_info = g_strdup_printf("nettl: record header length %u too short",
+            hdr_len);
+        return FALSE;
     }
     if (!wtap_read_bytes(fh, &rec_hdr.subsys, NETTL_REC_HDR_LEN - 2,
                               err, err_info))
-	return FALSE;
+        return FALSE;
     subsys = g_ntohs(rec_hdr.subsys);
     hdr_len -= NETTL_REC_HDR_LEN;
     if (file_seek(fh, hdr_len, SEEK_CUR, err) == -1)
-	return FALSE;
+        return FALSE;
 
     if ( (pntoh32(&rec_hdr.kind) & NETTL_HDR_PDU_MASK) == 0 ) {
         /* not actually a data packet (PDU) trace record */
@@ -367,72 +367,72 @@ nettl_read_rec(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf,
         caplen = pntoh32(&rec_hdr.caplen);
         padlen = 0;
     } else switch (subsys) {
-	case NETTL_SUBSYS_LAN100 :
-	case NETTL_SUBSYS_EISA100BT :
-	case NETTL_SUBSYS_BASE100 :
-	case NETTL_SUBSYS_GSC100BT :
-	case NETTL_SUBSYS_PCI100BT :
-	case NETTL_SUBSYS_SPP100BT :
-	case NETTL_SUBSYS_100VG :
-	case NETTL_SUBSYS_GELAN :
-	case NETTL_SUBSYS_BTLAN :
-	case NETTL_SUBSYS_INTL100 :
-	case NETTL_SUBSYS_IGELAN :
-	case NETTL_SUBSYS_IETHER :
-	case NETTL_SUBSYS_IXGBE :
-	case NETTL_SUBSYS_HSSN :
-	case NETTL_SUBSYS_IGSSN :
-	case NETTL_SUBSYS_ICXGBE :
-	case NETTL_SUBSYS_IEXGBE :
-	case NETTL_SUBSYS_IOCXGBE :
-	case NETTL_SUBSYS_IQXGBE :
-	case NETTL_SUBSYS_HPPB_FDDI :
-	case NETTL_SUBSYS_EISA_FDDI :
+        case NETTL_SUBSYS_LAN100 :
+        case NETTL_SUBSYS_EISA100BT :
+        case NETTL_SUBSYS_BASE100 :
+        case NETTL_SUBSYS_GSC100BT :
+        case NETTL_SUBSYS_PCI100BT :
+        case NETTL_SUBSYS_SPP100BT :
+        case NETTL_SUBSYS_100VG :
+        case NETTL_SUBSYS_GELAN :
+        case NETTL_SUBSYS_BTLAN :
+        case NETTL_SUBSYS_INTL100 :
+        case NETTL_SUBSYS_IGELAN :
+        case NETTL_SUBSYS_IETHER :
+        case NETTL_SUBSYS_IXGBE :
+        case NETTL_SUBSYS_HSSN :
+        case NETTL_SUBSYS_IGSSN :
+        case NETTL_SUBSYS_ICXGBE :
+        case NETTL_SUBSYS_IEXGBE :
+        case NETTL_SUBSYS_IOCXGBE :
+        case NETTL_SUBSYS_IQXGBE :
+        case NETTL_SUBSYS_HPPB_FDDI :
+        case NETTL_SUBSYS_EISA_FDDI :
         case NETTL_SUBSYS_PCI_FDDI :
         case NETTL_SUBSYS_HSC_FDDI :
         case NETTL_SUBSYS_TOKEN :
         case NETTL_SUBSYS_PCI_TR :
-	case NETTL_SUBSYS_NS_LS_IP :
-	case NETTL_SUBSYS_NS_LS_LOOPBACK :
-	case NETTL_SUBSYS_NS_LS_TCP :
-	case NETTL_SUBSYS_NS_LS_UDP :
-	case NETTL_SUBSYS_HP_APAPORT :
-	case NETTL_SUBSYS_HP_APALACP :
-	case NETTL_SUBSYS_NS_LS_IPV6 :
-	case NETTL_SUBSYS_NS_LS_ICMPV6 :
-	case NETTL_SUBSYS_NS_LS_ICMP :
-	case NETTL_SUBSYS_NS_LS_TELNET :
-	case NETTL_SUBSYS_NS_LS_SCTP :
-	    if( (subsys == NETTL_SUBSYS_NS_LS_IP)
-	     || (subsys == NETTL_SUBSYS_NS_LS_LOOPBACK)
-	     || (subsys == NETTL_SUBSYS_NS_LS_UDP)
-	     || (subsys == NETTL_SUBSYS_NS_LS_TCP)
-	     || (subsys == NETTL_SUBSYS_NS_LS_SCTP)
-	     || (subsys == NETTL_SUBSYS_NS_LS_IPV6)) {
-		phdr->pkt_encap = WTAP_ENCAP_NETTL_RAW_IP;
-	    } else if (subsys == NETTL_SUBSYS_NS_LS_ICMP) {
-		phdr->pkt_encap = WTAP_ENCAP_NETTL_RAW_ICMP;
-	    } else if (subsys == NETTL_SUBSYS_NS_LS_ICMPV6) {
-		phdr->pkt_encap = WTAP_ENCAP_NETTL_RAW_ICMPV6;
-	    } else if (subsys == NETTL_SUBSYS_NS_LS_TELNET) {
-		phdr->pkt_encap = WTAP_ENCAP_NETTL_RAW_TELNET;
-	    } else if( (subsys == NETTL_SUBSYS_HPPB_FDDI)
-		    || (subsys == NETTL_SUBSYS_EISA_FDDI)
-		    || (subsys == NETTL_SUBSYS_PCI_FDDI)
-		    || (subsys == NETTL_SUBSYS_HSC_FDDI) ) {
-		phdr->pkt_encap = WTAP_ENCAP_NETTL_FDDI;
-	    } else if( (subsys == NETTL_SUBSYS_PCI_TR)
-		    || (subsys == NETTL_SUBSYS_TOKEN) ) {
-		phdr->pkt_encap = WTAP_ENCAP_NETTL_TOKEN_RING;
-	    } else {
-		phdr->pkt_encap = WTAP_ENCAP_NETTL_ETHERNET;
-	    }
-
-	    length = pntoh32(&rec_hdr.length);
-	    caplen = pntoh32(&rec_hdr.caplen);
-
-	    /* HPPB FDDI has different inbound vs outbound trace records */
-	    if (subsys == NETTL_SUBSYS_HPPB_FDDI) {
+        case NETTL_SUBSYS_NS_LS_IP :
+        case NETTL_SUBSYS_NS_LS_LOOPBACK :
+        case NETTL_SUBSYS_NS_LS_TCP :
+        case NETTL_SUBSYS_NS_LS_UDP :
+        case NETTL_SUBSYS_HP_APAPORT :
+        case NETTL_SUBSYS_HP_APALACP :
+        case NETTL_SUBSYS_NS_LS_IPV6 :
+        case NETTL_SUBSYS_NS_LS_ICMPV6 :
+        case NETTL_SUBSYS_NS_LS_ICMP :
+        case NETTL_SUBSYS_NS_LS_TELNET :
+        case NETTL_SUBSYS_NS_LS_SCTP :
+            if( (subsys == NETTL_SUBSYS_NS_LS_IP)
+             || (subsys == NETTL_SUBSYS_NS_LS_LOOPBACK)
+             || (subsys == NETTL_SUBSYS_NS_LS_UDP)
+             || (subsys == NETTL_SUBSYS_NS_LS_TCP)
+             || (subsys == NETTL_SUBSYS_NS_LS_SCTP)
+             || (subsys == NETTL_SUBSYS_NS_LS_IPV6)) {
+                phdr->pkt_encap = WTAP_ENCAP_NETTL_RAW_IP;
+            } else if (subsys == NETTL_SUBSYS_NS_LS_ICMP) {
+                phdr->pkt_encap = WTAP_ENCAP_NETTL_RAW_ICMP;
+            } else if (subsys == NETTL_SUBSYS_NS_LS_ICMPV6) {
+                phdr->pkt_encap = WTAP_ENCAP_NETTL_RAW_ICMPV6;
+            } else if (subsys == NETTL_SUBSYS_NS_LS_TELNET) {
+                phdr->pkt_encap = WTAP_ENCAP_NETTL_RAW_TELNET;
+            } else if( (subsys == NETTL_SUBSYS_HPPB_FDDI)
+                    || (subsys == NETTL_SUBSYS_EISA_FDDI)
+                    || (subsys == NETTL_SUBSYS_PCI_FDDI)
+                    || (subsys == NETTL_SUBSYS_HSC_FDDI) ) {
+                phdr->pkt_encap = WTAP_ENCAP_NETTL_FDDI;
+            } else if( (subsys == NETTL_SUBSYS_PCI_TR)
+                    || (subsys == NETTL_SUBSYS_TOKEN) ) {
+                phdr->pkt_encap = WTAP_ENCAP_NETTL_TOKEN_RING;
+            } else {
+                phdr->pkt_encap = WTAP_ENCAP_NETTL_ETHERNET;
+            }
+
+            length = pntoh32(&rec_hdr.length);
+            caplen = pntoh32(&rec_hdr.caplen);
+
+            /* HPPB FDDI has different inbound vs outbound trace records */
+            if (subsys == NETTL_SUBSYS_HPPB_FDDI) {
                 if (pntoh32(&rec_hdr.kind) == NETTL_HDR_PDUIN) {
                     /* inbound is very strange...
                        there are an extra 3 bytes after the DSAP and SSAP
@@ -441,24 +441,24 @@ nettl_read_rec(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf,
                     fddihack=TRUE;
                     padlen = 0;
                 } else {
-	            /* outbound appears to have variable padding */
-	            if (!wtap_read_bytes(fh, dummyc, 9, err, err_info))
-			return FALSE;
+                    /* outbound appears to have variable padding */
+                    if (!wtap_read_bytes(fh, dummyc, 9, err, err_info))
+                        return FALSE;
                     /* padding is usually either a total 11 or 16 bytes??? */
-		    padlen = (int)dummyc[8];
-		    if (file_seek(fh, padlen, SEEK_CUR, err) == -1)
-			return FALSE;
-		    padlen += 9;
-		}
-	    } else if ( (subsys == NETTL_SUBSYS_PCI_FDDI)
-	             || (subsys == NETTL_SUBSYS_EISA_FDDI)
-	             || (subsys == NETTL_SUBSYS_HSC_FDDI) ) {
-	        /* other flavor FDDI cards have an extra 3 bytes of padding */
+                    padlen = (int)dummyc[8];
+                    if (file_seek(fh, padlen, SEEK_CUR, err) == -1)
+                        return FALSE;
+                    padlen += 9;
+                }
+            } else if ( (subsys == NETTL_SUBSYS_PCI_FDDI)
+                     || (subsys == NETTL_SUBSYS_EISA_FDDI)
+                     || (subsys == NETTL_SUBSYS_HSC_FDDI) ) {
+                /* other flavor FDDI cards have an extra 3 bytes of padding */
                 if (file_seek(fh, 3, SEEK_CUR, err) == -1)
                     return FALSE;
                 padlen = 3;
-	    } else if (subsys == NETTL_SUBSYS_NS_LS_LOOPBACK) {
-	        /* LOOPBACK has an extra 26 bytes of padding */
+            } else if (subsys == NETTL_SUBSYS_NS_LS_LOOPBACK) {
+                /* LOOPBACK has an extra 26 bytes of padding */
                 if (file_seek(fh, 26, SEEK_CUR, err) == -1)
                     return FALSE;
                 padlen = 26;
@@ -476,68 +476,68 @@ nettl_read_rec(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf,
                 if (file_seek(fh, 8, SEEK_CUR, err) == -1)
                     return FALSE;
                 padlen = 8;
-	    } else {
-	    	padlen = 0;
-	    }
-	    break;
-
-	case NETTL_SUBSYS_NS_LS_DRIVER :
-	    /* XXX we don't know how to identify this as ethernet frames, so
-	       we assume everything is. We will crash and burn for anything else */
-	    /* for encapsulated 100baseT we do this */
-	    phdr->pkt_encap = WTAP_ENCAP_NETTL_ETHERNET;
-	    if (!wtap_read_bytes(fh, &drv_eth_hdr, NS_LS_DRV_ETH_HDR_LEN,
-	                              err, err_info))
-		return FALSE;
-
-	    length = pntoh16(&drv_eth_hdr.length);
-	    caplen = pntoh16(&drv_eth_hdr.caplen);
-	    /*
-	     * XXX - is there a length field that would give the length
-	     * of this header, so that we don't have to check for
-	     * nettl files from HP-UX 11?
-	     *
-	     * And what are the extra two bytes?
-	     */
+            } else {
+                padlen = 0;
+            }
+            break;
+
+        case NETTL_SUBSYS_NS_LS_DRIVER :
+            /* XXX we don't know how to identify this as ethernet frames, so
+               we assume everything is. We will crash and burn for anything else */
+            /* for encapsulated 100baseT we do this */
+            phdr->pkt_encap = WTAP_ENCAP_NETTL_ETHERNET;
+            if (!wtap_read_bytes(fh, &drv_eth_hdr, NS_LS_DRV_ETH_HDR_LEN,
+                                      err, err_info))
+                return FALSE;
+
+            length = pntoh16(&drv_eth_hdr.length);
+            caplen = pntoh16(&drv_eth_hdr.caplen);
+            /*
+             * XXX - is there a length field that would give the length
+             * of this header, so that we don't have to check for
+             * nettl files from HP-UX 11?
+             *
+             * And what are the extra two bytes?
+             */
             if (nettl->is_hpux_11) {
                 if (file_seek(fh, 2, SEEK_CUR, err) == -1) return FALSE;
             }
-	    padlen = 0;
-	    break;
-
-	case NETTL_SUBSYS_SX25L2:
-	case NETTL_SUBSYS_SX25L3:
-	    /*
-	     * XXX - is the 24-byte padding actually a header with
-	     * packet lengths, time stamps, etc., just as is the case
-	     * for NETTL_SUBSYS_NS_LS_DRIVER?  It might be
-	     *
-	     *    guint8	caplen[2];
-	     *    guint8	length[2];
-	     *    guint8	xxc[4];
-	     *    guint8	sec[4];
-	     *    guint8	usec[4];
-	     *    guint8	xxd[4];
-	     *
-	     * or something such as that - if it has 4 bytes before that
-	     * (making it 24 bytes), it'd be like struct
-	     * nettlrec_ns_ls_drv_eth_hdr but with 2 more bytes at the end.
-	     *
-	     * And is "from_dce" at xxa[0] in the nettlrec_hdr structure?
-	     */
-	    phdr->pkt_encap = WTAP_ENCAP_NETTL_X25;
-	    length = pntoh32(&rec_hdr.length);
-	    caplen = pntoh32(&rec_hdr.caplen);
-	    padlen = 24;	/* sizeof (struct nettlrec_sx25l2_hdr) - NETTL_REC_HDR_LEN + 4 */
-	    if (file_seek(fh, padlen, SEEK_CUR, err) == -1)
-		return FALSE;
-	    break;
-
-	default:
+            padlen = 0;
+            break;
+
+        case NETTL_SUBSYS_SX25L2:
+        case NETTL_SUBSYS_SX25L3:
+            /*
+             * XXX - is the 24-byte padding actually a header with
+             * packet lengths, time stamps, etc., just as is the case
+             * for NETTL_SUBSYS_NS_LS_DRIVER?  It might be
+             *
+             *    guint8        caplen[2];
+             *    guint8        length[2];
+             *    guint8        xxc[4];
+             *    guint8        sec[4];
+             *    guint8        usec[4];
+             *    guint8        xxd[4];
+             *
+             * or something such as that - if it has 4 bytes before that
+             * (making it 24 bytes), it'd be like struct
+             * nettlrec_ns_ls_drv_eth_hdr but with 2 more bytes at the end.
+             *
+             * And is "from_dce" at xxa[0] in the nettlrec_hdr structure?
+             */
+            phdr->pkt_encap = WTAP_ENCAP_NETTL_X25;
+            length = pntoh32(&rec_hdr.length);
+            caplen = pntoh32(&rec_hdr.caplen);
+            padlen = 24;        /* sizeof (struct nettlrec_sx25l2_hdr) - NETTL_REC_HDR_LEN + 4 */
+            if (file_seek(fh, padlen, SEEK_CUR, err) == -1)
+                return FALSE;
+            break;
+
+        default:
             /* We're going to assume it's ethernet if we don't recognize the
                subsystem -- We'll probably spew junks and core if it isn't... */
-	    wth->file_encap = WTAP_ENCAP_PER_PACKET;
-	    phdr->pkt_encap = WTAP_ENCAP_NETTL_ETHERNET;
+            wth->file_encap = WTAP_ENCAP_PER_PACKET;
+            phdr->pkt_encap = WTAP_ENCAP_NETTL_ETHERNET;
             length = pntoh32(&rec_hdr.length);
             caplen = pntoh32(&rec_hdr.caplen);
             padlen = 0;
@@ -545,19 +545,19 @@ nettl_read_rec(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf,
     }
 
     if (length < padlen) {
-	*err = WTAP_ERR_BAD_FILE;
-	*err_info = g_strdup_printf("nettl: packet length %u in record header too short, less than %u",
-	    length, padlen);
-	return FALSE;
+        *err = WTAP_ERR_BAD_FILE;
+        *err_info = g_strdup_printf("nettl: packet length %u in record header too short, less than %u",
+            length, padlen);
+        return FALSE;
     }
     phdr->rec_type = REC_TYPE_PACKET;
     phdr->presence_flags = WTAP_HAS_TS|WTAP_HAS_CAP_LEN;
     phdr->len = length - padlen;
     if (caplen < padlen) {
-	*err = WTAP_ERR_BAD_FILE;
-	*err_info = g_strdup_printf("nettl: captured length %u in record header too short, less than %u",
-	    caplen, padlen);
-	return FALSE;
+        *err = WTAP_ERR_BAD_FILE;
+        *err_info = g_strdup_printf("nettl: captured length %u in record header too short, less than %u",
+            caplen, padlen);
+        return FALSE;
     }
     datalen = caplen - padlen;
     phdr->caplen = datalen;
@@ -571,14 +571,14 @@ nettl_read_rec(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf,
     pseudo_header->nettl.uid      = pntoh16(&rec_hdr.uid);
 
     if (phdr->caplen > WTAP_MAX_PACKET_SIZE) {
-	/*
-	 * Probably a corrupt capture file; don't blow up trying
-	 * to allocate space for an immensely-large packet.
-	 */
-	*err = WTAP_ERR_BAD_FILE;
-	*err_info = g_strdup_printf("nettl: File has %u-byte packet, bigger than maximum of %u",
-	    phdr->caplen, WTAP_MAX_PACKET_SIZE);
-	return FALSE;
+        /*
+         * Probably a corrupt capture file; don't blow up trying
+         * to allocate space for an immensely-large packet.
+         */
+        *err = WTAP_ERR_BAD_FILE;
+        *err_info = g_strdup_printf("nettl: File has %u-byte packet, bigger than maximum of %u",
+            phdr->caplen, WTAP_MAX_PACKET_SIZE);
+        return FALSE;
     }
 
     /*
@@ -609,14 +609,14 @@ nettl_read_rec(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf,
             datalen -= bytes_to_read;
             if (datalen == 0) {
                 /* There's nothing past the FC, dest, src, DSAP, SSAP, and 3 bytes to eat */
-		return TRUE;
-	    }
+                return TRUE;
+            }
         }
         if (!wtap_read_bytes(fh, pd + 15, datalen, err, err_info))
             return FALSE;
     } else {
-    	if (!wtap_read_bytes(fh, pd, datalen, err, err_info))
-    	    return FALSE;
+        if (!wtap_read_bytes(fh, pd, datalen, err, err_info))
+            return FALSE;
     }
 
     return TRUE;
@@ -630,27 +630,27 @@ nettl_read_rec(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf,
 int nettl_dump_can_write_encap(int encap)
 {
 
-	switch (encap) {
-		case WTAP_ENCAP_ETHERNET:
-		case WTAP_ENCAP_FDDI_BITSWAPPED:
-		case WTAP_ENCAP_TOKEN_RING:
-		case WTAP_ENCAP_NETTL_ETHERNET:
-		case WTAP_ENCAP_NETTL_FDDI:
-		case WTAP_ENCAP_NETTL_TOKEN_RING:
-		case WTAP_ENCAP_NETTL_RAW_IP:
-		case WTAP_ENCAP_NETTL_RAW_ICMP:
-		case WTAP_ENCAP_NETTL_RAW_ICMPV6:
-		case WTAP_ENCAP_NETTL_RAW_TELNET:
+        switch (encap) {
+                case WTAP_ENCAP_ETHERNET:
+                case WTAP_ENCAP_FDDI_BITSWAPPED:
+                case WTAP_ENCAP_TOKEN_RING:
+                case WTAP_ENCAP_NETTL_ETHERNET:
+                case WTAP_ENCAP_NETTL_FDDI:
+                case WTAP_ENCAP_NETTL_TOKEN_RING:
+                case WTAP_ENCAP_NETTL_RAW_IP:
+                case WTAP_ENCAP_NETTL_RAW_ICMP:
+                case WTAP_ENCAP_NETTL_RAW_ICMPV6:
+                case WTAP_ENCAP_NETTL_RAW_TELNET:
 /*
-		case WTAP_ENCAP_NETTL_X25:
+                case WTAP_ENCAP_NETTL_X25:
 */
-		case WTAP_ENCAP_PER_PACKET:
-		case WTAP_ENCAP_UNKNOWN:
-		case WTAP_ENCAP_NETTL_UNKNOWN:
-			return 0;
-		default:
-			return WTAP_ERR_UNSUPPORTED_ENCAP;
-	}
+                case WTAP_ENCAP_PER_PACKET:
+                case WTAP_ENCAP_UNKNOWN:
+                case WTAP_ENCAP_NETTL_UNKNOWN:
+                        return 0;
+                default:
+                        return WTAP_ERR_UNSUPPORTED_ENCAP;
+        }
 }
 
 
@@ -658,151 +658,151 @@ int nettl_dump_can_write_encap(int encap)
    sets "*err" to an error code on failure */
 gboolean nettl_dump_open(wtap_dumper *wdh, int *err)
 {
-	struct nettl_file_hdr file_hdr;
-
-	/* This is a nettl file */
-	wdh->subtype_write = nettl_dump;
-	wdh->subtype_close = NULL;
-
-	/* Write the file header. */
-	memset(&file_hdr,0,sizeof(file_hdr));
-	memcpy(file_hdr.magic,nettl_magic_hpux10,sizeof(file_hdr.magic));
-	g_strlcpy(file_hdr.file_name,"/tmp/wireshark.TRC000",NETTL_FILENAME_SIZE);
-	g_strlcpy(file_hdr.tz,"UTC",20);
-	g_strlcpy(file_hdr.host_name,"",9);
-	g_strlcpy(file_hdr.os_vers,"B.11.11",9);
-	file_hdr.os_v=0x55;
-	g_strlcpy(file_hdr.model,"9000/800",11);
-	file_hdr.unknown=g_htons(0x406);
-	if (!wtap_dump_file_write(wdh, &file_hdr, sizeof file_hdr, err))
-		return FALSE;
-	wdh->bytes_dumped += sizeof(file_hdr);
-
-	return TRUE;
+        struct nettl_file_hdr file_hdr;
+
+        /* This is a nettl file */
+        wdh->subtype_write = nettl_dump;
+        wdh->subtype_close = NULL;
+
+        /* Write the file header. */
+        memset(&file_hdr,0,sizeof(file_hdr));
+        memcpy(file_hdr.magic,nettl_magic_hpux10,sizeof(file_hdr.magic));
+        g_strlcpy(file_hdr.file_name,"/tmp/wireshark.TRC000",NETTL_FILENAME_SIZE);
+        g_strlcpy(file_hdr.tz,"UTC",20);
+        g_strlcpy(file_hdr.host_name,"",9);
+        g_strlcpy(file_hdr.os_vers,"B.11.11",9);
+        file_hdr.os_v=0x55;
+        g_strlcpy(file_hdr.model,"9000/800",11);
+        file_hdr.unknown=g_htons(0x406);
+        if (!wtap_dump_file_write(wdh, &file_hdr, sizeof file_hdr, err))
+                return FALSE;
+        wdh->bytes_dumped += sizeof(file_hdr);
+
+        return TRUE;
 }
 
 /* Write a record for a packet to a dump file.
    Returns TRUE on success, FALSE on failure. */
 static gboolean nettl_dump(wtap_dumper *wdh,
-	const struct wtap_pkthdr *phdr,
-	const guint8 *pd, int *err)
+        const struct wtap_pkthdr *phdr,
+        const guint8 *pd, int *err)
 {
-	const union wtap_pseudo_header *pseudo_header = &phdr->pseudo_header;
-	struct nettlrec_hdr rec_hdr;
-	guint8 dummyc[24];
-
-	/* We can only write packet records. */
-	if (phdr->rec_type != REC_TYPE_PACKET) {
-		*err = WTAP_ERR_REC_TYPE_UNSUPPORTED;
-		return FALSE;
-	}
-
-	/* Don't write anything we're not willing to read. */
-	if (phdr->caplen > WTAP_MAX_PACKET_SIZE) {
-		*err = WTAP_ERR_PACKET_TOO_LARGE;
-		return FALSE;
-	}
-
-	memset(&rec_hdr,0,sizeof(rec_hdr));
+        const union wtap_pseudo_header *pseudo_header = &phdr->pseudo_header;
+        struct nettlrec_hdr rec_hdr;
+        guint8 dummyc[24];
+
+        /* We can only write packet records. */
+        if (phdr->rec_type != REC_TYPE_PACKET) {
+                *err = WTAP_ERR_REC_TYPE_UNSUPPORTED;
+                return FALSE;
+        }
+
+        /* Don't write anything we're not willing to read. */
+        if (phdr->caplen > WTAP_MAX_PACKET_SIZE) {
+                *err = WTAP_ERR_PACKET_TOO_LARGE;
+                return FALSE;
+        }
+
+        memset(&rec_hdr,0,sizeof(rec_hdr));
         /* HP-UX 11.X header should be 68 bytes */
-	rec_hdr.hdr_len = g_htons(sizeof(rec_hdr) + 4);
-	rec_hdr.kind = g_htonl(NETTL_HDR_PDUIN);
-	rec_hdr.sec = g_htonl(phdr->ts.secs);
-	rec_hdr.usec = g_htonl(phdr->ts.nsecs/1000);
-	rec_hdr.caplen = g_htonl(phdr->caplen);
-	rec_hdr.length = g_htonl(phdr->len);
-	rec_hdr.devid = -1;
-	rec_hdr.pid = -1;
-	rec_hdr.uid = -1;
-
-	switch (phdr->pkt_encap) {
-
-		case WTAP_ENCAP_NETTL_FDDI:
-			/* account for pad bytes */
-			rec_hdr.caplen = g_htonl(phdr->caplen + 3);
-			rec_hdr.length = g_htonl(phdr->len + 3);
+        rec_hdr.hdr_len = g_htons(sizeof(rec_hdr) + 4);
+        rec_hdr.kind = g_htonl(NETTL_HDR_PDUIN);
+        rec_hdr.sec = g_htonl(phdr->ts.secs);
+        rec_hdr.usec = g_htonl(phdr->ts.nsecs/1000);
+        rec_hdr.caplen = g_htonl(phdr->caplen);
+        rec_hdr.length = g_htonl(phdr->len);
+        rec_hdr.devid = -1;
+        rec_hdr.pid = -1;
+        rec_hdr.uid = -1;
+
+        switch (phdr->pkt_encap) {
+
+                case WTAP_ENCAP_NETTL_FDDI:
+                        /* account for pad bytes */
+                        rec_hdr.caplen = g_htonl(phdr->caplen + 3);
+                        rec_hdr.length = g_htonl(phdr->len + 3);
                         /* fall through and fill the rest of the fields */
-		case WTAP_ENCAP_NETTL_ETHERNET:
-		case WTAP_ENCAP_NETTL_TOKEN_RING:
-		case WTAP_ENCAP_NETTL_RAW_IP:
-		case WTAP_ENCAP_NETTL_RAW_ICMP:
-		case WTAP_ENCAP_NETTL_RAW_ICMPV6:
-		case WTAP_ENCAP_NETTL_RAW_TELNET:
-		case WTAP_ENCAP_NETTL_UNKNOWN:
-			rec_hdr.subsys = g_htons(pseudo_header->nettl.subsys);
-			rec_hdr.devid = g_htonl(pseudo_header->nettl.devid);
-			rec_hdr.kind = g_htonl(pseudo_header->nettl.kind);
-			rec_hdr.pid = g_htonl(pseudo_header->nettl.pid);
-			rec_hdr.uid = g_htons(pseudo_header->nettl.uid);
-			break;
-
-		case WTAP_ENCAP_RAW_IP:
-			rec_hdr.subsys = g_htons(NETTL_SUBSYS_NS_LS_IP);
-			break;
-
-		case WTAP_ENCAP_ETHERNET:
-			rec_hdr.subsys = g_htons(NETTL_SUBSYS_BTLAN);
-			break;
-
-		case WTAP_ENCAP_FDDI_BITSWAPPED:
-			rec_hdr.subsys = g_htons(NETTL_SUBSYS_PCI_FDDI);
-			/* account for pad bytes */
-			rec_hdr.caplen = g_htonl(phdr->caplen + 3);
-			rec_hdr.length = g_htonl(phdr->len + 3);
-			break;
-
-		case WTAP_ENCAP_TOKEN_RING:
-			rec_hdr.subsys = g_htons(NETTL_SUBSYS_PCI_TR);
-			break;
+                case WTAP_ENCAP_NETTL_ETHERNET:
+                case WTAP_ENCAP_NETTL_TOKEN_RING:
+                case WTAP_ENCAP_NETTL_RAW_IP:
+                case WTAP_ENCAP_NETTL_RAW_ICMP:
+                case WTAP_ENCAP_NETTL_RAW_ICMPV6:
+                case WTAP_ENCAP_NETTL_RAW_TELNET:
+                case WTAP_ENCAP_NETTL_UNKNOWN:
+                        rec_hdr.subsys = g_htons(pseudo_header->nettl.subsys);
+                        rec_hdr.devid = g_htonl(pseudo_header->nettl.devid);
+                        rec_hdr.kind = g_htonl(pseudo_header->nettl.kind);
+                        rec_hdr.pid = g_htonl(pseudo_header->nettl.pid);
+                        rec_hdr.uid = g_htons(pseudo_header->nettl.uid);
+                        break;
+
+                case WTAP_ENCAP_RAW_IP:
+                        rec_hdr.subsys = g_htons(NETTL_SUBSYS_NS_LS_IP);
+                        break;
+
+                case WTAP_ENCAP_ETHERNET:
+                        rec_hdr.subsys = g_htons(NETTL_SUBSYS_BTLAN);
+                        break;
+
+                case WTAP_ENCAP_FDDI_BITSWAPPED:
+                        rec_hdr.subsys = g_htons(NETTL_SUBSYS_PCI_FDDI);
+                        /* account for pad bytes */
+                        rec_hdr.caplen = g_htonl(phdr->caplen + 3);
+                        rec_hdr.length = g_htonl(phdr->len + 3);
+                        break;
+
+                case WTAP_ENCAP_TOKEN_RING:
+                        rec_hdr.subsys = g_htons(NETTL_SUBSYS_PCI_TR);
+                        break;
 #if 0
-		case WTAP_ENCAP_NETTL_X25:
-			rec_hdr.caplen = g_htonl(phdr->caplen + 24);
-			rec_hdr.length = g_htonl(phdr->len + 24);
-			rec_hdr.subsys = g_htons(pseudo_header->nettl.subsys);
-			rec_hdr.devid = g_htonl(pseudo_header->nettl.devid);
-			rec_hdr.kind = g_htonl(pseudo_header->nettl.kind);
-			rec_hdr.pid = g_htonl(pseudo_header->nettl.pid);
-			rec_hdr.uid = g_htons(pseudo_header->nettl.uid);
-			break;
+                case WTAP_ENCAP_NETTL_X25:
+                        rec_hdr.caplen = g_htonl(phdr->caplen + 24);
+                        rec_hdr.length = g_htonl(phdr->len + 24);
+                        rec_hdr.subsys = g_htons(pseudo_header->nettl.subsys);
+                        rec_hdr.devid = g_htonl(pseudo_header->nettl.devid);
+                        rec_hdr.kind = g_htonl(pseudo_header->nettl.kind);
+                        rec_hdr.pid = g_htonl(pseudo_header->nettl.pid);
+                        rec_hdr.uid = g_htons(pseudo_header->nettl.uid);
+                        break;
 #endif
-		default:
-			/* found one we don't support */
-			*err = WTAP_ERR_UNSUPPORTED_ENCAP;
-			return FALSE;
-	}
-
-	if (!wtap_dump_file_write(wdh, &rec_hdr, sizeof(rec_hdr), err))
-		return FALSE;
-	wdh->bytes_dumped += sizeof(rec_hdr);
-
-	/* Write out 4 extra bytes of unknown stuff for HP-UX11
-	 * header format.
-	 */
-	memset(dummyc, 0, sizeof dummyc);
-	if (!wtap_dump_file_write(wdh, dummyc, 4, err))
-		return FALSE;
-	wdh->bytes_dumped += 4;
-
-	if ((phdr->pkt_encap == WTAP_ENCAP_FDDI_BITSWAPPED) ||
-	    (phdr->pkt_encap == WTAP_ENCAP_NETTL_FDDI)) {
-		/* add those weird 3 bytes of padding */
-		if (!wtap_dump_file_write(wdh, dummyc, 3, err))
-			return FALSE;
-        	wdh->bytes_dumped += 3;
-	}
+                default:
+                        /* found one we don't support */
+                        *err = WTAP_ERR_UNSUPPORTED_ENCAP;
+                        return FALSE;
+        }
+
+        if (!wtap_dump_file_write(wdh, &rec_hdr, sizeof(rec_hdr), err))
+                return FALSE;
+        wdh->bytes_dumped += sizeof(rec_hdr);
+
+        /* Write out 4 extra bytes of unknown stuff for HP-UX11
+         * header format.
+         */
+        memset(dummyc, 0, sizeof dummyc);
+        if (!wtap_dump_file_write(wdh, dummyc, 4, err))
+                return FALSE;
+        wdh->bytes_dumped += 4;
+
+        if ((phdr->pkt_encap == WTAP_ENCAP_FDDI_BITSWAPPED) ||
+            (phdr->pkt_encap == WTAP_ENCAP_NETTL_FDDI)) {
+                /* add those weird 3 bytes of padding */
+                if (!wtap_dump_file_write(wdh, dummyc, 3, err))
+                        return FALSE;
+                wdh->bytes_dumped += 3;
+        }
 /*
-	} else if (phdr->pkt_encap == WTAP_ENCAP_NETTL_X25) {
-		if (!wtap_dump_file_write(wdh, dummyc, 24, err))
-			return FALSE;
-		wdh->bytes_dumped += 24;
-	}
+        } else if (phdr->pkt_encap == WTAP_ENCAP_NETTL_X25) {
+                if (!wtap_dump_file_write(wdh, dummyc, 24, err))
+                        return FALSE;
+                wdh->bytes_dumped += 24;
+        }
 */
 
-	/* write actual PDU data */
+        /* write actual PDU data */
 
-	if (!wtap_dump_file_write(wdh, pd, phdr->caplen, err))
-		return FALSE;
+        if (!wtap_dump_file_write(wdh, pd, phdr->caplen, err))
+                return FALSE;
         wdh->bytes_dumped += phdr->caplen;
 
-	return TRUE;
+        return TRUE;
 }