Merge branch 'async-nif'
diff --git a/LICENSE b/LICENSE
index 8c982e3..f479304 100644
--- a/LICENSE
+++ b/LICENSE
@@ -82,3 +82,35 @@
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
+
+The asynchronous queue code (c_src/async_queue.c and
+c_src/async_queue.h) is from the esnappy project, copyright 2011
+Konstantin V. Sorokin. It is subject to the following license:
+
+Copyright (c) 2011 Konstantin V. Sorokin
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+3. Neither the name of the copyright holder nor the names of contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTOR(S) ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTOR(S) BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.
diff --git a/README.rst b/README.rst
index 2c8693d..4b84bfe 100644
--- a/README.rst
+++ b/README.rst
@@ -48,10 +48,10 @@
``mechanism``
Specifies whether to use the NIF implementation (``'nif'``) or a
- pool of port programs (``'port'``). Defaults to ``'port'``.
+ pool of port programs (``'port'``). Defaults to ``'nif'``.
- `WARNING: the NIF implementation will block Erlang VM scheduler
- threads and is not suitable for many applications.`
+ `Note: the NIF implementation no longer blocks the Erlang VM
+ scheduler threads`
``pool_size``
Specifies the size of the port program pool. Defaults to ``4``.
diff --git a/c_src/async_queue.c b/c_src/async_queue.c
new file mode 100644
index 0000000..e289c3a
--- /dev/null
+++ b/c_src/async_queue.c
@@ -0,0 +1,141 @@
+/*
+ From https://github.com/thekvs/esnappy:
+ Copyright (c) 2011 Konstantin V. Sorokin
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+
+ 1. Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ 3. Neither the name of the copyright holder nor the names of contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTOR(S) ``AS IS'' AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTOR(S) BE LIABLE
+ FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ SUCH DAMAGE.
+*/
+// vim: shiftwidth=4 expandtab
+#include "async_queue.h"
+
+async_queue_t*
+async_queue_create()
+{
+ async_queue_t *aq;
+
+ aq = ALLOC(sizeof(*aq));
+
+ if (!aq) {
+ errx(1, "enif_alloc() failed");
+ }
+
+ aq->q = ALLOC(sizeof(*(aq->q)));
+
+ if (!(aq->q)) {
+ errx(1, "enif_alloc() failed");
+ }
+
+ TAILQ_INIT(aq->q);
+
+ aq->waiting_threads = aq->len = 0;
+
+ aq->mutex = enif_mutex_create("erlang_snappy_mutex");
+
+ if (!aq->mutex) {
+ errx(1, "enif_mutex_create() failed");
+ }
+
+ aq->cond = enif_cond_create("erlang_snappy_condvar");
+
+ if (!aq->cond) {
+ errx(1, "enif_cond_create() failed");
+ }
+
+ return aq;
+}
+
+int
+async_queue_length(async_queue_t *aq)
+{
+ int length;
+
+ MUTEX_LOCK(aq->mutex);
+ length = aq->len - aq->waiting_threads;
+ MUTEX_UNLOCK(aq->mutex);
+
+ return length;
+}
+
+void *
+async_queue_pop(async_queue_t *aq)
+{
+ struct async_queue_entry *en;
+ void *d;
+
+ MUTEX_LOCK(aq->mutex);
+
+ d = NULL;
+ aq->waiting_threads++;
+ while (TAILQ_EMPTY(aq->q)) {
+ enif_cond_wait(aq->cond, aq->mutex);
+ }
+ aq->waiting_threads--;
+
+ en = TAILQ_FIRST(aq->q);
+ TAILQ_REMOVE(aq->q, en, entries);
+ d = en->data;
+ aq->len--;
+ enif_free(en);
+
+ MUTEX_UNLOCK(aq->mutex);
+
+ return d;
+}
+
+void
+async_queue_push(async_queue_t *aq, void *data)
+{
+ struct async_queue_entry *en;
+
+ MUTEX_LOCK(aq->mutex);
+
+ en = ALLOC(sizeof(*en));
+ en->data = data;
+ TAILQ_INSERT_TAIL(aq->q, en, entries);
+ aq->len++;
+
+ COND_SIGNAL(aq->cond);
+ MUTEX_UNLOCK(aq->mutex);
+}
+
+void
+async_queue_destroy(async_queue_t *aq)
+{
+ struct async_queue_entry *en;
+
+ while (!TAILQ_EMPTY(aq->q)) {
+ en = TAILQ_FIRST(aq->q);
+ TAILQ_REMOVE(aq->q, en, entries);
+ enif_free(en);
+ }
+
+ COND_DESTROY(aq->cond);
+ MUTEX_DESTROY(aq->mutex);
+
+ enif_free(aq->q);
+ enif_free(aq);
+}
+
diff --git a/c_src/async_queue.h b/c_src/async_queue.h
new file mode 100644
index 0000000..48384d0
--- /dev/null
+++ b/c_src/async_queue.h
@@ -0,0 +1,83 @@
+/*
+ From https://github.com/thekvs/esnappy:
+ Copyright (c) 2011 Konstantin V. Sorokin
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+
+ 1. Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ 3. Neither the name of the copyright holder nor the names of contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTOR(S) ``AS IS'' AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTOR(S) BE LIABLE
+ FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ SUCH DAMAGE.
+*/
+// vim: shiftwidth=4 expandtab
+#ifndef __ASYNC_QUEUE_H_INCLUDED__
+#define __ASYNC_QUEUE_H_INCLUDED__
+
+#include <sys/queue.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <err.h>
+
+#include <erl_nif.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+TAILQ_HEAD(queue, async_queue_entry);
+
+struct async_queue_entry {
+ TAILQ_ENTRY(async_queue_entry) entries;
+ void *data;
+};
+
+typedef struct __async_queue {
+ struct queue *q;
+ ErlNifMutex *mutex;
+ ErlNifCond *cond;
+ int waiting_threads;
+ int len;
+} async_queue_t;
+
+async_queue_t* async_queue_create();
+int async_queue_length(async_queue_t *aq);
+void* async_queue_pop(async_queue_t *aq);
+void async_queue_push(async_queue_t *aq, void *data);
+void async_queue_destroy(async_queue_t *aq);
+
+#define ALLOC(size) enif_alloc(size)
+#define MUTEX_LOCK(mutex) enif_mutex_lock(mutex)
+#define MUTEX_UNLOCK(mutex) enif_mutex_unlock(mutex)
+#define MUTEX_DESTROY(mutex) enif_mutex_destroy(mutex)
+#define COND_SIGNAL(condvar) enif_cond_signal(condvar)
+#define COND_DESTROY(condvar) enif_cond_destroy(condvar)
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif
diff --git a/c_src/bcrypt_nif.c b/c_src/bcrypt_nif.c
index 5dcf564..4186ac7 100644
--- a/c_src/bcrypt_nif.c
+++ b/c_src/bcrypt_nif.c
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2011 Hunter Morris <hunter.morris@smarkets.com>
+ * Copyright (c) 2011-2012 Hunter Morris <hunter.morris@smarkets.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@@ -14,6 +14,7 @@
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
+#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
@@ -21,13 +22,115 @@
#include "erl_nif.h"
#include "erl_blf.h"
+#include "bcrypt_nif.h"
-typedef unsigned char byte;
+void free_task(task_t* task)
+{
+ if (task->env != NULL)
+ enif_free_env(task->env);
+ enif_free(task);
+}
-char *bcrypt(const char *, const char *);
-void encode_salt(char *, u_int8_t *, u_int16_t, u_int8_t);
+task_t* alloc_task(task_type_t type)
+{
+ task_t* task = (task_t*)enif_alloc(sizeof(task_t));
+ if (task == NULL)
+ return NULL;
+ (void)memset(task, 0, sizeof(task_t));
+ task->type = type;
+ return task;
+}
-static ERL_NIF_TERM erl_encode_salt(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+task_t* alloc_init_task(task_type_t type, ERL_NIF_TERM ref, ErlNifPid pid, int num_orig_terms, const ERL_NIF_TERM orig_terms[])
+{
+ task_t* task = alloc_task(type);
+ task->pid = pid;
+ task->env = enif_alloc_env();
+ if (task->env == NULL) {
+ free_task(task);
+ return NULL;
+ }
+
+ if (type == HASH) {
+ assert(num_orig_terms == 2);
+ if (!enif_inspect_iolist_as_binary(
+ task->env, enif_make_copy(task->env, orig_terms[0]),
+ &task->data.hash.salt)) {
+ free_task(task);
+ return NULL;
+ }
+ if (!enif_inspect_iolist_as_binary(
+ task->env, enif_make_copy(task->env, orig_terms[1]),
+ &task->data.hash.password)) {
+ free_task(task);
+ return NULL;
+ }
+ }
+
+ task->ref = enif_make_copy(task->env, ref);
+ return task;
+}
+
+static ERL_NIF_TERM hashpw(task_t* task)
+{
+ char password[1024] = { 0 };
+ char salt[1024] = { 0 };
+ char *ret = NULL;
+
+ size_t password_sz = 1024;
+ if (password_sz > task->data.hash.password.size)
+ password_sz = task->data.hash.password.size;
+ (void)memcpy(&password, task->data.hash.password.data, password_sz);
+
+ size_t salt_sz = 1024;
+ if (salt_sz > task->data.hash.salt.size)
+ salt_sz = task->data.hash.salt.size;
+ (void)memcpy(&salt, task->data.hash.salt.data, salt_sz);
+
+ if (NULL == (ret = bcrypt(password, salt)) || 0 == strcmp(ret, ":")) {
+ return enif_make_tuple3(
+ task->env,
+ enif_make_atom(task->env, "error"),
+ task->ref,
+ enif_make_string(task->env, "bcrypt failed", ERL_NIF_LATIN1));
+ }
+
+ return enif_make_tuple3(
+ task->env,
+ enif_make_atom(task->env, "ok"),
+ task->ref,
+ enif_make_string(task->env, ret, ERL_NIF_LATIN1));
+}
+
+void* async_worker(void* arg)
+{
+ ctx_t* ctx;
+ task_t* task;
+
+ ERL_NIF_TERM result;
+
+ ctx = (ctx_t*)arg;
+
+ while (1) {
+ task = (task_t*)async_queue_pop(ctx->queue);
+
+ if (task->type == SHUTDOWN) {
+ free_task(task);
+ break;
+ } else if (task->type == HASH) {
+ result = hashpw(task);
+ } else {
+ errx(1, "Unexpected task type: %i", task->type);
+ }
+
+ enif_send(NULL, &task->pid, task->env, result);
+ free_task(task);
+ }
+
+ return NULL;
+}
+
+static ERL_NIF_TERM bcrypt_encode_salt(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
ErlNifBinary csalt, bin;
unsigned long log_rounds;
@@ -52,32 +155,87 @@
return enif_make_string(env, (char *)bin.data, ERL_NIF_LATIN1);
}
-static ERL_NIF_TERM hashpw(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+static ERL_NIF_TERM bcrypt_hashpw(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
- char pw[1024];
- char salt[1024];
- char *ret = NULL;
+ ctx_t *ctx;
+ task_t *task;
+ ErlNifPid pid;
- (void)memset(&pw, '\0', sizeof(pw));
- (void)memset(&salt, '\0', sizeof(salt));
-
- if (enif_get_string(env, argv[0], pw, sizeof(pw), ERL_NIF_LATIN1) < 1)
+ if (argc != 5)
return enif_make_badarg(env);
- if (enif_get_string(env, argv[1], salt, sizeof(salt), ERL_NIF_LATIN1) < 1)
+ bcrypt_privdata_t *priv = (bcrypt_privdata_t*)enif_priv_data(env);
+
+ if (!enif_get_resource(env, argv[0], priv->bcrypt_rt, (void**)(&ctx)))
return enif_make_badarg(env);
- if (NULL == (ret = bcrypt(pw, salt)) || 0 == strcmp(ret, ":")) {
+ if (!enif_is_ref(env, argv[1]))
+ return enif_make_badarg(env);
+
+ if (!enif_get_local_pid(env, argv[2], &pid))
+ return enif_make_badarg(env);
+
+ ERL_NIF_TERM orig_terms[] = { argv[4], argv[3] };
+ task = alloc_init_task(HASH, argv[1], pid, 2, orig_terms);
+
+ if (!task)
+ return enif_make_badarg(env);
+
+ async_queue_push(ctx->queue, task);
+
+ return enif_make_atom(env, "ok");
+}
+
+static ERL_NIF_TERM bcrypt_create_ctx(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+ ERL_NIF_TERM ret;
+ bcrypt_privdata_t *priv = (bcrypt_privdata_t*)enif_priv_data(env);
+ ctx_t* ctx = (ctx_t*)enif_alloc_resource(priv->bcrypt_rt, sizeof(ctx_t));
+ if (ctx == NULL)
+ return enif_make_badarg(env);
+ ctx->queue = async_queue_create();
+ ctx->topts = enif_thread_opts_create("bcrypt_thread_opts");
+ if (enif_thread_create("bcrypt_worker", &ctx->tid, async_worker, ctx, ctx->topts) != 0) {
+ enif_release_resource(ctx);
return enif_make_badarg(env);
}
-
- return enif_make_string(env, ret, ERL_NIF_LATIN1);
+ ret = enif_make_resource(env, ctx);
+ enif_release_resource(ctx);
+ return ret;
}
static ErlNifFunc bcrypt_nif_funcs[] =
{
- {"encode_salt", 2, erl_encode_salt},
- {"hashpw", 2, hashpw}
+ {"encode_salt", 2, bcrypt_encode_salt},
+ {"hashpw", 5, bcrypt_hashpw},
+ {"create_ctx", 0, bcrypt_create_ctx},
};
-ERL_NIF_INIT(bcrypt_nif, bcrypt_nif_funcs, NULL, NULL, NULL, NULL)
+static void bcrypt_rt_dtor(ErlNifEnv* env, void* obj)
+{
+ ctx_t *ctx = (ctx_t*)obj;
+ task_t *task = alloc_task(SHUTDOWN);
+ void *result = NULL;
+
+ async_queue_push(ctx->queue, task);
+ enif_thread_join(ctx->tid, &result);
+ async_queue_destroy(ctx->queue);
+ enif_thread_opts_destroy(ctx->topts);
+}
+
+static int on_load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info)
+{
+ const char *mod = "bcrypt_nif";
+ const char *name = "nif_resource";
+
+ ErlNifResourceFlags flags = (ErlNifResourceFlags)(ERL_NIF_RT_CREATE | ERL_NIF_RT_TAKEOVER);
+
+ bcrypt_privdata_t *priv = (bcrypt_privdata_t*)enif_alloc(sizeof(bcrypt_privdata_t));
+ priv->bcrypt_rt = enif_open_resource_type(env, mod, name, bcrypt_rt_dtor, flags, NULL);
+ if (priv->bcrypt_rt == NULL)
+ return -1;
+ *priv_data = priv;
+ return 0;
+}
+
+ERL_NIF_INIT(bcrypt_nif, bcrypt_nif_funcs, &on_load, NULL, NULL, NULL)
diff --git a/c_src/bcrypt_nif.h b/c_src/bcrypt_nif.h
new file mode 100644
index 0000000..5d513cb
--- /dev/null
+++ b/c_src/bcrypt_nif.h
@@ -0,0 +1,40 @@
+#ifndef ERLANG_BCRYPT_BCRYPT_NIF_H
+#define ERLANG_BCRYPT_BCRYPT_NIF_H
+
+#include "async_queue.h"
+
+typedef unsigned char byte;
+
+char *bcrypt(const char *, const char *);
+void encode_salt(char *, u_int8_t *, u_int16_t, u_int8_t);
+
+typedef struct {
+ ErlNifResourceType *bcrypt_rt;
+} bcrypt_privdata_t;
+
+typedef struct {
+ async_queue_t *queue;
+ ErlNifThreadOpts *topts;
+ ErlNifTid tid;
+} ctx_t;
+
+typedef enum {
+ UNKNOWN,
+ SHUTDOWN,
+ HASH
+} task_type_t;
+
+typedef struct {
+ task_type_t type;
+ ErlNifEnv *env;
+ ErlNifPid pid;
+ ERL_NIF_TERM ref;
+ union {
+ struct {
+ ErlNifBinary salt;
+ ErlNifBinary password;
+ } hash;
+ } data;
+} task_t;
+
+#endif // ERLANG_BCRYPT_BCRYPT_NIF_H
diff --git a/rebar.config b/rebar.config
index 3821a00..2d7e862 100644
--- a/rebar.config
+++ b/rebar.config
@@ -3,7 +3,7 @@
{so_specs,
[{"priv/bcrypt_nif.so",
- ["c_src/blowfish.o", "c_src/bcrypt.o", "c_src/bcrypt_nif.o"]}]}.
+ ["c_src/blowfish.o", "c_src/bcrypt.o", "c_src/bcrypt_nif.o", "c_src/async_queue.o"]}]}.
{post_hooks,
[{clean, "rm -f priv/bcrypt"},
diff --git a/src/bcrypt.app.src b/src/bcrypt.app.src
index 8242cb5..bf99118 100644
--- a/src/bcrypt.app.src
+++ b/src/bcrypt.app.src
@@ -1,7 +1,7 @@
%% -*- mode: erlang;erlang-indent-level: 2;indent-tabs-mode: nil -*-
{application, bcrypt,
[{description, "An Erlang wrapper (NIF or port program) for the OpenBSD password scheme, bcrypt."},
- {vsn, "0.4.1"},
+ {vsn, "0.5.0"},
{registered, [bcrypt_sup, bcrypt_nif_worker, bcrypt_port_sup, bcrypt_pool]},
{mod, {bcrypt_app, []}},
{applications, [kernel, stdlib, crypto]},
@@ -10,7 +10,7 @@
{default_log_rounds, 12},
% Mechanism to use 'nif' or 'port'
- {mechanism, port},
+ {mechanism, nif},
% Size of port program pool
{pool_size, 4}
diff --git a/src/bcrypt_nif.erl b/src/bcrypt_nif.erl
index 425c2ce..af83b0e 100644
--- a/src/bcrypt_nif.erl
+++ b/src/bcrypt_nif.erl
@@ -22,7 +22,7 @@
%% API
-export([init/0]).
--export([gen_salt/1, hashpw/2]).
+-export([gen_salt/1, hashpw/5, create_ctx/0]).
-on_load(init/0).
@@ -61,12 +61,24 @@
nif_stub_error(?LINE).
%%--------------------------------------------------------------------
-%% @doc Hash the specified password and the salt using the OpenBSD
-%% Blowfish password hashing algorithm. Returns the hashed password.
-%% @spec hashpw(Password::binary(), Salt::binary()) -> string()
+%% @doc Create a context which hashes passwords in a separate thread.
+%% @spec create_ctx() -> term()
%% @end
%%--------------------------------------------------------------------
-hashpw(_Password, _Salt) ->
+create_ctx() ->
+ nif_stub_error(?LINE).
+
+%%--------------------------------------------------------------------
+%% @doc Hash the specified password and the salt using the OpenBSD
+%% Blowfish password hashing algorithm. Returns the hashed password.
+%% @spec hashpw(Ctx::term(),
+%% Ref::reference(),
+%% Pid::pid(),
+%% Password::binary(),
+%% Salt::binary()) -> string()
+%% @end
+%%--------------------------------------------------------------------
+hashpw(_Ctx, _Ref, _Pid, _Password, _Salt) ->
nif_stub_error(?LINE).
nif_stub_error(Line) ->
diff --git a/src/bcrypt_nif_worker.erl b/src/bcrypt_nif_worker.erl
index a3bffd8..e849597 100644
--- a/src/bcrypt_nif_worker.erl
+++ b/src/bcrypt_nif_worker.erl
@@ -13,7 +13,10 @@
-export([init/1, code_change/3, terminate/2,
handle_call/3, handle_cast/2, handle_info/2]).
--record(state, {default_log_rounds}).
+-record(state, {
+ default_log_rounds,
+ context
+ }).
start_link() -> gen_server:start_link({local, ?MODULE}, ?MODULE, [], []).
@@ -25,7 +28,8 @@
init([]) ->
{ok, Default} = application:get_env(bcrypt, default_log_rounds),
- {ok, #state{default_log_rounds = Default}}.
+ Ctx = bcrypt_nif:create_ctx(),
+ {ok, #state{default_log_rounds = Default, context = Ctx}}.
terminate(shutdown, _) -> ok.
@@ -33,8 +37,15 @@
{reply, {ok, bcrypt_nif:gen_salt(R)}, State};
handle_call({gen_salt, R}, _From, State) ->
{reply, {ok, bcrypt_nif:gen_salt(R)}, State};
-handle_call({hashpw, Password, Salt}, _From, State) ->
- {reply, {ok, bcrypt_nif:hashpw(Password, Salt)}, State};
+handle_call({hashpw, Password, Salt}, _From, #state{context=Ctx}=State) ->
+ Ref = make_ref(),
+ ok = bcrypt_nif:hashpw(Ctx, Ref, self(), Password, Salt),
+ receive
+ {ok, Ref, Result} ->
+ {reply, {ok, Result}, State};
+ {error, Ref, Result} ->
+ {reply, {error, Result}, State}
+ end;
handle_call(Msg, _, _) -> exit({unknown_call, Msg}).
handle_cast(Msg, _) -> exit({unknown_cast, Msg}).
handle_info(Msg, _) -> exit({unknown_info, Msg}).
