sjero.net Git - linphone/blob - p2pproxy/dependencies-src/jxse-src-2.5/impl/src/net/jxta/impl/id/UUID/CodatID.java

   1 /*
   2  * Copyright (c) 2001-2007 Sun Microsystems, Inc.  All rights reserved.
   3  *
   4  *  The Sun Project JXTA(TM) Software License
   5  *
   6  *  Redistribution and use in source and binary forms, with or without
   7  *  modification, are permitted provided that the following conditions are met:
   8  *
   9  *  1. Redistributions of source code must retain the above copyright notice,
  10  *     this list of conditions and the following disclaimer.
  11  *
  12  *  2. Redistributions in binary form must reproduce the above copyright notice,
  13  *     this list of conditions and the following disclaimer in the documentation
  14  *     and/or other materials provided with the distribution.
  15  *
  16  *  3. The end-user documentation included with the redistribution, if any, must
  17  *     include the following acknowledgment: "This product includes software
  18  *     developed by Sun Microsystems, Inc. for JXTA(TM) technology."
  19  *     Alternately, this acknowledgment may appear in the software itself, if
  20  *     and wherever such third-party acknowledgments normally appear.
  21  *
  22  *  4. The names "Sun", "Sun Microsystems, Inc.", "JXTA" and "Project JXTA" must
  23  *     not be used to endorse or promote products derived from this software
  24  *     without prior written permission. For written permission, please contact
  25  *     Project JXTA at http://www.jxta.org.
  26  *
  27  *  5. Products derived from this software may not be called "JXTA", nor may
  28  *     "JXTA" appear in their name, without prior written permission of Sun.
  29  *
  30  *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
  31  *  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  32  *  FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SUN
  33  *  MICROSYSTEMS OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  34  *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  35  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
  36  *  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  37  *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  38  *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  39  *  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  40  *
  41  *  JXTA is a registered trademark of Sun Microsystems, Inc. in the United
  42  *  States and other countries.
  43  *
  44  *  Please see the license information page at :
  45  *  <http://www.jxta.org/project/www/license.html> for instructions on use of
  46  *  the license in source files.
  47  *
  48  *  ====================================================================
  49  *
  50  *  This software consists of voluntary contributions made by many individuals
  51  *  on behalf of Project JXTA. For more information on Project JXTA, please see
  52  *  http://www.jxta.org.
  53  *
  54  *  This license is based on the BSD license adopted by the Apache Foundation.
  55  */
  56
  57 package net.jxta.impl.id.UUID;
  58
  59
  60 import java.io.InputStream;
  61 import java.security.MessageDigest;
  62
  63 import java.io.IOException;
  64 import java.security.ProviderException;
  65 import java.security.NoSuchAlgorithmException;
  66
  67
  68 /**
  69  *  An implementation of the {@link net.jxta.codat.CodatID} ID Type.
  70  */
  71 public class CodatID extends net.jxta.codat.CodatID {
  72
  73     /**
  74      * size of a SHA1 hash. I would use MessageDigest.getDigestLength, but
  75      * possible exceptions make it difficult to do.
  76      */
  77     protected final static int hashSize = 20;
  78
  79     /**
  80      *  Location of the group id in the byte array.
  81      */
  82     protected final static int groupIdOffset = 0;
  83
  84     /**
  85      *  Location of the randomly chosen portion of the id within the byte array.
  86      */
  87     protected final static int idOffset = CodatID.groupIdOffset + IDFormat.uuidSize;
  88
  89     /**
  90      *  Location of the hash value portion of the id within the byte array.
  91      */
  92     protected final static int codatHashOffset = CodatID.idOffset + IDFormat.uuidSize;
  93
  94     /**
  95      *  Location of the beginning of pad (unused space) within the byte array.
  96      */
  97     protected final static int padOffset = CodatID.codatHashOffset + CodatID.hashSize;
  98
  99     /**
 100      * Size of the pad.
 101      */
 102     protected final static int padSize = IDFormat.flagsOffset - CodatID.padOffset;
 103
 104     /**
 105      *  The id data
 106      */
 107     protected IDBytes id;
 108
 109     /**
 110      * Internal constructor
 111      */
 112     protected CodatID() {
 113         super();
 114         id = new IDBytes(IDFormat.flagCodatID);
 115     }
 116
 117     /**
 118      * Initializes contents from provided bytes.
 119      *
 120      * @param id    the ID data
 121      */
 122     protected CodatID(IDBytes id) {
 123         super();
 124         this.id = id;
 125     }
 126
 127     protected CodatID(UUID groupUUID, UUID idUUID) {
 128         this();
 129
 130         id.longIntoBytes(CodatID.groupIdOffset, groupUUID.getMostSignificantBits());
 131         id.longIntoBytes(CodatID.groupIdOffset + 8, groupUUID.getLeastSignificantBits());
 132
 133         id.longIntoBytes(CodatID.idOffset, idUUID.getMostSignificantBits());
 134         id.longIntoBytes(CodatID.idOffset + 8, idUUID.getLeastSignificantBits());
 135     }
 136
 137     /**
 138      *  See {@link net.jxta.id.IDFactory.Instantiator#newCodatID(net.jxta.peergroup.PeerGroupID)}.
 139      */
 140     public CodatID(PeerGroupID groupID) {
 141         this(groupID.getUUID(), UUIDFactory.newUUID());
 142     }
 143
 144     /**
 145      *  See {@link net.jxta.id.IDFactory.Instantiator#newCodatID(net.jxta.peergroup.PeerGroupID,byte[])}.
 146      */
 147     public CodatID(PeerGroupID groupID, byte[] seed) {
 148         this();
 149
 150         UUID groupUUID = groupID.getUUID();
 151
 152         id.longIntoBytes(CodatID.groupIdOffset, groupUUID.getMostSignificantBits());
 153         id.longIntoBytes(CodatID.groupIdOffset + 8, groupUUID.getLeastSignificantBits());
 154
 155         System.arraycopy(seed, 0, id.bytes, CodatID.idOffset, Math.min(IDFormat.uuidSize, seed.length));
 156
 157         // make it a valid UUID
 158         id.bytes[CodatID.idOffset + 6] &= 0x0f;
 159         id.bytes[CodatID.idOffset + 6] |= 0x40; /* version 4 */
 160         id.bytes[CodatID.idOffset + 8] &= 0x3f;
 161         id.bytes[CodatID.idOffset + 8] |= 0x80; /* IETF variant */
 162         id.bytes[CodatID.idOffset + 10] &= 0x3f;
 163         id.bytes[CodatID.idOffset + 10] |= 0x80; /* multicast bit */
 164     }
 165
 166     /**
 167      *  See {@link net.jxta.id.IDFactory.Instantiator#newCodatID(net.jxta.peergroup.PeerGroupID,InputStream)}.
 168      */
 169     public CodatID(PeerGroupID groupID, InputStream in) throws IOException {
 170         this(groupID);
 171
 172         setHash(in);
 173     }
 174
 175     /**
 176      *  See {@link net.jxta.id.IDFactory.Instantiator#newCodatID(net.jxta.peergroup.PeerGroupID,InputStream)}.
 177      */
 178     public CodatID(PeerGroupID groupID, byte[] seed, InputStream in) throws IOException {
 179         this(groupID, seed);
 180
 181         setHash(in);
 182     }
 183
 184     /**
 185      *  {@inheritDoc}
 186      */
 187     @Override
 188     public boolean equals(Object target) {
 189         if (this == target) {
 190             return true;
 191         }
 192
 193         if (target instanceof CodatID) {
 194             CodatID codatTarget = (CodatID) target;
 195
 196             return id.equals(codatTarget.id);
 197         } else {
 198             return false;
 199         }
 200     }
 201
 202     /**
 203      *  {@inheritDoc}
 204      */
 205     @Override
 206     public int hashCode() {
 207         return id.hashCode();
 208     }
 209
 210     /**
 211      *  {@inheritDoc}
 212      */
 213     @Override
 214     public String getIDFormat() {
 215         return IDFormat.INSTANTIATOR.getSupportedIDFormat();
 216     }
 217
 218     /**
 219      *  {@inheritDoc}
 220      */
 221     @Override
 222     public Object getUniqueValue() {
 223         return getIDFormat() + "-" + (String) id.getUniqueValue();
 224     }
 225
 226     /**
 227      *  {@inheritDoc}
 228      */
 229     @Override
 230     public net.jxta.id.ID getPeerGroupID() {
 231         UUID groupUUID = new UUID(id.bytesIntoLong(CodatID.groupIdOffset), id.bytesIntoLong(CodatID.groupIdOffset + 8));
 232
 233         PeerGroupID groupID = new PeerGroupID(groupUUID);
 234
 235         // convert to the generic world PGID as necessary
 236         return IDFormat.translateToWellKnown(groupID);
 237     }
 238
 239     /**
 240      *  {@inheritDoc}
 241      */
 242     @Override
 243     public boolean isStatic() {
 244         for (int eachHashByte = CodatID.codatHashOffset; eachHashByte < (CodatID.padOffset); eachHashByte++) {
 245             if (0 != id.bytes[eachHashByte]) {
 246                 return true;
 247             }
 248         }
 249
 250         return false;
 251     }
 252
 253     /**
 254      *  Calculates the SHA-1 hash of a stream.
 255      *
 256      *  @param in The InputStream.
 257      */
 258     protected void setHash(InputStream in) throws IOException {
 259         MessageDigest dig = null;
 260
 261         try {
 262             dig = MessageDigest.getInstance("SHA-1");
 263         } catch (NoSuchAlgorithmException caught) {
 264             dig = null;
 265         }
 266
 267         if (dig == null) {
 268             throw new ProviderException("SHA-1 digest algorithm not found");
 269         }
 270
 271         dig.reset();
 272
 273         byte[] chunk = new byte[1024];
 274
 275         try {
 276             do {
 277                 int read = in.read(chunk);
 278
 279                 if (read == -1) {
 280                     break;
 281                 }
 282
 283                 dig.update(chunk, 0, read);
 284             } while (true);
 285         } finally {
 286             in.close();
 287         }
 288
 289         byte[] result = dig.digest();
 290
 291         System.arraycopy(result, 0, id.bytes, CodatID.codatHashOffset, CodatID.hashSize);
 292     }
 293 }