static ERL_NIF_TERM macros(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
const ERL_NIF_TERM* a;
ERL_NIF_TERM lists, tuples;
int arity;
if (!enif_get_tuple(env, argv[0], &arity, &a) || arity != 9) {
return enif_make_badarg(env);
}
lists = enif_make_list(env,9,
enif_make_list1(env,a[0]),
enif_make_list2(env,a[0],a[1]),
enif_make_list3(env,a[0],a[1],a[2]),
enif_make_list4(env,a[0],a[1],a[2],a[3]),
enif_make_list5(env,a[0],a[1],a[2],a[3],a[4]),
enif_make_list6(env,a[0],a[1],a[2],a[3],a[4],a[5]),
enif_make_list7(env,a[0],a[1],a[2],a[3],a[4],a[5],a[6]),
enif_make_list8(env,a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7]),
enif_make_list9(env,a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8]));
tuples = enif_make_list(env,9,
enif_make_tuple1(env,a[0]),
enif_make_tuple2(env,a[0],a[1]),
enif_make_tuple3(env,a[0],a[1],a[2]),
enif_make_tuple4(env,a[0],a[1],a[2],a[3]),
enif_make_tuple5(env,a[0],a[1],a[2],a[3],a[4]),
enif_make_tuple6(env,a[0],a[1],a[2],a[3],a[4],a[5]),
enif_make_tuple7(env,a[0],a[1],a[2],a[3],a[4],a[5],a[6]),
enif_make_tuple8(env,a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7]),
enif_make_tuple9(env,a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8]));
return enif_make_tuple2(env,lists,tuples);
}
ERL_NIF_TERM algorithms(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
#ifdef FIPS_SUPPORT
int fips_mode = FIPS_mode();
unsigned int hash_cnt = fips_mode ? algo_hash_fips_cnt : algo_hash_cnt;
unsigned int pubkey_cnt = fips_mode ? algo_pubkey_fips_cnt : algo_pubkey_cnt;
unsigned int mac_cnt = fips_mode ? algo_mac_fips_cnt : algo_mac_cnt;
unsigned int curve_cnt = fips_mode ? algo_curve_fips_cnt : algo_curve_cnt;
unsigned int rsa_opts_cnt = fips_mode ? algo_rsa_opts_fips_cnt : algo_rsa_opts_cnt;
#else
unsigned int hash_cnt = algo_hash_cnt;
unsigned int pubkey_cnt = algo_pubkey_cnt;
unsigned int mac_cnt = algo_mac_cnt;
unsigned int curve_cnt = algo_curve_cnt;
unsigned int rsa_opts_cnt = algo_rsa_opts_cnt;
#endif
return enif_make_tuple6(env,
enif_make_list_from_array(env, algo_hash, hash_cnt),
enif_make_list_from_array(env, algo_pubkey, pubkey_cnt),
cipher_types_as_list(env),
enif_make_list_from_array(env, algo_mac, mac_cnt),
enif_make_list_from_array(env, algo_curve, curve_cnt),
enif_make_list_from_array(env, algo_rsa_opts, rsa_opts_cnt)
);
}
static ERL_NIF_TERM get_imginfo(ErlNifEnv* env, GDALDatasetH out_ds) {
double padfTransform[6];
GDALGetGeoTransform(out_ds, padfTransform);
if (padfTransform[2] != 0.0 && padfTransform[4] != 0.0) {
return ATOM_ERROR;
}
return enif_make_tuple6(env,
enif_make_double(env, padfTransform[0]), // OriginX
enif_make_double(env, padfTransform[3]), // OriginY
enif_make_double(env, padfTransform[1]), // PixelXSize
enif_make_double(env, padfTransform[5]), // PixelYSize
enif_make_int(env, GDALGetRasterXSize(out_ds)), // RasterXSize
enif_make_int(env, GDALGetRasterYSize(out_ds)));// RasterYSize
}
void
ewpcap_send(u_char *user, const struct pcap_pkthdr *h, const u_char *bytes)
{
EWPCAP_STATE *ep = (EWPCAP_STATE *)user;
ErlNifBinary buf = {0};
int rv = 0;
/* XXX no way to indicate an error? */
if (ep->p == NULL)
return;
if (!enif_alloc_binary(h->caplen, &buf)) {
pcap_breakloop(ep->p);
return;
}
(void)memcpy(buf.data, bytes, buf.size);
/* {ewpcap, Ref, DatalinkType, Time, ActualLength, Packet} */
rv = enif_send(
NULL,
&ep->pid,
ep->env,
enif_make_tuple6(ep->env,
atom_ewpcap,
enif_make_copy(ep->env, ep->ref),
enif_make_int(ep->env, ep->datalink),
enif_make_tuple3(ep->env,
enif_make_ulong(ep->env, abs(h->ts.tv_sec / 1000000)),
enif_make_ulong(ep->env, h->ts.tv_sec % 1000000),
enif_make_ulong(ep->env, h->ts.tv_usec)
),
enif_make_ulong(ep->env, h->len),
enif_make_binary(ep->env, &buf)
)
);
if (!rv)
pcap_breakloop(ep->p);
enif_clear_env(ep->env);
}
/*-----------------------------------------------------------------------------------------------------------------------*/
static ERL_NIF_TERM get_header(ErlNifEnv* env, int32_t argc, ERL_NIF_TERM const argv[])
{
int32_t delimiter = 0;
ErlNifBinary bin;
if (!enif_inspect_binary(env, argv[0], &bin))
{
return make_error(env, FIX_FAILED, "Wrong delimiter.");
}
if (!enif_get_int(env, argv[1], &delimiter) || delimiter <= 0 || delimiter >= 255)
{
return make_error(env, FIX_FAILED, "Wrong binary.");
}
char const* beginString = NULL;
uint32_t beginStringLen = 0;
char const* msgType = NULL;
uint32_t msgTypeLen = 0;
char const* senderCompID = NULL;
uint32_t senderCompIDLen = 0;
char const* targetCompID = NULL;
uint32_t targetCompIDLen = 0;
int64_t msgSeqNum = 0;
FIXError* error = NULL;
if (FIX_FAILED == fix_parser_get_header((char const*)bin.data, bin.size, delimiter,
&beginString, &beginStringLen, &msgType, &msgTypeLen, &senderCompID, &senderCompIDLen,
&targetCompID, &targetCompIDLen, &msgSeqNum, &error))
{
ERL_NIF_TERM err = make_error(env, fix_error_get_code(error), fix_error_get_text(error));
fix_error_free(error);
return err;
}
return enif_make_tuple2(env, ok_atom,
enif_make_tuple6(env, msg_header,
enif_make_string_len(env, beginString, beginStringLen, ERL_NIF_LATIN1),
enif_make_string_len(env, msgType, msgTypeLen, ERL_NIF_LATIN1),
enif_make_string_len(env, senderCompID, senderCompIDLen, ERL_NIF_LATIN1),
enif_make_string_len(env, targetCompID, targetCompIDLen, ERL_NIF_LATIN1),
enif_make_int64(env, msgSeqNum)));
}
static ERL_NIF_TERM
get_config(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
return enif_make_list2(env,
enif_make_tuple2(env,
enif_make_string(env,"sizes", ERL_NIF_LATIN1),
enif_make_tuple6(env,
enif_make_uint(env, sizeof(short int)),
enif_make_uint(env, sizeof(int)),
enif_make_uint(env, sizeof(long int)),
enif_make_uint(env, sizeof(long long int)),
enif_make_uint(env, sizeof(float)),
enif_make_uint(env, sizeof(double)))),
enif_make_tuple2(env,
enif_make_string(env, "arch", ERL_NIF_LATIN1),
enif_make_tuple2(env,
#ifdef ENV64BIT
enif_make_string(env, "64bit", ERL_NIF_LATIN1),
#endif
#ifdef ENV32BIT
enif_make_string(env, "32bit", ERL_NIF_LATIN1),
#endif
enif_make_uint(env, sizeof(char*)))));
}
ERL_NIF_TERM parse_line(Parser* parser) {
unsigned long idx = parser->frame_start;
unsigned col = 0;
ERL_NIF_TERM reply[parser->table_width];
while(col < parser->table_width) {
unsigned char size_length = (parser->buffer[idx] <= MYSQL_LIMIT_BYTE) ? (1) : (parser->buffer[idx] - MYSQL_LIMIT_BYTE);
size_length *= (size_length == 4) ? (2) : (1);
unsigned long long content_length = 0;
if (parser->buffer[idx] != MYSQL_NULL_RESULT) {
switch (size_length) {
case 1:
content_length = D1(parser->buffer + idx);
break;
case 2:
content_length = D2I(parser->buffer + idx + 1);
size_length++;
break;
case 3:
content_length = D3I(parser->buffer + idx + 1);
size_length++;
break;
case 8:
content_length = D8I(parser->buffer + idx + 1);
size_length++;
break;
}
} else content_length = 0;
unsigned char *new_val = parser->buffer + idx + size_length;
MYSQL_TIME time_;
if (content_length == 0) reply[col] = parser->atoms->atom_undefined;
else if (parser->columns[col] == MYSQL_TYPE_BIT
|| parser->columns[col] == MYSQL_TYPE_TINY_BLOB
|| parser->columns[col] == MYSQL_TYPE_MEDIUM_BLOB
|| parser->columns[col] == MYSQL_TYPE_LONG_BLOB
|| parser->columns[col] == MYSQL_TYPE_BLOB
|| parser->columns[col] == MYSQL_TYPE_VAR_STRING
|| parser->columns[col] == MYSQL_TYPE_STRING) reply[col] = enif_make_sub_binary(parser->env, parser->raw, idx + size_length, size_length + content_length - 1);
else if (parser->columns[col] == MYSQL_TYPE_TINY
|| parser->columns[col] == MYSQL_TYPE_SHORT
|| parser->columns[col] == MYSQL_TYPE_LONG
|| parser->columns[col] == MYSQL_TYPE_LONGLONG
|| parser->columns[col] == MYSQL_TYPE_INT24
|| parser->columns[col] == MYSQL_TYPE_YEAR) reply[col] = enif_make_int(parser->env, atoi((char *) new_val));
else if (parser->columns[col] == MYSQL_TYPE_DECIMAL
|| parser->columns[col] == MYSQL_TYPE_NEWDECIMAL
|| parser->columns[col] == MYSQL_TYPE_FLOAT
|| parser->columns[col] == MYSQL_TYPE_DOUBLE) reply[col] = enif_make_double(parser->env, strtod((const char *) new_val, NULL));
else if (parser->columns[col] == MYSQL_TYPE_DATE) {
sscanf((const char*) new_val, "%d-%d-%d", &time_.year, &time_.month, &time_.day);
reply[col] = enif_make_tuple2(parser->env,
parser->atoms->atom_date,
enif_make_tuple3(parser->env,
enif_make_int(parser->env, time_.year),
enif_make_int(parser->env, time_.month),
enif_make_int(parser->env, time_.day))
);
}
else if (parser->columns[col] == MYSQL_TYPE_TIME) {
sscanf((const char*) new_val, "%d:%d:%d", &time_.hour, &time_.minute, &time_.second);
reply[col] = enif_make_tuple2(parser->env,
parser->atoms->atom_time,
enif_make_tuple3(parser->env,
enif_make_int(parser->env, time_.hour),
enif_make_int(parser->env, time_.minute),
enif_make_int(parser->env, time_.second))
);
}
else if (parser->columns[col] == MYSQL_TYPE_TIMESTAMP
|| parser->columns[col] == MYSQL_TYPE_DATETIME) {
sscanf((const char*) new_val, "%d-%d-%d %d:%d:%d", &time_.year, &time_.month, &time_.day, &time_.hour, &time_.minute, &time_.second);
reply[col] = enif_make_tuple2(parser->env,
parser->atoms->atom_datetime,
enif_make_tuple2(parser->env,
enif_make_tuple3(parser->env,
enif_make_int(parser->env, time_.year),
enif_make_int(parser->env, time_.month),
enif_make_int(parser->env, time_.day)
),
enif_make_tuple3(parser->env,
enif_make_int(parser->env, time_.hour),
enif_make_int(parser->env, time_.minute),
enif_make_int(parser->env, time_.second)
)
)
);
}
else if (parser->columns[col] == MYSQL_TYPE_FIELD_EXTRA) {
ERL_NIF_TERM default_content;
if (content_length > 12) default_content = enif_make_sub_binary(parser->env, parser->raw, idx + size_length + 12, size_length + content_length - 13);
else default_content = parser->atoms->atom_undefined;
reply[col] = enif_make_tuple6(parser->env,
enif_make_int(parser->env, D2I(new_val)),
enif_make_int(parser->env, D4I(new_val + 2)),
enif_make_int(parser->env, D1(new_val + 6)),
enif_make_int(parser->env, D2I(new_val + 7)),
enif_make_int(parser->env, D1(new_val + 11)),
default_content
);
}
col++;
idx += content_length + size_length;
}
return enif_make_list_from_array(parser->env, reply, parser->table_width);
}
