jam_policy.c

java 1.1 gemini 08_16

                kal_char* temp_str;
                switch(permision_setting)
                {
                    case PERMISSION_BLANKET_GRANTED:
                        permission_map = 1;
                    break;
                    case PERMISSION_BLANKET:
                        permission_map = 1;
                    break;
                    case PERMISSION_SESSION:
                        permission_map = 2;
                    break;
                    case PERMISSION_ONE_SHOT:
                        permission_map = 3;
                    break;
                    case PERMISSION_DENY_SESSION:
                    case PERMISSION_DENY:
                    case PERMISSION_USER_DENIED:
                        permission_map = 4;
                    break;
                }
                if(permission_map == 0)
                {
                    return J2ME_ACTION_FAILE;
                }
                str_index = 0;
                while(kp[temp_index].key[str_index] != 0 && kp[temp_index].key[str_index] != '(')
                {
                    str_index ++;
                }
                kp[temp_index].key[str_index] = 0;
                temp_str = kp[temp_index].key;
                if(permission_map != 4)
                {
                    kp[temp_index].key = (kal_char*)jvm_malloc(str_index + kp_map[permission_map].key_len + 3);
                    strcpy(kp[temp_index].key, temp_str);
                    kp[temp_index].key[str_index] = '(';
                    strcpy(&(kp[temp_index].key[str_index + 1]), kp_map[permission_map].key_string);
                    str_index = str_index + kp_map[permission_map].key_len;
                    kp[temp_index].key[str_index + 1] = ')';
                    kp[temp_index].key[str_index + 2] = 0;
                    jvm_free(temp_str);
                }
                break;
            }
            temp_index ++;
        }
        if(temp_index == end_index)
        {
            return J2ME_ACTION_FAILE;
        }
        a2p_index ++;
    }
    return J2ME_NO_ERROR;
}

/*****************************************************************************
 * FUNCTION
 *  get_key_pair_from_file
 * DESCRIPTION
 *  Get the key / value pairs from _policy.txt.
 * PARAMETERS
 *  void
 * RETURNS
 *  key_value_pair_struct    key / value pairs
 *****************************************************************************/
key_value_pair_struct* get_key_pair_from_file(game_type_enum type)
{
    kal_int32 file_size;
    kal_int32 src_handle;
    char* policy_file_data;
    key_value_pair_struct* kp;
    /* Update working internal system directory path */
    work_sys_dir_path = _jvm_get_dir_path(type);
    src_handle = jvm_file_open("_policy.txt", FS_READ_ONLY | FS_OPEN_SHARED);
    
    file_size = jvm_file_lseek(src_handle, 0, SEEK_END);
    policy_file_data = jvm_malloc(file_size);
    jvm_file_lseek(src_handle, 0, SEEK_SET);
    jvm_file_read(src_handle, policy_file_data, file_size);
	jvm_file_close(src_handle);
    kp = (key_value_pair_struct*) jvm_malloc(sizeof(key_value_pair_struct) * (get_attribute_number(policy_file_data) + 1));
    parse_key_pair(kp, policy_file_data);
    jvm_free(policy_file_data);
    return kp;
}

/*****************************************************************************
 * FUNCTION
 *  save_key_pair
 * DESCRIPTION
 *  Save key / value pairs to _policy.txt file
 * PARAMETERS
 *  kp          [IN]        The key / value pair structure
 * RETURNS
 *  J2ME_NO_ERROR if no error or J2ME_ACTION_FAILE if fail.
 *****************************************************************************/
kal_int32 save_key_pair(game_type_enum type, key_value_pair_struct* kp)
{
    kal_int32 dst_handle;
    kal_int32 kp_index = 0;
    if(kp[kp_index + 1].key == NULL)
    {
        return J2ME_NO_ERROR;
    }
    /* Update working internal system directory path */
    work_sys_dir_path = _jvm_get_dir_path(type);
    dst_handle = jvm_file_open("_policy.txt", FS_READ_WRITE | FS_CREATE_ALWAYS | FS_OPEN_SHARED);
    if(dst_handle < 0)
    {
        return J2ME_ACTION_FAILE;
    }
    while(KAL_TRUE)
    {
        jvm_file_write(dst_handle, kp[kp_index].key, strlen(kp[kp_index].key));
        jvm_file_write(dst_handle, ": ", 2);
        jvm_file_write(dst_handle, kp[kp_index].value, strlen(kp[kp_index].value));
        if(kp[kp_index + 1].key != NULL)
        {
            if(strcmp(kp[kp_index + 1].key, "alias") == 0 || strcmp(kp[kp_index + 1].key, "domain") == 0)
            {
                jvm_file_write(dst_handle, "\r\n\r\n", 4);
            }
            else
            {
                jvm_file_write(dst_handle, "\r\n", 2);
            }
            kp_index ++;
        }
        else
        {
            jvm_file_write(dst_handle, "\r\n", 2);
            jvm_file_close(dst_handle);
            return J2ME_NO_ERROR;
        }
    }  
}

/*****************************************************************************
 * FUNCTION
 *  free_a2p
 * DESCRIPTION
 *  Free memory.
 * PARAMETERS
 *  a2p          [IN]        
 * RETURNS
 *  void.
 *****************************************************************************/
void free_a2p(alias_to_perm_struct* a2p)
{
    kal_int32 a2p_index = 0;
    while(a2p[a2p_index].key != NULL)
    {
        jvm_free(a2p[a2p_index].key);
        a2p_index ++;
    }
    jvm_free(a2p);
}

/*****************************************************************************
 * FUNCTION
 *  free_kp
 * DESCRIPTION
 *  Free memory.
 * PARAMETERS
 *  kp          [IN]        
 * RETURNS
 *  void.
 *****************************************************************************/
void free_kp(key_value_pair_struct* kp)
{
    kal_int32 kp_index = 0;
    while(kp[kp_index].key != NULL)
    {
        jvm_free(kp[kp_index].key);
        jvm_free(kp[kp_index].value);
        kp_index ++;
    }
    jvm_free(kp);
}

/*****************************************************************************
 * FUNCTION
 *  free_domain_perm
 * DESCRIPTION
 *  Free memory.
 * PARAMETERS
 *  domain_perm          [IN]        
 * RETURNS
 *  void.
 *****************************************************************************/
void free_domain_perm(domain_permission_struct* domain_perm)
{
    kal_int32 domain_perm_index = 0;
    while(domain_perm[domain_perm_index].domain != NULL)
    {
        jvm_free(domain_perm[domain_perm_index].domain);
        domain_perm_index ++;
    }
    jvm_free(domain_perm);
}

/* Testing program */
/*
int main(int argc, char** argv)
{
    key_value_pair_struct* kp;
    mmi_setting_struct default_setting;
    
    domain_permission_struct* domain_perm;
    alias_to_perm_struct* a2p;

    kp = get_key_pair_from_file();
    a2p = get_a2p(kp);
    domain_perm = get_domain_perm(kp, a2p);
    
    default_setting.permission_network = PERMISSION_ONE_SHOT;
    default_setting.permission_push = PERMISSION_ONE_SHOT;
    default_setting.permission_message = PERMISSION_ONE_SHOT;
    default_setting.permission_multimedia = PERMISSION_ONE_SHOT;
    default_setting.permission_data_read = PERMISSION_ONE_SHOT;
    default_setting.permission_data_write = PERMISSION_ONE_SHOT;
    default_setting.permission_local_connectivity = PERMISSION_ONE_SHOT;

    set_permission(kp, "abc", a2p, domain_perm, &default_setting);
    set_permission(kp, "untrusted", a2p, domain_perm, &default_setting);
    
    default_setting.permission_network = PERMISSION_SESSION;
    default_setting.permission_push = PERMISSION_DENY;
    default_setting.permission_message = PERMISSION_BLANKET_GRANTED;
    default_setting.permission_multimedia = PERMISSION_BLANKET;
    default_setting.permission_data_read = PERMISSION_DENY;
    default_setting.permission_data_write = PERMISSION_ONE_SHOT;
    default_setting.permission_local_connectivity = PERMISSION_ONE_SHOT;

    set_permission(kp, "3rd-dmn", a2p, domain_perm, &default_setting);
    
    save_key_pair(kp);
    free_domain_perm(domain_perm);
    free_a2p(a2p);
    free_kp(kp);
    return 0;
}
*/

kal_int32 jam_get_domain_list(game_type_enum type, kal_int32* total_domain, kal_wchar domains[10][30])
{
    key_value_pair_struct* kp;
    domain_permission_struct* domain_perm;
    alias_to_perm_struct* a2p;
    kal_int32 total = 0;
    kp = get_key_pair_from_file(type);
    a2p = get_a2p(kp);
    domain_perm = get_domain_perm(kp, a2p);
    while(domain_perm[total].domain != NULL)
    {
		if(strlen(domain_perm[total].domain) > 29)
		{
			domain_perm[total].domain[29] = 0;
		}
        trans_utf8_to_ucs2(domains[total], domain_perm[total].domain);
        total ++;
        if(total >= 10)
        {
            break;
        }
    }
    *total_domain = total;
    free_domain_perm(domain_perm);
    free_a2p(a2p);
    free_kp(kp);
    return J2ME_NO_ERROR;
}

kal_int32 jam_get_default_setting(game_type_enum type, kal_int32 domain_id, mmi_setting_struct* max_setting, mmi_setting_struct* default_setting)
{
    key_value_pair_struct* kp;
    domain_permission_struct* domain_perm;
    alias_to_perm_struct* a2p;
    kp = get_key_pair_from_file(type);
    a2p = get_a2p(kp);
    domain_perm = get_domain_perm(kp, a2p);
    memcpy(max_setting, &domain_perm[domain_id].max_perm, sizeof(mmi_setting_struct));
    memcpy(default_setting, &domain_perm[domain_id].perm, sizeof(mmi_setting_struct));
    free_domain_perm(domain_perm);
    free_a2p(a2p);
    free_kp(kp);
    return J2ME_NO_ERROR;
}

kal_int32 jam_set_default_setting(game_type_enum type, kal_int32 domain_id, mmi_setting_struct* default_setting)
{
    key_value_pair_struct* kp;
    domain_permission_struct* domain_perm;
    alias_to_perm_struct* a2p;
    kal_int32 return_value = 0;
    kp = get_key_pair_from_file(type);
    a2p = get_a2p(kp);
    domain_perm = get_domain_perm(kp, a2p);
    return_value = set_permission(kp, domain_perm[domain_id].domain, a2p, domain_perm, default_setting);
    if(return_value == J2ME_NO_ERROR)
    {
   	    save_key_pair(type, kp);
   	}
    free_domain_perm(domain_perm);
    free_a2p(a2p);
    free_kp(kp);
    return return_value;
}

kal_int32 jam_reset_default_permission_setting(game_type_enum type)
{
    int result;
    int i;
    int handle;
    kal_uint32 realCount;
    const char* 			normal_file_name;
    const unsigned char* 	normal_file_data;
    kal_int32 normal_file_size;
    kal_char* dir_path = _jvm_get_dir_path(type);
    int normal_file_count = j2me_custom_file_info_ptr->normal_file_info.normal_file_count;

    /* generate normal file */
    for (i=0; i<normal_file_count; i++) {
        normal_file_name = j2me_custom_file_info_ptr->normal_file_info.normal_file_name[i];
        normal_file_data = j2me_custom_file_info_ptr->normal_file_info.normal_file_data[i];
        normal_file_size = j2me_custom_file_info_ptr->normal_file_info.normal_file_size[i];

        if(strcmp("_policy.txt", normal_file_name) == 0)
        {
            kal_wsprintf(WCHARFilename, "%s\\%s", dir_path, normal_file_name);
            handle = FS_Open(WCHARFilename, FS_READ_WRITE | FS_CREATE_ALWAYS | FS_OPEN_SHARED);
            result = FS_Write(handle, (void *)normal_file_data, normal_file_size, &realCount);

            ASSERT(result == FS_NO_ERROR);

            FS_Close(handle);
            break;
        }
    }

    return J2ME_NO_ERROR;
}
    
#endif /* OGDR_SECURITY_SETTING */