oysteikt/heimdal
0
0
Fork 0
Code Issues 5 Pull Requests Releases Activity

Make krb5_{ret,store}_* functions able to write data to more than file

Browse Source 
descriptors.


git-svn-id: svn://svn.h5l.se/heimdal/trunk/heimdal@1280 ec53bebd-3082-4978-b11e-865c3cabbd6b
This commit is contained in:
Johan Danielsson
1997-03-08 05:57:40 +00:00
parent a700b9bcaf
commit a97c83a342
2 changed files with 186 additions and 125 deletions
Download Patch File Download Diff File Expand all files Collapse all files

230
lib/krb5/store.c
View File

@@ -1,25 +1,133 @@
#include "krb5_locl.h" #include "krb5_locl.h"
RCSID("$Id$");
struct krb5_fd_storage{
int fd;
};
#define FD(S) (((struct krb5_fd_storage*)(S)->data)->fd)
struct krb5_mem_storage{
void *base;
size_t len;
void *ptr;
};
#define MEM(S) ((struct krb5_mem_storage*)((S)->data))
size_t
fd_fetch(krb5_storage *sp, void *data, size_t size)
{
return read(FD(sp), data, size);
}
size_t
fd_store(krb5_storage *sp, void *data, size_t size)
{
return write(FD(sp), data, size);
}
off_t
fd_seek(krb5_storage *sp, off_t offset, int whence)
{
return lseek(FD(sp), offset, whence);
}
size_t
mem_fetch(krb5_storage *sp, void *data, size_t size)
{
memmove(data, MEM(sp)->ptr, size);
sp->seek(sp, size, SEEK_CUR);
return size;
}
size_t
mem_store(krb5_storage *sp, void *data, size_t size)
{
memmove(MEM(sp)->ptr, data, size);
sp->seek(sp, size, SEEK_CUR);
return size;
}
off_t
mem_seek(krb5_storage *sp, off_t offset, int whence)
{
switch(whence){
case SEEK_SET:
if(offset > MEM(sp)->len)
offset = MEM(sp)->len;
if(offset < 0)
offset = 0;
MEM(sp)->ptr = (char*)(MEM(sp)->base) + offset;
break;
case SEEK_CUR:
sp->seek(sp, MEM(sp)->ptr - MEM(sp)->base + offset, SEEK_SET);
break;
case SEEK_END:
sp->seek(sp, MEM(sp)->len + offset, SEEK_SET);
default:
errno = EINVAL;
return -1;
}
return MEM(sp)->ptr - MEM(sp)->base;
}
krb5_storage *
krb5_storage_from_fd(int fd)
{
krb5_storage *sp = malloc(sizeof(krb5_storage));
sp->data = malloc(sizeof(struct krb5_fd_storage));
FD(sp) = fd;
sp->fetch = fd_fetch;
sp->store = fd_store;
sp->seek = fd_seek;
return sp;
}
krb5_storage *
krb5_storage_from_mem(void *buf, size_t len)
{
krb5_storage *sp = malloc(sizeof(krb5_storage));
sp->data = malloc(sizeof(struct krb5_mem_storage));
MEM(sp)->base = buf;
MEM(sp)->len = len;
MEM(sp)->ptr = buf;
sp->fetch = mem_fetch;
sp->store = mem_store;
sp->seek = mem_seek;
return sp;
}
krb5_error_code krb5_error_code
krb5_store_int32(int fd, krb5_storage_free(krb5_storage *sp)
{
free(sp->data);
free(sp);
return 0;
}
krb5_error_code
krb5_store_int32(krb5_storage *sp,
int32_t value) int32_t value)
{ {
int ret; int ret;
value = htonl(value); value = htonl(value);
ret = write(fd, &value, sizeof(value)); ret = sp->store(sp, &value, sizeof(value));
if (ret != sizeof(value)) if (ret != sizeof(value))
return (ret<0)?errno:KRB5_CC_END; return (ret<0)?errno:KRB5_CC_END;
return 0; return 0;
} }
krb5_error_code krb5_error_code
krb5_ret_int32(int fd, krb5_ret_int32(krb5_storage *sp,
int32_t *value) int32_t *value)
{ {
int32_t v; int32_t v;
int ret; int ret;
ret = read(fd, &v, sizeof(v)); ret = sp->fetch(sp, &v, sizeof(v));
if(ret != sizeof(v)) if(ret != sizeof(v))
return (ret<0)?errno:KRB5_CC_END; return (ret<0)?errno:KRB5_CC_END;
@@ -28,25 +136,25 @@ krb5_ret_int32(int fd,
} }
krb5_error_code krb5_error_code
krb5_store_int16(int fd, krb5_store_int16(krb5_storage *sp,
int16_t value) int16_t value)
{ {
int ret; int ret;
value = htons(value); value = htons(value);
ret = write(fd, &value, sizeof(value)); ret = sp->store(sp, &value, sizeof(value));
if (ret != sizeof(value)) if (ret != sizeof(value))
return (ret<0)?errno:KRB5_CC_END; return (ret<0)?errno:KRB5_CC_END;
return 0; return 0;
} }
krb5_error_code krb5_error_code
krb5_ret_int16(int fd, krb5_ret_int16(krb5_storage *sp,
int16_t *value) int16_t *value)
{ {
int16_t v; int16_t v;
int ret; int ret;
ret = read(fd, &v, sizeof(v)); ret = sp->fetch(sp, &v, sizeof(v));
if(ret != sizeof(v)) if(ret != sizeof(v))
return (ret<0)?errno:KRB5_CC_END; /* XXX */ return (ret<0)?errno:KRB5_CC_END; /* XXX */
@@ -55,38 +163,38 @@ krb5_ret_int16(int fd,
} }
krb5_error_code krb5_error_code
krb5_store_int8(int fd, krb5_store_int8(krb5_storage *sp,
int8_t value) int8_t value)
{ {
int ret; int ret;
ret = write(fd, &value, sizeof(value)); ret = sp->store(sp, &value, sizeof(value));
if (ret != sizeof(value)) if (ret != sizeof(value))
return (ret<0)?errno:KRB5_CC_END; return (ret<0)?errno:KRB5_CC_END;
return 0; return 0;
} }
krb5_error_code krb5_error_code
krb5_ret_int8(int fd, krb5_ret_int8(krb5_storage *sp,
int8_t *value) int8_t *value)
{ {
int ret; int ret;
ret = read (fd, value, sizeof(*value)); ret = sp->fetch(sp, value, sizeof(*value));
if (ret != sizeof(*value)) if (ret != sizeof(*value))
return (ret<0)?errno:KRB5_CC_END; return (ret<0)?errno:KRB5_CC_END;
return 0; return 0;
} }
krb5_error_code krb5_error_code
krb5_store_data(int fd, krb5_store_data(krb5_storage *sp,
krb5_data data) krb5_data data)
{ {
int ret; int ret;
ret = krb5_store_int32(fd, data.length); ret = krb5_store_int32(sp, data.length);
if(ret < 0) if(ret < 0)
return ret; return ret;
ret = write(fd, data.data, data.length); ret = sp->store(sp, data.data, data.length);
if(ret != data.length){ if(ret != data.length){
if(ret < 0) if(ret < 0)
return errno; return errno;
@@ -96,43 +204,44 @@ krb5_store_data(int fd,
} }
krb5_error_code krb5_error_code
krb5_ret_data(int fd, krb5_ret_data(krb5_storage *sp,
krb5_data *data) krb5_data *data)
{ {
int ret; int ret;
int size; int size;
ret = krb5_ret_int32(fd, &size); ret = krb5_ret_int32(sp, &size);
if(ret) if(ret)
return ret; return ret;
data->length = size; data->length = size;
data->data = malloc(size); data->data = malloc(size);
ret = read(fd, data->data, size); ret = sp->fetch(sp, data->data, size);
if(ret != size) if(ret != size)
return (ret < 0)? errno : KRB5_CC_END; return (ret < 0)? errno : KRB5_CC_END;
return 0; return 0;
} }
krb5_error_code krb5_error_code
krb5_store_principal(int fd, krb5_store_principal(krb5_storage *sp,
krb5_principal p) krb5_principal p)
{ {
int i; int i;
int ret; int ret;
ret = krb5_store_int32(fd, p->type); ret = krb5_store_int32(sp, p->type);
if(ret) return ret; if(ret) return ret;
ret = krb5_store_int32(fd, p->ncomp); ret = krb5_store_int32(sp, p->ncomp);
if(ret) return ret; if(ret) return ret;
ret = krb5_store_data(fd, p->realm); ret = krb5_store_data(sp, p->realm);
if(ret) return ret; if(ret) return ret;
for(i = 0; i < p->ncomp; i++){ for(i = 0; i < p->ncomp; i++){
ret = krb5_store_data(fd, p->comp[i]); ret = krb5_store_data(sp, p->comp[i]);
if(ret) return ret; if(ret) return ret;
} }
return 0; return 0;
} }
krb5_error_code krb5_error_code
krb5_ret_principal(int fd, krb5_ret_principal(krb5_storage *sp,
krb5_principal *princ) krb5_principal *princ)
{ {
int i; int i;
@@ -143,18 +252,18 @@ krb5_ret_principal(int fd,
if(p == NULL) if(p == NULL)
return ENOMEM; return ENOMEM;
if((ret = krb5_ret_int32(fd, &p->type))) if((ret = krb5_ret_int32(sp, &p->type)))
return ret; return ret;
ret = krb5_ret_int32(fd, &p->ncomp); ret = krb5_ret_int32(sp, &p->ncomp);
if(ret) return ret; if(ret) return ret;
ret = krb5_ret_data(fd, &p->realm); ret = krb5_ret_data(sp, &p->realm);
if(ret) return ret; if(ret) return ret;
p->comp = ALLOC(p->ncomp, krb5_data); p->comp = ALLOC(p->ncomp, krb5_data);
if(p->comp == NULL){ if(p->comp == NULL){
return ENOMEM; return ENOMEM;
} }
for(i = 0; i < p->ncomp; i++){ for(i = 0; i < p->ncomp; i++){
ret = krb5_ret_data(fd, &p->comp[i]); ret = krb5_ret_data(sp, &p->comp[i]);
if(ret) return ret; if(ret) return ret;
} }
*princ = p; *princ = p;
@@ -162,118 +271,117 @@ krb5_ret_principal(int fd,
} }
krb5_error_code krb5_error_code
krb5_store_keyblock(int fd, krb5_keyblock p) krb5_store_keyblock(krb5_storage *sp, krb5_keyblock p)
{ {
int ret; int ret;
ret =krb5_store_int32(fd, p.keytype); ret =krb5_store_int32(sp, p.keytype);
if(ret) return ret; if(ret) return ret;
ret = krb5_store_data(fd, p.contents); ret = krb5_store_data(sp, p.contents);
return ret; return ret;
} }
krb5_error_code krb5_error_code
krb5_ret_keyblock(int fd, krb5_keyblock *p) krb5_ret_keyblock(krb5_storage *sp, krb5_keyblock *p)
{ {
int ret; int ret;
ret = krb5_ret_int32(fd, (int32_t*)&p->keytype); /* keytype + etype */ ret = krb5_ret_int32(sp, (int32_t*)&p->keytype); /* keytype + etype */
if(ret) return ret; if(ret) return ret;
ret = krb5_ret_data(fd, &p->contents); ret = krb5_ret_data(sp, &p->contents);
return ret; return ret;
} }
krb5_error_code krb5_error_code
krb5_store_times(int fd, krb5_times times) krb5_store_times(krb5_storage *sp, krb5_times times)
{ {
int ret; int ret;
ret = krb5_store_int32(fd, times.authtime); ret = krb5_store_int32(sp, times.authtime);
if(ret) return ret; if(ret) return ret;
ret = krb5_store_int32(fd, times.starttime); ret = krb5_store_int32(sp, times.starttime);
if(ret) return ret; if(ret) return ret;
ret = krb5_store_int32(fd, times.endtime); ret = krb5_store_int32(sp, times.endtime);
if(ret) return ret; if(ret) return ret;
ret = krb5_store_int32(fd, times.renew_till); ret = krb5_store_int32(sp, times.renew_till);
return ret; return ret;
} }
krb5_error_code krb5_error_code
krb5_ret_times(int fd, krb5_times *times) krb5_ret_times(krb5_storage *sp, krb5_times *times)
{ {
int ret; int ret;
int32_t tmp; int32_t tmp;
ret = krb5_ret_int32(sp, &tmp);
ret = krb5_ret_int32(fd, &tmp);
times->authtime = tmp; times->authtime = tmp;
if(ret) return ret; if(ret) return ret;
ret = krb5_ret_int32(fd, &tmp); ret = krb5_ret_int32(sd, &tmp);
times->starttime = tmp; times->starttime = tmp;
if(ret) return ret; if(ret) return ret;
ret = krb5_ret_int32(fd, &tmp); ret = krb5_ret_int32(sp, &tmp);
times->endtime = tmp; times->endtime = tmp;
if(ret) return ret; if(ret) return ret;
ret = krb5_ret_int32(fd, &tmp); ret = krb5_ret_int32(sp, &tmp);
times->renew_till = tmp; times->renew_till = tmp;
return ret; return ret;
} }
krb5_error_code krb5_error_code
krb5_store_address(int fd, krb5_address p) krb5_store_address(krb5_storage *sp, krb5_address p)
{ {
int ret; int ret;
ret = krb5_store_int16(fd, p.type); ret = krb5_store_int16(sp, p.type);
if(ret) return ret; if(ret) return ret;
ret = krb5_store_data(fd, p.address); ret = krb5_store_data(sp, p.address);
return ret; return ret;
} }
krb5_error_code krb5_error_code
krb5_ret_address(int fd, krb5_address *adr) krb5_ret_address(krb5_storage *sp, krb5_address *adr)
{ {
int16_t t; int16_t t;
int ret; int ret;
ret = krb5_ret_int16(fd, &t); ret = krb5_ret_int16(sp, &t);
if(ret) return ret; if(ret) return ret;
adr->type = t; adr->type = t;
ret = krb5_ret_data(fd, &adr->address); ret = krb5_ret_data(sp, &adr->address);
return ret; return ret;
} }
krb5_error_code krb5_error_code
krb5_store_addrs(int fd, krb5_addresses p) krb5_store_addrs(krb5_storage *sp, krb5_addresses p)
{ {
int i; int i;
int ret; int ret;
ret = krb5_store_int32(fd, p.number); ret = krb5_store_int32(sp, p.number);
if(ret) return ret; if(ret) return ret;
for(i = 0; i<p.number; i++){ for(i = 0; i<p.number; i++){
ret = krb5_store_address(fd, p.addrs[i]); ret = krb5_store_address(sp, p.addrs[i]);
if(ret) break; if(ret) break;
} }
return ret; return ret;
} }
krb5_error_code krb5_error_code
krb5_ret_addrs(int fd, krb5_addresses *adr) krb5_ret_addrs(krb5_storage *sp, krb5_addresses *adr)
{ {
int i; int i;
int ret; int ret;
ret = krb5_ret_int32(fd, &adr->number); ret = krb5_ret_int32(sp, &adr->number);
if(ret) return ret; if(ret) return ret;
adr->addrs = ALLOC(adr->number, krb5_address); adr->addrs = ALLOC(adr->number, krb5_address);
for(i = 0; i < adr->number; i++){ for(i = 0; i < adr->number; i++){
ret = krb5_ret_address(fd, &adr->addrs[i]); ret = krb5_ret_address(sp, &adr->addrs[i]);
if(ret) break; if(ret) break;
} }
return ret; return ret;
} }
krb5_error_code krb5_error_code
krb5_store_authdata(int fd, krb5_data p) krb5_store_authdata(krb5_storage *sp, krb5_data p)
{ {
return krb5_store_data(fd, p); return krb5_store_data(sp, p);
} }
krb5_error_code krb5_error_code
krb5_ret_authdata(int fd, krb5_data *auth) krb5_ret_authdata(krb5_storage *sp, krb5_data *auth)
{ {
return krb5_ret_data(fd, auth); return krb5_ret_data(sp, auth);
} }

81
lib/krb5/store.h
View File

@@ -1,74 +1,27 @@
/* $Id$ */
#ifndef __STORE_H__ #ifndef __STORE_H__
#define __STORE_H__ #define __STORE_H__
krb5_error_code krb5_storage *krb5_storage_from_fd(int fd);
krb5_store_int32(int fd,
int32_t value);
krb5_error_code krb5_storage *krb5_storage_from_mem(void *buf, size_t len);
krb5_ret_int32(int fd,
int32_t *value);
krb5_error_code krb5_error_code krb5_storage_free(krb5_storage *sp);
krb5_store_int16(int fd,
int16_t value);
krb5_error_code #define __PT(N, T) krb5_error_code krb5_store_##N(krb5_storage*, T); krb5_error_code krb5_ret_##N(krb5_storage *, T*)
krb5_ret_int16(int fd,
int16_t *value);
krb5_error_code __PT(int32, int32_t);
krb5_store_int8(int fd, __PT(int16, int16_t);
int8_t value); __PT(int8, int8_t);
__PT(data, krb5_data);
__PT(principal, krb5_principal);
__PT(keyblock, krb5_keyblock);
__PT(times, krb5_times);
__PT(address, krb5_address);
__PT(addrs, krb5_addresses);
__PT(authdata, krb5_data);
krb5_error_code #undef __PT
krb5_ret_int8(int fd,
int8_t *value);
krb5_error_code
krb5_store_data(int fd,
krb5_data data);
krb5_error_code
krb5_ret_data(int fd,
krb5_data *data);
krb5_error_code
krb5_store_principal(int fd,
krb5_principal p);
krb5_error_code
krb5_ret_principal(int fd,
krb5_principal *princ);
krb5_error_code
krb5_store_keyblock(int fd, krb5_keyblock p);
krb5_error_code
krb5_ret_keyblock(int fd, krb5_keyblock *p);
krb5_error_code
krb5_store_times(int fd, krb5_times times);
krb5_error_code
krb5_ret_times(int fd, krb5_times *times);
krb5_error_code
krb5_store_address(int fd, krb5_address p);
krb5_error_code
krb5_ret_address(int fd, krb5_address *adr);
krb5_error_code
krb5_store_addrs(int fd, krb5_addresses p);
krb5_error_code
krb5_ret_addrs(int fd, krb5_addresses *adr);
krb5_error_code
krb5_store_authdata(int fd, krb5_data p);
krb5_error_code
krb5_ret_authdata(int fd, krb5_data *auth);
#endif /* __STORE_H__ */ #endif /* __STORE_H__ */