drlvm/vm/vmcore/src/util/natives_support.cpp - harmony - Git at Google

 /*
  *  Licensed to the Apache Software Foundation (ASF) under one or more
  *  contributor license agreements.  See the NOTICE file distributed with
  *  this work for additional information regarding copyright ownership.
  *  The ASF licenses this file to You under the Apache License, Version 2.0
  *  (the "License"); you may not use this file except in compliance with
  *  the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */
 /**
  * @author Pavel Rebriy, Ilya Berezhniuk
  */

 #include <string.h>
 #include <vector>
 #include <apr_strings.h>

 #define LOG_DOMAIN "natives"
 #include "cxxlog.h"

 #include "port_malloc.h"
 #include "port_dso.h"
 #include "exceptions.h"
 #include "natives_support.h"
 #include "environment.h"
 #include "lock_manager.h"
 #include "jni_direct.h" // FIXME ???? Can we use it here ????
 #include "open/vm_util.h"
 #include "port_filepath.h"

 #include "jni_types.h"
 #include "jni_utils.h"

 typedef jint (JNICALL *f_JNI_OnLoad) (JavaVM *vm, void *reserved);
 typedef void (JNICALL *f_JNI_OnUnload) (JavaVM *vm, void *reserved);

 struct JNILibInfo
 {
     JNILibInfo(): ppool(NULL) {}

 public:
     NativeLibInfo*      lib_info_list;
     apr_pool_t*         ppool;
     Lock_Manager        lock;
 };

 static JNILibInfo jni_libs;


 // Initializes natives_support module. Caller must provide thread safety.
 jint natives_init()
 {
     apr_status_t apr_status = apr_pool_create(&jni_libs.ppool, NULL);

     if (APR_SUCCESS != apr_status)
     {
         assert(jni_libs.ppool == NULL);
         return JNI_ENOMEM;
     }

     return JNI_OK;
 }

 // Searches for given name trough the list of loaded libraries
 // Lock must be acquired by the caller
 static NativeLibInfo* search_library_list(const char* library_name)
 {
     Global_Env *ge = VM_Global_State::loader_env;
     String* name = ge->string_pool.lookup(library_name);

     for(NativeLibraryList lib = jni_libs.lib_info_list;
         lib; lib = lib->next)
     {
         if (name == lib->name)
             return lib;
     }

     return NULL;
 }

 // Searches for JNI_OnLoad through given library and calls it
 static jint find_call_JNI_OnLoad(NativeLibraryHandle lib_handle)
 {
 static const char* name_list[] =
     {   "JNI_OnLoad"
 #ifdef PLATFORM_NT
     ,   "_JNI_OnLoad@8"
 #endif
     };

     assert(lib_handle);

     for (unsigned i = 0; i < sizeof(name_list)/sizeof(name_list[0]); i++)
     {
         f_JNI_OnLoad onload_func; // = (f_JNI_OnLoad)handle;

         //apr_dso_handle_sym_t handle = NULL;
         apr_status_t apr_status =
             apr_dso_sym((apr_dso_handle_sym_t*)&onload_func, lib_handle, name_list[i]);

         if (APR_SUCCESS != apr_status)
             continue;

         assert(onload_func);

         JavaVM* vm = jni_get_java_vm(p_TLS_vmthread->jni_env); // FIXME ???? Can we use it here ????

         assert(hythread_is_suspend_enabled());
         jint res = onload_func(vm, NULL);

         return res;
     }

     return 0;
 }

 // Searches for JNI_OnUnload through given library and calls it
 // Lock must be acquired by the caller
 // FIXME unused static
 void find_call_JNI_OnUnload(NativeLibraryHandle lib_handle)
 {
 static const char* name_list[] =
     {   "JNI_OnUnload"
 #ifdef PLATFORM_NT
     ,   "_JNI_OnUnload@8"
 #endif
     };

     assert(lib_handle);

     for (unsigned i = 0; i < sizeof(name_list)/sizeof(name_list[0]); i++)
     {
         f_JNI_OnUnload onunload_func;// = (f_JNI_OnUnload)handle;

         apr_status_t apr_status =
             apr_dso_sym((apr_dso_handle_sym_t*)&onunload_func, lib_handle, name_list[i]);

         if (APR_SUCCESS != apr_status)
             continue;

         assert(onunload_func);

         JavaVM* vm = jni_get_java_vm(p_TLS_vmthread->jni_env); // FIXME ???? Can we use it here ????

         assert(hythread_is_suspend_enabled());
         onunload_func(vm, NULL);
         return;
     }
 }


 static inline bool is_name_lowercase(const char* name)
 {
     for(; *name; name++)
     {
         if (isalpha(*name) && !islower(*name))
             return false;
     }

     return true;
 }

 /**
  *  Creates a copy of the argument with all characters
  *  lowercase
  *
  *  returns a new copy of the string with all chars lowercase
  */
 static inline char *convert_to_lowercase(const char* name)
 {
     if (name == NULL) {
         return NULL;
     }

     char *newCopy = strdup(name);
     char *temp = newCopy;

     for(; *temp; temp++)
     {
         if (isalpha(*temp) && !islower(*temp)) {
             *temp = tolower(*temp);
         }
     }

     return newCopy;
 }

 void ncai_library_load_callback(const char* name);
 void ncai_library_unload_callback(const char* name);

 // Function loads native library with a given name.
 NativeLibraryHandle
 natives_load_library(const char* library_name, bool* just_loaded,
                      NativeLoadStatus* pstatus)
 {
     assert(NULL != library_name);
     assert(NULL != pstatus);

     char *localLibName = (char *) library_name;
     NativeLibraryHandle returnCode = NULL;
     NativeLibInfo* pfound;
     NativeLibInfo* pinfo;
     NativeLibraryHandle handle;
     apr_status_t apr_status;
     Global_Env *ge;
     jint UNREF res;
 #ifdef PLATFORM_NT
     TRACE2("init", "### lib name = " << library_name);

     /*
      *  always convert on NT (and any other non-case-sensitive
      *  platform - it's as fast as checking to see if
      *  lowercase, and keeps the free() logic simpler
      */
     localLibName = convert_to_lowercase(localLibName);

     TRACE2("init", "### lib name = " << localLibName);

     assert(is_name_lowercase(localLibName));
 #endif

     jni_libs.lock._lock();

     pfound = search_library_list(localLibName);

     if (pfound)
     {
         jni_libs.lock._unlock();

         *just_loaded = false;
         *pstatus = APR_SUCCESS;
         returnCode = pfound->handle;

         goto NATIVES_LOAD_LIBRARY_EXIT;
     }

     *just_loaded = true;

     // library was not loaded previously, try to load it
     apr_status = port_dso_load_ex(&handle, localLibName,
                                                PORT_DSO_BIND_DEFER, jni_libs.ppool);
     if (APR_SUCCESS != apr_status)
     {
         char buf[1024];
         apr_dso_error( handle, buf, 1024 );
         TRACE( "Natives: could not load library " << localLibName << "; " << buf );

         jni_libs.lock._unlock();

         *pstatus = apr_status;

         returnCode = NULL;

         goto NATIVES_LOAD_LIBRARY_EXIT;
     }

     pinfo = (NativeLibInfo*)apr_palloc(jni_libs.ppool, sizeof(NativeLibInfo));
     if (NULL == pinfo)
     {
         apr_dso_unload(handle);
         jni_libs.lock._unlock();

         LDIE(29,"{0} apr_palloc failed" << "natives_load_library: ");

         returnCode = NULL;

         goto NATIVES_LOAD_LIBRARY_EXIT;
     }

     pinfo->handle = handle;

     ge = VM_Global_State::loader_env;
     pinfo->name = ge->string_pool.lookup(localLibName);

     pinfo->next = jni_libs.lib_info_list;
     jni_libs.lib_info_list = pinfo;

     ncai_library_load_callback(localLibName);

     jni_libs.lock._unlock();

     res = find_call_JNI_OnLoad(pinfo->handle); // What to do with result???

     *pstatus = APR_SUCCESS;

     returnCode = pinfo->handle;

 NATIVES_LOAD_LIBRARY_EXIT :

 #ifdef PLATFORM_NT
     free(localLibName);
 #endif

     return returnCode;

 } // natives_load_library


 // Function unloads native library.
 static void
 natives_unload_library_internal(NativeLibInfo* pfound)
 {
     assert(pfound);

     // FIXME find_call_JNI_OnUnload(pfound->handle);

     apr_dso_unload(pfound->handle);
 } // natives_unload_library

 // Function unloads native library.
 void
 natives_unload_library(NativeLibraryHandle library_handle)
 {
     assert(NULL != library_handle);

     NativeLibInfo* prev = NULL;
     for(NativeLibInfo* lib = jni_libs.lib_info_list;
         lib; lib = lib->next)
     {
         if(lib->handle == library_handle)
         {
             jni_libs.lock._lock();
             if(jni_libs.lib_info_list == lib) {
                 jni_libs.lib_info_list = lib->next;
             } else {
                 prev->next = lib->next;
             }
             ncai_library_unload_callback(lib->name->bytes);
             natives_unload_library_internal(lib);
             jni_libs.lock._unlock();
             return;
         }

         prev = lib;
     }
 } // natives_unload_library

 // Function looks for loaded native library with a given name.
 bool
 natives_is_library_loaded(const char* library_name)
 {
     return (search_library_list(library_name) != NULL);
 } // natives_is_library_loaded

 // Cleanups natives_support module. Cleans all remaining libraries.
 // Is tread safety provided?????
 void
 natives_cleanup()
 {
     for(NativeLibraryList lib = jni_libs.lib_info_list;
         lib; lib = lib->next)
     {
         natives_unload_library_internal(lib);
     }

     apr_pool_destroy(jni_libs.ppool);
     jni_libs.ppool = NULL;
 } // natives_cleanup

 // Function calculates mangled string length.
 static inline int
 natives_get_mangled_string_length( const char *string )
 {
     int added = 0;

     assert(string);
     // calculate mangled string length
     int len = (int)strlen(string);
     for( int index = 0; index < len; index++ ) {
         switch( string[index] ) {
         case '_':
         case ';':
         case '[':
             added++;
             break;
         case '$':
             added += 6 - 1;
             break;
         case '(':
             added--;
             continue;
         case ')':
             added -= len - index;
             index = len;
             break;
         default:
             break;
         }
     }
     return added + len;
 } // natives_get_mangled_string_length

 // Function mangles string.
 static inline char *
 natives_get_mangled_string( char *buf,
                             const char *string)
 {
     assert(buf);
     assert(string);

     // mangle string
     int len = (int)strlen(string);
     for( int index = 0; index < len; index++ ) {
         switch( string[index] ) {
         case '_':
             *buf = '_';
             *(buf + 1) = '1';
             buf += 2;
             break;
         case ';':
             *buf = '_';
             *(buf + 1) = '2';
             buf += 2;
             break;
         case '[':
             *buf = '_';
             *(buf + 1) = '3';
             buf += 2;
             break;
         case '/':
             *buf = '_';
             buf++;
             break;
         case '$':
             {
                 int len = sprintf(buf, "_0%04x", '$' );
                 assert(len == 6);
                 buf += len;
             }
             break;
         case '(':
             continue;
         case ')':
             index = len;
             break;
         default:
             *buf = string[index];
             buf++;
             break;
         }
     }
     return buf;
 } // natives_get_mangled_string

 // Function returns mangled symbol name length based on class and method names.
 static inline int
 natives_get_mangled_symbol_name_length( const char* klass,
                                         const char* name)
 {
     // 1. prefix 'Java_'
     int len = 5;

     // 2. class name
     len += natives_get_mangled_string_length( klass );

     // 3. an underscore ('_') separator
     len++;

     // 4. method name
     len += natives_get_mangled_string_length( name );

     return len;
 } // natives_get_mangled_symbol_name_length

 // Function extends mangled symbol name length to mandled overloaded symbol
 // name length which is based on class name method name and descriptor of method.
 static inline int
 natives_get_overloaded_length( int mandled_len,
                                const char* desc)
 {
     // 5. for overloaded an underscore ('__') separator
     mandled_len += 2;

     // 6. method descriptor
     mandled_len += natives_get_mangled_string_length( desc );

     return mandled_len;
 } // natives_get_overloaded_length

 // Function returns mangled symbol name based on class and method names.
 static void
 natives_get_mangled_symbol_name( char *buf,
                                  const char* klass,
                                  const char* name)
 {
     // 1. prefix 'Java_'
     memcpy( buf, "Java_", 5 );
     buf += 5;

     // 2. class name
     buf = natives_get_mangled_string( buf, klass );

     // 3. an underscore ('_') separator
     *buf = '_';
     buf++;

     // 4. method name
     buf = natives_get_mangled_string( buf, name );

     // 5. end of string
     *buf = '\0';

     return;
 } // natives_get_mangled_symbol_name

 // Function extends mangled symbol name to mangled overloaded symbol name
 // based on class name, method name and descriptor of method.
 static void
 natives_get_overloaded_name( char *buf,
                              const char* desc)
 {
     // 5. for overloaded an underscore ('__') separator
     buf[0] = '_';
     buf[1] = '_';
     buf += 2;

     // 6. method descriptor
     buf = natives_get_mangled_string( buf, desc );

     // 7. end of string
     *buf = '\0';

     return;
 } // natives_get_overloaded_name

 #ifdef PLATFORM_NT

 // Function calculates function arguments length in bytes
 //      and writes string to the buffer.
 static inline unsigned
 natives_get_args_len(const char* desc)
 {
     // calculate argument length
     unsigned value = 8;
     int len = (int)strlen(desc);
     bool is_array = false;
     for( int index = 0; index < len; index++ ) {
         switch( desc[index] ) {
         case 'L':
             // skip class name
             do {
                 index++;
             } while( desc[index] != ';' );
         case 'B':
         case 'C':
         case 'F':
         case 'I':
         case 'S':
         case 'Z':
             value += 4;
             is_array = false;
             break;
         case 'D':
         case 'J':
             if( is_array ) {
                 value += 4;
             } else {
                 value += 8;
             }
             is_array = false;
             break;
         case '[':
             is_array = true;
             break;
         case '(':
             break;
         case ')':
             index = len;
             break;
         default:
             break;
         }
     }

     return value;
 } // natives_append_args_size

 // Function extends mangled symbol name length to mangled name length for Windows.
 static inline int
 natives_get_win_length( int mandled_len,
                         const char* desc)
 {
     // 1. prefix '_' before 'Java_'
     mandled_len++;

     // 2. postfix '@' and bytes amount of arguments
     mandled_len += 1 + 10;

     return mandled_len;
 } // natives_get_win_length

 // Function extends mangled symbol name to mangled name for Windows.
 static inline void
 natives_get_win_name(char* buf,
                      const char* symbol,
                      unsigned args_len)
 {
     // 1. prefix '_' before 'Java_'
     *buf = '_';
     buf++;

     // 2. copy symbol name
     int len = (int)strlen(symbol);
     memcpy( buf, symbol, len);
     buf += len;

     // 3. postfix '@'
     *buf = '@';
     buf++;

     // 4. size of arguments in bytes
     sprintf(buf, "%d", args_len);

     return;
 } // natives_get_win_name

 #endif // PLATFORM_NT


 static GenericFunctionPointer
 natives_lookup_symbol(NativeLibraryList libraries, const char* symbol)
 {
     for(NativeLibInfo* lib = libraries; lib; lib = lib->next) {
         apr_dso_handle_sym_t func;
         apr_status_t res = apr_dso_sym(&func, lib->handle, symbol);
         if(res == APR_SUCCESS) {
             return (GenericFunctionPointer)func;
         }
     }
     return NULL;
 }


 // Function looks for method with a given name and descriptor in a given native library.
 GenericFunctionPointer
 natives_lookup_method( NativeLibraryList libraries,
                        const char* class_name,
                        const char* method_name,
                        const char* method_desc)
 {
     TRACE("Looking for native: "
         << class_name << "."
         << method_name << method_desc);

     // get mangled symbol name length and mangled overloaded symbol length
     int len = natives_get_mangled_symbol_name_length(class_name, method_name);
     int ov_len = natives_get_overloaded_length(len, method_desc);

 #ifdef PLATFORM_NT
     // get lengths for Windows
     int wlen = natives_get_win_length( len, method_desc );
     int wov_len = ov_len + wlen - len;
     int wargs_len = natives_get_args_len(method_desc);
 #endif // PLATFORM_NT

     // alloc memory for mangled overloaded symbol
     char *name = (char*)STD_ALLOCA( ov_len + 1 );

     // get mangled symbol name
     natives_get_mangled_symbol_name(name, class_name, method_name);
     TRACE("\ttrying: " << name);

     // find function in library
     GenericFunctionPointer func;
     if((func = natives_lookup_symbol(libraries, name)) != NULL)
         return func;

 #ifdef PLATFORM_NT
     // alloc memory for mangled overloaded symbol for Windows
     char *wname = (char*)STD_ALLOCA( wov_len + 1 );

     // get mangled symbol name for Windows
     natives_get_win_name(wname, name, wargs_len);
     TRACE("\ttrying: " << wname);

     // find function in library
     if((func = natives_lookup_symbol(libraries, wname)) != NULL)
         return func;
 #endif // PLATFORM_NT

     // get mangled overloaded symbol name
     natives_get_overloaded_name(name + len, method_desc);
     TRACE("\ttrying: " << name);

     // find function in library
     if((func = natives_lookup_symbol(libraries, name)) != NULL)
         return func;

 #ifdef PLATFORM_NT
     // get mangled overloaded symbol name
     natives_get_win_name(wname, name, wargs_len);
     TRACE("\ttrying: " << wname);

     // find function in library
     if((func = natives_lookup_symbol(libraries, wname)) != NULL)
         return func;
 #endif // PLATFORM_NT

     return NULL;
 } // natives_lookup_method

 void
 natives_describe_error(NativeLoadStatus error, char* buf, size_t buflen)
 {
     apr_strerror(error, buf, buflen);
 } // natives_describe_error


 #ifdef PLATFORM_NT
 // Converts to lower case within given buffer
 void lowercase_buf(char* name)
 {
     assert(name != NULL);

     for(; *name; name++)
     {
         if (isalpha(*name) && !islower(*name)) {
             *name = tolower(*name);
         }
     }
 }
 #endif // #ifdef PLATFORM_NT

 // Fills provided buffer with short file name
 // Returns pointer to buffer or NULL if file name is too long
 char* short_name(const char* name, char* buf)
 {
     assert(name != NULL && buf != NULL);

     const char* filepointer = port_filepath_basename(name);

     if (!filepointer)
         return NULL;

     if (strlen(filepointer) > PORT_PATH_MAX)
         return NULL;

     strcpy(buf, filepointer);

 #ifdef PLATFORM_NT
     lowercase_buf(buf);
 #endif
     return buf;
 }

 // Checks if given library was loaded already
 // Method is stupid and slow but it works for full and partial names
 bool natives_is_library_loaded_slow(const char* libname)
 {
     char src_buf[PORT_PATH_MAX + 1], cmp_buf[PORT_PATH_MAX + 1];

     if (short_name(libname, src_buf) == NULL)
         return false; // Error case

     bool result = false;

     jni_libs.lock._lock();

     for(NativeLibraryList lib = jni_libs.lib_info_list;
         lib; lib = lib->next)
     {
         if (short_name(lib->name->bytes, cmp_buf) == NULL)
             break; // Error case

         if (0 == strcmp(src_buf, cmp_buf))
         {
             result = true;
             break;
         }
     }

     jni_libs.lock._unlock();
     return result;
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	/**
	* @author Pavel Rebriy, Ilya Berezhniuk
	*/

	#include <string.h>
	#include <vector>
	#include <apr_strings.h>

	#define LOG_DOMAIN "natives"
	#include "cxxlog.h"

	#include "port_malloc.h"
	#include "port_dso.h"
	#include "exceptions.h"
	#include "natives_support.h"
	#include "environment.h"
	#include "lock_manager.h"
	#include "jni_direct.h" // FIXME ???? Can we use it here ????
	#include "open/vm_util.h"
	#include "port_filepath.h"

	#include "jni_types.h"
	#include "jni_utils.h"

	typedef jint (JNICALL f_JNI_OnLoad) (JavaVM vm, void *reserved);
	typedef void (JNICALL f_JNI_OnUnload) (JavaVM vm, void *reserved);

	struct JNILibInfo
	{
	JNILibInfo(): ppool(NULL) {}

	public:
	NativeLibInfo* lib_info_list;
	apr_pool_t* ppool;
	Lock_Manager lock;
	};

	static JNILibInfo jni_libs;


	// Initializes natives_support module. Caller must provide thread safety.
	jint natives_init()
	{
	apr_status_t apr_status = apr_pool_create(&jni_libs.ppool, NULL);

	if (APR_SUCCESS != apr_status)
	{
	assert(jni_libs.ppool == NULL);
	return JNI_ENOMEM;
	}

	return JNI_OK;
	}

	// Searches for given name trough the list of loaded libraries
	// Lock must be acquired by the caller
	static NativeLibInfo* search_library_list(const char* library_name)
	{
	Global_Env *ge = VM_Global_State::loader_env;
	String* name = ge->string_pool.lookup(library_name);

	for(NativeLibraryList lib = jni_libs.lib_info_list;
	lib; lib = lib->next)
	{
	if (name == lib->name)
	return lib;
	}

	return NULL;
	}

	// Searches for JNI_OnLoad through given library and calls it
	static jint find_call_JNI_OnLoad(NativeLibraryHandle lib_handle)
	{
	static const char* name_list[] =
	{ "JNI_OnLoad"
	#ifdef PLATFORM_NT
	, "_JNI_OnLoad@8"
	#endif
	};

	assert(lib_handle);

	for (unsigned i = 0; i < sizeof(name_list)/sizeof(name_list[0]); i++)
	{
	f_JNI_OnLoad onload_func; // = (f_JNI_OnLoad)handle;

	//apr_dso_handle_sym_t handle = NULL;
	apr_status_t apr_status =
	apr_dso_sym((apr_dso_handle_sym_t*)&onload_func, lib_handle, name_list[i]);

	if (APR_SUCCESS != apr_status)
	continue;

	assert(onload_func);

	JavaVM* vm = jni_get_java_vm(p_TLS_vmthread->jni_env); // FIXME ???? Can we use it here ????

	assert(hythread_is_suspend_enabled());
	jint res = onload_func(vm, NULL);

	return res;
	}

	return 0;
	}

	// Searches for JNI_OnUnload through given library and calls it
	// Lock must be acquired by the caller
	// FIXME unused static
	void find_call_JNI_OnUnload(NativeLibraryHandle lib_handle)
	{
	static const char* name_list[] =
	{ "JNI_OnUnload"
	#ifdef PLATFORM_NT
	, "_JNI_OnUnload@8"
	#endif
	};

	assert(lib_handle);

	for (unsigned i = 0; i < sizeof(name_list)/sizeof(name_list[0]); i++)
	{
	f_JNI_OnUnload onunload_func;// = (f_JNI_OnUnload)handle;

	apr_status_t apr_status =
	apr_dso_sym((apr_dso_handle_sym_t*)&onunload_func, lib_handle, name_list[i]);

	if (APR_SUCCESS != apr_status)
	continue;

	assert(onunload_func);

	JavaVM* vm = jni_get_java_vm(p_TLS_vmthread->jni_env); // FIXME ???? Can we use it here ????

	assert(hythread_is_suspend_enabled());
	onunload_func(vm, NULL);
	return;
	}
	}


	static inline bool is_name_lowercase(const char* name)
	{
	for(; *name; name++)
	{
	if (isalpha(name) && !islower(name))
	return false;
	}

	return true;
	}

	/**
	* Creates a copy of the argument with all characters
	* lowercase
	*
	* returns a new copy of the string with all chars lowercase
	*/
	static inline char convert_to_lowercase(const char name)
	{
	if (name == NULL) {
	return NULL;
	}

	char *newCopy = strdup(name);
	char *temp = newCopy;

	for(; *temp; temp++)
	{
	if (isalpha(temp) && !islower(temp)) {
	temp = tolower(temp);
	}
	}

	return newCopy;
	}

	void ncai_library_load_callback(const char* name);
	void ncai_library_unload_callback(const char* name);

	// Function loads native library with a given name.
	NativeLibraryHandle
	natives_load_library(const char* library_name, bool* just_loaded,
	NativeLoadStatus* pstatus)
	{
	assert(NULL != library_name);
	assert(NULL != pstatus);

	char localLibName = (char ) library_name;
	NativeLibraryHandle returnCode = NULL;
	NativeLibInfo* pfound;
	NativeLibInfo* pinfo;
	NativeLibraryHandle handle;
	apr_status_t apr_status;
	Global_Env *ge;
	jint UNREF res;
	#ifdef PLATFORM_NT
	TRACE2("init", "### lib name = " << library_name);

	/*
	* always convert on NT (and any other non-case-sensitive
	* platform - it's as fast as checking to see if
	* lowercase, and keeps the free() logic simpler
	*/
	localLibName = convert_to_lowercase(localLibName);

	TRACE2("init", "### lib name = " << localLibName);

	assert(is_name_lowercase(localLibName));
	#endif

	jni_libs.lock._lock();

	pfound = search_library_list(localLibName);

	if (pfound)
	{
	jni_libs.lock._unlock();

	*just_loaded = false;
	*pstatus = APR_SUCCESS;
	returnCode = pfound->handle;

	goto NATIVES_LOAD_LIBRARY_EXIT;
	}

	*just_loaded = true;

	// library was not loaded previously, try to load it
	apr_status = port_dso_load_ex(&handle, localLibName,
	PORT_DSO_BIND_DEFER, jni_libs.ppool);
	if (APR_SUCCESS != apr_status)
	{
	char buf[1024];
	apr_dso_error( handle, buf, 1024 );
	TRACE( "Natives: could not load library " << localLibName << "; " << buf );

	jni_libs.lock._unlock();

	*pstatus = apr_status;

	returnCode = NULL;

	goto NATIVES_LOAD_LIBRARY_EXIT;
	}

	pinfo = (NativeLibInfo*)apr_palloc(jni_libs.ppool, sizeof(NativeLibInfo));
	if (NULL == pinfo)
	{
	apr_dso_unload(handle);
	jni_libs.lock._unlock();

	LDIE(29,"{0} apr_palloc failed" << "natives_load_library: ");

	returnCode = NULL;

	goto NATIVES_LOAD_LIBRARY_EXIT;
	}

	pinfo->handle = handle;

	ge = VM_Global_State::loader_env;
	pinfo->name = ge->string_pool.lookup(localLibName);

	pinfo->next = jni_libs.lib_info_list;
	jni_libs.lib_info_list = pinfo;

	ncai_library_load_callback(localLibName);

	jni_libs.lock._unlock();

	res = find_call_JNI_OnLoad(pinfo->handle); // What to do with result???

	*pstatus = APR_SUCCESS;

	returnCode = pinfo->handle;

	NATIVES_LOAD_LIBRARY_EXIT :

	#ifdef PLATFORM_NT
	free(localLibName);
	#endif

	return returnCode;

	} // natives_load_library


	// Function unloads native library.
	static void
	natives_unload_library_internal(NativeLibInfo* pfound)
	{
	assert(pfound);

	// FIXME find_call_JNI_OnUnload(pfound->handle);

	apr_dso_unload(pfound->handle);
	} // natives_unload_library

	// Function unloads native library.
	void
	natives_unload_library(NativeLibraryHandle library_handle)
	{
	assert(NULL != library_handle);

	NativeLibInfo* prev = NULL;
	for(NativeLibInfo* lib = jni_libs.lib_info_list;
	lib; lib = lib->next)
	{
	if(lib->handle == library_handle)
	{
	jni_libs.lock._lock();
	if(jni_libs.lib_info_list == lib) {
	jni_libs.lib_info_list = lib->next;
	} else {
	prev->next = lib->next;
	}
	ncai_library_unload_callback(lib->name->bytes);
	natives_unload_library_internal(lib);
	jni_libs.lock._unlock();
	return;
	}

	prev = lib;
	}
	} // natives_unload_library

	// Function looks for loaded native library with a given name.
	bool
	natives_is_library_loaded(const char* library_name)
	{
	return (search_library_list(library_name) != NULL);
	} // natives_is_library_loaded

	// Cleanups natives_support module. Cleans all remaining libraries.
	// Is tread safety provided?????
	void
	natives_cleanup()
	{
	for(NativeLibraryList lib = jni_libs.lib_info_list;
	lib; lib = lib->next)
	{
	natives_unload_library_internal(lib);
	}

	apr_pool_destroy(jni_libs.ppool);
	jni_libs.ppool = NULL;
	} // natives_cleanup

	// Function calculates mangled string length.
	static inline int
	natives_get_mangled_string_length( const char *string )
	{
	int added = 0;

	assert(string);
	// calculate mangled string length
	int len = (int)strlen(string);
	for( int index = 0; index < len; index++ ) {
	switch( string[index] ) {
	case '_':
	case ';':
	case '[':
	added++;
	break;
	case '$':
	added += 6 - 1;
	break;
	case '(':
	added--;
	continue;
	case ')':
	added -= len - index;
	index = len;
	break;
	default:
	break;
	}
	}
	return added + len;
	} // natives_get_mangled_string_length

	// Function mangles string.
	static inline char *
	natives_get_mangled_string( char *buf,
	const char *string)
	{
	assert(buf);
	assert(string);

	// mangle string
	int len = (int)strlen(string);
	for( int index = 0; index < len; index++ ) {
	switch( string[index] ) {
	case '_':
	*buf = '_';
	*(buf + 1) = '1';
	buf += 2;
	break;
	case ';':
	*buf = '_';
	*(buf + 1) = '2';
	buf += 2;
	break;
	case '[':
	*buf = '_';
	*(buf + 1) = '3';
	buf += 2;
	break;
	case '/':
	*buf = '_';
	buf++;
	break;
	case '$':
	{
	int len = sprintf(buf, "_0%04x", '$' );
	assert(len == 6);
	buf += len;
	}
	break;
	case '(':
	continue;
	case ')':
	index = len;
	break;
	default:
	*buf = string[index];
	buf++;
	break;
	}
	}
	return buf;
	} // natives_get_mangled_string

	// Function returns mangled symbol name length based on class and method names.
	static inline int
	natives_get_mangled_symbol_name_length( const char* klass,
	const char* name)
	{
	// 1. prefix 'Java_'
	int len = 5;

	// 2. class name
	len += natives_get_mangled_string_length( klass );

	// 3. an underscore ('_') separator
	len++;

	// 4. method name
	len += natives_get_mangled_string_length( name );

	return len;
	} // natives_get_mangled_symbol_name_length

	// Function extends mangled symbol name length to mandled overloaded symbol
	// name length which is based on class name method name and descriptor of method.
	static inline int
	natives_get_overloaded_length( int mandled_len,
	const char* desc)
	{
	// 5. for overloaded an underscore ('__') separator
	mandled_len += 2;

	// 6. method descriptor
	mandled_len += natives_get_mangled_string_length( desc );

	return mandled_len;
	} // natives_get_overloaded_length

	// Function returns mangled symbol name based on class and method names.
	static void
	natives_get_mangled_symbol_name( char *buf,
	const char* klass,
	const char* name)
	{
	// 1. prefix 'Java_'
	memcpy( buf, "Java_", 5 );
	buf += 5;

	// 2. class name
	buf = natives_get_mangled_string( buf, klass );

	// 3. an underscore ('_') separator
	*buf = '_';
	buf++;

	// 4. method name
	buf = natives_get_mangled_string( buf, name );

	// 5. end of string
	*buf = '\0';

	return;
	} // natives_get_mangled_symbol_name

	// Function extends mangled symbol name to mangled overloaded symbol name
	// based on class name, method name and descriptor of method.
	static void
	natives_get_overloaded_name( char *buf,
	const char* desc)
	{
	// 5. for overloaded an underscore ('__') separator
	buf[0] = '_';
	buf[1] = '_';
	buf += 2;

	// 6. method descriptor
	buf = natives_get_mangled_string( buf, desc );

	// 7. end of string
	*buf = '\0';

	return;
	} // natives_get_overloaded_name

	#ifdef PLATFORM_NT

	// Function calculates function arguments length in bytes
	// and writes string to the buffer.
	static inline unsigned
	natives_get_args_len(const char* desc)
	{
	// calculate argument length
	unsigned value = 8;
	int len = (int)strlen(desc);
	bool is_array = false;
	for( int index = 0; index < len; index++ ) {
	switch( desc[index] ) {
	case 'L':
	// skip class name
	do {
	index++;
	} while( desc[index] != ';' );
	case 'B':
	case 'C':
	case 'F':
	case 'I':
	case 'S':
	case 'Z':
	value += 4;
	is_array = false;
	break;
	case 'D':
	case 'J':
	if( is_array ) {
	value += 4;
	} else {
	value += 8;
	}
	is_array = false;
	break;
	case '[':
	is_array = true;
	break;
	case '(':
	break;
	case ')':
	index = len;
	break;
	default:
	break;
	}
	}

	return value;
	} // natives_append_args_size

	// Function extends mangled symbol name length to mangled name length for Windows.
	static inline int
	natives_get_win_length( int mandled_len,
	const char* desc)
	{
	// 1. prefix '_' before 'Java_'
	mandled_len++;

	// 2. postfix '@' and bytes amount of arguments
	mandled_len += 1 + 10;

	return mandled_len;
	} // natives_get_win_length

	// Function extends mangled symbol name to mangled name for Windows.
	static inline void
	natives_get_win_name(char* buf,
	const char* symbol,
	unsigned args_len)
	{
	// 1. prefix '_' before 'Java_'
	*buf = '_';
	buf++;

	// 2. copy symbol name
	int len = (int)strlen(symbol);
	memcpy( buf, symbol, len);
	buf += len;

	// 3. postfix '@'
	*buf = '@';
	buf++;

	// 4. size of arguments in bytes
	sprintf(buf, "%d", args_len);

	return;
	} // natives_get_win_name

	#endif // PLATFORM_NT


	static GenericFunctionPointer
	natives_lookup_symbol(NativeLibraryList libraries, const char* symbol)
	{
	for(NativeLibInfo* lib = libraries; lib; lib = lib->next) {
	apr_dso_handle_sym_t func;
	apr_status_t res = apr_dso_sym(&func, lib->handle, symbol);
	if(res == APR_SUCCESS) {
	return (GenericFunctionPointer)func;
	}
	}
	return NULL;
	}


	// Function looks for method with a given name and descriptor in a given native library.
	GenericFunctionPointer
	natives_lookup_method( NativeLibraryList libraries,
	const char* class_name,
	const char* method_name,
	const char* method_desc)
	{
	TRACE("Looking for native: "
	<< class_name << "."
	<< method_name << method_desc);

	// get mangled symbol name length and mangled overloaded symbol length
	int len = natives_get_mangled_symbol_name_length(class_name, method_name);
	int ov_len = natives_get_overloaded_length(len, method_desc);

	#ifdef PLATFORM_NT
	// get lengths for Windows
	int wlen = natives_get_win_length( len, method_desc );
	int wov_len = ov_len + wlen - len;
	int wargs_len = natives_get_args_len(method_desc);
	#endif // PLATFORM_NT

	// alloc memory for mangled overloaded symbol
	char name = (char)STD_ALLOCA( ov_len + 1 );

	// get mangled symbol name
	natives_get_mangled_symbol_name(name, class_name, method_name);
	TRACE("\ttrying: " << name);

	// find function in library
	GenericFunctionPointer func;
	if((func = natives_lookup_symbol(libraries, name)) != NULL)
	return func;

	#ifdef PLATFORM_NT
	// alloc memory for mangled overloaded symbol for Windows
	char wname = (char)STD_ALLOCA( wov_len + 1 );

	// get mangled symbol name for Windows
	natives_get_win_name(wname, name, wargs_len);
	TRACE("\ttrying: " << wname);

	// find function in library
	if((func = natives_lookup_symbol(libraries, wname)) != NULL)
	return func;
	#endif // PLATFORM_NT

	// get mangled overloaded symbol name
	natives_get_overloaded_name(name + len, method_desc);
	TRACE("\ttrying: " << name);

	// find function in library
	if((func = natives_lookup_symbol(libraries, name)) != NULL)
	return func;

	#ifdef PLATFORM_NT
	// get mangled overloaded symbol name
	natives_get_win_name(wname, name, wargs_len);
	TRACE("\ttrying: " << wname);

	// find function in library
	if((func = natives_lookup_symbol(libraries, wname)) != NULL)
	return func;
	#endif // PLATFORM_NT

	return NULL;
	} // natives_lookup_method

	void
	natives_describe_error(NativeLoadStatus error, char* buf, size_t buflen)
	{
	apr_strerror(error, buf, buflen);
	} // natives_describe_error


	#ifdef PLATFORM_NT
	// Converts to lower case within given buffer
	void lowercase_buf(char* name)
	{
	assert(name != NULL);

	for(; *name; name++)
	{
	if (isalpha(name) && !islower(name)) {
	name = tolower(name);
	}
	}
	}
	#endif // #ifdef PLATFORM_NT

	// Fills provided buffer with short file name
	// Returns pointer to buffer or NULL if file name is too long
	char* short_name(const char* name, char* buf)
	{
	assert(name != NULL && buf != NULL);

	const char* filepointer = port_filepath_basename(name);

	if (!filepointer)
	return NULL;

	if (strlen(filepointer) > PORT_PATH_MAX)
	return NULL;

	strcpy(buf, filepointer);

	#ifdef PLATFORM_NT
	lowercase_buf(buf);
	#endif
	return buf;
	}

	// Checks if given library was loaded already
	// Method is stupid and slow but it works for full and partial names
	bool natives_is_library_loaded_slow(const char* libname)
	{
	char src_buf[PORT_PATH_MAX + 1], cmp_buf[PORT_PATH_MAX + 1];

	if (short_name(libname, src_buf) == NULL)
	return false; // Error case

	bool result = false;

	jni_libs.lock._lock();

	for(NativeLibraryList lib = jni_libs.lib_info_list;
	lib; lib = lib->next)
	{
	if (short_name(lib->name->bytes, cmp_buf) == NULL)
	break; // Error case

	if (0 == strcmp(src_buf, cmp_buf))
	{
	result = true;
	break;
	}
	}

	jni_libs.lock._unlock();
	return result;
	}