procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

decl.c (init_decl_processing): Add new class "protectionDomain" field.

Browse source 
gcc/java:

2001-04-25  Bryce McKinlay  <bryce@waitaki.otago.ac.nz>

	* decl.c (init_decl_processing): Add new class "protectionDomain"
	field.
	* class.c (make_class_data): Set initial value for "protectionDomain".

libjava:

2001-04-25  Bryce McKinlay  <bryce@albatross.co.nz>

	java.security merge and ClassLoader compliance fixes.

	* java/lang/Class.h (Class): Include ProtectionDomain.h.
	New protectionDomain field.
	(forName): Add initialize parameter. Fixes declaration to comply with
	JDK spec.
	* java/lang/natClass.cc (forName): Correct declaration of the three-arg
	variant. Honour	"initialize" flag.
	(getProtectionDomain0): New method.
	* java/lang/Class.java: Fix forName() declaration.
	(getPackage): New method based on Classpath implementation.
	(getProtectionDomain0): New native method decl.
	(getProtectionDomain): New method.
	* java/lang/ClassLoader.java (getParent): Now final.
	(definedPackages): New field.
	(getPackage): New.
	(defineClass): New variant with protectionDomain argument.
	(definePackage): New.
	(getPackages): New.
	(findSystemClass): Now final.
	(getSystemResourceAsStream): Remove redundant "final" modifier.
	(getSystemResource): Remove redundant "final" modifier.
	(getResources): Now final.
	(protectionDomainPermission): New static field.
	(unknownProtectionDomain): Ditto.
	(defaultProtectionDomain): Ditto.
	(getSystemClassLoader): Now non-native.
	* java/util/ResourceBundle.java (tryGetSomeBundle): Use the correct
	arguments for Class.forName().
	* java/lang/Package.java: New file.
	* gnu/gcj/runtime/VMClassLoader.java (getVMClassLoader): Removed.
	(instance): Static initialize singleton.
	(findClass): Override this, not findSystemClass.
	* java/lang/natClassLoader.cc (defineClass0): Set class's
	protectionDomain field as specified.
	(getSystemClassLoader): Removed.
	(findClass): Renamed from findSystemClass. Call the interpreter via
	URLClassLoader.findClass if loading class via dlopen fails.

	* java/security/*.java: java.security import/merge with Classpath.
	* java/security/acl/*.java: Likewise.
	* java/security/interfaces/*.java: Likewise.
	* java/security/spec/*.java: Likewise.
	* java/net/NetPermission.java: Likewise.
	* java/net/SocketPermission.java: Likewise.
	* gnu/java/security/provider/DefaultPolicy.java: Likewise.

	* Makefile.am: Add new classes.
	* Makefile.in: Rebuilt.
	* gcj/javaprims.h: CNI namespace rebuild.

From-SVN: r41543
This commit is contained in:
Bryce McKinlay 2001-04-25 16:45:15 +01:00
parent 744cfa53c3
commit 28f7d9d05a
115 changed files with 11887 additions and 1549 deletions
Download patch file Download diff file Expand all files Collapse all files

332
libjava/java/security/MessageDigest.java
View file

@ -1,144 +1,316 @@
// MessageDigest.java
/* MessageDigest.java --- The message digest interface.
Copyright (C) 1999 Free Software Foundation, Inc.
/* Copyright (C) 2000 Free Software Foundation
This file is part of GNU Classpath.
This file is part of libgcj.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
This software is copyrighted work licensed under the terms of the
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
details. */
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */
package java.security;
/**
* @author Tom Tromey <tromey@cygnus.com>
* @date February 11, 2000.
*/
/**
* Written using on-line Java Platform 1.1 API Specification.
* Status: Believed complete and correct to 1.1 spec.
* It is known not to comply with the 1.2 spec.
*/
public abstract class MessageDigest
public abstract class MessageDigest extends MessageDigestSpi
{
protected MessageDigest (String algorithm)
private String algorithm;
private Provider provider;
private byte[] lastDigest;
/**
Creates a MessageDigest representing the specified
algorithm.
@param algorithm the name of digest algorithm to choose
*/
protected MessageDigest(String algorithm)
{
name = algorithm;
this.algorithm = algorithm;
provider = null;
}
public static MessageDigest getInstance (String algorithm)
/**
Gets an instance of the MessageDigest class representing
the specified digest. If the algorithm is not found then,
it throws NoSuchAlgorithmException.
@param algorithm the name of digest algorithm to choose
@return a MessageDigest representing the desired algorithm
@exception NoSuchAlgorithmException if the algorithm is not implemented by providers
*/
public static MessageDigest getInstance(String algorithm)
throws NoSuchAlgorithmException
{
Provider[] p = Security.getProviders();
String name = "MessageDigest." + algorithm;
Provider[] provs = Security.getProviders ();
for (int i = 0; i < provs.length; ++i)
for (int i = 0; i < p.length; i++)
{
String val = provs[i].getProperty (name);
if (val != null)
{
try
{
return (MessageDigest) Class.forName(val).newInstance ();
}
catch (Throwable _)
{
// We just ignore failures.
}
}
String classname = p[i].getProperty(name);
if (classname != null)
return getInstance(classname, algorithm, p[i]);
}
throw new NoSuchAlgorithmException (algorithm);
throw new NoSuchAlgorithmException(algorithm);
}
public static MessageDigest getInstance (String algorithm, String provider)
/**
Gets an instance of the MessageDigest class representing
the specified digest from the specified provider. If the
algorithm is not found then, it throws NoSuchAlgorithmException.
If the provider is not found, then it throws
NoSuchProviderException.
@param algorithm the name of digest algorithm to choose
@param provider the name of the provider to find the algorithm in
@return a MessageDigest representing the desired algorithm
@exception NoSuchAlgorithmException if the algorithm is not implemented by the provider
@exception NoSuchProviderException if the provider is not found
*/
public static MessageDigest getInstance(String algorithm, String provider)
throws NoSuchAlgorithmException, NoSuchProviderException
{
String name = "MessageDigest." + algorithm;
Provider p = Security.getProvider (provider);
Provider p = Security.getProvider(provider);
if (p == null)
throw new NoSuchProviderException (provider);
String val = p.getProperty (name);
if (val != null)
throw new NoSuchProviderException(provider);
return getInstance(p.getProperty("MessageDigest." + algorithm),
algorithm, p);
}
private static MessageDigest getInstance(String classname,
String algorithm,
Provider provider)
throws NoSuchAlgorithmException
{
if (classname == null)
throw new NoSuchAlgorithmException(algorithm);
try
{
try
{
return (MessageDigest) Class.forName(val).newInstance ();
}
catch (Throwable _)
{
// Nothing.
}
MessageDigest m =
(MessageDigest) Class.forName(classname).newInstance();
m.algorithm = algorithm;
m.provider = provider;
return m;
}
catch (ClassNotFoundException cnfe)
{
throw new NoSuchAlgorithmException(algorithm + ": Class not found.");
}
catch (InstantiationException ie)
{
throw new NoSuchAlgorithmException(algorithm
+ ": Class instantiation failed.");
}
catch (IllegalAccessException iae)
{
throw new NoSuchAlgorithmException(algorithm + ": Illegal Access");
}
throw new NoSuchAlgorithmException (algorithm);
}
public void update (byte input)
/**
Gets the provider that the MessageDigest is from.
@return the provider the this MessageDigest
*/
public final Provider getProvider()
{
engineUpdate (input);
return provider;
}
public void update (byte[] input, int offset, int len)
/**
Updates the digest with the byte.
@param input byte to update the digest with
*/
public void update(byte input)
{
engineUpdate (input, offset, len);
engineUpdate(input);
}
public void update (byte[] input)
/**
Updates the digest with the bytes from the array from the
specified offset to the specified length.
@param input bytes to update the digest with
@param offset the offset to start at
@param len length of the data to update with
*/
public void update(byte[]input, int offset, int len)
{
engineUpdate (input, 0, input.length);
engineUpdate(input, 0, input.length);
}
public byte[] digest ()
/**
Updates the digest with the bytes from the array.
@param input bytes to update the digest with
*/
public void update(byte[]input)
{
return engineDigest ();
engineUpdate(input, 0, input.length);
}
public byte[] digest (byte[] input)
/**
Computes the digest of the stored data.
@return a byte array representing the message digest
*/
public byte[] digest()
{
update (input);
return engineDigest ();
return lastDigest = engineDigest();
}
public String toString ()
/**
Computes the final digest of the stored bytes and returns
them.
@param buf An array of bytes to store the digest
@param offset An offset to start storing the digest at
@param len The length of the buffer
@return Returns the length of the buffer
*/
public int digest(byte[]buf, int offset, int len) throws DigestException
{
// There is no spec for this.
return "[MessageDigest: " + name + "]";
return engineDigest(buf, offset, len);
}
public static boolean isEqual (byte[] digesta, byte[] digestb)
/**
Computes a final update using the input array of bytes,
then computes a final digest and returns it. It calls
update(input) and then digest();
@param buf An array of bytes to perform final update with
@return a byte array representing the message digest
*/
public byte[] digest(byte[]input)
{
update(input);
return digest();
}
/**
Returns a representation of the MessageDigest as a String.
@return a string representing the message digest
*/
public String toString()
{
return (getClass()).getName()
+ " Message Digest <" + digestToString() + ">";
}
/**
Does a simple byte comparison of the two digests.
@param digesta first digest to compare
@param digestb second digest to compare
@return true if they are equal, false otherwise
*/
public static boolean isEqual(byte[]digesta, byte[]digestb)
{
if (digesta == digestb)
return true;
if (digesta.length != digestb.length)
return false;
for (int i = digesta.length - 1; i >= 0; --i)
if (digesta[i] != digestb[i])
return false;
return true;
}
public void reset ()
/**
Resets the message digest.
*/
public void reset()
{
engineReset ();
engineReset();
}
public final String getAlgorithm ()
/**
Gets the name of the algorithm currently used.
The names of algorithms are usually SHA-1 or MD5.
@return name of algorithm.
*/
public final String getAlgorithm()
{
return name;
return algorithm;
}
protected abstract void engineUpdate (byte input);
protected abstract void engineUpdate (byte input[], int offset, int len);
protected abstract byte[] engineDigest ();
protected abstract void engineReset ();
/**
Gets the length of the message digest.
The default is zero which means that this message digest
does not implement this function.
@return length of the message digest
*/
public final int getDigestLength()
{
return engineGetDigestLength();
}
/**
Returns a clone of this class if supported.
If it does not then it throws CloneNotSupportedException.
The cloning of this class depends on whether the subclass
MessageDigestSpi implements Cloneable which contains the
actual implementation of the appropriate algorithm.
@return clone of this class
@exception CloneNotSupportedException this class does not support cloning
*/
public Object clone() throws CloneNotSupportedException
{
return super.clone ();
if (this instanceof Cloneable)
return super.clone();
else
throw new CloneNotSupportedException();
}
private String digestToString()
{
byte[] digest = lastDigest;
if (digest == null)
return "incomplete";
StringBuffer buf = new StringBuffer();
int len = digest.length;
for (int i = 0; i < len; ++i)
{
byte b = digest[i];
byte high = (byte) ((b & 0xff) >>> 4);
byte low = (byte) (b & 0xf);
buf.append(high > 9 ? ('a' - 10) + high : '0' + high);
buf.append(low > 9 ? ('a' - 10) + low : '0' + low);
}
return buf.toString();
}
// Algorithm name.
private String name;
}