Ejemplo n.º 1
0
static void *namespace_decl_handler(expat_parser *parser_data, const XML_Char *prefix, const XML_Char *uri)
{
    ErlNifBinary ns_name, ns_value;

    if(uri == NULL)
        {
            parser_data->xmlns = (ERL_NIF_TERM)NULL;
            return NULL;
        }

    if(prefix)
        {
            enif_alloc_binary(strlen(prefix)+6, &ns_name);
            strcpy((char *)ns_name.data, "xmlns:");
            strcpy((char *)ns_name.data+6, (const char *)prefix);
        } else
        {
            enif_alloc_binary(5, &ns_name);
            strcpy((char *)ns_name.data, "xmlns");
        }

    enif_alloc_binary(strlen(uri), &ns_value);
    strcpy((char *)ns_value.data, uri);

    parser_data->xmlns = enif_make_tuple(parser_data->env, 2,
                                         enif_make_binary(parser_data->env, &ns_name),
                                         enif_make_binary(parser_data->env, &ns_value));

    return NULL;
};
Ejemplo n.º 2
0
static ERL_NIF_TERM to_html_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
  ErlNifBinary  markdown_binary;
  ErlNifBinary  output_binary;
  char         *html;
  size_t        html_len;
  int           options = 0;

  if (argc != 1) {
    return enif_make_badarg(env);
  }

  if(!enif_inspect_binary(env, argv[0], &markdown_binary)){
    return enif_make_badarg(env);
  }

  if (markdown_binary.size <= 0){
    const char *empty_string = "";
    const int   empty_len    = strlen(empty_string);
    enif_alloc_binary(empty_len, &output_binary);
    strncpy((char*)output_binary.data, empty_string, empty_len);
    return enif_make_binary(env, &output_binary);
  }

  html = cmark_markdown_to_html((const char *)markdown_binary.data, markdown_binary.size, options);
  html_len = strlen(html);
  enif_release_binary(&markdown_binary);

  enif_alloc_binary(html_len, &output_binary);
  strncpy((char*)output_binary.data, html, html_len);

  return enif_make_binary(env, &output_binary);
};
Ejemplo n.º 3
0
static ErlNifBinary encode_name(expat_parser *parser_data, const XML_Char *name)
{
    ErlNifBinary encoded;
    int name_len, prefix_len;
    char *name_start;
    char *prefix_start;

    if((name_start = strchr(name, '\n')))
        {
            if((prefix_start = strchr(name_start+1, '\n')))
                {
                    name_len = prefix_start - name_start;
                    prefix_len = strlen(prefix_start+1);
                    enif_alloc_binary(name_len+prefix_len, &encoded);
                    strncpy((char *)encoded.data, prefix_start+1, prefix_len);
                    strncpy((char *)encoded.data+prefix_len, name_start, name_len);
                    encoded.data[prefix_len] = ':';
                } else
                {
                    name_len = strlen(name_start+1);
                    enif_alloc_binary(name_len, &encoded);
                    strncpy((char *)encoded.data, name_start+1, name_len);
                }
        } else
        {
            enif_alloc_binary(strlen(name), &encoded);
            strcpy((char *)encoded.data, name);
        };

    return encoded;
};
Ejemplo n.º 4
0
static int prefix_cb(void *data, const unsigned char *k, uint32_t k_len, void *val) 
{
    callback_data *cb_data = data;
    art_elem_struct *elem = val;
    ErlNifBinary key, value;

    enif_alloc_binary(k_len - 1, &key);
    memcpy(key.data, k, k_len - 1);

    enif_alloc_binary(elem->size, &value);
    memcpy(value.data, elem->data, elem->size);

    ErlNifEnv *msg_env = enif_alloc_env();

    if(msg_env == NULL)
        return mk_error(cb_data->env, "env_alloc_error");;

    ERL_NIF_TERM caller_ref = enif_make_copy(msg_env, cb_data->caller_ref);

    ERL_NIF_TERM res = enif_make_tuple2(msg_env, 
        caller_ref,
        enif_make_tuple2(msg_env, 
            enif_make_binary(msg_env, &key), enif_make_binary(msg_env, &value)));
    
    if(!enif_send(cb_data->env, &cb_data->pid, msg_env, res))
    {
        enif_free(msg_env);

        return -1;
    }

    enif_free(msg_env);    

    return 0;
}
Ejemplo n.º 5
0
static void *namespace_decl_handler(expat_parser *parser_data, const XML_Char *prefix, const XML_Char *uri)
{
    ErlNifBinary ns_prefix_bin, ns_uri_bin;
    ERL_NIF_TERM ns_prefix, ns_uri, ns_pair;

    if(uri == NULL)
        {
            /* parser_data->xmlns = (ERL_NIF_TERM)NULL; */
            fprintf(stderr, "URI IS NULL?\n");
            return NULL;
        }

    if(prefix)
        {
            enif_alloc_binary(strlen(prefix), &ns_prefix_bin);
            strcpy((char *)ns_prefix_bin.data, (const char *)prefix);
            ns_prefix = enif_make_binary(parser_data->env, &ns_prefix_bin);
        } else
        {
            ns_prefix = NONE;
        }

    enif_alloc_binary(strlen(uri), &ns_uri_bin);
    strcpy((char *)ns_uri_bin.data, uri);
    ns_uri = enif_make_binary(parser_data->env, &ns_uri_bin);

    ns_pair = enif_make_tuple(parser_data->env, 2, ns_uri, ns_prefix);
    parser_data->xmlns = enif_make_list_cell(parser_data->env, ns_pair, parser_data->xmlns);

    return NULL;
};
Ejemplo n.º 6
0
posix_errno_t efile_altname(ErlNifEnv *env, const efile_path_t *path, ERL_NIF_TERM *result) {
    ErlNifBinary result_bin;

    ASSERT_PATH_FORMAT(path);

    if(is_path_root(path)) {
        /* Root paths can't be queried so we'll just return them as they are. */
        if(!enif_alloc_binary(path->size, &result_bin)) {
            return ENOMEM;
        }

        sys_memcpy(result_bin.data, path->data, path->size);
    } else {
        WIN32_FIND_DATAW data;
        HANDLE handle;

        WCHAR *name_buffer;
        int name_length;

        /* Reject path wildcards. */
        if(wcspbrk(&((const WCHAR*)path->data)[LP_PREFIX_LENGTH], L"?*")) {
            return ENOENT;
        }

        handle = FindFirstFileW((const WCHAR*)path->data, &data);

        if(handle == INVALID_HANDLE_VALUE) {
            return windows_to_posix_errno(GetLastError());
        }

        FindClose(handle);

        name_length = wcslen(data.cAlternateFileName);

        if(name_length > 0) {
            name_buffer = data.cAlternateFileName;
        } else {
            name_length = wcslen(data.cFileName);
            name_buffer = data.cFileName;
        }

        /* Include NUL-terminator; it will be removed after normalization. */
        name_length += 1;

        if(!enif_alloc_binary(name_length * sizeof(WCHAR), &result_bin)) {
            return ENOMEM;
        }

        sys_memcpy(result_bin.data, name_buffer, name_length * sizeof(WCHAR));
    }

    if(!normalize_path_result(&result_bin)) {
        enif_release_binary(&result_bin);
        return ENOMEM;
    }

    (*result) = enif_make_binary(env, &result_bin);

    return 0;
}
Ejemplo n.º 7
0
/* 0: socket, 1: length, 2: flags, 3: struct sockaddr length */
    static ERL_NIF_TERM
nif_recvfrom(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
    int sockfd = -1;
    unsigned long len = 0;
    unsigned long salen = 0;
    int flags = 0;

    ErlNifBinary buf = {0};
    ErlNifBinary sa = {0};
    ssize_t bufsz = 0;


    if (!enif_get_int(env, argv[0], &sockfd))
        return enif_make_badarg(env);
    if (!enif_get_ulong(env, argv[1], &len))
        return enif_make_badarg(env);
    if (!enif_get_int(env, argv[2], &flags))
        return enif_make_badarg(env);
    if (!enif_get_ulong(env, argv[3], &salen))
        return enif_make_badarg(env);

    if (!enif_alloc_binary(len, &buf))
        return error_tuple(env, ENOMEM);

    if (!enif_alloc_binary(salen, &sa))
        return error_tuple(env, ENOMEM);

    if ( (bufsz = recvfrom(sockfd, buf.data, buf.size, flags,
        (sa.size == 0 ? NULL : (struct sockaddr *)sa.data),
        (socklen_t *)&salen)) == -1) {
        enif_release_binary(&buf);
        enif_release_binary(&sa);
        switch (errno) {
            case EAGAIN:
            case EINTR:
                return enif_make_tuple2(env, atom_error, atom_eagain);
            default:
                return error_tuple(env, errno);
        }
    }

    PROCKET_REALLOC(buf, bufsz);
    PROCKET_REALLOC(sa, salen);

    return enif_make_tuple3(env, atom_ok, enif_make_binary(env, &buf),
             enif_make_binary(env, &sa));
}
Ejemplo n.º 8
0
static nif_term_t
salt_scalarmult_base(nif_heap_t *hp, int argc, const nif_term_t argv[])
{
	/* salt_scalarmult(Integer) -> Group_q. */
	nif_bin_t 		n;
	nif_bin_t 		q;

	if (argc != 1)
		return (BADARG);

	/* Unpack arguments ensuring they're suitably typed. */
	if (! enif_inspect_binary(hp, argv[0], &n))
		return (BADARG);

	/* Check constraints on size. */
	if (n.size != crypto_scalarmult_SCALARBYTES)
		return (BADARG);

	/* Allocate space for plain text. NB: Passing ENOMEM as BADARG. */
	if (! enif_alloc_binary(crypto_scalarmult_BYTES, &q))
		return (BADARG);
	
	crypto_scalarmult_base(q.data, n.data);
	return (enif_make_binary(hp, &q));
}
Ejemplo n.º 9
0
posix_errno_t efile_get_device_cwd(ErlNifEnv *env, int device_index, ERL_NIF_TERM *result) {
    ErlNifBinary result_bin;

    /* _wgetdcwd might crash the entire emulator on debug builds since the CRT
     * invalid parameter handler asserts if passed a non-existent drive (Or
     * simply one that has been unmounted), so we check it ourselves to avoid
     * that. */
    if(!is_valid_drive(device_index)) {
        return EACCES;
    }

    if(!enif_alloc_binary(MAX_PATH * sizeof(WCHAR), &result_bin)) {
        return ENOMEM;
    }

    if(_wgetdcwd(device_index, (WCHAR*)result_bin.data, MAX_PATH) == NULL) {
        enif_release_binary(&result_bin);
        return EACCES;
    }

    if(!normalize_path_result(&result_bin)) {
        enif_release_binary(&result_bin);
        return ENOMEM;
    }

    (*result) = enif_make_binary(env, &result_bin);

    return 0;
}
Ejemplo n.º 10
0
//-
static
ERL_NIF_TERM
nif_decompress(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
    ErlNifBinary input;

    if(!enif_inspect_iolist_as_binary(env, argv[0], &input)) 
    {
        return(enif_make_badarg(env));
    }

    ErlNifBinary bin;

    // [rad] Get decompressed size.
    uint32_t decompressed_bytes = wfLZ_GetDecompressedSize((const uint8_t* const) input.data);

    if(!decompressed_bytes)
    {
        return(erlang_produce_error(env, "not_compressed"));
    }

    // [rad] Create binary stream to hold decompressed data.
    if(!enif_alloc_binary(decompressed_bytes, &bin))
    {
        return(erlang_produce_error(env, "not_enough_memory"));
    } 

    // [rad] Perform decompression.
    wfLZ_Decompress((const uint8_t* const) input.data, bin.data);

    return(enif_make_binary(env, &bin));
}
Ejemplo n.º 11
0
static ERL_NIF_TERM nif_get_json(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {

  gchar *path = get_char_argument(env, &argv[0]);
  if (!path)
    return enif_make_badarg(env);

  gchar include_content_atom[10];
  guint content_option = 0;
  if (argc == 2 && enif_get_atom(env, argv[1], include_content_atom, sizeof(include_content_atom), ERL_NIF_LATIN1)) {
    if (!g_ascii_strcasecmp(include_content_atom, "true"))
      content_option = 1;
    else if (!g_ascii_strcasecmp(include_content_atom, "raw"))
      content_option = 2;
  }

  GString *json_str = gmimex_get_json(path, content_option);
  g_free(path);

  if (!json_str)
    return enif_make_badarg(env);

  ErlNifBinary result_binary = {0};
  enif_alloc_binary(json_str->len, &result_binary);
  (void)memcpy(result_binary.data, json_str->str, json_str->len);

  g_string_free(json_str, TRUE);

  return enif_make_binary(env, &result_binary);

}
Ejemplo n.º 12
0
Archivo: serctl.c Proyecto: jj1bdx/srly
    static ERL_NIF_TERM
nif_tcgetattr(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
    SRLY_STATE *sp = NULL;
    ErlNifBinary buf = {0};

    int err = 0;


    if (!enif_get_resource(env, argv[0], SRLY_STATE_RESOURCE, (void **)&sp))
        return enif_make_badarg(env);

    if (!enif_alloc_binary(sizeof(struct termios), &buf))
        return error_tuple(env, ENOMEM);

    if (tcgetattr(sp->fd, (struct termios *)buf.data) < 0) {
        err = errno;
        enif_release_binary(&buf);
        return error_tuple(env, err);
    }

    return enif_make_tuple2(env,
        atom_ok,
        enif_make_binary(env, &buf));
}
Ejemplo n.º 13
0
static inline int
enc_unknown(Encoder* e, ERL_NIF_TERM value)
{
    ErlNifBinary* bin = e->curr;
    ERL_NIF_TERM curr;

    if(e->i > 0) {
        if(!enc_result(e, &curr)) {
            return 0;
        }

        e->iolist = enif_make_list_cell(e->env, curr, e->iolist);
        e->iolen++;
    }

    e->iolist = enif_make_list_cell(e->env, value, e->iolist);
    e->iolen++;

    // Reinitialize our binary for the next buffer.
    e->curr = bin;
    if(!enif_alloc_binary(BIN_INC_SIZE, e->curr)) {
        return 0;
    }

    memset(e->curr->data, 0, e->curr->size);

    e->p = (char*) e->curr->data;
    e->u = (unsigned char*) e->curr->data;
    e->i = 0;

    return 1;
}
Ejemplo n.º 14
0
// fwrite implementation
static ERL_NIF_TERM
io_libc_fwrite(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
  char fmt[1024];
  int len = 0;

  if((len = enif_get_string(env, argv[0], fmt, sizeof(fmt), ERL_NIF_LATIN1)) <= 0) return enif_make_badarg(env);
  if(!enif_is_list(env, argv[1])) return enif_make_badarg(env);
  
  ERL_NIF_TERM items = argv[1];

  // At first, allocate result as empty binary
  ErlNifBinary result;
  enif_alloc_binary(0, &result);

  // Get escape sequences one-by-one from fmt with according values from items
  char *cur_fmt = fmt;
  int format_result;
  while ((format_result = format_first(env, &result, &cur_fmt, &items)) > 0) {
    // Nothing to do here, everything is ok
  }

  // good: return resulting binary
  if (format_result >= 0) return enif_make_binary(env, &result);

  // bad: make badarg. TODO: return something pointing to erroneous place
  return enif_make_badarg(env);
};
Ejemplo n.º 15
0
static void *start_element_handler(expat_parser *parser_data, const XML_Char *name, const XML_Char **atts)
{
    ErlNifBinary element_name;
    ERL_NIF_TERM attrs_list = enif_make_list(parser_data->env, 0);
    int i;

    element_name = encode_name(parser_data, name);
    for(i = 0; atts[i]; i += 2);
    while(i)
        {
            ErlNifBinary attr_name, attr_value;

            enif_alloc_binary(strlen(atts[i-1]), &attr_value);
            strcpy((char *) attr_value.data, (const char *)atts[i-1]);
            attr_name = encode_name(parser_data, atts[i-2]);

            ERL_NIF_TERM attr = enif_make_tuple(parser_data->env, 2,
                                                enif_make_binary(parser_data->env, &attr_name),
                                                enif_make_binary(parser_data->env, &attr_value));
            attrs_list = enif_make_list_cell(parser_data->env, attr, attrs_list);

            i -= 2;
        };

    if(parser_data->xmlns)
        attrs_list = enif_make_list_cell(parser_data->env, parser_data->xmlns, attrs_list);
    parser_data->xmlns = (ERL_NIF_TERM)NULL;

    ERL_NIF_TERM event = enif_make_tuple(parser_data->env, 3, XML_ELEMENT_START,
                                         enif_make_binary(parser_data->env, &element_name),
                                         attrs_list);
    parser_data->result = enif_make_list_cell(parser_data->env, event, parser_data->result);

    return NULL;
};
Ejemplo n.º 16
0
static ERL_NIF_TERM nacl_box_padded(ErlNifEnv *env, int argc, ERL_NIF_TERM const argv[])
{
  ErlNifBinary padded_msg;
  ErlNifBinary nonce;
  ErlNifBinary pk;
  ErlNifBinary sk;
  ErlNifBinary result;

  if (!enif_inspect_iolist_as_binary(env, argv[0], &padded_msg))
    return enif_make_badarg(env);

  if (!enif_inspect_iolist_as_binary(env, argv[1], &nonce))
    return enif_make_badarg(env);

  if (!enif_inspect_iolist_as_binary(env, argv[2], &pk))
    return enif_make_badarg(env);

  if (!enif_inspect_iolist_as_binary(env, argv[3], &sk))
    return enif_make_badarg(env);

  if (nonce.size != crypto_box_NONCEBYTES) return enif_make_badarg(env);
  if (pk.size != crypto_box_PUBLICKEYBYTES) return enif_make_badarg(env);
  if (sk.size != crypto_box_SECRETKEYBYTES) return enif_make_badarg(env);
  if (padded_msg.size < crypto_box_ZEROBYTES) return enif_make_badarg(env);

  if (!enif_alloc_binary(padded_msg.size, &result))
    return nacl_error_tuple(env, "alloc_failed");

  crypto_box(result.data, padded_msg.data, padded_msg.size, nonce.data, pk.data, sk.data);

  return enif_make_sub_binary(env,
			      enif_make_binary(env, &result),
			      crypto_box_BOXZEROBYTES,
			      padded_msg.size - crypto_box_BOXZEROBYTES);
}
Ejemplo n.º 17
0
static ERL_NIF_TERM nacl_secretbox_open_padded(ErlNifEnv *env, int argc, ERL_NIF_TERM const argv[])
{
  ErlNifBinary key;
  ErlNifBinary nonce;
  ErlNifBinary padded_ciphertext;
  ErlNifBinary padded_message;
  
  if (!enif_inspect_iolist_as_binary(env, argv[0], &padded_ciphertext))
    return enif_make_badarg(env);

  if (!enif_inspect_iolist_as_binary(env, argv[1], &nonce))
    return enif_make_badarg(env);

  if (!enif_inspect_iolist_as_binary(env, argv[2], &key))
    return enif_make_badarg(env);

  if (key.size != crypto_secretbox_KEYBYTES) return enif_make_badarg(env);
  if (nonce.size !=  crypto_secretbox_NONCEBYTES) return enif_make_badarg(env);
  if (padded_ciphertext.size < crypto_secretbox_BOXZEROBYTES) return enif_make_badarg(env);

  if (!enif_alloc_binary(padded_ciphertext.size, &padded_message))
    return nacl_error_tuple(env, "alloc_failed");

  if (crypto_secretbox_open(padded_message.data, padded_ciphertext.data, padded_ciphertext.size,
			    nonce.data, key.data)) {
    return nacl_error_tuple(env, "crypto_failed");
  }

  return enif_make_sub_binary(env,
			      enif_make_binary(env, &padded_message),
			      crypto_secretbox_ZEROBYTES,
			      padded_ciphertext.size - crypto_secretbox_ZEROBYTES);
}
Ejemplo n.º 18
0
posix_errno_t efile_get_cwd(ErlNifEnv *env, ERL_NIF_TERM *result) {
    ErlNifBinary result_bin;
    size_t bytes_copied;

    if(!enif_alloc_binary(256, &result_bin)) {
        return ENOMEM;
    }

    while(getcwd((char*)result_bin.data, result_bin.size) == NULL) {
        posix_errno_t saved_errno = errno;

        if(saved_errno != ERANGE) {
            enif_release_binary(&result_bin);
            return saved_errno;
        } else {
            if(!enif_realloc_binary(&result_bin, result_bin.size * 2)) {
                enif_release_binary(&result_bin);
                return ENOMEM;
            }
        }
    }

    /* getcwd(2) guarantees null-termination. */
    bytes_copied = strlen((const char*)result_bin.data);

    if(!enif_realloc_binary(&result_bin, bytes_copied)) {
        enif_release_binary(&result_bin);
        return ENOMEM;
    }

    (*result) = enif_make_binary(env, &result_bin);

    return 0;
}
Ejemplo n.º 19
0
// read_com(_PORTID, _DATACNT)
static ERL_NIF_TERM read_com(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]){
	int ret = 0;
	int port = 0;
	int data_cnt = 0;
	DWORD dwBytesTransferred;
	ErlNifBinary bin;
	unsigned char* data;

	if (argc < 2)
		return enif_make_badarg(env);

	if (!enif_get_int (env, argv[0], &port))
		return enif_make_badarg(env);

	if (!enif_get_int (env, argv[1], &data_cnt))
		return enif_make_badarg(env);

	if (port > cur_port || port < 1 || data_cnt < 1 || data_cnt > INT_MAX)
		return enif_make_badarg(env);

	if(ports[port - 1] == NULL)
		return enif_make_string(env, "Port is already closed!", ERL_NIF_LATIN1);

	data = (unsigned char*) malloc(sizeof(unsigned char)*(data_cnt));

	ReadFile (ports[port - 1], data, data_cnt, &dwBytesTransferred, 0); //read 1 

	if(! enif_alloc_binary(dwBytesTransferred, &bin)){
		return enif_make_string(env, "Memory cannot be allocated!", ERL_NIF_LATIN1);
	}

	memcpy(bin.data, data, dwBytesTransferred);

	return enif_make_binary(env, &bin);
}
Ejemplo n.º 20
0
//
// build result for re2:match
//
static ERL_NIF_TERM mres(ErlNifEnv* env,
                         const re2::StringPiece& str,
                         const re2::StringPiece& match,
                         const matchoptions::capture_type ct)
{
    switch (ct) {
    case matchoptions::CT_BINARY:
        ErlNifBinary bmatch;
        if(!enif_alloc_binary(match.size(), &bmatch))
            return a_err_alloc_binary;
        memcpy(bmatch.data, match.data(), match.size());
        return enif_make_binary(env, &bmatch);
    default:
    case matchoptions::CT_INDEX:
        int l, r;
        if (match.empty()) {
            l = -1;
            r = 0;
        } else {
            l = match.data() - str.data();
            r = match.size();
        }
        return enif_make_tuple2(env,
                                enif_make_int(env, l),
                                enif_make_int(env, r));
    }
}
Ejemplo n.º 21
0
/* 0: socket, 1: length */
    static ERL_NIF_TERM
nif_read(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
    int fd = -1;
    unsigned long len = 0;

    ErlNifBinary buf = {0};
    ssize_t bufsz = 0;


    if (!enif_get_int(env, argv[0], &fd))
        return enif_make_badarg(env);
    if (!enif_get_ulong(env, argv[1], &len))
        return enif_make_badarg(env);

    if (!enif_alloc_binary(len, &buf))
        return error_tuple(env, ENOMEM);

    if ( (bufsz = read(fd, buf.data, buf.size)) == -1) {
        int err = errno;
        enif_release_binary(&buf);
        switch (err) {
            case EAGAIN:
            case EINTR:
                return enif_make_tuple2(env, atom_error, atom_eagain);
            default:
                return error_tuple(env, err);
        }
    }

    PROCKET_REALLOC(buf, bufsz);

    return enif_make_tuple2(env, atom_ok, enif_make_binary(env, &buf));
}
Ejemplo n.º 22
0
static ERL_NIF_TERM bf_init(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
	ErlNifBinary state;
	char key[1024];
	char salt[1024];
	uint8_t key_len;
	unsigned long key_len_arg;
	uint8_t salt_len;

	if (argc != 3 || !enif_get_string(env, argv[0], key, sizeof(key), ERL_NIF_LATIN1) ||
			!enif_get_ulong(env, argv[1], &key_len_arg) ||
			!enif_get_string(env, argv[2], salt, sizeof(salt), ERL_NIF_LATIN1))
		return enif_make_badarg(env);
	key_len = key_len_arg;
	salt_len = BCRYPT_MAXSALT;

	if (!enif_alloc_binary(sizeof(blf_ctx), &state))
		return enif_make_badarg(env);

	Blowfish_initstate((blf_ctx *) state.data);
	Blowfish_expandstate((blf_ctx *) state.data, (uint8_t *) salt,
			salt_len, (uint8_t *) key, key_len);

	return enif_make_binary(env, &state);
}
Ejemplo n.º 23
0
static nif_term_t
salt_box_beforenm(nif_heap_t *hp, int argc, const nif_term_t argv[])
{
	/* salt_box_beforenm(Public_key, Secret_key) -> Context. */
	nif_bin_t 		pk;
	nif_bin_t 		sk;
	nif_bin_t 		bn;

	if (argc != 2)
		return (BADARG);

	/* Unpack arguments ensuring they're suitably typed. */
	if (! enif_inspect_binary(hp, argv[0], &pk))
		return (BADARG);

	if (! enif_inspect_binary(hp, argv[1], &sk))
		return (BADARG);

	/* Check size constraints. */
	if (pk.size != crypto_box_PUBLICKEYBYTES)
		return (BADARG);

	if (sk.size != crypto_box_SECRETKEYBYTES)
		return (BADARG);

	/* Allocate space for precomputed context. NB: Passing ENOMEM as BADARG. */
	if (! enif_alloc_binary(crypto_box_BEFORENMBYTES, &bn))
		return (BADARG);

	(void)crypto_box_beforenm(bn.data, pk.data, sk.data);
	return (enif_make_binary(hp, &bn));
}
Ejemplo n.º 24
0
Archivo: serctl.c Proyecto: jj1bdx/srly
    static ERL_NIF_TERM
nif_read(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
    SRLY_STATE *sp = NULL;
    unsigned long len = 0;

    ErlNifBinary buf = {0};
    ssize_t bufsz = 0;


    if (!enif_get_resource(env, argv[0], SRLY_STATE_RESOURCE, (void **)&sp))
        return enif_make_badarg(env);

    if (!enif_get_ulong(env, argv[1], &len))
        return enif_make_badarg(env);

    if (!enif_alloc_binary(len, &buf))
        return error_tuple(env, ENOMEM);

    if ( (bufsz = read(sp->fd, buf.data, buf.size)) < 0) {
        int err = errno;
        enif_release_binary(&buf);
        return error_tuple(env, err);
    }

    if (bufsz < buf.size && !enif_realloc_binary(&buf, bufsz)) {
        enif_release_binary(&buf);
        return error_tuple(env, ENOMEM);
    }

    return enif_make_tuple2(env, atom_ok, enif_make_binary(env, &buf));
}
Ejemplo n.º 25
0
static nif_term_t
salt_onetimeauth(nif_heap_t *hp, int argc, const nif_term_t argv[])
{
	/* salt_onetimeauth(Message, Secret_key) -> Authenticator. */
	nif_bin_t 		ms;
	nif_bin_t 		sk;
	nif_bin_t 		au;

	if (argc != 2)
		return (BADARG);

	/* Unpack arguments ensuring they're suitably typed. */
	if (! enif_inspect_iolist_as_binary(hp, argv[0], &ms))
		return (BADARG);

	if (! enif_inspect_binary(hp, argv[1], &sk))
		return (BADARG);

	/* Check constraints on size. */
	if (ms.size < 1 || ms.size > SALT_MAX_MESSAGE_SIZE)
		return (BADARG);

	if (sk.size != crypto_onetimeauth_KEYBYTES)
		return (BADARG);

	/* Allocate space for authenticator. NB: Passing ENOMEM as BADARG. */
	if (! enif_alloc_binary(crypto_onetimeauth_BYTES, &au))
		return (BADARG);

	(void)crypto_onetimeauth(au.data, ms.data, ms.size, sk.data);
	return (enif_make_binary(hp, &au));
}
Ejemplo n.º 26
0
ERL_NIF_TERM _hh_to_binary_uncompressed(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
    hh_ctx_t* ctx = NULL;
    ErlNifBinary target;

    ErlNifResourceType* ctx_type = get_hh_ctx_type(env);
    if (argc != 1 ||
        ctx_type == NULL ||
        !enif_get_resource(env, argv[0], ctx_type, (void **)&ctx))
    {
        return enif_make_badarg(env);
    }
    int size = 0;
    uint8_t* data = NULL;
    int success = hdr_encode_uncompressed(ctx->data, &data, &size);

    if (!enif_alloc_binary(size, &target))
    {
        return make_error(env, "bad_hdr_binary_alloc");
    }
    target.size = size;
    memcpy(target.data,data,size);
    free(data);

    if (success != 0)
    {
        return make_error(env, "bad_hdr_binary");
    }

    return enif_make_binary(env, &target);
}
static ERL_NIF_TERM
get(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
    redisContext *c;
    redisReply *reply;

		ErlNifBinary uid, ibin;
    if (!enif_inspect_binary(env, argv[0], &uid))    return enif_make_badarg(env);

    c = redisConnectUnix((const char*)"/tmp/redis.sock");
    if (c->err) {
				return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "redis_connection_error"));
    }

    reply = redisCommand(c, "GET %b", uid.data, uid.size);
    redisFree(c);

		if(reply->type == REDIS_REPLY_NIL){
      freeReplyObject(reply);
			return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "nil_reply"));
		} else {
			enif_alloc_binary(reply->len, &ibin);
			memcpy(ibin.data, reply->str, reply->len);
      freeReplyObject(reply);
			return enif_make_tuple2(env, enif_make_atom(env, "ok"), enif_make_binary(env, &ibin));
		}
}
Ejemplo n.º 28
0
static ERL_NIF_TERM
hexlify_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
    ErlNifBinary bin, ret;
    unsigned int flags = 0;
    unsigned i, j;
    const char* digits;

    if (argc != 2 ||
        !enif_inspect_binary(env, argv[0], &bin) ||
        !enif_get_uint(env, argv[1], &flags)) {
        return enif_make_badarg(env);
    }
    digits = (flags & HMAC_UPPER) ? UPPER : LOWER;
    enif_alloc_binary(bin.size*2, &ret);
    for (i = 0, j = 0; i < bin.size; ++i) {
        unsigned char c = bin.data[i];
        ret.data[j++] = digits[(c & 0xF0) >> 4];
        ret.data[j++] = digits[(c & 0x0F)];
    }
    if (flags & HMAC_STRING) {
        const char* data = (char*)ret.data;
        ERL_NIF_TERM s = enif_make_string_len(env, data, ret.size, ERL_NIF_LATIN1);
        enif_release_binary(&ret);
        return s;
    } else {
        return enif_make_binary(env, &ret);
    }
}
Ejemplo n.º 29
0
static ERL_NIF_TERM nif_get_part(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {

  gchar *path = get_char_argument(env, &argv[0]);
  if (!path)
    return enif_make_badarg(env);

  int part_id;
  if(!enif_get_int(env, argv[1], &part_id)){
    g_free(path);
    return enif_make_badarg(env);
  }

  GByteArray *attachment = gmimex_get_part(path, part_id);
  g_free(path);

  if (!attachment)
    return enif_make_badarg(env);

  ErlNifBinary result_binary = {0};
  enif_alloc_binary(attachment->len, &result_binary);
  (void)memcpy(result_binary.data, attachment->data, attachment->len);
  g_byte_array_free(attachment, TRUE);

  return enif_make_binary(env, &result_binary);
}
Ejemplo n.º 30
0
static ERL_NIF_TERM make_binary(ErlNifEnv* env, const char* bin) {
  ErlNifBinary new_bin;
  size_t len = strlen(bin);
  enif_alloc_binary(len, &new_bin);
  memcpy(new_bin.data, bin, len);
  return enif_make_binary(env, &new_bin);
}