/*
 * 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 <unistd.h>
#include <hbaapi.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <sys/fibre-channel/fcio.h>
#include <sys/fibre-channel/impl/fc_error.h>
#include <sys/scsi/adapters/scsi_vhci.h>
#include "common.h"
#include "errorcodes.h"
#include <locale.h>

/* The i18n catalog */
nl_catd l_catd;

void
i18n_catopen() {
        static int fileopen = 0;

        if (setlocale(LC_ALL, "") == NULL) {
                (void) fprintf(stderr,
                "Cannot operate in the locale requested. "
                "Continuing in the default C locale\n");
        }
        if (!fileopen) {
                l_catd = catopen("a5k_g_fc_i18n_cat", NL_CAT_LOCALE);
                if (l_catd == (nl_catd)-1) {
                        return;
                }
                fileopen = 1;
        }
        return;

}

/*
 * Given an error number, this functions
 * calls the get_errString() to print a
 * corresponding error message to the stderr.
 * get_errString() always returns an error
 * message, even in case of undefined error number.
 * So, there is no need to check for a NULL pointer
 * while printing the error message to the stdout.
 *
 * RETURNS: N/A
 *
 */
void
print_errString(int errnum, char *devpath)
{

char    *errStr;

        errStr = get_errString(errnum);

        if (devpath == NULL) {
                (void) fprintf(stderr,
                                "%s \n\n", errStr);
        } else {
                (void) fprintf(stderr,
                                "%s - %s.\n\n", errStr, devpath);
        }

        /* free the allocated memory for error string */
        if (errStr != NULL)
                (void) free(errStr);
}

static void terminate() {
        fprintf(stdout, MSGSTR(2506, "Unsupported"));
        fprintf(stdout, "\n");
        exit(1);
}

/*ARGSUSED*/
int adm_display_config(char **a) {
        terminate();
        return (1);
}

/*ARGSUSED*/
void adm_download(char **a, char *b) {
        terminate();
}

/*ARGSUSED*/
void up_encl_name(char **a, int b) {
        terminate();
}

void adm_failover(char **argv) {
        int             path_index = 0, err = 0, fd;
        char            path_class[MAXNAMELEN];
        char            client_path[MAXPATHLEN];
        char            *path_phys = NULL, *trailingMinor;
        sv_switch_to_cntlr_iocdata_t    iocsc;

        (void) memset(path_class, 0, sizeof (path_class));
        (void) strcpy(path_class, argv[path_index++]);
        if ((strcmp(path_class, "primary") != 0) &&
                (strcmp(path_class, "secondary") != 0)) {
                        (void) fprintf(stderr,
                        MSGSTR(2300, "Incorrect pathclass\n"));
                        exit(-1);
        }

        if ((fd = open("/devices/scsi_vhci:devctl", O_RDWR)) < 0) {
            print_errString(L_OPEN_PATH_FAIL, "/devices/scsi_vhci:devctl");
            exit(-1);
        }

        iocsc.client = client_path;
        iocsc.class = path_class;

        while (argv[path_index] != NULL) {
                path_phys =
                    get_slash_devices_from_osDevName(argv[path_index++],
                        STANDARD_DEVNAME_HANDLING);
                if ((path_phys == NULL) ||
                        (strstr(path_phys, "/devices/scsi_vhci") == NULL)) {
                                (void) fprintf(stderr,
                                MSGSTR(2301, "Incorrect pathname\n"));
                                close(fd);
                                exit(-1);
                }

                strcpy(iocsc.client, path_phys + strlen("/devices"));

                /* Now chop off the trailing ":xxx" portion if present */
                if ((trailingMinor = strrchr(iocsc.client, ':')) != NULL) {
                        trailingMinor[0] = '\0';
                }

                if (ioctl(fd, SCSI_VHCI_SWITCH_TO_CNTLR, &iocsc) != 0) {
                    switch (errno) {
                        case EALREADY:
                                err = L_SCSI_VHCI_ALREADY_ACTIVE;
                                break;
                        case ENXIO:
                                err = L_INVALID_PATH;
                                break;
                        case EIO:
                                err = L_SCSI_VHCI_NO_STANDBY;
                                break;
                        case ENOTSUP:
                                err = L_SCSI_VHCI_FAILOVER_NOTSUP;
                                break;
                        case EBUSY:
                                err = L_SCSI_VHCI_FAILOVER_BUSY;
                                break;
                        case EFAULT:
                        default:
                                err = L_SCSI_VHCI_ERROR;
                    }
                }

                if (err != 0) {
                    close(fd);
                    print_errString(err, path_phys);
                    exit(-1);
                }
        }

        close(fd);
}

/*ARGSUSED*/
int adm_inquiry(char **a) {
        terminate();
        return (1);
}

/*ARGSUSED*/
void pho_probe() {
        terminate();
}

/*ARGSUSED*/
void non_encl_probe() {
        terminate();
}

/*ARGSUSED*/
void adm_led(char **a, int b) {
        terminate();
}

/*ARGSUSED*/
void up_password(char **a) {
        terminate();
}

/*ARGSUSED*/
int adm_reserve(char *path) {
        terminate();
        return (1);
}

/*ARGSUSED*/
int adm_release(char *path) {
        terminate();
        return (1);
}

/*ARGSUSED*/
int adm_start(char **a) {
        terminate();
        return (1);
}

/*ARGSUSED*/
int adm_stop(char **a) {
        terminate();
        return (1);
}

/*ARGSUSED*/
int adm_power_off(char **a, int b) {
        terminate();
        return (1);
}

int
adm_forcelip(char **argv)
{
        int             path_index = 0, fd;
        uint64_t        wwn;
        fcio_t          fcio;
        HBA_HANDLE handle;
        HBA_ADAPTERATTRIBUTES hbaAttrs;
        HBA_PORTATTRIBUTES portAttrs;
        HBA_FCPTARGETMAPPINGV2    *map;
        HBA_STATUS status;
        int count, adapterIndex, portIndex, mapIndex;
        char name[256];
        int             matched, ret = 0, wwnCompare = 0, ntries;
        char        *physical = NULL, *slash_OSDeviceName = NULL;

        if ((status = loadLibrary())) {
            /* loadLibrary print out error msg */
            return (ret++);
        }
        for (path_index = 0; argv[path_index] != NULL; path_index++) {

            if (is_wwn(argv[path_index])) {
                (void) sscanf(argv[path_index], "%016llx", &wwn);
                wwnCompare = 1;
            } else if (!is_path(argv[path_index])) {
                print_errString(L_INVALID_PATH, argv[path_index]);
                ret++;
                continue;
            }
            if (!wwnCompare) {
                /* Convert the paths to phsyical paths */
                physical = get_slash_devices_from_osDevName(argv[path_index],
                        STANDARD_DEVNAME_HANDLING);
                if (!physical) {
                    print_errString(L_INVALID_PATH, argv[path_index]);
                    ret++;
                    continue;
                }
            }

            count = getNumberOfAdapters();

            matched = 0;
            for (adapterIndex = 0; adapterIndex < count; adapterIndex ++) {
                status = HBA_GetAdapterName(adapterIndex, (char *)&name);
                if (status != HBA_STATUS_OK) {
                    /* May have been DR'd */
                    continue;
                }
                handle = HBA_OpenAdapter(name);
                if (handle == 0) {
                    /* May have been DR'd */
                    continue;
                }

                if (getAdapterAttrs(handle, name, &hbaAttrs)) {
                    /* Should never happen */
                    HBA_CloseAdapter(handle);
                    continue;
                }

                /* Loop over all HBA Ports */
                for (portIndex = 0; portIndex < hbaAttrs.NumberOfPorts;
                        portIndex++) {
                    if (getAdapterPortAttrs(handle, name, portIndex,
                            &portAttrs)) {
                        continue;
                    }

                    matched = 0;
                    if (is_wwn(argv[path_index])) {
                        if (wwn == wwnConversion(
                                portAttrs.NodeWWN.wwn) ||
                                wwn == wwnConversion(
                                portAttrs.PortWWN.wwn)) {
                            matched = 1;
                        }
                    } else {
                        slash_OSDeviceName = get_slash_devices_from_osDevName(
                            portAttrs.OSDeviceName, STANDARD_DEVNAME_HANDLING);
                        if (!slash_OSDeviceName) {
                            continue;
                        } else {
                            if (strncmp(physical, slash_OSDeviceName,
                                    strlen(slash_OSDeviceName) -
                                    strlen(strrchr(slash_OSDeviceName, ':')))
                                == 0) {
                                matched = 1;
                            }
                            free(slash_OSDeviceName);
                        }
                    }

                    if (!matched) {
                        if (!fetch_mappings(handle, portAttrs.PortWWN, &map)) {
                                /*
                                 * matchr_mapping checks the arg
                                 * so we pass argv here.
                                 */
                            mapIndex = match_mappings(argv[path_index], map);
                            if (mapIndex >= 0) {
                                matched = 1;
                            }
                        } else {
                            continue;
                        }
                    }

                    if (matched) {
                        if ((fd = open(portAttrs.OSDeviceName,
                                O_RDONLY | O_EXCL)) == -1) {
                            print_errString(L_OPEN_PATH_FAIL,
                                    portAttrs.OSDeviceName);
                            return (ret++);
                        }

                        fcio.fcio_cmd = FCIO_RESET_LINK;
                        fcio.fcio_xfer = FCIO_XFER_WRITE;
                        /*
                         * Reset the local loop here (fcio_ibuf = 0).
                         * Reset a remote loop on the Fabric by
                         * passing its node wwn (fcio_len = sizeof(nwwn)
                         * and fcio_ibuf = (caddr_t)&nwwn) to the port driver.
                         */
                        (void) memset(&wwn, 0, sizeof (wwn));
                        fcio.fcio_ilen = sizeof (wwn);
                        fcio.fcio_ibuf = (caddr_t)&wwn;

                        for (ntries = 0; ntries < RETRY_FCIO_IOCTL; ntries++) {
                            errno = 0;
                            if (ioctl(fd, FCIO_CMD, &fcio) != 0) {
                                /*
                                 * When port is offlined, qlc
                                 * returns the FC_OFFLINE error and errno
                                 * is set to EIO.
                                 * We do want to ignore this error,
                                 * especially when an enclosure is
                                 * removed from the loop.
                                 */
                                if (fcio.fcio_errno == FC_OFFLINE)
                                    break;
                                if ((errno == EAGAIN) &&
                                    (ntries+1 < RETRY_FCIO_IOCTL)) {
                                    /* wait WAIT_FCIO_IOCTL */
                                    (void) usleep(WAIT_FCIO_IOCTL);
                                    continue;
                                }
                                I_DPRINTF("FCIO ioctl failed.\n"
                                    "Error: %s. fc_error = %d (0x%x)\n",
                                strerror(errno), fcio.fcio_errno,
                                    fcio.fcio_errno);
                                close(fd);
                                print_errString(L_FCIO_FORCE_LIP_FAIL,
                                    portAttrs.OSDeviceName);
                                return (ret++);
                            } else {
                                break; /* ioctl succeeds. */
                            }
                        }
                        close(fd);
                        if (ntries == RETRY_FCIO_IOCTL) {
                            print_errString(L_FCIO_FORCE_LIP_FAIL,
                            portAttrs.OSDeviceName);
                            return (ret++);
                        }
                    }
                    if (matched)
                        break; /* for HBA port for loop */
                }
                if (matched) /* HBA adapter for loop */
                    break;
            }

            if (!matched) {
                print_errString(L_INVALID_PATH, argv[path_index]);
                ret++;
            }
        }
        HBA_FreeLibrary();
        return (ret);
}

/*ARGSUSED*/
void adm_bypass_enable(char **argv, int bypass_flag) {
        terminate();
}

/*ARGSUSED*/
int adm_port_offline_online(char **a, int b) {
        terminate();
        return (1);
}

/*ARGSUSED*/
void display_link_status(char **a) {
        terminate();
}

/*ARGSUSED*/
void dump_map(char **argv) {
        terminate();
}

/*ARGSUSED*/
int adm_display_port(int a) {
        terminate();
        return (1);
}

/*ARGSUSED*/
int adm_port_loopback(char *a, int b) {
        terminate();
        return (1);
}

/*ARGSUSED*/
int hotplug_e(int todo, char **argv, int verbose_flag, int force_flag) {
        terminate();
        return (1);
}

/*ARGSUSED*/
int
setboot(unsigned int yes, unsigned int verbose, char *fname)
{
        terminate();
        return (1);
}

/*ARGSUSED*/
int hotplug(int todo, char **argv, int verbose_flag, int force_flag) {
        terminate();
        return (1);
}

/*ARGSUSED*/
int adm_check_file(char **argv, int flag) {
        terminate();
        return (1);
}

/*ARGSUSED*/
int sysdump(int verbose) {
        terminate();
        return (1);
}

/*ARGSUSED*/
int fcal_update(unsigned int verbose, char *file) {
        terminate();
        return (1);
}

/*ARGSUSED*/
int q_qlgc_update(unsigned int verbose, char *file) {
        terminate();
        return (1);
}

/*ARGSUSED*/
int emulex_update(char *file) {
        terminate();
        return (1);
}

/*ARGSUSED*/
int emulex_fcode_reader(int fcode_fd, char *pattern, char *pattern_value,
    uint32_t pattern_value_size) {
        terminate();
        return (1);
}

/*ARGSUSED*/
void dump(char **argv) {
        terminate();
}

/*ARGSUSED*/
int h_insertSena_fcdev() {
        terminate();
        return (1);
}