Beispiel #1
0
  // start with the first available port in the range STARTPORT-ENDPORT
  private void start(int websterPort, InetAddress address) throws IOException {
    try {
      port = websterPort;
      // check if the port is not required by the JVM system property
      String s = System.getProperty("webster.port");
      if (s != null && s.length() > 0) {
        port = new Integer(s);
      }
      ss = new ServerSocket(port, 0, address);
    } catch (IOException ioe) {
      if (startPort == endPort) {
        logger.log(Level.SEVERE, "Port bind server socket failure: " + endPort, ioe);
        System.exit(1);
      } else {
        System.err.println("Port bind server socket failure: " + port);
        throw ioe;
      }
    }
    port = ss.getLocalPort();

    if (debug)
      System.out.println(
          "Webster serving on : " + ss.getInetAddress().getHostAddress() + ":" + port);
    if (logger.isLoggable(Level.INFO))
      logger.info("Webster serving on: " + ss.getInetAddress().getHostAddress() + ":" + port);
    if (debug) System.out.println("Webster listening on port: " + port);
    if (logger.isLoggable(Level.FINE)) {
      logger.fine("Webster listening on port: " + port);
    }
    try {
      pool = (ThreadPoolExecutor) Executors.newFixedThreadPool(maxThreads);
      if (debug)
        System.out.println(
            "Webster minThreads [" + minThreads + "], " + "maxThreads [" + maxThreads + "]");
      if (logger.isLoggable(Level.FINE))
        logger.fine(
            "Webster minThreads [" + minThreads + "], " + "maxThreads [" + maxThreads + "]");
    } catch (Exception e) {
      logger.log(Level.SEVERE, "Could not create ThreadPool", e);
      throw new RuntimeException("Could not create Thread Pool");
    }
    if (soTimeout > 0) {
      if (debug) System.out.println("Webster Socket SO_TIMEOUT set to [" + soTimeout + "] millis");
      if (logger.isLoggable(Level.FINE))
        logger.fine("Webster Socket SO_TIMEOUT set to [" + soTimeout + "] millis");
    }
    /* Set system property */
    System.setProperty(CODESERVER, "http://" + getAddress() + ":" + getPort());

    if (logger.isLoggable(Level.FINE)) logger.fine("Webster isDaemon: " + isDaemon);

    Thread runner = new Thread(this, "Webster");
    if (isDaemon) {
      runner.setDaemon(true);
    }
    runner.start();
  }
  private void onBind(ProxyMessage msg) throws IOException {
    ProxyMessage response = null;

    if (proxy == null) ss = new ServerSocket(0);
    else ss = new SocksServerSocket(proxy, msg.ip, msg.port);

    ss.setSoTimeout(acceptTimeout);

    log("Trying accept on " + ss.getInetAddress() + ":" + ss.getLocalPort());

    if (msg.version == 5)
      response = new Socks5Message(CProxy.SOCKS_SUCCESS, ss.getInetAddress(), ss.getLocalPort());
    else
      response = new Socks4Message(Socks4Message.REPLY_OK, ss.getInetAddress(), ss.getLocalPort());
    response.write(out);

    mode = ACCEPT_MODE;

    pipe_thread1 = Thread.currentThread();
    pipe_thread2 = new Thread(this);
    pipe_thread2.start();

    // Make timeout infinit.
    sock.setSoTimeout(0);
    int eof = 0;

    try {
      while ((eof = in.read()) >= 0) {
        if (mode != ACCEPT_MODE) {
          if (mode != PIPE_MODE) return; // Accept failed

          remote_out.write(eof);
          break;
        }
      }
    } catch (EOFException eofe) {
      // System.out.println("EOF exception");
      return; // Connection closed while we were trying to accept.
    } catch (InterruptedIOException iioe) {
      // Accept thread interrupted us.
      // System.out.println("Interrupted");
      if (mode != PIPE_MODE) return; // If accept thread was not successfull return.
    } finally {
      // System.out.println("Finnaly!");
    }

    if (eof < 0) // Connection closed while we were trying to accept;
    return;

    // Do not restore timeout, instead timeout is set on the
    // remote socket. It does not make any difference.

    pipe(in, remote_out);
  }
  public static void main(String[] args) {
    if (args.length < 1) {
      System.out.println("Need port");
      return;
    }
    int port = Integer.parseInt(args[0]);
    try {
      ServerSocket server = new ServerSocket(port);
      System.out.println(
          "Login on "
              + server.getInetAddress().toString()
              + ":"
              + server.getLocalPort()
              + ".\nExit with a single x");
      Socket client = server.accept();
      LineNumberReader in = new LineNumberReader(new InputStreamReader(client.getInputStream()));
      PrintWriter out = new PrintWriter(client.getOutputStream());
      while (true) {
        String str = in.readLine();
        System.out.println(str);
        if (str.equals("x") == true) {
          client.close();
          server.close();

          break;
        }
        out.println(str);
        out.flush();
      }
    } catch (IOException ex) {
    }
  }
Beispiel #4
0
 public static void startServer() {
   try {
     System.out.println("Starting server...");
     serverSocket = new ServerSocket(7788);
     System.out.println("Server Started... Address: " + serverSocket.getInetAddress());
     while (true) {
       socket = serverSocket.accept();
       for (int i = 0; i < 10; i++) {
         if (user[i] == null) {
           System.out.println("User " + (i + 1) + " connected from " + socket.getInetAddress());
           socket.setTcpNoDelay(false);
           out = new ObjectOutputStream(socket.getOutputStream());
           in = new ObjectInputStream(socket.getInputStream());
           out.writeInt(i);
           out.flush();
           User theUser = new User(out, in, i);
           user[i] = theUser;
           Thread thread = new Thread(user[i]);
           thread.start();
           break;
         }
       }
     }
   } catch (IOException e) {
     e.printStackTrace();
   }
 }
Beispiel #5
0
  public void run() {
    while (true) {
      try {
        System.out.println("Server name: " + serverSocket.getInetAddress().getHostName());
        System.out.println("Waiting for client on port " + serverSocket.getLocalPort() + "...");
        Socket server = serverSocket.accept();
        System.out.println("Just connected to " + server.getRemoteSocketAddress());

        ObjectInputStream objectIn = new ObjectInputStream(server.getInputStream());

        try {
          Recipe rec = (Recipe) objectIn.readObject();
          startHMI(rec, rec.getProductName());

          //				System.out.println("Object Received: width: "+rec.getWidth()+" height:
          // "+rec.getHeight());
        } catch (ClassNotFoundException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
        }

        DataOutputStream out = new DataOutputStream(server.getOutputStream());
        out.writeUTF(
            "Thank you for connecting to " + server.getLocalSocketAddress() + "\nGoodbye!");
        server.close();
      } catch (SocketTimeoutException s) {
        System.out.println("Socket timed out!");
        break;
      } catch (IOException e) {
        e.printStackTrace();
        break;
      }
    }
  }
  /*
   * receive process sent from slaves via socket
   */
  public void receiveProcess() throws IOException, ClassNotFoundException {
    ServerSocket listener = null;
    Socket socket;
    ObjectInputStream in = null;

    try {
      // 1. creating a server socket
      listener = new ServerSocket(getPort());

      while (true) {

        // 2. wait for connection
        System.out.println("Master Waiting for Slave");
        socket = listener.accept();
        System.out.println("Connection received from " + listener.getInetAddress().getHostName());

        // 3.read object from inputstream
        in = new ObjectInputStream(socket.getInputStream());
        //				String s = (String) in.readObject();
        //				System.out.println("Message Received from slave" + s);

        MigratableProcess process = (MigratableProcess) in.readObject();
        processList.add(process);
      }
    } catch (IOException e) {
      e.printStackTrace();
    } finally {
      // 4.close connection
      in.close();
      listener.close();
    }
  }
Beispiel #7
0
  public InetSocketAddress getAddress() {
    if (serverSocket != null && serverSocket.isBound()) {
      return new InetSocketAddress(serverSocket.getInetAddress(), serverSocket.getLocalPort());
    }

    return address;
  }
  public void listenSocket() {
    try {
      server = new ServerSocket(4321, 1, new InetSocketAddress(0).getAddress());
      System.out.println(
          "Server is listening on " + server.getInetAddress().getHostName() + ":" + 4321);
    } catch (IOException e) {
      System.out.println("Could not listen on port 4321");
      System.exit(-1);
    }
    try {
      client = server.accept();
      System.out.println("Client connected on port " + 4321);
      has_client = true;
    } catch (IOException e) {
      System.out.println("Accept failed: 4321");
      System.exit(-1);
    }

    try {
      in = new BufferedReader(new InputStreamReader(client.getInputStream()));
      out = new PrintWriter(client.getOutputStream(), true);
    } catch (IOException e) {
      System.out.println("Read failed");
      System.exit(-1);
    }
  }
Beispiel #9
0
  /**
   * Create a server with the specified port, listen backlog, and local IP address to bind to. The
   * localIP argument can be used on a multi-homed host for a ServerSocket that will only accept
   * connect requests to one of its addresses. If localIP is null, it will default accepting
   * connections on any/all local addresses. The port must be between 0 and 65535, inclusive. <br>
   * This methods blocks.
   */
  public void start(final int port, final int backlog, final InetAddress localIP) {

    executor = Executors.newFixedThreadPool(poolSize);

    try {
      ss = new ServerSocket(port, backlog, localIP);
      final String address = ss.getInetAddress().getHostAddress();
      final int localPort = ss.getLocalPort();
      log.info("Starting SOCKS Proxy on: {}:{}", address, localPort);
      setProxyStatus(ProxyStatus.STARTED);

      while (true) {
        final Socket s = ss.accept();
        final String hostName = s.getInetAddress().getHostName();
        final int port2 = s.getPort();
        log.info("Accepted from:{}:{}", hostName, port2);

        final DnsProxyServer ps = new DnsProxyServer(auth, s, dnsResolver);
        executor.submit(ps);
      }
    } catch (final IOException ioe) {
      log.error("Can't start proxy", ioe);
      setProxyStatus(ProxyStatus.ERROR);
    } finally {
    }
  }
Beispiel #10
0
 private void writeHostAndPortToFile(File portFile) {
   String host = socket.getInetAddress().getHostName();
   int port = socket.getLocalPort();
   // The motivation for the Log.warn would be better satisfied by Bug 38.
   Log.warn("echo " + host + ":" + port + " > " + portFile);
   StringUtilities.writeFile(portFile, host + ":" + port + "\n");
 }
 public void setTitleToListen() {
   try {
     String serverString = serverSocket.getInetAddress().getLocalHost().toString();
     String serverIP = serverString.split("/")[1];
     editor.setTitle("Listening on: " + serverIP + ":" + serverport);
   } catch (UnknownHostException e) {
     e.printStackTrace();
   }
 }
 /** @tests java.net.ServerSocket#getInetAddress() */
 public void test_getInetAddress() throws IOException {
   InetAddress addr = InetAddress.getLocalHost();
   s = new ServerSocket(0, 10, addr);
   try {
     assertEquals("Returned incorrect InetAdrees", addr, s.getInetAddress());
   } finally {
     s.close();
   }
 }
  /**
   * This method will create a tunnel of a type defined by the properties facade and will then bind
   * a local temporary port for a client app to use to communicate through the proxy tunnel. Returns
   * an address to the local server a client can talk to.
   *
   * @param token
   * @param serverProxyAddress
   * @param serverProxyPort
   * @return
   * @throws IOException
   */
  public InetSocketAddress startConnector(
      RequestToken token,
      InetAddress serverProxyAddress,
      int serverProxyPort,
      int bufferSize,
      ConsumerProxyPropertiesFacade props,
      SocketClientManagerController controller)
      throws IOException {
    /*
     * Attempts to start up a connection with the desired server proxy.
     */

    // Note that both client and server are closed when the thread completes
    log.debug(
        "Creating Client instance to connect to server proxy: "
            + serverProxyAddress
            + ":"
            + serverProxyPort);
    Client client = props.getClientInstance(serverProxyAddress, serverProxyPort, token);

    /*
     * Start up a socket server bound to the local proxy hostname and to a
     * port unique to this request.
     */
    InetAddress localProxyAddress = props.getClientProxyAddress();
    log.debug("Local client proxy address set as: " + localProxyAddress);

    InetSocketAddress connectorAddress = new InetSocketAddress(localProxyAddress, 0);
    log.debug("Starting server socket for client to access on port: " + connectorAddress.getPort());

    // Note that both client and server are closed when the thread completes
    ServerSocket server = new ServerSocket();
    server.bind(connectorAddress);
    log.debug("Creating Server bound: " + server.getInetAddress() + ": " + server.getLocalPort());

    ClientConnector connector = new ClientConnector(server, client, bufferSize, controller);
    Thread conn = new Thread(connector);

    log.debug("Starting new Client Connector thread.");
    conn.start();

    return new InetSocketAddress(server.getInetAddress(), server.getLocalPort());
  }
Beispiel #14
0
  public void shutdown() {
    synchronized (lock) {
      shutdownRequested = true;
    }

    /* Now close the ServerSocket */
    try {
      new Socket(sock.getInetAddress(), sock.getLocalPort()).close();
    } catch (IOException ex) {
      Ganymede.stackTrace(ex);
    }
  }
Beispiel #15
0
 @Override
 public String toString() {
   StringBuilder sb = new StringBuilder();
   sb.append("Server address  - ")
       .append(serverSocket.getInetAddress().getHostAddress())
       .append(":")
       .append(serverSocket.getLocalPort());
   sb.append("\nRoot folder     - ").append(Config.defaultFolder);
   sb.append("\nMax connections - ").append(Config.threadPoolSize);
   sb.append("\nFile part size  - ").append(Config.partSize).append(" bytes").append("\n");
   return sb.toString();
 }
Beispiel #16
0
    public void init() {
      serverSocket = createServerSocket();

      if (logger.isDebugEnabled()) {
        logger.debug(
            "Created "
                + info
                + "socket listener on "
                + serverSocket.getInetAddress()
                + ":"
                + serverSocket.getLocalPort());
      }
    }
 public String getListeningAddress(final boolean resolveMultiIfcWithLocal) {
   String address = serverSocket.getInetAddress().getHostAddress().toString();
   if (resolveMultiIfcWithLocal && address.equals("0.0.0.0"))
     try {
       address = InetAddress.getLocalHost().getHostAddress().toString();
     } catch (UnknownHostException e) {
       try {
         address = OChannel.getLocalIpAddress(true);
       } catch (Exception ex) {
       }
     }
   return address + ":" + serverSocket.getLocalPort();
 }
Beispiel #18
0
  public static void main(String[] args) throws IOException {
    ServerSocket ss = new ServerSocket(9999);

    System.out.println(ss.getLocalSocketAddress());
    System.out.println(ss.getInetAddress());

    while (true) {
      Socket client = ss.accept();

      String input = IOUtils.readAll(client.getInputStream());
      String info = String.format("Hello server");
      System.out.println(info);
    }
  }
Beispiel #19
0
    public IIOPAddress getLocalAddress() {
      IIOPAddress addr =
          new IIOPAddress(serverSocket.getInetAddress().toString(), serverSocket.getLocalPort());

      if (configuration != null) {
        try {
          addr.configure(configuration);
        } catch (ConfigurationException ce) {
          if (logger.isWarnEnabled()) {
            logger.warn("ConfigurationException", ce);
          }
        }
      }
      return addr;
    }
Beispiel #20
0
  public static void main(String[] args) {
    String ipv4;
    try {
      System.out.println("Stablishing the server socket...");
      ServerSocket srvSock = new ServerSocket(4201);
      System.out.println(
          "Server socket stablished to "
              + srvSock.getInetAddress().getHostName()
              + " at port number "
              + srvSock.getLocalPort()
              + ".\n");

      try {
        Socket comSock = srvSock.accept();
        System.out.println(
            "New connection stablished with "
                + comSock.getInetAddress().getHostName()
                + " (port "
                + comSock.getPort()
                + "), trying to communicate...");
        // DO STUFF
        try {
          BufferedReader br = new BufferedReader(new InputStreamReader(comSock.getInputStream()));
          ipv4 = br.readLine();
          br.close();
          comSock.close();
          srvSock.close();
          Socket sock = new Socket(ipv4, 4202);
          BufferedReader br2 = new BufferedReader(new InputStreamReader(sock.getInputStream()));
          System.out.println(br2.readLine());
          br2.close();
          sock.close();
          // System.out.println(ipv4);
        } catch (Exception e) {
          e.printStackTrace();
          System.out.println("Connection failed. Try again later.");
        }

      } catch (Exception e) {
        e.printStackTrace();
        System.out.println("Problem with client.\n");
      }

    } catch (Exception e) {
      System.out.println("Failed to create server socket:");
      e.printStackTrace();
    }
  }
Beispiel #21
0
 /**
  * Create a server with a specific id, which listens at the designated port.
  *
  * @param name Name of the agent
  * @param port Listen to this port for connection requests
  */
 public Server(String name, int port) {
   Name = name;
   listenPort = port;
   idCount = 0;
   try {
     server = new ServerSocket(listenPort);
     start();
     serverId = server.getInetAddress().getHostName() + "_" + port;
     Log.info("started server " + serverId + " name " + Name);
     clients = new Vector<Session>();
     Valid = true;
   } catch (Exception e) {
     Log.severe(Name + e.toString());
     // Valid will be false
   }
 }
    /*
     * Returns the string representation of the address that this
     * listen key represents.
     */
    public String address() {
      InetAddress address = ss.getInetAddress();

      /*
       * If bound to the wildcard address then use current local
       * hostname. In the event that we don't know our own hostname
       * then assume that host supports IPv4 and return something to
       * represent the loopback address.
       */
      if (address.isAnyLocalAddress()) {
        try {
          address = InetAddress.getLocalHost();
        } catch (UnknownHostException uhe) {
          byte[] loopback = {0x7f, 0x00, 0x00, 0x01};
          try {
            address = InetAddress.getByAddress("127.0.0.1", loopback);
          } catch (UnknownHostException x) {
            throw new InternalError("unable to get local hostname");
          }
        }
      }

      /*
       * Now decide if we return a hostname or IP address. Where possible
       * return a hostname but in the case that we are bound to an
       * address that isn't registered in the name service then we
       * return an address.
       */
      String result;
      String hostname = address.getHostName();
      String hostaddr = address.getHostAddress();
      if (hostname.equals(hostaddr)) {
        if (address instanceof Inet6Address) {
          result = "[" + hostaddr + "]";
        } else {
          result = hostaddr;
        }
      } else {
        result = hostname;
      }

      /*
       * Finally return "hostname:port", "ipv4-address:port" or
       * "[ipv6-address]:port".
       */
      return result + ":" + ss.getLocalPort();
    }
Beispiel #23
0
  /**
   * init the Selector
   *
   * @param ctx
   * @throws java.io.IOException
   */
  private final void initSelector(Context ctx) throws IOException {
    try {
      isShutDown.set(false);

      connectorInstanceHandler =
          new ConnectorInstanceHandler.ConcurrentQueueDelegateCIH(
              getConnectorInstanceHandlerDelegate());

      // Create the socket listener
      selector = Utils.openSelector();

      if (role != Role.CLIENT) {
        serverSocketChannel = ServerSocketChannel.open();
        serverSocket = serverSocketChannel.socket();
        if (receiveBufferSize > 0) {
          try {
            serverSocket.setReceiveBufferSize(receiveBufferSize);
          } catch (SocketException se) {
            if (logger.isLoggable(Level.FINE))
              logger.log(Level.FINE, "setReceiveBufferSize exception ", se);
          } catch (IllegalArgumentException iae) {
            if (logger.isLoggable(Level.FINE))
              logger.log(Level.FINE, "setReceiveBufferSize exception ", iae);
          }
        }

        if (inet == null) {
          portRange.bind(serverSocket, ssBackLog);
        } else {
          portRange.bind(serverSocket, inet, ssBackLog);
        }

        serverSocketChannel.configureBlocking(false);
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        serverSocket.setSoTimeout(serverTimeout);

        // Ephemeral support
        port = serverSocket.getLocalPort();
        inet = serverSocket.getInetAddress();
      }
      ctx.getController().notifyReady();
    } catch (SocketException ex) {
      throw new BindException(ex.getMessage() + ": " + port + "=" + this);
    }
  }
 private HostAndPort startServerSocket() throws Exception {
   if (serverSocketAddress != null) {
     serverSocket = new ServerSocket(serverSocketAddress.getPort());
   } else {
     for (int i = 40000; i < 40100; i++) {
       try {
         serverSocket = new ServerSocket(i);
       } catch (IOException e) {
         // try next port
       }
     }
     assertNotNull(serverSocket, "Failed to create server socket; no ports free in range!");
     serverSocketAddress =
         HostAndPort.fromParts(
             serverSocket.getInetAddress().getHostAddress(), serverSocket.getLocalPort());
   }
   return serverSocketAddress;
 }
Beispiel #25
0
  public Server() {
    try {
      serverSocket = new ServerSocket(1210);
      // window.setText("Сервер запущен. Адрес: " + serverSocket.getInetAddress().toString());
      System.out.println("Сервер запущен. Адрес: " + serverSocket.getInetAddress().toString());
      while (true) {
        // System.out.println("eee");
        klientSocket = serverSocket.accept();
        // window.setText("Подключён клиент. Адрес: " + klientSocket.getInetAddress().toString());
        System.out.println("Подключён клиент. Адрес: " + klientSocket.getInetAddress().toString());
        ServerThread server = new ServerThread(klientSocket);

        server.run(); // запуск потока
        // window.setText(server.getPlane().toString());
      }
    } catch (IOException e) {
      System.err.println(e);
    }
  }
 /**
  * Create a server with the specified port, listen backlog, and local IP address to bind to. The
  * localIP argument can be used on a multi-homed host for a ServerSocket that will only accept
  * connect requests to one of its addresses. If localIP is null, it will default accepting
  * connections on any/all local addresses. The port must be between 0 and 65535, inclusive. <br>
  * This methods blocks.
  */
 public void start(int port, int backlog, InetAddress localIP) {
   try {
     ss = new ServerSocket(port, backlog, localIP);
     log(
         "Starting SOCKS Proxy on:"
             + ss.getInetAddress().getHostAddress()
             + ":"
             + ss.getLocalPort());
     while (true) {
       Socket s = ss.accept();
       log("Accepted from:" + s.getInetAddress().getHostName() + ":" + s.getPort());
       ProxyServer ps = new ProxyServer(auth, s);
       (new Thread(ps)).start();
     }
   } catch (IOException ioe) {
     ioe.printStackTrace();
   } finally {
   }
 }
Beispiel #27
0
  /**
   * Constructor, makes a new server listening on specified port.
   *
   * @param port The port to listen on.
   */
  public Server(int port) {
    clientcounter = 0;
    shutdown = false;
    try {
      serversock = new ServerSocket(port);
    } catch (IOException e) {
      System.out.println("Could not create server socket.");
      return;
    }
    /* Server socket open, make a vector to store active threads. */
    serverthreads = new Vector<ServerThread>(0, 1);

    /* Output connection info for the server */
    System.out.println(
        "Server IP address: " + serversock.getInetAddress().getHostAddress() + ",  port " + port);

    /* listen on the socket for connections. */
    listen();
  }
 public void run() {
   try {
     LOG.debug("Starting proxy listener for address = '" + bindAddr + "', port = " + port);
     ss = new ServerSocket(port, 5, bindAddr);
     LOG.debug(
         "Proxy is listening for requests on "
             + ss.getInetAddress()
             + " port "
             + ss.getLocalPort());
   } catch (IOException ex) {
     LOG.error("Error while creating / binding the proxy's server socket", ex);
     throw new ServiceException("Startup / restart failed", ex);
   }
   try {
     while (true) {
       try {
         Socket s = ss.accept();
         // FIXME - Use a bounded thread pool executor.
         new Thread(factory.createProcessor(config, mapper, s)).start();
       } catch (InterruptedIOException ex) {
         // FIXME - Synchronously shut down the processor pool.
         LOG.info("Interrupted - we're done");
         break;
       } catch (IOException ex) {
         if (Thread.currentThread().isInterrupted()) {
           LOG.info("Interrupted - we're done (2)");
           break;
         }
         LOG.debug("IO error", ex);
       } catch (Throwable ex) {
         LOG.error("Unexpected exception - proxy listener exiting", ex);
         break;
       }
     }
   } finally {
     try {
       ss.close();
     } catch (IOException ex) {
       LOG.debug("IO error while closing ServerSocket", ex);
     }
   }
 }
Beispiel #29
0
  public static void main(String[] args) {
    try {
      serverPort = getServerPort(args);
      Server httpServer = new Server();

      // Open a server socket to accept incoming request
      // 1. If you want to test the server locally
      serverSocket = new ServerSocket(serverPort, 1, InetAddress.getByName("localhost"));

      // 2. If you want to test the server over network
      // serverSocket = new ServerSocket(serverPort);

      serverIP = serverSocket.getInetAddress().getHostAddress();

      // start the http server
      Thread serverThread = new Thread(httpServer);
      serverThread.start();
    } catch (IOException e) {
      System.out.println("Fatal Server Error!!!!");
      e.printStackTrace();
    }
  }
Beispiel #30
0
  /** The "listen" thread that accepts a connection to the server */
  public void run() {

    Socket socket;

    // accept a connection
    try {
      System.out.println("Bank running, listening for connections on " + server.getInetAddress());
      socket = server.accept();
      System.out.println(
          Calendar.getInstance().getTime()
              + " - Accepted new connection from "
              + socket.getInetAddress());
      handleUser(socket);
      socket.close();
    } catch (IOException e) {
      System.out.println("Class Server died: " + e.getMessage());
      e.printStackTrace();
      return;
    }

    // create a new thread to accept the next connection
    newListener();
  }