/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
 * This driver routine is used to test many of the standard Kerberos library
 * routines.
 */

#include "krb5.h"
#include "autoconf.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include "com_err.h"

void test_string_to_timestamp (krb5_context, char *);
void test_425_conv_principal (krb5_context, char *, char*, char *);
void test_524_conv_principal (krb5_context, char *);
void test_parse_name (krb5_context, const char *);
void test_set_realm (krb5_context, const char *, const char *);
void usage (char *);

void
test_string_to_timestamp(krb5_context ctx, char *ktime)
{
    krb5_timestamp      timestamp;
    time_t              t;
    krb5_error_code     retval;

    retval = krb5_string_to_timestamp(ktime, &timestamp);
    if (retval) {
        com_err("krb5_string_to_timestamp", retval, 0);
        return;
    }
    t = (time_t) timestamp;
    printf("Parsed time was %s", ctime(&t));
}

void
test_425_conv_principal(krb5_context ctx, char *name, char *inst, char *realm)
{
    krb5_error_code     retval;
    krb5_principal      princ;
    char                *out_name;

    retval = krb5_425_conv_principal(ctx, name, inst, realm, &princ);
    if (retval) {
        com_err("krb5_425_conv_principal", retval, 0);
        return;
    }
    retval = krb5_unparse_name(ctx, princ, &out_name);
    if (retval) {
        com_err("krb5_unparse_name", retval, 0);
        return;
    }
    printf("425_converted principal(%s, %s, %s): '%s'\n",
           name, inst, realm, out_name);
    free(out_name);
    krb5_free_principal(ctx, princ);
}

void
test_524_conv_principal(krb5_context ctx, char *name)
{
    krb5_principal princ = 0;
    krb5_error_code retval;
#define ANAME_SZ 40
#define INST_SZ  40
#define REALM_SZ  40
    char aname[ANAME_SZ+1], inst[INST_SZ+1], realm[REALM_SZ+1];

    aname[ANAME_SZ] = inst[INST_SZ] = realm[REALM_SZ] = 0;
    retval = krb5_parse_name(ctx, name, &princ);
    if (retval) {
        com_err("krb5_parse_name", retval, 0);
        goto fail;
    }
    retval = krb5_524_conv_principal(ctx, princ, aname, inst, realm);
    if (retval) {
        com_err("krb5_524_conv_principal", retval, 0);
        goto fail;
    }
    printf("524_converted_principal(%s): '%s' '%s' '%s'\n",
           name, aname, inst, realm);
fail:
    if (princ)
        krb5_free_principal (ctx, princ);
}

void
test_parse_name(krb5_context ctx, const char *name)
{
    krb5_error_code retval;
    krb5_principal  princ = 0, princ2 = 0;
    char            *outname = 0;

    retval = krb5_parse_name(ctx, name, &princ);
    if (retval) {
        com_err("krb5_parse_name", retval, 0);
        goto fail;
    }
    retval = krb5_copy_principal(ctx, princ, &princ2);
    if (retval) {
        com_err("krb5_copy_principal", retval, 0);
        goto fail;
    }
    retval = krb5_unparse_name(ctx, princ2, &outname);
    if (retval) {
        com_err("krb5_unparse_name", retval, 0);
        goto fail;
    }
    printf("parsed (and unparsed) principal(%s): ", name);
    if (strcmp(name, outname) == 0)
        printf("MATCH\n");
    else
        printf("'%s'\n", outname);
fail:
    if (outname)
        free(outname);
    if (princ)
        krb5_free_principal(ctx, princ);
    if (princ2)
        krb5_free_principal(ctx, princ2);
}

void
test_set_realm(krb5_context ctx, const char *name, const char *realm)
{
    krb5_error_code retval;
    krb5_principal  princ = 0;
    char            *outname = 0;

    retval = krb5_parse_name(ctx, name, &princ);
    if (retval) {
        com_err("krb5_parse_name", retval, 0);
        goto fail;
    }
    retval = krb5_set_principal_realm(ctx, princ, realm);
    if (retval) {
        com_err("krb5_set_principal_realm", retval, 0);
        goto fail;
    }
    retval = krb5_unparse_name(ctx, princ, &outname);
    if (retval) {
        com_err("krb5_unparse_name", retval, 0);
        goto fail;
    }
    printf("old principal: %s, modified principal: %s\n", name,
           outname);
fail:
    if (outname)
        free(outname);
    if (princ)
        krb5_free_principal(ctx, princ);
}

void
usage(char *progname)
{
    fprintf(stderr, "%s: Usage: %s 425_conv_principal <name> <inst> <realm\n",
            progname, progname);
    fprintf(stderr, "\t%s 524_conv_principal <name>\n", progname);
    fprintf(stderr, "\t%s parse_name <name>\n", progname);
    fprintf(stderr, "\t%s set_realm <name> <realm>\n", progname);
    fprintf(stderr, "\t%s string_to_timestamp <time>\n", progname);
    exit(1);
}

int
main(int argc, char **argv)
{
    krb5_context ctx;
    krb5_error_code retval;
    char *progname;
    char *name, *inst, *realm;

    retval = krb5_init_context(&ctx);
    if (retval) {
        fprintf(stderr, "krb5_init_context returned error %ld\n",
                (long) retval);
        exit(1);
    }
    progname = argv[0];

    /* Parse arguments. */
    argc--; argv++;
    while (argc) {
        if (strcmp(*argv, "425_conv_principal") == 0) {
            argc--; argv++;
            if (!argc) usage(progname);
            name = *argv;
            argc--; argv++;
            if (!argc) usage(progname);
            inst = *argv;
            argc--; argv++;
            if (!argc) usage(progname);
            realm = *argv;
            test_425_conv_principal(ctx, name, inst, realm);
        } else if (strcmp(*argv, "parse_name") == 0) {
            argc--; argv++;
            if (!argc) usage(progname);
            name = *argv;
            test_parse_name(ctx, name);
        } else if (strcmp(*argv, "set_realm") == 0) {
            argc--; argv++;
            if (!argc) usage(progname);
            name = *argv;
            argc--; argv++;
            if (!argc) usage(progname);
            realm = *argv;
            test_set_realm(ctx, name, realm);
        } else if (strcmp(*argv, "string_to_timestamp") == 0) {
            argc--; argv++;
            if (!argc) usage(progname);
            test_string_to_timestamp(ctx, *argv);
        } else if (strcmp(*argv, "524_conv_principal") == 0) {
            argc--; argv++;
            if (!argc) usage(progname);
            test_524_conv_principal(ctx, *argv);
        }
        else
            usage(progname);
        argc--; argv++;
    }

    krb5_free_context(ctx);

    return 0;
}