#if 0
#include "k5-int.h"
static krb5_error_code krb5_encrypt_block_size
(krb5_context, krb5_pointer, size_t *);
static krb5_error_code krb5_encrypt_block_externalize
(krb5_context, krb5_pointer, krb5_octet **, size_t *);
static krb5_error_code krb5_encrypt_block_internalize
(krb5_context,krb5_pointer *, krb5_octet **, size_t *);
static const krb5_ser_entry krb5_encrypt_block_ser_entry = {
KV5M_ENCRYPT_BLOCK,
krb5_encrypt_block_size,
krb5_encrypt_block_externalize,
krb5_encrypt_block_internalize
};
static krb5_error_code
krb5_encrypt_block_size(kcontext, arg, sizep)
krb5_context kcontext;
krb5_pointer arg;
size_t *sizep;
{
krb5_error_code kret;
krb5_encrypt_block *encrypt_block;
size_t required;
kret = EINVAL;
if ((encrypt_block = (krb5_encrypt_block *) arg)) {
required = (sizeof(krb5_int32) +
sizeof(krb5_int32) +
sizeof(krb5_int32) +
sizeof(krb5_int32) +
sizeof(krb5_int32) +
(size_t) encrypt_block->priv_size);
if (encrypt_block->key)
kret = krb5_size_opaque(kcontext,
KV5M_KEYBLOCK,
(krb5_pointer) encrypt_block->key,
&required);
else
kret = 0;
if (!kret)
*sizep += required;
}
return(kret);
}
static krb5_error_code
krb5_encrypt_block_externalize(kcontext, arg, buffer, lenremain)
krb5_context kcontext;
krb5_pointer arg;
krb5_octet **buffer;
size_t *lenremain;
{
krb5_error_code kret;
krb5_encrypt_block *encrypt_block;
size_t required;
krb5_octet *bp;
size_t remain;
required = 0;
bp = *buffer;
remain = *lenremain;
kret = EINVAL;
if ((encrypt_block = (krb5_encrypt_block *) arg)) {
kret = ENOMEM;
if (!krb5_encrypt_block_size(kcontext, arg, &required) &&
(required <= remain)) {
(void) krb5_ser_pack_int32(KV5M_ENCRYPT_BLOCK, &bp, &remain);
(void) krb5_ser_pack_int32((krb5_int32) encrypt_block->
crypto_entry->proto_enctype,
&bp, &remain);
(void) krb5_ser_pack_int32((krb5_int32) encrypt_block->priv_size,
&bp, &remain);
(void) krb5_ser_pack_bytes(encrypt_block->priv,
(size_t) encrypt_block->priv_size,
&bp, &remain);
if (encrypt_block->key)
kret = krb5_externalize_opaque(kcontext,
KV5M_KEYBLOCK,
(krb5_pointer)
encrypt_block->key,
&bp,
&remain);
else
kret = 0;
if (!kret) {
(void) krb5_ser_pack_int32(KV5M_ENCRYPT_BLOCK, &bp, &remain);
*buffer = bp;
*lenremain = remain;
}
}
}
return(kret);
}
static krb5_error_code
krb5_encrypt_block_internalize(kcontext, argp, buffer, lenremain)
krb5_context kcontext;
krb5_pointer *argp;
krb5_octet **buffer;
size_t *lenremain;
{
krb5_error_code kret;
krb5_encrypt_block *encrypt_block;
krb5_int32 ibuf;
krb5_enctype ktype;
krb5_octet *bp;
size_t remain;
bp = *buffer;
remain = *lenremain;
kret = EINVAL;
if (krb5_ser_unpack_int32(&ibuf, &bp, &remain))
ibuf = 0;
if (ibuf == KV5M_ENCRYPT_BLOCK) {
kret = ENOMEM;
if ((remain >= (3*sizeof(krb5_int32))) &&
(encrypt_block = (krb5_encrypt_block *)
malloc(sizeof(krb5_encrypt_block)))) {
memset(encrypt_block, 0, sizeof(krb5_encrypt_block));
(void) krb5_ser_unpack_int32(&ibuf, &bp, &remain);
ktype = (krb5_enctype) ibuf;
krb5_use_enctype(kcontext, encrypt_block, ktype);
(void) krb5_ser_unpack_int32(&ibuf, &bp, &remain);
encrypt_block->priv_size = (int) ibuf;
if (!ibuf ||
((encrypt_block->priv = (void *) malloc((size_t) (ibuf))) &&
!(kret = krb5_ser_unpack_bytes((krb5_octet *)
encrypt_block->priv,
(size_t)
encrypt_block->priv_size,
&bp, &remain)))) {
kret = krb5_internalize_opaque(kcontext,
KV5M_KEYBLOCK,
(krb5_pointer *)
&encrypt_block->key,
&bp,
&remain);
if (kret == EINVAL)
kret = 0;
if (!kret) {
kret = krb5_ser_unpack_int32(&ibuf, &bp, &remain);
if (!kret && (ibuf == KV5M_ENCRYPT_BLOCK)) {
*buffer = bp;
*lenremain = remain;
encrypt_block->magic = KV5M_ENCRYPT_BLOCK;
*argp = (krb5_pointer) encrypt_block;
}
else
kret = EINVAL;
}
}
if (kret) {
if (encrypt_block->priv)
free(encrypt_block->priv);
free(encrypt_block);
}
}
}
return(kret);
}
krb5_error_code
krb5_ser_encrypt_block_init(kcontext)
krb5_context kcontext;
{
return(krb5_register_serializer(kcontext, &krb5_encrypt_block_ser_entry));
}
#endif