OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libjava/] [classpath/] [java/] [net/] [ServerSocket.java] - Blame information for rev 791

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 771 jeremybenn
/* ServerSocket.java -- Class for implementing server side sockets
2
   Copyright (C) 1998, 1999, 2000, 2002, 2003, 2004, 2006
3
   Free Software Foundation, Inc.
4
 
5
This file is part of GNU Classpath.
6
 
7
GNU Classpath is free software; you can redistribute it and/or modify
8
it under the terms of the GNU General Public License as published by
9
the Free Software Foundation; either version 2, or (at your option)
10
any later version.
11
 
12
GNU Classpath is distributed in the hope that it will be useful, but
13
WITHOUT ANY WARRANTY; without even the implied warranty of
14
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
General Public License for more details.
16
 
17
You should have received a copy of the GNU General Public License
18
along with GNU Classpath; see the file COPYING.  If not, write to the
19
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
20
02110-1301 USA.
21
 
22
Linking this library statically or dynamically with other modules is
23
making a combined work based on this library.  Thus, the terms and
24
conditions of the GNU General Public License cover the whole
25
combination.
26
 
27
As a special exception, the copyright holders of this library give you
28
permission to link this library with independent modules to produce an
29
executable, regardless of the license terms of these independent
30
modules, and to copy and distribute the resulting executable under
31
terms of your choice, provided that you also meet, for each linked
32
independent module, the terms and conditions of the license of that
33
module.  An independent module is a module which is not derived from
34
or based on this library.  If you modify this library, you may extend
35
this exception to your version of the library, but you are not
36
obligated to do so.  If you do not wish to do so, delete this
37
exception statement from your version. */
38
 
39
package java.net;
40
 
41
import gnu.java.net.PlainSocketImpl;
42
 
43
import java.io.IOException;
44
import java.nio.channels.IllegalBlockingModeException;
45
import java.nio.channels.ServerSocketChannel;
46
 
47
 
48
/* Written using on-line Java Platform 1.2 API Specification.
49
 * Status:  I believe all methods are implemented.
50
 */
51
 
52
/**
53
 * This class models server side sockets.  The basic model is that the
54
 * server socket is created and bound to some well known port.  It then
55
 * listens for and accepts connections.  At that point the client and
56
 * server sockets are ready to communicate with one another utilizing
57
 * whatever application layer protocol they desire.
58
 *
59
 * As with the <code>Socket</code> class, most instance methods of this class
60
 * simply redirect their calls to an implementation class.
61
 *
62
 * @author Aaron M. Renn (arenn@urbanophile.com)
63
 * @author Per Bothner (bothner@cygnus.com)
64
 */
65
public class ServerSocket
66
{
67
  /**
68
   * This is the user defined SocketImplFactory, if one is supplied
69
   */
70
  private static SocketImplFactory factory;
71
 
72
  /**
73
   * This is the SocketImp object to which most instance methods in this
74
   * class are redirected
75
   */
76
  private SocketImpl impl;
77
 
78
  /**
79
   * We need to retain the local address even after the socket is closed.
80
   */
81
  private InetSocketAddress local;
82
  private int port;
83
 
84
  /*
85
   * This constructor is only used by java.nio.
86
   */
87
 
88
  ServerSocket(PlainSocketImpl impl) throws IOException
89
  {
90
    if (impl == null)
91
      throw new NullPointerException("impl may not be null");
92
 
93
    this.impl = impl;
94
    this.impl.create(true);
95
    setReuseAddress(true);
96
  }
97
 
98
  /*
99
   * This method is only used by java.nio.
100
   */
101
 
102
  SocketImpl getImpl()
103
  {
104
    return impl;
105
  }
106
 
107
  /**
108
   * Constructor that simply sets the implementation.
109
   *
110
   * @exception IOException If an error occurs
111
   *
112
   * @specnote This constructor is public since JDK 1.4
113
   */
114
  public ServerSocket() throws IOException
115
  {
116
    if (factory != null)
117
      impl = factory.createSocketImpl();
118
    else
119
      impl = new PlainSocketImpl();
120
 
121
    impl.create(true);
122
  }
123
 
124
  /**
125
   * Creates a server socket and binds it to the specified port.  If the
126
   * port number is 0, a random free port will be chosen.  The pending
127
   * connection queue on this socket will be set to 50.
128
   *
129
   * @param port The port number to bind to
130
   *
131
   * @exception IOException If an error occurs
132
   * @exception SecurityException If a security manager exists and its
133
   * checkListen method doesn't allow the operation
134
   */
135
  public ServerSocket(int port) throws IOException
136
  {
137
    this(port, 50);
138
  }
139
 
140
  /**
141
   * Creates a server socket and binds it to the specified port.  If the
142
   * port number is 0, a random free port will be chosen.  The pending
143
   * connection queue on this socket will be set to the value passed as
144
   * arg2.
145
   *
146
   * @param port The port number to bind to
147
   * @param backlog The length of the pending connection queue
148
   *
149
   * @exception IOException If an error occurs
150
   * @exception SecurityException If a security manager exists and its
151
   * checkListen method doesn't allow the operation
152
   */
153
  public ServerSocket(int port, int backlog) throws IOException
154
  {
155
    this(port, backlog, null);
156
  }
157
 
158
  /**
159
   * Creates a server socket and binds it to the specified port.  If the
160
   * port number is 0, a random free port will be chosen.  The pending
161
   * connection queue on this socket will be set to the value passed as
162
   * backlog.  The third argument specifies a particular local address to
163
   * bind t or null to bind to all local address.
164
   *
165
   * @param port The port number to bind to
166
   * @param backlog The length of the pending connection queue
167
   * @param bindAddr The address to bind to, or null to bind to all addresses
168
   *
169
   * @exception IOException If an error occurs
170
   * @exception SecurityException If a security manager exists and its
171
   * checkListen method doesn't allow the operation
172
   *
173
   * @since 1.1
174
   */
175
  public ServerSocket(int port, int backlog, InetAddress bindAddr)
176
    throws IOException
177
  {
178
    this();
179
 
180
    // bind/listen socket
181
    bind(new InetSocketAddress(bindAddr, port), backlog);
182
  }
183
 
184
  /**
185
   * Binds the server socket to a specified socket address
186
   *
187
   * @param endpoint The socket address to bind to
188
   *
189
   * @exception IOException If an error occurs
190
   * @exception IllegalArgumentException If address type is not supported
191
   * @exception SecurityException If a security manager exists and its
192
   * checkListen method doesn't allow the operation
193
   *
194
   * @since 1.4
195
   */
196
  public void bind(SocketAddress endpoint) throws IOException
197
  {
198
    bind(endpoint, 50);
199
  }
200
 
201
  /**
202
   * Binds the server socket to a specified socket address
203
   *
204
   * @param endpoint The socket address to bind to
205
   * @param backlog The length of the pending connection queue
206
   *
207
   * @exception IOException If an error occurs
208
   * @exception IllegalArgumentException If address type is not supported
209
   * @exception SecurityException If a security manager exists and its
210
   * checkListen method doesn't allow the operation
211
   *
212
   * @since 1.4
213
   */
214
  public void bind(SocketAddress endpoint, int backlog)
215
    throws IOException
216
  {
217
    if (isClosed())
218
      throw new SocketException("ServerSocket is closed");
219
 
220
    if (isBound())
221
      throw new SocketException("Already bound");
222
 
223
    InetAddress addr;
224
    int port;
225
 
226
    if (endpoint == null)
227
      {
228
        addr = InetAddress.ANY_IF;
229
        port = 0;
230
      }
231
    else if (! (endpoint instanceof InetSocketAddress))
232
      {
233
        throw new IllegalArgumentException("Address type not supported");
234
      }
235
    else
236
      {
237
        InetSocketAddress tmp = (InetSocketAddress) endpoint;
238
        if (tmp.isUnresolved())
239
          throw new SocketException("Unresolved address");
240
        addr = tmp.getAddress();
241
        port = tmp.getPort();
242
      }
243
 
244
    SecurityManager s = System.getSecurityManager();
245
    if (s != null)
246
      s.checkListen(port);
247
 
248
    try
249
      {
250
        impl.bind(addr, port);
251
        impl.listen(backlog);
252
        this.port = port;
253
        local = new InetSocketAddress(
254
            (InetAddress) impl.getOption(SocketOptions.SO_BINDADDR),
255
            impl.getLocalPort());
256
      }
257
    finally
258
      {
259
        try
260
          {
261
            if (local == null)
262
              close();
263
          }
264
        catch (IOException _)
265
          {
266
          }
267
      }
268
  }
269
 
270
  /**
271
   * This method returns the local address to which this socket is bound
272
   *
273
   * @return The socket's local address
274
   */
275
  public InetAddress getInetAddress()
276
  {
277
    if (local == null)
278
      return null;
279
 
280
    return local.getAddress();
281
  }
282
 
283
  /**
284
   * This method returns the local port number to which this socket is bound
285
   *
286
   * @return The socket's port number
287
   */
288
  public int getLocalPort()
289
  {
290
    if (local == null)
291
      return -1;
292
 
293
    return local.getPort();
294
  }
295
 
296
  /**
297
   * Returns the local socket address
298
   *
299
   * @return the local socket address, null if not bound
300
   *
301
   * @since 1.4
302
   */
303
  public SocketAddress getLocalSocketAddress()
304
  {
305
    return local;
306
  }
307
 
308
  /**
309
   * Accepts a new connection and returns a connected <code>Socket</code>
310
   * instance representing that connection.  This method will block until a
311
   * connection is available.
312
   *
313
   * @return socket object for the just accepted connection
314
   *
315
   * @exception IOException If an error occurs
316
   * @exception SecurityException If a security manager exists and its
317
   * checkListen method doesn't allow the operation
318
   * @exception IllegalBlockingModeException If this socket has an associated
319
   * channel, and the channel is in non-blocking mode
320
   * @exception SocketTimeoutException If a timeout was previously set with
321
   * setSoTimeout and the timeout has been reached
322
   */
323
  public Socket accept() throws IOException
324
  {
325
    Socket socket = new Socket();
326
 
327
    try
328
      {
329
        implAccept(socket);
330
      }
331
    catch (IOException e)
332
      {
333
        try
334
          {
335
            socket.close();
336
          }
337
        catch (IOException e2)
338
          {
339
            // Ignore.
340
          }
341
 
342
        throw e;
343
      }
344
    catch (SecurityException e)
345
      {
346
        try
347
          {
348
            socket.close();
349
          }
350
        catch (IOException e2)
351
          {
352
            // Ignore.
353
          }
354
 
355
        throw e;
356
      }
357
 
358
    return socket;
359
  }
360
 
361
  /**
362
   * This protected method is used to help subclasses override
363
   * <code>ServerSocket.accept()</code>.  The passed in socket will be
364
   * connected when this method returns.
365
   *
366
   * @param socket The socket that is used for the accepted connection
367
   *
368
   * @exception IOException If an error occurs
369
   * @exception IllegalBlockingModeException If this socket has an associated
370
   * channel, and the channel is in non-blocking mode
371
   *
372
   * @since 1.1
373
   */
374
  protected final void implAccept(Socket socket) throws IOException
375
  {
376
    if (isClosed())
377
      throw new SocketException("ServerSocket is closed");
378
 
379
    // The Sun spec says that if we have an associated channel and
380
    // it is in non-blocking mode, we throw an IllegalBlockingModeException.
381
    // However, in our implementation if the channel itself initiated this
382
    // operation, then we must honor it regardless of its blocking mode.
383
    if (getChannel() != null && ! getChannel().isBlocking()
384
        && ! ((PlainSocketImpl) getImpl()).isInChannelOperation())
385
      throw new IllegalBlockingModeException();
386
 
387
    impl.accept(socket.impl);
388
    socket.bound = true;
389
    socket.implCreated = true;
390
 
391
    SecurityManager sm = System.getSecurityManager();
392
    if (sm != null)
393
      sm.checkAccept(socket.getInetAddress().getHostAddress(),
394
                     socket.getPort());
395
  }
396
 
397
  /**
398
   * Closes this socket and stops listening for connections
399
   *
400
   * @exception IOException If an error occurs
401
   */
402
  public void close() throws IOException
403
  {
404
    if (impl != null)
405
      {
406
        impl.close();
407
        impl = null;
408
      }
409
  }
410
 
411
  /**
412
   * Returns the unique <code>ServerSocketChannel</code> object
413
   * associated with this socket, if any.
414
   *
415
   * <p>The socket only has a <code>ServerSocketChannel</code> if its created
416
   * by <code>ServerSocketChannel.open()</code>.</p>
417
   *
418
   * @return the associated socket channel, null if none exists
419
   *
420
   * @since 1.4
421
   */
422
  public ServerSocketChannel getChannel()
423
  {
424
    return null;
425
  }
426
 
427
  /**
428
   * Returns true when the socket is bound, otherwise false
429
   *
430
   * @return true if socket is bound, false otherwise
431
   *
432
   * @since 1.4
433
   */
434
  public boolean isBound()
435
  {
436
    return local != null;
437
  }
438
 
439
  /**
440
   * Returns true if the socket is closed, otherwise false
441
   *
442
   * @return true if socket is closed, false otherwise
443
   *
444
   * @since 1.4
445
   */
446
  public boolean isClosed()
447
  {
448
    ServerSocketChannel channel = getChannel();
449
    return impl == null || (channel != null && ! channel.isOpen());
450
  }
451
 
452
  /**
453
   * Sets the value of SO_TIMEOUT.  A value of 0 implies that SO_TIMEOUT is
454
   * disabled (ie, operations never time out).  This is the number of
455
   * milliseconds a socket operation can block before an
456
   * InterruptedIOException is thrown.
457
   *
458
   * @param timeout The new SO_TIMEOUT value
459
   *
460
   * @exception SocketException If an error occurs
461
   *
462
   * @since 1.1
463
   */
464
  public void setSoTimeout(int timeout) throws SocketException
465
  {
466
    if (isClosed())
467
      throw new SocketException("ServerSocket is closed");
468
 
469
    if (timeout < 0)
470
      throw new IllegalArgumentException("SO_TIMEOUT value must be >= 0");
471
 
472
    impl.setOption(SocketOptions.SO_TIMEOUT, Integer.valueOf(timeout));
473
  }
474
 
475
  /**
476
   * Retrieves the current value of the SO_TIMEOUT setting.  A value of 0
477
   * implies that SO_TIMEOUT is disabled (ie, operations never time out).
478
   * This is the number of milliseconds a socket operation can block before
479
   * an InterruptedIOException is thrown.
480
   *
481
   * @return The value of SO_TIMEOUT
482
   *
483
   * @exception IOException If an error occurs
484
   *
485
   * @since 1.1
486
   */
487
  public int getSoTimeout() throws IOException
488
  {
489
    if (isClosed())
490
      throw new SocketException("ServerSocket is closed");
491
 
492
    Object timeout = impl.getOption(SocketOptions.SO_TIMEOUT);
493
 
494
    if (! (timeout instanceof Integer))
495
      throw new IOException("Internal Error");
496
 
497
    return ((Integer) timeout).intValue();
498
  }
499
 
500
  /**
501
   * Enables/Disables the SO_REUSEADDR option
502
   *
503
   * @param on true if SO_REUSEADDR should be enabled, false otherwise
504
   *
505
   * @exception SocketException If an error occurs
506
   *
507
   * @since 1.4
508
   */
509
  public void setReuseAddress(boolean on) throws SocketException
510
  {
511
    if (isClosed())
512
      throw new SocketException("ServerSocket is closed");
513
 
514
    impl.setOption(SocketOptions.SO_REUSEADDR, Boolean.valueOf(on));
515
  }
516
 
517
  /**
518
   * Checks if the SO_REUSEADDR option is enabled
519
   *
520
   * @return true if SO_REUSEADDR is set, false otherwise
521
   *
522
   * @exception SocketException If an error occurs
523
   *
524
   * @since 1.4
525
   */
526
  public boolean getReuseAddress() throws SocketException
527
  {
528
    if (isClosed())
529
      throw new SocketException("ServerSocket is closed");
530
 
531
    Object reuseaddr = impl.getOption(SocketOptions.SO_REUSEADDR);
532
 
533
    if (! (reuseaddr instanceof Boolean))
534
      throw new SocketException("Internal Error");
535
 
536
    return ((Boolean) reuseaddr).booleanValue();
537
  }
538
 
539
  /**
540
   * This method sets the value for the system level socket option
541
   * SO_RCVBUF to the specified value.  Note that valid values for this
542
   * option are specific to a given operating system.
543
   *
544
   * @param size The new receive buffer size.
545
   *
546
   * @exception SocketException If an error occurs or Socket is not connected
547
   * @exception IllegalArgumentException If size is 0 or negative
548
   *
549
   * @since 1.4
550
   */
551
  public void setReceiveBufferSize(int size) throws SocketException
552
  {
553
    if (isClosed())
554
      throw new SocketException("ServerSocket is closed");
555
 
556
    if (size <= 0)
557
      throw new IllegalArgumentException("SO_RCVBUF value must be > 0");
558
 
559
    impl.setOption(SocketOptions.SO_RCVBUF, Integer.valueOf(size));
560
  }
561
 
562
  /**
563
   * This method returns the value of the system level socket option
564
   * SO_RCVBUF, which is used by the operating system to tune buffer
565
   * sizes for data transfers.
566
   *
567
   * @return The receive buffer size.
568
   *
569
   * @exception SocketException If an error occurs or Socket is not connected
570
   *
571
   * @since 1.4
572
   */
573
  public int getReceiveBufferSize() throws SocketException
574
  {
575
    if (isClosed())
576
      throw new SocketException("ServerSocket is closed");
577
 
578
    Object buf = impl.getOption(SocketOptions.SO_RCVBUF);
579
 
580
    if (! (buf instanceof Integer))
581
      throw new SocketException("Internal Error: Unexpected type");
582
 
583
    return ((Integer) buf).intValue();
584
  }
585
 
586
  /**
587
   * Returns the value of this socket as a <code>String</code>.
588
   *
589
   * @return This socket represented as a <code>String</code>.
590
   */
591
  public String toString()
592
  {
593
    if (! isBound())
594
      return "ServerSocket[unbound]";
595
 
596
    return ("ServerSocket[addr=" + getInetAddress() + ",port="
597
           + port + ",localport=" + getLocalPort() + "]");
598
  }
599
 
600
  /**
601
   * Sets the <code>SocketImplFactory</code> for all
602
   * <code>ServerSocket</code>'s.  This may only be done
603
   * once per virtual machine.  Subsequent attempts will generate an
604
   * exception.  Note that a <code>SecurityManager</code> check is made prior
605
   * to setting the factory.  If insufficient privileges exist to set the
606
   * factory, an exception will be thrown
607
   *
608
   * @param fac the factory to set
609
   *
610
   * @exception SecurityException If this operation is not allowed by the
611
   * <code>SecurityManager</code>.
612
   * @exception SocketException If the factory object is already defined
613
   * @exception IOException If any other error occurs
614
   */
615
  public static synchronized void setSocketFactory(SocketImplFactory fac)
616
    throws IOException
617
  {
618
    if (factory != null)
619
      throw new SocketException("SocketFactory already defined");
620
 
621
    SecurityManager sm = System.getSecurityManager();
622
    if (sm != null)
623
      sm.checkSetFactory();
624
 
625
    factory = fac;
626
  }
627
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.