1 /*

     2  * Copyright (c) 2014, 2015, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package jdk.internal.jshell.remote;

    27 import jdk.jshell.spi.SPIResolutionException;

    28 import java.io.File;

    29 import java.io.IOException;

    30 import java.io.ObjectInputStream;

    31 import java.io.ObjectOutputStream;

    32 import java.io.OutputStream;

    33 import java.io.PrintStream;

    34 import java.io.UnsupportedEncodingException;

    35 import java.lang.reflect.Field;

    36 import java.lang.reflect.InvocationTargetException;

    37 import java.lang.reflect.Method;

    38 import java.net.Socket;

    39 

    40 import java.util.ArrayList;

    41 import java.util.List;

    42 

    43 import static jdk.internal.jshell.remote.RemoteCodes.*;

    44 

    45 import java.util.Map;

    46 import java.util.TreeMap;

    47 

    48 /**

    49  * The remote agent runs in the execution process (separate from the main JShell

    50  * process.  This agent loads code over a socket from the main JShell process,

    51  * executes the code, and other misc,

    52  * @author Robert Field

    53  */

    54 class RemoteAgent {

    55 

    56     private final RemoteClassLoader loader = new RemoteClassLoader();

    57     private final Map<String, Class<?>> klasses = new TreeMap<>();

    58 

    59     public static void main(String[] args) throws Exception {

    60         String loopBack = null;

    61         Socket socket = new Socket(loopBack, Integer.parseInt(args[0]));

    62         (new RemoteAgent()).commandLoop(socket);

    63     }

    64 

    65     void commandLoop(Socket socket) throws IOException {

    66         // in before out -- so we don't hang the controlling process

    67         ObjectInputStream in = new ObjectInputStream(socket.getInputStream());

    68         OutputStream socketOut = socket.getOutputStream();

    69         System.setOut(new PrintStream(new MultiplexingOutputStream("out", socketOut), true));

    70         System.setErr(new PrintStream(new MultiplexingOutputStream("err", socketOut), true));

    71         ObjectOutputStream out = new ObjectOutputStream(new MultiplexingOutputStream("command", socketOut));

    72         while (true) {

    73             int cmd = in.readInt();

    74             switch (cmd) {

    75                 case CMD_EXIT:

    76                     // Terminate this process

    77                     return;

    78                 case CMD_LOAD:

    79                     // Load a generated class file over the wire

    80                     try {

    81                         int count = in.readInt();

    82                         List<String> names = new ArrayList<>(count);

    83                         for (int i = 0; i < count; ++i) {

    84                             String name = in.readUTF();

    85                             byte[] kb = (byte[]) in.readObject();

    86                             loader.delare(name, kb);

    87                             names.add(name);

    88                         }

    89                         for (String name : names) {

    90                             Class<?> klass = loader.loadClass(name);

    91                             klasses.put(name, klass);

    92                             // Get class loaded to the point of, at least, preparation

    93                             klass.getDeclaredMethods();

    94                         }

    95                         out.writeInt(RESULT_SUCCESS);

    96                         out.flush();

    97                     } catch (IOException | ClassNotFoundException | ClassCastException ex) {

    98                         debug("*** Load failure: %s\n", ex);

    99                         out.writeInt(RESULT_FAIL);

   100                         out.writeUTF(ex.toString());

   101                         out.flush();

   102                     }

   103                     break;

   104                 case CMD_INVOKE: {

   105                     // Invoke executable entry point in loaded code

   106                     String name = in.readUTF();

   107                     Class<?> klass = klasses.get(name);

   108                     if (klass == null) {

   109                         debug("*** Invoke failure: no such class loaded %s\n", name);

   110                         out.writeInt(RESULT_FAIL);

   111                         out.writeUTF("no such class loaded: " + name);

   112                         out.flush();

   113                         break;

   114                     }

   115                     String methodName = in.readUTF();

   116                     Method doitMethod;

   117                     try {

   118                         this.getClass().getModule().addExports(SPIResolutionException.class.getPackage().getName(), klass.getModule());

   119                         doitMethod = klass.getDeclaredMethod(methodName, new Class<?>[0]);

   120                         doitMethod.setAccessible(true);

   121                         Object res;

   122                         try {

   123                             clientCodeEnter();

   124                             res = doitMethod.invoke(null, new Object[0]);

   125                         } catch (InvocationTargetException ex) {

   126                             if (ex.getCause() instanceof StopExecutionException) {

   127                                 expectingStop = false;

   128                                 throw (StopExecutionException) ex.getCause();

   129                             }

   130                             throw ex;

   131                         } catch (StopExecutionException ex) {

   132                             expectingStop = false;

   133                             throw ex;

   134                         } finally {

   135                             clientCodeLeave();

   136                         }

   137                         out.writeInt(RESULT_SUCCESS);

   138                         out.writeUTF(valueString(res));

   139                         out.flush();

   140                     } catch (InvocationTargetException ex) {

   141                         Throwable cause = ex.getCause();

   142                         StackTraceElement[] elems = cause.getStackTrace();

   143                         if (cause instanceof SPIResolutionException) {

   144                             out.writeInt(RESULT_CORRALLED);

   145                             out.writeInt(((SPIResolutionException) cause).id());

   146                         } else {

   147                             out.writeInt(RESULT_EXCEPTION);

   148                             out.writeUTF(cause.getClass().getName());

   149                             out.writeUTF(cause.getMessage() == null ? "<none>" : cause.getMessage());

   150                         }

   151                         out.writeInt(elems.length);

   152                         for (StackTraceElement ste : elems) {

   153                             out.writeUTF(ste.getClassName());

   154                             out.writeUTF(ste.getMethodName());

   155                             out.writeUTF(ste.getFileName() == null ? "<none>" : ste.getFileName());

   156                             out.writeInt(ste.getLineNumber());

   157                         }

   158                         out.flush();

   159                     } catch (NoSuchMethodException | IllegalAccessException ex) {

   160                         debug("*** Invoke failure: %s -- %s\n", ex, ex.getCause());

   161                         out.writeInt(RESULT_FAIL);

   162                         out.writeUTF(ex.toString());

   163                         out.flush();

   164                     } catch (StopExecutionException ex) {

   165                         try {

   166                             out.writeInt(RESULT_KILLED);

   167                             out.flush();

   168                         } catch (IOException err) {

   169                             debug("*** Error writing killed result: %s -- %s\n", ex, ex.getCause());

   170                         }

   171                     }

   172                     System.out.flush();

   173                     break;

   174                 }

   175                 case CMD_VARVALUE: {

   176                     // Retrieve a variable value

   177                     String classname = in.readUTF();

   178                     String varname = in.readUTF();

   179                     Class<?> klass = klasses.get(classname);

   180                     if (klass == null) {

   181                         debug("*** Var value failure: no such class loaded %s\n", classname);

   182                         out.writeInt(RESULT_FAIL);

   183                         out.writeUTF("no such class loaded: " + classname);

   184                         out.flush();

   185                         break;

   186                     }

   187                     try {

   188                         Field var = klass.getDeclaredField(varname);

   189                         var.setAccessible(true);

   190                         Object res = var.get(null);

   191                         out.writeInt(RESULT_SUCCESS);

   192                         out.writeUTF(valueString(res));

   193                         out.flush();

   194                     } catch (Exception ex) {

   195                         debug("*** Var value failure: no such field %s.%s\n", classname, varname);

   196                         out.writeInt(RESULT_FAIL);

   197                         out.writeUTF("no such field loaded: " + varname + " in class: " + classname);

   198                         out.flush();

   199                     }

   200                     break;

   201                 }

   202                 case CMD_CLASSPATH: {

   203                     // Append to the claspath

   204                     String cp = in.readUTF();

   205                     for (String path : cp.split(File.pathSeparator)) {

   206                         loader.addURL(new File(path).toURI().toURL());

   207                     }

   208                     out.writeInt(RESULT_SUCCESS);

   209                     out.flush();

   210                     break;

   211                 }

   212                 default:

   213                     debug("*** Bad command code: %d\n", cmd);

   214                     break;

   215             }

   216         }

   217     }

   218 

   219     // These three variables are used by the main JShell process in interrupting

   220     // the running process.  Access is via JDI, so the reference is not visible

   221     // to code inspection.

   222     private boolean inClientCode; // Queried by the main process

   223     private boolean expectingStop; // Set by the main process

   224 

   225     // thrown by the main process via JDI:

   226     private final StopExecutionException stopException = new StopExecutionException();

   227 

   228     @SuppressWarnings("serial")             // serialVersionUID intentionally omitted

   229     private class StopExecutionException extends ThreadDeath {

   230         @Override public synchronized Throwable fillInStackTrace() {

   231             return this;

   232         }

   233     }

   234 

   235     void clientCodeEnter() {

   236         expectingStop = false;

   237         inClientCode = true;

   238     }

   239 

   240     void clientCodeLeave() {

   241         inClientCode = false;

   242         while (expectingStop) {

   243             try {

   244                 Thread.sleep(0);

   245             } catch (InterruptedException ex) {

   246                 debug("*** Sleep interrupted while waiting for stop exception: %s\n", ex);

   247             }

   248         }

   249     }

   250 

   251     private void debug(String format, Object... args) {

   252         System.err.printf("REMOTE: "+format, args);

   253     }

   254 

   255     static String valueString(Object value) {

   256         if (value == null) {

   257             return "null";

   258         } else if (value instanceof String) {

   259             return "\"" + (String)value + "\"";

   260         } else if (value instanceof Character) {

   261             return "'" + value + "'";

   262         } else {

   263             return value.toString();

   264         }

   265     }

   266 

   267     private static final class MultiplexingOutputStream extends OutputStream {

   268 

   269         private static final int PACKET_SIZE = 127;

   270 

   271         private final byte[] name;

   272         private final OutputStream delegate;

   273 

   274         public MultiplexingOutputStream(String name, OutputStream delegate) {

   275             try {

   276                 this.name = name.getBytes("UTF-8");

   277                 this.delegate = delegate;

   278             } catch (UnsupportedEncodingException ex) {

   279                 throw new IllegalStateException(ex); //should not happen

   280             }

   281         }

   282 

   283         @Override

   284         public void write(int b) throws IOException {

   285             synchronized (delegate) {

   286                 delegate.write(name.length); //assuming the len is small enough to fit into byte

   287                 delegate.write(name);

   288                 delegate.write(1);

   289                 delegate.write(b);

   290                 delegate.flush();

   291             }

   292         }

   293 

   294         @Override

   295         public void write(byte[] b, int off, int len) throws IOException {

   296             synchronized (delegate) {

   297                 int i = 0;

   298                 while (len > 0) {

   299                     int size = Math.min(PACKET_SIZE, len);

   300 

   301                     delegate.write(name.length); //assuming the len is small enough to fit into byte

   302                     delegate.write(name);

   303                     delegate.write(size);

   304                     delegate.write(b, off + i, size);

   305                     i += size;

   306                     len -= size;

   307                 }

   308 

   309                 delegate.flush();

   310             }

   311         }

   312 

   313         @Override

   314         public void flush() throws IOException {

   315             super.flush();

   316             delegate.flush();

   317         }

   318 

   319         @Override

   320         public void close() throws IOException {

   321             super.close();

   322             delegate.close();

   323         }

   324 

   325     }

   326 }