+2001-06-20 Ezra Peisach <epeisach@mit.edu>
+
+ * kcmd.c: Get rid of prototypes for krb5_write_message(),
+ krb5_net_write(), and krb5_net_read(). They are in krb5.h now.
+
2001-06-18 Ezra Peisach <epeisach@mit.edu>
* krcp.c (sink): Cast argument to isdigit() to int.
#endif
static int do_lencheck;
-/* XXX: These should be internal to krb5 library, or declared in krb5.h. */
-extern krb5_error_code krb5_write_message (krb5_context, krb5_pointer,
- krb5_data *);
-extern int krb5_net_read (krb5_context, int , char *, int);
-extern int krb5_net_write (krb5_context, int , const char *, int);
-/* XXX: And these should be declared in krb.h, or private. */
#ifdef KRB5_KRB4_COMPAT
extern int
krb_sendauth(long options, int fd, KTEXT ticket,
+2001-06-20 Ezra Peisach <epeisach@mit.edu>
+
+ * krb5.hin: Move prototypes for krb5_net_read() and
+ krb5_net_write() here.
+ * k5-int.h: From here.
+
2001-06-19 Ken Raeburn <raeburn@mit.edu>
* k5-int.h (struct addrlist): New type.
/* libos.spec */
krb5_error_code krb5_lock_file (krb5_context, int, int);
krb5_error_code krb5_unlock_file (krb5_context, int);
-int krb5_net_read (krb5_context, int , char *, int);
-int krb5_net_write (krb5_context, int , const char *, int);
krb5_error_code krb5_sendto_kdc (krb5_context, const krb5_data *,
const krb5_data *, krb5_data *, int);
krb5_error_code krb5_get_krbhst (krb5_context, const krb5_data *, char *** );
+2001-06-20 Ezra Peisach <epeisach@mit.edu>
+
+ * krb.h: Add prototype for krb__get_srvtabname() which is invoked
+ in place of KEYFILE.
+ Add prototypes for krb_kntoln(), k_isinst(), k_isname(), k_isrealm().
+
2001-06-11 Ezra Peisach <epeisach@mit.edu>
* krb.h: Add prototype for krb_sendauth().
KRB5_DLLIMP int KRB5_CALLCONV kname_parse
(char FAR *name, char FAR *inst, char FAR *realm,
char FAR *fullname);
+KRB5_DLLIMP int KRB5_CALLCONV k_isname
+ (char FAR *);
+KRB5_DLLIMP int KRB5_CALLCONV k_isinst
+ (char FAR *);
+KRB5_DLLIMP int KRB5_CALLCONV k_isrealm
+ (char FAR *);
+
+
/* kuserok.c */
KRB5_DLLIMP int KRB5_CALLCONV kuserok
(AUTH_DAT FAR *kdata, char FAR *luser);
char *session, int life, long time_sec,
char *sname, char *sinstance, C_Block key);
+extern char * krb__get_srvtabname(const char *);
+
+extern int krb_kntoln(AUTH_DAT *, char *);
+
#ifdef KRB5_GENERAL__
extern int krb_cr_tkt_krb5(KTEXT tkt, unsigned int flags, char *pname,
char *pinstance, char *prealm, long paddress,
krb5_error_code krb5_read_message (krb5_context, krb5_pointer, krb5_data *);
krb5_error_code krb5_write_message (krb5_context, krb5_pointer, krb5_data *);
+int krb5_net_read (krb5_context, int , char *, int);
+int krb5_net_write (krb5_context, int , const char *, int);
KRB5_DLLIMP krb5_error_code KRB5_CALLCONV krb5_read_password
(krb5_context,
+2001-06-20 Ezra Peisach <epeisach@mit.edu>
+
+ * krb524d.c: Include <krb5/adm_proto.h> for krb5_log_init()
+ prototype.
+ (cleanup_and_exit) Conditionalize krb5_kt_close on keytab being
+ non-null.
+
2001-06-20 Mitchell Berger <mitchb@mit.edu>
* krb524d.c: Call krb5_klog_init before the first point where the
#include <krb5.h>
#include <kadm5/admin.h>
+#include <krb5/adm_proto.h>
#include <com_err.h>
#include <stdarg.h>
if (use_master && handle) {
(void) kadm5_destroy(handle);
}
- if (use_keytab) krb5_kt_close(context, kt);
+ if (use_keytab && kt) krb5_kt_close(context, kt);
krb5_free_context(context);
exit(ret);
}
+2001-06-20 Ken Raeburn <raeburn@mit.edu>
+
+ * string2key.c (mit_des_string_to_key_int): Construct a krb5_data
+ object with proper length for the AFS case (indicated by a -1 salt
+ length on input).
+
2001-06-12 Ezra Peisach <epeisach@mit.edu>
* destest.c: main returns int instead of void. Add "const" to
krb5_error_code
mit_des_string_to_key_int (keyblock, data, salt)
-krb5_keyblock FAR * keyblock;
-const krb5_data FAR * data;
-const krb5_data FAR * salt;
+ krb5_keyblock FAR * keyblock;
+ const krb5_data FAR * data;
+ const krb5_data FAR * salt;
{
register krb5_octet *str, *copystr;
register krb5_octet *key;
key = keyblock->contents;
if (salt) {
- if (salt->length == SALT_TYPE_AFS_LENGTH || salt->length == (unsigned) -1) {
- /* cheat and do AFS string2key instead */
- return mit_afs_string_to_key (keyblock, data, salt);
- } else
- length = data->length + salt->length;
- }
- else
+ if (salt->length == SALT_TYPE_AFS_LENGTH || salt->length == (unsigned) -1) {
+ krb5_data salt2;
+ salt2.data = salt->data;
+ salt2.length = strlen (salt2.data);
+ /* cheat and do AFS string2key instead */
+ return mit_afs_string_to_key (keyblock, data, &salt2);
+ } else
+ length = data->length + salt->length;
+ } else
length = data->length;
copystr = malloc((size_t) length);
+2001-06-20 Ezra Peisach <epeisach@mit.edu>
+
+ * acquire_cred.c (acquire_init_cred): Include "k5-int.h" for
+ krb5int-cc_default() prototype.
+
2001-06-18 Ezra Peisach <epeisach@mit.edu>
* accept_sec_context.c acquire_cred.c import_sec_context.c
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*/
+#include "k5-int.h"
#include "gssapiP_krb5.h"
#ifdef HAVE_STRING_H
#include <string.h>
* If there is a facility present, then parse that.
*/
if (cp2) {
- if (!strcasecmp(cp2, "AUTH")) {
- log_control.log_entries[i].lsu_facility = LOG_AUTH;
- }
+ const struct {
+ const char *name;
+ int value;
+ } facilities[] = {
+ { "AUTH", LOG_AUTH },
+#ifdef LOG_AUTHPRIV
+ { "AUTHPRIV", LOG_AUTHPRIV },
+#endif /* LOG_AUTHPRIV */
#ifdef LOG_KERN
- else if (!strcasecmp(cp2, "KERN")) {
- log_control.log_entries[i].lsu_facility = LOG_KERN;
- }
+ { "KERN", LOG_KERN },
#endif /* LOG_KERN */
#ifdef LOG_USER
- else if (!strcasecmp(cp2, "USER")) {
- log_control.log_entries[i].lsu_facility = LOG_USER;
- }
+ { "USER", LOG_USER },
#endif /* LOG_USER */
#ifdef LOG_MAIL
- else if (!strcasecmp(cp2, "MAIL")) {
- log_control.log_entries[i].lsu_facility = LOG_MAIL;
- }
+ { "MAIL", LOG_MAIL },
#endif /* LOG_MAIL */
#ifdef LOG_DAEMON
- else if (!strcasecmp(cp2, "DAEMON")) {
- log_control.log_entries[i].lsu_facility = LOG_DAEMON;
- }
+ { "DAEMON", LOG_DAEMON },
#endif /* LOG_DAEMON */
+#ifdef LOG_FTP
+ { "FTP", LOG_FTP },
+#endif /* LOG_FTP */
#ifdef LOG_LPR
- else if (!strcasecmp(cp2, "LPR")) {
- log_control.log_entries[i].lsu_facility = LOG_LPR;
- }
+ { "LPR", LOG_LPR },
#endif /* LOG_LPR */
#ifdef LOG_NEWS
- else if (!strcasecmp(cp2, "NEWS")) {
- log_control.log_entries[i].lsu_facility = LOG_NEWS;
- }
+ { "NEWS", LOG_NEWS },
#endif /* LOG_NEWS */
#ifdef LOG_UUCP
- else if (!strcasecmp(cp2, "UUCP")) {
- log_control.log_entries[i].lsu_facility = LOG_UUCP;
- }
+ { "UUCP", LOG_UUCP },
#endif /* LOG_UUCP */
#ifdef LOG_CRON
- else if (!strcasecmp(cp2, "CRON")) {
- log_control.log_entries[i].lsu_facility = LOG_CRON;
- }
+ { "CRON", LOG_CRON },
#endif /* LOG_CRON */
#ifdef LOG_LOCAL0
- else if (!strcasecmp(cp2, "LOCAL0")) {
- log_control.log_entries[i].lsu_facility = LOG_LOCAL0;
- }
+ { "LOCAL0", LOG_LOCAL0 },
#endif /* LOG_LOCAL0 */
#ifdef LOG_LOCAL1
- else if (!strcasecmp(cp2, "LOCAL1")) {
- log_control.log_entries[i].lsu_facility = LOG_LOCAL1;
- }
+ { "LOCAL1", LOG_LOCAL1 },
#endif /* LOG_LOCAL1 */
#ifdef LOG_LOCAL2
- else if (!strcasecmp(cp2, "LOCAL2")) {
- log_control.log_entries[i].lsu_facility = LOG_LOCAL2;
- }
+ { "LOCAL2", LOG_LOCAL2 },
#endif /* LOG_LOCAL2 */
#ifdef LOG_LOCAL3
- else if (!strcasecmp(cp2, "LOCAL3")) {
- log_control.log_entries[i].lsu_facility = LOG_LOCAL3;
- }
+ { "LOCAL3", LOG_LOCAL3 },
#endif /* LOG_LOCAL3 */
#ifdef LOG_LOCAL4
- else if (!strcasecmp(cp2, "LOCAL4")) {
- log_control.log_entries[i].lsu_facility = LOG_LOCAL4;
- }
+ { "LOCAL4", LOG_LOCAL4 },
#endif /* LOG_LOCAL4 */
#ifdef LOG_LOCAL5
- else if (!strcasecmp(cp2, "LOCAL5")) {
- log_control.log_entries[i].lsu_facility = LOG_LOCAL5;
- }
+ { "LOCAL5", LOG_LOCAL5 },
#endif /* LOG_LOCAL5 */
#ifdef LOG_LOCAL6
- else if (!strcasecmp(cp2, "LOCAL6")) {
- log_control.log_entries[i].lsu_facility = LOG_LOCAL6;
- }
+ { "LOCAL6", LOG_LOCAL6 },
#endif /* LOG_LOCAL6 */
#ifdef LOG_LOCAL7
- else if (!strcasecmp(cp2, "LOCAL7")) {
- log_control.log_entries[i].lsu_facility = LOG_LOCAL7;
- }
+ { "LOCAL7", LOG_LOCAL7 },
#endif /* LOG_LOCAL7 */
+ };
+ int j;
+
+ for (j = 0; j < sizeof(facilities)/sizeof(facilities[0]); j++)
+ if (!strcasecmp(cp2, facilities[j].name)) {
+ log_control.log_entries[i].lsu_facility = facilities[j].value;
+ break;
+ }
cp2--;
*cp2 = savec;
}
+
+2001-06-20 Ezra Peisach <epeisach@mit.edu>
+
+ * kname_parse.c (k_isrealm, k_isname, k_isrealm): Add
+ KRB5_DLLIMP/KRB5_CALLCONV definitions for function with exported
+ prototype in krb.h.
+
+ * g_cnffile.c (krb__get_srvtabname, krb__v5_get_file): Declare
+ argument as const.
+
+ * g_svc_in_tkt.c, put_svc_key.c, rd_req.c, rd_svc_key.c: Get rid
+ of krb__get_srvtabname() prototype - in krb.h now.
+
+
2001-06-18 Ezra Peisach <epeisach@mit.edu>
* kparse.c (strutol): Cast argument to isupper()/tolower() to int.
static FILE*
krb__v5_get_file(s)
- char *s;
+ const char *s;
{
FILE *cnffile = 0;
const char* names[3];
char *
krb__get_srvtabname(default_srvtabname)
- char *default_srvtabname;
+ const char *default_srvtabname;
{
const char* names[3];
char **full_name = 0, **cpp;
#define NULL 0
#endif
-extern char *krb__get_srvtabname();
-
/*
* This file contains two routines: srvtab_to_key(), which gets
* a server's key from a srvtab file, and krb_get_svc_in_tkt() which
* Kerberos name; returns 0 if it's not.
*/
-int
+KRB5_DLLIMP int KRB5_CALLCONV
k_isname(s)
- char *s;
+ char FAR *s;
{
register char c;
int backslash = 0;
* We now allow periods in instance names -- they are unambiguous.
*/
-int
+KRB5_DLLIMP int KRB5_CALLCONV
k_isinst(s)
- char *s;
+ char FAR *s;
{
register char c;
int backslash = 0;
* Kerberos realm; returns 0 if it's not.
*/
-int
+KRB5_DLLIMP int KRB5_CALLCONV
k_isrealm(s)
- char *s;
+ char FAR *s;
{
register char c;
int backslash = 0;
#include <unistd.h>
#endif
-extern char *krb__get_srvtabname();
-
#define KEYSZ sizeof(C_Block)
/* strict put_svc_key.
The srvtab must already exist;
extern int krb_ap_req_debug;
-extern char *krb__get_srvtabname();
-
/* declared in krb.h */
int krb_ignore_ip_address = 0;
#include <krb54proto.h>
#include "prot.h"
-extern char *krb__get_srvtabname();
-
/*
* The private keys for servers on a given host are stored in a
* "srvtab" file (typically "/etc/srvtab"). This routine extracts
+2001-06-20 Ezra Peisach <epeisach@mit.edu>
+
+ * Makefile.in (check-unix): Add $(RUN_SETUP) before invocation of
+ transit-tests for shared library environment variables.
+
2001-06-19 Ken Raeburn <raeburn@mit.edu>
* chk_trans.c: Reimplemented from scratch.
KRB5_CONFIG=$(srcdir)/t_krb5.conf ; export KRB5_CONFIG ;\
$(RUN_SETUP) ./t_ser
./t_deltat
- sh $(srcdir)/transit-tests
+ $(RUN_SETUP) sh $(srcdir)/transit-tests
clean::
$(RM) $(OUTPRE)t_walk_rtree$(EXEEXT) $(OUTPRE)t_walk_rtree.$(OBJEXT) \
+2001-06-20 Ezra Peisach <epeisach@mit.edu>
+
+ * t_std_conf.c (test_locate_kdc): Update to new krb5_locate_kdc
+ interface.
+
2001-06-19 Ken Raeburn <raeburn@mit.edu>
* locate_kdc.c (struct addrlist, ADDRLIST_INIT): Moved to
* os-proto.h (krb5_locate_kdc): Update prototype.
- * t_std_conf.c (test_locate_kdc): Update tests for new API.
-
2001-06-12 Ezra Peisach <epeisach@mit.edu>
* sn2princ.c, hst_realm.c, an_to_ln.c: Cast argument to
krb5_context ctx;
char *realm;
{
- struct sockaddr **addrs;
+ struct addrlist addrs;
struct sockaddr_in *s_sin;
int i, naddrs;
int get_masters=0;
rlm.data = realm;
rlm.length = strlen(realm);
- retval = krb5_locate_kdc(ctx, &rlm, &addrs, &naddrs,
- get_masters);
+ retval = krb5_locate_kdc(ctx, &rlm, &addrs, get_masters);
if (retval) {
com_err("krb5_locate_kdc", retval, 0);
return;
}
printf("krb_locate_kdc(%s) returned:", realm);
- for (i=0; i < naddrs; i++) {
- s_sin = (struct sockaddr_in *) addrs[i];
+ for (i=0; i < addrs.naddrs; i++) {
+ s_sin = (struct sockaddr_in *) addrs.addrs[i];
printf(" %s/%d", inet_ntoa(s_sin->sin_addr),
ntohs(s_sin->sin_port));
}
- free(addrs);
+ krb5int_free_addrlist(&addrs);
printf("\n");
}
+2001-06-20 Danilo Almeida <dalmeida@mit.edu>
+
+ * rc_dfl.c, rc_io.c: More compliance with coding standards: use
+ ANSI function declarations, use curly braces to fix up #ifdef
+ reindenting under Emacs, reindent code, strip trailing whitespace,
+ wrap lines, fix commans. Not finished: fix indenting of curly
+ braces in control structures.
+
2001-01-23 Tom Yu <tlyu@mit.edu>
* rc_io.c (getdir): Subtract one from dirlen, since sizeof
#include <k5-int.h>
/*
-If NOIOSTUFF is defined at compile time, dfl rcaches will be per-process.
-*/
+ * If NOIOSTUFF is defined at compile time, dfl rcaches will be per-process.
+ */
/*
Local stuff:
-static int hash(krb5_donot_replay *rep,int hsize)
+static int hash(krb5_donot_replay *rep, int hsize)
returns hash value of *rep, between 0 and hsize - 1
HASHSIZE
size of hash table (constant), can be preset
-static int cmp(krb5_donot_replay *old,krb5_donot_replay *new,krb5_deltat t)
+static int cmp(krb5_donot_replay *old, krb5_donot_replay *new, krb5_deltat t)
compare old and new; return CMP_REPLAY or CMP_HOHUM
-static int alive (krb5_context, krb5_donot_replay *new,krb5_deltat t)
+static int alive(krb5_context, krb5_donot_replay *new, krb5_deltat t)
see if new is still alive; return CMP_EXPIRED or CMP_HOHUM
CMP_MALLOC, CMP_EXPIRED, CMP_REPLAY, CMP_HOHUM
return codes from cmp(), alive(), and store()
data stored in this cache type, namely "dfl"
struct authlist
multilinked list of reps
-static int rc_store(context, krb5_rcache id,krb5_donot_replay *rep)
+static int rc_store(context, krb5_rcache id, krb5_donot_replay *rep)
store rep in cache id; return CMP_REPLAY if replay, else CMP_MALLOC/CMP_HOHUM
*/
#ifndef EXCESSREPS
#define EXCESSREPS 30
#endif
-/* The rcache will be automatically expunged when the number of expired
-krb5_donot_replays encountered incidentally in searching exceeds the number
-of live krb5_donot_replays by EXCESSREPS. With the defaults here, a typical
-cache might build up some 10K of expired krb5_donot_replays before an automatic
-expunge, with the waste basically independent of the number of stores per
-minute.
-
-The rcache will also automatically be expunged when it encounters more
-than EXCESSREPS expired entries when recovering a cache in
-dfl_recover. */
-
-static int hash(rep, hsize)
-krb5_donot_replay *rep;
-int hsize;
+
+/*
+ * The rcache will be automatically expunged when the number of
+ * expired krb5_donot_replays encountered incidentally in searching
+ * exceeds the number of live krb5_donot_replays by EXCESSREPS. With
+ * the defaults here, a typical cache might build up some 10K of
+ * expired krb5_donot_replays before an automatic expunge, with the
+ * waste basically independent of the number of stores per minute.
+ *
+ * The rcache will also automatically be expunged when it encounters
+ * more than EXCESSREPS expired entries when recovering a cache in
+ * dfl_recover.
+ */
+
+static int
+hash(krb5_donot_replay *rep, int hsize)
{
- return (int) ((((rep->cusec + rep->ctime + *rep->server + *rep->client)
- % hsize) + hsize) % hsize);
- /* We take this opportunity to once again complain about C's idiotic %. */
+ return (int) ((((rep->cusec + rep->ctime + *rep->server + *rep->client)
+ % hsize) + hsize) % hsize);
+ /* We take this opportunity to once again complain about C's idiotic %. */
}
#define CMP_MALLOC -3
#define CMP_HOHUM 0
/*ARGSUSED*/
-static int cmp(old, new, t)
-krb5_donot_replay *old;
-krb5_donot_replay *new;
-krb5_deltat t;
+static int
+cmp(krb5_donot_replay *old, krb5_donot_replay *new, krb5_deltat t)
{
- if ((old->cusec == new->cusec) && /* most likely to distinguish */
- (old->ctime == new->ctime) &&
- (strcmp(old->client,new->client) == 0) &&
- (strcmp(old->server,new->server) == 0)) /* always true */
- return CMP_REPLAY;
- return CMP_HOHUM;
+ if ((old->cusec == new->cusec) && /* most likely to distinguish */
+ (old->ctime == new->ctime) &&
+ (strcmp(old->client, new->client) == 0) &&
+ (strcmp(old->server, new->server) == 0)) /* always true */
+ return CMP_REPLAY;
+ return CMP_HOHUM;
}
-static int alive(context, new, t)
- krb5_context context;
- krb5_donot_replay *new;
- krb5_deltat t;
+static int
+alive(krb5_context context, krb5_donot_replay *new, krb5_deltat t)
{
- krb5_int32 mytime;
-
- if (krb5_timeofday(context, &mytime))
- return CMP_HOHUM; /* who cares? */
- if (new->ctime + t < mytime) /* I hope we don't have to worry about overflow */
- return CMP_EXPIRED;
- return CMP_HOHUM;
+ krb5_int32 mytime;
+
+ if (krb5_timeofday(context, &mytime))
+ return CMP_HOHUM; /* who cares? */
+ /* I hope we don't have to worry about overflow */
+ if (new->ctime + t < mytime)
+ return CMP_EXPIRED;
+ return CMP_HOHUM;
}
struct dfl_data
- {
- char *name;
- krb5_deltat lifespan;
- int hsize;
- int numhits;
- int nummisses;
- struct authlist **h;
- struct authlist *a;
+{
+ char *name;
+ krb5_deltat lifespan;
+ int hsize;
+ int numhits;
+ int nummisses;
+ struct authlist **h;
+ struct authlist *a;
#ifndef NOIOSTUFF
- krb5_rc_iostuff d;
+ krb5_rc_iostuff d;
#endif
- char recovering;
- }
-;
+ char recovering;
+};
struct authlist
- {
- krb5_donot_replay rep;
- struct authlist *na;
- struct authlist *nh;
- }
-;
+{
+ krb5_donot_replay rep;
+ struct authlist *na;
+ struct authlist *nh;
+};
/* of course, list is backwards from file */
/* hash could be forwards since we have to search on match, but naaaah */
-static int rc_store(context, id, rep)
- krb5_context context;
- krb5_rcache id;
- krb5_donot_replay *rep;
+static int
+rc_store(krb5_context context, krb5_rcache id, krb5_donot_replay *rep)
{
- struct dfl_data *t = (struct dfl_data *)id->data;
- int rephash;
- struct authlist *ta;
-
- rephash = hash(rep,t->hsize);
+ struct dfl_data *t = (struct dfl_data *)id->data;
+ int rephash;
+ struct authlist *ta;
+
+ rephash = hash(rep, t->hsize);
+
+ for (ta = t->h[rephash]; ta; ta = ta->nh) {
+ switch(cmp(&ta->rep, rep, t->lifespan))
+ {
+ case CMP_REPLAY:
+ return CMP_REPLAY;
+ case CMP_HOHUM:
+ if (alive(context, &ta->rep, t->lifespan) == CMP_EXPIRED)
+ t->nummisses++;
+ else
+ t->numhits++;
+ break;
+ default:
+ ; /* wtf? */
+ }
+ }
- for (ta = t->h[rephash];ta;ta = ta->nh)
- switch(cmp(&ta->rep,rep,t->lifespan))
- {
- case CMP_REPLAY: return CMP_REPLAY;
- case CMP_HOHUM: if (alive(context, &ta->rep,t->lifespan) == CMP_EXPIRED)
- t->nummisses++;
- else
- t->numhits++;
- break;
- default: ; /* wtf? */
+ if (!(ta = (struct authlist *) malloc(sizeof(struct authlist))))
+ return CMP_MALLOC;
+ ta->na = t->a; t->a = ta;
+ ta->nh = t->h[rephash]; t->h[rephash] = ta;
+ ta->rep = *rep;
+ if (!(ta->rep.client = strdup(rep->client))) {
+ FREE(ta);
+ return CMP_MALLOC;
+ }
+ if (!(ta->rep.server = strdup(rep->server))) {
+ FREE(ta->rep.client);
+ FREE(ta);
+ return CMP_MALLOC;
}
- if (!(ta = (struct authlist *) malloc(sizeof(struct authlist))))
- return CMP_MALLOC;
- ta->na = t->a; t->a = ta;
- ta->nh = t->h[rephash]; t->h[rephash] = ta;
- ta->rep = *rep;
- if (!(ta->rep.client = strdup(rep->client))) {
- FREE(ta);
- return CMP_MALLOC;
- }
- if (!(ta->rep.server = strdup(rep->server))) {
- FREE(ta->rep.client);
- FREE(ta);
- return CMP_MALLOC;
- }
-
- return CMP_HOHUM;
+ return CMP_HOHUM;
}
char * KRB5_CALLCONV
-krb5_rc_dfl_get_name(context, id)
- krb5_context context;
- krb5_rcache id;
+krb5_rc_dfl_get_name(krb5_context context, krb5_rcache id)
{
- return ((struct dfl_data *) (id->data))->name;
+ return ((struct dfl_data *) (id->data))->name;
}
krb5_error_code KRB5_CALLCONV
-krb5_rc_dfl_get_span(context, id, lifespan)
- krb5_context context;
- krb5_rcache id;
- krb5_deltat *lifespan;
+krb5_rc_dfl_get_span(krb5_context context, krb5_rcache id,
+ krb5_deltat *lifespan)
{
- *lifespan = ((struct dfl_data *) (id->data))->lifespan;
- return 0;
+ *lifespan = ((struct dfl_data *) (id->data))->lifespan;
+ return 0;
}
krb5_error_code KRB5_CALLCONV
-krb5_rc_dfl_init(context, id, lifespan)
- krb5_context context;
-krb5_rcache id;
-krb5_deltat lifespan;
+krb5_rc_dfl_init(krb5_context context, krb5_rcache id, krb5_deltat lifespan)
{
struct dfl_data *t = (struct dfl_data *)id->data;
krb5_error_code retval;
t->lifespan = lifespan ? lifespan : context->clockskew;
/* default to clockskew from the context */
#ifndef NOIOSTUFF
- if ((retval = krb5_rc_io_creat(context, &t->d,&t->name)))
+ if ((retval = krb5_rc_io_creat(context, &t->d, &t->name)))
return retval;
if ((krb5_rc_io_write(context, &t->d,
(krb5_pointer) &t->lifespan, sizeof(t->lifespan))
return 0;
}
-krb5_error_code krb5_rc_dfl_close_no_free(context, id)
- krb5_context context;
- krb5_rcache id;
+krb5_error_code
+krb5_rc_dfl_close_no_free(krb5_context context, krb5_rcache id)
{
- struct dfl_data *t = (struct dfl_data *)id->data;
- struct authlist *q;
-
- FREE(t->h);
- if (t->name)
- FREE(t->name);
- while ((q = t->a))
- {
- t->a = q->na;
- FREE(q->rep.client);
- FREE(q->rep.server);
- FREE(q);
- }
+ struct dfl_data *t = (struct dfl_data *)id->data;
+ struct authlist *q;
+
+ FREE(t->h);
+ if (t->name)
+ FREE(t->name);
+ while ((q = t->a))
+ {
+ t->a = q->na;
+ FREE(q->rep.client);
+ FREE(q->rep.server);
+ FREE(q);
+ }
#ifndef NOIOSTUFF
- if (t->d.fd >= 0)
- (void) krb5_rc_io_close(context, &t->d);
+ if (t->d.fd >= 0)
+ (void) krb5_rc_io_close(context, &t->d);
#endif
- FREE(t);
- return 0;
+ FREE(t);
+ return 0;
}
krb5_error_code KRB5_CALLCONV
-krb5_rc_dfl_close(context, id)
- krb5_context context;
- krb5_rcache id;
+krb5_rc_dfl_close(krb5_context context, krb5_rcache id)
{
krb5_rc_dfl_close_no_free(context, id);
free(id);
}
krb5_error_code KRB5_CALLCONV
-krb5_rc_dfl_destroy(context, id)
- krb5_context context;
-krb5_rcache id;
+krb5_rc_dfl_destroy(krb5_context context, krb5_rcache id)
{
#ifndef NOIOSTUFF
- if (krb5_rc_io_destroy(context, &((struct dfl_data *) (id->data))->d))
- return KRB5_RC_IO;
+ if (krb5_rc_io_destroy(context, &((struct dfl_data *) (id->data))->d))
+ return KRB5_RC_IO;
#endif
- return krb5_rc_dfl_close(context, id);
+ return krb5_rc_dfl_close(context, id);
}
krb5_error_code KRB5_CALLCONV
-krb5_rc_dfl_resolve(context, id, name)
- krb5_context context;
- krb5_rcache id;
- char *name;
+krb5_rc_dfl_resolve(krb5_context context, krb5_rcache id, char *name)
{
struct dfl_data *t = 0;
krb5_error_code retval;
#endif
t->recovering = 0;
return 0;
-
+
cleanup:
if (t) {
if (t->name)
return retval;
}
-void krb5_rc_free_entry (context, rep)
- krb5_context context;
- krb5_donot_replay **rep;
+void
+krb5_rc_free_entry(krb5_context context, krb5_donot_replay **rep)
{
krb5_donot_replay *rp = *rep;
-
+
*rep = NULL;
- if (rp)
+ if (rp)
{
if (rp->client)
free(rp->client);
}
}
-static krb5_error_code krb5_rc_io_fetch(context, t, rep, maxlen)
- krb5_context context;
- struct dfl_data *t;
- krb5_donot_replay *rep;
- int maxlen;
+static krb5_error_code
+krb5_rc_io_fetch(krb5_context context, struct dfl_data *t,
+ krb5_donot_replay *rep, int maxlen)
{
int len;
krb5_error_code retval;
rep->client = rep->server = 0;
-
- retval = krb5_rc_io_read (context, &t->d, (krb5_pointer) &len, sizeof(len));
- if (retval)
+
+ retval = krb5_rc_io_read(context, &t->d, (krb5_pointer) &len, sizeof(len));
+ if (retval)
return retval;
-
+
if ((len <= 0) || (len >= maxlen))
return KRB5_RC_IO_EOF;
rep->client = malloc (len);
if (!rep->client)
return KRB5_RC_MALLOC;
-
- retval = krb5_rc_io_read (context, &t->d, (krb5_pointer) rep->client, len);
+
+ retval = krb5_rc_io_read(context, &t->d, (krb5_pointer) rep->client, len);
if (retval)
goto errout;
-
- retval = krb5_rc_io_read (context, &t->d, (krb5_pointer) &len, sizeof(len));
+
+ retval = krb5_rc_io_read(context, &t->d, (krb5_pointer) &len, sizeof(len));
if (retval)
goto errout;
-
+
if ((len <= 0) || (len >= maxlen)) {
retval = KRB5_RC_IO_EOF;
goto errout;
retval = KRB5_RC_MALLOC;
goto errout;
}
-
- retval = krb5_rc_io_read (context, &t->d, (krb5_pointer) rep->server, len);
+
+ retval = krb5_rc_io_read(context, &t->d, (krb5_pointer) rep->server, len);
if (retval)
goto errout;
-
- retval = krb5_rc_io_read (context, &t->d, (krb5_pointer) &rep->cusec, sizeof(rep->cusec));
+
+ retval = krb5_rc_io_read(context, &t->d, (krb5_pointer) &rep->cusec,
+ sizeof(rep->cusec));
if (retval)
goto errout;
-
- retval = krb5_rc_io_read (context, &t->d, (krb5_pointer) &rep->ctime, sizeof(rep->ctime));
+
+ retval = krb5_rc_io_read(context, &t->d, (krb5_pointer) &rep->ctime,
+ sizeof(rep->ctime));
if (retval)
goto errout;
return 0;
-
+
errout:
if (rep->client)
krb5_xfree(rep->client);
rep->client = rep->server = 0;
return retval;
}
-
+
krb5_error_code KRB5_CALLCONV
-krb5_rc_dfl_recover(context, id)
- krb5_context context;
-krb5_rcache id;
+krb5_rc_dfl_recover(krb5_context context, krb5_rcache id)
{
#ifdef NOIOSTUFF
return KRB5_RC_NOIO;
return retval;
t->recovering = 1;
-
+
max_size = krb5_rc_io_size(context, &t->d);
-
+
rep = NULL;
- if (krb5_rc_io_read(context, &t->d,(krb5_pointer) &t->lifespan,sizeof(t->lifespan))) {
+ if (krb5_rc_io_read(context, &t->d, (krb5_pointer) &t->lifespan,
+ sizeof(t->lifespan))) {
retval = KRB5_RC_IO;
goto io_fail;
}
retval = KRB5_RC_IO;
goto io_fail;
}
-
- retval = krb5_rc_io_fetch (context, t, rep, (int) max_size);
+
+ retval = krb5_rc_io_fetch(context, t, rep, (int) max_size);
if (retval == KRB5_RC_IO_EOF)
break;
else if (retval != 0)
goto io_fail;
-
- if (alive(context, rep,t->lifespan) != CMP_EXPIRED) {
+
+ if (alive(context, rep, t->lifespan) != CMP_EXPIRED) {
if (rc_store(context, id, rep) == CMP_MALLOC) {
retval = KRB5_RC_MALLOC; goto io_fail;
- }
+ }
} else {
expired_entries++;
}
retval = krb5_rc_dfl_expunge(context, id);
t->recovering = 0;
return retval;
-
+
#endif
}
static krb5_error_code
-krb5_rc_io_store (context, t, rep)
- krb5_context context;
- struct dfl_data *t;
- krb5_donot_replay *rep;
+krb5_rc_io_store(krb5_context context, struct dfl_data *t,
+ krb5_donot_replay *rep)
{
unsigned int clientlen, serverlen, len;
char *buf, *ptr;
krb5_error_code ret;
- clientlen = strlen (rep->client) + 1;
- serverlen = strlen (rep->server) + 1;
+ clientlen = strlen(rep->client) + 1;
+ serverlen = strlen(rep->server) + 1;
len = sizeof(clientlen) + clientlen + sizeof(serverlen) + serverlen +
sizeof(rep->cusec) + sizeof(rep->ctime);
- buf = malloc (len);
+ buf = malloc(len);
if (buf == 0)
return KRB5_RC_MALLOC;
ptr = buf;
}
krb5_error_code KRB5_CALLCONV
-krb5_rc_dfl_store(context, id, rep)
- krb5_context context;
-krb5_rcache id;
-krb5_donot_replay *rep;
+krb5_rc_dfl_store(krb5_context context, krb5_rcache id, krb5_donot_replay *rep)
{
krb5_error_code ret;
struct dfl_data *t = (struct dfl_data *)id->data;
- switch(rc_store(context, id,rep)) {
+ switch(rc_store(context, id, rep)) {
case CMP_MALLOC:
- return KRB5_RC_MALLOC;
+ return KRB5_RC_MALLOC;
case CMP_REPLAY:
- return KRB5KRB_AP_ERR_REPEAT;
+ return KRB5KRB_AP_ERR_REPEAT;
case 0: break;
default: /* wtf? */ ;
}
#ifndef NOIOSTUFF
- ret = krb5_rc_io_store (context, t, rep);
+ ret = krb5_rc_io_store(context, t, rep);
if (ret)
return ret;
#endif
- /* Shall we automatically expunge? */
- if (t->nummisses > t->numhits + EXCESSREPS)
+ /* Shall we automatically expunge? */
+ if (t->nummisses > t->numhits + EXCESSREPS)
{
- return krb5_rc_dfl_expunge(context, id);
+ return krb5_rc_dfl_expunge(context, id);
}
#ifndef NOIOSTUFF
else
return KRB5_RC_IO;
}
#endif
- return 0;
+ return 0;
}
krb5_error_code KRB5_CALLCONV
-krb5_rc_dfl_expunge(context, id)
- krb5_context context;
-krb5_rcache id;
+krb5_rc_dfl_expunge(krb5_context context, krb5_rcache id)
{
struct dfl_data *t = (struct dfl_data *)id->data;
#ifdef NOIOSTUFF
struct authlist *r;
struct authlist *rt;
- for (q = &t->a;*q;q = qt) {
+ for (q = &t->a; *q; q = qt) {
qt = &(*q)->na;
- if (alive(context, &(*q)->rep,t->lifespan) == CMP_EXPIRED) {
+ if (alive(context, &(*q)->rep, t->lifespan) == CMP_EXPIRED) {
FREE((*q)->rep.client);
FREE((*q)->rep.server);
FREE(*q);
*q = *qt; /* why doesn't this feel right? */
}
}
- for (i = 0;i < t->hsize;i++)
+ for (i = 0; i < t->hsize; i++)
t->h[i] = (struct authlist *) 0;
- for (r = t->a;r;r = r->na) {
- i = hash(&r->rep,t->hsize);
+ for (r = t->a; r; r = r->na) {
+ i = hash(&r->rep, t->hsize);
rt = t->h[i];
t->h[i] = r;
r->nh = rt;
}
-
+
#else
struct authlist *q;
char *name;
if (! t->recovering) {
name = t->name;
t->name = 0; /* Clear name so it isn't freed */
- (void) krb5_rc_dfl_close_no_free(context, id);
- retval = krb5_rc_dfl_resolve(context, id, name);
+ (void) krb5_rc_dfl_close_no_free(context, id);
+ retval = krb5_rc_dfl_resolve(context, id, name);
free(name);
if (retval)
return retval;
retval = krb5_rc_initialize(context, tmp, lifespan);
if (retval)
return retval;
- for (q = t->a;q;q = q->na) {
- if (krb5_rc_io_store (context, (struct dfl_data *)tmp->data, &q->rep))
+ for (q = t->a; q; q = q->na) {
+ if (krb5_rc_io_store(context, (struct dfl_data *)tmp->data, &q->rep))
return KRB5_RC_IO;
}
if (krb5_rc_io_sync(context, &t->d))
return KRB5_RC_IO;
if (krb5_rc_io_move(context, &t->d, &((struct dfl_data *)tmp->data)->d))
return KRB5_RC_IO;
- (void) krb5_rc_dfl_close(context, tmp);
+ (void) krb5_rc_dfl_close(context, tmp);
#endif
return 0;
}
#define KRB5_RC_VNO 0x0501 /* krb5, rcache v 1 */
#define NEED_SOCKETS
-#define NEED_LOWLEVEL_IO
+#define NEED_LOWLEVEL_IO
#include <krb5.h>
#include <stdio.h> /* for P_tmpdir */
#include <netinet/in.h>
#endif
#else
- #error find some way to use net-byte-order file version numbers.
+#error find some way to use net-byte-order file version numbers.
#endif
#ifndef HAVE_ERRNO
#define GETDIR do { if (!dirlen) getdir(); } while(0)
-static void getdir()
+static void
+getdir()
{
- if (!(dir = getenv("KRB5RCACHEDIR")))
+ if (!(dir = getenv("KRB5RCACHEDIR"))) {
#if defined(_MSDOS) || defined(_WIN32)
- if (!(dir = getenv("TEMP")))
- if (!(dir = getenv("TMP")))
- dir = "C:";
+ if (!(dir = getenv("TEMP")))
+ if (!(dir = getenv("TMP")))
+ dir = "C:";
#else
- if (!(dir = getenv("TMPDIR")))
+ if (!(dir = getenv("TMPDIR"))) {
#ifdef RCTMPDIR
- dir = RCTMPDIR;
+ dir = RCTMPDIR;
#else
- dir = "/tmp";
+ dir = "/tmp";
#endif
+ }
#endif
- dirlen = strlen(dir) + sizeof(PATH_SEPARATOR) - 1;
+ }
+ dirlen = strlen(dir) + sizeof(PATH_SEPARATOR) - 1;
}
-krb5_error_code krb5_rc_io_creat (context, d, fn)
- krb5_context context;
- krb5_rc_iostuff *d;
- char **fn;
+krb5_error_code
+krb5_rc_io_creat(krb5_context context, krb5_rc_iostuff *d, char **fn)
{
- char *c;
- krb5_int16 rc_vno = htons(KRB5_RC_VNO);
- krb5_error_code retval;
-
- GETDIR;
- if (fn && *fn)
- {
- if (!(d->fn = malloc(strlen(*fn) + dirlen + 1)))
- return KRB5_RC_IO_MALLOC;
- (void) strcpy(d->fn,dir);
- (void) strcat(d->fn,PATH_SEPARATOR);
- (void) strcat(d->fn,*fn);
- d->fd = THREEPARAMOPEN(d->fn,O_WRONLY | O_CREAT | O_TRUNC | O_EXCL | O_BINARY,0600);
- }
- else
- {
- /* %d is max 11 digits (-, 10 digits of 32-bit number)
- * 11 + /krb5_RC + aaa = 24, +6 for slop */
- if (!(d->fn = malloc(30 + dirlen)))
- return KRB5_RC_IO_MALLOC;
- if (fn)
- if (!(*fn = malloc(35)))
- { FREE(d->fn); return KRB5_RC_IO_MALLOC; }
- (void) sprintf(d->fn,"%s%skrb5_RC%d",dir,PATH_SEPARATOR, (int) UNIQUE);
- c = d->fn + strlen(d->fn);
- (void) strcpy(c,"aaa");
- while ((d->fd = THREEPARAMOPEN(d->fn,O_WRONLY|O_CREAT|O_TRUNC|O_EXCL|O_BINARY,0600)) == -1)
+ char *c;
+ krb5_int16 rc_vno = htons(KRB5_RC_VNO);
+ krb5_error_code retval;
+
+ GETDIR;
+ if (fn && *fn)
{
- if ((c[2]++) == 'z')
- {
- c[2] = 'a';
- if ((c[1]++) == 'z')
- {
- c[1] = 'a';
- if ((c[0]++) == 'z')
- break; /* sigh */
- }
- }
+ if (!(d->fn = malloc(strlen(*fn) + dirlen + 1)))
+ return KRB5_RC_IO_MALLOC;
+ (void) strcpy(d->fn, dir);
+ (void) strcat(d->fn, PATH_SEPARATOR);
+ (void) strcat(d->fn, *fn);
+ d->fd = THREEPARAMOPEN(d->fn, O_WRONLY | O_CREAT | O_TRUNC | O_EXCL |
+ O_BINARY, 0600);
}
- if (fn)
- (void) strcpy(*fn,d->fn + dirlen);
- }
- if (d->fd == -1)
+ else
{
- switch(errno)
+ /* %d is max 11 digits (-, 10 digits of 32-bit number)
+ * 11 + /krb5_RC + aaa = 24, +6 for slop */
+ if (!(d->fn = malloc(30 + dirlen)))
+ return KRB5_RC_IO_MALLOC;
+ if (fn)
+ if (!(*fn = malloc(35))) {
+ FREE(d->fn);
+ return KRB5_RC_IO_MALLOC;
+ }
+ (void) sprintf(d->fn, "%s%skrb5_RC%d", dir, PATH_SEPARATOR,
+ (int) UNIQUE);
+ c = d->fn + strlen(d->fn);
+ (void) strcpy(c, "aaa");
+ while ((d->fd = THREEPARAMOPEN(d->fn, O_WRONLY | O_CREAT | O_TRUNC |
+ O_EXCL | O_BINARY, 0600)) == -1)
+ {
+ if ((c[2]++) == 'z')
+ {
+ c[2] = 'a';
+ if ((c[1]++) == 'z')
+ {
+ c[1] = 'a';
+ if ((c[0]++) == 'z')
+ break; /* sigh */
+ }
+ }
+ }
+ if (fn)
+ (void) strcpy(*fn, d->fn + dirlen);
+ }
+ if (d->fd == -1)
{
- case EFBIG:
+ switch(errno)
+ {
+ case EFBIG:
#ifdef EDQUOT
case EDQUOT:
#endif
- case ENOSPC:
- retval = KRB5_RC_IO_SPACE;
+ case ENOSPC:
+ retval = KRB5_RC_IO_SPACE;
goto fail;
- case EIO:
- retval = KRB5_RC_IO_IO; goto fail;
- case EPERM:
- case EACCES:
- case EROFS:
- case EEXIST:
- retval = KRB5_RC_IO_PERM; goto no_unlink;
+ case EIO:
+ retval = KRB5_RC_IO_IO;
+ goto fail;
- default:
- retval = KRB5_RC_IO_UNKNOWN; goto fail;
- }
+ case EPERM:
+ case EACCES:
+ case EROFS:
+ case EEXIST:
+ retval = KRB5_RC_IO_PERM;
+ goto no_unlink;
+
+ default:
+ retval = KRB5_RC_IO_UNKNOWN;
+ goto fail;
+ }
}
- if ((retval = krb5_rc_io_write(context, d, (krb5_pointer)&rc_vno, sizeof(rc_vno))) ||
+ if ((retval = krb5_rc_io_write(context, d, (krb5_pointer)&rc_vno,
+ sizeof(rc_vno))) ||
(retval = krb5_rc_io_sync(context, d)))
{
fail:
- (void) unlink(d->fn);
+ (void) unlink(d->fn);
no_unlink:
- FREE(d->fn);
+ FREE(d->fn);
d->fn = NULL;
- (void) close(d->fd);
- return retval;
- }
- return 0;
+ (void) close(d->fd);
+ return retval;
+ }
+ return 0;
}
-krb5_error_code krb5_rc_io_open (context, d, fn)
- krb5_context context;
- krb5_rc_iostuff *d;
- char *fn;
+krb5_error_code
+krb5_rc_io_open(krb5_context context, krb5_rc_iostuff *d, char *fn)
{
- krb5_int16 rc_vno;
- krb5_error_code retval;
+ krb5_int16 rc_vno;
+ krb5_error_code retval;
#ifndef NO_USERID
- struct stat statb;
+ struct stat statb;
#endif
- GETDIR;
- if (!(d->fn = malloc(strlen(fn) + dirlen + 1)))
- return KRB5_RC_IO_MALLOC;
- (void) strcpy(d->fn,dir);
- (void) strcat(d->fn,PATH_SEPARATOR);
- (void) strcat(d->fn,fn);
+ GETDIR;
+ if (!(d->fn = malloc(strlen(fn) + dirlen + 1)))
+ return KRB5_RC_IO_MALLOC;
+ (void) strcpy(d->fn, dir);
+ (void) strcat(d->fn, PATH_SEPARATOR);
+ (void) strcat(d->fn, fn);
#ifdef NO_USERID
- d->fd = THREEPARAMOPEN(d->fn,O_RDWR | O_BINARY,0600);
+ d->fd = THREEPARAMOPEN(d->fn, O_RDWR | O_BINARY, 0600);
#else
- if ((d->fd = stat(d->fn, &statb)) != -1) {
- uid_t me;
+ if ((d->fd = stat(d->fn, &statb)) != -1) {
+ uid_t me;
- me = geteuid();
- /* must be owned by this user, to prevent some security problems with
+ me = geteuid();
+ /* must be owned by this user, to prevent some security problems with
* other users modifying replay cache stufff */
- if ((statb.st_uid != me) || ((statb.st_mode & S_IFMT) != S_IFREG)) {
- FREE(d->fn);
- return KRB5_RC_IO_PERM;
- }
- d->fd = THREEPARAMOPEN(d->fn,O_RDWR | O_BINARY,0600);
- }
+ if ((statb.st_uid != me) || ((statb.st_mode & S_IFMT) != S_IFREG)) {
+ FREE(d->fn);
+ return KRB5_RC_IO_PERM;
+ }
+ d->fd = THREEPARAMOPEN(d->fn, O_RDWR | O_BINARY, 0600);
+ }
#endif
- if (d->fd == -1) {
- switch(errno)
- {
- case EFBIG:
+ if (d->fd == -1) {
+ switch(errno)
+ {
+ case EFBIG:
#ifdef EDQUOT
case EDQUOT:
#endif
case ENOSPC:
- retval = KRB5_RC_IO_SPACE;
+ retval = KRB5_RC_IO_SPACE;
goto fail;
- case EIO:
- retval = KRB5_RC_IO_IO;
+ case EIO:
+ retval = KRB5_RC_IO_IO;
goto fail;
- case EPERM:
+ case EPERM:
case EACCES:
- case EROFS:
- retval = KRB5_RC_IO_PERM;
+ case EROFS:
+ retval = KRB5_RC_IO_PERM;
goto fail;
- default:
- retval = KRB5_RC_IO_UNKNOWN;
+ default:
+ retval = KRB5_RC_IO_UNKNOWN;
goto fail;
+ }
}
- }
if ((retval = krb5_rc_io_read(context, d, (krb5_pointer) &rc_vno,
sizeof(rc_vno))))
goto unlk;
- if (ntohs(rc_vno) != KRB5_RC_VNO)
+ if (ntohs(rc_vno) != KRB5_RC_VNO)
{
retval = KRB5_RCACHE_BADVNO;
unlk:
unlink(d->fn);
fail:
- (void) close(d->fd);
- FREE(d->fn);
+ (void) close(d->fd);
+ FREE(d->fn);
d->fn = NULL;
- return retval;
- }
- return 0;
+ return retval;
+ }
+ return 0;
}
-krb5_error_code krb5_rc_io_move (context, new, old)
- krb5_context context;
- krb5_rc_iostuff *new;
- krb5_rc_iostuff *old;
+krb5_error_code
+krb5_rc_io_move(krb5_context context, krb5_rc_iostuff *new,
+ krb5_rc_iostuff *old)
{
char *fn = NULL;
-
#if defined(_MSDOS) || defined(_WIN32)
/*
* Work around provided by Tom Sanfilippo to work around poor
close(new->fd);
unlink(new->fn);
close(old->fd);
- if (rename(old->fn,new->fn) == -1) /* MUST be atomic! */
+ if (rename(old->fn, new->fn) == -1) /* MUST be atomic! */
return KRB5_RC_IO_UNKNOWN;
fn = new->fn;
new->fn = NULL; /* avoid clobbering */
krb5_rc_io_open(context, new, fn);
free(fn);
#else
- if (rename(old->fn,new->fn) == -1) /* MUST be atomic! */
+ if (rename(old->fn, new->fn) == -1) /* MUST be atomic! */
return KRB5_RC_IO_UNKNOWN;
fn = new->fn;
new->fn = NULL; /* avoid clobbering */
return 0;
}
-krb5_error_code krb5_rc_io_write (context, d, buf, num)
- krb5_context context;
- krb5_rc_iostuff *d;
- krb5_pointer buf;
- unsigned int num;
+krb5_error_code
+krb5_rc_io_write(krb5_context context, krb5_rc_iostuff *d, krb5_pointer buf,
+ unsigned int num)
{
- if (write(d->fd,(char *) buf,num) == -1)
- switch(errno)
- {
- case EBADF: return KRB5_RC_IO_UNKNOWN;
- case EFBIG: return KRB5_RC_IO_SPACE;
+ if (write(d->fd, (char *) buf, num) == -1)
+ switch(errno)
+ {
+ case EBADF: return KRB5_RC_IO_UNKNOWN;
+ case EFBIG: return KRB5_RC_IO_SPACE;
#ifdef EDQUOT
- case EDQUOT: return KRB5_RC_IO_SPACE;
+ case EDQUOT: return KRB5_RC_IO_SPACE;
#endif
- case ENOSPC: return KRB5_RC_IO_SPACE;
- case EIO: return KRB5_RC_IO_IO;
- default: return KRB5_RC_IO_UNKNOWN;
- }
- return 0;
+ case ENOSPC: return KRB5_RC_IO_SPACE;
+ case EIO: return KRB5_RC_IO_IO;
+ default: return KRB5_RC_IO_UNKNOWN;
+ }
+ return 0;
}
-krb5_error_code krb5_rc_io_sync (context, d)
- krb5_context context;
- krb5_rc_iostuff *d;
+krb5_error_code
+krb5_rc_io_sync(
+ krb5_context context,
+ krb5_rc_iostuff *d
+ )
{
#if !defined(MSDOS_FILESYSTEM) && !defined(macintosh)
if (fsync(d->fd) == -1) {
- switch(errno)
- {
- case EBADF: return KRB5_RC_IO_UNKNOWN;
- case EIO: return KRB5_RC_IO_IO;
- default: return KRB5_RC_IO_UNKNOWN;
- }
+ switch(errno)
+ {
+ case EBADF: return KRB5_RC_IO_UNKNOWN;
+ case EIO: return KRB5_RC_IO_IO;
+ default: return KRB5_RC_IO_UNKNOWN;
+ }
}
#endif
return 0;
}
-krb5_error_code krb5_rc_io_read (context, d, buf, num)
- krb5_context context;
- krb5_rc_iostuff *d;
- krb5_pointer buf;
- unsigned int num;
+krb5_error_code
+krb5_rc_io_read(krb5_context context, krb5_rc_iostuff *d, krb5_pointer buf,
+ unsigned int num)
{
- int count;
- if ((count = read(d->fd,(char *) buf,num)) == -1)
- switch(errno)
- {
- case EBADF: return KRB5_RC_IO_UNKNOWN;
- case EIO: return KRB5_RC_IO_IO;
- default: return KRB5_RC_IO_UNKNOWN;
- }
- if (count == 0)
- return KRB5_RC_IO_EOF;
- return 0;
+ int count;
+ if ((count = read(d->fd, (char *) buf, num)) == -1)
+ switch(errno)
+ {
+ case EBADF: return KRB5_RC_IO_UNKNOWN;
+ case EIO: return KRB5_RC_IO_IO;
+ default: return KRB5_RC_IO_UNKNOWN;
+ }
+ if (count == 0)
+ return KRB5_RC_IO_EOF;
+ return 0;
}
-krb5_error_code krb5_rc_io_close (context, d)
- krb5_context context;
- krb5_rc_iostuff *d;
+krb5_error_code
+krb5_rc_io_close(krb5_context context, krb5_rc_iostuff *d)
{
- if (d->fn != NULL)
- FREE(d->fn);
- d->fn = NULL;
- if (close(d->fd) == -1) /* can't happen */
- return KRB5_RC_IO_UNKNOWN;
- return 0;
+ if (d->fn != NULL)
+ FREE(d->fn);
+ d->fn = NULL;
+ if (close(d->fd) == -1) /* can't happen */
+ return KRB5_RC_IO_UNKNOWN;
+ return 0;
}
-krb5_error_code krb5_rc_io_destroy (context, d)
- krb5_context context;
- krb5_rc_iostuff *d;
+krb5_error_code
+krb5_rc_io_destroy(krb5_context context, krb5_rc_iostuff *d)
{
- if (unlink(d->fn) == -1)
- switch(errno)
- {
- case EBADF: return KRB5_RC_IO_UNKNOWN;
- case EIO: return KRB5_RC_IO_IO;
- case EPERM: return KRB5_RC_IO_PERM;
- case EBUSY: return KRB5_RC_IO_PERM;
- case EROFS: return KRB5_RC_IO_PERM;
- default: return KRB5_RC_IO_UNKNOWN;
- }
- return 0;
+ if (unlink(d->fn) == -1)
+ switch(errno)
+ {
+ case EBADF: return KRB5_RC_IO_UNKNOWN;
+ case EIO: return KRB5_RC_IO_IO;
+ case EPERM: return KRB5_RC_IO_PERM;
+ case EBUSY: return KRB5_RC_IO_PERM;
+ case EROFS: return KRB5_RC_IO_PERM;
+ default: return KRB5_RC_IO_UNKNOWN;
+ }
+ return 0;
}
-krb5_error_code krb5_rc_io_mark (context, d)
- krb5_context context;
- krb5_rc_iostuff *d;
+krb5_error_code
+krb5_rc_io_mark(krb5_context context, krb5_rc_iostuff *d)
{
- d->mark = lseek(d->fd,(off_t) 0,SEEK_CUR); /* can't fail */
- return 0;
+ d->mark = lseek(d->fd, (off_t) 0, SEEK_CUR); /* can't fail */
+ return 0;
}
-krb5_error_code krb5_rc_io_unmark (context, d)
- krb5_context context;
- krb5_rc_iostuff *d;
+krb5_error_code
+krb5_rc_io_unmark(krb5_context context, krb5_rc_iostuff *d)
{
- (void) lseek(d->fd,d->mark,SEEK_SET); /* if it fails, tough luck */
- return 0;
+ (void) lseek(d->fd, d->mark, SEEK_SET); /* if it fails, tough luck */
+ return 0;
}
long
-krb5_rc_io_size (context, d)
- krb5_context context;
- krb5_rc_iostuff *d;
+krb5_rc_io_size(krb5_context context, krb5_rc_iostuff *d)
{
struct stat statb;
-
- if (fstat (d->fd, &statb) == 0)
+
+ if (fstat(d->fd, &statb) == 0)
return statb.st_size;
else
return 0;
}
-
+2001-06-20 Ken Raeburn <raeburn@mit.edu>
+
+ * request_tbl.c (ss_add_request_table): Delete unnecessary cast in
+ size arg to realloc.
+
+ * invocation.c (ss_delete_invocation): Delete unnecessary cast in
+ arg to free.
+
2001-06-07 Ezra Peisach <epeisach@mit.edu>
* request_tbl.c (ss_add_request_table): Do not cast argument to
t = ss_info(sci_idx);
free(t->prompt);
- free((char *)t->rqt_tables);
+ free(t->rqt_tables);
while(t->info_dirs[0] != (char *)NULL)
ss_delete_info_dir(sci_idx, t->info_dirs[0], &ignored_code);
free((char *)t->info_dirs);
/* size == C subscript of NULL == #elements */
size += 2; /* new element, and NULL */
info->rqt_tables = (ssrt **)realloc(info->rqt_tables,
- (unsigned)size*sizeof(ssrt));
+ size*sizeof(ssrt));
if (info->rqt_tables == (ssrt **)NULL) {
*code_ptr = errno;
return;
projects / thirdparty / krb5.git / commitdiff
