log.c revision 120945 
1/*
2 * Copyright (c) 1997 - 2003 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 "kadm5_locl.h"
35
36RCSID("$Id: log.c,v 1.20 2003/04/16 17:56:55 lha Exp $");
37
38/*
39 * A log record consists of:
40 *
41 * version number		4 bytes
42 * time in seconds		4 bytes
43 * operation (enum kadm_ops)	4 bytes
44 * length of record		4 bytes
45 * data...			n bytes
46 * length of record		4 bytes
47 * version number		4 bytes
48 *
49 */
50
51kadm5_ret_t
52kadm5_log_get_version_fd (int fd,
53			  u_int32_t *ver)
54{
55    int ret;
56    krb5_storage *sp;
57    int32_t old_version;
58
59    ret = lseek (fd, 0, SEEK_END);
60    if(ret < 0)
61	return errno;
62    if(ret == 0) {
63	*ver = 0;
64	return 0;
65    }
66    sp = krb5_storage_from_fd (fd);
67    krb5_storage_seek(sp, -4, SEEK_CUR);
68    krb5_ret_int32 (sp, &old_version);
69    *ver = old_version;
70    krb5_storage_free(sp);
71    lseek (fd, 0, SEEK_END);
72    return 0;
73}
74
75kadm5_ret_t
76kadm5_log_get_version (kadm5_server_context *context, u_int32_t *ver)
77{
78    return kadm5_log_get_version_fd (context->log_context.log_fd, ver);
79}
80
81kadm5_ret_t
82kadm5_log_set_version (kadm5_server_context *context, u_int32_t vno)
83{
84    kadm5_log_context *log_context = &context->log_context;
85
86    log_context->version = vno;
87    return 0;
88}
89
90kadm5_ret_t
91kadm5_log_init (kadm5_server_context *context)
92{
93    int fd;
94    kadm5_ret_t ret;
95    kadm5_log_context *log_context = &context->log_context;
96
97    if (log_context->log_fd != -1)
98	return 0;
99    fd = open (log_context->log_file, O_RDWR | O_CREAT, 0600);
100    if (fd < 0)
101	return errno;
102    if (flock (fd, LOCK_EX) < 0) {
103	close (fd);
104	return errno;
105    }
106
107    ret = kadm5_log_get_version_fd (fd, &log_context->version);
108    if (ret)
109	return ret;
110
111    log_context->log_fd  = fd;
112    return 0;
113}
114
115kadm5_ret_t
116kadm5_log_reinit (kadm5_server_context *context)
117{
118    int fd;
119    kadm5_log_context *log_context = &context->log_context;
120
121    if (log_context->log_fd != -1) {
122	close (log_context->log_fd);
123	log_context->log_fd = -1;
124    }
125    fd = open (log_context->log_file, O_RDWR | O_CREAT | O_TRUNC, 0600);
126    if (fd < 0)
127	return errno;
128    if (flock (fd, LOCK_EX) < 0) {
129	close (fd);
130	return errno;
131    }
132
133    log_context->version = 0;
134    log_context->log_fd  = fd;
135    return 0;
136}
137
138
139kadm5_ret_t
140kadm5_log_end (kadm5_server_context *context)
141{
142    kadm5_log_context *log_context = &context->log_context;
143    int fd = log_context->log_fd;
144
145    flock (fd, LOCK_UN);
146    close(fd);
147    log_context->log_fd = -1;
148    return 0;
149}
150
151static kadm5_ret_t
152kadm5_log_preamble (kadm5_server_context *context,
153		    krb5_storage *sp,
154		    enum kadm_ops op)
155{
156    kadm5_log_context *log_context = &context->log_context;
157    kadm5_ret_t kadm_ret;
158
159    kadm_ret = kadm5_log_init (context);
160    if (kadm_ret)
161	return kadm_ret;
162
163    krb5_store_int32 (sp, ++log_context->version);
164    krb5_store_int32 (sp, time(NULL));
165    krb5_store_int32 (sp, op);
166    return 0;
167}
168
169static kadm5_ret_t
170kadm5_log_postamble (kadm5_log_context *context,
171		     krb5_storage *sp)
172{
173    krb5_store_int32 (sp, context->version);
174    return 0;
175}
176
177/*
178 * flush the log record in `sp'.
179 */
180
181static kadm5_ret_t
182kadm5_log_flush (kadm5_log_context *log_context,
183		 krb5_storage *sp)
184{
185    krb5_data data;
186    size_t len;
187    int ret;
188
189    krb5_storage_to_data(sp, &data);
190    len = data.length;
191    ret = write (log_context->log_fd, data.data, len);
192    if (ret != len) {
193	krb5_data_free(&data);
194	return errno;
195    }
196    if (fsync (log_context->log_fd) < 0) {
197	krb5_data_free(&data);
198	return errno;
199    }
200    /*
201     * Try to send a signal to any running `ipropd-master'
202     */
203    sendto (log_context->socket_fd,
204	    (void *)&log_context->version,
205	    sizeof(log_context->version),
206	    0,
207	    (struct sockaddr *)&log_context->socket_name,
208	    sizeof(log_context->socket_name));
209
210    krb5_data_free(&data);
211    return 0;
212}
213
214/*
215 * Add a `create' operation to the log.
216 */
217
218kadm5_ret_t
219kadm5_log_create (kadm5_server_context *context,
220		  hdb_entry *ent)
221{
222    krb5_storage *sp;
223    kadm5_ret_t ret;
224    krb5_data value;
225    kadm5_log_context *log_context = &context->log_context;
226
227    sp = krb5_storage_emem();
228    ret = hdb_entry2value (context->context, ent, &value);
229    if (ret) {
230	krb5_storage_free(sp);
231	return ret;
232    }
233    ret = kadm5_log_preamble (context, sp, kadm_create);
234    if (ret) {
235	krb5_data_free (&value);
236	krb5_storage_free(sp);
237	return ret;
238    }
239    krb5_store_int32 (sp, value.length);
240    krb5_storage_write(sp, value.data, value.length);
241    krb5_store_int32 (sp, value.length);
242    krb5_data_free (&value);
243    ret = kadm5_log_postamble (log_context, sp);
244    if (ret) {
245	krb5_storage_free (sp);
246	return ret;
247    }
248    ret = kadm5_log_flush (log_context, sp);
249    krb5_storage_free (sp);
250    if (ret)
251	return ret;
252    ret = kadm5_log_end (context);
253    return ret;
254}
255
256/*
257 * Read the data of a create log record from `sp' and change the
258 * database.
259 */
260
261kadm5_ret_t
262kadm5_log_replay_create (kadm5_server_context *context,
263			 u_int32_t ver,
264			 u_int32_t len,
265			 krb5_storage *sp)
266{
267    krb5_error_code ret;
268    krb5_data data;
269    hdb_entry ent;
270
271    ret = krb5_data_alloc (&data, len);
272    if (ret)
273	return ret;
274    krb5_storage_read (sp, data.data, len);
275    ret = hdb_value2entry (context->context, &data, &ent);
276    krb5_data_free(&data);
277    if (ret)
278	return ret;
279    ret = context->db->store(context->context, context->db, 0, &ent);
280    hdb_free_entry (context->context, &ent);
281    return ret;
282}
283
284/*
285 * Add a `delete' operation to the log.
286 */
287
288kadm5_ret_t
289kadm5_log_delete (kadm5_server_context *context,
290		  krb5_principal princ)
291{
292    krb5_storage *sp;
293    kadm5_ret_t ret;
294    off_t off;
295    off_t len;
296    kadm5_log_context *log_context = &context->log_context;
297
298    sp = krb5_storage_emem();
299    ret = kadm5_log_preamble (context, sp, kadm_delete);
300    if (ret) {
301	krb5_storage_free(sp);
302	return ret;
303    }
304    krb5_store_int32 (sp, 0);
305    off = krb5_storage_seek (sp, 0, SEEK_CUR);
306    krb5_store_principal (sp, princ);
307    len = krb5_storage_seek (sp, 0, SEEK_CUR) - off;
308    krb5_storage_seek(sp, -(len + 4), SEEK_CUR);
309    krb5_store_int32 (sp, len);
310    krb5_storage_seek(sp, len, SEEK_CUR);
311    krb5_store_int32 (sp, len);
312    if (ret) {
313	krb5_storage_free (sp);
314	return ret;
315    }
316    ret = kadm5_log_postamble (log_context, sp);
317    if (ret) {
318	krb5_storage_free (sp);
319	return ret;
320    }
321    ret = kadm5_log_flush (log_context, sp);
322    krb5_storage_free (sp);
323    if (ret)
324	return ret;
325    ret = kadm5_log_end (context);
326    return ret;
327}
328
329/*
330 * Read a `delete' log operation from `sp' and apply it.
331 */
332
333kadm5_ret_t
334kadm5_log_replay_delete (kadm5_server_context *context,
335			 u_int32_t ver,
336			 u_int32_t len,
337			 krb5_storage *sp)
338{
339    krb5_error_code ret;
340    hdb_entry ent;
341
342    krb5_ret_principal (sp, &ent.principal);
343
344    ret = context->db->remove(context->context, context->db, &ent);
345    krb5_free_principal (context->context, ent.principal);
346    return ret;
347}
348
349/*
350 * Add a `rename' operation to the log.
351 */
352
353kadm5_ret_t
354kadm5_log_rename (kadm5_server_context *context,
355		  krb5_principal source,
356		  hdb_entry *ent)
357{
358    krb5_storage *sp;
359    kadm5_ret_t ret;
360    off_t off;
361    off_t len;
362    krb5_data value;
363    kadm5_log_context *log_context = &context->log_context;
364
365    sp = krb5_storage_emem();
366    ret = hdb_entry2value (context->context, ent, &value);
367    if (ret) {
368	krb5_storage_free(sp);
369	return ret;
370    }
371    ret = kadm5_log_preamble (context, sp, kadm_rename);
372    if (ret) {
373	krb5_storage_free(sp);
374	krb5_data_free (&value);
375	return ret;
376    }
377    krb5_store_int32 (sp, 0);
378    off = krb5_storage_seek (sp, 0, SEEK_CUR);
379    krb5_store_principal (sp, source);
380    krb5_storage_write(sp, value.data, value.length);
381    krb5_data_free (&value);
382    len = krb5_storage_seek (sp, 0, SEEK_CUR) - off;
383
384    krb5_storage_seek(sp, -(len + 4), SEEK_CUR);
385    krb5_store_int32 (sp, len);
386    krb5_storage_seek(sp, len, SEEK_CUR);
387    krb5_store_int32 (sp, len);
388    if (ret) {
389	krb5_storage_free (sp);
390	return ret;
391    }
392    ret = kadm5_log_postamble (log_context, sp);
393    if (ret) {
394	krb5_storage_free (sp);
395	return ret;
396    }
397    ret = kadm5_log_flush (log_context, sp);
398    krb5_storage_free (sp);
399    if (ret)
400	return ret;
401    ret = kadm5_log_end (context);
402    return ret;
403}
404
405/*
406 * Read a `rename' log operation from `sp' and apply it.
407 */
408
409kadm5_ret_t
410kadm5_log_replay_rename (kadm5_server_context *context,
411			 u_int32_t ver,
412			 u_int32_t len,
413			 krb5_storage *sp)
414{
415    krb5_error_code ret;
416    krb5_principal source;
417    hdb_entry source_ent, target_ent;
418    krb5_data value;
419    off_t off;
420    size_t princ_len, data_len;
421
422    off = krb5_storage_seek(sp, 0, SEEK_CUR);
423    krb5_ret_principal (sp, &source);
424    princ_len = krb5_storage_seek(sp, 0, SEEK_CUR) - off;
425    data_len = len - princ_len;
426    ret = krb5_data_alloc (&value, data_len);
427    if (ret) {
428	krb5_free_principal (context->context, source);
429	return ret;
430    }
431    krb5_storage_read (sp, value.data, data_len);
432    ret = hdb_value2entry (context->context, &value, &target_ent);
433    krb5_data_free(&value);
434    if (ret) {
435	krb5_free_principal (context->context, source);
436	return ret;
437    }
438    ret = context->db->store (context->context, context->db, 0, &target_ent);
439    hdb_free_entry (context->context, &target_ent);
440    if (ret) {
441	krb5_free_principal (context->context, source);
442	return ret;
443    }
444    source_ent.principal = source;
445    ret = context->db->remove (context->context, context->db, &source_ent);
446    krb5_free_principal (context->context, source);
447    return ret;
448}
449
450
451/*
452 * Add a `modify' operation to the log.
453 */
454
455kadm5_ret_t
456kadm5_log_modify (kadm5_server_context *context,
457		  hdb_entry *ent,
458		  u_int32_t mask)
459{
460    krb5_storage *sp;
461    kadm5_ret_t ret;
462    krb5_data value;
463    u_int32_t len;
464    kadm5_log_context *log_context = &context->log_context;
465
466    sp = krb5_storage_emem();
467    ret = hdb_entry2value (context->context, ent, &value);
468    if (ret) {
469	krb5_storage_free(sp);
470	return ret;
471    }
472    ret = kadm5_log_preamble (context, sp, kadm_modify);
473    if (ret) {
474	krb5_data_free (&value);
475	krb5_storage_free(sp);
476	return ret;
477    }
478    len = value.length + 4;
479    krb5_store_int32 (sp, len);
480    krb5_store_int32 (sp, mask);
481    krb5_storage_write (sp, value.data, value.length);
482    krb5_data_free (&value);
483    krb5_store_int32 (sp, len);
484    if (ret) {
485	krb5_storage_free (sp);
486	return ret;
487    }
488    ret = kadm5_log_postamble (log_context, sp);
489    if (ret) {
490	krb5_storage_free (sp);
491	return ret;
492    }
493    ret = kadm5_log_flush (log_context, sp);
494    krb5_storage_free (sp);
495    if (ret)
496	return ret;
497    ret = kadm5_log_end (context);
498    return ret;
499}
500
501/*
502 * Read a `modify' log operation from `sp' and apply it.
503 */
504
505kadm5_ret_t
506kadm5_log_replay_modify (kadm5_server_context *context,
507			 u_int32_t ver,
508			 u_int32_t len,
509			 krb5_storage *sp)
510{
511    krb5_error_code ret;
512    int32_t mask;
513    krb5_data value;
514    hdb_entry ent, log_ent;
515
516    krb5_ret_int32 (sp, &mask);
517    len -= 4;
518    ret = krb5_data_alloc (&value, len);
519    if (ret)
520	return ret;
521    krb5_storage_read (sp, value.data, len);
522    ret = hdb_value2entry (context->context, &value, &log_ent);
523    krb5_data_free(&value);
524    if (ret)
525	return ret;
526    ent.principal = log_ent.principal;
527    log_ent.principal = NULL;
528    ret = context->db->fetch(context->context, context->db,
529			     HDB_F_DECRYPT, &ent);
530    if (ret)
531	return ret;
532    if (mask & KADM5_PRINC_EXPIRE_TIME) {
533	if (log_ent.valid_end == NULL) {
534	    ent.valid_end = NULL;
535	} else {
536	    if (ent.valid_end == NULL)
537		ent.valid_end = malloc(sizeof(*ent.valid_end));
538	    *ent.valid_end = *log_ent.valid_end;
539	}
540    }
541    if (mask & KADM5_PW_EXPIRATION) {
542	if (log_ent.pw_end == NULL) {
543	    ent.pw_end = NULL;
544	} else {
545	    if (ent.pw_end == NULL)
546		ent.pw_end = malloc(sizeof(*ent.pw_end));
547	    *ent.pw_end = *log_ent.pw_end;
548	}
549    }
550    if (mask & KADM5_LAST_PWD_CHANGE) {
551	abort ();		/* XXX */
552    }
553    if (mask & KADM5_ATTRIBUTES) {
554	ent.flags = log_ent.flags;
555    }
556    if (mask & KADM5_MAX_LIFE) {
557	if (log_ent.max_life == NULL) {
558	    ent.max_life = NULL;
559	} else {
560	    if (ent.max_life == NULL)
561		ent.max_life = malloc (sizeof(*ent.max_life));
562	    *ent.max_life = *log_ent.max_life;
563	}
564    }
565    if ((mask & KADM5_MOD_TIME) && (mask & KADM5_MOD_NAME)) {
566	if (ent.modified_by == NULL) {
567	    ent.modified_by = malloc(sizeof(*ent.modified_by));
568	} else
569	    free_Event(ent.modified_by);
570	copy_Event(log_ent.modified_by, ent.modified_by);
571    }
572    if (mask & KADM5_KVNO) {
573	ent.kvno = log_ent.kvno;
574    }
575    if (mask & KADM5_MKVNO) {
576	abort ();		/* XXX */
577    }
578    if (mask & KADM5_AUX_ATTRIBUTES) {
579	abort ();		/* XXX */
580    }
581    if (mask & KADM5_POLICY) {
582	abort ();		/* XXX */
583    }
584    if (mask & KADM5_POLICY_CLR) {
585	abort ();		/* XXX */
586    }
587    if (mask & KADM5_MAX_RLIFE) {
588	if (log_ent.max_renew == NULL) {
589	    ent.max_renew = NULL;
590	} else {
591	    if (ent.max_renew == NULL)
592		ent.max_renew = malloc (sizeof(*ent.max_renew));
593	    *ent.max_renew = *log_ent.max_renew;
594	}
595    }
596    if (mask & KADM5_LAST_SUCCESS) {
597	abort ();		/* XXX */
598    }
599    if (mask & KADM5_LAST_FAILED) {
600	abort ();		/* XXX */
601    }
602    if (mask & KADM5_FAIL_AUTH_COUNT) {
603	abort ();		/* XXX */
604    }
605    if (mask & KADM5_KEY_DATA) {
606	size_t len;
607	int i;
608
609	for (i = 0; i < ent.keys.len; ++i)
610	    free_Key(&ent.keys.val[i]);
611	free (ent.keys.val);
612
613	len = log_ent.keys.len;
614
615	ent.keys.len = len;
616	ent.keys.val = malloc(len * sizeof(*ent.keys.val));
617	for (i = 0; i < ent.keys.len; ++i)
618	    copy_Key(&log_ent.keys.val[i],
619		     &ent.keys.val[i]);
620    }
621    ret = context->db->store(context->context, context->db,
622			     HDB_F_REPLACE, &ent);
623    hdb_free_entry (context->context, &ent);
624    hdb_free_entry (context->context, &log_ent);
625    return ret;
626}
627
628/*
629 * Add a `nop' operation to the log.
630 */
631
632kadm5_ret_t
633kadm5_log_nop (kadm5_server_context *context)
634{
635    krb5_storage *sp;
636    kadm5_ret_t ret;
637    kadm5_log_context *log_context = &context->log_context;
638
639    sp = krb5_storage_emem();
640    ret = kadm5_log_preamble (context, sp, kadm_nop);
641    if (ret) {
642	krb5_storage_free (sp);
643	return ret;
644    }
645    krb5_store_int32 (sp, 0);
646    krb5_store_int32 (sp, 0);
647    ret = kadm5_log_postamble (log_context, sp);
648    if (ret) {
649	krb5_storage_free (sp);
650	return ret;
651    }
652    ret = kadm5_log_flush (log_context, sp);
653    krb5_storage_free (sp);
654    if (ret)
655	return ret;
656    ret = kadm5_log_end (context);
657    return ret;
658}
659
660/*
661 * Read a `nop' log operation from `sp' and apply it.
662 */
663
664kadm5_ret_t
665kadm5_log_replay_nop (kadm5_server_context *context,
666		      u_int32_t ver,
667		      u_int32_t len,
668		      krb5_storage *sp)
669{
670    return 0;
671}
672
673/*
674 * Call `func' for each log record in the log in `context'
675 */
676
677kadm5_ret_t
678kadm5_log_foreach (kadm5_server_context *context,
679		   void (*func)(kadm5_server_context *server_context,
680				u_int32_t ver,
681				time_t timestamp,
682				enum kadm_ops op,
683				u_int32_t len,
684				krb5_storage *sp))
685{
686    int fd = context->log_context.log_fd;
687    krb5_storage *sp;
688
689    lseek (fd, 0, SEEK_SET);
690    sp = krb5_storage_from_fd (fd);
691    for (;;) {
692	int32_t ver, timestamp, op, len;
693
694	if(krb5_ret_int32 (sp, &ver) != 0)
695	    break;
696	krb5_ret_int32 (sp, &timestamp);
697	krb5_ret_int32 (sp, &op);
698	krb5_ret_int32 (sp, &len);
699	(*func)(context, ver, timestamp, op, len, sp);
700	krb5_storage_seek(sp, 8, SEEK_CUR);
701    }
702    return 0;
703}
704
705/*
706 * Go to end of log.
707 */
708
709krb5_storage *
710kadm5_log_goto_end (int fd)
711{
712    krb5_storage *sp;
713
714    sp = krb5_storage_from_fd (fd);
715    krb5_storage_seek(sp, 0, SEEK_END);
716    return sp;
717}
718
719/*
720 * Return previous log entry.
721 */
722
723kadm5_ret_t
724kadm5_log_previous (krb5_storage *sp,
725		    u_int32_t *ver,
726		    time_t *timestamp,
727		    enum kadm_ops *op,
728		    u_int32_t *len)
729{
730    off_t off;
731    int32_t tmp;
732
733    krb5_storage_seek(sp, -8, SEEK_CUR);
734    krb5_ret_int32 (sp, &tmp);
735    *len = tmp;
736    krb5_ret_int32 (sp, &tmp);
737    *ver = tmp;
738    off = 24 + *len;
739    krb5_storage_seek(sp, -off, SEEK_CUR);
740    krb5_ret_int32 (sp, &tmp);
741    assert(tmp == *ver);
742    krb5_ret_int32 (sp, &tmp);
743    *timestamp = tmp;
744    krb5_ret_int32 (sp, &tmp);
745    *op = tmp;
746    krb5_ret_int32 (sp, &tmp);
747    assert(tmp == *len);
748    return 0;
749}
750
751/*
752 * Replay a record from the log
753 */
754
755kadm5_ret_t
756kadm5_log_replay (kadm5_server_context *context,
757		  enum kadm_ops op,
758		  u_int32_t ver,
759		  u_int32_t len,
760		  krb5_storage *sp)
761{
762    switch (op) {
763    case kadm_create :
764	return kadm5_log_replay_create (context, ver, len, sp);
765    case kadm_delete :
766	return kadm5_log_replay_delete (context, ver, len, sp);
767    case kadm_rename :
768	return kadm5_log_replay_rename (context, ver, len, sp);
769    case kadm_modify :
770	return kadm5_log_replay_modify (context, ver, len, sp);
771    case kadm_nop :
772	return kadm5_log_replay_nop (context, ver, len, sp);
773    default :
774	return KADM5_FAILURE;
775    }
776}
777
778/*
779 * truncate the log - i.e. create an empty file with just (nop vno + 2)
780 */
781
782kadm5_ret_t
783kadm5_log_truncate (kadm5_server_context *server_context)
784{
785    kadm5_ret_t ret;
786    u_int32_t vno;
787
788    ret = kadm5_log_init (server_context);
789    if (ret)
790	return ret;
791
792    ret = kadm5_log_get_version (server_context, &vno);
793    if (ret)
794	return ret;
795
796    ret = kadm5_log_reinit (server_context);
797    if (ret)
798	return ret;
799
800    ret = kadm5_log_set_version (server_context, vno + 1);
801    if (ret)
802	return ret;
803
804    ret = kadm5_log_nop (server_context);
805    if (ret)
806	return ret;
807
808    ret = kadm5_log_end (server_context);
809    if (ret)
810	return ret;
811    return 0;
812
813}
814