1 /*
2 * Copyright (c) 1997, 2013, 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 sun.rmi.server;
27
28 import java.io.ByteArrayOutputStream;
29 import java.io.File;
30 import java.io.FileOutputStream;
31 import java.io.IOException;
32 import java.io.InputStream;
33 import java.io.ObjectInputStream;
34 import java.io.OutputStream;
35 import java.io.PrintStream;
36 import java.io.PrintWriter;
37 import java.io.Serializable;
38 import java.lang.Process;
39 import java.lang.reflect.InvocationTargetException;
40 import java.lang.reflect.Method;
41 import java.net.InetAddress;
42 import java.net.ServerSocket;
43 import java.net.Socket;
44 import java.net.SocketAddress;
45 import java.net.SocketException;
46 import java.nio.file.Files;
47 import java.nio.channels.Channel;
48 import java.nio.channels.ServerSocketChannel;
49 import java.rmi.AccessException;
50 import java.rmi.AlreadyBoundException;
51 import java.rmi.ConnectException;
52 import java.rmi.ConnectIOException;
53 import java.rmi.MarshalledObject;
54 import java.rmi.NoSuchObjectException;
55 import java.rmi.NotBoundException;
56 import java.rmi.Remote;
57 import java.rmi.RemoteException;
58 import java.rmi.activation.ActivationDesc;
59 import java.rmi.activation.ActivationException;
60 import java.rmi.activation.ActivationGroupDesc;
61 import java.rmi.activation.ActivationGroup;
62 import java.rmi.activation.ActivationGroupID;
63 import java.rmi.activation.ActivationID;
64 import java.rmi.activation.ActivationInstantiator;
65 import java.rmi.activation.ActivationMonitor;
66 import java.rmi.activation.ActivationSystem;
67 import java.rmi.activation.Activator;
68 import java.rmi.activation.UnknownGroupException;
69 import java.rmi.activation.UnknownObjectException;
70 import java.rmi.registry.Registry;
71 import java.rmi.server.ObjID;
72 import java.rmi.server.RMIClassLoader;
73 import java.rmi.server.RMIClientSocketFactory;
74 import java.rmi.server.RMIServerSocketFactory;
75 import java.rmi.server.RemoteObject;
76 import java.rmi.server.RemoteServer;
77 import java.rmi.server.ServerNotActiveException;
78 import java.rmi.server.UnicastRemoteObject;
79 import java.security.AccessControlException;
80 import java.security.AccessController;
81 import java.security.AllPermission;
82 import java.security.CodeSource;
83 import java.security.Permission;
84 import java.security.PermissionCollection;
85 import java.security.Permissions;
86 import java.security.Policy;
87 import java.security.PrivilegedAction;
88 import java.security.PrivilegedActionException;
89 import java.security.PrivilegedExceptionAction;
90 import java.security.cert.Certificate;
91 import java.text.MessageFormat;
92 import java.util.ArrayList;
93 import java.util.Arrays;
94 import java.util.Date;
95 import java.util.Enumeration;
96 import java.util.HashMap;
97 import java.util.HashSet;
98 import java.util.Iterator;
99 import java.util.List;
100 import java.util.Map;
101 import java.util.MissingResourceException;
102 import java.util.Properties;
103 import java.util.ResourceBundle;
104 import java.util.Set;
105 import java.util.concurrent.ConcurrentHashMap;
106 import sun.rmi.log.LogHandler;
107 import sun.rmi.log.ReliableLog;
108 import sun.rmi.registry.RegistryImpl;
109 import sun.rmi.runtime.NewThreadAction;
110 import sun.rmi.server.UnicastServerRef;
111 import sun.rmi.transport.LiveRef;
112 import sun.rmi.transport.tcp.TCPTransport;
113 import sun.security.action.GetBooleanAction;
114 import sun.security.action.GetIntegerAction;
115 import sun.security.action.GetPropertyAction;
116 import sun.security.provider.PolicyFile;
117 import com.sun.rmi.rmid.ExecPermission;
118 import com.sun.rmi.rmid.ExecOptionPermission;
119
120 /**
121 * The Activator facilitates remote object activation. A "faulting"
122 * remote reference calls the activator's <code>activate</code> method
123 * to obtain a "live" reference to a activatable remote object. Upon
124 * receiving a request for activation, the activator looks up the
125 * activation descriptor for the activation identifier, id, determines
126 * the group in which the object should be activated and invokes the
127 * activate method on the object's activation group (described by the
128 * remote interface <code>ActivationInstantiator</code>). The
129 * activator initiates the execution of activation groups as
130 * necessary. For example, if an activation group for a specific group
131 * identifier is not already executing, the activator will spawn a
132 * child process for the activation group. <p>
133 *
134 * The activator is responsible for monitoring and detecting when
135 * activation groups fail so that it can remove stale remote references
136 * from its internal tables. <p>
137 *
138 * @author Ann Wollrath
139 * @since 1.2
140 */
141 public class Activation implements Serializable {
142
143 /** indicate compatibility with JDK 1.2 version of class */
144 private static final long serialVersionUID = 2921265612698155191L;
145 private static final byte MAJOR_VERSION = 1;
146 private static final byte MINOR_VERSION = 0;
147
148 /** exec policy object */
149 private static Object execPolicy;
150 private static Method execPolicyMethod;
151 private static boolean debugExec;
152
153 /** maps activation id to its respective group id */
154 private Map<ActivationID,ActivationGroupID> idTable =
155 new ConcurrentHashMap<>();
156 /** maps group id to its GroupEntry groups */
157 private Map<ActivationGroupID,GroupEntry> groupTable =
158 new ConcurrentHashMap<>();
159
160 private byte majorVersion = MAJOR_VERSION;
161 private byte minorVersion = MINOR_VERSION;
162
163 /** number of simultaneous group exec's */
164 private transient int groupSemaphore;
165 /** counter for numbering groups */
166 private transient int groupCounter;
167 /** reliable log to hold descriptor table */
168 private transient ReliableLog log;
169 /** number of updates since last snapshot */
170 private transient int numUpdates;
171
172 /** the java command */
173 // accessed by GroupEntry
174 private transient String[] command;
175 /** timeout on wait for child process to be created or destroyed */
176 private static final long groupTimeout =
177 getInt("sun.rmi.activation.groupTimeout", 60000);
178 /** take snapshot after this many updates */
179 private static final int snapshotInterval =
180 getInt("sun.rmi.activation.snapshotInterval", 200);
181 /** timeout on wait for child process to be created */
182 private static final long execTimeout =
183 getInt("sun.rmi.activation.execTimeout", 30000);
184
185 private static final Object initLock = new Object();
186 private static boolean initDone = false;
187
188 private static final InetAddress remoteClientAddress;
189 static {
190 remoteClientAddress = java.security.AccessController.doPrivileged(
191 new java.security.PrivilegedAction<InetAddress>() {
192 public InetAddress run() {
193 String remoteClientProp =
194 System.getProperty("sun.rmi.activation.remoteClient",
195 null);
196
197 if (remoteClientProp == null) {
198 return null;
199 }
200
201 try {
202 return InetAddress.getByName(remoteClientProp);
203 } catch (Throwable t) {
204 System.err.println("Activation: Cannot get the IP " +
205 "address of the remote client: " +
206 remoteClientProp);
207 }
208
209 return null;
210 }});
211 }
212
213 // this should be a *private* method since it is privileged
214 private static int getInt(String name, int def) {
215 return AccessController.doPrivileged(new GetIntegerAction(name, def));
216 }
217
218 private transient Activator activator;
219 private transient Activator activatorStub;
220 private transient ActivationSystem system;
221 private transient ActivationSystem systemStub;
222 private transient ActivationMonitor monitor;
223 private transient Registry registry;
224 private transient volatile boolean shuttingDown = false;
225 private transient volatile Object startupLock;
226 private transient Thread shutdownHook;
227
228 private static ResourceBundle resources = null;
229
230 /**
231 * Create an uninitialized instance of Activation that can be
232 * populated with log data. This is only called when the initial
233 * snapshot is taken during the first incarnation of rmid.
234 */
235 private Activation() {}
236
237 /**
238 * Check that the caller has access to this interface.
239 * <p>
240 * Use the default policy as implemented in RegistryImpl.checkAccess,
241 * unless the sun.rmi.activation.remoteClient property is set, and in
242 * that case only allow access from that host.
243 *
244 * @param op name of operation used to create a meaningful exception
245 * message, the parameter is not used to determine access
246 */
247 static void checkAccess(String op) throws AccessException {
248 if (remoteClientAddress == null) {
249 /*
250 * Note, the op arg to checkAccess is only used to build an
251 * access exception message if needed.
252 */
253 RegistryImpl.checkAccess(op);
254 return;
255 }
256
257 InetAddress clientHost;
258
259 try {
260 // Get client host that this operation was made from.
261 final String clientHostName = TCPTransport.getClientHost();
262
263 try {
264 clientHost = java.security.AccessController.doPrivileged(
265 new java.security.PrivilegedExceptionAction<InetAddress>() {
266 public InetAddress run()
267 throws java.net.UnknownHostException
268 {
269 return InetAddress.getByName(clientHostName);
270 }
271 });
272 } catch (PrivilegedActionException pae) {
273 throw new AccessException("RMI " + op + " disallowed; " +
274 clientHostName + " is an unknown client");
275 }
276 } catch (ServerNotActiveException ex) {
277 throw new AccessException("RMI " + op +
278 " is not allowed from the local host");
279 }
280
281 if (remoteClientAddress.equals(clientHost)) {
282 return;
283 }
284
285 throw new AccessException("RMI " + op + " is not allowed from " +
286 clientHost);
287 }
288
289 /**
290 * Recover activation state from the reliable log and initialize
291 * activation services.
292 */
293 private static void startActivation(int port,
294 RMIServerSocketFactory ssf,
295 String logName,
296 String[] childArgs)
297 throws Exception
298 {
299 ReliableLog log = new ReliableLog(logName, new ActLogHandler());
300 Activation state = (Activation) log.recover();
301 state.init(port, ssf, log, childArgs);
302 }
303
304 /**
305 * Initialize the Activation instantiation; start activation
306 * services.
307 */
308 private void init(int port,
309 RMIServerSocketFactory ssf,
310 ReliableLog log,
311 String[] childArgs)
312 throws Exception
313 {
314 // initialize
315 this.log = log;
316 numUpdates = 0;
317 shutdownHook = new ShutdownHook();
318 groupSemaphore = getInt("sun.rmi.activation.groupThrottle", 3);
319 groupCounter = 0;
320 Runtime.getRuntime().addShutdownHook(shutdownHook);
321
322 // Use array size of 0, since the value from calling size()
323 // may be out of date by the time toArray() is called.
324 ActivationGroupID[] gids =
325 groupTable.keySet().toArray(new ActivationGroupID[0]);
326
327 synchronized (startupLock = new Object()) {
328 // all the remote methods briefly synchronize on startupLock
329 // (via checkShutdown) to make sure they don't happen in the
330 // middle of this block. This block must not cause any such
331 // incoming remote calls to happen, or deadlock would result!
332 activator = new ActivatorImpl(port, ssf);
333 activatorStub = (Activator) RemoteObject.toStub(activator);
334 system = new ActivationSystemImpl(port, ssf);
335 systemStub = (ActivationSystem) RemoteObject.toStub(system);
336 monitor = new ActivationMonitorImpl(port, ssf);
337 initCommand(childArgs);
338 registry = new SystemRegistryImpl(port, null, ssf, systemStub);
339
340 if (ssf != null) {
341 synchronized (initLock) {
342 initDone = true;
343 initLock.notifyAll();
344 }
345 }
346 }
347 startupLock = null;
348
349 // restart services
350 for (int i = gids.length; --i >= 0; ) {
351 try {
352 getGroupEntry(gids[i]).restartServices();
353 } catch (UnknownGroupException e) {
354 System.err.println(
355 getTextResource("rmid.restart.group.warning"));
356 e.printStackTrace();
357 }
358 }
359 }
360
361 /**
362 * Previous versions used HashMap instead of ConcurrentHashMap.
363 * Replace any HashMaps found during deserialization with
364 * ConcurrentHashMaps.
365 */
366 private void readObject(ObjectInputStream ois)
367 throws IOException, ClassNotFoundException
368 {
369 ois.defaultReadObject();
370 if (! (groupTable instanceof ConcurrentHashMap)) {
371 groupTable = new ConcurrentHashMap<>(groupTable);
372 }
373 if (! (idTable instanceof ConcurrentHashMap)) {
374 idTable = new ConcurrentHashMap<>(idTable);
375 }
376 }
377
378 private static class SystemRegistryImpl extends RegistryImpl {
379
380 private static final String NAME = ActivationSystem.class.getName();
381 private static final long serialVersionUID = 4877330021609408794L;
382 private final ActivationSystem systemStub;
383
384 SystemRegistryImpl(int port,
385 RMIClientSocketFactory csf,
386 RMIServerSocketFactory ssf,
387 ActivationSystem systemStub)
388 throws RemoteException
389 {
390 super(port, csf, ssf);
391 this.systemStub = systemStub;
392 }
393
394 /**
395 * Returns the activation system stub if the specified name
396 * matches the activation system's class name, otherwise
397 * returns the result of invoking super.lookup with the specified
398 * name.
399 */
400 public Remote lookup(String name)
401 throws RemoteException, NotBoundException
402 {
403 if (name.equals(NAME)) {
404 return systemStub;
405 } else {
406 return super.lookup(name);
407 }
408 }
409
410 public String[] list() throws RemoteException {
411 String[] list1 = super.list();
412 int length = list1.length;
413 String[] list2 = new String[length + 1];
414 if (length > 0) {
415 System.arraycopy(list1, 0, list2, 0, length);
416 }
417 list2[length] = NAME;
418 return list2;
419 }
420
421 public void bind(String name, Remote obj)
422 throws RemoteException, AlreadyBoundException, AccessException
423 {
424 if (name.equals(NAME)) {
425 throw new AccessException(
426 "binding ActivationSystem is disallowed");
427 } else {
428 super.bind(name, obj);
429 }
430 }
431
432 public void unbind(String name)
433 throws RemoteException, NotBoundException, AccessException
434 {
435 if (name.equals(NAME)) {
436 throw new AccessException(
437 "unbinding ActivationSystem is disallowed");
438 } else {
439 super.unbind(name);
440 }
441 }
442
443
444 public void rebind(String name, Remote obj)
445 throws RemoteException, AccessException
446 {
447 if (name.equals(NAME)) {
448 throw new AccessException(
449 "binding ActivationSystem is disallowed");
450 } else {
451 super.rebind(name, obj);
452 }
453 }
454 }
455
456
457 class ActivatorImpl extends RemoteServer implements Activator {
458 // Because ActivatorImpl has a fixed ObjID, it can be
459 // called by clients holding stale remote references. Each of
460 // its remote methods, then, must check startupLock (calling
461 // checkShutdown() is easiest).
462
463 private static final long serialVersionUID = -3654244726254566136L;
464
465 /**
466 * Construct a new Activator on a specified port.
467 */
468 ActivatorImpl(int port, RMIServerSocketFactory ssf)
469 throws RemoteException
470 {
471 /* Server ref must be created and assigned before remote object
472 * 'this' can be exported.
473 */
474 LiveRef lref =
475 new LiveRef(new ObjID(ObjID.ACTIVATOR_ID), port, null, ssf);
476 UnicastServerRef uref = new UnicastServerRef(lref);
477 ref = uref;
478 uref.exportObject(this, null, false);
479 }
480
481 public MarshalledObject<? extends Remote> activate(ActivationID id,
482 boolean force)
483 throws ActivationException, UnknownObjectException, RemoteException
484 {
485 checkShutdown();
486 return getGroupEntry(id).activate(id, force);
487 }
488 }
489
490 class ActivationMonitorImpl extends UnicastRemoteObject
491 implements ActivationMonitor
492 {
493 private static final long serialVersionUID = -6214940464757948867L;
494
495 ActivationMonitorImpl(int port, RMIServerSocketFactory ssf)
496 throws RemoteException
497 {
498 super(port, null, ssf);
499 }
500
501 public void inactiveObject(ActivationID id)
502 throws UnknownObjectException, RemoteException
503 {
504 try {
505 checkShutdown();
506 } catch (ActivationException e) {
507 return;
508 }
509 Activation.checkAccess("Activator.inactiveObject");
510 getGroupEntry(id).inactiveObject(id);
511 }
512
513 public void activeObject(ActivationID id,
514 MarshalledObject<? extends Remote> mobj)
515 throws UnknownObjectException, RemoteException
516 {
517 try {
518 checkShutdown();
519 } catch (ActivationException e) {
520 return;
521 }
522 Activation.checkAccess("ActivationSystem.activeObject");
523 getGroupEntry(id).activeObject(id, mobj);
524 }
525
526 public void inactiveGroup(ActivationGroupID id,
527 long incarnation)
528 throws UnknownGroupException, RemoteException
529 {
530 try {
531 checkShutdown();
532 } catch (ActivationException e) {
533 return;
534 }
535 Activation.checkAccess("ActivationMonitor.inactiveGroup");
536 getGroupEntry(id).inactiveGroup(incarnation, false);
537 }
538 }
539
540
541 class ActivationSystemImpl
542 extends RemoteServer
543 implements ActivationSystem
544 {
545 private static final long serialVersionUID = 9100152600327688967L;
546
547 // Because ActivationSystemImpl has a fixed ObjID, it can be
548 // called by clients holding stale remote references. Each of
549 // its remote methods, then, must check startupLock (calling
550 // checkShutdown() is easiest).
551 ActivationSystemImpl(int port, RMIServerSocketFactory ssf)
552 throws RemoteException
553 {
554 /* Server ref must be created and assigned before remote object
555 * 'this' can be exported.
556 */
557 LiveRef lref = new LiveRef(new ObjID(4), port, null, ssf);
558 UnicastServerRef uref = new UnicastServerRef(lref);
559 ref = uref;
560 uref.exportObject(this, null);
561 }
562
563 public ActivationID registerObject(ActivationDesc desc)
564 throws ActivationException, UnknownGroupException, RemoteException
565 {
566 checkShutdown();
567 Activation.checkAccess("ActivationSystem.registerObject");
568
569 ActivationGroupID groupID = desc.getGroupID();
570 ActivationID id = new ActivationID(activatorStub);
571 getGroupEntry(groupID).registerObject(id, desc, true);
572 return id;
573 }
574
575 public void unregisterObject(ActivationID id)
576 throws ActivationException, UnknownObjectException, RemoteException
577 {
578 checkShutdown();
579 Activation.checkAccess("ActivationSystem.unregisterObject");
580 getGroupEntry(id).unregisterObject(id, true);
581 }
582
583 public ActivationGroupID registerGroup(ActivationGroupDesc desc)
584 throws ActivationException, RemoteException
585 {
586 checkShutdown();
587 Activation.checkAccess("ActivationSystem.registerGroup");
588 checkArgs(desc, null);
589
590 ActivationGroupID id = new ActivationGroupID(systemStub);
591 GroupEntry entry = new GroupEntry(id, desc);
592 // table insertion must take place before log update
593 groupTable.put(id, entry);
594 addLogRecord(new LogRegisterGroup(id, desc));
595 return id;
596 }
597
598 public ActivationMonitor activeGroup(ActivationGroupID id,
599 ActivationInstantiator group,
600 long incarnation)
601 throws ActivationException, UnknownGroupException, RemoteException
602 {
603 checkShutdown();
604 Activation.checkAccess("ActivationSystem.activeGroup");
605
606 getGroupEntry(id).activeGroup(group, incarnation);
607 return monitor;
608 }
609
610 public void unregisterGroup(ActivationGroupID id)
611 throws ActivationException, UnknownGroupException, RemoteException
612 {
613 checkShutdown();
614 Activation.checkAccess("ActivationSystem.unregisterGroup");
615
616 // remove entry before unregister so state is updated before
617 // logged
618 removeGroupEntry(id).unregisterGroup(true);
619 }
620
621 public ActivationDesc setActivationDesc(ActivationID id,
622 ActivationDesc desc)
623 throws ActivationException, UnknownObjectException, RemoteException
624 {
625 checkShutdown();
626 Activation.checkAccess("ActivationSystem.setActivationDesc");
627
628 if (!getGroupID(id).equals(desc.getGroupID())) {
629 throw new ActivationException(
630 "ActivationDesc contains wrong group");
631 }
632 return getGroupEntry(id).setActivationDesc(id, desc, true);
633 }
634
635 public ActivationGroupDesc setActivationGroupDesc(ActivationGroupID id,
636 ActivationGroupDesc desc)
637 throws ActivationException, UnknownGroupException, RemoteException
638 {
639 checkShutdown();
640 Activation.checkAccess(
641 "ActivationSystem.setActivationGroupDesc");
642
643 checkArgs(desc, null);
644 return getGroupEntry(id).setActivationGroupDesc(id, desc, true);
645 }
646
647 public ActivationDesc getActivationDesc(ActivationID id)
648 throws ActivationException, UnknownObjectException, RemoteException
649 {
650 checkShutdown();
651 Activation.checkAccess("ActivationSystem.getActivationDesc");
652
653 return getGroupEntry(id).getActivationDesc(id);
654 }
655
656 public ActivationGroupDesc getActivationGroupDesc(ActivationGroupID id)
657 throws ActivationException, UnknownGroupException, RemoteException
658 {
659 checkShutdown();
660 Activation.checkAccess
661 ("ActivationSystem.getActivationGroupDesc");
662
663 return getGroupEntry(id).desc;
664 }
665
666 /**
667 * Shutdown the activation system. Destroys all groups spawned by
668 * the activation daemon and exits the activation daemon.
669 */
670 public void shutdown() throws AccessException {
671 Activation.checkAccess("ActivationSystem.shutdown");
672
673 Object lock = startupLock;
674 if (lock != null) {
675 synchronized (lock) {
676 // nothing
677 }
678 }
679
680 synchronized (Activation.this) {
681 if (!shuttingDown) {
682 shuttingDown = true;
683 (new Shutdown()).start();
684 }
685 }
686 }
687 }
688
689 private void checkShutdown() throws ActivationException {
690 // if the startup critical section is running, wait until it
691 // completes/fails before continuing with the remote call.
692 Object lock = startupLock;
693 if (lock != null) {
694 synchronized (lock) {
695 // nothing
696 }
697 }
698
699 if (shuttingDown == true) {
700 throw new ActivationException(
701 "activation system shutting down");
702 }
703 }
704
705 private static void unexport(Remote obj) {
706 for (;;) {
707 try {
708 if (UnicastRemoteObject.unexportObject(obj, false) == true) {
709 break;
710 } else {
711 Thread.sleep(100);
712 }
713 } catch (Exception e) {
714 continue;
715 }
716 }
717 }
718
719 /**
720 * Thread to shutdown rmid.
721 */
722 private class Shutdown extends Thread {
723 Shutdown() {
724 super("rmid Shutdown");
725 }
726
727 public void run() {
728 try {
729 /*
730 * Unexport activation system services
731 */
732 unexport(activator);
733 unexport(system);
734
735 // destroy all child processes (groups)
736 for (GroupEntry groupEntry : groupTable.values()) {
737 groupEntry.shutdown();
738 }
739
740 Runtime.getRuntime().removeShutdownHook(shutdownHook);
741
742 /*
743 * Unexport monitor safely since all processes are destroyed.
744 */
745 unexport(monitor);
746
747 /*
748 * Close log file, fix for 4243264: rmid shutdown thread
749 * interferes with remote calls in progress. Make sure
750 * the log file is only closed when it is impossible for
751 * its closure to interfere with any pending remote calls.
752 * We close the log when all objects in the rmid VM are
753 * unexported.
754 */
755 try {
756 synchronized (log) {
757 log.close();
758 }
759 } catch (IOException e) {
760 }
761
762 } finally {
763 /*
764 * Now exit... A System.exit should only be done if
765 * the RMI activation system daemon was started up
766 * by the main method below (in which should always
767 * be the case since the Activation contructor is private).
768 */
769 System.err.println(getTextResource("rmid.daemon.shutdown"));
770 System.exit(0);
771 }
772 }
773 }
774
775 /** Thread to destroy children in the event of abnormal termination. */
776 private class ShutdownHook extends Thread {
777 ShutdownHook() {
778 super("rmid ShutdownHook");
779 }
780
781 public void run() {
782 synchronized (Activation.this) {
783 shuttingDown = true;
784 }
785
786 // destroy all child processes (groups) quickly
787 for (GroupEntry groupEntry : groupTable.values()) {
788 groupEntry.shutdownFast();
789 }
790 }
791 }
792
793 /**
794 * Returns the groupID for a given id of an object in the group.
795 * Throws UnknownObjectException if the object is not registered.
796 */
797 private ActivationGroupID getGroupID(ActivationID id)
798 throws UnknownObjectException
799 {
800 ActivationGroupID groupID = idTable.get(id);
801 if (groupID != null) {
802 return groupID;
803 }
804 throw new UnknownObjectException("unknown object: " + id);
805 }
806
807 /**
808 * Returns the group entry for the group id, optionally removing it.
809 * Throws UnknownGroupException if the group is not registered.
810 */
811 private GroupEntry getGroupEntry(ActivationGroupID id, boolean rm)
812 throws UnknownGroupException
813 {
814 if (id.getClass() == ActivationGroupID.class) {
815 GroupEntry entry;
816 if (rm) {
817 entry = groupTable.remove(id);
818 } else {
819 entry = groupTable.get(id);
820 }
821 if (entry != null && !entry.removed) {
822 return entry;
823 }
824 }
825 throw new UnknownGroupException("group unknown");
826 }
827
828 /**
829 * Returns the group entry for the group id. Throws
830 * UnknownGroupException if the group is not registered.
831 */
832 private GroupEntry getGroupEntry(ActivationGroupID id)
833 throws UnknownGroupException
834 {
835 return getGroupEntry(id, false);
836 }
837
838 /**
839 * Removes and returns the group entry for the group id. Throws
840 * UnknownGroupException if the group is not registered.
841 */
842 private GroupEntry removeGroupEntry(ActivationGroupID id)
843 throws UnknownGroupException
844 {
845 return getGroupEntry(id, true);
846 }
847
848 /**
849 * Returns the group entry for the object's id. Throws
850 * UnknownObjectException if the object is not registered or the
851 * object's group is not registered.
852 */
853 private GroupEntry getGroupEntry(ActivationID id)
854 throws UnknownObjectException
855 {
856 ActivationGroupID gid = getGroupID(id);
857 GroupEntry entry = groupTable.get(gid);
858 if (entry != null && !entry.removed) {
859 return entry;
860 }
861 throw new UnknownObjectException("object's group removed");
862 }
863
864 /**
865 * Container for group information: group's descriptor, group's
866 * instantiator, flag to indicate pending group creation, and
867 * table of the group's actived objects.
868 *
869 * WARNING: GroupEntry objects should not be written into log file
870 * updates. GroupEntrys are inner classes of Activation and they
871 * can not be serialized independent of this class. If the
872 * complete Activation system is written out as a log update, the
873 * point of having updates is nullified.
874 */
875 private class GroupEntry implements Serializable {
876
877 /** indicate compatibility with JDK 1.2 version of class */
878 private static final long serialVersionUID = 7222464070032993304L;
879 private static final int MAX_TRIES = 2;
880 private static final int NORMAL = 0;
881 private static final int CREATING = 1;
882 private static final int TERMINATE = 2;
883 private static final int TERMINATING = 3;
884
885 ActivationGroupDesc desc = null;
886 ActivationGroupID groupID = null;
887 long incarnation = 0;
888 Map<ActivationID,ObjectEntry> objects = new HashMap<>();
889 Set<ActivationID> restartSet = new HashSet<>();
890
891 transient ActivationInstantiator group = null;
892 transient int status = NORMAL;
893 transient long waitTime = 0;
894 transient String groupName = null;
895 transient Process child = null;
896 transient boolean removed = false;
897 transient Watchdog watchdog = null;
898
899 GroupEntry(ActivationGroupID groupID, ActivationGroupDesc desc) {
900 this.groupID = groupID;
901 this.desc = desc;
902 }
903
904 void restartServices() {
905 Iterator<ActivationID> iter = null;
906
907 synchronized (this) {
908 if (restartSet.isEmpty()) {
909 return;
910 }
911
912 /*
913 * Clone the restartSet so the set does not have to be locked
914 * during iteration. Locking the restartSet could cause
915 * deadlock if an object we are restarting caused another
916 * object in this group to be activated.
917 */
918 iter = (new HashSet<ActivationID>(restartSet)).iterator();
919 }
920
921 while (iter.hasNext()) {
922 ActivationID id = iter.next();
923 try {
924 activate(id, true);
925 } catch (Exception e) {
926 if (shuttingDown) {
927 return;
928 }
929 System.err.println(
930 getTextResource("rmid.restart.service.warning"));
931 e.printStackTrace();
932 }
933 }
934 }
935
936 synchronized void activeGroup(ActivationInstantiator inst,
937 long instIncarnation)
938 throws ActivationException, UnknownGroupException
939 {
940 if (incarnation != instIncarnation) {
941 throw new ActivationException("invalid incarnation");
942 }
943
944 if (group != null) {
945 if (group.equals(inst)) {
946 return;
947 } else {
948 throw new ActivationException("group already active");
949 }
950 }
951
952 if (child != null && status != CREATING) {
953 throw new ActivationException("group not being created");
954 }
955
956 group = inst;
957 status = NORMAL;
958 notifyAll();
959 }
960
961 private void checkRemoved() throws UnknownGroupException {
962 if (removed) {
963 throw new UnknownGroupException("group removed");
964 }
965 }
966
967 private ObjectEntry getObjectEntry(ActivationID id)
968 throws UnknownObjectException
969 {
970 if (removed) {
971 throw new UnknownObjectException("object's group removed");
972 }
973 ObjectEntry objEntry = objects.get(id);
974 if (objEntry == null) {
975 throw new UnknownObjectException("object unknown");
976 }
977 return objEntry;
978 }
979
980 synchronized void registerObject(ActivationID id,
981 ActivationDesc desc,
982 boolean addRecord)
983 throws UnknownGroupException, ActivationException
984 {
985 checkRemoved();
986 objects.put(id, new ObjectEntry(desc));
987 if (desc.getRestartMode() == true) {
988 restartSet.add(id);
989 }
990
991 // table insertion must take place before log update
992 idTable.put(id, groupID);
993
994 if (addRecord) {
995 addLogRecord(new LogRegisterObject(id, desc));
996 }
997 }
998
999 synchronized void unregisterObject(ActivationID id, boolean addRecord)
1000 throws UnknownGroupException, ActivationException
1001 {
1002 ObjectEntry objEntry = getObjectEntry(id);
1003 objEntry.removed = true;
1004 objects.remove(id);
1005 if (objEntry.desc.getRestartMode() == true) {
1006 restartSet.remove(id);
1007 }
1008
1009 // table removal must take place before log update
1010 idTable.remove(id);
1011 if (addRecord) {
1012 addLogRecord(new LogUnregisterObject(id));
1013 }
1014 }
1015
1016 synchronized void unregisterGroup(boolean addRecord)
1017 throws UnknownGroupException, ActivationException
1018 {
1019 checkRemoved();
1020 removed = true;
1021 for (Map.Entry<ActivationID,ObjectEntry> entry :
1022 objects.entrySet())
1023 {
1024 ActivationID id = entry.getKey();
1025 idTable.remove(id);
1026 ObjectEntry objEntry = entry.getValue();
1027 objEntry.removed = true;
1028 }
1029 objects.clear();
1030 restartSet.clear();
1031 reset();
1032 childGone();
1033
1034 // removal should be recorded before log update
1035 if (addRecord) {
1036 addLogRecord(new LogUnregisterGroup(groupID));
1037 }
1038 }
1039
1040 synchronized ActivationDesc setActivationDesc(ActivationID id,
1041 ActivationDesc desc,
1042 boolean addRecord)
1043 throws UnknownObjectException, UnknownGroupException,
1044 ActivationException
1045 {
1046 ObjectEntry objEntry = getObjectEntry(id);
1047 ActivationDesc oldDesc = objEntry.desc;
1048 objEntry.desc = desc;
1049 if (desc.getRestartMode() == true) {
1050 restartSet.add(id);
1051 } else {
1052 restartSet.remove(id);
1053 }
1054 // restart information should be recorded before log update
1055 if (addRecord) {
1056 addLogRecord(new LogUpdateDesc(id, desc));
1057 }
1058
1059 return oldDesc;
1060 }
1061
1062 synchronized ActivationDesc getActivationDesc(ActivationID id)
1063 throws UnknownObjectException, UnknownGroupException
1064 {
1065 return getObjectEntry(id).desc;
1066 }
1067
1068 synchronized ActivationGroupDesc setActivationGroupDesc(
1069 ActivationGroupID id,
1070 ActivationGroupDesc desc,
1071 boolean addRecord)
1072 throws UnknownGroupException, ActivationException
1073 {
1074 checkRemoved();
1075 ActivationGroupDesc oldDesc = this.desc;
1076 this.desc = desc;
1077 // state update should occur before log update
1078 if (addRecord) {
1079 addLogRecord(new LogUpdateGroupDesc(id, desc));
1080 }
1081 return oldDesc;
1082 }
1083
1084 synchronized void inactiveGroup(long incarnation, boolean failure)
1085 throws UnknownGroupException
1086 {
1087 checkRemoved();
1088 if (this.incarnation != incarnation) {
1089 throw new UnknownGroupException("invalid incarnation");
1090 }
1091
1092 reset();
1093 if (failure) {
1094 terminate();
1095 } else if (child != null && status == NORMAL) {
1096 status = TERMINATE;
1097 watchdog.noRestart();
1098 }
1099 }
1100
1101 synchronized void activeObject(ActivationID id,
1102 MarshalledObject<? extends Remote> mobj)
1103 throws UnknownObjectException
1104 {
1105 getObjectEntry(id).stub = mobj;
1106 }
1107
1108 synchronized void inactiveObject(ActivationID id)
1109 throws UnknownObjectException
1110 {
1111 getObjectEntry(id).reset();
1112 }
1113
1114 private synchronized void reset() {
1115 group = null;
1116 for (ObjectEntry objectEntry : objects.values()) {
1117 objectEntry.reset();
1118 }
1119 }
1120
1121 private void childGone() {
1122 if (child != null) {
1123 child = null;
1124 watchdog.dispose();
1125 watchdog = null;
1126 status = NORMAL;
1127 notifyAll();
1128 }
1129 }
1130
1131 private void terminate() {
1132 if (child != null && status != TERMINATING) {
1133 child.destroy();
1134 status = TERMINATING;
1135 waitTime = System.currentTimeMillis() + groupTimeout;
1136 notifyAll();
1137 }
1138 }
1139
1140 /*
1141 * Fallthrough from TERMINATE to TERMINATING
1142 * is intentional
1143 */
1144 @SuppressWarnings("fallthrough")
1145 private void await() {
1146 while (true) {
1147 switch (status) {
1148 case NORMAL:
1149 return;
1150 case TERMINATE:
1151 terminate();
1152 case TERMINATING:
1153 try {
1154 child.exitValue();
1155 } catch (IllegalThreadStateException e) {
1156 long now = System.currentTimeMillis();
1157 if (waitTime > now) {
1158 try {
1159 wait(waitTime - now);
1160 } catch (InterruptedException ee) {
1161 }
1162 continue;
1163 }
1164 // REMIND: print message that group did not terminate?
1165 }
1166 childGone();
1167 return;
1168 case CREATING:
1169 try {
1170 wait();
1171 } catch (InterruptedException e) {
1172 }
1173 }
1174 }
1175 }
1176
1177 // no synchronization to avoid delay wrt getInstantiator
1178 void shutdownFast() {
1179 Process p = child;
1180 if (p != null) {
1181 p.destroy();
1182 }
1183 }
1184
1185 synchronized void shutdown() {
1186 reset();
1187 terminate();
1188 await();
1189 }
1190
1191 MarshalledObject<? extends Remote> activate(ActivationID id,
1192 boolean force)
1193 throws ActivationException
1194 {
1195 Exception detail = null;
1196
1197 /*
1198 * Attempt to activate object and reattempt (several times)
1199 * if activation fails due to communication problems.
1200 */
1201 for (int tries = MAX_TRIES; tries > 0; tries--) {
1202 ActivationInstantiator inst;
1203 long currentIncarnation;
1204
1205 // look up object to activate
1206 ObjectEntry objEntry;
1207 synchronized (this) {
1208 objEntry = getObjectEntry(id);
1209 // if not forcing activation, return cached stub
1210 if (!force && objEntry.stub != null) {
1211 return objEntry.stub;
1212 }
1213 inst = getInstantiator(groupID);
1214 currentIncarnation = incarnation;
1215 }
1216
1217 boolean groupInactive = false;
1218 boolean failure = false;
1219 // activate object
1220 try {
1221 return objEntry.activate(id, force, inst);
1222 } catch (NoSuchObjectException e) {
1223 groupInactive = true;
1224 detail = e;
1225 } catch (ConnectException e) {
1226 groupInactive = true;
1227 failure = true;
1228 detail = e;
1229 } catch (ConnectIOException e) {
1230 groupInactive = true;
1231 failure = true;
1232 detail = e;
1233 } catch (InactiveGroupException e) {
1234 groupInactive = true;
1235 detail = e;
1236 } catch (RemoteException e) {
1237 // REMIND: wait some here before continuing?
1238 if (detail == null) {
1239 detail = e;
1240 }
1241 }
1242
1243 if (groupInactive) {
1244 // group has failed or is inactive; mark inactive
1245 try {
1246 System.err.println(
1247 MessageFormat.format(
1248 getTextResource("rmid.group.inactive"),
1249 detail.toString()));
1250 detail.printStackTrace();
1251 getGroupEntry(groupID).
1252 inactiveGroup(currentIncarnation, failure);
1253 } catch (UnknownGroupException e) {
1254 // not a problem
1255 }
1256 }
1257 }
1258
1259 /**
1260 * signal that group activation failed, nested exception
1261 * specifies what exception occurred when the group did not
1262 * activate
1263 */
1264 throw new ActivationException("object activation failed after " +
1265 MAX_TRIES + " tries", detail);
1266 }
1267
1268 /**
1269 * Returns the instantiator for the group specified by id and
1270 * entry. If the group is currently inactive, exec some
1271 * bootstrap code to create the group.
1272 */
1273 private ActivationInstantiator getInstantiator(ActivationGroupID id)
1274 throws ActivationException
1275 {
1276 assert Thread.holdsLock(this);
1277
1278 await();
1279 if (group != null) {
1280 return group;
1281 }
1282 checkRemoved();
1283 boolean acquired = false;
1284
1285 try {
1286 groupName = Pstartgroup();
1287 acquired = true;
1288 String[] argv = activationArgs(desc);
1289 checkArgs(desc, argv);
1290
1291 if (debugExec) {
1292 StringBuffer sb = new StringBuffer(argv[0]);
1293 int j;
1294 for (j = 1; j < argv.length; j++) {
1295 sb.append(' ');
1296 sb.append(argv[j]);
1297 }
1298 System.err.println(
1299 MessageFormat.format(
1300 getTextResource("rmid.exec.command"),
1301 sb.toString()));
1302 }
1303
1304 try {
1305 child = Runtime.getRuntime().exec(argv);
1306 status = CREATING;
1307 ++incarnation;
1308 watchdog = new Watchdog();
1309 watchdog.start();
1310 addLogRecord(new LogGroupIncarnation(id, incarnation));
1311
1312 // handle child I/O streams before writing to child
1313 PipeWriter.plugTogetherPair
1314 (child.getInputStream(), System.out,
1315 child.getErrorStream(), System.err);
1316 try (MarshalOutputStream out =
1317 new MarshalOutputStream(child.getOutputStream())) {
1318 out.writeObject(id);
1319 out.writeObject(desc);
1320 out.writeLong(incarnation);
1321 out.flush();
1322 }
1323
1324
1325 } catch (IOException e) {
1326 terminate();
1327 throw new ActivationException(
1328 "unable to create activation group", e);
1329 }
1330
1331 try {
1332 long now = System.currentTimeMillis();
1333 long stop = now + execTimeout;
1334 do {
1335 wait(stop - now);
1336 if (group != null) {
1337 return group;
1338 }
1339 now = System.currentTimeMillis();
1340 } while (status == CREATING && now < stop);
1341 } catch (InterruptedException e) {
1342 }
1343
1344 terminate();
1345 throw new ActivationException(
1346 (removed ?
1347 "activation group unregistered" :
1348 "timeout creating child process"));
1349 } finally {
1350 if (acquired) {
1351 Vstartgroup();
1352 }
1353 }
1354 }
1355
1356 /**
1357 * Waits for process termination and then restarts services.
1358 */
1359 private class Watchdog extends Thread {
1360 private final Process groupProcess = child;
1361 private final long groupIncarnation = incarnation;
1362 private boolean canInterrupt = true;
1363 private boolean shouldQuit = false;
1364 private boolean shouldRestart = true;
1365
1366 Watchdog() {
1367 super("WatchDog-" + groupName + "-" + incarnation);
1368 setDaemon(true);
1369 }
1370
1371 public void run() {
1372
1373 if (shouldQuit) {
1374 return;
1375 }
1376
1377 /*
1378 * Wait for the group to crash or exit.
1379 */
1380 try {
1381 groupProcess.waitFor();
1382 } catch (InterruptedException exit) {
1383 return;
1384 }
1385
1386 boolean restart = false;
1387 synchronized (GroupEntry.this) {
1388 if (shouldQuit) {
1389 return;
1390 }
1391 canInterrupt = false;
1392 interrupted(); // clear interrupt bit
1393 /*
1394 * Since the group crashed, we should
1395 * reset the entry before activating objects
1396 */
1397 if (groupIncarnation == incarnation) {
1398 restart = shouldRestart && !shuttingDown;
1399 reset();
1400 childGone();
1401 }
1402 }
1403
1404 /*
1405 * Activate those objects that require restarting
1406 * after a crash.
1407 */
1408 if (restart) {
1409 restartServices();
1410 }
1411 }
1412
1413 /**
1414 * Marks this thread as one that is no longer needed.
1415 * If the thread is in a state in which it can be interrupted,
1416 * then the thread is interrupted.
1417 */
1418 void dispose() {
1419 shouldQuit = true;
1420 if (canInterrupt) {
1421 interrupt();
1422 }
1423 }
1424
1425 /**
1426 * Marks this thread as no longer needing to restart objects.
1427 */
1428 void noRestart() {
1429 shouldRestart = false;
1430 }
1431 }
1432 }
1433
1434 private String[] activationArgs(ActivationGroupDesc desc) {
1435 ActivationGroupDesc.CommandEnvironment cmdenv;
1436 cmdenv = desc.getCommandEnvironment();
1437
1438 // argv is the literal command to exec
1439 List<String> argv = new ArrayList<>();
1440
1441 // Command name/path
1442 argv.add((cmdenv != null && cmdenv.getCommandPath() != null)
1443 ? cmdenv.getCommandPath()
1444 : command[0]);
1445
1446 // Group-specific command options
1447 if (cmdenv != null && cmdenv.getCommandOptions() != null) {
1448 argv.addAll(Arrays.asList(cmdenv.getCommandOptions()));
1449 }
1450
1451 // Properties become -D parameters
1452 Properties props = desc.getPropertyOverrides();
1453 if (props != null) {
1454 for (Enumeration<?> p = props.propertyNames();
1455 p.hasMoreElements();)
1456 {
1457 String name = (String) p.nextElement();
1458 /* Note on quoting: it would be wrong
1459 * here, since argv will be passed to
1460 * Runtime.exec, which should not parse
1461 * arguments or split on whitespace.
1462 */
1463 argv.add("-D" + name + "=" + props.getProperty(name));
1464 }
1465 }
1466
1467 /* Finally, rmid-global command options (e.g. -C options)
1468 * and the classname
1469 */
1470 for (int i = 1; i < command.length; i++) {
1471 argv.add(command[i]);
1472 }
1473
1474 String[] realArgv = new String[argv.size()];
1475 System.arraycopy(argv.toArray(), 0, realArgv, 0, realArgv.length);
1476
1477 return realArgv;
1478 }
1479
1480 private void checkArgs(ActivationGroupDesc desc, String[] cmd)
1481 throws SecurityException, ActivationException
1482 {
1483 /*
1484 * Check exec command using execPolicy object
1485 */
1486 if (execPolicyMethod != null) {
1487 if (cmd == null) {
1488 cmd = activationArgs(desc);
1489 }
1490 try {
1491 execPolicyMethod.invoke(execPolicy, desc, cmd);
1492 } catch (InvocationTargetException e) {
1493 Throwable targetException = e.getTargetException();
1494 if (targetException instanceof SecurityException) {
1495 throw (SecurityException) targetException;
1496 } else {
1497 throw new ActivationException(
1498 execPolicyMethod.getName() + ": unexpected exception",
1499 e);
1500 }
1501 } catch (Exception e) {
1502 throw new ActivationException(
1503 execPolicyMethod.getName() + ": unexpected exception", e);
1504 }
1505 }
1506 }
1507
1508 private static class ObjectEntry implements Serializable {
1509
1510 private static final long serialVersionUID = -5500114225321357856L;
1511
1512 /** descriptor for object */
1513 ActivationDesc desc;
1514 /** the stub (if active) */
1515 volatile transient MarshalledObject<? extends Remote> stub = null;
1516 volatile transient boolean removed = false;
1517
1518 ObjectEntry(ActivationDesc desc) {
1519 this.desc = desc;
1520 }
1521
1522 synchronized MarshalledObject<? extends Remote>
1523 activate(ActivationID id,
1524 boolean force,
1525 ActivationInstantiator inst)
1526 throws RemoteException, ActivationException
1527 {
1528 MarshalledObject<? extends Remote> nstub = stub;
1529 if (removed) {
1530 throw new UnknownObjectException("object removed");
1531 } else if (!force && nstub != null) {
1532 return nstub;
1533 }
1534
1535 nstub = inst.newInstance(id, desc);
1536 stub = nstub;
1537 /*
1538 * stub could be set to null by a group reset, so return
1539 * the newstub here to prevent returning null.
1540 */
1541 return nstub;
1542 }
1543
1544 void reset() {
1545 stub = null;
1546 }
1547 }
1548
1549 /**
1550 * Add a record to the activation log. If the number of updates
1551 * passes a predetermined threshold, record a snapshot.
1552 */
1553 private void addLogRecord(LogRecord rec) throws ActivationException {
1554 synchronized (log) {
1555 checkShutdown();
1556 try {
1557 log.update(rec, true);
1558 } catch (Exception e) {
1559 numUpdates = snapshotInterval;
1560 System.err.println(getTextResource("rmid.log.update.warning"));
1561 e.printStackTrace();
1562 }
1563 if (++numUpdates < snapshotInterval) {
1564 return;
1565 }
1566 try {
1567 log.snapshot(this);
1568 numUpdates = 0;
1569 } catch (Exception e) {
1570 System.err.println(
1571 getTextResource("rmid.log.snapshot.warning"));
1572 e.printStackTrace();
1573 try {
1574 // shutdown activation system because snapshot failed
1575 system.shutdown();
1576 } catch (RemoteException ignore) {
1577 // can't happen
1578 }
1579 // warn the client of the original update problem
1580 throw new ActivationException("log snapshot failed", e);
1581 }
1582 }
1583 }
1584
1585 /**
1586 * Handler for the log that knows how to take the initial snapshot
1587 * and apply an update (a LogRecord) to the current state.
1588 */
1589 private static class ActLogHandler extends LogHandler {
1590
1591 ActLogHandler() {
1592 }
1593
1594 public Object initialSnapshot()
1595 {
1596 /**
1597 * Return an empty Activation object. Log will update
1598 * this object with recovered state.
1599 */
1600 return new Activation();
1601 }
1602
1603 public Object applyUpdate(Object update, Object state)
1604 throws Exception
1605 {
1606 return ((LogRecord) update).apply(state);
1607 }
1608
1609 }
1610
1611 /**
1612 * Abstract class for all log records. The subclass contains
1613 * specific update information and implements the apply method
1614 * that applys the update information contained in the record
1615 * to the current state.
1616 */
1617 private static abstract class LogRecord implements Serializable {
1618 /** indicate compatibility with JDK 1.2 version of class */
1619 private static final long serialVersionUID = 8395140512322687529L;
1620 abstract Object apply(Object state) throws Exception;
1621 }
1622
1623 /**
1624 * Log record for registering an object.
1625 */
1626 private static class LogRegisterObject extends LogRecord {
1627 /** indicate compatibility with JDK 1.2 version of class */
1628 private static final long serialVersionUID = -6280336276146085143L;
1629 private ActivationID id;
1630 private ActivationDesc desc;
1631
1632 LogRegisterObject(ActivationID id, ActivationDesc desc) {
1633 this.id = id;
1634 this.desc = desc;
1635 }
1636
1637 Object apply(Object state) {
1638 try {
1639 ((Activation) state).getGroupEntry(desc.getGroupID()).
1640 registerObject(id, desc, false);
1641 } catch (Exception ignore) {
1642 System.err.println(
1643 MessageFormat.format(
1644 getTextResource("rmid.log.recover.warning"),
1645 "LogRegisterObject"));
1646 ignore.printStackTrace();
1647 }
1648 return state;
1649 }
1650 }
1651
1652 /**
1653 * Log record for unregistering an object.
1654 */
1655 private static class LogUnregisterObject extends LogRecord {
1656 /** indicate compatibility with JDK 1.2 version of class */
1657 private static final long serialVersionUID = 6269824097396935501L;
1658 private ActivationID id;
1659
1660 LogUnregisterObject(ActivationID id) {
1661 this.id = id;
1662 }
1663
1664 Object apply(Object state) {
1665 try {
1666 ((Activation) state).getGroupEntry(id).
1667 unregisterObject(id, false);
1668 } catch (Exception ignore) {
1669 System.err.println(
1670 MessageFormat.format(
1671 getTextResource("rmid.log.recover.warning"),
1672 "LogUnregisterObject"));
1673 ignore.printStackTrace();
1674 }
1675 return state;
1676 }
1677 }
1678
1679 /**
1680 * Log record for registering a group.
1681 */
1682 private static class LogRegisterGroup extends LogRecord {
1683 /** indicate compatibility with JDK 1.2 version of class */
1684 private static final long serialVersionUID = -1966827458515403625L;
1685 private ActivationGroupID id;
1686 private ActivationGroupDesc desc;
1687
1688 LogRegisterGroup(ActivationGroupID id, ActivationGroupDesc desc) {
1689 this.id = id;
1690 this.desc = desc;
1691 }
1692
1693 Object apply(Object state) {
1694 // modify state directly; cant ask a nonexistent GroupEntry
1695 // to register itself.
1696 ((Activation) state).groupTable.put(id, ((Activation) state).new
1697 GroupEntry(id, desc));
1698 return state;
1699 }
1700 }
1701
1702 /**
1703 * Log record for udpating an activation desc
1704 */
1705 private static class LogUpdateDesc extends LogRecord {
1706 /** indicate compatibility with JDK 1.2 version of class */
1707 private static final long serialVersionUID = 545511539051179885L;
1708
1709 private ActivationID id;
1710 private ActivationDesc desc;
1711
1712 LogUpdateDesc(ActivationID id, ActivationDesc desc) {
1713 this.id = id;
1714 this.desc = desc;
1715 }
1716
1717 Object apply(Object state) {
1718 try {
1719 ((Activation) state).getGroupEntry(id).
1720 setActivationDesc(id, desc, false);
1721 } catch (Exception ignore) {
1722 System.err.println(
1723 MessageFormat.format(
1724 getTextResource("rmid.log.recover.warning"),
1725 "LogUpdateDesc"));
1726 ignore.printStackTrace();
1727 }
1728 return state;
1729 }
1730 }
1731
1732 /**
1733 * Log record for unregistering a group.
1734 */
1735 private static class LogUpdateGroupDesc extends LogRecord {
1736 /** indicate compatibility with JDK 1.2 version of class */
1737 private static final long serialVersionUID = -1271300989218424337L;
1738 private ActivationGroupID id;
1739 private ActivationGroupDesc desc;
1740
1741 LogUpdateGroupDesc(ActivationGroupID id, ActivationGroupDesc desc) {
1742 this.id = id;
1743 this.desc = desc;
1744 }
1745
1746 Object apply(Object state) {
1747 try {
1748 ((Activation) state).getGroupEntry(id).
1749 setActivationGroupDesc(id, desc, false);
1750 } catch (Exception ignore) {
1751 System.err.println(
1752 MessageFormat.format(
1753 getTextResource("rmid.log.recover.warning"),
1754 "LogUpdateGroupDesc"));
1755 ignore.printStackTrace();
1756 }
1757 return state;
1758 }
1759 }
1760
1761 /**
1762 * Log record for unregistering a group.
1763 */
1764 private static class LogUnregisterGroup extends LogRecord {
1765 /** indicate compatibility with JDK 1.2 version of class */
1766 private static final long serialVersionUID = -3356306586522147344L;
1767 private ActivationGroupID id;
1768
1769 LogUnregisterGroup(ActivationGroupID id) {
1770 this.id = id;
1771 }
1772
1773 Object apply(Object state) {
1774 GroupEntry entry = ((Activation) state).groupTable.remove(id);
1775 try {
1776 entry.unregisterGroup(false);
1777 } catch (Exception ignore) {
1778 System.err.println(
1779 MessageFormat.format(
1780 getTextResource("rmid.log.recover.warning"),
1781 "LogUnregisterGroup"));
1782 ignore.printStackTrace();
1783 }
1784 return state;
1785 }
1786 }
1787
1788 /**
1789 * Log record for an active group incarnation
1790 */
1791 private static class LogGroupIncarnation extends LogRecord {
1792 /** indicate compatibility with JDK 1.2 version of class */
1793 private static final long serialVersionUID = 4146872747377631897L;
1794 private ActivationGroupID id;
1795 private long inc;
1796
1797 LogGroupIncarnation(ActivationGroupID id, long inc) {
1798 this.id = id;
1799 this.inc = inc;
1800 }
1801
1802 Object apply(Object state) {
1803 try {
1804 GroupEntry entry = ((Activation) state).getGroupEntry(id);
1805 entry.incarnation = inc;
1806 } catch (Exception ignore) {
1807 System.err.println(
1808 MessageFormat.format(
1809 getTextResource("rmid.log.recover.warning"),
1810 "LogGroupIncarnation"));
1811 ignore.printStackTrace();
1812 }
1813 return state;
1814 }
1815 }
1816
1817 /**
1818 * Initialize command to exec a default group.
1819 */
1820 private void initCommand(String[] childArgs) {
1821 command = new String[childArgs.length + 2];
1822 AccessController.doPrivileged(new PrivilegedAction<Void>() {
1823 public Void run() {
1824 try {
1825 command[0] = System.getProperty("java.home") +
1826 File.separator + "bin" + File.separator + "java";
1827 } catch (Exception e) {
1828 System.err.println(
1829 getTextResource("rmid.unfound.java.home.property"));
1830 command[0] = "java";
1831 }
1832 return null;
1833 }
1834 });
1835 System.arraycopy(childArgs, 0, command, 1, childArgs.length);
1836 command[command.length-1] = "sun.rmi.server.ActivationGroupInit";
1837 }
1838
1839 private static void bomb(String error) {
1840 System.err.println("rmid: " + error); // $NON-NLS$
1841 System.err.println(MessageFormat.format(getTextResource("rmid.usage"),
1842 "rmid"));
1843 System.exit(1);
1844 }
1845
1846 /**
1847 * The default policy for checking a command before it is executed
1848 * makes sure the appropriate com.sun.rmi.rmid.ExecPermission and
1849 * set of com.sun.rmi.rmid.ExecOptionPermissions have been granted.
1850 */
1851 public static class DefaultExecPolicy {
1852
1853 public void checkExecCommand(ActivationGroupDesc desc, String[] cmd)
1854 throws SecurityException
1855 {
1856 PermissionCollection perms = getExecPermissions();
1857
1858 /*
1859 * Check properties overrides.
1860 */
1861 Properties props = desc.getPropertyOverrides();
1862 if (props != null) {
1863 Enumeration<?> p = props.propertyNames();
1864 while (p.hasMoreElements()) {
1865 String name = (String) p.nextElement();
1866 String value = props.getProperty(name);
1867 String option = "-D" + name + "=" + value;
1868 try {
1869 checkPermission(perms,
1870 new ExecOptionPermission(option));
1871 } catch (AccessControlException e) {
1872 if (value.equals("")) {
1873 checkPermission(perms,
1874 new ExecOptionPermission("-D" + name));
1875 } else {
1876 throw e;
1877 }
1878 }
1879 }
1880 }
1881
1882 /*
1883 * Check group class name (allow nothing but the default),
1884 * code location (must be null), and data (must be null).
1885 */
1886 String groupClassName = desc.getClassName();
1887 if ((groupClassName != null &&
1888 !groupClassName.equals(
1889 ActivationGroupImpl.class.getName())) ||
1890 (desc.getLocation() != null) ||
1891 (desc.getData() != null))
1892 {
1893 throw new AccessControlException(
1894 "access denied (custom group implementation not allowed)");
1895 }
1896
1897 /*
1898 * If group descriptor has a command environment, check
1899 * command and options.
1900 */
1901 ActivationGroupDesc.CommandEnvironment cmdenv;
1902 cmdenv = desc.getCommandEnvironment();
1903 if (cmdenv != null) {
1904 String path = cmdenv.getCommandPath();
1905 if (path != null) {
1906 checkPermission(perms, new ExecPermission(path));
1907 }
1908
1909 String[] options = cmdenv.getCommandOptions();
1910 if (options != null) {
1911 for (String option : options) {
1912 checkPermission(perms,
1913 new ExecOptionPermission(option));
1914 }
1915 }
1916 }
1917 }
1918
1919 /**
1920 * Prints warning message if installed Policy is the default Policy
1921 * implementation and globally granted permissions do not include
1922 * AllPermission or any ExecPermissions/ExecOptionPermissions.
1923 */
1924 static void checkConfiguration() {
1925 Policy policy =
1926 AccessController.doPrivileged(new PrivilegedAction<Policy>() {
1927 public Policy run() {
1928 return Policy.getPolicy();
1929 }
1930 });
1931 if (!(policy instanceof PolicyFile)) {
1932 return;
1933 }
1934 PermissionCollection perms = getExecPermissions();
1935 for (Enumeration<Permission> e = perms.elements();
1936 e.hasMoreElements();)
1937 {
1938 Permission p = e.nextElement();
1939 if (p instanceof AllPermission ||
1940 p instanceof ExecPermission ||
1941 p instanceof ExecOptionPermission)
1942 {
1943 return;
1944 }
1945 }
1946 System.err.println(getTextResource("rmid.exec.perms.inadequate"));
1947 }
1948
1949 private static PermissionCollection getExecPermissions() {
1950 /*
1951 * The approach used here is taken from the similar method
1952 * getLoaderAccessControlContext() in the class
1953 * sun.rmi.server.LoaderHandler.
1954 */
1955
1956 // obtain permissions granted to all code in current policy
1957 PermissionCollection perms = AccessController.doPrivileged(
1958 new PrivilegedAction<PermissionCollection>() {
1959 public PermissionCollection run() {
1960 CodeSource codesource =
1961 new CodeSource(null, (Certificate[]) null);
1962 Policy p = Policy.getPolicy();
1963 if (p != null) {
1964 return p.getPermissions(codesource);
1965 } else {
1966 return new Permissions();
1967 }
1968 }
1969 });
1970
1971 return perms;
1972 }
1973
1974 private static void checkPermission(PermissionCollection perms,
1975 Permission p)
1976 throws AccessControlException
1977 {
1978 if (!perms.implies(p)) {
1979 throw new AccessControlException(
1980 "access denied " + p.toString());
1981 }
1982 }
1983 }
1984
1985 /**
1986 * Main program to start the activation system. <br>
1987 * The usage is as follows: rmid [-port num] [-log dir].
1988 */
1989 public static void main(String[] args) {
1990 boolean stop = false;
1991
1992 // Create and install the security manager if one is not installed
1993 // already.
1994 if (System.getSecurityManager() == null) {
1995 System.setSecurityManager(new SecurityManager());
1996 }
1997
1998 try {
1999 int port = ActivationSystem.SYSTEM_PORT;
2000 RMIServerSocketFactory ssf = null;
2001
2002 /*
2003 * If rmid has an inherited channel (meaning that it was
2004 * launched from inetd), set the server socket factory to
2005 * return the inherited server socket.
2006 **/
2007 Channel inheritedChannel = AccessController.doPrivileged(
2008 new PrivilegedExceptionAction<Channel>() {
2009 public Channel run() throws IOException {
2010 return System.inheritedChannel();
2011 }
2012 });
2013
2014 if (inheritedChannel != null &&
2015 inheritedChannel instanceof ServerSocketChannel)
2016 {
2017 /*
2018 * Redirect System.err output to a file.
2019 */
2020 AccessController.doPrivileged(
2021 new PrivilegedExceptionAction<Void>() {
2022 public Void run() throws IOException {
2023 File file =
2024 Files.createTempFile("rmid-err", null).toFile();
2025 PrintStream errStream =
2026 new PrintStream(new FileOutputStream(file));
2027 System.setErr(errStream);
2028 return null;
2029 }
2030 });
2031
2032 ServerSocket serverSocket =
2033 ((ServerSocketChannel) inheritedChannel).socket();
2034 port = serverSocket.getLocalPort();
2035 ssf = new ActivationServerSocketFactory(serverSocket);
2036
2037 System.err.println(new Date());
2038 System.err.println(getTextResource(
2039 "rmid.inherited.channel.info") +
2040 ": " + inheritedChannel);
2041 }
2042
2043 String log = null;
2044 List<String> childArgs = new ArrayList<>();
2045
2046 /*
2047 * Parse arguments
2048 */
2049 for (int i = 0; i < args.length; i++) {
2050 if (args[i].equals("-port")) {
2051 if (ssf != null) {
2052 bomb(getTextResource("rmid.syntax.port.badarg"));
2053 }
2054 if ((i + 1) < args.length) {
2055 try {
2056 port = Integer.parseInt(args[++i]);
2057 } catch (NumberFormatException nfe) {
2058 bomb(getTextResource("rmid.syntax.port.badnumber"));
2059 }
2060 } else {
2061 bomb(getTextResource("rmid.syntax.port.missing"));
2062 }
2063
2064 } else if (args[i].equals("-log")) {
2065 if ((i + 1) < args.length) {
2066 log = args[++i];
2067 } else {
2068 bomb(getTextResource("rmid.syntax.log.missing"));
2069 }
2070
2071 } else if (args[i].equals("-stop")) {
2072 stop = true;
2073
2074 } else if (args[i].startsWith("-C")) {
2075 childArgs.add(args[i].substring(2));
2076
2077 } else {
2078 bomb(MessageFormat.format(
2079 getTextResource("rmid.syntax.illegal.option"),
2080 args[i]));
2081 }
2082 }
2083
2084 if (log == null) {
2085 if (ssf != null) {
2086 bomb(getTextResource("rmid.syntax.log.required"));
2087 } else {
2088 log = "log";
2089 }
2090 }
2091
2092 debugExec = AccessController.doPrivileged(
2093 new GetBooleanAction("sun.rmi.server.activation.debugExec"));
2094
2095 /**
2096 * Determine class name for activation exec policy (if any).
2097 */
2098 String execPolicyClassName = AccessController.doPrivileged(
2099 new GetPropertyAction("sun.rmi.activation.execPolicy", null));
2100 if (execPolicyClassName == null) {
2101 if (!stop) {
2102 DefaultExecPolicy.checkConfiguration();
2103 }
2104 execPolicyClassName = "default";
2105 }
2106
2107 /**
2108 * Initialize method for activation exec policy.
2109 */
2110 if (!execPolicyClassName.equals("none")) {
2111 if (execPolicyClassName.equals("") ||
2112 execPolicyClassName.equals("default"))
2113 {
2114 execPolicyClassName = DefaultExecPolicy.class.getName();
2115 }
2116
2117 try {
2118 Class<?> execPolicyClass = getRMIClass(execPolicyClassName);
2119 execPolicy = execPolicyClass.newInstance();
2120 execPolicyMethod =
2121 execPolicyClass.getMethod("checkExecCommand",
2122 ActivationGroupDesc.class,
2123 String[].class);
2124 } catch (Exception e) {
2125 if (debugExec) {
2126 System.err.println(
2127 getTextResource("rmid.exec.policy.exception"));
2128 e.printStackTrace();
2129 }
2130 bomb(getTextResource("rmid.exec.policy.invalid"));
2131 }
2132 }
2133
2134 if (stop == true) {
2135 final int finalPort = port;
2136 AccessController.doPrivileged(new PrivilegedAction<Void>() {
2137 public Void run() {
2138 System.setProperty("java.rmi.activation.port",
2139 Integer.toString(finalPort));
2140 return null;
2141 }
2142 });
2143 ActivationSystem system = ActivationGroup.getSystem();
2144 system.shutdown();
2145 System.exit(0);
2146 }
2147
2148 /*
2149 * Fix for 4173960: Create and initialize activation using
2150 * a static method, startActivation, which will build the
2151 * Activation state in two ways: if when rmid is run, no
2152 * log file is found, the ActLogHandler.recover(...)
2153 * method will create a new Activation instance.
2154 * Alternatively, if a logfile is available, a serialized
2155 * instance of activation will be read from the log's
2156 * snapshot file. Log updates will be applied to this
2157 * Activation object until rmid's state has been fully
2158 * recovered. In either case, only one instance of
2159 * Activation is created.
2160 */
2161 startActivation(port, ssf, log,
2162 childArgs.toArray(new String[childArgs.size()]));
2163
2164 // prevent activator from exiting
2165 while (true) {
2166 try {
2167 Thread.sleep(Long.MAX_VALUE);
2168 } catch (InterruptedException e) {
2169 }
2170 }
2171 } catch (Exception e) {
2172 System.err.println(
2173 MessageFormat.format(
2174 getTextResource("rmid.unexpected.exception"), e));
2175 e.printStackTrace();
2176 }
2177 System.exit(1);
2178 }
2179
2180 /**
2181 * Retrieves text resources from the locale-specific properties file.
2182 */
2183 private static String getTextResource(String key) {
2184 if (Activation.resources == null) {
2185 try {
2186 Activation.resources = ResourceBundle.getBundle(
2187 "sun.rmi.server.resources.rmid");
2188 } catch (MissingResourceException mre) {
2189 }
2190 if (Activation.resources == null) {
2191 // throwing an Error is a bit extreme, methinks
2192 return ("[missing resource file: " + key + "]");
2193 }
2194 }
2195
2196 String val = null;
2197 try {
2198 val = Activation.resources.getString (key);
2199 } catch (MissingResourceException mre) {
2200 }
2201
2202 if (val == null) {
2203 return ("[missing resource: " + key + "]");
2204 } else {
2205 return val;
2206 }
2207 }
2208
2209 @SuppressWarnings("deprecation")
2210 private static Class<?> getRMIClass(String execPolicyClassName) throws Exception {
2211 return RMIClassLoader.loadClass(execPolicyClassName);
2212 }
2213 /*
2214 * Dijkstra semaphore operations to limit the number of subprocesses
2215 * rmid attempts to make at once.
2216 */
2217 /**
2218 * Acquire the group semaphore and return a group name. Each
2219 * Pstartgroup must be followed by a Vstartgroup. The calling thread
2220 * will wait until there are fewer than <code>N</code> other threads
2221 * holding the group semaphore. The calling thread will then acquire
2222 * the semaphore and return.
2223 */
2224 private synchronized String Pstartgroup() throws ActivationException {
2225 while (true) {
2226 checkShutdown();
2227 // Wait until positive, then decrement.
2228 if (groupSemaphore > 0) {
2229 groupSemaphore--;
2230 return "Group-" + groupCounter++;
2231 }
2232
2233 try {
2234 wait();
2235 } catch (InterruptedException e) {
2236 }
2237 }
2238 }
2239
2240 /**
2241 * Release the group semaphore. Every P operation must be
2242 * followed by a V operation. This may cause another thread to
2243 * wake up and return from its P operation.
2244 */
2245 private synchronized void Vstartgroup() {
2246 // Increment and notify a waiter (not necessarily FIFO).
2247 groupSemaphore++;
2248 notifyAll();
2249 }
2250
2251 /**
2252 * A server socket factory to use when rmid is launched via 'inetd'
2253 * with 'wait' status. This socket factory's 'createServerSocket'
2254 * method returns the server socket specified during construction that
2255 * is specialized to delay accepting requests until the
2256 * 'initDone' flag is 'true'. The server socket supplied to
2257 * the constructor should be the server socket obtained from the
2258 * ServerSocketChannel returned from the 'System.inheritedChannel'
2259 * method.
2260 **/
2261 private static class ActivationServerSocketFactory
2262 implements RMIServerSocketFactory
2263 {
2264 private final ServerSocket serverSocket;
2265
2266 /**
2267 * Constructs an 'ActivationServerSocketFactory' with the specified
2268 * 'serverSocket'.
2269 **/
2270 ActivationServerSocketFactory(ServerSocket serverSocket) {
2271 this.serverSocket = serverSocket;
2272 }
2273
2274 /**
2275 * Returns the server socket specified during construction wrapped
2276 * in a 'DelayedAcceptServerSocket'.
2277 **/
2278 public ServerSocket createServerSocket(int port)
2279 throws IOException
2280 {
2281 return new DelayedAcceptServerSocket(serverSocket);
2282 }
2283
2284 }
2285
2286 /**
2287 * A server socket that delegates all public methods to the underlying
2288 * server socket specified at construction. The accept method is
2289 * overridden to delay calling accept on the underlying server socket
2290 * until the 'initDone' flag is 'true'.
2291 **/
2292 private static class DelayedAcceptServerSocket extends ServerSocket {
2293
2294 private final ServerSocket serverSocket;
2295
2296 DelayedAcceptServerSocket(ServerSocket serverSocket)
2297 throws IOException
2298 {
2299 this.serverSocket = serverSocket;
2300 }
2301
2302 public void bind(SocketAddress endpoint) throws IOException {
2303 serverSocket.bind(endpoint);
2304 }
2305
2306 public void bind(SocketAddress endpoint, int backlog)
2307 throws IOException
2308 {
2309 serverSocket.bind(endpoint, backlog);
2310 }
2311
2312 public InetAddress getInetAddress() {
2313 return serverSocket.getInetAddress();
2314 }
2315
2316 public int getLocalPort() {
2317 return serverSocket.getLocalPort();
2318 }
2319
2320 public SocketAddress getLocalSocketAddress() {
2321 return serverSocket.getLocalSocketAddress();
2322 }
2323
2324 /**
2325 * Delays calling accept on the underlying server socket until the
2326 * remote service is bound in the registry.
2327 **/
2328 public Socket accept() throws IOException {
2329 synchronized (initLock) {
2330 try {
2331 while (!initDone) {
2332 initLock.wait();
2333 }
2334 } catch (InterruptedException ignore) {
2335 throw new AssertionError(ignore);
2336 }
2337 }
2338 return serverSocket.accept();
2339 }
2340
2341 public void close() throws IOException {
2342 serverSocket.close();
2343 }
2344
2345 public ServerSocketChannel getChannel() {
2346 return serverSocket.getChannel();
2347 }
2348
2349 public boolean isBound() {
2350 return serverSocket.isBound();
2351 }
2352
2353 public boolean isClosed() {
2354 return serverSocket.isClosed();
2355 }
2356
2357 public void setSoTimeout(int timeout)
2358 throws SocketException
2359 {
2360 serverSocket.setSoTimeout(timeout);
2361 }
2362
2363 public int getSoTimeout() throws IOException {
2364 return serverSocket.getSoTimeout();
2365 }
2366
2367 public void setReuseAddress(boolean on) throws SocketException {
2368 serverSocket.setReuseAddress(on);
2369 }
2370
2371 public boolean getReuseAddress() throws SocketException {
2372 return serverSocket.getReuseAddress();
2373 }
2374
2375 public String toString() {
2376 return serverSocket.toString();
2377 }
2378
2379 public void setReceiveBufferSize(int size)
2380 throws SocketException
2381 {
2382 serverSocket.setReceiveBufferSize(size);
2383 }
2384
2385 public int getReceiveBufferSize()
2386 throws SocketException
2387 {
2388 return serverSocket.getReceiveBufferSize();
2389 }
2390 }
2391 }
2392
2393 /**
2394 * PipeWriter plugs together two pairs of input and output streams by
2395 * providing readers for input streams and writing through to
2396 * appropriate output streams. Both output streams are annotated on a
2397 * per-line basis.
2398 *
2399 * @author Laird Dornin, much code borrowed from Peter Jones, Ken
2400 * Arnold and Ann Wollrath.
2401 */
2402 class PipeWriter implements Runnable {
2403
2404 /** stream used for buffering lines */
2405 private ByteArrayOutputStream bufOut;
2406
2407 /** count since last separator */
2408 private int cLast;
2409
2410 /** current chunk of input being compared to lineSeparator.*/
2411 private byte[] currSep;
2412
2413 private PrintWriter out;
2414 private InputStream in;
2415
2416 private String pipeString;
2417 private String execString;
2418
2419 private static String lineSeparator;
2420 private static int lineSeparatorLength;
2421
2422 private static int numExecs = 0;
2423
2424 static {
2425 lineSeparator = AccessController.doPrivileged(
2426 new GetPropertyAction("line.separator"));
2427 lineSeparatorLength = lineSeparator.length();
2428 }
2429
2430 /**
2431 * Create a new PipeWriter object. All methods of PipeWriter,
2432 * except plugTogetherPair, are only accesible to PipeWriter
2433 * itself. Synchronization is unnecessary on functions that will
2434 * only be used internally in PipeWriter.
2435 *
2436 * @param in input stream from which pipe input flows
2437 * @param out output stream to which log messages will be sent
2438 * @param dest String which tags output stream as 'out' or 'err'
2439 * @param nExecs number of execed processes, Activation groups.
2440 */
2441 private PipeWriter
2442 (InputStream in, OutputStream out, String tag, int nExecs) {
2443
2444 this.in = in;
2445 this.out = new PrintWriter(out);
2446
2447 bufOut = new ByteArrayOutputStream();
2448 currSep = new byte[lineSeparatorLength];
2449
2450 /* set unique pipe/pair annotations */
2451 execString = ":ExecGroup-" +
2452 Integer.toString(nExecs) + ':' + tag + ':';
2453 }
2454
2455 /**
2456 * Create a thread to listen and read from input stream, in. buffer
2457 * the data that is read until a marker which equals lineSeparator
2458 * is read. Once such a string has been discovered; write out an
2459 * annotation string followed by the buffered data and a line
2460 * separator.
2461 */
2462 public void run() {
2463 byte[] buf = new byte[256];
2464 int count;
2465
2466 try {
2467 /* read bytes till there are no more. */
2468 while ((count = in.read(buf)) != -1) {
2469 write(buf, 0, count);
2470 }
2471
2472 /* flush internal buffer... may not have ended on a line
2473 * separator, we also need a last annotation if
2474 * something was left.
2475 */
2476 String lastInBuffer = bufOut.toString();
2477 bufOut.reset();
2478 if (lastInBuffer.length() > 0) {
2479 out.println (createAnnotation() + lastInBuffer);
2480 out.flush(); // add a line separator
2481 // to make output nicer
2482 }
2483
2484 } catch (IOException e) {
2485 }
2486 }
2487
2488 /**
2489 * Write a subarray of bytes. Pass each through write byte method.
2490 */
2491 private void write(byte b[], int off, int len) throws IOException {
2492
2493 if (len < 0) {
2494 throw new ArrayIndexOutOfBoundsException(len);
2495 }
2496 for (int i = 0; i < len; ++ i) {
2497 write(b[off + i]);
2498 }
2499 }
2500
2501 /**
2502 * Write a byte of data to the stream. If we have not matched a
2503 * line separator string, then the byte is appended to the internal
2504 * buffer. If we have matched a line separator, then the currently
2505 * buffered line is sent to the output writer with a prepended
2506 * annotation string.
2507 */
2508 private void write(byte b) throws IOException {
2509 int i = 0;
2510
2511 /* shift current to the left */
2512 for (i = 1 ; i < (currSep.length); i ++) {
2513 currSep[i-1] = currSep[i];
2514 }
2515 currSep[i-1] = b;
2516 bufOut.write(b);
2517
2518 /* enough characters for a separator? */
2519 if ( (cLast >= (lineSeparatorLength - 1)) &&
2520 (lineSeparator.equals(new String(currSep))) ) {
2521
2522 cLast = 0;
2523
2524 /* write prefix through to underlying byte stream */
2525 out.print(createAnnotation() + bufOut.toString());
2526 out.flush();
2527 bufOut.reset();
2528
2529 if (out.checkError()) {
2530 throw new IOException
2531 ("PipeWriter: IO Exception when"+
2532 " writing to output stream.");
2533 }
2534
2535 } else {
2536 cLast++;
2537 }
2538 }
2539
2540 /**
2541 * Create an annotation string to be printed out after
2542 * a new line and end of stream.
2543 */
2544 private String createAnnotation() {
2545
2546 /* construct prefix for log messages:
2547 * date/time stamp...
2548 */
2549 return ((new Date()).toString() +
2550 /* ... print pair # ... */
2551 (execString));
2552 }
2553
2554 /**
2555 * Allow plugging together two pipes at a time, to associate
2556 * output from an execed process. This is the only publicly
2557 * accessible method of this object; this helps ensure that
2558 * synchronization will not be an issue in the annotation
2559 * process.
2560 *
2561 * @param in input stream from which pipe input comes
2562 * @param out output stream to which log messages will be sent
2563 * @param in1 input stream from which pipe input comes
2564 * @param out1 output stream to which log messages will be sent
2565 */
2566 static void plugTogetherPair(InputStream in,
2567 OutputStream out,
2568 InputStream in1,
2569 OutputStream out1) {
2570 Thread inThread = null;
2571 Thread outThread = null;
2572
2573 int nExecs = getNumExec();
2574
2575 /* start RMI threads to read output from child process */
2576 inThread = AccessController.doPrivileged(
2577 new NewThreadAction(new PipeWriter(in, out, "out", nExecs),
2578 "out", true));
2579 outThread = AccessController.doPrivileged(
2580 new NewThreadAction(new PipeWriter(in1, out1, "err", nExecs),
2581 "err", true));
2582 inThread.start();
2583 outThread.start();
2584 }
2585
2586 private static synchronized int getNumExec() {
2587 return numExecs++;
2588 }
2589 }