/*++
/* NAME
/*	known_tcp_ports 3
/* SUMMARY
/*	reduce dependency on the services(5) database
/* SYNOPSIS
/*	#include <known_tcp_ports.h>
/*
/*	const char *add_known_tcp_port(
/*	const char *name)
/*	const char *port)
/*
/*	const char *filter_known_tcp_port(
/*	const char *name_or_port)
/*
/*	void    clear_known_tcp_ports(void)
/* AUXILIARY FUNCTIONS
/*	char	*export_known_tcp_ports(
/*	VSTRING *result)
/* DESCRIPTION
/*	This module reduces dependency on the services(5) database.
/*
/*	add_known_tcp_port() associates a symbolic name with a numerical
/*	port. The function returns a pointer to error text if the
/*	arguments are malformed or if the symbolic name already has
/*	an association.
/*
/*	filter_known_tcp_port() returns the argument if it does not
/*	specify a symbolic name, or if the argument specifies a symbolic
/*	name that is not associated with a numerical port.  Otherwise,
/*	it returns the associated numerical port.
/*
/*	clear_known_tcp_ports() destroys all name-number associations.
/*	string.
/*
/*	export_known_tcp_ports() overwrites a VSTRING with all known
/*	name=port associations, sorted by service name, and separated
/*	by whitespace. The result is pointer to the VSTRING payload.
/* LICENSE
/* .ad
/* .fi
/*	The Secure Mailer license must be distributed with this software.
/* AUTHOR(S)
/*	Wietse Venema
/*	Google, Inc.
/*	111 8th Avenue
/*	New York, NY 10011, USA
/*--*/

 /*
  * System library
  */
#include <sys_defs.h>
#include <stdlib.h>
#include <string.h>

 /*
  * Utility library
  */
#include <htable.h>
#include <mymalloc.h>
#include <stringops.h>

 /*
  * Application-specific.
  */
#include <known_tcp_ports.h>

#define STR(x)	vstring_str(x)

static HTABLE *known_tcp_ports;

/* add_known_tcp_port - associate symbolic name with numerical port */

const char *add_known_tcp_port(const char *name, const char *port)
{
    if (alldig(name))
	return ("numerical service name");
    if (!alldig(port))
	return ("non-numerical service port");
    if (known_tcp_ports == 0)
	known_tcp_ports = htable_create(10);
    if (htable_locate(known_tcp_ports, name) != 0)
	return ("duplicate service name");
    (void) htable_enter(known_tcp_ports, name, mystrdup(port));
    return (0);
}

/* filter_known_tcp_port - replace argument if associated with known port */

const char *filter_known_tcp_port(const char *name_or_port)
{
    HTABLE_INFO *ht;

    if (name_or_port == 0 || known_tcp_ports == 0 || alldig(name_or_port)) {
	return (name_or_port);
    } else if ((ht = htable_locate(known_tcp_ports, name_or_port)) != 0) {
	return (ht->value);
    } else {
	return (name_or_port);
    }
}

/* clear_known_tcp_ports - destroy all name-port associations */

void    clear_known_tcp_ports(void)
{
    htable_free(known_tcp_ports, myfree);
    known_tcp_ports = 0;
}

/* compare_ht_keys - compare table keys */

static int compare_ht_keys(const void *a, const void *b)
{
    HTABLE_INFO **ap = (HTABLE_INFO **) a;
    HTABLE_INFO **bp = (HTABLE_INFO **) b;

    return (strcmp((const char *) ap[0]->key, (const char *) bp[0]->key));
}

/* export_known_tcp_ports - sorted dump */

char   *export_known_tcp_ports(VSTRING *out)
{
    HTABLE_INFO **list;
    HTABLE_INFO **ht;

    VSTRING_RESET(out);
    if (known_tcp_ports) {
	list = htable_list(known_tcp_ports);
	qsort((void *) list, known_tcp_ports->used, sizeof(*list),
	      compare_ht_keys);
	for (ht = list; *ht; ht++)
	    vstring_sprintf_append(out, "%s%s=%s", ht > list ? " " : "",
				   ht[0]->key, (const char *) ht[0]->value);
	myfree((void *) list);
    }
    VSTRING_TERMINATE(out);
    return (STR(out));
}

#ifdef TEST

#include <msg.h>

struct association {
    const char *lhs;			/* service name */
    const char *rhs;			/* service port */
};

struct probe {
    const char *query;			/* query */
    const char *exp_reply;		/* expected reply */
};

struct test_case {
    const char *label;			/* identifies test case */
    struct association associations[10];
    const char *exp_err;		/* expected error */
    const char *exp_export;		/* expected export output */
    struct probe probes[10];
};

struct test_case test_cases[] = {
    {"good",
	 /* association */ {{"smtp", "25"}, {"lmtp", "24"}, 0},
	 /* error */ 0,
	 /* export */ "lmtp=24 smtp=25",
	 /* probe */ {{"smtp", "25"}, {"1", "1"}, {"x", "x"}, {"lmtp", "24"}, 0}
    },
    {"duplicate lhs",
	 /* association */ {{"smtp", "25"}, {"smtp", "100"}, 0},
	 /* error */ "duplicate service name"
    },
    {"numerical lhs",
	 /* association */ {{"100", "100"}, 0},
	 /* error */ "numerical service name"
    },
    {"symbolic rhs",
	 /* association */ {{"smtp", "lmtp"}, 0},
	 /* error */ "non-numerical service port"
    },
    {"uninitialized",
	 /* association */ {0},
	 /* error */ 0,
	 /* export */ "",
	 /* probe */ {{"smtp", "smtp"}, {"1", "1"}, {"x", "x"}, 0}
    },
    0,
};

int     main(int argc, char **argv)
{
    VSTRING *export_buf;
    struct test_case *tp;
    struct association *ap;
    struct probe *pp;
    int     pass = 0;
    int     fail = 0;
    const char *err;
    int     test_failed;
    const char *reply;
    const char *export;

#define STRING_OR_NULL(s) ((s) ? (s) : "(null)")

    export_buf = vstring_alloc(100);
    for (tp = test_cases; tp->label != 0; tp++) {
	test_failed = 0;
	for (err = 0, ap = tp->associations; err == 0 && ap->lhs != 0; ap++)
	    err = add_known_tcp_port(ap->lhs, ap->rhs);
	if (!err != !tp->exp_err) {
	    msg_warn("test case %s: got error: \"%s\", want: \"%s\"",
	       tp->label, STRING_OR_NULL(err), STRING_OR_NULL(tp->exp_err));
	    test_failed = 1;
	} else if (err != 0) {
	    if (strcmp(err, tp->exp_err) != 0) {
		msg_warn("test case %s: got err: \"%s\", want: \"%s\"",
			 tp->label, err, tp->exp_err);
		test_failed = 1;
	    }
	} else {
	    export = export_known_tcp_ports(export_buf);
	    if (strcmp(export, tp->exp_export) != 0) {
		msg_warn("test case %s: got export: \"%s\", want: \"%s\"",
			 tp->label, export, tp->exp_export);
		test_failed = 1;
	    }
	    for (pp = tp->probes; test_failed == 0 && pp->query != 0; pp++) {
		reply = filter_known_tcp_port(pp->query);
		if (strcmp(reply, pp->exp_reply) != 0) {
		    msg_warn("test case %s: got reply: \"%s\", want: \"%s\"",
			     tp->label, reply, pp->exp_reply);
		    test_failed = 1;
		}
	    }
	}
	clear_known_tcp_ports();
	if (test_failed) {
	    msg_info("%s: FAIL", tp->label);
	    fail++;
	} else {
	    msg_info("%s: PASS", tp->label);
	    pass++;
	}
    }
    msg_info("PASS=%d FAIL=%d", pass, fail);
    vstring_free(export_buf);
    exit(fail != 0);
}

#endif