chiark / gitweb /
81b04fcc65f456e3585001fd7425236b37d66ba5
[secnet.git] / privcache.c
1 /*
2  * This file is part of secnet.
3  * See README for full list of copyright holders.
4  *
5  * secnet is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 3 of the License, or
8  * (at your option) any later version.
9  * 
10  * secnet is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License for more details.
14  * 
15  * You should have received a copy of the GNU General Public License
16  * version 3 along with secnet; if not, see
17  * https://www.gnu.org/licenses/gpl.html.
18  */
19
20 #include "secnet.h"
21 #include "util.h"
22
23 #define DEFAULT_SIZE 5
24
25 struct ent {
26     struct sigkeyid id;
27     struct sigprivkey_if *sigpriv; /* 0 means none such */
28 };
29
30 struct privcache {
31     closure_t cl;
32     struct privcache_if ops;
33     int used, alloc;
34     struct pathprefix_template path;
35     struct ent *ents;
36     struct buffer_if databuf;
37     struct hash_if *defhash;
38 };
39
40 static struct sigprivkey_if *uncached_get(struct privcache *st,
41                            const struct sigkeyid *id, struct log_if *log)
42 {
43     bool_t ok=False;
44     FILE *f=0;
45
46     sprintf(st->path.write_here, SIGKEYID_PR_FMT, SIGKEYID_PR_VAL(id));
47
48     f = fopen(st->path.buffer,"rb");
49     if (!f) {
50         if (errno == ENOENT) {
51             slilog(log,M_DEBUG,"private key %s not found",
52                    st->path.buffer);
53         } else {
54             slilog(log,M_ERR,"failed to open private key file %s",
55                    st->path.buffer);
56         }
57         goto out;
58     }
59
60     setbuf(f,0);
61     buffer_init(&st->databuf,0);
62     ssize_t got=fread(st->databuf.base,1,st->databuf.alloclen,f);
63     if (ferror(f)) {
64         slilog(log,M_ERR,"failed to read private-key file %s",
65                st->path.buffer);
66         goto out;
67     }
68     if (!feof(f)) {
69         slilog(log,M_ERR,"private key file %s longer than max %d",
70                st->path.buffer, (int)st->databuf.alloclen);
71         goto out;
72     }
73     fclose(f); f=0;
74
75     struct sigprivkey_if *sigpriv=0;
76     for (const struct sigscheme_info *scheme=sigschemes;
77          scheme->name;
78          scheme++) {
79         st->databuf.start=st->databuf.base;
80         st->databuf.size=got;
81         struct cloc loc = { .file=st->path.buffer, .line=0 };
82         ok=scheme->loadpriv(scheme, &st->databuf, &sigpriv, log, loc);
83         if (ok) {
84             if (sigpriv->sethash) {
85                 if (!st->defhash) {
86                     slilog(log,M_ERR,
87  "private key %s requires `hash' config key for privcache to load",
88                            st->path.buffer);
89                     sigpriv->dispose(sigpriv->st);
90                     sigpriv=0;
91                     goto out;
92                 }
93                 sigpriv->sethash(sigpriv->st,st->defhash);
94             }
95             goto out;
96         }
97     }
98
99     slilog(log,M_ERR,"private key file %s not loaded (not recognised?)",
100            st->path.buffer);
101
102   out:
103     if (f) fclose(f);
104     return ok ? sigpriv : 0;
105 }
106
107 static struct sigprivkey_if *privcache_lookup(void *sst,
108                                               const struct sigkeyid *id,
109                                               struct log_if *log) {
110     struct privcache *st = sst;
111     int was;
112     struct ent result;
113
114     for (was=0; was<st->used; was++) {
115         if (sigkeyid_equal(id, &st->ents[was].id)) {
116             result = st->ents[was];
117             goto found;
118         }
119     }
120
121     if (st->used < st->alloc) {
122         was = st->used;
123         st->used++;
124     } else {
125         was = st->used-1;
126         if (st->ents[was].sigpriv) {
127             st->ents[was].sigpriv->dispose(st->ents[was].sigpriv->st);
128         }
129     }
130
131     COPY_OBJ(result.id, *id);
132     result.sigpriv=uncached_get(st,id,log);
133
134  found:
135     memmove(&st->ents[1], &st->ents[0], sizeof(st->ents[0]) * was);
136     st->ents[0] = result;
137     return result.sigpriv;
138 }
139
140 static list_t *privcache_apply(closure_t *self, struct cloc loc,
141                                dict_t *context, list_t *args)
142 {
143     struct privcache *st;
144     item_t *item;
145     dict_t *dict;
146
147     NEW(st);
148     st->cl.description="privcache";
149     st->cl.type=CL_PRIVCACHE;
150     st->cl.apply=NULL;
151     st->cl.interface=&st->ops;
152     st->ops.st=st;
153     st->ops.lookup=privcache_lookup;
154     st->ents=0;
155     st->path.buffer=0;
156     st->used=st->alloc=0;
157     st->defhash=0;
158
159     item=list_elem(args,0);
160     if (!item || item->type!=t_dict)
161         cfgfatal(loc,"privcache","parameter must be a dictionary\n");
162     
163     dict=item->data.dict;
164
165     st->alloc=dict_read_number(dict,"privcache-size",False,"privcache",loc,
166                                DEFAULT_SIZE);
167     NEW_ARY(st->ents,st->alloc);
168     st->used=0;
169
170     int32_t buflen=dict_read_number(dict,"privkey-max",False,"privcache",loc,
171                                     4095);
172     buffer_new(&st->databuf,buflen+1);
173
174     const char *path=dict_read_string(dict,"privkeys",True,"privcache",loc);
175     pathprefix_template_init(&st->path,path,KEYIDSZ*2);
176
177     st->defhash=find_cl_if(dict,"hash",CL_HASH,False,"site",loc);
178
179     return new_closure(&st->cl);
180 }
181
182 void privcache_module(dict_t *dict)
183 {
184     add_closure(dict,"priv-cache",privcache_apply);
185 }