MidpProperties mf_main(char* mfbuf, int mflength) { MidpProperties mfsmp = {0, ALL_OK, NULL}; jchar* save_jchar_buffer = NULL; jchar* jchar_buffer = NULL; int jbufsize = -1; #if REPORT_LEVEL <= LOG_INFORMATION int res = 0; #endif if ((mflength <= 0) || (!mfbuf)) { mfsmp.status = OUT_OF_MEMORY; return mfsmp; } jbufsize = mflength * sizeof(jchar); jchar_buffer = (jchar*)midpMalloc(jbufsize+2); if (!jchar_buffer) { midpFree(mfbuf); mfsmp.status = OUT_OF_MEMORY; return mfsmp; } memset(jchar_buffer,0,(jbufsize + 2)); convertChar2JChar(mfbuf,jchar_buffer,mflength); midpFree(mfbuf); save_jchar_buffer = jchar_buffer; REPORT_INFO(LC_AMS, "######################### Start of manifest parsing"); /* during execution of this, jchar_buffer pointer will be changed */ mfsmp = midpParseMf(jchar_buffer); midpFree(save_jchar_buffer); switch (mfsmp.status) { case NO_SUITE_NAME_PROP: midp_free_properties(&mfsmp); return mfsmp; case NO_SUITE_VENDOR_PROP: midp_free_properties(&mfsmp); return mfsmp; case NO_SUITE_VERSION_PROP: midp_free_properties(&mfsmp); return mfsmp; case NO_MIDLET_ONE_PROP: midp_free_properties(&mfsmp); return mfsmp; case NO_MICROEDITION_PROFILE_PROP: midp_free_properties(&mfsmp); return mfsmp; case NO_MICROEDITION_CONFIGURATION_PROP: REPORT_INFO1(LC_AMS, "Manifest MUST property missing %d", mfsmp.status); return mfsmp; case BAD_PARAMS: case BAD_MF_KEY: case BAD_MF_VALUE: REPORT_INFO1(LC_AMS, "Some NOT MUST Manifest property is not valid %d", mfsmp.status); break; case ALL_OK: REPORT_INFO1(LC_AMS, "Manifest ALL_OK %d", mfsmp.status); break; default: REPORT_INFO1(LC_AMS, "MF parse OUT_OF_MEMORY %d", mfsmp.status); /* for unknown result assuming OUT_OF_MEMORY */ return mfsmp; } /* end of switch */ #if REPORT_LEVEL <= LOG_INFORMATION reportToLog(LOG_INFORMATION, LC_AMS, "%s %s %d", "########################### End of manifest parsing: ", "mf_main() : number of Manifest properties = ", mfsmp.numberOfProperties); for (res = 0; res < mfsmp.numberOfProperties * 2; res += 2) { printPcslStringWithMessage(" ", &mfsmp.pStringArr[res]); printPcslStringWithMessage(" ", &mfsmp.pStringArr[res+1]); } #endif return mfsmp; } /* end of mf_main */
static MidpProperties midpParseMf(jchar* jchar_buffer) { MidpProperties mfsmp = {0, ALL_OK, NULL}; pcsl_string mfkey; pcsl_string mfkey_trimmed; pcsl_string mfvalue; pcsl_string mfvalue_trimmed; pcsl_string mfline; MIDPError err; pcsl_string_status rc; int countLines = 0; int index = 0; int count = 0; if (!jchar_buffer) { mfsmp.status = BAD_PARAMS; return mfsmp; } countLines = count_mf_lines(jchar_buffer); if (countLines <= 0) { REPORT_INFO(LC_AMS, "midpParseMf(): Empty manifest."); mfsmp.status = OUT_OF_MEMORY; return mfsmp; } mfsmp.pStringArr = alloc_pcsl_string_list(countLines * 2); if (mfsmp.pStringArr == NULL) { mfsmp.status = OUT_OF_MEMORY; return mfsmp; } mfsmp.numberOfProperties = countLines; for (count = 0; count < countLines * 2 ; /* count increased at the end of for */ ) { /* memory for the line is allocated here */ /* line continuation striped out */ err = readMfLine(&jchar_buffer, &mfline); if (OUT_OF_MEMORY == err) { midp_free_properties(&mfsmp); mfsmp.status = OUT_OF_MEMORY; return mfsmp; } else if (END_OF_MF == err) { /* we are done */ mfsmp.status = ALL_OK; break; } index = pcsl_string_index_of(&mfline, ':'); if (index <= 0) { mfsmp.status = BAD_MF_KEY; pcsl_string_free(&mfline); continue; } /* memory for mfkey is allocated here */ if (PCSL_STRING_OK != pcsl_string_substring(&mfline, 0, index, &mfkey)) { midp_free_properties(&mfsmp); mfsmp.status = OUT_OF_MEMORY; pcsl_string_free(&mfline); return mfsmp; } rc = pcsl_string_trim(&mfkey, &mfkey_trimmed); pcsl_string_free(&mfkey); if (PCSL_STRING_OK != rc) { mfsmp.status = OUT_OF_MEMORY; midp_free_properties(&mfsmp); pcsl_string_free(&mfline); return mfsmp; } if (pcsl_string_length(&mfkey_trimmed) < 1) { mfsmp.status = BAD_PARAMS; pcsl_string_free(&mfline); pcsl_string_free(&mfkey_trimmed); continue; } err = checkMfKeyChars(&mfkey_trimmed); if (OUT_OF_MEMORY == err) { mfsmp.status = OUT_OF_MEMORY; midp_free_properties(&mfsmp); pcsl_string_free(&mfline); pcsl_string_free(&mfkey_trimmed); return mfsmp; } else if (BAD_MF_KEY == err) { mfsmp.status = BAD_MF_KEY; pcsl_string_free(&mfline); pcsl_string_free(&mfkey_trimmed); continue; } rc = pcsl_string_substring(&mfline, index + 1, pcsl_string_length(&mfline), &mfvalue); /* free the mfline once we have got the key and value */ pcsl_string_free(&mfline); if (PCSL_STRING_OK != rc) { mfsmp.status = OUT_OF_MEMORY; midp_free_properties(&mfsmp); pcsl_string_free(&mfkey_trimmed); return mfsmp; } /* memory for value is allocated here */ rc = pcsl_string_trim(&mfvalue, &mfvalue_trimmed); pcsl_string_free(&mfvalue); if (PCSL_STRING_OK != rc) { mfsmp.status = OUT_OF_MEMORY; midp_free_properties(&mfsmp); pcsl_string_free(&mfkey_trimmed); return mfsmp; } if (pcsl_string_is_null(&mfvalue_trimmed)) { mfsmp.status = NULL_LEN; pcsl_string_free(&mfkey_trimmed); continue; } err = checkMfValueChars(&mfvalue_trimmed); if (OUT_OF_MEMORY == err) { mfsmp.status = OUT_OF_MEMORY; midp_free_properties(&mfsmp); pcsl_string_free(&mfkey_trimmed); pcsl_string_free(&mfvalue_trimmed); return mfsmp; } else if (BAD_MF_VALUE == err) { mfsmp.status = BAD_MF_VALUE; pcsl_string_free(&mfkey_trimmed); pcsl_string_free(&mfvalue_trimmed); continue; } printPcslStringWithMessage("midpParseMf()", &mfkey_trimmed); printPcslStringWithMessage(" = ", &mfvalue_trimmed); /* Store key:value pair. */ mfsmp.pStringArr[count] = mfkey_trimmed; mfsmp.pStringArr[count+1] = mfvalue_trimmed; count += 2; } /* end of for */ mfsmp = verifyMfMustProperties(mfsmp); REPORT_INFO3(LC_AMS, "End of midpParseMf: Status=%d, count=%d, countLines=%d", mfsmp.status, count, countLines); return mfsmp; } /* end of midpParseMf */
static MidpProperties midpParseJad(jchar* jchar_buffer) { MidpProperties jadsmp = {0, ALL_OK, NULL}; pcsl_string jadkey; pcsl_string jadkey_trimmed; pcsl_string jadvalue; pcsl_string jadvalue_trimmed; pcsl_string jadline; MIDPError err; pcsl_string_status rc; int countLines = 0; jint index = 0; int count = 0; if (!jchar_buffer) { jadsmp.status = BAD_PARAMS; return jadsmp; } countLines = count_jad_lines(jchar_buffer); if (countLines <= 0) { REPORT_INFO(LC_AMS, "midpParseJad(): Empty jad file."); jadsmp.status = OUT_OF_MEMORY; return jadsmp; } jadsmp.pStringArr = alloc_pcsl_string_list(countLines * 2); if (jadsmp.pStringArr == NULL) { jadsmp.status = OUT_OF_MEMORY; return jadsmp; } jadsmp.numberOfProperties = countLines; for (count = 0; count < countLines * 2 ; /* count increased at the end of for */ ) { /* memory for the line is allocated here */ err = readJadLine(&jchar_buffer, &jadline); if (OUT_OF_MEMORY == err) { midp_free_properties(&jadsmp); jadsmp.status = OUT_OF_MEMORY; return jadsmp; } else if (END_OF_JAD == err) { /* we are done */ jadsmp.status = ALL_OK; break; } index = pcsl_string_index_of(&jadline, ':'); if (index <= 0) { jadsmp.status = BAD_JAD_KEY; pcsl_string_free(&jadline); continue; } /* memory for key is allocated here */ if (PCSL_STRING_OK != pcsl_string_substring(&jadline, 0, index, &jadkey)) { midp_free_properties(&jadsmp); jadsmp.status = OUT_OF_MEMORY; pcsl_string_free(&jadline); return jadsmp; } rc = pcsl_string_trim(&jadkey, &jadkey_trimmed); pcsl_string_free(&jadkey); if (PCSL_STRING_OK != rc) { jadsmp.status = OUT_OF_MEMORY; midp_free_properties(&jadsmp); pcsl_string_free(&jadline); return jadsmp; } if (pcsl_string_length(&jadkey_trimmed) < 1) { jadsmp.status = BAD_PARAMS; pcsl_string_free(&jadline); pcsl_string_free(&jadkey_trimmed); continue; } err = checkJadKeyChars(&jadkey_trimmed); if (OUT_OF_MEMORY == err) { jadsmp.status = OUT_OF_MEMORY; midp_free_properties(&jadsmp); pcsl_string_free(&jadline); pcsl_string_free(&jadkey_trimmed); return jadsmp; } else if (BAD_JAD_KEY == err) { jadsmp.status = BAD_JAD_KEY; pcsl_string_free(&jadline); pcsl_string_free(&jadkey_trimmed); continue; } rc = pcsl_string_substring(&jadline, index + 1, pcsl_string_length(&jadline), &jadvalue); /* free the jadline once we have got the key and value */ pcsl_string_free(&jadline); if (PCSL_STRING_OK != rc) { jadsmp.status = OUT_OF_MEMORY; midp_free_properties(&jadsmp); pcsl_string_free(&jadkey_trimmed); return jadsmp; } /* memory for value is allocated here */ rc = pcsl_string_trim(&jadvalue, &jadvalue_trimmed); pcsl_string_free(&jadvalue); if (PCSL_STRING_OK != rc) { jadsmp.status = OUT_OF_MEMORY; midp_free_properties(&jadsmp); pcsl_string_free(&jadkey_trimmed); return jadsmp; } if (pcsl_string_is_null(&jadvalue_trimmed)) { jadsmp.status = NULL_LEN; pcsl_string_free(&jadkey_trimmed); continue; } err = checkJadValueChars(&jadvalue_trimmed); if (OUT_OF_MEMORY == err) { jadsmp.status = OUT_OF_MEMORY; midp_free_properties(&jadsmp); pcsl_string_free(&jadkey_trimmed); pcsl_string_free(&jadvalue_trimmed); return jadsmp; } else if (BAD_JAD_VALUE == err) { jadsmp.status = BAD_JAD_VALUE; pcsl_string_free(&jadkey_trimmed); pcsl_string_free(&jadvalue_trimmed); continue; } printPcslStringWithMessage("midpParseJad()", &jadkey_trimmed); printPcslStringWithMessage("midpParseJad()", &jadvalue_trimmed); /* Store key:value pair. */ jadsmp.pStringArr[count] = jadkey_trimmed; jadsmp.pStringArr[count+1] = jadvalue_trimmed; count += 2; } /* end of for */ jadsmp = verifyJadMustProperties(jadsmp); REPORT_INFO3(LC_AMS, "End jad parsing. Status=%d, count=%d, countLines=%d.", jadsmp.status, count, countLines); return jadsmp; } /* end of midpParseJad */
MidpProperties jad_main(char* jadbuf, int jadsize) { MidpProperties jadsmp = {0,ALL_OK,NULL}; jchar* jchar_buffer = NULL; jchar* save_jchar_buffer = NULL; int jbufsize = -1; #if REPORT_LEVEL <= LOG_INFORMATION int res = 0; #endif jbufsize = jadsize * sizeof(jchar); jchar_buffer = (jchar*)midpMalloc(jbufsize+2); if (!jchar_buffer) { midpFree(jadbuf); jadsmp.status = OUT_OF_MEMORY; return jadsmp; } memset(jchar_buffer,0,(jbufsize + 2)); convertChar2JChar(jadbuf,jchar_buffer,jadsize); midpFree(jadbuf); save_jchar_buffer = jchar_buffer; REPORT_INFO(LC_AMS, "####################### Start JAD parsing"); /* during execution of this function jadbuf pointer will be changed status will be set during midpParseJad() execution */ jadsmp = midpParseJad(jchar_buffer); midpFree(save_jchar_buffer); switch (jadsmp.status) { case OUT_OF_STORAGE: REPORT_WARN1(LC_AMS, "OUT_OF_STORAGE by JAD %d", jadsmp.status); midp_free_properties(&jadsmp); return jadsmp; case NO_JAR_URL_PROP: REPORT_WARN1(LC_AMS, "Jad property missing %d", jadsmp.status); midp_free_properties(&jadsmp); return jadsmp; case NO_SUITE_NAME_PROP: REPORT_WARN1(LC_AMS, "Jad property missing %d", jadsmp.status); midp_free_properties(&jadsmp); return jadsmp; case NO_SUITE_VENDOR_PROP: REPORT_WARN1(LC_AMS, "Jad property missing %d", jadsmp.status); midp_free_properties(&jadsmp); return jadsmp; case NO_SUITE_VERSION_PROP: REPORT_WARN1(LC_AMS, "Jad property missing %d", jadsmp.status); midp_free_properties(&jadsmp); return jadsmp; case NO_JAR_SIZE_PROP: REPORT_WARN1(LC_AMS, "Jad property missing %d", jadsmp.status); midp_free_properties(&jadsmp); return jadsmp; case NUMBER_ERROR: REPORT_INFO1(LC_AMS, "Error during parsing JAR size written in JAD %d", jadsmp.status); midp_free_properties(&jadsmp); return jadsmp; case BAD_PARAMS: case BAD_JAD_KEY: case BAD_JAD_VALUE: REPORT_INFO1(LC_AMS, "Some NOT mandatory Jad properties is not valid %d", jadsmp.status); break; case ALL_OK: REPORT_INFO1(LC_AMS, "Jad ALL_OK %d", jadsmp.status); break; default: /* for an unknown result assuming OUT_OF_MEMORY */ REPORT_INFO1(LC_AMS, "JAD parse OUT_OF_MEMORY %d", jadsmp.status); return jadsmp; } /* end of switch */ #if REPORT_LEVEL <= LOG_INFORMATION reportToLog(LOG_INFORMATION, LC_AMS, "######################### End of JAD parsing\n" "jad_main() : number of JAD properties = %d", jadsmp.numberOfProperties); for (res = 0; res < jadsmp.numberOfProperties*2; res+=2 ) { printPcslStringWithMessage(" ", &jadsmp.pStringArr[res]); printPcslStringWithMessage(" ", &jadsmp.pStringArr[res+1]); } #endif return jadsmp; } /* end of jad_main */
int find_midlet_class(SuiteIdType id, int midletNumber, pcsl_string* res) { MidpProperties properties; pcsl_string keySuffix = PCSL_STRING_NULL; pcsl_string key = PCSL_STRING_NULL; const pcsl_string* property = &PCSL_STRING_NULL; pcsl_string temp = PCSL_STRING_NULL; pcsl_string_status stat; int begin; int result = 0; *res = PCSL_STRING_NULL; properties = midp_get_suite_properties(id); if (OUT_OF_MEM_PROPERTY_STATUS(properties)) { return OUT_OF_MEM_LEN; } do { if (CORRUPTED_PROPERTY_STATUS(properties)) { midp_free_properties(&properties); REPORT_ERROR(LC_AMS, "Error : Suite is corrupted"); fprintf(stderr, "Error : Suite is corrupted\n"); result = NULL_LEN; break; } if (READ_ERROR_PROPERTY_STATUS(properties)) { midp_free_properties(&properties); REPORT_ERROR(LC_AMS, "Corrupt properties"); fprintf(stderr, "Corrupt properties\n"); result = NULL_LEN; break; } stat = pcsl_string_convert_from_jint(midletNumber, &keySuffix); if (PCSL_STRING_OK != stat) { if(PCSL_STRING_ENOMEM == stat) { result = OUT_OF_MEM_LEN; } else { result = NULL_LEN; } break; } stat = pcsl_string_cat(&KEY_PREFIX, &keySuffix, &key); pcsl_string_free(&keySuffix); if (PCSL_STRING_OK != stat) { result = OUT_OF_MEM_LEN; break; } property = midp_find_property(&properties, &key); if (pcsl_string_length(property) <= 0) { /* property not found */ result = NULL_LEN; break; } /* The class is the last item in the set. */ begin = pcsl_string_last_index_of(property, (jchar)','); if (begin < 0 || begin >= pcsl_string_length(property)) { result = NULL_LEN; break; } begin++; stat = pcsl_string_substring(property, begin, pcsl_string_length(property), &temp); if (PCSL_STRING_OK != stat) { result = OUT_OF_MEM_LEN; break; } if (pcsl_string_length(&temp) <= 0) { pcsl_string_free(&temp); result = NULL_LEN; break; } stat = pcsl_string_trim(&temp, res); pcsl_string_free(&temp); if (PCSL_STRING_OK != stat) { result = OUT_OF_MEM_LEN; break; } } while (0); midp_free_properties(&properties); return result; }
/** * Lists all installed MIDlet suites. This is an example of how to use * the public MIDP API. * * @param argc The total number of arguments * @param argv An array of 'C' strings containing the arguments * * @return <tt>0</tt> for success, otherwise <tt>-1</tt> * * IMPL_NOTE: determine if it is desirable for user targeted output * messages to be sent via the log/trace service, or if * they should remain as printf calls */ int listMidlets(int argc, char* argv[]) { int status = -1; int i; long size; char* midpHome = NULL; (void)argv; /* Avoid compiler warnings */ if (argc > 1) { REPORT_ERROR(LC_AMS, "Too many arguments given"); fprintf(stderr, "Too many arguments given\n"); return -1; } /* get midp home directory, set it */ midpHome = midpFixMidpHome(argv[0]); if (midpHome == NULL) { return -1; } /* set up midpHome before calling initialize */ midpSetHomeDir(midpHome); if (midpInitialize() != 0) { REPORT_ERROR(LC_AMS, "Not enough memory"); fprintf(stderr, "Not enough memory\n"); return -1; } do { SuiteIdType* pSuites = NULL; int numberOfSuites = 0; MIDPError err; err = midp_get_suite_ids(&pSuites, &numberOfSuites); if (err != ALL_OK) { REPORT_ERROR1(LC_AMS, "Error in midp_get_suite_ids(), code %d", err); fprintf(stderr, "Error in midp_get_suite_ids(), code %d.\n", err); break; } if (numberOfSuites == 0) { REPORT_ERROR(LC_AMS, "No MIDlet Suites installed on phone"); printf("** No MIDlet Suites installed on phone\n"); status = 0; break; } for (i = 0; i < numberOfSuites; i++) { MidpInstallInfo info; MidpProperties properties; info = midp_get_suite_install_info(pSuites[i]); if (BAD_ID_INFO_STATUS(info)) { REPORT_ERROR(LC_AMS, "Suite list is corrupt"); fprintf(stderr, "Suite list is corrupt\n"); break; } if (OUT_OF_MEM_INFO_STATUS(info)) { REPORT_ERROR(LC_AMS, "Out Of Memory for Info"); fprintf(stderr, "Out Of Memory for Info\n"); break; } if (SUITE_CORRUPTED_ERR_STATUS(info)) { /* * Installinfo is not initialsed in case of an error * so no need to free it */ REPORT_ERROR1(LC_AMS, "Error : Suite %d is corrupted", (i+1)); fprintf(stderr, "Error : Suite %d is corrupted\n", (i+1)); continue; } if (READ_ERROR_INFO_STATUS(info)) { REPORT_ERROR(LC_AMS, "Corrupt install info"); fprintf(stderr, "Corrupt install info\n"); break; } properties = midp_get_suite_properties(pSuites[i]); if (OUT_OF_MEM_PROPERTY_STATUS(properties)) { midp_free_install_info(&info); midp_free_properties(&properties); REPORT_ERROR(LC_AMS, "Out Of Memory for properties"); fprintf(stderr, "Out Of Memory for properties\n"); break; } if (CORRUPTED_PROPERTY_STATUS(properties)) { midp_free_install_info(&info); midp_free_properties(&properties); REPORT_ERROR1(LC_AMS, "Error : Suite %d is corrupted", (i+1)); fprintf(stderr, "Error : Suite %d is corrupted\n", (i+1)); continue; } if (READ_ERROR_PROPERTY_STATUS(properties)) { midp_free_install_info(&info); midp_free_properties(&properties); REPORT_ERROR(LC_AMS, "Corrupt properties"); fprintf(stderr, "Corrupt properties\n"); break; } printf("[%d]\n", (i + 1)); printProperty(" Name: ", &SUITE_NAME_PROP, properties); printProperty(" Vendor: ", &SUITE_VENDOR_PROP, properties); printProperty(" Version: ", &SUITE_VERSION_PROP, properties); printProperty(" Description: ", &SUITE_DESC_PROP, properties); if (info.authPathLen > 0) { int j; puts(" Authorized by: "); for (j = 0; j < info.authPathLen; j++) { print_field(" ", &info.authPath_as[j]); } } print_field(" SecurityDomain: ", &info.domain_s); printf(" Verified: %s\n", (info.pVerifyHash != NULL ? "true" : "false")); printf(" Suite ID: %ld\n", (long)pSuites[i]); print_field(" JAD URL: ", &info.jadUrl_s); print_field(" JAR URL: ", &info.jarUrl_s); size = midp_get_suite_storage_size(pSuites[i]); if (size < 0) { fprintf(stderr, "Ran out of memory getting the size\n"); } else { printf(" Size: %ldK\n", (size + 1023) / 1024); } midp_free_install_info(&info); midp_free_properties(&properties); } midp_free_suite_ids(pSuites, numberOfSuites); status = 0; } while (0); midpFinalize(); return status; }
/** * 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; }