예제 #1
0
파일: OsFile.cpp 프로젝트: jiangxilong/yari
bool OsFile_rename(const JvmPathChar *from, const JvmPathChar *to) {
  const int from_name_len = fn_strlen(from);
  const int to_name_len = fn_strlen(to);
  pcsl_string pcsl_filename_from = PCSL_STRING_NULL;
  pcsl_string pcsl_filename_to = PCSL_STRING_NULL;

  GUARANTEE(sizeof(jchar) == sizeof(JvmPathChar), "Types must match");

  if (pcsl_string_convert_from_utf16(from, 
                                     from_name_len, 
                                     &pcsl_filename_from) != PCSL_STRING_OK) {
    return -1;
  }

  if (pcsl_string_convert_from_utf16(to, 
                                     to_name_len, 
                                     &pcsl_filename_to) != PCSL_STRING_OK) {
    return -1;
  }

  int result = pcsl_file_rename(&pcsl_filename_from, &pcsl_filename_to);

  pcsl_string_free(&pcsl_filename_from);
  pcsl_string_free(&pcsl_filename_to);

  return (result == 0) ? true : false;
}
extern "C" MidpError
QString2pcsl_string(QString &qstring, pcsl_string &pstring) {
    pcsl_string_status pe;
    if (qstring.isNull()) {
	    pstring = PCSL_STRING_NULL;
    } else if (qstring.isEmpty()) {
	    pstring = PCSL_STRING_EMPTY;
    } else {
        jint mstring_len = qstring.length();
        jchar* mstring_data = (jchar *)midpMalloc(sizeof(jchar) * mstring_len);
        if (mstring_data == NULL) {
	        pstring = PCSL_STRING_NULL;
            return KNI_ENOMEM;
        } else {
            for (int i = 0; i < mstring_len; i++) {
            mstring_data[i] = qstring[i].unicode();
            }
            pe = pcsl_string_convert_from_utf16(mstring_data,
                                                mstring_len, &pstring);
            midpFree(mstring_data);
            if (PCSL_STRING_OK != pe) {
                return KNI_ENOMEM;
            }
        }
    }
    return KNI_OK;
}
예제 #3
0
/**
 * 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);
}
예제 #4
0
파일: rms.c 프로젝트: jiangxilong/yari
/**
 * Perform the reverse conversion of unicodeToEscapedAscii().
 *
 * @param str a string previously returned by escape()
 * @return the original string before the conversion by escape().
 */
static pcsl_string_status
escaped_ascii_to_unicode(const pcsl_string* str, pcsl_string* result) {
    int result_len=0;
    jchar* result_data = NULL;
    pcsl_string_status status = PCSL_STRING_OK;
    GET_PCSL_STRING_DATA_AND_LENGTH(str) do {
        int i;

        result_data = (jchar*)midpMalloc(str_len * sizeof (jchar));

        if (result_data == NULL) {
            status = PCSL_STRING_ENOMEM;
            break;
        }

        for (i = 0, result_len = 0; i < str_len; i++) {
            jchar c = str_data[i];

            if (c == '%') {
                jchar v = 0;

                v += hexValue(str_data[i+1]);
                v <<= 4;
                v += hexValue(str_data[i+2]);
                v <<= 4;
                v += hexValue(str_data[i+3]);
                v <<= 4;
                v += hexValue(str_data[i+4]);

                i += 4;

                result_data[result_len] = v;
                result_len++;
            } else if (c == '#') {
                /* drop c */
            } else {
                result_data[result_len] = c;
                result_len++;
            }
        }

    } while(0); RELEASE_PCSL_STRING_DATA_AND_LENGTH

    if (PCSL_STRING_OK == status) {
        if (PCSL_STRING_OK !=
                pcsl_string_convert_from_utf16(result_data, result_len, result)) {
            status = PCSL_STRING_ENOMEM;
        }
    }
    midpFree(result_data);
    return status;
}
예제 #5
0
/**
 * Reads a line from a jad file.
 *
 * @param jadbuf pointer to the jad jchar_buffer; this pointer will move to
 *               the next line
 * @param result pointer to pcsl_string where the new line from jad file
 *               will be stored, the caller is responsible for freeing this
 *               string
 * @return error code
 */
static MIDPError readJadLine(jchar** jadbuf, pcsl_string * result) {

    jchar* lineStart = NULL;
    jchar* p = NULL;
    int count = 0;

    /* will use p to avoid all the *(*jadbuf) stuff and make it more readable */
    p = (*jadbuf);

    if (!(*p)) {
        /* end of jchar_buffer */
        *result = PCSL_STRING_NULL;
        return END_OF_JAD;
    }

    /* skip commented out and blank lines */
    while (COMMENTED_OUT(p) || NEW_LINE(p)) {
        while (!NEW_LINE(p)) {
            /* skip commented out line */
            p++;
        }
        while (NEW_LINE(p)) {
            /* skip new line */
            p++;
        }
    }

    lineStart = p;

    for (;*p ; ) {
        count++;
        p++;
        if (NEW_LINE(p)) {
            *p = 0x00; /* cut the line */
            if (*(p+1)) { /* if not end of jchar_buffer */
                p++; /* point to the next line beginning */
                break;
            } /* end of if */
        } /* end of if */
    } /* end of for */

    /* move jadbuf to point to the next line */
    (*jadbuf) = p;

    if (PCSL_STRING_OK !=
        pcsl_string_convert_from_utf16(lineStart, count, result)) {
        return OUT_OF_MEMORY;
    }

    return ALL_OK;
} /* end of readJadLine */
예제 #6
0
파일: OsFile.cpp 프로젝트: jiangxilong/yari
// Disabled temporarily - pcsl_file_exist does not distinguish between
// directory and "file".
bool OsFile_exists(const JvmPathChar *filename) {
  int name_len = fn_strlen(filename);
  pcsl_string pcsl_filename = PCSL_STRING_NULL;

  GUARANTEE(sizeof(jchar) == sizeof(JvmPathChar), "Types must match");

  if (pcsl_string_convert_from_utf16(filename, 
                                     name_len, 
                                     &pcsl_filename) != PCSL_STRING_OK) {
    return false;
  }

  jboolean result = pcsl_file_exist(&pcsl_filename);
  pcsl_string_free(&pcsl_filename);

  return result;
}
예제 #7
0
파일: midpStorage.c 프로젝트: sfsy1989/j2me
/**
 * 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;
}
예제 #8
0
파일: OsFile.cpp 프로젝트: jiangxilong/yari
int OsFile_remove(const JvmPathChar * filename) {
  int name_len = fn_strlen(filename);
  pcsl_string pcsl_filename = PCSL_STRING_NULL;

  GUARANTEE(sizeof(jchar) == sizeof(JvmPathChar), "Types must match");

  if (pcsl_string_convert_from_utf16(filename, 
                                     name_len, 
                                     &pcsl_filename) != PCSL_STRING_OK) {
    return -1;
  }

  int result = pcsl_file_unlink(&pcsl_filename);

  pcsl_string_free(&pcsl_filename);

  return result;
}
예제 #9
0
파일: OsFile.cpp 프로젝트: jiangxilong/yari
OsFile_Handle OsFile_open(const JvmPathChar *filename, const char *mode) {
  int name_len = fn_strlen(filename);
  pcsl_string pcsl_filename = PCSL_STRING_NULL;

  GUARANTEE(sizeof(jchar) == sizeof(JvmPathChar), "Types must match");

  if (pcsl_string_convert_from_utf16(filename, 
                                     name_len, 
                                     &pcsl_filename) != PCSL_STRING_OK) {
    return NULL;
  }

/*
  int pcsl_flags = (*mode == 'w') ? (PCSL_FILE_O_CREAT|PCSL_FILE_O_WRONLY|
                                     PCSL_FILE_O_TRUNC) :
                                    (PCSL_FILE_O_RDONLY);
*/

  int pcsl_flags;
  if(*mode == 'w') { 
    pcsl_flags = (PCSL_FILE_O_CREAT | PCSL_FILE_O_WRONLY | PCSL_FILE_O_TRUNC);
  } else if(*mode == 'a') {
    pcsl_flags = (PCSL_FILE_O_WRONLY | PCSL_FILE_O_APPEND);
  } else {
    pcsl_flags = PCSL_FILE_O_RDONLY;
  }

  void *pcsl_handle;
  if (pcsl_file_open(&pcsl_filename, pcsl_flags, &pcsl_handle) == 0) {
    pcsl_string_free(&pcsl_filename);
    OsFile_Handle handle =
      (OsFile_Handle)pcsl_mem_malloc(sizeof(struct _OsFile_Handle));
    if (handle) {
      handle->pcsl_handle = pcsl_handle;
    } else {
      pcsl_file_close(pcsl_handle);
    }
    return handle;
  } else {
    pcsl_string_free(&pcsl_filename);
    return NULL;
  }
}
예제 #10
0
static int findNextMatch(PCSLFileIterator* pIterator,
                         const pcsl_string * match,
                         pcsl_string * result) {
    WIN32_FIND_DATAW findData;
    pcsl_string root = PCSL_STRING_NULL;
    pcsl_string foundName = PCSL_STRING_NULL;
    jsize rootLen = 0;

    if (result == NULL) {
      return -1;
    }

    * result = PCSL_STRING_NULL;

    if (!FindNextFileW(pIterator->iteratorHandle, &findData)) {
	return -1;
    }

    rootLen = pIterator->savedRootLength;

    if (pcsl_string_substring(match, 0, rootLen, &root) != PCSL_STRING_OK) {
      return -1;
    }

    if (pcsl_string_convert_from_utf16(findData.cFileName,
				       wcslen(findData.cFileName),
				       &foundName) != PCSL_STRING_OK) {
      pcsl_string_free(&root);    
      return -1;
    }

    if (pcsl_string_cat(&root, &foundName, result) != PCSL_STRING_OK) {
      pcsl_string_free(&foundName);    
      pcsl_string_free(&root);    
      return -1;
    }

    pcsl_string_free(&foundName);    
    pcsl_string_free(&root);

    return 0;
}
예제 #11
0
/**
 * Create pcsl_string from the specified Java String object.
 * The caller is responsible for freeing the created pcsl_string when done.
 *
 * @param java_str pointer to the Java String instance
 * @param pcsl_str pointer to the pcsl_string instance
 * @return status of the operation
 */
pcsl_string_status midp_jstring_to_pcsl_string(jstring java_str,
					       pcsl_string * pcsl_str) {
  if (pcsl_str == NULL) {
    return PCSL_STRING_EINVAL;
  }

  if (KNI_IsNullHandle(java_str)) {
    * pcsl_str = PCSL_STRING_NULL;
    return PCSL_STRING_OK;
  } else {
    const jsize length  = KNI_GetStringLength(java_str);

    if (length < 0) {
      * pcsl_str = PCSL_STRING_NULL;
      return PCSL_STRING_ERR;
    } else if (length == 0) {
      * pcsl_str = PCSL_STRING_EMPTY;
      return PCSL_STRING_OK;
    } else {
      jchar * buffer = pcsl_mem_malloc(length * sizeof(jchar));

      if (buffer == NULL) {
	* pcsl_str = PCSL_STRING_NULL;
	return PCSL_STRING_ENOMEM;
      }

      KNI_GetStringRegion(java_str, 0, length, buffer);

      {
	pcsl_string_status status =
	  pcsl_string_convert_from_utf16(buffer, length, pcsl_str);

	pcsl_mem_free(buffer);

	return status;
      }
    }
  }
}
예제 #12
0
/**
 * Create pcsl_string from the specified KNI CharArray object.
 * The caller is responsible for freeing the created pcsl_string when done.
 *
 * @param java_arr pointer to the KNI CharArray instance
 * @param length length of the text in the CharArray
 * @param pcsl_str pointer to the pcsl_string instance
 * @return status of the operation
 */
pcsl_string_status
midp_jchar_array_to_pcsl_string(jcharArray java_arr, jint length,
                                pcsl_string * pcsl_str) {
    if (pcsl_str == NULL) {
        return PCSL_STRING_EINVAL;
    }

    if (KNI_IsNullHandle(java_arr)) {
        *pcsl_str = PCSL_STRING_NULL;
        return PCSL_STRING_OK;
    } else if (length < 0) {
        *pcsl_str = PCSL_STRING_NULL;
        return PCSL_STRING_ERR;
    } else if (length == 0) {
        *pcsl_str = PCSL_STRING_EMPTY;
        return PCSL_STRING_OK;
    } else {
        jchar * buffer = pcsl_mem_malloc(length * sizeof(jchar));

        if (buffer == NULL) {
              * pcsl_str = PCSL_STRING_NULL;
            return PCSL_STRING_ENOMEM;
        }

          KNI_GetRawArrayRegion(java_arr, 0,
                                          length * sizeof(jchar),
                                          (jbyte *) buffer);

        {
            pcsl_string_status status =
                  pcsl_string_convert_from_utf16(buffer, length, pcsl_str);

              pcsl_mem_free(buffer);

            return status;
        }
    }
}
예제 #13
0
파일: fcCleanup.c 프로젝트: sfsy1989/j2me
/**
 * The function is called upon MIDlet suite removal.
 * It deletes suites's private directory and all it's content.
 *
 * @param suiteId the ID of MIDlet suite
 */
void jsr75_suite_remove_cleanup(SuiteIdType suiteId)
{
    const pcsl_string* pStg = storage_get_root(INTERNAL_STORAGE_ID);
    const jchar jsep = pcsl_file_getfileseparator();

    pcsl_string dirName1 = PCSL_STRING_NULL;
    pcsl_string dirName2 = PCSL_STRING_NULL;
    pcsl_string dirName  = PCSL_STRING_NULL;
    pcsl_string sep      = PCSL_STRING_NULL;

    if (pcsl_string_convert_from_utf16(&jsep, 1, &sep) != PCSL_STRING_OK) {
        return;
    }
    if (pcsl_string_cat(pStg, &privateDir, &dirName1) != PCSL_STRING_OK) {
        pcsl_string_free(&sep);
        return;
    }
    if (pcsl_string_cat(&dirName1, &sep, &dirName2) != PCSL_STRING_OK) {
        pcsl_string_free(&sep);
        pcsl_string_free(&dirName1);
        return;
    }
    if (pcsl_string_cat(&dirName2, midp_suiteid2pcsl_string(suiteId),
            &dirName) != PCSL_STRING_OK) {
        pcsl_string_free(&sep);
        pcsl_string_free(&dirName1);
        pcsl_string_free(&dirName2);
        return;
    }
    pcsl_string_free(&dirName1);
    pcsl_string_free(&dirName2);

    do_cleanup(&dirName, &sep);

    pcsl_string_free(&sep);
    pcsl_string_free(&dirName);
}
예제 #14
0
/**
 * Reads the file with information about the installed suites.
 *
 * Note that if the value of the global variable g_numberOfSuites
 * is zero, this function does nothing.
 *
 * @param ppszError pointer to character string pointer to accept an error
 *
 * @return status code: ALL_OK if no errors,
 *         OUT_OF_MEMORY if malloc failed
 *         IO_ERROR if an IO_ERROR,
 *         SUITE_CORRUPTED_ERROR if the suite database is corrupted
 */
MIDPError
read_suites_data(char** ppszError) {
    MIDPError status;
    int i;
    long bufferLen, pos;
    char* buffer = NULL;
    pcsl_string_status rc;
    pcsl_string suitesDataFile;
    MidletSuiteData *pSuitesData = g_pSuitesData;
    MidletSuiteData *pData, *pPrevData = NULL;
    int numOfSuites = 0;

    *ppszError = NULL;

    if (g_isSuitesDataLoaded) {
        return ALL_OK;
    }

    if (midpInit(LIST_LEVEL) != 0) {
        return OUT_OF_MEMORY;
    }

    /* get a full path to the _suites.dat */
    rc = pcsl_string_cat(storage_get_root(INTERNAL_STORAGE_ID),
                         &SUITE_DATA_FILENAME, &suitesDataFile);
    if (rc != PCSL_STRING_OK) {
        return OUT_OF_MEMORY;
    }

    /* read the file */
    status = read_file(ppszError, &suitesDataFile, &buffer, &bufferLen);
    pcsl_string_free(&suitesDataFile);

    if (status == NOT_FOUND || (status == ALL_OK && bufferLen == 0)) {
        /* _suites.dat is absent or empty, it's a normal situation */
        g_pSuitesData        = NULL;
        g_numberOfSuites     = 0;
        g_isSuitesDataLoaded = 1;
        return ALL_OK;
    }

    if (status == ALL_OK && bufferLen < (long) sizeof(int)) {
        pcsl_mem_free(buffer);
        status = SUITE_CORRUPTED_ERROR; /* _suites.dat is corrupted */
    }
    if (status != ALL_OK) {
        return status;
    }

    /* parse contents of the suite database */
    pos = 0;
    numOfSuites = *(int*)&buffer[pos];
    ADJUST_POS_IN_BUF(pos, bufferLen, sizeof(int));

    for (i = 0; i < numOfSuites; i++) {
        pData = (MidletSuiteData*) pcsl_mem_malloc(sizeof(MidletSuiteData));
        if (!pData) {
            status = OUT_OF_MEMORY;
            break;
        }

        if (pPrevData) {
            pPrevData->nextEntry = pData;
        } else {
            pSuitesData = pData;
        }

        /* IMPL_NOTE: introduce pcsl_mem_copy() */
        if (bufferLen < (long)MIDLET_SUITE_DATA_SIZE) {
            status = IO_ERROR;
            break;
        }
        memcpy((char*)pData, (char*)&buffer[pos], MIDLET_SUITE_DATA_SIZE);
        ADJUST_POS_IN_BUF(pos, bufferLen, MIDLET_SUITE_DATA_SIZE);

        pData->nextEntry = NULL;

        /* this suite was not checked if it is corrupted */
        pData->isChecked = 0;

        /* setup pJarHash */
        if (pData->jarHashLen > 0) {
            pData->varSuiteData.pJarHash = (unsigned char*)pcsl_mem_malloc(pData->jarHashLen);
            if (pData->varSuiteData.pJarHash == NULL) {
                status = OUT_OF_MEMORY;
                break;
            }
            memcpy(pData->varSuiteData.pJarHash, (char*)&buffer[pos],
                pData->jarHashLen);
            ADJUST_POS_IN_BUF(pos, bufferLen, pData->jarHashLen);
        } else {
            pData->varSuiteData.pJarHash = NULL;
        }

        /* setup string fields */
        {
            int i;
            jint strLen;
            pcsl_string* pStrings[] = {
                &pData->varSuiteData.midletClassName,
                &pData->varSuiteData.displayName,
                &pData->varSuiteData.iconName,
                &pData->varSuiteData.suiteVendor,
                &pData->varSuiteData.suiteName,
                &pData->varSuiteData.pathToJar,
                &pData->varSuiteData.pathToSettings
            };

            status = ALL_OK;

            for (i = 0; i < (int) (sizeof(pStrings) / sizeof(pStrings[0]));
                    i++) {
                if (bufferLen < (long)sizeof(jint)) {
                    status = IO_ERROR; /* _suites.dat is corrupted */
                    break;
                }

                /*
                 * We have to guarantee 4 - bytes alignment to use this:
                 *     strLen = *(jint*)&buffer[pos];
                 * on RISC CPUs.
                 */
                pos = SUITESTORE_ALIGN_4(pos);
                strLen = *(jint*)&buffer[pos];
                ADJUST_POS_IN_BUF(pos, bufferLen, sizeof(jint));

                if (bufferLen < (long)strLen) {
                    status = IO_ERROR; /* _suites.dat is corrupted */
                    break;
                }

                if (strLen > 0) {
                    rc = pcsl_string_convert_from_utf16(
                        (jchar*)&buffer[pos], strLen, pStrings[i]);

                    if (rc != PCSL_STRING_OK) {
                        status = OUT_OF_MEMORY;
                        break;
                    }
                    ADJUST_POS_IN_BUF(pos, bufferLen, strLen * sizeof(jchar));
                } else {
                    *pStrings[i] = strLen ?
                        PCSL_STRING_NULL : PCSL_STRING_EMPTY;
                }
            }
        }

        if (status != ALL_OK) {
            break;
        }

        pData->nextEntry = NULL;
        pPrevData = pData;
    } /* end for (numOfSuites) */

    pcsl_mem_free(buffer);

    if (status == ALL_OK) {
        g_numberOfSuites = numOfSuites;
        g_pSuitesData = pSuitesData;
        g_isSuitesDataLoaded = 1;
    } else {
        free_suites_data();
    }

    return status;
}
예제 #15
0
/**
 * Reads a line from a manifest file. Compacts continuation lines.<BR>
 * (Allocates memory for this line.)
 *
 * @param mfbuf  pointer to the manifest jchar_buffer; this pointer will move to
 *               the next line
 * @param result pointer to pcsl_string where the new line from manifest
 *               will be stored
 * @return error code
 */
static MIDPError readMfLine(jchar** mfbuf, pcsl_string * result) {
    jchar* lineStart = NULL;
    int is_broken_line = 0;
    jchar* p = NULL;
    int count = 0;
    int i = 0;

    *result = PCSL_STRING_NULL;

    /* will use p to avoid all the *(*mfbuf) stuff and make it more readable */
    p = (*mfbuf);

    if (!(*p)) {
        /* end of jchar_buffer */
        return END_OF_MF;
    }

    /* skip commented out and blank lines */
    while (COMMENTED_OUT(p) || NEW_LINE(p)) {

        while (!NEW_LINE(p)) {
            p++; /* skip commented out line */
        }
        while (NEW_LINE(p)) {
            p++; /* skip new line */
        }

        /* now pointing to the next line */
        if (MF_SPACE(p)) { /* if starting with space */
            while (!NEW_LINE(p)) {
                p++; /* skip the line */
            }
        } /* end of if */

    } /* end of while */

    lineStart = p;

    for (;*p ;) {
        count++;
        p++;
        if (NEW_LINE(p) && !MF_BROKEN_LINE(p)) {
            *p = 0x00; /* cut the line */
            if (*(p+1)) { /* if not end of the buffer */
                p++; /* point to the next line beginning */
                break;
            }
        } else if (MF_BROKEN_LINE(p)) {
            while (!MF_SPACE(p)) { /* look for the space */
                count++;
                p++;
            }
            /* once space found, point to the next character and go ahead */
            count++;
            p++;
            is_broken_line = 1;
            continue;
        } /* end of else */

    } /* end of for */

    /* move mfbuf to point to the next line */
    (*mfbuf) = p;

    pcsl_string_predict_size(result, count);
    if (is_broken_line) {
        i = 0;
        while (*(lineStart+i)) {

            /* here once we have a new line it will be followed by space */
            if (NEW_LINE_1(lineStart+i)) {
                i+=3;
                count-=3;
            } else if (NEW_LINE(lineStart+i)) {
                i+=2;
                count-=2;
            }

            if (PCSL_STRING_OK !=
                pcsl_string_append_char(result, lineStart[i])) {
                pcsl_string_free(result);
                return OUT_OF_MEMORY;
            }
            i++;
        }
    } else {
        if (PCSL_STRING_OK !=
            pcsl_string_convert_from_utf16(lineStart, count, result)) {
            return OUT_OF_MEMORY;
        }
    }

    return ALL_OK;
} /* end of readMfLine */
예제 #16
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;
}
예제 #17
0
static int findFirstMatch(PCSLFileIterator* pIterator,
                          const pcsl_string * match,
                          pcsl_string * result) {
    WIN32_FIND_DATAW findData;
    HANDLE handle;
    PCSL_DEFINE_ASCII_STRING_LITERAL_START(starSuffix)
      {'*', '\0'}
    PCSL_DEFINE_ASCII_STRING_LITERAL_END(starSuffix);
    pcsl_string root = PCSL_STRING_NULL;
    pcsl_string foundName = PCSL_STRING_NULL;
    pcsl_string matchStar = PCSL_STRING_NULL;
    jsize rootLen = 0;

    if (result == NULL) {
      return -1;
    }

    * result = PCSL_STRING_NULL;

    if (pcsl_string_cat(match, &starSuffix, &matchStar) != PCSL_STRING_OK) {
      return -1;
    }

    {
      const jchar * pwszMatch = pcsl_string_get_utf16_data(&matchStar);

      if (NULL == pwszMatch) {
        pcsl_string_free(&matchStar);
	return -1;
      }

      handle = FindFirstFileW(pwszMatch, &findData);

      pcsl_string_free(&matchStar);
    }

    if (INVALID_HANDLE_VALUE == handle) {
	return -1;
    }

    pIterator->iteratorHandle = handle;
    rootLen = pIterator->savedRootLength;

    if (pcsl_string_substring(match, 0, rootLen, &root) != PCSL_STRING_OK) {
      return -1;
    }

    if (pcsl_string_convert_from_utf16(findData.cFileName,
				       wcslen(findData.cFileName),
				       &foundName) != PCSL_STRING_OK) {
      pcsl_string_free(&root);    
      return -1;
    }

    if (pcsl_string_cat(&root, &foundName, result) != PCSL_STRING_OK) {
      pcsl_string_free(&foundName);    
      pcsl_string_free(&root);    
      return -1;
    }

    pcsl_string_free(&foundName);    
    pcsl_string_free(&root);    

    return 0;
}
/*
 * This function is called by the VM periodically. It has to check if
 * system has sent a signal to MIDP and return the result in the
 * structs given.
 *
 * Values for the <timeout> paramater:
 *  >0 = Block until a signal sent to MIDP, or until <timeout> milliseconds
 *       has elapsed.
 *   0 = Check the system for a signal but do not block. Return to the
 *       caller immediately regardless of the if a signal was sent.
 *  -1 = Do not timeout. Block until a signal is sent to MIDP.
 */
void checkForSystemSignal(MidpReentryData* pNewSignal,
                          MidpEvent* pNewMidpEvent,
                          jlong timeout) {

    midp_jc_event_union *event;
    static unsigned char binaryBuffer[BINARY_BUFFER_MAX_LEN];
    javacall_bool res;
    int outEventLen;
    
#if !ENABLE_CDC
    res = javacall_event_receive((long)timeout, binaryBuffer,
                                 BINARY_BUFFER_MAX_LEN, &outEventLen);
#else
    res = javacall_event_receive_cvm(MIDP_EVENT_QUEUE_ID, binaryBuffer,
                                 BINARY_BUFFER_MAX_LEN, &outEventLen);
#endif

    if (!JAVACALL_SUCCEEDED(res)) {
        return;
    }
    
    event = (midp_jc_event_union *) binaryBuffer;

    switch (event->eventType) {
    case MIDP_JC_EVENT_KEY:
        pNewSignal->waitingFor = UI_SIGNAL;
        pNewMidpEvent->type    = MIDP_KEY_EVENT;
        pNewMidpEvent->CHR     = event->data.keyEvent.key;
        pNewMidpEvent->ACTION  = event->data.keyEvent.keyEventType;
        break;
    case MIDP_JC_EVENT_PEN:
        pNewSignal->waitingFor = UI_SIGNAL;
        pNewMidpEvent->type    = MIDP_PEN_EVENT;
        pNewMidpEvent->ACTION  = event->data.penEvent.type;
        pNewMidpEvent->X_POS   = event->data.penEvent.x;
        pNewMidpEvent->Y_POS   = event->data.penEvent.y;
	break;
    case MIDP_JC_EVENT_SOCKET:
        pNewSignal->waitingFor = event->data.socketEvent.waitingFor;
        pNewSignal->descriptor = (int)event->data.socketEvent.handle;
        pNewSignal->status     = event->data.socketEvent.status;
        pNewSignal->pResult    = (void *) event->data.socketEvent.extraData;
        break;
    case MIDP_JC_EVENT_END:
        pNewSignal->waitingFor = AMS_SIGNAL;
        pNewMidpEvent->type    = SHUTDOWN_EVENT;
        break;
#if !ENABLE_CDC
     case MIDP_JC_EVENT_PAUSE: 
        /*
         * IMPL_NOTE: if VM is running, the following call will send
         * PAUSE_ALL_EVENT message to AMS; otherwise, the resources
         * will be suspended in the context of the caller.
         */
        midp_suspend();
        break;
#endif	
    case MIDP_JC_EVENT_PUSH:
        pNewSignal->waitingFor = PUSH_ALARM_SIGNAL;
        pNewSignal->descriptor = event->data.pushEvent.alarmHandle;
        break;
    case MIDP_JC_EVENT_ROTATION:
        pNewSignal->waitingFor = UI_SIGNAL;
        pNewMidpEvent->type    = ROTATION_EVENT;
        break;
    case MIDP_JC_EVENT_CHANGE_LOCALE:
        pNewSignal->waitingFor = UI_SIGNAL;
        pNewMidpEvent->type    = CHANGE_LOCALE_EVENT;
        break;
    case MIDP_JC_EVENT_VIRTUAL_KEYBOARD:
        pNewSignal->waitingFor = UI_SIGNAL;
        pNewMidpEvent->type    = VIRTUAL_KEYBOARD_EVENT;
        break;

    case MIDP_JC_EVENT_DISPLAY_DEVICE_STATE_CHANGED:
        pNewSignal->waitingFor = DISPLAY_DEVICE_SIGNAL;
        pNewMidpEvent->type    = DISPLAY_DEVICE_STATE_CHANGED_EVENT;
        pNewMidpEvent->intParam1 = event->data.displayDeviceEvent.hardwareId;
        pNewMidpEvent->intParam2 = event->data.displayDeviceEvent.state;
        break;

	case MIDP_JC_EVENT_CLAMSHELL_STATE_CHANGED:
        pNewSignal->waitingFor = UI_SIGNAL;
        pNewMidpEvent->type    = DISPLAY_CLAMSHELL_STATE_CHANGED_EVENT;
        pNewMidpEvent->intParam1 = event->data.clamshellEvent.state;
        break;

#if ENABLE_ON_DEVICE_DEBUG
    case MIDP_JC_ENABLE_ODD_EVENT:
        pNewSignal->waitingFor = AMS_SIGNAL;
        pNewMidpEvent->type = MIDP_ENABLE_ODD_EVENT;
        break;
#endif

#ifdef ENABLE_JSR_75
    case JSR75_FC_JC_EVENT_ROOTCHANGED:
        notifyDisksChanged();
        break;
#endif

#if ENABLE_JSR_120
    case MIDP_JC_EVENT_SMS_INCOMING:
        pNewSignal->waitingFor = WMA_SMS_READ_SIGNAL;
        pNewSignal->descriptor = event->data.smsIncomingEvent.stub;
        break;
    case MIDP_JC_EVENT_CBS_INCOMING:
        pNewSignal->waitingFor = WMA_CBS_READ_SIGNAL;
        pNewSignal->descriptor = event->data.cbsIncomingEvent.stub;
        break;
    case MIDP_JC_EVENT_SMS_SENDING_RESULT:
        pNewSignal->waitingFor = WMA_SMS_WRITE_SIGNAL;
        pNewSignal->descriptor = (int)event->data.smsSendingResultEvent.handle;
        pNewSignal->status = event->data.smsSendingResultEvent.result;
        break;
#endif
#if ENABLE_JSR_205
    case MIDP_JC_EVENT_MMS_INCOMING:
        pNewSignal->waitingFor = WMA_MMS_READ_SIGNAL;
        pNewSignal->descriptor = event->data.mmsIncomingEvent.stub;
        break;
    case MIDP_JC_EVENT_MMS_SENDING_RESULT:
        pNewSignal->waitingFor = WMA_MMS_WRITE_SIGNAL;
        pNewSignal->descriptor = (int)event->data.mmsSendingResultEvent.handle;
        pNewSignal->status = event->data.mmsSendingResultEvent.result;
        break;
#endif

    case MIDP_JC_EVENT_MULTIMEDIA:
#if ENABLE_JSR_135
        pNewSignal->waitingFor = MEDIA_EVENT_SIGNAL;
        pNewSignal->status = JAVACALL_OK;

        pNewMidpEvent->type         = MMAPI_EVENT;
        pNewMidpEvent->MM_PLAYER_ID = event->data.multimediaEvent.playerId;
        pNewMidpEvent->MM_DATA      = event->data.multimediaEvent.data.num32;
        pNewMidpEvent->MM_ISOLATE   = event->data.multimediaEvent.appId;
        pNewMidpEvent->MM_EVT_TYPE  = event->data.multimediaEvent.mediaType;
        pNewMidpEvent->MM_EVT_STATUS= event->data.multimediaEvent.status;

        /* SYSTEM_VOLUME_CHANGED event must be sent to all players.             */
        /* MM_ISOLATE = -1 causes bradcast by StoreMIDPEventInVmThread() */
        if( JAVACALL_EVENT_MEDIA_SYSTEM_VOLUME_CHANGED == event->data.multimediaEvent.mediaType )
            pNewMidpEvent->MM_ISOLATE = -1; 

        REPORT_CALL_TRACE4(LC_NONE, "[media event] External event recevied %d %d %d %d\n",
                pNewMidpEvent->type, 
                event->data.multimediaEvent.appId, 
                pNewMidpEvent->MM_PLAYER_ID, 
                pNewMidpEvent->MM_DATA);
#endif
        break;
#ifdef ENABLE_JSR_234
    case MIDP_JC_EVENT_ADVANCED_MULTIMEDIA:
        pNewSignal->waitingFor = AMMS_EVENT_SIGNAL;
        pNewSignal->status     = JAVACALL_OK;

        pNewMidpEvent->type         = AMMS_EVENT;
        pNewMidpEvent->MM_PLAYER_ID = event->data.multimediaEvent.playerId;
        pNewMidpEvent->MM_ISOLATE   = event->data.multimediaEvent.appId;
        pNewMidpEvent->MM_EVT_TYPE  = event->data.multimediaEvent.mediaType;

        switch( event->data.multimediaEvent.mediaType )
        {
        case JAVACALL_EVENT_AMMS_SNAP_SHOOTING_STOPPED:
        case JAVACALL_EVENT_AMMS_SNAP_STORAGE_ERROR:
            {
                int len = 0;
                javacall_utf16_string str = event->data.multimediaEvent.data.str16;
                while( str[len] != 0 ) len++;
                pcsl_string_convert_from_utf16( str, len, &pNewMidpEvent->MM_STRING );
                free( str );
            }
            break;
        default:
            pNewMidpEvent->MM_DATA = event->data.multimediaEvent.data.num32;
            break;
        }

        REPORT_CALL_TRACE4(LC_NONE, "[jsr234 event] External event recevied %d %d %d %d\n",
            pNewMidpEvent->type, 
            event->data.multimediaEvent.appId, 
            pNewMidpEvent->MM_PLAYER_ID, 
            pNewMidpEvent->MM_DATA);

        break;
#endif
#ifdef ENABLE_JSR_179
    case JSR179_LOCATION_JC_EVENT:
        pNewSignal->waitingFor = event->data.jsr179LocationEvent.event;
        pNewSignal->descriptor = (int)event->data.jsr179LocationEvent.provider;
        pNewSignal->status = event->data.jsr179LocationEvent.operation_result;
        REPORT_CALL_TRACE2(LC_NONE, "[jsr179 event] JSR179_LOCATION_SIGNAL %d %d\n", pNewSignal->descriptor, pNewSignal->status);
        break;
    case JSR179_PROXIMITY_JC_EVENT:
        pNewSignal->waitingFor = JSR179_PROXIMITY_SIGNAL;
        pNewSignal->descriptor = (int)event->data.jsr179ProximityEvent.provider;
        pNewSignal->status = event->data.jsr179ProximityEvent.operation_result;
        REPORT_CALL_TRACE2(LC_NONE, "[jsr179 event] JSR179_PROXIMITY_SIGNAL %d %d\n", pNewSignal->descriptor, pNewSignal->status);
        break;
#endif

#ifdef ENABLE_JSR_211
    case JSR211_JC_EVENT_PLATFORM_FINISH:
        pNewSignal->waitingFor = JSR211_PLATFORM_FINISH_SIGNAL;
        pNewSignal->descriptor = event->data.jsr211PlatformEvent.invoc_id;
        pNewSignal->pResult    = event->data.jsr211PlatformEvent.jsr211event;
        pNewMidpEvent->type    = CHAPI_EVENT;
        break;
    case JSR211_JC_EVENT_JAVA_INVOKE:
        pNewSignal->waitingFor = JSR211_JAVA_INVOKE_SIGNAL;
        pNewSignal->descriptor = event->data.jsr211PlatformEvent.invoc_id;
        pNewSignal->pResult    = event->data.jsr211PlatformEvent.jsr211event;
        pNewMidpEvent->type    = CHAPI_EVENT;
        break;
    case JSR211_JC_EVENT_REQUEST_RECEIVED:
        pNewSignal->waitingFor = JSR211_REQUEST_SIGNAL;
        pNewSignal->pResult    = event->data.jsr211RequestEvent.data;
        pNewMidpEvent->type    = CHAPI_EVENT;
        break;
    case JSR211_JC_EVENT_RESPONSE_RECEIVED:
        pNewSignal->waitingFor = JSR211_RESPONSE_SIGNAL;
        pNewSignal->pResult    = event->data.jsr211ResponseEvent.data;
        pNewMidpEvent->type    = CHAPI_EVENT;
        break;

#endif /* ENABLE_JSR_211 */

#ifdef ENABLE_JSR_290
    case JSR290_JC_EVENT_FLUID_INVALIDATE:
        pNewSignal->waitingFor   = JSR290_INVALIDATE_SIGNAL;
        pNewSignal->descriptor   = (int)event->data.jsr290FluidEvent.fluid_image;
        pNewSignal->pResult      = event->data.jsr290FluidEvent.app_id;
        break;
    case JSR290_JC_EVENT_FLUID_LISTENER_COMPLETED:
        pNewSignal->waitingFor   = JSR290_FLUID_EVENT_SIGNAL;
        pNewSignal->descriptor   = (int)event->data.jsr290FluidEvent.fluid_image;
        pNewSignal->pResult      = event->data.jsr290FluidEvent.app_id;
        pNewMidpEvent->type      = FLUID_EVENT;
        pNewMidpEvent->intParam2 = (int)((jlong)(event->data.jsr290FluidEvent.fluid_image));
        pNewMidpEvent->intParam3 = (int)((jlong)(event->data.jsr290FluidEvent.fluid_image) >> 32);
        pNewMidpEvent->intParam1 = JSR290_LISTENER_COMPLETED;
        break;
    case JSR290_JC_EVENT_FLUID_LISTENER_FAILED:
        pNewSignal->waitingFor   = JSR290_FLUID_EVENT_SIGNAL;
        pNewSignal->descriptor   = (int)event->data.jsr290FluidEvent.fluid_image;
        pNewSignal->pResult      = event->data.jsr290FluidEvent.app_id;
        pNewMidpEvent->type      = FLUID_EVENT;
        pNewMidpEvent->intParam2 = (int)((jlong)(event->data.jsr290FluidEvent.fluid_image));
        pNewMidpEvent->intParam3 = (int)((jlong)(event->data.jsr290FluidEvent.fluid_image) >> 32);
        pNewMidpEvent->intParam1 = JSR290_LISTENER_FAILED;
        pNewMidpEvent->intParam4 = (jint)(event->data.jsr290FluidEvent.failure_type);
        {
            int len = 0;
            if (JAVACALL_OK != javautil_unicode_utf16_ulength(event->data.jsr290FluidEvent.text, &len)) {
                len = 0;
            }
            pcsl_string_convert_from_utf16(event->data.jsr290FluidEvent.text, len,
                                           &pNewMidpEvent->stringParam1);
        }
        javacall_free(event->data.jsr290FluidEvent.text);
        break;
    case JSR290_JC_EVENT_FLUID_LISTENER_PERCENTAGE:
        pNewSignal->waitingFor   = JSR290_FLUID_EVENT_SIGNAL;
        pNewSignal->descriptor   = (int)event->data.jsr290FluidEvent.fluid_image;
        pNewSignal->pResult      = event->data.jsr290FluidEvent.app_id;
        pNewMidpEvent->type      = FLUID_EVENT;
        pNewMidpEvent->intParam2 = (int)(((jlong)event->data.jsr290FluidEvent.fluid_image));
        pNewMidpEvent->intParam3 = (int)(((jlong)event->data.jsr290FluidEvent.fluid_image) >> 32);
        pNewMidpEvent->intParam1 = JSR290_LISTENER_PERCENTAGE;
        pNewMidpEvent->intParam4 = *((int*)&event->data.jsr290FluidEvent.percentage);
        break;
    case JSR290_JC_EVENT_FLUID_LISTENER_STARTED:
        pNewSignal->waitingFor   = JSR290_FLUID_EVENT_SIGNAL;
        pNewSignal->descriptor   = (int)event->data.jsr290FluidEvent.fluid_image;
        pNewSignal->pResult      = event->data.jsr290FluidEvent.app_id;
        pNewMidpEvent->type      = FLUID_EVENT;
        pNewMidpEvent->intParam2 = (int)((jlong)(event->data.jsr290FluidEvent.fluid_image));
        pNewMidpEvent->intParam3 = (int)((jlong)(event->data.jsr290FluidEvent.fluid_image) >> 32);
        pNewMidpEvent->intParam1 = JSR290_LISTENER_STARTED;
        break;
    case JSR290_JC_EVENT_FLUID_IMAGE_SPAWNED:
        pNewSignal->waitingFor   = JSR290_FLUID_EVENT_SIGNAL;
        pNewSignal->descriptor   = (int)event->data.jsr290FluidEvent.fluid_image;
        pNewSignal->pResult      = event->data.jsr290FluidEvent.app_id;
        pNewMidpEvent->type      = FLUID_EVENT;
        pNewMidpEvent->intParam2 = (int)((jlong)(event->data.jsr290FluidEvent.fluid_image));
        pNewMidpEvent->intParam3 = (int)((jlong)(event->data.jsr290FluidEvent.fluid_image) >> 32);
        pNewMidpEvent->intParam4 = (int)((jlong)(event->data.jsr290FluidEvent.spare));
        pNewMidpEvent->intParam5 = (int)((jlong)(event->data.jsr290FluidEvent.spare) >> 32);
        pNewMidpEvent->intParam1 = JSR290_IMAGE_SPAWNED;
        break;
    case JSR290_JC_EVENT_FLUID_LISTENER_WARNING:
        pNewSignal->waitingFor   = JSR290_FLUID_EVENT_SIGNAL;
        pNewSignal->descriptor   = (int)event->data.jsr290FluidEvent.fluid_image;
        pNewSignal->pResult      = event->data.jsr290FluidEvent.app_id;
        pNewMidpEvent->type      = FLUID_EVENT;
        pNewMidpEvent->intParam2 = (int)((jlong)(event->data.jsr290FluidEvent.fluid_image));
        pNewMidpEvent->intParam3 = (int)((jlong)(event->data.jsr290FluidEvent.fluid_image) >> 32);
        pNewMidpEvent->intParam1 = JSR290_LISTENER_WARNING;
        {
            int len = 0;
            if (JAVACALL_OK != javautil_unicode_utf16_ulength(event->data.jsr290FluidEvent.text, &len)) {
                len = 0;
            }
            pcsl_string_convert_from_utf16(event->data.jsr290FluidEvent.text, len,
                                           &pNewMidpEvent->stringParam1);
        }
        javacall_free(event->data.jsr290FluidEvent.text);
        break;
    case JSR290_JC_EVENT_FLUID_LISTENER_DOCUMENT_AVAILABLE:
        pNewSignal->waitingFor   = JSR290_FLUID_EVENT_SIGNAL;
        pNewSignal->descriptor   = (int)event->data.jsr290FluidEvent.fluid_image;
        pNewSignal->pResult      = event->data.jsr290FluidEvent.app_id;
        pNewMidpEvent->type      = FLUID_EVENT;
        pNewMidpEvent->intParam2 = (int)((jlong)(event->data.jsr290FluidEvent.fluid_image));
        pNewMidpEvent->intParam3 = (int)((jlong)(event->data.jsr290FluidEvent.fluid_image) >> 32);
        pNewMidpEvent->intParam1 = JSR290_LISTENER_DOCUMENT_AVAILABLE;
        break;
    case JSR290_JC_EVENT_FLUID_REQUEST_RESOURCE:
        pNewSignal->waitingFor   = JSR290_FLUID_EVENT_SIGNAL;
        pNewSignal->descriptor   = (int)event->data.jsr290FluidEvent.fluid_image;
        pNewSignal->pResult      = event->data.jsr290FluidEvent.app_id;
        pNewMidpEvent->type      = FLUID_EVENT;
        pNewMidpEvent->intParam2 = (int)((jlong)(event->data.jsr290FluidEvent.fluid_image));
        pNewMidpEvent->intParam3 = (int)((jlong)(event->data.jsr290FluidEvent.fluid_image) >> 32);
        pNewMidpEvent->intParam4 = (int)((jlong)(event->data.jsr290FluidEvent.spare));
        pNewMidpEvent->intParam5 = (int)((jlong)(event->data.jsr290FluidEvent.spare) >> 32);
        pNewMidpEvent->intParam1 = JSR290_REQUEST_RESOURCE;
        {
            int len = 0;
            if (JAVACALL_OK != javautil_unicode_utf16_ulength(event->data.jsr290FluidEvent.text, &len)) {
                len = 0;
            }
            pcsl_string_convert_from_utf16(event->data.jsr290FluidEvent.text, len,
                                           &pNewMidpEvent->stringParam1);
        }
        javacall_free(event->data.jsr290FluidEvent.text);
        break;
    case JSR290_JC_EVENT_FLUID_CANCEL_REQUEST:
        pNewSignal->waitingFor   = JSR290_FLUID_EVENT_SIGNAL;
        pNewSignal->descriptor   = (int)event->data.jsr290FluidEvent.fluid_image;
        pNewSignal->pResult      = event->data.jsr290FluidEvent.app_id;
        pNewMidpEvent->type      = FLUID_EVENT;
        pNewMidpEvent->intParam2 = (int)((jlong)(event->data.jsr290FluidEvent.fluid_image));
        pNewMidpEvent->intParam3 = (int)((jlong)(event->data.jsr290FluidEvent.fluid_image) >> 32);
        pNewMidpEvent->intParam4 = (int)((jlong)(event->data.jsr290FluidEvent.spare));
        pNewMidpEvent->intParam5 = (int)((jlong)(event->data.jsr290FluidEvent.spare) >> 32);
        pNewMidpEvent->intParam1 = JSR290_CANCEL_REQUEST;
        break;
    case JSR290_JC_EVENT_FLUID_FILTER_XML_HTTP_REQUEST:
        pNewSignal->waitingFor   = JSR290_FLUID_EVENT_SIGNAL;
        pNewSignal->descriptor   = (int)event->data.jsr290FluidEvent.fluid_image;
        pNewSignal->pResult      = event->data.jsr290FluidEvent.app_id;
        pNewMidpEvent->type      = FLUID_EVENT;
        pNewMidpEvent->intParam2 = (int)((jlong)(event->data.jsr290FluidEvent.fluid_image));
        pNewMidpEvent->intParam3 = (int)((jlong)(event->data.jsr290FluidEvent.fluid_image) >> 32);
        pNewMidpEvent->intParam1 = JSR290_FILTER_XML_HTTP;
        pNewMidpEvent->intParam4 = (int)((jlong)(event->data.jsr290FluidEvent.spare));
        pNewMidpEvent->intParam5 = (int)((jlong)(event->data.jsr290FluidEvent.spare) >> 32);
        {
            int len = 0;
            if (JAVACALL_OK != javautil_unicode_utf16_ulength(event->data.jsr290FluidEvent.text, &len)) {
                len = 0;
            }
            pcsl_string_convert_from_utf16(event->data.jsr290FluidEvent.text, len,
                                           &pNewMidpEvent->stringParam1);
        }
        javacall_free(event->data.jsr290FluidEvent.text);
        {
            int len = 0;
            if (JAVACALL_OK != javautil_unicode_utf16_ulength(event->data.jsr290FluidEvent.text1, &len)) {
                len = 0;
            }
            pcsl_string_convert_from_utf16(event->data.jsr290FluidEvent.text1, len,
                                           &pNewMidpEvent->stringParam2);
        }
        javacall_free(event->data.jsr290FluidEvent.text1);
        break;
    case JSR290_JC_EVENT_COMPLETION_NOTIFICATION:
        pNewSignal->waitingFor   = JSR290_INVOCATION_COMPLETION_SIGNAL;
        pNewSignal->descriptor   = (int)event->data.jsr290NotificationEvent.invocation_id;
        break;
    case JSR290_JC_EVENT_HANDLE_EVENT:
        pNewSignal->waitingFor   = JSR290_FLUID_EVENT_SIGNAL;
        pNewSignal->pResult      = event->data.jsr290FluidEvent.app_id;
        pNewMidpEvent->type      = FLUID_EVENT;
        pNewMidpEvent->intParam4 = (int)((jlong)(event->data.jsr290HandleEventRequest.request_handle));
        pNewMidpEvent->intParam5 = (int)((jlong)(event->data.jsr290HandleEventRequest.request_handle) >> 32);
        pNewMidpEvent->intParam1 = JSR290_HANDLE_EVENT;
    	break;
    case JSR290_JC_EVENT_DISPLAY_BOX:
        pNewSignal->waitingFor   = JSR290_FLUID_EVENT_SIGNAL;
        pNewSignal->descriptor   = (int)event->data.jsr290FluidEvent.fluid_image;
        pNewSignal->pResult      = event->data.jsr290FluidEvent.app_id;
        pNewMidpEvent->type      = FLUID_EVENT;
        pNewMidpEvent->intParam2 = (int)((jlong)(event->data.jsr290FluidEvent.fluid_image));
        pNewMidpEvent->intParam3 = (int)((jlong)(event->data.jsr290FluidEvent.fluid_image) >> 32);
        pNewMidpEvent->intParam4 = (int)((jlong)(event->data.jsr290FluidEvent.spare));
        pNewMidpEvent->intParam5 = (int)((jlong)(event->data.jsr290FluidEvent.spare) >> 32);
        switch ((int)event->data.jsr290FluidEvent.result) {
            case 0: pNewMidpEvent->intParam1 = JSR290_DISPLAY_ALERT_BOX;
                break;
            case 1: pNewMidpEvent->intParam1 = JSR290_DISPLAY_CONFIRM_BOX;
                break;
            case 2: pNewMidpEvent->intParam1 = JSR290_DISPLAY_PROMPT_BOX;
                break;
        }
        {
            int len = 0;
            if (JAVACALL_OK != javautil_unicode_utf16_ulength(event->data.jsr290FluidEvent.text, &len)) {
                len = 0;
            }
            pcsl_string_convert_from_utf16(event->data.jsr290FluidEvent.text, len,
                                           &pNewMidpEvent->stringParam1);
        }
        javacall_free(event->data.jsr290FluidEvent.text);

        {
            int len = 0;
            if (JAVACALL_OK != javautil_unicode_utf16_ulength(event->data.jsr290FluidEvent.text1, &len)) {
                len = 0;
            }
            pcsl_string_convert_from_utf16(event->data.jsr290FluidEvent.text1, len,
                                           &pNewMidpEvent->stringParam2);
        }
        javacall_free(event->data.jsr290FluidEvent.text1);
    	break;
    case JSR290_JC_EVENT_FLUID_LAYOUT_CHANGED:
        pNewSignal->waitingFor   = JSR290_FLUID_EVENT_SIGNAL;
        pNewSignal->descriptor   = (int)event->data.jsr290FluidEvent.fluid_image;
        pNewSignal->pResult      = event->data.jsr290FluidEvent.app_id;
        pNewMidpEvent->type      = FLUID_EVENT;
        pNewMidpEvent->intParam1 = JSR290_LAYOUT_CHANGED;
        pNewMidpEvent->intParam2 = (int)(((jlong)event->data.jsr290FluidEvent.fluid_image));
        pNewMidpEvent->intParam3 = (int)(((jlong)event->data.jsr290FluidEvent.fluid_image) >> 32);
        break;
    case JSR290_JC_EVENT_FLUID_FOCUS_CHANGED:
        pNewSignal->waitingFor   = JSR290_FLUID_EVENT_SIGNAL;
        pNewSignal->descriptor   = (int)event->data.jsr290FluidEvent.fluid_image;
        pNewSignal->pResult      = event->data.jsr290FluidEvent.app_id;
        pNewMidpEvent->type      = FLUID_EVENT;
        pNewMidpEvent->intParam1 = JSR290_FOCUS_CHANGED;
        pNewMidpEvent->intParam2 = (int)(((jlong)event->data.jsr290FluidEvent.fluid_image));
        pNewMidpEvent->intParam3 = (int)(((jlong)event->data.jsr290FluidEvent.fluid_image) >> 32);
        break;
#endif /* ENABLE_JSR_290 */

#ifdef ENABLE_JSR_177
    case MIDP_JC_EVENT_CARDDEVICE:
        switch (event->data.carddeviceEvent.eventType) {
        case MIDP_CARDDEVICE_RESET:
            pNewSignal->waitingFor = CARD_READER_DATA_SIGNAL;
            pNewSignal->descriptor = SIGNAL_RESET;
            pNewSignal->status     = SIGNAL_RESET;
            pNewSignal->pResult    = (void *)event->data.carddeviceEvent.handle;
            break;
        case MIDP_CARDDEVICE_XFER:
            pNewSignal->waitingFor = CARD_READER_DATA_SIGNAL;
            pNewSignal->descriptor = SIGNAL_XFER;
            pNewSignal->status     = SIGNAL_XFER;
            pNewSignal->pResult    = (void *)event->data.carddeviceEvent.handle;
            break;
        case MIDP_CARDDEVICE_UNLOCK:
            pNewSignal->waitingFor = CARD_READER_DATA_SIGNAL;
            pNewSignal->descriptor = SIGNAL_LOCK;
            pNewSignal->status     = SIGNAL_LOCK;
            pNewSignal->pResult    = NULL;
            break;
        default:    /* just ignore invalid event type */
            REPORT_ERROR1(LC_CORE,"Invalid carddevice event type: %d\n", 
                event->data.carddeviceEvent.eventType);
            break;
        }
        break;
#endif /* ENABLE_JSR_177 */

#ifdef ENABLE_JSR_257
    case JSR257_JC_EVENT_CONTACTLESS:
        if(event->data.jsr257Event.eventType < JSR257_EVENTS_NUM) {
            pNewSignal->waitingFor = JSR257_CONTACTLESS_SIGNAL;
            pNewSignal->descriptor = event->data.jsr257Event.eventType;
        } else {
            REPORT_ERROR1(LC_CORE,"Invalid contactless event type: %d\n", 
                event->data.jsr257Event.eventType);
        }
        break;
         
    case JSR257_JC_MIDP_EVENT:
      printf("\n DEBUG: midp_msgQueue_md.c(): data.jsr257Event.eventType = %d\n",
        event->data.jsr257Event.eventType);
       if(event->data.jsr257Event.eventType < JSR257_MIDP_EVENTS_NUM) {
            pNewSignal->waitingFor   = JSR257_EVENT_SIGNAL;
            pNewSignal->descriptor   = event->data.jsr257Event.eventType;
            pNewMidpEvent->type      = CONTACTLESS_EVENT;
            pNewMidpEvent->intParam1 = event->data.jsr257Event.eventType;
            pNewMidpEvent->JSR257_ISOLATE = (int)(event->data.jsr257Event.isolateId);
            pNewMidpEvent->intParam3 = (int)(event->data.jsr257Event.eventData[0]);
            pNewMidpEvent->intParam4 = (int)(event->data.jsr257Event.eventData[1]);
            pNewMidpEvent->intParam5 = (int)(event->data.jsr257Event.eventData[2]);
            
       } else {
            REPORT_ERROR1(LC_CORE,"Invalid contactless MIDP event type: %d\n", 
                event->data.jsr257Event.eventType);
       }
       break;
       
    case JSR257_JC_PUSH_NDEF_RECORD_DISCOVERED:
        pNewSignal->waitingFor   = JSR257_PUSH_SIGNAL;
        pNewSignal->descriptor = event->data.jsr257Event.eventData[0];
       break;

#endif /* ENABLE_JSR_257 */

#if ENABLE_MULTIPLE_ISOLATES
    case MIDP_JC_EVENT_SWITCH_FOREGROUND:
        pNewSignal->waitingFor = AMS_SIGNAL;
        pNewMidpEvent->type    = SELECT_FOREGROUND_EVENT;
        pNewMidpEvent->intParam1 = 1;
        break;
    case MIDP_JC_EVENT_SELECT_APP:
        pNewSignal->waitingFor = AMS_SIGNAL;
        pNewMidpEvent->type    = SELECT_FOREGROUND_EVENT;
        pNewMidpEvent->intParam1 = 0;
        break;
#endif /* ENABLE_MULTIPLE_ISOLATES */
#if !ENABLE_CDC
#ifdef ENABLE_JSR_256
    case JSR256_JC_EVENT_SENSOR_AVAILABLE:
        pNewSignal->waitingFor = JSR256_SIGNAL;
        pNewMidpEvent->type    = SENSOR_EVENT;
        pNewMidpEvent->intParam1 = event->data.jsr256SensorAvailable.sensor_type;
        pNewMidpEvent->intParam2 = event->data.jsr256SensorAvailable.is_available;
        break;
    case JSR256_JC_EVENT_SENSOR_OPEN_CLOSE:
        pNewSignal->waitingFor = JSR256_SIGNAL;
        pNewSignal->descriptor = (int)event->data.jsr256_jc_event_sensor.sensor;
        break;
#endif /* ENABLE_JSR_256 */
#endif /* !ENABLE_CDC */
#ifdef ENABLE_API_EXTENSIONS
case MIDP_JC_EVENT_VOLUME:
		pNewSignal->waitingFor = VOLUME_SIGNAL;
		pNewSignal->status     = JAVACALL_OK;
	
	break;
#endif /* ENABLE_API_EXTENSIONS */
	default:
        REPORT_ERROR(LC_CORE,"Unknown event.\n");
        break;
    };

    REPORT_CALL_TRACE(LC_HIGHUI, "LF:STUB:checkForSystemSignal()\n");
}