#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;
}
-
projects / krb5.git / commitdiff