Changeset 3c8cc16


Ignore:
Timestamp:
Nov 30, 2015 8:20:55 PM (5 years ago)
Author:
zzz <zzz@…>
Branches:
master
Children:
f778c23f
Parents:
1c15112
Message:

SAM: Use the Destination cache
Comment out some unused methods
SAM client: Add SSL forward support
Handle header line in forwarded stream
Name some threads, number some others

Location:
apps/sam/java/src/net/i2p/sam
Files:
1 added
6 edited

Legend:

Unmodified
Added
Removed
  • apps/sam/java/src/net/i2p/sam/SAMBridge.java

    r1c15112 r3c8cc16  
    208208     * @param name name of the destination
    209209     * @return null if the name does not exist, or if it is improperly formatted
    210      * @deprecated unused
    211      */
     210     */
     211/****
    212212    public Destination getDestination(String name) {
    213213        synchronized (nameToPrivKeys) {
     
    225225        }
    226226    }
     227****/
    227228   
    228229    /**
  • apps/sam/java/src/net/i2p/sam/SAMStreamSession.java

    r1c15112 r3c8cc16  
    227227        }
    228228
    229         Destination d = new Destination();
    230         d.fromBase64(dest);
     229        Destination d = SAMUtils.getDest(dest);
    231230
    232231        I2PSocketOptions opts = socketMgr.buildOptions(props);
  • apps/sam/java/src/net/i2p/sam/SAMUtils.java

    r1c15112 r3c8cc16  
    8383     * @return True if the destination is valid, false otherwise
    8484     */
     85/****
    8586    public static boolean checkDestination(String dest) {
    8687        try {
     
    9394        }
    9495    }
     96****/
    9597
    9698    /**
     
    106108        ByteArrayInputStream destKeyStream = new ByteArrayInputStream(b);
    107109        try {
    108                 Destination d = new Destination();
    109                 d.readBytes(destKeyStream);
     110                Destination d = Destination.create(destKeyStream);
    110111                new PrivateKey().readBytes(destKeyStream);
    111112                SigningPrivateKey spk = new SigningPrivateKey(d.getSigningPublicKey().getType());
  • apps/sam/java/src/net/i2p/sam/SAMv2StreamSession.java

    r1c15112 r3c8cc16  
    106106                        }
    107107
    108                         Destination d = new Destination();
    109 
    110                         d.fromBase64 ( dest );
    111 
     108                        Destination d = SAMUtils.getDest(dest);
    112109                        I2PSocketOptions opts = socketMgr.buildOptions ( props );
    113 
    114110                        if ( props.getProperty ( I2PSocketOptions.PROP_CONNECT_TIMEOUT ) == null )
    115111                                opts.setConnectTimeout ( 60 * 1000 );
     
    118114                                _log.debug ( "Connecting new I2PSocket..." );
    119115
    120 
    121116                        // non-blocking connection (SAMv2)
    122 
    123                         StreamConnector connector ;
    124 
    125                         connector = new StreamConnector ( id, d, opts );
    126                        
     117                        StreamConnector connector = new StreamConnector ( id, d, opts );
    127118                        I2PAppThread connectThread = new I2PAppThread ( connector, "StreamConnector" + id ) ;
    128 
    129119                        connectThread.start() ;
    130 
    131120                        return true ;
    132121                }
  • apps/sam/java/src/net/i2p/sam/client/SAMReader.java

    r1c15112 r3c8cc16  
    66import java.util.Properties;
    77import java.util.StringTokenizer;
     8import java.util.concurrent.atomic.AtomicInteger;
    89
    910import net.i2p.I2PAppContext;
     
    2324    private volatile boolean _live;
    2425    private Thread _thread;
     26    private static final AtomicInteger _count = new AtomicInteger();
    2527   
    2628    public SAMReader(I2PAppContext context, InputStream samIn, SAMClientEventListener listener) {
     
    3436            throw new IllegalStateException();
    3537        _live = true;
    36         I2PAppThread t = new I2PAppThread(new Runner(), "SAM reader");
     38        I2PAppThread t = new I2PAppThread(new Runner(), "SAM reader " + _count.incrementAndGet());
    3739        t.start();
    3840        _thread = t;
  • apps/sam/java/src/net/i2p/sam/client/SAMStreamSink.java

    r1c15112 r3c8cc16  
    1717import javax.net.ssl.SSLSocket;
    1818import javax.net.ssl.SSLServerSocket;
     19import javax.net.ssl.SSLServerSocketFactory;
    1920
    2021import gnu.getopt.Getopt;
     
    5758    private static I2PSSLSocketFactory _sslSocketFactory;
    5859   
    59     private static final int STREAM=0, DG=1, V1DG=2, RAW=3, V1RAW=4, RAWHDR = 5, FORWARD = 6;
    60     private static final String USAGE = "Usage: SAMStreamSink [-s] [-m mode] [-v version] [-b samHost] [-p samPort] [-o opt=val] [-u user] [-w password] myDestFile sinkDir\n" +
    61                                         "       modes: stream: 0; datagram: 1; v1datagram: 2; raw: 3; v1raw: 4; raw-with-headers: 5; stream-forward: 6\n" +
    62                                         "       -s: use SSL\n" +
     60    private static final int STREAM=0, DG=1, V1DG=2, RAW=3, V1RAW=4, RAWHDR = 5, FORWARD = 6, FORWARDSSL=7;
     61    private static final String USAGE = "Usage: SAMStreamSink [-s] [-m mode] [-v version] [-b samHost] [-p samPort]\n" +
     62                                        "                     [-o opt=val] [-u user] [-w password] myDestFile sinkDir\n" +
     63                                        "       modes: stream: 0; datagram: 1; v1datagram: 2;\n" +
     64                                        "              raw: 3; v1raw: 4; raw-with-headers: 5;\n" +
     65                                        "              stream-forward: 6; stream-forward-ssl: 7\n" +
     66                                        "       -s: use SSL to connect to bridge\n" +
    6367                                        "       multiple -o session options are allowed";
    6468    private static final int V3FORWARDPORT=9998;
     
    8488            case 'm':
    8589                mode = Integer.parseInt(g.getOptarg());
    86                 if (mode < 0 || mode > FORWARD) {
     90                if (mode < 0 || mode > FORWARDSSL) {
    8791                    System.err.println(USAGE);
    8892                    return;
     
    175179                t.start();
    176180            }
    177             if (_isV3 && (mode == STREAM || mode == FORWARD)) {
     181            if (_isV3 && (mode == STREAM || mode == FORWARD || mode == FORWARDSSL)) {
    178182                // test multiple acceptors, only works in 3.2
    179183                int acceptors = (_isV32 && mode == STREAM) ? 4 : 1;
     
    194198                if (mode == FORWARD) {
    195199                    // set up a listening ServerSocket
    196                     (new FwdRcvr(isSSL)).start();
     200                    (new FwdRcvr(false, null)).start();
     201                } else if (mode == FORWARDSSL) {
     202                    // set up a listening ServerSocket
     203                    String scfile = SSLUtil.DEFAULT_SAMCLIENT_CONFIGFILE;
     204                    File file = new File(scfile);
     205                    Properties opts = new Properties();
     206                    if (file.exists())
     207                        DataHelper.loadProps(opts, file);
     208                    boolean shouldSave = SSLUtil.verifyKeyStore(opts);
     209                    if (shouldSave)
     210                        DataHelper.storeProps(opts, file);
     211                    (new FwdRcvr(true, opts)).start();
    197212                }
    198213            } else if (_isV3 && (mode == DG || mode == RAW || mode == RAWHDR)) {
     
    209224        private final int _mode;
    210225
    211         public DGRcvr(int mode) { _mode = mode; }
     226        public DGRcvr(int mode) {
     227            super("SAM DG Rcvr");
     228            _mode = mode;
     229        }
    212230
    213231        public void run() {
     
    258276    private class FwdRcvr extends I2PAppThread {
    259277        private final boolean _isSSL;
    260 
    261         public FwdRcvr(boolean isSSL) {
    262             if (isSSL)
    263                 throw new UnsupportedOperationException("TODO");
     278        // for SSL only
     279        private final Properties _opts;
     280
     281        public FwdRcvr(boolean isSSL, Properties opts) {
     282            super("SAM Fwd Rcvr");
    264283            _isSSL = isSSL;
     284            _opts = opts;
    265285        }
    266286
     
    269289                ServerSocket ss;
    270290                if (_isSSL) {
    271                     throw new UnsupportedOperationException("TODO");
     291                    SSLServerSocketFactory fact = SSLUtil.initializeFactory(_opts);
     292                    SSLServerSocket sock = (SSLServerSocket) fact.createServerSocket(V3FORWARDPORT);
     293                    I2PSSLSocketFactory.setProtocolsAndCiphers(sock);
     294                    ss = sock;
    272295                } else {
    273296                    ss = new ServerSocket(V3FORWARDPORT);
     
    278301                    try {
    279302                        InputStream in = s.getInputStream();
     303                        boolean gotDest = false;
     304                        byte[] dest = new byte[1024];
     305                        int dlen = 0;
    280306                        byte[] buf = new byte[32768];
    281307                        int len;
    282308                        while((len = in.read(buf)) >= 0) {
    283                             sink.received(buf, 0, len);
     309                            if (!gotDest) {
     310                                // eat the dest line
     311                                for (int i = 0; i < len; i++) {
     312                                    byte b = buf[i];
     313                                    if (b == (byte) '\n') {
     314                                        gotDest = true;
     315                                        if (_log.shouldInfo()) {
     316                                            try {
     317                                                _log.info("Got incoming accept from: \"" + new String(dest, 0, dlen, "ISO-8859-1") + '"');
     318                                            } catch (IOException uee) {}
     319                                        }
     320                                        // feed any remaining to the sink
     321                                        i++;
     322                                        if (i < len)
     323                                            sink.received(buf, i, len - i);
     324                                        break;
     325                                    } else {
     326                                        if (dlen < dest.length) {
     327                                            dest[dlen++] = b;
     328                                        } else if (dlen == dest.length) {
     329                                            dlen++;
     330                                            _log.error("first line overflow on accept");
     331                                        }
     332                                    }
     333                                }
     334                            } else {
     335                                sink.received(buf, 0, len);
     336                            }
    284337                        }
    285338                        sink.closed();
     
    535588                    else if (mode == FORWARD)
    536589                        req = "STREAM FORWARD ID=" + _v3ID + " PORT=" + V3FORWARDPORT + '\n';
     590                    else if (mode == FORWARDSSL)
     591                        req = "STREAM FORWARD ID=" + _v3ID + " PORT=" + V3FORWARDPORT + " SSL=true\n";
    537592                    else
    538593                        throw new IllegalStateException("mode " + mode);
     
    541596                    if (_log.shouldLog(Log.DEBUG))
    542597                        _log.debug("STREAM ACCEPT/FORWARD sent");
    543                     if (mode == FORWARD) {
     598                    if (mode == FORWARD || mode == FORWARDSSL) {
    544599                        // docs were wrong, we do not get a STREAM STATUS if SILENT=true for ACCEPT
    545600                        boolean ok = eventHandler.waitForStreamStatusReply();
     
    588643                }
    589644                String style;
    590                 if (mode == STREAM || mode == FORWARD)
     645                if (mode == STREAM || mode == FORWARD || mode == FORWARDSSL)
    591646                    style = "STREAM";
    592647                else if (mode == V1DG)
Note: See TracChangeset for help on using the changeset viewer.