Example #1
0
 /**
  * Wait for Acknowledgement from other server. FIXME Please, not wait only for three characters,
  * better control that the wait ack message is correct.
  *
  * @throws java.io.IOException
  * @throws java.net.SocketTimeoutException
  */
 protected void waitForAck() throws java.io.IOException {
   try {
     boolean ackReceived = false;
     boolean failAckReceived = false;
     ackbuf.clear();
     int bytesRead = 0;
     int i = soIn.read();
     while ((i != -1) && (bytesRead < Constants.ACK_COMMAND.length)) {
       bytesRead++;
       byte d = (byte) i;
       ackbuf.append(d);
       if (ackbuf.doesPackageExist()) {
         byte[] ackcmd = ackbuf.extractDataPackage(true).getBytes();
         ackReceived =
             Arrays.equals(ackcmd, org.apache.catalina.tribes.transport.Constants.ACK_DATA);
         failAckReceived =
             Arrays.equals(ackcmd, org.apache.catalina.tribes.transport.Constants.FAIL_ACK_DATA);
         ackReceived = ackReceived || failAckReceived;
         break;
       }
       i = soIn.read();
     }
     if (!ackReceived) {
       if (i == -1)
         throw new IOException(
             sm.getString(
                 "IDataSender.ack.eof", getAddress(), new Integer(socket.getLocalPort())));
       else
         throw new IOException(
             sm.getString(
                 "IDataSender.ack.wrong", getAddress(), new Integer(socket.getLocalPort())));
     } else if (failAckReceived && getThrowOnFailedAck()) {
       throw new RemoteProcessException(
           "Received a failed ack:org.apache.catalina.tribes.transport.Constants.FAIL_ACK_DATA");
     }
   } catch (IOException x) {
     String errmsg =
         sm.getString(
             "IDataSender.ack.missing",
             getAddress(),
             new Integer(socket.getLocalPort()),
             new Long(getTimeout()));
     if (SenderState.getSenderState(getDestination()).isReady()) {
       SenderState.getSenderState(getDestination()).setSuspect();
       if (log.isWarnEnabled()) log.warn(errmsg, x);
     } else {
       if (log.isDebugEnabled()) log.debug(errmsg, x);
     }
     throw x;
   } finally {
     ackbuf.clear();
   }
 }
 /** @see com.thinkparity.network.NetworkConnection#connect() */
 @Override
 public void connect() throws NetworkException {
   logger.logTraceId();
   logger.logInfo("{0} - Connect.", getId());
   Exception lastX = null;
   connected = false;
   for (final NetworkProxy proxy : proxies) {
     this.proxy = proxy;
     try {
       connectViaProxy();
       setSocketOptions();
       setSocketStreams();
       logger.logInfo("{0} - Connected.", getId());
       logger.logDebug(
           "{0} - Local:  {1}:{2}",
           getId(), socket.getLocalAddress().getHostAddress(), socket.getLocalPort());
       final InetSocketAddress remoteSocketAddress =
           (InetSocketAddress) socket.getRemoteSocketAddress();
       logger.logDebug(
           "{0} - Remote:  {1}:{2}",
           getId(),
           remoteSocketAddress.getAddress().getHostAddress(),
           remoteSocketAddress.getPort());
       connected = true;
       break;
     } catch (final SocketException sx) {
       lastX = sx;
     } catch (final IOException iox) {
       lastX = iox;
     }
   }
   if (false == connected) {
     throw new NetworkException(lastX);
   }
 }
  /** Test of TCP socket programming. */
  public void listen() {
    ServerSocket socket = null;

    try {
      socket = new ServerSocket(PORT_NO);
      System.out.println("Opened server socket");
      socket.setSoTimeout(TIMEOUT);
      connection = socket.accept();
      System.out.println("Server: Received connection from port " + connection.getPort());
      System.out.println("Server: local port: " + connection.getLocalPort());

      ObjectInputStream iStream = new ObjectInputStream(connection.getInputStream());
      MessageObject message = (MessageObject) iStream.readObject();

      System.out.println("message received... by server");
      System.out.println(
          "Server: received object, item=" + message.getItem() + " count: " + message.getCount());

      // sendResponse("'Acknowledging message: object, item=" + message.getItem() + " count: "
      //		+ message.getCount()+"'");
      connection.close();
      socket.close();

    } catch (SocketTimeoutException ste) {
      System.out.println("Timed out after " + TIMEOUT + " ms");
    } catch (Exception e) {
      System.out.println(e.getClass().getName() + " at server: " + e.getMessage());
    }
  } /*
  @Test
  public void testSocketBind() throws Exception {
    final InetAddress localAddress = InetAddress.getByAddress(new byte[] {127, 0, 0, 1});
    final int localPort = 8888;
    final InetAddress remoteAddress = InetAddress.getByAddress(new byte[] {10, 0, 0, 2});
    final int remotePort = 80;
    final InetSocketAddress localSockAddress = new InetSocketAddress(localAddress, localPort);
    final InetSocketAddress remoteSockAddress = new InetSocketAddress(remoteAddress, remotePort);
    Mockito.when(socket.getLocalSocketAddress()).thenReturn(localSockAddress);
    Mockito.when(socket.getRemoteSocketAddress()).thenReturn(remoteSockAddress);
    Mockito.when(socket.getLocalAddress()).thenReturn(localAddress);
    Mockito.when(socket.getLocalPort()).thenReturn(localPort);
    Mockito.when(socket.getInetAddress()).thenReturn(remoteAddress);
    Mockito.when(socket.getPort()).thenReturn(remotePort);
    conn.bind(socket);

    Assert.assertEquals("127.0.0.1:8888<->10.0.0.2:80", conn.toString());
    Assert.assertTrue(conn.isOpen());
    Assert.assertEquals(8888, conn.getLocalPort());
    Assert.assertEquals(80, conn.getRemotePort());
    Assert.assertEquals(
        InetAddress.getByAddress(new byte[] {127, 0, 0, 1}), conn.getLocalAddress());
    Assert.assertEquals(
        InetAddress.getByAddress(new byte[] {10, 0, 0, 2}), conn.getRemoteAddress());
  }
Example #5
0
  public void executa() {
    try {
      cliente = new Socket(this.host, Servidor.serverPort);
      System.out.println(
          "PortaLocal do socket: "
              + cliente.getLocalPort()
              + "\nPorta conectada: "
              + cliente.getPort()
              + "\nLocalSocketAddress: "
              + cliente.getLocalSocketAddress()
              + "\nInetAddress: "
              + cliente.getInetAddress()
              + "\nRemoteSocketAddress: "
              + cliente.getRemoteSocketAddress());
      System.out.println("Cliente conectado!");
      System.out.println("testes");

      // thread para receber mensagens do servidor
      ImpressoraCliente r = new ImpressoraCliente(cliente.getInputStream());
      new Thread(r).start();

      conectado = true;
      mainWindow.conectado(this);
      // cliente.close();

    } catch (IOException e) {
      mainWindow.getTextConsole().setText("Não foi possível se conectar ao servidor.");
      conectado = false;
      System.err.println(e.getMessage());
    }
  }
  /**
   * initialize
   *
   * @param serverPort: Port des Servers
   * @param remoteServerAddress: Adresse des Servers
   * @param numberOfClient: Laufende Nummer des Test-Clients
   * @param messagelength: Laenge einer Nachricht
   * @param numberOfMessages: Anzahl zu sendender Nachrichten je Thread
   * @param clientThinkTime: Denkzeit des Test-Clients
   * @param sharedData: Gemeinsame Daten der Threads
   */
  @Override
  public void initialize(
      int serverPort,
      String remoteServerAddress,
      int numberOfClient,
      int messageLength,
      int numberOfMessages,
      int clientThinkTime,
      SharedClientStatistics sharedData) {
    this.serverPort = serverPort;
    this.remoteServerAddress = remoteServerAddress;
    this.numberOfClient = numberOfClient;
    this.messageLength = messageLength;
    this.numberOfMessages = numberOfMessages;
    this.clientThinkTime = clientThinkTime;
    this.sharedData = sharedData;
    this.setName("EchoClient-".concat(String.valueOf(numberOfClient + 1)));
    threadName = getName();

    // Verbindung zum Server aufbauen
    try {
      con = new Socket(remoteServerAddress, serverPort);
      out = new ObjectOutputStream(con.getOutputStream());
      in = new ObjectInputStream(con.getInputStream());
      localPort = con.getLocalPort();
      log.debug(threadName + ": Verbindung zum Server aufgebaut mit Port " + localPort);
      log.debug(threadName + ": Registrierter Port: " + currentPort);
    } catch (Exception e) {
      log.debug("Exception beim Verbindungsaufbau: " + e);
    }
  }
Example #7
0
  void SocketTests() throws Exception {
    Socket s1 = new Socket();

    test("Socket should be created with SO_REUSEADDR disabled");
    check(!s1.getReuseAddress());

    test("Socket.setReuseAddress(true)");
    s1.setReuseAddress(true);
    check(s1.getReuseAddress());

    test("Socket.setReuseAddress(false)");
    s1.setReuseAddress(false);
    check(!s1.getReuseAddress());

    /* bind to any port */
    s1.bind(new InetSocketAddress(0));

    test("Binding Socket to port already in use should throw " + "a BindException");
    Socket s2 = new Socket();
    try {
      s2.bind(new InetSocketAddress(s1.getLocalPort()));
      failed();
    } catch (BindException e) {
      passed();
    }
    s2.close();

    s1.close();
  }
Example #8
0
  private void onConnect(final ProxyMessage msg) throws IOException {
    Socket s;

    if (proxy == null) {
      s = new Socket(msg.ip, msg.port);
    } else {
      s = new SocksSocket(proxy, msg.ip, msg.port);
    }

    log.info("Connected to " + s.getInetAddress() + ":" + s.getPort());

    ProxyMessage response = null;
    final InetAddress localAddress = s.getLocalAddress();
    final int localPort = s.getLocalPort();

    if (msg instanceof Socks5Message) {
      final int cmd = SocksProxyBase.SOCKS_SUCCESS;
      Socks5Message socks5Message = new Socks5Message(cmd, localAddress, localPort);
      socks5Message.setDnsResolver(dnsResolver);
      response = socks5Message;
    } else {
      final int cmd = Socks4Message.REPLY_OK;
      Socks4Message socks4Message = new Socks4Message(cmd, localAddress, localPort);
      socks4Message.setDnsResolver(dnsResolver);
      response = socks4Message;
    }
    response.write(out);
    startPipe(s);
  }
Example #9
0
  /** Waits for incoming connections and spins off threads to deal with them. */
  private void listen() {
    Socket client = new Socket();
    ServerThread st;

    /* Should only do this when it hasn't been told to shutdown. */
    while (!shutdown) {
      /* Try to accept an incoming connection. */
      try {
        client = serversock.accept();
        if (debug)
          /* Output info about the client */
          System.out.println(
              "Client on machine "
                  + client.getInetAddress().getHostAddress()
                  + " has connected on port "
                  + client.getLocalPort()
                  + ".");

        /*
         * Create a new thread to deal with the client, add it to the
         * vector of open connections. Finally, start the thread's
         * execution. Start method makes the threads go by calling their
         * run() methods.
         */
        st = new ServerThread(client, this, clientcounter++, debug);
        serverthreads.add(st);
        st.start();
      } catch (IOException e) {
        /*
         * Server Socket is closed, probably because a client told the
         * server to shutdown
         */
      }
    }
  }
Example #10
0
  public static void printSocketParameters(Socket cl) throws SocketException {

    boolean SO_KEEPALIVE = cl.getKeepAlive();
    boolean TCP_NODELAY = cl.getTcpNoDelay();

    int SO_LINGER = cl.getSoLinger();
    int SO_TIMEOUT = cl.getSoTimeout();

    int SO_RCVBUF = cl.getReceiveBufferSize();
    int SO_SNDBUF = cl.getSendBufferSize();

    int trafficClassVal = cl.getTrafficClass();
    /*
     		0 <= trafficClassVal <= 255
    	IPTOS_LOWCOST (0x02)
    	IPTOS_RELIABILITY (0x04)
     			IPTOS_THROUGHPUT (0x08)
    	IPTOS_LOWDELAY (0x10)

    */

    int remotePort = cl.getPort();
    int localPort = cl.getLocalPort();
    String localIP = getIPstr(cl.getLocalAddress());
    String remoteIP = getIPstr(cl.getInetAddress());

    System.out.println("Socket Paramaters :");
    System.out.println("SO_KEEPAILVE = " + SO_KEEPALIVE + " TCP_NODELAY = " + TCP_NODELAY);
    System.out.println("SO_LINGER = " + SO_LINGER + "  SO_TIMEOUT = " + SO_TIMEOUT);
    System.out.println("SO_RCVBUF = " + SO_RCVBUF + "  SO_SNDBUF = " + SO_SNDBUF);
    System.out.println("Traffic Class = " + trafficClassVal);
    System.out.println("Local Address = " + localIP + ":" + localPort);
    System.out.println("Remote Address = " + remoteIP + ":" + remotePort);
  }
Example #11
0
    public String toString() {
      StringBuilder ret = new StringBuilder();
      InetAddress local = null, remote = null;
      String local_str, remote_str;

      Socket tmp_sock = sock;
      if (tmp_sock == null) ret.append("<null socket>");
      else {
        // since the sock variable gets set to null we want to make
        // make sure we make it through here without a nullpointer exception
        local = tmp_sock.getLocalAddress();
        remote = tmp_sock.getInetAddress();
        local_str = local != null ? Util.shortName(local) : "<null>";
        remote_str = remote != null ? Util.shortName(remote) : "<null>";
        ret.append(
            '<'
                + local_str
                + ':'
                + tmp_sock.getLocalPort()
                + " --> "
                + remote_str
                + ':'
                + tmp_sock.getPort()
                + "> ("
                + ((System.currentTimeMillis() - last_access) / 1000)
                + " secs old)");
      }
      tmp_sock = null;

      return ret.toString();
    }
Example #12
0
  /** Setup the sockets needed for the given transfer mode (either passive or active). */
  private void setupTransferMode() {
    String resp = "";

    if (passive) {
      debug("Switching to passive mode");
      System.out.println("=> PASV");
      out.println(commands[PASV]);
      resp = getResponse();
      System.out.println(resp);

      /* If we've successfully entered passive mode, setup the socket */
      if (resp.startsWith("227")) {
        String[] foo = resp.split(",");
        int pasvPort =
            new Integer(foo[4]) * 256 + new Integer(foo[5].replaceAll("[a-zA-Z).]+", ""));

        debug("Opening passive socket on " + serverAddr + ":" + pasvPort);

        try {
          pasvSock = new Socket(serverAddr, pasvPort, null, sock.getLocalPort() + 1);
          pasvIn = new BufferedReader(new InputStreamReader(pasvSock.getInputStream()));
        } catch (IOException e) {
          System.err.println(e.getMessage());
        }
      } else {
        debug("Got invalid response from PASV command");
      }
    } else {
      /* Active mode */
      debug("Switching to active mode");

      try {
        activeSock = new ServerSocket(0);
      } catch (IOException e) {
        System.err.println("Error creating active socket: " + e.getMessage());
      }

      byte[] addr = sock.getLocalAddress().getAddress();
      debug("Listening on local port " + activeSock.getLocalPort());

      String portCmd =
          "PORT "
              + ((int) addr[0] & 0xFF)
              + ","
              + ((int) addr[1] & 0xFF)
              + ","
              + ((int) addr[2] & 0xFF)
              + ","
              + ((int) addr[3] & 0xFF)
              + ","
              + activeSock.getLocalPort() / 256
              + ","
              + activeSock.getLocalPort() % 256;

      System.out.println("=> " + portCmd);
      out.println(portCmd);
      System.out.println(getResponse());
    }
  }
Example #13
0
 public String toString() {
   return socket.getInetAddress()
       + ":"
       + socket.getPort()
       + "(localport="
       + socket.getLocalPort()
       + ")";
 }
 /** Get something unique for this connection. */
 public String connectionId() {
   if (selectionKey == null) {
     return "null.null";
   } else {
     Socket socket = ((SocketChannel) selectionKey.channel()).socket();
     return "" + socket.getLocalPort() + "." + socket.getPort();
   }
 }
Example #15
0
 private String describeConnection(Socket s) {
   return String.format(
       "from %s:%d to %s:%d",
       s.getInetAddress().getHostAddress(),
       s.getPort(),
       s.getLocalAddress().getHostAddress(),
       s.getLocalPort());
 }
 public FrontendConnection(SocketChannel channel) {
   super(channel);
   Socket socket = channel.socket();
   this.host = socket.getInetAddress().getHostAddress();
   this.port = socket.getPort();
   this.localPort = socket.getLocalPort();
   this.handler = new FrontendAuthenticator(this);
 }
  public ServerMessageGetterSender(Socket socket) {

    this.socket = socket;

    // Get input and output streams in reverse order of ClientMessageGetterSender class
    try {
      this.out = new ObjectOutputStream(socket.getOutputStream());
    } catch (IOException ioe) {
      System.out.println("Could not get ObjectOutputStream on socket: " + socket.getLocalPort());
    }

    try {
      this.in = new ObjectInputStream(socket.getInputStream());
    } catch (IOException ioe) {
      System.out.println("Could not get ObjectInputStream on socket: " + socket.getLocalPort());
    }
  }
 @Override
 public void disconnect() throws LWTRTException {
   log.trace("disconnect, localport:" + socket.getLocalPort());
   try {
     socket.close();
   } catch (IOException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
   }
 }
Example #19
0
 /**
  * Create a new message and record the source ip and port
  *
  * @param aSocket The socket through which the message will be read.
  * @return The {@link AS2Message} to use and never <code>null</code>.
  */
 @Nonnull
 protected AS2Message createMessage(@Nonnull final Socket aSocket) {
   final AS2Message aMsg = new AS2Message();
   aMsg.setAttribute(CNetAttribute.MA_SOURCE_IP, aSocket.getInetAddress().toString());
   aMsg.setAttribute(CNetAttribute.MA_SOURCE_PORT, Integer.toString(aSocket.getPort()));
   aMsg.setAttribute(CNetAttribute.MA_DESTINATION_IP, aSocket.getLocalAddress().toString());
   aMsg.setAttribute(CNetAttribute.MA_DESTINATION_PORT, Integer.toString(aSocket.getLocalPort()));
   aMsg.setAttribute(AS2Message.ATTRIBUTE_RECEIVED, Boolean.TRUE.toString());
   return aMsg;
 }
  public ClientApp(String serverName, int serverPort) {

    response = new Scanner(System.in);

    System.out.print("Enter your name: ");
    playerName = response.nextLine();
    System.out.println();

    System.out.println(playerName + ": Establishing connection. Please wait ...");
    logger.info(playerName + ": Establishing connection. Please wait ...");
    player = new Player(playerName);

    try {
      this.socket = new Socket(serverName, serverPort);
      this.ID = socket.getLocalPort();
      System.out.println();
      logger.info("=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=");
      System.out.println("=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=");
      logger.info("WELCOME TO GAME OF THE SURVIVAL OF THE FITTEST");
      System.out.println("WELCOME TO GAME OF THE SURVIVAL OF THE FITTEST");
      logger.info("=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=\n");
      System.out.println("=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=\n");
      System.out.println(playerName + ": Connected to server: " + socket.getInetAddress());
      logger.info(playerName + ": Connected to server: " + socket.getInetAddress());
      System.out.println(playerName + ": Connected to portid: " + socket.getLocalPort());
      logger.info(playerName + ": Connected to portid: " + socket.getLocalPort());
      this.start();
      sendJoinMessageAcross = sendJoinMessage(playerName, socket.getInetAddress().getHostAddress());
      send(sendJoinMessageAcross);
      logger.info("Client sent to server: " + sendJoinMessageAcross);
    } catch (UnknownHostException uhe) {
      System.err.println(ID + ": Unknown Host");
      logger.error(ID + ": Unknown Host");
      System.out.println(uhe.getMessage());
      logger.info(uhe.getMessage());
    } catch (IOException ioe) {
      logger.error(ID + ": Unexpected exception");
      System.out.println(ID + ": Unexpected exception");
      System.out.println(ioe.getMessage());
      logger.info(ioe.getMessage());
    }
  }
Example #21
0
    public void run() {
      int port = -1;
      Socket toServer = null;
      try {
        toServer = new Socket("localhost", this.pingPort);
        toServer.setSoTimeout(MAX_HEARTBEAT_DELAY);

        port = toServer.getLocalPort();

        in = new BufferedReader(new InputStreamReader(toServer.getInputStream()));
        out = new PrintWriter(toServer.getOutputStream(), true);

        while (true) {
          long start = System.currentTimeMillis();

          String data = in.readLine();
          if (HEARTBEAT.equals(data)) {
            log("Got heartbeat for main class " + this.forClass);
          } else if (SHUTDOWN.equals(data)) {
            if (!honorShutdownMsg) continue;
            log("Client received shutdown message from server. Shutting Down...");
            System.exit(0);
          } else if (ARE_YOU_ALIVE.equals(data)) {
            out.println(forClass);
            out.flush();
          } else {
            throw new Exception("Doesn't recognize data: " + data);
          }

          long elapsed = System.currentTimeMillis() - start;
          if (elapsed > MAX_HEARTBEAT_DELAY) {
            throw new Exception("Client took too long to response.");
          }
        }
      } catch (Exception e) {
        log(e.getClass() + ": " + Arrays.asList(e.getStackTrace()));
        log(
            "Didn't get heartbeat for at least "
                + MAX_HEARTBEAT_DELAY
                + " milliseconds. Killing self (port "
                + port
                + ").");
      } finally {
        log("Ping thread exiting port (" + port + ")");
        if (toServer != null) {
          try {
            toServer.close();
          } catch (IOException e) {
            throw new RuntimeException(e);
          }
        }
        System.exit(EXIT_CODE);
      }
    }
  public boolean sendMessage(Message messageToSend) {

    try {
      out.writeObject(messageToSend);
    } catch (IOException ioe) {
      System.out.println("Could not write to socket: " + socket.getLocalPort());
      return false;
    }

    return true;
  }
Example #23
0
 private String getSockAddress() {
   StringBuilder sb = new StringBuilder();
   if (sock != null) {
     sb.append(sock.getLocalAddress().getHostAddress()).append(':').append(sock.getLocalPort());
     sb.append(" - ")
         .append(sock.getInetAddress().getHostAddress())
         .append(':')
         .append(sock.getPort());
   }
   return sb.toString();
 }
Example #24
0
 /** @return pretty print of 'this' */
 @Override
 public String toString() {
   return ""
       + (socket.isConnected()
           ? "tcp://"
               + socket.getInetAddress()
               + ":"
               + socket.getPort()
               + "@"
               + socket.getLocalPort()
           : (localLocation != null ? localLocation : remoteLocation));
 }
Example #25
0
 @Override
 public void run() {
   try {
     while (running) {
       final Socket socket = serverSocket.accept();
       log.info("Accepting Client on port " + socket.getLocalPort());
       executorService.submit(new Acceptor(socket));
     }
   } catch (IOException e) {
     if (running) e.printStackTrace();
   }
 }
 @Override
 public void send(Object pdu) throws LWTRTException {
   log.trace("send from " + socket.getLocalPort() + " to " + socket.getPort());
   if (socket.isClosed()) {
     throw new LWTRTException("Socket is closed");
   }
   try {
     oout.writeObject(pdu);
   } catch (IOException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
   }
 }
 @Override
 public Object receive() throws LWTRTException {
   log.trace("receive, localport:" + socket.getLocalPort());
   if (socket.isClosed()) {
     throw new LWTRTException("Socket is closed");
   }
   try {
     return oin.readObject();
   } catch (IOException e) {
     throw new LWTRTException("Verbindung wurde disconnected");
   } catch (ClassNotFoundException e) {
     throw new LWTRTException(e);
   }
 }
Example #28
0
 public String toString() {
   Socket tmp_sock = sock;
   if (tmp_sock == null) return "<null socket>";
   InetAddress local = tmp_sock.getLocalAddress(), remote = tmp_sock.getInetAddress();
   String local_str = local != null ? Util.shortName(local) : "<null>";
   String remote_str = remote != null ? Util.shortName(remote) : "<null>";
   return String.format(
       "%s:%s --> %s:%s (%d secs old) [%s] [recv_buf=%d]",
       local_str,
       tmp_sock.getLocalPort(),
       remote_str,
       tmp_sock.getPort(),
       TimeUnit.SECONDS.convert(getTimestamp() - last_access, TimeUnit.NANOSECONDS),
       status(),
       receiver != null ? receiver.bufferSize() : 0);
 }
Example #29
0
 public void run() {
   logger.info("Server Started");
   while (true) {
     try {
       nodeSd = server.accept();
     } catch (IOException e) {
       logger.error("Accept failed.");
       logger.error(e);
     }
     /* start a new thread to handle the new node */
     // Thread t = new Thread(new Node(nodeSd, false));
     Thread t =
         new Thread(new HandleNewNode(nodeSd.getInetAddress(), nodeSd.getLocalPort(), nodeSd));
     t.start();
   }
 }
Example #30
0
  public void init(String server) {
    try {
      socket = new Socket(server, BANKPORT);
      System.out.println("Socket created on the local port " + socket.getLocalPort());
      System.out.println(
          "A connection established with the remote port "
              + socket.getPort()
              + " at "
              + socket.getInetAddress().toString());

      in = new Scanner(socket.getInputStream());
      out = new PrintWriter(socket.getOutputStream());
      System.out.println("I/O setup done.");
    } catch (IOException exception) {
    }
  }