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"
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_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)
{
int ret;
value = htonl(value);
ret = write(fd, &value, sizeof(value));
ret = sp->store(sp, &value, sizeof(value));
if (ret != sizeof(value))
return (ret<0)?errno:KRB5_CC_END;
return 0;
}
krb5_error_code
krb5_ret_int32(int fd,
krb5_ret_int32(krb5_storage *sp,
int32_t *value)
{
int32_t v;
int ret;
ret = read(fd, &v, sizeof(v));
ret = sp->fetch(sp, &v, sizeof(v));
if(ret != sizeof(v))
return (ret<0)?errno:KRB5_CC_END;
@@ -28,25 +136,25 @@ krb5_ret_int32(int fd,
}
krb5_error_code
krb5_store_int16(int fd,
krb5_store_int16(krb5_storage *sp,
int16_t value)
{
int ret;
value = htons(value);
ret = write(fd, &value, sizeof(value));
ret = sp->store(sp, &value, sizeof(value));
if (ret != sizeof(value))
return (ret<0)?errno:KRB5_CC_END;
return 0;
}
krb5_error_code
krb5_ret_int16(int fd,
krb5_ret_int16(krb5_storage *sp,
int16_t *value)
{
int16_t v;
int ret;
ret = read(fd, &v, sizeof(v));
ret = sp->fetch(sp, &v, sizeof(v));
if(ret != sizeof(v))
return (ret<0)?errno:KRB5_CC_END; /* XXX */
@@ -55,38 +163,38 @@ krb5_ret_int16(int fd,
}
krb5_error_code
krb5_store_int8(int fd,
krb5_store_int8(krb5_storage *sp,
int8_t value)
{
int ret;
ret = write(fd, &value, sizeof(value));
ret = sp->store(sp, &value, sizeof(value));
if (ret != sizeof(value))
return (ret<0)?errno:KRB5_CC_END;
return 0;
}
krb5_error_code
krb5_ret_int8(int fd,
krb5_ret_int8(krb5_storage *sp,
int8_t *value)
{
int ret;
ret = read (fd, value, sizeof(*value));
ret = sp->fetch(sp, value, sizeof(*value));
if (ret != sizeof(*value))
return (ret<0)?errno:KRB5_CC_END;
return 0;
}
krb5_error_code
krb5_store_data(int fd,
krb5_store_data(krb5_storage *sp,
krb5_data data)
{
int ret;
ret = krb5_store_int32(fd, data.length);
ret = krb5_store_int32(sp, data.length);
if(ret < 0)
return ret;
ret = write(fd, data.data, data.length);
ret = sp->store(sp, data.data, data.length);
if(ret != data.length){
if(ret < 0)
return errno;
@@ -96,43 +204,44 @@ krb5_store_data(int fd,
}
krb5_error_code
krb5_ret_data(int fd,
krb5_ret_data(krb5_storage *sp,
krb5_data *data)
{
int ret;
int size;
ret = krb5_ret_int32(fd, &size);
ret = krb5_ret_int32(sp, &size);
if(ret)
return ret;
data->length = size;
data->data = malloc(size);
ret = read(fd, data->data, size);
ret = sp->fetch(sp, data->data, size);
if(ret != size)
return (ret < 0)? errno : KRB5_CC_END;
return 0;
}
krb5_error_code
krb5_store_principal(int fd,
krb5_store_principal(krb5_storage *sp,
krb5_principal p)
{
int i;
int ret;
ret = krb5_store_int32(fd, p->type);
ret = krb5_store_int32(sp, p->type);
if(ret) return ret;
ret = krb5_store_int32(fd, p->ncomp);
ret = krb5_store_int32(sp, p->ncomp);
if(ret) return ret;
ret = krb5_store_data(fd, p->realm);
ret = krb5_store_data(sp, p->realm);
if(ret) return ret;
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;
}
return 0;
}
krb5_error_code
krb5_ret_principal(int fd,
krb5_ret_principal(krb5_storage *sp,
krb5_principal *princ)
{
int i;
@@ -143,18 +252,18 @@ krb5_ret_principal(int fd,
if(p == NULL)
return ENOMEM;
if((ret = krb5_ret_int32(fd, &p->type)))
if((ret = krb5_ret_int32(sp, &p->type)))
return ret;
ret = krb5_ret_int32(fd, &p->ncomp);
ret = krb5_ret_int32(sp, &p->ncomp);
if(ret) return ret;
ret = krb5_ret_data(fd, &p->realm);
ret = krb5_ret_data(sp, &p->realm);
if(ret) return ret;
p->comp = ALLOC(p->ncomp, krb5_data);
if(p->comp == NULL){
return ENOMEM;
}
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;
}
*princ = p;
@@ -162,118 +271,117 @@ krb5_ret_principal(int fd,
}
krb5_error_code
krb5_store_keyblock(int fd, krb5_keyblock p)
krb5_store_keyblock(krb5_storage *sp, krb5_keyblock p)
{
int ret;
ret =krb5_store_int32(fd, p.keytype);
ret =krb5_store_int32(sp, p.keytype);
if(ret) return ret;
ret = krb5_store_data(fd, p.contents);
ret = krb5_store_data(sp, p.contents);
return ret;
}
krb5_error_code
krb5_ret_keyblock(int fd, krb5_keyblock *p)
krb5_ret_keyblock(krb5_storage *sp, krb5_keyblock *p)
{
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;
ret = krb5_ret_data(fd, &p->contents);
ret = krb5_ret_data(sp, &p->contents);
return ret;
}
krb5_error_code
krb5_store_times(int fd, krb5_times times)
krb5_store_times(krb5_storage *sp, krb5_times times)
{
int ret;
ret = krb5_store_int32(fd, times.authtime);
ret = krb5_store_int32(sp, times.authtime);
if(ret) return ret;
ret = krb5_store_int32(fd, times.starttime);
ret = krb5_store_int32(sp, times.starttime);
if(ret) return ret;
ret = krb5_store_int32(fd, times.endtime);
ret = krb5_store_int32(sp, times.endtime);
if(ret) return ret;
ret = krb5_store_int32(fd, times.renew_till);
ret = krb5_store_int32(sp, times.renew_till);
return ret;
}
krb5_error_code
krb5_ret_times(int fd, krb5_times *times)
krb5_ret_times(krb5_storage *sp, krb5_times *times)
{
int ret;
int32_t tmp;
ret = krb5_ret_int32(fd, &tmp);
ret = krb5_ret_int32(sp, &tmp);
times->authtime = tmp;
if(ret) return ret;
ret = krb5_ret_int32(fd, &tmp);
ret = krb5_ret_int32(sd, &tmp);
times->starttime = tmp;
if(ret) return ret;
ret = krb5_ret_int32(fd, &tmp);
ret = krb5_ret_int32(sp, &tmp);
times->endtime = tmp;
if(ret) return ret;
ret = krb5_ret_int32(fd, &tmp);
ret = krb5_ret_int32(sp, &tmp);
times->renew_till = tmp;
return ret;
}
krb5_error_code
krb5_store_address(int fd, krb5_address p)
krb5_store_address(krb5_storage *sp, krb5_address p)
{
int ret;
ret = krb5_store_int16(fd, p.type);
ret = krb5_store_int16(sp, p.type);
if(ret) return ret;
ret = krb5_store_data(fd, p.address);
ret = krb5_store_data(sp, p.address);
return ret;
}
krb5_error_code
krb5_ret_address(int fd, krb5_address *adr)
krb5_ret_address(krb5_storage *sp, krb5_address *adr)
{
int16_t t;
int ret;
ret = krb5_ret_int16(fd, &t);
ret = krb5_ret_int16(sp, &t);
if(ret) return ret;
adr->type = t;
ret = krb5_ret_data(fd, &adr->address);
ret = krb5_ret_data(sp, &adr->address);
return ret;
}
krb5_error_code
krb5_store_addrs(int fd, krb5_addresses p)
krb5_store_addrs(krb5_storage *sp, krb5_addresses p)
{
int i;
int ret;
ret = krb5_store_int32(fd, p.number);
ret = krb5_store_int32(sp, p.number);
if(ret) return ret;
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;
}
return ret;
}
krb5_error_code
krb5_ret_addrs(int fd, krb5_addresses *adr)
krb5_ret_addrs(krb5_storage *sp, krb5_addresses *adr)
{
int i;
int ret;
ret = krb5_ret_int32(fd, &adr->number);
ret = krb5_ret_int32(sp, &adr->number);
if(ret) return ret;
adr->addrs = ALLOC(adr->number, krb5_address);
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;
}
return ret;
}
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_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__
#define __STORE_H__
krb5_error_code
krb5_store_int32(int fd,
int32_t value);
krb5_storage *krb5_storage_from_fd(int fd);
krb5_error_code
krb5_ret_int32(int fd,
int32_t *value);
krb5_storage *krb5_storage_from_mem(void *buf, size_t len);
krb5_error_code
krb5_store_int16(int fd,
int16_t value);
krb5_error_code krb5_storage_free(krb5_storage *sp);
krb5_error_code
krb5_ret_int16(int fd,
int16_t *value);
#define __PT(N, T) krb5_error_code krb5_store_##N(krb5_storage*, T); krb5_error_code krb5_ret_##N(krb5_storage *, T*)
krb5_error_code
krb5_store_int8(int fd,
int8_t value);
__PT(int32, int32_t);
__PT(int16, int16_t);
__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
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);
#undef __PT
#endif /* __STORE_H__ */