Subversion Repositories programming

Rev

Rev 216 | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 216 Rev 218
Line 3... Line 3...
3 
 * Author: Ira W. Snyder (devel@irasnyder.com)
 3 
 * Author: Ira W. Snyder (devel@irasnyder.com)
4 
 * License: GNU General Public License v2
 4 
 * License: GNU General Public License v2
5 
 * Class: CS380 - Computer Networking
 5 
 * Class: CS380 - Computer Networking
6 
 *
 6 
 *
7 
 * Assignment: Project #2
 7 
 * Assignment: Project #2
8 
 * Date Last Modified: 2006-02-05
 8 
 * Date Last Modified: 2006-02-08
9 
 *
 9 
 *
10 
 * Purpose: Implement a simple server which will listen on UDP port 1337 for
 10 
 * Purpose: Implement a simple server which will listen on UDP port 1337 for
11 
 * incoming datagrams. It will first recieve a message telling it to drop
 11 
 * incoming datagrams. It will first recieve a message telling it to drop
12 
 * every n-th message. After that it will convert every message it recieves
 12 
 * every n-th message. After that it will convert every message it recieves
13 
 * from 4B to 5B encoding, and reply back to the client. It will only exit on
 13 
 * from 4B to 5B encoding, and reply back to the client. It will only exit on
Line 35... Line 35...
35 
    public static P2_Packet readPacket ()
 35 
    public static P2_Packet readPacket ()
36 
    {
 36 
    {
37 
        byte[] buf = new byte[256];
 37 
        byte[] buf = new byte[256];
38 
        packet = new DatagramPacket (buf, buf.length);
 38 
        packet = new DatagramPacket (buf, buf.length);
39 
 
 39 
 
- 
 
 40 
        // Try to recieve data from the client. Catch any
- 
 
 41 
        // exceptions that may occur.
40 
        try {
 42 
        try {
41 
            socket.receive (packet);
 43 
            socket.receive (packet);
42 
        } catch (IllegalArgumentException e) {
 44 
        } catch (IllegalArgumentException e) {
43 
            System.err.println ("Caught exception in readPacket()");
 45 
            System.err.println ("Caught exception in readPacket()");
44 
            e.printStackTrace ();
 46 
            e.printStackTrace ();
Line 46... Line 48...
46 
            System.err.println ("Caught exception in readPacket()");
 48 
            System.err.println ("Caught exception in readPacket()");
47 
            e.printStackTrace ();
 49 
            e.printStackTrace ();
48 
            return null;
 50 
            return null;
49 
        }
 51 
        }
50 
 
 52 
 
- 
 
 53 
        // Convert the packet, and print a status message.
51 
        return new P2_Packet (packet.getData());
 54 
        P2_Packet ret = new P2_Packet (packet.getData());
- 
 
 55 
        System.out.printf ("Recieved a packet: %d bytes -- packetNum: %d\n",
- 
 
 56 
                ret.getPacketDataSize(), ret.getPacketNumber());
- 
 
 57 
 
- 
 
 58 
        return ret;
52 
    }
 59 
    }
53 
 
 60 
 
54 
    /**
 61 
    /**
55 
     * Method: writePacket()
 62 
     * Method: writePacket()
56 
     * Purpose: write a message to the last client that sent us a message,
 63 
     * Purpose: Write a message to the last client that sent us a message.
57 
     * while dropping every n-th message, as specified by the client.
 - 
 
58 
     */
 64 
     */
59 
    public static boolean writePacket (byte type, byte[] data)
 65 
    public static boolean writePacket (byte type, byte[] data)
60 
    {
 66 
    {
- 
 
 67 
        // Get the address and port of the last message sent to us.
61 
        InetAddress address = packet.getAddress();
 68 
        InetAddress address = packet.getAddress();
62 
        int port = packet.getPort();
 69 
        int port = packet.getPort();
63 
 
 70 
 
- 
 
 71 
        // Set up our packet
64 
        byte[] buf = P2_Packet.createPacket (type, data);
 72 
        byte[] buf = P2_Packet.createPacket (type, data);
65 
        packet = new DatagramPacket (buf, buf.length, address, port);
 73 
        packet = new DatagramPacket (buf, buf.length, address, port);
66 
 
 74 
 
- 
 
 75 
        // Attempt to send the packet
67 
        try {
 76 
        try {
68 
            socket.send (packet);
 77 
            socket.send (packet);
69 
        } catch (IOException e) {
 78 
        } catch (IOException e) {
70 
            System.out.println ("Caught exception in writePacket()");
 79 
            System.out.println ("Caught exception in writePacket()");
71 
            e.printStackTrace();
 80 
            e.printStackTrace();
72 
            return false;
 81 
            return false;
73 
        }
 82 
        }
74 
 
 83 
 
- 
 
 84 
        // It got sent ok
75 
        return true;
 85 
        return true;
76 
    }
 86 
    }
77 
 
 87 
 
- 
 
 88 
    /**
- 
 
 89 
     * Method: writePacket()
- 
 
 90 
     * Purpose: A simplified version of writePacket() above.
- 
 
 91 
     */
78 
    public static boolean writePacket (byte type)
 92 
    public static boolean writePacket (byte type)
79 
    {
 93 
    {
80 
        byte[] pData = { 0 };
 94 
        byte[] pData = { 0 };
81 
        return writePacket (type, pData);
 95 
        return writePacket (type, pData);
82 
    }
 96 
    }
83 
 
 97 
 
84 
    /**
 98 
    /**
85 
     * Method: calcDrops()
 99 
     * Method: calcDropNum()
86 
     * Purpose: Parse a message sent by the client telling us to drop
 100 
     * Purpose: Parse a message sent by the client telling us to drop
87 
     * every n-th message.
 101 
     * every n-th message.
88 
     */
 102 
     */
89 
    public static int calcDrops (P2_Packet p)
 103 
    public static int calcDropNum (P2_Packet p)
90 
    {
 104 
    {
91 
        if (p.getPacketType() != P2_Packet.DROP)
 105 
        if (p.getPacketType() != P2_Packet.DROP)
92 
            throw new IllegalArgumentException(); // major problem
 106 
            throw new IllegalArgumentException(); // major problem
93 
 
 107 
 
- 
 
 108 
        // The byte informing us how often to drop packets is in
- 
 
 109 
        // the first byte only.
94 
        byte[] num = p.getPacketData();
 110 
        byte[] num = p.getPacketData();
95 
        return (int)num[0];
 111 
        return (int)num[0];
96 
    }
 112 
    }
97 
 
 113 
 
98 
    /**
 114 
    /**
Line 111... Line 127...
111 
 
 127 
 
112 
        // Try to get a "timeout info" packet
 128 
        // Try to get a "timeout info" packet
113 
        while (!done)
 129 
        while (!done)
114 
        {
 130 
        {
115 
            decodedPacket = readPacket ();
 131 
            decodedPacket = readPacket ();
116 
            dropEvery = calcDrops(decodedPacket);
 132 
            dropEvery = calcDropNum (decodedPacket);
117 
 
 133 
 
118 
            if (dropEvery != -1)
 134 
            if (dropEvery != -1)
119 
            {
 135 
            {
120 
                done = true;
 136 
                done = true;
121 
                System.out.println ("dropEvery: " + dropEvery);
 137 
                System.out.println ("dropEvery: " + dropEvery);
Line 127... Line 143...
127 
        done = false;
 143 
        done = false;
128 
 
 144 
 
129 
        // Keep reading until we get a quit packet
 145 
        // Keep reading until we get a quit packet
130 
        while (!done)
 146 
        while (!done)
131 
        {
 147 
        {
132 
 
 - 
 
133 
            decodedPacket = readPacket ();
 148 
            decodedPacket = readPacket ();
134 
 
 149 
 
- 
 
 150 
            // Drop a packet if it is the correct time to do so
135 
            if ((decodedPacket.getPacketNumber() == dropEvery) && !droppedLast)
 151 
            if ((decodedPacket.getPacketNumber() == dropEvery) && !droppedLast)
136 
            {
 152 
            {
- 
 
 153 
                System.out.println ("Purposely dropped a packet");
137 
                droppedLast = true;
 154 
                droppedLast = true;
138 
                continue;
 155 
                continue;
139 
            }
 156 
            }
140 
 
 157 
 
141 
            droppedLast = false;
 158 
            droppedLast = false;
142 
 
 159 
 
- 
 
 160 
            // Figure out what type of packet to send in reply
143 
            switch (decodedPacket.getPacketType())
 161 
            switch (decodedPacket.getPacketType())
144 
            {
 162 
            {
145 
                case P2_Packet.TRANSREQ:
 163 
                case P2_Packet.TRANSREQ:
146 
                    try {
 164 
                    try {
147 
                        pData = P2_EncDec.convert4B (decodedPacket.getPacketData());
 165 
                        pData = P2_EncDec.convert4B (decodedPacket.getPacketData());
Line 159... Line 177...
159 
                    System.err.println ("Got a packetType that I was not "
 177 
                    System.err.println ("Got a packetType that I was not "
160 
                                      + "expecting here.");
 178 
                                      + "expecting here.");
161 
                    writePacket (P2_Packet.BADPACKET);
 179 
                    writePacket (P2_Packet.BADPACKET);
162 
                    break;
 180 
                    break;
163 
            }
 181 
            }
164
- 
 
165 
        }
 182 
        }
166 
 
 183 
 
167 
        // Close the socket
 184 
        // Close the socket
168 
        socket.close();
 185 
        socket.close();
169 
    }
 186 
    }