/* * Copyright (c) 2013 Eric des Courtis * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ /* ┌─────────────────────────────────────────────────────────────┐ │▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓│ │▓ ▓│ │▓ ██ ██▀▀██ ██▀██ ███ ██ ██ ██ ██████ ██▀▀██ ██ ▓│ │▓ ██ ██ ▀ ██ ██ ██████ ██ ██ ██▄▄ ██▄▄██ ██ ▓│ │▓ ██ ██ ██ ██ ██ ███ ████ ██▀▀ ██▀██ ██ ▄ ▓│ │▓ ██ ██▄▄██ ██▄██ ██ ██ ██ ██████ ██ ██ ██▄▄██ ▓│ │▓ ▓│ │▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓│ └─────────────────────────────────────────────────────────────┘ */ #include "erl_nif.h" #include #include #include #include #include #include #include #define CHUNK_SIZE 4096 static ErlNifResourceType *iconv_cd_type = NULL; static ERL_NIF_TERM iconv_iconv_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]); static ERL_NIF_TERM iconv_open_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]); static ERL_NIF_TERM iconv_reset_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]); static ERL_NIF_TERM iconv_ignores_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]); static ERL_NIF_TERM make_error_tuple_from_errno(ErlNifEnv* env, int errn); static ERL_NIF_TERM make_error_tuple_from_string(ErlNifEnv* env, const char *error); static ERL_NIF_TERM make_error_tuple(ErlNifEnv* env, ERL_NIF_TERM error); static void garbage_collect_iconv_cd(ErlNifEnv *env, void *cd); static int handle_load(ErlNifEnv *env, void **priv, ERL_NIF_TERM load_info); static int handle_upgrade(ErlNifEnv* env, void** priv_data, void** old_priv_data, ERL_NIF_TERM load_info); /* ERL_NIF >= 2.8 */ #if ERL_NIF_MAJOR_VERSION > 2 || \ (ERL_NIF_MAJOR_VERSION == 2 && \ (ERL_NIF_MINOR_VERSION > 8 || (ERL_NIF_MINOR_VERSION == 8))) static ErlNifFunc nif_funcs[] = { {"open_priv", 2, iconv_open_nif, 0 }, {"iconv", 2, iconv_iconv_nif, 0 }, {"reset", 1, iconv_reset_nif, 0 }, {"ignores", 1, iconv_ignores_nif, 0 } }; #else static ErlNifFunc nif_funcs[] = { {"open_priv", 2, iconv_open_nif }, {"iconv", 2, iconv_iconv_nif }, {"reset", 1, iconv_reset_nif }, {"ignores", 1, iconv_ignores_nif } }; #endif typedef struct { iconv_t conv_desc; int ignore; } iconv_state_t; static ERL_NIF_TERM iconv_open_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { unsigned int to_len; unsigned int from_len; char *to; char *from; iconv_state_t *state_desc_ref; iconv_state_t state; int res; ERL_NIF_TERM resource; assert(argc == 2); if(!enif_get_list_length(env, argv[0], &to_len)){ return make_error_tuple_from_string(env, "to_not_a_list"); } if(!enif_get_list_length(env, argv[1], &from_len)){ return make_error_tuple_from_string(env, "from_not_a_list"); } to = (char *)enif_alloc(++to_len); if(to == NULL){ return make_error_tuple_from_string(env, "to_enif_alloc"); } from = (char *)enif_alloc(++from_len); if(from == NULL){ enif_free(to); return make_error_tuple_from_string(env, "from_enif_alloc"); } res = enif_get_string( env, argv[0], to, to_len, ERL_NIF_LATIN1 ); if(res < 0){ enif_free(to); enif_free(from); return make_error_tuple_from_string(env, "to_enif_get_string_truncation"); } if(res == 0){ enif_free(to); enif_free(from); return make_error_tuple_from_string(env, "to_enif_get_string_cannot_encode"); } res = enif_get_string( env, argv[1], from, from_len, ERL_NIF_LATIN1 ); if(res < 0){ enif_free(to); enif_free(from); return make_error_tuple_from_string(env, "from_enif_get_string_truncation"); } if(res == 0){ enif_free(to); enif_free(from); return make_error_tuple_from_string(env, "from_enif_get_string_cannot_encode"); } state.ignore = 0; if(strlen(to) > 6){ if(!strcasecmp(to + strlen(to) -6, "ignore")){ state.ignore = 1; } } state.conv_desc = iconv_open(to, from); if(state.conv_desc == (iconv_t) -1){ enif_free(to); enif_free(from); switch(errno){ case EINVAL: return make_error_tuple_from_string(env, "unsupported"); default: return make_error_tuple_from_errno(env, errno); } } state_desc_ref = (iconv_state_t *)enif_alloc_resource(iconv_cd_type, sizeof(iconv_state_t)); *state_desc_ref = state; enif_free(to); enif_free(from); resource = enif_make_resource(env, state_desc_ref); enif_release_resource(state_desc_ref); return resource; } static ERL_NIF_TERM iconv_iconv_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { iconv_state_t *cd_ptr = NULL; int res; size_t ret; ErlNifBinary in_bin; ErlNifBinary out_bin; ERL_NIF_TERM final_bin; char *inbuf; char *outbuf; size_t inbytesleft; size_t outbytesleft; assert(argc == 2); if(!enif_get_resource(env, argv[0], iconv_cd_type, (void **)&cd_ptr)) { return make_error_tuple_from_string(env, "bad_resource"); } assert(cd_ptr != NULL); res = enif_inspect_binary(env, argv[1], &in_bin); if(res == 0){ return make_error_tuple_from_string(env, "not_a_byte_aligned_binary"); } if(enif_alloc_binary(CHUNK_SIZE, &out_bin) == 0){ return make_error_tuple_from_string(env, "enif_alloc_binary"); } inbytesleft = in_bin.size; outbytesleft = out_bin.size; inbuf = (char *)in_bin.data; outbuf = (char *)out_bin.data; ret = iconv(cd_ptr->conv_desc, &inbuf, &inbytesleft, &outbuf, &outbytesleft); if(enif_realloc_binary(&out_bin, out_bin.size - outbytesleft) == 0){ enif_release_binary(&out_bin); return make_error_tuple_from_string(env, "enif_realloc_binary"); } final_bin = enif_make_binary(env, &out_bin); if(ret == (size_t)-1){ switch(errno){ case E2BIG: return enif_make_tuple4( env, enif_make_atom(env, "ok"), enif_make_atom(env, "e2big"), enif_make_uint64(env, (ErlNifUInt64)inbytesleft), final_bin ); case EILSEQ: if(cd_ptr->ignore == 1){ if(inbytesleft == 0){ ret = 0; break; }else{ if(in_bin.size == inbytesleft){ return enif_make_tuple4( env, enif_make_atom(env, "ok"), enif_make_atom(env, "e2big"), enif_make_uint64(env, (ErlNifUInt64)inbytesleft - 1), final_bin ); }else{ return enif_make_tuple4( env, enif_make_atom(env, "ok"), enif_make_atom(env, "e2big"), enif_make_uint64(env, (ErlNifUInt64)inbytesleft), final_bin ); } } } return enif_make_tuple4( env, enif_make_atom(env, "ok"), enif_make_atom(env, "eilseq"), enif_make_uint64(env, (ErlNifUInt64)inbytesleft), final_bin ); case EINVAL: if(cd_ptr->ignore == 1){ return enif_make_tuple3( env, enif_make_atom(env, "ok"), enif_make_uint64(env, (ErlNifUInt64)inbytesleft - 1), final_bin ); } return enif_make_tuple4( env, enif_make_atom(env, "ok"), enif_make_atom(env, "einval"), enif_make_uint64(env, (ErlNifUInt64)inbytesleft), final_bin ); case EBADF: return make_error_tuple_from_string(env, "ebadf"); default: return make_error_tuple_from_errno(env, errno); } } return enif_make_tuple3( env, enif_make_atom(env, "ok"), enif_make_uint64(env, (ErlNifUInt64)inbytesleft), final_bin ); } static ERL_NIF_TERM iconv_reset_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { iconv_state_t *cd_ptr = NULL; size_t ret; assert(argc == 1); if(!enif_get_resource(env, argv[0], iconv_cd_type, (void **)&cd_ptr)) { return make_error_tuple_from_string(env, "bad_resource"); } assert(cd_ptr != NULL); ret = iconv(cd_ptr->conv_desc, NULL, NULL, NULL, NULL); if(ret == (size_t) -1) { return make_error_tuple_from_errno(env, errno); } return enif_make_atom(env, "ok"); } static ERL_NIF_TERM iconv_ignores_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { iconv_state_t *cd_ptr = NULL; size_t ret; assert(argc == 1); if(!enif_get_resource(env, argv[0], iconv_cd_type, (void **)&cd_ptr)) { return make_error_tuple_from_string(env, "bad_resource"); } assert(cd_ptr != NULL); if(cd_ptr->ignore == 1){ return enif_make_atom(env, "true"); }else{ return enif_make_atom(env, "false"); } } static ERL_NIF_TERM make_error_tuple_from_errno(ErlNifEnv* env, int errn) { return enif_make_tuple2( env, enif_make_atom(env, "error"), enif_make_int(env, errn) ); } static ERL_NIF_TERM make_error_tuple_from_string(ErlNifEnv* env, const char *error) { return make_error_tuple(env, enif_make_atom(env, error)); } static ERL_NIF_TERM make_error_tuple(ErlNifEnv* env, ERL_NIF_TERM error) { return enif_make_tuple2(env, enif_make_atom(env, "error"), error); } static void garbage_collect_iconv_cd(ErlNifEnv *env, void *cd) { int res; iconv_state_t *cd_ptr = (iconv_state_t *)cd; res = iconv_close(cd_ptr->conv_desc); if(res == -1){ fprintf( stderr, "iconv_close() in file: %s at line: %d failed with errno: %d\n", __FILE__, __LINE__, errno ); abort(); } assert(res == 0); } static int handle_load(ErlNifEnv *env, void **priv, ERL_NIF_TERM load_info) { ErlNifResourceType *rt; ErlNifResourceFlags rf; rt = enif_open_resource_type( env, NULL, "iconv_cd_type", garbage_collect_iconv_cd, ERL_NIF_RT_CREATE, &rf ); if(rt == NULL) return -1; iconv_cd_type = rt; return 0; } static int handle_upgrade(ErlNifEnv* env, void** priv_data, void** old_priv_data, ERL_NIF_TERM load_info) { return 0; } ERL_NIF_INIT(iconverl, nif_funcs, handle_load, NULL, handle_upgrade, NULL)