private final void socketrun() {
do {
if (link.socketport != 0) {
try {
Socket socket =
new Socket(InetAddress.getByName(getCodeBase().getHost()), link.socketport);
socket.setSoTimeout(30000);
socket.setTcpNoDelay(true);
link.s = socket;
} catch (Exception _ex) {
link.s = null;
}
link.socketport = 0;
}
if (link.runme != null) {
Thread thread = new Thread(link.runme);
thread.setDaemon(true);
thread.start();
link.runme = null;
}
if (link.iplookup != null) {
String s = "unknown";
try {
s = InetAddress.getByName(link.iplookup).getHostName();
} catch (Exception _ex) {
}
link.host = s;
link.iplookup = null;
}
try {
Thread.sleep(100L);
} catch (Exception _ex) {
}
} while (true);
}
public void open(int serverId) {
close();
Server server = ServerManager.getInstance().getServer(serverId);
if (server == null) {
return;
}
try {
socket = new Socket();
///
socket.setKeepAlive(true);
socket.setTcpNoDelay(true);
// socket.setSoLinger(true, 0);
///
socket.connect(new InetSocketAddress(server.getIp(), server.getPort()), 3000);
socket.setTcpNoDelay(true);
socket.setSoTimeout(4000);
in = new DataInputX(new BufferedInputStream(socket.getInputStream()));
out = new DataOutputX(new BufferedOutputStream(socket.getOutputStream()));
// *************//
out.writeInt(NetCafe.TCP_CLIENT);
out.flush();
// *************//
if (server.isConnected() == false) {
System.out.println("Success to connect " + server.getIp() + ":" + server.getPort());
server.setConnected(true);
}
} catch (Throwable t) {
t.printStackTrace();
close();
server.setConnected(false);
}
}
public void run() {
ServerSocket server = null;
try {
server = new ServerSocket(link.getSerPort());
System.out.println("System Online!");
} catch (Exception e) {
e.printStackTrace();
return;
}
try {
Socket remoteSocket = server.accept();
System.out.println("remoteSocket accpet!");
Socket localSocket = server.accept();
System.out.println("localSocket accpet!");
remoteSocket.setSoTimeout(0);
localSocket.setSoTimeout(0);
remoteSocket.setTcpNoDelay(true);
localSocket.setTcpNoDelay(true);
new TransferDown(remoteSocket, localSocket, "ToCZ");
new TransferUp(remoteSocket, localSocket, "ToYonYou");
} catch (Exception e) {
e.printStackTrace();
}
}
private void passTcpFileDescriptor(
LocalSocket fdSocket,
OutputStream outputStream,
String socketId,
String dstIp,
int dstPort,
int connectTimeout)
throws Exception {
Socket sock = new Socket();
sock.setTcpNoDelay(true); // force file descriptor being created
if (protect(sock)) {
try {
sock.connect(new InetSocketAddress(dstIp, dstPort), connectTimeout);
ParcelFileDescriptor fd = ParcelFileDescriptor.fromSocket(sock);
tcpSockets.put(socketId, sock);
fdSocket.setFileDescriptorsForSend(new FileDescriptor[] {fd.getFileDescriptor()});
outputStream.write('*');
outputStream.flush();
fd.detachFd();
} catch (ConnectException e) {
LogUtils.e("connect " + dstIp + ":" + dstPort + " failed");
outputStream.write('!');
sock.close();
} catch (SocketTimeoutException e) {
LogUtils.e("connect " + dstIp + ":" + dstPort + " failed");
outputStream.write('!');
sock.close();
} finally {
outputStream.flush();
}
} else {
LogUtils.e("protect tcp socket failed");
}
}
/**
* Method declaration
*
* @return
*/
private Session init() {
try {
mSocket.setTcpNoDelay(true);
mInput = new DataInputStream(new BufferedInputStream(mSocket.getInputStream()));
mOutput = new DataOutputStream(new BufferedOutputStream(mSocket.getOutputStream()));
user = mInput.readUTF();
String password = mInput.readUTF();
Session c;
try {
mServer.trace(mThread + ":trying to connect user " + user);
return mServer.mDatabase.connect(user, password);
} catch (SQLException e) {
write(new Result(e.getMessage(), e.getErrorCode()).getBytes());
}
} catch (Exception e) {
mServer.trace(mThread + ":couldn't connect " + user);
}
close();
return null;
}
void test() throws Exception {
InetSocketAddress proxyAddress = new InetSocketAddress(proxyHost, proxyPort);
Proxy httpProxy = new Proxy(Proxy.Type.HTTP, proxyAddress);
try (ServerSocket ss = new ServerSocket(0);
Socket sock = new Socket(httpProxy)) {
sock.setSoTimeout(SO_TIMEOUT);
sock.setTcpNoDelay(false);
InetSocketAddress externalAddress =
new InetSocketAddress(InetAddress.getLocalHost(), ss.getLocalPort());
out.println("Trying to connect to server socket on " + externalAddress);
sock.connect(externalAddress);
try (Socket externalSock = ss.accept()) {
// perform some simple checks
check(sock.isBound(), "Socket is not bound");
check(sock.isConnected(), "Socket is not connected");
check(!sock.isClosed(), "Socket should not be closed");
check(sock.getSoTimeout() == SO_TIMEOUT, "Socket should have a previously set timeout");
check(sock.getTcpNoDelay() == false, "NODELAY should be false");
simpleDataExchange(sock, externalSock);
}
}
}
/**
* Establish a connection with the Leader found by findLeader. Retries 5 times before giving up.
*
* @param addr - the address of the Leader to connect to.
* @throws IOException - if the socket connection fails on the 5th attempt
* @throws ConnectException
* @throws InterruptedException
*/
protected void connectToLeader(InetSocketAddress addr)
throws IOException, ConnectException, InterruptedException {
sock = new Socket();
sock.setSoTimeout(self.tickTime * self.initLimit);
for (int tries = 0; tries < 5; tries++) {
try {
sock.connect(addr, self.tickTime * self.syncLimit);
sock.setTcpNoDelay(nodelay);
break;
} catch (IOException e) {
if (tries == 4) {
LOG.error("Unexpected exception", e);
throw e;
} else {
LOG.warn("Unexpected exception, tries=" + tries + ", connecting to " + addr, e);
sock = new Socket();
sock.setSoTimeout(self.tickTime * self.initLimit);
}
}
Thread.sleep(1000);
}
leaderIs = M2mBinaryInputArchive.getArchive(new BufferedInputStream(sock.getInputStream()));
bufferedOutput = new BufferedOutputStream(sock.getOutputStream());
leaderOs = M2mBinaryOutputArchive.getArchive(bufferedOutput);
}
/**
* Create a client socket for the specified InetSocketAddress. Creates an SSL socket if the type
* specified is SSL or SSL_MUTUALAUTH.
*
* @param type
* @param inetSocketAddress
* @return the socket.
*/
public Socket createSocket(String type, InetSocketAddress inetSocketAddress) throws IOException {
try {
String host = inetSocketAddress.getHostName();
int port = inetSocketAddress.getPort();
if (_logger.isLoggable(Level.FINE)) {
_logger.log(Level.FINE, "createSocket(" + type + ", " + host + ", " + port + ")");
}
if (type.equals(SSL) || type.equals(SSL_MUTUALAUTH)) {
return createSSLSocket(host, port);
} else {
Socket socket = null;
if (_logger.isLoggable(Level.FINE)) {
_logger.log(Level.FINE, "Creating CLEAR_TEXT socket for:" + port);
}
if (orb.getORBData().connectionSocketType().equals(ORBConstants.SOCKETCHANNEL)) {
SocketChannel socketChannel = ORBUtility.openSocketChannel(inetSocketAddress);
socket = socketChannel.socket();
} else {
socket = new Socket(inetSocketAddress.getHostName(), inetSocketAddress.getPort());
}
// Disable Nagle's algorithm (i.e. always send immediately).
socket.setTcpNoDelay(true);
return socket;
}
} catch (Exception ex) {
if (_logger.isLoggable(Level.FINE)) {
_logger.log(Level.FINE, "Exception creating socket", ex);
}
throw new RuntimeException(ex);
}
}
/**
* Configures the socket for use
*
* @param sock
* @throws SocketException, IllegalArgumentException if setting the options on the socket failed.
*/
protected void initialiseSocket(Socket sock) throws SocketException, IllegalArgumentException {
if (socketOptions != null) {
IntrospectionSupport.setProperties(socket, socketOptions);
}
try {
sock.setReceiveBufferSize(socketBufferSize);
sock.setSendBufferSize(socketBufferSize);
} catch (SocketException se) {
LOG.warn("Cannot set socket buffer size = " + socketBufferSize);
LOG.debug("Cannot set socket buffer size. Reason: " + se, se);
}
sock.setSoTimeout(soTimeout);
if (keepAlive != null) {
sock.setKeepAlive(keepAlive.booleanValue());
}
if (soLinger > -1) {
sock.setSoLinger(true, soLinger);
} else if (soLinger == -1) {
sock.setSoLinger(false, 0);
}
if (tcpNoDelay != null) {
sock.setTcpNoDelay(tcpNoDelay.booleanValue());
}
if (!this.trafficClassSet) {
this.trafficClassSet = setTrafficClass(sock);
}
}
SocketConnection(Socket socket, int buffersize) throws IOException {
this.socket = socket;
socket.setSoTimeout(30000);
socket.setTcpNoDelay(true);
inputstreamWorker = new InputstreamWorker(socket.getInputStream(), buffersize);
outputstreamWorker = new OutputstreamWorker(socket.getOutputStream(), buffersize);
}
/**
* Listen for one object and place it on the request queue
*
* @throws IOException
* @throws InterruptedException
* @throws RadiusException
*/
public void listen() throws Exception {
RadiusLog.debug("Listening on socket...");
Socket socket = serverSocket.accept();
socket.setTcpNoDelay(false);
if (keepAlive) {
KeepAliveListener keepAliveListener = new KeepAliveListener(socket, this, queue);
keepAliveListener.start();
synchronized (keepAliveListeners) {
keepAliveListeners.add(keepAliveListener);
}
} else {
TCPListenerRequest lr = (TCPListenerRequest) requestObjectPool.borrowObject();
lr.setBorrowedFromPool(requestObjectPool);
lr.accept(socket, this, false, false);
while (true) {
try {
this.queue.put(lr);
break;
} catch (InterruptedException e) {
}
}
}
}
/** Constructor declaration */
public JICPConnection(TransportAddress ta, int timeout) throws IOException {
// #MIDP_EXCLUDE_BEGIN
// For some reason the local address or port may be in use
while (true) {
try {
// #PJAVA_EXCLUDE_BEGIN
sc = new Socket();
bindSocket(sc);
sc.setTcpNoDelay(true);
sc.connect(new InetSocketAddress(ta.getHost(), Integer.parseInt(ta.getPort())), timeout);
// #PJAVA_EXCLUDE_END
/*#PJAVA_INCLUDE_BEGIN
sc = new Socket(ta.getHost(), Integer.parseInt(ta.getPort()));
#PJAVA_INCLUDE_END*/
is = sc.getInputStream();
os = getOutputStream();
break;
} catch (BindException be) {
// Do nothing and try again
}
}
// #MIDP_EXCLUDE_END
/*#MIDP_INCLUDE_BEGIN
String url = "socket://"+ta.getHost()+":"+ta.getPort();
sc = (StreamConnection) Connector.open(url, Connector.READ_WRITE, false);
is = sc.openInputStream();
os = getOutputStream();
#MIDP_INCLUDE_END*/
}
void applySocketParams(Socket s) {
if (sendBuffer > 0) {
try {
s.setSendBufferSize(sendBuffer);
} catch (SocketException e) {
logger.error("error setting sendBuffer to " + sendBuffer, e);
}
}
if (recvBuffer > 0) {
try {
s.setReceiveBufferSize(recvBuffer);
} catch (SocketException e) {
logger.error("error setting recvBuffer to " + recvBuffer, e);
}
}
try {
s.setTcpNoDelay(tcpNoDelay);
} catch (SocketException e) {
logger.error("error setting TcpNoDelay to " + tcpNoDelay, e);
}
try {
s.setKeepAlive(keepAlive);
} catch (SocketException e) {
logger.error("error setting KeepAlive to " + keepAlive, e);
}
}
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();
}
}
private void connect() throws IOException {
Socket tmp = null;
try {
tmp = socketFactory.createSocket();
tmp.setTcpNoDelay(tcpNoDelay);
if (sendBuffer > 0) tmp.setSendBufferSize(sendBuffer);
tmp.bind(bindaddr);
if (tmp instanceof SSLSocket) {
SSLSocket sslsock = (SSLSocket) tmp;
sslsock.setEnabledProtocols(new String[] {tlsProtocol});
sslsock.setEnabledCipherSuites(tlsCiphers);
}
tmp.connect(addr, tcpConnectTimeout);
if (tmp instanceof SSLSocket) {
SSLSocket sslsock = (SSLSocket) tmp;
sslsock.startHandshake();
}
sockout = new BufferedOutputStream(tmp.getOutputStream());
sock = tmp;
tmp = null;
} finally {
if (tmp != null)
try {
tmp.close();
} catch (Exception ignore) {
}
}
}
private void setSocketParameters(Socket client_sock) throws SocketException {
if (log.isTraceEnabled())
log.trace(
"["
+ local_addr
+ "] accepted connection from "
+ client_sock.getInetAddress()
+ ":"
+ client_sock.getPort());
try {
client_sock.setSendBufferSize(send_buf_size);
} catch (IllegalArgumentException ex) {
if (log.isErrorEnabled())
log.error("exception setting send buffer size to " + send_buf_size + " bytes", ex);
}
try {
client_sock.setReceiveBufferSize(recv_buf_size);
} catch (IllegalArgumentException ex) {
if (log.isErrorEnabled())
log.error("exception setting receive buffer size to " + send_buf_size + " bytes", ex);
}
client_sock.setKeepAlive(true);
client_sock.setTcpNoDelay(tcp_nodelay);
if (linger > 0) client_sock.setSoLinger(true, linger);
else client_sock.setSoLinger(false, -1);
}
public SelectionKey accept(Selector selector, SocketChannel socketChannel) throws IOException {
writeBuffer.clear();
readBuffer.clear();
readBuffer.flip();
currentObjectLength = 0;
try {
this.socketChannel = socketChannel;
socketChannel.configureBlocking(false);
Socket socket = socketChannel.socket();
socket.setTcpNoDelay(true);
selectionKey = socketChannel.register(selector, SelectionKey.OP_READ);
if (DEBUG) {
debug(
"kryonet",
"Port "
+ socketChannel.socket().getLocalPort()
+ "/TCP connected to: "
+ socketChannel.socket().getRemoteSocketAddress());
}
lastReadTime = lastWriteTime = System.currentTimeMillis();
return selectionKey;
} catch (IOException ex) {
close();
throw ex;
}
}
@Override
public final void run() {
try {
final TcpPipe enclosing = TcpPipe.this;
Log.log("startup send endpoint for %s @ ", enclosing, soport);
Socket so = new Socket();
so.setKeepAlive(true);
so.setPerformancePreferences(SO_CONNTIME_PREF, SO_LATENCY_PREF, SO_BANDWIDTH_PREF);
so.setTcpNoDelay(true);
so.setSendBufferSize(SO_SND_BUFF_SIZE);
Log.log("... connecting to port %d", soport);
final InetAddress localhost = InetAddress.getLocalHost();
SocketAddress endpoint = new InetSocketAddress(localhost, soport);
so.connect(endpoint);
Log.log("client connected to %s", so.getRemoteSocketAddress());
if (!sndsocket_ref.compareAndSet(null, so))
throw new IllegalStateException("sendInUpdater");
Log.log("-- SND endpoint connected to remote endpoint %s", so.getRemoteSocketAddress());
} catch (Exception e) {
throw new RuntimeException("SND bootstrap failed", e);
} finally {
Log.log("SND endpoint established");
}
}
void serviceClientApp(final Socket socket) throws Throwable {
socket.setTcpNoDelay(true);
final InputStream clientInput = socket.getInputStream();
clientOutput = socket.getOutputStream();
patchNumber = 1;
mainFilePath = readPath(clientInput, false);
byte ok[] = new byte[] {1, 0, 0, 0};
clientOutput.write(ok);
executablePath = readPath(clientInput, true);
new Thread(
new Runnable() {
public void run() {
try {
while (true) {
int bundleLoaded = readInt(clientInput);
}
} catch (IOException e) {
} finally {
try {
socket.close();
} catch (IOException e) {
}
clientOutput = null;
}
}
})
.start();
}
@Override
public void setTcpNoDelay(boolean tcpNoDelay) {
try {
socket.setTcpNoDelay(tcpNoDelay);
} catch (SocketException e) {
throw new ChannelException(e);
}
}
protected void initSocket(Socket socket) throws Exception {
if (ioService.getSocketLingerSeconds() > 0) {
socket.setSoLinger(true, ioService.getSocketLingerSeconds());
}
socket.setKeepAlive(ioService.getSocketKeepAlive());
socket.setTcpNoDelay(ioService.getSocketNoDelay());
socket.setReceiveBufferSize(ioService.getSocketReceiveBufferSize() * KILO_BYTE);
socket.setSendBufferSize(ioService.getSocketSendBufferSize() * KILO_BYTE);
}
@Override
public void open() throws IOException {
if (_socket != null) {
_socket.close();
}
_socket = new java.net.Socket(this._host, this._port);
// Disable Nagle's algorithm, preventing delays in sending bundles to the daemon
_socket.setTcpNoDelay(true);
}
/** @param on */
public final void setTcpNoDelay(boolean on) {
try {
sock.setTcpNoDelay(on);
} catch (SocketException e) {
/*
* Mantem o default em caso de excep��o.
*/
}
}
public TcpSocketPeer(Socket socket) {
this.socket = socket;
// turn off Nagle's algorithm since we should
// always be doing buffering in the virtual machine
try {
socket.setTcpNoDelay(true);
} catch (Exception e) {
}
}
/** 启动服务，监听端口用于接收联通上行信息 */
public void startSvr() throws IOException {
while (true) {
Socket unicomSocket = null;
unicomSocket = spsvrSocket.accept();
unicomSocket.setSoLinger(true, 0); // socket关闭时，不再发送缓冲区里的数据，立即释放低层资源
unicomSocket.setTcpNoDelay(true); // 不使用缓冲区，立即发送数据
unicomSocket.setTrafficClass(0x04 | 0x10);
exec.execute(new DealThread(unicomSocket));
}
}
/* ------------------------------------------------------------ */
protected void configure(Socket socket) throws IOException {
try {
socket.setTcpNoDelay(true);
if (_maxIdleTime >= 0) socket.setSoTimeout(_maxIdleTime);
if (_soLingerTime >= 0) socket.setSoLinger(true, _soLingerTime / 1000);
else socket.setSoLinger(false, 0);
} catch (Exception e) {
Log.ignore(e);
}
}
public void setAcceptedSocketOptions(Acceptor acceptor, ServerSocket serverSocket, Socket socket)
throws SocketException {
if (_logger.isLoggable(Level.FINE)) {
_logger.log(
Level.FINE, "setAcceptedSocketOptions: " + acceptor + " " + serverSocket + " " + socket);
}
// Disable Nagle's algorithm (i.e., always send immediately).
socket.setTcpNoDelay(true);
}
/**
* Open the Socket to the destination endpoint and
*
* @return the open java Socket.
* @throws IOException
*/
public Socket connect() throws IOException {
LOG.info("Connecting to endpoint: " + endpoint);
socket = new Socket();
socket.setTcpNoDelay(true);
socket.connect(endpoint, 1000);
out = socket.getOutputStream();
in = socket.getInputStream();
return socket;
}
/** Initializes the socket object */
private void initSocket() {
socket_ = new Socket();
try {
socket_.setSoLinger(false, 0);
socket_.setTcpNoDelay(true);
socket_.setKeepAlive(true);
socket_.setSoTimeout(timeout_);
} catch (SocketException sx) {
LOGGER.error("Could not configure socket.", sx);
}
}
@Override
public void run() {
while (datanode.shouldRun) {
Socket s = null;
try {
s = ss.accept();
s.setTcpNoDelay(true);
// Timeouts are set within DataXceiver.run()
// Make sure the xceiver count is not exceeded
int curXceiverCount = datanode.getXceiverCount();
if (curXceiverCount > maxXceiverCount) {
throw new IOException(
"Xceiver count "
+ curXceiverCount
+ " exceeds the limit of concurrent xcievers: "
+ maxXceiverCount);
}
new Daemon(datanode.threadGroup, DataXceiver.create(s, datanode, this)).start();
} catch (SocketTimeoutException ignored) {
// wake up to see if should continue to run
} catch (AsynchronousCloseException ace) {
// another thread closed our listener socket - that's expected during shutdown,
// but not in other circumstances
if (datanode.shouldRun) {
LOG.warn(datanode.getDisplayName() + ":DataXceiverServer: ", ace);
}
} catch (IOException ie) {
IOUtils.closeSocket(s);
LOG.warn(datanode.getDisplayName() + ":DataXceiverServer: ", ie);
} catch (OutOfMemoryError ie) {
IOUtils.closeSocket(s);
// DataNode can run out of memory if there is too many transfers.
// Log the event, Sleep for 30 seconds, other transfers may complete by
// then.
LOG.warn("DataNode is out of memory. Will retry in 30 seconds.", ie);
try {
Thread.sleep(30 * 1000);
} catch (InterruptedException e) {
// ignore
}
} catch (Throwable te) {
LOG.error(datanode.getDisplayName() + ":DataXceiverServer: Exiting due to: ", te);
datanode.shouldRun = false;
}
}
try {
ss.close();
} catch (IOException ie) {
LOG.warn(datanode.getDisplayName() + " :DataXceiverServer: close exception", ie);
}
}