/** * Converts the given suite ID to array of chars. * NOTE: this function returns a pointer to the static buffer! * * @param value suite id to convert * * @return char[] representation of the given suite ID * or NULL in case of error. */ const char* midp_suiteid2chars(SuiteIdType value) { jsize resLen; static jbyte resChars[GET_SUITE_ID_LEN(value) + 1]; /* +1 for last zero */ const pcsl_string* pResString = midp_suiteid2pcsl_string(value); pcsl_string_status rc; rc = pcsl_string_convert_to_utf8(pResString, resChars, (jsize)SUITESTORE_COUNTOF(resChars), &resLen); return (rc == PCSL_STRING_OK) ? (char*)&resChars : NULL; }
/** * The getUsedSpace function checks the size of used space by * all of the files that are contained in the directory. */ long pcsl_file_getusedspace(const pcsl_string * dirName) { DIR *dir; long size; struct dirent *de; struct stat stat_buf; char filename[PCSL_FILE_MAX_NAME_LEN + 1]; int rootLen; int exists; dir = (DIR *)pcsl_file_opendir(dirName); if (dir == NULL) { return 0; } size = 0; { if (pcsl_string_convert_to_utf8(dirName, (jbyte*)filename, sizeof(filename), NULL) != PCSL_STRING_OK) { pcsl_file_closedir(dir); return 0; } rootLen = strlen(filename); for (de = readdir(dir); de != NULL; de = readdir(dir), filename[rootLen] = 0) { if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0) { continue; } strncat(filename, de->d_name, sizeof (filename) - 1 - rootLen); exists = stat(filename, &stat_buf); if (exists != -1 && !S_ISDIR(stat_buf.st_mode)) { size += stat_buf.st_size; } } pcsl_file_closedir(dir); return size; } }
/** * Parses a value of MIDP_CONTROL_ARGS property from the midlet suite's * JAD file. Syntax of this property is defined by the following grammar: * <pre> * JAD_CONTROL_PARAM = "MIDP_CONTROL_ARGS" EQUAL *( ";" param) * param = report_level_param / log_channels_param / permissions_param / * trace_param / assert_param * report_level_param = "report_level" EQUAL 1*DIGIT * log_channels_param = "log_channels" EQUAL 1*DIGIT *( "," 1*DIGIT) * permissions_param = "allow_all_permissions" * trace_param = "enable_trace" EQUAL bool_val * assert_param = "enable_trace" EQUAL bool_val * bool_val = 0 / 1 * </pre> * * @param pJadProps properties of the midlet suite from its jad file * @param pJadArgs [out] buffer where to store pointers to the name and value of * each control argument * @param maxJadArgs maximal number of arguments that the output buffer can hold */ void parse_control_args_from_jad(const MidpProperties* pJadProps, MIDP_JAD_CONTROL_ARGS* pJadArgs, int maxJadArgs) { int i, currArgNum = 0; int numOfJadProps = pJadProps ? pJadProps->numberOfProperties : 0; /* MIDP_CONTROL_ARGS */ PCSL_DEFINE_STATIC_ASCII_STRING_LITERAL_START(propertyName) { 'M', 'I', 'D', 'P', '_', 'C', 'O', 'N', 'T', 'R', 'O', 'L', '_', 'A', 'R', 'G', 'S', '\0' } PCSL_DEFINE_STATIC_ASCII_STRING_LITERAL_END(propertyName); static jbyte propValue[128]; /* buffer to hold MIDP_ARGS jad property */ for (i = 0; i < (numOfJadProps << 1); i++, i++) { if (pcsl_string_equals(&pJadProps->pStringArr[i], &propertyName)) { const char *pCurr; int propLen = pcsl_string_utf8_length(&pJadProps->pStringArr[i+1]); int start_pos, pos = 0; if (pcsl_string_convert_to_utf8(&pJadProps->pStringArr[i+1], propValue, sizeof(propValue), NULL) != PCSL_STRING_OK) { break; } /* Parse the value of MIDP_CONTROL_ARGS jad property. */ pCurr = (const char*)propValue; while (pos < propLen && currArgNum < maxJadArgs) { /* skip spaces */ if (*pCurr == ' ') { pCurr++; pos++; continue; } pJadArgs[currArgNum].pArgName = pCurr; start_pos = pos; /* look for "=", ";" or end-of-line) */ while (pos < propLen && *pCurr) { if (*pCurr == '=') { pos++; pJadArgs[currArgNum].pArgValue = ++pCurr; break; } else if (*pCurr == ';') { pJadArgs[currArgNum].pArgValue = NULL; break; } pos++; pCurr++; } pJadArgs[currArgNum].argNameLen = pos - start_pos - 1; /* look for the next delimeter (";" or end-of-line) */ while (pos < propLen && *pCurr) { pos++; if (*pCurr++ == ';') { break; } } currArgNum++; } /* end while */ break; } /* end if MIDP_ARGS property found in JAD */ } /* end for each property */ pJadArgs[currArgNum].pArgName = pJadArgs[currArgNum].pArgValue = NULL; pJadArgs[currArgNum].argNameLen = 0; }
/** * Get size in bytes of all files and possibly subdirectories contained * in the specified dir. * * @param pathName full directory path * @param pathNameLen length of path name * @param includeSubdirs if 0, do not include subdirectories, * otherwise include subdirectories size too * @param result returned value: size in bytes of all files contained in * the specified directory and possibly its subdirectories * @return 0 on success, -1 otherwise */ int fileconnection_dir_content_size(const jchar* pathName, int pathNameLen, int includeSubdirs, jlong* /* OUT */ result) { char subSearch[MAX_FILE_NAME_LENGTH]; int subSearchLen; struct dirent *dir_data; struct stat stat_buf; int status; jlong contentSize = 0; DIR* listHandle[MAX_DIRECTORY_NESTING_LEVEL]; int pathLen[MAX_DIRECTORY_NESTING_LEVEL]; int nestLevel = 0; int nextExists; pcsl_string name = PCSL_STRING_NULL; if (PCSL_STRING_OK != pcsl_string_convert_from_utf16(pathName, pathNameLen, &name)) { return -1; } if (PCSL_STRING_OK != pcsl_string_convert_to_utf8(&name, (jbyte*)subSearch, MAX_FILE_NAME_LENGTH, &subSearchLen)) { pcsl_string_free(&name); return -1; } pcsl_string_free(&name); listHandle[0] = opendir(subSearch); pathLen[0] = subSearchLen; if (NULL == listHandle[0]) { /* Cannot open directory */ return -1; } dir_data = readdir(listHandle[0]); nextExists = (NULL != dir_data); for ( ; ; ) { while (nextExists) { subSearch[pathLen[nestLevel]] = '/'; subSearch[pathLen[nestLevel] + 1] = 0; strcat(subSearch, dir_data->d_name); status = stat(subSearch, &stat_buf); if (status < 0) { /* Failed to get file status */ while (nestLevel >= 0) { closedir(listHandle[nestLevel--]); } return -1; } if (S_ISDIR(stat_buf.st_mode)) { /* Found subdirectory */ if (includeSubdirs) { /* Must count subdirectory sizes */ if (strcmp(dir_data->d_name, ".") && strcmp(dir_data->d_name, "..")) { /* The subdirectory is not "." or ".." */ int dirNameLen = strlen(dir_data->d_name); if (nestLevel >= MAX_DIRECTORY_NESTING_LEVEL - 1) { /* Nesting level overflow */ while (nestLevel >= 0) { closedir(listHandle[nestLevel--]); } return -1; } pathLen[nestLevel + 1] = pathLen[nestLevel] + dirNameLen + 1; listHandle[++nestLevel] = opendir(subSearch); if (NULL == listHandle[nestLevel]) { /* Cannot open subdirectory */ while (--nestLevel >= 0) { closedir(listHandle[nestLevel]); } return -1; } } } } else { contentSize += stat_buf.st_size; } dir_data = readdir(listHandle[nestLevel]); nextExists = (NULL != dir_data); } closedir(listHandle[nestLevel]); if (nestLevel == 0) { break; } dir_data = readdir(listHandle[--nestLevel]); nextExists = (NULL != dir_data); } *result = contentSize; return 0; }