static void tls_http_accident(void **state) { selene_error_t *err; sln_parser_baton_t *baton; selene_conf_t *conf = NULL; selene_t *s = NULL; http_cb_t cbb; sln_bucket_t *e1; selene_conf_create(&conf); SLN_ERR(selene_conf_use_reasonable_defaults(conf)); SLN_ERR(selene_server_create(conf, &s)); SLN_ASSERT_CONTEXT(s); baton = (sln_parser_baton_t *)s->backend_baton; cbb.gotit = 0; selene_handler_set(s, SELENE_EVENT_TLS_GOT_HTTP, http_cb, &cbb); SLN_ERR(sln_bucket_create_copy_bytes(sln_test_alloc, &e1, http_message, strlen(http_message))); SLN_BRIGADE_INSERT_TAIL(s->bb.in_enc, e1); err = sln_io_tls_read(s, baton); SLN_ASSERT(err != NULL); SLN_ASSERT(err->err == SELENE_EINVAL); selene_error_clear(err); assert_int_equal(1, cbb.gotit); selene_destroy(s); selene_conf_destroy(conf); }
static void handshake_io_slowly(void **state) { selene_error_t *err; sln_parser_baton_t *baton; selene_conf_t *conf = NULL; selene_t *s = NULL; sln_bucket_t *e1; size_t maxlen = sizeof(openssl_client_hello_basic); size_t i; selene_conf_create(&conf); SLN_ERR(selene_conf_use_reasonable_defaults(conf)); SLN_ERR(selene_server_create(conf, &s)); SLN_ASSERT_CONTEXT(s); baton = (sln_parser_baton_t *)s->backend_baton; for (i = maxlen; i <= maxlen; i++) { SLN_ERR(sln_bucket_create_copy_bytes(sln_test_alloc, &e1, openssl_client_hello_basic, i)); SLN_BRIGADE_INSERT_TAIL(baton->in_handshake, e1); err = sln_io_handshake_read(s, baton); if (err) { SLN_ASSERT(err->err == SELENE_EINVAL); } else { /* TODO: more asserts */ } sln_brigade_clear(baton->in_handshake); } selene_destroy(s); selene_conf_destroy(conf); }
static void brigade_flatten_leftover(void **state) { char buf[80]; char bufcmp[80]; char buf2[2]; char bufcmp2[2]; size_t len = sizeof(buf); size_t len2 = sizeof(buf2); sln_brigade_t *bb; sln_bucket_t *e1; sln_bucket_t *e2; SLN_ERR(sln_brigade_create(&bb)); SLN_ERR(sln_bucket_create_empty(&e1, 40)); memset(e1->data, 'A', e1->size); SLN_BRIGADE_INSERT_TAIL(bb, e1); SLN_ERR(sln_bucket_create_empty(&e2, 42)); memset(e2->data, 'B', e2->size); SLN_BRIGADE_INSERT_TAIL(bb, e2); SLN_ERR(sln_brigade_flatten(bb, &buf[0], &len)); assert_int_equal(len, 80); assert_int_equal(sln_brigade_size(bb), 2); SLN_ERR(sln_brigade_flatten(bb, &buf2[0], &len2)); assert_int_equal(len2, 2); sln_brigade_destroy(bb); memset(&bufcmp[0], 'A', 40); memset(&bufcmp[0]+40, 'B', 40); assert_memory_equal(buf, bufcmp, 80); memset(&bufcmp2[0], 'B', 2); assert_memory_equal(buf2, bufcmp2, 2); }
static void init_server(void **state) { selene_conf_t *conf = NULL; selene_t *ctxt = NULL; selene_conf_create(&conf); SLN_ERR(selene_conf_use_reasonable_defaults(conf)); SLN_ERR(selene_server_create(conf, &ctxt)); SLN_ASSERT_CONTEXT(ctxt); selene_destroy(ctxt); selene_conf_destroy(conf); }
static void init_ctxt(void **state, selene_t **s_, selene_conf_t **conf_) { selene_t *s = NULL; selene_conf_t *conf = NULL; selene_conf_create(&conf); SLN_ERR(selene_conf_use_reasonable_defaults(conf)); SLN_ERR(selene_server_create(conf, &s)); SLN_ASSERT_CONTEXT(s); *s_ = s; *conf_ = conf; }
static void tok_nowork(void **state) { sln_brigade_t *bb; baton_t baton; baton.count = 0; SLN_ERR(sln_brigade_create(sln_test_alloc, &bb)); SLN_ERR(sln_tok_parser(bb, tok_nowork_cb, &baton)); assert_int_equal(1, baton.count); sln_brigade_destroy(bb); }
static void brigade_operations(void **state) { sln_brigade_t *bb; sln_bucket_t *e; SLN_ERR(sln_brigade_create(&bb)); assert_int_equal(sln_brigade_size(bb), 0); SLN_ERR(sln_bucket_create_empty(&e, 40)); SLN_BRIGADE_INSERT_TAIL(bb, e); assert_int_equal(sln_brigade_size(bb), 40); SLN_BUCKET_REMOVE(e); assert_int_equal(sln_brigade_size(bb), 0); sln_brigade_destroy(bb); }
static void brigade_copy_into(void **state) { sln_brigade_t *source; sln_brigade_t *dest; sln_bucket_t *e1; char buf[20]; size_t len = 0; SLN_ERR(sln_brigade_create(sln_test_alloc, &source)); SLN_ERR(sln_bucket_create_empty(sln_test_alloc, &e1, 10)); SLN_BRIGADE_INSERT_TAIL(source, e1); memset(e1->data, 'A', e1->size); SLN_ERR(sln_brigade_create(sln_test_alloc, &dest)); SLN_ERR(sln_brigade_copy_into(source, 0, 10, dest)); assert_int_equal(sln_brigade_size(dest), 10); SLN_ERR(sln_brigade_pread_bytes(dest, 0, 10, &buf[0], &len)); assert_memory_equal(buf, "AAAAAAAAAA", 2); sln_brigade_clear(dest); sln_brigade_destroy(dest); SLN_ERR(sln_brigade_create(sln_test_alloc, &dest)); SLN_ERR(sln_brigade_copy_into(source, 2, 4, dest)); assert_int_equal(sln_brigade_size(dest), 4); SLN_ERR(sln_brigade_pread_bytes(dest, 0, 4, &buf[0], &len)); assert_memory_equal(buf, "AAAA", 4); sln_brigade_clear(dest); sln_brigade_destroy(dest); sln_brigade_destroy(source); }
static void tok_bytes(void **state) { sln_brigade_t *bb; sln_bucket_t *e1; baton_t baton; baton.count = 0; SLN_ERR(sln_brigade_create(sln_test_alloc, &bb)); SLN_ERR(sln_bucket_create_empty(sln_test_alloc, &e1, 10)); SLN_BRIGADE_INSERT_TAIL(bb, e1); memset(e1->data, 'A', e1->size); SLN_ERR(sln_tok_parser(bb, tok_bytes_cb, &baton)); assert_int_equal(2, baton.count); sln_brigade_destroy(bb); }
static void init_conf(void **state) { selene_conf_t *conf = NULL; SLN_ERR(selene_conf_create(&conf)); SLN_ASSERT_CONF(conf); selene_conf_destroy(conf); }
static void tls_io_slowly(void **state) { selene_error_t *err; sln_parser_baton_t *baton; selene_conf_t *conf = NULL; selene_t *s = NULL; sln_bucket_t *e1; size_t maxlen = sizeof(openssl_client_hello_basic); size_t i; init_ctxt(state, &s, &conf); baton = (sln_parser_baton_t *)s->backend_baton; for (i = 0; i <= maxlen; i++) { SLN_ERR(sln_bucket_create_copy_bytes( sln_test_alloc, &e1, (const char *)openssl_client_hello_basic, i)); SLN_BRIGADE_INSERT_TAIL(s->bb.in_enc, e1); err = sln_io_tls_read(s, baton); if (err) { SLN_ASSERT(err->err == SELENE_EINVAL); } else if (baton->peer_version_major != 0) { assert_int_equal(baton->peer_version_major, 3); assert_int_equal(baton->peer_version_minor, 1); } sln_brigade_clear(baton->in_handshake); sln_brigade_clear(s->bb.in_enc); } destroy_ctxt(state, s, conf); }
static void logging_levels(void **state) { selene_conf_t *conf = NULL; selene_t *ctxt = NULL; selene_conf_create(&conf); SLN_ERR(selene_conf_use_reasonable_defaults(conf)); SLN_ERR(selene_server_create(conf, &ctxt)); SLN_ASSERT_CONTEXT(ctxt); sln_log_level_set(ctxt, SLN_LOG_NOTHING); assert_int_equal(SLN_LOG_NOTHING, sln_log_level_get(ctxt)); sln_log_level_set(ctxt, SLN_LOG_EVERYTHING); assert_int_equal(SLN_LOG_EVERYTHING, sln_log_level_get(ctxt)); selene_destroy(ctxt); selene_conf_destroy(conf); }
static void brigade_pread_simple(void **state) { sln_brigade_t *bb; sln_bucket_t *e; char buf[5]; size_t len = 0; SLN_ERR(sln_brigade_create(&bb)); SLN_ERR(sln_bucket_create_empty(&e, 20)); SLN_BRIGADE_INSERT_TAIL(bb, e); memset(e->data, 'B', e->size); memset(e->data, 'A', 1); SLN_ERR(sln_brigade_pread_bytes(bb, 0, 1, &buf[0], &len)); assert_int_equal(len, 1); assert_memory_equal(buf, "A", 1); SLN_ERR(sln_brigade_pread_bytes(bb, 1, 1, &buf[0], &len)); assert_int_equal(len, 1); assert_memory_equal(buf, "B", 1); SLN_ERR(sln_brigade_pread_bytes(bb, 0, 2, &buf[0], &len)); assert_int_equal(len, 2); assert_memory_equal(buf, "AB", 2); SLN_ERR(sln_brigade_pread_bytes(bb, 2, 2, &buf[0], &len)); assert_int_equal(len, 2); assert_memory_equal(buf, "BB", 2); sln_brigade_destroy(bb); }
static void logging_types(void **state) { selene_conf_t *conf = NULL; selene_t *s = NULL; log_cb_t b; selene_conf_create(&conf); SLN_ERR(selene_conf_use_reasonable_defaults(conf)); SLN_ERR(selene_server_create(conf, &s)); SLN_ASSERT_CONTEXT(s); sln_log_level_set(s, SLN_LOG_EVERYTHING); selene_handler_set(s, SELENE_EVENT_LOG_MSG, log_cb, &b); b.cmp = "CRT: test:0\n"; slnCrit(s, "test:%u", 0); b.cmp = "ERR: test:1\n"; slnErr(s, "test:%u", 1); b.cmp = "INF: test:2\n"; slnInfo(s, "test:%u", 2); b.cmp = "WRN: test:3\n"; slnWarn(s, "test:%u", 3); b.cmp = "DBG: test:4\n"; slnDbg(s, "test:%u", 4); b.cmp = "TRC: test:5\n"; slnTrace(s, "test:%u", 5); b.cmp = "UNK: test:6\n"; sln_log_fmt(s, 44, "test:%u", 6); sln_log_level_set(s, SLN_LOG_NOTHING); slnDbg(s, "test:%u", 4); selene_destroy(s); selene_conf_destroy(conf); }
static void prf_vector_from_book(void **state) { selene_conf_t *conf = NULL; selene_t *s = NULL; char buf[20]; selene_conf_create(&conf); SLN_ERR(selene_conf_use_reasonable_defaults(conf)); SLN_ERR(selene_server_create(conf, &s)); SLN_ASSERT_CONTEXT(s); /** * Test vector from Implementing SSL/TLS.... * inputs: secret label seed 20 * output: b5baf4722b91851a8816d22ebd8c1d8cc2e94d55 */ SLN_ERR(sln_prf(s, "label", strlen("label"), "secret", strlen("secret"), "seed", strlen("seed"), buf, sizeof(buf))); assert_memory_equal(buf, ssl_test_vector, 20); selene_destroy(s); selene_conf_destroy(conf); }
static selene_error_t* tok_copy_brigade_cb(sln_tok_value_t *v, void *baton_) { baton_t *baton = (baton_t *)baton_; if (baton->count == 0) { v->next = TOK_COPY_BRIGADE; v->wantlen = 4; } if (baton->count == 1) { char buf[4]; size_t len = sizeof(buf); v->next = TOK_DONE; SLN_ERR(sln_brigade_flatten(v->v.bb, &buf[0], &len)); assert_memory_equal(buf, "AAAA", 4); } baton->count++; return SELENE_SUCCESS; }
static void brigade_pread_more_buckets(void **state) { sln_brigade_t *bb; sln_bucket_t *e1; sln_bucket_t *e2; char buf[20]; size_t len = 0; SLN_ERR(sln_brigade_create(&bb)); SLN_ERR(sln_bucket_create_empty(&e1, 10)); SLN_BRIGADE_INSERT_TAIL(bb, e1); memset(e1->data, 'A', e1->size); SLN_ERR(sln_bucket_create_empty(&e2, 10)); SLN_BRIGADE_INSERT_TAIL(bb, e2); memset(e2->data, 'B', e2->size); SLN_ERR(sln_brigade_pread_bytes(bb, 9, 1, &buf[0], &len)); assert_int_equal(len, 1); assert_memory_equal(buf, "A", 1); SLN_ERR(sln_brigade_pread_bytes(bb, 11, 1, &buf[0], &len)); assert_int_equal(len, 1); assert_memory_equal(buf, "B", 1); SLN_ERR(sln_brigade_pread_bytes(bb, 9, 2, &buf[0], &len)); assert_int_equal(len, 2); assert_memory_equal(buf, "AB", 2); SLN_ERR(sln_brigade_pread_bytes(bb, 11, 2, &buf[0], &len)); assert_int_equal(len, 2); assert_memory_equal(buf, "BB", 2); SLN_ERR(sln_brigade_pread_bytes(bb, 0, 20, &buf[0], &len)); assert_int_equal(len, 20); assert_memory_equal(buf, "AAAAAAAAAABBBBBBBBBB", 20); sln_brigade_destroy(bb); }
static void tls_v2_hello(void **state) { selene_error_t *err; sln_parser_baton_t *baton; selene_conf_t *conf = NULL; selene_t *s = NULL; sln_bucket_t *e1; init_ctxt(state, &s, &conf); baton = (sln_parser_baton_t *)s->backend_baton; SLN_ERR(sln_bucket_create_copy_bytes(sln_test_alloc, &e1, (const char *)openssl_client_hello_sslv2, sizeof(openssl_client_hello_sslv2))); SLN_BRIGADE_INSERT_TAIL(s->bb.in_enc, e1); err = sln_io_tls_read(s, baton); /* TODO: successfully parse the sslv2 client hello... enough to know it was * sslv2. */ /* SLN_ASSERT(err == NULL); */ selene_error_clear(err); destroy_ctxt(state, s, conf); }
static void brigade_chomp(void **state) { sln_brigade_t *bb; sln_bucket_t *e1; char buf[20]; size_t len = 0; SLN_ERR(sln_brigade_create(sln_test_alloc, &bb)); SLN_ERR(sln_bucket_create_empty(sln_test_alloc, &e1, 10)); SLN_BRIGADE_INSERT_TAIL(bb, e1); memset(e1->data, 'A', e1->size); assert_int_equal(sln_brigade_size(bb), 10); SLN_ERR(sln_brigade_chomp(bb, 1)); assert_int_equal(sln_brigade_size(bb), 9); SLN_ERR(sln_brigade_chomp(bb, 8)); assert_int_equal(sln_brigade_size(bb), 1); sln_brigade_destroy(bb); SLN_ERR(sln_brigade_create(sln_test_alloc, &bb)); SLN_ERR(sln_bucket_create_empty(sln_test_alloc, &e1, 10)); SLN_BRIGADE_INSERT_TAIL(bb, e1); memset(e1->data, 'A', e1->size); SLN_ERR(sln_bucket_create_empty(sln_test_alloc, &e1, 10)); SLN_BRIGADE_INSERT_TAIL(bb, e1); memset(e1->data, 'B', e1->size); assert_int_equal(sln_brigade_size(bb), 20); SLN_ERR(sln_brigade_chomp(bb, 8)); assert_int_equal(sln_brigade_size(bb), 12); SLN_ERR(sln_brigade_pread_bytes(bb, 0, 4, &buf[0], &len)); assert_memory_equal(buf, "AABB", 4); SLN_ERR(sln_brigade_chomp(bb, 2)); assert_int_equal(sln_brigade_size(bb), 10); SLN_ERR(sln_brigade_pread_bytes(bb, 0, 4, &buf[0], &len)); assert_memory_equal(buf, "BBBB", 4); SLN_ERR(sln_brigade_chomp(bb, 2)); SLN_ERR(sln_brigade_pread_bytes(bb, 0, 8, &buf[0], &len)); assert_memory_equal(buf, "BBBBBBBB", 8); assert_int_equal(sln_brigade_size(bb), 8); sln_brigade_destroy(bb); }