[unix-history] / usr / src / kerberosIV / krb / send_to_kdc.c

/*
 * $Source: /usr/src/kerberosIV/krb/RCS/send_to_kdc.c,v $
 * $Author: kfall $
 *
 * Copyright 1987, 1988 by the Massachusetts Institute of Technology.
 *
 * For copying and distribution information, please see the file
 * <mit-copyright.h>.
 */

#ifndef lint
static char rcsid_send_to_kdc_c[] =
"$Id: send_to_kdc.c,v 4.21 90/06/25 20:57:21 kfall Exp $";
#endif /* lint */

#include <mit-copyright.h>

#include <des.h>
#include <krb.h>
#include <prot.h>

#include <stdio.h>
#include <errno.h>
#include <sys/time.h>
#include <sys/types.h>
#ifdef lint
#include <sys/uio.h>            /* struct iovec to make lint happy */
#endif /* lint */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <strings.h>

#define S_AD_SZ sizeof(struct sockaddr_in)

extern int errno;
extern int krb_debug;

extern char *malloc(), *calloc(), *realloc();

int krb_udp_port = 0;

/* CLIENT_KRB_TIMEOUT indicates the time to wait before
 * retrying a server.  It's defined in "krb.h".
 */
static struct timeval timeout = { CLIENT_KRB_TIMEOUT, 0};
static char *prog = "send_to_kdc";
static send_recv();

/*
 * This file contains two routines, send_to_kdc() and send_recv().
 * send_recv() is a static routine used by send_to_kdc().
 */

/*
 * send_to_kdc() sends a message to the Kerberos authentication
 * server(s) in the given realm and returns the reply message.
 * The "pkt" argument points to the message to be sent to Kerberos;
 * the "rpkt" argument will be filled in with Kerberos' reply.
 * The "realm" argument indicates the realm of the Kerberos server(s)
 * to transact with.  If the realm is null, the local realm is used.
 *
 * If more than one Kerberos server is known for a given realm,
 * different servers will be queried until one of them replies.
 * Several attempts (retries) are made for each server before
 * giving up entirely.
 *
 * If an answer was received from a Kerberos host, KSUCCESS is
 * returned.  The following errors can be returned:
 *
 * SKDC_CANT    - can't get local realm
 *              - can't find "kerberos" in /etc/services database
 *              - can't open socket
 *              - can't bind socket
 *              - all ports in use
 *              - couldn't find any Kerberos host
 *
 * SKDC_RETRY   - couldn't get an answer from any Kerberos server,
 *		  after several retries
 */

send_to_kdc(pkt,rpkt,realm)
    KTEXT pkt;
    KTEXT rpkt;
    char *realm;
{
    int i, f;
    int no_host; /* was a kerberos host found? */
    int retry;
    int n_hosts;
    int retval;
    struct sockaddr_in to;
    struct hostent *host, *hostlist;
    char *cp;
    char krbhst[MAX_HSTNM];
    char lrealm[REALM_SZ];

    /*
     * If "realm" is non-null, use that, otherwise get the
     * local realm.
     */
    if (realm)
	(void) strcpy(lrealm, realm);
    else
	if (krb_get_lrealm(lrealm,1)) {
	    if (krb_debug)
		fprintf(stderr, "%s: can't get local realm\n", prog);
	    return(SKDC_CANT);
	}
    if (krb_debug)
        printf("lrealm is %s\n", lrealm);
    if (krb_udp_port == 0) {
        register struct servent *sp;
        if ((sp = getservbyname("kerberos","udp")) == 0) {
            if (krb_debug)
                fprintf(stderr, "%s: Can't get kerberos/udp service\n",
                        prog);
            return(SKDC_CANT);
        }
        krb_udp_port = sp->s_port;
        if (krb_debug)
            printf("krb_udp_port is %d\n", krb_udp_port);
    }
    bzero((char *)&to, S_AD_SZ);
    hostlist = (struct hostent *) malloc(sizeof(struct hostent));
    if (!hostlist)
        return (/*errno */SKDC_CANT);
    if ((f = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        if (krb_debug)
            fprintf(stderr,"%s: Can't open socket\n", prog);
        return(SKDC_CANT);
    }
    /* from now on, exit through rtn label for cleanup */

    no_host = 1;
    /* get an initial allocation */
    n_hosts = 0;
    for (i = 1; krb_get_krbhst(krbhst, lrealm, i) == KSUCCESS; ++i) {
        if (krb_debug) {
            printf("Getting host entry for %s...",krbhst);
            (void) fflush(stdout);
        }
        host = gethostbyname(krbhst);
        if (krb_debug) {
            printf("%s.\n",
                   host ? "Got it" : "Didn't get it");
            (void) fflush(stdout);
        }
        if (!host)
            continue;
        no_host = 0;    /* found at least one */
        n_hosts++;
        /* preserve host network address to check later
         * (would be better to preserve *all* addresses,
         * take care of that later)
         */
        hostlist = (struct hostent *)
            realloc((char *)hostlist,
                    (unsigned)
                    sizeof(struct hostent)*(n_hosts+1));
        if (!hostlist)
            return /*errno */SKDC_CANT;
        bcopy((char *)host, (char *)&hostlist[n_hosts-1],
              sizeof(struct hostent));
        host = &hostlist[n_hosts-1];
        cp = malloc((unsigned)host->h_length);
        if (!cp) {
            retval = /*errno */SKDC_CANT;
            goto rtn;
        }
        bcopy((char *)host->h_addr, cp, host->h_length);
/* At least Sun OS version 3.2 (or worse) and Ultrix version 2.2
   (or worse) only return one name ... */
#if !(defined(ULTRIX022) || (defined(SunOS) && SunOS < 40))
        host->h_addr_list = (char **)malloc(sizeof(char *));
        if (!host->h_addr_list) {
            retval = /*errno */SKDC_CANT;
            goto rtn;
        }
#endif /* ULTRIX022 || SunOS */
        host->h_addr = cp;
        bzero((char *)&hostlist[n_hosts],
              sizeof(struct hostent));
        to.sin_family = host->h_addrtype;
        bcopy(host->h_addr, (char *)&to.sin_addr,
              host->h_length);
        to.sin_port = krb_udp_port;
        if (send_recv(pkt, rpkt, f, &to, hostlist)) {
            retval = KSUCCESS;
            goto rtn;
        }
        if (krb_debug) {
            printf("Timeout, error, or wrong descriptor\n");
            (void) fflush(stdout);
        }
    }
    if (no_host) {
	if (krb_debug)
	    fprintf(stderr, "%s: can't find any Kerberos host.\n",
		    prog);
        retval = SKDC_CANT;
        goto rtn;
    }
    /* retry each host in sequence */
    for (retry = 0; retry < CLIENT_KRB_RETRY; ++retry) {
        for (host = hostlist; host->h_name != (char *)NULL; host++) {
            to.sin_family = host->h_addrtype;
            bcopy(host->h_addr, (char *)&to.sin_addr,
                  host->h_length);
            if (send_recv(pkt, rpkt, f, &to, hostlist)) {
                retval = KSUCCESS;
                goto rtn;
            }
        }
    }
    retval = SKDC_RETRY;
rtn:
    (void) close(f);
    if (hostlist) {
        register struct hostent *hp;
        for (hp = hostlist; hp->h_name; hp++)
#if !(defined(ULTRIX022) || (defined(SunOS) && SunOS < 40))
            if (hp->h_addr_list) {
#endif /* ULTRIX022 || SunOS */
                if (hp->h_addr)
                    free(hp->h_addr);
#if !(defined(ULTRIX022) || (defined(SunOS) && SunOS < 40))
                free((char *)hp->h_addr_list);
            }
#endif /* ULTRIX022 || SunOS */
        free((char *)hostlist);
    }
    return(retval);
}

/*
 * try to send out and receive message.
 * return 1 on success, 0 on failure
 */

static send_recv(pkt,rpkt,f,_to,addrs)
    KTEXT pkt;
    KTEXT rpkt;
    int f;
    struct sockaddr_in *_to;
    struct hostent *addrs;
{
    fd_set readfds;
    register struct hostent *hp;
    struct sockaddr_in from;
    int sin_size;
    int numsent;

    if (krb_debug) {
        if (_to->sin_family == AF_INET)
            printf("Sending message to %s...",
                   inet_ntoa(_to->sin_addr));
        else
            printf("Sending message...");
        (void) fflush(stdout);
    }
    if ((numsent = sendto(f,(char *)(pkt->dat), pkt->length, 0, 
			  (struct sockaddr *)_to,
                          S_AD_SZ)) != pkt->length) {
        if (krb_debug)
            printf("sent only %d/%d\n",numsent, pkt->length);
        return 0;
    }
    if (krb_debug) {
        printf("Sent\nWaiting for reply...");
        (void) fflush(stdout);
    }
    FD_ZERO(&readfds);
    FD_SET(f, &readfds);
    errno = 0;
    /* select - either recv is ready, or timeout */
    /* see if timeout or error or wrong descriptor */
    if (select(f + 1, &readfds, (fd_set *)0, (fd_set *)0, &timeout) < 1
        || !FD_ISSET(f, &readfds)) {
        if (krb_debug) {
            fprintf(stderr, "select failed: readfds=%x",
                    readfds);
            perror("");
        }
        return 0;
    }
    sin_size = sizeof(from);
    if (recvfrom(f, (char *)(rpkt->dat), sizeof(rpkt->dat), 0,
		 (struct sockaddr *)&from, &sin_size)
        < 0) {
        if (krb_debug)
            perror("recvfrom");
        return 0;
    }
    if (krb_debug) {
        printf("received packet from %s\n", inet_ntoa(from.sin_addr));
        fflush(stdout);
    }
    for (hp = addrs; hp->h_name != (char *)NULL; hp++) {
        if (!bcmp(hp->h_addr, (char *)&from.sin_addr.s_addr,
                  hp->h_length)) {
            if (krb_debug) {
                printf("Received it\n");
                (void) fflush(stdout);
            }
            return 1;
        }
        if (krb_debug)
            fprintf(stderr,
                    "packet not from %x\n",
                    hp->h_addr);
    }
    if (krb_debug)
        fprintf(stderr, "%s: received packet from wrong host! (%x)\n",
                "send_to_kdc(send_rcv)", from.sin_addr.s_addr);
    return 0;
}
Commit	Line	Data
3cf9afd3 C	1	/*
	2	* $Source: /usr/src/kerberosIV/krb/RCS/send_to_kdc.c,v $
	3	* $Author: kfall $
	4	*
	5	* Copyright 1987, 1988 by the Massachusetts Institute of Technology.
	6	*
	7	* For copying and distribution information, please see the file
	8	* <mit-copyright.h>.
	9	*/
	10
	11	#ifndef lint
	12	static char rcsid_send_to_kdc_c[] =
	13	"$Id: send_to_kdc.c,v 4.21 90/06/25 20:57:21 kfall Exp $";
	14	#endif /* lint */
	15
	16	#include <mit-copyright.h>
	17
	18	#include <des.h>
	19	#include <krb.h>
	20	#include <prot.h>
	21
	22	#include <stdio.h>
	23	#include <errno.h>
	24	#include <sys/time.h>
	25	#include <sys/types.h>
	26	#ifdef lint
	27	#include <sys/uio.h> /* struct iovec to make lint happy */
	28	#endif /* lint */
	29	#include <sys/socket.h>
	30	#include <netinet/in.h>
	31	#include <netdb.h>
	32	#include <strings.h>
	33
	34	#define S_AD_SZ sizeof(struct sockaddr_in)
	35
	36	extern int errno;
	37	extern int krb_debug;
	38
	39	extern char malloc(), calloc(), *realloc();
	40
	41	int krb_udp_port = 0;
	42
	43	/* CLIENT_KRB_TIMEOUT indicates the time to wait before
	44	* retrying a server. It's defined in "krb.h".
	45	*/
	46	static struct timeval timeout = { CLIENT_KRB_TIMEOUT, 0};
	47	static char *prog = "send_to_kdc";
	48	static send_recv();
	49
	50	/*
	51	* This file contains two routines, send_to_kdc() and send_recv().
	52	* send_recv() is a static routine used by send_to_kdc().
	53	*/
	54
	55	/*
	56	* send_to_kdc() sends a message to the Kerberos authentication
	57	* server(s) in the given realm and returns the reply message.
	58	* The "pkt" argument points to the message to be sent to Kerberos;
	59	* the "rpkt" argument will be filled in with Kerberos' reply.
	60	* The "realm" argument indicates the realm of the Kerberos server(s)
	61	* to transact with. If the realm is null, the local realm is used.
	62	*
	63	* If more than one Kerberos server is known for a given realm,
	64	* different servers will be queried until one of them replies.
65	* Several attempts (retries) are made for each server before
66	* giving up entirely.
67	*
68	* If an answer was received from a Kerberos host, KSUCCESS is
69	* returned. The following errors can be returned:
70	*
71	* SKDC_CANT - can't get local realm
72	* - can't find "kerberos" in /etc/services database
73	* - can't open socket
74	* - can't bind socket
75	* - all ports in use
76	* - couldn't find any Kerberos host
77	*
78	* SKDC_RETRY - couldn't get an answer from any Kerberos server,
79	* after several retries
80	*/
81
82	send_to_kdc(pkt,rpkt,realm)
83	KTEXT pkt;
84	KTEXT rpkt;
85	char *realm;
86	{
87	int i, f;
88	int no_host; /* was a kerberos host found? */
89	int retry;
90	int n_hosts;
91	int retval;
92	struct sockaddr_in to;
93	struct hostent host, hostlist;
94	char *cp;
95	char krbhst[MAX_HSTNM];
96	char lrealm[REALM_SZ];
97
98	/*
99	* If "realm" is non-null, use that, otherwise get the
100	* local realm.
101	*/
102	if (realm)
103	(void) strcpy(lrealm, realm);
104	else
105	if (krb_get_lrealm(lrealm,1)) {
106	if (krb_debug)
107	fprintf(stderr, "%s: can't get local realm\n", prog);
108	return(SKDC_CANT);
109	}
110	if (krb_debug)
111	printf("lrealm is %s\n", lrealm);
112	if (krb_udp_port == 0) {
113	register struct servent *sp;
114	if ((sp = getservbyname("kerberos","udp")) == 0) {
115	if (krb_debug)
116	fprintf(stderr, "%s: Can't get kerberos/udp service\n",
117	prog);
118	return(SKDC_CANT);
119	}
120	krb_udp_port = sp->s_port;
121	if (krb_debug)
122	printf("krb_udp_port is %d\n", krb_udp_port);
123	}
124	bzero((char *)&to, S_AD_SZ);
125	hostlist = (struct hostent *) malloc(sizeof(struct hostent));
126	if (!hostlist)
127	return (/errno /SKDC_CANT);
128	if ((f = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
129	if (krb_debug)
130	fprintf(stderr,"%s: Can't open socket\n", prog);
131	return(SKDC_CANT);
132	}
133	/* from now on, exit through rtn label for cleanup */
134
135	no_host = 1;
136	/* get an initial allocation */
137	n_hosts = 0;
138	for (i = 1; krb_get_krbhst(krbhst, lrealm, i) == KSUCCESS; ++i) {
139	if (krb_debug) {
140	printf("Getting host entry for %s...",krbhst);
141	(void) fflush(stdout);
142	}
143	host = gethostbyname(krbhst);
144	if (krb_debug) {
145	printf("%s.\n",
146	host ? "Got it" : "Didn't get it");
147	(void) fflush(stdout);
148	}
149	if (!host)
150	continue;
151	no_host = 0; /* found at least one */
152	n_hosts++;
153	/* preserve host network address to check later
154	* (would be better to preserve all addresses,
155	* take care of that later)
156	*/
157	hostlist = (struct hostent *)
158	realloc((char *)hostlist,
159	(unsigned)
160	sizeof(struct hostent)*(n_hosts+1));
161	if (!hostlist)
162	return /errno /SKDC_CANT;
163	bcopy((char )host, (char )&hostlist[n_hosts-1],
164	sizeof(struct hostent));
165	host = &hostlist[n_hosts-1];
166	cp = malloc((unsigned)host->h_length);
167	if (!cp) {
168	retval = /errno /SKDC_CANT;
169	goto rtn;
170	}
171	bcopy((char *)host->h_addr, cp, host->h_length);
172	/* At least Sun OS version 3.2 (or worse) and Ultrix version 2.2
173	(or worse) only return one name ... */
174	#if !(defined(ULTRIX022) \|\| (defined(SunOS) && SunOS < 40))
175	host->h_addr_list = (char *)malloc(sizeof(char ));
176	if (!host->h_addr_list) {
177	retval = /errno /SKDC_CANT;
178	goto rtn;
179	}
180	#endif /* ULTRIX022 \|\| SunOS */
181	host->h_addr = cp;
182	bzero((char *)&hostlist[n_hosts],
183	sizeof(struct hostent));
184	to.sin_family = host->h_addrtype;
185	bcopy(host->h_addr, (char *)&to.sin_addr,
186	host->h_length);
187	to.sin_port = krb_udp_port;
188	if (send_recv(pkt, rpkt, f, &to, hostlist)) {
189	retval = KSUCCESS;
190	goto rtn;
191	}
192	if (krb_debug) {
193	printf("Timeout, error, or wrong descriptor\n");
194	(void) fflush(stdout);
195	}
196	}
197	if (no_host) {
198	if (krb_debug)
199	fprintf(stderr, "%s: can't find any Kerberos host.\n",
200	prog);
201	retval = SKDC_CANT;
202	goto rtn;
203	}
204	/* retry each host in sequence */
205	for (retry = 0; retry < CLIENT_KRB_RETRY; ++retry) {
206	for (host = hostlist; host->h_name != (char *)NULL; host++) {
207	to.sin_family = host->h_addrtype;
208	bcopy(host->h_addr, (char *)&to.sin_addr,
209	host->h_length);
210	if (send_recv(pkt, rpkt, f, &to, hostlist)) {
211	retval = KSUCCESS;
212	goto rtn;
213	}
214	}
215	}
216	retval = SKDC_RETRY;
217	rtn:
218	(void) close(f);
219	if (hostlist) {
220	register struct hostent *hp;
221	for (hp = hostlist; hp->h_name; hp++)
222	#if !(defined(ULTRIX022) \|\| (defined(SunOS) && SunOS < 40))
223	if (hp->h_addr_list) {
224	#endif /* ULTRIX022 \|\| SunOS */
225	if (hp->h_addr)
226	free(hp->h_addr);
227	#if !(defined(ULTRIX022) \|\| (defined(SunOS) && SunOS < 40))
228	free((char *)hp->h_addr_list);
229	}
230	#endif /* ULTRIX022 \|\| SunOS */
231	free((char *)hostlist);
232	}
233	return(retval);
234	}
235
236	/*
237	* try to send out and receive message.
238	* return 1 on success, 0 on failure
239	*/
240
241	static send_recv(pkt,rpkt,f,_to,addrs)
242	KTEXT pkt;
243	KTEXT rpkt;
244	int f;
245	struct sockaddr_in *_to;
246	struct hostent *addrs;
247	{
248	fd_set readfds;
249	register struct hostent *hp;
250	struct sockaddr_in from;
251	int sin_size;
252	int numsent;
253
254	if (krb_debug) {
255	if (_to->sin_family == AF_INET)
256	printf("Sending message to %s...",
257	inet_ntoa(_to->sin_addr));
258	else
259	printf("Sending message...");
260	(void) fflush(stdout);
261	}
262	if ((numsent = sendto(f,(char *)(pkt->dat), pkt->length, 0,
263	(struct sockaddr *)_to,
264	S_AD_SZ)) != pkt->length) {
265	if (krb_debug)
266	printf("sent only %d/%d\n",numsent, pkt->length);
267	return 0;
268	}
269	if (krb_debug) {
270	printf("Sent\nWaiting for reply...");
271	(void) fflush(stdout);
272	}
273	FD_ZERO(&readfds);
274	FD_SET(f, &readfds);
275	errno = 0;
276	/* select - either recv is ready, or timeout */
277	/* see if timeout or error or wrong descriptor */
278	if (select(f + 1, &readfds, (fd_set )0, (fd_set )0, &timeout) < 1
279	\|\| !FD_ISSET(f, &readfds)) {
280	if (krb_debug) {
281	fprintf(stderr, "select failed: readfds=%x",
282	readfds);
283	perror("");
284	}
285	return 0;
286	}
287	sin_size = sizeof(from);
288	if (recvfrom(f, (char *)(rpkt->dat), sizeof(rpkt->dat), 0,
289	(struct sockaddr *)&from, &sin_size)
290	< 0) {
291	if (krb_debug)
292	perror("recvfrom");
293	return 0;
294	}
295	if (krb_debug) {
296	printf("received packet from %s\n", inet_ntoa(from.sin_addr));
297	fflush(stdout);
298	}
299	for (hp = addrs; hp->h_name != (char *)NULL; hp++) {
300	if (!bcmp(hp->h_addr, (char *)&from.sin_addr.s_addr,
301	hp->h_length)) {
302	if (krb_debug) {
303	printf("Received it\n");
304	(void) fflush(stdout);
305	}
306	return 1;
307	}
308	if (krb_debug)
309	fprintf(stderr,
310	"packet not from %x\n",
311	hp->h_addr);
312	}
313	if (krb_debug)
314	fprintf(stderr, "%s: received packet from wrong host! (%x)\n",
315	"send_to_kdc(send_rcv)", from.sin_addr.s_addr);
316	return 0;
317	}