#define NEED_SOCKETS
#include "fake-addrinfo.h"
#include "k5-int.h"
#include "os-proto.h"
#include <stdio.h>
#ifdef KRB5_DNS_LOOKUP
#ifdef WSHELPER
#include <wshelper.h>
#else
#include <netinet/in.h>
#include <arpa/inet.h>
#include <arpa/nameser.h>
#include <resolv.h>
#include <netdb.h>
#endif
#ifndef T_SRV
#define T_SRV 33
#endif
#ifndef MAXHOSTNAMELEN
#define MAXHOSTNAMELEN 64
#endif
#define MAX_DNS_NAMELEN (15*(MAXHOSTNAMELEN + 1)+1)
#if KRB5_DNS_LOOKUP_KDC
#define DEFAULT_LOOKUP_KDC 1
#else
#define DEFAULT_LOOKUP_KDC 0
#endif
#if KRB5_DNS_LOOKUP_REALM
#define DEFAULT_LOOKUP_REALM 1
#else
#define DEFAULT_LOOKUP_REALM 0
#endif
static int
maybe_use_dns (krb5_context context, const char *name, int defalt)
{
krb5_error_code code;
char * value = NULL;
int use_dns = 0;
code = profile_get_string(context->profile, "libdefaults",
name, 0, 0, &value);
if (value == 0 && code == 0)
code = profile_get_string(context->profile, "libdefaults",
"dns_fallback", 0, 0, &value);
if (code)
return defalt;
if (value == 0)
return defalt;
use_dns = _krb5_conf_boolean(value);
profile_release_string(value);
return use_dns;
}
int
_krb5_use_dns_kdc(krb5_context context)
{
return maybe_use_dns (context, "dns_lookup_kdc", DEFAULT_LOOKUP_KDC);
}
int
_krb5_use_dns_realm(krb5_context context)
{
return maybe_use_dns (context, "dns_lookup_realm", DEFAULT_LOOKUP_REALM);
}
#endif
static int get_port (const char *service, int stream, int defalt)
{
#if 0
struct addrinfo hints = { 0 };
struct addrinfo *ai;
int err;
hints.ai_family = PF_INET;
hints.ai_socktype = stream ? SOCK_STREAM : SOCK_DGRAM;
err = getaddrinfo (NULL, service, &hints, &ai);
if (err == 0 && ai != 0) {
if (ai->ai_addr->sa_family == AF_INET) {
int port = ((struct sockaddr_in *)ai->ai_addr)->sin_port;
freeaddrinfo (ai);
return port;
}
freeaddrinfo (ai);
}
#endif
return htons (defalt);
}
int
krb5int_grow_addrlist (struct addrlist *lp, int nmore)
{
int i;
int newspace = lp->space + nmore;
size_t newsize = newspace * sizeof (struct addrlist);
struct addrinfo **newaddrs;
if (lp->addrs)
newaddrs = realloc (lp->addrs, newsize);
else
newaddrs = malloc (newsize);
if (newaddrs == NULL)
return errno;
for (i = lp->space; i < newspace; i++)
newaddrs[i] = NULL;
lp->addrs = newaddrs;
lp->space = newspace;
return 0;
}
#define grow_list krb5int_grow_addrlist
void
krb5int_free_addrlist (struct addrlist *lp)
{
int i;
for (i = 0; i < lp->naddrs; i++)
freeaddrinfo (lp->addrs[i]);
free (lp->addrs);
lp->addrs = NULL;
lp->naddrs = lp->space = 0;
}
#define free_list krb5int_free_addrlist
static int translate_ai_error (int err)
{
switch (err) {
case 0:
return 0;
case EAI_BADFLAGS:
case EAI_FAMILY:
case EAI_SOCKTYPE:
case EAI_SERVICE:
return EINVAL;
case EAI_AGAIN:
return EAGAIN;
case EAI_MEMORY:
return ENOMEM;
#ifdef EAI_ADDRFAMILY
case EAI_ADDRFAMILY:
#endif
#if EAI_NODATA != EAI_NONAME
case EAI_NODATA:
#endif
case EAI_NONAME:
return 0;
#ifdef EAI_SYSTEM
case EAI_SYSTEM:
return errno;
#endif
default:
return EINVAL;
}
}
#include <stdarg.h>
static inline void Tprintf(const char *fmt, ...)
{
#ifdef TEST
va_list ap;
va_start(ap, fmt);
vfprintf(stderr, fmt, ap);
va_end(ap);
#endif
}
static int add_addrinfo_to_list (struct addrlist *lp, struct addrinfo *a)
{
int err;
switch (a->ai_socktype) {
case SOCK_DGRAM:
Tprintf("\tdgram\n");
break;
case SOCK_STREAM:
Tprintf("\tstream\n");
break;
case SOCK_RAW:
Tprintf("\traw\n");
break;
case 0:
break;
default:
Tprintf("\tsocket type %d\n", a->ai_socktype);
break;
}
if (lp->naddrs == lp->space) {
err = grow_list (lp, 1);
if (err) {
Tprintf ("grow_list failed %d\n", err);
return err;
}
}
lp->addrs[lp->naddrs++] = a;
a->ai_next = 0;
Tprintf ("count is now %d\n", lp->naddrs);
return 0;
}
#define add_host_to_list krb5int_add_host_to_list
int
krb5int_add_host_to_list (struct addrlist *lp, const char *hostname,
int port, int secport,
int socktype, int family)
{
struct addrinfo *addrs, *a, *anext, hint;
int err;
char portbuf[10], secportbuf[10];
Tprintf ("adding hostname %s, ports %d,%d, family %d, socktype %d\n",
hostname, ntohs (port), ntohs (secport),
family, socktype);
memset(&hint, 0, sizeof(hint));
hint.ai_family = family;
hint.ai_socktype = socktype;
#ifdef AI_NUMERICSERV
hint.ai_flags = AI_NUMERICSERV;
#endif
sprintf(portbuf, "%d", ntohs(port));
sprintf(secportbuf, "%d", ntohs(secport));
err = getaddrinfo (hostname, portbuf, &hint, &addrs);
if (err) {
Tprintf ("\tgetaddrinfo(\"%s\", \"%s\", ...)\n\treturns %d: %s\n",
hostname, portbuf, err, gai_strerror (err));
return translate_ai_error (err);
}
anext = 0;
for (a = addrs; a != 0 && err == 0; a = anext) {
anext = a->ai_next;
err = add_addrinfo_to_list (lp, a);
}
if (err || secport == 0)
goto egress;
if (socktype == 0)
socktype = SOCK_DGRAM;
else if (socktype != SOCK_DGRAM)
goto egress;
hint.ai_family = AF_INET;
err = getaddrinfo (hostname, secportbuf, &hint, &addrs);
if (err) {
err = translate_ai_error (err);
goto egress;
}
for (a = addrs; a != 0 && err == 0; a = anext) {
anext = a->ai_next;
err = add_addrinfo_to_list (lp, a);
}
egress:
if (anext)
freeaddrinfo (anext);
return err;
}
static krb5_error_code
krb5_locate_srv_conf_1(krb5_context context, const krb5_data *realm,
const char * name, struct addrlist *addrlist,
int get_masters, int socktype,
int udpport, int sec_udpport, int family)
{
const char *realm_srv_names[4];
char **masterlist, **hostlist, *host, *port, *cp;
krb5_error_code code;
int i, j, count, ismaster;
Tprintf ("looking in krb5.conf for realm %s entry %s; ports %d,%d\n",
realm->data, name, ntohs (udpport), ntohs (sec_udpport));
if ((host = malloc(realm->length + 1)) == NULL)
return ENOMEM;
strncpy(host, realm->data, realm->length);
host[realm->length] = '\0';
hostlist = 0;
masterlist = NULL;
realm_srv_names[0] = "realms";
realm_srv_names[1] = host;
realm_srv_names[2] = name;
realm_srv_names[3] = 0;
code = profile_get_values(context->profile, realm_srv_names, &hostlist);
if (code) {
Tprintf ("config file lookup failed: %s\n",
error_message(code));
if (code == PROF_NO_SECTION || code == PROF_NO_RELATION)
code = KRB5_REALM_UNKNOWN;
krb5_xfree(host);
return code;
}
count = 0;
while (hostlist && hostlist[count])
count++;
Tprintf ("found %d entries under 'kdc'\n", count);
if (count == 0) {
profile_free_list(hostlist);
krb5_xfree(host);
addrlist->naddrs = 0;
return 0;
}
if (get_masters) {
realm_srv_names[0] = "realms";
realm_srv_names[1] = host;
realm_srv_names[2] = "admin_server";
realm_srv_names[3] = 0;
code = profile_get_values(context->profile, realm_srv_names,
&masterlist);
krb5_xfree(host);
if (code == 0) {
for (i=0; masterlist[i]; i++) {
host = masterlist[i];
cp = strchr(host, ' ');
if (cp)
*cp = 0;
cp = strchr(host, '\t');
if (cp)
*cp = 0;
cp = strchr(host, ':');
if (cp)
*cp = 0;
}
}
} else {
krb5_xfree(host);
}
#ifdef HAVE_NETINET_IN_H
if (sec_udpport)
count = count * 2;
#endif
for (i=0; hostlist[i]; i++) {
int p1, p2;
host = hostlist[i];
Tprintf ("entry %d is '%s'\n", i, host);
cp = strchr(host, ' ');
if (cp)
*cp = 0;
cp = strchr(host, '\t');
if (cp)
*cp = 0;
port = strchr(host, ':');
if (port) {
*port = 0;
port++;
}
ismaster = 0;
if (masterlist) {
for (j=0; masterlist[j]; j++) {
if (strcasecmp(hostlist[i], masterlist[j]) == 0) {
ismaster = 1;
}
}
}
if (get_masters && !ismaster)
continue;
if (port) {
unsigned long l;
#ifdef HAVE_STROUL
char *endptr;
l = strtoul (port, &endptr, 10);
if (endptr == NULL || *endptr != 0)
return EINVAL;
#else
l = atoi (port);
#endif
if (l > 65535)
return EINVAL;
p1 = htons (l);
p2 = 0;
} else {
p1 = udpport;
p2 = sec_udpport;
}
if (socktype != 0)
code = add_host_to_list (addrlist, hostlist[i], p1, p2,
socktype, family);
else {
code = add_host_to_list (addrlist, hostlist[i], p1, p2,
SOCK_DGRAM, family);
if (code == 0)
code = add_host_to_list (addrlist, hostlist[i], p1, p2,
SOCK_STREAM, family);
}
if (code) {
Tprintf ("error %d (%s) returned from add_host_to_list\n", code,
error_message (code));
if (hostlist)
profile_free_list (hostlist);
if (masterlist)
profile_free_list (masterlist);
return code;
}
}
if (hostlist)
profile_free_list(hostlist);
if (masterlist)
profile_free_list(masterlist);
return 0;
}
#ifdef TEST
static krb5_error_code
krb5_locate_srv_conf(krb5_context context, const krb5_data *realm,
const char *name, struct addrlist *al, int get_masters,
int udpport, int sec_udpport)
{
krb5_error_code ret;
ret = krb5_locate_srv_conf_1 (context, realm, name, al,
get_masters, 0, udpport, sec_udpport, 0);
if (ret)
return ret;
if (al->naddrs == 0)
return KRB5_REALM_CANT_RESOLVE;
return 0;
}
#endif
#ifdef KRB5_DNS_LOOKUP
static krb5_error_code
krb5_locate_srv_dns_1 (const krb5_data *realm,
const char *service,
const char *protocol,
struct addrlist *addrlist,
int family)
{
struct srv_dns_entry *head = NULL;
struct srv_dns_entry *entry = NULL, *next;
krb5_error_code code = 0;
code = krb5int_make_srv_query_realm(realm, service, protocol, &head);
if (code)
return 0;
if (head == NULL)
return 0;
if (head->next == 0 && head->host[0] == 0) {
free(head->host);
free(head);
return KRB5_ERR_NO_SERVICE;
}
Tprintf ("walking answer list:\n");
for (entry = head; entry != NULL; entry = next) {
Tprintf ("\tport=%d host=%s\n", entry->port, entry->host);
next = entry->next;
code = add_host_to_list (addrlist, entry->host, htons (entry->port), 0,
(strcmp("_tcp", protocol)
? SOCK_DGRAM
: SOCK_STREAM), family);
if (code) {
break;
}
if (entry == head) {
free(entry->host);
free(entry);
head = next;
entry = 0;
}
}
Tprintf ("[end]\n");
krb5int_free_srv_dns_data(head);
return code;
}
#endif
krb5_error_code
krb5int_locate_server (krb5_context context, const krb5_data *realm,
struct addrlist *addrlist,
int get_masters,
const char *profname, const char *dnsname,
int socktype,
int dflport1, int dflport2,
int family)
{
krb5_error_code code;
struct addrlist al = ADDRLIST_INIT;
*addrlist = al;
code = krb5_locate_srv_conf_1(context, realm, profname, &al, get_masters,
socktype, dflport1, dflport2, family);
#ifdef KRB5_DNS_LOOKUP
if (code && dnsname != 0) {
int use_dns = _krb5_use_dns_kdc(context);
if (use_dns) {
code = 0;
if (socktype == SOCK_DGRAM || socktype == 0) {
code = krb5_locate_srv_dns_1(realm, dnsname, "_udp",
&al, family);
if (code)
Tprintf("dns udp lookup returned error %d\n", code);
}
if ((socktype == SOCK_STREAM || socktype == 0) && code == 0) {
code = krb5_locate_srv_dns_1(realm, dnsname, "_tcp",
&al, family);
if (code)
Tprintf("dns tcp lookup returned error %d\n", code);
}
}
}
#endif
if (code == 0)
Tprintf ("krb5int_locate_server found %d addresses\n",
al.naddrs);
else
Tprintf ("krb5int_locate_server returning error code %d\n",
code);
if (code != 0) {
if (al.space)
free_list (&al);
return code;
}
if (al.naddrs == 0) {
if (al.space)
free_list (&al);
return KRB5_REALM_CANT_RESOLVE;
}
*addrlist = al;
return 0;
}
krb5_error_code
krb5_locate_kdc(krb5_context context, const krb5_data *realm,
struct addrlist *addrlist,
int get_masters, int socktype, int family)
{
int udpport, sec_udpport;
udpport = get_port (KDC_PORTNAME, 0, KRB5_DEFAULT_PORT);
if (socktype == SOCK_STREAM)
sec_udpport = 0;
else {
sec_udpport = get_port (KDC_SECONDARY_PORTNAME, 0,
(udpport == htons (KRB5_DEFAULT_PORT)
? KRB5_DEFAULT_SEC_PORT
: KRB5_DEFAULT_PORT));
if (sec_udpport == udpport)
sec_udpport = 0;
}
return krb5int_locate_server(context, realm, addrlist, 0,
get_masters ? "master_kdc" : "kdc",
(get_masters
? "_kerberos-master"
: "_kerberos"),
socktype, udpport, sec_udpport, family);
}