Subversion Repositories programming

Rev

Rev 213 | Rev 216 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 213 Rev 215
Line 30... Line 30...
30 
    /**
 30 
    /**
31 
     * Method: readPacket()
 31 
     * Method: readPacket()
32 
     * Purpose: Read a packet from the currently opened socket.
 32 
     * Purpose: Read a packet from the currently opened socket.
33 
     * Note: Blocks until it recieves data.
 33 
     * Note: Blocks until it recieves data.
34 
     */
 34 
     */
35 
    public static String readPacket (int maxlen)
 35 
    public static P2_Packet readPacket ()
36 
    {
 36 
    {
37 
        byte[] buf = new byte[maxlen];
 37 
        byte[] buf = new byte[256];
38 
        packet = new DatagramPacket (buf, buf.length);
 38 
        packet = new DatagramPacket (buf, buf.length);
39 
 
 39 
 
40 
        try {
 40 
        try {
41 
            socket.receive (packet);
 41 
            socket.receive (packet);
- 
 
 42 
        } catch (IllegalArgumentException e) {
- 
 
 43 
            System.err.println ("Caught exception in readPacket()");
- 
 
 44 
            e.printStackTrace ();
42 
        } catch (IOException e) {
 45 
        } catch (IOException e) {
43 
            System.out.println ("Caught exception in readPacket()");
 46 
            System.err.println ("Caught exception in readPacket()");
44 
            e.printStackTrace();
 47 
            e.printStackTrace ();
45 
            return null;
 48 
            return null;
46 
        }
 49 
        }
47 
 
 50 
 
48 
        System.out.println ("Recieved Packet. Len: " + packet.getLength());
 51 
        return new P2_Packet (packet.getData());
49 
 
 - 
 
50 
        String s = new String (buf, 0, packet.getLength() /*- 1*/);
 - 
 
51 
        return s;
 - 
 
52 
    }
 52 
    }
53 
 
 53 
 
54 
    /**
 54 
    /**
55 
     * Method: writePacket()
 55 
     * Method: writePacket()
56 
     * Purpose: write a message to the last client that sent us a message,
 56 
     * 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.
 57 
     * while dropping every n-th message, as specified by the client.
58 
     */
 58 
     */
59 
    public static boolean writePacket (String msg)
 59 
    public static boolean writePacket (byte type, byte[] data)
60 
    {
 60 
    {
61 
        if (sendCount == dropEvery && !msg.equals("QUIT"))
 61 
        if (sendCount >= dropEvery && type != P2_Packet.QUIT)
62 
        {
 62 
        {
63 
            System.out.println ("Dropped a packet");
 63 
            System.out.println ("Dropped a packet");
64 
            sendCount = 0; // reset the sendCount
 64 
            sendCount = 0; // reset the sendCount
65 
            return true;   // "Fake" send
 65 
            return true;   // Fake send
66 
        }
 66 
        }
67 
        else { sendCount++; }
 67 
        else { sendCount++; }
68 
 
 68 
 
69 
        InetAddress address = packet.getAddress();
 69 
        InetAddress address = packet.getAddress();
70 
        int port = packet.getPort();
 70 
        int port = packet.getPort();
71 
 
 71 
 
72 
        byte[] buf = msg.getBytes();
 72 
        byte[] buf = P2_Packet.createPacket (type, data);
73 
        packet = new DatagramPacket (buf, buf.length, address, port);
 73 
        packet = new DatagramPacket (buf, buf.length, address, port);
74 
 
 74 
 
75 
        try {
 75 
        try {
76 
            socket.send (packet);
 76 
            socket.send (packet);
77 
        } catch (IOException e) {
 77 
        } catch (IOException e) {
Line 81... Line 81...
81 
        }
 81 
        }
82 
 
 82 
 
83 
        return true;
 83 
        return true;
84 
    }
 84 
    }
85 
 
 85 
 
- 
 
 86 
    public static boolean writePacket (byte type)
- 
 
 87 
    {
- 
 
 88 
        byte[] pData = { 0 };
- 
 
 89 
        return writePacket (type, pData);
- 
 
 90 
    }
- 
 
 91 
 
86 
    /**
 92 
    /**
87 
     * Method: calcDrops()
 93 
     * Method: calcDrops()
88 
     * Purpose: Parse a message sent by the client telling us to drop
 94 
     * Purpose: Parse a message sent by the client telling us to drop
89 
     * every n-th message.
 95 
     * every n-th message.
90 
     */
 96 
     */
91 
    public static int calcDrops (String s)
 97 
    public static int calcDrops (P2_Packet p)
92 
    {
 98 
    {
93 
        String dropRegex = "^DROP(\\d*)(.*)$";
 99 
        if (p.getPacketType() != P2_Packet.DROP)
94 
        Pattern p = Pattern.compile(dropRegex);
 - 
 
95 
        Matcher m = p.matcher(s);
 - 
 
96 
 
 - 
 
97 
        if (m.matches())
 - 
 
98 
            return Integer.parseInt(m.group(1));
 100 
            throw new IllegalArgumentException(); // major problem
99 
 
 101 
 
- 
 
 102 
        byte[] num = p.getPacketData();
100 
        return -1;
 103 
        return (int)num[0];
101 
    }
 104 
    }
102 
 
 105 
 
103 
    /**
 106 
    /**
104 
     * Method: main()
 107 
     * Method: main()
105 
     * Purpose: Open a listening UDP socket, and convert a client's
 108 
     * Purpose: Open a listening UDP socket, and convert a client's
Line 109... Line 112...
109 
    {
 112 
    {
110 
        boolean done = false;
 113 
        boolean done = false;
111 
        socket = new DatagramSocket(portNumber);
 114 
        socket = new DatagramSocket(portNumber);
112 
        packet = null;
 115 
        packet = null;
113 
        String s;
 116 
        String s;
- 
 
 117 
        P2_Packet decodedPacket = null;
- 
 
 118 
        byte[] pData;
114 
 
 119 
 
115 
        // Try to get a "timeout info" packet
 120 
        // Try to get a "timeout info" packet
116 
        while (!done)
 121 
        while (!done)
117 
        {
 122 
        {
118 
            s = readPacket (8);
 123 
            decodedPacket = readPacket ();
119 
            dropEvery = calcDrops(s);
 124 
            dropEvery = calcDrops(decodedPacket);
120 
 
 125 
 
121 
            if (dropEvery != -1)
 126 
            if (dropEvery != -1)
122 
            {
 127 
            {
123 
                done = true;
 128 
                done = true;
124 
                System.out.println ("dropEvery: " + dropEvery);
 129 
                System.out.println ("dropEvery: " + dropEvery);
125 
            }
 130 
            }
126 
 
 131 
 
127 
            writePacket (s);
 132 
            writePacket (P2_Packet.DROP);
128 
        }
 133 
        }
129 
 
 134 
 
130 
        done = false;
 135 
        done = false;
131 
 
 136 
 
132 
        // Keep reading until we get a quit packet
 137 
        // Keep reading until we get a quit packet
133 
        while (!done)
 138 
        while (!done)
134 
        {
 139 
        {
135 
            s = readPacket (5);
 140 
            decodedPacket = readPacket ();
136 
 
 141 
 
137 
            // Check and see if we got a quit message
 142 
            // Check and see if we got a quit message
138 
            if (s.equals("QUIT"))
 143 
            if (decodedPacket.getPacketType() == P2_Packet.QUIT)
139 
            {
 144 
            {
140 
                done = true;
 145 
                done = true;
141 
                writePacket(s);
 146 
                writePacket(P2_Packet.QUIT);
142 
                continue;
 147 
                continue;
143 
            }
 148 
            }
144 
 
 149 
 
- 
 
 150 
            if (decodedPacket.getPacketType() == P2_Packet.TRANSREQ)
- 
 
 151 
            {
145 
            try {
 152 
                try {
146 
                s = P2_EncDec.convert4B (s);
 153 
                    pData = P2_EncDec.convert4B (decodedPacket.getPacketData());
- 
 
 154 
 
- 
 
 155 
                    writePacket (P2_Packet.TRANSREPL, pData);
147 
            } catch (IllegalArgumentException e) {
 156 
                } catch (IllegalArgumentException e) {
148 
                System.out.println ("Recieved a bad packet");
 157 
                    System.out.println ("Recieved a bad packet");
- 
 
 158 
                    writePacket (P2_Packet.BADPACKET);
149 
                s = "BADVAL";
 159 
                    continue;
- 
 
 160 
                }
150 
            }
 161 
            }
151 
 
 162 
 
152 
            writePacket (s);
 163 
            System.out.println ("Got a strange packet type for this area");
153 
        }
 164 
        }
154 
 
 165 
 
155 
        // Close the socket
 166 
        // Close the socket
156 
        socket.close();
 167 
        socket.close();
157 
    }
 168 
    }