public static void main(String[] args) throws IOException, InterruptedException { boolean running = true; // udp protocol over a socket. DatagramSocket socket = new DatagramSocket(); while (running) { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); String line = br.readLine(); String[] inputs = line.split(" "); if (inputs.length < 2) { System.out.println("Usage: username command id"); socket.close(); return; } byte[] byteArr = (inputs[0] + " " + inputs[1] + " " + inputs[2]).getBytes(); // send request byte[] buf = new byte[256]; InetAddress address = InetAddress.getByName("localhost"); DatagramPacket packet = new DatagramPacket(byteArr, byteArr.length, address, 4445); socket.send(packet); // get response packet = new DatagramPacket(buf, buf.length); socket.receive(packet); // display response String received = new String(packet.getData(), 0, packet.getLength()); System.out.println("From server: " + received); } // socket.close(); }
public void run() { try { while (running) { byte[] sendClientData = new byte[512]; byte[] sendServerData = new byte[512]; byte[] receiveClientData = new byte[512]; byte[] receiveServerData = new byte[512]; DatagramPacket receiveClientPacket = receivePacket(receiveClientData, receiveSocket); receiveClientPacket.getLength(); // find port used by client int clientPort = receiveClientPacket.getPort(); DatagramSocket hostSocket = new DatagramSocket(); sendServerData = receiveClientPacket.getData(); sendPacket(sendServerData, serverIPAddress, ServerPort, hostSocket); DatagramPacket receiveServerPacket = receivePacket(receiveServerData, hostSocket); if (receiveServerPacket.getData()[0] == 1) { running = false; } sendClientData = receiveServerPacket.getData(); sendPacket(sendClientData, clientIPAddress, clientPort, hostSocket); hostSocket.close(); } receiveSocket.close(); } catch (Exception e) { e.printStackTrace(); } }
public static void main(String args[]) { try { DatagramSocket d1 = new DatagramSocket(2071); DatagramSocket d2 = new DatagramSocket(2081); UDPSender s = new UDPSender(d1); UDPReceiver r = new UDPReceiver(d2); s.t.join(); r.t.join(); d1.close(); d2.close(); } catch (Exception e) { } }
public static void main(String args[]) { DatagramSocket aSocket = null; try { aSocket = new DatagramSocket(); String stringMsg = "0"; String prevReply = "0"; InetAddress aHost = InetAddress.getByName("localhost"); // recieve a message from the same computer int serverPort = 6789; // agreed port while (true) { stringMsg = "" + (Integer.parseInt(stringMsg) + 1); byte[] message = stringMsg.getBytes(); DatagramPacket request = new DatagramPacket(message, message.length, aHost, serverPort); System.out.printf("Producer: Sending: %s\n", stringMsg); aSocket.send(request); // send a message byte[] buffer = new byte[1000]; DatagramPacket reply = new DatagramPacket(buffer, buffer.length); aSocket.receive(reply); // wait for a reply try { Thread.sleep(2000); // have a small waiting period } catch (InterruptedException e) { } } } catch (SocketException e) { System.out.println("Socket: " + e.getMessage()); } catch (IOException e) { System.out.println("IO: " + e.getMessage()); } finally { if (aSocket != null) aSocket.close(); } }
/** * Tries to obtain a mapped/public address for the specified port (possibly by executing a STUN * query). * * @param dst the destination that we'd like to use this address with. * @param port the port whose mapping we are interested in. * @return a public address corresponding to the specified port or null if all attempts to * retrieve such an address have failed. * @throws IOException if an error occurs while stun4j is using sockets. * @throws BindException if the port is already in use. */ public InetSocketAddress getPublicAddressFor(InetAddress dst, int port) throws IOException, BindException { if (!useStun || (dst instanceof Inet6Address)) { logger.debug( "Stun is disabled for destination " + dst + ", skipping mapped address recovery (useStun=" + useStun + ", IPv6@=" + (dst instanceof Inet6Address) + ")."); // we'll still try to bind though so that we could notify the caller // if the port has been taken already. DatagramSocket bindTestSocket = new DatagramSocket(port); bindTestSocket.close(); // if we're here then the port was free. return new InetSocketAddress(getLocalHost(dst), port); } StunAddress mappedAddress = queryStunServer(port); InetSocketAddress result = null; if (mappedAddress != null) result = mappedAddress.getSocketAddress(); else { // Apparently STUN failed. Let's try to temporarily disble it // and use algorithms in getLocalHost(). ... We should probably // eveng think about completely disabling stun, and not only // temporarily. // Bug report - John J. Barton - IBM InetAddress localHost = getLocalHost(dst); result = new InetSocketAddress(localHost, port); } if (logger.isDebugEnabled()) logger.debug("Returning mapping for port:" + port + " as follows: " + result); return result; }
public static void main(String args[]) throws Exception { // Making a text file String filename = "C:\\Users\\S.S. Mehta\\Desktop\\Codes\\ComputerNetworks\\CN_project\\CN_project\\test3.txt"; makeTextFile(filename); // Reading the file and puttin it in buffer BufferedReader in = new BufferedReader(new FileReader(filename)); char[] c1 = new char[PACKET_SIZE]; c1 = readData(in); displayPacket(c1); // Step3 - making a socket , makeing a packet with inet address and sending it byte[] buffer = new byte[PACKET_SIZE]; DatagramSocket skt = new DatagramSocket(PORT_NUMBER); DatagramPacket request = new DatagramPacket(buffer, buffer.length); // stop till you receive wait(skt, request); System.out.println("On server side \nrequest received from Slient"); // making a packet with an inet address - InetAddress host = InetAddress.getByName("localhost"); DatagramPacket reply = makePacket(c1, host); // Sending reply packet System.out.println("Sending reply packet to client"); Thread.sleep(5000); skt.send(reply); // closing the socket skt.close(); }
public void run() { while (moreQuotes) { try { byte[] buf = new byte[256]; // receive request DatagramPacket packet = new DatagramPacket(buf, buf.length); socket.receive(packet); // containing IP ecc. // figure out response String dString = null; if (in == null) dString = new Date().toString(); else dString = getNextQuote(); buf = dString.getBytes(); // send the response to the client at "address" and "port" InetAddress address = packet.getAddress(); int port = packet.getPort(); packet = new DatagramPacket(buf, buf.length, address, port); socket.send(packet); } catch (IOException e) { e.printStackTrace(); moreQuotes = false; } } socket.close(); }
public void destory() { procMsgThd.stop0(); procMsgThd.interrupt(); mainThread.interrupt(); if (group != null) { try { if (recvSocket instanceof MulticastSocket) { ((MulticastSocket) recvSocket).leaveGroup(group); } } catch (IOException ioe) { } } sendSocket.close(); recvSocket.close(); }
public static void main(String args[]) throws Exception { String serverHostname = args[0]; int portNumber = Integer.parseInt(args[1]); try { BufferedReader inFromUser = new BufferedReader(new InputStreamReader(System.in)); DatagramSocket clientSocket = new DatagramSocket(); InetAddress IPAddress = InetAddress.getByName(serverHostname); System.out.println("Attempting to connect to " + IPAddress + ") via UDP port " + portNumber); System.out.println("Enter \"Quit\" to exit program"); while (true) { byte[] sendData = new byte[1024]; byte[] receiveData = new byte[1024]; System.out.print("Enter Message: "); String sentence = inFromUser.readLine(); if (sentence.equals("Quit")) break; sendData = sentence.getBytes(); System.out.println("Sending data to " + sendData.length + " bytes to server."); DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, IPAddress, portNumber); clientSocket.send(sendPacket); DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length); System.out.println("Waiting for return packet"); clientSocket.setSoTimeout(10000); try { clientSocket.receive(receivePacket); String modifiedSentence = new String(receivePacket.getData()); InetAddress returnIPAddress = receivePacket.getAddress(); int port = receivePacket.getPort(); System.out.println("From server at: " + returnIPAddress + ":" + port); System.out.println("Message: " + modifiedSentence); } catch (SocketTimeoutException ste) { System.out.println("Timeout Occurred: Packet assumed lost"); } System.out.print("\n"); } clientSocket.close(); } catch (UnknownHostException ex) { System.err.println(ex); } catch (IOException ex) { System.err.println(ex); } }
public static void main(String args[]) throws Exception { BufferedReader inFromUser = new BufferedReader(new InputStreamReader(System.in)); DatagramSocket clientSocket = new DatagramSocket(); InetAddress IPAddress = InetAddress.getByName("192.168.1.16"); byte[] sendData = new byte[1024]; byte[] receiveData = new byte[1024]; String sentence = new String("HELLO"); sendData = sentence.getBytes(); DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, IPAddress, 9876); clientSocket.send(sendPacket); DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length); clientSocket.receive(receivePacket); sentence = new String(receivePacket.getData(), 0, receivePacket.getLength()); if (sentence.equals("##100##")) { System.out.println(sentence + ": Waiting for Red."); } while (!sentence.equals("##200##")) { try { receivePacket = new DatagramPacket(receiveData, receiveData.length); clientSocket.receive(receivePacket); sentence = new String(receivePacket.getData(), 0, receivePacket.getLength()); } catch (Exception e) { } } if (sentence.equals("##200##")) { System.out.println(sentence + ": Red and Blue are connected"); } while (true) { receiveData = new byte[1024]; receivePacket = new DatagramPacket(receiveData, receiveData.length); clientSocket.receive(receivePacket); sentence = new String(receivePacket.getData(), 0, receivePacket.getLength()); if (sentence.equals("##300##")) { break; } System.out.println("RED: " + sentence); sentence = inFromUser.readLine(); sendData = sentence.getBytes(); sendPacket = new DatagramPacket(sendData, sendData.length, IPAddress, 9876); clientSocket.send(sendPacket); } System.out.println(sentence + ": Disconnected."); clientSocket.close(); }
private void enviar(byte[] frame) { try { socket.send(new DatagramPacket(frame, frame.length, remaddr, remport)); // System.out.println("Link envió algo "); } catch (IOException e) { // throw new NodeException(NodeException.EXCEPCION_ENVIO); // System.out.println("Excepcion al enviar"); socket.close(); } }
static byte[] sendReq(byte abyte0[], int i, String s, int j) throws Exception { DatagramSocket datagramsocket = new DatagramSocket(i); try { datagramsocket.setSoTimeout(30000); datagramsocket.send(new DatagramPacket(abyte0, abyte0.length, InetAddress.getByName(s), j)); byte abyte1[] = new byte[512]; DatagramPacket datagrampacket = new DatagramPacket(abyte1, abyte1.length); datagramsocket.receive(datagrampacket); byte abyte2[] = new byte[datagrampacket.getLength()]; System.arraycopy(datagrampacket.getData(), 0, abyte2, 0, datagrampacket.getLength()); datagramsocket.close(); return abyte2; } catch (Exception exception) { try { datagramsocket.close(); } catch (Exception exception1) { } throw exception; } }
void closeSocket() { if (sock != null) { // by sending a dummy packet, the thread will terminate (if it was flagged as stopped before) sendDummyPacket(sock.getLocalAddress(), sock.getLocalPort()); sock.close(); sock = null; if (Trace.trace) { Trace.info("UDP.closeSocket()", "socket closed"); } } }
public void run() { while (listen) { try { byte[] buf = new byte[256]; byte[] buf2 = new byte[256]; DatagramPacket packet = new DatagramPacket(buf, buf.length); InetAddress address; socket.receive(packet); String in = new String(packet.getData(), 0, packet.getLength()); address = packet.getAddress(); int port = packet.getPort(); // newClient = findPort(port, address, newClient); String name = findPerson(port, address); // System.out.println(name); if (in.startsWith("1")) { String nama = new String(packet.getData(), 0, packet.getLength()); nama = nama.substring(1); newClient = new Client(packet.getAddress(), packet.getPort(), nama); threads.add(newClient); String wel = "\nWelcome " + newClient.nama + "\n " + "to quit type \"bye\" and to whisper use prefix @name : "; buf = (wel).getBytes(); packet = new DatagramPacket(buf, buf.length, packet.getAddress(), packet.getPort()); socket.send(packet); wel = " enters the room"; buf = (newClient.nama + wel).getBytes(); Broadcast(address, port, buf); } else if (in.startsWith("@")) { // findPort(port, address, newClient); Whisper(newClient, packet.getData()); } else if (in.equals("bye")) { String bye = name + " is leaving"; buf2 = bye.getBytes(); // packet = new DatagramPacket(buf,buf.length,newClient.address, newClient.port); Broadcast(address, port, buf2); } else { byte[] buf3 = new byte[256]; String text = name + "<broadcast> : " + new String(packet.getData(), 0, packet.getLength()); buf3 = text.getBytes(); Broadcast(packet.getAddress(), packet.getPort(), buf3); } } catch (IOException ex) { Logger.getLogger(DatagramServer.class.getName()).log(Level.SEVERE, null, ex); } } socket.close(); }
private void passFileDescriptor(LocalSocket fdSocket, FileDescriptor tunFD) throws Exception { OutputStream outputStream = fdSocket.getOutputStream(); InputStream inputStream = fdSocket.getInputStream(); try { BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream), 1); String request = reader.readLine(); String[] parts = request.split(","); LogUtils.i("current open tcp sockets: " + tcpSockets.size()); LogUtils.i("current open udp sockets: " + udpSockets.size()); if ("TUN".equals(parts[0])) { fdSocket.setFileDescriptorsForSend(new FileDescriptor[] {tunFD}); outputStream.write('*'); } else if ("OPEN UDP".equals(parts[0])) { String socketId = parts[1]; passUdpFileDescriptor(fdSocket, outputStream, socketId); } else if ("OPEN TCP".equals(parts[0])) { String socketId = parts[1]; String dstIp = parts[2]; int dstPort = Integer.parseInt(parts[3]); int connectTimeout = Integer.parseInt(parts[4]); passTcpFileDescriptor(fdSocket, outputStream, socketId, dstIp, dstPort, connectTimeout); } else if ("CLOSE UDP".equals(parts[0])) { String socketId = parts[1]; DatagramSocket sock = udpSockets.get(socketId); if (sock != null) { udpSockets.remove(socketId); sock.close(); } } else if ("CLOSE TCP".equals(parts[0])) { String socketId = parts[1]; Socket sock = tcpSockets.get(socketId); if (sock != null) { tcpSockets.remove(socketId); sock.close(); } } else { throw new UnsupportedOperationException("fdsock unable to handle: " + request); } } finally { try { inputStream.close(); } catch (Exception e) { LogUtils.e("failed to close input stream", e); } try { outputStream.close(); } catch (Exception e) { LogUtils.e("failed to close output stream", e); } fdSocket.close(); } }
public void run() { while (true) { try { ByteArrayOutputStream b_out = new ByteArrayOutputStream(); ObjectOutputStream o_out = new ObjectOutputStream(b_out); o_out.writeObject(new BroadcastMessage(username)); DatagramPacket packet = new DatagramPacket(b_out.toByteArray(), b_out.toByteArray().length, group, 6969); socket = new DatagramSocket(multicastPort); socket.send(packet); socket.close(); // sleep for a while try { sleep(FIVE_SECONDS); } catch (InterruptedException e) { } } catch (IOException e) { e.printStackTrace(); socket.close(); } } }
static void LoadModule(String s, int i, String s1, boolean flag) { DatagramSocket datagramsocket = null; Object obj = null; System.out.println("Loading from " + s + ":" + i); try { datagramsocket = new DatagramSocket(); datagramsocket.setSoTimeout(10000); InetAddress inetaddress = InetAddress.getByName(s); Module module = LoadModule(datagramsocket, inetaddress, i, s1, flag); if (module != null) module.write(); } catch (Exception exception) { exception.printStackTrace(); if (datagramsocket != null) try { datagramsocket.close(); } catch (Exception exception2) { } return; } try { datagramsocket.close(); } catch (Exception exception1) { } }
public static void main(String args[]) throws Exception { BufferedReader inFromUser = new BufferedReader(new InputStreamReader(System.in)); DatagramSocket clientSocket = new DatagramSocket(); InetAddress IPAddress = InetAddress.getByName("62.38.242.7"); byte[] sendData = new byte[1024]; byte[] receiveData = new byte[1024]; String sentence = inFromUser.readLine(); sendData = sentence.getBytes(); DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, IPAddress, 9310); clientSocket.send(sendPacket); DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length); clientSocket.receive(receivePacket); String modifiedSentence = new String(receivePacket.getData()); System.out.println("FROM SERVER:" + modifiedSentence); clientSocket.close(); }
void run() { try { // 1. creating a socket to connect to the server requestSocket = new DatagramSocket(); serverAddr = InetAddress.getByName(serverIpAddr); registerWithServer(); receiveInitialBoardStateAndInitializeBoard(); listenToServer(); } catch (UnknownHostException unknownHost) { System.err.println("You are trying to connect to an unknown host!"); } catch (IOException ioException) { ioException.printStackTrace(); } finally { requestSocket.close(); System.exit(0); } }
/** * Main method keeps waiting for request and do math operation accordingly * * @param args */ public static void main(String args[]) { DatagramSocket aSocket = null; try { aSocket = new DatagramSocket(6789); byte[] buffer = new byte[1000]; while (true) { DatagramPacket request = new DatagramPacket(buffer, buffer.length); aSocket.receive(request); // receive byte array of equation and put it in string String equation = new String(request.getData()); String answer = ""; String[] split = equation.split(" "); // parse to integer and calculate String op = split[1]; double var1 = Double.parseDouble(split[0]); double var2 = Double.parseDouble(split[2]); if (op.equals("+")) { answer = Double.toString(var1 + var2); } else if (op.equals("-")) { answer = Double.toString(var1 - var2); } else if (op.toLowerCase().equals("X") || op.toLowerCase().equals("x")) { answer = Double.toString(var1 * var2); } else if (op.equals("/")) { answer = Double.toString(var1 / var2); } // send answer back DatagramPacket reply = new DatagramPacket( answer.getBytes(), (answer.getBytes()).length, request.getAddress(), request.getPort()); aSocket.send(reply); } } catch (SocketException e) { System.out.println("Socket: " + e.getMessage()); } catch (IOException e) { System.out.println("IO: " + e.getMessage()); } finally { if (aSocket != null) { aSocket.close(); } } }
// sends a response to the Client based upon the contents of the receive packet private void reply(DatagramPacket receivedPacket) { // verify the packet byte serverMsg[] = {}; try { Request recReq = new Request(receivedPacket.getData(), receivedPacket.getLength()); if (!recReq.isValid()) { throw new IllegalStateException(); } switch (recReq.getFormat()) { case RRQ: serverMsg = new byte[] {0, 3, 0, 1}; break; case WRQ: serverMsg = new byte[] {0, 4, 0, 0}; break; default: throw new IllegalStateException(); } } catch (IllegalStateException e) { e.printStackTrace(); System.exit(1); } DatagramPacket sendPacket = new DatagramPacket( serverMsg, serverMsg.length, receivedPacket.getAddress(), receivedPacket.getPort()); readSendPacket(sendPacket); try { // Send the datagram packet to the client via the send socket. DatagramSocket sendSocket = new DatagramSocket(); sendSocket.send(sendPacket); sendSocket.close(); } catch (SocketException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); System.exit(1); } System.out.println("Server: packet sent.\n"); }
public static void main(String[] args) { if (args.length != 1) System.out.println("This program requires a command line argument."); else { int port = Integer.parseInt(args[0]); final int MAX_LEN = 10; // This is the assumed maximum byte length of the datagram to be received. try { DatagramSocket mySocket = new DatagramSocket(port); // instantiates a datagram socket for receiving the data byte[] buffer = new byte[MAX_LEN]; DatagramPacket datagram = new DatagramPacket(buffer, MAX_LEN); mySocket.receive(datagram); String message = new String(buffer); System.out.println(message); mySocket.close(); } // end try catch (Exception ex) { ex.printStackTrace(); } } // end else } // end main
public void run() { System.out.println(" -----------------UDP Demo Server-----------------" + "\n\n"); while (true) { try { // Create a new socket connection bound to the defined port DatagramSocket sock = new DatagramSocket(BROADCAST_PORT); System.out.println("Waiting for data on local port: " + sock.getLocalPort()); // Create a packet to contain incoming data byte[] buf = new byte[256]; DatagramPacket packet = new DatagramPacket(buf, buf.length); // Wait for incoming data (receive() is a blocking method) sock.receive(packet); // Retrieve data from packet and display String data = new String(packet.getData()); int endIndex = data.indexOf(0); data = data.substring(0, endIndex); int remotePort = packet.getPort(); System.out.println("Received data from remote port " + remotePort + ":\n" + data); // Determine origin of packet and display information InetAddress remoteAddress = packet.getAddress(); System.out.println("Sent from address: " + remoteAddress.getHostAddress()); // Send back an acknowledgment String ack = "RECEIVED " + new Date().toString(); sock.send(new DatagramPacket(ack.getBytes(), ack.length(), remoteAddress, remotePort)); sock.close(); } catch (IOException ioe) { System.out.println("Error: IOException - " + ioe.toString()); } } }
public void run() { while (true) { try { DatagramSocket ds = new DatagramSocket(local_port); while (ds.isBound()) { Thread.sleep(50); // ds = new DatagramSocket(local_port); } DatagramPacket packin = new DatagramPacket(byte_packet1, byte_packet1.length, ia, getport); ds.send(packin); ds.close(); Thread.sleep(5000); } catch (SocketException ex) { Logger.getLogger(myIP.class.getName()).log(Level.SEVERE, null, ex); // System.out.println(ex.getMessage()); } catch (IOException ex) { Logger.getLogger(myIP.class.getName()).log(Level.SEVERE, null, ex); } catch (InterruptedException ex) { Logger.getLogger(myIP.class.getName()).log(Level.SEVERE, null, ex); } } }
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); }
public static void default_fn() throws IOException { // Declaring Socket for sending and receiving data DatagramSocket skt = null; // declaring the fields to be used String client_name, movie_name, time, cost, password, reply_string; int i, j; // assigning the socket a port number skt = new DatagramSocket(6789); // defining the buffer and its size byte[] buffer = new byte[1000]; while (true) { // defining the packet to be received from client DatagramPacket request = new DatagramPacket(buffer, buffer.length); // receiving the packet skt.receive(request); // comment on the console System.out.println("Data received from client"); // Thread.sleep(5000);//for error check // converting the message to string and then splitting it into fields divided by newline // character String[] arrayMsg = (new String(request.getData())).split("\n"); client_name = arrayMsg[1]; movie_name = arrayMsg[2]; time = arrayMsg[3]; cost = "$12"; password = "******"; // Composing the reply message by appending start time,cost and password reply_string = client_name + "\n" + movie_name + "\n" + time + "\n" + cost + "\n" + password; System.out.println(reply_string); // Thread.sleep(5000); for error check // converting string message to byte byte[] sendMsg = (reply_string).getBytes(); // composing the data packet and sending it to the client's address and the same port the // client used DatagramPacket reply = new DatagramPacket(sendMsg, sendMsg.length, request.getAddress(), request.getPort()); System.out.println("sending confirmation"); // Thread.sleep(5000);//for error check // writing server log file PrintWriter writer = new PrintWriter("server_log.txt", "UTF-8"); writer.println(client_name); writer.println(movie_name); writer.println(time); writer.close(); // sending the data packet skt.send(reply); // Closing the server socket skt.close(); } }
public void stop() throws Exception { if (t == null) return; t.interrupt(); server.close(); t.join(); }
public static void main(String args[]) throws InterruptedException, IOException { int i, j; String serverInetAddress = "localhost"; String server1AddressString = "10.10.1.1"; InetAddress server1Address = InetAddress.getByName(server1AddressString); String server2AddressString = "10.10.2.2"; InetAddress server2Address = InetAddress.getByName(server2AddressString); String server3AddressString = "10.10.3.2"; InetAddress server3Address = InetAddress.getByName(server3AddressString); String server4AddressString = "localhost"; InetAddress server4Address = InetAddress.getByName(server4AddressString); DatagramSocket skt; { skt = new DatagramSocket(PORT_NUMBER_CLIENT); // socket used to listen and write InetAddress host = InetAddress.getByName(serverInetAddress); int serversocket = S1.PORT_NUMBER_SERVER; String msg = "Send file size"; byte[] b = msg.getBytes(); // dummy assignments - not used anywhere int filesize = 1; DatagramPacket reply, request; reply = new DatagramPacket(b, b.length, host, serversocket); request = new DatagramPacket(b, b.length, host, serversocket); for (i = 1; i <= 3; i++) { // defining a packet called request with parameters b(msg in bytes), b.length, host Internet // address and socket number if (i == 1) { host = server1Address; } else if (i == 2) { host = server2Address; } else if (i == 3) { host = server3Address; } request = new DatagramPacket(b, b.length, host, serversocket); // System.out.println("request sent from client to server"); Thread.sleep(S1.PAUSE_DURATION); // for error checks // Sending the packet- for getting the file size skt.send(request); // getting reply from // server........................................................................................ byte[] buffer = new byte [S1.PACKET_SIZE]; // apparently the size of data packet at the receiving side needs // to be bigger than the size of incoming datapacket reply = new DatagramPacket(buffer, buffer.length); // receiving packet from server - contatining filesize skt.receive(reply); // System.out.println("Response Received from server"); // System.out.println("on Client: - filesize= "+new String(reply.getData())); filesize = Integer.parseInt(new String(reply.getData()).trim()); // System.out.println("on Client: - filesize= "+filesize); Thread.sleep(S1.PAUSE_DURATION); } // here the client know the size of the file // Find the number of times it must make iterations - dividing filesize by packet_size // Request that many packets from server String[] buffer_string = new String[BUFFER_SIZE_CLIENT]; float delay[] = new float[filesize / S1.PACKET_SIZE]; System.out.println(filesize); System.out.println(S1.PACKET_SIZE); System.out.println(filesize / S1.PACKET_SIZE); Thread.sleep(2000); byte[] buffer = new byte[S1.PACKET_SIZE]; for (i = 0; i < filesize / S1.PACKET_SIZE; i++) { if (i % 100 != 0) { // System.out.print(" "+i); } else { System.out.println(" " + i); } msg = String.valueOf(i); b = msg.getBytes(); if (i % 3 == 0) { host = server1Address; } else if (i % 3 == 1) { host = server2Address; } else if (i % 3 == 2) { host = server3Address; } request = new DatagramPacket(b, b.length, host, serversocket); skt.send(request); delay[i] = System.nanoTime(); Thread.sleep(10); skt.receive(reply); delay[i] = System.nanoTime() - delay[i]; delay[i] = delay[i] / (1000000); /* if(empty_index<BUFFER_SIZE_CLIENT) { buffer_string[empty_index]=new String(reply.getData()); empty_index++; } else { for(j=0;j<BUFFER_SIZE_CLIENT-1;j++) { buffer_string[j]=buffer_string[j+1]; } buffer_string[BUFFER_SIZE_CLIENT-1]=new String(reply.getData()); }*/ // display_buffer(buffer_string); } Arrays.sort(delay); float delay2[] = new float[filesize / S1.PACKET_SIZE]; for (i = 0; i < delay2.length; i++) { delay2[i] = delay[delay.length - i - 1]; } // delay2 stores the array in descending values float[] Sk = new float[filesize / S1.PACKET_SIZE]; Sk[0] = (float) 0.0; for (i = 1; i < filesize / S1.PACKET_SIZE; i++) { for (j = 1; j <= i; j++) { Sk[i] = Sk[i] + delay2[j]; } Sk[i] = Sk[i] / (10 * i); } make_output(Sk); System.out.format( "Sk at 2=%f\n,10=%f\n,20=%f\n,100=%f\n and 30000=%f\n ", Sk[1], Sk[9], Sk[19], Sk[99], Sk[29999]); // display_buffer(buffer_string); skt.close(); } }
myIP(int temp_local_port) throws UnknownHostException, SocketException, IOException { try { local_port = temp_local_port; short length_message = 0; short temp_short; int temp_int; byte[] temp_byte = null; // STUN Massage Type temp_short = 0x0001; temp_byte = myFunc.ShortToByte(temp_short); data[0] = temp_byte[0]; data[1] = temp_byte[1]; // Massage Length temp_short = length_message; temp_byte = myFunc.ShortToByte(temp_short); data[2] = temp_byte[0]; data[3] = temp_byte[1]; // Magic Cookie temp_int = 0x2112A442; temp_byte = myFunc.IntToByte(temp_int); data[4] = temp_byte[0]; data[5] = temp_byte[1]; data[6] = temp_byte[2]; data[7] = temp_byte[3]; // Translation ID for (int i = 0; i < 3; i++) { temp_int = 12314 + i; temp_byte = myFunc.IntToByte(temp_int); data[8 + i * 4] = temp_byte[0]; data[9 + i * 4] = temp_byte[1]; data[10 + i * 4] = temp_byte[2]; data[11 + i * 4] = temp_byte[3]; } ia = InetAddress.getByName(STUN_host); DatagramSocket ds = new DatagramSocket(local_port); DatagramPacket pack = new DatagramPacket(data, data.length, ia, getport); for (int i = 0; i < data.length; i++) { System.out.println(data[i]); } ds.send(pack); int btlength = 64; short Res_type_message = 0, Res_length_message = 0, Res_atribute_type = 0, Res_atribute_length = 0; int Res_magic_cookie = 0; byte Res_family = 0; int Res_port = 0; int[] Res_IP = new int[4]; int[] Res_translationID = new int[3]; DatagramPacket packet = new DatagramPacket(new byte[btlength], btlength); ds.receive(packet); byte[] arr = packet.getData(); temp_byte = new byte[2]; temp_byte[0] = arr[0]; temp_byte[1] = arr[1]; Res_type_message = myFunc.ByteToShort(temp_byte); temp_byte = new byte[2]; temp_byte[0] = arr[2]; temp_byte[1] = arr[3]; Res_length_message = myFunc.ByteToShort(temp_byte); temp_byte = new byte[4]; temp_byte[0] = arr[4]; temp_byte[1] = arr[5]; temp_byte[2] = arr[6]; temp_byte[3] = arr[7]; Res_magic_cookie = myFunc.ByteToInt(temp_byte); for (int i = 0; i < 3; i++) { temp_byte = new byte[4]; temp_byte[0] = arr[8 + i * 4]; temp_byte[1] = arr[9 + i * 4]; temp_byte[2] = arr[10 + i * 4]; temp_byte[3] = arr[11 + i * 4]; Res_translationID[i] = myFunc.ByteToInt(temp_byte); } temp_byte = new byte[2]; temp_byte[0] = arr[20]; temp_byte[1] = arr[21]; Res_atribute_type = myFunc.ByteToShort(temp_byte); temp_byte = new byte[2]; temp_byte[0] = arr[22]; temp_byte[1] = arr[23]; Res_atribute_length = myFunc.ByteToShort(temp_byte); Res_family = arr[25]; // IPv4 or IPv6 temp_byte = new byte[2]; temp_byte[0] = arr[26]; temp_byte[1] = arr[27]; Res_port = myFunc.ByteToShort(temp_byte); port = Res_port; for (int i = 0; i < 4; i++) { Res_IP[i] = Byte.toUnsignedInt(arr[28 + i]); } IPv4 = Res_IP; short indic = 0x0010; temp_short = indic; temp_byte = myFunc.ShortToByte(temp_short); data[0] = temp_byte[0]; data[1] = temp_byte[1]; ds.close(); } catch (IOException e) { System.err.println(e); } }
static Module LoadModule( DatagramSocket datagramsocket, InetAddress inetaddress, int i, String s, boolean flag) { try { Module module = new Module(); module.Name = s; int j = Challenge(datagramsocket, inetaddress, i); System.out.print("Sending the get request, file '" + s); if (flag) System.out.print(" [beta] "); byte abyte0[] = Cmd_Get(s, j, flag); datagramsocket.send(new DatagramPacket(abyte0, abyte0.length, inetaddress, i)); try { Thread.sleep(50L); } catch (Exception exception2) { } System.out.print("' ..."); abyte0 = new byte[256]; DatagramPacket datagrampacket = new DatagramPacket(abyte0, abyte0.length); datagramsocket.receive(datagrampacket); System.out.println(" ok "); ReqFile reqfile = new ReqFile(abyte0); if (!((Req) (reqfile)).legal) { System.out.println("Can't download module " + s); return null; } module.Size = reqfile.Size; module.Header = reqfile.Header; module.Data = new byte[module.Size]; Module module1 = null; try { module1 = new Module(s); } catch (Exception exception3) { module1 = null; } if (module1 != null && module1.compareHeader(module)) { byte abyte1[] = Cmd_Abort(""); datagramsocket.send(new DatagramPacket(abyte1, abyte1.length, inetaddress, i)); System.out.println(s + " is already the newest version."); return null; } System.out.print("downloading data"); int k = 0; do { byte abyte2[] = Cmd_Next(k); datagramsocket.send(new DatagramPacket(abyte2, abyte2.length, inetaddress, i)); try { Thread.sleep(50L); } catch (Exception exception4) { } abyte2 = new byte[16534]; DatagramPacket datagrampacket1 = new DatagramPacket(abyte2, abyte2.length); try { datagramsocket.receive(datagrampacket1); } catch (InterruptedIOException e) { continue; } ReqBlock reqblock = new ReqBlock(abyte2); if (!((Req) (reqblock)).legal) { if (!"FINISH".equals(((Req) (reqblock)).Cmd)) throw new Exception("Protocol violation"); break; } System.arraycopy(reqblock.Data, 0, module.Data, k, reqblock.Size); k += reqblock.Size; System.out.print("."); } while (true); if (k != module.Size) { throw new Exception("File size mismatch"); } else { System.out.println("done"); Module.decode(module.Data, j); return module; } } catch (Exception exception) { exception.printStackTrace(); } if (datagramsocket != null) try { datagramsocket.close(); } catch (Exception exception1) { } System.out.println("Can't download module " + s); return null; }