/*
|
* Bit packing and Base64 utils for EWP
|
*
|
* Copyright (C) 2020, Broadcom.
|
*
|
* Unless you and Broadcom execute a separate written software license
|
* agreement governing use of this software, this software is licensed to you
|
* under the terms of the GNU General Public License version 2 (the "GPL"),
|
* available at http://www.broadcom.com/licenses/GPLv2.php, with the
|
* following added to such license:
|
*
|
* As a special exception, the copyright holders of this software give you
|
* permission to link this software with independent modules, and to copy and
|
* distribute the resulting executable under terms of your choice, provided that
|
* you also meet, for each linked independent module, the terms and conditions of
|
* the license of that module. An independent module is a module which is not
|
* derived from this software. The special exception does not apply to any
|
* modifications of the software.
|
*
|
*
|
* <<Broadcom-WL-IPTag/Open:>>
|
*
|
* $Id$
|
*/
|
|
#include <dhd_bitpack.h>
|
|
#define BIT_PACK_OVERFLOW 0xFFFFFFFFu
|
|
const char* base64_table = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
#define BASE64_MAX_VALUE 63u
|
|
#define BASE64_UNIT_LEN 6u
|
|
#define BASE64_OFFSET0 0u
|
#define BASE64_OFFSET1 6u
|
#define BASE64_OFFSET2 12u
|
|
#define MASK_UPPER_6BIT 0xfc
|
#define MASK_LOWER_6BIT 0x3f
|
|
#define MASK_UPPER_4BIT 0xf0
|
#define MASK_LOWER_4BIT 0x0f
|
|
#define MASK_UPPER_2BIT 0xc0
|
#define MASK_LOWER_2BIT 0x03
|
|
#define SHIFT_2BIT 2u
|
#define SHIFT_4BIT 4u
|
#define SHIFT_6BIT 6u
|
|
#define BASE64_PADDING_MARGIN 4u
|
|
/*
|
* Function: dhd_bit_pack
|
*
|
* Purpose: bit data packing to given buffer
|
*
|
* Input Parameters:
|
* buf buffer to pack bit data
|
* buf_len total buffer length
|
* bit_offset offset in buffer (bitwise)
|
* data data to pack (max 32 bit)
|
* bit_length bit length to pack
|
*
|
* Output:
|
* Updated bit offset in buf
|
*/
|
int32
|
dhd_bit_pack(char *buf, int buf_len, int bit_offset, uint32 data, int32 bit_length)
|
{
|
|
int32 byte_shift = (bit_offset / 8);
|
int32 local_bit_offset = bit_offset % 8;
|
int32 available_bit = 8 - local_bit_offset;
|
int32 remain_bit = bit_length;
|
uint32 cropped_data;
|
int32 idx;
|
int32 total_byte = BYTE_SIZE(local_bit_offset + bit_length);
|
|
if (bit_length > 32) {
|
/* exceeded max bit length, do nothing */
|
return bit_offset;
|
}
|
if (BYTE_SIZE(bit_offset + bit_length) > buf_len) {
|
/* can't pack more bits if expected offset is
|
* exceeded then buffer size
|
*/
|
return bit_offset;
|
}
|
if (bit_length < 32 && data >= 1<<bit_length) {
|
cropped_data = BIT_PACK_OVERFLOW << (32 - bit_length);
|
cropped_data = cropped_data >> (32 - bit_length);
|
} else {
|
cropped_data = data << (32 - bit_length);
|
cropped_data = cropped_data >> (32 - bit_length);
|
}
|
|
buf += byte_shift;
|
|
remain_bit = bit_length;
|
if (total_byte > 10) {
|
return bit_offset;
|
}
|
for (idx = 0; idx < total_byte; idx++) {
|
char temp_byte = 0x00;
|
if (idx == 0) {
|
local_bit_offset = bit_offset % 8;
|
} else {
|
local_bit_offset = 0;
|
}
|
|
available_bit = 8 - local_bit_offset;
|
remain_bit -= available_bit;
|
if (remain_bit >= 0) {
|
temp_byte = cropped_data >> remain_bit;
|
} else {
|
temp_byte = cropped_data << (-1*remain_bit);
|
}
|
*buf = *buf | temp_byte;
|
buf ++;
|
}
|
bit_offset += bit_length;
|
|
return bit_offset;
|
}
|
|
static char
|
dhd_base64_get_code(char input)
|
{
|
if (input > BASE64_MAX_VALUE) {
|
return '=';
|
}
|
return base64_table[(int)input];
|
}
|
|
/*
|
* Function: dhd_base64_encode
|
*
|
* Purpose: base64 encoding module which converts from 8 bits to
|
* 6 bit based, base64 format using base64_table
|
* eg: input: hex-123456
|
* bin-0001|0010|0011|0100|0101|0110
|
* encode every 6 bit :
|
* bin-000100|100011|010001|010110
|
* base64 code :
|
* base64-EjRW
|
*
|
* Input Parameters:
|
* in_buf input buffer
|
* in_buf_len length of input buffer
|
* out_buf output buffer
|
* out_buf_len length_ of output buffer
|
*
|
* Output:
|
* length of encoded base64 string
|
*/
|
int32
|
dhd_base64_encode(char* in_buf, int32 in_buf_len, char* out_buf, int32 out_buf_len)
|
{
|
char* input_pos;
|
char* input_end;
|
char* base64_out;
|
char* base64_out_pos;
|
char* base64_output_end;
|
char current_byte = 0;
|
char masked_byte = 0;
|
int32 estimated_out_len = 0;
|
int32 offset = 0;
|
|
if (!in_buf || !out_buf || in_buf_len == 0 || out_buf_len == 0) {
|
/* wrong input parameters */
|
return 0;
|
}
|
|
input_pos = in_buf;
|
input_end = in_buf + in_buf_len;
|
base64_out = out_buf;
|
base64_out_pos = base64_out;
|
base64_output_end = out_buf + out_buf_len - BASE64_PADDING_MARGIN;
|
estimated_out_len = in_buf_len / 3 * 4;
|
|
if (estimated_out_len > out_buf_len) {
|
/* estimated output length is
|
* larger than output buffer size
|
*/
|
return 0;
|
}
|
|
while (input_pos != input_end) {
|
if (base64_out_pos > base64_output_end) {
|
/* outbuf buffer size exceeded, finish encoding */
|
break;
|
}
|
if (offset == BASE64_OFFSET0) {
|
current_byte = *input_pos++;
|
masked_byte = (current_byte & MASK_UPPER_6BIT) >> SHIFT_2BIT;
|
*base64_out_pos++ = dhd_base64_get_code(masked_byte);
|
masked_byte = (current_byte & MASK_LOWER_2BIT) << SHIFT_4BIT;
|
offset += BASE64_UNIT_LEN;
|
} else if (offset == BASE64_OFFSET1) {
|
current_byte = *input_pos++;
|
masked_byte |= (current_byte & MASK_UPPER_4BIT) >> SHIFT_4BIT;
|
*base64_out_pos++ = dhd_base64_get_code(masked_byte);
|
masked_byte = (current_byte & MASK_LOWER_4BIT) << SHIFT_2BIT;
|
offset += BASE64_UNIT_LEN;
|
} else if (offset == BASE64_OFFSET2) {
|
current_byte = *input_pos++;
|
masked_byte |= (current_byte & MASK_UPPER_2BIT) >> SHIFT_6BIT;
|
*base64_out_pos++ = dhd_base64_get_code(masked_byte);
|
offset += BASE64_UNIT_LEN;
|
masked_byte = (current_byte & MASK_LOWER_6BIT);
|
*base64_out_pos++ = dhd_base64_get_code(masked_byte);
|
offset = BASE64_OFFSET0;
|
}
|
}
|
if (offset == BASE64_OFFSET1) {
|
*base64_out_pos++ = dhd_base64_get_code(masked_byte);
|
*base64_out_pos++ = '=';
|
*base64_out_pos++ = '=';
|
} else if (offset == BASE64_OFFSET2) {
|
*base64_out_pos++ = dhd_base64_get_code(masked_byte);
|
*base64_out_pos++ = '=';
|
}
|
|
return base64_out_pos - base64_out;
|
}
|
