ex_dtls

#include "native.h"
#include <stdio.h>

UnifexState *unifex_alloc_state(UnifexEnv *_env) {
  UNIFEX_UNUSED(_env);
  return (UnifexState *)malloc(sizeof(UnifexState));
}

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

void unifex_cnode_destroy_state(UnifexEnv *env, void *state) {
  handle_destroy_state(env, (UnifexState *)state);
  free(state);
}

UNIFEX_TERM init_result_ok(UnifexEnv *env, UnifexState *state) {
  UNIFEX_TERM out_buff = (ei_x_buff *)malloc(sizeof(ei_x_buff));
  unifex_cnode_prepare_ei_x_buff(env, out_buff, "result");

  ei_x_encode_atom(out_buff, "ok");
  {
    UnifexState *unifex_state = state;
    env->state = unifex_state;
  };

  return out_buff;
}

UNIFEX_TERM init_from_key_cert_result_ok(UnifexEnv *env, UnifexState *state) {
  UNIFEX_TERM out_buff = (ei_x_buff *)malloc(sizeof(ei_x_buff));
  unifex_cnode_prepare_ei_x_buff(env, out_buff, "result");

  ei_x_encode_atom(out_buff, "ok");
  {
    UnifexState *unifex_state = state;
    env->state = unifex_state;
  };

  return out_buff;
}

UNIFEX_TERM generate_cert_result_ok(UnifexEnv *env, UnifexPayload *cert,
                                    UnifexState *state) {
  UNIFEX_TERM out_buff = (ei_x_buff *)malloc(sizeof(ei_x_buff));
  unifex_cnode_prepare_ei_x_buff(env, out_buff, "result");

  ei_x_encode_tuple_header(out_buff, 2);
  ei_x_encode_atom(out_buff, "ok");
  unifex_payload_encode(env, out_buff, cert);
  {
    UnifexState *unifex_state = state;
    env->state = unifex_state;
  };

  return out_buff;
}

UNIFEX_TERM get_pkey_result_ok(UnifexEnv *env, UnifexPayload *pkey,
                               UnifexState *state) {
  UNIFEX_TERM out_buff = (ei_x_buff *)malloc(sizeof(ei_x_buff));
  unifex_cnode_prepare_ei_x_buff(env, out_buff, "result");

  ei_x_encode_tuple_header(out_buff, 2);
  ei_x_encode_atom(out_buff, "ok");
  unifex_payload_encode(env, out_buff, pkey);
  {
    UnifexState *unifex_state = state;
    env->state = unifex_state;
  };

  return out_buff;
}

UNIFEX_TERM get_cert_result_ok(UnifexEnv *env, UnifexPayload *cert,
                               UnifexState *state) {
  UNIFEX_TERM out_buff = (ei_x_buff *)malloc(sizeof(ei_x_buff));
  unifex_cnode_prepare_ei_x_buff(env, out_buff, "result");

  ei_x_encode_tuple_header(out_buff, 2);
  ei_x_encode_atom(out_buff, "ok");
  unifex_payload_encode(env, out_buff, cert);
  {
    UnifexState *unifex_state = state;
    env->state = unifex_state;
  };

  return out_buff;
}

UNIFEX_TERM get_cert_fingerprint_result_ok(UnifexEnv *env,
                                           UnifexPayload *fingerprint,
                                           UnifexState *state) {
  UNIFEX_TERM out_buff = (ei_x_buff *)malloc(sizeof(ei_x_buff));
  unifex_cnode_prepare_ei_x_buff(env, out_buff, "result");

  ei_x_encode_tuple_header(out_buff, 2);
  ei_x_encode_atom(out_buff, "ok");
  unifex_payload_encode(env, out_buff, fingerprint);
  {
    UnifexState *unifex_state = state;
    env->state = unifex_state;
  };

  return out_buff;
}

UNIFEX_TERM do_handshake_result_ok(UnifexEnv *env, UnifexPayload *packets,
                                   UnifexState *state) {
  UNIFEX_TERM out_buff = (ei_x_buff *)malloc(sizeof(ei_x_buff));
  unifex_cnode_prepare_ei_x_buff(env, out_buff, "result");

  ei_x_encode_tuple_header(out_buff, 2);
  ei_x_encode_atom(out_buff, "ok");
  unifex_payload_encode(env, out_buff, packets);
  {
    UnifexState *unifex_state = state;
    env->state = unifex_state;
  };

  return out_buff;
}

UNIFEX_TERM handle_timeout_result_ok(UnifexEnv *env, UnifexState *state) {
  UNIFEX_TERM out_buff = (ei_x_buff *)malloc(sizeof(ei_x_buff));
  unifex_cnode_prepare_ei_x_buff(env, out_buff, "result");

  ei_x_encode_atom(out_buff, "ok");
  {
    UnifexState *unifex_state = state;
    env->state = unifex_state;
  };

  return out_buff;
}

UNIFEX_TERM handle_timeout_result_retransmit(UnifexEnv *env,
                                             UnifexPayload *packets,
                                             UnifexState *state) {
  UNIFEX_TERM out_buff = (ei_x_buff *)malloc(sizeof(ei_x_buff));
  unifex_cnode_prepare_ei_x_buff(env, out_buff, "result");

  ei_x_encode_tuple_header(out_buff, 2);
  ei_x_encode_atom(out_buff, "retransmit");
  unifex_payload_encode(env, out_buff, packets);
  {
    UnifexState *unifex_state = state;
    env->state = unifex_state;
  };

  return out_buff;
}

UNIFEX_TERM process_result_ok(UnifexEnv *env, UnifexState *state,
                              UnifexPayload *packets) {
  UNIFEX_TERM out_buff = (ei_x_buff *)malloc(sizeof(ei_x_buff));
  unifex_cnode_prepare_ei_x_buff(env, out_buff, "result");

  ei_x_encode_tuple_header(out_buff, 2);
  ei_x_encode_atom(out_buff, "ok");
  {
    UnifexState *unifex_state = state;
    env->state = unifex_state;
  };

  unifex_payload_encode(env, out_buff, packets);

  return out_buff;
}

UNIFEX_TERM process_result_hsk_want_read(UnifexEnv *env, UnifexState *state) {
  UNIFEX_TERM out_buff = (ei_x_buff *)malloc(sizeof(ei_x_buff));
  unifex_cnode_prepare_ei_x_buff(env, out_buff, "result");

  ei_x_encode_atom(out_buff, "hsk_want_read");
  {
    UnifexState *unifex_state = state;
    env->state = unifex_state;
  };

  return out_buff;
}

UNIFEX_TERM process_result_hsk_packets(UnifexEnv *env, UnifexPayload *packets,
                                       UnifexState *state) {
  UNIFEX_TERM out_buff = (ei_x_buff *)malloc(sizeof(ei_x_buff));
  unifex_cnode_prepare_ei_x_buff(env, out_buff, "result");

  ei_x_encode_tuple_header(out_buff, 2);
  ei_x_encode_atom(out_buff, "hsk_packets");
  unifex_payload_encode(env, out_buff, packets);
  {
    UnifexState *unifex_state = state;
    env->state = unifex_state;
  };

  return out_buff;
}

UNIFEX_TERM process_result_hsk_finished(UnifexEnv *env,
                                        UnifexPayload *client_keying_material,
                                        UnifexPayload *server_keying_material,
                                        int protection_profile,
                                        UnifexPayload *packets,
                                        UnifexState *state) {
  UNIFEX_TERM out_buff = (ei_x_buff *)malloc(sizeof(ei_x_buff));
  unifex_cnode_prepare_ei_x_buff(env, out_buff, "result");

  ei_x_encode_tuple_header(out_buff, 5);
  ei_x_encode_atom(out_buff, "hsk_finished");
  unifex_payload_encode(env, out_buff, client_keying_material);
  unifex_payload_encode(env, out_buff, server_keying_material);
  ({
    int tmp_int = protection_profile;
    ei_x_encode_longlong(out_buff, (long long)tmp_int);
  });

  unifex_payload_encode(env, out_buff, packets);
  {
    UnifexState *unifex_state = state;
    env->state = unifex_state;
  };

  return out_buff;
}

UNIFEX_TERM
process_result_connection_closed_peer_closed_for_writing(UnifexEnv *env,
                                                         UnifexState *state) {
  UNIFEX_TERM out_buff = (ei_x_buff *)malloc(sizeof(ei_x_buff));
  unifex_cnode_prepare_ei_x_buff(env, out_buff, "result");

  ei_x_encode_tuple_header(out_buff, 2);
  ei_x_encode_atom(out_buff, "connection_closed");
  ei_x_encode_atom(out_buff, "peer_closed_for_writing");
  {
    UnifexState *unifex_state = state;
    env->state = unifex_state;
  };

  return out_buff;
}

UNIFEX_TERM init_caller(UnifexEnv *env, UnifexCNodeInBuff *in_buff) {
  UNIFEX_MAYBE_UNUSED(in_buff);
  UNIFEX_TERM result;
  int client_mode;
  int dtls_srtp;

  if (({
        int res = -1;
        char boolean_str[6];
        ei_decode_atom(in_buff->buff, in_buff->index, boolean_str);

        if (strcmp(boolean_str, "true") == 0) {
          client_mode = 1;
          res = 0;
        } else if (strcmp(boolean_str, "false") == 0) {
          client_mode = 0;
          res = 0;
        }
        res;
      })) {
    result = unifex_raise(
        env,
        "Unifex CNode: cannot parse argument 'client_mode' of type ':bool'");
    goto exit_init_caller;
  }

  if (({
        int res = -1;
        char boolean_str[6];
        ei_decode_atom(in_buff->buff, in_buff->index, boolean_str);

        if (strcmp(boolean_str, "true") == 0) {
          dtls_srtp = 1;
          res = 0;
        } else if (strcmp(boolean_str, "false") == 0) {
          dtls_srtp = 0;
          res = 0;
        }
        res;
      })) {
    result = unifex_raise(
        env, "Unifex CNode: cannot parse argument 'dtls_srtp' of type ':bool'");
    goto exit_init_caller;
  }

  result = init(env, client_mode, dtls_srtp);
  goto exit_init_caller;
exit_init_caller:

  return result;
}

UNIFEX_TERM init_from_key_cert_caller(UnifexEnv *env,
                                      UnifexCNodeInBuff *in_buff) {
  UNIFEX_MAYBE_UNUSED(in_buff);
  UNIFEX_TERM result;
  int client_mode;
  int dtls_srtp;
  UnifexPayload *pkey;
  UnifexPayload *cert;

  pkey = NULL;
  cert = NULL;
  if (({
        int res = -1;
        char boolean_str[6];
        ei_decode_atom(in_buff->buff, in_buff->index, boolean_str);

        if (strcmp(boolean_str, "true") == 0) {
          client_mode = 1;
          res = 0;
        } else if (strcmp(boolean_str, "false") == 0) {
          client_mode = 0;
          res = 0;
        }
        res;
      })) {
    result = unifex_raise(
        env,
        "Unifex CNode: cannot parse argument 'client_mode' of type ':bool'");
    goto exit_init_from_key_cert_caller;
  }

  if (({
        int res = -1;
        char boolean_str[6];
        ei_decode_atom(in_buff->buff, in_buff->index, boolean_str);

        if (strcmp(boolean_str, "true") == 0) {
          dtls_srtp = 1;
          res = 0;
        } else if (strcmp(boolean_str, "false") == 0) {
          dtls_srtp = 0;
          res = 0;
        }
        res;
      })) {
    result = unifex_raise(
        env, "Unifex CNode: cannot parse argument 'dtls_srtp' of type ':bool'");
    goto exit_init_from_key_cert_caller;
  }

  if (unifex_payload_decode(env, in_buff, &pkey)) {
    result = unifex_raise(
        env, "Unifex CNode: cannot parse argument 'pkey' of type ':payload'");
    goto exit_init_from_key_cert_caller;
  }

  if (unifex_payload_decode(env, in_buff, &cert)) {
    result = unifex_raise(
        env, "Unifex CNode: cannot parse argument 'cert' of type ':payload'");
    goto exit_init_from_key_cert_caller;
  }

  result = init_from_key_cert(env, client_mode, dtls_srtp, pkey, cert);
  goto exit_init_from_key_cert_caller;
exit_init_from_key_cert_caller:
  if (pkey && !pkey->owned) {
    unifex_payload_release(pkey);
  }
  unifex_free(pkey);

  if (cert && !cert->owned) {
    unifex_payload_release(cert);
  }
  unifex_free(cert);

  return result;
}

UNIFEX_TERM generate_cert_caller(UnifexEnv *env, UnifexCNodeInBuff *in_buff) {
  UNIFEX_MAYBE_UNUSED(in_buff);
  UNIFEX_TERM result;
  UnifexState *state;

  if (({
        state = (UnifexState *)env->state;
        0;
      })) {
    result = unifex_raise(
        env, "Unifex CNode: cannot parse argument 'state' of type ':state'");
    goto exit_generate_cert_caller;
  }

  result = generate_cert(env, state);
  goto exit_generate_cert_caller;
exit_generate_cert_caller:

  return result;
}

UNIFEX_TERM get_pkey_caller(UnifexEnv *env, UnifexCNodeInBuff *in_buff) {
  UNIFEX_MAYBE_UNUSED(in_buff);
  UNIFEX_TERM result;
  UnifexState *state;

  if (({
        state = (UnifexState *)env->state;
        0;
      })) {
    result = unifex_raise(
        env, "Unifex CNode: cannot parse argument 'state' of type ':state'");
    goto exit_get_pkey_caller;
  }

  result = get_pkey(env, state);
  goto exit_get_pkey_caller;
exit_get_pkey_caller:

  return result;
}

UNIFEX_TERM get_cert_caller(UnifexEnv *env, UnifexCNodeInBuff *in_buff) {
  UNIFEX_MAYBE_UNUSED(in_buff);
  UNIFEX_TERM result;
  UnifexState *state;

  if (({
        state = (UnifexState *)env->state;
        0;
      })) {
    result = unifex_raise(
        env, "Unifex CNode: cannot parse argument 'state' of type ':state'");
    goto exit_get_cert_caller;
  }

  result = get_cert(env, state);
  goto exit_get_cert_caller;
exit_get_cert_caller:

  return result;
}

UNIFEX_TERM get_cert_fingerprint_caller(UnifexEnv *env,
                                        UnifexCNodeInBuff *in_buff) {
  UNIFEX_MAYBE_UNUSED(in_buff);
  UNIFEX_TERM result;
  UnifexState *state;

  if (({
        state = (UnifexState *)env->state;
        0;
      })) {
    result = unifex_raise(
        env, "Unifex CNode: cannot parse argument 'state' of type ':state'");
    goto exit_get_cert_fingerprint_caller;
  }

  result = get_cert_fingerprint(env, state);
  goto exit_get_cert_fingerprint_caller;
exit_get_cert_fingerprint_caller:

  return result;
}

UNIFEX_TERM do_handshake_caller(UnifexEnv *env, UnifexCNodeInBuff *in_buff) {
  UNIFEX_MAYBE_UNUSED(in_buff);
  UNIFEX_TERM result;
  UnifexState *state;

  if (({
        state = (UnifexState *)env->state;
        0;
      })) {
    result = unifex_raise(
        env, "Unifex CNode: cannot parse argument 'state' of type ':state'");
    goto exit_do_handshake_caller;
  }

  result = do_handshake(env, state);
  goto exit_do_handshake_caller;
exit_do_handshake_caller:

  return result;
}

UNIFEX_TERM handle_timeout_caller(UnifexEnv *env, UnifexCNodeInBuff *in_buff) {
  UNIFEX_MAYBE_UNUSED(in_buff);
  UNIFEX_TERM result;
  UnifexState *state;

  if (({
        state = (UnifexState *)env->state;
        0;
      })) {
    result = unifex_raise(
        env, "Unifex CNode: cannot parse argument 'state' of type ':state'");
    goto exit_handle_timeout_caller;
  }

  result = handle_timeout(env, state);
  goto exit_handle_timeout_caller;
exit_handle_timeout_caller:

  return result;
}

UNIFEX_TERM process_caller(UnifexEnv *env, UnifexCNodeInBuff *in_buff) {
  UNIFEX_MAYBE_UNUSED(in_buff);
  UNIFEX_TERM result;
  UnifexState *state;
  UnifexPayload *packets;

  packets = NULL;
  if (({
        state = (UnifexState *)env->state;
        0;
      })) {
    result = unifex_raise(
        env, "Unifex CNode: cannot parse argument 'state' of type ':state'");
    goto exit_process_caller;
  }

  if (unifex_payload_decode(env, in_buff, &packets)) {
    result = unifex_raise(
        env,
        "Unifex CNode: cannot parse argument 'packets' of type ':payload'");
    goto exit_process_caller;
  }

  result = process(env, state, packets);
  goto exit_process_caller;
exit_process_caller:
  if (packets && !packets->owned) {
    unifex_payload_release(packets);
  }
  unifex_free(packets);

  return result;
}

UNIFEX_TERM unifex_cnode_handle_message(UnifexEnv *env, char *fun_name,
                                        UnifexCNodeInBuff *in_buff) {
  if (strcmp(fun_name, "init") == 0) {
    return init_caller(env, in_buff);
  } else if (strcmp(fun_name, "init_from_key_cert") == 0) {
    return init_from_key_cert_caller(env, in_buff);
  } else if (strcmp(fun_name, "generate_cert") == 0) {
    return generate_cert_caller(env, in_buff);
  } else if (strcmp(fun_name, "get_pkey") == 0) {
    return get_pkey_caller(env, in_buff);
  } else if (strcmp(fun_name, "get_cert") == 0) {
    return get_cert_caller(env, in_buff);
  } else if (strcmp(fun_name, "get_cert_fingerprint") == 0) {
    return get_cert_fingerprint_caller(env, in_buff);
  } else if (strcmp(fun_name, "do_handshake") == 0) {
    return do_handshake_caller(env, in_buff);
  } else if (strcmp(fun_name, "handle_timeout") == 0) {
    return handle_timeout_caller(env, in_buff);
  } else if (strcmp(fun_name, "process") == 0) {
    return process_caller(env, in_buff);
  } else {
    return unifex_cnode_undefined_function_error(env, fun_name);
  }
}

int main(int argc, char **argv) {
  return unifex_cnode_main_function(argc, argv);
}