/** * Report NTLM variable-length data test result * * @v msg Message header * @v msg_len Length of message * @v data Variable-length data descriptor * @v expected Expected message header * @v expected_data Expected variable-length data descriptor * @v field Field name * @v file Test code file * @v line Test code line */ static void ntlm_data_okx ( struct ntlm_header *msg, size_t msg_len, struct ntlm_data *data, struct ntlm_header *expected, struct ntlm_data *expected_data, const char *field, const char *file, unsigned int line ) { size_t offset; size_t len; void *raw; void *expected_raw; /* Verify data lies within message */ okx ( data->len == data->max_len, file, line ); offset = le32_to_cpu ( data->offset ); len = le16_to_cpu ( data->len ); okx ( offset <= msg_len, file, line ); okx ( len <= ( msg_len - offset ), file, line ); /* Verify content matches expected content */ raw = ( ( ( void * ) msg ) + offset ); expected_raw = ( ( ( void * ) expected ) + le32_to_cpu ( expected_data->offset ) ); DBGC ( msg, "NTLM %s expected:\n", field ); DBGC_HDA ( msg, 0, expected_raw, le16_to_cpu ( expected_data->len ) ); DBGC ( msg, "NTLM %s actual:\n", field ); DBGC_HDA ( msg, 0, raw, len ); okx ( data->len == expected_data->len, file, line ); okx ( memcmp ( raw, expected_raw, len ) == 0, file, line ); }
/** * Report server passphrase test result * * @v test Content information segment test * @v info Content information * @v pass Server passphrase * @v pass_len Length of server passphrase * @v file Test code file * @v line Test code line */ static void peerdist_info_passphrase_okx ( struct peerdist_info_segment_test *test, const struct peerdist_info *info, uint8_t *pass, size_t pass_len, const char *file, unsigned int line ) { struct digest_algorithm *digest = info->digest; uint8_t ctx[digest->ctxsize]; uint8_t secret[digest->digestsize]; uint8_t expected[digest->digestsize]; size_t digestsize = info->digestsize; size_t secretsize = digestsize; /* Calculate server secret */ digest_init ( digest, ctx ); digest_update ( digest, ctx, pass, pass_len ); digest_final ( digest, ctx, secret ); /* Calculate expected segment secret */ hmac_init ( digest, ctx, secret, &secretsize ); assert ( secretsize == digestsize ); hmac_update ( digest, ctx, test->expected_hash, digestsize ); hmac_final ( digest, ctx, secret, &secretsize, expected ); assert ( secretsize == digestsize ); /* Verify segment secret */ okx ( memcmp ( test->expected_secret, expected, digestsize ) == 0, file, line ); }
KDB_API K K_DECL testSerial(K a) { K k = kpn("000001.SZ", 9); //K s = b9(-1, k); K s = b9(1, k); for (G* i = kG(s); i < kG(s) + s->n; ++i) { std::cout << std::setiosflags(std::ios::uppercase) << std::setfill('0') << std::setw(2) << std::hex << static_cast<int>(*i) << ','; } std::cout << std::endl; # if KX_HAS_OKX std::cout << "okx = " << okx(s) << std::endl; # endif if (a->g) { r0(s); return k; } else { r0(k); return s; } }
/** * Report key generation test result * * @v test Key generation test * @v file Test code file * @v line Test code line */ static void ntlm_key_okx ( struct ntlm_key_test *test, const char *file, unsigned int line ) { struct ntlm_key key; ntlm_key ( test->domain, test->username, test->password, &key ); okx ( memcmp ( &key, &test->expected, sizeof ( key ) ) == 0, file, line ); }
/** * Report pixel buffer test result * * @v test Pixel buffer test * @v file Test code file * @v line Test code line */ void pixbuf_okx ( struct pixel_buffer_test *test, const char *file, unsigned int line ) { struct pixel_buffer *pixbuf; int rc; /* Sanity check */ assert ( ( test->width * test->height * sizeof ( test->data[0] ) ) == test->len ); /* Correct image data pointer */ test->image->data = virt_to_user ( ( void * ) test->image->data ); /* Check that image is detected as PNM */ okx ( image_probe ( test->image ) == 0, file, line ); okx ( test->image->type == test->type, file, line ); /* Check that a pixel buffer can be created from the image */ okx ( ( rc = image_pixbuf ( test->image, &pixbuf ) ) == 0, file, line ); if ( rc == 0 ) { /* Check pixel buffer dimensions */ okx ( pixbuf->width == test->width, file, line ); okx ( pixbuf->height == test->height, file, line ); /* Check pixel buffer data */ okx ( pixbuf->len == test->len, file, line ); okx ( memcmp_user ( pixbuf->data, 0, virt_to_user ( test->data ), 0, test->len ) == 0, file, line ); pixbuf_put ( pixbuf ); } }
/** * Report content information test result * * @v test Content information test * @v info Content information to fill in * @v file Test code file * @v line Test code line */ static void peerdist_info_okx ( struct peerdist_info_test *test, struct peerdist_info *info, const char *file, unsigned int line ) { /* Parse content information */ okx ( peerdist_info ( virt_to_user ( test->data ), test->len, info ) == 0, file, line ); /* Verify content information */ okx ( info->raw.data == virt_to_user ( test->data ), file, line ); okx ( info->raw.len == test->len, file, line ); okx ( info->digest == test->expected_digest, file, line ); okx ( info->digestsize == test->expected_digestsize, file, line ); okx ( info->trim.start >= info->range.start, file, line ); okx ( info->trim.start == test->expected_trim.start, file, line ); okx ( info->trim.end <= info->range.end, file, line ); okx ( info->trim.end == test->expected_trim.end, file, line ); okx ( info->segments == test->expected_segments, file, line ); }
/** * Report a profiling test result * * @v test Profiling test * @v file Test code file * @v line Test code line */ static void profile_okx ( struct profile_test *test, const char *file, unsigned int line ) { struct profiler profiler; unsigned long mean; unsigned long stddev; unsigned int i; /* Initialise profiler */ memset ( &profiler, 0, sizeof ( profiler ) ); /* Record sample values */ for ( i = 0 ; i < test->count ; i++ ) profile_update ( &profiler, test->samples[i] ); /* Check resulting statistics */ mean = profile_mean ( &profiler ); stddev = profile_stddev ( &profiler ); DBGC ( test, "PROFILE calculated mean %ld stddev %ld\n", mean, stddev ); okx ( mean == test->mean, file, line ); okx ( stddev == test->stddev, file, line ); }
// Data processor (executed within q's main thread) K invokeCallback(I socket) { static_assert(sizeof(::SOCKET) == sizeof(I), "SOCKET vs I: type mismatch!"); ::SOCKET sock = socket; assert(sock != INVALID_SOCKET); // Receive (WQID, len, serialized_K) from subscription thread # define RECV_CHECK(expectedSize, errorMsg) \ if (recvd != (expectedSize)) { \ std::cerr << "<recv> " << (errorMsg) << ": " << recvd << " < " << (expectedSize) << std::endl; \ return K_NIL; \ } ::WQID qid = 0; int recvd = ::recv(sock, reinterpret_cast<char*>(&qid), sizeof(::WQID), 0); RECV_CHECK(sizeof(::WQID), "WQID incomplete"); std::size_t len = 0; recvd = ::recv(sock, reinterpret_cast<char*>(&len), sizeof(len), 0); RECV_CHECK(sizeof(len), "size incomplete"); if (len > static_cast<std::size_t>(std::numeric_limits<int>::max())) { std::cerr << "<recv> serialized data (" << len << ") > 2G" << std::endl; return K_NIL; } q::K_ptr serialized(ktn(KB, len)); std::memset(kG(serialized.get()), 0, len); recvd = ::recv(sock, reinterpret_cast<char*>(kG(serialized.get())), len, 0); RECV_CHECK(len, "data incomplete"); # undef RECV_CHECK // Deserialize K object # if KX_USE_OKX //@ref https://groups.google.com/forum/#!topic/personal-kdbplus/pjsugT7590A if (!okx(serialized.get())) { std::cerr << "<recv> bad data: [" << util::hexBytes(kG(serialized.get()), static_cast<std::size_t>(serialized->n)) << ']' << std::endl; return K_NIL; } # endif q::K_ptr result(d9(serialized.get())); // Identify the origial query and callback std::string const callback = REGISTRY[qid]; if (callback.empty()) { std::cerr << "unknown WQID: " << qid << std::endl; return K_NIL; } static_assert(std::is_same<::WQID, J>::value, "WQID data type mismatch"); q::K_ptr output(k(0, const_cast<S>(callback.c_str()), kj(qid), result.release(), K_NIL)); if (output->t == -128) { std::cerr << "<q> '" << output->s << std::endl; } return output.release(); }
/** * Report content information segment test result * * @v test Content information segment test * @v info Content information * @v segment Segment information to fill in * @v file Test code file * @v line Test code line */ static void peerdist_info_segment_okx ( struct peerdist_info_segment_test *test, const struct peerdist_info *info, struct peerdist_info_segment *segment, const char *file, unsigned int line ) { size_t digestsize = info->digestsize; /* Parse content information segment */ okx ( peerdist_info_segment ( info, segment, test->index ) == 0, file, line ); /* Verify content information segment */ okx ( segment->info == info, file, line ); okx ( segment->index == test->index, file, line ); okx ( segment->range.start == test->expected_range.start, file, line ); okx ( segment->range.end == test->expected_range.end, file, line ); okx ( segment->blocks == test->expected_blocks, file, line ); okx ( segment->blksize == test->expected_blksize, file, line ); okx ( memcmp ( segment->hash, test->expected_hash, digestsize ) == 0, file, line ); okx ( memcmp ( segment->secret, test->expected_secret, digestsize ) == 0, file, line ); okx ( memcmp ( segment->id, test->expected_id, digestsize ) == 0, file, line ); }
/** * Report content information block test result * * @v test Content information block test * @v segment Segment information * @v block Block information to fill in * @v file Test code file * @v line Test code line */ static void peerdist_info_block_okx ( struct peerdist_info_block_test *test, const struct peerdist_info_segment *segment, struct peerdist_info_block *block, const char *file, unsigned int line ) { const struct peerdist_info *info = segment->info; size_t digestsize = info->digestsize; /* Parse content information block */ okx ( peerdist_info_block ( segment, block, test->index ) == 0, file, line ); /* Verify content information block */ okx ( block->segment == segment, file, line ); okx ( block->index == test->index, file, line ); okx ( block->range.start == test->expected_range.start, file, line ); okx ( block->range.end == test->expected_range.end, file, line ); okx ( memcmp ( block->hash, test->expected_hash, digestsize ) == 0, file, line ); }
/** * Report NTLM authentication test result * * @v test Authentication test * @v file Test code file * @v line Test code line */ static void ntlm_authenticate_okx ( struct ntlm_authenticate_test *test, const char *file, unsigned int line ) { struct ntlm_authenticate *expected = test->expected; struct ntlm_challenge_info info; struct ntlm_authenticate *auth; struct ntlm_key key; struct ntlm_lm_response lm; struct ntlm_nt_response nt; size_t len; /* Parse Challenge message */ okx ( ntlm_challenge ( test->challenge, test->challenge_len, &info ) == 0, file, line ); /* Generate key */ ntlm_key ( test->domain, test->username, test->password, &key ); /* Generate responses */ ntlm_response ( &info, &key, &test->nonce, &lm, &nt ); /* Allocate buffer for Authenticate message */ len = ntlm_authenticate_len ( &info, test->domain, test->username, test->workstation ); okx ( len >= sizeof ( *auth ), file, line ); auth = malloc ( len ); okx ( auth != NULL, file, line ); /* Construct Authenticate message */ okx ( ntlm_authenticate ( &info, test->domain, test->username, test->workstation, &lm, &nt, auth ) == len, file, line ); /* Verify header */ okx ( memcmp ( &auth->header, &expected->header, sizeof ( auth->header ) ) == 0, file, line ); /* Verify LAN Manager response */ ntlm_data_okx ( &auth->header, len, &auth->lm, &expected->header, &expected->lm, "LM", file, line ); /* Verify NT response */ ntlm_data_okx ( &auth->header, len, &auth->nt, &expected->header, &expected->nt, "NT", file, line ); /* Verify domain name */ ntlm_data_okx ( &auth->header, len, &auth->domain, &expected->header, &expected->domain, "domain", file, line ); /* Verify user name */ ntlm_data_okx ( &auth->header, len, &auth->user, &expected->header, &expected->user, "user", file, line ); /* Verify workstation name */ ntlm_data_okx ( &auth->header, len, &auth->workstation, &expected->header, &expected->workstation, "workstation",file, line ); /* Verify session key */ if ( auth->flags & NTLM_NEGOTIATE_KEY_EXCH ) { ntlm_data_okx ( &auth->header, len, &auth->session, &expected->header, &expected->session, "session", file, line ); } /* Free Authenticate message */ free ( auth ); }
K threads_init(K x) { unsigned char bytes[]={0x01,0x00,0x00,0x00,0x0a,0x00,0x00,0x00,0x65,0x13}; K s=ktn(KG,sizeof(bytes));memcpy(kG(s),bytes,sizeof(bytes)); if(!okx(s))R krr("serialization");value_fn=d9(s); if(!(threadpool=threadpool_create(NUMTHREADS,QUEUESIZE,0)))R krr("threadpool"); if(pipe(mainloop_pipe)==-1)R krr("pipe");sd1(mainloop_pipe[0],threads_q_callback);R(K)0;}