/** * 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; }