Changeset de6edc6


Ignore:
Timestamp:
Apr 4, 2009 10:28:31 AM (11 years ago)
Author:
mkvore-commit <mkvore-commit@…>
Branches:
master
Children:
2cf5221
Parents:
bc086a7
Message:
 
Location:
apps
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • apps/ministreaming/java/src/net/i2p/client/streaming/I2PServerSocket.java

    rbc086a7 rde6edc6  
    4545     * @throws SocketTimeoutException
    4646     */
    47     public I2PSocket accept(boolean blocking) throws I2PException, ConnectException, SocketTimeoutException;
     47    public I2PSocket accept(long timeout) throws I2PException, ConnectException, SocketTimeoutException, InterruptedException;
    4848
    4949    /**
     
    5959     * @throws ConnectException if the I2PServerSocket is closed
    6060     */
    61     public boolean waitIncoming(long timeoutMs) throws I2PException, ConnectException, InterruptedException;
     61    public void waitIncoming(long timeoutMs) throws I2PException, ConnectException, InterruptedException;
    6262
    6363    /**
  • apps/ministreaming/java/src/net/i2p/client/streaming/I2PServerSocketImpl.java

    rbc086a7 rde6edc6  
    6161     * @param timeoutMs timeout in ms. A negative value waits forever.
    6262     *
    63      * @return true if a socket is available, false if not
    64      *
    6563     * @throws I2PException if there is a problem with reading a new socket
    6664     *         from the data available (aka the I2PSession closed, etc)
    6765     * @throws ConnectException if the I2PServerSocket is closed
    6866     */
    69     public boolean waitIncoming(long timeoutMs) throws I2PException, ConnectException {
     67    public void waitIncoming(long timeoutMs) throws I2PException, ConnectException, InterruptedException {
    7068        if (_log.shouldLog(Log.DEBUG))
    7169            _log.debug("waitIncoming() called, pending: " + pendingSockets.size());
    7270       
    73         boolean isTimed = (timeoutMs>=0);
     71        boolean isTimed = (timeoutMs>0);
    7472        if (isTimed) {
    7573            Clock clock = I2PAppContext.getGlobalContext().clock();
     
    7876            while (pendingSockets.size() <= 0 && now<end) {
    7977                if (closing) throw new ConnectException("I2PServerSocket closed");
    80                 try {
    81                     synchronized(socketAddedLock) {
    82                         socketAddedLock.wait(end - now);
    83                     }
    84                 } catch (InterruptedException ie) {}
     78                synchronized(socketAddedLock) {
     79                    socketAddedLock.wait(end - now);
     80                }
    8581                now = clock.now();
    8682            }
     
    9591            }
    9692        }
    97                 return (pendingSockets.size()>0);
    9893        }
    9994
     
    113108     */
    114109
    115         public I2PSocket accept(boolean blocking) throws I2PException, ConnectException {
     110        public I2PSocket accept(long timeout) throws I2PException, ConnectException, InterruptedException {
    116111        I2PSocket ret = null;
    117112       
    118         if (blocking) {
     113        if (timeout<=0) {
    119114                ret = accept();
    120115        } else {
     116                long now  = I2PAppContext.getGlobalContext().clock().now();
     117            long expiration = timeout + now ;
    121118                synchronized (pendingSockets) {
    122                 if (pendingSockets.size() > 0) {
    123                     ret = (I2PSocket)pendingSockets.remove(0);
    124                 }
     119                while (pendingSockets.size() == 0 && expiration>now) {
     120                        pendingSockets.wait(expiration-now);
     121                        now  = I2PAppContext.getGlobalContext().clock().now();
     122                }
     123                ret = (I2PSocket)pendingSockets.remove(0);
    125124            }
    126125            if (ret != null) {
     
    152151       
    153152        while ( (ret == null) && (!closing) ){
    154                
    155                 this.waitIncoming(-1);
    156 
    157                 ret = accept(false);
     153                try {
     154                        this.waitIncoming(0);
     155                        ret = accept(1);
     156                } catch (InterruptedException e) {
     157                        throw new I2PException("Thread interrupted") ;
     158                }
    158159        }
    159160       
  • apps/sam/Demos/datagramTests/samForward.py

    rbc086a7 rde6edc6  
    1717        name = sys.argv[2]
    1818else :
    19         name = "essaiSamForward"
     19        name = "datagramSamForward"
    2020
    2121sess = socket.socket(
  • apps/sam/java/src/net/i2p/sam/SAMv3StreamSession.java

    rbc086a7 rde6edc6  
    270270                        while (session.socketServer!=null) {
    271271                               
    272                         boolean available = false ;
    273272                                I2PSocket i2ps = null ;
    274273                                try {
    275                                         available = session.socketServer.waitIncoming(-1);
     274                                        session.socketServer.waitIncoming(0);
    276275                                } catch (ConnectException e) {
    277276                                        _log.debug("ConnectException");
     
    284283                                        break ;
    285284                                }
    286                                 if ( !available ) continue ;
    287285                               
    288286                                java.net.InetSocketAddress addr = new java.net.InetSocketAddress(host,port);
     
    297295                               
    298296                                try {
    299                                         i2ps = session.socketServer.accept(false);
     297                                        i2ps = session.socketServer.accept(1);
    300298                                } catch (Exception e) {}
    301299                               
  • apps/streaming/java/src/net/i2p/client/streaming/ConnectionHandler.java

    rbc086a7 rde6edc6  
    2424    private ConnectionManager _manager;
    2525    private LinkedBlockingQueue<Packet> _synQueue;
     26    private Object _synSignal;
    2627    private boolean _active;
    2728    private int _acceptTimeout;
     
    8283        if (success) {
    8384            SimpleScheduler.getInstance().addEvent(new TimeoutSyn(packet), _acceptTimeout);
    84         } else {
     85            if (packet.isFlagSet(Packet.FLAG_SYNCHRONIZE))
     86                synchronized (this._synSignal)
     87                {
     88                        this._synSignal.notifyAll();
     89                }
     90
     91       } else {
    8592            if (_log.shouldLog(Log.WARN))
    8693                _log.warn("Dropping new SYN request, as the queue is full");
     
    9097    }
    9198   
    92     public boolean waitSyn( long ms ) throws InterruptedException {
    93         throw new InterruptedException();
     99    /**
     100     * Wait until some SYN packet is available
     101     * @param ms max amount of time to wait for a connection (if negative or null,
     102     *                wait indefinitely)
     103     * @throws InterruptedException
     104     */
     105    public void waitSyn( long ms ) throws InterruptedException {
     106        synchronized (this._synSignal)
     107        {
     108                this._synSignal.wait(ms);
     109        }
    94110    }
    95111   
     
    121137            }
    122138           
     139            if ( (timeoutMs > 0) && (expiration < _context.clock().now()) )
     140                return null;
     141
    123142            Packet syn = null;
    124143            while ( _active && syn == null) {
     
    163182            }
    164183            // keep looping...
    165             if ( (timeoutMs >= 0) && (expiration < _context.clock().now()) )
    166                 return null;
    167184        }
    168185    }
  • apps/streaming/java/src/net/i2p/client/streaming/I2PServerSocketFull.java

    rbc086a7 rde6edc6  
    6666     */
    6767
    68         public I2PSocket accept(boolean blocking)  throws I2PException, SocketTimeoutException {
    69                 long timeout = this.getSoTimeout();
     68        public I2PSocket accept(long timeout)  throws I2PException {
     69                long reset_timeout = this.getSoTimeout();
    7070
    7171                try {
    72                         if (blocking)
    73                         {
    74                                 this.setSoTimeout(-1);
    75                         } else {
    76                                 this.setSoTimeout(0);
    77                         }
    78                         try {
    79                                 return this.accept();
    80                         } catch (SocketTimeoutException e) {
    81                                 if (blocking) throw e;
    82                                 else return null ;
    83                         }
     72                        this.setSoTimeout(timeout);
     73                        return this.accept();
     74                } catch (SocketTimeoutException e) {
     75                        return null ;
    8476                } finally {
    85                         this.setSoTimeout(timeout);
     77                        this.setSoTimeout(reset_timeout);
    8678                }
    8779        }
    8880
    89         public boolean waitIncoming(long timeoutMs) throws InterruptedException {
    90         return this._socketManager.getConnectionManager().getConnectionHandler().waitSyn(timeoutMs);
     81        public void waitIncoming(long timeoutMs) throws InterruptedException {
     82        this._socketManager.getConnectionManager().getConnectionHandler().waitSyn(timeoutMs);
    9183        }
    9284}
Note: See TracChangeset for help on using the changeset viewer.