Commit | Line | Data |
---|---|---|
42d5ec27 DH |
1 | /* Decoder for ASN.1 BER/DER/CER encoded bytestream |
2 | * | |
3 | * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved. | |
4 | * Written by David Howells (dhowells@redhat.com) | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or | |
7 | * modify it under the terms of the GNU General Public Licence | |
8 | * as published by the Free Software Foundation; either version | |
9 | * 2 of the Licence, or (at your option) any later version. | |
10 | */ | |
11 | ||
12 | #include <linux/export.h> | |
13 | #include <linux/kernel.h> | |
14 | #include <linux/errno.h> | |
ccab6058 | 15 | #include <linux/module.h> |
42d5ec27 DH |
16 | #include <linux/asn1_decoder.h> |
17 | #include <linux/asn1_ber_bytecode.h> | |
18 | ||
19 | static const unsigned char asn1_op_lengths[ASN1_OP__NR] = { | |
20 | /* OPC TAG JMP ACT */ | |
21 | [ASN1_OP_MATCH] = 1 + 1, | |
22 | [ASN1_OP_MATCH_OR_SKIP] = 1 + 1, | |
23 | [ASN1_OP_MATCH_ACT] = 1 + 1 + 1, | |
24 | [ASN1_OP_MATCH_ACT_OR_SKIP] = 1 + 1 + 1, | |
25 | [ASN1_OP_MATCH_JUMP] = 1 + 1 + 1, | |
26 | [ASN1_OP_MATCH_JUMP_OR_SKIP] = 1 + 1 + 1, | |
27 | [ASN1_OP_MATCH_ANY] = 1, | |
233ce79d | 28 | [ASN1_OP_MATCH_ANY_OR_SKIP] = 1, |
42d5ec27 | 29 | [ASN1_OP_MATCH_ANY_ACT] = 1 + 1, |
233ce79d | 30 | [ASN1_OP_MATCH_ANY_ACT_OR_SKIP] = 1 + 1, |
42d5ec27 DH |
31 | [ASN1_OP_COND_MATCH_OR_SKIP] = 1 + 1, |
32 | [ASN1_OP_COND_MATCH_ACT_OR_SKIP] = 1 + 1 + 1, | |
33 | [ASN1_OP_COND_MATCH_JUMP_OR_SKIP] = 1 + 1 + 1, | |
34 | [ASN1_OP_COND_MATCH_ANY] = 1, | |
233ce79d | 35 | [ASN1_OP_COND_MATCH_ANY_OR_SKIP] = 1, |
42d5ec27 | 36 | [ASN1_OP_COND_MATCH_ANY_ACT] = 1 + 1, |
233ce79d | 37 | [ASN1_OP_COND_MATCH_ANY_ACT_OR_SKIP] = 1 + 1, |
42d5ec27 DH |
38 | [ASN1_OP_COND_FAIL] = 1, |
39 | [ASN1_OP_COMPLETE] = 1, | |
40 | [ASN1_OP_ACT] = 1 + 1, | |
3f3af97d | 41 | [ASN1_OP_MAYBE_ACT] = 1 + 1, |
42d5ec27 DH |
42 | [ASN1_OP_RETURN] = 1, |
43 | [ASN1_OP_END_SEQ] = 1, | |
44 | [ASN1_OP_END_SEQ_OF] = 1 + 1, | |
45 | [ASN1_OP_END_SET] = 1, | |
46 | [ASN1_OP_END_SET_OF] = 1 + 1, | |
47 | [ASN1_OP_END_SEQ_ACT] = 1 + 1, | |
48 | [ASN1_OP_END_SEQ_OF_ACT] = 1 + 1 + 1, | |
49 | [ASN1_OP_END_SET_ACT] = 1 + 1, | |
50 | [ASN1_OP_END_SET_OF_ACT] = 1 + 1 + 1, | |
51 | }; | |
52 | ||
53 | /* | |
54 | * Find the length of an indefinite length object | |
dbadc176 DH |
55 | * @data: The data buffer |
56 | * @datalen: The end of the innermost containing element in the buffer | |
57 | * @_dp: The data parse cursor (updated before returning) | |
58 | * @_len: Where to return the size of the element. | |
59 | * @_errmsg: Where to return a pointer to an error message on error | |
42d5ec27 DH |
60 | */ |
61 | static int asn1_find_indefinite_length(const unsigned char *data, size_t datalen, | |
dbadc176 DH |
62 | size_t *_dp, size_t *_len, |
63 | const char **_errmsg) | |
42d5ec27 DH |
64 | { |
65 | unsigned char tag, tmp; | |
dbadc176 | 66 | size_t dp = *_dp, len, n; |
42d5ec27 DH |
67 | int indef_level = 1; |
68 | ||
69 | next_tag: | |
70 | if (unlikely(datalen - dp < 2)) { | |
71 | if (datalen == dp) | |
72 | goto missing_eoc; | |
73 | goto data_overrun_error; | |
74 | } | |
75 | ||
76 | /* Extract a tag from the data */ | |
77 | tag = data[dp++]; | |
78 | if (tag == 0) { | |
79 | /* It appears to be an EOC. */ | |
80 | if (data[dp++] != 0) | |
81 | goto invalid_eoc; | |
dbadc176 DH |
82 | if (--indef_level <= 0) { |
83 | *_len = dp - *_dp; | |
84 | *_dp = dp; | |
85 | return 0; | |
86 | } | |
42d5ec27 DH |
87 | goto next_tag; |
88 | } | |
89 | ||
99cca91e | 90 | if (unlikely((tag & 0x1f) == ASN1_LONG_TAG)) { |
42d5ec27 DH |
91 | do { |
92 | if (unlikely(datalen - dp < 2)) | |
93 | goto data_overrun_error; | |
94 | tmp = data[dp++]; | |
95 | } while (tmp & 0x80); | |
96 | } | |
97 | ||
98 | /* Extract the length */ | |
99 | len = data[dp++]; | |
f3537f91 | 100 | if (len <= 0x7f) { |
42d5ec27 DH |
101 | dp += len; |
102 | goto next_tag; | |
103 | } | |
104 | ||
99cca91e | 105 | if (unlikely(len == ASN1_INDEFINITE_LENGTH)) { |
42d5ec27 DH |
106 | /* Indefinite length */ |
107 | if (unlikely((tag & ASN1_CONS_BIT) == ASN1_PRIM << 5)) | |
108 | goto indefinite_len_primitive; | |
109 | indef_level++; | |
110 | goto next_tag; | |
111 | } | |
112 | ||
113 | n = len - 0x80; | |
114 | if (unlikely(n > sizeof(size_t) - 1)) | |
115 | goto length_too_long; | |
116 | if (unlikely(n > datalen - dp)) | |
117 | goto data_overrun_error; | |
118 | for (len = 0; n > 0; n--) { | |
119 | len <<= 8; | |
120 | len |= data[dp++]; | |
121 | } | |
122 | dp += len; | |
123 | goto next_tag; | |
124 | ||
125 | length_too_long: | |
126 | *_errmsg = "Unsupported length"; | |
127 | goto error; | |
128 | indefinite_len_primitive: | |
129 | *_errmsg = "Indefinite len primitive not permitted"; | |
130 | goto error; | |
131 | invalid_eoc: | |
132 | *_errmsg = "Invalid length EOC"; | |
133 | goto error; | |
134 | data_overrun_error: | |
135 | *_errmsg = "Data overrun error"; | |
136 | goto error; | |
137 | missing_eoc: | |
138 | *_errmsg = "Missing EOC in indefinite len cons"; | |
139 | error: | |
dbadc176 | 140 | *_dp = dp; |
42d5ec27 DH |
141 | return -1; |
142 | } | |
143 | ||
144 | /** | |
145 | * asn1_ber_decoder - Decoder BER/DER/CER ASN.1 according to pattern | |
146 | * @decoder: The decoder definition (produced by asn1_compiler) | |
147 | * @context: The caller's context (to be passed to the action functions) | |
148 | * @data: The encoded data | |
548bbff9 | 149 | * @datalen: The size of the encoded data |
42d5ec27 DH |
150 | * |
151 | * Decode BER/DER/CER encoded ASN.1 data according to a bytecode pattern | |
152 | * produced by asn1_compiler. Action functions are called on marked tags to | |
153 | * allow the caller to retrieve significant data. | |
154 | * | |
155 | * LIMITATIONS: | |
156 | * | |
157 | * To keep down the amount of stack used by this function, the following limits | |
158 | * have been imposed: | |
159 | * | |
160 | * (1) This won't handle datalen > 65535 without increasing the size of the | |
161 | * cons stack elements and length_too_long checking. | |
162 | * | |
163 | * (2) The stack of constructed types is 10 deep. If the depth of non-leaf | |
164 | * constructed types exceeds this, the decode will fail. | |
165 | * | |
166 | * (3) The SET type (not the SET OF type) isn't really supported as tracking | |
167 | * what members of the set have been seen is a pain. | |
168 | */ | |
169 | int asn1_ber_decoder(const struct asn1_decoder *decoder, | |
170 | void *context, | |
171 | const unsigned char *data, | |
172 | size_t datalen) | |
173 | { | |
174 | const unsigned char *machine = decoder->machine; | |
175 | const asn1_action_t *actions = decoder->actions; | |
176 | size_t machlen = decoder->machlen; | |
177 | enum asn1_opcode op; | |
178 | unsigned char tag = 0, csp = 0, jsp = 0, optag = 0, hdr = 0; | |
179 | const char *errmsg; | |
180 | size_t pc = 0, dp = 0, tdp = 0, len = 0; | |
181 | int ret; | |
182 | ||
183 | unsigned char flags = 0; | |
184 | #define FLAG_INDEFINITE_LENGTH 0x01 | |
185 | #define FLAG_MATCHED 0x02 | |
3f3af97d | 186 | #define FLAG_LAST_MATCHED 0x04 /* Last tag matched */ |
42d5ec27 DH |
187 | #define FLAG_CONS 0x20 /* Corresponds to CONS bit in the opcode tag |
188 | * - ie. whether or not we are going to parse | |
189 | * a compound type. | |
190 | */ | |
191 | ||
192 | #define NR_CONS_STACK 10 | |
193 | unsigned short cons_dp_stack[NR_CONS_STACK]; | |
194 | unsigned short cons_datalen_stack[NR_CONS_STACK]; | |
195 | unsigned char cons_hdrlen_stack[NR_CONS_STACK]; | |
196 | #define NR_JUMP_STACK 10 | |
197 | unsigned char jump_stack[NR_JUMP_STACK]; | |
198 | ||
199 | if (datalen > 65535) | |
200 | return -EMSGSIZE; | |
201 | ||
202 | next_op: | |
203 | pr_debug("next_op: pc=\e[32m%zu\e[m/%zu dp=\e[33m%zu\e[m/%zu C=%d J=%d\n", | |
204 | pc, machlen, dp, datalen, csp, jsp); | |
205 | if (unlikely(pc >= machlen)) | |
206 | goto machine_overrun_error; | |
207 | op = machine[pc]; | |
208 | if (unlikely(pc + asn1_op_lengths[op] > machlen)) | |
209 | goto machine_overrun_error; | |
210 | ||
211 | /* If this command is meant to match a tag, then do that before | |
212 | * evaluating the command. | |
213 | */ | |
214 | if (op <= ASN1_OP__MATCHES_TAG) { | |
215 | unsigned char tmp; | |
216 | ||
217 | /* Skip conditional matches if possible */ | |
0d62e9dd DH |
218 | if ((op & ASN1_OP_MATCH__COND && flags & FLAG_MATCHED) || |
219 | (op & ASN1_OP_MATCH__SKIP && dp == datalen)) { | |
3f3af97d | 220 | flags &= ~FLAG_LAST_MATCHED; |
42d5ec27 DH |
221 | pc += asn1_op_lengths[op]; |
222 | goto next_op; | |
223 | } | |
224 | ||
225 | flags = 0; | |
226 | hdr = 2; | |
227 | ||
228 | /* Extract a tag from the data */ | |
229 | if (unlikely(dp >= datalen - 1)) | |
230 | goto data_overrun_error; | |
231 | tag = data[dp++]; | |
99cca91e | 232 | if (unlikely((tag & 0x1f) == ASN1_LONG_TAG)) |
42d5ec27 DH |
233 | goto long_tag_not_supported; |
234 | ||
235 | if (op & ASN1_OP_MATCH__ANY) { | |
236 | pr_debug("- any %02x\n", tag); | |
237 | } else { | |
238 | /* Extract the tag from the machine | |
239 | * - Either CONS or PRIM are permitted in the data if | |
240 | * CONS is not set in the op stream, otherwise CONS | |
241 | * is mandatory. | |
242 | */ | |
243 | optag = machine[pc + 1]; | |
244 | flags |= optag & FLAG_CONS; | |
245 | ||
246 | /* Determine whether the tag matched */ | |
247 | tmp = optag ^ tag; | |
248 | tmp &= ~(optag & ASN1_CONS_BIT); | |
249 | pr_debug("- match? %02x %02x %02x\n", tag, optag, tmp); | |
250 | if (tmp != 0) { | |
251 | /* All odd-numbered tags are MATCH_OR_SKIP. */ | |
252 | if (op & ASN1_OP_MATCH__SKIP) { | |
253 | pc += asn1_op_lengths[op]; | |
254 | dp--; | |
255 | goto next_op; | |
256 | } | |
257 | goto tag_mismatch; | |
258 | } | |
259 | } | |
260 | flags |= FLAG_MATCHED; | |
261 | ||
262 | len = data[dp++]; | |
263 | if (len > 0x7f) { | |
99cca91e | 264 | if (unlikely(len == ASN1_INDEFINITE_LENGTH)) { |
42d5ec27 DH |
265 | /* Indefinite length */ |
266 | if (unlikely(!(tag & ASN1_CONS_BIT))) | |
267 | goto indefinite_len_primitive; | |
268 | flags |= FLAG_INDEFINITE_LENGTH; | |
269 | if (unlikely(2 > datalen - dp)) | |
270 | goto data_overrun_error; | |
271 | } else { | |
272 | int n = len - 0x80; | |
273 | if (unlikely(n > 2)) | |
274 | goto length_too_long; | |
275 | if (unlikely(dp >= datalen - n)) | |
276 | goto data_overrun_error; | |
277 | hdr += n; | |
278 | for (len = 0; n > 0; n--) { | |
279 | len <<= 8; | |
280 | len |= data[dp++]; | |
281 | } | |
282 | if (unlikely(len > datalen - dp)) | |
283 | goto data_overrun_error; | |
284 | } | |
285 | } | |
286 | ||
287 | if (flags & FLAG_CONS) { | |
288 | /* For expected compound forms, we stack the positions | |
289 | * of the start and end of the data. | |
290 | */ | |
291 | if (unlikely(csp >= NR_CONS_STACK)) | |
292 | goto cons_stack_overflow; | |
293 | cons_dp_stack[csp] = dp; | |
294 | cons_hdrlen_stack[csp] = hdr; | |
295 | if (!(flags & FLAG_INDEFINITE_LENGTH)) { | |
296 | cons_datalen_stack[csp] = datalen; | |
297 | datalen = dp + len; | |
298 | } else { | |
299 | cons_datalen_stack[csp] = 0; | |
300 | } | |
301 | csp++; | |
302 | } | |
303 | ||
304 | pr_debug("- TAG: %02x %zu%s\n", | |
305 | tag, len, flags & FLAG_CONS ? " CONS" : ""); | |
306 | tdp = dp; | |
307 | } | |
308 | ||
309 | /* Decide how to handle the operation */ | |
310 | switch (op) { | |
311 | case ASN1_OP_MATCH_ANY_ACT: | |
233ce79d | 312 | case ASN1_OP_MATCH_ANY_ACT_OR_SKIP: |
42d5ec27 | 313 | case ASN1_OP_COND_MATCH_ANY_ACT: |
233ce79d | 314 | case ASN1_OP_COND_MATCH_ANY_ACT_OR_SKIP: |
42d5ec27 DH |
315 | ret = actions[machine[pc + 1]](context, hdr, tag, data + dp, len); |
316 | if (ret < 0) | |
317 | return ret; | |
318 | goto skip_data; | |
319 | ||
320 | case ASN1_OP_MATCH_ACT: | |
321 | case ASN1_OP_MATCH_ACT_OR_SKIP: | |
322 | case ASN1_OP_COND_MATCH_ACT_OR_SKIP: | |
323 | ret = actions[machine[pc + 2]](context, hdr, tag, data + dp, len); | |
324 | if (ret < 0) | |
325 | return ret; | |
326 | goto skip_data; | |
327 | ||
328 | case ASN1_OP_MATCH: | |
329 | case ASN1_OP_MATCH_OR_SKIP: | |
330 | case ASN1_OP_MATCH_ANY: | |
233ce79d | 331 | case ASN1_OP_MATCH_ANY_OR_SKIP: |
42d5ec27 DH |
332 | case ASN1_OP_COND_MATCH_OR_SKIP: |
333 | case ASN1_OP_COND_MATCH_ANY: | |
233ce79d | 334 | case ASN1_OP_COND_MATCH_ANY_OR_SKIP: |
42d5ec27 DH |
335 | skip_data: |
336 | if (!(flags & FLAG_CONS)) { | |
337 | if (flags & FLAG_INDEFINITE_LENGTH) { | |
dbadc176 DH |
338 | ret = asn1_find_indefinite_length( |
339 | data, datalen, &dp, &len, &errmsg); | |
340 | if (ret < 0) | |
42d5ec27 | 341 | goto error; |
dbadc176 DH |
342 | } else { |
343 | dp += len; | |
42d5ec27 DH |
344 | } |
345 | pr_debug("- LEAF: %zu\n", len); | |
42d5ec27 DH |
346 | } |
347 | pc += asn1_op_lengths[op]; | |
348 | goto next_op; | |
349 | ||
350 | case ASN1_OP_MATCH_JUMP: | |
351 | case ASN1_OP_MATCH_JUMP_OR_SKIP: | |
352 | case ASN1_OP_COND_MATCH_JUMP_OR_SKIP: | |
353 | pr_debug("- MATCH_JUMP\n"); | |
354 | if (unlikely(jsp == NR_JUMP_STACK)) | |
355 | goto jump_stack_overflow; | |
356 | jump_stack[jsp++] = pc + asn1_op_lengths[op]; | |
357 | pc = machine[pc + 2]; | |
358 | goto next_op; | |
359 | ||
360 | case ASN1_OP_COND_FAIL: | |
361 | if (unlikely(!(flags & FLAG_MATCHED))) | |
362 | goto tag_mismatch; | |
363 | pc += asn1_op_lengths[op]; | |
364 | goto next_op; | |
365 | ||
366 | case ASN1_OP_COMPLETE: | |
367 | if (unlikely(jsp != 0 || csp != 0)) { | |
368 | pr_err("ASN.1 decoder error: Stacks not empty at completion (%u, %u)\n", | |
369 | jsp, csp); | |
370 | return -EBADMSG; | |
371 | } | |
372 | return 0; | |
373 | ||
374 | case ASN1_OP_END_SET: | |
375 | case ASN1_OP_END_SET_ACT: | |
376 | if (unlikely(!(flags & FLAG_MATCHED))) | |
377 | goto tag_mismatch; | |
378 | case ASN1_OP_END_SEQ: | |
379 | case ASN1_OP_END_SET_OF: | |
380 | case ASN1_OP_END_SEQ_OF: | |
381 | case ASN1_OP_END_SEQ_ACT: | |
382 | case ASN1_OP_END_SET_OF_ACT: | |
383 | case ASN1_OP_END_SEQ_OF_ACT: | |
384 | if (unlikely(csp <= 0)) | |
385 | goto cons_stack_underflow; | |
386 | csp--; | |
387 | tdp = cons_dp_stack[csp]; | |
388 | hdr = cons_hdrlen_stack[csp]; | |
389 | len = datalen; | |
390 | datalen = cons_datalen_stack[csp]; | |
391 | pr_debug("- end cons t=%zu dp=%zu l=%zu/%zu\n", | |
392 | tdp, dp, len, datalen); | |
393 | if (datalen == 0) { | |
394 | /* Indefinite length - check for the EOC. */ | |
395 | datalen = len; | |
396 | if (unlikely(datalen - dp < 2)) | |
397 | goto data_overrun_error; | |
398 | if (data[dp++] != 0) { | |
399 | if (op & ASN1_OP_END__OF) { | |
400 | dp--; | |
401 | csp++; | |
402 | pc = machine[pc + 1]; | |
403 | pr_debug("- continue\n"); | |
404 | goto next_op; | |
405 | } | |
406 | goto missing_eoc; | |
407 | } | |
408 | if (data[dp++] != 0) | |
409 | goto invalid_eoc; | |
410 | len = dp - tdp - 2; | |
411 | } else { | |
412 | if (dp < len && (op & ASN1_OP_END__OF)) { | |
413 | datalen = len; | |
414 | csp++; | |
415 | pc = machine[pc + 1]; | |
416 | pr_debug("- continue\n"); | |
417 | goto next_op; | |
418 | } | |
419 | if (dp != len) | |
420 | goto cons_length_error; | |
421 | len -= tdp; | |
422 | pr_debug("- cons len l=%zu d=%zu\n", len, dp - tdp); | |
423 | } | |
424 | ||
425 | if (op & ASN1_OP_END__ACT) { | |
426 | unsigned char act; | |
427 | if (op & ASN1_OP_END__OF) | |
428 | act = machine[pc + 2]; | |
429 | else | |
430 | act = machine[pc + 1]; | |
431 | ret = actions[act](context, hdr, 0, data + tdp, len); | |
432 | } | |
433 | pc += asn1_op_lengths[op]; | |
434 | goto next_op; | |
435 | ||
3f3af97d DH |
436 | case ASN1_OP_MAYBE_ACT: |
437 | if (!(flags & FLAG_LAST_MATCHED)) { | |
438 | pc += asn1_op_lengths[op]; | |
439 | goto next_op; | |
440 | } | |
42d5ec27 DH |
441 | case ASN1_OP_ACT: |
442 | ret = actions[machine[pc + 1]](context, hdr, tag, data + tdp, len); | |
3f3af97d DH |
443 | if (ret < 0) |
444 | return ret; | |
42d5ec27 DH |
445 | pc += asn1_op_lengths[op]; |
446 | goto next_op; | |
447 | ||
448 | case ASN1_OP_RETURN: | |
449 | if (unlikely(jsp <= 0)) | |
450 | goto jump_stack_underflow; | |
451 | pc = jump_stack[--jsp]; | |
3f3af97d | 452 | flags |= FLAG_MATCHED | FLAG_LAST_MATCHED; |
42d5ec27 DH |
453 | goto next_op; |
454 | ||
455 | default: | |
456 | break; | |
457 | } | |
458 | ||
459 | /* Shouldn't reach here */ | |
3f3af97d DH |
460 | pr_err("ASN.1 decoder error: Found reserved opcode (%u) pc=%zu\n", |
461 | op, pc); | |
42d5ec27 DH |
462 | return -EBADMSG; |
463 | ||
464 | data_overrun_error: | |
465 | errmsg = "Data overrun error"; | |
466 | goto error; | |
467 | machine_overrun_error: | |
468 | errmsg = "Machine overrun error"; | |
469 | goto error; | |
470 | jump_stack_underflow: | |
471 | errmsg = "Jump stack underflow"; | |
472 | goto error; | |
473 | jump_stack_overflow: | |
474 | errmsg = "Jump stack overflow"; | |
475 | goto error; | |
476 | cons_stack_underflow: | |
477 | errmsg = "Cons stack underflow"; | |
478 | goto error; | |
479 | cons_stack_overflow: | |
480 | errmsg = "Cons stack overflow"; | |
481 | goto error; | |
482 | cons_length_error: | |
483 | errmsg = "Cons length error"; | |
484 | goto error; | |
485 | missing_eoc: | |
486 | errmsg = "Missing EOC in indefinite len cons"; | |
487 | goto error; | |
488 | invalid_eoc: | |
489 | errmsg = "Invalid length EOC"; | |
490 | goto error; | |
491 | length_too_long: | |
492 | errmsg = "Unsupported length"; | |
493 | goto error; | |
494 | indefinite_len_primitive: | |
495 | errmsg = "Indefinite len primitive not permitted"; | |
496 | goto error; | |
497 | tag_mismatch: | |
498 | errmsg = "Unexpected tag"; | |
499 | goto error; | |
500 | long_tag_not_supported: | |
501 | errmsg = "Long tag not supported"; | |
502 | error: | |
503 | pr_debug("\nASN1: %s [m=%zu d=%zu ot=%02x t=%02x l=%zu]\n", | |
504 | errmsg, pc, dp, optag, tag, len); | |
505 | return -EBADMSG; | |
506 | } | |
507 | EXPORT_SYMBOL_GPL(asn1_ber_decoder); | |
ccab6058 TA |
508 | |
509 | MODULE_LICENSE("GPL"); |