public AprImpl() 
{
    
        aprSingleton=this;
}

 public  void addJkHandler(String type,
    JkHandler cb) 
{
        jkHandlers.put( type, cb );
}

Add a Handler for jni callbacks.

 public static Object createJavaContext(String type,
    long cContext) 
{
        // XXX will be an instance method, fields accessible directly
        AprImpl apr=aprSingleton;
        JkChannel jkH=(JkChannel)apr.jkHandlers.get( type );
        if( jkH==null ) return null;
        MsgContext ep=jkH.createMsgContext();
        ep.setSource( jkH );
        ep.setJniContext( cContext );
        return ep;
}

 public native long createJkHandler(long xEnv,
    String compName)

 public static byte[] getBuffer(Object ctx,
    int id) 
{
        return ((MsgContext)ctx).getBuffer(  id );
}

Return a buffer associated with the ctx.

 public native long getJkEnv()

 public native long getJkHandler(long xEnv,
    String compName)
Get a native component

 public  void init() throws IOException 
{
        try {
            initialized=true;
            loadNative();
            initialize();
            jkSetAttribute(0, 0, "channel:jni", "starting");
            log.info("JK: Initialized apr" );
        } catch( Throwable t ) {
            throw new IOException( t.toString() );
        }
        ok=true;
}

 public native int initialize()
Initialize APR

 public boolean isLoaded() 
{
        if( ! initialized ) {
            try {
                init();
            } catch( Throwable t ) {
                log.info("Apr not loaded: " + t);
            }
        }
        return ok;
}

 public native int jkDestroy(long xEnv,
    long componentP)

 public native String jkGetAttribute(long xEnv,
    long componentP,
    String name)

 public native int jkInit(long xEnv,
    long componentP)

 public static native int jkInvoke(long xEnv,
    long componentP,
    long endpointP,
    int code,
    byte[] data,
    int off,
    int len,
    int raw)
Send the packet to the C side. On return it contains the response
or indication there is no response. Asymetrical because we can't
do things like continuations.

 public native  void jkRecycle(long xEnv,
    long endpointP)
Recycle an endpoint after use.

 public native int jkSetAttribute(long xEnv,
    long componentP,
    String name,
    String val)

 public static int jniInvoke(long jContext,
    Object ctx) 
{
        try {
            MsgContext ep=(MsgContext)ctx;
            ep.setJniEnv(  jContext );
            ep.setType( 0 );
            return ((MsgContext)ctx).execute();
        } catch( Throwable ex ) {
            ex.printStackTrace();
            return -1;
        }
}

 public static  void jniMode() 
{
    
        jniMode=true;
}

 public  void loadNative() throws Throwable 
{
        if( aprHome==null )
            aprHome=baseDir;
        // XXX Update for windows
        if( jniMode ) {
            /* In JNI mode we use mod_jk for the native functions.
               This seems the cleanest solution that works with multiple
               VMs.
            */
            if (jniModeSo.equals("inprocess")) {
                ok=true;
                return;                                
            }
            try {
                log.info("Loading " + jniModeSo);
                if( jniModeSo!= null ) System.load( jniModeSo );
            } catch( Throwable ex ) {
                // ignore
                //ex.printStackTrace();
                return;
            }
            ok=true;
            return;
        }
            /*
              jkjni _must_ be linked with apr and crypt -
              this seem the only ( decent ) way to support JDK1.4 and
              JDK1.3 at the same time
              try {
                  System.loadLibrary( "crypt" );
              } catch( Throwable ex ) {
                  // ignore
                  ex.printStackTrace();
              }
              try {
                  System.loadLibrary( "apr" );
              } catch( Throwable ex ) {
                  System.out.println("can't load apr, that's fine");
                  ex.printStackTrace();
              }
            */
        try {
            if( nativeSo == null ) {
                // This will load libjkjni.so or jkjni.dll in LD_LIBRARY_PATH
                log.debug("Loading jkjni from " + System.getProperty("java.library.path"));
                System.loadLibrary( "jkjni" );
            } else {
                System.load( nativeSo );
            }
        } catch( Throwable ex ) {
            ok=false;
            //ex.printStackTrace();
            throw ex;
        }
}

This method of loading the libs doesn't require setting LD_LIBRARY_PATH. Assuming a 'right' binary distribution, or a correct build all files will be in their right place. The burden is on our code to deal with platform specific extensions and to keep the paths consistent - not easy, but worth it if it avoids one extra step for the user. Of course, this can change to System.load() and putting the libs in LD_LIBRARY_PATH.

 public  void loadNative(String libPath) 
{
        try {
            System.load( libPath );
        } catch( Throwable ex ) {
            ok=false;
            if( log.isDebugEnabled() ) 
                log.debug( "Error loading native library ", ex);
        }
}

 public native  void releaseJkEnv(long xEnv)
Clean the temp pool, put back the env in the pool

 public  void setAprHome(String s) 
{
        aprHome=s;
}

 public  void setBaseDir(String s) 
{
        baseDir=s;
}

Native libraries are located based on base dir. XXX Add platform, version, etc

 public static  void setErr(String filename) 
{
        try{ 
            if( filename !=null ){
                System.setErr( new PrintStream(new FileOutputStream(filename )));
            }                                                 
        }catch (Throwable th){
        }
}

Sets the System.err stream

 public  void setJniModeSo(String jniModeSo) 
{
        this.jniModeSo=jniModeSo;
}

Name of the so used in inprocess mode

 public  void setNativeSo(String nativeSo) 
{
        this.nativeSo=nativeSo;
}

name of the so used by java. If not set we'll loadLibrary("jkjni" ), if set we load( nativeSo )

 public static  void setOut(String filename) 
{
        try{ 
            if( filename !=null ){
                System.setOut( new PrintStream(new FileOutputStream(filename )));
            }
        }catch (Throwable th){
        }
}

Sets the System.out stream

 public  void setSoExt(String s) 
{
        soExt=s;
}

 public native int terminate()