path: root/common/src/email-utils.c

/*
 * Copyright 2012  Samsung Electronics Co., Ltd
 *
 * Licensed under the Flora License, Version 1.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.tizenopensource.org/license
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <sys/time.h>
#include <glib.h>
#include <glib/gprintf.h>
#include <appcore-common.h>
#include <vconf.h>
#include <stdlib.h>
#include <regex.h>
#include <errno.h>
#include <drm_client.h>
#include <drm_client_types.h>

#include "email-utils.h"

char *icu_locale = NULL;
static UDateTimePatternGenerator *icu_pattern_generator = NULL;
static UDateFormat *icu_formatter_hmm = NULL;
static UDateFormat *icu_formatter_Hmm = NULL;
static UDateFormat *icu_formatter_MMMyyyy = NULL;
static UDateFormat *icu_formatter_MMMd = NULL;
static UDateFormat *icu_formatter_EEEMMMd = NULL;
enum appcore_time_format icu_timeformat;


static void _generate_best_pattern(const char *locale, UChar * customSkeleton, char *formattedString, void *time);
static int _open_icu_pattern_n_formatter(const char *locale, char *skeleton, UDateFormat **formatter);
static int _close_icu_pattern_n_formatter(UDateFormat *formatter);

/*
 * Function implementation
 */
char *email_get_current_theme_name(void)
{
	char *theme_name = NULL;
	char *save_ptr = NULL;

	/* Get current theme path. Return value is a full path of theme file. ex) blue-hd:default */
	const char *current_theme_path = elm_theme_get(NULL);
	debug_log("current_theme_path [%s]", current_theme_path);

	if (current_theme_path == NULL) {
		debug_log("current_theme_path is NULL !!");
		return NULL;
	}

	theme_name = strdup(current_theme_path);
	if (theme_name == NULL) {
		debug_log("theme_name is NULL !!");
		return NULL;
	}

	theme_name = strtok_r(theme_name, ":", &save_ptr);
	if (theme_name == NULL) {
		debug_log("theme_name is NULL !!");
		return NULL;
	}

	debug_log("theme_name [%s]", theme_name);

	return theme_name;
}

gboolean email_check_file_exist(const gchar *path)
{
	debug_log("");
	RETURN_VAL_IF_FAIL(STR_VALID(path), FALSE);

	if (!g_file_test(path, G_FILE_TEST_EXISTS)) {
		return FALSE;
	}
	return TRUE;
}

gboolean email_check_dir_exist(const gchar *path)
{
	debug_log("");
	RETURN_VAL_IF_FAIL(STR_VALID(path), FALSE);

	if (!g_file_test(path, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)) {
		return FALSE;
	}
	return TRUE;
}

gchar *email_parse_get_filename_from_path(const gchar *path)
{
	debug_log("");
	RETURN_VAL_IF_FAIL(STR_VALID(path), NULL);

	guint index = 0;

	gchar *file_path = g_strdup(path);
	file_path = g_strstrip(file_path);
	gchar **token_list = g_strsplit_set(file_path, "/", -1);
	g_free(file_path);	/* MUST BE. */

	RETURN_VAL_IF_FAIL(token_list != NULL, NULL);

	while (token_list[index] != NULL) {
		index++;
	}

	gchar *file_name = g_strdup(token_list[index - 1]);

	g_strfreev(token_list);	/* MUST BE. */

	/*token_list = g_strsplit_set(file_name, ".", -1);
	RETURN_VAL_IF_FAIL(token_list != NULL, NULL);
	gchar *file_name_without_ext = g_strdup(token_list[0]);
	g_strfreev(token_list);*/

	int len = 0;
	if (file_name)
		len = strlen(file_name);

	gchar *ext = g_strrstr(file_name, ".");
	if (ext)
		len = len - strlen(ext);

	gchar *file_name_without_ext = g_strndup(file_name, len);

	g_free(file_name);	/* MUST BE. */

	debug_log("file name (%s)", file_name_without_ext);

	return file_name_without_ext;
}

void email_parse_get_filename_n_ext_from_path(const gchar *path, gchar **ret_file_name, gchar **ret_ext)
{
	debug_log("");
	RETURN_IF_FAIL(STR_VALID(path));

	guint index = 0;

	gchar *file_path = g_strdup(path);
	file_path = g_strstrip(file_path);
	gchar **token_list = g_strsplit_set(file_path, "/", -1);
	g_free(file_path);	/* MUST BE. */

	RETURN_IF_FAIL(token_list != NULL);

	while (token_list[index] != NULL) {
		index++;
	}

	gchar *file_name = g_strdup(token_list[index - 1]);

	g_strfreev(token_list);	/* MUST BE. */

	/*token_list = g_strsplit_set(file_name, ".", -1);
	RETURN_VAL_IF_FAIL(token_list != NULL, NULL);
	gchar *file_name_without_ext = g_strdup(token_list[0]);
	g_strfreev(token_list);*/

	int len = 0;
	if (file_name)
		len = strlen(file_name);

	gchar *ext = g_strrstr(file_name, ".");
	if (ext)
		len = len - strlen(ext);

	*ret_file_name = g_strndup(file_name, len);

	*ret_ext = g_strdup(ext);

	g_free(file_name);
}

void email_save_file(const gchar *path, const gchar *buf, gsize len)
{
	debug_log("");
	if (STR_LEN((gchar *)buf) > 0 && len > 0) {
		int fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
		if (fd != -1) {
			int size = write(fd, (const void *)buf, (size_t) len);
			debug_log("size:%d", size);
			close(fd);
		}
	}
}

gchar *email_get_buff_from_file(const gchar *path, guint max_kbyte)
{
	debug_log("");
	RETURN_VAL_IF_FAIL(STR_VALID(path), NULL);

	debug_log("path (%s)", path);

	FILE *fp = fopen(path, "r");

	if (fp) {

		char body[MAX_STR_LEN + 1] = { 0, };
		size_t size = 0;
		guint kbyte = 0;
		gchar *buff = NULL;
		gchar *temp = NULL;

		while (1) {

			memset(body, 0, sizeof(body));

			size = fread(body, sizeof(unsigned char), MAX_STR_LEN, fp);
			body[MAX_STR_LEN] = '\0';

			if (size <= 0 || STR_LEN(body) == 0)
				break;

			if (max_kbyte > 0 && kbyte > max_kbyte)
				break;

			if (STR_VALID(buff)) {
				temp = g_strconcat(buff, body, NULL);
				g_free(buff);
				buff = temp;
				temp = NULL;
			} else {
				buff = g_strdup(body);
			}

			++kbyte;
		}

		fclose(fp);

		/*
		debug_log("buff [%s]", buff);
		*/

		return buff;
	}

	return NULL;
}

gchar *email_get_file_size_string(guint64 size)
{
	debug_log("");
	gchar str_buf[16] = "\0";

	if (size < 1024) {
		g_sprintf(str_buf, "%d %s", (gint) size, dgettext("sys_string", "IDS_COM_BODY_B"));
	} else {
		gdouble tmpsize = (gdouble) (size / 1024.);

		if (tmpsize < 1024) {
			g_sprintf(str_buf, "%.2f %s", tmpsize, dgettext("sys_string", "IDS_COM_BODY_KB"));
		} else {
			tmpsize /= 1024.;

			if (tmpsize < 1024) {
				g_sprintf(str_buf, "%.2f %s", tmpsize, dgettext("sys_string", "IDS_COM_BODY_MB"));
			} else {
				tmpsize /= 1024.;
				g_sprintf(str_buf, "%.2f %s", tmpsize, dgettext("sys_string", "IDS_COM_BODY_GB"));
			}
		}
	}
	return STR_LEN(str_buf) > 0 ? g_strdup(str_buf) : NULL;
}

guint64 email_get_file_size(const gchar *path)
{
	debug_log("");
	guint64 size = 0;
	struct stat st;
	memset(&st, 0, sizeof(struct stat));

	if (stat(path, &st) == 0) {
		if (S_ISREG(st.st_mode)) {
			size = (guint64) st.st_size;
			debug_log("size (%llu)", size);
		}
	} else {
		size = 0;
	}
	return size;
}

char *email_get_date_text(const char *locale, char *skeleton, void *time)
{
	debug_log("");
	char formattedString[128] = { 0, };
	UChar customSkeleton[64] = { 0, };
	int skeletonLength = strlen(skeleton);

	u_uastrncpy(customSkeleton, skeleton, skeletonLength);
	_generate_best_pattern(locale, customSkeleton, formattedString, time);
	return g_strdup(formattedString);
}

int email_open_icu_pattern_generator(void)
{
	debug_log("");
	UErrorCode status = U_ZERO_ERROR;

	uloc_setDefault(getenv("LC_TIME"), &status);
	if (U_FAILURE(status)) {
		debug_critical("uloc_setDefault() failed: %s\n", u_errorName(status));
		return -1;
	}

	status = U_ZERO_ERROR;
	icu_locale = (char *)uloc_getDefault();
	debug_log("uloc_getDefault: %s", icu_locale);
	appcore_get_timeformat(&icu_timeformat);
	icu_pattern_generator = udatpg_open(icu_locale, &status);

	if (!icu_pattern_generator) {
		debug_log("udatpg_open() failed: %s", u_errorName(status));
		return -1;
	}

	_open_icu_pattern_n_formatter(icu_locale, "hmm", &icu_formatter_hmm);
	_open_icu_pattern_n_formatter(icu_locale, "Hmm", &icu_formatter_Hmm);
	_open_icu_pattern_n_formatter(icu_locale, "MMMyyyy", &icu_formatter_MMMyyyy);
	_open_icu_pattern_n_formatter(icu_locale, "MMMd", &icu_formatter_MMMd);
	_open_icu_pattern_n_formatter(icu_locale, "EEEMMMd", &icu_formatter_EEEMMMd);

	return 0;
}

int email_close_icu_pattern_generator(void)
{
	debug_log("");

	if (icu_pattern_generator) {
		udatpg_close(icu_pattern_generator);
		icu_pattern_generator = NULL;
	}

	_close_icu_pattern_n_formatter(icu_formatter_hmm);
	_close_icu_pattern_n_formatter(icu_formatter_Hmm);
	_close_icu_pattern_n_formatter(icu_formatter_MMMyyyy);
	_close_icu_pattern_n_formatter(icu_formatter_MMMd);
	_close_icu_pattern_n_formatter(icu_formatter_EEEMMMd);

	return 0;
}

static int _open_icu_pattern_n_formatter(const char *locale, char *skeleton, UDateFormat **formatter)
{
	debug_log("");
	UErrorCode status = U_ZERO_ERROR;
	UChar bestPattern[64] = { 0, };
	UChar customSkeleton[64] = { 0, };
	int32_t bestPatternCapacity;
	int32_t bestPatternLength;
	int skeletonLength = strlen(skeleton);

	u_uastrncpy(customSkeleton, skeleton, skeletonLength);

	bestPatternCapacity = (int32_t) (sizeof(bestPattern) / sizeof(bestPattern[0]));
	bestPatternLength = udatpg_getBestPattern(icu_pattern_generator, customSkeleton, u_strlen(customSkeleton), bestPattern, bestPatternCapacity, &status);
	*formatter = udat_open(UDAT_IGNORE, UDAT_IGNORE, locale, NULL, -1, bestPattern, -1, &status);

	return 0;
}

static int _close_icu_pattern_n_formatter(UDateFormat *formatter)
{
	debug_log("");

	udat_close(formatter);

	return 0;
}

static void _generate_best_pattern(const char *locale, UChar * customSkeleton, char *formattedString, void *time)
{
	debug_log("");
	UErrorCode status = U_ZERO_ERROR;
	UDateFormat *formatter;
	UDate date = 0;
	UChar bestPattern[64] = { 0, };
	UChar formatted[64] = { 0, };
	int32_t bestPatternCapacity, formattedCapacity;
	int32_t bestPatternLength, formattedLength;

	bestPatternCapacity = (int32_t) (sizeof(bestPattern) / sizeof(bestPattern[0]));
	bestPatternLength = udatpg_getBestPattern(icu_pattern_generator, customSkeleton, u_strlen(customSkeleton), bestPattern, bestPatternCapacity, &status);

	formatter = udat_open(UDAT_IGNORE, UDAT_IGNORE, locale, NULL, -1, bestPattern, -1, &status);
	formattedCapacity = (int32_t) (sizeof(formatted) / sizeof(formatted[0]));
	if (time) {
		time_t msg_time = *(time_t *)time;
		date = (UDate)msg_time * 1000;	/* Equivalent to Date = ucal_getNow() in Milliseconds */
	}
	formattedLength = udat_format(formatter, date, formatted, formattedCapacity, NULL, &status);
	u_austrncpy(formattedString, formatted, 128);
	udat_close(formatter);
}

gboolean email_drm_file_is_right(const gchar *path)
{
	RETURN_VAL_IF_FAIL(STR_VALID(path), FALSE);

	debug_log("");

	drm_bool_type_e is_drm_file = FALSE;

	if (drm_is_drm_file(path, &is_drm_file) != DRM_RETURN_SUCCESS) {
		debug_log("drm_is_drm_file is failed");
		return FALSE;
	}

	return is_drm_file;
}

gboolean email_drm_file_forward_lock_check(const gchar *path)
{
	RETURN_VAL_IF_FAIL(STR_VALID(path), FALSE);
	RETURN_VAL_IF_FAIL(email_drm_file_is_right(path), FALSE);

	debug_log("");

	drm_file_info_s drm_info;

	memset(&drm_info, 0, sizeof(drm_file_info_s));

	if (drm_get_file_info(path, &drm_info)) {
		debug_log("drm_info.oma_info.method (%d)", drm_info.oma_info.method);
		if (drm_info.oma_info.method == DRM_METHOD_TYPE_FORWARD_LOCK || drm_info.oma_info.method == DRM_METHOD_TYPE_COMBINED_DELIVERY) {
			debug_log("Forward Lock");
			return TRUE;
		}
	}

	return FALSE;
}
/* EOF */