/** Create the serversocket and use its stream to receive serialized objects */ public static void main(String args[]) { ServerSocket ser = null; Socket soc = null; String str = null; Date d = null; try { ser = new ServerSocket(8020); /* * This will wait for a connection to be made to this socket. */ soc = ser.accept(); InputStream o = soc.getInputStream(); ObjectInput s = new ObjectInputStream(o); str = (String) s.readObject(); d = (Date) s.readObject(); s.close(); // print out what we just received System.out.println(str); System.out.println(d); } catch (Exception e) { System.out.println(e.getMessage()); System.out.println("Error during serialization"); System.exit(1); } }
private void server() { new CountDown(60).start(); while (true) { try { Socket socket = serverSock.accept(); System.out.println("New Client:" + socket); if (readyState[6] == 1) { System.out.println("正在游戏中,无法加入"); continue; } for (i = 0; i <= 5; i++) { if (players[i].equals("虚位以待")) break; } if (i > 5) { System.out.println("房间已满,无法加入"); continue; } i++; ObjectOutputStream remoteOut = new ObjectOutputStream(socket.getOutputStream()); clients.addElement(remoteOut); ObjectInputStream remoteIn = new ObjectInputStream(socket.getInputStream()); new ServerHelder(remoteIn, remoteOut, socket.getPort(), i).start(); } catch (IOException e) { System.out.println(e.getMessage() + ": Failed to connect to client."); try { serverSock.close(); } catch (IOException x) { System.out.println(e.getMessage() + ": Failed to close server socket."); } } } }
public void run() throws IOException { ServerSocket server = new ServerSocket(this.portNumber); this.socket = server.accept(); this.socket.setTcpNoDelay(true); server.close(); DataInputStream in = new DataInputStream(this.socket.getInputStream()); final DataOutputStream out = new DataOutputStream(this.socket.getOutputStream()); while (true) { final String className = in.readUTF(); Thread thread = new Thread() { public void run() { try { loadAndRun(className); out.writeBoolean(true); System.err.println(VerifyTests.class.getName()); System.out.println(VerifyTests.class.getName()); } catch (Throwable e) { e.printStackTrace(); try { System.err.println(VerifyTests.class.getName()); System.out.println(VerifyTests.class.getName()); out.writeBoolean(false); } catch (IOException e1) { // ignore } } } }; thread.start(); } }
/** List file names */ public Enumeration nlst(String s) throws IOException { InetAddress inetAddress = InetAddress.getLocalHost(); byte ab[] = inetAddress.getAddress(); serverSocket_ = new ServerSocket(0, 1); StringBuffer sb = new StringBuffer(32); sb.append("PORT "); for (int i = 0; i < ab.length; i++) { sb.append(String.valueOf(ab[i] & 255)); sb.append(","); } sb.append(String.valueOf(serverSocket_.getLocalPort() >>> 8 & 255)); sb.append(","); sb.append(String.valueOf(serverSocket_.getLocalPort() & 255)); if (issueCommand(sb.toString()) != FTP_SUCCESS) { serverSocket_.close(); throw new IOException(getResponseString()); } else if (issueCommand("NLST " + ((s == null) ? "" : s)) != FTP_SUCCESS) { serverSocket_.close(); throw new IOException(getResponseString()); } dataSocket_ = serverSocket_.accept(); serverSocket_.close(); serverSocket_ = null; Vector v = readServerResponse_(dataSocket_.getInputStream()); dataSocket_.close(); dataSocket_ = null; return (v == null) ? null : v.elements(); }
/** Creates the server. */ public static void main(String args[]) { client = null; ServerSocket server = null; try { System.out.print("\nCreating Server...\n"); // creates the server server = new ServerSocket(8008); System.out.print("Created\n"); // get the ip Address and the host name. InetAddress localAddr = InetAddress.getLocalHost(); System.out.println("IP address: " + localAddr.getHostAddress()); System.out.println("Hostname: " + localAddr.getHostName()); } catch (IOException e) { // sends a System.out.println("IO" + e); } // constantly checks for a new aocket trying to attach itself to the trhead while (true) { try { client = server.accept(); // create a new thread. FinalMultiThread thr = new FinalMultiThread(client); System.out.print(client.getInetAddress() + " : " + thr.getUserName() + "\n"); CliList.add(thr); current++; thr.start(); } catch (IOException e) { System.out.println(e); } } }
/** Listens for client requests until stopped. */ public void run() { try { while (listener != null) { try { Socket socket = serverSocket.accept(); if (!paranoid || checkSocket(socket)) { Runner runner = getRunner(); runner.handle(socket); // new Connection (socket); } else socket.close(); } catch (Exception ex) { System.err.println("Exception in XML-RPC listener loop (" + ex + ")."); } catch (Error err) { System.err.println("Error in XML-RPC listener loop (" + err + ")."); } } } catch (Exception exception) { System.err.println("Error accepting XML-RPC connections (" + exception + ")."); } finally { System.err.println("Closing XML-RPC server socket."); try { serverSocket.close(); serverSocket = null; } catch (IOException ignore) { } } }
public static void main(String args[]) throws IOException { ServerSocket sSocket = new ServerSocket(sPort, 10); // Arguments Handling if (args.length != 1) { System.out.println("Must specify a file-path argument."); } else { String currentDir = System.getProperty("user.dir"); filePath = currentDir + "/src/srcFile/" + args[0]; filename = args[0]; } // Get list of chunks owned chunkOwned(); // Call FileSplitter FileSplitter fs = new FileSplitter(); fs.split(filePath); System.out.println("Waiting for connection"); while (true) { Socket connection = sSocket.accept(); System.out.println("Connection received from " + connection.getInetAddress().getHostName()); new Thread(new MultiThreadServer(connection)).start(); } }
/** * creates a server socket listening on port specified in the object constructor, and then * enters an infinite loop waiting for incoming socket connection requests representing a worker * process attempting to connect to this server, which it handles via the enclosing server's * <CODE>addNewWorkerConnection(s)</CODE> method. */ public void run() { try { ServerSocket ss = new ServerSocket(_port); System.out.println("Srv: Now Accepting Worker Connections"); while (true) { try { Socket s = ss.accept(); System.out.println("Srv: Incoming New Worker Connection to the Network"); System.out.println( "Srv: Thread may have to wait if an init_cmd has not yet arrived from the client"); addNewWorkerConnection(s); System.out.println("Srv: finished adding new worker connection to the _workers"); } catch (Exception e) { utils.Messenger.getInstance() .msg( "PDBTExecSingleCltWrkInitSrv.W2Thread.run(): " + "An error occured while adding new worker connection", 2); // e.printStackTrace(); } } } catch (IOException e) { // e.printStackTrace(); utils.Messenger.getInstance() .msg( "PDBTExecSingleCltWrkInitSrv.W2Thread.run(): " + "Failed to create Server Socket, Server exiting.", 0); System.exit(-1); } }
/** * creates a server socket listening on the port specified in the parameter of the constructor, * and waits for a single incoming client connection which it handles by invoking the <CODE> * addNewClientConnection(s)</CODE> method of the enclosing server, and then the thread exits. */ public void run() { try { ServerSocket ss = new ServerSocket(_port); System.out.println("Srv: Now Accepting Single Client Connection"); // while (true) { try { Socket s = ss.accept(); System.out.println("Srv: Client Added to the Network"); addNewClientConnection(s); System.out.println("Srv: finished adding client connection"); } catch (Exception e) { // e.printStackTrace(); System.err.println("Client Connection failed, exiting..."); System.exit(-1); } // } } catch (IOException e) { // e.printStackTrace(); utils.Messenger.getInstance() .msg( "PDBTExecSingleCltWrkInitSrv.C2Thread.run(): " + "Failed to create Server Socket, Server exiting.", 0); System.exit(-1); } }
@Override public void run() { List<Socket> inProgress = new ArrayList<>(); ServerSocketFactory factory = ServerSocketFactory.getDefault(); try { ss = factory.createServerSocket(0); ss.setSoTimeout(5000); socketReadyLatch.countDown(); while (!interrupted()) { inProgress.add(ss.accept()); // eat socket } } catch (java.net.SocketTimeoutException expected) { } catch (Exception e) { e.printStackTrace(); } finally { try { ss.close(); } catch (IOException ignored) { } for (Socket s : inProgress) { try { s.close(); } catch (IOException ignored) { } } } }
public static void main(String[] args) throws IOException { ServerSocket serverSocket = null; try { serverSocket = new ServerSocket(10008); System.out.println("Enroll: 130050131071"); System.out.println("Connection Socket Created"); try { while (true) { System.out.println("Waiting for Connection"); new EchoServer2(serverSocket.accept()); } } catch (IOException e) { System.err.println("Accept failed."); System.exit(1); } } catch (IOException e) { System.err.println("Could not listen on port: 10008."); System.exit(1); } finally { try { serverSocket.close(); } catch (IOException e) { System.err.println("Could not close port: 10008."); System.exit(1); } } }
public static void main(String[] args) throws IOException { ServerSocket serverSocket = null; try { serverSocket = new ServerSocket(PORT); } catch (IOException e) { System.err.println("Could not listen on port: " + PORT + "."); System.exit(1); } while (true) { Socket clientSocket = null; try { clientSocket = serverSocket.accept(); startTime = System.currentTimeMillis(); } catch (IOException e) { System.err.println("Accept failed."); System.exit(1); } PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true); BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream())); String inputLine, outputLine; while ((inputLine = in.readLine()) != null) { if (messageCount.get(clientSocket) == null) { messageCount.put(clientSocket, 1); } else { messageCount.put(clientSocket, messageCount.get(clientSocket) + 1); } overallMessageCount += 1; System.out.println("---------------------------------------"); System.out.println("Client: " + clientSocket.toString()); System.out.println( "aktive since " + ((System.currentTimeMillis() - startTime) / 1000) + " seconds"); System.out.println(new Date(System.currentTimeMillis())); System.out.println("Overall Message Count: " + overallMessageCount); System.out.println("Message Count from Client: " + messageCount.get(clientSocket)); System.out.println("Message " + inputLine); System.out.println("---------------------------------------"); outputLine = inputLine.toUpperCase(); if (outputLine.equals("END")) { out.println("abort"); break; } out.println(outputLine); } out.close(); in.close(); clientSocket.close(); System.out.println("All Closed"); } // serverSocket.close(); }
public void startServer() throws Exception { while (true) { Socket s = server.accept(); cClient.add(new ClientConn(s)); ta.append("NEW-CLIENT " + s.getInetAddress() + ":" + s.getPort()); ta.append("\n" + "CLIENTS-COUNT: " + cClient.size() + "\n\n"); } }
public static void main(String args[]) throws Exception { int count = 0; ServerSocket serv = null; InputStream in = null; OutputStream out = null; Socket sock = null; int clientId = 0; Map<Integer, Integer> totals = new HashMap<Integer, Integer>(); try { serv = new ServerSocket(8888); } catch (Exception e) { e.printStackTrace(); } while (serv.isBound() && !serv.isClosed()) { System.out.println("Ready..."); try { sock = serv.accept(); in = sock.getInputStream(); out = sock.getOutputStream(); char c = (char) in.read(); System.out.print("Server received " + c); switch (c) { case 'r': clientId = in.read(); totals.put(clientId, 0); out.write(0); break; case 't': clientId = in.read(); int x = in.read(); System.out.print(" for client " + clientId + " " + x); Integer total = totals.get(clientId); if (total == null) { total = 0; } totals.put(clientId, total + x); out.write(totals.get(clientId)); break; default: int x2 = in.read(); int y = in.read(); System.out.print(" " + x2 + " " + y); out.write(x2 + y); } System.out.println(""); out.flush(); } catch (Exception e) { e.printStackTrace(); } finally { if (out != null) out.close(); if (in != null) in.close(); if (sock != null) sock.close(); } } }
public void startServer() throws IOException { serverSock = new ServerSocket(); serverSock.bind(new InetSocketAddress(ip, port)); System.out.println("You have connected"); while (true) { Socket socket = serverSock.accept(); // Remember that .accept is a blocking call. handleClient(socket); } }
private void acceptConnections() { for (; ; ) { try { String handlerName = fullName + "-Handler-" + Thread.activeCount(); new Thread(new ClientHandler(socket.accept()), handlerName).start(); } catch (Exception ex) { Log.warn(fullName + ": exception accepting connection.", ex); } } }
@Override public void run() { isActive = true; try { serverSocket = new ServerSocket(Utils.getLOCAL_PORT()); notifyStatusListeners( Messages.getInstance() .getString( "T_NET_SERVER_LISTENING_ON_PORT", Integer.toString(Utils.getLOCAL_PORT()))); // $NON-NLS-1$ } catch (IOException e) { if (e instanceof BindException) { notifyStatusListeners( Messages.getInstance() .getString( "T_PORT_ALREADY_IN_USE", Integer.toString(Utils.getLOCAL_PORT()))); // $NON-NLS-1$ } else e.printStackTrace(); isActive = false; } while (isActive) { try { listenSocket = serverSocket.accept(); ois = new ObjectInputStream(listenSocket.getInputStream()); oos = new ObjectOutputStream(listenSocket.getOutputStream()); receivedMessage = ois.readInt(); System.out.println(messageToString(receivedMessage)); switch (receivedMessage) { case CONNECT: handleConnect(); break; case SEND_CODE: handleSendCode(); break; case KEEP_ALIVE: handleKeepAlive(); break; case DISCONNECT: handleDisconnect(); break; } ois.close(); oos.close(); } catch (IOException e) { System.out.println(e.getMessage()); } finally { if (listenSocket != null) try { listenSocket.close(); } catch (IOException e) { e.printStackTrace(); } } } }
/** launches the administration of the switch */ private void runAdmin() { try { final ServerSocket ss = new ServerSocket(admin_port); while ( /*!this.stop &&*/ !Main.stop) { // Idealement, il faurait gerer un pool de threads Socket s = ss.accept(); new Thread(new AdminSwitch(this, s)).start(); } } catch (IOException e) { System.err.println("pb de connection admin switch"); } }
/** Starts the server. */ public void start() { System.out.println("JavaChat server started on port " + PORT_NUMBER + "!"); try { ServerSocket s = new ServerSocket(PORT_NUMBER); for (; ; ) { Socket incoming = s.accept(); new ClientHandler(incoming).start(); } } catch (Exception e) { e.printStackTrace(); } System.out.println("JavaChat server stopped."); }
private static void handleClient() { Socket link = null; try { link = serverSocket.accept(); Scanner input = new Scanner(link.getInputStream()); PrintWriter output = new PrintWriter(link.getOutputStream(), true); int numMessages = 0; String message = input.nextLine(); while (!message.equals("***CLOSE***")) { System.out.println("Message received."); numMessages++; int messageLength = message.length(); String newMessage = ""; int charcount = 0; // String[] newMessage = null; for (int i = 0; i < messageLength; i++) { if (charcount < 2) { charcount = countChars( message, message.charAt( i)); // This loops through the whole message and counts for the char at // string[i] newMessage += "" + message.charAt(i) + charcount + ", "; } // newMessage[i] = "" + message.charAt(i) + charcount + ", "; } /*String finalMessage = ""; for (int i = 0; i < newMessage.length; i++) { finalMessage += newMessage[i]; }*/ output.println("Message " + numMessages + ": " + newMessage); message = input.nextLine(); } output.println(numMessages + " messages received"); } catch (IOException ioEx) { ioEx.printStackTrace(); } finally { try { System.out.println("\nClosing connection ..."); link.close(); } catch (IOException ioEx) { System.out.println("Unable to disconnect!"); System.exit(1); } } }
public void run() { try { while (true) { Socket client = listen.accept(); System.out.println("Eingehende Verbindung..."); connection c = new connection(this, client); connections.addElement(c); } } catch (IOException e) { System.err.println("Fehler beim Warten auf Verbindungen: " + e); System.exit(1); } }
public void run() { try { while (true) { Socket link = server.accept(); String id = Name + "_" + idCount; idCount++; Responder r = new Responder(); Session ias = new Session(id, this, link, r); clients.add(ias); Log.info(Name + ": Added client " + ias.sid); } } catch (Exception e) { Log.severe(Name + ": run " + e.toString()); } }
public void launch() { try { ss = new ServerSocket(8888); started = true; System.out.println("server is start!"); while (started) { s = ss.accept(); VClient vc = new VClient(s); clients.add(vc); new Thread(vc).start(); } ss.close(); } catch (IOException e) { e.printStackTrace(); } }
/** Runs the listening thread that allows clients to connect. Not to be called. */ public final void run() { // call the hook method to notify that the server is starting readyToStop = false; // added in version 2.31 serverStarted(); try { // Repeatedly waits for a new client connection, accepts it, and // starts a new thread to handle data exchange. while (!readyToStop) { try { // Wait here for new connection attempts, or a timeout Socket clientSocket = serverSocket.accept(); // When a client is accepted, create a thread to handle // the data exchange, then add it to thread group synchronized (this) { if (!readyToStop) // added in version 2.2 { if (connectionFactory == null) { new ConnectionToClient(this.clientThreadGroup, clientSocket, this); } else { // added in version 2.3 connectionFactory.createConnection(this.clientThreadGroup, clientSocket, this); } } } } catch (InterruptedIOException exception) { // This will be thrown when a timeout occurs. // The server will continue to listen if not ready to stop. } } } catch (IOException exception) { if (!readyToStop) { // Closing the socket must have thrown a SocketException listeningException(exception); } } finally { readyToStop = true; connectionListener = null; // call the hook method to notify that the server has stopped serverStopped(); // moved in version 2.31 } }
/** Accepts connections */ public void run() { Socket client = null; try { client = socket.accept(); new Thread(this).start(); getMessage(client); } catch (IOException ex) { Logging.getLogger().warning("#Err > Unable to accept connections."); } try { client.close(); } catch (Exception ex) { Logging.getLogger().warning("#Err > Socket::close()"); } }
public void run() { Socket socket = null; try { host = InetAddress.getLocalHost().getHostAddress(); l.setText("Adres servera : " + host); serverSocket = new ServerSocket(port); JOptionPane.showMessageDialog(null, "Serwer dzia³a na adresie " + host); while (true) { socket = serverSocket.accept(); if (socket != null) { sList.add(new ServerThread(socket, clientList, this)); } } } catch (Exception e) { } }
public ChatServer(int port) { // constructor portNumber = port; try { serverSock = new ServerSocket(portNumber); System.out.println( "ChatServer started on port " + portNumber + " at " + new Date().toString()); // then, wait for a client to connect into while (true) { clientSock = serverSock.accept(); // after accept a connection, fork a thread to handle it new ClientThread(clientSock).start(); // 用thread 處理連線 /// ClientThread guest = new ClientThread(clientSock); /// guest.start( ); // it will call run( ) } } catch (Exception e) { System.err.println("Cannot startup ChatServer!"); } } // ChatServer constructor
public void run() { boolean status; sf.DEBUG("Listen server running."); // open up our server socket try { m_serverSocket = new ServerSocket(m_nPort); } catch (IOException e) { sf.VERBOSE("Could not listen on port: " + m_nPort); if (sf.cntrlWndw != null) { sf.cntrlWndw.ClearListenServer(); } return; } sf.VERBOSE("Listening for client connections on port " + m_nPort); // if (SerialForward.bSourceSim) // { SetDataSource(); sf.InitSerialPortIO(); // } // start listening for connections try { ClientServicer rcv; Socket currentSocket; while (!m_bShutdown) { currentSocket = m_serverSocket.accept(); ClientServicer newServicer = new ClientServicer(currentSocket, sf, this); newServicer.start(); vctServicers.add(newServicer); } m_serverSocket.close(); } catch (IOException e) { /*try { this.sleep(500); } catch (Exception e2) { }*/ sf.VERBOSE("Server Socket closed"); } finally { ShutdownAllClientServicers(); if (sf.serialPortIO != null) sf.serialPortIO.Shutdown(); sf.VERBOSE("--------------------------"); if (sf.cntrlWndw != null) { sf.cntrlWndw.ClearListenServer(); } } }
public void run() { try { while (true) { Socket nsk; try { nsk = sk.accept(); } catch (IOException e) { break; } new Client(nsk); } } finally { try { sk.close(); } catch (IOException e) { throw (new RuntimeException(e)); } } }
public void run() { while (true) { try { System.out.println( "TCP Server waiting for client on port " + serverSocket.getLocalPort() + "..."); Socket server = serverSocket.accept(); System.out.println("Just received request from " + server.getRemoteSocketAddress()); /* parsing a request from socket */ DataInputStream in = new DataInputStream(server.getInputStream()); String request = in.readUTF(); System.out.println("Request: " + request); /* handle the request */ String output = null; output = requestHandler(request); System.out.print(output); /* display dataTable */ System.out.print("-dataTable--------\n"); Enumeration<String> key = dataTable.keys(); while (key.hasMoreElements()) { String str = key.nextElement(); System.out.println(str + ": " + dataTable.get(str)); } System.out.print("------------------\n"); /* send the result back to the client */ DataOutputStream out = new DataOutputStream(server.getOutputStream()); out.writeUTF(output); server.close(); } catch (SocketTimeoutException s) { System.out.println("Socket timed out!"); break; } catch (IOException e) { e.printStackTrace(); break; } } }