static
void dcrypt_gnutls_ctx_sym_set_key_iv_random(struct dcrypt_context_symmetric *ctx)
{
if(ctx->key.data != NULL) p_free(ctx->pool, ctx->key.data);
if(ctx->iv.data != NULL) p_free(ctx->pool, ctx->iv.data);
ctx->key.data = p_malloc(ctx->pool, gnutls_cipher_get_key_size(ctx->cipher));
random_fill(ctx->key.data, gnutls_cipher_get_key_size(ctx->cipher));
ctx->key.size = gnutls_cipher_get_key_size(ctx->cipher);
ctx->iv.data = p_malloc(ctx->pool, gnutls_cipher_get_iv_size(ctx->cipher));
random_fill(ctx->iv.data, gnutls_cipher_get_iv_size(ctx->cipher));
ctx->iv.size = gnutls_cipher_get_iv_size(ctx->cipher);
}
static void test_buffer(skiatest::Reporter* reporter) {
SkRandom rand;
SkAutoMalloc am(MAX_SIZE * 2);
char* storage = (char*)am.get();
char* storage2 = storage + MAX_SIZE;
random_fill(rand, storage, MAX_SIZE);
for (int sizeTimes = 0; sizeTimes < 100; sizeTimes++) {
int size = rand.nextU() % MAX_SIZE;
if (size == 0) {
size = MAX_SIZE;
}
for (int times = 0; times < 100; times++) {
int bufferSize = 1 + (rand.nextU() & 0xFFFF);
SkMemoryStream mstream(storage, size);
SkBufferStream bstream(&mstream, bufferSize);
int bytesRead = 0;
while (bytesRead < size) {
int s = 17 + (rand.nextU() & 0xFFFF);
int ss = bstream.read(storage2, s);
REPORTER_ASSERT(reporter, ss > 0 && ss <= s);
REPORTER_ASSERT(reporter, bytesRead + ss <= size);
REPORTER_ASSERT(reporter,
memcmp(storage + bytesRead, storage2, ss) == 0);
bytesRead += ss;
}
REPORTER_ASSERT(reporter, bytesRead == size);
}
}
}
int main()
{
random_fill(0,0x7fffffff,6,list0,list1,list2,list3,list4,list5);
//random_fill(0,N,6,list0,list1,list2,list3,list4,list5);
test_sort(list0,0,N-1,"my quick_sort_0",quick_sort_0);
test_sort(list1,0,N-1,"my quick_sort_1",quick_sort_1);
test_sort(list2,0,N-1,"other_quick_sort_0",other_quick_sort_0);
test_sort(list3,0,N-1,"other eq_sort",eq_sort);
// test_sort(list3,0,N-1,"clib_quick_sort",clib_quick_sort);
test_sort1(list4,0,N-1,"other bq_sort",bq_sort);
test_sort1(list5,0,N-1,"my quick_sort_2",quick_sort_2);
return 0;
}
static string_t *get_digest_challenge(struct digest_auth_request *request)
{
const struct auth_settings *set = request->auth_request.set;
buffer_t buf;
string_t *str;
const char *const *tmp;
unsigned char nonce[16];
unsigned char nonce_base64[MAX_BASE64_ENCODED_SIZE(sizeof(nonce))+1];
int i;
bool first_qop;
/*
realm="hostname" (multiple allowed)
nonce="randomized data, at least 64bit"
qop="auth,auth-int,auth-conf"
maxbuf=number (with auth-int, auth-conf, defaults to 64k)
charset="utf-8" (iso-8859-1 if it doesn't exist)
algorithm="md5-sess"
cipher="3des,des,rc4-40,rc4,rc4-56" (with auth-conf)
*/
/* get 128bit of random data as nonce */
random_fill(nonce, sizeof(nonce));
buffer_create_from_data(&buf, nonce_base64, sizeof(nonce_base64));
base64_encode(nonce, sizeof(nonce), &buf);
buffer_append_c(&buf, '\0');
request->nonce = p_strdup(request->pool, buf.data);
str = t_str_new(256);
if (*set->realms_arr == NULL) {
/* If no realms are given, at least Cyrus SASL client defaults
to destination host name */
str_append(str, "realm=\"\",");
} else {
for (tmp = set->realms_arr; *tmp != NULL; tmp++)
str_printfa(str, "realm=\"%s\",", *tmp);
}
str_printfa(str, "nonce=\"%s\",", request->nonce);
str_append(str, "qop=\""); first_qop = TRUE;
for (i = 0; i < QOP_COUNT; i++) {
if (request->qop & (1 << i)) {
if (first_qop)
first_qop = FALSE;
else
str_append_c(str, ',');
str_append(str, qop_names[i]);
}
}
str_append(str, "\",");
str_append(str, "charset=\"utf-8\","
"algorithm=\"md5-sess\"");
return str;
}
static void oracle(const byteblock *prefix, const byteblock *secret, byteblock *out)
{
uint8_t key[16];
random_fill(key, sizeof key);
out->len = prefix->len + secret->len;
memcpy(out->buf, prefix->buf, prefix->len);
memcpy(out->buf + prefix->len, secret->buf, secret->len);
rc4(key, sizeof key, out->buf, out->len);
}
void random_init(void)
{
unsigned int seed;
if (RAND_status() == 0) {
i_fatal("Random generator not initialized: "
"Install egd on /var/run/egd-pool");
}
random_fill(&seed, sizeof(seed));
rand_set_seed(seed);
}
static void
block_rw_write (int fd, char *out, size_t pos, size_t size)
{
ssize_t n;
random_fill (out + pos, size);
block_rw_lseek (fd, pos);
n = write (fd, out + pos, size);
rtems_test_assert (n == (ssize_t) size);
}
static void
block_rw_write_cont (int fd, char *out, size_t *pos, size_t size)
{
ssize_t n;
random_fill (out + *pos, size);
n = write (fd, out + *pos, size);
rtems_test_assert (n == (ssize_t) size);
*pos += size;
}
const char *password_generate_salt(size_t len)
{
unsigned int i;
char *salt;
salt = t_malloc_no0(len + 1);
random_fill(salt, len);
for (i = 0; i < len; i++)
salt[i] = salt_chars[salt[i] % (sizeof(salt_chars)-1)];
salt[len] = '\0';
return salt;
}
static
void test_write_read_v2(void)
{
test_begin("test_write_read_v2");
unsigned char payload[IO_BLOCK_SIZE*10];
const unsigned char *ptr;
size_t pos = 0, siz;
random_fill(payload, IO_BLOCK_SIZE*10);
buffer_t *buf = buffer_create_dynamic(default_pool, sizeof(payload));
struct ostream *os = o_stream_create_buffer(buf);
struct ostream *os_2 = o_stream_create_encrypt(os, "aes-256-gcm-sha256", test_v1_kp.pub, IO_STREAM_ENC_INTEGRITY_AEAD);
o_stream_nsend(os_2, payload, sizeof(payload));
test_assert(o_stream_finish(os_2) > 0);
if (os_2->stream_errno != 0)
i_debug("error: %s", o_stream_get_error(os_2));
o_stream_unref(&os);
o_stream_unref(&os_2);
struct istream *is = test_istream_create_data(buf->data, buf->used);
/* test regression where read fails due to incorrect behaviour
when buffer is full before going to decrypt code */
i_stream_set_max_buffer_size(is, 8192);
i_stream_read(is);
struct istream *is_2 = i_stream_create_decrypt(is, test_v1_kp.priv);
size_t offset = 0;
test_istream_set_size(is, 0);
test_istream_set_allow_eof(is, FALSE);
while(i_stream_read_data(is_2, &ptr, &siz, 0)>=0) {
if (offset == buf->used)
test_istream_set_allow_eof(is, TRUE);
else
test_istream_set_size(is, ++offset);
test_assert_idx(pos + siz <= sizeof(payload), pos);
if (pos + siz > sizeof(payload)) break;
test_assert_idx(siz == 0 || memcmp(ptr, payload + pos, siz) == 0, pos);
i_stream_skip(is_2, siz); pos += siz;
}
test_assert(is_2->stream_errno == 0);
if (is_2->stream_errno != 0)
i_debug("error: %s", i_stream_get_error(is_2));
i_stream_unref(&is);
i_stream_unref(&is_2);
buffer_free(&buf);
test_end();
}
static const char *get_cram_challenge(void)
{
unsigned char buf[17];
size_t i;
random_fill(buf, sizeof(buf)-1);
for (i = 0; i < sizeof(buf)-1; i++)
buf[i] = (buf[i] % 10) + '0';
buf[sizeof(buf)-1] = '\0';
return t_strdup_printf("<%s.%s@%s>", (const char *)buf,
dec2str(ioloop_time), my_hostname);
}
static
void test_write_read_v1_short(void)
{
test_begin("test_write_read_v1_short");
unsigned char payload[1];
const unsigned char *ptr;
size_t pos = 0, siz;
random_fill(payload, 1);
buffer_t *buf = buffer_create_dynamic(default_pool, 64);
struct ostream *os = o_stream_create_buffer(buf);
struct ostream *os_2 = o_stream_create_encrypt(os, "<unused>", test_v2_kp.pub, IO_STREAM_ENC_VERSION_1);
o_stream_nsend(os_2, payload, sizeof(payload));
if (os_2->stream_errno != 0)
i_debug("error: %s", o_stream_get_error(os_2));
test_assert(os_2->stream_errno == 0);
test_assert(o_stream_finish(os_2) > 0);
test_assert(os_2->stream_errno == 0);
o_stream_unref(&os);
o_stream_unref(&os_2);
struct istream *is = test_istream_create_data(buf->data, buf->used);
struct istream *is_2 = i_stream_create_decrypt(is, test_v2_kp.priv);
size_t offset = 0;
test_istream_set_allow_eof(is, FALSE);
test_istream_set_size(is, 0);
while(i_stream_read_data(is_2, &ptr, &siz, 0)>=0) {
if (offset == buf->used)
test_istream_set_allow_eof(is, TRUE);
else
test_istream_set_size(is, ++offset);
test_assert_idx(pos + siz <= sizeof(payload), pos);
if (siz > sizeof(payload) || pos + siz > sizeof(payload)) break;
test_assert_idx(siz == 0 || memcmp(ptr, payload + pos, siz) == 0, pos);
i_stream_skip(is_2, siz); pos += siz;
}
test_assert(is_2->stream_errno == 0);
i_stream_unref(&is);
i_stream_unref(&is_2);
buffer_free(&buf);
test_end();
}
void auth_token_init(void)
{
const char *secret_path =
t_strconcat(global_auth_settings->base_dir, "/",
AUTH_TOKEN_SECRET_FNAME, NULL);
if (auth_token_read_secret(secret_path, auth_token_secret) < 0) {
random_fill(auth_token_secret, sizeof(auth_token_secret));
if (auth_token_write_secret(secret_path, auth_token_secret) < 0) {
i_error("Failed to write auth token secret file; "
"returned tokens will be invalid once auth restarts");
}
}
}
int main()
{
int i;
for(i=10; i--;)
{
random_fill(A,size,i);
slow_way(R0,A,size/2);
fast_way(R1,A,size/2);
if( (R0[0] != R1[0]) || (R0[1] != R1[1]) || (R0[2] != R1[2]) )
assert(0);
fazt_way(R2,A,size/2);
if( (R0[0] != R2[0]) || (R0[1] != R2[1]) || (R0[2] != R2[2]) )
assert(0);
}
printf("Test passed\n");
}
void vogl_tracked_free(const char *pFile_line, void *p)
{
if (!p)
return;
if (reinterpret_cast<ptr_bits_t>(p) & (VOGL_MIN_ALLOC_ALIGNMENT - 1))
{
vogl_mem_error("vogl_free: bad ptr", pFile_line);
return;
}
#if VOGL_SCRUB_FREED_MEMORY
random_fill(p, msize_block(p, pFile_line));
#endif
free_block(p, pFile_line);
}
void auth_client_connection_create(struct auth *auth, int fd,
bool login_requests, bool token_auth)
{
static unsigned int connect_uid_counter = 0;
struct auth_client_connection *conn;
const char *mechanisms;
string_t *str;
conn = i_new(struct auth_client_connection, 1);
conn->auth = auth;
conn->refcount = 1;
conn->connect_uid = ++connect_uid_counter;
conn->login_requests = login_requests;
conn->token_auth = token_auth;
random_fill(conn->cookie, sizeof(conn->cookie));
conn->fd = fd;
conn->input = i_stream_create_fd(fd, AUTH_CLIENT_MAX_LINE_LENGTH);
conn->output = o_stream_create_fd(fd, (size_t)-1);
o_stream_set_no_error_handling(conn->output, TRUE);
o_stream_set_flush_callback(conn->output, auth_client_output, conn);
conn->io = io_add(fd, IO_READ, auth_client_input, conn);
DLLIST_PREPEND(&auth_client_connections, conn);
if (token_auth) {
mechanisms = t_strconcat("MECH\t",
mech_dovecot_token.mech_name, "\n", NULL);
} else {
mechanisms = str_c(auth->reg->handshake);
}
str = t_str_new(128);
str_printfa(str, "VERSION\t%u\t%u\n%sSPID\t%s\nCUID\t%u\nCOOKIE\t",
AUTH_CLIENT_PROTOCOL_MAJOR_VERSION,
AUTH_CLIENT_PROTOCOL_MINOR_VERSION,
mechanisms, my_pid, conn->connect_uid);
binary_to_hex_append(str, conn->cookie, sizeof(conn->cookie));
str_append(str, "\nDONE\n");
if (o_stream_send(conn->output, str_data(str), str_len(str)) < 0)
auth_client_disconnected(&conn);
}
void time_svd(std::size_t sz1, std::size_t sz2)
{
std::vector<ScalarType> in(sz1 * sz2);
random_fill(in);
viennacl::matrix<ScalarType> Ai(sz1, sz2), QL(sz1, sz1), QR(sz2, sz2);
viennacl::fast_copy(&in[0], &in[0] + in.size(), Ai);
Timer timer;
timer.start();
viennacl::linalg::svd(Ai, QL, QR);
viennacl::backend::finish();
double time_spend = timer.get();
printf("[%dx%d] time = %.6f\n", static_cast<int>(sz1), static_cast<int>(sz2), time_spend);
}
int main(int argc, char **argv) {
int len = 10;
if (argc > 1)
len = atoi(argv[1]);
if (len < 10) len = 10;
char *t = malloc(len + 1);
if (len == 10)
memcpy(t, "aabaaabcaab", 10);
else
random_fill(t, len);
t[len] = '\0';
int *z;
fundamental(t, len, &z);
inspect(z, len);
inspect_c(t, len);
free(z);
return 0;
}
/********************************************************
* main: implement find_largest() function
********************************************************/
int main(void)
{
PRINT_FILE_INFO
int *lrg_ptr; /* stores index to largest element within a[] */
int a[MAX];
random_fill(MAX, a, MAX);
for(int i = 0; i < MAX; ++i)
printf("a[%d]: %d\n%s", i, a[i], i == MAX -1 ? "\n" : "");
lrg_ptr = find_largest(a, MAX);
printf("*lrg_ptr:\t %02d\n\n", *lrg_ptr);
printf("lrg_ptr: %ld, &a[0]: %ld, a: %ld\n", lrg_ptr, &a[0], a);
printf("lrg_ptr - &a[0]: %02ld\n", lrg_ptr - &a[0]);
printf("lrg_ptr - a[0]:\t %02ld\n", lrg_ptr - a);
return 0;
}
void random_init(void)
{
unsigned int seed;
if (init_refcount++ > 0)
return;
urandom_fd = open(DEV_URANDOM_PATH, O_RDONLY);
if (urandom_fd == -1) {
if (errno == ENOENT) {
i_fatal(DEV_URANDOM_PATH" doesn't exist, "
"currently we require it");
} else {
i_fatal("Can't open "DEV_URANDOM_PATH": %m");
}
}
random_fill(&seed, sizeof(seed));
rand_set_seed(seed);
fd_close_on_exec(urandom_fd, TRUE);
}
void *vogl_tracked_malloc(const char *pFile_line, size_t size, size_t *pActual_size)
{
size = (size + sizeof(uint32) - 1U) & ~(sizeof(uint32) - 1U);
if (!size)
size = sizeof(uint32);
if (size > VOGL_MAX_POSSIBLE_HEAP_BLOCK_SIZE)
{
vogl_mem_error("vogl_malloc: size too big", pFile_line);
return NULL;
}
uint8 *p_new = (uint8 *)malloc_block(size, pFile_line);
VOGL_ASSERT((reinterpret_cast<ptr_bits_t>(p_new) & (VOGL_MIN_ALLOC_ALIGNMENT - 1)) == 0);
if (!p_new)
{
vogl_mem_error("vogl_malloc: out of memory", pFile_line);
return NULL;
}
if (pActual_size)
{
*pActual_size = msize_block(p_new, pFile_line);
if ((size) && (*pActual_size >= static_cast<uint64_t>(size) * 16U))
{
// I've seen this happen with glibc's absolutely terrible debug heap crap, best to let the caller know that shit is going to die
fprintf(stderr, "%s: malloc_usable_size may be misbehaving! Requested %zu bytes, but the usable size is reported as %zu bytes.\n", __FUNCTION__, size, *pActual_size);
}
}
#if VOGL_RAND_FILL_ALLLOCATED_MEMORY
random_fill(p_new, size);
#endif
return p_new;
}
int imap_urlauth_fetch_parsed(struct imap_urlauth_context *uctx,
struct imap_url *url,
struct imap_msgpart_url **mpurl_r,
enum mail_error *error_code_r,
const char **error_r)
{
struct mail_user *user = uctx->user;
struct imap_msgpart_url *mpurl;
struct mailbox *box;
const char *error;
unsigned char mailbox_key[IMAP_URLAUTH_KEY_LEN];
int ret;
*mpurl_r = NULL;
*error_r = NULL;
*error_code_r = MAIL_ERROR_NONE;
/* check urlauth mechanism, access, userid and authority */
if (!imap_urlauth_check(uctx, url, FALSE, error_r)) {
*error_code_r = MAIL_ERROR_PARAMS;
return 0;
}
/* validate target user */
if (user->anonymous || strcmp(url->userid, user->username) != 0) {
*error_r = t_strdup_printf("Not permitted to fetch URLAUTH for user %s",
url->userid);
*error_code_r = MAIL_ERROR_PARAMS;
return 0;
}
/* validate mailbox */
if ((ret = imap_msgpart_url_create(user, url, &mpurl, &error)) < 0) {
*error_r = t_strdup_printf("Invalid URLAUTH: %s", error);
*error_code_r = MAIL_ERROR_PARAMS;
return ret;
}
if ((ret = imap_msgpart_url_open_mailbox(mpurl, &box, error_code_r,
&error)) < 0) {
*error_r = "Internal server error";
imap_msgpart_url_free(&mpurl);
return -1;
}
if (ret == 0) {
/* RFC says: `If the mailbox cannot be identified, an
authorization token is calculated on the rump URL, using
random "plausible" keys (selected by the server) as needed,
before returning a validation failure. This prevents timing
attacks aimed at identifying mailbox names.' */
random_fill(mailbox_key, sizeof(mailbox_key));
(void)imap_urlauth_internal_verify(url->uauth_rumpurl,
mailbox_key, url->uauth_token, url->uauth_token_size);
*error_r = t_strdup_printf("Invalid URLAUTH: %s", error);
imap_msgpart_url_free(&mpurl);
return 0;
}
/* obtain mailbox key */
ret = imap_urlauth_backend_get_mailbox_key(box, FALSE, mailbox_key,
error_r, error_code_r);
if (ret < 0) {
imap_msgpart_url_free(&mpurl);
return -1;
}
if (ret == 0 ||
!imap_urlauth_internal_verify(url->uauth_rumpurl, mailbox_key,
url->uauth_token,
url->uauth_token_size)) {
*error_r = "URLAUTH verification failed";
*error_code_r = MAIL_ERROR_PERM;
imap_msgpart_url_free(&mpurl);
ret = 0;
} else {
ret = 1;
}
safe_memset(mailbox_key, 0, sizeof(mailbox_key));
*mpurl_r = mpurl;
return ret;
}
int main(int argc, char **argv) {
tap_n((3+5)*4 + (2+5)*2 + (2+5));
if (argc > 1) {
long s = atol(argv[1]);
init_by_array((uint32_t*)&s, sizeof s / sizeof(uint32_t));
} else {
time_t s = time(NULL);
init_by_array((uint32_t*)&s, sizeof s / sizeof(uint32_t));
}
void *data = malloc(DATA_LEN);
random_fill(data, DATA_LEN);
const size_t codepoints = DATA_LEN * CHAR_BIT / 21;
const mushcell pos = MUSHCELL_MAX - WRAP_AFTER;
mushcoords beg = MUSHCOORDS(pos,pos,pos), end;
void *space_buf = malloc(mushspace_sizeof);
mushspace *space;
bool ok;
mushbounds bounds, expected_loose, expected_tight;
size_t spaces_beg, spaces_end;
codepoint_reader cp_reader;
#define BOUNDS_CHECK \
mushspace_get_loose_bounds(space, &bounds); \
\
tap_leqcos(bounds.beg, expected_loose.beg, \
"get_loose_bounds reports appropriate beg", \
"get_loose_bounds reports too large beg"); \
tap_geqcos(bounds.end, expected_loose.end, \
"get_loose_bounds reports appropriate end", \
"get_loose_bounds reports too small end"); \
\
ok = mushspace_get_tight_bounds(space, &bounds); \
tap_bool(ok, "get_tight_bounds says that the space is nonempty", \
"get_tight_bounds says that the space is empty"); \
\
tap_eqcos(bounds.beg, expected_tight.beg, \
"get_tight_bounds reports correct beg", \
"get_tight_bounds reports incorrect beg"); \
tap_eqcos(bounds.end, expected_tight.end, \
"get_tight_bounds reports correct end", \
"get_tight_bounds reports incorrect end"); \
#define LOAD_STRING(suf, T, ENCODER, BLOWUP, FOREACH_CP) \
space = mushspace_init(space_buf, NULL); \
if (!space) { \
tap_not_ok("init returned null"); \
tap_skip_remaining("init failed"); \
return 1; \
} \
tap_ok("init succeeded"); \
\
T *encoded_data##suf = (T*)data; \
size_t encoded_len##suf = DATA_LEN / sizeof *encoded_data##suf; \
if (BLOWUP) { \
encoded_data##suf = \
malloc((codepoints * BLOWUP) * sizeof *encoded_data##suf); \
encoded_len##suf = ENCODER(data, encoded_data##suf, codepoints); \
} \
\
mushspace_load_string##suf( \
space, encoded_data##suf, encoded_len##suf, &end, beg, true); \
\
if (BLOWUP) \
free(encoded_data##suf); \
\
size_t ii##suf = 0; \
mushcell cp##suf; \
\
spaces_beg = 0; \
spaces_end = 0; \
\
FOREACH_CP(suf) { \
if (ii##suf <= WRAP_AFTER) { \
if (cp##suf == ' ') \
++spaces_end; \
else \
spaces_end = 0; \
continue; \
} \
if (cp##suf == ' ') \
++spaces_beg; \
else \
break; \
} \
\
expected_loose.beg = expected_tight.beg = \
MUSHCOORDS(MUSHCELL_MIN, beg.y, beg.z); \
expected_loose.end = expected_tight.end = \
MUSHCOORDS(MUSHCELL_MAX, beg.y, beg.z); \
\
expected_loose.beg.x = expected_tight.beg.x += spaces_beg; \
expected_loose.end.x = expected_tight.end.x -= spaces_end; \
\
tap_eqcos(end, expected_tight.end, \
"load_string" #suf " reports correct end", \
"load_string" #suf " reports incorrect end"); \
\
ok = true; \
FOREACH_CP(suf) { \
mushcell gc = \
mushspace_get(space, mushcoords_add(beg, MUSHCOORDS(ii##suf,0,0))); \
if (gc == cp##suf) \
continue; \
ok = false; \
tap_not_ok("get doesn't match data given to load_string" #suf); \
printf(" ---\n" \
" failed index: %zu\n" \
" expected: %" MUSHCELL_PRIx "\n" \
" got: %" MUSHCELL_PRIx "\n" \
" ...\n", \
ii##suf, cp##suf, gc); \
break; \
} \
if (ok) \
tap_ok("get matches data given to load_string" #suf); \
\
BOUNDS_CHECK; \
mushspace_free(space);
#define DIRECT_FOREACH_CP(s) \
ii##s = 0; \
for (; ii##s < encoded_len##s && (cp##s = encoded_data##s[ii##s], true); \
++ii##s)
#define READER_FOREACH_CP(s) \
cp_reader = make_codepoint_reader(data, codepoints); \
for (ii##s = 0; (cp##s = next_codepoint(&cp_reader)) != UINT32_MAX; ++ii##s)
LOAD_STRING(, unsigned char, dummy, 0, DIRECT_FOREACH_CP);
LOAD_STRING(_cell, mushcell, dummy, 0, DIRECT_FOREACH_CP);
LOAD_STRING(_utf8, uint8_t, encode_utf8, 4, READER_FOREACH_CP);
LOAD_STRING(_utf16, uint16_t, encode_utf16, 2, READER_FOREACH_CP);
const mushcell *data_cell = (const mushcell*)data;
const size_t data_cell_count = DATA_LEN / sizeof *data_cell;
spaces_beg = 0;
spaces_end = 0;
for (size_t i = WRAP_AFTER+1; i < data_cell_count && data_cell[i++] == ' ';)
++spaces_beg;
for (size_t i = WRAP_AFTER+1; i-- > 0 && data_cell[i] == ' ';)
++spaces_end;
expected_loose.beg = expected_tight.beg =
MUSHCOORDS(MUSHCELL_MIN, beg.y, beg.z);
expected_loose.end = expected_tight.end =
MUSHCOORDS(MUSHCELL_MAX, beg.y, beg.z);
expected_loose.beg.x = expected_tight.beg.x += spaces_beg;
expected_loose.end.x = expected_tight.end.x -= spaces_beg;
#define PUT(FOREACH_CELL, S) \
space = mushspace_init(space_buf, NULL); \
if (!space) { \
tap_not_ok("init returned null"); \
tap_skip_remaining("init failed"); \
return 1; \
} \
tap_ok("init succeeded"); \
FOREACH_CELL { \
mushspace_put(space, mushcoords_add(beg, MUSHCOORDS(i, 0, 0)), \
data_cell[i]); \
} \
\
ok = true; \
for (size_t i = 0; i < data_cell_count; ++i) { \
mushcell dc = data_cell[i], \
gc = mushspace_get(space, \
mushcoords_add(beg, MUSHCOORDS(i, 0, 0))); \
if (gc == dc) \
continue; \
ok = false; \
tap_not_ok("get doesn't match what was put" S); \
printf(" ---\n" \
" failed index: %zu\n" \
" expected: %" MUSHCELL_PRIx "\n" \
" got: %" MUSHCELL_PRIx "\n" \
" ...\n", \
i, dc, gc); \
break; \
} \
if (ok) \
tap_ok("get matches what was put" S); \
\
BOUNDS_CHECK;
#define FORWARD for (size_t i = 0; i < data_cell_count; ++i)
#define REVERSE for (size_t i = data_cell_count; i--;)
PUT(FORWARD, " (forward order)");
mushspace_free(space);
PUT(REVERSE, " (reverse order)");
if (!ok) {
tap_skip_remaining("won't copy bad space");
return 1;
}
void *space_buf2 = malloc(mushspace_sizeof);
mushspace *space2 = mushspace_copy(space_buf2, space, NULL);
mushspace_free(space);
free(space_buf);
space = space2;
if (!space) {
tap_not_ok("copy returned null");
tap_skip_remaining("copy failed");
return 1;
}
tap_ok("copy succeeded");
ok = true;
for (size_t i = 0; i < DATA_LEN / sizeof *data_cell; ++i) {
mushcell dc = data_cell[i],
gc = mushspace_get(space,
mushcoords_add(beg, MUSHCOORDS(i, 0, 0)));
if (gc == dc)
continue;
ok = false;
tap_not_ok("get in copy doesn't match data");
printf(" ---\n"
" failed index: %zu\n"
" expected: %" MUSHCELL_PRIx "\n"
" got: %" MUSHCELL_PRIx "\n"
" ...\n",
i, dc, gc);
break;
}
if (ok)
tap_ok("get in copy matched data");
BOUNDS_CHECK;
free(data);
mushspace_free(space);
free(space_buf2);
}
static
int o_stream_encrypt_keydata_create_v2(struct encrypt_ostream *stream, const char *malg)
{
const struct hash_method *hash = hash_method_lookup(malg);
const char *error;
size_t tagsize;
const unsigned char *ptr;
size_t kl;
unsigned int val;
buffer_t *keydata, *res;
if (hash == NULL) {
io_stream_set_error(&stream->ostream.iostream,
"Encryption init error: Hash algorithm '%s' not supported", malg);
return -1;
}
/* key data length for internal use */
if ((stream->flags & IO_STREAM_ENC_INTEGRITY_HMAC) == IO_STREAM_ENC_INTEGRITY_HMAC) {
tagsize = IOSTREAM_TAG_SIZE;
} else if ((stream->flags & IO_STREAM_ENC_INTEGRITY_AEAD) == IO_STREAM_ENC_INTEGRITY_AEAD) {
tagsize = IOSTREAM_TAG_SIZE;
} else {
/* do not include MAC */
tagsize = 0;
}
/* generate keydata length of random data for key/iv/mac */
kl = dcrypt_ctx_sym_get_key_length(stream->ctx_sym) + dcrypt_ctx_sym_get_iv_length(stream->ctx_sym) + tagsize;
keydata = buffer_create_dynamic(pool_datastack_create(), kl);
random_fill(buffer_append_space_unsafe(keydata, kl), kl);
buffer_set_used_size(keydata, kl);
ptr = keydata->data;
res = buffer_create_dynamic(default_pool, 256);
/* store number of public key(s) */
buffer_append(res, "\1", 1); /* one key for now */
/* we can do multiple keys at this point, but do it only once now */
if (o_stream_encrypt_key_for_pubkey_v2(stream, malg, ptr, kl, stream->pub, res) != 0) {
buffer_free(&res);
return -1;
}
/* create hash of the key data */
unsigned char hctx[hash->context_size];
unsigned char hres[hash->digest_size];
hash->init(hctx);
hash->loop(hctx, ptr, kl);
hash->result(hctx, hres);
for(int i = 1; i < 2049; i++) {
uint32_t i_msb = htonl(i);
hash->init(hctx);
hash->loop(hctx, hres, sizeof(hres));
hash->loop(hctx, &i_msb, sizeof(i_msb));
hash->result(hctx, hres);
}
/* store key data hash */
val = htonl(sizeof(hres));
buffer_append(res, &val, 4);
buffer_append(res, hres, sizeof(hres));
/* pick up key data that goes into stream */
stream->key_data_len = res->used;
stream->key_data = buffer_free_without_data(&res);
/* prime contexts */
dcrypt_ctx_sym_set_key(stream->ctx_sym, ptr, dcrypt_ctx_sym_get_key_length(stream->ctx_sym));
ptr += dcrypt_ctx_sym_get_key_length(stream->ctx_sym);
dcrypt_ctx_sym_set_iv(stream->ctx_sym, ptr, dcrypt_ctx_sym_get_iv_length(stream->ctx_sym));
ptr += dcrypt_ctx_sym_get_iv_length(stream->ctx_sym);
if ((stream->flags & IO_STREAM_ENC_INTEGRITY_HMAC) == IO_STREAM_ENC_INTEGRITY_HMAC) {
dcrypt_ctx_hmac_set_key(stream->ctx_mac, ptr, tagsize);
dcrypt_ctx_hmac_init(stream->ctx_mac, &error);
} else if ((stream->flags & IO_STREAM_ENC_INTEGRITY_AEAD) == IO_STREAM_ENC_INTEGRITY_AEAD) {
dcrypt_ctx_sym_set_aad(stream->ctx_sym, ptr, tagsize);
}
/* clear out private key data */
safe_memset(buffer_get_modifiable_data(keydata, 0), 0, keydata->used);
if (!dcrypt_ctx_sym_init(stream->ctx_sym, &error)) {
io_stream_set_error(&stream->ostream.iostream, "Encryption init error: %s", error);
return -1;
}
return 0;
}
int main() {
cl_int status;
srand(time(NULL));
cl_platform_id platform;
CHECK_STATUS(clGetPlatformIDs(1, &platform, NULL));
cl_device_id device;
CHECK_STATUS(clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 1, &device, NULL));
cl_context context = clCreateContext(NULL, 1, &device, NULL, NULL, &status);
CHECK_STATUS(status);
cl_command_queue queue = clCreateCommandQueue(context, device, 0, &status);
CHECK_STATUS(status);
char* source = read_source("find_minimum.cl");
cl_program program = clCreateProgramWithSource(context, 1,
(const char**)&source, NULL, NULL);
CHECK_STATUS(status);
free(source);
CHECK_STATUS(clBuildProgram(program, 0, NULL, NULL, NULL, NULL));
cl_kernel kernel = clCreateKernel(program, "find_minimum", &status);
CHECK_STATUS(status);
cl_float values[NUM_VALUES];
random_fill(values, NUM_VALUES);
cl_mem valuesBuffer = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
sizeof(cl_float) * NUM_VALUES, values, &status);
CHECK_STATUS(status);
cl_mem resultBuffer = clCreateBuffer(context, CL_MEM_WRITE_ONLY,
sizeof(cl_float), NULL, &status);
CHECK_STATUS(status);
CHECK_STATUS(clSetKernelArg(kernel, 0, sizeof(cl_mem), &valuesBuffer));
CHECK_STATUS(clSetKernelArg(kernel, 1, sizeof(cl_mem), &resultBuffer));
// START:allocatelocal
CHECK_STATUS(clSetKernelArg(kernel, 2, sizeof(cl_float) * NUM_VALUES, NULL));
// END:allocatelocal
size_t work_units[] = {NUM_VALUES};
CHECK_STATUS(clEnqueueNDRangeKernel(queue, kernel, 1, NULL, work_units,
work_units, 0, NULL, NULL));
cl_float result;
CHECK_STATUS(clEnqueueReadBuffer(queue, resultBuffer, CL_TRUE, 0, sizeof(cl_float),
&result, 0, NULL, NULL));
CHECK_STATUS(clReleaseMemObject(resultBuffer));
CHECK_STATUS(clReleaseMemObject(valuesBuffer));
CHECK_STATUS(clReleaseKernel(kernel));
CHECK_STATUS(clReleaseProgram(program));
CHECK_STATUS(clReleaseCommandQueue(queue));
CHECK_STATUS(clReleaseContext(context));
// START:sequential
cl_float acc = FLT_MAX;
for (int i = 0; i < NUM_VALUES; ++i)
acc = fmin(acc, values[i]);
// END:sequential
if (acc != result)
fprintf(stderr, "Error: %f != %f", acc, result);
return 0;
}
Blob encryptECIES (const openssl::ec_key& secretKey, const openssl::ec_key& publicKey, Blob const& plaintext)
{
ECIES_ENC_IV_TYPE iv;
random_fill (iv.begin (), ECIES_ENC_BLK_SIZE);
ECIES_ENC_KEY_TYPE secret;
ECIES_HMAC_KEY_TYPE hmacKey;
getECIESSecret (secretKey, publicKey, secret, hmacKey);
ECIES_HMAC_TYPE hmac = makeHMAC (hmacKey, plaintext);
hmacKey.zero ();
EVP_CIPHER_CTX ctx;
EVP_CIPHER_CTX_init (&ctx);
if (EVP_EncryptInit_ex (&ctx, ECIES_ENC_ALGO, nullptr, secret.begin (), iv.begin ()) != 1)
{
EVP_CIPHER_CTX_cleanup (&ctx);
secret.zero ();
throw std::runtime_error ("init cipher ctx");
}
secret.zero ();
Blob out (plaintext.size () + ECIES_HMAC_SIZE + ECIES_ENC_KEY_SIZE + ECIES_ENC_BLK_SIZE, 0);
int len = 0, bytesWritten;
// output IV
memcpy (& (out.front ()), iv.begin (), ECIES_ENC_BLK_SIZE);
len = ECIES_ENC_BLK_SIZE;
// Encrypt/output HMAC
bytesWritten = out.capacity () - len;
assert (bytesWritten > 0);
if (EVP_EncryptUpdate (&ctx, & (out.front ()) + len, &bytesWritten, hmac.begin (), ECIES_HMAC_SIZE) < 0)
{
EVP_CIPHER_CTX_cleanup (&ctx);
throw std::runtime_error ("");
}
len += bytesWritten;
// encrypt/output plaintext
bytesWritten = out.capacity () - len;
assert (bytesWritten > 0);
if (EVP_EncryptUpdate (&ctx, & (out.front ()) + len, &bytesWritten, & (plaintext.front ()), plaintext.size ()) < 0)
{
EVP_CIPHER_CTX_cleanup (&ctx);
throw std::runtime_error ("");
}
len += bytesWritten;
// finalize
bytesWritten = out.capacity () - len;
if (EVP_EncryptFinal_ex (&ctx, & (out.front ()) + len, &bytesWritten) < 0)
{
EVP_CIPHER_CTX_cleanup (&ctx);
throw std::runtime_error ("encryption error");
}
len += bytesWritten;
// Output contains: IV, encrypted HMAC, encrypted data, encrypted padding
assert (len <= (plaintext.size () + ECIES_HMAC_SIZE + (2 * ECIES_ENC_BLK_SIZE)));
assert (len >= (plaintext.size () + ECIES_HMAC_SIZE + ECIES_ENC_BLK_SIZE)); // IV, HMAC, data
out.resize (len);
EVP_CIPHER_CTX_cleanup (&ctx);
return out;
}
int main(int argc, char **argv) {
// We don't check bounds here: we'd end up essentially duplicating the logic
// from load_string, and there's little point in that.
tap_n(2*4 + 2*2 + 2);
if (argc > 1) {
long s = atol(argv[1]);
init_by_array((uint32_t*)&s, sizeof s / sizeof(uint32_t));
} else {
time_t s = time(NULL);
init_by_array((uint32_t*)&s, sizeof s / sizeof(uint32_t));
}
void *data = malloc(DATA_LEN);
random_fill(data, DATA_LEN);
const size_t codepoints = DATA_LEN * CHAR_BIT / 21;
mushcoords beg = MUSHCOORDS(MUSHCELL_MAX-WRAP_AFTER,
MUSHCELL_MAX-WRAP_AFTER,
MUSHCELL_MAX-WRAP_AFTER),
end;
void *space_buf = malloc(mushspace_sizeof);
mushspace *space;
bool ok;
codepoint_reader cp_reader;
mushcoords pos, pos_next;
bool cr;
#define POS_INIT \
pos_next = beg; \
cr = false;
#define CP_POS(cp) \
pos = pos_next; \
switch (cp) { \
default: \
if (MUSHSPACE_DIM > 1 && cr) { \
cr = false; \
pos = MUSHCOORDS(beg.x, pos.y + 1, pos.z); \
} \
pos_next = MUSHCOORDS(pos.x + 1, pos.y, pos.z); \
break; \
case '\r': \
if (MUSHSPACE_DIM > 1) { \
if (cr) \
pos_next = pos = MUSHCOORDS(beg.x, pos.y + 1, pos.z); \
cr = true; \
} \
continue; \
case '\n': \
if (MUSHSPACE_DIM > 1) { \
cr = false; \
pos_next = pos = MUSHCOORDS(beg.x, pos.y + 1, pos.z); \
} \
continue; \
case '\f': \
if (MUSHSPACE_DIM > 2) { \
cr = false; \
pos_next = pos = MUSHCOORDS(beg.x, beg.y, pos.z + 1); \
} else if (cr) { \
cr = false; \
pos_next = pos = MUSHCOORDS(beg.x, pos.y + 1, pos.z); \
} \
continue; \
}
#define LOAD_STRING(suf, T, ENCODER, BLOWUP, FOREACH_CP) \
space = mushspace_init(space_buf, NULL); \
if (!space) { \
tap_not_ok("init returned null"); \
tap_skip_remaining("init failed"); \
return 1; \
} \
tap_ok("init succeeded"); \
\
T *encoded_data##suf = (T*)data; \
size_t encoded_len##suf = DATA_LEN / sizeof *encoded_data##suf; \
if (BLOWUP) { \
encoded_data##suf = \
malloc((codepoints * BLOWUP) * sizeof *encoded_data##suf); \
encoded_len##suf = ENCODER(data, encoded_data##suf, codepoints); \
} \
\
mushspace_load_string##suf( \
space, encoded_data##suf, encoded_len##suf, &end, beg, false); \
\
if (BLOWUP) \
free(encoded_data##suf); \
\
ok = true; \
POS_INIT; \
FOREACH_CP(suf) { \
CP_POS(cp##suf); \
mushcell gc = mushspace_get(space, pos); \
if (gc == cp##suf) \
continue; \
ok = false; \
tap_not_ok("get doesn't match data given to load_string" #suf); \
printf(" ---\n" \
" expected: %" MUSHCELL_PRIx "\n" \
" got: %" MUSHCELL_PRIx "\n" \
" failed index: %zu\n", \
cp##suf, gc, ii##suf); \
printf(" failed pos relative to min: ("); \
for (uint8_t i = 0; i < MUSHSPACE_DIM; ++i) \
printf(" %" MUSHCELL_PRId, mushcell_sub(pos.v[i], MUSHCELL_MIN)); \
printf(" )\n" \
" ...\n"); \
break; \
} \
if (ok) \
tap_ok("get matches data given to load_string" #suf); \
\
mushspace_free(space);
#define DIRECT_FOREACH_CP(s) \
mushcell cp##s; \
size_t ii##s = 0; \
for (; ii##s < encoded_len##s && (cp##s = encoded_data##s[ii##s], true); \
++ii##s)
#define READER_FOREACH_CP(s) \
cp_reader = make_codepoint_reader(data, codepoints); \
size_t ii##s = 0; \
for (mushcell cp##s; (cp##s = next_codepoint(&cp_reader)) != UINT32_MAX; \
++ii##s)
LOAD_STRING(, unsigned char, dummy, 0, DIRECT_FOREACH_CP);
LOAD_STRING(_cell, mushcell, dummy, 0, DIRECT_FOREACH_CP);
LOAD_STRING(_utf8, uint8_t, encode_utf8, 4, READER_FOREACH_CP);
LOAD_STRING(_utf16, uint16_t, encode_utf16, 2, READER_FOREACH_CP);
const mushcell *data_cell = (const mushcell*)data;
const size_t data_cell_count = DATA_LEN / sizeof *data_cell;
mushcoords *saved_pos = malloc(data_cell_count * sizeof *saved_pos);
#define PUT(FOREACH_CELL, S, GET_POS, SAVE_POS) \
space = mushspace_init(space_buf, NULL); \
if (!space) { \
tap_not_ok("init returned null"); \
tap_skip_remaining("init failed"); \
free(saved_pos); \
return 1; \
} \
tap_ok("init succeeded"); \
POS_INIT; \
FOREACH_CELL { \
GET_POS(data_cell[i]); \
if (SAVE_POS) \
saved_pos[i] = pos; \
mushspace_put(space, pos, data_cell[i]); \
} \
\
ok = true; \
POS_INIT; \
for (size_t i = 0; i < data_cell_count; ++i) { \
mushcell dc = data_cell[i]; \
GET_POS(dc); \
mushcell gc = mushspace_get(space, pos); \
if (gc == dc) \
continue; \
ok = false; \
tap_not_ok("get doesn't match what was put" S); \
printf(" ---\n" \
" failed index: %zu\n" \
" expected: %" MUSHCELL_PRIx "\n" \
" got: %" MUSHCELL_PRIx "\n", \
i, dc, gc); \
printf(" failed pos relative to min: ("); \
for (uint8_t j = 0; j < MUSHSPACE_DIM; ++j) \
printf(" %" MUSHCELL_PRId, mushcell_sub(pos.v[j], MUSHCELL_MIN)); \
printf(" )\n" \
" ...\n"); \
break; \
} \
if (ok) \
tap_ok("get matches what was put" S);
#define FORWARD for (size_t i = 0; i < data_cell_count; ++i)
#define REVERSE for (size_t i = data_cell_count; i--;)
#define SAVED_POS(_) pos = saved_pos[i];
PUT(FORWARD, " (forward order)", CP_POS, true);
mushspace_free(space);
PUT(REVERSE, " (reverse order)", SAVED_POS, false);
free(saved_pos);
if (!ok) {
tap_skip_remaining("won't copy bad space");
return 1;
}
void *space_buf2 = malloc(mushspace_sizeof);
mushspace *space2 = mushspace_copy(space_buf2, space, NULL);
mushspace_free(space);
free(space_buf);
space = space2;
if (!space) {
tap_not_ok("copy returned null");
tap_skip_remaining("copy failed");
return 1;
}
tap_ok("copy succeeded");
ok = true;
POS_INIT;
for (size_t i = 0; i < DATA_LEN / sizeof *data_cell; ++i) {
mushcell dc = data_cell[i];
CP_POS(dc);
mushcell gc = mushspace_get(space, pos);
if (gc == dc)
continue;
ok = false;
tap_not_ok("get in copy doesn't match data");
printf(" ---\n"
" failed index: %zu\n"
" expected: %" MUSHCELL_PRIx "\n"
" got: %" MUSHCELL_PRIx "\n",
i, dc, gc);
printf(" failed pos relative to min: (");
for (uint8_t j = 0; j < MUSHSPACE_DIM; ++j)
printf(" %" MUSHCELL_PRId, mushcell_sub(pos.v[j], MUSHCELL_MIN)); \
printf(" )\n"
" ...\n");
break;
}
if (ok)
tap_ok("get in copy matched data");
free(data);
mushspace_free(space);
free(space_buf2);
}
void *vogl_tracked_realloc(const char *pFile_line, void *p, size_t size, size_t *pActual_size)
{
if ((ptr_bits_t)p & (VOGL_MIN_ALLOC_ALIGNMENT - 1))
{
vogl_mem_error("vogl_realloc: bad ptr", pFile_line);
return NULL;
}
if (size > VOGL_MAX_POSSIBLE_HEAP_BLOCK_SIZE)
{
vogl_mem_error("vogl_realloc: size too big!", pFile_line);
return NULL;
}
if ((size) && (size < sizeof(uint32)))
size = sizeof(uint32);
#if VOGL_RAND_FILL_ALLLOCATED_MEMORY || VOGL_SCRUB_FREED_MEMORY
size_t orig_size = p ? msize_block(p, pFile_line) : 0;
#if VOGL_SCRUB_FREED_MEMORY
if ((orig_size) && (!size))
random_fill(p, orig_size);
#endif
#endif
void *p_new = realloc_block(p, size, pFile_line);
VOGL_ASSERT((reinterpret_cast<ptr_bits_t>(p_new) & (VOGL_MIN_ALLOC_ALIGNMENT - 1)) == 0);
if (pActual_size)
{
*pActual_size = 0;
if (size)
{
if (p_new)
*pActual_size = msize_block(p_new, pFile_line);
else if (p)
*pActual_size = msize_block(p, pFile_line);
if (*pActual_size >= static_cast<uint64_t>(size) * 16U)
{
// I've seen this happen with glibc's absolutely terrible debug heap crap, best to let the caller know that shit is going to die
fprintf(stderr, "%s: malloc_usable_size may be misbehaving! Requested %zu bytes, but the usable size is reported as %zu bytes.\n", __FUNCTION__, size, *pActual_size);
}
}
}
#if VOGL_RAND_FILL_ALLLOCATED_MEMORY
if ((size) && (p_new))
{
size_t new_size = msize_block(p_new, pFile_line);
if (new_size > orig_size)
random_fill(static_cast<uint8 *>(p_new) + orig_size, new_size - orig_size);
}
#endif
return p_new;
}
int main() {
cl_int status;
cl_platform_id platform;
CHECK_STATUS(clGetPlatformIDs(1, &platform, NULL));
cl_device_id device;
CHECK_STATUS(clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 1, &device, NULL));
cl_context context = clCreateContext(NULL, 1, &device, NULL, NULL, &status);
CHECK_STATUS(status);
cl_command_queue queue = clCreateCommandQueue(context, device, 0, &status);
CHECK_STATUS(status);
char* source = read_source("multiply_arrays.cl");
cl_program program = clCreateProgramWithSource(context, 1,
(const char**)&source, NULL, NULL);
CHECK_STATUS(status);
free(source);
CHECK_STATUS(clBuildProgram(program, 0, NULL, NULL, NULL, NULL));
cl_kernel kernel = clCreateKernel(program, "multiply_arrays", &status);
CHECK_STATUS(status);
cl_float a[1024], b[1024];
random_fill(a, 1024);
random_fill(b, 1024);
cl_mem inputA = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
sizeof(cl_float) * 1024, a, &status);
CHECK_STATUS(status);
cl_mem inputB = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
sizeof(cl_float) * 1024, b, &status);
CHECK_STATUS(status);
cl_mem output = clCreateBuffer(context, CL_MEM_WRITE_ONLY,
sizeof(cl_float) * 1024, NULL, &status);
CHECK_STATUS(status);
CHECK_STATUS(clSetKernelArg(kernel, 0, sizeof(cl_mem), &inputA));
CHECK_STATUS(clSetKernelArg(kernel, 1, sizeof(cl_mem), &inputB));
CHECK_STATUS(clSetKernelArg(kernel, 2, sizeof(cl_mem), &output));
size_t work_units = 1024;
CHECK_STATUS(clEnqueueNDRangeKernel(queue, kernel, 1, NULL, &work_units, NULL, 0, NULL, NULL));
cl_float results[1024];
CHECK_STATUS(clEnqueueReadBuffer(queue, output, CL_TRUE, 0, sizeof(cl_float) * 1024,
results, 0, NULL, NULL));
CHECK_STATUS(clReleaseMemObject(inputA));
CHECK_STATUS(clReleaseMemObject(inputB));
CHECK_STATUS(clReleaseMemObject(output));
CHECK_STATUS(clReleaseKernel(kernel));
CHECK_STATUS(clReleaseProgram(program));
CHECK_STATUS(clReleaseCommandQueue(queue));
CHECK_STATUS(clReleaseContext(context));
for (int i = 0; i < 1024; ++i) {
printf("%f * %f = %f\n", a[i], b[i], results[i]);
}
return 0;
}
int start_run()
{
FILE* work_file;
char *start_menu[] = {
"Create file;\n",
"Open file;\n",
"Read file;\n",
"Delete file;\n",
"Exit program;\n",
};
char menu_symb[] = "0";
char random = '\0';
char path[PATH_LEN + 1];
char full_path[FPATH_LEN + 1];
int fill_number = 0;
int menu_count = 0;
int incorrect_choice = 1;
int exit = 0;
do
{
incorrect_choice = 1;
system("clear");
for(menu_count = 0; menu_count < 5; menu_count++)
printf("%d) %s", menu_count + 1, start_menu[menu_count]);
printf("Input the number of menu item:\n");
while(incorrect_choice)
{
menu_symb[0] = getche();
if(!strpbrk(menu_symb, "12345"))
printf("Unknown value: %c; repeat the choice\n", menu_symb[0]);
else
incorrect_choice = 0;
}
switch(menu_symb[0])
{
case '1':
{
puts("Input the name of the file to create:");
puts("(If you wish inner directories, "
"type them with '/' separator;");
puts("Further this path may be appended "
"to executable's base dir)");
string_input(stdin, PATH_LEN, path, 0);
getcwd(full_path, FPATH_LEN + 1);
strcat(full_path, "/");
strcat(full_path, path);
work_file = file_create(full_path);
if(work_file)
{
incorrect_choice = 1;
puts("Do you want to fill the file with random values?[Y/N]");
while(incorrect_choice)
{
random = getche();
if(!strpbrk(&random, "ynYN"))
printf("Unknown value: %c; repeat the choice\n",
random);
else
incorrect_choice = 0;
}
if(random == 'y' || random == 'Y')
{
puts("Input the number of items to create:");
fill_number = integer_input(1, 200);
random_fill(work_file, fill_number);
}
file_run(work_file);
}
}
break;
case '2':
{
puts("Input the name of the file to open & operate with:");
string_input(stdin, PATH_LEN, path, 0);
getcwd(full_path, FPATH_LEN + 1);
strcat(full_path, "/");
strcat(full_path, path);
if(!file_exist(full_path))
alert("\tNo such file or directory;");
else
{
work_file = file_open(full_path);
if(work_file)
file_run(work_file);
}
}
break;
case '3':
{
puts("Input the name of the file to read:");
string_input(stdin, PATH_LEN, path, 0);
getcwd(full_path, FPATH_LEN + 1);
strcat(full_path, "/");
strcat(full_path, path);
if(!file_exist(full_path))
alert("\tNo such file or directory;");
else
{
work_file = file_open(full_path);
if(work_file)
file_read(work_file);
}
}
break;
case '4':
{
puts("Input the name of the file to delete:");
string_input(stdin, PATH_LEN, path, 0);
getcwd(full_path, FPATH_LEN + 1);
strcat(full_path, "/");
strcat(full_path, path);
if(!file_exist(full_path))
alert("\tNo such file or directory;");
else
if(remove(full_path))
alert("\tUnable to delete this file;");
}
break;
case '5':
{
printf("Good luck;\n");
exit = 1;
}
break;
}
}while(!exit);
return menu_symb[0] - '0';
}
