diff --git a/lib/krb5/store.c b/lib/krb5/store.c
index fc950a39b..ca0884555 100644
--- a/lib/krb5/store.c
+++ b/lib/krb5/store.c
@@ -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);
 }
diff --git a/lib/krb5/store.h b/lib/krb5/store.h
index 8c96db43a..700f39e99 100644
--- a/lib/krb5/store.h
+++ b/lib/krb5/store.h
@@ -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__ */