term_t bif_open0_3(term_t FileName, term_t Mode, term_t Perms, process_t *ctx) { apr_status_t rs; apr_pool_t *p; apr_file_t *file; port_t *port; if (!is_binary(FileName) || !is_int(Mode) || !is_int(Perms)) return A_BADARG; apr_pool_create(&p, 0); rs = apr_file_open(&file, (char *)bin_data(FileName), (apr_uint32_t)int_value(Mode), (apr_uint32_t)int_value(Perms), p); if (rs != 0) { apr_pool_destroy(p); return decipher_status(rs); } port = port_file_make(file); //set initial port owner //port->owner_in = port->owner_out = proc_pid(ctx, port->xp); port->owner_in = port->owner_out = A_UNDEFINED; //put port to polling ring port_register(port); result(port_id(port, proc_gc_pool(ctx))); return AI_OK; }
term_t bif_rc4_init1(term_t Key, process_t *ctx) { apr_byte_t *s; apr_byte_t i, j; apr_byte_t key_len; apr_byte_t *key_data; if (!is_binary(Key)) return A_BADARG; s = xalloc(proc_gc_pool(ctx), 256+2); //2 for i and j key_len = (apr_byte_t)int_value(bin_size(Key)); key_data = bin_data(Key); i = 0; do { s[i] = i++; } while (i != 0); i = j = 0; do { apr_byte_t temp; j += key_data[i%key_len]+s[i]; temp = s[i]; s[i] = s[j]; s[j] = temp; i++; } while (i != 0); s[256] = 0; s[257] = 0; result(make_binary(intnum(256+2), s, proc_gc_pool(ctx))); return AI_OK; }
term_t bif_md5_1(term_t Data, process_t *ctx) { apr_byte_t *digest = xalloc(proc_gc_pool(ctx), MD5_DIGESTSIZE); if (!is_binary(Data)) return A_BADARG; md5(digest, bin_data(Data), (apr_size_t)int_value(bin_size(Data))); result(make_binary(intnum(MD5_DIGESTSIZE), digest, proc_gc_pool(ctx))); return AI_OK; }
term_t bif_md5_update2(term_t Data, term_t Context, process_t *ctx) { apr_size_t size; md5_ctx_t *tmp; if (!is_binary(Data) || !is_binary(Context)) return A_BADARG; if (int_value2(bin_size(Context)) != sizeof(md5_ctx_t)) return A_BADARG; size = (apr_size_t)int_value(bin_size(Data)); tmp = xalloc(proc_gc_pool(ctx), sizeof(*tmp)); memcpy(tmp, bin_data(Context), sizeof(*tmp)); md5_update(tmp, bin_data(Data), size); result(make_binary(intnum(sizeof(*tmp)), (apr_byte_t *)tmp, proc_gc_pool(ctx))); return AI_OK; }
term_t bif_sendto4(term_t Sock, term_t RemIP, term_t RemPort, term_t Bin, process_t *ctx) { apr_status_t rs; port_t *port; apr_socket_t *sock; const char *host; int udp_port; apr_sockaddr_t *sa; apr_pool_t *p; if (!is_port(Sock)) return A_BADARG; if (!is_binary(RemIP) || !is_int(RemPort)) return A_BADARG; if (!is_binary(Bin)) return A_BADARG; port = port_lookup(prp_serial(Sock)); if (port == 0) return A_CLOSED; if (!port->is_socket(port)) return A_BADARG; sock = port->get_socket(port); host = (const char *)bin_data(RemIP); udp_port = (apr_port_t)int_value(RemPort); apr_pool_create(&p, 0); rs = apr_sockaddr_info_get(&sa, host, APR_INET, udp_port, 0, p); if (rs == 0) { apr_size_t len = (apr_size_t)int_value(bin_size(Bin)); rs = apr_socket_sendto(sock, sa, 0, (const char *)bin_data(Bin), &len); } if (rs != 0) { apr_pool_destroy(p); return decipher_status(rs); } result(A_OK); return AI_OK; }
term_t bif_rc4_update2(term_t Text, term_t Opaque, process_t *ctx) { apr_byte_t *text_data; apr_uint32_t text_size, k; apr_byte_t *s; apr_byte_t i, j; term_t Text1, Opaque1; if (!is_binary(Text) || !is_binary(Opaque) || bin_size(Opaque) != intnum(256+2)) return A_BADARG; text_size = int_value2(bin_size(Text)); text_data = xalloc(proc_gc_pool(ctx), text_size); memcpy(text_data, bin_data(Text), text_size); s = xalloc(proc_gc_pool(ctx), 256+2); memcpy(s, bin_data(Opaque), 256+2); i = s[256]; j = s[257]; for (k = 0; k < text_size; k++) { apr_byte_t temp; i++; j += s[i]; temp = s[i]; s[i] = s[j]; s[j] = temp; text_data[k] ^= s[(s[i]+s[j]) & 255]; } s[256] = i; s[257] = j; Text1 = make_binary(intnum(text_size), text_data, proc_gc_pool(ctx)); Opaque1 = make_binary(intnum(256+2), s, proc_gc_pool(ctx)); result(make_tuple2(Text1, Opaque1, proc_gc_pool(ctx))); return AI_OK; }
term_t bif_md5_final1(term_t Context, process_t *ctx) { apr_byte_t *data; if (!is_binary(Context) || int_value2(bin_size(Context)) != sizeof(md5_ctx_t)) return A_BADARG; data = xalloc(proc_gc_pool(ctx), 16); md5_final(data, (md5_ctx_t *)bin_data(Context)); result(make_binary(intnum(MD5_DIGESTSIZE), data, proc_gc_pool(ctx))); return AI_OK; }
HISTOGRAM::HISTOGRAM(int nbins, double start, double end, std::vector<double> data){ _nbins = nbins; _start = start; _end = end; _data = data; _dbin = (_end - _start) / (double)_nbins; gen_bins(); bin_data(); }
static apr_status_t port_buffer_send(buffer_t *buf, term_t io) { int avail; if (is_nil(io)) return 0; avail = buffer_available(buf); if (is_int(io)) { if (avail == 0) return APR_EINCOMPLETE; else buffer_put_byte(buf, int_value(io)); } else if (is_binary(io)) { int size = int_value2(bin_size(io)); if (size > avail) { buffer_put_data(buf, bin_data(io), avail); return APR_EINCOMPLETE; } else buffer_put_data(buf, bin_data(io), size); } if (is_list(io)) { while (is_cons(io)) { apr_status_t rs; rs = port_buffer_send(buf, lst_value(io)); if (rs != 0) return rs; io = lst_next(io); } } return APR_SUCCESS; }
term_t bif_open_socket2(term_t LocIP, term_t LocPort, process_t *ctx) { apr_status_t rs; apr_pool_t *p; apr_sockaddr_t *sa; apr_socket_t *socket; port_t *port; term_t id; const char *host; apr_port_t udp_port; if (LocIP != A_ANY && !is_binary(LocIP)) return A_BADARG; if (!is_int(LocPort)) return A_BADARG; host = (LocIP == A_ANY) ?0 :(const char *)bin_data(LocIP); udp_port = (apr_port_t)int_value(LocPort); apr_pool_create(&p, 0); rs = apr_sockaddr_info_get(&sa, host, APR_INET, udp_port, 0, p); if (rs == 0) rs = apr_socket_create(&socket, APR_INET, SOCK_DGRAM, APR_PROTO_UDP, p); //only APR_INET is supported, not APR_INET6 if (rs == 0) rs = apr_socket_bind(socket, sa); if (rs == 0) rs = apr_socket_opt_set(socket, APR_SO_NONBLOCK, 1); if (rs != 0) { apr_pool_destroy(p); return decipher_status(rs); } port = port_udp_make(socket); //takes care of pool p //add to poll ring port_register(port); //set initial port owner port->owner_in = port->owner_out = proc_pid(ctx, port->xp); id = make_port(my_node, port->key, my_creation, proc_gc_pool(ctx)); result(id); return AI_OK; }
term_t bif_write0_2(term_t Port, term_t Bin, process_t *ctx) { apr_status_t rs; apr_size_t size; port_t *p; if (!is_port(Port) || !is_binary(Bin)) return A_BADARG; p = port_lookup(prp_serial(Port)); if (p == 0) return A_BADARG; size = (apr_size_t)int_value(bin_size(Bin)); rs = p->write(p, bin_data(Bin), &size); if (rs != 0) return decipher_status(rs); //TODO: something may still be written result(intnum(size)); return AI_OK; }