2 * Copyright (c) 1997-2008 Kungliga Tekniska Högskolan
3 * (Royal Institute of Technology, Stockholm, Sweden).
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
17 * 3. Neither the name of the Institute nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 #include "krb5_locl.h"
35 #include "store-int.h"
37 #define BYTEORDER_IS(SP, V) (((SP)->flags & KRB5_STORAGE_BYTEORDER_MASK) == (V))
38 #define BYTEORDER_IS_LE(SP) BYTEORDER_IS((SP), KRB5_STORAGE_BYTEORDER_LE)
39 #define BYTEORDER_IS_BE(SP) BYTEORDER_IS((SP), KRB5_STORAGE_BYTEORDER_BE)
40 #define BYTEORDER_IS_HOST(SP) (BYTEORDER_IS((SP), KRB5_STORAGE_BYTEORDER_HOST) || \
41 krb5_storage_is_flags((SP), KRB5_STORAGE_HOST_BYTEORDER))
44 * Add the flags on a storage buffer by or-ing in the flags to the buffer.
46 * @param sp the storage buffer to set the flags on
47 * @param flags the flags to set
49 * @ingroup krb5_storage
52 KRB5_LIB_FUNCTION
void KRB5_LIB_CALL
53 krb5_storage_set_flags(krb5_storage
*sp
, krb5_flags flags
)
59 * Clear the flags on a storage buffer
61 * @param sp the storage buffer to clear the flags on
62 * @param flags the flags to clear
64 * @ingroup krb5_storage
67 KRB5_LIB_FUNCTION
void KRB5_LIB_CALL
68 krb5_storage_clear_flags(krb5_storage
*sp
, krb5_flags flags
)
74 * Return true or false depending on if the storage flags is set or
75 * not. NB testing for the flag 0 always return true.
77 * @param sp the storage buffer to check flags on
78 * @param flags The flags to test for
80 * @return true if all the flags are set, false if not.
82 * @ingroup krb5_storage
85 KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
86 krb5_storage_is_flags(krb5_storage
*sp
, krb5_flags flags
)
88 return (sp
->flags
& flags
) == flags
;
92 * Set the new byte order of the storage buffer.
94 * @param sp the storage buffer to set the byte order for.
95 * @param byteorder the new byte order.
97 * The byte order are: KRB5_STORAGE_BYTEORDER_BE,
98 * KRB5_STORAGE_BYTEORDER_LE and KRB5_STORAGE_BYTEORDER_HOST.
100 * @ingroup krb5_storage
103 KRB5_LIB_FUNCTION
void KRB5_LIB_CALL
104 krb5_storage_set_byteorder(krb5_storage
*sp
, krb5_flags byteorder
)
106 sp
->flags
&= ~KRB5_STORAGE_BYTEORDER_MASK
;
107 sp
->flags
|= byteorder
;
111 * Return the current byteorder for the buffer. See krb5_storage_set_byteorder() for the list or byte order contants.
113 * @ingroup krb5_storage
116 KRB5_LIB_FUNCTION krb5_flags KRB5_LIB_CALL
117 krb5_storage_get_byteorder(krb5_storage
*sp
)
119 return sp
->flags
& KRB5_STORAGE_BYTEORDER_MASK
;
123 * Seek to a new offset.
125 * @param sp the storage buffer to seek in.
126 * @param offset the offset to seek
127 * @param whence relateive searching, SEEK_CUR from the current
128 * position, SEEK_END from the end, SEEK_SET absolute from the start.
130 * @return The new current offset
132 * @ingroup krb5_storage
135 KRB5_LIB_FUNCTION off_t KRB5_LIB_CALL
136 krb5_storage_seek(krb5_storage
*sp
, off_t offset
, int whence
)
138 return (*sp
->seek
)(sp
, offset
, whence
);
142 * Truncate the storage buffer in sp to offset.
144 * @param sp the storage buffer to truncate.
145 * @param offset the offset to truncate too.
147 * @return An Kerberos 5 error code.
149 * @ingroup krb5_storage
152 KRB5_LIB_FUNCTION
int KRB5_LIB_CALL
153 krb5_storage_truncate(krb5_storage
*sp
, off_t offset
)
155 return (*sp
->trunc
)(sp
, offset
);
159 * Read to the storage buffer.
161 * @param sp the storage buffer to read from
162 * @param buf the buffer to store the data in
163 * @param len the length to read
165 * @return The length of data read (can be shorter then len), or negative on error.
167 * @ingroup krb5_storage
170 KRB5_LIB_FUNCTION krb5_ssize_t KRB5_LIB_CALL
171 krb5_storage_read(krb5_storage
*sp
, void *buf
, size_t len
)
173 return sp
->fetch(sp
, buf
, len
);
177 * Write to the storage buffer.
179 * @param sp the storage buffer to write to
180 * @param buf the buffer to write to the storage buffer
181 * @param len the length to write
183 * @return The length of data written (can be shorter then len), or negative on error.
185 * @ingroup krb5_storage
188 KRB5_LIB_FUNCTION krb5_ssize_t KRB5_LIB_CALL
189 krb5_storage_write(krb5_storage
*sp
, const void *buf
, size_t len
)
191 return sp
->store(sp
, buf
, len
);
195 * Set the return code that will be used when end of storage is reached.
197 * @param sp the storage
198 * @param code the error code to return on end of storage
200 * @ingroup krb5_storage
203 KRB5_LIB_FUNCTION
void KRB5_LIB_CALL
204 krb5_storage_set_eof_code(krb5_storage
*sp
, int code
)
210 * Get the return code that will be used when end of storage is reached.
212 * @param sp the storage
214 * @return storage error code
216 * @ingroup krb5_storage
219 KRB5_LIB_FUNCTION
int KRB5_LIB_CALL
220 krb5_storage_get_eof_code(krb5_storage
*sp
)
225 KRB5_LIB_FUNCTION krb5_ssize_t KRB5_LIB_CALL
226 _krb5_put_int(void *buffer
, unsigned long value
, size_t size
)
228 unsigned char *p
= buffer
;
230 for (i
= size
- 1; i
>= 0; i
--) {
237 KRB5_LIB_FUNCTION krb5_ssize_t KRB5_LIB_CALL
238 _krb5_get_int(void *buffer
, unsigned long *value
, size_t size
)
240 unsigned char *p
= buffer
;
243 for (i
= 0; i
< size
; i
++)
250 * Free a krb5 storage.
252 * @param sp the storage to free.
254 * @return An Kerberos 5 error code.
256 * @ingroup krb5_storage
259 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
260 krb5_storage_free(krb5_storage
*sp
)
270 * Copy the contnent of storage
272 * @param sp the storage to copy to a data
273 * @param data the copied data, free with krb5_data_free()
275 * @return 0 for success, or a Kerberos 5 error code on failure.
277 * @ingroup krb5_storage
280 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
281 krb5_storage_to_data(krb5_storage
*sp
, krb5_data
*data
)
286 pos
= sp
->seek(sp
, 0, SEEK_CUR
);
288 return HEIM_ERR_NOT_SEEKABLE
;
289 size
= (size_t)sp
->seek(sp
, 0, SEEK_END
);
290 if (size
> (size_t)-1)
291 return HEIM_ERR_TOO_BIG
;
292 ret
= krb5_data_alloc (data
, size
);
294 sp
->seek(sp
, pos
, SEEK_SET
);
298 sp
->seek(sp
, 0, SEEK_SET
);
299 sp
->fetch(sp
, data
->data
, data
->length
);
300 sp
->seek(sp
, pos
, SEEK_SET
);
305 static krb5_error_code
306 krb5_store_int(krb5_storage
*sp
,
315 _krb5_put_int(v
, value
, len
);
316 ret
= sp
->store(sp
, v
, len
);
318 return (ret
<0)?errno
:sp
->eof_code
;
323 * Store a int32 to storage, byte order is controlled by the settings
324 * on the storage, see krb5_storage_set_byteorder().
326 * @param sp the storage to write too
327 * @param value the value to store
329 * @return 0 for success, or a Kerberos 5 error code on failure.
331 * @ingroup krb5_storage
334 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
335 krb5_store_int32(krb5_storage
*sp
,
338 if(BYTEORDER_IS_HOST(sp
))
339 value
= htonl(value
);
340 else if(BYTEORDER_IS_LE(sp
))
341 value
= bswap32(value
);
342 return krb5_store_int(sp
, value
, 4);
346 * Store a uint32 to storage, byte order is controlled by the settings
347 * on the storage, see krb5_storage_set_byteorder().
349 * @param sp the storage to write too
350 * @param value the value to store
352 * @return 0 for success, or a Kerberos 5 error code on failure.
354 * @ingroup krb5_storage
357 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
358 krb5_store_uint32(krb5_storage
*sp
,
361 return krb5_store_int32(sp
, (int32_t)value
);
364 static krb5_error_code
365 krb5_ret_int(krb5_storage
*sp
,
372 ret
= sp
->fetch(sp
, v
, len
);
374 return (ret
<0)?errno
:sp
->eof_code
;
375 _krb5_get_int(v
, &w
, len
);
381 * Read a int32 from storage, byte order is controlled by the settings
382 * on the storage, see krb5_storage_set_byteorder().
384 * @param sp the storage to write too
385 * @param value the value read from the buffer
387 * @return 0 for success, or a Kerberos 5 error code on failure.
389 * @ingroup krb5_storage
392 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
393 krb5_ret_int32(krb5_storage
*sp
,
396 krb5_error_code ret
= krb5_ret_int(sp
, value
, 4);
399 if(BYTEORDER_IS_HOST(sp
))
400 *value
= htonl(*value
);
401 else if(BYTEORDER_IS_LE(sp
))
402 *value
= bswap32(*value
);
407 * Read a uint32 from storage, byte order is controlled by the settings
408 * on the storage, see krb5_storage_set_byteorder().
410 * @param sp the storage to write too
411 * @param value the value read from the buffer
413 * @return 0 for success, or a Kerberos 5 error code on failure.
415 * @ingroup krb5_storage
418 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
419 krb5_ret_uint32(krb5_storage
*sp
,
425 ret
= krb5_ret_int32(sp
, &v
);
427 *value
= (uint32_t)v
;
433 * Store a int16 to storage, byte order is controlled by the settings
434 * on the storage, see krb5_storage_set_byteorder().
436 * @param sp the storage to write too
437 * @param value the value to store
439 * @return 0 for success, or a Kerberos 5 error code on failure.
441 * @ingroup krb5_storage
444 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
445 krb5_store_int16(krb5_storage
*sp
,
448 if(BYTEORDER_IS_HOST(sp
))
449 value
= htons(value
);
450 else if(BYTEORDER_IS_LE(sp
))
451 value
= bswap16(value
);
452 return krb5_store_int(sp
, value
, 2);
456 * Store a uint16 to storage, byte order is controlled by the settings
457 * on the storage, see krb5_storage_set_byteorder().
459 * @param sp the storage to write too
460 * @param value the value to store
462 * @return 0 for success, or a Kerberos 5 error code on failure.
464 * @ingroup krb5_storage
467 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
468 krb5_store_uint16(krb5_storage
*sp
,
471 return krb5_store_int16(sp
, (int16_t)value
);
475 * Read a int16 from storage, byte order is controlled by the settings
476 * on the storage, see krb5_storage_set_byteorder().
478 * @param sp the storage to write too
479 * @param value the value read from the buffer
481 * @return 0 for success, or a Kerberos 5 error code on failure.
483 * @ingroup krb5_storage
486 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
487 krb5_ret_int16(krb5_storage
*sp
,
492 ret
= krb5_ret_int(sp
, &v
, 2);
496 if(BYTEORDER_IS_HOST(sp
))
497 *value
= htons(*value
);
498 else if(BYTEORDER_IS_LE(sp
))
499 *value
= bswap16(*value
);
504 * Read a int16 from storage, byte order is controlled by the settings
505 * on the storage, see krb5_storage_set_byteorder().
507 * @param sp the storage to write too
508 * @param value the value read from the buffer
510 * @return 0 for success, or a Kerberos 5 error code on failure.
512 * @ingroup krb5_storage
515 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
516 krb5_ret_uint16(krb5_storage
*sp
,
522 ret
= krb5_ret_int16(sp
, &v
);
524 *value
= (uint16_t)v
;
530 * Store a int8 to storage.
532 * @param sp the storage to write too
533 * @param value the value to store
535 * @return 0 for success, or a Kerberos 5 error code on failure.
537 * @ingroup krb5_storage
540 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
541 krb5_store_int8(krb5_storage
*sp
,
546 ret
= sp
->store(sp
, &value
, sizeof(value
));
547 if (ret
!= sizeof(value
))
548 return (ret
<0)?errno
:sp
->eof_code
;
553 * Store a uint8 to storage.
555 * @param sp the storage to write too
556 * @param value the value to store
558 * @return 0 for success, or a Kerberos 5 error code on failure.
560 * @ingroup krb5_storage
563 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
564 krb5_store_uint8(krb5_storage
*sp
,
567 return krb5_store_int8(sp
, (int8_t)value
);
571 * Read a int8 from storage
573 * @param sp the storage to write too
574 * @param value the value read from the buffer
576 * @return 0 for success, or a Kerberos 5 error code on failure.
578 * @ingroup krb5_storage
581 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
582 krb5_ret_int8(krb5_storage
*sp
,
587 ret
= sp
->fetch(sp
, value
, sizeof(*value
));
588 if (ret
!= sizeof(*value
))
589 return (ret
<0)?errno
:sp
->eof_code
;
594 * Read a uint8 from storage
596 * @param sp the storage to write too
597 * @param value the value read from the buffer
599 * @return 0 for success, or a Kerberos 5 error code on failure.
601 * @ingroup krb5_storage
604 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
605 krb5_ret_uint8(krb5_storage
*sp
,
611 ret
= krb5_ret_int8(sp
, &v
);
619 * Store a data to the storage. The data is stored with an int32 as
620 * lenght plus the data (not padded).
622 * @param sp the storage buffer to write to
623 * @param data the buffer to store.
625 * @return 0 on success, a Kerberos 5 error code on failure.
627 * @ingroup krb5_storage
630 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
631 krb5_store_data(krb5_storage
*sp
,
635 ret
= krb5_store_int32(sp
, data
.length
);
638 ret
= sp
->store(sp
, data
.data
, data
.length
);
639 if(ret
!= data
.length
){
648 * Parse a data from the storage.
650 * @param sp the storage buffer to read from
651 * @param data the parsed data
653 * @return 0 on success, a Kerberos 5 error code on failure.
655 * @ingroup krb5_storage
658 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
659 krb5_ret_data(krb5_storage
*sp
,
665 ret
= krb5_ret_int32(sp
, &size
);
668 ret
= krb5_data_alloc (data
, size
);
672 ret
= sp
->fetch(sp
, data
->data
, size
);
674 return (ret
< 0)? errno
: sp
->eof_code
;
680 * Store a string to the buffer. The data is formated as an len:uint32
681 * plus the string itself (not padded).
683 * @param sp the storage buffer to write to
684 * @param s the string to store.
686 * @return 0 on success, a Kerberos 5 error code on failure.
688 * @ingroup krb5_storage
691 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
692 krb5_store_string(krb5_storage
*sp
, const char *s
)
695 data
.length
= strlen(s
);
696 data
.data
= rk_UNCONST(s
);
697 return krb5_store_data(sp
, data
);
701 * Parse a string from the storage.
703 * @param sp the storage buffer to read from
704 * @param string the parsed string
706 * @return 0 on success, a Kerberos 5 error code on failure.
708 * @ingroup krb5_storage
712 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
713 krb5_ret_string(krb5_storage
*sp
,
718 ret
= krb5_ret_data(sp
, &data
);
721 *string
= realloc(data
.data
, data
.length
+ 1);
726 (*string
)[data
.length
] = 0;
731 * Store a zero terminated string to the buffer. The data is stored
732 * one character at a time until a NUL is stored.
734 * @param sp the storage buffer to write to
735 * @param s the string to store.
737 * @return 0 on success, a Kerberos 5 error code on failure.
739 * @ingroup krb5_storage
742 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
743 krb5_store_stringz(krb5_storage
*sp
, const char *s
)
745 size_t len
= strlen(s
) + 1;
748 ret
= sp
->store(sp
, s
, len
);
759 * Parse zero terminated string from the storage.
761 * @param sp the storage buffer to read from
762 * @param string the parsed string
764 * @return 0 on success, a Kerberos 5 error code on failure.
766 * @ingroup krb5_storage
769 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
770 krb5_ret_stringz(krb5_storage
*sp
,
778 while((ret
= sp
->fetch(sp
, &c
, 1)) == 1){
782 tmp
= realloc (s
, len
);
802 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
803 krb5_store_stringnl(krb5_storage
*sp
, const char *s
)
805 size_t len
= strlen(s
);
808 ret
= sp
->store(sp
, s
, len
);
815 ret
= sp
->store(sp
, "\n", 1);
827 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
828 krb5_ret_stringnl(krb5_storage
*sp
,
837 while((ret
= sp
->fetch(sp
, &c
, 1)) == 1){
844 if (expect_nl
&& c
!= '\n') {
846 return KRB5_BADMSGTYPE
;
850 tmp
= realloc (s
, len
);
873 * Write a principal block to storage.
875 * @param sp the storage buffer to write to
876 * @param p the principal block to write.
878 * @return 0 on success, a Kerberos 5 error code on failure.
880 * @ingroup krb5_storage
883 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
884 krb5_store_principal(krb5_storage
*sp
,
885 krb5_const_principal p
)
890 if(!krb5_storage_is_flags(sp
, KRB5_STORAGE_PRINCIPAL_NO_NAME_TYPE
)) {
891 ret
= krb5_store_int32(sp
, p
->name
.name_type
);
894 if(krb5_storage_is_flags(sp
, KRB5_STORAGE_PRINCIPAL_WRONG_NUM_COMPONENTS
))
895 ret
= krb5_store_int32(sp
, p
->name
.name_string
.len
+ 1);
897 ret
= krb5_store_int32(sp
, p
->name
.name_string
.len
);
900 ret
= krb5_store_string(sp
, p
->realm
);
902 for(i
= 0; i
< p
->name
.name_string
.len
; i
++){
903 ret
= krb5_store_string(sp
, p
->name
.name_string
.val
[i
]);
910 * Parse principal from the storage.
912 * @param sp the storage buffer to read from
913 * @param princ the parsed principal
915 * @return 0 on success, a Kerberos 5 error code on failure.
917 * @ingroup krb5_storage
920 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
921 krb5_ret_principal(krb5_storage
*sp
,
922 krb5_principal
*princ
)
930 p
= calloc(1, sizeof(*p
));
934 if(krb5_storage_is_flags(sp
, KRB5_STORAGE_PRINCIPAL_NO_NAME_TYPE
))
935 type
= KRB5_NT_UNKNOWN
;
936 else if((ret
= krb5_ret_int32(sp
, &type
))){
940 if((ret
= krb5_ret_int32(sp
, &ncomp
))){
944 if(krb5_storage_is_flags(sp
, KRB5_STORAGE_PRINCIPAL_WRONG_NUM_COMPONENTS
))
950 p
->name
.name_type
= type
;
951 p
->name
.name_string
.len
= ncomp
;
952 ret
= krb5_ret_string(sp
, &p
->realm
);
957 p
->name
.name_string
.val
= calloc(ncomp
, sizeof(*p
->name
.name_string
.val
));
958 if(p
->name
.name_string
.val
== NULL
&& ncomp
!= 0){
963 for(i
= 0; i
< ncomp
; i
++){
964 ret
= krb5_ret_string(sp
, &p
->name
.name_string
.val
[i
]);
967 free(p
->name
.name_string
.val
[i
--]);
978 * Store a keyblock to the storage.
980 * @param sp the storage buffer to write to
981 * @param p the keyblock to write
983 * @return 0 on success, a Kerberos 5 error code on failure.
985 * @ingroup krb5_storage
988 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
989 krb5_store_keyblock(krb5_storage
*sp
, krb5_keyblock p
)
992 ret
= krb5_store_int16(sp
, p
.keytype
);
995 if(krb5_storage_is_flags(sp
, KRB5_STORAGE_KEYBLOCK_KEYTYPE_TWICE
)){
996 /* this should really be enctype, but it is the same as
998 ret
= krb5_store_int16(sp
, p
.keytype
);
1002 ret
= krb5_store_data(sp
, p
.keyvalue
);
1007 * Read a keyblock from the storage.
1009 * @param sp the storage buffer to write to
1010 * @param p the keyblock read from storage, free using krb5_free_keyblock()
1012 * @return 0 on success, a Kerberos 5 error code on failure.
1014 * @ingroup krb5_storage
1017 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1018 krb5_ret_keyblock(krb5_storage
*sp
, krb5_keyblock
*p
)
1023 ret
= krb5_ret_int16(sp
, &tmp
);
1027 if(krb5_storage_is_flags(sp
, KRB5_STORAGE_KEYBLOCK_KEYTYPE_TWICE
)){
1028 ret
= krb5_ret_int16(sp
, &tmp
);
1032 ret
= krb5_ret_data(sp
, &p
->keyvalue
);
1037 * Write a times block to storage.
1039 * @param sp the storage buffer to write to
1040 * @param times the times block to write.
1042 * @return 0 on success, a Kerberos 5 error code on failure.
1044 * @ingroup krb5_storage
1047 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1048 krb5_store_times(krb5_storage
*sp
, krb5_times times
)
1051 ret
= krb5_store_int32(sp
, times
.authtime
);
1053 ret
= krb5_store_int32(sp
, times
.starttime
);
1055 ret
= krb5_store_int32(sp
, times
.endtime
);
1057 ret
= krb5_store_int32(sp
, times
.renew_till
);
1062 * Read a times block from the storage.
1064 * @param sp the storage buffer to write to
1065 * @param times the times block read from storage
1067 * @return 0 on success, a Kerberos 5 error code on failure.
1069 * @ingroup krb5_storage
1072 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1073 krb5_ret_times(krb5_storage
*sp
, krb5_times
*times
)
1077 ret
= krb5_ret_int32(sp
, &tmp
);
1078 times
->authtime
= tmp
;
1080 ret
= krb5_ret_int32(sp
, &tmp
);
1081 times
->starttime
= tmp
;
1083 ret
= krb5_ret_int32(sp
, &tmp
);
1084 times
->endtime
= tmp
;
1086 ret
= krb5_ret_int32(sp
, &tmp
);
1087 times
->renew_till
= tmp
;
1092 * Write a address block to storage.
1094 * @param sp the storage buffer to write to
1095 * @param p the address block to write.
1097 * @return 0 on success, a Kerberos 5 error code on failure.
1099 * @ingroup krb5_storage
1102 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1103 krb5_store_address(krb5_storage
*sp
, krb5_address p
)
1106 ret
= krb5_store_int16(sp
, p
.addr_type
);
1108 ret
= krb5_store_data(sp
, p
.address
);
1113 * Read a address block from the storage.
1115 * @param sp the storage buffer to write to
1116 * @param adr the address block read from storage
1118 * @return 0 on success, a Kerberos 5 error code on failure.
1120 * @ingroup krb5_storage
1123 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1124 krb5_ret_address(krb5_storage
*sp
, krb5_address
*adr
)
1128 ret
= krb5_ret_int16(sp
, &t
);
1131 ret
= krb5_ret_data(sp
, &adr
->address
);
1136 * Write a addresses block to storage.
1138 * @param sp the storage buffer to write to
1139 * @param p the addresses block to write.
1141 * @return 0 on success, a Kerberos 5 error code on failure.
1143 * @ingroup krb5_storage
1146 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1147 krb5_store_addrs(krb5_storage
*sp
, krb5_addresses p
)
1151 ret
= krb5_store_int32(sp
, p
.len
);
1153 for(i
= 0; i
<p
.len
; i
++){
1154 ret
= krb5_store_address(sp
, p
.val
[i
]);
1161 * Read a addresses block from the storage.
1163 * @param sp the storage buffer to write to
1164 * @param adr the addresses block read from storage
1166 * @return 0 on success, a Kerberos 5 error code on failure.
1168 * @ingroup krb5_storage
1171 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1172 krb5_ret_addrs(krb5_storage
*sp
, krb5_addresses
*adr
)
1178 ret
= krb5_ret_int32(sp
, &tmp
);
1181 ALLOC(adr
->val
, adr
->len
);
1182 if (adr
->val
== NULL
&& adr
->len
!= 0)
1184 for(i
= 0; i
< adr
->len
; i
++){
1185 ret
= krb5_ret_address(sp
, &adr
->val
[i
]);
1192 * Write a auth data block to storage.
1194 * @param sp the storage buffer to write to
1195 * @param auth the auth data block to write.
1197 * @return 0 on success, a Kerberos 5 error code on failure.
1199 * @ingroup krb5_storage
1202 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1203 krb5_store_authdata(krb5_storage
*sp
, krb5_authdata auth
)
1205 krb5_error_code ret
;
1207 ret
= krb5_store_int32(sp
, auth
.len
);
1209 for(i
= 0; i
< auth
.len
; i
++){
1210 ret
= krb5_store_int16(sp
, auth
.val
[i
].ad_type
);
1212 ret
= krb5_store_data(sp
, auth
.val
[i
].ad_data
);
1219 * Read a auth data from the storage.
1221 * @param sp the storage buffer to write to
1222 * @param auth the auth data block read from storage
1224 * @return 0 on success, a Kerberos 5 error code on failure.
1226 * @ingroup krb5_storage
1229 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1230 krb5_ret_authdata(krb5_storage
*sp
, krb5_authdata
*auth
)
1232 krb5_error_code ret
;
1236 ret
= krb5_ret_int32(sp
, &tmp
);
1238 ALLOC_SEQ(auth
, tmp
);
1239 if (auth
->val
== NULL
&& tmp
!= 0)
1241 for(i
= 0; i
< tmp
; i
++){
1242 ret
= krb5_ret_int16(sp
, &tmp2
);
1244 auth
->val
[i
].ad_type
= tmp2
;
1245 ret
= krb5_ret_data(sp
, &auth
->val
[i
].ad_data
);
1252 bitswap32(int32_t b
)
1256 for (i
= 0; i
< 32; i
++) {
1257 r
= r
<< 1 | (b
& 1);
1264 * Write a credentials block to storage.
1266 * @param sp the storage buffer to write to
1267 * @param creds the creds block to write.
1269 * @return 0 on success, a Kerberos 5 error code on failure.
1271 * @ingroup krb5_storage
1274 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1275 krb5_store_creds(krb5_storage
*sp
, krb5_creds
*creds
)
1279 ret
= krb5_store_principal(sp
, creds
->client
);
1282 ret
= krb5_store_principal(sp
, creds
->server
);
1285 ret
= krb5_store_keyblock(sp
, creds
->session
);
1288 ret
= krb5_store_times(sp
, creds
->times
);
1291 ret
= krb5_store_int8(sp
, creds
->second_ticket
.length
!= 0); /* is_skey */
1295 if(krb5_storage_is_flags(sp
, KRB5_STORAGE_CREDS_FLAGS_WRONG_BITORDER
))
1296 ret
= krb5_store_int32(sp
, creds
->flags
.i
);
1298 ret
= krb5_store_int32(sp
, bitswap32(TicketFlags2int(creds
->flags
.b
)));
1302 ret
= krb5_store_addrs(sp
, creds
->addresses
);
1305 ret
= krb5_store_authdata(sp
, creds
->authdata
);
1308 ret
= krb5_store_data(sp
, creds
->ticket
);
1311 ret
= krb5_store_data(sp
, creds
->second_ticket
);
1316 * Read a credentials block from the storage.
1318 * @param sp the storage buffer to write to
1319 * @param creds the credentials block read from storage
1321 * @return 0 on success, a Kerberos 5 error code on failure.
1323 * @ingroup krb5_storage
1326 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1327 krb5_ret_creds(krb5_storage
*sp
, krb5_creds
*creds
)
1329 krb5_error_code ret
;
1333 memset(creds
, 0, sizeof(*creds
));
1334 ret
= krb5_ret_principal (sp
, &creds
->client
);
1335 if(ret
) goto cleanup
;
1336 ret
= krb5_ret_principal (sp
, &creds
->server
);
1337 if(ret
) goto cleanup
;
1338 ret
= krb5_ret_keyblock (sp
, &creds
->session
);
1339 if(ret
) goto cleanup
;
1340 ret
= krb5_ret_times (sp
, &creds
->times
);
1341 if(ret
) goto cleanup
;
1342 ret
= krb5_ret_int8 (sp
, &dummy8
);
1343 if(ret
) goto cleanup
;
1344 ret
= krb5_ret_int32 (sp
, &dummy32
);
1345 if(ret
) goto cleanup
;
1347 * Runtime detect the what is the higher bits of the bitfield. If
1348 * any of the higher bits are set in the input data, it's either a
1349 * new ticket flag (and this code need to be removed), or it's a
1350 * MIT cache (or new Heimdal cache), lets change it to our current
1354 uint32_t mask
= 0xffff0000;
1356 creds
->flags
.b
.anonymous
= 1;
1357 if (creds
->flags
.i
& mask
)
1360 dummy32
= bitswap32(dummy32
);
1362 creds
->flags
.i
= dummy32
;
1363 ret
= krb5_ret_addrs (sp
, &creds
->addresses
);
1364 if(ret
) goto cleanup
;
1365 ret
= krb5_ret_authdata (sp
, &creds
->authdata
);
1366 if(ret
) goto cleanup
;
1367 ret
= krb5_ret_data (sp
, &creds
->ticket
);
1368 if(ret
) goto cleanup
;
1369 ret
= krb5_ret_data (sp
, &creds
->second_ticket
);
1373 krb5_free_cred_contents(context
, creds
); /* XXX */
1379 #define SC_CLIENT_PRINCIPAL 0x0001
1380 #define SC_SERVER_PRINCIPAL 0x0002
1381 #define SC_SESSION_KEY 0x0004
1382 #define SC_TICKET 0x0008
1383 #define SC_SECOND_TICKET 0x0010
1384 #define SC_AUTHDATA 0x0020
1385 #define SC_ADDRESSES 0x0040
1388 * Write a tagged credentials block to storage.
1390 * @param sp the storage buffer to write to
1391 * @param creds the creds block to write.
1393 * @return 0 on success, a Kerberos 5 error code on failure.
1395 * @ingroup krb5_storage
1398 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1399 krb5_store_creds_tag(krb5_storage
*sp
, krb5_creds
*creds
)
1405 header
|= SC_CLIENT_PRINCIPAL
;
1407 header
|= SC_SERVER_PRINCIPAL
;
1408 if (creds
->session
.keytype
!= ETYPE_NULL
)
1409 header
|= SC_SESSION_KEY
;
1410 if (creds
->ticket
.data
)
1411 header
|= SC_TICKET
;
1412 if (creds
->second_ticket
.length
)
1413 header
|= SC_SECOND_TICKET
;
1414 if (creds
->authdata
.len
)
1415 header
|= SC_AUTHDATA
;
1416 if (creds
->addresses
.len
)
1417 header
|= SC_ADDRESSES
;
1419 ret
= krb5_store_int32(sp
, header
);
1423 if (creds
->client
) {
1424 ret
= krb5_store_principal(sp
, creds
->client
);
1429 if (creds
->server
) {
1430 ret
= krb5_store_principal(sp
, creds
->server
);
1435 if (creds
->session
.keytype
!= ETYPE_NULL
) {
1436 ret
= krb5_store_keyblock(sp
, creds
->session
);
1441 ret
= krb5_store_times(sp
, creds
->times
);
1444 ret
= krb5_store_int8(sp
, creds
->second_ticket
.length
!= 0); /* is_skey */
1448 ret
= krb5_store_int32(sp
, bitswap32(TicketFlags2int(creds
->flags
.b
)));
1452 if (creds
->addresses
.len
) {
1453 ret
= krb5_store_addrs(sp
, creds
->addresses
);
1458 if (creds
->authdata
.len
) {
1459 ret
= krb5_store_authdata(sp
, creds
->authdata
);
1464 if (creds
->ticket
.data
) {
1465 ret
= krb5_store_data(sp
, creds
->ticket
);
1470 if (creds
->second_ticket
.data
) {
1471 ret
= krb5_store_data(sp
, creds
->second_ticket
);
1480 * Read a tagged credentials block from the storage.
1482 * @param sp the storage buffer to write to
1483 * @param creds the credentials block read from storage
1485 * @return 0 on success, a Kerberos 5 error code on failure.
1487 * @ingroup krb5_storage
1490 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1491 krb5_ret_creds_tag(krb5_storage
*sp
,
1494 krb5_error_code ret
;
1496 int32_t dummy32
, header
;
1498 memset(creds
, 0, sizeof(*creds
));
1500 ret
= krb5_ret_int32 (sp
, &header
);
1501 if (ret
) goto cleanup
;
1503 if (header
& SC_CLIENT_PRINCIPAL
) {
1504 ret
= krb5_ret_principal (sp
, &creds
->client
);
1505 if(ret
) goto cleanup
;
1507 if (header
& SC_SERVER_PRINCIPAL
) {
1508 ret
= krb5_ret_principal (sp
, &creds
->server
);
1509 if(ret
) goto cleanup
;
1511 if (header
& SC_SESSION_KEY
) {
1512 ret
= krb5_ret_keyblock (sp
, &creds
->session
);
1513 if(ret
) goto cleanup
;
1515 ret
= krb5_ret_times (sp
, &creds
->times
);
1516 if(ret
) goto cleanup
;
1517 ret
= krb5_ret_int8 (sp
, &dummy8
);
1518 if(ret
) goto cleanup
;
1519 ret
= krb5_ret_int32 (sp
, &dummy32
);
1520 if(ret
) goto cleanup
;
1522 * Runtime detect the what is the higher bits of the bitfield. If
1523 * any of the higher bits are set in the input data, it's either a
1524 * new ticket flag (and this code need to be removed), or it's a
1525 * MIT cache (or new Heimdal cache), lets change it to our current
1529 uint32_t mask
= 0xffff0000;
1531 creds
->flags
.b
.anonymous
= 1;
1532 if (creds
->flags
.i
& mask
)
1535 dummy32
= bitswap32(dummy32
);
1537 creds
->flags
.i
= dummy32
;
1538 if (header
& SC_ADDRESSES
) {
1539 ret
= krb5_ret_addrs (sp
, &creds
->addresses
);
1540 if(ret
) goto cleanup
;
1542 if (header
& SC_AUTHDATA
) {
1543 ret
= krb5_ret_authdata (sp
, &creds
->authdata
);
1544 if(ret
) goto cleanup
;
1546 if (header
& SC_TICKET
) {
1547 ret
= krb5_ret_data (sp
, &creds
->ticket
);
1548 if(ret
) goto cleanup
;
1550 if (header
& SC_SECOND_TICKET
) {
1551 ret
= krb5_ret_data (sp
, &creds
->second_ticket
);
1552 if(ret
) goto cleanup
;
1558 krb5_free_cred_contents(context
, creds
); /* XXX */