← Back to branch summary

~ubuntu-branches/ubuntu/raring/libjboss-remoting-java/raring

« back to all changes in this revision

Viewing changes to src/main/org/jboss/remoting/transport/multiplex/VirtualSocket.java

  • Committer: Package Import Robot
  • Author(s): Torsten Werner
  • Date: 2011-09-09 14:01:03 UTC
  • mfrom: (1.1.6 upstream)
  • Revision ID: package-import@ubuntu.com-20110909140103-hqokx61534tas9rg
Tags: 2.5.3.SP1-1
http://bugs.debian.org/628303
* Newer but not newest upstream release. Do not build samples.
* Change debian/watch to upstream's svn repo.
* Add patch to fix compile error caused by tomcat update.
  (Closes: #628303)
* Switch to source format 3.0.
* Switch to debhelper level 7.
* Remove useless Depends.
* Update Standards-Version: 3.9.2.
* Update README.source.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/main/org/jboss/remoting/transport/multiplex/VirtualSocket.java
 
1
/*
 
2
* JBoss, Home of Professional Open Source
 
3
* Copyright 2005, JBoss Inc., and individual contributors as indicated
 
4
* by the @authors tag. See the copyright.txt in the distribution for a
 
5
* full listing of individual contributors.
 
6
*
 
7
* This is free software; you can redistribute it and/or modify it
 
8
* under the terms of the GNU Lesser General Public License as
 
9
* published by the Free Software Foundation; either version 2.1 of
 
10
* the License, or (at your option) any later version.
 
11
*
 
12
* This software is distributed in the hope that it will be useful,
 
13
* but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 
15
* Lesser General Public License for more details.
 
16
*
 
17
* You should have received a copy of the GNU Lesser General Public
 
18
* License along with this software; if not, write to the Free
 
19
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 
20
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
 
21
*/
 
22
 
 
23
/*
 
24
 * Created on Jul 22, 2005
 
25
 */
 
26
 
 
27
package org.jboss.remoting.transport.multiplex;
 
28
 
 
29
import org.jboss.logging.Logger;
 
30
 
 
31
import java.io.IOException;
 
32
import java.io.InputStream;
 
33
import java.io.OutputStream;
 
34
import java.net.InetAddress;
 
35
import java.net.InetSocketAddress;
 
36
import java.net.Socket;
 
37
import java.net.SocketAddress;
 
38
import java.net.SocketException;
 
39
import java.net.SocketImpl;
 
40
import java.net.SocketTimeoutException;
 
41
import java.net.UnknownHostException;
 
42
import java.nio.channels.SocketChannel;
 
43
import java.util.HashMap;
 
44
import java.util.HashSet;
 
45
import java.util.Iterator;
 
46
import java.util.Map;
 
47
import java.util.Set;
 
48
 
 
49
/**
 
50
 * <code>VirtualSocket</code> represents an endpoint on a virtual connection created by the
 
51
 * Multiplex system.  It extends <code>java.net.Socket</code> and reimplements nearly all of
 
52
 * the methods in <code>java.net.Socket</code>.  For information about method behavior, please
 
53
 * see the <code>java.net.Socket</code> javadoc.  For more information about the nature of
 
54
 * virtual sockets, please see the Multiplex documentation at the labs.jboss.org
 
55
 * web site.
 
56
 *
 
57
 * <p>
 
58
 * Copyright (c) 2005
 
59
 * <p>
 
60
 * @author <a href="mailto:r.sigal@computer.org">Ron Sigal</a>
 
61
 * 
 
62
 * @deprecated As of release 2.4.0 the multiplex transport will no longer be actively supported.
 
63
 */
 
64
public class VirtualSocket extends Socket
 
65
{
 
66
   protected static final Logger log = Logger.getLogger(VirtualSocket.class);
 
67
   protected static Thread closingThread;
 
68
 
 
69
   private Map configuration = new HashMap();
 
70
   private MultiplexingManager manager;
 
71
   private Protocol protocol;
 
72
   private Socket actualSocket;
 
73
   private SocketId remoteSocketId;
 
74
   private SocketId localSocketId;
 
75
   private MultiplexingInputStream inputStream;
 
76
   private MultiplexingOutputStream outputStream;
 
77
   private Set disconnectListeners = new HashSet();
 
78
 
 
79
   private boolean bound = false;
 
80
   private boolean closed = false;
 
81
   private boolean connected = false;
 
82
   private boolean inputShutdown = false;
 
83
   private boolean outputShutdown = false;
 
84
   private boolean receivedDisconnectMessage = false;
 
85
 
 
86
   private int     timeout;
 
87
   private Socket  dummySocket;
 
88
 
 
89
   private boolean functional = true;
 
90
 
 
91
   private boolean trace;
 
92
   private boolean debug;
 
93
   private boolean info;
 
94
 
 
95
 
 
96
   /**
 
97
    * A class that implements <code>DisconnectListener</code> can register to
 
98
    * be notified if the remote peer of this <code>VirtualSocket</code> has
 
99
    * disconnected.
 
100
    */
 
101
   public interface DisconnectListener
 
102
   {
 
103
      void notifyDisconnected(VirtualSocket virtualSocket);
 
104
   }
 
105
 
 
106
 
 
107
   public VirtualSocket(MultiplexingManager manager, SocketId remoteSocketId, Map configuration) throws IOException
 
108
   {
 
109
      this.manager = manager;
 
110
      this.actualSocket = manager.getSocket();
 
111
      this.remoteSocketId = remoteSocketId;
 
112
      this.configuration.putAll(configuration);
 
113
      protocol = manager.getProtocol();
 
114
      localSocketId = new SocketId();
 
115
      inputStream = manager.registerSocket(this);
 
116
//      outputStream = new MultiplexingOutputStream(manager, this, remoteSocketId);
 
117
      outputStream = manager.getAnOutputStream(this, remoteSocketId);
 
118
      bound = true;
 
119
      connected = true;
 
120
 
 
121
      trace = log.isTraceEnabled();
 
122
      debug = log.isDebugEnabled();
 
123
      info = log.isInfoEnabled();
 
124
      if (debug) log.debug("created virtual socket on port: " + localSocketId.getPort());
 
125
   }
 
126
 
 
127
 
 
128
   public VirtualSocket(Map configuration)
 
129
   {
 
130
      this.configuration.putAll(configuration);
 
131
   }
 
132
 
 
133
 
 
134
//////////////////////////////////////////////////////////////////////////////////////////////////
 
135
///           The following constructors duplicate those of the parent class Socket           '///
 
136
//////////////////////////////////////////////////////////////////////////////////////////////////
 
137
 
 
138
/**
 
139
 * See superclass javadoc.
 
140
 */
 
141
   public VirtualSocket()
 
142
   {
 
143
      log.debug("created unbound virtual socket");
 
144
   }
 
145
 
 
146
 
 
147
/**
 
148
 * See superclass javadoc.
 
149
 */
 
150
   public VirtualSocket(String host, int port) throws UnknownHostException, IOException
 
151
   {
 
152
      InetSocketAddress address = null;
 
153
 
 
154
      if (host == null)
 
155
         address = new InetSocketAddress(InetAddress.getByName(null), port);
 
156
      else
 
157
         address = new InetSocketAddress(host, port);
 
158
 
 
159
      connect(address);
 
160
      if (debug) log.debug("created virtual socket on port: " + localSocketId.getPort());
 
161
   }
 
162
 
 
163
 
 
164
/**
 
165
 * See superclass javadoc.
 
166
 * @param host
 
167
 * @param port
 
168
 * @param stream
 
169
 * @throws java.io.IOException
 
170
 */
 
171
   public VirtualSocket(String host, int port, boolean stream) throws IOException
 
172
   {
 
173
      if (!stream)
 
174
      {
 
175
         throw new SocketException("Deprecated: use DataGramSocket instead of stream = false");
 
176
      }
 
177
 
 
178
      InetSocketAddress address = null;
 
179
 
 
180
      if (host == null)
 
181
         address = new InetSocketAddress(InetAddress.getByName(null), port);
 
182
      else
 
183
         address = new InetSocketAddress(host, port);
 
184
 
 
185
      connect(address);
 
186
      if (debug) log.debug("created virtual socket on port: " + localSocketId.getPort());
 
187
   }
 
188
 
 
189
 
 
190
/**
 
191
 * See superclass javadoc.
 
192
 * @param address
 
193
 * @param port
 
194
 * @throws java.io.IOException
 
195
 */
 
196
   public VirtualSocket(InetAddress address, int port) throws IOException
 
197
   {
 
198
      connect(new InetSocketAddress(address, port));
 
199
      if (debug) log.debug("created virtual socket on port: " + localSocketId.getPort());
 
200
   }
 
201
 
 
202
 
 
203
/**
 
204
 * See superclass javadoc.
 
205
 * @param host
 
206
 * @param port
 
207
 * @param stream
 
208
 * @throws java.io.IOException
 
209
 */
 
210
   public VirtualSocket(InetAddress host, int port, boolean stream) throws IOException
 
211
   {
 
212
      if (!stream)
 
213
      {
 
214
         throw new SocketException("Deprecated: use DataGramSocket instead of stream = false");
 
215
      }
 
216
 
 
217
      connect(new InetSocketAddress(host, port));
 
218
      if (debug) log.debug("created virtual socket on port: " + localSocketId.getPort());
 
219
   }
 
220
 
 
221
 
 
222
/**
 
223
 * This constuctor is not implemented.
 
224
 * <p>
 
225
 * @param impl
 
226
 * @throws java.net.SocketException in all cases
 
227
 */
 
228
   public VirtualSocket(SocketImpl impl) throws SocketException
 
229
   {
 
230
      throw new SocketException("VirtualSocket does not use SocketImpl");
 
231
   }
 
232
 
 
233
 
 
234
/**
 
235
 * See superclass javadoc.
 
236
 * @param host
 
237
 * @param port
 
238
 * @param localAddr
 
239
 * @param localPort
 
240
 * @throws java.io.IOException
 
241
 */
 
242
   public VirtualSocket(String host, int port, InetAddress localAddr, int localPort) throws IOException
 
243
   {
 
244
      this(InetAddress.getByName(host), port, localAddr, localPort);
 
245
   }
 
246
 
 
247
 
 
248
/**
 
249
 * See superclass javadoc.
 
250
 * @param address
 
251
 * @param port
 
252
 * @param localAddr
 
253
 * @param localPort
 
254
 * @throws java.io.IOException
 
255
 */
 
256
   public VirtualSocket(InetAddress address, int port, InetAddress localAddr, int localPort) throws IOException
 
257
   {
 
258
      this();
 
259
      connect(new InetSocketAddress(address, port), new InetSocketAddress(localAddr, localPort), 0);
 
260
      if (debug) log.debug("created virtual socket on port: " + localSocketId.getPort());
 
261
   }
 
262
 
 
263
 
 
264
 
 
265
//////////////////////////////////////////////////////////////////////////////////////////////////
 
266
///                     The following methods are required of all Socket's                    '///
 
267
//////////////////////////////////////////////////////////////////////////////////////////////////
 
268
 
 
269
 
 
270
   /*************************************************************************************************
 
271
    * public methods in Socket class
 
272
    *
 
273
      ok: public void connect(SocketAddress endpoint) throws IOException;
 
274
      ok: public void connect(SocketAddress endpoint, int timeout) throws IOException;
 
275
      ok: public void bind(SocketAddress bindpoint) throws IOException;
 
276
      ok: public InetAddress getInetAddress();
 
277
      ok: public InetAddress getLocalAddress();
 
278
      ok: public int getPort();
 
279
      ok: public int getLocalPort();
 
280
      ok: public SocketAddress getRemoteSocketAddress();
 
281
      ok: public SocketAddress getLocalSocketAddress();
 
282
      ok: public SocketChannel getChannel();
 
283
      ok: public InputStream getInputStream() throws IOException;
 
284
      ok: public OutputStream getOutputStream() throws IOException;
 
285
      ok: public void setTcpNoDelay(boolean on) throws SocketException;
 
286
      ok: public boolean getTcpNoDelay() throws SocketException;
 
287
      ok: public void setSoLinger(boolean on, int linger) throws SocketException;
 
288
      ok: public int getSoLinger() throws SocketException;
 
289
      ok: public void sendUrgentData(int data) throws IOException;
 
290
      ok: public void setOOBInline(boolean on) throws SocketException;
 
291
      ok: public boolean getOOBInline() throws SocketException;
 
292
      ok: public void setSoTimeout(int timeout) throws SocketException;
 
293
      ok: public int getSoTimeout() throws SocketException;
 
294
      ok: public void setSendBufferSize(int size) throws SocketException;
 
295
      ok: public int getSendBufferSize() throws SocketException;
 
296
      ok: public void setReceiveBufferSize(int size) throws SocketException;
 
297
      ok: public int getReceiveBufferSize() throws SocketException;
 
298
      ok: public void setKeepAlive(boolean on) throws SocketException;
 
299
      ok: public boolean getKeepAlive() throws SocketException;
 
300
      ok: public void setTrafficClass(int tc) throws SocketException;
 
301
      ok: public int getTrafficClass() throws SocketException;
 
302
      ok: public void setReuseAddress(boolean on) throws SocketException;
 
303
      ok: public boolean getReuseAddress() throws SocketException;
 
304
      ok: public void close() throws IOException;
 
305
      ok: public void shutdownInput() throws IOException;
 
306
      ok: public void shutdownOutput() throws IOException;
 
307
      ok: public String toString();
 
308
      ok: public boolean isConnected();
 
309
      ok: public boolean isBound();
 
310
      ok: public boolean isClosed();
 
311
      ok: public boolean isInputShutdown();
 
312
      ok: public boolean isOutputShutdown();
 
313
   *************************************************************************************************/
 
314
 
 
315
 
 
316
/**
 
317
 * See superclass javadoc.
 
318
 */
 
319
   public void bind(SocketAddress address) throws IOException
 
320
   {
 
321
      if (isClosed())
 
322
         throw new SocketException("Socket is closed");
 
323
 
 
324
      if (isBound())
 
325
         throw new SocketException("Already bound");
 
326
 
 
327
      if (address != null && (!(address instanceof InetSocketAddress)))
 
328
         throw new IllegalArgumentException("Unsupported address type");
 
329
 
 
330
      InetSocketAddress inetAddress = (InetSocketAddress) address;
 
331
 
 
332
      if (inetAddress != null && inetAddress.isUnresolved())
 
333
         throw new SocketException("Unresolved address");
 
334
 
 
335
      manager = MultiplexingManager.getaManagerByLocalAddress(inetAddress, configuration);
 
336
      actualSocket = manager.getSocket();
 
337
      localSocketId = new SocketId();
 
338
      if (debug) log.debug("bound virtual socket to port: " + localSocketId.getPort());
 
339
      bound = true;
 
340
   }
 
341
 
 
342
 
 
343
/**
 
344
 * See superclass javadoc.
 
345
 */
 
346
   public void close() throws IOException
 
347
   {
 
348
      if (closed)
 
349
         return;
 
350
 
 
351
      log.debug("closing: " + localSocketId);
 
352
      closed = true;
 
353
 
 
354
      if (connected && !receivedDisconnectMessage)
 
355
         protocol.disconnect(remoteSocketId);
 
356
 
 
357
      if (inputStream != null)
 
358
         inputStream.close();
 
359
 
 
360
      if (outputStream != null)
 
361
      {
 
362
         outputStream.flush();
 
363
         outputStream.close();
 
364
      }
 
365
 
 
366
      if (localSocketId != null)
 
367
         localSocketId.releasePort();
 
368
 
 
369
      // This VirtualSocket might have been unregistered when connect() failed.
 
370
      if (manager.isSocketRegistered(this.localSocketId))
 
371
      {
 
372
         MultiplexingManager.addToPendingActions(new PendingClose(this));
 
373
      }
 
374
 
 
375
      if (debug) log.debug("virtual socket closed on port: " + localSocketId.getPort());
 
376
   }
 
377
 
 
378
 
 
379
   /**
 
380
    * See superclass javadoc.
 
381
    */
 
382
   public void connect(SocketAddress socketAddress) throws IOException
 
383
   {
 
384
      connect(socketAddress, null, timeout);
 
385
   }
 
386
 
 
387
 
 
388
/**
 
389
 * See superclass javadoc.
 
390
 */
 
391
   public void connect(SocketAddress socketAddress, int timeout) throws IOException
 
392
   {
 
393
      connect(socketAddress, null, timeout);
 
394
   }
 
395
 
 
396
 
 
397
/**
 
398
 * See superclass javadoc.
 
399
 */
 
400
   public SocketChannel getChannel()
 
401
   {
 
402
      return null;
 
403
   }
 
404
 
 
405
 
 
406
/**
 
407
 * See superclass javadoc.
 
408
 */
 
409
   public InetAddress getInetAddress()
 
410
   {
 
411
      if (actualSocket == null)
 
412
         return null;
 
413
 
 
414
      return actualSocket.getInetAddress();
 
415
   }
 
416
 
 
417
 
 
418
/**
 
419
 * See superclass javadoc.
 
420
 */
 
421
   public InputStream getInputStream() throws IOException
 
422
   {
 
423
      if (isClosed())
 
424
         throw new SocketException("Socket is closed");
 
425
 
 
426
      if (actualSocket == null || !connected)
 
427
         throw new SocketException("Socket is not connected");
 
428
 
 
429
      if (isInputShutdown())
 
430
         throw new SocketException("Socket input is shutdown");
 
431
 
 
432
      return inputStream;
 
433
   }
 
434
 
 
435
 
 
436
/**
 
437
 * See superclass javadoc.
 
438
 */
 
439
   public boolean getKeepAlive() throws SocketException
 
440
   {
 
441
      if (actualSocket == null)
 
442
         return false;
 
443
 
 
444
      return actualSocket.getKeepAlive();
 
445
   }
 
446
 
 
447
 
 
448
/**
 
449
 * See superclass javadoc.
 
450
 * Note. <code>Socket.getLocalAddress()</code> returns "wildcard" address for an unbound socket.
 
451
 */
 
452
   public InetAddress getLocalAddress()
 
453
   {
 
454
      if (actualSocket == null)
 
455
      {
 
456
         if (dummySocket == null)
 
457
            dummySocket = new Socket();
 
458
 
 
459
         return dummySocket.getLocalAddress();
 
460
      }
 
461
 
 
462
      // The following is a workaround for a problem in NIO sockets, which sometimes
 
463
      // return "0.0.0.0" instead of "127.0.0.1".
 
464
      InetAddress address = actualSocket.getLocalAddress();
 
465
      try
 
466
      {
 
467
         if ("0.0.0.0".equals(address.getHostAddress()))
 
468
            return InetAddress.getByName("localhost");
 
469
      }
 
470
      catch (UnknownHostException e)
 
471
      {
 
472
         return address;
 
473
      }
 
474
 
 
475
      return address;
 
476
   }
 
477
 
 
478
 
 
479
/**
 
480
 * See superclass javadoc.
 
481
 */
 
482
   public int getLocalPort()
 
483
   {
 
484
      if (actualSocket == null)
 
485
         return -1;
 
486
 
 
487
      return actualSocket.getLocalPort();
 
488
   }
 
489
 
 
490
 
 
491
/**
 
492
 * See superclass javadoc.
 
493
 */
 
494
   public SocketAddress getLocalSocketAddress()
 
495
   {
 
496
      if (actualSocket == null)
 
497
         return null;
 
498
 
 
499
      SocketAddress address = actualSocket.getLocalSocketAddress();
 
500
      InetSocketAddress socketAddress = null;
 
501
 
 
502
      // The following is a workaround for a problem in NIO sockets, which sometimes
 
503
      // return "0.0.0.0" instead of "127.0.0.1".
 
504
      if (address instanceof InetSocketAddress)
 
505
      {
 
506
         socketAddress = (InetSocketAddress) address;
 
507
         if ("0.0.0.0".equals(socketAddress.getHostName()) ||
 
508
             socketAddress.getAddress() == null)
 
509
            return new InetSocketAddress("localhost", socketAddress.getPort());
 
510
      }
 
511
 
 
512
      return address;
 
513
   }
 
514
 
 
515
 
 
516
/**
 
517
 * See superclass javadoc.
 
518
 */
 
519
   public boolean getOOBInline() throws SocketException
 
520
   {
 
521
      return false;
 
522
   }
 
523
 
 
524
 
 
525
/**
 
526
 * See superclass javadoc.
 
527
 */
 
528
   public OutputStream getOutputStream() throws IOException
 
529
   {
 
530
      if (isClosed())
 
531
         throw new SocketException("Socket is closed");
 
532
 
 
533
      if (actualSocket == null || !connected)
 
534
         throw new SocketException("Socket is not connected");
 
535
 
 
536
      if (isOutputShutdown())
 
537
         throw new SocketException("Socket output is shutdown");
 
538
 
 
539
      // TODO: return distinct output streams? See PlainSocketImpl.
 
540
      //return new SocketOutputStream(this);
 
541
      return outputStream;
 
542
   }
 
543
 
 
544
 
 
545
/**
 
546
 * See superclass javadoc.
 
547
 */
 
548
   public int getPort()
 
549
   {
 
550
      if (actualSocket == null)
 
551
         return 0;
 
552
 
 
553
      return actualSocket.getPort();
 
554
   }
 
555
 
 
556
 
 
557
/**
 
558
 * See superclass javadoc.
 
559
 */
 
560
   public int getReceiveBufferSize() throws SocketException
 
561
   {
 
562
      if (actualSocket == null)
 
563
      {
 
564
         if (dummySocket == null)
 
565
            dummySocket = new Socket();
 
566
 
 
567
         return dummySocket.getReceiveBufferSize();
 
568
      }
 
569
 
 
570
      return actualSocket.getReceiveBufferSize();
 
571
   }
 
572
 
 
573
 
 
574
/**
 
575
 * See superclass javadoc.
 
576
 */
 
577
   public SocketAddress getRemoteSocketAddress()
 
578
   {
 
579
      if (actualSocket == null)
 
580
         return null;
 
581
 
 
582
      return actualSocket.getRemoteSocketAddress();
 
583
   }
 
584
 
 
585
 
 
586
/**
 
587
 * See superclass javadoc.
 
588
 */
 
589
   public boolean getReuseAddress() throws SocketException
 
590
   {
 
591
      if (actualSocket == null)
 
592
         return false;
 
593
 
 
594
      return actualSocket.getReuseAddress();
 
595
   }
 
596
 
 
597
 
 
598
/**
 
599
 * See superclass javadoc.
 
600
 */
 
601
   public int getSendBufferSize() throws SocketException
 
602
   {
 
603
      if (actualSocket == null)
 
604
      {
 
605
         if (dummySocket == null)
 
606
            dummySocket = new Socket();
 
607
 
 
608
         return dummySocket.getSendBufferSize();
 
609
      }
 
610
 
 
611
      return actualSocket.getSendBufferSize();
 
612
   }
 
613
 
 
614
 
 
615
/**
 
616
 * See superclass javadoc.
 
617
 */
 
618
   public int getSoLinger() throws SocketException
 
619
   {
 
620
      if (actualSocket == null)
 
621
         return -1;
 
622
 
 
623
      return actualSocket.getSoLinger();
 
624
   }
 
625
 
 
626
 
 
627
/**
 
628
 * See superclass javadoc.
 
629
 */
 
630
   public int getSoTimeout() throws SocketException
 
631
   {
 
632
      if (isClosed())
 
633
         throw new SocketException("Socket is closed");
 
634
 
 
635
      return timeout;
 
636
   }
 
637
 
 
638
 
 
639
/**
 
640
 * See superclass javadoc.
 
641
 */
 
642
   public boolean getTcpNoDelay() throws SocketException
 
643
   {
 
644
      if (actualSocket == null)
 
645
         return false;
 
646
 
 
647
      return actualSocket.getTcpNoDelay();
 
648
   }
 
649
 
 
650
 
 
651
/**
 
652
 * See superclass javadoc.
 
653
 */
 
654
   public int getTrafficClass() throws SocketException
 
655
   {
 
656
      if (actualSocket == null)
 
657
         return 0;
 
658
 
 
659
      return actualSocket.getTrafficClass();
 
660
   }
 
661
 
 
662
 
 
663
 /**
 
664
 * See superclass javadoc.
 
665
 */
 
666
   public boolean isBound()
 
667
   {
 
668
      return bound;
 
669
   }
 
670
 
 
671
 
 
672
/**
 
673
 * See superclass javadoc.
 
674
 */
 
675
   public boolean isClosed()
 
676
   {
 
677
      return closed;
 
678
   }
 
679
 
 
680
 
 
681
/**
 
682
 * See superclass javadoc.
 
683
 */
 
684
   public boolean isConnected()
 
685
   {
 
686
      return connected;
 
687
   }
 
688
 
 
689
 
 
690
/**
 
691
 * See superclass javadoc.
 
692
 */
 
693
   public boolean isInputShutdown()
 
694
   {
 
695
      return inputShutdown;
 
696
   }
 
697
 
 
698
 
 
699
/**
 
700
 * See superclass javadoc.
 
701
 */
 
702
   public boolean isOutputShutdown()
 
703
   {
 
704
      return outputShutdown;
 
705
   }
 
706
 
 
707
 
 
708
/**
 
709
 * This method is not implemented.
 
710
 * <p>
 
711
 * See superclass javadoc.
 
712
 */
 
713
   public void sendUrgentData(int data) throws IOException
 
714
   {
 
715
      log.warn("sendUrgentData() called: ignored");
 
716
 
 
717
      if (isClosed())
 
718
         throw new IOException("Socket Closed");
 
719
   }
 
720
 
 
721
 
 
722
/**
 
723
 * See superclass javadoc.
 
724
 */
 
725
   public void setKeepAlive(boolean on) throws SocketException
 
726
   {
 
727
      if (actualSocket != null)
 
728
         actualSocket.setKeepAlive(on);
 
729
   }
 
730
 
 
731
 
 
732
/**
 
733
 *
 
734
 */
 
735
   public void setOOBInline(boolean on) throws SocketException
 
736
   {
 
737
      log.warn("setOOBInLine() called: ignored");
 
738
 
 
739
      if (isClosed())
 
740
         throw new SocketException("Socket is closed");
 
741
   }
 
742
 
 
743
 
 
744
/**
 
745
 * See superclass javadoc.
 
746
 */
 
747
   public void setReceiveBufferSize(int size) throws SocketException
 
748
   {
 
749
      if (actualSocket != null)
 
750
         actualSocket.setReceiveBufferSize(size);
 
751
   }
 
752
 
 
753
 
 
754
/**
 
755
 * See superclass javadoc.
 
756
 */
 
757
   public void setReuseAddress(boolean on) throws SocketException
 
758
   {
 
759
      if (actualSocket != null)
 
760
         actualSocket.setReuseAddress(on);
 
761
   }
 
762
 
 
763
 
 
764
/**
 
765
 * See superclass javadoc.
 
766
 */
 
767
   public void setSendBufferSize(int size) throws SocketException
 
768
   {
 
769
      if (actualSocket != null)
 
770
         actualSocket.setSendBufferSize(size);
 
771
   }
 
772
 
 
773
 
 
774
/**
 
775
 * See superclass javadoc.
 
776
 */
 
777
   public void setSoLinger(boolean on, int linger) throws SocketException
 
778
   {
 
779
      if (actualSocket != null)
 
780
         actualSocket.setSoLinger(on, linger);
 
781
   }
 
782
 
 
783
 
 
784
/**
 
785
 * See superclass javadoc.
 
786
 */
 
787
   public void setSoTimeout(int timeout) throws SocketException
 
788
   {
 
789
      if (isClosed())
 
790
         throw new SocketException("Socket is closed");
 
791
 
 
792
      if (timeout < 0)
 
793
         throw new IllegalArgumentException("timeout can't be negative");
 
794
 
 
795
      this.timeout = timeout;
 
796
 
 
797
      if (inputStream != null)
 
798
         inputStream.setTimeout(timeout);
 
799
   }
 
800
 
 
801
 
 
802
/**
 
803
 * See superclass javadoc.
 
804
 */
 
805
   public void setTcpNoDelay(boolean on) throws SocketException
 
806
   {
 
807
      if (actualSocket != null)
 
808
         actualSocket.setTcpNoDelay(on);
 
809
   }
 
810
 
 
811
 
 
812
/**
 
813
 * See superclass javadoc.
 
814
 */
 
815
   public void setTrafficClass(int tc) throws SocketException
 
816
   {
 
817
      if (actualSocket != null)
 
818
         actualSocket.setTrafficClass(tc);
 
819
   }
 
820
 
 
821
 
 
822
/**
 
823
 * See superclass javadoc.
 
824
 */
 
825
   public void shutdownInput() throws IOException
 
826
   {
 
827
      if (isClosed())
 
828
         throw new SocketException("Socket is closed");
 
829
 
 
830
      if (!isConnected())
 
831
         throw new SocketException("Socket is not connected");
 
832
 
 
833
      if (isInputShutdown())
 
834
         throw new SocketException("Socket input is already shutdown");
 
835
 
 
836
      inputStream.setEOF();
 
837
      inputShutdown = true;
 
838
      //         protocol.notifyInputShutdown(localSocketId);
 
839
   }
 
840
 
 
841
 
 
842
/**
 
843
* See superclass javadoc.
 
844
*/
 
845
   public void shutdownOutput() throws IOException
 
846
   {
 
847
      if (isClosed())
 
848
         throw new SocketException("Socket is closed");
 
849
 
 
850
      if (!isConnected())
 
851
         throw new SocketException("Socket is not connected");
 
852
 
 
853
      if (isOutputShutdown())
 
854
         throw new SocketException("Socket output is already shutdown");
 
855
 
 
856
      outputStream.shutdown();
 
857
      outputShutdown = true;
 
858
      protocol.notifyOutputShutdown(remoteSocketId);
 
859
   }
 
860
 
 
861
 
 
862
/**
 
863
 * See superclass javadoc.
 
864
 */
 
865
   public String toString()
 
866
   {
 
867
      StringBuffer answer = new StringBuffer().append("VirtualSocket[");
 
868
 
 
869
      if (actualSocket == null)
 
870
         answer.append("unbound");
 
871
      else
 
872
         answer.append(actualSocket.toString());
 
873
 
 
874
      return answer.append("]").toString();
 
875
   }
 
876
 
 
877
//////////////////////////////////////////////////////////////////////////////////////////////////
 
878
///                     The following methods are specific to VirtualSockets                   ///
 
879
//////////////////////////////////////////////////////////////////////////////////////////////////
 
880
 
 
881
/**
 
882
 *
 
883
 */
 
884
   public void addDisconnectListener(DisconnectListener listener)
 
885
   {
 
886
      disconnectListeners.add(listener);
 
887
   }
 
888
 
 
889
 
 
890
/**
 
891
 *
 
892
 */
 
893
   public void connect(SocketAddress remoteAddress, SocketAddress localAddress, int timeout) throws IOException
 
894
   {
 
895
      log.debug("entering connect()");
 
896
      long start = System.currentTimeMillis();
 
897
      int timeLeft = 0;
 
898
 
 
899
      if (remoteAddress == null)
 
900
         throw new IllegalArgumentException("connect: The address can't be null");
 
901
 
 
902
      if (timeout < 0)
 
903
         throw new IllegalArgumentException("connect: timeout can't be negative");
 
904
 
 
905
      if (isClosed())
 
906
         throw new SocketException("Socket is closed");
 
907
 
 
908
      if (isConnected())
 
909
         throw new SocketException("already connected");
 
910
 
 
911
      if (!(remoteAddress instanceof InetSocketAddress))
 
912
         throw new IllegalArgumentException("Unsupported address type");
 
913
 
 
914
      InetSocketAddress remoteInetSocketAddress = (InetSocketAddress) remoteAddress;
 
915
      SecurityManager security = System.getSecurityManager();
 
916
 
 
917
      if (security != null)
 
918
      {
 
919
         if (remoteInetSocketAddress.isUnresolved())
 
920
            security.checkConnect(remoteInetSocketAddress.getHostName(), remoteInetSocketAddress.getPort());
 
921
         else
 
922
            security.checkConnect(remoteInetSocketAddress.getAddress().getHostAddress(), remoteInetSocketAddress.getPort());
 
923
      }
 
924
 
 
925
      if (timeout > 0)
 
926
         if ((timeLeft = timeout - (int) (System.currentTimeMillis() - start)) <= 0)
 
927
            throw new SocketTimeoutException("connect timed out");
 
928
 
 
929
      if (manager == null)
 
930
      {
 
931
         if (localAddress == null)
 
932
            manager = MultiplexingManager.getaShareableManager(remoteInetSocketAddress, timeLeft, configuration);
 
933
         else
 
934
         {
 
935
            InetSocketAddress localInetSocketAddress = (InetSocketAddress) localAddress;
 
936
            manager = MultiplexingManager.getaShareableManagerByAddressPair(remoteInetSocketAddress,
 
937
                                                                            localInetSocketAddress,
 
938
                                                                            timeLeft,
 
939
                                                                            configuration);
 
940
         }
 
941
      }
 
942
 
 
943
      try
 
944
      {
 
945
         if (timeout > 0)
 
946
            if ((timeLeft = timeout - (int) (System.currentTimeMillis() - start)) <= 0)
 
947
               throw new SocketTimeoutException("connect timed out");
 
948
 
 
949
         manager.connect(remoteInetSocketAddress, timeLeft);
 
950
         actualSocket = manager.getSocket();
 
951
         protocol = manager.getProtocol();
 
952
 
 
953
         if (!bound)
 
954
         {
 
955
            localSocketId = new SocketId();
 
956
            bound = true;
 
957
         }
 
958
 
 
959
         inputStream = manager.registerSocket(this);
 
960
         inputStream.setTimeout(timeout);
 
961
 
 
962
         if (timeout > 0)
 
963
            if ((timeLeft = timeout - (int) (System.currentTimeMillis() - start)) <= 0)
 
964
               throw new SocketTimeoutException("connect timed out");
 
965
 
 
966
         remoteSocketId = protocol.connect(inputStream, localSocketId, timeLeft);
 
967
         outputStream = new MultiplexingOutputStream(manager, this, remoteSocketId);
 
968
      }
 
969
      catch (IOException e)
 
970
      {
 
971
         // Calling unRegisterSocket() will lead to this VirtualSocket being closed.
 
972
         try
 
973
         {
 
974
            manager.unRegisterSocket(this);
 
975
         }
 
976
         catch (IOException ignored)
 
977
         {
 
978
            // May not be registered yet.
 
979
         }
 
980
 
 
981
         if (e instanceof SocketTimeoutException)
 
982
            throw new SocketTimeoutException("connect timed out");
 
983
 
 
984
         throw e;
 
985
      }
 
986
      finally
 
987
      {
 
988
         if (inputStream != null)
 
989
            inputStream.setTimeout(this.timeout);
 
990
      }
 
991
 
 
992
      connected = true;
 
993
   }
 
994
 
 
995
 
 
996
   public MultiplexingManager getMultiplexingManager()
 
997
   {
 
998
      return manager;
 
999
   }
 
1000
 
 
1001
 
 
1002
   public int getVirtualPort()
 
1003
   {
 
1004
      return remoteSocketId.getPort();
 
1005
   }
 
1006
 
 
1007
 
 
1008
   public int getLocalVirtualPort()
 
1009
   {
 
1010
      return localSocketId.getPort();
 
1011
   }
 
1012
 
 
1013
 
 
1014
/**
 
1015
 *
 
1016
 * @return
 
1017
 */
 
1018
   public SocketId getLocalSocketId()
 
1019
   {
 
1020
      return localSocketId;
 
1021
   }
 
1022
 
 
1023
 
 
1024
/**
 
1025
 * @return
 
1026
 */
 
1027
   public Socket getRealSocket()
 
1028
   {
 
1029
      return actualSocket;
 
1030
   }
 
1031
 
 
1032
 
 
1033
/**
 
1034
 *
 
1035
 * @return
 
1036
 */
 
1037
   public SocketId getRemoteSocketId()
 
1038
   {
 
1039
      return localSocketId;
 
1040
   }
 
1041
 
 
1042
 
 
1043
   /**
 
1044
    * Returns true if and only if has not received notification of error state
 
1045
    * on actual connection.
 
1046
    *
 
1047
    * @return true if and only if has not received notification of error state
 
1048
    *         on actual connection
 
1049
    */
 
1050
   public boolean isFunctional()
 
1051
   {
 
1052
      return functional;
 
1053
   }
 
1054
 
 
1055
/**
 
1056
 *
 
1057
 * @param listener
 
1058
 */
 
1059
   public void removeDisconnectListener(DisconnectListener listener)
 
1060
   {
 
1061
      if (!disconnectListeners.remove(listener))
 
1062
         log.error("attempt to remove unregistered DisconnectListener: " + listener);
 
1063
   }
 
1064
 
 
1065
 
 
1066
/**
 
1067
 * @param configuration
 
1068
 */
 
1069
   public void setConfiguration(Map configuration)
 
1070
   {
 
1071
      this.configuration.putAll(configuration);
 
1072
   }
 
1073
//////////////////////////////////////////////////////////////////////////////////////////////////
 
1074
///                              Protected getters and setters                                '///
 
1075
//////////////////////////////////////////////////////////////////////////////////////////////////
 
1076
 
 
1077
/**
 
1078
 * @return Returns the actualSocket.
 
1079
 */
 
1080
   protected Socket getActualSocket()
 
1081
   {
 
1082
      return actualSocket;
 
1083
   }
 
1084
 
 
1085
/**
 
1086
 * @param actualSocket The actualSocket to set.
 
1087
 */
 
1088
   protected void setActualSocket(Socket actualSocket)
 
1089
   {
 
1090
      this.actualSocket = actualSocket;
 
1091
   }
 
1092
 
 
1093
// in socket API section
 
1094
///**
 
1095
// * @return Returns the bound.
 
1096
// */
 
1097
//   public boolean isBound()
 
1098
//   {
 
1099
//      return bound;
 
1100
//   }
 
1101
 
 
1102
/**
 
1103
 * @param bound The bound to set.
 
1104
 */
 
1105
   protected void setBound(boolean bound)
 
1106
   {
 
1107
      this.bound = bound;
 
1108
   }
 
1109
 
 
1110
/**
 
1111
 * @param closed The closed to set.
 
1112
 */
 
1113
   protected void setClosed(boolean closed)
 
1114
   {
 
1115
      this.closed = closed;
 
1116
   }
 
1117
 
 
1118
/**
 
1119
 * @param connected The connected to set.
 
1120
 */
 
1121
   protected void setConnected(boolean connected)
 
1122
   {
 
1123
      this.connected = connected;
 
1124
   }
 
1125
 
 
1126
/**
 
1127
 * @param inputShutdown The inputShutdown to set.
 
1128
 */
 
1129
   protected void setInputShutdown(boolean inputShutdown)
 
1130
   {
 
1131
      this.inputShutdown = inputShutdown;
 
1132
   }
 
1133
 
 
1134
/**
 
1135
 * @param inputStream The inputStream to set.
 
1136
 */
 
1137
   protected void setInputStream(MultiplexingInputStream inputStream)
 
1138
   {
 
1139
      this.inputStream = inputStream;
 
1140
   }
 
1141
 
 
1142
/**
 
1143
 * @param localSocketId The localSocketId to set.
 
1144
 */
 
1145
   protected void setLocalSocketId(SocketId localSocketId)
 
1146
   {
 
1147
      this.localSocketId = localSocketId;
 
1148
   }
 
1149
 
 
1150
/**
 
1151
 *
 
1152
 * @return
 
1153
 */
 
1154
   protected MultiplexingManager getManager()
 
1155
   {
 
1156
      return manager;
 
1157
   }
 
1158
 
 
1159
/**
 
1160
 * @param manager The manager to set.
 
1161
 */
 
1162
   protected void setManager(MultiplexingManager manager)
 
1163
   {
 
1164
      this.manager = manager;
 
1165
   }
 
1166
 
 
1167
/**
 
1168
 * @param outputShutdown The outputShutdown to set.
 
1169
 */
 
1170
   protected void setOutputShutdown(boolean outputShutdown)
 
1171
   {
 
1172
      this.outputShutdown = outputShutdown;
 
1173
   }
 
1174
 
 
1175
/**
 
1176
 * @param outputStream The outputStream to set.
 
1177
 */
 
1178
   protected void setOutputStream(MultiplexingOutputStream outputStream)
 
1179
   {
 
1180
      this.outputStream = outputStream;
 
1181
   }
 
1182
 
 
1183
/**
 
1184
 * @return Returns the protocol.
 
1185
 */
 
1186
   protected Protocol getProtocol()
 
1187
   {
 
1188
      return protocol;
 
1189
   }
 
1190
 
 
1191
/**
 
1192
 * @param protocol The protocol to set.
 
1193
 */
 
1194
   protected void setProtocol(Protocol protocol)
 
1195
   {
 
1196
      this.protocol = protocol;
 
1197
   }
 
1198
 
 
1199
/**
 
1200
 *
 
1201
 * @return
 
1202
 */
 
1203
   protected boolean hasReceivedDisconnectMessage()
 
1204
   {
 
1205
      return receivedDisconnectMessage;
 
1206
   }
 
1207
 
 
1208
/**
 
1209
 *
 
1210
 * @param receivedDisconnectMessage
 
1211
 */
 
1212
   protected void setReceivedDisconnectMessage(boolean receivedDisconnectMessage)
 
1213
   {
 
1214
      this.receivedDisconnectMessage = receivedDisconnectMessage;
 
1215
   }
 
1216
 
 
1217
/**
 
1218
 * @param remoteSocketId The remoteSocketId to set.
 
1219
 */
 
1220
   protected void setRemoteSocketId(SocketId remoteSocketId)
 
1221
   {
 
1222
      this.remoteSocketId = remoteSocketId;
 
1223
   }
 
1224
 
 
1225
 
 
1226
 
 
1227
//////////////////////////////////////////////////////////////////////////////////////////////////
 
1228
///                                  Other protected methods                                  '///
 
1229
//////////////////////////////////////////////////////////////////////////////////////////////////
 
1230
 
 
1231
 
 
1232
/**
 
1233
 *
 
1234
 */
 
1235
   protected void doClose()
 
1236
   {
 
1237
      if (debug) log.debug("doClose()" + this.localSocketId.getPort());
 
1238
      try
 
1239
      {
 
1240
//         if (connected && !receivedDisconnectMessage)
 
1241
//            protocol.disconnect(remoteSocketId);
 
1242
 
 
1243
         // This VirtualSocket might have been unregistered when connect() failed.
 
1244
         if (manager.isSocketRegistered(getLocalSocketId()))
 
1245
            manager.unRegisterSocket(this);
 
1246
 
 
1247
         if (debug) log.debug("virtual socket closed on port: " + remoteSocketId.getPort());
 
1248
      }
 
1249
      catch (Exception e)
 
1250
      {
 
1251
         log.error("error closing socket: " + this);
 
1252
         log.error(e);
 
1253
      }
 
1254
   }
 
1255
 
 
1256
 
 
1257
 
 
1258
/**
 
1259
 *
 
1260
 * @throws IOException
 
1261
 */
 
1262
   protected void handleRemoteOutputShutDown() throws IOException
 
1263
   {
 
1264
      // already closed ?
 
1265
      try
 
1266
      {
 
1267
         inputStream.handleRemoteShutdown();
 
1268
      }
 
1269
      catch (NullPointerException ignored)
 
1270
      {
 
1271
      }
 
1272
   }
 
1273
 
 
1274
 
 
1275
   /**
 
1276
    *
 
1277
    * @throws IOException
 
1278
    */
 
1279
   protected void handleRemoteDisconnect() throws IOException
 
1280
   {
 
1281
      if (isClosed())
 
1282
         return;
 
1283
 
 
1284
      if (debug) log.debug("remote virtual socket disconnecting: local port: " + getLocalVirtualPort());
 
1285
      receivedDisconnectMessage = true;
 
1286
 
 
1287
      // already closed ?
 
1288
      if (inputStream != null)
 
1289
         inputStream.handleRemoteShutdown();
 
1290
 
 
1291
      // already closed ?
 
1292
      if (outputStream != null)
 
1293
      {
 
1294
         outputStream.flush();
 
1295
         outputStream.handleRemoteDisconnect();
 
1296
      }
 
1297
 
 
1298
      MultiplexingManager.addToPendingActions(new PendingRemoteDisconnect(this));
 
1299
 
 
1300
      log.debug("handleRemoteDisconnect(): done.");
 
1301
      // TODO
 
1302
      //     connected = false;
 
1303
      //     inputShutdown = true;
 
1304
      //     outputShutdown = true;
 
1305
   }
 
1306
 
 
1307
 
 
1308
   /**
 
1309
    * Indicate error condition on actual connection.
 
1310
    */
 
1311
   protected void notifyOfException()
 
1312
   {
 
1313
      functional = false;
 
1314
   }
 
1315
 
 
1316
   protected class PendingRemoteDisconnect extends PendingAction
 
1317
   {
 
1318
      public PendingRemoteDisconnect(Object o)
 
1319
      {
 
1320
         super(o);
 
1321
      }
 
1322
 
 
1323
      void doAction()
 
1324
      {
 
1325
         VirtualSocket vs = (VirtualSocket) o;
 
1326
         Set disconnectListeners = vs.disconnectListeners;
 
1327
 
 
1328
         Iterator it = disconnectListeners.iterator();
 
1329
         while (it.hasNext())
 
1330
            ((DisconnectListener) it.next()).notifyDisconnected(vs);
 
1331
      }
 
1332
   }
 
1333
 
 
1334
 
 
1335
   protected class PendingClose extends PendingAction
 
1336
   {
 
1337
      public PendingClose(Object o)
 
1338
      {
 
1339
         super(o);
 
1340
      }
 
1341
 
 
1342
      public void doAction()
 
1343
      {
 
1344
         ((VirtualSocket)o).doClose();
 
1345
      }
 
1346
   }
 
1347
}
 
 
b'\\ No newline at end of file'