jam_call_back_handler.c

java 1.1 gemini 08_16

			{
				error_code = old_handler;
				goto install_copy_error;
			}
			file_size = FS_Seek(old_handler, 0, SEEK_END);
			FS_Seek(old_handler, 0, SEEK_SET);
			scan_off = 0;
			while (scan_off < file_size - 1000)
			{
				error_code = FS_Read(old_handler, save_buffer, 1000, &dummy);
				if (error_code < 0)
				{
					goto install_copy_error;
				}
				error_code = FS_Write(new_handler, save_buffer, 1000, &dummy);
				if (error_code < 0)
				{
					goto install_copy_error;
				}
				scan_off += 1000;
			}
			if (file_size - scan_off > 0)
			{
				error_code = FS_Read(old_handler, save_buffer, file_size - scan_off, &dummy);
				if (error_code < 0)
				{
					goto install_copy_error;
				}
				error_code = FS_Write(new_handler, save_buffer, file_size - scan_off, &dummy);
			}
			install_copy_error:
			midpFree(save_buffer);
			FS_Close(old_handler);
			FS_Close(new_handler);
			if (error_code < FS_NO_ERROR)
			{
				if (error_code == FS_PATH_NOT_FOUND)
				{
					return_code = JAR_NOT_FOUND;
					has_disk_op_error = KAL_TRUE;
				} else if (error_code == FS_DISK_FULL)
				{
					has_disk_op_error = KAL_TRUE;               
				} else
				{
					return_code = DISK_OPERATION_FAIL;
					has_disk_op_error = KAL_TRUE;   
				}
			}
		} else
			return_code	= JAR_NOT_FOUND;

		if (!has_disk_op_error && return_code == -1)
		{
			argv[0] = "midp";
			if (jad_file_name == NULL)
			{
				argv[1] = "-installJar";
				argv[2] = "file://li.jar";
			} else
			{
				argv[1] = "-install";
				argv[2] = "file://li.jad";
			}

			enterAMS = 0;

#ifndef __SUPPORT_NATIVE_INSTALLER__
			Java_State = JAVA_ACTIVATED_STATE;
			midp_main(type, 3, argv);
			Java_State = JAVA_IDLE_STATE;
#else			
			saved_state = Java_State;
			Java_State = JAVA_IDLE_STATE;
			if (jad_file_name != NULL) install_main(type, AMS_OP_INSTALL, work_dir_path, argv[2]);
			else install_main(type, AMS_OP_INSTALL_JAR, work_dir_path,argv[2]);
			Java_State = saved_state;
#endif /* !__SUPPORT_NATIVE_INSTALLER__ */

		} else
		{
			if (return_code == -1)
				/* disk operation fail --> must be disk full */
				return_code = INSUFFICIENT_STORAGE;
		}

		if (return_code != -1)
		{
			jam_install_confirm_error_code(return_code);
			install_update_status.has_returned_res = KAL_TRUE;
		}

		kal_sleep_task(40);
		local_install_return_and_clean:
		deleteTempFile(type);
		delete_need_to_recover_file(type);
		if (is_mms_jad_jar_intallation)
		{
			if (jad_file_name != NULL)
			{
				free_ctrl_buffer(jad_file_name);
				jad_file_name = NULL;
			}
			if (jar_file_name != NULL)
			{
				free_ctrl_buffer(jar_file_name);
				jar_file_name = NULL;
			}
		}
		if (work_dir_path != work_sys_dir_path)
		{
			jam_listmem_free(work_dir_path);
			work_dir_path = work_sys_dir_path;
		}
	} else
	{
		kal_char* argv[3];
		kal_char* file_path = NULL;
		kal_char * myError = NULL;
		kal_int32 handle;
		kal_int32 len;
		kal_wchar * save_path;
		kal_int32 result;
#ifdef __DRM_SUPPORT__	
		kal_int32 drm_check_handle;
        kal_uint8 method;
#endif /* __DRM_SUPPORT__ */

		if (jad_file_name != NULL)
		{
			len = strlen(work_sys_dir_path) + 1 +  get_ucs2_len((kal_wchar*)temp_file_name);
			save_path = get_ctrl_buffer((len+1) << 1);
			kal_wsprintf(save_path,"%s\\%w",work_sys_dir_path, temp_file_name);
			save_path[len -1] = 'd';
			/* move file to c:\@JAVA */
#ifdef __DRM_SUPPORT__	
            drm_check_handle = DRM_open_file(jad_file_name, FS_READ_ONLY | FS_OPEN_SHARED, DRM_PERMISSION_EXECUTE);
            method = DRM_get_object_method(drm_check_handle, NULL);
            DRM_close_file(drm_check_handle);

			if ( DRM_METHOD_FORWARD_LOCK != method && DRM_METHOD_NONE != method)
			{
				result = FS_Move(jad_file_name, save_path, FS_MOVE_COPY | FS_MOVE_OVERWRITE, NULL, NULL, 0);
			}
			else
#endif /* __DRM_SUPPORT__ */
			{
				result = FS_Move(jad_file_name, save_path, FS_MOVE_KILL | FS_MOVE_OVERWRITE, NULL, NULL, 0);
			}                
			

			/* SHK: Under this case, we need to deallocate the ctrl buffer later. */
			jad_file_name = save_path;
			is_jad_file_name_changed = KAL_TRUE;
			
			if (result<0)
			{
				/* SHK: When in this case, the jad_file_name's ctrl buffer has been replaced and therefore need to be de-allocated.
				            However, the jar_file_name's ctrl buffer does not changed, and therefore MUST NOT be de-allocated.*/
				goto normal_install_return_and_clean;
			}
			len = get_ucs2_len(jad_file_name);
		}

		if (jar_file_name != NULL)
		{
			kal_int32 j2me_dir_length = strlen(work_sys_dir_path);
			kal_char temp_char;
			kal_char* temp_j2me_dir;
			len = strlen(work_sys_dir_path) + 1 +  get_ucs2_len((kal_wchar*)temp_file_name);
			save_path = get_ctrl_buffer((len+1) << 1);
			trans_utf8_to_ucs2(save_path, work_sys_dir_path);
			kal_wsprintf(save_path+strlen(work_sys_dir_path),"\\%w",temp_file_name);
			temp_char = (kal_char)save_path[j2me_dir_length];
			/* change from c:\@Java to d:\@Java */
			if (jar_file_name[0] >= 'A' && jar_file_name[0] <= 'Z')
			{
				save_path[0] = jar_file_name[0];
			} else
			{
				kal_wchar tempPath[2];
				FS_GetCurrentDir(tempPath, 1);
				save_path[0] = tempPath[0];
			}

			/* create d:\@Java */
			save_path[j2me_dir_length] = 0;
			result = check_and_create_hidden_folder(save_path);

			if (result < 0)
			{
				if(result == FS_ROOT_DIR_FULL)
				{
					jam_install_confirm_error_code(ROOT_DIR_FULL);
				}
				else
				{
					jam_install_confirm_error_code(INSUFFICIENT_STORAGE);
				}
				install_update_status.has_returned_res = KAL_TRUE;
				free_ctrl_buffer(save_path);
				save_path = NULL;

				/* SHK: When in this case, the jar_file_name's ctrl buffer does not changed, and therefore MUST NOT be de-allocated.*/
				goto normal_install_return_and_clean;
			}
			/* roll back the path */
			save_path[j2me_dir_length] = temp_char;
			if (result >= 0)
			{
#ifdef __DRM_SUPPORT__
                drm_check_handle = DRM_open_file(jar_file_name, FS_READ_ONLY | FS_OPEN_SHARED, DRM_PERMISSION_EXECUTE);
                method = DRM_get_object_method(drm_check_handle, NULL);
                DRM_close_file(drm_check_handle);

                if ( DRM_METHOD_FORWARD_LOCK != method && DRM_METHOD_NONE != method)
				{
					result = FS_Move(jar_file_name, save_path, FS_MOVE_COPY | FS_MOVE_OVERWRITE, NULL, NULL, 0);
				}
				else
#endif /* __DRM_SUPPORT__ */
				{
					result = FS_Move(jar_file_name, save_path, FS_MOVE_KILL | FS_MOVE_OVERWRITE, NULL, NULL, 0);
				}
			}

			/* SHK: Under this case, we need to deallocate the ctrl buffer later. */
			jar_file_name = save_path;
			is_jar_file_name_changed = KAL_TRUE;
			
			if (result == FS_DISK_FULL)
			{
				jam_install_confirm_error_code(INSUFFICIENT_STORAGE);
				install_update_status.has_returned_res = KAL_TRUE;
				goto normal_install_return_and_clean;               
			} else if (result<0)
			{
				goto normal_install_return_and_clean;
			}
			temp_j2me_dir = jam_listmem_malloc(strlen(work_sys_dir_path) + 1);
			strcpy(temp_j2me_dir, work_sys_dir_path);
			temp_j2me_dir[0] = jar_file_name[0];
			work_dir_path = temp_j2me_dir;
		}

		argv[0] = "midp";
		if (jad_file_name != NULL)
		{
			file_path = (kal_char*)get_ctrl_buffer(
												  get_ucs2_len(jad_file_name + strlen(work_dir_path) + 1)
												  + 1 + 7);	/* c:\JAVA/ file:// */

			strcpy(file_path, "file://");
			trans_ucs2_to_utf8(file_path + 7, jad_file_name + strlen(work_dir_path) + 1);	/* c:\JAVA/ */
			argv[1] = "-install";
		} else
		{
			file_path = (kal_char*)get_ctrl_buffer(
												  get_ucs2_len(jar_file_name + strlen(work_dir_path) + 1)
												  + 1 + 7);	/* c:\JAVA/ file:// */

			strcpy(file_path, "file://");
			trans_ucs2_to_utf8(file_path + 7, jar_file_name + strlen(work_dir_path) + 1);	/* c:\JAVA/ */
			argv[1] = "-installJar";
		}
		argv[2] = file_path;
		/* adjust the WAP downloading file size. */
		handle = storageOpen(&myError, (kal_char*)(file_path + 7), OPEN_READ);


		if (myError == NULL)
		{
			java_total_used_space += storageSizeOf(&myError, handle);
			storageClose(&myError, handle);
		}

		enterAMS = 0;

#ifndef __SUPPORT_NATIVE_INSTALLER__
		Java_State = JAVA_ACTIVATED_STATE;
		midp_main(type, 3, argv);
		Java_State = JAVA_IDLE_STATE;
#else			
		saved_state = Java_State;
		Java_State = JAVA_IDLE_STATE;
		if (jad_file_name != NULL) install_main(type, AMS_OP_INSTALL, work_dir_path, argv[2]);
		else install_main(type, AMS_OP_INSTALL_JAR, work_dir_path,argv[2]);
		 Java_State = saved_state;
#endif /* !__SUPPORT_NATIVE_INSTALLER__ */

		if (work_dir_path != work_sys_dir_path)
		{
			jam_listmem_free(work_dir_path);
			work_dir_path = work_sys_dir_path;
		}
		normal_install_return_and_clean:

		if((jad_file_name != NULL) && (is_jad_file_name_changed == KAL_TRUE))
		{
			free_ctrl_buffer(jad_file_name);
			jad_file_name 	= NULL;
		}
		
		/* SHK: It will cause doubly free the control buffer. */
		if((jar_file_name != NULL) && (is_jar_file_name_changed == KAL_TRUE))
		{
			free_ctrl_buffer(jar_file_name);
			jar_file_name 	= NULL;
		}
		
		if (file_path != NULL)
		{
			storageDeleteFile(&myError, file_path + 7);
			free_ctrl_buffer(file_path);
			file_path 			= NULL;
		}
		deleteTempFile(type);
		delete_need_to_recover_file(type);
	}
	jam_restore_work_dir();
	finialize_file_handler();
}

kal_int32 
jam_get_event_abort_handler(void)
{
	if (is_in_critical_path == 0 && (install_update_status.is_normal_install ||
									 install_update_status.is_update ||
									 install_update_status.is_local_install))
	{
		if (install_update_status.need_to_clean ||
			install_update_status.is_normal_install ||
			install_update_status.is_update)
		{
#ifndef __SUPPORT_NATIVE_INSTALLER__
			KNI_ThrowNew("java/lang/RuntimeException", "");
#endif
			return J2ME_GET_NEXT_EVENT_ABORT;
		}
		jvm_stopVMExternal();
	} else
	{
		return J2ME_GET_NEXT_EVENT_ABORT;
	}

	return 0;
}

kal_wchar* 
jam_get_jar_storage_name(void* (*this_malloc)(int size), kal_int32 MIDS_id)
{
	kal_char* storage_name;
	kal_char* mids_id_str;
	kal_int32 total_string_len = 0;
	WCHAR* wfilename;
	kal_char* tempPath = get_dir_path_from_midsid(MIDS_id);
	mids_id_str = (kal_char*)get_ctrl_buffer(get_dec_len(MIDS_id) + 1);
	trans_dec_to_ascii(mids_id_str, MIDS_id);
	storage_name = getStorageNameFromNumber(mids_id_str);
	free_ctrl_buffer(mids_id_str);
	total_string_len += strlen(work_sys_dir_path);
	total_string_len += strlen(storage_name);
	total_string_len += 11;
	wfilename = this_malloc(total_string_len << 1);

	if (tempPath != NULL) kal_wsprintf(wfilename,"%s\\%s%s", tempPath, storage_name, "suite.jar");
	else kal_wsprintf(wfilename,"%s\\%s%s", work_sys_dir_path, storage_name, "suite.jar");
	if (tempPath != NULL) jam_listmem_free(tempPath);

	midpFree(storage_name);
	return wfilename;
}

kal_char *jam_get_running_storage_name(void)
{

	return currently_running_storage_name;
}

void jam_backup_work_dir(void)
{
	kal_char *temp_buffer = NULL;
	
	saved_work_dir_path = work_dir_path;
	saved_work_sys_dir_path = work_sys_dir_path;
	if(strlen(work_dir_path) > 0)
	{
		temp_buffer = midpMalloc(strlen(work_dir_path) + 1);
		strcpy(temp_buffer, work_dir_path);
		work_dir_path = temp_buffer;
	}

	if(strlen(work_sys_dir_path) > 0)
	{
		temp_buffer = midpMalloc(strlen(work_sys_dir_path) + 1);
		strcpy(temp_buffer, work_sys_dir_path);
		work_sys_dir_path = temp_buffer;
	}
}

void jam_restore_work_dir(void)
{
	if( work_dir_path != NULL)
	{
		midpFree(work_dir_path);
	}
	if( work_sys_dir_path != NULL)
	{
		midpFree(work_sys_dir_path);
	}
#ifdef __SUPPORT_INFUSIO__
	if(infusio_mids_type == GAMETYPE_INFUSIO_EUREKA)
	{
		set_work_sys_dir_path_for_EGE();
		strcpy(work_dir_path, work_sys_dir_path);
	}else {
#endif
	work_dir_path = saved_work_dir_path;
	work_sys_dir_path = saved_work_sys_dir_path;
#ifdef __SUPPORT_INFUSIO__
	}
#endif
}