public static void checkHeader(ByteBuffer b, int length, int psecret, short step) { int l = b.getInt(); int ps = b.getInt(); int s = b.getShort(); b.getShort(); // the student number, which I am not checking. if (l != length) { System.out.println("Packet length was " + l + " instead of " + length); } if (ps != psecret) { System.out.println("Psecret was " + ps + " instead of " + psecret); } if (s != step) { System.out.println("Packet length was " + s + " instead of " + step); } }
static byte[] extractByteArray(ByteBuffer buf) { int len = buf.getInt(); if (len > 0) { byte[] a = new byte[len]; buf.get(a, 0, len); return a; } else return new byte[0]; }
private void recv(SocketChannel sc, ClientInfo ci) throws IOException { ci.channel.read(ci.inBuf); ByteBuffer tmpBuf = ci.inBuf.duplicate(); tmpBuf.flip(); int bytesProcessed = 0; boolean doneLoop = false; while (!doneLoop) { byte b; try { b = tmpBuf.get(); } catch (BufferUnderflowException bue) { // Processed all data in buffer ci.inBuf.clear(); doneLoop = true; break; } switch (b) { case TypeServerConstants.WELCOME: bytesProcessed++; break; case TypeServerConstants.GET_STRING_REQUEST: bytesProcessed++; if (ci.outputPending) { // Client is backed up. We can't append to // the byte buffer because it's in the wrong // state. We could allocate another buffer // here and change our send method to know // about multiple buffers, but we'll just // assume that the client is dead break; } ci.outBuf.put(TypeServerConstants.GET_STRING_RESPONSE); ByteBuffer strBuf = encoder.encode(testString); ci.outBuf.putShort((short) strBuf.remaining()); ci.outBuf.put(strBuf); ci.outBuf.flip(); send(sc, ci); break; case TypeServerConstants.GET_STRING_RESPONSE: int startPos = tmpBuf.position(); try { int nBytes = tmpBuf.getInt(); byte[] buf = new byte[nBytes]; tmpBuf.get(buf); bytesProcessed += buf.length + 5; String s = new String(buf); // Send the string to the GUI break; } catch (BufferUnderflowException bue) { // Processed all available data ci.inBuf.position(ci.inBuf.position() + bytesProcessed); doneLoop = true; } break; } } }
// Takes the byte array received from the server and parses. // The server responds with a UDP packet containing 4 integers. The // integer array returned contains has those 4 integers. public static int[] partA(byte[] response) { ByteBuffer bb = ByteBuffer.wrap(response); checkHeader(bb, 16, 0, STEP2); int[] res = new int[4]; for (int i = 0; i < res.length; i++) { res[i] = bb.getInt(); } return res; }
static byte[] extractByteString(ByteBuffer buf) { int len = buf.getInt(); byte[] str = null; if (len > 0) { str = new byte[len]; buf.get(str, 0, len); buf.get(); // trailing null } else str = new byte[0]; return str; }
static String extractString(ByteBuffer buf) throws java.io.UnsupportedEncodingException { int len = buf.getInt(); byte[] str = null; if (len > 0) { str = new byte[len - 1]; ; buf.get(str, 0, len - 1); buf.get(); // trailing null } else str = new byte[0]; return new String(str, "UTF-8"); }
private synchronized DBMessage go(DBMessage msg, ByteDecoder decoder) throws IOException { if (_sock == null) _open(); { ByteBuffer out = msg.prepare(); while (out.remaining() > 0) _sock.write(out); } if (_pool != null) _pool._everWorked = true; if (decoder == null) return null; ByteBuffer response = decoder._buf; if (response.position() != 0) throw new IllegalArgumentException(); int read = 0; while (read < DBMessage.HEADER_LENGTH) read += _read(response); int len = response.getInt(0); if (len <= DBMessage.HEADER_LENGTH) throw new IllegalArgumentException("db sent invalid length: " + len); if (len > response.capacity()) throw new IllegalArgumentException( "db message size is too big (" + len + ") " + "max is (" + response.capacity() + ")"); response.limit(len); while (read < len) read += _read(response); if (read != len) throw new RuntimeException("something is wrong"); response.flip(); return new DBMessage(response); }
/** * Handles control packet. * * @param data raw packet data that arrived on control PPID. * @param sid SCTP stream id on which the data has arrived. */ private synchronized void onCtrlPacket(byte[] data, int sid) throws IOException { ByteBuffer buffer = ByteBuffer.wrap(data); int messageType = /* 1 byte unsigned integer */ 0xFF & buffer.get(); if (messageType == MSG_CHANNEL_ACK) { if (logger.isDebugEnabled()) { logger.debug(getEndpoint().getID() + " ACK received SID: " + sid); } // Open channel ACK WebRtcDataStream channel = channels.get(sid); if (channel != null) { // Ack check prevents from firing multiple notifications // if we get more than one ACKs (by mistake/bug). if (!channel.isAcknowledged()) { channel.ackReceived(); notifyChannelOpened(channel); } else { logger.warn("Redundant ACK received for SID: " + sid); } } else { logger.error("No channel exists on sid: " + sid); } } else if (messageType == MSG_OPEN_CHANNEL) { int channelType = /* 1 byte unsigned integer */ 0xFF & buffer.get(); int priority = /* 2 bytes unsigned integer */ 0xFFFF & buffer.getShort(); long reliability = /* 4 bytes unsigned integer */ 0xFFFFFFFFL & buffer.getInt(); int labelLength = /* 2 bytes unsigned integer */ 0xFFFF & buffer.getShort(); int protocolLength = /* 2 bytes unsigned integer */ 0xFFFF & buffer.getShort(); String label; String protocol; if (labelLength == 0) { label = ""; } else { byte[] labelBytes = new byte[labelLength]; buffer.get(labelBytes); label = new String(labelBytes, "UTF-8"); } if (protocolLength == 0) { protocol = ""; } else { byte[] protocolBytes = new byte[protocolLength]; buffer.get(protocolBytes); protocol = new String(protocolBytes, "UTF-8"); } if (logger.isDebugEnabled()) { logger.debug( "!!! " + getEndpoint().getID() + " data channel open request on SID: " + sid + " type: " + channelType + " prio: " + priority + " reliab: " + reliability + " label: " + label + " proto: " + protocol); } if (channels.containsKey(sid)) { logger.error("Channel on sid: " + sid + " already exists"); } WebRtcDataStream newChannel = new WebRtcDataStream(sctpSocket, sid, label, true); channels.put(sid, newChannel); sendOpenChannelAck(sid); notifyChannelOpened(newChannel); } else { logger.error("Unexpected ctrl msg type: " + messageType); } }
public static void main(String[] args) throws Exception { //////////////////// STAGE A////////////////////////////////////////// int portNum = 12235; // InetAddress ip=InetAddress.getLocalHost(); InetAddress ip = InetAddress.getByName("attu2.cs.washington.edu"); DatagramSocket sock = new DatagramSocket(); byte[] response = new byte[HEADER_SIZE + 16]; String partA = "hello world\0"; byte[] buf = createBuffer(partA.getBytes(), 0, STEP1); DatagramPacket packet = new DatagramPacket(buf, buf.length, ip, portNum); sock.send(packet); packet = new DatagramPacket(response, response.length); sock.receive(packet); int[] a2 = partA(response); // putting the 4 ints from server into int[] // for (int i = 0; i < a2.length; i++) { // System.out.println(a2[i]); // } ////////////////////// STAGE B//////////////////////////////////////// int numSent = 0; int send = a2[0]; int len = a2[1]; portNum = a2[2]; int secretA = a2[3]; System.out.println("The secrets:\nA: " + secretA); sock.setSoTimeout(500); // .5s while (numSent < send) { // create packet buf = createBuffer(partB(numSent, len), secretA, STEP1); packet = new DatagramPacket(buf, buf.length, ip, portNum); sock.send(packet); // send packet try { sock.receive(new DatagramPacket(response, response.length)); numSent++; ByteBuffer temp = ByteBuffer.wrap(response); checkHeader(temp, 4, secretA, STEP1); // System.out.println(temp.getInt()); // For debug. See if counts up by 1 } catch (SocketTimeoutException e) { // if there's a timeout, try again continue; } } response = new byte[HEADER_SIZE + 8]; // 8 bytes -- 2 integers sock.receive(new DatagramPacket(response, response.length)); ByteBuffer bb = ByteBuffer.wrap(response); // Header checkHeader(bb, 8, secretA, STEP2); // reset the port number to the one given portNum = bb.getInt(); int secretB = bb.getInt(); System.out.println("B: " + secretB); // close the UDP socket sock.close(); /////////////////////////// STAGE C/////////////////////////////////// Socket socket = new Socket(ip, portNum); InputStream in = socket.getInputStream(); OutputStream out = socket.getOutputStream(); response = new byte[HEADER_SIZE + 16]; // 4 ints given to us this time in.read(response); bb = ByteBuffer.wrap(response); // Header checkHeader(bb, 13, secretB, STEP2); // num2 len2 secretC and char c numSent = bb.getInt(); len = bb.getInt(); int secretC = bb.getInt(); System.out.println("C: " + secretC); // stage d byte c = (byte) bb.getChar(); buf = new byte[len]; Arrays.fill(buf, c); for (int i = 0; i < numSent; i++) { byte[] b = createBuffer(buf, secretC, STEP1); out.write(b); } response = new byte[12 + 4]; // one integer. secretD plus header in.read(response); bb = ByteBuffer.wrap(response); checkHeader(bb, 4, secretC, STEP2); int secretD = bb.getInt(); socket.close(); in.close(); out.close(); System.out.println("D: " + secretD); }