abstract protected  void checkAcceptPermission(AccessControlContext acc)
Verify that the current access control context has permission to accept
the connection being dispatched by the current thread. The current
access control context is passed as a parameter to avoid the overhead of
an additional call to AccessController.getContext.

 static Transport currentTransport() 
{
        return (Transport) currentTransport.get();
}

Returns the current transport if a call is being serviced, otherwise returns null.

 public  void exportObject(Target target) throws RemoteException 
{
                                                              
        target.setExportedTransport(this);
        ObjectTable.putTarget(target);
}

Export the object so that it can accept incoming calls.

 abstract public  void free(Endpoint ep)
Removes the Channel that generates connections to the
endpoint ep.

 abstract public Channel getChannel(Endpoint ep)
Returns a Channel that generates connections to the
endpoint ep. A Channel is an object that creates and
manages connections of a particular type to some particular
address space.

 public boolean serviceCall(RemoteCall call) 
{
        try {
            /* read object id */
            final Remote impl;
            ObjID id;
            try {
                id = ObjID.read(call.getInputStream());
            } catch (java.io.IOException e) {
                throw new MarshalException("unable to read objID", e);
            }
            /* get the remote object */
            Transport transport = id.equals(dgcID) ? null : this;
            Target target =
                ObjectTable.getTarget(new ObjectEndpoint(id, transport));
            if (target == null || (impl = target.getImpl()) == null) {
                throw new NoSuchObjectException("no such object in table");
            }
            final Dispatcher disp = target.getDispatcher();
            target.incrementCallCount();
            try {
                /* call the dispatcher */
                transportLog.log(Log.VERBOSE, "call dispatcher");
                final AccessControlContext acc =
                    target.getAccessControlContext();
                ClassLoader ccl = target.getContextClassLoader();
                Thread t = Thread.currentThread();
                ClassLoader savedCcl = t.getContextClassLoader();
                try {
                    t.setContextClassLoader(ccl);
                    currentTransport.set(this);
                    try {
                        java.security.AccessController.doPrivileged(
                            new java.security.PrivilegedExceptionAction< Void >() {
                            public Void run() throws IOException {
                                checkAcceptPermission(acc);
                                disp.dispatch(impl, call);
                                return null;
                            }
                        }, acc);
                    } catch (java.security.PrivilegedActionException pae) {
                        throw (IOException) pae.getException();
                    }
                } finally {
                    t.setContextClassLoader(savedCcl);
                    currentTransport.set(null);
                }
            } catch (IOException ex) {
                transportLog.log(Log.BRIEF,
                                 "exception thrown by dispatcher: ", ex);
                return false;
            } finally {
                target.decrementCallCount();
            }
        } catch (RemoteException e) {
            // if calls are being logged, write out exception
            if (UnicastServerRef.callLog.isLoggable(Log.BRIEF)) {
                // include client host name if possible
                String clientHost = "";
                try {
                    clientHost = "[" +
                        RemoteServer.getClientHost() + "] ";
                } catch (ServerNotActiveException ex) {
                }
                String message = clientHost + "exception: ";
                UnicastServerRef.callLog.log(Log.BRIEF, message, e);
            }
            /* We will get a RemoteException if either a) the objID is
             * not readable, b) the target is not in the object table, or
             * c) the object is in the midst of being unexported (note:
             * NoSuchObjectException is thrown by the incrementCallCount
             * method if the object is being unexported).  Here it is
             * relatively safe to marshal an exception to the client
             * since the client will not have seen a return value yet.
             */
            try {
                ObjectOutput out = call.getResultStream(false);
                UnicastServerRef.clearStackTraces(e);
                out.writeObject(e);
                call.releaseOutputStream();
            } catch (IOException ie) {
                transportLog.log(Log.BRIEF,
                    "exception thrown marshalling exception: ", ie);
                return false;
            }
        }
        return true;
}

Service an incoming remote call. When a message arrives on the connection indicating the beginning of a remote call, the threads are required to call the serviceCall method of their transport. The default implementation of this method locates and calls the dispatcher object. Ordinarily a transport implementation will not need to override this method. At the entry to tr.serviceCall(conn), the connection's input stream is positioned at the start of the incoming message. The serviceCall method processes the incoming remote invocation and sends the result on the connection's output stream. If it returns "true", then the remote invocation was processed without error and the transport can cache the connection. If it returns "false", a protocol error occurred during the call, and the transport should destroy the connection.

 protected  void targetUnexported() 
{

}

Invoked when an object that was exported on this transport has become unexported, either by being garbage collected or by being explicitly unexported.