Examples with Destination net.i2p.data.Destination used on opensource projects

Example 36 with Destination

use of net.i2p.data.Destination in project i2p.i2p by i2p.

the class BlockfileNamingService method addDestination.

/**
 *  Add a Destination to an existing hostname's entry in the addressbook.
 *
 *  This does not prevent adding b32. Caller must check.
 *
 *  @param options NamingService-specific, may be null
 *  @return success
 *  @since 0.9.26
 */
@Override
public boolean addDestination(String hostname, Destination d, Properties options) {
    if (!_isVersion4)
        return putIfAbsent(hostname, d, options);
    List<Properties> storedOptions = new ArrayList<Properties>(4);
    synchronized (_bf) {
        // We use lookupAll2(), not lookupAll(), because if hostname starts with www.,
        // we do not want to read in from the
        // non-www hostname and then copy it to a new www hostname.
        List<Destination> dests = lookupAll2(hostname, options, storedOptions);
        if (dests == null)
            return put(hostname, d, options, false);
        if (dests.contains(d))
            return false;
        if (dests.size() >= MAX_DESTS_PER_HOST)
            return false;
        List<Destination> newDests = new ArrayList<Destination>(dests.size() + 1);
        newDests.addAll(dests);
        // TODO better sort by sigtype preference.
        // For now, non-DSA at the front, DSA at the end
        SigType type = d.getSigningPublicKey().getType();
        if (type != SigType.DSA_SHA1 && type.isAvailable()) {
            newDests.add(0, d);
            storedOptions.add(0, options);
        } else {
            newDests.add(d);
            storedOptions.add(options);
        }
        return put(hostname, newDests, storedOptions, false);
    }
}

Example 37 with Destination

use of net.i2p.data.Destination in project i2p.i2p by i2p.

the class DoCMDS method run.

/**
 * The actual parser.
 * It probabbly needs a rewrite into functions, but I kind-of like inline code.
 */
public void run() {
    dk = ns = ip = op = false;
    try {
        try {
            // Get input from the client
            BufferedReader in = new BufferedReader(new InputStreamReader(server.getInputStream()));
            PrintStream out = new PrintStream(server.getOutputStream());
            quit: {
                die: {
                    prikey = new ByteArrayOutputStream();
                    out.println("BOB " + BOBversion);
                    out.println("OK");
                    while ((line = in.readLine()) != null) {
                        // use a space as a delimiter
                        StringTokenizer token = new StringTokenizer(line, " ");
                        String Command = "";
                        String Arg = "";
                        NamedDB info;
                        if (token.countTokens() != 0) {
                            Command = token.nextToken();
                            Command = Command.toLowerCase(Locale.US);
                            if (token.countTokens() != 0) {
                                Arg = token.nextToken();
                            } else {
                                Arg = "";
                            }
                            // and discarded without any warnings.
                            if (Command.equals(C_help)) {
                                for (int i = 0; !C_ALL[i][0].equals(" "); i++) {
                                    if (C_ALL[i][0].equalsIgnoreCase(Arg)) {
                                        out.println("OK " + C_ALL[i][1]);
                                    }
                                }
                            } else if (Command.equals(C_visit)) {
                                visitAllThreads();
                                out.println("OK ");
                            } else if (Command.equals(C_lookup)) {
                                Destination dest = null;
                                String reply = null;
                                if (Arg.endsWith(".i2p")) {
                                    try {
                                        // try {
                                        // dest = I2PTunnel.destFromName(Arg);
                                        // } catch (DataFormatException ex) {
                                        // }
                                        dest = I2PAppContext.getGlobalContext().namingService().lookup(Arg);
                                        if (dest != null) {
                                            reply = dest.toBase64();
                                        }
                                    } catch (NullPointerException npe) {
                                    // Could not find the destination!?
                                    }
                                }
                                if (reply == null) {
                                    out.println("ERROR Address Not found.");
                                } else {
                                    out.println("OK " + reply);
                                }
                            } else if (Command.equals(C_getdest)) {
                                if (ns) {
                                    if (dk) {
                                        rlock();
                                        try {
                                            out.println("OK " + nickinfo.get(P_DEST));
                                        } catch (Exception e) {
                                            break die;
                                        } finally {
                                            runlock();
                                        }
                                    } else {
                                        out.println("ERROR keys not set.");
                                    }
                                } else {
                                    nns(out);
                                }
                            } else if (Command.equals(C_list)) {
                                // Produce a formatted list of all nicknames
                                database.getReadLock();
                                try {
                                    for (Object ndb : database.values()) {
                                        try {
                                            info = (NamedDB) ndb;
                                            out.print("DATA");
                                        } catch (Exception e) {
                                            break die;
                                        }
                                        nickprint(out, info);
                                    }
                                } finally {
                                    database.releaseReadLock();
                                }
                                out.println("OK Listing done");
                            } else if (Command.equals(C_quit)) {
                                // End the command session
                                break quit;
                            } else if (Command.equals(C_zap)) {
                                // Kill BOB!! (let's hope this works!)
                                LIVE.set(false);
                                // End the command session
                                break quit;
                            } else if (Command.equals(C_newkeys)) {
                                if (ns) {
                                    try {
                                        if (tunnelactive(nickinfo)) {
                                            out.println("ERROR tunnel is active");
                                        } else {
                                            try {
                                                // Make a new PublicKey and PrivateKey
                                                prikey = new ByteArrayOutputStream();
                                                d = I2PClientFactory.createClient().createDestination(prikey);
                                                wlock();
                                                try {
                                                    nickinfo.add(P_KEYS, prikey.toByteArray());
                                                    nickinfo.add(P_DEST, d.toBase64());
                                                    out.println("OK " + nickinfo.get(P_DEST));
                                                } catch (Exception e) {
                                                    break die;
                                                } finally {
                                                    wunlock();
                                                }
                                                dk = true;
                                            } catch (I2PException ipe) {
                                                _log.error("Error generating keys", ipe);
                                                out.println("ERROR generating keys");
                                            }
                                        }
                                    } catch (Exception e) {
                                        break die;
                                    }
                                } else {
                                    nns(out);
                                }
                            } else if (Command.equals(C_getkeys)) {
                                // Return public key
                                if (dk) {
                                    prikey = new ByteArrayOutputStream();
                                    rlock();
                                    try {
                                        prikey.write(((byte[]) nickinfo.get(P_KEYS)));
                                    } catch (Exception ex) {
                                        break die;
                                    } finally {
                                        runlock();
                                    }
                                    out.println("OK " + net.i2p.data.Base64.encode(prikey.toByteArray()));
                                } else {
                                    out.println("ERROR no public key has been set");
                                }
                            } else if (Command.equals(C_quiet)) {
                                if (ns) {
                                    try {
                                        if (tunnelactive(nickinfo)) {
                                            out.println("ERROR tunnel is active");
                                        } else {
                                            wlock();
                                            try {
                                                nickinfo.add(P_QUIET, Boolean.valueOf(Arg));
                                            } catch (Exception ex) {
                                                break die;
                                            } finally {
                                                wunlock();
                                            }
                                            out.println("OK Quiet set");
                                        }
                                    } catch (Exception ex) {
                                        break die;
                                    }
                                } else {
                                    nns(out);
                                }
                            } else if (Command.equals(C_verify)) {
                                if (is64ok(Arg)) {
                                    out.println("OK");
                                } else {
                                    out.println("ERROR not in BASE64 format");
                                }
                            } else if (Command.equals(C_setkeys)) {
                                // Set the NamedDB to a privatekey in BASE64 format
                                if (ns) {
                                    try {
                                        if (tunnelactive(nickinfo)) {
                                            out.println("ERROR tunnel is active");
                                        } else {
                                            try {
                                                prikey = new ByteArrayOutputStream();
                                                prikey.write(net.i2p.data.Base64.decode(Arg));
                                                d = new Destination();
                                                d.fromBase64(Arg);
                                            } catch (Exception ex) {
                                                Arg = "";
                                            }
                                            if ((Arg.length() == 884) && is64ok(Arg)) {
                                                wlock();
                                                try {
                                                    nickinfo.add(P_KEYS, prikey.toByteArray());
                                                    nickinfo.add(P_DEST, d.toBase64());
                                                    out.println("OK " + nickinfo.get(P_DEST));
                                                } catch (Exception ex) {
                                                    break die;
                                                } finally {
                                                    wunlock();
                                                }
                                                dk = true;
                                            } else {
                                                out.println("ERROR not in BASE64 format");
                                            }
                                        }
                                    } catch (Exception ex) {
                                        break die;
                                    }
                                } else {
                                    nns(out);
                                }
                            } else if (Command.equals(C_setnick)) {
                                ns = dk = ip = op = false;
                                database.getReadLock();
                                try {
                                    nickinfo = (NamedDB) database.get(Arg);
                                    if (!tunnelactive(nickinfo)) {
                                        nickinfo = null;
                                        ns = true;
                                    }
                                } catch (Exception b) {
                                    nickinfo = null;
                                    ns = true;
                                } finally {
                                    database.releaseReadLock();
                                }
                                // Clears and Sets the initial NamedDB structure to work with
                                if (ns) {
                                    nickinfo = new NamedDB();
                                    wlock();
                                    try {
                                        database.add(Arg, nickinfo);
                                        nickinfo.add(P_NICKNAME, Arg);
                                        nickinfo.add(P_STARTING, Boolean.FALSE);
                                        nickinfo.add(P_RUNNING, Boolean.FALSE);
                                        nickinfo.add(P_STOPPING, Boolean.FALSE);
                                        nickinfo.add(P_QUIET, Boolean.FALSE);
                                        nickinfo.add(P_INHOST, "localhost");
                                        nickinfo.add(P_OUTHOST, "localhost");
                                        Properties Q = new Properties();
                                        Lifted.copyProperties(this.props, Q);
                                        Q.setProperty("inbound.nickname", Arg);
                                        Q.setProperty("outbound.nickname", Arg);
                                        nickinfo.add(P_PROPERTIES, Q);
                                    } catch (Exception e) {
                                        break die;
                                    } finally {
                                        wunlock();
                                    }
                                    out.println("OK Nickname set to " + Arg);
                                } else {
                                    out.println("ERROR tunnel is active");
                                }
                            } else if (Command.equals(C_option)) {
                                if (ns) {
                                    try {
                                        if (tunnelactive(nickinfo)) {
                                            out.println("ERROR tunnel is active");
                                        } else {
                                            // use an equal sign as a delimiter
                                            StringTokenizer otoken = new StringTokenizer(Arg, "=");
                                            if (otoken.countTokens() != 2) {
                                                out.println("ERROR too many or no options.");
                                            } else {
                                                String pname = otoken.nextToken();
                                                String pval = otoken.nextToken();
                                                wlock();
                                                try {
                                                    Properties Q = (Properties) nickinfo.get(P_PROPERTIES);
                                                    Q.setProperty(pname, pval);
                                                    nickinfo.add(P_PROPERTIES, Q);
                                                } catch (Exception ex) {
                                                    break die;
                                                } finally {
                                                    wunlock();
                                                }
                                                out.println("OK " + pname + " set to " + pval);
                                            }
                                        }
                                    } catch (Exception ex) {
                                        break die;
                                    }
                                } else {
                                    nns(out);
                                }
                            } else if (Command.equals(C_getnick)) {
                                // Get the NamedDB to work with...
                                boolean nsfail = false;
                                database.getReadLock();
                                try {
                                    nickinfo = (NamedDB) database.get(Arg);
                                    ns = true;
                                } catch (RuntimeException b) {
                                    nsfail = true;
                                    nns(out);
                                } finally {
                                    database.releaseReadLock();
                                }
                                if (ns && !nsfail) {
                                    rlock();
                                    try {
                                        dk = nickinfo.exists(P_KEYS);
                                        ip = nickinfo.exists(P_INPORT);
                                        op = nickinfo.exists(P_OUTPORT);
                                    } catch (Exception ex) {
                                        break die;
                                    } finally {
                                        runlock();
                                    }
                                    // Finally say OK.
                                    out.println("OK Nickname set to " + Arg);
                                }
                            } else if (Command.equals(C_inport)) {
                                // app --> BOB
                                if (ns) {
                                    try {
                                        if (tunnelactive(nickinfo)) {
                                            out.println("ERROR tunnel is active");
                                        } else {
                                            int prt;
                                            wlock();
                                            try {
                                                nickinfo.kill(P_INPORT);
                                                prt = Integer.parseInt(Arg);
                                                if (prt > 1 && prt < 65536) {
                                                    try {
                                                        nickinfo.add(P_INPORT, Integer.valueOf(prt));
                                                    } catch (Exception ex) {
                                                        break die;
                                                    }
                                                }
                                                ip = nickinfo.exists(P_INPORT);
                                            } catch (NumberFormatException nfe) {
                                                out.println("ERROR not a number");
                                            } finally {
                                                wunlock();
                                            }
                                            if (ip) {
                                                out.println("OK inbound port set");
                                            } else {
                                                out.println("ERROR port out of range");
                                            }
                                        }
                                    } catch (Exception ex) {
                                        break die;
                                    }
                                } else {
                                    nns(out);
                                }
                            } else if (Command.equals(C_outport)) {
                                // BOB --> app
                                if (ns) {
                                    try {
                                        if (tunnelactive(nickinfo)) {
                                            out.println("ERROR tunnel is active");
                                        } else {
                                            int prt;
                                            wlock();
                                            try {
                                                nickinfo.kill(P_OUTPORT);
                                                prt = Integer.parseInt(Arg);
                                                if (prt > 1 && prt < 65536) {
                                                    nickinfo.add(P_OUTPORT, Integer.valueOf(prt));
                                                }
                                                ip = nickinfo.exists(P_OUTPORT);
                                            } catch (NumberFormatException nfe) {
                                                out.println("ERROR not a number");
                                            } catch (Exception ex) {
                                                break die;
                                            } finally {
                                                wunlock();
                                            }
                                            if (ip) {
                                                out.println("OK outbound port set");
                                            } else {
                                                out.println("ERROR port out of range");
                                            }
                                        }
                                    } catch (Exception ex) {
                                        break die;
                                    }
                                } else {
                                    nns(out);
                                }
                            } else if (Command.equals(C_inhost)) {
                                if (ns) {
                                    try {
                                        if (tunnelactive(nickinfo)) {
                                            out.println("ERROR tunnel is active");
                                        } else {
                                            wlock();
                                            try {
                                                nickinfo.add(P_INHOST, Arg);
                                            } catch (Exception ex) {
                                                break die;
                                            } finally {
                                                wunlock();
                                            }
                                            out.println("OK inhost set");
                                        }
                                    } catch (Exception ex) {
                                        break die;
                                    }
                                } else {
                                    nns(out);
                                }
                            } else if (Command.equals(C_outhost)) {
                                if (ns) {
                                    try {
                                        if (tunnelactive(nickinfo)) {
                                            out.println("ERROR tunnel is active");
                                        } else {
                                            wlock();
                                            try {
                                                nickinfo.add(P_OUTHOST, Arg);
                                            } catch (Exception ex) {
                                                break die;
                                            } finally {
                                                wunlock();
                                            }
                                            out.println("OK outhost set");
                                        }
                                    } catch (Exception ex) {
                                        break die;
                                    }
                                } else {
                                    nns(out);
                                }
                            } else if (Command.equals(C_show)) {
                                // Get the current NamedDB properties
                                if (ns) {
                                    out.print("OK");
                                    nickprint(out, nickinfo);
                                } else {
                                    nns(out);
                                }
                            } else if (Command.equals(C_show_props)) {
                                // Get the current options properties
                                if (ns) {
                                    out.print("OK");
                                    propprint(out, nickinfo);
                                } else {
                                    nns(out);
                                }
                            } else if (Command.equals(C_start)) {
                                // Start the tunnel, if we have all the information
                                if (ns && dk && (ip || op)) {
                                    try {
                                        if (tunnelactive(nickinfo)) {
                                            out.println("ERROR tunnel is active");
                                        } else {
                                            MUXlisten tunnel;
                                            try {
                                                while (!lock.compareAndSet(false, true)) {
                                                // wait
                                                }
                                                tunnel = new MUXlisten(lock, database, nickinfo, _log);
                                                Thread t = new I2PAppThread(tunnel);
                                                t.start();
                                                // try {
                                                // Thread.sleep(1000 * 10); // Slow down the startup.
                                                // } catch(InterruptedException ie) {
                                                // // ignore it
                                                // }
                                                out.println("OK tunnel starting");
                                            } catch (I2PException e) {
                                                lock.set(false);
                                                out.println("ERROR starting tunnel: " + e);
                                            } catch (IOException e) {
                                                lock.set(false);
                                                out.println("ERROR starting tunnel: " + e);
                                            }
                                        }
                                    } catch (Exception ex) {
                                        break die;
                                    }
                                } else {
                                    out.println("ERROR tunnel settings incomplete");
                                }
                            } else if (Command.equals(C_stop)) {
                                // Stop the tunnel, if it is running
                                if (ns) {
                                    rlock();
                                    boolean released = false;
                                    try {
                                        if (nickinfo.get(P_RUNNING).equals(Boolean.TRUE) && nickinfo.get(P_STOPPING).equals(Boolean.FALSE) && nickinfo.get(P_STARTING).equals(Boolean.FALSE)) {
                                            runlock();
                                            released = true;
                                            wlock();
                                            try {
                                                nickinfo.add(P_STOPPING, Boolean.TRUE);
                                            } catch (Exception e) {
                                                break die;
                                            } finally {
                                                wunlock();
                                            }
                                            out.println("OK tunnel stopping");
                                        } else {
                                            out.println("ERROR tunnel is inactive");
                                        }
                                    } catch (Exception e) {
                                        break die;
                                    } finally {
                                        if (!released)
                                            runlock();
                                    }
                                } else {
                                    nns(out);
                                }
                            } else if (Command.equals(C_clear)) {
                                // Clear use of the NamedDB if stopped
                                if (ns) {
                                    try {
                                        if (tunnelactive(nickinfo)) {
                                            out.println("ERROR tunnel is active");
                                        } else {
                                            database.getWriteLock();
                                            try {
                                                database.kill((String) nickinfo.get(P_NICKNAME));
                                            } catch (Exception e) {
                                            } finally {
                                                database.releaseWriteLock();
                                            }
                                            dk = ns = ip = op = false;
                                            out.println("OK cleared");
                                        }
                                    } catch (Exception ex) {
                                        break die;
                                    }
                                } else {
                                    nns(out);
                                }
                            } else if (Command.equals(C_status)) {
                                database.getReadLock();
                                try {
                                    if (database.exists(Arg)) {
                                        // Show status of a NamedDB
                                        out.print("OK ");
                                        try {
                                            ttlpnt(out, Arg);
                                        } catch (Exception e) {
                                            // this will cause an IOE if IOE
                                            out.println();
                                            break die;
                                        }
                                    } else {
                                        nns(out);
                                    }
                                } catch (Exception e) {
                                    break die;
                                } finally {
                                    database.releaseReadLock();
                                }
                            } else {
                                out.println("ERROR UNKNOWN COMMAND! Try help");
                            }
                        }
                    }
                }
                // die
                out.print("ERROR A really bad error just happened, ");
            }
            // quit
            // Say goodbye.
            out.println("OK Bye!");
        } catch (IOException ioe) {
        // not really needed, except to debug.
        // BOB.warn("IOException on socket listen: " + ioe);
        // ioe.printStackTrace();
        }
    } finally {
        try {
            server.close();
        } catch (IOException ex) {
        // nop
        }
    }
}

Example 38 with Destination

use of net.i2p.data.Destination in project i2p.i2p by i2p.

the class BlockfileNamingServiceTest method testRepeatedLookup.

public void testRepeatedLookup() throws Exception {
    int found = 0;
    int notfound = 0;
    int rfound = 0;
    int rnotfound = 0;
    for (String name : _names) {
        Destination dest = _bns.lookup(name);
        if (dest != null) {
            found++;
            String reverse = _bns.reverseLookup(dest);
            if (reverse != null)
                rfound++;
            else
                rnotfound++;
        } else {
            notfound++;
        }
    }
    assertEquals(0, notfound);
    assertEquals(0, rnotfound);
}

Example 39 with Destination

use of net.i2p.data.Destination in project i2p.i2p by i2p.

the class DatagramTest method testBadagram.

public void testBadagram() throws Exception {
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    I2PClient client = I2PClientFactory.createClient();
    Destination d = client.createDestination(out);
    I2PSession session = client.createSession(new ByteArrayInputStream(out.toByteArray()), null);
    DSAEngine dsaEng = DSAEngine.getInstance();
    ByteArrayOutputStream dout = new ByteArrayOutputStream();
    d.writeBytes(dout);
    dsaEng.sign(Hash.FAKE_HASH.toByteArray(), session.getPrivateKey()).writeBytes(dout);
    dout.write(DataHelper.getASCII("blah"));
    byte[] data = dout.toByteArray();
    I2PDatagramDissector dd = new I2PDatagramDissector();
    dd.loadI2PDatagram(data);
    boolean error = false;
    try {
        dd.getPayload();
    } catch (I2PInvalidDatagramException i2pide) {
        error = true;
    }
    assertTrue(error);
    error = false;
    try {
        dd.getSender();
    } catch (I2PInvalidDatagramException i2pide) {
        error = true;
    }
    assertTrue(error);
    error = false;
    try {
        dd.getHash();
    } catch (I2PInvalidDatagramException i2pide) {
        error = true;
    }
    assertTrue(error);
}

Example 40 with Destination

use of net.i2p.data.Destination in project i2p.i2p by i2p.

the class I2PSessionIT method testSendClosedMessage.

public void testSendClosedMessage() throws Exception {
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    Destination d = I2PClientFactory.createClient().createDestination(out);
    I2PSession session = new I2PSessionImpl2(I2PAppContext.getGlobalContext(), new ByteArrayInputStream(out.toByteArray()), null);
    boolean error = false;
    try {
        session.sendMessage(d, out.toByteArray());
    } catch (I2PSessionException i2pse) {
        error = true;
    }
    assertTrue(error);
}