/*
 * 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.
 */

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <limits.h>
#include <unistd.h>
#include <libintl.h>
#include <locale.h>
#include <dbus/dbus.h>
#include <hal/libhal.h>

#include "msgs.h"
#include "device.h"
#include "util.h"
#include "main.h"
#include "options.h"
#include "mmc.h"
#include "misc_scsi.h"

/*
 * global flags
 */
int     debug = 0;
int     keep_disc_open = 0;
int     requested_speed = 0;
int     simulation = 0;
int     verbose = 0;
char    *image_file = NULL;
char    *blanking_type = NULL;
int     audio_type = AUDIO_TYPE_NONE;
int     extract_track_no = 0;
char    *extract_file = NULL;
char    *alt_tmp_dir = NULL;
char    *copy_src = NULL;
int     vol_running = 0;
int     cflag = 0;
int     tflag = 0;
uid_t   ruid, cur_uid;

/*
 * global variables
 */
cd_device *target = NULL;               /* Default target device */
static char *tgtdev = NULL;
int device_type = CD_RW;                /* Default to CD/RW */
int write_mode = TAO_MODE;              /* Default to track at once */

static void
print_usage(void)
{
        err_msg(gettext("USAGE:\n"));
        err_msg(gettext("\tcdrw -i [ -vSCO ] [ -d device ] [ -p speed ]"));
        err_msg(gettext(" [ image-file ]\n"));
        err_msg(gettext("\tcdrw -a [ -vSCO ] [ -d device ] [ -p speed ]"));
        err_msg(gettext(" [ -T audio-type ] audio-file1 audio-file2 ...\n"));
        err_msg(gettext("\tcdrw -x [ -v ] [ -d device ] [ -T audio-type ]"));
        err_msg(gettext(" track-number audio-file\n"));
        err_msg(gettext("\tcdrw -c [ -SC ] [ -d device ] [ -p speed ]"));
        err_msg(gettext(" [ -m tmp-dir ] [ -s src-device ]\n"));
        err_msg(
            gettext("\tcdrw -b [ -v ] [ -d device ] all | session | fast\n"));
        err_msg(gettext("\tcdrw -M [ -v ] [ -d device ]\n"));
        err_msg(gettext("\tcdrw -L [ -v ] [ -d device ]\n"));
        err_msg(gettext("\tcdrw -l [ -v ]\n"));
        err_msg(gettext("\tcdrw -h\n"));

        exit(2);
}

static void
check_invalid_option(options *specified, char *opstr)
{
        options c_op;
        int ret;

        set_options_mask(&c_op, opstr);
        if ((ret = compare_options_mask(&c_op, specified)) != 0) {
                err_msg(
                    gettext("Option %c is not defined for this operation.\n"),
                    (char)ret);
                print_usage();
        }
}

LibHalContext *
attach_to_hald(void)
{
        LibHalContext *ctx = NULL;
        DBusConnection *con = NULL;
        DBusError error;
        hal_state_t state;

        /* Initialize the dbus error states */
        dbus_error_init(&error);

        if ((con = dbus_bus_get(DBUS_BUS_SYSTEM, &error)) == NULL) {
                return (NULL);
        }
        state = DBUS_CONNECTION;

        /* Allocate a new hal context to work with the dbus */
        if ((ctx = libhal_ctx_new()) == NULL)
                return (NULL);
        state = HAL_CONTEXT;

        /* Pair up the context with the connection */
        if (!libhal_ctx_set_dbus_connection(ctx, con))
                goto fail;
        state = HAL_PAIRED;

        /* If libhal_ctx_init fails hald is not present */
        if (!libhal_ctx_init(ctx, &error)) {
                goto fail;
        }
        state = HAL_INITIALIZED;

        return (ctx);
fail:
        if (dbus_error_is_set(&error))
                dbus_error_free(&error);
        detach_from_hald(ctx, state);
        return (NULL);

}

void
detach_from_hald(LibHalContext *ctx, hal_state_t state)
{
        DBusError error;
        DBusConnection *con = libhal_ctx_get_dbus_connection(ctx);

        dbus_error_init(&error);

        switch (state) {
        case HAL_INITIALIZED:
                if (libhal_ctx_shutdown(ctx, &error) == FALSE)
                        if (dbus_error_is_set(&error))
                                dbus_error_free(&error);
        /*FALLTHROUGH*/
        case HAL_PAIRED:
                (void) libhal_ctx_free(ctx);
                dbus_connection_unref(con);
                break;
        case HAL_CONTEXT:
                (void) libhal_ctx_free(ctx);
                break;
        case DBUS_CONNECTION:
        default:
                break;
        }
}

/*
 * This function returns one if hald is running and
 * zero if hald is not running
 */
int
hald_running(void)
{
        LibHalContext *ctx;

        if ((ctx = attach_to_hald()) == NULL)
                return (0);

        detach_from_hald(ctx, HAL_INITIALIZED);
        return (1);
}

int
setup_target(int flag)
{
        char *devpath;

        if (tgtdev != NULL) {
                devpath = (char *)my_zalloc(PATH_MAX);
                if (lookup_device(tgtdev, devpath)) {
                        target = get_device(tgtdev, devpath);
                }
                free(devpath);
                if (target == NULL) {
                        return (0);
                }
                return (1);
        }
        return (scan_for_cd_device(flag, &target));
}

int
main(int argc, char **argv)
{
        int             c;
        int             operations;
        options         specified_ops;
        int             aflag, iflag, Mflag, Lflag, lflag, bflag, xflag;
        int             ret;

        (void) setlocale(LC_ALL, "");

#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN     "SYS_TEST"
#endif


        (void) textdomain(TEXT_DOMAIN);

        ruid = getuid();
        cur_uid = geteuid();

        if (check_auth(ruid) != 1)  {
                err_msg(gettext(
                    "Authorization failed, Cannot access disks.\n"));
                exit(1);
        }

        if ((cur_uid == 0) && (ruid != 0)) {
                priv_change_needed = 1;
                lower_priv();
        }

        vol_running = hald_running();

        tgtdev = NULL;
        operations = 0;
        set_options_mask(&specified_ops, "");
        iflag = Mflag = Lflag = lflag = bflag = aflag = xflag = cflag = 0;

        while ((c = getopt(argc, argv, "abcCd:hiLlm:MOp:s:ST:vVx")) != EOF) {
                add_option(&specified_ops, c);
                switch (c) {
                case 'a':
                        aflag = 1;
                        operations++;
                        break;
                case 'b':
                        bflag = 1;
                        operations++;
                        break;
                case 'c':
                        cflag = 1;
                        operations++;
                        break;
                case 'C':
                        /*
                         * cdrw now attempts to use the stated medium capacity
                         * by default, so this option no longer has any effect.
                         * It remains in the interface for backwards
                         * compatibility only.
                         */
                        break;
                case 'd':
                        tgtdev = optarg;
                        break;
                case 'h':
                        print_usage(); /* will not return */
                        break;
                case 'i':
                        iflag = 1;
                        operations++;
                        break;
                case 'L':
                        Lflag = 1;
                        operations++;
                        break;
                case 'l':
                        lflag = 1;
                        operations++;
                        break;
                case 'm':
                        alt_tmp_dir = optarg;
                        break;
                case 'M':
                        Mflag = 1;
                        operations++;
                        break;
                case 'O':
                        keep_disc_open = 1;
                        break;
                case 'p':
                        requested_speed = atoi(optarg);
                        break;
                case 's':
                        copy_src = optarg;
                        break;
                case 'S':
                        simulation++;
                        break;
                case 'T':
                        audio_type = get_audio_type(optarg);
                        if (audio_type == -1) {
                                err_msg(gettext("Unknown audio type %s\n"),
                                    optarg);
                                exit(1);
                        }
                        break;
                case 'v':
                        verbose++;
                        break;
                case 'V':
                        /*
                         * more verbose. this will print out debug comments
                         */

                        debug++;
                        break;
                case 'x':
                        xflag++;
                        operations++;
                        break;
                default:
                        print_usage();
                }
        }
        if (operations == 0) {
                err_msg(gettext("No operation specified.\n"));
                exit(1);
        }
        if (operations != 1) {
                err_msg(gettext("More than one operation specified.\n"));
                exit(1);
        }

        if (lflag) {
                check_invalid_option(&specified_ops, "lhvV");
                list();
        }

        /*
         * we'll allow the user to specify the source device (-s) when
         *  extracting audio.
         */

        if (xflag && copy_src)
                tgtdev = copy_src;

        /*
         * This will scan for all CD devices when xflag or Mflag
         * (extract audio, list toc) commands are used, providing
         * no CD-RW devices are found. Since these commands can
         * be used without a CD writer.
         */

        if (xflag || Mflag) {
                ret = setup_target(SCAN_ALL_CDS);
        } else {
                ret = setup_target(SCAN_WRITERS);
        }

        if (ret == 0) {

                if (tgtdev != NULL) {
                        err_msg(gettext(
                            "Cannot find device %s.\n"), tgtdev);

                }

                if (vol_running) {
                        err_msg(gettext(
                            "No CD writers found or no media in the drive.\n"));
                } else {
                        if (cur_uid != 0) {
                                err_msg(gettext(
                                    "Volume manager is not running.\n"));
                                err_msg(gettext(
"Please start volume manager or run cdrw as root to access all devices.\n"));
                        } else {
                                err_msg(gettext(
                                    "No CD writers found.\n"));
                        }
                }
                exit(1);

        } else if (ret != 1) {
                err_msg(gettext("More than one CD device found.\n"));
                err_msg(gettext("Specify one using -d option.\n"));
                err_msg(gettext(
                    "Or use -l option to list all the CD devices found\n"));
                exit(1);
        }
        (void) check_device(target, CHECK_TYPE_NOT_CDROM|EXIT_IF_CHECK_FAILED);

        if (check_device(target, CHECK_NO_MEDIA) == 0) {
                int retry;
                for (retry = 0; retry < 5; retry++) {
                        if (check_device(target, CHECK_DEVICE_NOT_READY) == 0)
                                break;
                        (void) sleep(3);
                }
        }

        if (aflag) {
                check_invalid_option(&specified_ops, "ahvSCOdpTV");
                if (optind == argc) {
                        err_msg(gettext("No audio files specified.\n"));
                        exit(1);
                }
                write_audio(argv, optind, argc);
        }
        if (Mflag) {
                check_invalid_option(&specified_ops, "MhvdV");
                info();
        }
        if (iflag) {
                check_invalid_option(&specified_ops, "ihvSCOdpV");
                if (optind == (argc - 1)) {
                        image_file = argv[optind];
                        write_image();
                }
                if (optind == argc)
                        write_image();
                err_msg(gettext("Command line parsing error.\n"));
                err_msg(gettext("Only one image-file can be specified.\n"));
                exit(1);
        }
        if (bflag) {
                check_invalid_option(&specified_ops, "bhvdV");
                if (optind != (argc - 1)) {
                        err_msg(gettext("Command line parsing error.\n"));
                        print_usage();
                }
                blanking_type = argv[argc - 1];
                blank();
        }
        if (xflag) {
                check_invalid_option(&specified_ops, "xhpvdsTV");
                if (optind != (argc - 2)) {
                        err_msg(gettext("Command line parsing error.\n"));
                        print_usage();
                }
                extract_track_no = atoi(argv[argc - 2]);
                extract_file = argv[argc - 1];
                extract_audio();
        }
        if (cflag) {
                check_invalid_option(&specified_ops, "chvSCdpmsV");
                copy_cd();
        }

        /*
         * Open a closed disk, we do this by erasing the track tail
         * and then re-finalizing with an open leadout.
         */
        if (Lflag) {
                check_invalid_option(&specified_ops, "LvdV");
                (void) check_device(target, CHECK_NO_MEDIA |
                    CHECK_DEVICE_NOT_READY | EXIT_IF_CHECK_FAILED);

                /* no need to erase blank media */
                if (!check_device(target, CHECK_MEDIA_IS_NOT_BLANK))
                        exit(0);

                blanking_type = "leadout";
                blank();

                write_init(TRACK_MODE_DATA);
                (void) close_track(target->d_fd, 0, 1, 1);
                (void) finalize(target);
                (void) printf(gettext("done.\n"));
                exit(0);
        }
        return (0);
}