ex_libsrtp

#include "srtp.h"

UNIFEX_TERM create_result(UnifexEnv *env, UnifexState *state) {
  return unifex_make_resource(env, state);
}

UNIFEX_TERM add_stream_result_ok(UnifexEnv *env) {
  return enif_make_atom(env, "ok");
}

UNIFEX_TERM remove_stream_result_ok(UnifexEnv *env) {
  return enif_make_atom(env, "ok");
}

UNIFEX_TERM update_result_ok(UnifexEnv *env) {
  return enif_make_atom(env, "ok");
}

UNIFEX_TERM protect_result_ok(UnifexEnv *env, UnifexPayload *payload) {
  return ({
    const ERL_NIF_TERM terms[] = {enif_make_atom(env, "ok"),
                                  unifex_payload_to_term(env, payload)};
    enif_make_tuple_from_array(env, terms, 2);
  });
}

UNIFEX_TERM unprotect_result_ok(UnifexEnv *env, UnifexPayload *payload) {
  return ({
    const ERL_NIF_TERM terms[] = {enif_make_atom(env, "ok"),
                                  unifex_payload_to_term(env, payload)};
    enif_make_tuple_from_array(env, terms, 2);
  });
}

UNIFEX_TERM unprotect_result_error_auth_fail(UnifexEnv *env) {
  return ({
    const ERL_NIF_TERM terms[] = {enif_make_atom(env, "error"),
                                  enif_make_atom(env, "auth_fail")};
    enif_make_tuple_from_array(env, terms, 2);
  });
}

UNIFEX_TERM unprotect_result_error_replay_fail(UnifexEnv *env) {
  return ({
    const ERL_NIF_TERM terms[] = {enif_make_atom(env, "error"),
                                  enif_make_atom(env, "replay_fail")};
    enif_make_tuple_from_array(env, terms, 2);
  });
}

UNIFEX_TERM unprotect_result_error_bad_mki(UnifexEnv *env) {
  return ({
    const ERL_NIF_TERM terms[] = {enif_make_atom(env, "error"),
                                  enif_make_atom(env, "bad_mki")};
    enif_make_tuple_from_array(env, terms, 2);
  });
}

UNIFEX_TERM unprotect_result_error_replay_too_old(UnifexEnv *env) {
  return ({
    const ERL_NIF_TERM terms[] = {enif_make_atom(env, "error"),
                                  enif_make_atom(env, "replay_too_old")};
    enif_make_tuple_from_array(env, terms, 2);
  });
}

ErlNifResourceType *STATE_RESOURCE_TYPE;

UnifexState *unifex_alloc_state(UnifexEnv *env) {
  UNIFEX_UNUSED(env);
  return (UnifexState *)enif_alloc_resource(STATE_RESOURCE_TYPE,
                                            sizeof(UnifexState));
}

void unifex_release_state(UnifexEnv *env, UnifexState *state) {
  UNIFEX_UNUSED(env);
  enif_release_resource(state);
}

void unifex_keep_state(UnifexEnv *env, UnifexState *state) {
  UNIFEX_UNUSED(env);
  enif_keep_resource(state);
}

static void destroy_state(ErlNifEnv *env, void *value) {
  UnifexState *state = (UnifexState *)value;
  UnifexEnv *unifex_env = env;
  handle_destroy_state(unifex_env, state);
}

static int unifex_load_nif(ErlNifEnv *env, void **priv_data,
                           ERL_NIF_TERM load_info) {
  UNIFEX_UNUSED(load_info);
  UNIFEX_UNUSED(priv_data);

  ErlNifResourceFlags flags =
      (ErlNifResourceFlags)(ERL_NIF_RT_CREATE | ERL_NIF_RT_TAKEOVER);

  STATE_RESOURCE_TYPE =
      enif_open_resource_type(env, NULL, "UnifexState",
                              (ErlNifResourceDtor *)destroy_state, flags, NULL);

  UNIFEX_PAYLOAD_GUARD_RESOURCE_TYPE = enif_open_resource_type(
      env, NULL, "UnifexPayloadGuard",
      (ErlNifResourceDtor *)unifex_payload_guard_destructor, flags, NULL);

  return on_load(env, priv_data);
}

static void unifex_unload_nif(ErlNifEnv *env, void *priv_data) {
  on_unload(env, priv_data);
}

static ERL_NIF_TERM export_create(ErlNifEnv *env, int argc,
                                  const ERL_NIF_TERM argv[]) {
  UNIFEX_MAYBE_UNUSED(argc);
  UNIFEX_MAYBE_UNUSED(argv);
  ERL_NIF_TERM result;
  UnifexEnv *unifex_env = env;

  result = create(unifex_env);
  goto exit_export_create;
exit_export_create:

  return result;
}

static ERL_NIF_TERM export_add_stream(ErlNifEnv *env, int argc,
                                      const ERL_NIF_TERM argv[]) {
  UNIFEX_MAYBE_UNUSED(argc);
  UNIFEX_MAYBE_UNUSED(argv);
  ERL_NIF_TERM result;
  UnifexEnv *unifex_env = env;
  UnifexState *state;
  int ssrc_type;
  unsigned int ssrc;
  UnifexPayload **keys;
  unsigned int keys_length;
  UnifexPayload **keys_mkis;
  unsigned int keys_mkis_length;
  char *rtp_crypto_profile;
  char *rtcp_crypto_profile;
  unsigned int window_size;
  int allow_repeat_tx;

  keys = NULL;
  keys_mkis = NULL;
  rtp_crypto_profile = NULL;
  rtcp_crypto_profile = NULL;

  if (!enif_get_resource(env, argv[0], STATE_RESOURCE_TYPE, (void **)&state)) {
    result = unifex_raise_args_error(env, "state", ":state");
    goto exit_export_add_stream;
  }

  if (!enif_get_int(env, argv[1], &ssrc_type)) {
    result = unifex_raise_args_error(env, "ssrc_type", ":int");
    goto exit_export_add_stream;
  }

  if (!enif_get_uint(env, argv[2], &ssrc)) {
    result = unifex_raise_args_error(env, "ssrc", ":unsigned");
    goto exit_export_add_stream;
  }

  if (!({
        int get_list_length_result =
            enif_get_list_length(env, argv[3], &keys_length);
        if (get_list_length_result) {
          keys = (UnifexPayload **)enif_alloc(sizeof(UnifexPayload *) *
                                              keys_length);

          for (unsigned int i = 0; i < keys_length; i++) {
            keys[i] = (UnifexPayload *)unifex_alloc(sizeof(UnifexPayload));
          }

          ERL_NIF_TERM list = argv[3];
          for (unsigned int i = 0; i < keys_length; i++) {
            ERL_NIF_TERM elem;
            enif_get_list_cell(env, list, &elem, &list);
            if (!unifex_payload_from_term(env, elem, keys[i])) {
              result =
                  unifex_raise_args_error(env, "keys", "{:list, :payload}");
              goto exit_export_add_stream;
            }
          }
        }
        get_list_length_result;
      })) {
    result = unifex_raise_args_error(env, "keys", "{:list, :payload}");
    goto exit_export_add_stream;
  }

  if (!({
        int get_list_length_result =
            enif_get_list_length(env, argv[4], &keys_mkis_length);
        if (get_list_length_result) {
          keys_mkis = (UnifexPayload **)enif_alloc(sizeof(UnifexPayload *) *
                                                   keys_mkis_length);

          for (unsigned int i = 0; i < keys_mkis_length; i++) {
            keys_mkis[i] = (UnifexPayload *)unifex_alloc(sizeof(UnifexPayload));
          }

          ERL_NIF_TERM list = argv[4];
          for (unsigned int i = 0; i < keys_mkis_length; i++) {
            ERL_NIF_TERM elem;
            enif_get_list_cell(env, list, &elem, &list);
            if (!unifex_payload_from_term(env, elem, keys_mkis[i])) {
              result = unifex_raise_args_error(env, "keys_mkis",
                                               "{:list, :payload}");
              goto exit_export_add_stream;
            }
          }
        }
        get_list_length_result;
      })) {
    result = unifex_raise_args_error(env, "keys_mkis", "{:list, :payload}");
    goto exit_export_add_stream;
  }

  if (!unifex_alloc_and_get_atom(env, argv[5], &rtp_crypto_profile)) {
    result = unifex_raise_args_error(env, "rtp_crypto_profile", ":atom");
    goto exit_export_add_stream;
  }

  if (!unifex_alloc_and_get_atom(env, argv[6], &rtcp_crypto_profile)) {
    result = unifex_raise_args_error(env, "rtcp_crypto_profile", ":atom");
    goto exit_export_add_stream;
  }

  if (!enif_get_uint(env, argv[7], &window_size)) {
    result = unifex_raise_args_error(env, "window_size", ":unsigned");
    goto exit_export_add_stream;
  }

  if (!unifex_parse_bool(env, argv[8], &allow_repeat_tx)) {
    result = unifex_raise_args_error(env, "allow_repeat_tx", ":bool");
    goto exit_export_add_stream;
  }

  result = add_stream(unifex_env, state, ssrc_type, ssrc, keys, keys_length,
                      keys_mkis, keys_mkis_length, rtp_crypto_profile,
                      rtcp_crypto_profile, window_size, allow_repeat_tx);
  goto exit_export_add_stream;
exit_export_add_stream:
  if (keys != NULL) {
    for (unsigned int i = 0; i < keys_length; i++) {
      unifex_payload_release(keys[i]);
      unifex_free(keys[i]);
    }
    unifex_free(keys);
  }

  if (keys_mkis != NULL) {
    for (unsigned int i = 0; i < keys_mkis_length; i++) {
      unifex_payload_release(keys_mkis[i]);
      unifex_free(keys_mkis[i]);
    }
    unifex_free(keys_mkis);
  }

  if (rtp_crypto_profile != NULL)
    unifex_free(rtp_crypto_profile);
  if (rtcp_crypto_profile != NULL)
    unifex_free(rtcp_crypto_profile);
  return result;
}

static ERL_NIF_TERM export_remove_stream(ErlNifEnv *env, int argc,
                                         const ERL_NIF_TERM argv[]) {
  UNIFEX_MAYBE_UNUSED(argc);
  UNIFEX_MAYBE_UNUSED(argv);
  ERL_NIF_TERM result;
  UnifexEnv *unifex_env = env;
  UnifexState *state;
  unsigned int ssrc;

  if (!enif_get_resource(env, argv[0], STATE_RESOURCE_TYPE, (void **)&state)) {
    result = unifex_raise_args_error(env, "state", ":state");
    goto exit_export_remove_stream;
  }

  if (!enif_get_uint(env, argv[1], &ssrc)) {
    result = unifex_raise_args_error(env, "ssrc", ":unsigned");
    goto exit_export_remove_stream;
  }

  result = remove_stream(unifex_env, state, ssrc);
  goto exit_export_remove_stream;
exit_export_remove_stream:

  return result;
}

static ERL_NIF_TERM export_update(ErlNifEnv *env, int argc,
                                  const ERL_NIF_TERM argv[]) {
  UNIFEX_MAYBE_UNUSED(argc);
  UNIFEX_MAYBE_UNUSED(argv);
  ERL_NIF_TERM result;
  UnifexEnv *unifex_env = env;
  UnifexState *state;
  int ssrc_type;
  unsigned int ssrc;
  UnifexPayload **keys;
  unsigned int keys_length;
  UnifexPayload **keys_mkis;
  unsigned int keys_mkis_length;
  char *rtp_crypto_profile;
  char *rtcp_crypto_profile;
  unsigned int window_size;
  int allow_repeat_tx;

  keys = NULL;
  keys_mkis = NULL;
  rtp_crypto_profile = NULL;
  rtcp_crypto_profile = NULL;

  if (!enif_get_resource(env, argv[0], STATE_RESOURCE_TYPE, (void **)&state)) {
    result = unifex_raise_args_error(env, "state", ":state");
    goto exit_export_update;
  }

  if (!enif_get_int(env, argv[1], &ssrc_type)) {
    result = unifex_raise_args_error(env, "ssrc_type", ":int");
    goto exit_export_update;
  }

  if (!enif_get_uint(env, argv[2], &ssrc)) {
    result = unifex_raise_args_error(env, "ssrc", ":unsigned");
    goto exit_export_update;
  }

  if (!({
        int get_list_length_result =
            enif_get_list_length(env, argv[3], &keys_length);
        if (get_list_length_result) {
          keys = (UnifexPayload **)enif_alloc(sizeof(UnifexPayload *) *
                                              keys_length);

          for (unsigned int i = 0; i < keys_length; i++) {
            keys[i] = (UnifexPayload *)unifex_alloc(sizeof(UnifexPayload));
          }

          ERL_NIF_TERM list = argv[3];
          for (unsigned int i = 0; i < keys_length; i++) {
            ERL_NIF_TERM elem;
            enif_get_list_cell(env, list, &elem, &list);
            if (!unifex_payload_from_term(env, elem, keys[i])) {
              result =
                  unifex_raise_args_error(env, "keys", "{:list, :payload}");
              goto exit_export_update;
            }
          }
        }
        get_list_length_result;
      })) {
    result = unifex_raise_args_error(env, "keys", "{:list, :payload}");
    goto exit_export_update;
  }

  if (!({
        int get_list_length_result =
            enif_get_list_length(env, argv[4], &keys_mkis_length);
        if (get_list_length_result) {
          keys_mkis = (UnifexPayload **)enif_alloc(sizeof(UnifexPayload *) *
                                                   keys_mkis_length);

          for (unsigned int i = 0; i < keys_mkis_length; i++) {
            keys_mkis[i] = (UnifexPayload *)unifex_alloc(sizeof(UnifexPayload));
          }

          ERL_NIF_TERM list = argv[4];
          for (unsigned int i = 0; i < keys_mkis_length; i++) {
            ERL_NIF_TERM elem;
            enif_get_list_cell(env, list, &elem, &list);
            if (!unifex_payload_from_term(env, elem, keys_mkis[i])) {
              result = unifex_raise_args_error(env, "keys_mkis",
                                               "{:list, :payload}");
              goto exit_export_update;
            }
          }
        }
        get_list_length_result;
      })) {
    result = unifex_raise_args_error(env, "keys_mkis", "{:list, :payload}");
    goto exit_export_update;
  }

  if (!unifex_alloc_and_get_atom(env, argv[5], &rtp_crypto_profile)) {
    result = unifex_raise_args_error(env, "rtp_crypto_profile", ":atom");
    goto exit_export_update;
  }

  if (!unifex_alloc_and_get_atom(env, argv[6], &rtcp_crypto_profile)) {
    result = unifex_raise_args_error(env, "rtcp_crypto_profile", ":atom");
    goto exit_export_update;
  }

  if (!enif_get_uint(env, argv[7], &window_size)) {
    result = unifex_raise_args_error(env, "window_size", ":unsigned");
    goto exit_export_update;
  }

  if (!unifex_parse_bool(env, argv[8], &allow_repeat_tx)) {
    result = unifex_raise_args_error(env, "allow_repeat_tx", ":bool");
    goto exit_export_update;
  }

  result = update(unifex_env, state, ssrc_type, ssrc, keys, keys_length,
                  keys_mkis, keys_mkis_length, rtp_crypto_profile,
                  rtcp_crypto_profile, window_size, allow_repeat_tx);
  goto exit_export_update;
exit_export_update:
  if (keys != NULL) {
    for (unsigned int i = 0; i < keys_length; i++) {
      unifex_payload_release(keys[i]);
      unifex_free(keys[i]);
    }
    unifex_free(keys);
  }

  if (keys_mkis != NULL) {
    for (unsigned int i = 0; i < keys_mkis_length; i++) {
      unifex_payload_release(keys_mkis[i]);
      unifex_free(keys_mkis[i]);
    }
    unifex_free(keys_mkis);
  }

  if (rtp_crypto_profile != NULL)
    unifex_free(rtp_crypto_profile);
  if (rtcp_crypto_profile != NULL)
    unifex_free(rtcp_crypto_profile);
  return result;
}

static ERL_NIF_TERM export_protect(ErlNifEnv *env, int argc,
                                   const ERL_NIF_TERM argv[]) {
  UNIFEX_MAYBE_UNUSED(argc);
  UNIFEX_MAYBE_UNUSED(argv);
  ERL_NIF_TERM result;
  UnifexEnv *unifex_env = env;
  UnifexState *state;
  char *what;
  UnifexPayload *payload;
  int use_mki;
  unsigned int mki_index;

  what = NULL;
  payload = (UnifexPayload *)unifex_alloc(sizeof(UnifexPayload));

  if (!enif_get_resource(env, argv[0], STATE_RESOURCE_TYPE, (void **)&state)) {
    result = unifex_raise_args_error(env, "state", ":state");
    goto exit_export_protect;
  }

  if (!unifex_alloc_and_get_atom(env, argv[1], &what)) {
    result = unifex_raise_args_error(env, "what", ":atom");
    goto exit_export_protect;
  }

  if (!unifex_payload_from_term(env, argv[2], payload)) {
    result = unifex_raise_args_error(env, "payload", ":payload");
    goto exit_export_protect;
  }

  if (!unifex_parse_bool(env, argv[3], &use_mki)) {
    result = unifex_raise_args_error(env, "use_mki", ":bool");
    goto exit_export_protect;
  }

  if (!enif_get_uint(env, argv[4], &mki_index)) {
    result = unifex_raise_args_error(env, "mki_index", ":unsigned");
    goto exit_export_protect;
  }

  result = protect(unifex_env, state, what, payload, use_mki, mki_index);
  goto exit_export_protect;
exit_export_protect:
  if (what != NULL)
    unifex_free(what);
  unifex_payload_release(payload);
  unifex_free(payload);

  return result;
}

static ERL_NIF_TERM export_unprotect(ErlNifEnv *env, int argc,
                                     const ERL_NIF_TERM argv[]) {
  UNIFEX_MAYBE_UNUSED(argc);
  UNIFEX_MAYBE_UNUSED(argv);
  ERL_NIF_TERM result;
  UnifexEnv *unifex_env = env;
  UnifexState *state;
  char *what;
  UnifexPayload *payload;
  int use_mki;

  what = NULL;
  payload = (UnifexPayload *)unifex_alloc(sizeof(UnifexPayload));

  if (!enif_get_resource(env, argv[0], STATE_RESOURCE_TYPE, (void **)&state)) {
    result = unifex_raise_args_error(env, "state", ":state");
    goto exit_export_unprotect;
  }

  if (!unifex_alloc_and_get_atom(env, argv[1], &what)) {
    result = unifex_raise_args_error(env, "what", ":atom");
    goto exit_export_unprotect;
  }

  if (!unifex_payload_from_term(env, argv[2], payload)) {
    result = unifex_raise_args_error(env, "payload", ":payload");
    goto exit_export_unprotect;
  }

  if (!unifex_parse_bool(env, argv[3], &use_mki)) {
    result = unifex_raise_args_error(env, "use_mki", ":bool");
    goto exit_export_unprotect;
  }

  result = unprotect(unifex_env, state, what, payload, use_mki);
  goto exit_export_unprotect;
exit_export_unprotect:
  if (what != NULL)
    unifex_free(what);
  unifex_payload_release(payload);
  unifex_free(payload);

  return result;
}

static ErlNifFunc nif_funcs[] = {
    {"unifex_create", 0, export_create, 0},
    {"unifex_add_stream", 9, export_add_stream, 0},
    {"unifex_remove_stream", 2, export_remove_stream, 0},
    {"unifex_update", 9, export_update, 0},
    {"unifex_protect", 5, export_protect, 0},
    {"unifex_unprotect", 4, export_unprotect, 0}};

ERL_NIF_INIT(Elixir.ExLibSRTP.Native.Nif, nif_funcs, unifex_load_nif, NULL,
             NULL, unifex_unload_nif)