@Override
 public String toString() {
   StringBuilder sb = new StringBuilder("sig[");
   sb.append(number1.toString()).append('/');
   sb.append(number2.toString()).append(']');
   return sb.toString();
 }
 /* (non-Javadoc)
  * @see net.tomp2p.message.SignatureCodec#encode()
  */
 @Override
 public byte[] encode() throws IOException {
   byte me[] = new byte[2 + (2 * (20 + 2))];
   me[0] = 0x30;
   me[1] = 2 * (20 + 2);
   me[2] = 0x02;
   me[3] = 20;
   number1.toByteArray(me, 4);
   me[24] = 0x02;
   me[25] = 20;
   number2.toByteArray(me, 26);
   return me;
 }
 @Override
 public void handleResponseMessage(ResponseMessage responseMessage) {
   String receivedSecret = (String) responseMessage.getContent();
   Number160 lKey = Number160.createHash(networkManager.getNodeId());
   Number160 cKey = Number160.createHash(contentKey);
   try {
     networkManager
         .getDataManager()
         .put(lKey, Number160.ZERO, cKey, new H2HTestData(receivedSecret), null)
         .awaitUninterruptibly();
   } catch (NoPeerConnectionException e) {
     Assert.fail();
   }
 }
Beispiel #4
0
  public P2PClient() throws Exception {

    this.localIP = getLocalPeerIP();
    this.serviceID = "medical";
    this.peerID = Number160.createHash(localIP);
    this.peer = new Peer(peerID);
    this.peer.listen(4000, 4000);
    PeerAddress superAddr = new PeerAddress(Number160.createHash(1), "109.231.77.242", 8888, 8888);
    FutureDiscover future = this.peer.discover(superAddr);
    future.awaitUninterruptibly();
    FutureBootstrap fb = this.peer.bootstrap(superAddr);
    fb.awaitUninterruptibly();
    peer.discover(fb.getBootstrapTo().iterator().next()).awaitUninterruptibly();
  }
Beispiel #5
0
 private Data deserializeFile(DataInput in) throws IOException, FileNotFoundException {
   byte[] me = new byte[Number160.BYTE_ARRAY_SIZE];
   in.readFully(me);
   Number160 hash = new Number160(me);
   RandomAccessFile file = new RandomAccessFile(new File(path, hash.toString()), "r");
   FileChannel inChannel = file.getChannel();
   MappedByteBuffer buffer = inChannel.map(FileChannel.MapMode.READ_ONLY, 0, inChannel.size());
   buffer.load();
   ByteBuf buf = Unpooled.wrappedBuffer(buffer);
   Data data = Data.decodeHeader(buf, signatureFactory);
   data.decodeBuffer(buf);
   data.decodeDone(buf, signatureFactory);
   file.close();
   return data;
 }
 private FutureDHT put(String key, String domain, String content, String data)
     throws IOException {
   Number160 locationKey = Number160.createHash(key);
   Number160 domainKey = Number160.createHash(domain);
   Number160 contentKey = Number160.createHash(content);
   MyData myData = new MyData();
   myData.setKey(key);
   myData.setDomain(domain);
   myData.setContent(content);
   myData.setData(data);
   return peer.put(locationKey)
       .setDomainKey(domainKey)
       .setData(contentKey, new Data(myData))
       .start();
 }
Beispiel #7
0
 private String get(String name) throws ClassNotFoundException, IOException {
   FutureDHT futureDHT = peer.get(Number160.createHash(name));
   futureDHT.awaitUninterruptibly();
   if (futureDHT.isSuccess()) {
     return futureDHT.getData().values().iterator().next().getObject().toString();
   } else return "Not Found";
 }
Beispiel #8
0
 @SuppressWarnings("unchecked")
 private Vector<Number160> getPeerList(String name) throws ClassNotFoundException, IOException {
   FutureDHT futureDHT = peer.get(Number160.createHash(name));
   futureDHT.awaitUninterruptibly();
   if (futureDHT.isSuccess()) {
     return (Vector<Number160>) futureDHT.getData().values().iterator().next().getObject();
   } else return null;
 }
  @Override
  public void run() {
    String secret = NetworkTestUtil.randomString();

    Number160 lKey = Number160.createHash(networkManager.getNodeId());
    Number160 cKey = Number160.createHash(contentKey);
    try {
      networkManager
          .getDataManager()
          .put(lKey, Number160.ZERO, cKey, new H2HTestData(secret), null)
          .awaitUninterruptibly();
    } catch (NoPeerConnectionException e) {
      Assert.fail();
    }

    sendDirectResponse(createResponse(secret));
  }
Beispiel #10
0
 public static void routing(Number160 key, Peer[] peers, int start) {
   System.out.println("routing: searching for key " + key);
   NavigableSet<PeerAddress> pa1 = new TreeSet<PeerAddress>(PeerMap.createComparator(key));
   NavigableSet<PeerAddress> queried = new TreeSet<PeerAddress>(PeerMap.createComparator(key));
   Number160 result = Number160.ZERO;
   Number160 resultPeer = new Number160("0xd75d1a3d57841fbc9e2a3d175d6a35dc2e15b9f");
   int round = 0;
   while (!resultPeer.equals(result)) {
     System.out.println("round " + round);
     round++;
     pa1.addAll(peers[start].getPeerBean().peerMap().getAll());
     queried.add(peers[start].getPeerAddress());
     System.out.println("closest so far: " + queried.first());
     PeerAddress next = pa1.pollFirst();
     while (queried.contains(next)) {
       next = pa1.pollFirst();
     }
     result = next.getPeerId();
     start = findNr(next.getPeerId().toString(), peers);
   }
 }
Beispiel #11
0
  public static void main(String[] args) throws Exception {

    P2PClient client = new P2PClient();
    System.out.println(
        client.localIP + "   " + client.serviceID + "  " + client.peer.getPeerID().toString());

    System.out.println("Getting peerIDs for the serviceID \"medical\"");
    Vector<Number160> vec = client.getPeerList(client.serviceID);
    if (vec == null) {
      vec = new Vector<Number160>();
      System.out.println("vec was null, now is empty: " + vec.isEmpty());
      vec.add(client.peerID);
      client.store(client.serviceID, vec);
    } else {
      for (Number160 number160 : vec) {
        System.out.println("PeerID = " + number160.toString());
        for (String string : client.get(number160)) {
          System.out.print("\t" + string);
        }
        System.out.println("");
      }
      if (!vec.contains(client.peerID)) {
        vec.add(client.peerID);
        client.store(client.serviceID, vec);
      }
    }
    ///////////////////////////////////////////////////
    String[] localVals = {client.localIP, "IPSecrets"};
    client.store(client.peerID, localVals);

    for (String string : client.get(client.peerID)) {
      System.out.println(string);
    }

    ///////////////////////////////////////////////////
    if (args.length > 1) client.store(args[0], args[1]);
    if (args.length == 1) System.out.println("Name: " + args[0] + " IP:" + client.get(args[0]));
  }
Beispiel #12
0
  private void serializeFile(DataOutput out, Data value) throws IOException, FileNotFoundException {
    Number160 hash = value.hash();
    // store file name
    out.write(hash.toByteArray());
    // store as external file, create path
    RandomAccessFile file = null;
    FileChannel rwChannel = null;
    try {
      file = new RandomAccessFile(new File(path, hash.toString()), "rw");
      rwChannel = file.getChannel();
      AlternativeCompositeByteBuf acb = AlternativeCompositeByteBuf.compBuffer();
      // store data to disk
      // header first
      value.encodeHeader(acb, signatureFactory);
      rwChannel.write(acb.nioBuffers());
      // next data - no need to copy to another buffer, just take the
      // data from memory
      rwChannel.write(value.toByteBuffers());
      // rest
      try {
        value.encodeDone(acb, signatureFactory);
        rwChannel.write(acb.nioBuffers());
      } catch (InvalidKeyException e) {
        throw new IOException(e);
      } catch (SignatureException e) {
        throw new IOException(e);
      }
    } finally {

      if (rwChannel != null) {
        rwChannel.close();
      }
      if (file != null) {
        file.close();
      }
    }
  }
Beispiel #13
0
 private void store(String key, String val) throws IOException {
   peer.put(Number160.createHash(key), new Data(val)).awaitUninterruptibly();
 }
 @Override
 public int hashCode() {
   return number1.hashCode() ^ number2.hashCode();
 }
Beispiel #15
0
 private static boolean isMine(Number160 key, PublicKey publicKey) {
   return key.equals(Utils.makeSHAHash(publicKey.getEncoded()));
 }
Beispiel #16
0
 /**
  * Encodes payload in a big switch statement. Types are: EMPTY, KEY_KEY, PUBLIC_KEY,
  * KEY_KEY_PUBLIC_KEY, MAP_KEY_DATA, MAP_KEY_DATA_TTL, SET_DATA_TTL, MAP_KEY_KEY, SET_KEYS,
  * SET_NEIGHBORS, BYTE_ARRAY, INTEGER, USER1, USER2, USER3
  *
  * @param contentType The type of the content to encode
  * @param input The ProtocolChunkedInput to fill
  * @param message The message which contains the payload
  * @throws NoSuchAlgorithmException
  * @throws SignatureException
  * @throws InvalidKeyException
  */
 private static int encodePayloadType(
     final Content content, final ProtocolChunkedInput input, final Message message) {
   final int size;
   final byte[] data;
   int count;
   switch (content) {
     case KEY:
       input.copyToCurrent(message.getKey().toByteArray());
       return 20;
     case KEY_KEY:
       input.copyToCurrent(message.getKeyKey1().toByteArray());
       input.copyToCurrent(message.getKeyKey2().toByteArray());
       return 40;
     case MAP_KEY_DATA:
       count = 4;
       if (message.isConvertNumber480to160()) {
         Map<Number480, Data> dataMap = message.getDataMapConvert();
         input.copyToCurrent(dataMap.size());
         for (Map.Entry<Number480, Data> entry : dataMap.entrySet()) {
           input.copyToCurrent(entry.getKey().getContentKey().toByteArray());
           count += 20;
           count += encodeData(input, message, entry.getValue());
         }
         return count;
       } else {
         input.copyToCurrent(message.getDataMap().size());
         for (Map.Entry<Number160, Data> entry : message.getDataMap().entrySet()) {
           input.copyToCurrent(entry.getKey().toByteArray());
           count += 20;
           count += encodeData(input, message, entry.getValue());
         }
         return count;
       }
     case MAP_KEY_KEY:
       Map<Number160, Number160> keyMap = message.getKeyMap();
       size = keyMap.size();
       input.copyToCurrent(size);
       for (final Map.Entry<Number160, Number160> entry : keyMap.entrySet()) {
         input.copyToCurrent(entry.getKey().toByteArray());
         input.copyToCurrent(entry.getValue().toByteArray());
       }
       return 4 + (size * (20 + 20));
     case SET_KEYS:
       if (message.isConvertNumber480to160()) {
         Collection<Number480> keys = message.getKeysConvert();
         size = keys.size();
         input.copyToCurrent(size);
         for (Number480 key : keys) input.copyToCurrent(key.getContentKey().toByteArray());
         return 4 + (size * 20);
       } else {
         size = message.getKeys().size();
         input.copyToCurrent(size);
         for (Number160 key : message.getKeys()) input.copyToCurrent(key.toByteArray());
         return 4 + (size * 20);
       }
     case SET_NEIGHBORS:
       count = 1;
       size =
           Math.min(
               message.getNeighbors().size(), Math.min(message.getUseAtMostNeighbors(), MAX_BYTE));
       input.copyToCurrent((byte) size);
       final Iterator<PeerAddress> iterator = message.getNeighbors().iterator();
       for (int i = 0; iterator.hasNext() && i < size; i++) {
         byte[] data1 = iterator.next().toByteArray();
         input.copyToCurrent(data1);
         count += data1.length;
       }
       return count;
     case SET_TRACKER_DATA:
       count = 1;
       final Collection<TrackerData> trackerDatas = message.getTrackerData();
       input.copyToCurrent((byte) trackerDatas.size());
       for (TrackerData trackerData : trackerDatas) {
         byte[] data1 = trackerData.getPeerAddress().toByteArray();
         input.copyToCurrent(data1);
         count += data1.length;
         if (trackerData.getAttachement() != null) {
           input.copyToCurrent((byte) 1);
           input.copyToCurrent(trackerData.getLength());
           count += 5;
           input.copyToCurrent(
               trackerData.getAttachement(), trackerData.getOffset(), trackerData.getLength());
           count += trackerData.getLength();
         } else {
           input.copyToCurrent((byte) 0);
           count += 1;
         }
       }
       return count;
     case CHANNEL_BUFFER:
       ChannelBuffer tmpBuffer = message.getPayload1();
       if (tmpBuffer == null) tmpBuffer = message.getPayload2();
       else message.setPayload1(null);
       size = tmpBuffer.writerIndex();
       input.copyToCurrent(size);
       input.copyToCurrent(tmpBuffer.slice());
       return 4 + size;
     case LONG:
       input.copyToCurrent(message.getLong());
       return 8;
     case INTEGER:
       input.copyToCurrent(message.getInteger());
       return 4;
     case PUBLIC_KEY:
       data = message.getPublicKey().getEncoded();
       size = data.length;
       input.copyToCurrent((short) size);
       input.copyToCurrent(data);
       return 2 + size;
     case PUBLIC_KEY_SIGNATURE:
       // flag to encode public key
       data = message.getPublicKey().getEncoded();
       size = data.length;
       input.copyToCurrent((short) size);
       input.copyToCurrent(data);
       message.setHintSign(true);
       // count 40 for the signature, which comes later in ProtocolChunkedInput
       return 40 + 2 + size;
     case EMPTY:
     case RESERVED1:
     case RESERVED2:
     case RESERVED3:
     default:
       return 0;
   }
 }
 private FutureDHT get(String key, String domain, String content) {
   Number160 locationKey = Number160.createHash(key);
   Number160 domainKey = Number160.createHash(domain);
   Number160 contentKey = Number160.createHash(content);
   return peer.get(locationKey).setDomainKey(domainKey).setContentKey(contentKey).start();
 }
 /* (non-Javadoc)
  * @see net.tomp2p.message.SignatureCodec#write(io.netty.buffer.ByteBuf)
  */
 @Override
 public SignatureCodec write(ByteBuf buf) {
   buf.writeBytes(number1.toByteArray());
   buf.writeBytes(number2.toByteArray());
   return this;
 }