fileinstallershared.c

来自「This is a resource based on j2me embedde」· C语言 代码 · 共 1,463 行 · 第 1/4 页

/*
 *
 *
 * Copyright  1990-2007 Sun Microsystems, Inc. All Rights Reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version
 * 2 only, as published by the Free Software Foundation.
 * 
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License version 2 for more details (a copy is
 * included at /legal/license.txt).
 * 
 * You should have received a copy of the GNU General Public License
 * version 2 along with this work; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 * 
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
 * Clara, CA 95054 or visit www.sun.com if you need additional
 * information or have any questions.
 */

#include <string.h>

#include <midpMalloc.h>
#include <midpStorage.h>
#include <midpDataHash.h>
#include <fileInstallerInternal.h>
#include <midp_logging.h>
#include <jvm.h>
#include <pcsl_string.h>
#include <midpUtilKni.h>
#include <push_server_export.h>
#include <suitestore_installer.h>
#include <suitestore_secure.h> /* for VERIFY_ONCE */

#ifdef ENABLE_JSR_211
#include <jsr211_nams_installer.h>
#endif  /* ENABLE_JSR_211 */

PCSL_DEFINE_ASCII_STRING_LITERAL_START(JAR_URL_PROP)
    {'M', 'I', 'D', 'l', 'e', 't', '-',
     'J', 'a', 'r','-', 'U', 'R', 'L', '\0'}
PCSL_DEFINE_ASCII_STRING_LITERAL_END(JAR_URL_PROP);

PCSL_DEFINE_ASCII_STRING_LITERAL_START(JAR_SIZE_PROP)
    {'M', 'I', 'D', 'l', 'e', 't', '-',
     'J', 'a', 'r','-', 'S', 'i', 'z', 'e', '\0'}
PCSL_DEFINE_ASCII_STRING_LITERAL_END(JAR_SIZE_PROP);

PCSL_DEFINE_ASCII_STRING_LITERAL_START(MIDLET_ONE_PROP)
    {'M', 'I', 'D', 'l', 'e', 't', '-', '1', '\0'}
PCSL_DEFINE_ASCII_STRING_LITERAL_END(MIDLET_ONE_PROP);

PCSL_DEFINE_ASCII_STRING_LITERAL_START(MICROEDITION_PROFILE_PROP)
    {'M', 'i', 'c', 'r', 'o',
     'E', 'd', 'i', 't', 'i','o', 'n',
     '-', 'P','r','o','f','i','l','e', '\0'}
PCSL_DEFINE_ASCII_STRING_LITERAL_END(MICROEDITION_PROFILE_PROP);

PCSL_DEFINE_ASCII_STRING_LITERAL_START(MICROEDITION_CONFIGURATION_PROP)
    {'M', 'i', 'c', 'r', 'o', 'E', 'd', 'i', 't', 'i', 'o', 'n',
     '-', 'C', 'o', 'n', 'f', 'i', 'g', 'u', 'r', 'a', 't', 'i', 'o', 'n', '\0'}
PCSL_DEFINE_ASCII_STRING_LITERAL_END(MICROEDITION_CONFIGURATION_PROP);

PCSL_DEFINE_STATIC_ASCII_STRING_LITERAL_START(class_suffix)
    {'.','c','l','a','s','s', '\0'}
PCSL_DEFINE_STATIC_ASCII_STRING_LITERAL_END(class_suffix);

extern char* getApplicationDir(char *cmd);

PCSL_DEFINE_ASCII_STRING_LITERAL_START(ENTRY_NAME)
    {'M', 'E', 'T', 'A', '-', 'I', 'N', 'F', '/',
     'M','A', 'N', 'I', 'F', 'E', 'S', 'T',
     '.', 'M', 'F', '\0'}
PCSL_DEFINE_ASCII_STRING_LITERAL_END(ENTRY_NAME);

PCSL_DEFINE_ASCII_STRING_LITERAL_START(TEMP_JAR_NAME)
    {'t', 'e', 'm', 'p', '.', 'j', 'a', 'r', '\0'}
PCSL_DEFINE_ASCII_STRING_LITERAL_END(TEMP_JAR_NAME);

/* Dummy implementations of functions needed to run in NamsTestService mode. */
#if !ENABLE_I3_TEST
void nams_test_service_setup_listeners() {}
void nams_test_service_remove_listeners() {}
#endif

/**
 * 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;
}
/**
 * Converts char buffer to jchar buffer
 *
 * @param char_buf  pointer to already allocated char buffer
 * @param jchar_buf pointer to already allocated jchar buffer
 * @param char_buf_size
 *                  size of the char buf
 */
void convertChar2JChar(char* char_buf, jchar* jchar_buf, int char_buf_size) {
    while ((*char_buf) && (char_buf_size--)) {
        *jchar_buf = (jchar)*char_buf;
        char_buf++;
        jchar_buf++;
    }
} /* end of convertChar2JChar */

/**
 * Converts jchar buffer to char buffer
 *
 * @param char_buf  pointer to char buffer
 * @param jchar_buf pointer to jchar buffer
 * @param char_buf_size
 *                  size of the char buf
 */
void convertJChar2Char(jchar* jchar_buf, char* char_buf, int jchar_buf_size) {
    int i = 0;
    for (i = 0; i < jchar_buf_size; i++) {
        *(char_buf+i) = (char)(*(jchar_buf+i));
    }
}/* end of convertJChar2Char */

/**
 * Version string may looks like Major:Minor:Micro
 *
 * @param ver    pcsl_string that contains a version
 * @param major  Major version
 * @param minor  Minor version
 * @param micro  Micro version
 * @return 1 == OK
 *         0 = BAD version
 */
int midpGetVersion(const pcsl_string * ver, int *major, int *minor, int *micro) {
    int ma = 0;
    int mi = 0;
    int mc = 0;
    int count = 0;
    int dot_count = 0;
    int segment_size = 0;
    const jchar* p = NULL;
    const jchar* ver_data;
    jsize ver_len = pcsl_string_utf16_length(ver);

    *major = -1;
    *minor = -1;
    *micro = -1;

    if ((ver_len <= 0) || (ver_len > 8)) {
        return 0;
    }
    printPcslStringWithMessage("ver", ver);

    ver_data = pcsl_string_get_utf16_data(ver);
    if (NULL == ver_data) {
        return 0;
    }

    /* most checking done here */
    for (count=0; count < ver_len; count++) {
        if ((ver_data[count] >= '0') && (ver_data[count] <= '9')) {
            segment_size++;
        } else if (ver_data[count] == '.') {
            if ((segment_size == 0) || (segment_size > 2)) {
                REPORT_ERROR1(LC_AMS, "segment size wrong %d",
                              segment_size);
                pcsl_string_release_utf16_data(ver_data, ver);
                return 0;
            }
            dot_count++;
            segment_size = 0;
        } else {
            pcsl_string_release_utf16_data(ver_data, ver);
            return 0;
        }
    } /* end of for */

    /* can't be more then 2 dots in version */
    if (dot_count > 2) {
        REPORT_ERROR1(LC_AMS, "too many dots (%d)", dot_count);
        pcsl_string_release_utf16_data(ver_data, ver);
        return 0;
    }

    /*
     * Get major version
     */
    for (p = ver_data, count = 0; (*p != '.') && (count < ver_len); ) {
        if (*p >= '0' && *p <= '9') {
            ma *= 10;
            ma += *p - '0';
        } else {
            pcsl_string_release_utf16_data(ver_data, ver);
            return 0;
        }
        count++;
        p++;
    } /* end of for */

    if(*p == '.') {
        p++;
        count++;
    }

    /*
     * Get minor version.
     */
    for ( ; (*p != '.') && (count < ver_len); ) {
        if (*p >= '0' && *p <= '9') {
            mi *= 10;
            mi += *p - '0';
        } else {
            pcsl_string_release_utf16_data(ver_data, ver);
            return 0;
        }
        count++;
        p++;
    }

    if(*p == '.') {
        p++;
        count++;
    }

    /*
     * Get micro version; if it exists..
     */
    for ( ; (*p != '.') && (count < ver_len); ) {
        if (*p >= '0' && *p <= '9') {
            mc *= 10;
            mc += *p - '0';
        } else {
            pcsl_string_release_utf16_data(ver_data, ver);
            return 0;
        }
        p++;
        count++;
    }
    *major = ma;
    *minor = mi;
    *micro = mc;
    pcsl_string_release_utf16_data(ver_data, ver);
    return 1;
}

/**
 * Compares two versions.
 * A version must be "<major>.<minor>".
 * Both <major> and <minor> must be a string of 1 to 3 decimal digits.
 * <BR>
 * <B>Note:</B>
 * (1) If both version strings are invalid, treat them as the same version.
 * (2) If only the second version is valid, treat the second version as newer.
 * (3) If only the first version is valid, treat the first version as newer.
 *
 * @param ver1   First version
 * @param ver2   Second version
 * @return < 0 if ver1 < ver2
 *         = 0 if ver1 = ver2
 *         > 0 if ver1 > ver2
 */
int midpCompareVersion(const pcsl_string * ver1, const pcsl_string * ver2) {
    int major1, minor1, micro1;
    int major2, minor2, micro2;
    int error1, error2;

    error1 = (midpGetVersion(ver1, &major1, &minor1, &micro1) != 1);
    error2 = (midpGetVersion(ver2, &major2, &minor2, &micro2) != 1);

    /*
     * (1) If both version strings are invalid, treat them as the same
     *     version.
     * (2) If only the second version is valid, treat the second version
     *     as newer.
     * (3) If only the first version is valid, treat the first version
     *     as newer.
     */
    if (error1 && error2) {
        return 0;
    }
    if (error1) {
        return -1;
    }
    if (error2) {
        return 1;
    }
    if (major1 < major2) {
        return -1;
    }
    if (major1 > major2) {
        return  1;
    }
    if (minor1 < minor2) {
        return -1;
    }
    if (minor1 > minor2) {
        return  1;
    }
    if (micro1 < micro2) {
        return -1;
    }
    if (micro1 > micro2) {
        return  1;
    }
    return 0;
}

/**
 *
 * @param ver
 * @return 1 == OK
 *         0 = BAD version
 */
int midpCheckVersion(const pcsl_string * ver) {
    int major = 0;
    int minor = 0;
    int micro = 0;
    return midpGetVersion(ver, &major, &minor, &micro);
}

/**