Debian Codegraph @

lib/krb5/keytab_file.c

raw
1 /*
2 * Copyright (c) 1997 - 2008 Kungliga Tekniska Högskolan
3 * (Royal Institute of Technology, Stockholm, Sweden).
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
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.
16 *
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.
20 *
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
31 * SUCH DAMAGE.
32 */
33
34 #include "krb5_locl.h"
35
36 #define KRB5_KT_VNO_1 1
37 #define KRB5_KT_VNO_2 2
38 #define KRB5_KT_VNO KRB5_KT_VNO_2
39
40 #define KRB5_KT_FL_JAVA 1
41
42
43 /* file operations -------------------------------------------- */
44
45 struct fkt_data {
46 char *filename;
47 int flags;
48 };
49
50 static krb5_error_code
51 krb5_kt_ret_data(krb5_context context,
52 krb5_storage *sp,
53 krb5_data *data)
54 {
55 int ret;
56 int16_t size;
57 ret = krb5_ret_int16(sp, &size);
58 if(ret)
59 return ret;
60 data->length = size;
61 data->data = malloc(size);
62 if (data->data == NULL)
63 return krb5_enomem(context);
64 ret = krb5_storage_read(sp, data->data, size);
65 if(ret != size)
66 return (ret < 0)? errno : KRB5_KT_END;
67 return 0;
68 }
69
70 static krb5_error_code
71 krb5_kt_ret_string(krb5_context context,
72 krb5_storage *sp,
73 heim_general_string *data)
74 {
75 int ret;
76 int16_t size;
77 ret = krb5_ret_int16(sp, &size);
78 if(ret)
79 return ret;
80 *data = malloc(size + 1);
81 if (*data == NULL)
82 return krb5_enomem(context);
83 ret = krb5_storage_read(sp, *data, size);
84 (*data)[size] = '\0';
85 if(ret != size)
86 return (ret < 0)? errno : KRB5_KT_END;
87 return 0;
88 }
89
90 static krb5_error_code
91 krb5_kt_store_data(krb5_context context,
92 krb5_storage *sp,
93 krb5_data data)
94 {
95 int ret;
96 ret = krb5_store_int16(sp, data.length);
97 if(ret < 0)
98 return ret;
99 ret = krb5_storage_write(sp, data.data, data.length);
100 if(ret != (int)data.length){
101 if(ret < 0)
102 return errno;
103 return KRB5_KT_END;
104 }
105 return 0;
106 }
107
108 static krb5_error_code
109 krb5_kt_store_string(krb5_storage *sp,
110 heim_general_string data)
111 {
112 int ret;
113 size_t len = strlen(data);
114 ret = krb5_store_int16(sp, len);
115 if(ret < 0)
116 return ret;
117 ret = krb5_storage_write(sp, data, len);
118 if(ret != (int)len){
119 if(ret < 0)
120 return errno;
121 return KRB5_KT_END;
122 }
123 return 0;
124 }
125
126 static krb5_error_code
127 krb5_kt_ret_keyblock(krb5_context context,
128 struct fkt_data *fkt,
129 krb5_storage *sp,
130 krb5_keyblock *p)
131 {
132 int ret;
133 int16_t tmp;
134
135 ret = krb5_ret_int16(sp, &tmp); /* keytype + etype */
136 if(ret) {
137 krb5_set_error_message(context, ret,
138 N_("Cant read keyblock from file %s", ""),
139 fkt->filename);
140 return ret;
141 }
142 p->keytype = tmp;
143 ret = krb5_kt_ret_data(context, sp, &p->keyvalue);
144 if (ret)
145 krb5_set_error_message(context, ret,
146 N_("Cant read keyblock from file %s", ""),
147 fkt->filename);
148 return ret;
149 }
150
151 static krb5_error_code
152 krb5_kt_store_keyblock(krb5_context context,
153 struct fkt_data *fkt,
154 krb5_storage *sp,
155 krb5_keyblock *p)
156 {
157 int ret;
158
159 ret = krb5_store_int16(sp, p->keytype); /* keytype + etype */
160 if(ret) {
161 krb5_set_error_message(context, ret,
162 N_("Cant store keyblock to file %s", ""),
163 fkt->filename);
164 return ret;
165 }
166 ret = krb5_kt_store_data(context, sp, p->keyvalue);
167 if (ret)
168 krb5_set_error_message(context, ret,
169 N_("Cant store keyblock to file %s", ""),
170 fkt->filename);
171 return ret;
172 }
173
174
175 static krb5_error_code
176 krb5_kt_ret_principal(krb5_context context,
177 struct fkt_data *fkt,
178 krb5_storage *sp,
179 krb5_principal *princ)
180 {
181 size_t i;
182 int ret;
183 krb5_principal p;
184 int16_t len;
185
186 ALLOC(p, 1);
187 if(p == NULL)
188 return krb5_enomem(context);
189
190 ret = krb5_ret_int16(sp, &len);
191 if(ret) {
192 krb5_set_error_message(context, ret,
193 N_("Failed decoding length of "
194 "keytab principal in keytab file %s", ""),
195 fkt->filename);
196 goto out;
197 }
198 if(krb5_storage_is_flags(sp, KRB5_STORAGE_PRINCIPAL_WRONG_NUM_COMPONENTS))
199 len--;
200 if (len < 0) {
201 ret = KRB5_KT_END;
202 krb5_set_error_message(context, ret,
203 N_("Keytab principal contains "
204 "invalid length in keytab %s", ""),
205 fkt->filename);
206 goto out;
207 }
208 ret = krb5_kt_ret_string(context, sp, &p->realm);
209 if(ret) {
210 krb5_set_error_message(context, ret,
211 N_("Can't read realm from keytab: %s", ""),
212 fkt->filename);
213 goto out;
214 }
215 p->name.name_string.val = calloc(len, sizeof(*p->name.name_string.val));
216 if(p->name.name_string.val == NULL) {
217 ret = krb5_enomem(context);
218 goto out;
219 }
220 p->name.name_string.len = len;
221 for(i = 0; i < p->name.name_string.len; i++){
222 ret = krb5_kt_ret_string(context, sp, p->name.name_string.val + i);
223 if(ret) {
224 krb5_set_error_message(context, ret,
225 N_("Can't read principal from "
226 "keytab: %s", ""),
227 fkt->filename);
228 goto out;
229 }
230 }
231 if (krb5_storage_is_flags(sp, KRB5_STORAGE_PRINCIPAL_NO_NAME_TYPE))
232 p->name.name_type = KRB5_NT_UNKNOWN;
233 else {
234 int32_t tmp32;
235 ret = krb5_ret_int32(sp, &tmp32);
236 p->name.name_type = tmp32;
237 if (ret) {
238 krb5_set_error_message(context, ret,
239 N_("Can't read name-type from "
240 "keytab: %s", ""),
241 fkt->filename);
242 goto out;
243 }
244 }
245 *princ = p;
246 return 0;
247 out:
248 krb5_free_principal(context, p);
249 return ret;
250 }
251
252 static krb5_error_code
253 krb5_kt_store_principal(krb5_context context,
254 krb5_storage *sp,
255 krb5_principal p)
256 {
257 size_t i;
258 int ret;
259
260 if(krb5_storage_is_flags(sp, KRB5_STORAGE_PRINCIPAL_WRONG_NUM_COMPONENTS))
261 ret = krb5_store_int16(sp, p->name.name_string.len + 1);
262 else
263 ret = krb5_store_int16(sp, p->name.name_string.len);
264 if(ret) return ret;
265 ret = krb5_kt_store_string(sp, p->realm);
266 if(ret) return ret;
267 for(i = 0; i < p->name.name_string.len; i++){
268 ret = krb5_kt_store_string(sp, p->name.name_string.val[i]);
269 if(ret)
270 return ret;
271 }
272 if(!krb5_storage_is_flags(sp, KRB5_STORAGE_PRINCIPAL_NO_NAME_TYPE)) {
273 ret = krb5_store_int32(sp, p->name.name_type);
274 if(ret)
275 return ret;
276 }
277
278 return 0;
279 }
280
281 static krb5_error_code KRB5_CALLCONV
282 fkt_resolve(krb5_context context, const char *name, krb5_keytab id)
283 {
284 struct fkt_data *d;
285
286 d = malloc(sizeof(*d));
287 if(d == NULL)
288 return krb5_enomem(context);
289 d->filename = strdup(name);
290 if(d->filename == NULL) {
291 free(d);
292 return krb5_enomem(context);
293 }
294 d->flags = 0;
295 id->data = d;
296 return 0;
297 }
298
299 static krb5_error_code KRB5_CALLCONV
300 fkt_resolve_java14(krb5_context context, const char *name, krb5_keytab id)
301 {
302 krb5_error_code ret;
303
304 ret = fkt_resolve(context, name, id);
305 if (ret == 0) {
306 struct fkt_data *d = id->data;
307 d->flags |= KRB5_KT_FL_JAVA;
308 }
309 return ret;
310 }
311
312 static krb5_error_code KRB5_CALLCONV
313 fkt_close(krb5_context context, krb5_keytab id)
314 {
315 struct fkt_data *d = id->data;
316 free(d->filename);
317 free(d);
318 return 0;
319 }
320
321 static krb5_error_code KRB5_CALLCONV
322 fkt_destroy(krb5_context context, krb5_keytab id)
323 {
324 struct fkt_data *d = id->data;
325 _krb5_erase_file(context, d->filename);
326 return 0;
327 }
328
329 static krb5_error_code KRB5_CALLCONV
330 fkt_get_name(krb5_context context,
331 krb5_keytab id,
332 char *name,
333 size_t namesize)
334 {
335 /* This function is XXX */
336 struct fkt_data *d = id->data;
337 strlcpy(name, d->filename, namesize);
338 return 0;
339 }
340
341 static void
342 storage_set_flags(krb5_context context, krb5_storage *sp, int vno)
343 {
344 int flags = 0;
345 switch(vno) {
346 case KRB5_KT_VNO_1:
347 flags |= KRB5_STORAGE_PRINCIPAL_WRONG_NUM_COMPONENTS;
348 flags |= KRB5_STORAGE_PRINCIPAL_NO_NAME_TYPE;
349 flags |= KRB5_STORAGE_HOST_BYTEORDER;
350 break;
351 case KRB5_KT_VNO_2:
352 break;
353 default:
354 krb5_warnx(context,
355 "storage_set_flags called with bad vno (%d)", vno);
356 }
357 krb5_storage_set_flags(sp, flags);
358 }
359
360 static krb5_error_code
361 fkt_start_seq_get_int(krb5_context context,
362 krb5_keytab id,
363 int flags,
364 int exclusive,
365 krb5_kt_cursor *c)
366 {
367 int8_t pvno, tag;
368 krb5_error_code ret;
369 struct fkt_data *d = id->data;
370
371 c->fd = open (d->filename, flags);
372 if (c->fd < 0) {
373 ret = errno;
374 krb5_set_error_message(context, ret,
375 N_("keytab %s open failed: %s", ""),
376 d->filename, strerror(ret));
377 return ret;
378 }
379 rk_cloexec(c->fd);
380 ret = _krb5_xlock(context, c->fd, exclusive, d->filename);
381 if (ret) {
382 close(c->fd);
383 return ret;
384 }
385 c->sp = krb5_storage_from_fd(c->fd);
386 if (c->sp == NULL) {
387 _krb5_xunlock(context, c->fd);
388 close(c->fd);
389 return krb5_enomem(context);
390 }
391 krb5_storage_set_eof_code(c->sp, KRB5_KT_END);
392 ret = krb5_ret_int8(c->sp, &pvno);
393 if(ret) {
394 krb5_storage_free(c->sp);
395 _krb5_xunlock(context, c->fd);
396 close(c->fd);
397 krb5_clear_error_message(context);
398 return ret;
399 }
400 if(pvno != 5) {
401 krb5_storage_free(c->sp);
402 _krb5_xunlock(context, c->fd);
403 close(c->fd);
404 krb5_clear_error_message (context);
405 return KRB5_KEYTAB_BADVNO;
406 }
407 ret = krb5_ret_int8(c->sp, &tag);
408 if (ret) {
409 krb5_storage_free(c->sp);
410 _krb5_xunlock(context, c->fd);
411 close(c->fd);
412 krb5_clear_error_message(context);
413 return ret;
414 }
415 id->version = tag;
416 storage_set_flags(context, c->sp, id->version);
417 return 0;
418 }
419
420 static krb5_error_code KRB5_CALLCONV
421 fkt_start_seq_get(krb5_context context,
422 krb5_keytab id,
423 krb5_kt_cursor *c)
424 {
425 return fkt_start_seq_get_int(context, id, O_RDONLY | O_BINARY | O_CLOEXEC, 0, c);
426 }
427
428 static krb5_error_code
429 fkt_next_entry_int(krb5_context context,
430 krb5_keytab id,
431 krb5_keytab_entry *entry,
432 krb5_kt_cursor *cursor,
433 off_t *start,
434 off_t *end)
435 {
436 struct fkt_data *d = id->data;
437 int32_t len;
438 int ret;
439 int8_t tmp8;
440 int32_t tmp32;
441 uint32_t utmp32;
442 off_t pos, curpos;
443
444 pos = krb5_storage_seek(cursor->sp, 0, SEEK_CUR);
445 loop:
446 ret = krb5_ret_int32(cursor->sp, &len);
447 if (ret)
448 return ret;
449 if(len < 0) {
450 pos = krb5_storage_seek(cursor->sp, -len, SEEK_CUR);
451 goto loop;
452 }
453 ret = krb5_kt_ret_principal (context, d, cursor->sp, &entry->principal);
454 if (ret)
455 goto out;
456 ret = krb5_ret_uint32(cursor->sp, &utmp32);
457 entry->timestamp = utmp32;
458 if (ret)
459 goto out;
460 ret = krb5_ret_int8(cursor->sp, &tmp8);
461 if (ret)
462 goto out;
463 entry->vno = tmp8;
464 ret = krb5_kt_ret_keyblock (context, d, cursor->sp, &entry->keyblock);
465 if (ret)
466 goto out;
467 /* there might be a 32 bit kvno here
468 * if it's zero, assume that the 8bit one was right,
469 * otherwise trust the new value */
470 curpos = krb5_storage_seek(cursor->sp, 0, SEEK_CUR);
471 if(len + 4 + pos - curpos >= 4) {
472 ret = krb5_ret_int32(cursor->sp, &tmp32);
473 if (ret == 0 && tmp32 != 0)
474 entry->vno = tmp32;
475 }
476 /* there might be a flags field here */
477 if(len + 4 + pos - curpos >= 8) {
478 ret = krb5_ret_uint32(cursor->sp, &utmp32);
479 if (ret == 0)
480 entry->flags = utmp32;
481 } else
482 entry->flags = 0;
483
484 entry->aliases = NULL;
485
486 if(start) *start = pos;
487 if(end) *end = pos + 4 + len;
488 out:
489 if (ret)
490 krb5_kt_free_entry(context, entry);
491 krb5_storage_seek(cursor->sp, pos + 4 + len, SEEK_SET);
492 return ret;
493 }
494
495 static krb5_error_code KRB5_CALLCONV
496 fkt_next_entry(krb5_context context,
497 krb5_keytab id,
498 krb5_keytab_entry *entry,
499 krb5_kt_cursor *cursor)
500 {
501 return fkt_next_entry_int(context, id, entry, cursor, NULL, NULL);
502 }
503
504 static krb5_error_code KRB5_CALLCONV
505 fkt_end_seq_get(krb5_context context,
506 krb5_keytab id,
507 krb5_kt_cursor *cursor)
508 {
509 krb5_storage_free(cursor->sp);
510 _krb5_xunlock(context, cursor->fd);
511 close(cursor->fd);
512 return 0;
513 }
514
515 static krb5_error_code KRB5_CALLCONV
516 fkt_setup_keytab(krb5_context context,
517 krb5_keytab id,
518 krb5_storage *sp)
519 {
520 krb5_error_code ret;
521 ret = krb5_store_int8(sp, 5);
522 if(ret)
523 return ret;
524 if(id->version == 0)
525 id->version = KRB5_KT_VNO;
526 return krb5_store_int8 (sp, id->version);
527 }
528
529 static krb5_error_code KRB5_CALLCONV
530 fkt_add_entry(krb5_context context,
531 krb5_keytab id,
532 krb5_keytab_entry *entry)
533 {
534 int ret;
535 int fd;
536 krb5_storage *sp;
537 struct fkt_data *d = id->data;
538 krb5_data keytab;
539 int32_t len;
540
541 fd = open (d->filename, O_RDWR | O_BINARY | O_CLOEXEC);
542 if (fd < 0) {
543 fd = open (d->filename, O_RDWR | O_CREAT | O_EXCL | O_BINARY | O_CLOEXEC, 0600);
544 if (fd < 0) {
545 ret = errno;
546 krb5_set_error_message(context, ret,
547 N_("open(%s): %s", ""), d->filename,
548 strerror(ret));
549 return ret;
550 }
551 rk_cloexec(fd);
552
553 ret = _krb5_xlock(context, fd, 1, d->filename);
554 if (ret) {
555 close(fd);
556 return ret;
557 }
558 sp = krb5_storage_from_fd(fd);
559 krb5_storage_set_eof_code(sp, KRB5_KT_END);
560 ret = fkt_setup_keytab(context, id, sp);
561 if(ret) {
562 goto out;
563 }
564 storage_set_flags(context, sp, id->version);
565 } else {
566 int8_t pvno, tag;
567
568 rk_cloexec(fd);
569
570 ret = _krb5_xlock(context, fd, 1, d->filename);
571 if (ret) {
572 close(fd);
573 return ret;
574 }
575 sp = krb5_storage_from_fd(fd);
576 krb5_storage_set_eof_code(sp, KRB5_KT_END);
577 ret = krb5_ret_int8(sp, &pvno);
578 if(ret) {
579 /* we probably have a zero byte file, so try to set it up
580 properly */
581 ret = fkt_setup_keytab(context, id, sp);
582 if(ret) {
583 krb5_set_error_message(context, ret,
584 N_("%s: keytab is corrupted: %s", ""),
585 d->filename, strerror(ret));
586 goto out;
587 }
588 storage_set_flags(context, sp, id->version);
589 } else {
590 if(pvno != 5) {
591 ret = KRB5_KEYTAB_BADVNO;
592 krb5_set_error_message(context, ret,
593 N_("Bad version in keytab %s", ""),
594 d->filename);
595 goto out;
596 }
597 ret = krb5_ret_int8 (sp, &tag);
598 if (ret) {
599 krb5_set_error_message(context, ret,
600 N_("failed reading tag from "
601 "keytab %s", ""),
602 d->filename);
603 goto out;
604 }
605 id->version = tag;
606 storage_set_flags(context, sp, id->version);
607 }
608 }
609
610 {
611 krb5_storage *emem;
612 emem = krb5_storage_emem();
613 if(emem == NULL) {
614 ret = krb5_enomem(context);
615 goto out;
616 }
617 ret = krb5_kt_store_principal(context, emem, entry->principal);
618 if(ret) {
619 krb5_set_error_message(context, ret,
620 N_("Failed storing principal "
621 "in keytab %s", ""),
622 d->filename);
623 krb5_storage_free(emem);
624 goto out;
625 }
626 ret = krb5_store_int32 (emem, entry->timestamp);
627 if(ret) {
628 krb5_set_error_message(context, ret,
629 N_("Failed storing timpstamp "
630 "in keytab %s", ""),
631 d->filename);
632 krb5_storage_free(emem);
633 goto out;
634 }
635 ret = krb5_store_int8 (emem, entry->vno % 256);
636 if(ret) {
637 krb5_set_error_message(context, ret,
638 N_("Failed storing kvno "
639 "in keytab %s", ""),
640 d->filename);
641 krb5_storage_free(emem);
642 goto out;
643 }
644 ret = krb5_kt_store_keyblock (context, d, emem, &entry->keyblock);
645 if(ret) {
646 krb5_storage_free(emem);
647 goto out;
648 }
649 if ((d->flags & KRB5_KT_FL_JAVA) == 0) {
650 ret = krb5_store_int32 (emem, entry->vno);
651 if (ret) {
652 krb5_set_error_message(context, ret,
653 N_("Failed storing extended kvno "
654 "in keytab %s", ""),
655 d->filename);
656 krb5_storage_free(emem);
657 goto out;
658 }
659 ret = krb5_store_uint32 (emem, entry->flags);
660 if (ret) {
661 krb5_set_error_message(context, ret,
662 N_("Failed storing extended kvno "
663 "in keytab %s", ""),
664 d->filename);
665 krb5_storage_free(emem);
666 goto out;
667 }
668 }
669
670 ret = krb5_storage_to_data(emem, &keytab);
671 krb5_storage_free(emem);
672 if(ret) {
673 krb5_set_error_message(context, ret,
674 N_("Failed converting keytab entry "
675 "to memory block for keytab %s", ""),
676 d->filename);
677 goto out;
678 }
679 }
680
681 while(1) {
682 ret = krb5_ret_int32(sp, &len);
683 if(ret == KRB5_KT_END) {
684 len = keytab.length;
685 break;
686 }
687 if(len < 0) {
688 len = -len;
689 if(len >= (int)keytab.length) {
690 krb5_storage_seek(sp, -4, SEEK_CUR);
691 break;
692 }
693 }
694 krb5_storage_seek(sp, len, SEEK_CUR);
695 }
696 ret = krb5_store_int32(sp, len);
697 if(krb5_storage_write(sp, keytab.data, keytab.length) < 0) {
698 ret = errno;
699 krb5_set_error_message(context, ret,
700 N_("Failed writing keytab block "
701 "in keytab %s: %s", ""),
702 d->filename, strerror(ret));
703 }
704 memset(keytab.data, 0, keytab.length);
705 krb5_data_free(&keytab);
706 out:
707 krb5_storage_free(sp);
708 _krb5_xunlock(context, fd);
709 close(fd);
710 return ret;
711 }
712
713 static krb5_error_code KRB5_CALLCONV
714 fkt_remove_entry(krb5_context context,
715 krb5_keytab id,
716 krb5_keytab_entry *entry)
717 {
718 krb5_keytab_entry e;
719 krb5_kt_cursor cursor;
720 off_t pos_start, pos_end;
721 int found = 0;
722 krb5_error_code ret;
723
724 ret = fkt_start_seq_get_int(context, id, O_RDWR | O_BINARY | O_CLOEXEC, 1, &cursor);
725 if(ret != 0)
726 goto out; /* return other error here? */
727 while(fkt_next_entry_int(context, id, &e, &cursor,
728 &pos_start, &pos_end) == 0) {
729 if(krb5_kt_compare(context, &e, entry->principal,
730 entry->vno, entry->keyblock.keytype)) {
731 int32_t len;
732 unsigned char buf[128];
733 found = 1;
734 krb5_storage_seek(cursor.sp, pos_start, SEEK_SET);
735 len = pos_end - pos_start - 4;
736 krb5_store_int32(cursor.sp, -len);
737 memset(buf, 0, sizeof(buf));
738 while(len > 0) {
739 krb5_storage_write(cursor.sp, buf,
740 min((size_t)len, sizeof(buf)));
741 len -= min((size_t)len, sizeof(buf));
742 }
743 }
744 krb5_kt_free_entry(context, &e);
745 }
746 krb5_kt_end_seq_get(context, id, &cursor);
747 out:
748 if (!found) {
749 krb5_clear_error_message (context);
750 return KRB5_KT_NOTFOUND;
751 }
752 return 0;
753 }
754
755 const krb5_kt_ops krb5_fkt_ops = {
756 "FILE",
757 fkt_resolve,
758 fkt_get_name,
759 fkt_close,
760 fkt_destroy,
761 NULL, /* get */
762 fkt_start_seq_get,
763 fkt_next_entry,
764 fkt_end_seq_get,
765 fkt_add_entry,
766 fkt_remove_entry,
767 NULL,
768 0
769 };
770
771 const krb5_kt_ops krb5_wrfkt_ops = {
772 "WRFILE",
773 fkt_resolve,
774 fkt_get_name,
775 fkt_close,
776 fkt_destroy,
777 NULL, /* get */
778 fkt_start_seq_get,
779 fkt_next_entry,
780 fkt_end_seq_get,
781 fkt_add_entry,
782 fkt_remove_entry,
783 NULL,
784 0
785 };
786
787 const krb5_kt_ops krb5_javakt_ops = {
788 "JAVA14",
789 fkt_resolve_java14,
790 fkt_get_name,
791 fkt_close,
792 fkt_destroy,
793 NULL, /* get */
794 fkt_start_seq_get,
795 fkt_next_entry,
796 fkt_end_seq_get,
797 fkt_add_entry,
798 fkt_remove_entry,
799 NULL,
800 0
801 };