/**
* 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;}
