Add heimdal-0.6.3
[dragonfly.git] / crypto / heimdal-0.6.3 / lib / hdb / print.c
1 /*
2  * Copyright (c) 1999-2002 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 KTH nor the names of its contributors may be
18  *    used to endorse or promote products derived from this software without
19  *    specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY KTH AND ITS CONTRIBUTORS ``AS IS'' AND ANY
22  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
24  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL KTH OR ITS CONTRIBUTORS BE
25  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
28  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
29  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
30  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
31  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
32
33 #include "hdb_locl.h"
34 #include <ctype.h>
35
36 RCSID("$Id: print.c,v 1.8 2002/05/24 15:18:02 joda Exp $");
37
38 /* 
39    This is the present contents of a dump line. This might change at
40    any time. Fields are separated by white space.
41
42   principal
43   keyblock
44         kvno
45         keys...
46                 mkvno
47                 enctype
48                 keyvalue
49                 salt (- means use normal salt)
50   creation date and principal
51   modification date and principal
52   principal valid from date (not used)
53   principal valid end date (not used)
54   principal key expires (not used)
55   max ticket life
56   max renewable life
57   flags
58   generation number
59   */
60
61 static krb5_error_code
62 append_string(krb5_context context, krb5_storage *sp, const char *fmt, ...)
63 {
64     krb5_error_code ret;
65     char *s;
66     va_list ap;
67     va_start(ap, fmt);
68     vasprintf(&s, fmt, ap);
69     va_end(ap);
70     if(s == NULL) {
71         krb5_set_error_string(context, "malloc: out of memory");
72         return ENOMEM;
73     }
74     ret = krb5_storage_write(sp, s, strlen(s));
75     free(s);
76     return ret;
77 }
78
79 static krb5_error_code
80 append_hex(krb5_context context, krb5_storage *sp, krb5_data *data)
81 {
82     int i, printable = 1;
83     char *p;
84
85     p = data->data;
86     for(i = 0; i < data->length; i++)
87         if(!isalnum((unsigned char)p[i]) && p[i] != '.'){
88             printable = 0;
89             break;
90         }
91     if(printable)
92         return append_string(context, sp, "\"%.*s\"",
93                              data->length, data->data);
94     for(i = 0; i < data->length; i++) 
95         append_string(context, sp, "%02x", ((unsigned char*)data->data)[i]);
96     return 0;
97 }
98
99 static char *
100 time2str(time_t t)
101 {
102     static char buf[128];
103     strftime(buf, sizeof(buf), "%Y%m%d%H%M%S", gmtime(&t));
104     return buf;
105 }
106
107 static krb5_error_code
108 append_event(krb5_context context, krb5_storage *sp, Event *ev)
109 {
110     char *pr = NULL;
111     krb5_error_code ret;
112     if(ev == NULL)
113         return append_string(context, sp, "- ");
114     if (ev->principal != NULL) {
115        ret = krb5_unparse_name(context, ev->principal, &pr);
116        if(ret)
117            return ret;
118     }
119     ret = append_string(context, sp, "%s:%s ",
120                         time2str(ev->time), pr ? pr : "UNKNOWN");
121     free(pr);
122     return ret;
123 }
124
125 static krb5_error_code
126 entry2string_int (krb5_context context, krb5_storage *sp, hdb_entry *ent)
127 {
128     char *p;
129     int i;
130     krb5_error_code ret;
131
132     /* --- principal */
133     ret = krb5_unparse_name(context, ent->principal, &p);
134     if(ret)
135         return ret;
136     append_string(context, sp, "%s ", p);
137     free(p);
138     /* --- kvno */
139     append_string(context, sp, "%d", ent->kvno);
140     /* --- keys */
141     for(i = 0; i < ent->keys.len; i++){
142         /* --- mkvno, keytype */
143         if(ent->keys.val[i].mkvno)
144             append_string(context, sp, ":%d:%d:", 
145                           *ent->keys.val[i].mkvno, 
146                           ent->keys.val[i].key.keytype);
147         else
148             append_string(context, sp, "::%d:", 
149                           ent->keys.val[i].key.keytype);
150         /* --- keydata */
151         append_hex(context, sp, &ent->keys.val[i].key.keyvalue);
152         append_string(context, sp, ":");
153         /* --- salt */
154         if(ent->keys.val[i].salt){
155             append_string(context, sp, "%u/", ent->keys.val[i].salt->type);
156             append_hex(context, sp, &ent->keys.val[i].salt->salt);
157         }else
158             append_string(context, sp, "-");
159     }
160     append_string(context, sp, " ");
161     /* --- created by */
162     append_event(context, sp, &ent->created_by);
163     /* --- modified by */
164     append_event(context, sp, ent->modified_by);
165
166     /* --- valid start */
167     if(ent->valid_start)
168         append_string(context, sp, "%s ", time2str(*ent->valid_start));
169     else
170         append_string(context, sp, "- ");
171
172     /* --- valid end */
173     if(ent->valid_end)
174         append_string(context, sp, "%s ", time2str(*ent->valid_end));
175     else
176         append_string(context, sp, "- ");
177     
178     /* --- password ends */
179     if(ent->pw_end)
180         append_string(context, sp, "%s ", time2str(*ent->pw_end));
181     else
182         append_string(context, sp, "- ");
183
184     /* --- max life */
185     if(ent->max_life)
186         append_string(context, sp, "%d ", *ent->max_life);
187     else
188         append_string(context, sp, "- ");
189
190     /* --- max renewable life */
191     if(ent->max_renew)
192         append_string(context, sp, "%d ", *ent->max_renew);
193     else
194         append_string(context, sp, "- ");
195     
196     /* --- flags */
197     append_string(context, sp, "%d ", HDBFlags2int(ent->flags));
198
199     /* --- generation number */
200     if(ent->generation) {
201         append_string(context, sp, "%s:%d:%d", time2str(ent->generation->time),
202                       ent->generation->usec,
203                       ent->generation->gen);
204     } else
205         append_string(context, sp, "-");
206     
207     return 0;
208 }
209
210 krb5_error_code
211 hdb_entry2string (krb5_context context, hdb_entry *ent, char **str)
212 {
213     krb5_error_code ret;
214     krb5_data data;
215     krb5_storage *sp;
216
217     sp = krb5_storage_emem();
218     if(sp == NULL) {
219         krb5_set_error_string(context, "malloc: out of memory");
220         return ENOMEM;
221     }
222     
223     ret = entry2string_int(context, sp, ent);
224     if(ret) {
225         krb5_storage_free(sp);
226         return ret;
227     }
228
229     krb5_storage_write(sp, "\0", 1);
230     krb5_storage_to_data(sp, &data);
231     krb5_storage_free(sp);
232     *str = data.data;
233     return 0;
234 }
235
236 /* print a hdb_entry to (FILE*)data; suitable for hdb_foreach */
237
238 krb5_error_code
239 hdb_print_entry(krb5_context context, HDB *db, hdb_entry *entry, void *data)
240 {
241     krb5_error_code ret;
242     krb5_storage *sp;
243
244     FILE *f = data;
245
246     fflush(f);
247     sp = krb5_storage_from_fd(fileno(f));
248     if(sp == NULL) {
249         krb5_set_error_string(context, "malloc: out of memory");
250         return ENOMEM;
251     }
252     
253     ret = entry2string_int(context, sp, entry);
254     if(ret) {
255         krb5_storage_free(sp);
256         return ret;
257     }
258
259     krb5_storage_write(sp, "\n", 1);
260     krb5_storage_free(sp);
261     return 0;
262 }