/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
* Copyright 1994 by OpenVision Technologies, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appears in all copies and
* that both that copyright notice and this permission notice appear in
* supporting documentation, and that the name of OpenVision not be used
* in advertising or publicity pertaining to distribution of the software
* without specific, written prior permission. OpenVision makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
* OPENVISION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
* EVENT SHALL OPENVISION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
* USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
* OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/*
* Copyright (C) 2003, 2004 by the Massachusetts Institute of Technology.
* All rights reserved.
*
* Export of this software from the United States of America may
* require a specific license from the United States Government.
* It is the responsibility of any person or organization contemplating
* export to obtain such a license before exporting.
*
* WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
* distribute this software and its documentation for any purpose and
* without fee is hereby granted, provided that the above copyright
* notice appear in all copies and that both that copyright notice and
* this permission notice appear in supporting documentation, and that
* the name of M.I.T. not be used in advertising or publicity pertaining
* to distribution of the software without specific, written prior
* permission. Furthermore if you modify this software you must label
* your software as modified software and not distribute it in such a
* fashion that it might be confused with the original M.I.T. software.
* M.I.T. makes no representations about the suitability of
* this software for any purpose. It is provided "as is" without express
* or implied warranty.
*/
#include "autoconf.h"
#include <stdio.h>
#ifdef _WIN32
#include <windows.h>
#include <winsock.h>
#else
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#endif
#include <errno.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <string.h>
/* need struct timeval */
#if HAVE_TIME_H && (!HAVE_SYS_TIME_H || TIME_WITH_SYS_TIME)
# include <time.h>
#endif
#if HAVE_SYS_TIME_H
# include <sys/time.h>
#endif
#include <gssapi/gssapi_generic.h>
#include "gss-misc.h"
/* for store_32_be */
#include "k5-platform.h"
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#else
extern char *malloc();
#endif
FILE *display_file;
gss_buffer_desc empty_token_buf = { 0, (void *)"" };
gss_buffer_t empty_token = &empty_token_buf;
static void display_status_1(char *m, OM_uint32 code, int type);
static int
write_all(int fildes, char *buf, unsigned int nbyte)
{
int ret;
char *ptr;
for (ptr = buf; nbyte; ptr += ret, nbyte -= ret) {
ret = send(fildes, ptr, nbyte, 0);
if (ret < 0) {
if (errno == EINTR)
continue;
return ret;
} else if (ret == 0) {
return ptr - buf;
}
}
return ptr - buf;
}
static int
read_all(int fildes, char *buf, unsigned int nbyte)
{
int ret;
char *ptr;
fd_set rfds;
struct timeval tv;
FD_ZERO(&rfds);
FD_SET(fildes, &rfds);
tv.tv_sec = 10;
tv.tv_usec = 0;
for (ptr = buf; nbyte; ptr += ret, nbyte -= ret) {
if (select(FD_SETSIZE, &rfds, NULL, NULL, &tv) <= 0 ||
!FD_ISSET(fildes, &rfds))
return ptr - buf;
ret = recv(fildes, ptr, nbyte, 0);
if (ret < 0) {
if (errno == EINTR)
continue;
return ret;
} else if (ret == 0) {
return ptr - buf;
}
}
return ptr - buf;
}
/*
* Function: send_token
*
* Purpose: Writes a token to a file descriptor.
*
* Arguments:
*
* s (r) an open file descriptor
* flags (r) the flags to write
* tok (r) the token to write
*
* Returns: 0 on success, -1 on failure
*
* Effects:
*
* If the flags are non-null, send_token writes the token flags (a
* single byte, even though they're passed in in an integer). Next,
* the token length (as a network long) and then the token data are
* written to the file descriptor s. It returns 0 on success, and -1
* if an error occurs or if it could not write all the data.
*/
int
send_token(int s, int flags, gss_buffer_t tok)
{
int ret;
unsigned char char_flags = (unsigned char)flags;
unsigned char lenbuf[4];
if (char_flags) {
ret = write_all(s, (char *)&char_flags, 1);
if (ret != 1) {
perror("sending token flags");
return -1;
}
}
if (tok->length > 0xffffffffUL)
abort();
store_32_be(tok->length, lenbuf);
ret = write_all(s, (char *)lenbuf, 4);
if (ret < 0) {
perror("sending token length");
return -1;
} else if (ret != 4) {
if (display_file) {
fprintf(display_file,
"sending token length: %d of %d bytes written\n", ret, 4);
}
return -1;
}
ret = write_all(s, tok->value, tok->length);
if (ret < 0) {
perror("sending token data");
return -1;
} else if ((size_t)ret != tok->length) {
if (display_file) {
fprintf(display_file,
"sending token data: %d of %d bytes written\n",
ret, (int)tok->length);
}
return -1;
}
return 0;
}
/*
* Function: recv_token
*
* Purpose: Reads a token from a file descriptor.
*
* Arguments:
*
* s (r) an open file descriptor
* flags (w) the read flags
* tok (w) the read token
*
* Returns: 0 on success, -1 on failure
*
* Effects:
*
* recv_token reads the token flags (a single byte, even though
* they're stored into an integer, then reads the token length (as a
* network long), allocates memory to hold the data, and then reads
* the token data from the file descriptor s. It blocks to read the
* length and data, if necessary. On a successful return, the token
* should be freed with gss_release_buffer. It returns 0 on success,
* and -1 if an error occurs or if it could not read all the data.
*/
int
recv_token(int s, int *flags, gss_buffer_t tok)
{
int ret;
unsigned char char_flags;
unsigned char lenbuf[4];
ret = read_all(s, (char *)&char_flags, 1);
if (ret < 0) {
perror("reading token flags");
return -1;
} else if (!ret) {
if (display_file)
fputs("reading token flags: 0 bytes read\n", display_file);
return -1;
} else {
*flags = char_flags;
}
if (char_flags == 0) {
lenbuf[0] = 0;
ret = read_all(s, (char *)&lenbuf[1], 3);
if (ret < 0) {
perror("reading token length");
return -1;
} else if (ret != 3) {
if (display_file) {
fprintf(display_file,
"reading token length: %d of %d bytes read\n", ret, 3);
}
return -1;
}
} else {
ret = read_all(s, (char *)lenbuf, 4);
if (ret < 0) {
perror("reading token length");
return -1;
} else if (ret != 4) {
if (display_file) {
fprintf(display_file,
"reading token length: %d of %d bytes read\n", ret, 4);
}
return -1;
}
}
tok->length = load_32_be(lenbuf);
tok->value = malloc(tok->length ? tok->length : 1);
if (tok->length && tok->value == NULL) {
if (display_file)
fprintf(display_file, "Out of memory allocating token data\n");
return -1;
}
ret = read_all(s, (char *)tok->value, tok->length);
if (ret < 0) {
perror("reading token data");
free(tok->value);
return -1;
} else if ((size_t)ret != tok->length) {
fprintf(stderr, "sending token data: %d of %d bytes written\n",
ret, (int)tok->length);
free(tok->value);
return -1;
}
return 0;
}
static void
display_status_1(char *m, OM_uint32 code, int type)
{
OM_uint32 min_stat;
gss_buffer_desc msg;
OM_uint32 msg_ctx;
msg_ctx = 0;
while (1) {
(void)gss_display_status(&min_stat, code, type, GSS_C_NULL_OID,
&msg_ctx, &msg);
if (display_file) {
fprintf(display_file, "GSS-API error %s: %s\n", m,
(char *)msg.value);
}
(void)gss_release_buffer(&min_stat, &msg);
if (!msg_ctx)
break;
}
}
/*
* Function: display_status
*
* Purpose: displays GSS-API messages
*
* Arguments:
*
* msg a string to be displayed with the message
* maj_stat the GSS-API major status code
* min_stat the GSS-API minor status code
*
* Effects:
*
* The GSS-API messages associated with maj_stat and min_stat are
* displayed on stderr, each preceeded by "GSS-API error <msg>: " and
* followed by a newline.
*/
void
display_status(char *msg, OM_uint32 maj_stat, OM_uint32 min_stat)
{
display_status_1(msg, maj_stat, GSS_C_GSS_CODE);
display_status_1(msg, min_stat, GSS_C_MECH_CODE);
}
/*
* Function: display_ctx_flags
*
* Purpose: displays the flags returned by context initation in
* a human-readable form
*
* Arguments:
*
* int ret_flags
*
* Effects:
*
* Strings corresponding to the context flags are printed on
* stdout, preceded by "context flag: " and followed by a newline
*/
void
display_ctx_flags(OM_uint32 flags)
{
if (flags & GSS_C_DELEG_FLAG)
fprintf(display_file, "context flag: GSS_C_DELEG_FLAG\n");
if (flags & GSS_C_MUTUAL_FLAG)
fprintf(display_file, "context flag: GSS_C_MUTUAL_FLAG\n");
if (flags & GSS_C_REPLAY_FLAG)
fprintf(display_file, "context flag: GSS_C_REPLAY_FLAG\n");
if (flags & GSS_C_SEQUENCE_FLAG)
fprintf(display_file, "context flag: GSS_C_SEQUENCE_FLAG\n");
if (flags & GSS_C_CONF_FLAG)
fprintf(display_file, "context flag: GSS_C_CONF_FLAG \n");
if (flags & GSS_C_INTEG_FLAG)
fprintf(display_file, "context flag: GSS_C_INTEG_FLAG \n");
}
void
print_token(gss_buffer_t tok)
{
size_t i;
unsigned char *p = tok->value;
if (!display_file)
return;
for (i = 0; i < tok->length; i++, p++) {
fprintf(display_file, "%02x ", *p);
if (i % 16 == 15) {
fprintf(display_file, "\n");
}
}
fprintf(display_file, "\n");
fflush(display_file);
}
#ifdef _WIN32
#include <sys\timeb.h>
#include <time.h>
int
gettimeofday(struct timeval *tv, void *ignore_tz)
{
struct _timeb tb;
_tzset();
_ftime(&tb);
if (tv) {
tv->tv_sec = tb.time;
tv->tv_usec = tb.millitm * 1000;
}
return 0;
}
#endif /* _WIN32 */