/** * Copyright 2012 Marc Worrell * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ #include "erl_nif_compat.h" #include "dclass/dclass_client.h" #include #include #ifdef OTP_R13B03 #error OTP R13B03 not supported. Upgrade to R13B04 or later. #endif typedef struct { dclass_index di; dclass_index bi; } ua_state; static int is_number(const char *s) { if (*s) { while (*s) { if (!isdigit(*s)) { return 0; } s++; } return 1; } return 0; } static ERL_NIF_TERM make_atom(ErlNifEnv *env, const char *name) { ERL_NIF_TERM ret; if (enif_make_existing_atom_compat(env, name, &ret, ERL_NIF_LATIN1)) { return ret; } return enif_make_atom(env, name); } static ERL_NIF_TERM make_binary_string(ErlNifEnv *env, const char *s) { ErlNifBinary b; int n; n = strlen(s); enif_alloc_binary(n, &b); memcpy(b.data, s, n); b.size = n; return enif_make_binary(env, &b); } static ERL_NIF_TERM make_value(ErlNifEnv *env, const char *key, const char *s) { if (strcmp(s, "false") == 0) { return make_atom(env, "false"); } if (strcmp(s, "true") == 0) { return make_atom(env, "true"); } if ( is_number(s) && strcmp(key, "id") && strcmp(key, "model")) { return enif_make_int(env, atoi(s)); } return make_binary_string(env, s); } static ERL_NIF_TERM ua_do_classify(ErlNifEnv *env, dclass_index *index, char *ua, ERL_NIF_TERM tl) { const dclass_keyvalue *kvd; ERL_NIF_TERM hd; int i; kvd = dclass_classify(index, ua); if(!kvd) return tl; /* Make a list of all key/value pairs */ hd = enif_make_tuple2(env, make_atom(env, "id"), make_value(env, "id", kvd->id)); tl = enif_make_list_cell(env, hd, tl); for (i = 0; i < kvd->size; i++) { hd = enif_make_tuple2(env, make_atom(env, kvd->keys[i]), make_value(env, kvd->keys[i], kvd->values[i])); tl = enif_make_list_cell(env, hd, tl); } return tl; } static ERL_NIF_TERM make_eos(ErlNifEnv *env, const ERL_NIF_TERM iolist) { ERL_NIF_TERM eos = enif_make_int(env, 0); return enif_make_list2(env, iolist, eos); } static ERL_NIF_TERM ua_classify(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { ErlNifBinary input; ua_state *state; char *ua; ERL_NIF_TERM hd; ERL_NIF_TERM tl; if (argc != 1) { return enif_make_badarg(env); } if (!enif_inspect_iolist_as_binary(env, make_eos(env, argv[0]), &input)) { return enif_make_badarg(env); } ua = (char *) input.data; tl = enif_make_list(env, 0); /* Handle some exceptions from the dClass library */ if ( strncmp(ua, "Lynx", 4) == 0 /* Lynx text browser */ || strstr(ua, "Series60/") != NULL /* Nokia phone */ || strstr(ua, "Series50/") != NULL /* Nokia phone */ ) { hd = enif_make_tuple2(env, make_atom(env, "id"), make_value(env, "id", "textDevice")); tl = enif_make_list_cell(env, hd, tl); } else { /* Find the classification in the dclass tree */ state = (ua_state *) enif_priv_data_compat(env); tl = ua_do_classify(env, &state->di, ua, tl); } return enif_make_tuple2(env, make_atom(env, "ok"), tl); } static ERL_NIF_TERM ua_browser_classify(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { ErlNifBinary input; ua_state *state; char *ua; ERL_NIF_TERM tl; if (argc != 1) { return enif_make_badarg(env); } if (!enif_inspect_iolist_as_binary(env, make_eos(env, argv[0]), &input)) { return enif_make_badarg(env); } /* Get ua string */ ua = (char *) input.data; /* Find the classification in the dclass browser tree */ state = (ua_state *) enif_priv_data_compat(env); tl = ua_do_classify(env, &state->bi, ua, enif_make_list(env, 0)); return enif_make_tuple2(env, make_atom(env, "ok"), tl); } static int on_load(ErlNifEnv *env, void **priv, ERL_NIF_TERM info) { int ret; ua_state *state; ErlNifBinary dtree; ErlNifBinary btree; int arity; const ERL_NIF_TERM* tuple; if(!enif_get_tuple(env, info, &arity, &tuple)) { return enif_make_badarg(env); } if(arity != 2) { return enif_make_badarg(env); } if(!enif_inspect_iolist_as_binary(env, make_eos(env, tuple[0]), &dtree)) { return enif_make_badarg(env); } if(!enif_inspect_iolist_as_binary(env, make_eos(env, tuple[1]), &btree)) { return enif_make_badarg(env); } /* Allocate the dclass tree datastructure, this will be kept between NIF calls */ state = (ua_state *) enif_alloc(sizeof(ua_state)); if (!state) { return enif_make_badarg(env); } /* Parse the dtree file, bail out on an error */ dclass_init_index(&state->di); ret = dclass_load_file(&state->di, (char *) dtree.data); if (ret < 0) { enif_free(state); return enif_make_badarg(env); } /* Parse the browser dtree file, bail out on an error */ dclass_init_index(&state->bi); ret = dclass_load_file(&state->bi, (char *) btree.data); if (ret < 0) { dclass_free(&state->di); enif_free(state); return enif_make_badarg(env); } /* Keep the dtree as priv data */ *priv = (void *) state; return 0; } static int on_upgrade(ErlNifEnv *env, void **new_priv, void **old_priv, ERL_NIF_TERM info) { return on_load(env, new_priv, info); } static void on_unload(ErlNifEnv *env, void *priv) { ua_state *state; state = (ua_state *) priv; dclass_free(&state->di); dclass_free(&state->bi); enif_free(state); } static ErlNifFunc nif_functions[] = { {"classify", 1, ua_classify}, {"browser_classify", 1, ua_browser_classify} }; ERL_NIF_INIT(ua_classifier, nif_functions, &on_load, NULL, &on_upgrade, &on_unload);