Added libb64-1.2.1 for base64 encoding/decoding
This commit is contained in:
Jordan Cristiano
parent
60888b0c97
commit
94d1c32319
|
|
@ -0,0 +1,15 @@
|
|||
libb64: Base64 Encoding/Decoding Routines
|
||||
======================================
|
||||
|
||||
Authors:
|
||||
-------
|
||||
|
||||
Chris Venter chris.venter@gmail.com http://controlaltfire.com
|
||||
|
||||
Contributors:
|
||||
------------
|
||||
|
||||
Mario Rugiero
|
||||
Shlok Datye
|
||||
Peter K. Lee
|
||||
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
libb64: Base64 Encoding/Decoding Routines
|
||||
======================================
|
||||
|
||||
## Changelog ##
|
||||
|
||||
Version 1.2.1 Release
|
||||
---------------------
|
||||
Fixed a long-standing bug in src/cdecode.c where value_in was not correctly
|
||||
checked against the bounds [0..decoding_size)
|
||||
Thanks to both Mario Rugiero and Shlok Datye for pointing this out.
|
||||
Added some simple example code to answer some of the most common misconceptions
|
||||
people have about the library usage.
|
||||
|
||||
Version 1.2 Release
|
||||
-------------------
|
||||
Removed the b64dec, b64enc, encoder and decoder programs in favour of
|
||||
a better example, called base64, which encodes and decodes
|
||||
depending on its arguments.
|
||||
|
||||
Created a solution for Microsoft Visual Studio C++ Express 2010
|
||||
edition, which simply builds the base64 example as a console application.
|
||||
|
||||
Version 1.1 Release
|
||||
-------------------
|
||||
Modified encode.h to (correctly) read from the iostream argument,
|
||||
instead of std::cin.
|
||||
Thanks to Peter K. Lee for the heads-up.
|
||||
|
||||
No API changes.
|
||||
|
||||
Version 1.0 Release
|
||||
-------------------
|
||||
The current content is the changeset.
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
Copyright-Only Dedication (based on United States law)
|
||||
or Public Domain Certification
|
||||
|
||||
The person or persons who have associated work with this document (the
|
||||
"Dedicator" or "Certifier") hereby either (a) certifies that, to the best of
|
||||
his knowledge, the work of authorship identified is in the public domain of the
|
||||
country from which the work is published, or (b) hereby dedicates whatever
|
||||
copyright the dedicators holds in the work of authorship identified below (the
|
||||
"Work") to the public domain. A certifier, moreover, dedicates any copyright
|
||||
interest he may have in the associated work, and for these purposes, is
|
||||
described as a "dedicator" below.
|
||||
|
||||
A certifier has taken reasonable steps to verify the copyright status of this
|
||||
work. Certifier recognizes that his good faith efforts may not shield him from
|
||||
liability if in fact the work certified is not in the public domain.
|
||||
|
||||
Dedicator makes this dedication for the benefit of the public at large and to
|
||||
the detriment of the Dedicator's heirs and successors. Dedicator intends this
|
||||
dedication to be an overt act of relinquishment in perpetuity of all present
|
||||
and future rights under copyright law, whether vested or contingent, in the
|
||||
Work. Dedicator understands that such relinquishment of all rights includes
|
||||
the relinquishment of all rights to enforce (by lawsuit or otherwise) those
|
||||
copyrights in the Work.
|
||||
|
||||
Dedicator recognizes that, once placed in the public domain, the Work may be
|
||||
freely reproduced, distributed, transmitted, used, modified, built upon, or
|
||||
otherwise exploited by anyone for any purpose, commercial or non-commercial,
|
||||
and in any way, including by methods that have not yet been invented or
|
||||
conceived.
|
||||
|
|
@ -0,0 +1,143 @@
|
|||
b64: Base64 Encoding/Decoding Routines
|
||||
======================================
|
||||
|
||||
Overview:
|
||||
--------
|
||||
libb64 is a library of ANSI C routines for fast encoding/decoding data into and
|
||||
from a base64-encoded format. C++ wrappers are included, as well as the source
|
||||
code for standalone encoding and decoding executables.
|
||||
|
||||
base64 consists of ASCII text, and is therefore a useful encoding for storing
|
||||
binary data in a text file, such as xml, or sending binary data over text-only
|
||||
email.
|
||||
|
||||
References:
|
||||
----------
|
||||
* Wikipedia article:
|
||||
http://en.wikipedia.org/wiki/Base64
|
||||
* base64, another implementation of a commandline en/decoder:
|
||||
http://www.fourmilab.ch/webtools/base64/
|
||||
|
||||
Why?
|
||||
---
|
||||
I did this because I need an implementation of base64 encoding and decoding,
|
||||
without any licensing problems. Most OS implementations are released under
|
||||
either the GNU/GPL, or a BSD-variant, which is not what I require.
|
||||
|
||||
Also, the chance to actually use the co-routine implementation in code is rare,
|
||||
and its use here is fitting. I couldn't pass up the chance.
|
||||
For more information on this technique, see "Coroutines in C", by Simon Tatham,
|
||||
which can be found online here:
|
||||
http://www.chiark.greenend.org.uk/~sgtatham/coroutines.html
|
||||
|
||||
So then, under which license do I release this code? On to the next section...
|
||||
|
||||
License:
|
||||
-------
|
||||
This work is released under into the Public Domain.
|
||||
It basically boils down to this: I put this work in the public domain, and you
|
||||
can take it and do whatever you want with it.
|
||||
|
||||
An example of this "license" is the Creative Commons Public Domain License, a
|
||||
copy of which can be found in the LICENSE file, and also online at
|
||||
http://creativecommons.org/licenses/publicdomain/
|
||||
|
||||
Commandline Use:
|
||||
---------------
|
||||
There is a new executable available, it is simply called base64.
|
||||
It can encode and decode files, as instructed by the user.
|
||||
|
||||
To encode a file:
|
||||
$ ./base64 -e filea fileb
|
||||
fileb will now be the base64-encoded version of filea.
|
||||
|
||||
To decode a file:
|
||||
$ ./base64 -d fileb filec
|
||||
filec will now be identical to filea.
|
||||
|
||||
Programming:
|
||||
-----------
|
||||
Some C++ wrappers are provided as well, so you don't have to get your hands
|
||||
dirty. Encoding from standard input to standard output is as simple as
|
||||
|
||||
#include <b64/encode.h>
|
||||
#include <iostream>
|
||||
int main()
|
||||
{
|
||||
base64::encoder E;
|
||||
E.encode(std::cin, std::cout);
|
||||
return 0;
|
||||
}
|
||||
|
||||
Both standalone executables and a static library is provided in the package,
|
||||
|
||||
Example code:
|
||||
------------
|
||||
The 'examples' directory contains some simple example C code, that demonstrates
|
||||
how to use the C interface of the library.
|
||||
|
||||
Implementation:
|
||||
--------------
|
||||
It is DAMN fast, if I may say so myself. The C code uses a little trick which
|
||||
has been used to implement coroutines, of which one can say that this
|
||||
implementation is an example.
|
||||
|
||||
(To see how the libb64 codebase compares with some other BASE64 implementations
|
||||
available, see the BENCHMARKS file)
|
||||
|
||||
The trick involves the fact that a switch-statement may legally cross into
|
||||
sub-blocks. A very thorough and enlightening essay on co-routines in C, using
|
||||
this method, can be found in the above mentioned "Coroutines in C", by Simon
|
||||
Tatham: http://www.chiark.greenend.org.uk/~sgtatham/coroutines.html
|
||||
|
||||
For example, an RLE decompressing routine, adapted from the article:
|
||||
1 static int STATE = 0;
|
||||
2 static int len, c;
|
||||
3 switch (STATE)
|
||||
4 {
|
||||
5 while (1)
|
||||
6 {
|
||||
7 c = getchar();
|
||||
8 if (c == EOF) return EOF;
|
||||
9 if (c == 0xFF) {
|
||||
10 len = getchar();
|
||||
11 c = getchar();
|
||||
12 while (len--)
|
||||
13 {
|
||||
14 STATE = 0;
|
||||
15 return c;
|
||||
16 case 0:
|
||||
17 }
|
||||
18 } else
|
||||
19 STATE = 1;
|
||||
20 return c;
|
||||
21 case 1:
|
||||
22 }
|
||||
23 }
|
||||
24 }
|
||||
|
||||
As can be seen from this example, a coroutine depends on a state variable,
|
||||
which it sets directly before exiting (lines 14 and 119). The next time the
|
||||
routine is entered, the switch moves control to the specific point directly
|
||||
after the previous exit (lines 16 and 21).hands
|
||||
|
||||
(As an aside, in the mentioned article the combination of the top-level switch,
|
||||
the various setting of the state, the return of a value, and the labelling of
|
||||
the exit point is wrapped in #define macros, making the structure of the
|
||||
routine even clearer.)
|
||||
|
||||
The obvious problem with any such routine is the static keyword.
|
||||
Any static variables in a function spell doom for multithreaded applications.
|
||||
Also, in situations where this coroutine is used by more than one other
|
||||
coroutines, the consistency is disturbed.
|
||||
|
||||
What is needed is a structure for storing these variabled, which is passed to
|
||||
the routine seperately. This obviously breaks the modularity of the function,
|
||||
since now the caller has to worry about and care for the internal state of the
|
||||
routine (the callee). This allows for a fast, multithreading-enabled
|
||||
implementation, which may (obviously) be wrapped in a C++ object for ease of
|
||||
use.
|
||||
|
||||
The base64 encoding and decoding functionality in this package is implemented
|
||||
in exactly this way, providing both a high-speed high-maintanence C interface,
|
||||
and a wrapped C++ which is low-maintanence and only slightly less performant.
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
/*
|
||||
cdecode.h - c header for a base64 decoding algorithm
|
||||
|
||||
This is part of the libb64 project, and has been placed in the public domain.
|
||||
For details, see http://sourceforge.net/projects/libb64
|
||||
*/
|
||||
|
||||
#ifndef BASE64_CDECODE_H
|
||||
#define BASE64_CDECODE_H
|
||||
|
||||
typedef enum
|
||||
{
|
||||
step_a, step_b, step_c, step_d
|
||||
} base64_decodestep;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
base64_decodestep step;
|
||||
char plainchar;
|
||||
} base64_decodestate;
|
||||
|
||||
void base64_init_decodestate(base64_decodestate* state_in);
|
||||
|
||||
int base64_decode_value(char value_in);
|
||||
|
||||
int base64_decode_block(const char* code_in, const int length_in, char* plaintext_out, base64_decodestate* state_in);
|
||||
|
||||
#endif /* BASE64_CDECODE_H */
|
||||
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
/*
|
||||
cencode.h - c header for a base64 encoding algorithm
|
||||
|
||||
This is part of the libb64 project, and has been placed in the public domain.
|
||||
For details, see http://sourceforge.net/projects/libb64
|
||||
*/
|
||||
|
||||
#ifndef BASE64_CENCODE_H
|
||||
#define BASE64_CENCODE_H
|
||||
|
||||
typedef enum
|
||||
{
|
||||
step_A, step_B, step_C
|
||||
} base64_encodestep;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
base64_encodestep step;
|
||||
char result;
|
||||
int stepcount;
|
||||
} base64_encodestate;
|
||||
|
||||
void base64_init_encodestate(base64_encodestate* state_in);
|
||||
|
||||
char base64_encode_value(char value_in);
|
||||
|
||||
int base64_encode_block(const char* plaintext_in, int length_in, char* code_out, base64_encodestate* state_in);
|
||||
|
||||
int base64_encode_blockend(char* code_out, base64_encodestate* state_in);
|
||||
|
||||
#endif /* BASE64_CENCODE_H */
|
||||
|
||||
|
|
@ -0,0 +1,70 @@
|
|||
// :mode=c++:
|
||||
/*
|
||||
decode.h - c++ wrapper for a base64 decoding algorithm
|
||||
|
||||
This is part of the libb64 project, and has been placed in the public domain.
|
||||
For details, see http://sourceforge.net/projects/libb64
|
||||
*/
|
||||
#ifndef BASE64_DECODE_H
|
||||
#define BASE64_DECODE_H
|
||||
|
||||
#include <iostream>
|
||||
|
||||
namespace base64
|
||||
{
|
||||
extern "C"
|
||||
{
|
||||
#include "cdecode.h"
|
||||
}
|
||||
|
||||
struct decoder
|
||||
{
|
||||
base64_decodestate _state;
|
||||
int _buffersize;
|
||||
|
||||
decoder(int buffersize_in = BUFFERSIZE)
|
||||
: _buffersize(buffersize_in)
|
||||
{}
|
||||
|
||||
int decode(char value_in)
|
||||
{
|
||||
return base64_decode_value(value_in);
|
||||
}
|
||||
|
||||
int decode(const char* code_in, const int length_in, char* plaintext_out)
|
||||
{
|
||||
return base64_decode_block(code_in, length_in, plaintext_out, &_state);
|
||||
}
|
||||
|
||||
void decode(std::istream& istream_in, std::ostream& ostream_in)
|
||||
{
|
||||
base64_init_decodestate(&_state);
|
||||
//
|
||||
const int N = _buffersize;
|
||||
char* code = new char[N];
|
||||
char* plaintext = new char[N];
|
||||
int codelength;
|
||||
int plainlength;
|
||||
|
||||
do
|
||||
{
|
||||
istream_in.read((char*)code, N);
|
||||
codelength = istream_in.gcount();
|
||||
plainlength = decode(code, codelength, plaintext);
|
||||
ostream_in.write((const char*)plaintext, plainlength);
|
||||
}
|
||||
while (istream_in.good() && codelength > 0);
|
||||
//
|
||||
base64_init_decodestate(&_state);
|
||||
|
||||
delete [] code;
|
||||
delete [] plaintext;
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace base64
|
||||
|
||||
|
||||
|
||||
#endif // BASE64_DECODE_H
|
||||
|
||||
|
|
@ -0,0 +1,77 @@
|
|||
// :mode=c++:
|
||||
/*
|
||||
encode.h - c++ wrapper for a base64 encoding algorithm
|
||||
|
||||
This is part of the libb64 project, and has been placed in the public domain.
|
||||
For details, see http://sourceforge.net/projects/libb64
|
||||
*/
|
||||
#ifndef BASE64_ENCODE_H
|
||||
#define BASE64_ENCODE_H
|
||||
|
||||
#include <iostream>
|
||||
|
||||
namespace base64
|
||||
{
|
||||
extern "C"
|
||||
{
|
||||
#include "cencode.h"
|
||||
}
|
||||
|
||||
struct encoder
|
||||
{
|
||||
base64_encodestate _state;
|
||||
int _buffersize;
|
||||
|
||||
encoder(int buffersize_in = BUFFERSIZE)
|
||||
: _buffersize(buffersize_in)
|
||||
{}
|
||||
|
||||
int encode(char value_in)
|
||||
{
|
||||
return base64_encode_value(value_in);
|
||||
}
|
||||
|
||||
int encode(const char* code_in, const int length_in, char* plaintext_out)
|
||||
{
|
||||
return base64_encode_block(code_in, length_in, plaintext_out, &_state);
|
||||
}
|
||||
|
||||
int encode_end(char* plaintext_out)
|
||||
{
|
||||
return base64_encode_blockend(plaintext_out, &_state);
|
||||
}
|
||||
|
||||
void encode(std::istream& istream_in, std::ostream& ostream_in)
|
||||
{
|
||||
base64_init_encodestate(&_state);
|
||||
//
|
||||
const int N = _buffersize;
|
||||
char* plaintext = new char[N];
|
||||
char* code = new char[2*N];
|
||||
int plainlength;
|
||||
int codelength;
|
||||
|
||||
do
|
||||
{
|
||||
istream_in.read(plaintext, N);
|
||||
plainlength = istream_in.gcount();
|
||||
//
|
||||
codelength = encode(plaintext, plainlength, code);
|
||||
ostream_in.write(code, codelength);
|
||||
}
|
||||
while (istream_in.good() && plainlength > 0);
|
||||
|
||||
codelength = encode_end(code);
|
||||
ostream_in.write(code, codelength);
|
||||
//
|
||||
base64_init_encodestate(&_state);
|
||||
|
||||
delete [] code;
|
||||
delete [] plaintext;
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace base64
|
||||
|
||||
#endif // BASE64_ENCODE_H
|
||||
|
||||
|
|
@ -0,0 +1,88 @@
|
|||
/*
|
||||
cdecoder.c - c source to a base64 decoding algorithm implementation
|
||||
|
||||
This is part of the libb64 project, and has been placed in the public domain.
|
||||
For details, see http://sourceforge.net/projects/libb64
|
||||
*/
|
||||
|
||||
#include <b64/cdecode.h>
|
||||
|
||||
int base64_decode_value(char value_in)
|
||||
{
|
||||
static const char decoding[] = {62,-1,-1,-1,63,52,53,54,55,56,57,58,59,60,61,-1,-1,-1,-2,-1,-1,-1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,-1,-1,-1,-1,-1,-1,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51};
|
||||
static const char decoding_size = sizeof(decoding);
|
||||
value_in -= 43;
|
||||
if (value_in < 0 || value_in >= decoding_size) return -1;
|
||||
return decoding[(int)value_in];
|
||||
}
|
||||
|
||||
void base64_init_decodestate(base64_decodestate* state_in)
|
||||
{
|
||||
state_in->step = step_a;
|
||||
state_in->plainchar = 0;
|
||||
}
|
||||
|
||||
int base64_decode_block(const char* code_in, const int length_in, char* plaintext_out, base64_decodestate* state_in)
|
||||
{
|
||||
const char* codechar = code_in;
|
||||
char* plainchar = plaintext_out;
|
||||
char fragment;
|
||||
|
||||
*plainchar = state_in->plainchar;
|
||||
|
||||
switch (state_in->step)
|
||||
{
|
||||
while (1)
|
||||
{
|
||||
case step_a:
|
||||
do {
|
||||
if (codechar == code_in+length_in)
|
||||
{
|
||||
state_in->step = step_a;
|
||||
state_in->plainchar = *plainchar;
|
||||
return plainchar - plaintext_out;
|
||||
}
|
||||
fragment = (char)base64_decode_value(*codechar++);
|
||||
} while (fragment < 0);
|
||||
*plainchar = (fragment & 0x03f) << 2;
|
||||
case step_b:
|
||||
do {
|
||||
if (codechar == code_in+length_in)
|
||||
{
|
||||
state_in->step = step_b;
|
||||
state_in->plainchar = *plainchar;
|
||||
return plainchar - plaintext_out;
|
||||
}
|
||||
fragment = (char)base64_decode_value(*codechar++);
|
||||
} while (fragment < 0);
|
||||
*plainchar++ |= (fragment & 0x030) >> 4;
|
||||
*plainchar = (fragment & 0x00f) << 4;
|
||||
case step_c:
|
||||
do {
|
||||
if (codechar == code_in+length_in)
|
||||
{
|
||||
state_in->step = step_c;
|
||||
state_in->plainchar = *plainchar;
|
||||
return plainchar - plaintext_out;
|
||||
}
|
||||
fragment = (char)base64_decode_value(*codechar++);
|
||||
} while (fragment < 0);
|
||||
*plainchar++ |= (fragment & 0x03c) >> 2;
|
||||
*plainchar = (fragment & 0x003) << 6;
|
||||
case step_d:
|
||||
do {
|
||||
if (codechar == code_in+length_in)
|
||||
{
|
||||
state_in->step = step_d;
|
||||
state_in->plainchar = *plainchar;
|
||||
return plainchar - plaintext_out;
|
||||
}
|
||||
fragment = (char)base64_decode_value(*codechar++);
|
||||
} while (fragment < 0);
|
||||
*plainchar++ |= (fragment & 0x03f);
|
||||
}
|
||||
}
|
||||
/* control should not reach here */
|
||||
return plainchar - plaintext_out;
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,109 @@
|
|||
/*
|
||||
cencoder.c - c source to a base64 encoding algorithm implementation
|
||||
|
||||
This is part of the libb64 project, and has been placed in the public domain.
|
||||
For details, see http://sourceforge.net/projects/libb64
|
||||
*/
|
||||
|
||||
#include <b64/cencode.h>
|
||||
|
||||
const int CHARS_PER_LINE = 72;
|
||||
|
||||
void base64_init_encodestate(base64_encodestate* state_in)
|
||||
{
|
||||
state_in->step = step_A;
|
||||
state_in->result = 0;
|
||||
state_in->stepcount = 0;
|
||||
}
|
||||
|
||||
char base64_encode_value(char value_in)
|
||||
{
|
||||
static const char* encoding = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
||||
if (value_in > 63) return '=';
|
||||
return encoding[(int)value_in];
|
||||
}
|
||||
|
||||
int base64_encode_block(const char* plaintext_in, int length_in, char* code_out, base64_encodestate* state_in)
|
||||
{
|
||||
const char* plainchar = plaintext_in;
|
||||
const char* const plaintextend = plaintext_in + length_in;
|
||||
char* codechar = code_out;
|
||||
char result;
|
||||
char fragment;
|
||||
|
||||
result = state_in->result;
|
||||
|
||||
switch (state_in->step)
|
||||
{
|
||||
while (1)
|
||||
{
|
||||
case step_A:
|
||||
if (plainchar == plaintextend)
|
||||
{
|
||||
state_in->result = result;
|
||||
state_in->step = step_A;
|
||||
return codechar - code_out;
|
||||
}
|
||||
fragment = *plainchar++;
|
||||
result = (fragment & 0x0fc) >> 2;
|
||||
*codechar++ = base64_encode_value(result);
|
||||
result = (fragment & 0x003) << 4;
|
||||
case step_B:
|
||||
if (plainchar == plaintextend)
|
||||
{
|
||||
state_in->result = result;
|
||||
state_in->step = step_B;
|
||||
return codechar - code_out;
|
||||
}
|
||||
fragment = *plainchar++;
|
||||
result |= (fragment & 0x0f0) >> 4;
|
||||
*codechar++ = base64_encode_value(result);
|
||||
result = (fragment & 0x00f) << 2;
|
||||
case step_C:
|
||||
if (plainchar == plaintextend)
|
||||
{
|
||||
state_in->result = result;
|
||||
state_in->step = step_C;
|
||||
return codechar - code_out;
|
||||
}
|
||||
fragment = *plainchar++;
|
||||
result |= (fragment & 0x0c0) >> 6;
|
||||
*codechar++ = base64_encode_value(result);
|
||||
result = (fragment & 0x03f) >> 0;
|
||||
*codechar++ = base64_encode_value(result);
|
||||
|
||||
++(state_in->stepcount);
|
||||
if (state_in->stepcount == CHARS_PER_LINE/4)
|
||||
{
|
||||
*codechar++ = '\n';
|
||||
state_in->stepcount = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
/* control should not reach here */
|
||||
return codechar - code_out;
|
||||
}
|
||||
|
||||
int base64_encode_blockend(char* code_out, base64_encodestate* state_in)
|
||||
{
|
||||
char* codechar = code_out;
|
||||
|
||||
switch (state_in->step)
|
||||
{
|
||||
case step_B:
|
||||
*codechar++ = base64_encode_value(state_in->result);
|
||||
*codechar++ = '=';
|
||||
*codechar++ = '=';
|
||||
break;
|
||||
case step_C:
|
||||
*codechar++ = base64_encode_value(state_in->result);
|
||||
*codechar++ = '=';
|
||||
break;
|
||||
case step_A:
|
||||
break;
|
||||
}
|
||||
*codechar++ = '\n';
|
||||
|
||||
return codechar - code_out;
|
||||
}
|
||||
|
||||
|
|
@ -29,6 +29,7 @@ solution "demboyz"
|
|||
includedirs
|
||||
{
|
||||
"../external/json_checker/include",
|
||||
"../external/libb64-1.2.1/include",
|
||||
"../external/sourcesdk/include",
|
||||
"../external/rapidjson-1.0.2/include",
|
||||
"../demboyz"
|
||||
|
|
|
|||
Loading…
Reference in New Issue