kingkevin
/
espressif_idf-extra-components
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Format code

This commit is contained in:
Tomas Rezucha 2022-02-17 14:56:45 +01:00
parent 5362db237b
commit e651ec16c5
8 changed files with 1555 additions and 1537 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
esp_encrypted_img/include/esp_encrypted_img.h
View File

@ -9,6 +9,7 @@
#if 0 //High level layout for state machine #if 0 //High level layout for state machine
// *INDENT-OFF*
@startuml @startuml
[*] --> READ_MAGIC [*] --> READ_MAGIC
READ_MAGIC --> READ_MAGIC : READ LEN < 4 READ_MAGIC --> READ_MAGIC : READ LEN < 4
@ -34,7 +35,7 @@ PROCESS_BINARY --> ESP_OK : READ LEN = BIN_SIZE
ESP_OK --> [*] ESP_OK --> [*]
ESP_FAIL --> [*] ESP_FAIL --> [*]
@enduml @enduml
// *INDENT-OFF*
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus

3
esp_encrypted_img/src/esp_encrypted_img.c
View File

@ -378,8 +378,7 @@ esp_err_t esp_encrypted_img_decrypt_data(esp_decrypt_handle_t *ctx, pre_enc_decr
return ESP_ERR_NOT_FINISHED; return ESP_ERR_NOT_FINISHED;
} }
/* falls through */ /* falls through */
case ESP_PRE_ENC_IMG_READ_EXTRA_HEADER: case ESP_PRE_ENC_IMG_READ_EXTRA_HEADER: {
{
int temp = curr_index; int temp = curr_index;
curr_index += MIN(args->data_in_len - curr_index, RESERVED_HEADER - handle->binary_file_read); curr_index += MIN(args->data_in_len - curr_index, RESERVED_HEADER - handle->binary_file_read);
handle->binary_file_read += MIN(args->data_in_len - temp, RESERVED_HEADER - handle->binary_file_read); handle->binary_file_read += MIN(args->data_in_len - temp, RESERVED_HEADER - handle->binary_file_read);

12
expat/test/test_expat.c
View File

@ -36,8 +36,8 @@ static void XMLCALL start_element(void *userData, const XML_Char *name, const XM
insert_space(user_data); insert_space(user_data);
const int ret = snprintf(user_data->output + user_data->output_off, const int ret = snprintf(user_data->output + user_data->output_off,
sizeof(user_data->output) - user_data->output_off, sizeof(user_data->output) - user_data->output_off,
"<%s>", name); "<%s>", name);
TEST_ASSERT_EQUAL(strlen(name) + 2, ret); // 2 are the tag characters: "<>" TEST_ASSERT_EQUAL(strlen(name) + 2, ret); // 2 are the tag characters: "<>"
user_data->output_off += ret; user_data->output_off += ret;
++user_data->depth; ++user_data->depth;
@ -51,7 +51,7 @@ static void XMLCALL end_element(void *userData, const XML_Char *name)
insert_space(user_data); insert_space(user_data);
int ret = snprintf(user_data->output + user_data->output_off, sizeof(user_data->output) - user_data->output_off, int ret = snprintf(user_data->output + user_data->output_off, sizeof(user_data->output) - user_data->output_off,
"</%s>", name); "</%s>", name);
TEST_ASSERT_EQUAL(strlen(name) + 3, ret); // 3 are the tag characters: "</>" TEST_ASSERT_EQUAL(strlen(name) + 3, ret); // 3 are the tag characters: "</>"
user_data->output_off += ret; user_data->output_off += ret;
} }
@ -63,11 +63,11 @@ static void data_handler(void *userData, const XML_Char *s, int len)
insert_space(user_data); insert_space(user_data);
// s is not zero-terminated // s is not zero-terminated
char tmp_str[len+1]; char tmp_str[len + 1];
strlcpy(tmp_str, s, len+1); strlcpy(tmp_str, s, len + 1);
int ret = snprintf(user_data->output + user_data->output_off, sizeof(user_data->output) - user_data->output_off, int ret = snprintf(user_data->output + user_data->output_off, sizeof(user_data->output) - user_data->output_off,
"%s", tmp_str); "%s", tmp_str);
TEST_ASSERT_EQUAL(strlen(tmp_str), ret); TEST_ASSERT_EQUAL(strlen(tmp_str), ret);
user_data->output_off += ret; user_data->output_off += ret;
} }

54
jsmn/include/jsmn.h
View File

@ -39,41 +39,41 @@ extern "C" {
/** /**
* JSON type identifier. Basic types are: * JSON type identifier. Basic types are:
* o Object * o Object
* o Array * o Array
* o String * o String
* o Other primitive: number, boolean (true/false) or null * o Other primitive: number, boolean (true/false) or null
*/ */
typedef enum { typedef enum {
JSMN_UNDEFINED = 0, JSMN_UNDEFINED = 0,
JSMN_OBJECT = 1, JSMN_OBJECT = 1,
JSMN_ARRAY = 2, JSMN_ARRAY = 2,
JSMN_STRING = 3, JSMN_STRING = 3,
JSMN_PRIMITIVE = 4 JSMN_PRIMITIVE = 4
} jsmntype_t; } jsmntype_t;
enum jsmnerr { enum jsmnerr {
/* Not enough tokens were provided */ /* Not enough tokens were provided */
JSMN_ERROR_NOMEM = -1, JSMN_ERROR_NOMEM = -1,
/* Invalid character inside JSON string */ /* Invalid character inside JSON string */
JSMN_ERROR_INVAL = -2, JSMN_ERROR_INVAL = -2,
/* The string is not a full JSON packet, more bytes expected */ /* The string is not a full JSON packet, more bytes expected */
JSMN_ERROR_PART = -3 JSMN_ERROR_PART = -3
}; };
/** /**
* JSON token description. * JSON token description.
* @param type type (object, array, string etc.) * @param type type (object, array, string etc.)
* @param start start position in JSON data string * @param start start position in JSON data string
* @param end end position in JSON data string * @param end end position in JSON data string
*/ */
typedef struct { typedef struct {
jsmntype_t type; jsmntype_t type;
int start; int start;
int end; int end;
int size; int size;
#ifdef JSMN_PARENT_LINKS #ifdef JSMN_PARENT_LINKS
int parent; int parent;
#endif #endif
} jsmntok_t; } jsmntok_t;
@ -82,9 +82,9 @@ typedef struct {
* the string being parsed now and current position in that string * the string being parsed now and current position in that string
*/ */
typedef struct { typedef struct {
unsigned int pos; /* offset in the JSON string */ unsigned int pos; /* offset in the JSON string */
unsigned int toknext; /* next token to allocate */ unsigned int toknext; /* next token to allocate */
int toksuper; /* superior token node, e.g parent object or array */ int toksuper; /* superior token node, e.g parent object or array */
} jsmn_parser; } jsmn_parser;
/** /**
@ -97,7 +97,7 @@ void jsmn_init(jsmn_parser *parser);
* a single JSON object. * a single JSON object.
*/ */
int jsmn_parse(jsmn_parser *parser, const char *js, size_t len, int jsmn_parse(jsmn_parser *parser, const char *js, size_t len,
jsmntok_t *tokens, unsigned int num_tokens); jsmntok_t *tokens, unsigned int num_tokens);
#ifdef __cplusplus #ifdef __cplusplus
} }

488
jsmn/src/jsmn.c
View File

@ -34,307 +34,323 @@
* Allocates a fresh unused token from the token pull. * Allocates a fresh unused token from the token pull.
*/ */
static jsmntok_t *jsmn_alloc_token(jsmn_parser *parser, static jsmntok_t *jsmn_alloc_token(jsmn_parser *parser,
jsmntok_t *tokens, size_t num_tokens) { jsmntok_t *tokens, size_t num_tokens)
jsmntok_t *tok; {
if (parser->toknext >= num_tokens) { jsmntok_t *tok;
return NULL; if (parser->toknext >= num_tokens) {
} return NULL;
tok = &tokens[parser->toknext++]; }
tok->start = tok->end = -1; tok = &tokens[parser->toknext++];
tok->size = 0; tok->start = tok->end = -1;
tok->size = 0;
#ifdef JSMN_PARENT_LINKS #ifdef JSMN_PARENT_LINKS
tok->parent = -1; tok->parent = -1;
#endif #endif
return tok; return tok;
} }
/** /**
* Fills token type and boundaries. * Fills token type and boundaries.
*/ */
static void jsmn_fill_token(jsmntok_t *token, jsmntype_t type, static void jsmn_fill_token(jsmntok_t *token, jsmntype_t type,
int start, int end) { int start, int end)
token->type = type; {
token->start = start; token->type = type;
token->end = end; token->start = start;
token->size = 0; token->end = end;
token->size = 0;
} }
/** /**
* Fills next available token with JSON primitive. * Fills next available token with JSON primitive.
*/ */
static int jsmn_parse_primitive(jsmn_parser *parser, const char *js, static int jsmn_parse_primitive(jsmn_parser *parser, const char *js,
size_t len, jsmntok_t *tokens, size_t num_tokens) { size_t len, jsmntok_t *tokens, size_t num_tokens)
jsmntok_t *token; {
int start; jsmntok_t *token;
int start;
start = parser->pos; start = parser->pos;
for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) { for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) {
switch (js[parser->pos]) { switch (js[parser->pos]) {
#ifndef JSMN_STRICT #ifndef JSMN_STRICT
/* In strict mode primitive must be followed by "," or "}" or "]" */ /* In strict mode primitive must be followed by "," or "}" or "]" */
case ':': case ':':
#endif #endif
case '\t' : case '\r' : case '\n' : case ' ' : case '\t' : case '\r' : case '\n' : case ' ' :
case ',' : case ']' : case '}' : case ',' : case ']' : case '}' :
goto found; goto found;
} }
if (js[parser->pos] < 32 || js[parser->pos] >= 127) { if (js[parser->pos] < 32 || js[parser->pos] >= 127) {
parser->pos = start; parser->pos = start;
return JSMN_ERROR_INVAL; return JSMN_ERROR_INVAL;
} }
} }
#ifdef JSMN_STRICT #ifdef JSMN_STRICT
/* In strict mode primitive must be followed by a comma/object/array */ /* In strict mode primitive must be followed by a comma/object/array */
parser->pos = start; parser->pos = start;
return JSMN_ERROR_PART; return JSMN_ERROR_PART;
#endif #endif
found: found:
if (tokens == NULL) { if (tokens == NULL) {
parser->pos--; parser->pos--;
return 0; return 0;
} }
token = jsmn_alloc_token(parser, tokens, num_tokens); token = jsmn_alloc_token(parser, tokens, num_tokens);
if (token == NULL) { if (token == NULL) {
parser->pos = start; parser->pos = start;
return JSMN_ERROR_NOMEM; return JSMN_ERROR_NOMEM;
} }
jsmn_fill_token(token, JSMN_PRIMITIVE, start, parser->pos); jsmn_fill_token(token, JSMN_PRIMITIVE, start, parser->pos);
#ifdef JSMN_PARENT_LINKS #ifdef JSMN_PARENT_LINKS
token->parent = parser->toksuper; token->parent = parser->toksuper;
#endif #endif
parser->pos--; parser->pos--;
return 0; return 0;
} }
/** /**
* Fills next token with JSON string. * Fills next token with JSON string.
*/ */
static int jsmn_parse_string(jsmn_parser *parser, const char *js, static int jsmn_parse_string(jsmn_parser *parser, const char *js,
size_t len, jsmntok_t *tokens, size_t num_tokens) { size_t len, jsmntok_t *tokens, size_t num_tokens)
jsmntok_t *token; {
jsmntok_t *token;
int start = parser->pos; int start = parser->pos;
parser->pos++; parser->pos++;
/* Skip starting quote */ /* Skip starting quote */
for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) { for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) {
char c = js[parser->pos]; char c = js[parser->pos];
/* Quote: end of string */ /* Quote: end of string */
if (c == '\"') { if (c == '\"') {
if (tokens == NULL) { if (tokens == NULL) {
return 0; return 0;
} }
token = jsmn_alloc_token(parser, tokens, num_tokens); token = jsmn_alloc_token(parser, tokens, num_tokens);
if (token == NULL) { if (token == NULL) {
parser->pos = start; parser->pos = start;
return JSMN_ERROR_NOMEM; return JSMN_ERROR_NOMEM;
} }
jsmn_fill_token(token, JSMN_STRING, start+1, parser->pos); jsmn_fill_token(token, JSMN_STRING, start + 1, parser->pos);
#ifdef JSMN_PARENT_LINKS #ifdef JSMN_PARENT_LINKS
token->parent = parser->toksuper; token->parent = parser->toksuper;
#endif #endif
return 0; return 0;
} }
/* Backslash: Quoted symbol expected */ /* Backslash: Quoted symbol expected */
if (c == '\\' && parser->pos + 1 < len) { if (c == '\\' && parser->pos + 1 < len) {
int i; int i;
parser->pos++; parser->pos++;
switch (js[parser->pos]) { switch (js[parser->pos]) {
/* Allowed escaped symbols */ /* Allowed escaped symbols */
case '\"': case '/' : case '\\' : case 'b' : case '\"': case '/' : case '\\' : case 'b' :
case 'f' : case 'r' : case 'n' : case 't' : case 'f' : case 'r' : case 'n' : case 't' :
break; break;
/* Allows escaped symbol \uXXXX */ /* Allows escaped symbol \uXXXX */
case 'u': case 'u':
parser->pos++; parser->pos++;
for(i = 0; i < 4 && parser->pos < len && js[parser->pos] != '\0'; i++) { for (i = 0; i < 4 && parser->pos < len && js[parser->pos] != '\0'; i++) {
/* If it isn't a hex character we have an error */ /* If it isn't a hex character we have an error */
if(!((js[parser->pos] >= 48 && js[parser->pos] <= 57) || /* 0-9 */ if (!((js[parser->pos] >= 48 && js[parser->pos] <= 57) || /* 0-9 */
(js[parser->pos] >= 65 && js[parser->pos] <= 70) || /* A-F */ (js[parser->pos] >= 65 && js[parser->pos] <= 70) || /* A-F */
(js[parser->pos] >= 97 && js[parser->pos] <= 102))) { /* a-f */ (js[parser->pos] >= 97 && js[parser->pos] <= 102))) { /* a-f */
parser->pos = start; parser->pos = start;
return JSMN_ERROR_INVAL; return JSMN_ERROR_INVAL;
} }
parser->pos++; parser->pos++;
} }
parser->pos--; parser->pos--;
break; break;
/* Unexpected symbol */ /* Unexpected symbol */
default: default:
parser->pos = start; parser->pos = start;
return JSMN_ERROR_INVAL; return JSMN_ERROR_INVAL;
} }
} }
} }
parser->pos = start; parser->pos = start;
return JSMN_ERROR_PART; return JSMN_ERROR_PART;
} }
/** /**
* Parse JSON string and fill tokens. * Parse JSON string and fill tokens.
*/ */
int jsmn_parse(jsmn_parser *parser, const char *js, size_t len, int jsmn_parse(jsmn_parser *parser, const char *js, size_t len,
jsmntok_t *tokens, unsigned int num_tokens) { jsmntok_t *tokens, unsigned int num_tokens)
int r; {
int i; int r;
jsmntok_t *token; int i;
int count = parser->toknext; jsmntok_t *token;
int count = parser->toknext;
for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) { for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) {
char c; char c;
jsmntype_t type; jsmntype_t type;
c = js[parser->pos]; c = js[parser->pos];
switch (c) { switch (c) {
case '{': case '[': case '{': case '[':
count++; count++;
if (tokens == NULL) { if (tokens == NULL) {
break; break;
} }
token = jsmn_alloc_token(parser, tokens, num_tokens); token = jsmn_alloc_token(parser, tokens, num_tokens);
if (token == NULL) if (token == NULL) {
return JSMN_ERROR_NOMEM; return JSMN_ERROR_NOMEM;
if (parser->toksuper != -1) { }
tokens[parser->toksuper].size++; if (parser->toksuper != -1) {
tokens[parser->toksuper].size++;
#ifdef JSMN_PARENT_LINKS #ifdef JSMN_PARENT_LINKS
token->parent = parser->toksuper; token->parent = parser->toksuper;
#endif #endif
} }
token->type = (c == '{' ? JSMN_OBJECT : JSMN_ARRAY); token->type = (c == '{' ? JSMN_OBJECT : JSMN_ARRAY);
token->start = parser->pos; token->start = parser->pos;
parser->toksuper = parser->toknext - 1; parser->toksuper = parser->toknext - 1;
break; break;
case '}': case ']': case '}': case ']':
if (tokens == NULL) if (tokens == NULL) {
break; break;
type = (c == '}' ? JSMN_OBJECT : JSMN_ARRAY); }
type = (c == '}' ? JSMN_OBJECT : JSMN_ARRAY);
#ifdef JSMN_PARENT_LINKS #ifdef JSMN_PARENT_LINKS
if (parser->toknext < 1) { if (parser->toknext < 1) {
return JSMN_ERROR_INVAL; return JSMN_ERROR_INVAL;
} }
token = &tokens[parser->toknext - 1]; token = &tokens[parser->toknext - 1];
for (;;) { for (;;) {
if (token->start != -1 && token->end == -1) { if (token->start != -1 && token->end == -1) {
if (token->type != type) { if (token->type != type) {
return JSMN_ERROR_INVAL; return JSMN_ERROR_INVAL;
} }
token->end = parser->pos + 1; token->end = parser->pos + 1;
parser->toksuper = token->parent; parser->toksuper = token->parent;
break; break;
} }
if (token->parent == -1) { if (token->parent == -1) {
break; break;
} }
token = &tokens[token->parent]; token = &tokens[token->parent];
} }
#else #else
for (i = parser->toknext - 1; i >= 0; i--) { for (i = parser->toknext - 1; i >= 0; i--) {
token = &tokens[i]; token = &tokens[i];
if (token->start != -1 && token->end == -1) { if (token->start != -1 && token->end == -1) {
if (token->type != type) { if (token->type != type) {
return JSMN_ERROR_INVAL; return JSMN_ERROR_INVAL;
} }
parser->toksuper = -1; parser->toksuper = -1;
token->end = parser->pos + 1; token->end = parser->pos + 1;
break; break;
} }
} }
/* Error if unmatched closing bracket */ /* Error if unmatched closing bracket */
if (i == -1) return JSMN_ERROR_INVAL; if (i == -1) {
for (; i >= 0; i--) { return JSMN_ERROR_INVAL;
token = &tokens[i]; }
if (token->start != -1 && token->end == -1) { for (; i >= 0; i--) {
parser->toksuper = i; token = &tokens[i];
break; if (token->start != -1 && token->end == -1) {
} parser->toksuper = i;
} break;
}
}
#endif #endif
break; break;
case '\"': case '\"':
r = jsmn_parse_string(parser, js, len, tokens, num_tokens); r = jsmn_parse_string(parser, js, len, tokens, num_tokens);
if (r < 0) return r; if (r < 0) {
count++; return r;
if (parser->toksuper != -1 && tokens != NULL) }
tokens[parser->toksuper].size++; count++;
break; if (parser->toksuper != -1 && tokens != NULL) {
case '\t' : case '\r' : case '\n' : case ' ': tokens[parser->toksuper].size++;
break; }
case ':': break;
parser->toksuper = parser->toknext - 1; case '\t' : case '\r' : case '\n' : case ' ':
break; break;
case ',': case ':':
if (tokens != NULL && parser->toksuper != -1 && parser->toksuper = parser->toknext - 1;
tokens[parser->toksuper].type != JSMN_ARRAY && break;
tokens[parser->toksuper].type != JSMN_OBJECT) { case ',':
if (tokens != NULL && parser->toksuper != -1 &&
tokens[parser->toksuper].type != JSMN_ARRAY &&
tokens[parser->toksuper].type != JSMN_OBJECT) {
#ifdef JSMN_PARENT_LINKS #ifdef JSMN_PARENT_LINKS
parser->toksuper = tokens[parser->toksuper].parent; parser->toksuper = tokens[parser->toksuper].parent;
#else #else
for (i = parser->toknext - 1; i >= 0; i--) { for (i = parser->toknext - 1; i >= 0; i--) {
if (tokens[i].type == JSMN_ARRAY || tokens[i].type == JSMN_OBJECT) { if (tokens[i].type == JSMN_ARRAY || tokens[i].type == JSMN_OBJECT) {
if (tokens[i].start != -1 && tokens[i].end == -1) { if (tokens[i].start != -1 && tokens[i].end == -1) {
parser->toksuper = i; parser->toksuper = i;
break; break;
} }
} }
} }
#endif #endif
} }
break; break;
#ifdef JSMN_STRICT #ifdef JSMN_STRICT
/* In strict mode primitives are: numbers and booleans */ /* In strict mode primitives are: numbers and booleans */
case '-': case '0': case '1' : case '2': case '3' : case '4': case '-': case '0': case '1' : case '2': case '3' : case '4':
case '5': case '6': case '7' : case '8': case '9': case '5': case '6': case '7' : case '8': case '9':
case 't': case 'f': case 'n' : case 't': case 'f': case 'n' :
/* And they must not be keys of the object */ /* And they must not be keys of the object */
if (tokens != NULL && parser->toksuper != -1) { if (tokens != NULL && parser->toksuper != -1) {
jsmntok_t *t = &tokens[parser->toksuper]; jsmntok_t *t = &tokens[parser->toksuper];
if (t->type == JSMN_OBJECT || if (t->type == JSMN_OBJECT ||
(t->type == JSMN_STRING && t->size != 0)) { (t->type == JSMN_STRING && t->size != 0)) {
return JSMN_ERROR_INVAL; return JSMN_ERROR_INVAL;
} }
} }
#else #else
/* In non-strict mode every unquoted value is a primitive */ /* In non-strict mode every unquoted value is a primitive */
default: default:
#endif #endif
r = jsmn_parse_primitive(parser, js, len, tokens, num_tokens); r = jsmn_parse_primitive(parser, js, len, tokens, num_tokens);
if (r < 0) return r; if (r < 0) {
count++; return r;
if (parser->toksuper != -1 && tokens != NULL) }
tokens[parser->toksuper].size++; count++;
break; if (parser->toksuper != -1 && tokens != NULL) {
tokens[parser->toksuper].size++;
}
break;
#ifdef JSMN_STRICT #ifdef JSMN_STRICT
/* Unexpected char in strict mode */ /* Unexpected char in strict mode */
default: default:
return JSMN_ERROR_INVAL; return JSMN_ERROR_INVAL;
#endif #endif
} }
} }
if (tokens != NULL) { if (tokens != NULL) {
for (i = parser->toknext - 1; i >= 0; i--) { for (i = parser->toknext - 1; i >= 0; i--) {
/* Unmatched opened object or array */ /* Unmatched opened object or array */
if (tokens[i].start != -1 && tokens[i].end == -1) { if (tokens[i].start != -1 && tokens[i].end == -1) {
return JSMN_ERROR_PART; return JSMN_ERROR_PART;
} }
} }
} }
return count; return count;
} }
/** /**
* Creates a new parser based over a given buffer with an array of tokens * Creates a new parser based over a given buffer with an array of tokens
* available. * available.
*/ */
void jsmn_init(jsmn_parser *parser) { void jsmn_init(jsmn_parser *parser)
parser->pos = 0; {
parser->toknext = 0; parser->pos = 0;
parser->toksuper = -1; parser->toknext = 0;
parser->toksuper = -1;
} }

10
libsodium/test/test_sodium.c
View File

@ -71,7 +71,8 @@ TEST_CASE("sha256 sanity check", "[libsodium]")
const uint8_t expected[] = { 0xba, 0x78, 0x16, 0xbf, 0x8f, 0x01, 0xcf, 0xea, 0x41, const uint8_t expected[] = { 0xba, 0x78, 0x16, 0xbf, 0x8f, 0x01, 0xcf, 0xea, 0x41,
0x41, 0x40, 0xde, 0x5d, 0xae, 0x22, 0x23, 0xb0, 0x03, 0x41, 0x40, 0xde, 0x5d, 0xae, 0x22, 0x23, 0xb0, 0x03,
0x61, 0xa3, 0x96, 0x17, 0x7a, 0x9c, 0xb4, 0x10, 0xff, 0x61, 0xa3, 0x96, 0x17, 0x7a, 0x9c, 0xb4, 0x10, 0xff,
0x61, 0xf2, 0x00, 0x15, 0xad, }; 0x61, 0xf2, 0x00, 0x15, 0xad,
};
uint8_t calculated[32]; uint8_t calculated[32];
crypto_hash_sha256_state state; crypto_hash_sha256_state state;
@ -87,7 +88,7 @@ TEST_CASE("sha256 sanity check", "[libsodium]")
// Multi-line version // Multi-line version
crypto_hash_sha256_init(&state); crypto_hash_sha256_init(&state);
crypto_hash_sha256_update(&state, in, inlen - 1); // split into two updates crypto_hash_sha256_update(&state, in, inlen - 1); // split into two updates
crypto_hash_sha256_update(&state, in + (inlen -1), 1); crypto_hash_sha256_update(&state, in + (inlen - 1), 1);
crypto_hash_sha256_final(&state, calculated); crypto_hash_sha256_final(&state, calculated);
TEST_ASSERT_EQUAL_MEMORY(expected, calculated, crypto_hash_sha256_bytes()); TEST_ASSERT_EQUAL_MEMORY(expected, calculated, crypto_hash_sha256_bytes());
} }
@ -101,7 +102,8 @@ TEST_CASE("sha512 sanity check", "[libsodium]")
0x27, 0x4f, 0xc1, 0xa8, 0x36, 0xba, 0x3c, 0x23, 0xa3, 0x27, 0x4f, 0xc1, 0xa8, 0x36, 0xba, 0x3c, 0x23, 0xa3,
0xfe, 0xeb, 0xbd, 0x45, 0x4d, 0x44, 0x23, 0x64, 0x3c, 0xfe, 0xeb, 0xbd, 0x45, 0x4d, 0x44, 0x23, 0x64, 0x3c,
0xe8, 0x0e, 0x2a, 0x9a, 0xc9, 0x4f, 0xa5, 0x4c, 0xa4, 0xe8, 0x0e, 0x2a, 0x9a, 0xc9, 0x4f, 0xa5, 0x4c, 0xa4,
0x9f }; 0x9f
};
uint8_t calculated[64]; uint8_t calculated[64];
crypto_hash_sha512_state state; crypto_hash_sha512_state state;
@ -118,7 +120,7 @@ TEST_CASE("sha512 sanity check", "[libsodium]")
// Multi-line version // Multi-line version
crypto_hash_sha512_init(&state); crypto_hash_sha512_init(&state);
crypto_hash_sha512_update(&state, in, inlen - 1); // split into two updates crypto_hash_sha512_update(&state, in, inlen - 1); // split into two updates
crypto_hash_sha512_update(&state, in + (inlen -1), 1); crypto_hash_sha512_update(&state, in + (inlen - 1), 1);
crypto_hash_sha512_final(&state, calculated); crypto_hash_sha512_final(&state, calculated);
TEST_ASSERT_EQUAL_MEMORY(expected, calculated, crypto_hash_sha512_bytes()); TEST_ASSERT_EQUAL_MEMORY(expected, calculated, crypto_hash_sha512_bytes());
} }

2
nghttp/port/private_include/config.h
View File

@ -10,7 +10,7 @@
#include "string.h" #include "string.h"
#if (!defined(nghttp_unlikely)) #if (!defined(nghttp_unlikely))
#define nghttp_unlikely(Expression) !!(Expression) #define nghttp_unlikely(Expression) !!(Expression)
#endif #endif
#define nghttp_ASSERT(Expression) do{if (!(Expression)) printf("%d\n", __LINE__);}while(0) #define nghttp_ASSERT(Expression) do{if (!(Expression)) printf("%d\n", __LINE__);}while(0)

4
sh2lib/sh2lib.c
View File

@ -182,8 +182,8 @@ static int callback_on_data_chunk_recv(nghttp2_session *session, uint8_t flags,
data_recv_cb = nghttp2_session_get_stream_user_data(session, stream_id); data_recv_cb = nghttp2_session_get_stream_user_data(session, stream_id);
if (data_recv_cb) { if (data_recv_cb) {
ESP_LOGD(TAG, "[data-chunk] C <---------------------------- S (DATA chunk)" ESP_LOGD(TAG, "[data-chunk] C <---------------------------- S (DATA chunk)"
"%lu bytes", "%lu bytes",
(unsigned long int)len); (unsigned long int)len);
struct sh2lib_handle *h2 = user_data; struct sh2lib_handle *h2 = user_data;
(*data_recv_cb)(h2, (char *)data, len, 0); (*data_recv_cb)(h2, (char *)data, len, 0);
/* TODO: What to do with the return value: look for pause/abort */ /* TODO: What to do with the return value: look for pause/abort */