/**
* Retrieves an ID of the storage where the midlet suite with the given suite ID
* is stored.
*
* @param suiteId The application suite ID
* @param pSuiteId [out] receives an ID of the storage where the suite is stored
*
* @return error code (ALL_OK if successful)
*/
MIDPError
midp_suite_get_suite_storage(SuiteIdType suiteId, StorageIdType* pStorageId) {
MIDPError status;
MidletSuiteData* pData;
char* pszError;
if (pStorageId == NULL) {
return BAD_PARAMS;
}
if (suiteId == INTERNAL_SUITE_ID) {
/* handle a special case: predefined suite ID is given */
*pStorageId = INTERNAL_STORAGE_ID;
return ALL_OK;
}
/* load _suites.dat */
status = read_suites_data(&pszError);
storageFreeError(pszError);
if (status == ALL_OK) {
pData = get_suite_data(suiteId);
if (pData) {
*pStorageId = pData->storageId;
} else {
*pStorageId = UNUSED_STORAGE_ID;
status = NOT_FOUND;
}
}
return status;
}
/**
* Tells if a given suite is in a list of the installed suites.
*
* @param suiteId unique ID of the midlet suite
*
* @return ALL_OK if the suite is in the list of the installed suites,
* NOT_FOUND if not,
* IO_ERROR if an i/o error occured when reading the information
* about the installed suites,
* OUT_OF_MEMORY if out of memory or IO error,
* SUITE_CORRUPTED_ERROR is suite is found in the list, but it's
* corrupted.
*/
static MIDPError
suite_in_list(SuiteIdType suiteId) {
MIDPError status;
char* pszError;
MidletSuiteData* pData;
/* load _suites.dat */
status = read_suites_data(&pszError);
storageFreeError(pszError);
if (status != ALL_OK) {
return status;
}
pData = get_suite_data(suiteId);
if (pData != NULL) {
/*
* Make sure that suite is not corrupted. Return
* SUITE_CORRUPTED_ERROR if the suite is corrupted.
* Remove the suite before returning the status.
*/
status = check_for_corrupted_suite(suiteId);
} else {
status = NOT_FOUND;
}
return status;
}
/**
* Check if the suite is corrupted
* @param suiteId ID of a suite
*
* @return ALL_OK if the suite is not corrupted,
* SUITE_CORRUPTED_ERROR is suite is corrupted,
* OUT_OF_MEMORY if out of memory,
* IO_ERROR if I/O error
*/
MIDPError
check_for_corrupted_suite(SuiteIdType suiteId) {
pcsl_string filename[NUM_SUITE_FILES];
int arc[NUM_SUITE_FILES];
int i;
StorageIdType storageId;
MIDPError status = ALL_OK; /* Default to no error */
MidletSuiteData *pData = get_suite_data(suiteId);
if (!pData) {
return SUITE_CORRUPTED_ERROR;
}
/* if this suite was already checked, just return "OK" status */
if (pData->isChecked) {
return status;
}
/* get an id of the storage where the suite is located */
status = midp_suite_get_suite_storage(suiteId, &storageId);
if (status != ALL_OK) {
return status;
}
arc[0] = get_suite_filename(suiteId, &INSTALL_INFO_FILENAME, &filename[0]);
arc[1] = get_suite_filename(suiteId, &SETTINGS_FILENAME, &filename[1]);
arc[2] = midp_suite_get_class_path(suiteId, storageId,
KNI_FALSE, &filename[2]);
arc[3] = get_property_file(suiteId, KNI_FALSE, &filename[3]);
for (i = 0; i < NUM_SUITE_FILES; i++) {
if (arc[i] != ALL_OK) {
status = (MIDPError)arc[i];
break;
}
if (!storage_file_exists(&filename[i])) {
/* File does not exist; suite must be corrupted */
status = SUITE_CORRUPTED_ERROR;
break;
}
}
if (status == ALL_OK) {
/* if the suite is not currupted, mark it as "checked" */
pData->isChecked = 1;
}
pcsl_string_free(&filename[0]);
pcsl_string_free(&filename[1]);
pcsl_string_free(&filename[2]);
pcsl_string_free(&filename[3]);
return status;
}
/**
* Tells if a given suite is in a list of the installed suites.
*
* @param suiteId unique ID of the midlet suite
*
* @return ALL_OK if the suite is in the list of the installed suites,
* NOT_FOUND if not,
* IO_ERROR if an i/o error occured when reading the information
* about the installed suites,
* OUT_OF_MEMORY if out of memory or IO error,
* SUITE_CORRUPTED_ERROR is suite is found in the list, but it's
* corrupted.
*/
static MIDPError
suite_in_list(ComponentType type, SuiteIdType suiteId,
ComponentIdType componentId) {
MIDPError status;
char* pszError;
MidletSuiteData* pData;
#if !ENABLE_DYNAMIC_COMPONENTS
/** to supress compilation warnings */
(void)type;
(void)componentId;
#endif
/* load _suites.dat */
status = read_suites_data(&pszError);
storageFreeError(pszError);
if (status != ALL_OK) {
return status;
}
#if ENABLE_DYNAMIC_COMPONENTS
if (type == COMPONENT_DYNAMIC) {
pData = get_component_data(componentId);
if (pData == NULL) {
status = NOT_FOUND;
}
} else {
#endif /* ENABLE_DYNAMIC_COMPONENTS */
pData = get_suite_data(suiteId);
if (pData != NULL) {
/*
* Make sure that suite is not corrupted. Return
* SUITE_CORRUPTED_ERROR if the suite is corrupted.
* Remove the suite before returning the status.
*/
status = check_for_corrupted_suite(suiteId);
} else {
status = NOT_FOUND;
}
#if ENABLE_DYNAMIC_COMPONENTS
}
#endif
return status;
}
/**
* Retrieves an ID of the requested type for the given suite.
*
* @param suiteId The application suite ID
* @param resultType 0 to return suite storage ID, 1 - suite folder ID
* @param pResult [out] receives the requested ID
*
* @return error code (ALL_OK if successful)
*/
static MIDPError
get_suite_int_impl(SuiteIdType suiteId, int resultType, void* pResult) {
MIDPError status;
MidletSuiteData* pData;
char* pszError;
if (pResult == NULL) {
return BAD_PARAMS;
}
if (suiteId == INTERNAL_SUITE_ID) {
/* handle a special case: predefined suite ID is given */
if (resultType) {
*(FolderIdType*)pResult = 0;
} else {
*(StorageIdType*)pResult = INTERNAL_STORAGE_ID;
}
return ALL_OK;
}
/* load _suites.dat */
status = read_suites_data(&pszError);
storageFreeError(pszError);
if (status == ALL_OK) {
pData = get_suite_data(suiteId);
if (pData) {
if (resultType) {
*(FolderIdType*)pResult = pData->folderId;
} else {
*(StorageIdType*)pResult = pData->storageId;
}
} else {
if (resultType) {
*(FolderIdType*)pResult = -1;
} else {
*(StorageIdType*)pResult = UNUSED_STORAGE_ID;
}
status = NOT_FOUND;
}
}
return status;
}
/**
* Change the enabled state of a suite.
*
* @param suiteId ID of the suite
* @param enabled true if the suite is be enabled
*
* @return an error code (ALL_OK if no errors)
*/
static MIDPError
change_enabled_state(SuiteIdType suiteId, jboolean enabled) {
char* pszError;
MIDPError status;
jbyte* pPermissions;
int numberOfPermissions;
jbyte pushInterrupt;
jint pushOptions;
jboolean temp;
lockStorageList* node;
MidletSuiteData* pData;
/*
* This is a public API which can be called without the VM running
* so we need automatically init anything needed, to make the
* caller's code less complex.
*
* Initialization is performed in steps so that we do use any
* extra resources such as the VM for the operation being performed.
*/
if (midpInit(LIST_LEVEL) != 0) {
return OUT_OF_MEMORY;
}
status = midp_suite_exists(suiteId);
if ((status != ALL_OK) && (status != SUITE_CORRUPTED_ERROR)) {
return status;
}
node = find_storage_lock(suiteId);
if (node != NULL) {
if (node->update == KNI_TRUE) {
/* Suite is being updated currently. */
return SUITE_LOCKED;
}
}
status = read_settings(&pszError, suiteId, &temp, &pushInterrupt,
&pushOptions, &pPermissions, &numberOfPermissions);
if (status != ALL_OK) {
storageFreeError(pszError);
return status;
}
status = begin_transaction(TRANSACTION_ENABLE_SUITE, suiteId, NULL);
if (status != ALL_OK) {
return status;
}
status = write_settings(&pszError, suiteId, enabled, pushInterrupt,
pushOptions, pPermissions, numberOfPermissions,
NULL);
pcsl_mem_free(pPermissions);
if (status != ALL_OK) {
storageFreeError(pszError);
/* nothing was written, so nothing to rollback, just finish */
(void)finish_transaction();
return status;
}
/* synchronize the settings in the list of MidletSuiteData structures */
pData = get_suite_data(suiteId);
/*
* We can assert that pData is not NULL because midp_suite_exists()
* was called above to ensure that the suite with the given ID exists.
*/
if (pData != NULL) {
int status;
char* pszError;
pData->isEnabled = enabled;
/* IMPL_NOTE: these settings must be cached and saved on AMS exit. */
status = write_suites_data(&pszError);
storageFreeError(pszError);
if (status != ALL_OK) {
(void)rollback_transaction();
return IO_ERROR;
}
}
(void)finish_transaction();
return ALL_OK;
}
/**
* Gets the amount of storage on the device that this suite is using.
* This includes the JAD, JAR, management data, and RMS.
*
* @param suiteId ID of the suite
*
* @return number of bytes of storage the suite is using or less than
* OUT_OF_MEM_LEN if out of memory
*/
long
midp_get_suite_storage_size(SuiteIdType suiteId) {
long used = 0;
long rms = 0;
pcsl_string filename[NUM_SUITE_FILES];
int i;
char* pszError;
StorageIdType storageId;
MIDPError status;
MidletSuiteData* pData;
pcsl_string filenameBase;
// get the filename base from the suite id
status = build_suite_filename(suiteId, &PCSL_STRING_EMPTY,
&filenameBase);
if (status != ALL_OK) {
return status;
}
pData = get_suite_data(suiteId);
if (pData) {
used = (jint)pData->suiteSize;
}
if (used <= 0) {
/* Suite size is not cached (should not happen!), calculate it. */
for (i = 0; i < NUM_SUITE_FILES; i++) {
filename[i] = PCSL_STRING_NULL;
}
/*
* This is a public API which can be called without the VM running
* so we need automatically init anything needed, to make the
* caller's code less complex.
*
* Initialization is performed in steps so that we do use any
* extra resources such as the VM for the operation being performed.
*/
if (midpInit(LIST_LEVEL) != 0) {
return OUT_OF_MEM_LEN;
}
status = midp_suite_get_suite_storage(suiteId, &storageId);
if (status != ALL_OK) {
return OUT_OF_MEM_LEN;
}
status = build_suite_filename(suiteId, &INSTALL_INFO_FILENAME, &filename[0]);
if (status != ALL_OK) {
return status;
}
status = build_suite_filename(suiteId, &SETTINGS_FILENAME, &filename[1]);
if (status != ALL_OK) {
return status;
}
midp_suite_get_class_path(suiteId, storageId, KNI_TRUE, &filename[2]);
get_property_file(suiteId, KNI_TRUE, &filename[3]);
for (i = 0; i < NUM_SUITE_FILES; i++) {
long tmp;
if (pcsl_string_is_null(&filename[i])) {
continue;
}
tmp = storage_size_of_file_by_name(&pszError, &filename[i]);
pcsl_string_free(&filename[i]);
if (pszError != NULL) {
storageFreeError(pszError);
continue;
}
used += tmp;
}
if (pData) {
/* cache the calculated size */
pData->suiteSize = (jint)used;
status = write_suites_data(&pszError);
if (status != ALL_OK) {
storageFreeError(pszError);
return OUT_OF_MEM_LEN;
}
}
}
rms = rmsdb_get_rms_storage_size(&filenameBase, suiteId);
if (rms == OUT_OF_MEM_LEN) {
return OUT_OF_MEM_LEN;
}
return used + rms;
}
/**
* Moves the given midlet suite to another folder.
*
* @param suiteId ID of the suite
* @param newFolderId ID of the folder where the suite must be moved
*
* @return ALL_OK if no errors or an error code
*/
MIDPError midp_move_suite_to_folder(SuiteIdType suiteId,
FolderIdType newFolderId) {
MIDPError status = ALL_OK;
char* pszError = NULL;
lockStorageList *node = NULL;
MidletSuiteData* pSuiteData;
FolderIdType oldFolderId;
/*
* This is a public API which can be called without the VM running
* so we need automatically init anything needed, to make the
* caller's code less complex.
*
* Initialization is performed in steps so that we do use any
* extra resources such as the VM for the operation being performed.
*/
if (midpInit(REMOVE_LEVEL) != 0) {
return OUT_OF_MEMORY;
}
/* load _suites.dat */
status = read_suites_data(&pszError);
storageFreeError(pszError);
if (status != ALL_OK) {
return status;
}
node = find_storage_lock(suiteId);
if (node != NULL) {
if (node->update != KNI_TRUE) {
return SUITE_LOCKED;
}
}
pSuiteData = get_suite_data(suiteId);
if (pSuiteData == NULL) {
remove_storage_lock(suiteId);
return NOT_FOUND;
}
status = begin_transaction(TRANSACTION_MOVE_TO_FOLDER, suiteId, NULL);
if (status != ALL_OK) {
remove_storage_lock(suiteId);
return status;
}
oldFolderId = pSuiteData->folderId;
pSuiteData->folderId = newFolderId;
status = write_suites_data(&pszError);
storageFreeError(pszError);
if (status != ALL_OK) {
pSuiteData->folderId = oldFolderId;
(void)rollback_transaction();
} else {
(void)finish_transaction();
}
remove_storage_lock(suiteId);
return status;
}
/**
* Moves a software package with given suite ID to the specified storage.
*
* @param suiteId suite ID for the installed package
* @param storageId new storage ID
*
* @return SUITE_LOCKED if the
* suite is locked, NOT_FOUND if the suite cannot be found or
* invalid storage ID specified, BAD_PARAMS if attempt is made
* to move suite to the external storage, GENERAL_ERROR if
* VERIFY_ONCE is not enabled and if MONET is enabled
*/
MIDPError
midp_change_suite_storage(SuiteIdType suiteId, StorageIdType newStorageId) {
#ifndef VERIFY_ONCE
(void)suiteId;
(void)newStorageId;
return GENERAL_ERROR;
#else
/*
* if VERIFY_ONCE is enabled then MONET is disabled
* so we don't have to check ENABLE_MONET.
*/
{
pcsl_string suiteRoot;
MidletSuiteData* pData = NULL;
int status;
void* fileIteratorHandle = NULL;
lockStorageList *node = NULL;
if ((UNUSED_STORAGE_ID == newStorageId) ||
(newStorageId >= MAX_STORAGE_NUM)) {
return BAD_PARAMS;
}
/*
* IMPL_NOTE: for security reasons we allow to move suite
* only to the internal storage.
*/
if (newStorageId != INTERNAL_STORAGE_ID) {
return BAD_PARAMS;
}
node = find_storage_lock(suiteId);
if (node != NULL) {
if (node->update != KNI_TRUE) {
return SUITE_LOCKED;
}
}
/*
* This is a public API which can be called without the VM running
* so we need automatically init anything needed, to make the
* caller's code less complex.
*
* Initialization is performed in steps so that we do use any
* extra resources such as the VM for the operation being performed.
*/
if (midpInit(REMOVE_LEVEL) != 0) {
remove_storage_lock(suiteId);
return OUT_OF_MEMORY;
}
/* check that the suite exists and it is not a preloaded one */
pData = get_suite_data(suiteId);
if (pData == NULL) {
remove_storage_lock(suiteId);
return NOT_FOUND;
}
if (pData->storageId == newStorageId) {
remove_storage_lock(suiteId);
return BAD_PARAMS;
}
if (pData->type == COMPONENT_PREINSTALLED_SUITE) {
remove_storage_lock(suiteId);
return BAD_PARAMS;
}
do {
jsize oldRootLength;
jsize newRootLength;
const pcsl_string* newRoot;
const pcsl_string* oldRoot;
char* pszError = NULL;
pcsl_string filePath;
pcsl_string newFilePath;
status = begin_transaction(TRANSACTION_CHANGE_STORAGE, suiteId, NULL);
if (status != ALL_OK) {
break;
}
if ((status = get_suite_storage_root(suiteId, &suiteRoot)) != ALL_OK) {
break;
}
fileIteratorHandle = storage_open_file_iterator(&suiteRoot);
if (!fileIteratorHandle) {
status = IO_ERROR;
break;
}
newRoot = storage_get_root(newStorageId);
oldRoot = storage_get_root(pData->storageId);
newRootLength = pcsl_string_length(newRoot);
oldRootLength = pcsl_string_length(oldRoot);
status = ALL_OK;
if ((status = midp_suite_get_class_path(suiteId,
pData->storageId, KNI_FALSE, &filePath)) != ALL_OK) {
break;
}
if ((status = midp_suite_get_class_path(suiteId,
newStorageId, KNI_FALSE, &newFilePath)) != ALL_OK) {
break;
}
storage_rename_file(&pszError, &filePath, &newFilePath);
if (pszError != NULL) {
status = IO_ERROR;
storageFreeError(pszError);
pcsl_string_free(&filePath);
pcsl_string_free(&newFilePath);
break;
}
pcsl_string_free(&filePath);
pcsl_string_free(&newFilePath);
#if ENABLE_IMAGE_CACHE
moveImageCache(suiteId, pData->storageId, newStorageId);
#endif
pData->storageId = newStorageId;
status = write_suites_data(&pszError);
storageFreeError(pszError);
} while (0);
pcsl_string_free(&suiteRoot);
storageCloseFileIterator(fileIteratorHandle);
if (status != ALL_OK) {
(void)rollback_transaction();
} else {
(void)finish_transaction();
}
remove_storage_lock(suiteId);
return status;
}
#endif /* VERIFY_ONCE */
}
/**
* Removes a software package given its suite ID
* <p>
* If the component is in use it must continue to be available
* to the other components that are using it. The resources it
* consumes must not be released until it is not in use.
*
* @param suiteId ID of the suite
*
* @return ALL_OK if no errors,
* NOT_FOUND if the suite does not exist,
* SUITE_LOCKED if the suite is locked,
* BAD_PARAMS this suite cannot be removed
*/
MIDPError
midp_remove_suite(SuiteIdType suiteId) {
pcsl_string filename;
char* pszError;
pcsl_string suiteRoot;
MIDPError status;
int operationStarted = 0;
void* fileIteratorHandle = NULL;
MidpProperties properties;
pcsl_string* pproperty;
MidletSuiteData* pData = NULL;
pcsl_string filenameBase;
lockStorageList *node = NULL;
/* get the filename base from the suite id */
status = build_suite_filename(suiteId, &PCSL_STRING_EMPTY,
&filenameBase);
if (status != ALL_OK) {
return status;
}
node = find_storage_lock(suiteId);
if (node != NULL) {
if (node->update != KNI_TRUE) {
return SUITE_LOCKED;
}
}
/*
* This is a public API which can be called without the VM running
* so we need automatically init anything needed, to make the
* caller's code less complex.
*
* Initialization is performed in steps so that we do use any
* extra resources such as the VM for the operation being performed.
*/
if (midpInit(REMOVE_LEVEL) != 0) {
return OUT_OF_MEMORY;
}
do {
int rc; /* return code for rmsdb_... and storage_... */
/* load _suites.dat */
status = read_suites_data(&pszError);
storageFreeError(pszError);
if (status != ALL_OK) {
break;
}
/* check that the suite exists and it is not a preloaded one */
pData = get_suite_data(suiteId);
if (pData == NULL) {
status = NOT_FOUND;
break;
}
/* notify the listeners that we starting to remove the suite */
operationStarted = 1;
suite_listeners_notify(SUITESTORE_LISTENER_TYPE_REMOVE,
SUITESTORE_OPERATION_START, ALL_OK, pData);
if (pData->type == COMPONENT_PREINSTALLED_SUITE) {
status = BAD_PARAMS;
break;
}
status = begin_transaction(TRANSACTION_REMOVE_SUITE, suiteId, NULL);
if (status != ALL_OK) {
return status;
}
/*
* Remove the files
* Call the native RMS method to remove the RMS data.
* This function call is needed for portability
*/
rc = rmsdb_remove_record_stores_for_suite(&filenameBase, suiteId);
if (rc == KNI_FALSE) {
status = SUITE_LOCKED;
break;
}
pushdeletesuite(suiteId);
/*
* If there is a delete notify property, add the value to the delete
* notify URL list.
*/
properties = midp_get_suite_properties(suiteId);
if (properties.numberOfProperties > 0) {
pproperty = midp_find_property(&properties, &DELETE_NOTIFY_PROP);
if (pcsl_string_length(pproperty) > 0) {
midpAddDeleteNotification(suiteId, pproperty);
}
pproperty = midp_find_property(&properties, &INSTALL_NOTIFY_PROP);
if (pcsl_string_length(pproperty) > 0) {
/*
* Remove any pending install notifications since they are only
* retried when the suite is run.
*/
midpRemoveInstallNotification(suiteId);
}
midp_free_properties(&properties);
}
if ((status = get_suite_storage_root(suiteId, &suiteRoot)) != ALL_OK) {
break;
}
fileIteratorHandle = storage_open_file_iterator(&suiteRoot);
if (!fileIteratorHandle) {
status = IO_ERROR;
break;
}
#if ENABLE_ICON_CACHE
midp_remove_suite_icons(suiteId);
#endif
for (;;) {
rc = storage_get_next_file_in_iterator(&suiteRoot,
fileIteratorHandle, &filename);
if (0 != rc) {
break;
}
storage_delete_file(&pszError, &filename);
pcsl_string_free(&filename);
if (pszError != NULL) {
storageFreeError(pszError);
break;
}
}
} while (0);
pcsl_string_free(&suiteRoot);
storageCloseFileIterator(fileIteratorHandle);
(void)finish_transaction();
/*
* Notify the listeners the we've finished removing the suite.
* It should be done before remove_from_suite_list_and_save()
* call because it frees pData structure.
*/
if (operationStarted) {
suite_listeners_notify(SUITESTORE_LISTENER_TYPE_REMOVE,
SUITESTORE_OPERATION_END, status, pData);
}
if (status == ALL_OK) {
(void)remove_from_suite_list_and_save(suiteId);
}
remove_storage_lock(suiteId);
return status;
}