Modifying the value DELETED_SEQUENCES_OFF in the script from 0 to 1 as per bug/error...
[pingpong.git] / Code / Projects / PacketLevelSignatureExtractor / src / main / java / edu / uci / iotproject / trafficreassembly / layer3 / FinAckPair.java
1 package edu.uci.iotproject.trafficreassembly.layer3;
2
3 import org.pcap4j.core.PcapPacket;
4 import org.pcap4j.packet.IpV4Packet;
5 import org.pcap4j.packet.TcpPacket;
6
7 /**
8  * Groups a FIN packet and its corresponding ACK packet. <b>Immutable and thread safe</b>.
9  *
10  * @author Janus Varmarken {@literal <jvarmark@uci.edu>}
11  * @author Rahmadi Trimananda {@literal <rtrimana@uci.edu>}
12  */
13 public class FinAckPair {
14
15     private final PcapPacket mFinPacket;
16     private final PcapPacket mCorrespondingAckPacket;
17
18     /**
19      * Constructs a {@code FinAckPair} given a FIN packet.
20      * The corresponding ACK packet field is set to {@code null}.
21      * @param finPacket A FIN packet.
22      */
23     public FinAckPair(PcapPacket finPacket) {
24         if (!finPacket.get(TcpPacket.class).getHeader().getFin()) {
25             throw new IllegalArgumentException("not a FIN packet");
26         }
27         mFinPacket = finPacket;
28         mCorrespondingAckPacket = null;
29     }
30
31     /**
32      * Constructs a {@code FinAckPair} given a FIN and an ACK packet.
33      * @param finPacket A FIN packet.
34      * @param correspondingAckPacket The ACK packet corresponding to {@code finPacket}.
35      */
36     public FinAckPair(PcapPacket finPacket, PcapPacket correspondingAckPacket) {
37         // Enforce class invariant, i.e. that the FIN and ACK are related.
38         // Note that it is indirectly checked whether finPacket is indeed a FIN packet
39         // as isCorrespondingAckPacket calls the single parameter constructor.
40         if (!FinAckPair.isCorrespondingAckPacket(finPacket, correspondingAckPacket)) {
41             throw new IllegalArgumentException("FIN and ACK not related");
42         }
43         mFinPacket = finPacket;
44         mCorrespondingAckPacket = correspondingAckPacket;
45     }
46
47     /**
48      * Get the FIN packet of this pair.
49      * @return the FIN packet of this pair.
50      */
51     public PcapPacket getFinPacket() {
52         return mFinPacket;
53     }
54
55     /**
56      * Get the corresponding ACK packet of this pair, if any.
57      * @return the corresponding ACK packet of this pair, if any.
58      */
59     public PcapPacket getCorrespondingAckPacket() {
60         return mCorrespondingAckPacket;
61     }
62
63     /**
64      * Was the FIN in this {@code FinAckPair} acknowledged?
65      *
66      * @return {@code true} if the corresponding ACK has been set in this {@code FinAckPair}.
67      */
68     public boolean isAcknowledged() {
69         return mFinPacket != null && mCorrespondingAckPacket != null;
70     }
71
72     /**
73      * Checks if a given packet is an ACK corresponding to the FIN packet in this {@code FinAckPair}.
74      * @return {@code true} if {@code packet} is an ACK that corresponds to the FIN in this pair, {@code false} otherwise.
75      */
76     public boolean isCorrespondingAckPacket(PcapPacket packet) {
77         IpV4Packet inputIpPacket = packet.get(IpV4Packet.class);
78         TcpPacket inputTcpPacket = packet.get(TcpPacket.class);
79         if (inputIpPacket == null || inputTcpPacket == null || !inputTcpPacket.getHeader().getAck()) {
80             return false;
81         }
82
83         IpV4Packet finIpPacket = mFinPacket.get(IpV4Packet.class);
84         TcpPacket finTcpPacket = mFinPacket.get(TcpPacket.class);
85
86         // Extract (srcIp:port,dstIp:port) for input and member (FIN) packets.
87         String inputPacketIpSrc = inputIpPacket.getHeader().getSrcAddr().getHostAddress();
88         String inputPacketIpDst = inputIpPacket.getHeader().getDstAddr().getHostAddress();
89         int inputPacketPortSrc = inputTcpPacket.getHeader().getSrcPort().valueAsInt();
90         int inputPacketPortDst = inputTcpPacket.getHeader().getDstPort().valueAsInt();
91         String finPacketIpSrc = finIpPacket.getHeader().getSrcAddr().getHostAddress();
92         String finPacketIpDst = finIpPacket.getHeader().getDstAddr().getHostAddress();
93         int finPacketPortSrc = finTcpPacket.getHeader().getSrcPort().valueAsInt();
94         int finPacketPortDst = finTcpPacket.getHeader().getDstPort().valueAsInt();
95
96         // For the two packets to be related, the dst of one must be the src of the other.
97         // Split into multiple if statements for readability. First check IP fields, then ports.
98         if (!(inputPacketIpDst.equals(finPacketIpSrc) && finPacketIpDst.equals(inputPacketIpSrc))) {
99             return false;
100         }
101         if (!(inputPacketPortDst == finPacketPortSrc && finPacketPortDst == inputPacketPortSrc)) {
102             return false;
103         }
104
105         // Packets are (most likely) related (part of same conversation/stream).
106         // Now all that is left for us to check is if the sequence numbers match.
107         // Note: recall that the FIN packet advances the seq numbers by 1,
108         // so the ACK number will be one larger than the seq. number in the FIN packet.
109         return inputTcpPacket.getHeader().getAcknowledgmentNumber() == finTcpPacket.getHeader().getSequenceNumber() + 1;
110     }
111
112     /**
113      * Static method to check if two given packets are a FIN and the corresponding ACK packet.
114      * The purpose of this method is a workaround to enforce the class invariant in the two parameter constructor.
115      * Specifically, the following should be avoided:
116      * <pre>
117      *     public FinAckPair(PcapPacket finPacket, PcapPacket correspondingAckPacket) {
118      *         mFinPacket = finPacket;
119      *         // Below line is considered bad practice as the object has not been fully initialized at this stage.
120      *         if (!this.isCorrespondingAckPacket(correspondingAckPacket)) {
121      *             // ... throw exception
122      *         }
123      *     }
124      * </pre>
125      * @param finPacket The FIN packet.
126      * @param ackPacket The ACK packet that is to be checked if it corresponds to the given FIN packet.
127      * @return {@code true} if the ACK corresponds to the FIN, {@code false} otherwise.
128      */
129     private static boolean isCorrespondingAckPacket(PcapPacket finPacket, PcapPacket ackPacket) {
130         FinAckPair tmp = new FinAckPair(finPacket);
131         return tmp.isCorrespondingAckPacket(ackPacket);
132     }
133
134 }