/** * Searches fields in records. * * @param fld_num internal ID of field to be found * @return number of bytes read */ static int position_field(int fld_num) { int record_size; int field_cnt; field_type* cur_type; if (fld_num < 0 || fld_num >= JSR211_CHR_COUNT) { return -1; } /* skip header */ if (storageRead(&io_error_message, table_file, (char *)&record_size, sizeof(int)) == -1) { return 0; } for (field_cnt = 0, cur_type = record_struct; field_cnt < fld_num; field_cnt++, cur_type++) { int field_size; if (*cur_type != field_int) { storageRead(&io_error_message, table_file, (char*)&field_size, sizeof(int)); } else { field_size = sizeof(int); } storageRelativePosition(&io_error_message, table_file, field_size); } return record_size; }
/** * Loads current handler's main fields (ID, suite_ID, class_name, flag). * @param handler loaded structure pointer. * @return operation result */ static void load_current_handler(JSR211_CH* ch) { long pos = storageRelativePosition(&io_error_message, table_file, sizeof(int)) - sizeof(int); read_string(&(ch->id)); storageRead(&io_error_message, table_file, (char*)&(ch->flag), sizeof(int)); storageRead(&io_error_message, table_file, (char*)&(ch->suite_id), sizeof(int)); read_string(&(ch->class_name)); storagePosition(&io_error_message, table_file, pos); }
/** * 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; }
/** * Reads string from the file. * * @param string pointer to result string * @return number of bytes read */ static int read_string(pcsl_string* string) { jint string_len; jchar *string_data; storageRead(&io_error_message, table_file, (char*)&string_len, sizeof(int)); string_data = (jchar*)JSR211_MALLOC(string_len); storageRead(&io_error_message, table_file, (char*)string_data, string_len); pcsl_string_convert_from_utf16(string_data, string_len/sizeof(jchar), string); JSR211_FREE(string_data); return string_len + sizeof(int); }
/** * Searches specified string in the array record field * Reads strings from a current field of a current * record and compares it with a passed value. * * @param key compare key * @param cond internal ID of comparision mode * @return 1 if strings are equal (for the given mode) */ static int compare_array(const pcsl_string* key, jsr211_boolean case_sensitive, find_condition cond) { int array_size, array_len, current_string; storageRead(&io_error_message, table_file, (char *)&array_size, sizeof(int)); storageRead(&io_error_message, table_file, (char *)&array_len, sizeof(int)); for (current_string = 0; current_string < array_len; current_string++) { if (compare_string(key, case_sensitive, cond)) { return 1; } } return 0; }
uint32_t configGetTh1Timeout(void) { struct config config; storageRead(Storage, &config); return (config.th[1].time); }
/** * Searches the next content handler in the file by its suite id. * * @param suite search suite ID * @return offset of found record or -1 */ static long find_next_by_suite(int suite) { long current_position; int record_size; int testSuite; int found = 0; current_position = storageRelativePosition(&io_error_message, table_file, 0); do { record_size = position_field(JSR211_CHR_SUITE); if (record_size <= 0) { current_position = -1; break; } storageRead(&io_error_message, table_file, (char*)&testSuite, sizeof(int)); found = (testSuite == suite? 1: 0); storagePosition(&io_error_message, table_file, current_position); if (found) { break; } current_position = storageRelativePosition(&io_error_message, table_file, record_size); } while (current_position > 0); return current_position; }
uint32_t configGetTh0Vacuum(void) { struct config config; storageRead(Storage, &config); return (config.th[0].vacuum); }
/** * Moves file position to next record. */ static void goto_next_record(void) { int current_size; storageRead(&io_error_message, table_file, (char*)¤t_size, sizeof(int)); storageRelativePosition(&io_error_message, table_file, current_size - sizeof(int)); }
uint32_t configGetTh1RawVacuum(void) { struct config config; storageRead(Storage, &config); return (config.th[1].rawVacuum); }
void initAppConfig(void) { struct config config; if (storageRead(Storage, &config) != ES_ERROR_NONE) { appConfigReset(&config); storageWrite(Storage, &config); } }
/** * Read pcsl_string from storage. * First read a jint with length, then read the text * of that length in the utf-16 encoding. * * @param ppszError in the case of error, receives address of a string * describing the problem; receives NULL in the case of success * @param handle handle of the file to read from * @param str string to receive the text */ void storage_read_utf16_string(char** ppszError, int handle, pcsl_string* str) { jint bytesRead = 0; jchar *tempStr = NULL; jint tempLen = 0; pcsl_string_status prc; storageRead(ppszError, handle, (char*)&tempLen, sizeof (jint)); if (*ppszError != NULL) { return; } /* special cases: null and empty strings */ if (tempLen < 0) { if(0 == tempLen) { *str = PCSL_STRING_NULL; } else if (-1 == tempLen) { *str = PCSL_STRING_EMPTY; } else { *str = PCSL_STRING_NULL; *ppszError = (char *)STRING_CORRUPT_ERROR; } return; } tempStr = (jchar*)midpMalloc(tempLen * sizeof (jchar)); if (tempStr == NULL) { *ppszError = (char *)OUT_OF_MEM_ERROR; return; } bytesRead = storageRead(ppszError, handle, (char*)tempStr, tempLen * sizeof (jchar)); if (*ppszError != NULL) { /* do nothing: error code already there */ } else if (bytesRead != (signed)(tempLen * sizeof (jchar))) { *ppszError = (char *)STRING_CORRUPT_ERROR; } else if (PCSL_STRING_OK != (prc = pcsl_string_convert_from_utf16(tempStr, tempLen, str))) { *ppszError = PCSL_STRING_ENOMEM == prc ? (char *)OUT_OF_MEM_ERROR : (char *)STRING_CORRUPT_ERROR; } midpFree(tempStr); return; }
/** * 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; }
static long readChars(void* state, unsigned char* buffer, long n) { long size; char* pszError; size = storageRead(&pszError, (int)state, (char*)buffer, n); storageFreeError(pszError); return size; }
/** * Opens a file and fills the content of the file in the result_buf. <BR> * This function made memory allocation inside. * * @param filename Path to the file. * @param result_buf Pointer to the buffer that will be filled by content of the file. * @return buffer file size in bytes */ long readJadFile(const pcsl_string * filename, char** result_buf) { int fd = 0; char* err = NULL; long bufsize = -1; int numread = 0; char* res = *result_buf; if (pcsl_string_length(filename) <= 0) { REPORT_INFO(LC_AMS, "readJadFile():No file name."); return BAD_PARAMS; } fd = storage_open(&err, filename, OPEN_READ); if(err != NULL) { REPORT_INFO1(LC_AMS, "readJadFile():Can't open jad file '%s'",err); storageFreeError(err); return NO_JAD_FILE; } bufsize = storageSizeOf(&err, fd); if((bufsize <= 0) || (err != NULL)) { REPORT_INFO1(LC_AMS, "readJadFile():Problem getting file size: %s", err ); storageFreeError(err); return IO_ERROR; } res = (char*)midpMalloc(bufsize+1); if (res == NULL || (err != NULL)) { REPORT_INFO1(LC_AMS, "readJadFile():Can't allocate memory. %s", err); storageFreeError(err); return OUT_OF_MEMORY; } memset(res,0,(bufsize+1)); REPORT_INFO2(LC_AMS, "fd = %d, bufsize = %ld\n", fd, bufsize); numread = storageRead(&err, fd, res, bufsize); if((numread <= 0) || (numread != bufsize) || (err)) { REPORT_INFO3(LC_AMS, "size = %ld, numread = %d, err = %s.", bufsize, numread, err); storageClose(&err, fd); return IO_ERROR; } REPORT_INFO2(LC_AMS, "size = %ld, numread = %d", bufsize, numread); storageClose(&err, fd); if(err != NULL) { REPORT_INFO1(LC_AMS, "Can't close jad file %s\n", err); } *result_buf = res; return bufsize; } /* end of readJadFile */
/** * Reads string array from the file. * * @param array_size pointer to result array length * @param strings pointer to result array * @return number of bytes read */ static int read_string_array(int* array_size, pcsl_string** strings) { int array_len; int bytes_read; pcsl_string* current_string; storageRead(&io_error_message, table_file, (char *)&array_len, sizeof(int)); storageRead(&io_error_message, table_file, (char *)array_size, sizeof(int)); bytes_read = sizeof(int) * 2; if (*array_size > 0) { *strings = alloc_pcsl_string_list(*array_size); for (current_string = *strings; bytes_read < array_len; current_string++) { bytes_read += read_string(current_string); } } else { *array_size = 0; } return bytes_read; }
bool configIsPasswordCharValid(char character, uint8_t position) { struct config config; storageRead(Storage, &config); if (config.password[position] == character) { return (true); } else { return (false); } }
/** * Copies a file. * * @param srcName source file * @param destName destination file * * @return 0 for success */ static int copyFile(const pcsl_string * srcName, const pcsl_string * destName) { char* pszError = NULL; char* pszDummy = NULL; int src; int dest; char buffer[1024]; long bytesRead; src = storage_open(&pszError, srcName, OPEN_READ); if (pszError == NULL) { dest = storage_open(&pszError, destName, OPEN_READ_WRITE_TRUNCATE); if (pszError == NULL) { bytesRead = storageRead(&pszError, src, buffer, sizeof (buffer)); while (pszError == NULL && bytesRead > 0) { storageWrite(&pszError, dest, buffer, bytesRead); if (pszError == NULL) { bytesRead = storageRead(&pszError, src, buffer, sizeof (buffer)); } } storageClose(&pszDummy, dest); storageFreeError(pszDummy); pszDummy = NULL; } storageClose(&pszDummy, src); storageFreeError(pszDummy); } if (pszError != NULL) { REPORT_ERROR1(LC_AMS, "Error while copying file: %s", pszError); storageFreeError(pszError); return -1; } return 0; }
/** * Deletes content handler information from a registry. * * @param handler_id content handler ID * @return JSR211_OK if content handler unregistered successfully */ jsr211_result jsr211_unregister_handler(const pcsl_string* handler_id) { long current_position, file_size, buffer_size; int record_size; char *buffer; if (open_table_file(1) != JSR211_OK) { return JSR211_FAILED; } if (find_next_by_field(NULL, JSR211_FIELD_ID, handler_id, JSR211_TRUE, find_exact) == -1) { close_table_file(); return JSR211_FAILED; } storageRead(&io_error_message, table_file, (char *)&record_size, sizeof(int)); current_position = storageRelativePosition(&io_error_message, table_file, -(long)sizeof(int)); file_size = storageSizeOf(&io_error_message, table_file); goto_next_record(); if (!(buffer = JSR211_MALLOC((buffer_size = file_size - current_position - record_size)))) { close_table_file(); return JSR211_FAILED; } storageRead(&io_error_message, table_file, buffer, buffer_size); storagePosition(&io_error_message, table_file, current_position); storageWrite(&io_error_message, table_file, buffer, buffer_size); JSR211_FREE(buffer); storageTruncate(&io_error_message, table_file, current_position + buffer_size); close_table_file(); return JSR211_OK; }
/** * Returns class of device and service classes saved for an * emulated device with the same address previous time. * It is considered to be the same device as current one. */ static int loadCod() { char *error; int cod = DEFAULT_COD; int handle = openCodFile(); if (-1 != handle) { storageRead(&error, handle, (char*)&cod, sizeof(int)); storageFreeError(error); } storageClose(&error, handle); storageFreeError(error); return cod; }
bool configSetTh1Timeout(uint32_t timeoutMs) { struct config config; if (storageRead(Storage, &config) != ES_ERROR_NONE) { goto SPACE_FAILURE; } config.th[1].time = timeoutMs; if (storageWrite(Storage, &config) != ES_ERROR_NONE) { goto SPACE_FAILURE; } return (true); SPACE_FAILURE: return (false); }
bool configSetTh0RawVacuum(uint32_t rawVacuum) { struct config config; if (storageRead(Storage, &config) != ES_ERROR_NONE) { goto SPACE_FAILURE; } config.th[0].rawVacuum = rawVacuum; if (storageWrite(Storage, &config) != ES_ERROR_NONE) { goto SPACE_FAILURE; } return (true); SPACE_FAILURE: return (false); }
/** * Verifies access of caller for current content handler. * Reads access restrictions from a current record and * compares it with a passed caller_id. * * @param caller_id caller * @param current_position current position of the file * @param current_size [out] size of current record * @return 1 if access is permitted */ static int check_access(const pcsl_string* caller_id, long current_position, int* current_size) { int access_len, access_ok; if ((*current_size = position_field(JSR211_CHR_ACCESSES)) <= 0) { return -1; } if (caller_id != NULL && pcsl_string_length(caller_id) > 0) { storageRelativePosition(&io_error_message, table_file, sizeof(int)); storageRead(&io_error_message, table_file, (char*)&access_len, sizeof(int)); if (!access_len) { access_ok = 1; } else { storageRelativePosition(&io_error_message, table_file, -2 * (long)sizeof(int)); access_ok = compare_array(caller_id, JSR211_TRUE, find_first); } } else { access_ok = 1; } storagePosition(&io_error_message, table_file, current_position); return access_ok; }
/** * Gets the settings of a MIDlet suite from persistent storage. * <pre> * The format of the properties file will be: * * push interrupt setting as an jbyte * length of a permissions as an int * array of permissions jbytes * push options as jint * </pre> * * @param ppszError pointer to character string pointer to accept an error * @param suiteId ID of the suite * @param pEnabled pointer to an enabled setting * @param pPushInterrupt pointer to a push interruptSetting * @param pPushOptions user options for push interrupts * @param ppPermissions pointer a pointer to accept a permissions array * @param pNumberOfPermissions pointer to an int * * @return error code (ALL_OK if successful) */ MIDPError read_settings(char** ppszError, SuiteIdType suiteId, jboolean* pEnabled, jbyte* pPushInterrupt, jint* pPushOptions, jbyte** ppPermissions, int* pNumberOfPermissions) { pcsl_string filename; int handle; int bytesRead; char* pszTemp; MIDPError status; *ppszError = NULL; *ppPermissions = NULL; *pNumberOfPermissions = 0; status = build_suite_filename(suiteId, &SETTINGS_FILENAME, &filename); if (status != ALL_OK) { return status; } handle = storage_open(ppszError, &filename, OPEN_READ); pcsl_string_free(&filename); if (*ppszError != NULL) { return IO_ERROR; } bytesRead = storageRead(ppszError, handle, (char*)pEnabled, sizeof (jboolean)); do { if (*ppszError != NULL) { status = IO_ERROR; break; } bytesRead = storageRead(ppszError, handle, (char*)pPushInterrupt, sizeof (jbyte)); if (*ppszError != NULL) { status = IO_ERROR; break; } bytesRead = storageRead(ppszError, handle, (char*)pNumberOfPermissions, sizeof (int)); if (bytesRead != sizeof (int) || *pNumberOfPermissions == 0) { status = IO_ERROR; break; } *ppPermissions = (jbyte*)pcsl_mem_malloc( *pNumberOfPermissions * sizeof (jbyte)); if (*ppPermissions == NULL) { status = OUT_OF_MEMORY; break; } bytesRead = storageRead(ppszError, handle, (char*)(*ppPermissions), *pNumberOfPermissions * sizeof (jbyte)); if (bytesRead != *pNumberOfPermissions) { *pNumberOfPermissions = 0; pcsl_mem_free(*ppPermissions); status = SUITE_CORRUPTED_ERROR; break; } /* Old versions of the file may not have options. */ status = ALL_OK; *pPushOptions = 0; bytesRead = storageRead(ppszError, handle, (char*)pPushOptions, sizeof (jint)); if (*ppszError != NULL) { storageFreeError(*ppszError); *ppszError = NULL; break; } } while (0); storageClose(&pszTemp, handle); storageFreeError(pszTemp); return status; }
/** * Retrieves the list of strings in a file. * The file has the number of strings at the front, each string * is a length and the jchars. * * @param ppszError pointer to character string pointer to accept an error * @param pFilename name of the file of strings * @param paList pointer to an array of pcsl_strings, free with * free_pcsl_string_list * @param pStringNum number of strings if successful (can be 0) * * @return error code (ALL_OK if successful) */ static MIDPError get_string_list(char** ppszError, const pcsl_string* pFilename, pcsl_string** paList, int* pStringNum) { char* pszTemp; int i = 0; int handle; int numberOfStrings = 0; pcsl_string* pStrings = NULL; MIDPError status = ALL_OK; *ppszError = NULL; *paList = NULL; *pStringNum = 0; handle = storage_open(ppszError, pFilename, OPEN_READ); if (*ppszError != NULL) { return IO_ERROR; } do { storageRead(ppszError, handle, (char*)&numberOfStrings, sizeof (numberOfStrings)); if (*ppszError != NULL) { status = IO_ERROR; break; } if (numberOfStrings == 0) { break; } pStrings = alloc_pcsl_string_list(numberOfStrings); if (pStrings == NULL) { status = OUT_OF_MEMORY; break; } for (i = 0; i < numberOfStrings; i++) { pStrings[i] = PCSL_STRING_NULL; } for (i = 0; i < numberOfStrings; i++) { storage_read_utf16_string(ppszError, handle, &pStrings[i]); if (*ppszError != NULL) { status = IO_ERROR; break; } } if (i != numberOfStrings) { status = SUITE_CORRUPTED_ERROR; break; } } while (0); storageClose(&pszTemp, handle); storageFreeError(pszTemp); if (status == ALL_OK) { *paList = pStrings; *pStringNum = numberOfStrings; } else if (pStrings != NULL) { free_pcsl_string_list(pStrings, i); } return status; }
javacall_result bt_push_startup() { int i; char *error; pcsl_string full_name = PCSL_STRING_NULL; int storage; REPORT_INFO(LC_PUSH, "Bluetooth PushRegistry is now starting."); javacall_bt_sddb_initialize(); pcsl_string_cat(storage_get_root(INTERNAL_STORAGE_ID), &BT_PUSH_FILENAME, &full_name); if (!storage_file_exists(&full_name)) { pcsl_string_free(&full_name); return JAVACALL_OK; } storage = storage_open(&error, &full_name, OPEN_READ); pcsl_string_free(&full_name); if (error != NULL) { REPORT_ERROR1(LC_PUSH, "Failed to open `BtPush' file: %s", error); storageFreeError(error); return JAVACALL_FAIL; } storageRead(&error, storage, (char *)&g_count, sizeof(g_count)); for (i = 0; error == NULL && i < g_count; i++) { bt_push_t *push = (bt_push_t *)pcsl_mem_malloc(sizeof(bt_push_t)); if (push == NULL) { REPORT_ERROR(LC_PUSH, "Failed to allocate memory."); storageClose(&error, storage); storageFreeError(error); return JAVACALL_FAIL; } storageRead(&error, storage, (char *)&push->port, sizeof(push->port)); if (error != NULL) { pcsl_mem_free(push); break; } storageRead(&error, storage, (char *)&push->params, sizeof(push->params)); if (error != NULL) { pcsl_mem_free(push); break; } storageRead(&error, storage, (char *)&push->record.classes, sizeof(push->record.classes)); if (error != NULL) { pcsl_mem_free(push); break; } storageRead(&error, storage, (char *)&push->record.size, sizeof(push->record.size)); if (error != NULL) { pcsl_mem_free(push); break; } push->record.data = pcsl_mem_malloc(push->record.size); if (push->record.data == NULL) { pcsl_mem_free(push); REPORT_ERROR(LC_PUSH, "Failed to allocate memory."); storageClose(&error, storage); storageFreeError(error); return JAVACALL_FAIL; } storageRead(&error, storage, (char *)push->record.data, push->record.size); if (error != NULL) { pcsl_mem_free(push->record.data); pcsl_mem_free(push); break; } storageRead(&error, storage, (char *)&push->record.id, sizeof(push->record.id)); if (error != NULL) { pcsl_mem_free(push); break; } push->server = BT_INVALID_HANDLE; push->client = NULL; push->next = g_registry; g_registry = push; } if (error != NULL) { REPORT_ERROR1(LC_PUSH, "Error reading `BtPush' file: %s", error); storageFreeError(error); storageClose(&error, storage); storageFreeError(error); return JAVACALL_FAIL; } REPORT_INFO1(LC_PUSH, "%d record(s) read.", g_count); storageClose(&error, storage); storageFreeError(error); if (g_count > 0) { /* Attempt to enable Bluetooth radio, if it is not already on. */ javacall_bool enabled; javacall_bt_stack_initialize(); if (javacall_bt_stack_is_enabled(&enabled) == JAVACALL_OK && enabled == JAVACALL_FALSE) { javacall_bt_stack_enable(); } } return JAVACALL_OK; }
/** * Loads the properties of a MIDlet suite from persistent storage. * * @param suiteId ID of the suite * @param pJadProps [out] pointer to a structure containing an array of strings, * in a pair pattern of key and value; NULL may be passed if it is not required * to read JAD properties * @param pJarProps [out] pointer to a structure containing an array of strings, * in a pair pattern of key and value; NULL may be passed if it is not required * to read JAR properties * * @return error code (ALL_OK for success) */ MIDPError load_install_properties(SuiteIdType suiteId, MidpProperties* pJadProps, MidpProperties* pJarProps) { pcsl_string filename; char* pszError = NULL; int handle, i, n; int numberOfProps; MIDPError status; status = get_property_file(suiteId, KNI_TRUE, &filename); if (status != ALL_OK) { return status; } handle = storage_open(&pszError, &filename, OPEN_READ); pcsl_string_free(&filename); if (pszError != NULL) { storageFreeError(pszError); return IO_ERROR; } status = ALL_OK; /* Read JAD, then JAR properties. */ for (n = 0; n < 2; n++) { MidpProperties *pProps = n ? pJarProps : pJadProps; if (!pProps) { continue; } storageRead(&pszError, handle, (char*)&numberOfProps, sizeof (numberOfProps)); if (pszError != NULL) { break; } pProps->pStringArr = alloc_pcsl_string_list(numberOfProps << 1); for (i = 0; i < numberOfProps << 1; i++) { storage_read_utf16_string(&pszError, handle, &pProps->pStringArr[i]); if (pszError != NULL) { break; } } if (pszError != NULL) { break; } pProps->numberOfProperties = numberOfProps; } if (pszError != NULL) { status = IO_ERROR; storageFreeError(pszError); } storageClose(&pszError, handle); storageFreeError(pszError); if (status != ALL_OK) { if (pJadProps) { free_pcsl_string_list(pJadProps->pStringArr, pJadProps->numberOfProperties << 1); } if (pJarProps) { free_pcsl_string_list(pJarProps->pStringArr, pJarProps->numberOfProperties << 1); } } return status; }
KNIEXPORT KNI_RETURNTYPE_VOID KNIDECL(com_sun_midp_chameleon_skins_resources_LoadedSkinData_beginReadingSkinFile) { const unsigned char* skin_description = lfj_get_skin_description(); if (skin_description != NULL) { gsSkinFileDataStart = gsSkinFileDataPos = (unsigned char*)skin_description; gsSkinFileDataEnd = gsSkinFileDataStart + lfj_get_skin_description_size(); } else { char* errorStr = NULL; int fileHandle = -1; int fileSize; int bytesRead; jfieldID fid; KNI_StartHandles(2); KNI_DeclareHandle(classHandle); KNI_GetClassPointer(classHandle); fid = KNI_GetStaticFieldID(classHandle, "STRING_ENCODING_USASCII", "B"); STRING_ENCODING_USASCII = (unsigned char) KNI_GetStaticByteField(classHandle, fid); fid = KNI_GetStaticFieldID(classHandle, "STRING_ENCODING_UTF8", "B"); STRING_ENCODING_UTF8 = (unsigned char) KNI_GetStaticByteField(classHandle, fid); GET_PARAMETER_AS_PCSL_STRING(1, fileName); do { /* * Open skin file */ fileHandle = storage_open(&errorStr, &fileName, OPEN_READ); if (errorStr != NULL) { KNI_ThrowNew(midpIOException, errorStr); storageFreeError(errorStr); break; } /* * Obtain file size */ fileSize = storageSizeOf(&errorStr, fileHandle); if (errorStr != NULL) { KNI_ThrowNew(midpIOException, errorStr); storageFreeError(errorStr); break; } /* * Read whole file into heap memory */ gsSkinFileDataStart = (unsigned char*)midpMalloc(fileSize); if (gsSkinFileDataStart == NULL) { KNI_ThrowNew(midpOutOfMemoryError, NULL); break; } bytesRead = storageRead(&errorStr, fileHandle, (char*)gsSkinFileDataStart, fileSize); if (errorStr != NULL) { KNI_ThrowNew(midpIOException, errorStr); storageFreeError(errorStr); midpFree(gsSkinFileDataStart); gsSkinFileDataStart = NULL; break; } if (bytesRead != fileSize) { KNI_ThrowNew(midpIOException, "Failed to read whole file"); midpFree(gsSkinFileDataStart); gsSkinFileDataStart = NULL; break; } gsSkinFileDataPos = gsSkinFileDataStart; gsSkinFileDataEnd = gsSkinFileDataStart + fileSize; } while (0); RELEASE_PCSL_STRING_PARAMETER; /* * Close skin file */ if (fileHandle != -1) { storageClose(&errorStr, fileHandle); } KNI_EndHandles(); } KNI_ReturnVoid(); }
/** * Reads in a property file and makes the key/value pairs available * to MIDP as a property set. * * @param fd An open file descriptor of the property file to read. * @param props A property set to hold the key/value pairs read from * the property file. * @return <tt>0</tt> for success, otherwise <tt>-1</tt> */ static int parseConfig(int fd, Property** props) { char *buffer; int bufferSize; int i; int j; int key_index; int value_index; int len; char *errStr = NULL; int startPos; int endPos; bufferSize = storageSizeOf(&errStr, fd); buffer = (char *)midpMalloc(bufferSize); if (buffer == NULL) { REPORT_WARN(LC_CORE, "midpMalloc failed to allocate buffer for config file."); return -1; } /* Read the config file in one pass */ len = storageRead(&errStr, fd, buffer, bufferSize); if ((errStr != NULL) || (len != bufferSize)) { REPORT_WARN1(LC_CORE, "Warning: can not read config file: %s", errStr); storageFreeError(errStr); midpFree(buffer); return 0; } startPos = 0; for (i = startPos; i < bufferSize; i++) { if (buffer[i] == '\n') { buffer[i] = 0; /* Skip comment lines which begin with '#'*/ if (buffer[startPos] != '#') { /* Parse the line */ key_index = startPos; for (j = key_index; buffer[j]; j++){ Property *prop; if (buffer[j] == ':') { buffer[j] = 0; value_index = ++j; prop = (Property *) midpMalloc(sizeof(Property)); if (NULL != prop) { char *key, *value; key = midpStrdup(buffer + key_index); value = midpStrdup(buffer + value_index); /* trim leading and trailing white spaces */ trim_WhiteSpace(key); trim_WhiteSpace(value); prop->next = *props; prop->key = key; prop->value = value; if ((prop->key == NULL) || (prop->value == NULL)) { midpFree((void*)prop->key); midpFree((void*)prop->value); midpFree(prop); /* * since we are freeing memory, we're not * exactly out of memory at this point */ break; } *props = prop; } break; } } } endPos = i; startPos = endPos + 1; } } midpFree(buffer); return 0; }