KNI_RETURNTYPE_BYTE
KNIDECL(com_sun_midp_security_Permissions_getMaxValue) {
    
    int str_len;
    jbyte value;
    jchar jbuff[64];
    char  domain_name[64], group_name[64];

    KNI_StartHandles(2);
    KNI_DeclareHandle(domain);
    KNI_DeclareHandle(group);

    value = 0;
    KNI_GetParameterAsObject(1, domain);
    KNI_GetParameterAsObject(2, group);
    if (!KNI_IsNullHandle(domain) && !KNI_IsNullHandle(group)) {
        str_len = KNI_GetStringLength(domain);
        KNI_GetStringRegion(domain, 0, str_len, jbuff);
        jchar_to_char(jbuff, domain_name, str_len);
        str_len = KNI_GetStringLength(group);
        KNI_GetStringRegion(group, 0, str_len, jbuff);
        jchar_to_char(jbuff, group_name, str_len);
        value = (jbyte)permissions_get_max_value(domain_name, group_name);
    }

    KNI_EndHandles();
    KNI_ReturnByte(value);
}
Ejemplo n.º 2
0
KNIEXPORT KNI_RETURNTYPE_VOID
KNIDECL(com_sun_midp_main_CDCInit_initMidpNativeStates) {
    jchar jbuff[1024];
    static char conf_buff[1024], store_buff[1024];
    int max = sizeof(conf_buff) - 1;
    int len, i;

    KNI_StartHandles(2);    
    KNI_DeclareHandle(config);
    KNI_DeclareHandle(storage);
    
    KNI_GetParameterAsObject(1, config);
    KNI_GetParameterAsObject(2, storage);
	
    len = KNI_GetStringLength(config);
    if (len > max) {
        len = max;
    }
    KNI_GetStringRegion(config, 0, len, jbuff);
    for (i=0; i<len; i++) {
        conf_buff[i] = (char)jbuff[i];
    }
    conf_buff[len] = 0;
    len = KNI_GetStringLength(storage);
    if (len > max) {
        len = max;
    }
    KNI_GetStringRegion(storage, 0, len, jbuff);
    for (i=0; i<len; i++) {
        store_buff[i] = (char)jbuff[i];
    }
    store_buff[len] = 0;

    initCDCEvents();

    midpSetAppDir(store_buff);
    midpSetConfigDir(conf_buff);
    
    if (midpInitialize() != 0) {
        printf("midpInitialize() failed\n");

    }

    if (midpInitCallback(VM_LEVEL, midpInitializeUI, midpFinalizeUI) != 0) {
        printf("midpInitCallback(VM_LEVEL, ...) failed\n");
    }

    KNI_EndHandles();
    KNI_ReturnVoid();
}
Ejemplo n.º 3
0
/**
 * Compare two strings using locale- and level-specific rules.
 * <p>
 * Java declaration:
 * <pre>
 *     compare0(Ljava/lang/String;Ljava/lang/String;II)I
 * </pre>
 *
 * @param locale_index  the locale index in supported locales list
 * @param hstr1         first string to compare
 * @param hstr2         second string to compare
 * @param level         the collation level to use
 * @return negative if <code>s1</code> belongs before <code>s2</code>,
 *      zero if the strings are equal, positive if <code>s1</code> belongs
 *      after <code>s2</code>
 */
KNIEXPORT KNI_RETURNTYPE_INT
Java_com_sun_j2me_global_StringComparatorImpl_compare0() {
   jint locale_index = KNI_GetParameterAsInt(1);
   jint level = KNI_GetParameterAsInt(4);
   jchar *s1, *s2;
   jsize s1_len, s2_len;
   jint res, compare_result = 0;

   KNI_StartHandles(2);
   KNI_DeclareHandle(hstr1);
   KNI_DeclareHandle(hstr2);
   KNI_GetParameterAsObject(2, hstr1);
   KNI_GetParameterAsObject(3, hstr2);

   s1_len = KNI_GetStringLength(hstr1);
   if (s1_len == -1){
		KNI_ThrowNew(midpNullPointerException, NULL);
   } else {
	   s1 = (jchar *)midpMalloc(s1_len * sizeof(jchar));
	   if (NULL == s1) {
		   KNI_ThrowNew(midpOutOfMemoryError, 
			   "Cannot allocate string for collation");
	   } else {
		   s2_len = KNI_GetStringLength(hstr2);
		   if (s2_len == -1){
			   KNI_ThrowNew(midpNullPointerException, NULL);
		   } else {
			   s2 = (jchar *)midpMalloc(s2_len * sizeof(jchar));
			   if (NULL == s2) {
				   KNI_ThrowNew(midpOutOfMemoryError, 
					   "Cannot allocate string for collation");
			   } else {
				   KNI_GetStringRegion(hstr1, 0, s1_len, s1);
				   KNI_GetStringRegion(hstr2, 0, s2_len, s2);
				   res = jsr238_compare_strings(locale_index, s1, s1_len, s2, s2_len, 
													   level, &compare_result);
				   if (res < 0){
						KNI_ThrowNew(midpRuntimeException,"Error comparing strings");
				   }
				   midpFree(s2);
			   }
		   }
		   midpFree(s1);
	   }
   }

   KNI_EndHandles();
   KNI_ReturnInt(compare_result);
}
/**
 * Gets the value of the specified property key in the internal
 * property set. If the key is not found in the internal property
 * set, the application property set is then searched.
 * <p>
 * Java declaration:
 * <pre>
 *     getProperty0(Ljava.lang.String;)Ljava.lang.String;
 * <pre>
 *
 * @param key The key to search for
 *
 * @return The value associated with <tt>key<tt> if found, otherwise
 *         <tt>null<tt>
 */
KNIEXPORT KNI_RETURNTYPE_OBJECT
KNIDECL(com_sun_midp_main_Configuration_getProperty0) {
    jchar* uStr;
    const char* key;
    const char* value;
    int strLen;

    KNI_StartHandles(2);
    KNI_DeclareHandle(str);
    KNI_DeclareHandle(result);

    KNI_GetParameterAsObject(1, str);
    strLen = KNI_GetStringLength(str);

    if (strLen <= 0 || (uStr = (jchar*) midpMalloc(strLen * sizeof(jchar))) == NULL) {
        KNI_ThrowNew(midpOutOfMemoryError, NULL);
    } else {
        KNI_GetStringRegion(str, 0, strLen, uStr);
        key = UnicodeToCString(uStr, strLen);
        midpFree(uStr);

        /* Look up the property value */
        value = getInternalProperty(key);
        midpFree((void *)key);

        if (value != NULL) {
            KNI_NewStringUTF(value, result);
        } else {
            KNI_ReleaseHandle(result);
        }
    }
    KNI_EndHandlesAndReturnObject(result);
}
Ejemplo n.º 5
0
/**
 * Get index of supported locales for collation by its name.
 * <p>
 * Java declaration:
 * <pre>
 *     getDevLocaleIndex(Ljava/lang/String)I
 * </pre>
 *
 * @param locale name
 * @return internal index of locale or -1 if locale is not supported 
 */
KNIEXPORT KNI_RETURNTYPE_INT
Java_com_sun_j2me_global_CollationAbstractionLayerImpl_getCollationLocaleIndex() {
	jint result =-1, index = 0;
	jsize len = 0;
	int error = 0;
	jchar* locale_name;

	KNI_StartHandles(1);
	KNI_DeclareHandle(hstr1);
	KNI_GetParameterAsObject(1, hstr1);

	if (KNI_IsNullHandle(hstr1)) {
		locale_name = NULL;
	} else  {
		len = KNI_GetStringLength(hstr1);
		locale_name = (jchar *)midpMalloc((len + 1) * sizeof(jchar));
		if (NULL == locale_name) {
		   KNI_ThrowNew(midpOutOfMemoryError, 
			   "Out of memory");
		   error = 1;
		} else {
			KNI_GetStringRegion(hstr1, 0, len, locale_name);
			locale_name[len]=0;
		}
	}

	if (!error){
		result = jsr238_get_collation_locale_index(locale_name, &index);
		if (result < 0) index =-1;
		midpFree(locale_name);
	}

	KNI_EndHandles();
	KNI_ReturnInt(index);
}
Ejemplo n.º 6
0
/**
 * Get index of supported locales for device resources by its name.
 * <p>
 * Java declaration:
 * <pre>
 *     getDevLocaleIndex(Ljava/lang/String)I
 * </pre>
 *
 * @param locale name
 * @return internal index of locale or -1 if locale is not supported 
 */
KNIEXPORT KNI_RETURNTYPE_INT
KNIDECL(com_sun_j2me_global_DevResourceManagerFactory_getDevLocaleIndex) {
	jint result =-1, index = 0;
	jsize len = 0;
	int error = 0;
	jchar* locale_name;

	KNI_StartHandles(1);
	KNI_DeclareHandle(hstr1);
	KNI_GetParameterAsObject(1, hstr1);

	if (KNI_IsNullHandle(hstr1)) {
		locale_name = NULL;
	} else  {
		len = KNI_GetStringLength(hstr1);
		locale_name = (jchar *)JAVAME_MALLOC((len + 1) * sizeof(jchar));
		if (NULL == locale_name) {
		   KNI_ThrowNew(jsropOutOfMemoryError, 
			   "Out of memory");
		   error = 1;
		} else {
			KNI_GetStringRegion(hstr1, 0, len, locale_name);
			locale_name[len]=0;
		}
	}

	if (!error){
		result = jsr238_get_resource_locale_index(locale_name, &index);
		if (result < 0) index =-1;
		JAVAME_FREE(locale_name);
	}

	KNI_EndHandles();
	KNI_ReturnInt(index);
}
Ejemplo n.º 7
0
/**
 * Gets a handle to specific character encoding conversion routine.
 * <p>
 * Java declaration:
 * <pre>
 *     getHandler(Ljava/lang/String;)I
 * </pre>
 *
 * @param encoding character encoding
 *
 * @return identifier for requested handler, or <tt>-1</tt> if
 *         the encoding was not supported.
 */
KNIEXPORT KNI_RETURNTYPE_INT
Java_com_sun_cldc_i18n_j2me_Conv_getHandler() {
    jint     result = 0;

    KNI_StartHandles(1);

    KNI_DeclareHandle(str);
    KNI_GetParameterAsObject(1, str);

    if (!KNI_IsNullHandle(str)) {
        int      strLen = KNI_GetStringLength(str);
	jchar* strBuf;

	/* Instead of always multiplying the length by sizeof(jchar),
	 * we shift left by 1. This can be done because jchar has a
	 * size of 2 bytes.
	 */
	strBuf = (jchar*)midpMalloc(strLen<<1);
	if (strBuf != NULL) { 
	    KNI_GetStringRegion(str, 0, strLen, strBuf);
	    result = getLcConvMethodsID(strBuf, strLen);
	    midpFree(strBuf);
	} else {
	    KNI_ThrowNew(midpOutOfMemoryError, NULL);
	}
    }

    KNI_EndHandles();
    KNI_ReturnInt(result);
}
Ejemplo n.º 8
0
/*  private native int nSetLocator ( int handle , String locator ) ; */
KNIEXPORT KNI_RETURNTYPE_INT
Java_com_sun_mmedia_DirectRecord_nSetLocator() {
    jint handle = KNI_GetParameterAsInt(1);
    KNIPlayerInfo* pKniInfo = (KNIPlayerInfo*)handle;
    jint locatorLength;
    jchar* locator = NULL;
    jint returnValue = 0;
    javacall_result ret;

    KNI_StartHandles(1);
    KNI_DeclareHandle(locatorHandle);
    KNI_GetParameterAsObject(2, locatorHandle);
    
    locatorLength = KNI_GetStringLength(locatorHandle);
    locator = MMP_MALLOC(locatorLength * sizeof(jchar));
    if (locator) {
        KNI_GetStringRegion(locatorHandle, 0, locatorLength, locator);
        if (pKniInfo && pKniInfo->pNativeHandle) {
            ret = javacall_media_recording_handled_by_native(pKniInfo->pNativeHandle, locator, locatorLength);
            if (JAVACALL_INVALID_ARGUMENT == ret) {
                returnValue = -1;
                REPORT_ERROR1(LC_MMAPI, "[kni_record] Set recording location \
                    return JAVACALL_INVALID_ARGUMENT handle=%d\n", pKniInfo->pNativeHandle);
            } else {
                if (JAVACALL_OK == ret) {
Ejemplo n.º 9
0
KNIEXPORT KNI_RETURNTYPE_VOID
KNIDECL(javax_microedition_lcdui_TextFieldLFImpl_setNativeEditorContent) {
#if 0
    int cursorIndex = KNI_GetParameterAsInt(2);
    _JavaString *jstr;
    jchar *p;
    int strLen;

    if (editBoxShown) {
        KNI_StartHandles(1);
        KNI_DeclareHandle(str);
        KNI_GetParameterAsObject(1, str);

        jstr = getJavaStringPtr(str);
        p = jstr->value->elements + jstr->offset;
        strLen = KNI_GetStringLength(str);

        /* This is OK: we know that the Java string that gets passed here
         * is always on the heap.
         */
        jchar saved = p[strLen];
        p[strLen] = 0;
        int oldSize = GetWindowTextLength(hwndTextActive);

        SendMessage(hwndTextActive, EM_SETSEL, (WPARAM)0, (LPARAM)oldSize);
        SendMessage(hwndTextActive, EM_REPLACESEL, 0, (LPARAM)((LPSTR)p));
        SendMessage(hwndTextActive, EM_SETSEL, cursorIndex, cursorIndex);
        p[strLen] = saved; /* restore corruption of the heap! */

        KNI_EndHandles();
    }
#endif
    KNI_ReturnVoid();
}
Ejemplo n.º 10
0
static void sendControlStringField(KNIDECLARGS kjobject objectHandle,
                                   kjobject stringObj, jfieldID fieldID) {
    int len;
    jchar *data = NULL;
    (void) _arguments;
    (void) _p_mb;
    (void) _ee;

    KNI_GetObjectField(objectHandle, fieldID, stringObj);
    len = KNI_GetStringLength(stringObj);
    if (len > 0) {
        data = (jchar*)midpMalloc(len * sizeof(jchar));
        if (data == NULL) {
            len = 0; /* IMPL_NOTE: throw out of memory */
        } else {
            KNI_GetStringRegion(stringObj, 0, len, data);
        }
    }

    write(controlPipe[1], &len, sizeof(int));
    if (len > 0) {
        write(controlPipe[1], data, len * sizeof(jchar));
        midpFree(data);
    }
}
Ejemplo n.º 11
0
/**
 * Gets the total advance width of the given <tt>String</tt> in this
 * <tt>Font</tt>.
 * <p>
 * Java declaration:
 * <pre>
 *     stringWidth(Ljava/lang/String;)I
 * </pre>
 *
 * @param str the <tt>String</tt> to be measured
 *
 * @return the total advance width of the <tt>String</tt> in pixels
 */
KNIEXPORT KNI_RETURNTYPE_INT
KNIDECL(javax_microedition_lcdui_Font_stringWidth) {
    int strLen;
    jint result = 0;

    KNI_StartHandles(2);

    KNI_DeclareHandle(str);
    KNI_DeclareHandle(thisObject);

    KNI_GetParameterAsObject(1, str);
    KNI_GetParameterAsObject(0, thisObject);

    if ((strLen = KNI_GetStringLength(str)) == -1) {
        KNI_ThrowNew(midpNullPointerException, NULL);
    } else {
        int      face, style, size;
        _JavaString *jstr;

        DECLARE_FONT_PARAMS(thisObject);

        SNI_BEGIN_RAW_POINTERS;
     
        jstr = GET_STRING_PTR(str);

        result = gx_get_charswidth(face, style, size, 
				   jstr->value->elements + jstr->offset,
				   strLen);

        SNI_END_RAW_POINTERS;
    }

    KNI_EndHandles();
    KNI_ReturnInt(result);
}
Ejemplo n.º 12
0
KNIEXPORT KNI_RETURNTYPE_INT
KNIDECL(KNITest_getStringLength) {
    jint result;
    KNI_StartHandles(1);
    KNI_DeclareHandle(str);
    KNI_GetParameterAsObject(1, str);
    result = KNI_GetStringLength(str);
    KNI_EndHandles();
    KNI_ReturnInt(result);
}
Ejemplo n.º 13
0
/**
 * Create fill buffer of javacall_utf16 from the specified Java platform String object.
 *
 * @param java_str pointer to the Java platform String instance
 * @param utf16_str address of buffer to fill
 * @param length length of buffer to fill
 * @return status of the operation
 */
javacall_result jsrop_jstring_to_utf16(jstring java_str,
                    javacall_utf16_string utf16_str, int length) {
    javacall_result res = JAVACALL_FAIL;
    jsize string_length = KNI_GetStringLength(java_str);

    if (string_length <= length) {
        KNI_GetStringRegion(java_str, 0, string_length, (jchar *)utf16_str);
        *(utf16_str + string_length) = 0;
        res = JAVACALL_OK;
    }
    else {
        res = JAVACALL_INVALID_ARGUMENT;
    }
    return res;
}
static jboolean jsr179_jstring_to_utf16(jobject stringObj, javacall_utf16 *string, jint len) {
    if (!KNI_IsNullHandle(stringObj)) {
        if (KNI_GetStringLength(stringObj) > 0) {
            if (JAVACALL_OK != jsrop_jstring_to_utf16(stringObj, string, len)) {
                return KNI_FALSE;
            }
        } else {
            string[0] = (javacall_utf16)0x0000;
            string[1] = (javacall_utf16)0x0000;
        }
    } else {
        string[0] = (javacall_utf16)0x0000;
        string[1] = (javacall_utf16)0xFFFF;
    }
    return KNI_TRUE;
}
KNI_RETURNTYPE_OBJECT
KNIDECL(com_sun_midp_security_Permissions_loadGroupPermissions)
{
    int lines, i1;
	unsigned int str_len;
    void *array;
    jchar jbuff[64];
    char  group_name[64];

    KNI_StartHandles(3);
    KNI_DeclareHandle(members);
    KNI_DeclareHandle(tmpString);
    KNI_DeclareHandle(group);

    KNI_GetParameterAsObject(1, group);
    if (!KNI_IsNullHandle(group)) {
        str_len = KNI_GetStringLength(group);
        if (str_len <= sizeof(group_name)-1) {
            KNI_GetStringRegion(group, 0, str_len, jbuff);
            jchar_to_char(jbuff, group_name, str_len);
            lines = permissions_load_group_permissions(&array, group_name);
            if (lines > 0) {
                char **list = (char**)array;
                SNI_NewArray(SNI_STRING_ARRAY,  lines, members);
                if (KNI_IsNullHandle(members))
                    KNI_ThrowNew(midpOutOfMemoryError, NULL);
                else
                    for (i1 = 0; i1 < lines; i1++) {
                        KNI_NewStringUTF(list[i1], tmpString);
                        KNI_SetObjectArrayElement(members, (jint)i1,
                                                            tmpString);
                    }
                permissions_dealloc(array);
            } else
                KNI_ReleaseHandle(members);  /* set object to NULL */
        }
    } else
        KNI_ThrowNew(midpNullPointerException, "null group parameter");


    KNI_EndHandlesAndReturnObject(members);
}
Ejemplo n.º 16
0
/**
 * Allocates a jchar array and copies all Unicode characters
 * from the given java.lang.String object (specified by jStringHandle)
 * to the allocated array.
 * A pointer to the array is stored in pAddr.
 * The caller MUST free the allocated array with midpFree() after use.
 *
 * If the given java.lang.String is null, NULL_LEN will be returned
 * and pAddr will be set to NULL.
 * If out of memory, OUT_OF_MEM_LEN will be returned
 * and pAddr will be set to NULL.
 *
 * @param jStringHandle KNI Java String object handle
 * @param pAddr points to a jchar* variable receiving the address of the buffer
 *              with a new unicode string. The caller MUST free this memory
 *              using midpFree when it's not needed anymore.
 *              Receives NULL if no memory has been allocated
 *              (error or null string).
 *
 * @return the new unicode string length, or one of the values:
 *          NULL_LEN if the string is null
 *          OUT_OF_MEM_LEN in the case of out-of-memory error
 */
jint midp_jstring_to_address_and_length(jstring jStringHandle, jchar* * pAddr) {
    jchar* result_data;
    jint result_len;

    result_data = NULL;
    result_len  = KNI_GetStringLength(jStringHandle);

    if (result_len < 0) {
        result_len = NULL_LEN;
    } else if (result_len > 0) {
    	result_data = (jchar*)midpMalloc(result_len * sizeof (jchar));
        if (result_data == NULL) {
            result_len = OUT_OF_MEM_LEN;
        } else {
            KNI_GetStringRegion(jStringHandle, 0, result_len, result_data);
        }
    }

    *pAddr = result_data;
    return result_len;
}
Ejemplo n.º 17
0
/**
 * Passes the URL to the native handler. Return true to signal the suite
 * that it must exit before the request can be handled, or false if
 * the request was spawned in the background. Throw ConnectionNotFoundException
 * if we know at the time of this call the request cannot be handled.
 * <p>
 * Java declaration:
 * <pre>
 *     boolean dispatchPlatformRequest(String url)
 *             throws ConnectionNotFoundException
 * </pre>
 * Java parameter:
 * <pre>
 *     url - The URL String to handle
 * </pre>
 */
KNIEXPORT KNI_RETURNTYPE_BOOLEAN
KNIDECL(com_sun_midp_main_CldcPlatformRequest_dispatchPlatformRequest) {
    jsize urlLen;
    char* pszUrl;
    jchar* temp;
    int i;
    int connectionFound = KNI_FALSE;

    KNI_StartHandles(1);
    KNI_DeclareHandle(urlObj);

    KNI_GetParameterAsObject(1, urlObj);
    if (!KNI_IsNullHandle(urlObj)) {
        urlLen = KNI_GetStringLength(urlObj);
        if (urlLen >= 0) {
            pszUrl = (char*)midpMalloc((urlLen + 1) * sizeof (jchar));
            if (pszUrl != NULL) {
                temp = (jchar*)pszUrl;
                KNI_GetStringRegion(urlObj, 0, urlLen, (jchar*)temp);

                /* simply convert the unicode by stripping the high byte */
                for (i = 0; i < urlLen; i++) {
                    pszUrl[i] = (char)temp[i];
                }

                pszUrl[urlLen] = 0;
                connectionFound = platformRequest(pszUrl);
                midpFree(pszUrl);
            }
        }
    }

    KNI_EndHandles();

    if (!connectionFound) {
        KNI_ThrowNew(midpConnectionNotFoundException, NULL);
    }

    KNI_ReturnBoolean(KNI_FALSE);
}
Ejemplo n.º 18
0
/**
 * Create javacall_utf16_string from the specified Java platform String object.
 * The caller is responsible for freeing the created javacall_utf16_string when done.
 *
 * @param java_str pointer to the Java platform String instance. 
 * @param utf16_str address of variable to receive the javacall_utf16_string instance.
 *                  NULL if java_str is null
 * @return status of the operation
 */
javacall_result jsrop_jstring_to_utf16_string(jstring java_str,
                             javacall_utf16_string * utf16_str) {
    javacall_result res = JAVACALL_FAIL;
    if (!KNI_IsNullHandle(java_str)) {
        jsize string_length = KNI_GetStringLength(java_str);
        javacall_utf16_string str_buffer = JAVAME_MALLOC((string_length + 1) *
                                                    sizeof(javacall_utf16));
        if (str_buffer != NULL) {
            KNI_GetStringRegion(java_str, 0, string_length, (jchar *)str_buffer);
            *(str_buffer + string_length) = 0;
            *utf16_str = str_buffer;
            res = JAVACALL_OK;
        }
        else {
            res = JAVACALL_OUT_OF_MEMORY;
        }
    } else {
        *utf16_str = NULL;
        res = JAVACALL_OK;
    }
    return res;
}
Ejemplo n.º 19
0
/**
 * Create pcsl_string from the specified Java String object.
 * The caller is responsible for freeing the created pcsl_string when done.
 *
 * @param java_str pointer to the Java String instance
 * @param pcsl_str pointer to the pcsl_string instance
 * @return status of the operation
 */
pcsl_string_status midp_jstring_to_pcsl_string(jstring java_str,
					       pcsl_string * pcsl_str) {
  if (pcsl_str == NULL) {
    return PCSL_STRING_EINVAL;
  }

  if (KNI_IsNullHandle(java_str)) {
    * pcsl_str = PCSL_STRING_NULL;
    return PCSL_STRING_OK;
  } else {
    const jsize length  = KNI_GetStringLength(java_str);

    if (length < 0) {
      * pcsl_str = PCSL_STRING_NULL;
      return PCSL_STRING_ERR;
    } else if (length == 0) {
      * pcsl_str = PCSL_STRING_EMPTY;
      return PCSL_STRING_OK;
    } else {
      jchar * buffer = pcsl_mem_malloc(length * sizeof(jchar));

      if (buffer == NULL) {
	* pcsl_str = PCSL_STRING_NULL;
	return PCSL_STRING_ENOMEM;
      }

      KNI_GetStringRegion(java_str, 0, length, buffer);

      {
	pcsl_string_status status =
	  pcsl_string_convert_from_utf16(buffer, length, pcsl_str);

	pcsl_mem_free(buffer);

	return status;
      }
    }
  }
}
Ejemplo n.º 20
0
/**
 * Create a new MIDP string from a KNI String object.
 * If KNI String is null, an NULL_LEN length MidpString will be returned.
 * If out of memory a OUT_OF_MEM_LEN length MidpString will be returned.
 * The caller is responsible for calling midpFreeString() after use.
 * This function should not be used directly,
 * use the midpNewString macro.
 *
 * @param jStringHandle KNI Java String object handle
 * @param filename provided by the midpNewString macro
 * @param line provided by the midpNewString macro
 *
 * @return a new unicode string
 */
MidpString midpNewStringImpl(jstring jStringHandle, char* filename,
       int line) {
    MidpString result;

    (void)filename;                               /* Avoid compiler warnings */
    (void)line;                                   /* Avoid compiler warnings */

    result.data = NULL;
    result.len  = KNI_GetStringLength(jStringHandle);

    if (result.len < 0) {
        result.len = NULL_LEN;
    } else if (result.len > 0) {
    	result.data = (jchar*)midpMallocImpl(result.len * sizeof (jchar),
					     filename, line);
	if (result.data == NULL) {
            result.len = OUT_OF_MEM_LEN;
	} else {
	    KNI_GetStringRegion(jStringHandle, 0, result.len, result.data);
	}
    }

    return result;
}
Ejemplo n.º 21
0
/**
 * Copies the contents of fromMsg to the contents of toMsg. Both must be
 * instances of LinkMessage. The toLink object must be an instance of Link.
 * It's filled in if the contents of fromMsg are a Link.  Returns KNI_TRUE if
 * successful, otherwise KNI_FALSE.
 */
static jboolean
copy(jobject fromMsg, jobject toMsg, jobject toLink) {
    jboolean retval;

    KNI_StartHandles(6);
    KNI_DeclareHandle(byteArrayClass);
    KNI_DeclareHandle(stringClass);
    KNI_DeclareHandle(linkClass);
    KNI_DeclareHandle(fromContents);
    KNI_DeclareHandle(newString);
    KNI_DeclareHandle(newByteArray);

    KNI_FindClass("[B", byteArrayClass);
    KNI_FindClass("java/lang/String", stringClass);
    KNI_FindClass("com/sun/midp/links/Link", linkClass);
    getContents(fromMsg, fromContents);
    
    if (KNI_IsInstanceOf(fromContents, byteArrayClass)) {
        /* do a byte array copy */
        jint fromOffset;
        jint fromLength;

        getRange(fromMsg, &fromOffset, &fromLength);

        SNI_NewArray(SNI_BYTE_ARRAY, fromLength, newByteArray);
        if (KNI_IsNullHandle(newByteArray)) {
            retval = KNI_FALSE;
        } else {
            KNI_GetRawArrayRegion(fromContents, fromOffset, fromLength,
                SNI_GetRawArrayPointer(newByteArray));
            setContents(toMsg, newByteArray);
            setRange(toMsg, 0, fromLength);
            retval = KNI_TRUE;
        }
    } else if (KNI_IsInstanceOf(fromContents, stringClass)) {
        /* do a string copy */
        jchar *buf;
        jsize slen = KNI_GetStringLength(fromContents);

        SNI_NewArray(SNI_BYTE_ARRAY, slen*sizeof(jchar), newByteArray);

        if (KNI_IsNullHandle(newByteArray)) {
            retval = KNI_FALSE;
        } else {
            buf = SNI_GetRawArrayPointer(newByteArray);
            KNI_GetStringRegion(fromContents, 0, slen, buf);
            KNI_NewString(buf, slen, newString);
            setContents(toMsg, newString);
            retval = KNI_TRUE;
        }
    } else if (KNI_IsInstanceOf(fromContents, linkClass)) {
        /* copy the link */
        rendezvous *rp = getNativePointer(fromContents);
        setNativePointer(toLink, rp);
        rp_incref(rp);
        setContents(toMsg, toLink);
        retval = KNI_TRUE;
    } else {
        retval = KNI_FALSE;
    }

    KNI_EndHandles();
    return retval;
}
Ejemplo n.º 22
0
/**
 * Sends an SMS message.
 *
 * @param handle The handle to the open SMS connection.
 * @param messageType The type of message: binary or text.
 * @param address The SMS-formatted address.
 * @param destPort The port number of the recipient.
 * @param sourcePort The port number of the sender.
 * @param messageBuffer The buffer containing the SMS message.
 *
 * @return Always returns <code>0</code>.
 */
KNIEXPORT KNI_RETURNTYPE_INT
KNIDECL(com_sun_midp_io_j2me_sms_Protocol_send0) {
    WMA_STATUS status = WMA_ERR;
    jint messageLength = 0;
    jint messageType;
    jint sourcePort;
    jint destPort;
    jint handle;
    jint msAddress_len;
    jchar* msAddress_data;
    int i;
    unsigned char *pAddress = NULL;
    unsigned char *pMessageBuffer = NULL;
    jboolean stillWaiting = KNI_FALSE;
    jboolean trySend = KNI_FALSE;
    void *pdContext = NULL;
#if ENABLE_REENTRY
    MidpReentryData *info;
    jsr120_sms_message_state_data *messageStateData = NULL;
#endif
    jboolean isOpen;

    KNI_StartHandles(4);

    KNI_DeclareHandle(this);
    KNI_DeclareHandle(thisClass);
    KNI_GetThisPointer(this);
    KNI_GetObjectClass(this, thisClass);
    isOpen = KNI_GetBooleanField(this, KNI_GetFieldID(thisClass, "open", "Z"));
    
    if (isOpen) { /* No close in progress */
        KNI_DeclareHandle(messageBuffer);
        KNI_DeclareHandle(address);

        handle = KNI_GetParameterAsInt(1);
        messageType = KNI_GetParameterAsInt(2);
        KNI_GetParameterAsObject(3, address);
        destPort = KNI_GetParameterAsInt(4);
        sourcePort = KNI_GetParameterAsInt(5);
        KNI_GetParameterAsObject(6, messageBuffer);

        do {
#if ENABLE_REENTRY
            info = (MidpReentryData*)SNI_GetReentryData(NULL);
            if (info == NULL) {	  /* First invocation. */
#endif
                if (KNI_IsNullHandle(address)) {

                    KNI_ThrowNew(midpIllegalArgumentException, NULL);
                    break;
                } else {
                    msAddress_len = KNI_GetStringLength(address);
                    msAddress_data = (jchar *)pcsl_mem_malloc(msAddress_len * sizeof (jchar));
                    if (msAddress_data == NULL) {

                        KNI_ThrowNew(midpOutOfMemoryError, NULL);
                        break;
                    } else {

                        KNI_GetStringRegion(address, 0, msAddress_len, msAddress_data);
                        pAddress = (unsigned char*)pcsl_mem_malloc(msAddress_len + 1);
                        if (pAddress != NULL) {
                            for (i = 0; i < msAddress_len; i++) {
                                pAddress[i] = (unsigned char)msAddress_data[i];
                            }	
                            pAddress[msAddress_len] = 0;
                        }
                        //pAddress = (unsigned char *)midpJcharsToChars(msAddress);
                        pcsl_mem_free(msAddress_data);

                        if (!KNI_IsNullHandle(messageBuffer)) {
                            messageLength = KNI_GetArrayLength(messageBuffer);
                        }
                        if (messageLength >= 0) {
                            if (messageLength > 0) {
                                pMessageBuffer = (unsigned char *)pcsl_mem_malloc(messageLength);
                                memset(pMessageBuffer, 0, messageLength);
                                KNI_GetRawArrayRegion(messageBuffer, 0, messageLength,
                                                      (jbyte *)pMessageBuffer);
                            }

                            trySend = KNI_TRUE;
                        }
                    }
                }
#if ENABLE_REENTRY
            } else { /* Reinvocation after unblocking the thread. */

                if (info->pResult == NULL) {
                    /* waiting for mms_send_completed event */
                    if (info->status == WMA_ERR) {
                        KNI_ThrowNew(midpInterruptedIOException, "Sending SMS");
                    }
                    break;
                }
                messageStateData = info->pResult;
                pMessageBuffer = messageStateData->pMessageBuffer;
                pAddress = messageStateData->pAddress;
                pdContext = messageStateData->pdContext;

                trySend = KNI_TRUE;
            }
#endif

            if (trySend == KNI_TRUE) {
                /* send message. */
                status = jsr120_send_sms((jchar)messageType,
                                         pAddress,
                                         pMessageBuffer,
                                         (jchar)messageLength,
                                         (jchar)sourcePort,
                                         (jchar)destPort,
                                         handle,
                                         &pdContext);

                if (status == WMA_ERR) {
                    KNI_ThrowNew(midpIOException, "Sending SMS");
                    break;
                } 
#if ENABLE_REENTRY
                else if (status == WMA_NET_WOULDBLOCK) {
                    if (messageStateData == NULL) {
                        messageStateData =
                            (jsr120_sms_message_state_data *)pcsl_mem_malloc(
                                sizeof(*messageStateData));
                        messageStateData->pMessageBuffer = pMessageBuffer;
                        messageStateData->pAddress = pAddress;
                    }

                    messageStateData->pdContext = pdContext;

                    /* Block calling Java Thread. */
                    midp_thread_wait(WMA_SMS_WRITE_SIGNAL, handle,
                                     messageStateData);

                    stillWaiting = KNI_TRUE;
                    break;
                } else {
                    /* waiting for sms_send_completed event */
                    midp_thread_wait(WMA_SMS_WRITE_SIGNAL, handle, NULL);
                }
#endif
            }
        } while (0);

        if (!stillWaiting) {
            pcsl_mem_free(pMessageBuffer);
            pcsl_mem_free(pAddress);
        }
    }

    KNI_EndHandles();

    KNI_ReturnInt(0); /* currently ignored. */
}
Ejemplo n.º 23
0
/**
 * Open a serial port by system dependent device name.
 *
 * @param name device name of the port
 * @param baud baud rate to set the port at
 * @param flags options for the serial port
 *
 * @return handle to a native serial port
 *
 * @exception  IOException  if an I/O error occurs.
 */
KNIEXPORT KNI_RETURNTYPE_INT
    Java_com_sun_midp_io_j2me_comm_Protocol_native_1openByName() {

    int    flags = (int)KNI_GetParameterAsInt(3);
    int    baud = (int)KNI_GetParameterAsInt(2);
    int    nameLen;
    char   szName[MAX_NAME_LEN];
    jchar* temp;
    int    hPort = (int)INVALID_HANDLE;
    int    i;
    int status = PCSL_NET_IOERROR;
    void* context = NULL;
    MidpReentryData* info;

    KNI_StartHandles(1);
    KNI_DeclareHandle(nameObject);
    KNI_GetParameterAsObject(1, nameObject);
    
    info = (MidpReentryData*)SNI_GetReentryData(NULL);
    if (info == NULL) {
        nameLen = KNI_GetStringLength(nameObject);
        if (nameLen > MAX_NAME_LEN) {
            midp_snprintf(gKNIBuffer, KNI_BUFFER_SIZE,
                "Serial device name has wrong length: %d\n", nameLen);
            REPORT_INFO1(LC_PROTOCOL, "%s\n", gKNIBuffer);
            KNI_ThrowNew(midpIllegalArgumentException, gKNIBuffer);
        } else {
            temp = (jchar*)szName;
            KNI_GetStringRegion(nameObject, 0, nameLen, temp);

            /* device names are in ASCII */
            for (i = 0; i < nameLen; i++) {
                szName[i] = (char)temp[i];
            }
            szName[nameLen] = 0;
		
            status = openPortByNameStart(szName, baud, flags, &hPort, &context);
        }
    } else {
        /* reinvocation */
        hPort = info->descriptor;
        context = info->pResult;
        status = openPortByNameFinish(szName, baud, flags, &hPort, context);	
    }

    switch (status) {
        case PCSL_NET_SUCCESS:			
            /* do nothing and return normally */
            break;
        case PCSL_NET_INTERRUPTED:			
            midp_snprintf(gKNIBuffer, KNI_BUFFER_SIZE,
                "Opening port %s has been interrupted\n", szName);
            REPORT_INFO1(LC_PROTOCOL, "%s\n", gKNIBuffer);
            KNI_ThrowNew(midpInterruptedIOException, gKNIBuffer);
            break;
        case PCSL_NET_WOULDBLOCK:			
            midp_thread_wait(COMM_OPEN_SIGNAL, hPort, context);
            break;
        default:	   
            midp_snprintf(gKNIBuffer, KNI_BUFFER_SIZE,
                "Opening port %s was failed\n", szName);
            REPORT_INFO1(LC_PROTOCOL, "%s\n", gKNIBuffer);
            KNI_ThrowNew(midpIOException, gKNIBuffer);
    }

    KNI_EndHandles();
    KNI_ReturnInt((jint)hPort);
}
Ejemplo n.º 24
0
KNIEXPORT KNI_RETURNTYPE_INT
KNIDECL(com_sun_mmedia_DefaultConfiguration_nListProtocolsOpen) {
    const javacall_media_configuration *cfg;
    javacall_media_caps *caps;
    ListIterator *iterator = NULL;
    javacall_int32 proto_mask = 0;
    javacall_bool supportDeviceProtocol = JAVACALL_FALSE;
    char *p = NULL;
    
    /* stack buffers. Trying to avoid malloc if a string is not big */
    jchar stack_string16_buffer[MAX_PROTOCOLNAME_LEN], *string16 = NULL;
    char stack_string_buffer[MAX_PROTOCOLNAME_LEN], *mime = NULL;
    
    KNI_StartHandles(1);
    KNI_DeclareHandle(stringObj);
    KNI_GetParameterAsObject(1, stringObj);

    do {
        if (KNI_IsNullHandle(stringObj)) {
            mime = NULL;
        } else {
            unsigned int len = KNI_GetStringLength(stringObj);
            /* if the string is longer than the stack buffer try to malloc it */
            if (len >= sizeof stack_string16_buffer / sizeof stack_string16_buffer[0]) {
                string16 = MMP_MALLOC((len + 1) * sizeof *string16);
                if (string16 == NULL) {
                    KNI_ThrowNew(jsropOutOfMemoryError, NULL);
                    break;
                }
            } else {
                string16 = stack_string16_buffer;
            }
            if (len >= sizeof stack_string_buffer / sizeof stack_string_buffer[0]) {
                mime = MMP_MALLOC(len + 1);
                if (mime == NULL) {
                    KNI_ThrowNew(jsropOutOfMemoryError, NULL);
                    break;
                }
            } else {
                mime = stack_string_buffer;
            }
            KNI_GetStringRegion(stringObj, 0, len, string16);
            if (simple_jcharString_to_asciiString(string16, len, mime, len + 1) != JAVACALL_OK) {
                KNI_ThrowNew(jsropIllegalArgumentException, "Illegal character in MIME type name");
                break;
            }
        }
        if (javacall_media_get_configuration(&cfg) != JAVACALL_OK) {
            KNI_ThrowNew(jsropRuntimeException, "Couldn't get MMAPI configuration");
            break;
        }
        
        if ((mime == NULL || !javautil_stricmp(mime, MIME_AUDIO_MIDI)) && 
                    cfg->supportDeviceMIDI) {
            supportDeviceProtocol = JAVACALL_TRUE;
        }
        if (!supportDeviceProtocol && 
                    (mime == NULL || !javautil_stricmp(mime, MIME_AUDIO_TONE)) && 
                    cfg->supportDeviceTone) {
            supportDeviceProtocol = JAVACALL_TRUE;
        }
        /* trying to find given MIME type among caps->contentTypes */
        for (caps = cfg->mediaCaps; caps != NULL && caps->mediaFormat != NULL; caps++) {
            if (caps->wholeProtocols != 0 || caps->streamingProtocols != 0) {
                if (mime != NULL) {
                    char *s;
                    int m_len = strlen(mime);
                    
                    for (p = (char *)caps->contentTypes; p != NULL; p = s) {
                        int p_len;
                        
                        while (*p == ' ') {
                            p++;
                        }
                        if ((s = strchr(p, ' ')) != NULL) {
                            p_len = (int)(s - p);
                        } else {
                            p_len = strlen(p);
                        }
                        if (p_len == m_len && !javautil_strnicmp(mime, p, p_len)) {
                            break;
                        }
                    }
                }
                if (mime == NULL || p != NULL) {
                    proto_mask |= caps->wholeProtocols;
                    proto_mask |= caps->streamingProtocols;
                }
            }
        }
        
        if (proto_mask != 0 || supportDeviceProtocol) {
            /* some protocols were found */
            unsigned int i;
            unsigned int len = 0;
            
            /* trying to resolve protocol names: calculating needed memory */
            for (i = 0; i < sizeof protocolNames / sizeof protocolNames[0]; i++) {
                if ((protocolNames[i].proto_mask & proto_mask) != 0 && protocolNames[i].proto_name != NULL) {
                    len += strlen(protocolNames[i].proto_name) + 1; /* +1 for space char */
                }
            }
            if (supportDeviceProtocol) {
                len += strlen(DEVICE_PROTOCOL) + 1;
            }
            if (len == 0) {
                /* Protocol wasn't found in the protocol name table */
                KNI_ThrowNew(jsropRuntimeException, "Incorrect MMAPI configuration: missing protocol name");
                break;
            }
         
            iterator = (ListIterator*)MMP_MALLOC(
                sizeof *iterator + len); /* zero terminator instead of last space */
            if (iterator == NULL) {
                KNI_ThrowNew(jsropOutOfMemoryError, NULL);
                break;
            }
        
            /* initialize the iterator */
            iterator->current = iterator->list;
        
            /* building the list of protocols */
            p = iterator->list;
            for (i = 0; i < sizeof protocolNames / sizeof protocolNames[0]; i++) {
                if ((protocolNames[i].proto_mask & proto_mask) != 0 && protocolNames[i].proto_name != NULL) {
                    int proto_len = strlen(protocolNames[i].proto_name);
                    memcpy(p, protocolNames[i].proto_name, proto_len);
                    p += proto_len;
                    *p++ = ' ';
                }
            }
            if (supportDeviceProtocol) {
                int proto_len = strlen(DEVICE_PROTOCOL);
                memcpy(p, DEVICE_PROTOCOL, proto_len);
                p += proto_len;
                *p++ = ' ';
            }
            p--; *p = '\0'; /* replace last space with zero */
        } else {
            /* No protocols were found for provided MIME type. Return 0 */
            break;
        }
        mmapi_string_delete_duplicates(iterator->list);
    } while (0);

    /* freeing buffers */
    if (mime != NULL && mime != stack_string_buffer) {
        MMP_FREE(mime);
    }
    if (string16 != NULL && string16 != stack_string16_buffer) {
        MMP_FREE(string16);
    }
    KNI_EndHandles();
    KNI_ReturnInt((jint)iterator); 
}
Ejemplo n.º 25
0
KNIEXPORT KNI_RETURNTYPE_INT
KNIDECL(com_sun_mmedia_DefaultConfiguration_nListContentTypesOpen) {
    javacall_int32 proto_mask = 0;
    javacall_bool deviceProtocol = JAVACALL_FALSE;
    const javacall_media_configuration *cfg;
    const javacall_media_caps *caps;
    unsigned int len;
    ListIterator *iterator = NULL;
    char *p;
    
    /* stack buffers. Trying to avoid malloc if a string is not big */
    jchar stack_string16_buffer[MAX_PROTOCOLNAME_LEN], *string16 = NULL;
    char stack_string_buffer[MAX_PROTOCOLNAME_LEN], *proto = NULL;
    
    KNI_StartHandles(1);
    KNI_DeclareHandle(stringObj);
    KNI_GetParameterAsObject(1, stringObj);

    do {
        if (KNI_IsNullHandle(stringObj)) {
            proto = NULL;
        } else {
            len = KNI_GetStringLength(stringObj);
            /* if the string is longer than the stack buffer try to malloc it */
            if (len >= sizeof stack_string16_buffer / sizeof stack_string16_buffer[0]) {
                string16 = MMP_MALLOC((len + 1) * sizeof *string16);
                if (string16 == NULL) {
                    KNI_ThrowNew(jsropOutOfMemoryError, NULL);
                    break;
                }
            } else {
                string16 = stack_string16_buffer;
            }
            if (len >= sizeof stack_string_buffer) {
                proto = MMP_MALLOC(len + 1);
                if (proto == NULL) {
                    KNI_ThrowNew(jsropOutOfMemoryError, NULL);
                    break;
                }
            } else {
                proto = stack_string_buffer;
            }
            KNI_GetStringRegion(stringObj, 0, len, string16);
            if (simple_jcharString_to_asciiString(string16, len, proto, len + 1) != JAVACALL_OK) {
                KNI_ThrowNew(jsropIllegalArgumentException, "Illegal character in protocol name");
                break;
            }
        }
        if (proto != NULL) {
            unsigned int i;
            
            /* trying to find protocol by name */
            for (i = 0; i < sizeof protocolNames / sizeof protocolNames[0]; i++) {
                if (protocolNames[i].proto_name != NULL && !javautil_stricmp(protocolNames[i].proto_name, proto)) {
                    proto_mask |= protocolNames[i].proto_mask;
                }
            }
            if (!javautil_stricmp(proto, DEVICE_PROTOCOL)) {
                deviceProtocol = JAVACALL_TRUE;
            }
        }
        if (proto != NULL && proto_mask == 0 && !deviceProtocol) {
            /* Requested protocol wasn't found. Return 0 */
            break;
        }
        
        if (javacall_media_get_configuration(&cfg) != JAVACALL_OK) {
            KNI_ThrowNew(jsropRuntimeException, "Couldn't get MMAPI configuration");
            break;
        }
        
        /* how long will be list of content types? */
        len = 0;
        for (caps = cfg->mediaCaps; caps != NULL && caps->mediaFormat != NULL; caps++) {
            if (proto == NULL || (caps->wholeProtocols & proto_mask) != 0
                    || (caps->streamingProtocols & proto_mask) != 0) {
                len += strlen(caps->contentTypes) + 1; /* +1 for space char */
            }
        }
        if (proto == NULL || deviceProtocol) {
            if (cfg->supportDeviceMIDI) {
                len += strlen(MIME_AUDIO_MIDI) + 1;
            }
            if (cfg->supportDeviceTone) {
                len += strlen(MIME_AUDIO_TONE) + 1;
            }
        }
     
        if (len == 0) {
            /* No MIME types were found for provided protocol. Return 0 */
            break;
        }
     
        iterator = (ListIterator*)MMP_MALLOC(
            sizeof *iterator + len); /* zero terminator instead of last space */
        if (iterator == NULL) {
            KNI_ThrowNew(jsropOutOfMemoryError, NULL);
            break;
        }
    
        /* initialize the iterator */
        iterator->current = iterator->list;
    
        /* filling the list of content types */
        p = iterator->list;
        for (caps = cfg->mediaCaps; caps != NULL && caps->mediaFormat != NULL; caps++) {
            if (proto == NULL || (caps->wholeProtocols & proto_mask) != 0
                    || (caps->streamingProtocols & proto_mask) != 0) {
                int types_len = strlen(caps->contentTypes);
                memcpy(p, caps->contentTypes, types_len);
                p += types_len;
                *p++ = ' ';
            }
        }
        if (proto == NULL || deviceProtocol) {
            int types_len;
            if (cfg->supportDeviceMIDI) {
                types_len = strlen(MIME_AUDIO_MIDI);
                memcpy(p, MIME_AUDIO_MIDI, types_len);
                p += types_len;
                *p++ = ' ';
            }
            if (cfg->supportDeviceTone) {
                types_len = strlen(MIME_AUDIO_TONE);
                memcpy(p, MIME_AUDIO_TONE, types_len);
                p += types_len;
                *p++ = ' ';
            }
        }
        p--; *p = '\0'; /* replace last space with zero */
        
        mmapi_string_delete_duplicates(iterator->list);
    } while (0);

    /* freeing buffers */
    if (proto != NULL && proto != stack_string_buffer) {
        MMP_FREE(proto);
    }
    if (string16 != NULL && string16 != stack_string16_buffer) {
        MMP_FREE(string16);
    }
    KNI_EndHandles();
    KNI_ReturnInt((jint)iterator); 
}
/**
 * (Internal) Fill landmark structure from the Landmark Object.
 */
static jboolean fill_landmark(jobject landmarkObj, javacall_landmarkstore_landmark *landmark, 
                                jobject stringObj) {
    /* Fill javacall_landmarkstore_landmark structure */
    /* landmark.name */
    KNI_GetObjectField(landmarkObj, landmarkImplFieldID.name, stringObj);
    if (!KNI_IsNullHandle(stringObj) && 
        KNI_GetStringLength(stringObj)<=JAVACALL_LANDMARKSTORE_MAX_LANDMARK_NAME) {
        if (JAVACALL_OK != 
                jsrop_jstring_to_utf16(stringObj, landmark->name, JAVACALL_LANDMARKSTORE_MAX_LANDMARK_NAME)) {
            return KNI_FALSE;
        }
    } else {
        return KNI_FALSE;
    }
    /* landmark.description */
    KNI_GetObjectField(landmarkObj, landmarkImplFieldID.description, stringObj);
    jsr179_jstring_to_utf16(stringObj, landmark->description, JAVACALL_LANDMARKSTORE_MAX_LANDMARK_DESCRIPTION);

    landmark->isValidCoordinate = KNI_GetBooleanField(landmarkObj, 
                                landmarkImplFieldID.isCoordinates);
    if (landmark->isValidCoordinate) {
        /* landmark.latitude */
        landmark->latitude = KNI_GetDoubleField(landmarkObj, 
                                    landmarkImplFieldID.latitude);
        /* landmark.longitude */
        landmark->longitude = KNI_GetDoubleField(landmarkObj, 
                                    landmarkImplFieldID.longitude);
        /* landmark.altitude */
        landmark->altitude = KNI_GetFloatField(landmarkObj, 
                                    landmarkImplFieldID.altitude);
        /* landmark.horizontalAccuracy */
        landmark->horizontalAccuracy = KNI_GetFloatField(landmarkObj, 
                                    landmarkImplFieldID.horizontalAccuracy);
        /* landmark.altitude */
        landmark->verticalAccuracy = KNI_GetFloatField(landmarkObj, 
                                    landmarkImplFieldID.verticalAccuracy);
    }

    /* AddressInfo */
    landmark->addressInfoFieldNumber = KNI_GetIntField(landmarkObj, 
            landmarkImplFieldID.numAddressInfoFields);
    if (landmark->addressInfoFieldNumber > 0) {
            jint counter = 0;
            /* AddressInfo_EXTENSION */
            if ((counter < landmark->addressInfoFieldNumber) &&
                (fill_adressInfoField(landmarkObj, 
                            landmarkImplFieldID.AddressInfo_EXTENSION,
                            stringObj, 
                            &landmark->fields[counter],
                            JAVACALL_LOCATION_ADDRESSINFO_EXTENSION) == KNI_TRUE)) {
                counter++;
            }
            /* AddressInfo_STREET */
            if ((counter < landmark->addressInfoFieldNumber) &&
                (fill_adressInfoField(landmarkObj, 
                            landmarkImplFieldID.AddressInfo_STREET,
                            stringObj, 
                            &landmark->fields[counter],
                            JAVACALL_LOCATION_ADDRESSINFO_STREET) == KNI_TRUE)) {
                counter++;
            }
            /* AddressInfo_POSTAL_CODE */
            if ((counter < landmark->addressInfoFieldNumber) &&
                (fill_adressInfoField(landmarkObj, 
                            landmarkImplFieldID.AddressInfo_POSTAL_CODE,
                            stringObj, 
                            &landmark->fields[counter],
                            JAVACALL_LOCATION_ADDRESSINFO_POSTAL_CODE) == KNI_TRUE)) {
                counter++;
            }
            /* AddressInfo_CITY */
            if ((counter < landmark->addressInfoFieldNumber) &&
                (fill_adressInfoField(landmarkObj, 
                            landmarkImplFieldID.AddressInfo_CITY,
                            stringObj, 
                            &landmark->fields[counter],
                            JAVACALL_LOCATION_ADDRESSINFO_CITY) == KNI_TRUE)) {
                counter++;
            }
            /* AddressInfo_COUNTY */
            if ((counter < landmark->addressInfoFieldNumber) &&
                (fill_adressInfoField(landmarkObj, 
                            landmarkImplFieldID.AddressInfo_COUNTY,
                            stringObj, 
                            &landmark->fields[counter],
                            JAVACALL_LOCATION_ADDRESSINFO_COUNTY) == KNI_TRUE)) {
                counter++;
            }
            /* AddressInfo_STATE */
            if ((counter < landmark->addressInfoFieldNumber) &&
                (fill_adressInfoField(landmarkObj, 
                            landmarkImplFieldID.AddressInfo_STATE,
                            stringObj, 
                            &landmark->fields[counter],
                            JAVACALL_LOCATION_ADDRESSINFO_STATE) == KNI_TRUE)) {
                counter++;
            }
            /* AddressInfo_COUNTRY */
            if ((counter < landmark->addressInfoFieldNumber) &&
                (fill_adressInfoField(landmarkObj, 
                            landmarkImplFieldID.AddressInfo_COUNTRY,
                            stringObj, 
                            &landmark->fields[counter],
                            JAVACALL_LOCATION_ADDRESSINFO_COUNTRY) == KNI_TRUE)) {
                counter++;
            }
            /* AddressInfo_COUNTRY_CODE */
            if ((counter < landmark->addressInfoFieldNumber) &&
                (fill_adressInfoField(landmarkObj, 
                            landmarkImplFieldID.AddressInfo_COUNTRY_CODE,
                            stringObj, 
                            &landmark->fields[counter],
                            JAVACALL_LOCATION_ADDRESSINFO_COUNTRY_CODE) == KNI_TRUE)) {
                counter++;
            }
            /* AddressInfo_DISTRICT */
            if ((counter < landmark->addressInfoFieldNumber) &&
                (fill_adressInfoField(landmarkObj, 
                            landmarkImplFieldID.AddressInfo_DISTRICT,
                            stringObj, 
                            &landmark->fields[counter],
                            JAVACALL_LOCATION_ADDRESSINFO_DISTRICT) == KNI_TRUE)) {
                counter++;
            }
            /* AddressInfo_BUILDING_NAME */
            if ((counter < landmark->addressInfoFieldNumber) &&
                (fill_adressInfoField(landmarkObj, 
                            landmarkImplFieldID.AddressInfo_BUILDING_NAME,
                            stringObj, 
                            &landmark->fields[counter],
                            JAVACALL_LOCATION_ADDRESSINFO_BUILDING_NAME) == KNI_TRUE)) {
                counter++;
            }
            /* AddressInfo_BUILDING_FLOOR */
            if ((counter < landmark->addressInfoFieldNumber) &&
                (fill_adressInfoField(landmarkObj, 
                            landmarkImplFieldID.AddressInfo_BUILDING_FLOOR,
                            stringObj, 
                            &landmark->fields[counter],
                            JAVACALL_LOCATION_ADDRESSINFO_BUILDING_FLOOR) == KNI_TRUE)) {
                counter++;
            }
            /* AddressInfo_BUILDING_ROOM */
            if ((counter < landmark->addressInfoFieldNumber) &&
                (fill_adressInfoField(landmarkObj, 
                            landmarkImplFieldID.AddressInfo_BUILDING_ROOM,
                            stringObj, 
                            &landmark->fields[counter],
                            JAVACALL_LOCATION_ADDRESSINFO_BUILDING_ROOM) == KNI_TRUE)) {
                counter++;
            }
            /* AddressInfo_BUILDING_ZONE */
            if ((counter < landmark->addressInfoFieldNumber) &&
                (fill_adressInfoField(landmarkObj, 
                            landmarkImplFieldID.AddressInfo_BUILDING_ZONE,
                            stringObj, 
                            &landmark->fields[counter],
                            JAVACALL_LOCATION_ADDRESSINFO_BUILDING_ZONE) == KNI_TRUE)) {
                counter++;
            }
            /* AddressInfo_CROSSING1 */
            if ((counter < landmark->addressInfoFieldNumber) &&
                (fill_adressInfoField(landmarkObj, 
                            landmarkImplFieldID.AddressInfo_CROSSING1,
                            stringObj, 
                            &landmark->fields[counter],
                            JAVACALL_LOCATION_ADDRESSINFO_CROSSING1) == KNI_TRUE)) {
                counter++;
            }
            /* AddressInfo_CROSSING2 */
            if ((counter < landmark->addressInfoFieldNumber) &&
                (fill_adressInfoField(landmarkObj, 
                            landmarkImplFieldID.AddressInfo_CROSSING2,
                            stringObj, 
                            &landmark->fields[counter],
                            JAVACALL_LOCATION_ADDRESSINFO_CROSSING2) == KNI_TRUE)) {
                counter++;
            }
            /* AddressInfo_URL */
            if ((counter < landmark->addressInfoFieldNumber) &&
                (fill_adressInfoField(landmarkObj, 
                            landmarkImplFieldID.AddressInfo_URL,
                            stringObj, 
                            &landmark->fields[counter],
                            JAVACALL_LOCATION_ADDRESSINFO_URL) == KNI_TRUE)) {
                counter++;
            }
            /* AddressInfo_PHONE_NUMBER */
            if ((counter < landmark->addressInfoFieldNumber) &&
                (fill_adressInfoField(landmarkObj, 
                            landmarkImplFieldID.AddressInfo_PHONE_NUMBER,
                            stringObj, 
                            &landmark->fields[counter],
                            JAVACALL_LOCATION_ADDRESSINFO_PHONE_NUMBER) == KNI_TRUE)) {
                counter++;
            }
    }
    return KNI_TRUE;
}