Newbie question on trying to create multiple sockets (connections) to same port

[Melinda Savoy]

In the code below, I establish the first connection without issue however, when I come back around in my while statement (highlighted in BOLD RED below) at the newSocket = serverSocket.accept(); line my program stops there. The objective is to allow multiple connections to one PORT. I'm in the middle of re-factoring an inherited application that has been working but only allowing one connection to one port at a time. This is my first crack at socket programming and any suggestions/direction would be greatly appreciated. Thanks.

Here is the code that I'm working with:

public void connect() {		
		
		LOGGER.info("Connecting ... ");
		while (!shouldTerminate) {
						
			ActiveSocket activeSocket = null;
			Socket newSocket = null;
			int tries = 0;
			int loopCounter = 0;
			
			if (isServer) {
				if (host == null) {
					LOGGER.info("Must specify a host ip or host name with HOST configuration tag ");
					return;
				} else {
					// keep accepting new socket connections until you have max active sockets
					while (!shouldTerminate && (activeSockets.size() < this.maxActiveSockets)) {
						activeSocket = new ActiveSocket();
						newSocket = null;		
						if (serverSocket != null) {							
							try {
								LOGGER.info("Accept socket ");
								[color=red][b]newSocket = serverSocket.accept();[/b][/color]
							} catch (final IOException ex) {
								if (shouldTerminate) {
									if (ex.getMessage() != null) {
										LOGGER.info(ex.getMessage());
									}
								} else {
									LOGGER.info("IOException while accepting connection ");
									LOGGER.warn(FormatData.fullStackTrace(ex));
								}
								newSocket = null;
							}
							if (newSocket != null) {
								try {
									LOGGER.info("Socket keepalive ... ");
									newSocket.setKeepAlive(true);									
									activeSocket.setSocket(newSocket);
									increaseConnects();
								} catch (final SocketException ex) {
									LOGGER.info("SocketException while opening socket ");
									LOGGER.warn(FormatData.fullStackTrace(ex));
									newSocket = null;
								}
							}
						} else { // first time through the loop
							try {
								LOGGER.info("Opening server socket (" + host + "," + port + ") for BankID:" + Integer.toString(this.getBankID()));
								serverSocket = new ServerSocket(port);
							} catch (final IOException ex) {
								LOGGER.info("Unable to open server socket socket (" + host + "," + port + ")");
								if (ex.getMessage().indexOf("Cannot assign requested address") > -1) {
									this.terminate();
									final String logMessage = "Invalid IP Address assigned:" + host + ",port:" + port;
									final String subject = logMessage;
									ATMServer.sendNotification(subject, logMessage);
								} else if (tries == 0) {
									tries++;
									final String logMessage = "Unable to open server socket (" + host + "," + port + ")";
									final String subject = "Unable to open server socket (" + host + "," + port + ")";
									ATMServer.sendNotification(subject, logMessage);
								}
								LOGGER.warn(FormatData.fullStackTrace(ex));
							}
						}
					}
				}
			} else { // client socket -- connecting to a bank
				LOGGER.info("Not server and terminal type is null ");
				while (!shouldTerminate && (activeSockets.size() < this.maxActiveSockets)) { 
					activeSocket = new ActiveSocket();
					newSocket = null;
					if (this.isInForcedStandIn()) {
						LOGGER.info("Forced standin " + getName());
						try {
							Thread.sleep(3000); // @TODO switch to a
												// notification when not in
												// standin
						} catch (final InterruptedException ex) {
							LOGGER.info("Interrupted while waiting for connection ");
							LOGGER.warn(FormatData.fullStackTrace(ex));
						}
					} else {
						if (!shouldTerminate) {
							if ((loopCounter % 120) == 0) {
								try {
									LOGGER.info("Connecting to host (" + remoteHost + "," + remotePort + ") for BankID:" + Integer.toString(this.getBankID()));
									newSocket = new Socket(InetAddress.getByName(remoteHost), remotePort);
									if (newSocket.isConnected()) {
										tries = 0;
										LOGGER.info("socket connected to host (" + remoteHost + "," + remotePort + ") for BankID:" + Integer.toString(this.getBankID()));
									}

									newSocket.setKeepAlive(true);
									if (newSocket.getKeepAlive()) {
										LOGGER.info("socket keep alive to host (" + remoteHost + "," + remotePort + ") for BankID:" + Integer.toString(this.getBankID()));
									}
									activeSocket.setSocket(newSocket);
									increaseConnects();
								} catch (final IOException ex) {
									loopCounter++;
									tries++;
									LOGGER.info("SocketException while opening remote socket (" + remoteHost + "," + remotePort + ") " + " " + ex.getClass() + " " + ex.getMessage());

									if ((tries % 300) == 0) {
										recordErrorToDatabase(ex.getMessage());
									}
								}
							} else {
								loopCounter++;
								try {
									synchronized (clientConnectLock) {
										clientConnectLock.wait(1000);
									}
								} catch (final InterruptedException inex) {
									LOGGER.info("SocketException while opening remote socket " + Thread.currentThread().getName());
									LOGGER.warn(FormatData.fullStackTrace(inex));
									if (!this.shouldTerminate) {
										recordErrorToDatabase("InterruptedException without terminate set.");
									}
								}
							}
						}
					}
				}
			}
			try {
				// here, if we created a new ActiveSocket, establish dataInput and dataOuput streams
				// then add to the list of active streams.
				// for Discover, this will mean adding up to MaxActiveSockets # of sockets
				// to the activeSockets list.
				// for each other SwitchChannel, this will be the only activeSocket
				if (activeSocket != null) {
					LOGGER.info("Creating serverIn/serverOut data streams " + Thread.currentThread().getName());
					DataInputStream dataInputStream = new DataInputStream(new BufferedInputStream(newSocket.getInputStream()));
					if (newSocket.isConnected()) {
						LOGGER.info("socket still connected to host (" + remoteHost + "," + remotePort + ") for BankID:" + Integer.toString(this.getBankID()));
					}
					DataOutputStream dataOutputStream = new DataOutputStream(new BufferedOutputStream(newSocket.getOutputStream(), 2048));
					activeSocket.setDataInputStream(dataInputStream);
					activeSocket.setDataOutputStream(dataOutputStream);
					activeSockets.add(activeSocket);
					activeSocket.setNumReceivers(this.numReceivers);
					ReceiveQueuer[] receiveQueuers = activeSocket.getReceiveQueuers();
					LOGGER.info("Starting receive queuers");
					for (int cnt = 0; cnt < numReceivers; cnt++) {
						receiveQueuers[cnt].setName(this.systemName + "-Socket-" + Integer.toString(activeSockets.size()) + "-ReceiveQueuer-" + Integer.toString(cnt));
						receiveQueuers[cnt].setActiveSocket(activeSocket);
						receiveQueuers[cnt].start();
					}
				}
			} catch (final Exception ex) {
				LOGGER.info("Exception while creating input/output streams " + Thread.currentThread().getName());
				LOGGER.warn(FormatData.fullStackTrace(ex));
			}
		}
		if (!shouldTerminate) {
			LOGGER.info("Socket connection complete " + Thread.currentThread().getName());
		} else {
			LOGGER.info("Stopped establishing socket connection " + Thread.currentThread().getName());
		}
}