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); }
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(); }
/** * 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 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); }
/* 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) {
/** * 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); }
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); } }
/** * 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); }
/** * 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); }
KNIEXPORT KNI_RETURNTYPE_OBJECT KNIDECL(KNITest_getStringRegion) { jchar buf[20]; jint offset = KNI_GetParameterAsInt(2); jint len = KNI_GetParameterAsInt(3); KNI_StartHandles(2); KNI_DeclareHandle(str); KNI_DeclareHandle(newStr); KNI_GetParameterAsObject(1, str); KNI_GetStringRegion(str, offset, len, buf); KNI_NewString(buf, len, newStr); KNI_EndHandlesAndReturnObject(newStr); }
/** * 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; }
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); }
/** * 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; }
/** * 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); }
/** * 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; }
/** * 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; } } } }
/** * 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; }
/** * 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); }
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); }
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); }
/** * 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; }
/** * 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. */ }