/**
* Delete the given CBS message. The memory used by the message will be
* released to the memory pool.
*
* @param message The message that will have its memory freed.
*/
void jsr120_cbs_delete_msg(CbsMessage* msg) {
if (msg != NULL) {
pcsl_mem_free(msg->msgBuffer);
pcsl_mem_free(msg);
}
}
/**
* Free all of the memory used by a stored invocation.
*
* @param stored pointer to an StoredInvoc.
*/
static void invocFree(StoredInvoc* invoc) {
/*
* An error occurred allocating memory; release all of the unused
* Strings, free the structure and throw OutOfMemoryError.
*/
if (invoc != NULL) {
if (invoc->args != NULL) {
/* Free the argument array and strings, if any */
pcsl_string* args = invoc->args;
int i = invoc->argsLen;
while (i--) {
pcsl_string_free(args++);
}
pcsl_mem_free(invoc->args);
}
if (invoc->data != NULL) {
pcsl_mem_free(invoc->data);
}
pcsl_string_free(&invoc->url);
pcsl_string_free(&invoc->type);
pcsl_string_free(&invoc->action);
pcsl_string_free(&invoc->ID);
pcsl_string_free(&invoc->classname);
pcsl_string_free(&invoc->invokingAuthority);
pcsl_string_free(&invoc->invokingAppName);
pcsl_string_free(&invoc->invokingClassname);
pcsl_string_free(&invoc->invokingID);
pcsl_string_free(&invoc->username);
pcsl_string_free(&invoc->password);
pcsl_mem_free(invoc);
}
}
/**
* Delete the given SMS message. The memory used by the message will be
* released to the memory pool.
*
* @param message The message that will have its memory freed.
*/
void jsr120_sms_delete_msg(SmsMessage* sms) {
if (sms) {
pcsl_mem_free(sms->msgAddr);
pcsl_mem_free(sms->msgBuffer);
pcsl_mem_free(sms);
}
}
/**
* Delete the given CBS message. The memory used by the message will be
* released to the memory pool.
*
* @param message The message that will have its memory freed.
*/
void jsr120_cbs_delete_msg(CbsMessage* message) {
if (message != NULL) {
pcsl_mem_free(message->msgBuffer);
pcsl_mem_free(message);
}
}
/**
* Delete the given MMS message and release the memory used by the message to
* the memory pool.
*
* @param msg The message that will have its memory freed.
*/
void jsr205_mms_delete_msg(MmsMessage* msg) {
if (msg != NULL) {
pcsl_mem_free(msg->fromAddress);
pcsl_mem_free(msg->appID);
pcsl_mem_free(msg->replyToAppID);
pcsl_mem_free(msg->msgBuffer);
pcsl_mem_free(msg);
}
}
void
JPEG_To_RGB_free(void *info)
{
struct jpeg_decompress_struct *cinfo =
(struct jpeg_decompress_struct *) info;
jm_jpeg_destroy_decompress(cinfo);
pcsl_mem_free(((jmf_src_data*)cinfo->client_data)->jerr);
pcsl_mem_free(cinfo->client_data);
pcsl_mem_free(cinfo->src);
pcsl_mem_free(cinfo);
}
void bt_push_shutdown()
{
bt_push_t *push = g_registry;
REPORT_INFO(LC_PUSH, "Shutting down Bluetooth PushRegistry.");
while (push != NULL) {
bt_push_t *next = push->next;
javacall_bt_sddb_remove_record(push->record.id);
pcsl_mem_free(push->record.data);
close_all(push);
pcsl_mem_free(push);
push = next;
}
g_registry = NULL;
javacall_bt_sddb_finalize();
}
/**
* Perform a platform-defined procedure for obtaining random bytes and
* store the obtained bytes into b, starting from index 0.
* (see IETF RFC 1750, Randomness Recommendations for Security,
* http://www.ietf.org/rfc/rfc1750.txt)
* @param b array that receives random bytes
* @param nbytes the number of random bytes to receive, must not be less than size of b
* @return the number of actually obtained random bytes, -1 in case of an error
*/
KNIEXPORT KNI_RETURNTYPE_BOOLEAN
KNIDECL(com_sun_midp_crypto_PRand_getRandomBytes) {
jint size;
jboolean res = KNI_FALSE;
unsigned char* buffer;
KNI_StartHandles(1);
KNI_DeclareHandle(hBytes);
KNI_GetParameterAsObject(1, hBytes);
size = KNI_GetParameterAsInt(2);
buffer = pcsl_mem_malloc(size);
if (0 == buffer) {
KNI_ThrowNew(midpOutOfMemoryError, NULL);
} else {
int i;
res = get_random_bytes_port(buffer, size);
for(i=0; i<size; i++) {
KNI_SetByteArrayElement(hBytes,i,(jbyte)buffer[i]);
}
pcsl_mem_free(buffer);
}
KNI_EndHandles();
KNI_ReturnBoolean(res);
}
/**
* Unregisters the given listener of the specified type.
*
* @param fn_callback pointer to the listener function
* @param listenerType type of events this listener listens for
*
* @return error code: ALL_OK if successful,
* NOT_FOUND if the listener was not found
*/
MIDPError
remove_event_listener_impl(void* fn_callback, int listenerType) {
GenericListener *pListener, *pPrev = NULL;
int index;
index = get_listeners_list_index(listenerType);
if (index < 0) {
return NOT_FOUND;
}
pListener = g_pRegisteredListeners[index];
while (pListener) {
if (pListener->fn_callback == fn_callback) {
if (pPrev) {
pPrev->pNext = pListener->pNext;
} else {
g_pRegisteredListeners[index] = pListener->pNext;
if (g_pRegisteredListeners[index] == NULL) {
remove_listener_type(listenerType);
}
}
pcsl_mem_free(pListener);
return ALL_OK;
}
pPrev = pListener;
pListener = pListener->pNext;
}
return NOT_FOUND;
}
javacall_result bt_push_unregister_url(const char *url)
{
bt_port_t port;
bt_push_t *push, *prev;
REPORT_INFO(LC_PUSH, "Bluetooth PushRegistry URL un-registration:");
REPORT_INFO1(LC_PUSH, "%s", url);
bt_push_parse_url(url, &port, NULL);
push = find_push(&port, &prev);
if (push == NULL) {
return JAVACALL_FAIL;
}
/* remove the service record */
javacall_bt_sddb_remove_record(push->record.id);
/* close server and client connections */
close_all(push);
/* remove the entry */
if (prev != NULL) {
prev->next = push->next;
} else {
g_registry = push->next;
}
g_count--;
pcsl_mem_free(push);
push_save();
javacall_bt_stack_set_service_classes(javacall_bt_sddb_get_service_classes(0));
REPORT_INFO(LC_PUSH, "Un-registration successful.");
return JAVACALL_OK;
}
/*
* Test the pcsl_mem_malloc method and pcsl_mem_get_free_heap method
* This test ensures that after a pcsl_mem_malloc call for 1000 bytes
* that the heap size available is reduced by 1000 bytes.
* note: acutally, the heap pcsl_memory.c impl adds 4 guard bytes, so
* we have to take that into account...
*/
void testMalloc() {
int spcBefore;
int spcAfter;
void * buffer;
spcBefore = pcsl_mem_get_free_heap();
buffer = pcsl_mem_malloc(1000);
assertTrue("failed to allocate a 1000 byte buffer",
(buffer != NULL));
spcAfter = pcsl_mem_get_free_heap();
if (spcAfter != -1) {
assertTrue("pcsl_mem_malloc & heap_size_available mis-match",
(spcBefore - 1004 == spcAfter ||
spcBefore - 1000 == spcAfter));
}
spcBefore = pcsl_mem_get_free_heap();
pcsl_mem_free(buffer);
spcAfter = pcsl_mem_get_free_heap();
if (spcAfter != -1) {
assertTrue("pcsl_mem_free & heap_size_available mis-match",
(spcBefore + 1004 == spcAfter ||
spcBefore + 1000 == spcAfter));
}
}
/**
* Test address to string conversion.
*/
void
testAddrToString() {
unsigned char addr[4];
unsigned short* result;
int resultLen;
int status;
int i;
/* test of success */
addr[0] = 80;
addr[1] = 80;
addr[2] = 80;
addr[3] = 80;
status = pcsl_network_addrToString(addr, &result, &resultLen);
assertTrue("gethostbyname failed", PCSL_NET_SUCCESS == status);
if (PCSL_NET_SUCCESS != status) {
return;
}
printf("Result of addr \"80.80.80.80\" = ");
for (i = 0; i < resultLen, i++) {
putchar(result[i]);
}
putchar('\n');
pcsl_mem_free(result);
}
/**
* Cleans up resources used by file system. It is only needed for the
* Ram File System (RMFS).
* @return 0 on success, -1 otherwise
*/
int pcsl_file_finalize() {
#ifndef PCSL_RAMFS_USE_STATIC
if (RamfsMemory != NULL) {
pcsl_mem_free(RamfsMemory);
}
#endif /* ! PCSL_RAMSF_USE_STATIC */
return 0;
}
/*
* Test simple memory allocation
* This test checks to see that NULL is not returned from a pcsl_mem_malloc
* call. (Note: NULL may be a valid return in a very full/limited
* memory system)
*/
void testAllocation() {
void * buffer = pcsl_mem_malloc(1000);
assertTrue("failed to allocate a 1000 byte buffer",
(buffer != NULL));
pcsl_mem_free(buffer);
}
/**
* Release all memory used by an MMS header.
*
* @param header The MMS header whose memory will be freed.
*/
void destroyMMSHeader(MmsHeader* header) {
if (header != NULL) {
/* Use pcsl_mem_free(header->part) to free each part. */
/* Free the header itself. */
pcsl_mem_free(header);
}
}
/**
* Frees the memory occupied by the given MidletSuiteData structure.
*
* @param pData MidletSuiteData entry to be freed
*/
void
free_suite_data_entry(MidletSuiteData* pData) {
if (pData != NULL) {
if ((pData->jarHashLen > 0) && pData->varSuiteData.pJarHash) {
pcsl_mem_free(pData->varSuiteData.pJarHash);
}
pcsl_string_free(&pData->varSuiteData.midletClassName);
pcsl_string_free(&pData->varSuiteData.displayName);
pcsl_string_free(&pData->varSuiteData.iconName);
pcsl_string_free(&pData->varSuiteData.suiteVendor);
pcsl_string_free(&pData->varSuiteData.suiteName);
pcsl_string_free(&pData->varSuiteData.pathToJar);
pcsl_string_free(&pData->varSuiteData.pathToSettings);
pcsl_mem_free(pData);
}
}
/**
* Reads the given file into the given buffer.
* File contents is read as one piece.
*
* @param ppszError pointer to character string pointer to accept an error
* @param pFileName file to read
* @param outBuffer buffer where the file contents should be stored
* @param outBufferLen length of the outBuffer
*
* @return status code (ALL_OK if there was no errors)
*/
MIDPError
read_file(char** ppszError, const pcsl_string* pFileName,
char** outBuffer, long* outBufferLen) {
int handle, status = ALL_OK;
long fileSize, len;
char* pszTemp;
char* buffer = NULL;
*ppszError = NULL;
*outBuffer = NULL;
*outBufferLen = 0;
/* open the file */
handle = storage_open(ppszError, pFileName, OPEN_READ);
if (*ppszError != NULL) {
if (!storage_file_exists(pFileName)) {
return NOT_FOUND;
}
return IO_ERROR;
}
do {
/* get the size of file */
fileSize = storageSizeOf(ppszError, handle);
if (*ppszError != NULL) {
status = IO_ERROR;
break;
}
if (fileSize > 0) {
/* allocate a buffer to store the file contents */
buffer = (char*)pcsl_mem_malloc(fileSize);
if (buffer == NULL) {
status = OUT_OF_MEMORY;
break;
}
/* read the whole file */
len = storageRead(ppszError, handle, buffer, fileSize);
if (*ppszError != NULL || len != fileSize) {
pcsl_mem_free(buffer);
status = IO_ERROR;
}
}
} while (0);
/* close the file */
storageClose(&pszTemp, handle);
storageFreeError(pszTemp);
if (status == ALL_OK) {
*outBuffer = buffer;
*outBufferLen = fileSize;
}
return (MIDPError)status;
}
/**
* Deconstruct the entire list and free all memory.
*
* @param head The first element of the list to be deconstructed.
*/
void jsr120_list_destroy(ListElement* head) {
/* If the list doesn't exist, exit now. */
if (head == NULL) {
return;
}
/* If the next element exists, recursively destroy. */
if (head->next) {
jsr120_list_destroy(head->next);
}
/* Release any string ID memory. */
pcsl_mem_free(head->strid);
/* Release the memory required by the list element. */
pcsl_mem_free(head);
}
javacall_bool bt_push_accept(bt_pushid_t pushid, const char *filter,
javacall_handle *handle)
{
bt_push_t *push = (bt_push_t *)pushid;
bt_client_t *client;
if (push == NULL) {
return JAVACALL_FALSE;
}
client = (bt_client_t *)pcsl_mem_malloc(sizeof(bt_client_t));
switch (push->port.protocol) {
case BT_L2CAP:
if (javacall_bt_l2cap_accept(push->server,
&client->handle, &client->bdaddr,
&client->rmtu, &client->tmtu) != JAVACALL_OK) {
pcsl_mem_free(client);
return JAVACALL_FALSE;
}
break;
case BT_SPP:
case BT_GOEP:
if (javacall_bt_rfcomm_accept(push->server,
&client->handle, &client->bdaddr) != JAVACALL_OK) {
pcsl_mem_free(client);
return JAVACALL_FALSE;
}
break;
default:
pcsl_mem_free(client);
return JAVACALL_FALSE;
}
if (bt_push_test_filter(client->bdaddr, filter) == JAVACALL_TRUE) {
bt_client_t **client_ptr = &push->client;
while (*client_ptr != NULL) {
client_ptr = &(*client_ptr)->next;
}
*client_ptr = client;
client->next = NULL;
*handle = client->handle;
return JAVACALL_TRUE;
}
close_handle(push->port.protocol, client->handle);
pcsl_mem_free(client);
return JAVACALL_FALSE;
}
/**
* Transforms prepared result buffer to jstring object and release memory of
* the allocated buffer.
* It is safe to call this function after detecting out-of-memory error
* provided that buf is set to _JSR211_RESULT_INITIALIZER_
*/
static void result2string(_JSR211_INTERNAL_RESULT_BUFFER_* buf, jstring str) {
if (buf->len > 0 && buf->buf != NULL) {
KNI_NewString(buf->buf, buf->len, str);
pcsl_mem_free(buf->buf);
} else {
KNI_ReleaseHandle(str);
}
buf->len = 0;
buf->buf = NULL;
}
/**
* Reads named secure resource of the suite with specified suiteId
* from secure persistent storage.
*
* Note that when porting memory for the in/out parameter
* returnValue MUST be allocated using pcsl_mem_malloc().
* The caller is responsible for freeing it.
*
* @param suiteId The suite id used to identify the MIDlet suite
* @param resourceName The name of secure resource to read from storage
* @param returnValue The in/out parameter that will return the
* value part of the requested secure resource
* (NULL is a valid return value)
* @param valueSize The length of the secure resource value
*
* @return one of the error codes:
* <pre>
* ALL_OK, OUT_OF_MEMORY, NOT_FOUND,
* SUITE_CORRUPTED_ERROR, BAD_PARAMS
* </pre>
*/
MIDPError
midp_suite_read_secure_resource(SuiteIdType suiteId,
const pcsl_string* resourceName,
jbyte **returnValue,
jint *valueSize) {
pcsl_string filename = PCSL_STRING_NULL;
char *pszError = NULL;
MIDPError errorCode;
int bytesRead;
int handle;
*returnValue = NULL;
*valueSize = 0;
errorCode = get_secure_resource_file(suiteId, resourceName, &filename);
if (errorCode != ALL_OK) {
pcsl_string_free(&filename);
return errorCode;
}
handle = storage_open(&pszError, &filename, OPEN_READ);
pcsl_string_free(&filename);
if (pszError != NULL) {
storageFreeError(pszError);
return SUITE_CORRUPTED_ERROR;
}
do {
bytesRead = storageRead(&pszError, handle,
(char*)valueSize, sizeof (int));
if (bytesRead != sizeof (int) || *valueSize == 0)
break;
*returnValue = (jbyte*)pcsl_mem_malloc(*valueSize * sizeof (jbyte));
if (*returnValue == NULL) {
errorCode = OUT_OF_MEMORY;
break;
}
bytesRead = storageRead(&pszError, handle, (char*)(*returnValue),
*valueSize * sizeof (jbyte));
if (pszError != NULL || bytesRead != *valueSize) {
errorCode = SUITE_CORRUPTED_ERROR;
pcsl_mem_free(*returnValue);
*returnValue = NULL;
break;
}
} while (0);
storageClose(&pszError, handle);
storageFreeError(pszError);
return errorCode;
}
/**
* Shutdowns Links subsystem.
*/
void midp_links_shutdown() {
if (portals != NULL) {
int i;
for (i = 0; i < JVM_MaxIsolates(); i++) {
portal_free(&portals[i]);
}
pcsl_mem_free(portals);
portals = NULL;
}
}
static void close_all(bt_push_t *push)
{
bt_client_t *client = push->client;
close_handle(push->port.protocol, push->server);
while (client != NULL) {
bt_client_t *next = client->next;
close_handle(push->port.protocol, client->handle);
pcsl_mem_free(client);
client = next;
}
push->client = NULL;
}
/**
* @internal
*
* FUNCTION: pcsl_end_memory()
* TYPE: private operation
* OVERVIEW: Finalize the PCSL memory pool
* INTERFACE:
* parameters: count address to store memory leak count
* size address to store totol bytes of memory leaked
* returns: the number of memory leaks detected
*
*/
static int
pcsl_end_memory(int* count, int* size) {
_PcslMemHdrPtr pcslMemoryHdr;
char* pcslMemoryPtr;
*count = 0;
*size = 0;
for (pcslMemoryPtr = PcslMemoryStart;
pcslMemoryPtr < PcslMemoryEnd;
pcslMemoryPtr += pcslMemoryHdr->size + sizeof(_PcslMemHdr)) {
pcslMemoryHdr = (_PcslMemHdrPtr)pcslMemoryPtr;
if (pcslMemoryHdr->magic != MAGIC) {
REPORT1("ERROR: Corrupted start of memory header: 0x%p\n",
pcslMemoryPtr);
return -1;
}
#ifdef PCSL_DEBUG
if (pcslMemoryHdr->guard != GUARD_WORD) {
report("ERROR: Corrupted end of memory header: 0x%p\n",
pcslMemoryPtr);
return -1;
}
/* The memory block header is valid, now check the guard data */
if (verify_tail_guard_data(pcslMemoryHdr)) {
report("ERROR: Memory overrun: 0x%p\n",
pcslMemoryPtr);
print_alloc("allocated",
pcslMemoryHdr->filename,
pcslMemoryHdr->lineno);
}
#endif
if (pcslMemoryHdr->free != 1) {
#ifdef PCSL_DEBUG
report("WARNING: memory leak: size= %d address= 0x%p\n",
pcslMemoryHdr->size,
(void*)((char*)pcslMemoryHdr + sizeof(_PcslMemHdr)));
print_alloc("allocated",
pcslMemoryHdr->filename, pcslMemoryHdr->lineno);
#endif
pcsl_mem_free((void*)((char*)pcslMemoryHdr + sizeof(_PcslMemHdr)));
*count += 1;
*size += pcslMemoryHdr->size;
}
}
return *count;
}
/**
* The close function loses the file with descriptor identifier in FS.
*/
int pcsl_file_close(void *handle)
{
if (NULL == handle)
return -1;
{
PCSLFile* pFH = (PCSLFile*)handle;
pcsl_file_commitwrite(handle); /* commit pending writes */
if (!CloseHandle(pFH->fileHandle))
return -1;
pcsl_mem_free(handle);
return 0;
}
}
javacall_result bt_push_register_url(const char *url, const void *data,
size_t size)
{
bt_port_t port;
bt_params_t params;
bt_push_t *push;
REPORT_INFO(LC_PUSH, "Bluetooth PushRegistry URL registration:");
REPORT_INFO1(LC_PUSH, "%s", url);
bt_push_parse_url(url, &port, ¶ms);
push = find_push(&port, NULL);
if (push != NULL) {
/* found existing entry with the same protocol/uuid, can not proceed */
REPORT_ERROR(LC_PUSH, "Entry already exists, registration failed.");
return JAVACALL_FAIL;
}
/* save the entry in the registry */
push = (bt_push_t *)pcsl_mem_malloc(sizeof(bt_push_t));
if (push == NULL) {
REPORT_ERROR(LC_PUSH, "Failed to allocate memory.");
return JAVACALL_FAIL;
}
memcpy(&push->port, &port, sizeof(bt_port_t));
memcpy(&push->params, ¶ms, sizeof(bt_params_t));
push->record.id = BT_INVALID_SDDB_HANDLE;
push->record.classes = 0;
if (data != NULL) {
push->record.data = pcsl_mem_malloc(size);
if (push->record.data == NULL) {
pcsl_mem_free(push);
return JAVACALL_FAIL;
}
memcpy(push->record.data, data, size);
} else {
push->record.data = NULL;
}
push->record.size = size;
push->server = BT_INVALID_HANDLE;
push->client = NULL;
push->next = g_registry;
g_registry = push;
g_count++;
if (javacall_bt_sddb_update_record(&push->record.id, push->record.classes,
push->record.data, push->record.size) != JAVACALL_OK) {
return JAVACALL_FAIL;
}
push_save();
REPORT_INFO(LC_PUSH, "Registration successful.");
return JAVACALL_OK;
}
static void
rp_decref(rendezvous *rp)
{
rp->refcount -= 1;
if (rp->refcount == 0) {
if (rp->msg != INVALID_REFERENCE_ID) {
/* IMPL_NOTE: really should be an assertion failure */
KNI_FatalError("rp_decref refcount 0 with stale refid!");
}
#if ENABLE_I3_TEST
log_rp_free(rp);
#endif
pcsl_mem_free(rp);
}
}
/**
* Remove the entry by updating the pointers in the next and
* previous entries.
* The pointers in the entry are set to NULL to prevent accidental
* dereferences.
*/
static void removeEntry(StoredLink* entry) {
if (entry != NULL) {
StoredLink *blink = entry->blink;
StoredLink *flink = entry->flink;
if (blink == NULL) {
invocQueue = flink;
} else {
blink->flink = flink;
}
if (flink != NULL) {
flink->blink = blink;
}
pcsl_mem_free(entry);
}
}
javacall_result bt_push_reject(bt_pushid_t pushid)
{
bt_push_t *push = (bt_push_t *)pushid;
bt_client_t *client;
if (push == NULL) {
return JAVACALL_FAIL;
}
client = push->client;
while (client != NULL) {
bt_client_t *next = client->next;
close_handle(push->port.protocol, client->handle);
pcsl_mem_free(client);
client = next;
}
push->client = NULL;
return JAVACALL_OK;
}
/*
* Test the fact that global heap size never changes
*/
void testHeapSize() {
void *buffer;
int rv, rv2, rv3;
rv = pcsl_mem_get_total_heap();
buffer = pcsl_mem_malloc(1000);
rv2 = pcsl_mem_get_total_heap();
pcsl_mem_free(buffer);
rv3 = pcsl_mem_get_total_heap();
assertTrue("pcsl total heap size should never change, but did",
(rv == rv2) && (rv2 == rv3));
}
