jeka
/
utun2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
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.
1314 Commits
15 Branches
2 Tags
165 MiB
 
 
 
 
 
 
Tree: 26f4da1b7c
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '26f4da1b7c'
${ noResults }
utun2/tests/test_media_delivery_download.c

508 lines
23 KiB
Raw Blame History

// test_media_delivery_download.c — тест скачивания блоков (chunk → done → assembly)
//
// Покрытие:
// 1. media_download_start — регистрация в очереди, сбор суперузлов
// 2. media_download_handle_chunk — запись чанка в .chunk_N
// 3. media_download_handle_chunk — неизвестный media_id → игнор
// 4. media_download_handle_done — проверка подписи, отметка validated
// 5. media_download_handle_done — неверная подпись → сброс started/received
// 6. media_download_handle_done — все блоки получены → сборка файла
// 7. media_download_cancel — отправка CANCEL, done_cb с err=-2
#include "media_delivery.h"
#include "media_delivery_proto.h"
#include "media_download.h"
#include "media_index.h"
#include "../lib/u_async.h"
#include "../lib/debug_config.h"
#include "../lib/mem.h"
#include "../transport_layer/secure_channel.h"
#include "../routing_layer/topo_node_sqlite.h"
#include "../routing_layer/conn_mgr.h"
#include <sqlite3.h>
#include <openssl/evp.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>
#define TEMP_DIR "/tmp/test_mdl_dl_XXXXXX"
#define CHUNK_SIZE 100
#define NUM_BLOCKS 3
static int g_passed = 0, g_failed = 0, g_total = 0;
static char g_temp_dir[256];
static struct UASYNC* g_ua = NULL;
#define TEST(name) do { g_total++; printf(" %-55s", name); } while(0)
#define OK() do { g_passed++; printf("OK\n"); } while(0)
#define FAIL(fmt, ...) do { g_failed++; printf("FAIL: " fmt "\n", ##__VA_ARGS__); } while(0)
/* ── helpers ── */
static void make_uuid(uint8_t buf[16]) { for (int i = 0; i < 16; i++) buf[i] = (uint8_t)(rand() & 0xFF); }
static void write_file(const char* path, const uint8_t* data, size_t len) {
FILE* f = fopen(path, "wb");
if (f) { fwrite(data, 1, len, f); fclose(f); }
}
static int file_exists(const char* path) { return access(path, F_OK) == 0; }
static int file_size(const char* path) {
struct stat st; if (stat(path, &st) != 0) return -1; return (int)st.st_size;
}
static void test_setup(void) {
snprintf(g_temp_dir, sizeof(g_temp_dir), "%s", TEMP_DIR);
if (!mkdtemp(g_temp_dir)) { fprintf(stderr, "mkdtemp failed\n"); exit(1); }
debug_config_init(); debug_set_level(DEBUG_LEVEL_ERROR);
g_ua = uasync_create();
}
static void test_cleanup(void) {
char cmd[512]; snprintf(cmd, sizeof(cmd), "rm -rf %s", g_temp_dir); system(cmd);
if (g_ua) { uasync_destroy(g_ua, 0); g_ua = NULL; }
}
/* ── create minimal UTUN_INSTANCE with media_delivery ── */
#include "../src/utun_instance.h"
static struct UTUN_INSTANCE* make_minimal_instance(sqlite3* db) {
struct UTUN_INSTANCE* inst = u_calloc(1, sizeof(*inst));
if (!inst) return NULL;
inst->ua = g_ua;
inst->node_id = 0xDEADBEEFDEADBEEFULL;
inst->topo_sqlite_db = db;
/* generate Ed25519 key pair — just random bytes for test */
for (int i = 0; i < 32; i++) inst->my_ed25519_privkey[i] = (uint8_t)(rand() & 0xFF);
memset(inst->my_ed25519_pubkey, 0xDD, 32);
/* init media_delivery */
inst->md.inst = inst;
inst->md.db = db;
inst->md.self_node_id = inst->node_id;
inst->md.initialized = 1;
return inst;
}
/* ── test cases ── */
static void test_download_chunk(void) {
TEST("download handle_chunk writes to temp file"); {
sqlite3* db = NULL; sqlite3_open(":memory:", &db);
struct UTUN_INSTANCE* inst = make_minimal_instance(db);
inst->md.downloads = queue_new(inst->ua, 256, offsetof(struct media_download, media_id), 16, "md_dl_test");
struct media_download dl_buf; memset(&dl_buf, 0, sizeof(dl_buf));
make_uuid(dl_buf.media_id);
dl_buf.num_blocks = NUM_BLOCKS;
snprintf(dl_buf.dest_path, sizeof(dl_buf.dest_path), "%s/test_output.bin", g_temp_dir);
dl_buf.block_ids = u_malloc(NUM_BLOCKS * 16);
dl_buf.block_sigs = u_malloc(NUM_BLOCKS * 64);
for (int i = 0; i < NUM_BLOCKS; i++) make_uuid(dl_buf.block_ids + i * 16);
dl_buf.active = 1;
memcpy(dl_buf.ll.data, dl_buf.media_id, 16);
struct ll_entry* qe = queue_entry_new(sizeof(struct media_download));
if (qe) { memcpy(qe->data, &dl_buf, sizeof(dl_buf)); queue_data_put_with_index(inst->md.downloads, qe); }
uint8_t chunk_data[256];
for (int i = 0; i < 256; i++) chunk_data[i] = (uint8_t)(i & 0xFF);
uint8_t pkt[MEDIA_BLOCK_CHUNK_HDR_SIZE + sizeof(chunk_data)];
struct media_pkt_block_chunk* ch = (struct media_pkt_block_chunk*)pkt;
ch->subcmd = MEDIA_SUBCMD_BLOCK_CHUNK;
memcpy(ch->media_id, dl_buf.media_id, 16);
memcpy(ch->block_id, dl_buf.block_ids, 16);
ch->chunk = 0; ch->offset = 0; ch->data_len = (uint16_t)sizeof(chunk_data);
memcpy(pkt + MEDIA_BLOCK_CHUNK_HDR_SIZE, chunk_data, sizeof(chunk_data));
media_download_handle_chunk(inst, pkt, sizeof(pkt));
char tmp[1024]; snprintf(tmp, sizeof(tmp), "%s.chunk_0", dl_buf.dest_path);
int ok1 = file_exists(tmp) && file_size(tmp) == (int)sizeof(chunk_data);
/* send second chunk with same block_id → appends */
ch->offset = (uint32_t)sizeof(chunk_data);
media_download_handle_chunk(inst, pkt, sizeof(pkt));
int ok2 = file_size(tmp) == 2 * (int)sizeof(chunk_data);
if (ok1 && ok2) OK(); else FAIL("chunk: ok1=%d ok2=%d size=%d", ok1, ok2, file_size(tmp));
u_free(dl_buf.block_ids); u_free(dl_buf.block_sigs);
if (inst->md.downloads) queue_free(inst->md.downloads);
u_free(inst); sqlite3_close(db);
}
TEST("download handle_chunk unknown media_id"); {
sqlite3* db = NULL; sqlite3_open(":memory:", &db);
struct UTUN_INSTANCE* inst = make_minimal_instance(db);
inst->md.downloads = queue_new(inst->ua, 256, offsetof(struct media_download, media_id), 16, "md_dl_test2");
uint8_t pkt[MEDIA_BLOCK_CHUNK_HDR_SIZE];
struct media_pkt_block_chunk* ch = (struct media_pkt_block_chunk*)pkt;
ch->subcmd = MEDIA_SUBCMD_BLOCK_CHUNK;
make_uuid(ch->media_id); make_uuid(ch->block_id);
ch->chunk = 0; ch->offset = 0; ch->data_len = 0;
media_download_handle_chunk(inst, pkt, sizeof(pkt));
OK(); /* should not crash or create files */
if (inst->md.downloads) queue_free(inst->md.downloads);
u_free(inst); sqlite3_close(db);
}
}
static void test_download_done(void) {
TEST("download handle_done sig ok + assembly"); {
sqlite3* db = NULL; sqlite3_open(":memory:", &db);
struct UTUN_INSTANCE* inst = make_minimal_instance(db);
inst->md.downloads = queue_new(inst->ua, 256, offsetof(struct media_download, media_id), 16, "md_dl_test3");
struct media_download dl; memset(&dl, 0, sizeof(dl));
make_uuid(dl.media_id);
dl.num_blocks = 2;
snprintf(dl.dest_path, sizeof(dl.dest_path), "%s/out.bin", g_temp_dir);
dl.block_ids = u_malloc(16 * 2); dl.block_sigs = u_malloc(64 * 2);
make_uuid(dl.block_ids); make_uuid(dl.block_ids + 16);
memset(dl.block_sigs, 0x42, 64); memset(dl.block_sigs + 64, 0x43, 64);
dl.block_size = CHUNK_SIZE; dl.file_size = CHUNK_SIZE * 2;
dl.active = 1;
memcpy(dl.ll.data, dl.media_id, 16);
struct ll_entry* qe = queue_entry_new(sizeof(struct media_download));
if (!qe) { FAIL("queue_entry_new"); goto done3; }
memcpy(qe->data, &dl, sizeof(dl)); queue_data_put_with_index(inst->md.downloads, qe);
/* write chunk files */
uint8_t data0[CHUNK_SIZE]; memset(data0, 0xA0, CHUNK_SIZE);
uint8_t data1[CHUNK_SIZE]; memset(data1, 0xB1, CHUNK_SIZE);
{
char c0[1024]; snprintf(c0, sizeof(c0), "%s.chunk_0", dl.dest_path);
char c1[1024]; snprintf(c1, sizeof(c1), "%s.chunk_1", dl.dest_path);
write_file(c0, data0, CHUNK_SIZE); write_file(c1, data1, CHUNK_SIZE);
}
/* BLOCK_DONE for block 0 */
{
uint8_t pkt[MEDIA_BLOCK_DONE_SIZE];
struct media_pkt_block_done* bd = (struct media_pkt_block_done*)pkt;
memset(pkt, 0, sizeof(pkt));
bd->subcmd = MEDIA_SUBCMD_BLOCK_DONE;
memcpy(bd->media_id, dl.media_id, 16);
memcpy(bd->block_id, dl.block_ids, 16);
bd->chunk = 0; bd->total_size = CHUNK_SIZE;
memcpy(bd->block_sig, dl.block_sigs, 64); /* match expected */
media_download_handle_done(inst, pkt, sizeof(pkt));
}
/* BLOCK_DONE for block 1 */
{
uint8_t pkt[MEDIA_BLOCK_DONE_SIZE];
struct media_pkt_block_done* bd = (struct media_pkt_block_done*)pkt;
memset(pkt, 0, sizeof(pkt));
bd->subcmd = MEDIA_SUBCMD_BLOCK_DONE;
memcpy(bd->media_id, dl.media_id, 16);
memcpy(bd->block_id, dl.block_ids + 16, 16);
bd->chunk = 1; bd->total_size = CHUNK_SIZE;
memcpy(bd->block_sig, dl.block_sigs + 64, 64);
media_download_handle_done(inst, pkt, sizeof(pkt));
}
/* verify assembly */
if (file_exists(dl.dest_path)) {
int sz = file_size(dl.dest_path);
if (sz == CHUNK_SIZE * 2) OK(); else FAIL("assembled size %d != %d", sz, CHUNK_SIZE * 2);
} else { FAIL("assembled file not created"); }
done3:
u_free(dl.block_ids); u_free(dl.block_sigs);
if (inst->md.downloads) queue_free(inst->md.downloads);
u_free(inst); sqlite3_close(db);
}
TEST("download handle_done bad sig → retry"); {
sqlite3* db = NULL; sqlite3_open(":memory:", &db);
struct UTUN_INSTANCE* inst = make_minimal_instance(db);
inst->md.downloads = queue_new(inst->ua, 256, offsetof(struct media_download, media_id), 16, "md_dl_test4");
struct media_download dl; memset(&dl, 0, sizeof(dl));
make_uuid(dl.media_id);
dl.num_blocks = 1;
snprintf(dl.dest_path, sizeof(dl.dest_path), "%s/bad_sig.bin", g_temp_dir);
dl.block_ids = u_malloc(16); dl.block_sigs = u_malloc(64);
make_uuid(dl.block_ids);
memset(dl.block_sigs, 0x55, 64); /* expected sig */
dl.block_size = CHUNK_SIZE; dl.file_size = CHUNK_SIZE;
dl.active = 1;
memcpy(dl.ll.data, dl.media_id, 16);
struct ll_entry* qe = queue_entry_new(sizeof(struct media_download));
if (!qe) { FAIL("queue_entry_new"); goto done4; }
memcpy(qe->data, &dl, sizeof(dl)); queue_data_put_with_index(inst->md.downloads, qe);
/* write chunk file */
uint8_t data[CHUNK_SIZE]; memset(data, 0xFF, CHUNK_SIZE);
char c0[1024]; snprintf(c0, sizeof(c0), "%s.chunk_0", dl.dest_path);
write_file(c0, data, CHUNK_SIZE);
/* send BLOCK_DONE with WRONG signature */
uint8_t pkt[MEDIA_BLOCK_DONE_SIZE];
struct media_pkt_block_done* bd = (struct media_pkt_block_done*)pkt;
memset(pkt, 0, sizeof(pkt));
bd->subcmd = MEDIA_SUBCMD_BLOCK_DONE;
memcpy(bd->media_id, dl.media_id, 16);
memcpy(bd->block_id, dl.block_ids, 16);
bd->chunk = 0; bd->total_size = CHUNK_SIZE;
memset(bd->block_sig, 0xAA, 64); /* WRONG */
media_download_handle_done(inst, pkt, sizeof(pkt));
/* file should NOT be assembled (sig mismatch) */
if (!file_exists(dl.dest_path)) OK(); else FAIL("assembled despite bad sig");
done4:
u_free(dl.block_ids); u_free(dl.block_sigs);
if (inst->md.downloads) queue_free(inst->md.downloads);
u_free(inst); sqlite3_close(db);
}
}
static void test_download_cancel(void) {
TEST("download cancel marks inactive and calls done_cb"); {
sqlite3* db = NULL; sqlite3_open(":memory:", &db);
struct UTUN_INSTANCE* inst = make_minimal_instance(db);
inst->md.downloads = queue_new(inst->ua, 256, offsetof(struct media_download, media_id), 16, "md_dl_test5");
struct media_download dl; memset(&dl, 0, sizeof(dl));
make_uuid(dl.media_id);
dl.num_blocks = 1;
snprintf(dl.dest_path, sizeof(dl.dest_path), "%s/cancel.bin", g_temp_dir);
dl.block_ids = u_malloc(16); make_uuid(dl.block_ids);
dl.block_sigs = u_malloc(64); memset(dl.block_sigs, 0, 64);
dl.active = 1;
memcpy(dl.ll.data, dl.media_id, 16);
struct ll_entry* qe = queue_entry_new(sizeof(struct media_download));
if (!qe) { FAIL("queue_entry_new"); goto done5; }
memcpy(qe->data, &dl, sizeof(dl)); queue_data_put_with_index(inst->md.downloads, qe);
int rc = media_download_cancel(inst, dl.media_id, NULL, 0);
if (rc == 0) OK(); else FAIL("cancel returned %d", rc);
done5:
u_free(dl.block_ids); u_free(dl.block_sigs);
if (inst->md.downloads) queue_free(inst->md.downloads);
u_free(inst); sqlite3_close(db);
}
}
/* ────────────────────────────────────────────────────────────────
Tests for block download fixes (backpressure, OOB block_id, conn_mgr close)
──────────────────────────────────────────────────────────────── */
static struct media_download* make_test_dl(sqlite3* db, struct UTUN_INSTANCE* inst, int num_blocks) {
if (!inst->md.downloads) inst->md.downloads = queue_new(inst->ua, 256, offsetof(struct media_download, media_id), 16, "md_dl_test");
struct media_download* dl = u_calloc(1, sizeof(*dl));
if (!dl) return NULL;
make_uuid(dl->media_id);
dl->num_blocks = num_blocks;
snprintf(dl->dest_path, sizeof(dl->dest_path), "%s/test.bin", g_temp_dir);
dl->block_ids = u_calloc((size_t)num_blocks, 16);
dl->block_sigs = u_calloc((size_t)num_blocks, 64);
for (int i = 0; i < num_blocks; i++) { make_uuid(dl->block_ids + i * 16); memset(dl->block_sigs + i * 64, (uint8_t)(0x42 + i), 64); }
dl->block_size = CHUNK_SIZE; dl->file_size = (int64_t)CHUNK_SIZE * num_blocks;
dl->active = 1; dl->inst = inst;
memcpy(dl->ll.data, dl->media_id, 16);
struct ll_entry* qe = queue_entry_new(sizeof(*dl));
if (!qe) { u_free(dl->block_ids); u_free(dl->block_sigs); u_free(dl); return NULL; }
memcpy(qe->data, dl, sizeof(*dl)); u_free(dl);
queue_data_put_with_index(inst->md.downloads, qe);
return (struct media_download*)qe->data;
}
static struct media_download_peer* add_peer(struct media_download* dl, uint64_t node_id, int num_blocks) {
if (dl->num_peers >= 10) return NULL;
int pi = dl->num_peers++;
struct media_download_peer* p = &dl->peers[pi];
p->node_id = node_id;
p->num_blocks = num_blocks;
for (int i = 0; i < num_blocks; i++) { make_uuid(p->blocks[i].block_id); }
return p;
}
/* ── Тест: conn_cb отправляет только первый блок (backpressure) ── */
static void test_conn_cb_backpressure(void) {
TEST("conn_cb starts only first block (backpressure)"); {
sqlite3* db = NULL; sqlite3_open(":memory:", &db);
struct UTUN_INSTANCE* inst = make_minimal_instance(db);
struct media_download* dl = make_test_dl(db, inst, 1);
if (!dl) { FAIL("make_test_dl"); sqlite3_close(db); u_free(inst); return; }
add_peer(dl, 0x1234, 5); /* 5 blocks on peer */
md_dl_conn_cb(NULL, 0x1234, 0, CONN_EVENT_UP, dl);
int started_count = 0;
for (int i = 0; i < dl->peers[0].num_blocks; i++)
if (dl->peers[0].blocks[i].started) started_count++;
if (dl->peers[0].connected && started_count == 1 && dl->peers[0].blocks[0].started && !dl->peers[0].blocks[1].started)
OK(); else FAIL("connected=%d started=%d b0=%d b1=%d", dl->peers[0].connected, started_count, dl->peers[0].blocks[0].started, dl->peers[0].blocks[1].started);
u_free(dl->block_ids); u_free(dl->block_sigs);
if (inst->md.downloads) queue_free(inst->md.downloads);
u_free(inst); sqlite3_close(db);
}
}
/* ── Тест: conn_cb для разных пиров ── */
static void test_conn_cb_multi_peer(void) {
TEST("conn_cb starts first block per peer"); {
sqlite3* db = NULL; sqlite3_open(":memory:", &db);
struct UTUN_INSTANCE* inst = make_minimal_instance(db);
struct media_download* dl = make_test_dl(db, inst, 1);
if (!dl) { FAIL("make_test_dl"); sqlite3_close(db); u_free(inst); return; }
add_peer(dl, 0x1000, 3);
add_peer(dl, 0x2000, 2);
md_dl_conn_cb(NULL, 0x1000, 0, CONN_EVENT_UP, dl);
md_dl_conn_cb(NULL, 0x2000, 0, CONN_EVENT_UP, dl);
int ok = dl->peers[0].connected && dl->peers[1].connected
&& dl->peers[0].blocks[0].started && !dl->peers[0].blocks[1].started
&& dl->peers[1].blocks[0].started && !dl->peers[1].blocks[1].started;
if (ok) OK(); else FAIL("p0:conn=%d b0=%d b1=%d p1:conn=%d b0=%d b1=%d",
dl->peers[0].connected, dl->peers[0].blocks[0].started, dl->peers[0].blocks[1].started,
dl->peers[1].connected, dl->peers[1].blocks[0].started, dl->peers[1].blocks[1].started);
u_free(dl->block_ids); u_free(dl->block_sigs);
if (inst->md.downloads) queue_free(inst->md.downloads);
u_free(inst); sqlite3_close(db);
}
}
/* ── Тест: BLOCK_DONE → relay: следующий блок с того же пира ── */
static void test_done_block_relay(void) {
TEST("BLOCK_DONE triggers next block from same peer"); {
sqlite3* db = NULL; sqlite3_open(":memory:", &db);
struct UTUN_INSTANCE* inst = make_minimal_instance(db);
struct media_download* dl = make_test_dl(db, inst, 2);
if (!dl) { FAIL("make_test_dl"); sqlite3_close(db); u_free(inst); return; }
/* peer with 3 blocks for 2-block download */
add_peer(dl, 0x5555, 3);
/* map dl->block_ids to peer blocks for matching in handle_done */
for (int i = 0; i < dl->num_blocks; i++)
memcpy(dl->peers[0].blocks[i].block_id, dl->block_ids + i * 16, 16);
/* pre-set: block 0 started and fake-received via conn_cb */
dl->peers[0].blocks[0].started = 1;
/* write chunk for block 0 */
uint8_t data0[CHUNK_SIZE]; memset(data0, 0xBB, CHUNK_SIZE);
{ char c[1024]; snprintf(c, sizeof(c), "%s.chunk_0", dl->dest_path); write_file(c, data0, CHUNK_SIZE); }
/* BLOCK_DONE for block 0 with matching sig */
{ uint8_t pkt[MEDIA_BLOCK_DONE_SIZE]; memset(pkt, 0, sizeof(pkt));
struct media_pkt_block_done* bd = (struct media_pkt_block_done*)pkt;
bd->subcmd = MEDIA_SUBCMD_BLOCK_DONE;
memcpy(bd->media_id, dl->media_id, 16); memcpy(bd->block_id, dl->block_ids, 16);
bd->chunk = 0; bd->total_size = CHUNK_SIZE;
memcpy(bd->block_sig, dl->block_sigs, 64);
media_download_handle_done(inst, pkt, sizeof(pkt)); }
/* block 1 should be started (relay); block 2 NOT (peer-local index unrelated to dl) */
int ok = dl->peers[0].blocks[1].started && !dl->peers[0].blocks[2].started;
if (ok) OK(); else FAIL("b1_started=%d b2_started=%d", dl->peers[0].blocks[1].started, dl->peers[0].blocks[2].started);
u_free(dl->block_ids); u_free(dl->block_sigs);
if (inst->md.downloads) queue_free(inst->md.downloads);
u_free(inst); sqlite3_close(db);
}
}
/* ── Тест: ассемблинг при всех блоках ── */
static void test_done_assembly(void) {
TEST("BLOCK_DONE all blocks → assembly"); {
sqlite3* db = NULL; sqlite3_open(":memory:", &db);
struct UTUN_INSTANCE* inst = make_minimal_instance(db);
struct media_download* dl = make_test_dl(db, inst, 2);
if (!dl) { FAIL("make_test_dl"); sqlite3_close(db); u_free(inst); return; }
/* write two chunk files with different content */
uint8_t d0[CHUNK_SIZE], d1[CHUNK_SIZE];
memset(d0, 0xA0, CHUNK_SIZE); memset(d1, 0xB1, CHUNK_SIZE);
{ char c[1024]; snprintf(c, sizeof(c), "%s.chunk_0", dl->dest_path); write_file(c, d0, CHUNK_SIZE); }
{ char c[1024]; snprintf(c, sizeof(c), "%s.chunk_1", dl->dest_path); write_file(c, d1, CHUNK_SIZE); }
/* BLOCK_DONE for both */
for (int bi = 0; bi < 2; bi++) {
uint8_t pkt[MEDIA_BLOCK_DONE_SIZE]; memset(pkt, 0, sizeof(pkt));
struct media_pkt_block_done* bd = (struct media_pkt_block_done*)pkt;
bd->subcmd = MEDIA_SUBCMD_BLOCK_DONE;
memcpy(bd->media_id, dl->media_id, 16); memcpy(bd->block_id, dl->block_ids + bi * 16, 16);
bd->chunk = (uint32_t)bi; bd->total_size = CHUNK_SIZE;
memcpy(bd->block_sig, dl->block_sigs + bi * 64, 64);
media_download_handle_done(inst, pkt, sizeof(pkt));
}
int sz = file_size(dl->dest_path);
int ok = dl->assembled && sz == CHUNK_SIZE * 2;
if (ok) OK(); else FAIL("assembled=%d size=%d expected=%d", dl->assembled, sz, CHUNK_SIZE * 2);
u_free(dl->block_ids); u_free(dl->block_sigs);
if (inst->md.downloads) queue_free(inst->md.downloads);
u_free(inst); sqlite3_close(db);
}
}
/* ── Тест: пир имеет больше блоков чем dl → без OOB ── */
static void test_peer_more_blocks_than_dl(void) {
TEST("conn_cb with peer blocks > dl blocks → no OOB"); {
sqlite3* db = NULL; sqlite3_open(":memory:", &db);
struct UTUN_INSTANCE* inst = make_minimal_instance(db);
struct media_download* dl = make_test_dl(db, inst, 1); /* 1 block */
if (!dl) { FAIL("make_test_dl"); sqlite3_close(db); u_free(inst); return; }
add_peer(dl, 0x9999, 6); /* peer has 6 blocks — more than dl */
/* should NOT crash (was OOB before fix) */
md_dl_conn_cb(NULL, 0x9999, 0, CONN_EVENT_UP, dl);
/* should have started only first peer block; no OOB access to dl->block_ids[1..5] */
int ok = dl->peers[0].connected && dl->peers[0].blocks[0].started
&& !dl->peers[0].blocks[1].started && !dl->peers[0].blocks[5].started;
if (ok) OK(); else FAIL("conn=%d b0=%d b1=%d b5=%d", dl->peers[0].connected, dl->peers[0].blocks[0].started, dl->peers[0].blocks[1].started, dl->peers[0].blocks[5].started);
u_free(dl->block_ids); u_free(dl->block_sigs);
if (inst->md.downloads) queue_free(inst->md.downloads);
u_free(inst); sqlite3_close(db);
}
}
int main(void) {
test_setup();
printf("=== test_media_delivery_download ===\n");
test_download_chunk();
test_download_done();
test_download_cancel();
printf("\n=== block download fixes (backpressure, OOB, relay) ===\n");
test_conn_cb_backpressure();
test_conn_cb_multi_peer();
test_done_block_relay();
test_done_assembly();
test_peer_more_blocks_than_dl();
printf("\n%d/%d passed, %d failed\n", g_passed, g_total, g_failed);
test_cleanup();
return g_failed > 0 ? 1 : 0;
}