mirror of https://github.com/sysown/proxysql
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
426 lines
13 KiB
426 lines
13 KiB
/**
|
|
* @file protocol_unit-t.cpp
|
|
* @brief Unit tests for protocol encoding/decoding and query digest functions.
|
|
*
|
|
* Tests standalone protocol utility functions in isolation:
|
|
* - MySQL length-encoded integer encoding and decoding
|
|
* - mysql_hdr packet header structure
|
|
* - Query digest functions (MySQL and PostgreSQL)
|
|
* - String utility functions (escaping, wildcard matching)
|
|
* - Byte copy helpers (CPY3, CPY8)
|
|
*
|
|
* These functions are pure computation with no global state
|
|
* dependencies, making them ideal for unit testing.
|
|
*
|
|
* @see Phase 2.5 of the Unit Testing Framework (GitHub issue #5477)
|
|
*/
|
|
|
|
#include "tap.h"
|
|
#include "test_globals.h"
|
|
#include "test_init.h"
|
|
|
|
#include "proxysql.h"
|
|
#include "MySQL_Protocol.h"
|
|
#include "MySQL_encode.h"
|
|
#include "c_tokenizer.h"
|
|
#include "gen_utils.h"
|
|
|
|
#include <cstring>
|
|
#include <climits>
|
|
|
|
// ============================================================================
|
|
// 1. MySQL length-encoded integer decoding
|
|
// ============================================================================
|
|
|
|
/**
|
|
* @brief Test mysql_decode_length() for 1-byte values (0-250).
|
|
*/
|
|
static void test_decode_length_1byte() {
|
|
unsigned char buf[1];
|
|
uint32_t len = 0;
|
|
|
|
buf[0] = 0;
|
|
uint8_t bytes = mysql_decode_length(buf, &len);
|
|
ok(len == 0 && bytes == 1,
|
|
"decode_length: 0 → 1 byte");
|
|
|
|
buf[0] = 1;
|
|
bytes = mysql_decode_length(buf, &len);
|
|
ok(len == 1 && bytes == 1,
|
|
"decode_length: 1 → 1 byte");
|
|
|
|
buf[0] = 250;
|
|
bytes = mysql_decode_length(buf, &len);
|
|
ok(len == 250 && bytes == 1,
|
|
"decode_length: 250 → 1 byte (max 1-byte value)");
|
|
}
|
|
|
|
/**
|
|
* @brief Test mysql_decode_length() for 2-byte values (0xFC prefix).
|
|
*/
|
|
static void test_decode_length_2byte() {
|
|
unsigned char buf[3];
|
|
uint32_t len = 0;
|
|
|
|
// 0xFC prefix = 2-byte length follows
|
|
buf[0] = 0xFC;
|
|
buf[1] = 0x01;
|
|
buf[2] = 0x00;
|
|
uint8_t bytes = mysql_decode_length(buf, &len);
|
|
ok(len == 1 && bytes == 3,
|
|
"decode_length: 0xFC 0x01 0x00 → 1 (3 bytes total)");
|
|
|
|
buf[0] = 0xFC;
|
|
buf[1] = 0xFF;
|
|
buf[2] = 0xFF;
|
|
bytes = mysql_decode_length(buf, &len);
|
|
ok(len == 0xFFFF && bytes == 3,
|
|
"decode_length: 0xFC 0xFF 0xFF → 65535 (3 bytes total)");
|
|
}
|
|
|
|
/**
|
|
* @brief Test mysql_decode_length() for 3-byte values (0xFD prefix).
|
|
*/
|
|
static void test_decode_length_3byte() {
|
|
// CPY3() reads 4 bytes via uint32_t* cast, so pad buffer to avoid OOB
|
|
unsigned char buf[5];
|
|
uint32_t len = 0;
|
|
|
|
buf[0] = 0xFD;
|
|
buf[1] = 0x00;
|
|
buf[2] = 0x00;
|
|
buf[3] = 0x01;
|
|
buf[4] = 0x00; // padding for CPY3's 4-byte read from buf+1
|
|
uint8_t bytes = mysql_decode_length(buf, &len);
|
|
ok(len == 0x010000 && bytes == 4,
|
|
"decode_length: 0xFD prefix → 65536 (4 bytes total)");
|
|
}
|
|
|
|
/**
|
|
* @brief Test mysql_decode_length_ll() for 8-byte values (0xFE prefix).
|
|
*/
|
|
static void test_decode_length_8byte() {
|
|
unsigned char buf[9];
|
|
uint64_t len = 0;
|
|
|
|
buf[0] = 0xFE;
|
|
memset(buf + 1, 0, 8);
|
|
buf[1] = 0x01;
|
|
uint8_t bytes = mysql_decode_length_ll(buf, &len);
|
|
ok(len == 1 && bytes == 9,
|
|
"decode_length_ll: 0xFE prefix → 1 (9 bytes total)");
|
|
|
|
// Large value
|
|
buf[0] = 0xFE;
|
|
buf[1] = 0xFF;
|
|
buf[2] = 0xFF;
|
|
buf[3] = 0xFF;
|
|
buf[4] = 0xFF;
|
|
buf[5] = 0x00;
|
|
buf[6] = 0x00;
|
|
buf[7] = 0x00;
|
|
buf[8] = 0x00;
|
|
bytes = mysql_decode_length_ll(buf, &len);
|
|
ok(len == 0xFFFFFFFF && bytes == 9,
|
|
"decode_length_ll: 0xFE prefix → 4294967295 (9 bytes total)");
|
|
}
|
|
|
|
// ============================================================================
|
|
// 2. MySQL length-encoded integer encoding
|
|
// ============================================================================
|
|
|
|
/**
|
|
* @brief Test mysql_encode_length() and roundtrip with decode.
|
|
*/
|
|
static void test_encode_length() {
|
|
char hd[9];
|
|
|
|
// 1-byte range (0-250): encode returns 1, does NOT write hd
|
|
// (the value itself is the length byte, no prefix needed)
|
|
uint8_t enc_len = mysql_encode_length(0, hd);
|
|
ok(enc_len == 1,
|
|
"encode_length: 0 → 1 byte");
|
|
|
|
enc_len = mysql_encode_length(250, hd);
|
|
ok(enc_len == 1,
|
|
"encode_length: 250 → 1 byte");
|
|
|
|
// 2-byte range (251-65535)
|
|
enc_len = mysql_encode_length(251, hd);
|
|
ok(enc_len == 3 && (unsigned char)hd[0] == 0xFC,
|
|
"encode_length: 251 → 3 bytes (0xFC prefix)");
|
|
|
|
enc_len = mysql_encode_length(65535, hd);
|
|
ok(enc_len == 3 && (unsigned char)hd[0] == 0xFC,
|
|
"encode_length: 65535 → 3 bytes (0xFC prefix)");
|
|
|
|
// 3-byte range (65536 - 16777215)
|
|
enc_len = mysql_encode_length(65536, hd);
|
|
ok(enc_len == 4 && (unsigned char)hd[0] == 0xFD,
|
|
"encode_length: 65536 → 4 bytes (0xFD prefix)");
|
|
|
|
// 8-byte range (>= 16777216)
|
|
enc_len = mysql_encode_length(16777216, hd);
|
|
ok(enc_len == 9 && (unsigned char)hd[0] == 0xFE,
|
|
"encode_length: 16777216 → 9 bytes (0xFE prefix)");
|
|
}
|
|
|
|
/**
|
|
* @brief Test write_encoded_length + decode roundtrip for various values.
|
|
*
|
|
* write_encoded_length() writes both prefix and value bytes.
|
|
* mysql_decode_length_ll() reads them back.
|
|
*/
|
|
static void test_encode_decode_roundtrip() {
|
|
unsigned char buf[9];
|
|
char prefix[1];
|
|
uint64_t test_values[] = {0, 1, 250, 251, 1000, 65535, 65536, 16777215, 16777216, 100000000ULL};
|
|
int num_values = sizeof(test_values) / sizeof(test_values[0]);
|
|
|
|
int pass_count = 0;
|
|
for (int i = 0; i < num_values; i++) {
|
|
memset(buf, 0, sizeof(buf));
|
|
prefix[0] = 0; // Initialize to avoid UB for 1-byte values
|
|
uint8_t enc_len = mysql_encode_length(test_values[i], prefix);
|
|
write_encoded_length(buf, test_values[i], enc_len, prefix[0]);
|
|
|
|
uint64_t decoded = 0;
|
|
mysql_decode_length_ll(buf, &decoded);
|
|
if (decoded == test_values[i]) pass_count++;
|
|
}
|
|
ok(pass_count == num_values,
|
|
"encode/decode roundtrip: all %d values survive roundtrip", num_values);
|
|
}
|
|
|
|
// ============================================================================
|
|
// 3. mysql_hdr packet header structure
|
|
// ============================================================================
|
|
|
|
/**
|
|
* @brief Test mysql_hdr structure layout (24-bit length + 8-bit id).
|
|
*/
|
|
static void test_mysql_hdr() {
|
|
mysql_hdr hdr;
|
|
memset(&hdr, 0, sizeof(hdr));
|
|
|
|
ok(sizeof(mysql_hdr) == 4,
|
|
"mysql_hdr: sizeof is 4 bytes");
|
|
|
|
hdr.pkt_length = 100;
|
|
hdr.pkt_id = 1;
|
|
ok(hdr.pkt_length == 100 && hdr.pkt_id == 1,
|
|
"mysql_hdr: pkt_length and pkt_id set correctly");
|
|
|
|
// Max 24-bit value
|
|
hdr.pkt_length = 0xFFFFFF;
|
|
ok(hdr.pkt_length == 0xFFFFFF,
|
|
"mysql_hdr: max pkt_length (16MB-1)");
|
|
}
|
|
|
|
// ============================================================================
|
|
// 4. CPY3 and CPY8 byte copy helpers
|
|
// ============================================================================
|
|
|
|
/**
|
|
* @brief Test CPY3() — copies 3 bytes as little-endian unsigned int.
|
|
*/
|
|
static void test_cpy3() {
|
|
// CPY3() reads 4 bytes via uint32_t* cast, so use 4-byte buffers
|
|
unsigned char buf[4] = {0x01, 0x02, 0x03, 0x00};
|
|
unsigned int val = CPY3(buf);
|
|
ok(val == 0x030201,
|
|
"CPY3: little-endian 3-byte copy correct");
|
|
|
|
unsigned char zero[4] = {0, 0, 0, 0};
|
|
ok(CPY3(zero) == 0, "CPY3: zero bytes → 0");
|
|
}
|
|
|
|
/**
|
|
* @brief Test CPY8() — copies 8 bytes as little-endian uint64.
|
|
*/
|
|
static void test_cpy8() {
|
|
unsigned char buf[8] = {0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
|
|
uint64_t val = CPY8(buf);
|
|
ok(val == 1, "CPY8: little-endian 8-byte copy correct");
|
|
|
|
unsigned char max[8];
|
|
memset(max, 0xFF, 8);
|
|
uint64_t maxval = CPY8(max);
|
|
ok(maxval == UINT64_MAX, "CPY8: all 0xFF → UINT64_MAX");
|
|
}
|
|
|
|
// ============================================================================
|
|
// 5. Query digest functions
|
|
// ============================================================================
|
|
|
|
/**
|
|
* @brief Test MySQL query digest normalization (two-stage pipeline).
|
|
*
|
|
* first_stage normalizes whitespace/structure, second_stage replaces
|
|
* literals with '?'. The combined _2 function does both.
|
|
*/
|
|
static void test_mysql_query_digest() {
|
|
char buf[QUERY_DIGEST_BUF];
|
|
char *first_comment = nullptr;
|
|
|
|
// Digest normalizes the query (whitespace, literals)
|
|
char *digest = mysql_query_digest_and_first_comment_2(
|
|
"SELECT * FROM users WHERE id = 1", 37,
|
|
&first_comment, buf);
|
|
ok(digest != nullptr,
|
|
"mysql digest: SELECT produces non-null digest");
|
|
if (digest != nullptr) {
|
|
// Verify whitespace is normalized (collapsed to single space)
|
|
ok(strstr(digest, " ") == nullptr,
|
|
"mysql digest: extra whitespace normalized");
|
|
} else {
|
|
ok(0, "mysql digest: whitespace normalized (skipped)");
|
|
}
|
|
|
|
// Query with comment — first_comment should capture it
|
|
if (first_comment) { free(first_comment); first_comment = nullptr; }
|
|
digest = mysql_query_digest_and_first_comment_2(
|
|
"/* my_comment */ SELECT 1", 25,
|
|
&first_comment, buf);
|
|
ok(digest != nullptr,
|
|
"mysql digest: query with comment produces non-null digest");
|
|
|
|
// Empty query
|
|
if (first_comment) { free(first_comment); first_comment = nullptr; }
|
|
digest = mysql_query_digest_and_first_comment_2(
|
|
"", 0, &first_comment, buf);
|
|
ok(digest != nullptr,
|
|
"mysql digest: empty query produces non-null digest");
|
|
if (first_comment) { free(first_comment); first_comment = nullptr; }
|
|
}
|
|
|
|
/**
|
|
* @brief Test PgSQL query digest normalization.
|
|
*/
|
|
static void test_pgsql_query_digest() {
|
|
char buf[QUERY_DIGEST_BUF];
|
|
char *first_comment = nullptr;
|
|
|
|
const char *pgsql_q = "SELECT * FROM orders WHERE total > 0";
|
|
char *digest = pgsql_query_digest_and_first_comment_2(
|
|
pgsql_q, strlen(pgsql_q),
|
|
&first_comment, buf);
|
|
ok(digest != nullptr,
|
|
"pgsql digest: SELECT produces non-null digest");
|
|
if (digest != nullptr) {
|
|
// Verify whitespace is normalized
|
|
ok(strstr(digest, " ") == nullptr,
|
|
"pgsql digest: extra whitespace normalized");
|
|
} else {
|
|
ok(0, "pgsql digest: whitespace normalized (skipped)");
|
|
}
|
|
if (first_comment) { free(first_comment); first_comment = nullptr; }
|
|
}
|
|
|
|
// ============================================================================
|
|
// 6. String utility functions
|
|
// ============================================================================
|
|
|
|
/**
|
|
* @brief Test escape_string_single_quotes().
|
|
*/
|
|
static void test_escape_single_quotes() {
|
|
// No quotes — returns the original pointer (not a copy)
|
|
char *input1 = strdup("hello world");
|
|
char *escaped1 = escape_string_single_quotes(input1, true);
|
|
ok(escaped1 != nullptr && strcmp(escaped1, "hello world") == 0,
|
|
"escape: string without quotes unchanged");
|
|
free(escaped1);
|
|
|
|
// With single quotes — should double them
|
|
char *input2 = strdup("it's a test");
|
|
char *escaped2 = escape_string_single_quotes(input2, true);
|
|
ok(escaped2 != nullptr && strcmp(escaped2, "it''s a test") == 0,
|
|
"escape: single quote doubled");
|
|
free(escaped2);
|
|
|
|
// Multiple quotes
|
|
char *input3 = strdup("a'b'c");
|
|
char *escaped3 = escape_string_single_quotes(input3, true);
|
|
ok(escaped3 != nullptr && strcmp(escaped3, "a''b''c") == 0,
|
|
"escape: multiple single quotes doubled");
|
|
free(escaped3);
|
|
}
|
|
|
|
/**
|
|
* @brief Test mywildcmp() — wildcard pattern matching with % and _.
|
|
*/
|
|
static void test_wildcard_matching() {
|
|
// Exact match
|
|
ok(mywildcmp("hello", "hello") == true,
|
|
"wildcard: exact match");
|
|
|
|
// % matches any sequence
|
|
ok(mywildcmp("hel%", "hello") == true,
|
|
"wildcard: % suffix matches");
|
|
ok(mywildcmp("%llo", "hello") == true,
|
|
"wildcard: % prefix matches");
|
|
ok(mywildcmp("%ll%", "hello") == true,
|
|
"wildcard: % on both sides matches");
|
|
ok(mywildcmp("%", "anything") == true,
|
|
"wildcard: lone % matches anything");
|
|
|
|
// _ matches single character
|
|
ok(mywildcmp("h_llo", "hello") == true,
|
|
"wildcard: _ matches single char");
|
|
ok(mywildcmp("h_llo", "hallo") == true,
|
|
"wildcard: _ matches any single char");
|
|
|
|
// Non-match
|
|
ok(mywildcmp("hello", "world") == false,
|
|
"wildcard: no match on different strings");
|
|
ok(mywildcmp("hel%", "world") == false,
|
|
"wildcard: % prefix doesn't match unrelated");
|
|
ok(mywildcmp("h_llo", "hllo") == false,
|
|
"wildcard: _ requires exactly one char");
|
|
|
|
// Empty cases
|
|
ok(mywildcmp("", "") == true,
|
|
"wildcard: empty pattern matches empty string");
|
|
ok(mywildcmp("%", "") == true,
|
|
"wildcard: % matches empty string");
|
|
}
|
|
|
|
// ============================================================================
|
|
// Main
|
|
// ============================================================================
|
|
|
|
int main() {
|
|
plan(43);
|
|
|
|
test_init_minimal();
|
|
|
|
// MySQL length-encoded integers
|
|
test_decode_length_1byte(); // 3 tests
|
|
test_decode_length_2byte(); // 2 tests
|
|
test_decode_length_3byte(); // 1 test
|
|
test_decode_length_8byte(); // 2 tests
|
|
test_encode_length(); // 6 tests
|
|
test_encode_decode_roundtrip(); // 1 test
|
|
|
|
// Packet header
|
|
test_mysql_hdr(); // 3 tests
|
|
|
|
// Byte copy helpers
|
|
test_cpy3(); // 2 tests
|
|
test_cpy8(); // 2 tests
|
|
|
|
// Query digest
|
|
test_mysql_query_digest(); // 4 tests
|
|
test_pgsql_query_digest(); // 2 tests
|
|
|
|
// String utilities
|
|
test_escape_single_quotes(); // 3 tests
|
|
test_wildcard_matching(); // 12 tests
|
|
// Total: 3+2+1+2+6+1+3+2+2+4+2+3+12 = 43
|
|
|
|
test_cleanup_minimal();
|
|
|
|
return exit_status();
|
|
}
|