kssl/ksslcfg/ksslcfg_create.c

/*
 * 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 (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include <libscf.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <sys/types.h>
#include "ksslcfg.h"

void
usage_create(boolean_t do_print)
{
    if (do_print)
        (void) fprintf(stderr, gettext("Usage:\n"));
    (void) fprintf(stderr, "ksslcfg create"
        " -f pkcs11 [-d softtoken_directory] -T <token_label>"
        " -C <certificate_label> -x <proxy_port>"
        " [-h <ca_certchain_file>]"
        " [options] [<server_address>] <server_port>\n");

    (void) fprintf(stderr, "ksslcfg create"
        " -f pkcs12 -i <cert_and_key_pk12file> -x <proxy_port>"
        " [options] [<server_address>] <server_port>\n");

    (void) fprintf(stderr, "ksslcfg create"
        " -f pem -i <cert_and_key_pemfile> -x <proxy_port>"
        " [options] [<server_address>] <server_port>\n");

    (void) fprintf(stderr, gettext("options are:\n"));
    (void) fprintf(stderr, "\t[-c <ciphersuites>]\n"
        "\t[-p <password_file>]\n"
        "\t[-t <ssl_session_cache_timeout>]\n"
        "\t[-u <username>]\n"
        "\t[-z <ssl_session_cache_size>]\n"
        "\t[-v]\n");
}

static scf_propertygroup_t *
add_property_group_to_instance(scf_handle_t *handle, scf_instance_t *instance,
    const char *pg_name, const char *pg_type)
{
    scf_propertygroup_t *pg;

    pg = scf_pg_create(handle);
    if (pg == NULL) {
        KSSL_DEBUG("scf_pg_create failed: %s\n",
            scf_strerror(scf_error()));
        (void) fprintf(stderr, gettext(
            "Unexpected fatal libscf error: %s. Exiting.\n"),
            scf_strerror(scf_error()));
        return (NULL);
    }

    if (scf_instance_add_pg(instance, pg_name, pg_type, 0, pg) != 0) {
        KSSL_DEBUG("ERROR: scf_instance_add_pg failed: %s\n",
            scf_strerror(scf_error()));
        if (scf_error() == SCF_ERROR_EXISTS)
            (void) fprintf(stderr, gettext(
                "Error: another process is modifying this instance."
                " Exiting.\n"));
        else
            (void) fprintf(stderr, gettext(
                "Unexpected fatal libscf error: %s. Exiting.\n"),
                scf_strerror(scf_error()));
        scf_pg_destroy(pg);
        return (NULL);
    } else {
        KSSL_DEBUG("property group created\n");
    }

    return (pg);
}

static int
add_new_property(scf_handle_t *handle, const char *prop_name,
    scf_type_t type, const char *val, scf_transaction_t *tx)
{
    scf_value_t *value = NULL;
    scf_transaction_entry_t *entry = NULL;
    int status = FAILURE;

    entry = scf_entry_create(handle);
    if (entry == NULL) {
        KSSL_DEBUG("scf_entry_create failed: %s\n",
            scf_strerror(scf_error()));
        goto out;
    }
    KSSL_DEBUG("scf_entry_create succeeded\n");

    value = scf_value_create(handle);
    if (value == NULL) {
        goto out;
    }
    KSSL_DEBUG("scf_value_create succeeded\n");

    if (scf_transaction_property_new(tx, entry, prop_name, type) != 0) {
        goto out;
    }
    KSSL_DEBUG("scf_transaction_property_new succeeded\n");

    if (scf_value_set_from_string(value, type, val) != 0) {
        goto out;
    }
    KSSL_DEBUG("scf_value_set_from_string \'%s\' succeeded\n", val);

    if (scf_entry_add_value(entry, value) != 0) {
        KSSL_DEBUG(
            "scf_entry_add_value failed: %s\n",
            scf_strerror(scf_error()));
        goto out;
    }
    KSSL_DEBUG("scf_entry_add_value succeeded\n");

    status = SUCCESS;

out:
    if (status != SUCCESS)
        (void) fprintf(stderr, gettext(
            "Unexpected fatal libscf error: %s. Exiting.\n"),
            scf_strerror(scf_error()));
    return (status);
}

static int
set_method_context(scf_handle_t *handle, scf_transaction_t *tran,
    const char *value_str)
{
    if ((add_new_property(handle, SCF_PROPERTY_USE_PROFILE,
        SCF_TYPE_BOOLEAN, "false", tran) != SUCCESS) ||
        (add_new_property(handle, SCF_PROPERTY_USER, SCF_TYPE_ASTRING,
        value_str, tran) != SUCCESS) ||
        (add_new_property(handle, SCF_PROPERTY_GROUP, SCF_TYPE_ASTRING,
        ":default", tran) != SUCCESS) ||
        (add_new_property(handle, SCF_PROPERTY_LIMIT_PRIVILEGES,
        SCF_TYPE_ASTRING, ":default", tran) != SUCCESS) ||
        (add_new_property(handle, SCF_PROPERTY_WORKING_DIRECTORY,
        SCF_TYPE_ASTRING, ":default", tran) != SUCCESS) ||
        (add_new_property(handle, SCF_PROPERTY_SUPP_GROUPS,
        SCF_TYPE_ASTRING, ":default", tran) != SUCCESS) ||
        (add_new_property(handle, SCF_PROPERTY_RESOURCE_POOL,
        SCF_TYPE_ASTRING, ":default", tran) != SUCCESS) ||
        (add_new_property(handle, SCF_PROPERTY_PROJECT, SCF_TYPE_ASTRING,
        ":default", tran) != SUCCESS) ||
        (add_new_property(handle, SCF_PROPERTY_PRIVILEGES,
        SCF_TYPE_ASTRING, "basic,sys_net_config", tran) != SUCCESS))
        return (FAILURE);

    return (SUCCESS);
}

static int
add_pg_method(scf_handle_t *handle, scf_instance_t *instance,
    const char *kssl_entry, const char *pg_name, const char *flags,
    const char *value_str)
{
    int len, rv;
    char *command;
    const char *base_command;
    int status = FAILURE;
    boolean_t errflag = B_FALSE;
    scf_transaction_t *tran;
    scf_propertygroup_t *pg;

    pg = add_property_group_to_instance(handle, instance,
        pg_name, SCF_GROUP_METHOD);
    if (pg == NULL) {
        /* flag is false to suppress duplicate error messages */
        errflag = B_FALSE;
        goto out0;
    }
    KSSL_DEBUG("%s method added\n", pg_name);

    tran = scf_transaction_create(handle);
    if (tran == NULL) {
        KSSL_DEBUG("scf_transaction_create failed: %s\n",
            scf_strerror(scf_error()));
        errflag = B_TRUE;
        goto out0;
    }
    KSSL_DEBUG("scf_transaction_create succeeded\n");

    do {
        if (scf_transaction_start(tran, pg) != 0) {
            KSSL_DEBUG("scf_transaction_start failed: %s\n",
                scf_strerror(scf_error()));
            if (scf_error() == SCF_ERROR_PERMISSION_DENIED) {
                (void) fprintf(stderr, gettext(
                    "Error: Permission denied.\n"));
                errflag = B_FALSE;
            } else if (scf_error() ==  SCF_ERROR_DELETED) {
                (void) fprintf(stderr, gettext(
                    "Error: property group %s has"
                    " been deleted.\n"), pg_name);
                errflag = B_FALSE;
            } else
                errflag = B_TRUE;
            goto out1;
        }
        KSSL_DEBUG("scf_transaction_start succeeded\n");

        if (strcmp(pg_name, "stop") == 0)
            base_command = "/usr/lib/kssladm delete";
        else
            base_command = "/usr/lib/kssladm create";

        len = strlen(base_command) + strlen(flags) +
            strlen(kssl_entry) + 3;

        command = malloc(len);
        if (command == NULL) {
            goto out2;
        }

        (void) snprintf(command, len, "%s %s %s",
            base_command, flags, kssl_entry);
        KSSL_DEBUG("command=%s\n", command);

        if (add_new_property(handle, SCF_PROPERTY_EXEC,
            SCF_TYPE_ASTRING, command, tran) != SUCCESS) {
            free(command);
            goto out2;
        }
        free(command);

        if (add_new_property(handle, SCF_PROPERTY_TIMEOUT,
            SCF_TYPE_COUNT, "60", tran) != SUCCESS)
            goto out2;

        if (set_method_context(handle, tran, value_str) != SUCCESS)
            goto out2;

        rv = scf_transaction_commit(tran);
        switch (rv) {
        case 1:
            KSSL_DEBUG("scf_transaction_commit succeeded\n");
            status = SUCCESS;
            goto out2;
        case 0:
            scf_transaction_reset(tran);
            if (scf_pg_update(pg) == -1) {
                goto out2;
            }
            break;
        case -1:
        default:
            KSSL_DEBUG("ERROR: scf_transaction_commit failed: %s\n",
                scf_strerror(scf_error()));
            if (scf_error() == SCF_ERROR_PERMISSION_DENIED) {
                (void) fprintf(stderr, gettext(
                    "Error: Permission denied.\n"));
                errflag = B_FALSE;
            } else {
                errflag = B_TRUE;
            }
            goto out2;
        }
    } while (rv == 0);

out2:
    scf_transaction_reset(tran);
out1:
    scf_transaction_destroy_children(tran);
    scf_transaction_destroy(tran);
out0:
    if (pg != NULL)
        scf_pg_destroy(pg);
    if (errflag)
        (void) fprintf(stderr, gettext(
            "Unexpected fatal libscf error: %s. Exiting.\n"),
            scf_strerror(scf_error()));
    return (status);
}

static int
create_instance(scf_handle_t *handle, scf_service_t *svc,
    const char *instance_name, const char *kssl_entry, const char *command,
    const char *username, char *inaddr_any_name)
{
    int status = FAILURE;
    char *buf;
    boolean_t errflag = B_FALSE;
    ssize_t max_fmri_len;
    scf_instance_t *instance;

    instance = scf_instance_create(handle);
    if (instance == NULL) {
        errflag = B_TRUE;
        KSSL_DEBUG("scf_instance_create failed: %s\n",
            scf_strerror(scf_error()));
        goto out;
    }
    KSSL_DEBUG("scf_instance_create succeeded\n");

    if (scf_service_get_instance(svc, inaddr_any_name, instance) == 0) {
        /* Let the caller deal with the duplicate instance */
        status = INSTANCE_ANY_EXISTS;
        goto out;
    }

    if (scf_service_add_instance(svc, instance_name, instance) != 0) {
        if (scf_error() == SCF_ERROR_EXISTS) {
            /* Let the caller deal with the duplicate instance */
            status = INSTANCE_OTHER_EXISTS;
            goto out;
        }

        errflag = B_TRUE;
        KSSL_DEBUG("scf_service_add_instance failed: %s\n",
            scf_strerror(scf_error()));
        goto out;
    }
    KSSL_DEBUG("scf_service_add_instance succeeded\n");

    if ((add_pg_method(handle, instance, kssl_entry, "start",
        command, username) != SUCCESS) ||
        (add_pg_method(handle, instance, kssl_entry, "refresh",
        command, username) != SUCCESS) ||
        (add_pg_method(handle, instance, kssl_entry, "stop",
        "", username) != SUCCESS)) {
        scf_instance_destroy(instance);
        return (status);
    }

    /* enabling the instance */
    max_fmri_len = scf_limit(SCF_LIMIT_MAX_FMRI_LENGTH);
    if ((buf = malloc(max_fmri_len + 1)) == NULL)
        goto out;

    if (scf_instance_to_fmri(instance, buf, max_fmri_len + 1) > 0) {
        KSSL_DEBUG("instance_fmri=%s\n", buf);
        if (smf_enable_instance(buf, 0) != 0) {
            errflag = B_TRUE;
            KSSL_DEBUG(
                "smf_enable_instance failed: %s\n",
                scf_strerror(scf_error()));
            goto out;
        }
        status = SUCCESS;
    }

out:
    if (instance != NULL)
        scf_instance_destroy(instance);
    if (errflag)
        (void) fprintf(stderr, gettext(
            "Unexpected fatal libscf error: %s. Exiting.\n"),
            scf_strerror(scf_error()));
    return (status);
}

static int
create_service(const char *instance_name, const char *kssl_entry,
    const char *command, const char *username, char *inaddr_any_name)
{
    int status = FAILURE;
    scf_scope_t *scope;
    scf_service_t *svc;
    scf_handle_t *handle;
    boolean_t errflag = B_TRUE;

    handle = scf_handle_create(SCF_VERSION);
    if (handle == NULL) {
        KSSL_DEBUG("scf_handle_create failed: %s\n",
            scf_strerror(scf_error()));
        goto out1;
    }
    KSSL_DEBUG("scf_handle_create succeeded\n");

    if (scf_handle_bind(handle) == -1) {
        KSSL_DEBUG("scf_handle_bind failed: %s\n",
            scf_strerror(scf_error()));
        goto out1;
    }
    KSSL_DEBUG("scf_handle_bind succeeded\n");

    if ((scope = scf_scope_create(handle)) == NULL) {
        KSSL_DEBUG("scf_scope_create failed: %s\n",
            scf_strerror(scf_error()));
        goto out2;
    }
    KSSL_DEBUG("scf_scope_create succeeded\n");

    if ((svc = scf_service_create(handle)) == NULL) {
        KSSL_DEBUG("scf_service_create failed: %s\n",
            scf_strerror(scf_error()));
        goto out3;
    }
    KSSL_DEBUG("scf_service_create succeeded\n");

    if (scf_handle_decode_fmri(handle, SERVICE_NAME, NULL, svc,
        NULL, NULL, NULL, SCF_DECODE_FMRI_EXACT) != 0) {
        KSSL_DEBUG("scf_handle_decode_fmri failed: %s\n",
            scf_strerror(scf_error()));
        if (scf_error() == SCF_ERROR_NOT_FOUND) {
            (void) fprintf(stderr, gettext(
                "service %s not found in the repository."
                " Exiting.\n"), SERVICE_NAME);
            errflag = B_FALSE;
        }
        goto out4;
    }

    status = create_instance(handle, svc, instance_name, kssl_entry,
        command, username, inaddr_any_name);

out4:
    scf_service_destroy(svc);
out3:
    scf_scope_destroy(scope);
out2:
    (void) scf_handle_unbind(handle);
out1:
    if (handle != NULL)
        scf_handle_destroy(handle);

    if (status != SUCCESS && status != INSTANCE_OTHER_EXISTS &&
        status != INSTANCE_ANY_EXISTS && errflag)
        (void) fprintf(stderr, gettext(
            "Unexpected fatal libscf error: %s. Exiting.\n"),
            scf_strerror(scf_error()));
    return (status);
}

int
do_create(int argc, char *argv[])
{
    char c;
    char *buf, *ptr, *instance_name;
    char *inaddr_any_name = NULL;
    int i, status, len, pcnt;
    const char *token_label = NULL;
    const char *filename = NULL;
    const char *certname = NULL;
    const char *username = NULL;
    const char *proxy_port = NULL;
    char *format = NULL;
    boolean_t quote_next;
    char address_port[MAX_ADRPORT_LEN + 1];

    argc -= 1;
    argv += 1;

    /*
     * Many of these arguments are passed on to kssladm command
     * in the start method of the SMF instance created. So, we do only
     * the basic usage checks here and let kssladm check the validity
     * of the arguments. This is the reason we ignore optarg
     * for some of the cases below.
     */
    while ((c = getopt(argc, argv, "vT:d:f:h:i:p:c:C:t:u:x:z:")) != -1) {
        switch (c) {
        case 'd':
            break;
        case 'c':
            break;
        case 'C':
            certname = optarg;
            break;
        case 'f':
            format = optarg;
            break;
        case 'h':
            break;
        case 'i':
            filename = optarg;
            break;
        case 'T':
            token_label = optarg;
            break;
        case 'p':
            break;
        case 't':
            break;
        case 'u':
            username = optarg;
            break;
        case 'x':
            proxy_port = optarg;
            break;
        case 'v':
            verbose = B_TRUE;
            break;
        case 'z':
            break;
        default:
            goto err;
        }
    }

    if (format == NULL || proxy_port == NULL) {
        goto err;
    }

    if (get_portnum(proxy_port, NULL) == 0) {
        (void) fprintf(stderr,
            gettext("Error: Invalid proxy port value %s\n"),
            proxy_port);
        goto err;
    }

    if (strcmp(format, "pkcs11") == 0) {
        if (token_label == NULL || certname == NULL) {
            goto err;
        }
    } else if (strcmp(format, "pkcs12") == 0 ||
        strcmp(format, "pem") == 0) {
        if (filename == NULL) {
            goto err;
        }
    } else {
        goto err;
    }

    pcnt = argc - optind;
    if (pcnt == 1) {
        if (strlen(argv[optind]) < MAX_ADRPORT_LEN) {
            (void) strcpy(address_port, argv[optind]);
        } else {
            (void) fprintf(stderr, gettext(
                "argument too long -- %s\n"),
                argv[optind]);
            return (FAILURE);
        }
    } else if (pcnt == 2) {
        if ((len = strlen(argv[optind])) +
            (strlen(argv[optind + 1])) < MAX_ADRPORT_LEN) {
            (void) strcpy(address_port, argv[optind]);
            address_port[len] = ' ';
            (void) strcpy(address_port + len + 1, argv[optind + 1]);
        } else {
            (void) fprintf(stderr, gettext(
                "arguments too long -- %s %s\n"),
                argv[optind], argv[optind + 1]);
            return (FAILURE);
        }
    } else {
        goto err;
    }

    /*
     * We need to create the kssladm command line in
     * the SMF instance from the current arguments.
     *
     * Construct a buffer with all the arguments except
     * the -u argument. We have to quote the string arguments,
     * -T and -C, as they can contain white space.
     */
    len = 0;
    for (i = 1; i < optind; i++) {
        len += strlen(argv[i]) + 3;
    }

    if ((buf = malloc(len)) == NULL) {
        return (FAILURE);
    }

    ptr = buf;
    quote_next = B_FALSE;
    for (i = 1; i < optind; i++) {
        int arglen =  strlen(argv[i]) + 1;

        if (strncmp(argv[i], "-u", 2) == 0) {
            i++;
            continue;
        }

        if (quote_next) {
            (void) snprintf(ptr, len, "\"%s\" ", argv[i]);
            quote_next = B_FALSE;
            arglen += 2;
        } else {
            (void) snprintf(ptr, len, "%s ", argv[i]);
        }

        quote_next = (strncmp(argv[i], "-T", 2) == 0 ||
            strncmp(argv[i], "-C", 2) == 0);

        ptr += arglen;
        len -= arglen;
    }
    KSSL_DEBUG("buf=%s\n", buf);

    instance_name = create_instance_name(address_port,
        &inaddr_any_name, B_TRUE);
    if (instance_name == NULL || inaddr_any_name == NULL) {
        free(buf);
        return (FAILURE);
    }
    KSSL_DEBUG("instance_name=%s\n", instance_name);
    KSSL_DEBUG("inaddr_any_name=%s\n", inaddr_any_name);

    if (username == NULL)
        username = "root";
    status = create_service(instance_name, address_port,
        buf, username, inaddr_any_name);
    if (status == INSTANCE_OTHER_EXISTS || status == INSTANCE_ANY_EXISTS) {
        if (status == INSTANCE_ANY_EXISTS &&
            (strcmp(instance_name, inaddr_any_name) != SUCCESS)) {
            /*
             * The following could result in a misconfiguration.
             * Better bail out with an error.
             */
            (void) fprintf(stderr,
                gettext("Error: INADDR_ANY instance exists."
                " Can not create a new instance %s.\n"),
                instance_name);
            free(instance_name);
            free(inaddr_any_name);
            free(buf);
            return (status);
        }

        /*
         * Delete the existing instance and create a new instance
         * with the supplied arguments.
         */
        KSSL_DEBUG("Deleting duplicate instance\n");
        if (delete_instance(instance_name) != SUCCESS) {
            (void) fprintf(stderr,
                gettext(
                "Error: Can not delete existing instance %s.\n"),
                instance_name);
        } else {
            (void) fprintf(stdout, gettext(
                "Note: reconfiguring the existing instance %s.\n"),
                instance_name);
            status = create_service(instance_name, address_port,
                buf, username, inaddr_any_name);
        }
    }

    /*
     * network/ssl/proxy depends on network/socket-filter:kssl;
     * enable that service now.
     */
    if (smf_enable_instance(KSSL_FILTER_SVC_NAME, 0) != 0) {
        KSSL_DEBUG(
            "smf_enable_instance failed: %s\n" KSSL_FILTER_SVC_NAME);
        (void) fprintf(stderr, gettext(
            "Unable to enable required service \"%s\". Error: %s"),
            KSSL_FILTER_SVC_NAME, scf_strerror(scf_error()));
        status = FAILURE;
    }

    free(instance_name);
    free(inaddr_any_name);
    free(buf);
    return (status);

err:
    usage_create(B_TRUE);
    return (ERROR_USAGE);
}