/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.

 * Use is subject to license terms.

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include <locale.h>

#include <strings.h>

#include <string.h>

#include <unistd.h>

#include <libgen.h>

#include <stdlib.h>

#include <sys/types.h>

#include <dirent.h>

#include <glib.h>

#include <glib/gi18n.h>

#include "fsexam-header.h"

#include "fsexam-specialfile.h"

/* -------------  Compress file type implementation ------------ */

typedef enum {

    COMP_TARGZ = 0,

    COMP_TARBZ2,

    COMP_TAR,

    COMP_ZIP,

    COMP_Z,

}Compress_Type; 

typedef struct {

    gchar *result_path;      /* used to generate hist path */

    gchar *search_path;      /* used to generate hist search path */

    gchar *log_path;         /* used to generate log_path */

    gint  temp_dir_len;

}Compress_info;

static gchar    *iso8859_locale = NULL;

const gchar *compress_pair[][3] = {

    /* Type         UNCOMPRESS                 COMPRESS */

    {".tar.gz",  "LC_ALL=%s gzcat %s | tar -xf - 2>/dev/null",    "LC_ALL=%s tar -cf - . | gzip > ../%s"},

    {".tar.bz2", "LC_ALL=%s bzcat %s | tar -xf - 2>/dev/null",    "LC_ALL=%s tar -cf - . | bzip2 -z > ../%s"},

    {".tar",     "LC_ALL=%s tar -xf %s 2>/dev/null",              "LC_ALL=%s tar -cf - . > ../%s"},

    {".zip",     "unzip -q %s 2>/dev/null",             "zip -qr %s .; mv %s .."},

    {".tar.Z",   "uncompress -c %s | tar -xf - 2>/dev/null", "tar -cf - . | compress -fc > ../%s"},

};

#define TARCMD  "/usr/sfw/bin/gtar"

static gboolean fsexam_special_is_compress (const gchar *, Compress_Type *);

static gboolean compress_common_convert (const gchar *,

        Compress_info *,

        FSEXAM_setting *,

        gboolean restore,

        gboolean nameconvert);

static gboolean compress_convert_content (const gchar *,

        Compress_info *,

        FSEXAM_setting *,

        gboolean restore);

static Compress_info *

compress_info_new (const gchar *result_path,

        const gchar *search_path,

        const gchar *log_path)

{

    Compress_info *info = NULL;

    if (NULL == result_path)

        return NULL;

    info = g_new0 (Compress_info, 1);

    info->result_path = g_strdup (result_path);

    info->search_path = g_strdup (search_path ? search_path : result_path);

    info->log_path = g_strdup (log_path ? log_path : result_path);

    return info;

}

static void

compress_info_free (Compress_info *info)

{

    if (info == NULL) {

        return;

    }

    g_free (info->result_path);

    g_free (info->search_path);

    g_free (info->log_path);

    g_free (info);

    return;

}

/*

 *  ensure $PWD is the directory of temparay directory

 */

static gchar *

compose_compress_cmd (Compress_Type type, const gchar *bname)

{

    if (type == COMP_ZIP) {

        return g_strdup_printf (compress_pair[type][2], bname, bname);

    }

    if (type <= COMP_TAR) {

        return g_strdup_printf (compress_pair[type][2], iso8859_locale, bname);

    }

    return g_strdup_printf (compress_pair[type][2], bname);

}

/* 

 * Generate history path or log path for compress file.

 *      Please note that we may nested to handling compress file. so 

 *      orig_compress_file 

 *      may be in the form "/tmp/test/test.tar[src/test.tar][cmd/data.tar]

 *                          -------------------------------  ------------

 *                          orig_compress_file               fullpath - temp..

 *

 *      fullpath: the full path of compress file in question such as /tmp/a.tar

 *

 * The sequence of converting compress filename and content:

 *      regurlar: first file name , then file content. otherwise the log/hist

 *                info is not consistent with disk data.

 *      resotre ; first filecontent, then file name itself, otherwise 

 *                        can't search the history  correctly

 */

static gchar *

compose_path (const gchar *fullpath, 

        Compress_info *info, 

        gboolean forhist,

        gboolean restore)

{

    const gchar *relative_path;

    gchar       *result = NULL;

#define URI_HEAD_LEN    7

    if ((NULL == fullpath) || (NULL == info))

        return NULL;

    relative_path = fullpath + info->temp_dir_len + 1;

    if (forhist) { 

        /* 

         *  Convert hist_path to uri, remove 'file://' then concat with

         *  relative_path

         */

        gchar *uri;

        uri = g_filename_to_uri (

                restore ? info->search_path : info->result_path, 

                NULL, 

                NULL);

        result = g_strdup_printf ("%s\t%s", 

                uri + URI_HEAD_LEN, 

                relative_path);

        g_free (uri);

    }else {

        gchar *esc_path = NULL;

        if (! g_utf8_validate (relative_path, -1, NULL)) {

            esc_path = g_strescape (relative_path, NULL);

        }

        if (g_utf8_validate (info->log_path, -1, NULL)) {

            result = g_strdup_printf ("%s [%s]", 

                    info->log_path, 

                    esc_path ? esc_path : relative_path);

        }else{

            gchar *uri = g_filename_to_uri (info->log_path, NULL, NULL);

            result = g_strdup_printf ("%s [%s]", 

                    uri, 

                    esc_path ? esc_path : relative_path);

            g_free (uri);

        }

    }

    return result;

}

/*

 *  caller pass in orig_compress_file;

 */

static gboolean

compress_write_to_disk (FSEXAM_setting *setting, 

            const gchar *path,      /* the path of current file */

            const gchar *origname,  /* old base name            */

            const gchar *utf8name,  /* new base name            */

            Compress_info *info,

            short from_encoding,    /* from encoding            */

            short to_encoding,      /* to encoding              */

            gchar **actualname)      /* return the actual used   */

{

    static gchar    oldname[PATH_MAX];

    static gchar    newname[PATH_MAX];

    gchar           *retname = NULL;

    gchar           *fname = NULL;

    gchar           *log_path = NULL;

    gboolean        ret = FALSE;

    fsexam_errno = ERR_OK;

    /* construct full old name and full new name */

    g_snprintf (oldname, PATH_MAX - 1, "%s/%s", path, origname);

    g_snprintf (newname, PATH_MAX - 1, "%s/%s", path, utf8name);

    if (g_file_test (newname, G_FILE_TEST_EXISTS)) {

        fsexam_errno = ERR_NAME_EXIST;

        fname = find_non_exist_name (newname);

        if (fname == NULL) {

            fsexam_errno = ERR_CANNOT_RENAME;

        }else if (rename(oldname, fname) == 0){

            retname = g_strdup (basename (fname));

            ret = TRUE;

        }else{

            fsexam_errno = ERR_CANNOT_RENAME;

        }

    }else{

        if (rename(oldname, newname) == 0){

            retname = g_strdup (utf8name);

            ret = TRUE;

        }else{

            fsexam_errno = ERR_CANNOT_RENAME;

        }

    }

    /* history file; GUI vs. CLI */

    if ((ret)  && (! (setting->flags & FSEXAM_SETTING_FLAGS_UNDO))) {

        gboolean same_serial = TRUE;

        if (setting->flags & FSEXAM_SETTING_FLAGS_DIFF_SERIAL) {

            setting->flags &= ~FSEXAM_SETTING_FLAGS_DIFF_SERIAL;

            same_serial = FALSE;

        }

        gchar *hist_path =  compose_path (newname, info, TRUE, FALSE);

        fsexam_history_put (setting->hist_info, 

                            ConvNameSpecial, 

                            hist_path,

                            from_encoding, 

                            to_encoding, 

                            same_serial);

        g_free (hist_path);

    } 

    ret ? ++setting->succ_num : ++setting->fail_num;

    log_path = compose_path (ret ? newname : oldname, info, FALSE, FALSE);

    /* log file */

    if (fsexam_errno == ERR_OK) {

        gchar   *msg = g_strdup_printf ("%s -> %s", 

                        id2encoding (from_encoding), 

                        id2encoding (to_encoding));

        fsexam_log_puts (setting->log_info, log_path, msg);

        if (setting->display_msg) {

            setting->display_msg (log_path, msg);

        }

        g_free (msg);

    }else if (fsexam_errno == ERR_NAME_EXIST) {

        fsexam_log_puts (setting->log_info, log_path, NULL);

        if (setting->display_msg) {

            setting->display_msg (log_path, fsexam_error_get_msg ());

        }

    }else{

        fsexam_log_puts (setting->log_info, log_path, NULL);

        if (setting->display_msg) {

            setting->display_msg (log_path, fsexam_error_get_msg ());

        }

    }

    if (actualname != NULL)

        *actualname = retname;  //freed outside

    else

        g_free (retname);

    g_free (log_path);

    g_free (fname);

    return ret;

}

/*

 * Restore single file.

 *

 * Note that search path is in info directly, don't use compose any more.

 * This is diff with non-restore operation.

 */

static gboolean

compress_restore_single_filename (FSEXAM_setting *setting,

        const gchar *fullpath,

        const gchar *dname,

        const gchar *bname,

        Compress_info *info,

        gchar **newname)

{

    gboolean ret = FALSE;

    Hist_item *item = NULL;

    gchar     *converted_text = NULL;

    gchar     *log_path;

    fsexam_errno = ERR_OK;

    item = fsexam_history_search (setting->hist_info, info->search_path, TRUE);

    if ((item == NULL) || (item->convtype != ConvNameSpecial)) {

        fsexam_errno = ERR_HIST_NO_ITEM;

        goto done;

    }

    converted_text = g_convert (bname,

            strlen (bname),

            id2encoding (item->from_encoding),

            id2encoding (item->to_encoding),

            NULL,

            NULL,

            NULL);

    if (converted_text == NULL) {

        fsexam_errno = ERR_CANNOT_CONVERT;

        goto done;

    }

    ret = compress_write_to_disk (setting,

            dname,

            bname,

            converted_text,

            info,

            item->to_encoding,

            item->from_encoding,

            newname);

    g_free (converted_text);

    return ret;

done:

    log_path = compose_path (fullpath, info, FALSE, FALSE);

    fsexam_log_puts (setting->log_info, log_path, NULL);

    if (setting->display_msg)

        setting->display_msg (log_path, fsexam_error_get_msg());

    g_free (log_path);

    return ret;

}

/*

 *

 */

static gboolean

compress_convert_single_filename (FSEXAM_setting *setting,

        const gchar *fullpath,

        const gchar *dname, /* info->log path, info->dname */

        const gchar *bname,

        Compress_info *info,

        gchar **newname)

{

    Score       score;

    Encoding    *encoding = NULL;

    gboolean    ret = FALSE;

    fsexam_errno = ERR_OK;  /* initialize fsexam_errno */

    if (setting->pref->auto_detect) { /* handle encoding auto detection */

        GList *detected_encoding = str_encoding_detect (bname, 

                DEFAULT_DETECTING_FLAG);

        setting->pref->encode_list = fsexam_encoding_add_auto (

                setting->pref->encode_list, 

                detected_encoding);

        auto_encoding_free (detected_encoding);

    }

    score = fsexam_encoding_decode (setting->pref->encode_list, 

                             ConvName, 

                             (char *)bname, 

                             strlen(bname), 

                             setting->pref->force);

    if (setting->pref->dry_run){    /* dry run */

        //don't support dryrun

    } else {                    /* real convert */  

        gint     index = 0;

        gchar    *actualname = NULL;

        if ((score == FAIL) || (score == ORIGINAL)){

            fsexam_errno = (score == FAIL) ? ERR_NO_PROPER_ENCODING 

                                           : ERR_NAME_UTF8_ALREADY;

            goto done;

        }   

        if (setting->gold_index != -1) {

            index = setting->gold_index;

	    } else if (setting->pref->auto_conversion) {

            index = fsexam_encoding_get_first_index (

                    setting->pref->encode_list);

        } else {

            index = setting->get_index (setting->pref->encode_list, TRUE);

        }

        if (-1 == index) {

            goto cleanup;

        }

        encoding = (Encoding *)g_list_nth_data (setting->pref->encode_list, 

                index);

        if (NULL == encoding){

            fsexam_errno = ERR_ENCODING_INDEX_INVALID;

            goto done;

        }

        ret = compress_write_to_disk (setting, 

                dname, 

                bname, 

                encoding->u.converted_text, 

                info,

                encoding->encodingID, 

                encoding2id ("UTF-8"),

                &actualname);

        if ((ret) && (newname)) {   // Return new name

            *newname = actualname;

        }else{

            g_free (actualname);

        }

        return ret;

    }

done:

    if (fsexam_errno != ERR_OK && !setting->pref->dry_run) {

        gchar *log_path;

        log_path = compose_path (fullpath, info, FALSE, FALSE);

        fsexam_log_puts (setting->log_info, log_path, NULL);

        if (setting->display_msg)

            setting->display_msg (log_path, fsexam_error_get_msg());

        g_free (log_path);

    }

cleanup:

    if (setting->pref->auto_detect)

        setting->pref->encode_list = fsexam_encoding_remove_auto (

                setting->pref->encode_list);

    return ret;

}

/*

 * Convert the name of files in archive/compress type file

 * And will handle flags

 */

static gboolean

compress_convert_filename (const gchar *fullpath, 

        Compress_info *info,

        FSEXAM_setting *setting, 

        gboolean restore)

{

    gchar           *bname = NULL;

    gchar           *dname = NULL;

    gchar           *newname = NULL;

    gchar           *abs_path = NULL;

    struct stat     statbuf;

    gboolean        ret = FALSE;

    gboolean        need_free_newname = FALSE;

    if ((NULL == fullpath) || (NULL == info) || (NULL == setting))

        return FALSE;

    fsexam_errno = ERR_OK;

    bname = g_path_get_basename (fullpath);

    dname = g_path_get_dirname (fullpath);

    if (lstat (fullpath, &statbuf) == -1) 

        fsexam_errno = ERR_FILE_NONEXIST;

    else if (!(S_ISREG(statbuf.st_mode)) 

            && !(S_ISDIR(statbuf.st_mode)) && !(S_ISLNK(statbuf.st_mode))){

        fsexam_errno = ERR_FILE_TYPE_NOT_SUPPORT; 

    }else if ((! setting->pref->hidden) && (*bname == '.')){

        fsexam_errno = ERR_IGNORE_HIDDEN_FILE;

    }else if ((!setting->pref->remote) 

            && (is_remote_file (setting->remote_path, fullpath))) {

        fsexam_errno = ERR_IGNORE_REMOTE_FILE;

    }

    if (fsexam_errno != ERR_OK) {

        gchar *log_path = compose_path (fullpath, info, FALSE, FALSE);

        fsexam_log_puts (setting->log_info, log_path, NULL);

        if (setting->display_msg)

            setting->display_msg (log_path, fsexam_error_get_msg());

        g_free (log_path);

        goto done;

    }

    if (restore && (strlen (fullpath) != info->temp_dir_len)) {

       ret = compress_restore_single_filename (setting,