![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to cred_encoding.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / credentials|
Return to cred_encoding.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / credentials |
1.1 misho 1: /*
2: * Copyright (C) 2009 Martin Willi
3: * HSR Hochschule fuer Technik Rapperswil
4: *
5: * This program is free software; you can redistribute it and/or modify it
6: * under the terms of the GNU General Public License as published by the
7: * Free Software Foundation; either version 2 of the License, or (at your
8: * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
9: *
10: * This program is distributed in the hope that it will be useful, but
11: * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
12: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13: * for more details.
14: */
15:
16: #include "cred_encoding.h"
17:
18: #include <stdint.h>
19:
20: #include <collections/linked_list.h>
21: #include <collections/hashtable.h>
22: #include <threading/rwlock.h>
23:
24: typedef struct private_cred_encoding_t private_cred_encoding_t;
25:
26: /**
27: * Private data of an cred_encoding_t object.
28: */
29: struct private_cred_encoding_t {
30:
31: /**
32: * Public cred_encoding_t interface.
33: */
34: cred_encoding_t public;
35:
36: /**
37: * cached encodings, a table for each encoding_type_t, containing chunk_t*
38: */
39: hashtable_t *cache[CRED_ENCODING_MAX];
40:
41: /**
42: * Registered encoding functions, cred_encoder_t
43: */
44: linked_list_t *encoders;
45:
46: /**
47: * lock to access cache/encoders
48: */
49: rwlock_t *lock;
50: };
51:
52: /**
53: * See header.
54: */
55: bool cred_encoding_args(va_list args, ...)
56: {
57: va_list parts, copy;
58: bool failed = FALSE;
59:
60: va_start(parts, args);
61:
62: while (!failed)
63: {
64: cred_encoding_part_t current, target;
65: chunk_t *out, data;
66:
67: /* get the part we are looking for */
68: target = va_arg(parts, cred_encoding_part_t);
69: if (target == CRED_PART_END)
70: {
71: break;
72: }
73: out = va_arg(parts, chunk_t*);
74:
75: va_copy(copy, args);
76: while (!failed)
77: {
78: current = va_arg(copy, cred_encoding_part_t);
79: if (current == CRED_PART_END)
80: {
81: failed = TRUE;
82: break;
83: }
84: data = va_arg(copy, chunk_t);
85: if (current == target)
86: {
87: *out = data;
88: break;
89: }
90: }
91: va_end(copy);
92: }
93: va_end(parts);
94: return !failed;
95: }
96:
97: METHOD(cred_encoding_t, get_cache, bool,
98: private_cred_encoding_t *this, cred_encoding_type_t type, void *cache,
99: chunk_t *encoding)
100: {
101: chunk_t *chunk;
102:
103: if (type >= CRED_ENCODING_MAX || (int)type < 0)
104: {
105: return FALSE;
106: }
107: this->lock->read_lock(this->lock);
108: chunk = this->cache[type]->get(this->cache[type], cache);
109: if (chunk)
110: {
111: *encoding = *chunk;
112: }
113: this->lock->unlock(this->lock);
114: return !!chunk;
115: }
116:
117: /**
118: * Implementation of cred_encoding_t.encode
119: */
120: static bool encode(private_cred_encoding_t *this, cred_encoding_type_t type,
121: void *cache, chunk_t *encoding, ...)
122: {
123: enumerator_t *enumerator;
124: va_list args, copy;
125: cred_encoder_t encode;
126: bool success = FALSE;
127: chunk_t *chunk;
128:
129: if (type >= CRED_ENCODING_MAX || (int)type < 0)
130: {
131: return FALSE;
132: }
133: this->lock->read_lock(this->lock);
134: if (cache)
135: {
136: chunk = this->cache[type]->get(this->cache[type], cache);
137: if (chunk)
138: {
139: *encoding = *chunk;
140: this->lock->unlock(this->lock);
141: return TRUE;
142: }
143: }
144: va_start(args, encoding);
145: enumerator = this->encoders->create_enumerator(this->encoders);
146: while (enumerator->enumerate(enumerator, &encode))
147: {
148: va_copy(copy, args);
149: success = encode(type, encoding, copy);
150: va_end(copy);
151: if (success)
152: {
153: break;
154: }
155: }
156: enumerator->destroy(enumerator);
157: this->lock->unlock(this->lock);
158: va_end(args);
159:
160: if (success && cache)
161: {
162: chunk = malloc_thing(chunk_t);
163: *chunk = *encoding;
164: this->lock->write_lock(this->lock);
165: chunk = this->cache[type]->put(this->cache[type], cache, chunk);
166: this->lock->unlock(this->lock);
167: if (chunk)
168: {
169: free(chunk->ptr);
170: free(chunk);
171: }
172: }
173: return success;
174: }
175:
176: METHOD(cred_encoding_t, cache, void,
177: private_cred_encoding_t *this, cred_encoding_type_t type, void *cache,
178: chunk_t encoding)
179: {
180: chunk_t *chunk;
181:
182: if (type >= CRED_ENCODING_MAX || (int)type < 0)
183: {
184: return free(encoding.ptr);
185: }
186: chunk = malloc_thing(chunk_t);
187: *chunk = encoding;
188: this->lock->write_lock(this->lock);
189: chunk = this->cache[type]->put(this->cache[type], cache, chunk);
190: this->lock->unlock(this->lock);
191: /* free an encoding already associated to the cache */
192: if (chunk)
193: {
194: free(chunk->ptr);
195: free(chunk);
196: }
197: }
198:
199: METHOD(cred_encoding_t, clear_cache, void,
200: private_cred_encoding_t *this, void *cache)
201: {
202: cred_encoding_type_t type;
203: chunk_t *chunk;
204:
205: this->lock->write_lock(this->lock);
206: for (type = 0; type < CRED_ENCODING_MAX; type++)
207: {
208: chunk = this->cache[type]->remove(this->cache[type], cache);
209: if (chunk)
210: {
211: chunk_free(chunk);
212: free(chunk);
213: }
214: }
215: this->lock->unlock(this->lock);
216: }
217:
218: METHOD(cred_encoding_t, add_encoder, void,
219: private_cred_encoding_t *this, cred_encoder_t encoder)
220: {
221: this->lock->write_lock(this->lock);
222: this->encoders->insert_last(this->encoders, encoder);
223: this->lock->unlock(this->lock);
224: }
225:
226: METHOD(cred_encoding_t, remove_encoder, void,
227: private_cred_encoding_t *this, cred_encoder_t encoder)
228: {
229: this->lock->write_lock(this->lock);
230: this->encoders->remove(this->encoders, encoder, NULL);
231: this->lock->unlock(this->lock);
232: }
233:
234: METHOD(cred_encoding_t, destroy, void,
235: private_cred_encoding_t *this)
236: {
237: cred_encoding_type_t type;
238:
239: for (type = 0; type < CRED_ENCODING_MAX; type++)
240: {
241: /* We explicitly do not free remaining encodings. All creds should
242: * have gone now, and they are responsible for cleaning out their
243: * cache entries. Not flushing here allows the leak detective to
244: * complain if a credential did not flush cached encodings. */
245: this->cache[type]->destroy(this->cache[type]);
246: }
247: this->encoders->destroy(this->encoders);
248: this->lock->destroy(this->lock);
249: free(this);
250: }
251:
252: /**
253: * See header
254: */
255: cred_encoding_t *cred_encoding_create()
256: {
257: private_cred_encoding_t *this;
258: cred_encoding_type_t type;
259:
260: INIT(this,
261: .public = {
262: .encode = (bool(*)(cred_encoding_t*, cred_encoding_type_t type, void *cache, chunk_t *encoding, ...))encode,
263: .get_cache = _get_cache,
264: .cache = _cache,
265: .clear_cache = _clear_cache,
266: .add_encoder = _add_encoder,
267: .remove_encoder = _remove_encoder,
268: .destroy = _destroy,
269: },
270: .encoders = linked_list_create(),
271: .lock = rwlock_create(RWLOCK_TYPE_DEFAULT),
272: );
273:
274: for (type = 0; type < CRED_ENCODING_MAX; type++)
275: {
276: this->cache[type] = hashtable_create(hashtable_hash_ptr,
277: hashtable_equals_ptr, 8);
278: }
279:
280: return &this->public;
281: }
282: