package org.astrogrid.samp;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.logging.Logger;
/**
* Platform-dependent features required by the SAMP implementation.
*
* @author Mark Taylor
* @since 14 Jul 2008
*/
public abstract class Platform {
private static Platform instance_;
private final String name_;
private static final Logger logger_ =
Logger.getLogger( Platform.class.getName() );
/**
* Constructor.
*
* @param name platform name
*/
protected Platform( String name ) {
name_ = name;
}
/**
* Returns SAMP's definition of the "home" directory.
*
* @return directory containing SAMP lockfile
*/
public abstract File getHomeDirectory();
/**
* Returns the value of an environment variable.
* If it can't be done, null is returned.
*
* @param varname name of environment variable
* @return value of environment variable
*/
public String getEnv( String varname ) {
try {
return System.getenv( varname );
}
// System.getenv is unimplemented at 1.4, and throws an Error.
catch ( Throwable e ) {
String[] argv = getGetenvArgs( varname );
if ( argv == null ) {
return null;
}
else {
try {
String cmdout = exec( argv );
return cmdout.trim();
}
catch ( Throwable e2 ) {
return null;
}
}
}
}
/**
* Sets file permissions on a given file so that it cannot be read by
* anyone other than its owner.
*
* @param file file whose permissions are to be altered
* @throws IOException if permissions cannot be changed
*/
public void setPrivateRead( File file ) throws IOException {
if ( setPrivateReadReflect( file ) ) {
return;
}
else {
String[] privateReadArgs = getPrivateReadArgs( file );
if ( privateReadArgs != null ) {
exec( privateReadArgs );
}
else {
logger_.info( "No known way to set user-only read permissions"
+ "; possible security implications"
+ " on multi-user systems" );
}
}
}
/**
* Returns an array of words to pass to
* {@link java.lang.Runtime#exec(java.lang.String[])} in order
* to read an environment variable name.
* If null is returned, no way is known to do this with a system command.
*
* @param varname environment variable name to read
* @return exec args
*/
protected abstract String[] getGetenvArgs( String varname );
/**
* Returns an array of words to pass to
* {@link java.lang.Runtime#exec(java.lang.String[])} in order
* to set permissions on a given file so that it cannot be read by
* anyone other than its owner.
* If null is returned, no way is known to do this with a system command.
*
* @param file file to alter
* @return exec args
*/
protected abstract String[] getPrivateReadArgs( File file )
throws IOException;
/**
* Attempt to use the File.setReadable() method to set
* permissions on a file so that it cannot be read by anyone other
* than its owner.
*
* @param file file to alter
* @return true if the attempt succeeded, false if it failed because
* we are running the wrong version of java
* @throws IOException if there was some I/O failure
*/
private static boolean setPrivateReadReflect( File file )
throws IOException {
try {
Method setReadableMethod =
File.class.getMethod( "setReadable",
new Class[] { boolean.class,
boolean.class, } );
boolean success =
( setReadableMethod.invoke( file,
new Object[] { Boolean.FALSE,
Boolean.FALSE } )
.equals( Boolean.TRUE ) ) &&
( setReadableMethod.invoke( file,
new Object[] { Boolean.TRUE,
Boolean.TRUE } )
.equals( Boolean.TRUE ) );
return success;
}
catch ( InvocationTargetException e1 ) {
Throwable e2 = e1.getCause();
if ( e2 instanceof IOException ) {
throw (IOException) e2;
}
else if ( e2 instanceof RuntimeException ) {
throw (RuntimeException) e2;
}
else {
throw (IOException) new IOException( e2.getMessage() )
.initCause( e2 );
}
}
catch ( NoSuchMethodException e ) {
// method only available at java 1.6+
return false;
}
catch ( IllegalAccessException e ) {
// not likely.
return false;
}
}
/**
* Attempts a {@java.lang.Runtime#exec(java.lang.String[])} with a given
* list of arguments. The output from stdout is returned as a string;
* in the case of error an IOException is thrown with a message giving
* the output from stderr.
*
*
Note: do not use this for cases in which the
* output from stdout or stderr might be more than a few characters -
* blocking or deadlock is possible (see {@link java.lang.Process}).
*
* @param args array of words to pass to exec
* @return output from standard output
* @throws IOException with text from standard error if there is an error
*/
private static String exec( String[] args ) throws IOException {
String argv = Arrays.asList( args ).toString();
logger_.info( "System exec: " + argv );
final Process process;
final StreamReader outReader;
final StreamReader errReader;
try {
process = Runtime.getRuntime().exec( args );
outReader = new StreamReader( process.getInputStream() );
errReader = new StreamReader( process.getErrorStream() );
outReader.start();
errReader.start();
process.waitFor();
}
catch ( InterruptedException e ) {
throw new IOException( "Exec failed: " + argv );
}
catch ( IOException e ) {
throw (IOException)
new IOException( "Exec failed: " + argv ).initCause( e );
}
return process.exitValue() == 0 ? outReader.getContent()
: errReader.getContent();
}
/**
* Returns a Platform instance for the current system.
*
* @return platform instance
*/
public static Platform getPlatform() {
if ( instance_ == null ) {
instance_ = createPlatform();
}
return instance_;
}
/**
* Constructs a Platform for the current system.
*
* @return new platform
*/
private static Platform createPlatform() {
// Is this reliable?
String osname = System.getProperty( "os.name" );
if ( osname.toLowerCase().startsWith( "windows" ) ||
osname.toLowerCase().indexOf( "microsoft" ) >= 0 ) {
return new WindowsPlatform();
}
else {
return new UnixPlatform();
}
}
/**
* Thread which reads the contents of a stream into a string buffer.
*/
private static class StreamReader extends Thread {
private final InputStream in_;
private final StringBuffer sbuf_;
/**
* Constructor.
*
* @param in input stream
*/
StreamReader( InputStream in ) {
super( "StreamReader" );
in_ = in;
sbuf_ = new StringBuffer();
setDaemon( true );
}
public void run() {
try {
for ( int c; ( c = in_.read() ) >= 0; ) {
sbuf_.append( (char) c );
}
in_.close();
}
catch ( IOException e ) {
}
}
/**
* Returns the content of the stream.
*
* @return content
*/
public String getContent() {
return sbuf_.toString();
}
}
/**
* Platform implementation for Un*x-like systems.
*/
private static class UnixPlatform extends Platform {
/**
* Constructor.
*/
UnixPlatform() {
super( "Un*x" );
}
public File getHomeDirectory() {
return new File( System.getProperty( "user.home" ) );
}
protected String[] getGetenvArgs( String varname ) {
return new String[] { "printenv", varname, };
}
protected String[] getPrivateReadArgs( File file ) {
return new String[] { "chmod", "600", file.toString(), };
}
}
/**
* Platform implementation for Microsoft Windows-like systems.
*/
private static class WindowsPlatform extends Platform {
/**
* Constructor.
*/
WindowsPlatform() {
super( "MS Windows" );
}
protected String[] getPrivateReadArgs( File file ) throws IOException {
// No good way known. For a while I was using "attrib -R file",
// but this wasn't doing what was wanted. Bruno Rino has
// suggested "CALCS file /G %USERNAME%:F". Sounds kind of
// sensible, but requires user input (doable, but fiddly),
// and from my experiments on NTFS doesn't seem to have any
// discernable effect. As I understand it, it's unlikely to do
// anything on FAT (no ACLs). Given my general ignorance of
// MS OSes and file systems, I'm inclined to leave this for
// fear of inadvertently doing something bad.
return null;
}
public File getHomeDirectory() {
String userprofile = getEnv( "USERPROFILE" );
if ( userprofile != null && userprofile.trim().length() > 0 ) {
return new File( userprofile );
}
else {
return new File( System.getProperty( "user.home" ) );
}
}
public String[] getGetenvArgs( String varname ) {
return new String[] { "cmd", "/c", "echo", "%" + varname + "%", };
}
}
}