Restructure Makefiles to accomodate multiple archs
[dragonfly.git] / crypto / heimdal-0.6.3 / lib / hdb / hdb.c
1 /*
2  * Copyright (c) 1997 - 2001 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 "hdb_locl.h"
35
36 RCSID("$Id: hdb.c,v 1.44 2001/08/09 08:41:48 assar Exp $");
37
38 struct hdb_method {
39     const char *prefix;
40     krb5_error_code (*create)(krb5_context, HDB **, const char *filename);
41 };
42
43 static struct hdb_method methods[] = {
44 #if HAVE_DB1 || HAVE_DB3
45     {"db:",     hdb_db_create},
46 #endif
47 #if HAVE_NDBM
48     {"ndbm:",   hdb_ndbm_create},
49 #endif
50 #ifdef OPENLDAP
51     {"ldap:",   hdb_ldap_create},
52 #endif
53 #if HAVE_DB1 || HAVE_DB3
54     {"",        hdb_db_create},
55 #elif defined(HAVE_NDBM)
56     {"",        hdb_ndbm_create},
57 #elif defined(OPENLDAP)
58     {"",        hdb_ldap_create},
59 #endif
60     {NULL,      NULL}
61 };
62
63 krb5_error_code
64 hdb_next_enctype2key(krb5_context context,
65                      const hdb_entry *e,
66                      krb5_enctype enctype,
67                      Key **key)
68 {
69     Key *k;
70     
71     for (k = *key ? (*key) + 1 : e->keys.val;
72          k < e->keys.val + e->keys.len; 
73          k++)
74         if(k->key.keytype == enctype){
75             *key = k;
76             return 0;
77         }
78     return KRB5_PROG_ETYPE_NOSUPP; /* XXX */
79 }
80
81 krb5_error_code
82 hdb_enctype2key(krb5_context context, 
83                 hdb_entry *e, 
84                 krb5_enctype enctype, 
85                 Key **key)
86 {
87     *key = NULL;
88     return hdb_next_enctype2key(context, e, enctype, key);
89 }
90
91 void
92 hdb_free_key(Key *key)
93 {
94     memset(key->key.keyvalue.data, 
95            0,
96            key->key.keyvalue.length);
97     free_Key(key);
98     free(key);
99 }
100
101
102 krb5_error_code
103 hdb_lock(int fd, int operation)
104 {
105     int i, code = 0;
106
107     for(i = 0; i < 3; i++){
108         code = flock(fd, (operation == HDB_RLOCK ? LOCK_SH : LOCK_EX) | LOCK_NB);
109         if(code == 0 || errno != EWOULDBLOCK)
110             break;
111         sleep(1);
112     }
113     if(code == 0)
114         return 0;
115     if(errno == EWOULDBLOCK)
116         return HDB_ERR_DB_INUSE;
117     return HDB_ERR_CANT_LOCK_DB;
118 }
119
120 krb5_error_code
121 hdb_unlock(int fd)
122 {
123     int code;
124     code = flock(fd, LOCK_UN);
125     if(code)
126         return 4711 /* XXX */;
127     return 0;
128 }
129
130 void
131 hdb_free_entry(krb5_context context, hdb_entry *ent)
132 {
133     int i;
134
135     for(i = 0; i < ent->keys.len; ++i) {
136         Key *k = &ent->keys.val[i];
137
138         memset (k->key.keyvalue.data, 0, k->key.keyvalue.length);
139     }
140     free_hdb_entry(ent);
141 }
142
143 krb5_error_code
144 hdb_foreach(krb5_context context,
145             HDB *db,
146             unsigned flags,
147             hdb_foreach_func_t func,
148             void *data)
149 {
150     krb5_error_code ret;
151     hdb_entry entry;
152     ret = db->firstkey(context, db, flags, &entry);
153     while(ret == 0){
154         ret = (*func)(context, db, &entry, data);
155         hdb_free_entry(context, &entry);
156         if(ret == 0)
157             ret = db->nextkey(context, db, flags, &entry);
158     }
159     if(ret == HDB_ERR_NOENTRY)
160         ret = 0;
161     return ret;
162 }
163
164 krb5_error_code
165 hdb_check_db_format(krb5_context context, HDB *db)
166 {
167     krb5_data tag;
168     krb5_data version;
169     krb5_error_code ret;
170     unsigned ver;
171     int foo;
172
173     tag.data = HDB_DB_FORMAT_ENTRY;
174     tag.length = strlen(tag.data);
175     ret = (*db->_get)(context, db, tag, &version);
176     if(ret)
177         return ret;
178     foo = sscanf(version.data, "%u", &ver);
179     krb5_data_free (&version);
180     if (foo != 1)
181         return HDB_ERR_BADVERSION;
182     if(ver != HDB_DB_FORMAT)
183         return HDB_ERR_BADVERSION;
184     return 0;
185 }
186
187 krb5_error_code
188 hdb_init_db(krb5_context context, HDB *db)
189 {
190     krb5_error_code ret;
191     krb5_data tag;
192     krb5_data version;
193     char ver[32];
194     
195     ret = hdb_check_db_format(context, db);
196     if(ret != HDB_ERR_NOENTRY)
197         return ret;
198     
199     tag.data = HDB_DB_FORMAT_ENTRY;
200     tag.length = strlen(tag.data);
201     snprintf(ver, sizeof(ver), "%u", HDB_DB_FORMAT);
202     version.data = ver;
203     version.length = strlen(version.data) + 1; /* zero terminated */
204     ret = (*db->_put)(context, db, 0, tag, version);
205     return ret;
206 }
207
208 /*
209  * find the relevant method for `filename', returning a pointer to the
210  * rest in `rest'.
211  * return NULL if there's no such method.
212  */
213
214 static const struct hdb_method *
215 find_method (const char *filename, const char **rest)
216 {
217     const struct hdb_method *h;
218
219     for (h = methods; h->prefix != NULL; ++h)
220         if (strncmp (filename, h->prefix, strlen(h->prefix)) == 0) {
221             *rest = filename + strlen(h->prefix);
222             return h;
223         }
224     return NULL;
225 }
226
227 krb5_error_code
228 hdb_create(krb5_context context, HDB **db, const char *filename)
229 {
230     const struct hdb_method *h;
231     const char *residual;
232
233     if(filename == NULL)
234         filename = HDB_DEFAULT_DB;
235     krb5_add_et_list(context, initialize_hdb_error_table_r);
236     h = find_method (filename, &residual);
237     if (h == NULL)
238         krb5_errx(context, 1, "No database support! (hdb_create)");
239     return (*h->create)(context, db, residual);
240 }