Erlang NIF problem

#include "erl_nif.h"
#include <stdlib.h>
#include <time.h>
#include <stdio.h>

static int
load(ErlNifEnv* env, void** priv, ERL_NIF_TERM load_info)
{
  return 0;
}

static int
reload(ErlNifEnv* env, void** priv, ERL_NIF_TERM load_info)
{
  return 0;
}

static int
upgrade(ErlNifEnv* env, void** priv, void** old_priv,
    ERL_NIF_TERM load_info)
{
  return 0;
}

static void
unload(ErlNifEnv* env, void* priv)
{
  return;
}


// Function to generate binary
// Right now we are only constructing one binary and returns that.
static ERL_NIF_TERM
generate_binary(ErlNifEnv* env, int argc, const ERL_NIF_TERM *argv)
{

  ErlNifPid to_pid;
  ErlNifBinary bin;
  int SIZE, i;

  //ErlNifEnv *env = enif_alloc_env();


  enif_get_int(env, argv[0], &SIZE);
  fprintf(stderr, "Value of argv[0]: %d\n", SIZE);


  enif_get_local_pid(env, argv[1], &to_pid);

  // Allocate memory for the binary
  enif_alloc_binary(SIZE, &bin);


  srand( (unsigned int) time(NULL));

  fprintf(stderr, "SIZE = %d\n", SIZE);

  // This is just random data right now. We might want to generate something more useful
  for(i = 0; i < SIZE; i++)
    {
      fprintf(stderr, "Iteration %d\n", i);
      bin.data[i] = (i % 26) + 'a';
    }

  // Create a enviroment
  ErlNifEnv *tmp_env = enif_alloc_env();

  // Make a NIF_TERM out of our binary
  ERL_NIF_TERM msg = enif_make_binary(tmp_env, &bin);

  // We send a message to the PID we have in the argumentlist
  if(enif_send(NULL, &to_pid, tmp_env, msg))
    {
      fprintf(stderr, "Sent message");
    } else {
    fprintf(stderr, "Could not send message");
  }


  return enif_make_string(env, "Hello world", ERL_NIF_LATIN1);

}


static ERL_NIF_TERM
generate_buffer(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
  ErlNifTid thread;
  ErlNifThreadOpts *thread_opts;

  thread_opts = enif_thread_opts_create("thread_opts");





  int size, buffers_per_batch;
  ErlNifPid pid;

  // Extract the arguments
  if (!enif_get_int(env, argv[0], &size)) {
    fprintf(stderr, "Argument 1 not an int: %d\n", size);
    return enif_make_badarg(env);
  }


  if (!enif_get_int(env, argv[2], &buffers_per_batch)) {
    fprintf(stderr, "Argument 3 not an int: %d\n", buffers_per_batch);
    return enif_make_badarg(env);
  }

  if (!enif_get_local_pid(env, argv[1], &pid)) {
    fprintf(stderr, "Argument 2 not a pid\n");
    return enif_make_badarg(env);
  }
  ERL_NIF_TERM *arguments = (ERL_NIF_TERM *)malloc(sizeof(ERL_NIF_TERM)*5);

  arguments[0] = enif_make_int(env, size);
  arguments[1] = enif_make_pid(env, &pid);
  arguments[2] = enif_make_int(env, buffers_per_batch);


  enif_thread_create("data_generation", &thread, (void *)generate_binary, &arguments, NULL);



  return enif_make_string(env, "Hello World",ERL_NIF_LATIN1);
}

static ErlNifFunc mynif_funcs[] =
  {
    {"generate_binary", 3, generate_binary},
    {"generate_buffer", 3, generate_buffer}
  };


ERL_NIF_INIT(ctr_in_fg_nif,mynif_funcs,NULL,NULL,NULL,NULL);