From 571250d5f5ab2417d73c5e439c97fa89808d232e Mon Sep 17 00:00:00 2001 From: Paul Park Date: Tue, 29 Aug 1995 18:35:21 +0000 Subject: [PATCH] Add rcache serialization support git-svn-id: svn://anonsvn.mit.edu/krb5/trunk@6617 dc483132-0cff-0310-8789-dd5450dbe970 --- src/lib/krb5/rcache/.Sanitize | 1 + src/lib/krb5/rcache/ChangeLog | 4 + src/lib/krb5/rcache/Makefile.in | 6 +- src/lib/krb5/rcache/ser_rc.c | 216 ++++++++++++++++++++++++++++++++ 4 files changed, 225 insertions(+), 2 deletions(-) create mode 100644 src/lib/krb5/rcache/ser_rc.c diff --git a/src/lib/krb5/rcache/.Sanitize b/src/lib/krb5/rcache/.Sanitize index 8015627ee..83e629405 100644 --- a/src/lib/krb5/rcache/.Sanitize +++ b/src/lib/krb5/rcache/.Sanitize @@ -39,6 +39,7 @@ rc_dfl.h rc_io.c rc_io.h rcdef.c +ser_rc.c Things-to-lose: diff --git a/src/lib/krb5/rcache/ChangeLog b/src/lib/krb5/rcache/ChangeLog index 2009b245b..56245e1e1 100644 --- a/src/lib/krb5/rcache/ChangeLog +++ b/src/lib/krb5/rcache/ChangeLog @@ -1,3 +1,7 @@ + +Tue Aug 29 14:19:54 EDT 1995 Paul Park (pjpark@mit.edu) + * Makefile.in, .Sanitize, ser_rc.c - Add routines to serialize rcache. + Fri Aug 4 22:07:46 1995 Tom Yu * rc_conv.c (krb5_auth_to_rep): Add parens to shut up gcc -Wall diff --git a/src/lib/krb5/rcache/Makefile.in b/src/lib/krb5/rcache/Makefile.in index e5ab7a3e3..69ee6bc76 100644 --- a/src/lib/krb5/rcache/Makefile.in +++ b/src/lib/krb5/rcache/Makefile.in @@ -13,14 +13,16 @@ OBJS= \ rc_dfl.$(OBJEXT) \ rc_io.$(OBJEXT) \ rcdef.$(OBJEXT) \ - rc_conv.$(OBJEXT) + rc_conv.$(OBJEXT) \ + ser_rc.$(OBJEXT) SRCS= \ $(srcdir)/rc_base.c \ $(srcdir)/rc_dfl.c \ $(srcdir)/rc_io.c \ $(srcdir)/rcdef.c \ - $(srcdir)/rc_conv.c + $(srcdir)/rc_conv.c \ + $(srcdir)/ser_rc.c all:: all-$(WHAT) diff --git a/src/lib/krb5/rcache/ser_rc.c b/src/lib/krb5/rcache/ser_rc.c new file mode 100644 index 000000000..4ebfbe080 --- /dev/null +++ b/src/lib/krb5/rcache/ser_rc.c @@ -0,0 +1,216 @@ +/* + * lib/krb5/rcache/ser_rc.c + * + * Copyright 1995 by the Massachusetts Institute of Technology. + * All Rights Reserved. + * + * Export of this software from the United States of America may + * require a specific license from the United States Government. + * It is the responsibility of any person or organization contemplating + * export to obtain such a license before exporting. + * + * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and + * distribute this software and its documentation for any purpose and + * without fee is hereby granted, provided that the above copyright + * notice appear in all copies and that both that copyright notice and + * this permission notice appear in supporting documentation, and that + * the name of M.I.T. not be used in advertising or publicity pertaining + * to distribution of the software without specific, written prior + * permission. M.I.T. makes no representations about the suitability of + * this software for any purpose. It is provided "as is" without express + * or implied warranty. + * + */ + +/* + * ser_rcdfl.c - Serialize replay cache context. + */ +#include "k5-int.h" + +/* + * Routines to deal with externalizing krb5_rcache. + * krb5_rcache_size(); + * krb5_rcache_externalize(); + * krb5_rcache_internalize(); + */ +static krb5_error_code krb5_rcache_size + KRB5_PROTOTYPE((krb5_context, krb5_pointer, size_t *)); +static krb5_error_code krb5_rcache_externalize + KRB5_PROTOTYPE((krb5_context, krb5_pointer, krb5_octet **, size_t *)); +static krb5_error_code krb5_rcache_internalize + KRB5_PROTOTYPE((krb5_context,krb5_pointer *, krb5_octet **, size_t *)); + +/* + * Serialization entry for this type. + */ +static const krb5_ser_entry krb5_rcache_ser_entry = { + KV5M_RCACHE, /* Type */ + krb5_rcache_size, /* Sizer routine */ + krb5_rcache_externalize, /* Externalize routine */ + krb5_rcache_internalize /* Internalize routine */ +}; + +/* + * krb5_rcache_size() - Determine the size required to externalize + * this krb5_rcache variant. + */ +static krb5_error_code +krb5_rcache_size(kcontext, arg, sizep) + krb5_context kcontext; + krb5_pointer arg; + size_t *sizep; +{ + krb5_error_code kret; + krb5_rcache rcache; + size_t required; + + kret = EINVAL; + if ((rcache = (krb5_rcache) arg)) { + /* + * Saving FILE: variants of krb5_rcache requires at minimum: + * krb5_int32 for KV5M_RCACHE + * krb5_int32 for length of rcache name. + * krb5_int32 for KV5M_RCACHE + */ + required = sizeof(krb5_int32) * 3; + if (rcache->ops && rcache->ops->type) + required += (strlen(rcache->ops->type)+1); + + /* + * The rcache name is formed as follows: + * : + */ + required += strlen(krb5_rc_get_name(kcontext, rcache)); + + kret = 0; + *sizep += required; + } + return(kret); +} + +/* + * krb5_rcache_externalize() - Externalize the krb5_rcache. + */ +static krb5_error_code +krb5_rcache_externalize(kcontext, arg, buffer, lenremain) + krb5_context kcontext; + krb5_pointer arg; + krb5_octet **buffer; + size_t *lenremain; +{ + krb5_error_code kret; + krb5_rcache rcache; + size_t required; + krb5_octet *bp; + size_t remain; + char *rcname; + size_t namelen; + char *fnamep; + + required = 0; + bp = *buffer; + remain = *lenremain; + kret = EINVAL; + if ((rcache = (krb5_rcache) arg)) { + kret = ENOMEM; + if (!krb5_rcache_size(kcontext, arg, &required) && + (required <= remain)) { + /* Our identifier */ + (void) krb5_ser_pack_int32(KV5M_RCACHE, &bp, &remain); + + /* Calculate the length of the name */ + namelen = (rcache->ops && rcache->ops->type) ? + strlen(rcache->ops->type)+1 : 0; + fnamep = krb5_rc_get_name(kcontext, rcache); + namelen += (strlen(fnamep)+1); + + if ((rcname = (char *) malloc(namelen))) { + /* Format the rcache name. */ + if (rcache->ops && rcache->ops->type) + sprintf(rcname, "%s:%s", rcache->ops->type, fnamep); + else + strcpy(rcname, fnamep); + + /* Put the length of the file name */ + (void) krb5_ser_pack_int32((krb5_int32) strlen(rcname), + &bp, &remain); + + /* Put the name */ + (void) krb5_ser_pack_bytes((krb5_octet *) rcname, + strlen(rcname), + &bp, &remain); + + /* Put the trailer */ + (void) krb5_ser_pack_int32(KV5M_RCACHE, &bp, &remain); + kret = 0; + *buffer = bp; + *lenremain = remain; + free(rcname); + } + } + } + return(kret); +} + +/* + * krb5_rcache_internalize() - Internalize the krb5_rcache. + */ +static krb5_error_code +krb5_rcache_internalize(kcontext, argp, buffer, lenremain) + krb5_context kcontext; + krb5_pointer *argp; + krb5_octet **buffer; + size_t *lenremain; +{ + krb5_error_code kret; + krb5_rcache rcache; + krb5_int32 ibuf; + krb5_octet *bp; + size_t remain; + char *rcname; + + bp = *buffer; + remain = *lenremain; + kret = EINVAL; + /* Read our magic number */ + if (krb5_ser_unpack_int32(&ibuf, &bp, &remain)) + ibuf = 0; + if (ibuf == KV5M_RCACHE) { + kret = ENOMEM; + + /* Get the length of the rcache name */ + kret = krb5_ser_unpack_int32(&ibuf, &bp, &remain); + + if (!kret && + (rcname = (char *) malloc((size_t) (ibuf+1))) && + !(kret = krb5_ser_unpack_bytes((krb5_octet *) rcname, + (size_t) ibuf, + &bp, &remain))) { + rcname[ibuf] = '\0'; + if (!(kret = krb5_rc_resolve_full(kcontext, &rcache, rcname))) { + (void) krb5_rc_recover(kcontext, rcache); + if (!kret && + !(kret = krb5_ser_unpack_int32(&ibuf, &bp, &remain)) && + (ibuf == KV5M_RCACHE)) { + *buffer = bp; + *lenremain = remain; + *argp = (krb5_pointer) rcache; + } + else + krb5_rc_close(kcontext, rcache); + } + free(rcname); + } + } + return(kret); +} + +/* + * Register the rcache serializer. + */ +krb5_error_code +krb5_ser_rcache_init(kcontext) + krb5_context kcontext; +{ + return(krb5_register_serializer(kcontext, &krb5_rcache_ser_entry)); +} -- 2.26.2