Changeset 555 for Tests


Ignore:
Timestamp:
07/12/12 20:36:23 (10 years ago)
Author:
BegemoT
Message:
 
Location:
Tests/JAVA/test/src/main/java/test/ivan
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • Tests/JAVA/test/src/main/java/test/ivan/FileParser.java

    r547 r555  
    22 
    33import java.io.*; 
    4 import java.util.Arrays; 
     4import java.util.*; 
    55 
    66import com.google.common.base.Function; 
     7import static com.google.common.base.Preconditions.checkState; 
    78import com.google.common.primitives.Ints; 
    89import org.apache.commons.logging.Log; 
    910import org.apache.commons.logging.LogFactory; 
    1011import test.ivan.PacketEntry.PacketKind; 
    11  
    12 import static com.google.common.base.Preconditions.checkState; 
    1312 
    1413/** 
     
    1918 */ 
    2019public class FileParser { 
    21     private static final Log log = LogFactory.getLog( FileParser.class ); 
    22     protected static final int HASH_LENGTH = 16; 
    23     protected static final long MAGIC_NUMBER = 0xa1b2c3d4L; 
     20        private static final Log log = LogFactory.getLog( FileParser.class ); 
     21        protected static final int HASH_LENGTH = 16; 
     22        protected static final long MAGIC_NUMBER = 0xa1b2c3d4L; 
    2423 
    2524 
    26     public static long forEachEntry( final InputStream is, 
    27                                      final Function<PacketEntry, Boolean> processor ) throws IOException { 
    28         final DataInputStream dis = new DataInputStream( is ); 
    29         try { 
    30             //read pcap-file header (24 bytes) 
     25        public static long forEachEntry( final InputStream is, 
     26                                         final Function<PacketEntry, Boolean> processor ) throws IOException { 
     27                final DataInputStream dis = new DataInputStream( is ); 
     28                try { 
     29                        //read pcap-file header (24 bytes) 
    3130 
    32             //guint32 magic_number;   /* magic number */ 
    33             //guint16 version_major;  /* major version number */ 
    34             //guint16 version_minor;  /* minor version number */ 
    35             //gint32  thiszone;       /* GMT to local correction */ 
    36             //guint32 sigfigs;        /* accuracy of timestamps */ 
    37             //guint32 snaplen;        /* max length of captured packets, in octets */ 
    38             //guint32 network;        /* data link type */ 
     31                        //guint32 magic_number;   /* magic number */ 
     32                        //guint16 version_major;  /* major version number */ 
     33                        //guint16 version_minor;  /* minor version number */ 
     34                        //gint32  thiszone;       /* GMT to local correction */ 
     35                        //guint32 sigfigs;        /* accuracy of timestamps */ 
     36                        //guint32 snaplen;        /* max length of captured packets, in octets */ 
     37                        //guint32 network;        /* data link type */ 
    3938 
    40             final long magicNumber = readUnsignedInt( dis ); 
    41             checkState( 
    42                     magicNumber == MAGIC_NUMBER, 
    43                     "magicNumber(%s) must be %s", magicNumber, MAGIC_NUMBER 
    44             ); 
     39                        final long magicNumber = readUnsignedInt( dis ); 
     40                        checkState( 
     41                                        magicNumber == MAGIC_NUMBER, 
     42                                        "magicNumber(%s) must be %s", magicNumber, MAGIC_NUMBER 
     43                        ); 
    4544 
    46             final int version = dis.readInt(); 
    47             final int timeZoneCorrection = dis.readInt(); 
    48             final int timestampAccuracy = dis.readInt(); 
    49             final int maxPacketLength = Ints.checkedCast( readUnsignedInt( dis ) ); 
    50             final int dataLinkType = dis.readInt(); 
     45                        final int version = dis.readInt(); 
     46                        final int timeZoneCorrection = dis.readInt(); 
     47                        final int timestampAccuracy = dis.readInt(); 
     48                        final int maxPacketLength = Ints.checkedCast( readUnsignedInt( dis ) ); 
     49                        final int dataLinkType = dis.readInt(); 
    5150 
    52             final byte[] buffer = new byte[maxPacketLength]; 
    53             long entriesRead = 0; 
    54             //can't use .available() > 0 'cos of http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6631046 
    55             while ( dis.available() != 0 ) { 
    56                 final PacketEntry entry = readEntry( dis, buffer ); 
    57                 if ( entry != null ) { 
    58                     if ( log.isDebugEnabled() ) { 
    59                         log.debug( entry ); 
    60                     } 
    61                     try { 
    62                         processor.apply( entry ); 
    63                     } catch ( IllegalStateException e ) { 
    64                         log.warn( "rec #" + entriesRead + " [" + entry + "]: " + e.getMessage() ); 
    65                     } catch ( IllegalArgumentException e ) { 
    66                         log.warn( "rec #" + entriesRead + " [" + entry + "]: " + e.getMessage() ); 
    67                     } catch ( Exception e ) { 
    68                         log.error( "rec #" + entriesRead + " [" + entry + "]", e ); 
    69                     } 
    70                     entriesRead++; 
    71                 } 
    72             } 
    73             return entriesRead; 
    74         } finally { 
    75             dis.close(); 
    76         } 
    77     } 
     51                        final byte[] buffer = new byte[maxPacketLength]; 
     52                        long entriesRead = 0; 
     53                        //can't use .available() > 0 'cos of http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6631046 
     54                        while( dis.available() != 0 ) { 
     55                                final PacketEntry entry = readEntry( dis, buffer ); 
     56                                if( entry != null ) { 
     57                                        if( log.isDebugEnabled() ) { 
     58                                                log.debug( entry ); 
     59                                        } 
     60                                        try { 
     61                                                processor.apply( entry ); 
     62                                        } catch( IllegalStateException e ) { 
     63                                                log.warn( "rec #" + entriesRead + " [" + entry + "]: " + e.getMessage() ); 
     64                                        } catch( IllegalArgumentException e ) { 
     65                                                log.warn( "rec #" + entriesRead + " [" + entry + "]: " + e.getMessage() ); 
     66                                        } catch( Exception e ) { 
     67                                                log.error( "rec #" + entriesRead + " [" + entry + "]", e ); 
     68                                        } 
     69                                        entriesRead++; 
     70                                } 
     71                        } 
     72                        return entriesRead; 
     73                } finally { 
     74                        dis.close(); 
     75                } 
     76        } 
    7877 
    79     private static PacketEntry readEntry( final DataInputStream dis, 
    80                                           final byte[] buffer ) throws IOException { 
    81         while ( dis.available() != 0 ) { 
    82             //libpcap header structure 
    83             final long timestampSeconds = readUnsignedInt( dis ); 
    84             final long timestampMs = readUnsignedInt( dis ); 
     78        private static PacketEntry readEntry( final DataInputStream dis, 
     79                                              final byte[] buffer ) throws IOException { 
     80                while( dis.available() != 0 ) { 
     81                        //libpcap header structure 
     82                        final long timestampSeconds = readUnsignedInt( dis ); 
     83                        final long timestampUs = readUnsignedInt( dis ); 
    8584 
    8685 
    87             final long octetsCount = readUnsignedInt( dis );/* number of octets of packet saved in file */ 
    88             final long packetLength = readUnsignedInt( dis );/* actual length of packet */ 
     86                        final long octetsCount = readUnsignedInt( dis );/* number of octets of packet saved in file */ 
     87                        final long packetLength = readUnsignedInt( dis );/* actual length of packet */ 
    8988 
    9089 
    91             final long timestamp = ( 1000L * timestampSeconds ) + timestampMs; 
     90                        final long timestamp = ( 1000L * timestampSeconds ) + timestampUs / 1000; 
    9291 
    9392 
    94             final int actualBufferLength = Math.min( 
    95                     Ints.checkedCast( octetsCount ), 
    96                     Ints.checkedCast( packetLength ) 
    97             ); 
    98             checkState( 
    99                     actualBufferLength <= buffer.length, 
    100                     "packetsLength(%s) > buffer(%s)", 
    101                     packetLength, 
    102                     buffer.length 
    103             ); 
     93                        final int actualBufferLength = Math.min( 
     94                                        Ints.checkedCast( octetsCount ), 
     95                                        Ints.checkedCast( packetLength ) 
     96                        ); 
     97                        checkState( 
     98                                        actualBufferLength <= buffer.length, 
     99                                        "packetsLength(%s) > buffer(%s)", 
     100                                        packetLength, 
     101                                        buffer.length 
     102                        ); 
    104103 
    105             final int read = dis.read( buffer, 0, actualBufferLength ); 
    106             if ( read != actualBufferLength ) { 
    107                 throw new IOException( "Unexpected EOF: actualBufferLength=" + actualBufferLength + ", but only " + read + " actually read" ); 
    108             } 
     104                        final int read = dis.read( buffer, 0, actualBufferLength ); 
     105                        if( read != actualBufferLength ) { 
     106                                throw new IOException( "Unexpected EOF: actualBufferLength=" + actualBufferLength + ", but only " + read + " actually read" ); 
     107                        } 
    109108 
    110             final byte packetType = buffer[12]; 
    111             if ( packetType != 0x08 ) { 
    112                 //Это не IP пакеты, мы с ними не дружим 
    113                 continue; 
    114             } 
     109                        final byte packetType = buffer[12]; 
     110                        if( packetType != 0x08 ) { 
     111                                //Это не IP пакеты, мы с ними не дружим 
     112                                continue; 
     113                        } 
    115114 
    116             final byte packetTypeEx = buffer[43]; 
    117             final PacketKind packetKind; 
    118             switch ( packetTypeEx ) { 
    119                 case 0x08: 
    120                     packetKind = PacketKind.G711; 
    121                     break; 
    122                 case 0x12: 
    123                     packetKind = PacketKind.G729; 
    124                     break; 
    125                 default: 
    126                     packetKind = PacketKind.UNKNOWN; 
    127             } 
     115                        final byte packetTypeEx = buffer[43]; 
     116                        final PacketKind packetKind; 
     117                        switch( packetTypeEx ) { 
     118                                case 0x08: 
     119                                        packetKind = PacketKind.G711; 
     120                                        break; 
     121                                case 0x12: 
     122                                        packetKind = PacketKind.G729; 
     123                                        break; 
     124                                default: 
     125                                        packetKind = PacketKind.UNKNOWN; 
     126                        } 
    128127 
    129             if ( packetKind == PacketKind.UNKNOWN ) { 
    130                 continue; 
    131             } 
     128                        if( packetKind == PacketKind.UNKNOWN ) { 
     129                                continue; 
     130                        } 
    132131 
    133132 
    134             final byte[] hash = Arrays.copyOfRange( 
    135                     buffer, 
    136                     54, 
    137                     54 + HASH_LENGTH 
    138             ); 
     133                        final byte[] hash = Arrays.copyOfRange( 
     134                                        buffer, 
     135                                        54, 
     136                                        54 + HASH_LENGTH 
     137                        ); 
    139138 
    140             return new PacketEntry( 
    141                     packetKind, 
    142                     timestamp, 
    143                     hash 
    144             ); 
    145         } 
    146         return null; 
    147     } 
     139                        return new PacketEntry( 
     140                                        packetKind, 
     141                                        timestamp, 
     142                                        hash 
     143                        ); 
     144                } 
     145                return null; 
     146        } 
    148147 
    149     private static long readUnsignedInt( final DataInputStream dis ) throws IOException { 
    150         final int b1 = dis.read(); 
    151         final int b2 = dis.read(); 
    152         final int b3 = dis.read(); 
    153         final int b4 = dis.read(); 
    154         if ( ( b1 | b2 | b3 | b4 ) < 0 ) { 
    155             throw new EOFException(); 
    156         } 
    157         final int sint = ( b4 << 24 ) + ( b3 << 16 ) + ( b2 << 8 ) + ( b1 << 0 ); 
     148        private static long readUnsignedInt( final DataInputStream dis ) throws IOException { 
     149                final int b1 = dis.read(); 
     150                final int b2 = dis.read(); 
     151                final int b3 = dis.read(); 
     152                final int b4 = dis.read(); 
     153                if( ( b1 | b2 | b3 | b4 ) < 0 ) { 
     154                        throw new EOFException(); 
     155                } 
     156                final int sint = ( b4 << 24 ) + ( b3 << 16 ) + ( b2 << 8 ) + ( b1 << 0 ); 
    158157 
    159158 
    160         return ( ( long ) sint ) & 0xFFFFFFFFL; 
    161     } 
     159                return ( ( long ) sint ) & 0xFFFFFFFFL; 
     160        } 
    162161 
    163     private static int readUnsignedShort( final DataInputStream dis ) throws IOException { 
    164         final int b1 = dis.read(); 
    165         final int b2 = dis.read(); 
    166         if ( ( b1 | b2 ) < 0 ) { 
    167             throw new EOFException(); 
    168         } 
    169         return packUnsignedShort( b1, b2 ); 
    170     } 
     162        private static int readUnsignedShort( final DataInputStream dis ) throws IOException { 
     163                final int b1 = dis.read(); 
     164                final int b2 = dis.read(); 
     165                if( ( b1 | b2 ) < 0 ) { 
     166                        throw new EOFException(); 
     167                } 
     168                return packUnsignedShort( b1, b2 ); 
     169        } 
    171170 
    172     private static int packUnsignedShort( final int b1, 
    173                                           final int b2 ) { 
    174         final int signedShort = ( b2 << 8 ) + b1; 
     171        private static int packUnsignedShort( final int b1, 
     172                                              final int b2 ) { 
     173                final int signedShort = ( b2 << 8 ) + b1; 
    175174 
    176175 
    177         return signedShort & 0xFFFF; 
    178     } 
     176                return signedShort & 0xFFFF; 
     177        } 
    179178} 
  • Tests/JAVA/test/src/main/java/test/ivan/PacketEntry.java

    r547 r555  
    11package test.ivan; 
    22 
    3 import java.util.Arrays; 
    4 import java.util.Date; 
     3import java.util.*; 
    54 
    65import net.jcip.annotations.Immutable; 
    76 
    87/** 
    9  * fixme: Class PacketEntry is for porn 
    10  * 
    118 * @author cheremin 
    129 * @since 24.04.12,  18:56 
     
    1411@Immutable 
    1512public class PacketEntry { 
    16     private final PacketKind kind; 
     13        private final PacketKind kind; 
    1714 
    1815 
    19     private final long timestamp; 
    20     private final byte[] hash; 
     16        private final long timestamp; 
     17        private final byte[] hash; 
    2118 
    22     public PacketEntry( final PacketKind kind, 
    23                         final long timestamp, 
    24                         final byte[] hash ) { 
    25         this.kind = kind; 
    26         this.timestamp = timestamp; 
    27         this.hash = hash; 
    28     } 
     19        public PacketEntry( final PacketKind kind, 
     20                            final long timestamp, 
     21                            final byte[] hash ) { 
     22                this.kind = kind; 
     23                this.timestamp = timestamp; 
     24                this.hash = hash; 
     25        } 
    2926 
    30     public PacketKind kind() { 
    31         return kind; 
    32     } 
     27        public PacketKind kind() { 
     28                return kind; 
     29        } 
    3330 
    34     public long timestamp() { 
    35         return timestamp; 
    36     } 
     31        public long timestamp() { 
     32                return timestamp; 
     33        } 
    3734 
    38     public byte[] hash() { 
    39         return hash; 
    40     } 
     35        public byte[] hash() { 
     36                return hash; 
     37        } 
    4138 
    4239 
    43     @Override 
    44     public String toString() { 
    45         return String.format( 
    46                 "%s[%s][%tD][%s]", 
    47                 getClass().getSimpleName(), 
    48                 kind(), 
    49                 new Date( timestamp() ), 
    50                 Arrays.toString( hash ) 
    51         ); 
    52     } 
     40        @Override 
     41        public String toString() { 
     42                return String.format( 
     43                                "%s[%s][%tD][%s]", 
     44                                getClass().getSimpleName(), 
     45                                kind(), 
     46                                new Date( timestamp() ), 
     47                                Arrays.toString( hash ) 
     48                ); 
     49        } 
    5350 
    54     public enum PacketKind { 
    55         UNKNOWN, 
    56         G711, 
    57         G729; 
    58     } 
     51        public enum PacketKind { 
     52                UNKNOWN, 
     53                G711, 
     54                G729; 
     55        } 
    5956 
    6057 
Note: See TracChangeset for help on using the changeset viewer.