The R13B03 release.OTP_R13B03

1 files changed, 1525 insertions, 0 deletions

diff --git a/lib/kernel/src/inet_db.erl b/lib/kernel/src/inet_db.erl
new file mode 100644
index 0000000000..211847014f
--- /dev/null
+++ b/lib/kernel/src/inet_db.erl
@@ -0,0 +1,1525 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 1997-2009. All Rights Reserved.
+%% 
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%% 
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%% 
+%% %CopyrightEnd%
+%%
+
+-module(inet_db).
+
+%% Store info about ip addresses, names, aliases host files resolver
+%% options
+
+%% If the macro DEBUG is defined during compilation, 
+%% debug printouts are done through erlang:display/1.
+%% Activate this feature by starting the compiler 
+%% with> erlc -DDEBUG ... 
+%% or by> setenv ERL_COMPILER_FLAGS DEBUG 
+%% before running make (in the OTP make system)
+%% (the example is for tcsh)
+
+%% External exports
+-export([start/0, start_link/0, stop/0, reset/0, clear_cache/0]).
+-export([add_rr/1,add_rr/5,del_rr/4]).
+-export([add_ns/1,add_ns/2, ins_ns/1, ins_ns/2,
+	 del_ns/2, del_ns/1, del_ns/0]).
+-export([add_alt_ns/1,add_alt_ns/2, ins_alt_ns/1, ins_alt_ns/2, 
+	 del_alt_ns/2, del_alt_ns/1, del_alt_ns/0]).
+-export([add_search/1,ins_search/1,del_search/1, del_search/0]).
+-export([set_lookup/1, set_recurse/1]).
+-export([set_socks_server/1, set_socks_port/1, add_socks_methods/1,
+	 del_socks_methods/1, del_socks_methods/0,
+	 add_socks_noproxy/1, del_socks_noproxy/1]).
+-export([set_cache_size/1, set_cache_refresh/1]).
+-export([set_timeout/1, set_retry/1, set_inet6/1, set_usevc/1]).
+-export([set_edns/1, set_udp_payload_size/1]).
+-export([set_resolv_conf/1, set_hosts_file/1, get_hosts_file/0]).
+-export([tcp_module/0, set_tcp_module/1]).
+-export([udp_module/0, set_udp_module/1]).
+-export([sctp_module/0,set_sctp_module/1]).
+-export([register_socket/2, unregister_socket/1, lookup_socket/1]).
+
+%% Host name & domain
+-export([set_hostname/1, set_domain/1]).
+-export([gethostname/0]).
+
+%% file interface
+-export([add_host/2, del_host/1, clear_hosts/0, add_hosts/1]).
+-export([add_resolv/1]).
+-export([add_rc/1, add_rc_bin/1, add_rc_list/1, get_rc/0]).
+
+-export([res_option/1, res_option/2, res_check_option/2]).
+-export([socks_option/1]).
+-export([getbyname/2, get_searchlist/0]).
+-export([gethostbyaddr/1]).
+-export([res_gethostbyaddr/2,res_hostent_by_domain/3]).
+-export([res_update_conf/0, res_update_hosts/0]).
+%% inet help functions
+-export([tolower/1]).
+-ifdef(DEBUG).
+-define(dbg(Fmt, Args), io:format(Fmt, Args)).
+-else.
+-define(dbg(Fmd, Args), ok).
+-endif.
+
+-include_lib("kernel/include/file.hrl").
+
+%% gen_server callbacks
+-export([init/1, handle_call/3, handle_cast/2, handle_info/2, terminate/2]).
+
+-record(state, 
+	{db,                %% resolver data
+	 cache,             %% bag of resource records
+	 hosts_byname,      %% hosts table
+	 hosts_byaddr,      %% hosts table
+	 hosts_file_byname, %% hosts table from system file
+	 hosts_file_byaddr, %% hosts table from system file
+	 cache_timer        %% timer reference for refresh
+	}).
+
+-include("inet.hrl").
+-include("inet_int.hrl").
+-include("inet_res.hrl").
+-include("inet_dns.hrl").
+-include("inet_config.hrl").
+
+%%%----------------------------------------------------------------------
+%%% API
+%%%----------------------------------------------------------------------
+
+start() ->
+    case gen_server:start({local, inet_db}, inet_db, [], []) of
+	{ok,Pid} -> inet_config:init(), {ok,Pid};
+	Error -> Error
+    end.
+
+
+start_link() ->
+    case gen_server:start_link({local, inet_db}, inet_db, [], []) of
+	{ok,Pid} -> inet_config:init(), {ok,Pid};
+	Error -> Error
+    end.
+	       
+call(Req) -> 
+    gen_server:call(inet_db, Req, infinity).
+
+stop() ->
+    call(stop).
+
+reset() ->
+    call(reset).
+
+
+%% insert all resolve options from this file (MAY GO)
+add_resolv(File) ->
+    case inet_parse:resolv(File) of
+	{ok, Res} -> add_rc_list(Res);
+	Error -> Error
+    end.
+
+%% add all aliases from this hosts file (MAY GO)
+add_hosts(File) ->
+    case inet_parse:hosts(File) of
+	{ok, Res} ->
+	    lists:foreach(
+	      fun({IP, Name, Aliases}) -> add_host(IP, [Name|Aliases]) end,
+	      Res);
+	Error -> Error
+    end.
+
+
+add_host(IP, Names) -> call({add_host, IP, Names}).
+
+del_host(IP) ->  call({del_host, IP}).
+
+clear_hosts() -> call(clear_hosts).
+
+%% add to the end of name server list
+add_ns(IP) -> 
+    add_ns(IP,?NAMESERVER_PORT).
+add_ns(IP,Port) ->
+    call({listop, nameservers, add, {IP,Port}}).
+
+%% insert at head of name server list
+ins_ns(IP) ->
+    ins_ns(IP, ?NAMESERVER_PORT).
+ins_ns(IP,Port) ->
+    call({listop, nameservers, ins, {IP,Port}}).
+
+%% delete this name server entry (delete all ns having this ip)
+del_ns(IP) -> 
+    del_ns(IP, ?NAMESERVER_PORT).
+del_ns(IP, Port) ->
+    call({listop, nameservers, del, {IP,Port}}).
+
+del_ns() -> 
+    call({listdel, nameservers}).
+
+%% ALTERNATIVE NAME SERVER
+%% add to the end of name server list
+add_alt_ns(IP) -> 
+    add_alt_ns(IP, ?NAMESERVER_PORT).
+add_alt_ns(IP,Port) ->
+    call({listop, alt_nameservers, add, {IP,Port}}).
+
+%% insert at head of name server list
+ins_alt_ns(IP) -> 
+    ins_alt_ns(IP, ?NAMESERVER_PORT).
+ins_alt_ns(IP,Port) ->
+    call({listop, alt_nameservers, ins, {IP,Port}}).
+
+%% delete this name server entry
+del_alt_ns(IP) ->
+    del_alt_ns(IP, ?NAMESERVER_PORT).
+del_alt_ns(IP, Port) ->
+    call({listop, alt_nameservers, del, {IP,Port}}).
+
+del_alt_ns() -> 
+    call({listdel, alt_nameservers}).
+
+%% add this domain to the search list
+add_search(Domain) when is_list(Domain) -> 
+    call({listop, search, add, Domain}).
+
+ins_search(Domain) when is_list(Domain) ->
+    call({listop, search, ins, Domain}).
+
+del_search(Domain) ->
+    call({listop, search, del, Domain}).
+
+del_search() ->
+    call({listdel, search}).
+
+%% set host name used by inet
+%% Should only be used by inet_config at startup!
+set_hostname(Name) ->
+    call({set_hostname, Name}).
+
+%% set default domain
+set_domain(Domain) -> res_option(domain, Domain).
+
+%% set lookup methods
+set_lookup(Methods) -> res_option(lookup, Methods).
+
+%% resolver
+set_recurse(Flag) -> res_option(recurse, Flag).
+
+set_timeout(Time) -> res_option(timeout, Time).
+
+set_retry(N) -> res_option(retry, N).
+
+set_inet6(Bool) -> res_option(inet6, Bool).
+
+set_usevc(Bool) -> res_option(usevc, Bool).
+
+set_edns(Version) -> res_option(edns, Version).
+
+set_udp_payload_size(Size) -> res_option(udp_payload_size, Size).
+
+set_resolv_conf(Fname) -> res_option(resolv_conf, Fname).
+
+set_hosts_file(Fname) -> res_option(hosts_file, Fname).
+
+get_hosts_file() ->
+    get_rc_hosts([], [], inet_hosts_file_byname).
+
+%% set socks options
+set_socks_server(Server) -> call({set_socks_server, Server}).
+
+set_socks_port(Port) -> call({set_socks_port, Port}).
+
+add_socks_methods(Ms) -> call({add_socks_methods,Ms}).
+
+del_socks_methods(Ms) -> call({del_socks_methods,Ms}).
+
+del_socks_methods() -> call(del_socks_methods).
+
+add_socks_noproxy({Net,Mask}) -> call({add_socks_noproxy, {Net,Mask}}).
+
+del_socks_noproxy(Net) -> call({del_socks_noproxy, Net}).
+
+%% cache options
+set_cache_size(Limit) -> call({set_cache_size, Limit}).
+
+set_cache_refresh(Time) -> call({set_cache_refresh, Time}).
+
+clear_cache() -> call(clear_cache).
+
+
+set_tcp_module(Module) -> call({set_tcp_module, Module}).
+
+tcp_module() -> db_get(tcp_module).
+
+set_udp_module(Module) -> call({set_udp_module, Module}).
+
+udp_module() -> db_get(udp_module).
+
+set_sctp_module(Family)-> call({set_sctp_module,Family}).
+
+sctp_module()-> db_get(sctp_module).
+
+%% Add an inetrc file
+add_rc(File) -> 
+    case file:consult(File) of
+	{ok, List} -> add_rc_list(List);
+	Error -> Error
+    end.
+
+%% Add an inetrc binary term must be a rc list
+add_rc_bin(Bin) ->
+    case catch binary_to_term(Bin) of
+	List when is_list(List) ->
+	    add_rc_list(List);
+	_ ->
+	    {error, badarg}
+    end.
+
+add_rc_list(List) -> call({add_rc_list, List}).
+
+
+
+%% All kind of flavors !
+translate_lookup(["bind" | Ls]) -> [dns | translate_lookup(Ls)];
+translate_lookup(["dns" | Ls]) -> [dns | translate_lookup(Ls)];
+translate_lookup(["hosts" | Ls]) -> [file | translate_lookup(Ls)];
+translate_lookup(["files" | Ls]) -> [file | translate_lookup(Ls)];
+translate_lookup(["file"  | Ls]) -> [file | translate_lookup(Ls)];
+translate_lookup(["yp" | Ls]) -> [yp | translate_lookup(Ls)];
+translate_lookup(["nis" | Ls]) -> [nis | translate_lookup(Ls)];
+translate_lookup(["nisplus" | Ls]) -> [nisplus | translate_lookup(Ls)];
+translate_lookup(["native" | Ls]) -> [native | translate_lookup(Ls)];
+translate_lookup([M | Ls]) when is_atom(M) -> translate_lookup([atom_to_list(M) | Ls]);
+translate_lookup([_ | Ls]) -> translate_lookup(Ls);
+translate_lookup([]) -> [].
+
+valid_lookup() -> [dns, file, yp, nis, nisplus, native].
+    
+
+%% Reconstruct an inetrc sturcture from inet_db
+get_rc() -> 
+    get_rc([hosts, domain, nameservers, search, alt_nameservers,
+	    timeout, retry, inet6, usevc,
+	    edns, udp_payload_size, resolv_conf, hosts_file,
+	    socks5_server,  socks5_port, socks5_methods, socks5_noproxy,
+	    udp, sctp, tcp, host, cache_size, cache_refresh, lookup], []).
+
+get_rc([K | Ks], Ls) ->
+    case K of
+	hosts      -> get_rc_hosts(Ks, Ls, inet_hosts_byname);
+	domain     -> get_rc(domain, res_domain, "", Ks, Ls);
+	nameservers -> get_rc_ns(db_get(res_ns),nameservers,Ks,Ls);
+	alt_nameservers -> get_rc_ns(db_get(res_alt_ns),alt_nameservers,Ks,Ls);
+	search  -> get_rc(search, res_search, [], Ks, Ls);
+	timeout -> get_rc(timeout,res_timeout,?RES_TIMEOUT, Ks,Ls);
+	retry   -> get_rc(retry, res_retry, ?RES_RETRY, Ks, Ls);
+	inet6   -> get_rc(inet6, res_inet6, false, Ks, Ls);
+	usevc   -> get_rc(usevc, res_usevc, false, Ks, Ls);
+	edns    -> get_rc(edns, res_edns, false, Ks, Ls);
+	udp_payload_size -> get_rc(udp_payload_size, res_udp_payload_size,
+				   ?DNS_UDP_PAYLOAD_SIZE, Ks, Ls);
+	resolv_conf -> get_rc(resolv_conf, res_resolv_conf, undefined, Ks, Ls);
+	hosts_file -> get_rc(hosts_file, res_hosts_file, undefined, Ks, Ls);
+	tcp     -> get_rc(tcp,  tcp_module,  ?DEFAULT_TCP_MODULE,  Ks, Ls); 
+	udp     -> get_rc(udp,  udp_module,  ?DEFAULT_UDP_MODULE,  Ks, Ls);
+	sctp	-> get_rc(sctp, sctp_module, ?DEFAULT_SCTP_MODULE, Ks, Ls);
+	lookup  -> get_rc(lookup, res_lookup, [native,file], Ks, Ls);
+	cache_size -> get_rc(cache_size, cache_size, ?CACHE_LIMIT, Ks, Ls);
+	cache_refresh ->
+	    get_rc(cache_refresh, cache_refresh_interval,?CACHE_REFRESH,Ks,Ls);
+	socks5_server -> get_rc(socks5_server, socks5_server, "", Ks, Ls);
+	socks5_port    -> get_rc(socks5_port,socks5_port,?IPPORT_SOCKS,Ks,Ls);
+	socks5_methods -> get_rc(socks5_methods,socks5_methods,[none],Ks,Ls);
+	socks5_noproxy ->
+	    case db_get(socks5_noproxy) of
+		[] -> get_rc(Ks, Ls);
+		NoProxy -> get_rc_noproxy(NoProxy, Ks, Ls)
+	    end;
+	_ ->
+	    get_rc(Ks, Ls)
+    end;
+get_rc([], Ls) -> 
+    lists:reverse(Ls).
+
+get_rc(Name, Key, Default, Ks, Ls) ->
+    case db_get(Key) of
+	Default -> get_rc(Ks, Ls);
+	Value -> get_rc(Ks, [{Name, Value} | Ls])
+    end.
+
+get_rc_noproxy([{Net,Mask} | Ms], Ks, Ls) ->
+    get_rc_noproxy(Ms, Ks, [{socks5_noproxy, Net, Mask} | Ls]);
+get_rc_noproxy([], Ks, Ls) -> get_rc(Ks, Ls).
+
+get_rc_ns([{IP,?NAMESERVER_PORT} | Ns], Tag, Ks, Ls) ->
+    get_rc_ns(Ns, Tag, Ks, [{Tag, IP} | Ls]);
+get_rc_ns([{IP,Port} | Ns], Tag, Ks, Ls) ->
+    get_rc_ns(Ns, Tag, Ks, [{Tag, IP, Port} | Ls]);
+get_rc_ns([], _Tag, Ks, Ls) ->
+    get_rc(Ks, Ls).
+
+get_rc_hosts(Ks, Ls, Tab) ->
+    case lists:keysort(3, ets:tab2list(Tab)) of
+	[] -> get_rc(Ks, Ls);
+	[{N,_,IP}|Hosts] -> get_rc_hosts(Ks, Ls, IP, Hosts, [N])
+    end.
+
+get_rc_hosts(Ks, Ls, IP, [], Ns) ->
+    get_rc(Ks, [{host,IP,lists:reverse(Ns)}|Ls]);
+get_rc_hosts(Ks, Ls, IP, [{N,_,IP}|Hosts], Ns) ->
+    get_rc_hosts(Ks, Ls, IP, Hosts, [N|Ns]);
+get_rc_hosts(Ks, Ls, IP, [{N,_,NewIP}|Hosts], Ns) ->
+    [{host,IP,lists:reverse(Ns)}|get_rc_hosts(Ks, Ls, NewIP, Hosts, [N])].
+
+%%
+%% Resolver options
+%%
+res_option(next_id)        ->
+    Cnt = ets:update_counter(inet_db, res_id, 1),
+    case Cnt band 16#ffff of
+	0 ->
+	    ets:update_counter(inet_db, res_id, -Cnt),
+	    0;
+	Id ->
+	    Id
+    end;
+res_option(Option) ->
+    case res_optname(Option) of
+	undefined ->
+	    erlang:error(badarg, [Option]);
+	ResOptname ->
+	    db_get(ResOptname)
+    end.
+
+res_option(Option, Value) ->
+    case res_optname(Option) of
+	undefined ->
+	    erlang:error(badarg, [Option,Value]);
+	_ ->
+	    call({res_set,Option,Value})
+    end.
+
+res_optname(nameserver) -> res_ns;     %% Legacy
+res_optname(alt_nameserver) -> res_alt_ns; %% Legacy
+res_optname(nameservers) -> res_ns;
+res_optname(alt_nameservers) -> res_alt_ns;
+res_optname(domain) -> res_domain;
+res_optname(lookup) -> res_lookup;
+res_optname(recurse) -> res_recurse;
+res_optname(search) -> res_search;
+res_optname(retry) -> res_retry;
+res_optname(timeout) -> res_timeout;
+res_optname(inet6) -> res_inet6;
+res_optname(usevc) -> res_usevc;
+res_optname(edns) -> res_edns;
+res_optname(udp_payload_size) -> res_udp_payload_size;
+res_optname(resolv_conf) -> res_resolv_conf;
+res_optname(hosts_file) -> res_hosts_file;
+res_optname(_) -> undefined.
+
+res_check_option(nameserver, NSs) -> %% Legacy
+    res_check_list(NSs, fun res_check_ns/1);
+res_check_option(alt_nameserver, NSs) -> %% Legacy
+    res_check_list(NSs, fun res_check_ns/1);
+res_check_option(nameservers, NSs) ->
+    res_check_list(NSs, fun res_check_ns/1);
+res_check_option(alt_nameservers, NSs) ->
+    res_check_list(NSs, fun res_check_ns/1);
+res_check_option(domain, Dom) ->
+    inet_parse:visible_string(Dom);
+res_check_option(lookup, Methods) ->
+    try lists_subtract(Methods, valid_lookup()) of
+	[] -> true;
+	_ -> false
+    catch
+	error:_ -> false
+    end;
+res_check_option(recurse, R) when R =:= 0; R =:= 1 -> true; %% Legacy
+res_check_option(recurse, R) when is_boolean(R) -> true;
+res_check_option(search, SearchList) ->
+    res_check_list(SearchList, fun res_check_search/1);
+res_check_option(retry, N) when is_integer(N), N > 0 -> true;
+res_check_option(timeout, T) when is_integer(T), T > 0 -> true;
+res_check_option(inet6, Bool) when is_boolean(Bool) -> true;
+res_check_option(usevc, Bool) when is_boolean(Bool) -> true;
+res_check_option(edns, V) when V =:= false; V =:= 0 -> true;
+res_check_option(udp_payload_size, S) when is_integer(S), S >= 512 -> true;
+res_check_option(resolv_conf, "") -> true;
+res_check_option(resolv_conf, F) ->
+    res_check_option_absfile(F);
+res_check_option(hosts_file, "") -> true;
+res_check_option(hosts_file, F) ->
+    res_check_option_absfile(F);
+res_check_option(_, _) -> false.
+
+res_check_option_absfile(F) ->
+    try filename:pathtype(F) of
+	absolute -> true;
+	_ -> false
+    catch
+	_:_ -> false
+    end.
+
+res_check_list([], _Fun) -> true;
+res_check_list([H|T], Fun) ->
+    case Fun(H) of
+	true -> res_check_list(T, Fun);
+	false -> false
+    end;
+res_check_list(_, _Fun) -> false.
+
+res_check_ns({{A,B,C,D,E,F,G,H}, Port})
+  when ?ip6(A,B,C,D,E,F,G,H), Port band 65535 =:= Port -> true;
+res_check_ns({{A,B,C,D}, Port})
+  when ?ip(A,B,C,D), Port band 65535 =:= Port -> true;
+res_check_ns(_) -> false.
+
+res_check_search("") -> true;
+res_check_search(Dom) -> inet_parse:visible_string(Dom).
+
+socks_option(server)       -> db_get(socks5_server);
+socks_option(port)         -> db_get(socks5_port);
+socks_option(methods)      -> db_get(socks5_methods);
+socks_option(noproxy)      -> db_get(socks5_noproxy).
+
+gethostname()              -> db_get(hostname).
+
+res_update_conf() ->
+    res_update(res_resolv_conf, res_resolv_conf_tm, res_resolv_conf_info,
+	       set_resolv_conf_tm, fun set_resolv_conf/1).
+
+res_update_hosts() ->
+    res_update(res_hosts_file, res_hosts_file_tm, res_hosts_file_info,
+	       set_hosts_file_tm, fun set_hosts_file/1).
+
+res_update(Tag, TagTm, TagInfo, CallTag, SetFun) ->
+    case db_get(TagTm) of
+	undefined -> ok;
+	TM ->
+	    case times() of
+		Now when Now >= TM + ?RES_FILE_UPDATE_TM ->
+		    case db_get(Tag) of
+			undefined ->
+			    SetFun("");
+			"" ->
+			    SetFun("");
+			File ->
+			    case erl_prim_loader:read_file_info(File) of
+				{ok, Finfo0} ->
+				    Finfo =
+					Finfo0#file_info{access = undefined,
+							 atime = undefined},
+				    case db_get(TagInfo) of
+					Finfo ->
+					    call({CallTag, Now});
+					_ ->
+					    SetFun(File)
+				    end;
+				_ ->
+				    call({CallTag, Now}),
+				    error
+			    end
+		    end;
+		_ -> ok
+	    end
+    end.
+
+db_get(Name) ->
+    case ets:lookup(inet_db, Name) of
+	[] -> undefined;
+	[{_,Val}] -> Val
+    end.
+
+add_rr(RR) ->
+    call({add_rr, RR}).
+
+add_rr(Domain, Class, Type, TTL, Data) ->
+    call({add_rr, #dns_rr { domain = Domain, class = Class,
+		       type = Type, ttl = TTL, data = Data}}).
+
+del_rr(Domain, Class, Type, Data) ->
+    call({del_rr, #dns_rr { domain = Domain, class = Class,
+		       type = Type, cnt = '_', tm = '_', ttl = '_',
+		       bm = '_', func = '_', data = Data}}).
+
+res_cache_answer(Rec) ->
+    lists:foreach( fun(RR) -> add_rr(RR) end, Rec#dns_rec.anlist).
+
+    
+
+
+%%
+%% getbyname (cache version)
+%%
+%% This function and inet_res:res_getbyname/3 must look up names
+%% in the same manner, but not from the same places.
+%%
+getbyname(Name, Type) ->
+    {EmbeddedDots, TrailingDot} = inet_parse:dots(Name),
+    Dot = if TrailingDot -> ""; true -> "." end,
+    if  TrailingDot ->
+	    hostent_by_domain(Name, Type);
+	EmbeddedDots =:= 0 ->
+	    getbysearch(Name, Dot, get_searchlist(), Type, {error,nxdomain});
+	true ->
+	    case hostent_by_domain(Name, Type) of
+		{error,_}=Error ->
+		    getbysearch(Name, Dot, get_searchlist(), Type, Error);
+		Other -> Other
+	    end
+    end.
+
+getbysearch(Name, Dot, [Dom | Ds], Type, _) ->
+    case hostent_by_domain(Name ++ Dot ++ Dom, Type) of
+	{ok, HEnt} -> {ok, HEnt};
+	Error      ->
+	    getbysearch(Name, Dot, Ds, Type, Error)
+    end;
+getbysearch(_Name, _Dot, [], _Type, Error) ->
+    Error.
+
+
+
+%%
+%% get_searchlist
+%%
+get_searchlist() ->
+    case res_option(search) of
+	[] -> [res_option(domain)];
+	L -> L
+    end.
+
+
+
+make_hostent(Name, Addrs, Aliases, ?S_A) ->
+    #hostent {
+	      h_name = Name,
+	      h_addrtype = inet,
+	      h_length = 4,
+	      h_addr_list = Addrs,
+	      h_aliases = Aliases
+	     };
+make_hostent(Name, Addrs, Aliases, ?S_AAAA) ->
+    #hostent {
+	      h_name = Name,
+	      h_addrtype = inet6,
+	      h_length = 16,
+	      h_addr_list = Addrs,
+	      h_aliases = Aliases
+	     };
+make_hostent(Name, Datas, Aliases, Type) ->
+    %% Use #hostent{} for other Types as well !
+    #hostent {
+	      h_name = Name,
+	      h_addrtype = Type,
+	      h_length = length(Datas),
+	      h_addr_list = Datas,
+	      h_aliases = Aliases
+	     }.
+
+hostent_by_domain(Domain, Type) ->
+    ?dbg("hostent_by_domain: ~p~n", [Domain]),
+    hostent_by_domain(stripdot(Domain), [], Type).
+
+hostent_by_domain(Domain, Aliases, Type) ->
+    case lookup_type(Domain, Type) of
+	[] ->
+	    case lookup_cname(Domain) of
+		[] ->  
+		    {error, nxdomain};
+		[CName | _] ->
+		    case lists:member(CName, [Domain | Aliases]) of
+                        true -> 
+			    {error, nxdomain};
+                        false ->
+			    hostent_by_domain(CName, [Domain | Aliases], Type)
+		    end
+	    end;
+	Addrs ->
+	    {ok, make_hostent(Domain, Addrs, Aliases, Type)}
+    end.
+
+%% lookup address record
+lookup_type(Domain, Type) ->
+    [R#dns_rr.data || R <- lookup_rr(Domain, in, Type) ].
+
+%% lookup canonical name
+lookup_cname(Domain) ->
+    [R#dns_rr.data || R <- lookup_rr(Domain, in, ?S_CNAME) ].
+
+%% Have to do all lookups (changes to the db) in the
+%% process in order to make it possible to refresh the cache.
+lookup_rr(Domain, Class, Type) ->
+    call({lookup_rr, Domain, Class, Type}).
+
+%%
+%% hostent_by_domain (newly resolved version)
+%% match data field directly and cache RRs.
+%%
+res_hostent_by_domain(Domain, Type, Rec) ->
+    res_cache_answer(Rec),
+    RRs = Rec#dns_rec.anlist,
+    ?dbg("res_hostent_by_domain: ~p - ~p~n", [Domain, RRs]),
+    res_hostent_by_domain(stripdot(Domain), [], Type, RRs).
+
+res_hostent_by_domain(Domain, Aliases, Type, RRs) ->
+    case res_lookup_type(Domain, Type, RRs) of
+	[] ->
+	    case res_lookup_type(Domain, ?S_CNAME, RRs) of
+		[] ->  
+		    {error, nxdomain};
+		[CName | _] ->
+		    case lists:member(CName, [Domain | Aliases]) of
+			true -> 
+			    {error, nxdomain};
+			false ->
+			    res_hostent_by_domain(CName, [Domain | Aliases],
+						  Type, RRs)
+		    end
+	    end;
+	Addrs ->
+	    {ok, make_hostent(Domain, Addrs, Aliases, Type)}
+    end.
+
+%% newly resolved lookup address record
+res_lookup_type(Domain,Type,RRs) ->
+    [R#dns_rr.data || R <- RRs,
+		      R#dns_rr.domain =:= Domain,
+		      R#dns_rr.type =:= Type].
+
+%%
+%% gethostbyaddr (cache version)
+%% match data field directly
+%%
+gethostbyaddr(IP) ->
+    case dnip(IP) of
+	{ok, {IP1, HType, HLen, DnIP}} ->
+	    RRs = match_rr(#dns_rr { domain = DnIP, class = in, type = ptr,
+				     cnt = '_', tm = '_', ttl = '_',
+				     bm = '_', func = '_', data = '_' }),
+	    ent_gethostbyaddr(RRs,  IP1, HType, HLen);
+	Error -> Error
+    end.
+
+%%
+%% res_gethostbyaddr (newly resolved version)
+%% match data field directly and cache RRs.
+%%
+res_gethostbyaddr(IP, Rec) ->
+    {ok, {IP1, HType, HLen}} = dnt(IP),
+    res_cache_answer(Rec),
+    ent_gethostbyaddr(Rec#dns_rec.anlist, IP1, HType, HLen).
+
+ent_gethostbyaddr(RRs, IP, AddrType, Length) ->
+    case RRs of
+	[] -> {error, nxdomain};
+	[RR|TR] ->
+	    %% debug
+	    if TR =/= [] ->
+		    ?dbg("gethostbyaddr found extra=~p~n", [TR]);
+	       true -> ok
+	    end,
+	    Domain = RR#dns_rr.data,
+	    H = #hostent { h_name = Domain,
+			   h_aliases = lookup_cname(Domain),
+			   h_addr_list = [IP],
+			   h_addrtype = AddrType,
+			   h_length = Length },
+	    {ok, H}
+    end.
+
+dnip(IP) ->
+    case dnt(IP) of
+	{ok,{IP1 = {A,B,C,D}, inet, HLen}} ->
+	    {ok,{IP1, inet, HLen, dn_in_addr_arpa(A,B,C,D)}};
+	{ok,{IP1 = {A,B,C,D,E,F,G,H}, inet6, HLen}} ->
+	    {ok,{IP1, inet6, HLen, dn_ip6_int(A,B,C,D,E,F,G,H)}};
+	_ ->
+	    {error, formerr}
+    end.
+
+
+dnt(IP = {A,B,C,D}) when ?ip(A,B,C,D) ->
+    {ok, {IP, inet, 4}};
+dnt({0,0,0,0,0,16#ffff,G,H}) when is_integer(G+H) ->
+    A = G div 256, B = G rem 256, C = H div 256, D = H rem 256,
+    {ok, {{A,B,C,D}, inet, 4}};
+dnt(IP = {A,B,C,D,E,F,G,H}) when ?ip6(A,B,C,D,E,F,G,H) ->
+    {ok, {IP, inet6, 16}};
+dnt(_) ->
+    {error, formerr}.
+
+%%
+%% Register socket Modules
+%%
+register_socket(Socket, Module) when is_port(Socket), is_atom(Module) ->
+    try erlang:port_set_data(Socket, Module)
+    catch
+	error:badarg -> false
+    end.
+
+unregister_socket(Socket) when is_port(Socket) ->
+    ok. %% not needed any more
+
+lookup_socket(Socket) when is_port(Socket) ->
+    try erlang:port_get_data(Socket) of
+	Module when is_atom(Module) -> {ok,Module};
+	_                           -> {error,closed}
+    catch
+	error:badarg                -> {error,closed}
+    end.
+
+%%%----------------------------------------------------------------------
+%%% Callback functions from gen_server
+%%%----------------------------------------------------------------------
+
+%%----------------------------------------------------------------------
+%% Func: init/1
+%% Returns: {ok, State}          |
+%%          {ok, State, Timeout} |
+%%          {stop, Reason}
+%%----------------------------------------------------------------------
+
+%% INET DB ENTRY TYPES:
+%%
+%% KEY            VALUE           - DESCRIPTION
+%%
+%% hostname       String          - SHORT host name
+%%
+%% Resolver options
+%% ----------------
+%% res_ns         [Nameserver]    - list of name servers
+%% res_alt_ns     [AltNameServer] - list of alternate name servers (nxdomain)
+%% res_search     [Domain]        - list of domains for short names
+%% res_domain     Domain          - local domain for short names
+%% res_recurse    Bool            - recursive query 
+%% res_usevc      Bool            - use tcp only
+%% res_id         Integer         - NS query identifier
+%% res_retry      Integer         - Retry count for UDP query
+%% res_timeout    Integer         - UDP query timeout before retry
+%% res_inet6      Bool            - address family inet6 for gethostbyname/1
+%% res_usevc      Bool            - use Virtual Circuit (TCP)
+%% res_edns       false|Integer   - false or EDNS version
+%% res_udp_payload_size Integer   - size for EDNS, both query and reply
+%% res_resolv_conf Filename       - file to watch for resolver config i.e
+%%                                  {res_ns, res_search}
+%% res_hosts_file Filename        - file to watch for hosts config
+%%
+%% Socks5 options
+%% --------------
+%% socks5_server  Server          - IP address of the socks5 server
+%% socks5_port    Port            - TCP port of the socks5 server
+%% socks5_methods Ls              - List of authentication methods
+%% socks5_noproxy IPs             - List of {Net,Subnetmask}
+%%
+%% Generic tcp/udp options
+%% -----------------------
+%% tcp_module     Module          - The default gen_tcp  module
+%% udp_module     Module          - The default gen_udp  module
+%% sctp_module	  Module	  - The default gen_sctp module
+%%
+%% Distribution options
+%% --------------------
+%% {node_auth,N}  Ls              - List of authentication for node N
+%% {node_crypt,N} Ls              - List of encryption methods for node N
+%% node_auth      Ls              - Default authenication
+%% node_crypt     Ls              - Default encryption
+%%
+init([]) ->
+    process_flag(trap_exit, true),
+    Db = ets:new(inet_db, [public, named_table]),
+    reset_db(Db),
+    Cache = ets:new(inet_cache, [public, bag, {keypos,2}, named_table]),
+    BynameOpts = [protected, bag, named_table, {keypos,1}],
+    ByaddrOpts = [protected, bag, named_table, {keypos,3}],
+    HostsByname = ets:new(inet_hosts_byname, BynameOpts),
+    HostsByaddr = ets:new(inet_hosts_byaddr, ByaddrOpts),
+    HostsFileByname = ets:new(inet_hosts_file_byname, BynameOpts),
+    HostsFileByaddr = ets:new(inet_hosts_file_byaddr, ByaddrOpts),
+    {ok, #state{db = Db,
+		cache = Cache,
+		hosts_byname = HostsByname,
+		hosts_byaddr = HostsByaddr,
+		hosts_file_byname = HostsFileByname,
+		hosts_file_byaddr = HostsFileByaddr,
+		cache_timer = init_timer() }}.
+
+reset_db(Db) ->
+    ets:insert(Db, {hostname, []}),
+    ets:insert(Db, {res_ns, []}),
+    ets:insert(Db, {res_alt_ns, []}),
+    ets:insert(Db, {res_search, []}),
+    ets:insert(Db, {res_domain, ""}),
+    ets:insert(Db, {res_lookup, []}),
+    ets:insert(Db, {res_recurse, true}),
+    ets:insert(Db, {res_usevc, false}),
+    ets:insert(Db, {res_id, 0}),
+    ets:insert(Db, {res_retry, ?RES_RETRY}),
+    ets:insert(Db, {res_timeout, ?RES_TIMEOUT}),
+    ets:insert(Db, {res_inet6, false}),
+    ets:insert(Db, {res_edns, false}),
+    ets:insert(Db, {res_udp_payload_size, ?DNS_UDP_PAYLOAD_SIZE}),
+    ets:insert(Db, {cache_size, ?CACHE_LIMIT}),
+    ets:insert(Db, {cache_refresh_interval,?CACHE_REFRESH}),
+    ets:insert(Db, {socks5_server, ""}),
+    ets:insert(Db, {socks5_port, ?IPPORT_SOCKS}),
+    ets:insert(Db, {socks5_methods, [none]}),
+    ets:insert(Db, {socks5_noproxy, []}),
+    ets:insert(Db, {tcp_module,  ?DEFAULT_TCP_MODULE}),
+    ets:insert(Db, {udp_module,  ?DEFAULT_UDP_MODULE}),
+    ets:insert(Db, {sctp_module, ?DEFAULT_SCTP_MODULE}).
+
+%%----------------------------------------------------------------------
+%% Func: handle_call/3
+%% Returns: {reply, Reply, State}          |
+%%          {reply, Reply, State, Timeout} |
+%%          {noreply, State}               |
+%%          {noreply, State, Timeout}      |
+%%          {stop, Reason, Reply, State}   | (terminate/2 is called)
+%%          {stop, Reason, Reply, State}     (terminate/2 is called)
+%%----------------------------------------------------------------------
+handle_call(Request, From, #state{db=Db}=State) ->
+    case Request of
+	{load_hosts_file,IPNmAs} when is_list(IPNmAs) ->
+	    NIPs = lists:flatten([ [{N,if tuple_size(IP) =:= 4 -> inet;
+					  tuple_size(IP) =:= 8 -> inet6
+				       end,IP} || N <- [Nm|As]]
+				   || {IP,Nm,As} <- IPNmAs]),
+	    Byname = State#state.hosts_file_byname,
+	    Byaddr = State#state.hosts_file_byaddr,
+	    ets:delete_all_objects(Byname),
+	    ets:delete_all_objects(Byaddr),
+	    ets:insert(Byname, NIPs),
+	    ets:insert(Byaddr, NIPs),
+	    {reply, ok, State};
+
+	{add_host,{A,B,C,D}=IP,[N|As]=Names}
+	when ?ip(A,B,C,D), is_list(N), is_list(As) ->
+	    do_add_host(State#state.hosts_byname,
+			State#state.hosts_byaddr,
+			Names, inet, IP),
+	    {reply, ok, State};
+	{add_host,{A,B,C,D,E,F,G,H}=IP,[N|As]=Names}
+	when ?ip6(A,B,C,D,E,F,G,H), is_list(N), is_list(As) ->
+	    do_add_host(State#state.hosts_byname,
+			State#state.hosts_byaddr,
+			Names, inet6, IP),
+	    {reply, ok, State};
+
+	{del_host,{A,B,C,D}=IP}	when ?ip(A,B,C,D) ->
+	    do_del_host(State#state.hosts_byname,
+			State#state.hosts_byaddr,
+			IP),
+	    {reply, ok, State};
+	{del_host,{A,B,C,D,E,F,G,H}=IP}	when ?ip6(A,B,C,D,E,F,G,H) ->
+	    do_del_host(State#state.hosts_byname,
+			State#state.hosts_byaddr,
+			IP),
+	    {reply, ok, State};
+
+	{add_rr, RR} when is_record(RR, dns_rr) ->
+	    RR1 = lower_rr(RR),
+	    ?dbg("add_rr: ~p~n", [RR1]),
+	    do_add_rr(RR1, Db, State),
+	    {reply, ok, State};
+
+	{del_rr, RR} when is_record(RR, dns_rr) ->
+	    RR1 = lower_rr(RR),
+	    %% note. del_rr will handle wildcards !!!
+	    Cache = State#state.cache,
+	    ets:match_delete(Cache, RR1),
+	    {reply, ok, State};
+
+	{lookup_rr, Domain, Class, Type} ->
+	    {reply, do_lookup_rr(Domain, Class, Type), State};
+
+	{listop, Opt, Op, E} ->
+	    El = [E],
+	    case res_check_option(Opt, El) of
+		true ->
+		    Optname = res_optname(Opt),
+		    [{_,Es}] = ets:lookup(Db, Optname),
+		    NewEs = case Op of
+				ins -> [E | lists_delete(E, Es)];
+				add -> lists_delete(E, Es) ++ El;
+				del -> lists_delete(E, Es)
+			    end,
+		    ets:insert(Db, {Optname, NewEs}),
+		    {reply,ok,State};
+		false ->
+		    {reply,error,State}
+	    end;
+
+	{listdel, Opt} ->
+ 	    ets:insert(Db, {res_optname(Opt), []}),
+ 	    {reply, ok, State};
+
+	{set_hostname, Name} ->
+	    case inet_parse:visible_string(Name) of
+		true ->
+		    ets:insert(Db, {hostname, Name}),
+		    {reply, ok, State};
+		false ->
+		    {reply, error, State}
+	    end;
+
+	{res_set, hosts_file=Option, Fname} ->
+	    handle_set_file(Option, Fname,
+			    res_hosts_file_tm, res_hosts_file_info,
+			    fun (Bin) ->
+				    case inet_parse:hosts(Fname,
+							  {chars,Bin}) of
+					{ok,Opts} ->
+					    [{load_hosts_file,Opts}];
+					_ -> error
+				    end
+			    end,
+			    From, State);
+	%%
+	{res_set, resolv_conf=Option, Fname} ->
+	    handle_set_file(Option, Fname,
+			    res_resolv_conf_tm, res_resolv_conf_info,
+			    fun (Bin) ->
+				    case inet_parse:resolv(Fname,
+							  {chars,Bin}) of
+					{ok,Opts} ->
+					    [del_ns,
+					     clear_search,
+					     clear_cache
+					     |[Opt ||
+						  {T,_}=Opt <- Opts,
+						  (T =:= nameserver orelse
+						   T =:= search)]];
+					_ -> error
+				    end
+			    end,
+			    From, State);
+	%%
+	{res_set, Opt, Value} ->
+	    case res_optname(Opt) of
+		undefined ->
+		    {reply, error, State};
+		Optname ->
+		    case res_check_option(Opt, Value) of
+			true ->
+			    ets:insert(Db, {Optname, Value}),
+			    {reply, ok, State};
+			false ->
+			    {reply, error, State}
+		    end
+	    end;
+
+	{set_resolv_conf_tm, TM} ->
+	    ets:insert(Db, {res_resolv_conf_tm, TM}),
+	    {reply, ok, State};
+
+	{set_hosts_file_tm, TM} ->
+	    ets:insert(Db, {res_hosts_file_tm, TM}),
+	    {reply, ok, State};
+
+	{set_socks_server, {A,B,C,D}} when ?ip(A,B,C,D) ->
+	    ets:insert(Db, {socks5_server, {A,B,C,D}}),
+	    {reply, ok, State};
+
+	{set_socks_port, Port} when is_integer(Port) ->
+	    ets:insert(Db, {socks5_port, Port}),
+	    {reply, ok, State};
+
+	{add_socks_methods, Ls} -> 
+	    [{_,As}] = ets:lookup(Db, socks5_methods),
+	    As1 = lists_subtract(As, Ls),
+	    ets:insert(Db, {socks5_methods, As1 ++ Ls}),
+	    {reply, ok, State};
+	    
+	{del_socks_methods, Ls} ->
+	    [{_,As}] = ets:lookup(Db, socks5_methods),
+	    As1 = lists_subtract(As, Ls),
+	    case lists:member(none, As1) of
+		false -> ets:insert(Db, {socks5_methods, As1 ++ [none]});
+		true  -> ets:insert(Db, {socks5_methods, As1})
+	    end,
+	    {reply, ok, State};
+	
+	del_socks_methods ->
+	    ets:insert(Db, {socks5_methods, [none]}),
+	    {reply, ok, State};
+
+	{add_socks_noproxy, {{A,B,C,D},{MA,MB,MC,MD}}} 
+	when ?ip(A,B,C,D), ?ip(MA,MB,MC,MD) ->
+	    [{_,As}] = ets:lookup(Db, socks5_noproxy),
+	    ets:insert(Db, {socks5_noproxy, As++[{{A,B,C,D},{MA,MB,MC,MD}}]}),
+	    {reply, ok, State};
+
+	{del_socks_noproxy, {A,B,C,D}=IP} when ?ip(A,B,C,D) ->
+	    [{_,As}] = ets:lookup(Db, socks5_noproxy),
+	    ets:insert(Db, {socks5_noproxy, lists_keydelete(IP, 1, As)}),
+	    {reply, ok, State};
+
+	{set_tcp_module, Mod} when is_atom(Mod) ->
+	    ets:insert(Db, {tcp_module, Mod}), %% check/load module ?
+	    {reply, ok, State};
+
+	{set_udp_module, Mod} when is_atom(Mod) ->
+	    ets:insert(Db, {udp_module, Mod}), %% check/load module ?
+	    {reply, ok, State};
+
+	{set_sctp_module, Fam} when is_atom(Fam) ->
+	    ets:insert(Db, {sctp_module, Fam}), %% check/load module ?
+	    {reply, ok, State};
+
+	{set_cache_size, Size} when is_integer(Size), Size >= 0 ->
+	    ets:insert(Db, {cache_size, Size}),
+	    {reply, ok, State};
+	
+	{set_cache_refresh, Time} when is_integer(Time), Time > 0 ->
+	    Time1 = ((Time+999) div 1000)*1000, %% round up
+	    ets:insert(Db, {cache_refresh_interval, Time1}),
+	    stop_timer(State#state.cache_timer),
+	    {reply, ok, State#state{cache_timer = init_timer()}};
+
+	clear_hosts ->
+	    ets:delete_all_objects(State#state.hosts_byname),
+	    ets:delete_all_objects(State#state.hosts_byaddr),
+	    {reply, ok, State};
+
+	clear_cache ->
+	    ets:match_delete(State#state.cache, '_'),
+	    {reply, ok, State};
+
+	reset ->
+	    reset_db(Db),
+	    stop_timer(State#state.cache_timer),
+	    {reply, ok, State#state{cache_timer = init_timer()}};
+
+	{add_rc_list, List} ->
+	    handle_rc_list(List, From, State);
+
+	stop ->
+	    {stop, normal, ok, State};
+
+	_ ->
+	    {reply, error, State}
+    end.
+
+
+%%----------------------------------------------------------------------
+%% Func: handle_cast/2
+%% Returns: {noreply, State}          |
+%%          {noreply, State, Timeout} |
+%%          {stop, Reason, State}            (terminate/2 is called)
+%%----------------------------------------------------------------------
+handle_cast(_Msg, State) ->
+    {noreply, State}.
+
+%%----------------------------------------------------------------------
+%% Func: handle_info/2
+%% Returns: {noreply, State}          |
+%%          {noreply, State, Timeout} |
+%%          {stop, Reason, State}            (terminate/2 is called)
+%%----------------------------------------------------------------------
+handle_info(refresh_timeout, State) ->
+    do_refresh_cache(State#state.cache),
+    {noreply, State#state{cache_timer = init_timer()}};
+
+handle_info(_Info, State) ->
+    {noreply, State}.
+
+%%----------------------------------------------------------------------
+%% Func: terminate/2
+%% Purpose: Shutdown the server
+%% Returns: any (ignored by gen_server)
+%%----------------------------------------------------------------------
+terminate(_Reason, State) ->
+    stop_timer(State#state.cache_timer),
+    ok.
+
+%%%----------------------------------------------------------------------
+%%% Internal functions
+%%%----------------------------------------------------------------------
+
+handle_set_file(Option, Fname, TagTm, TagInfo, ParseFun, From,
+		#state{db=Db}=State) ->
+    case res_check_option(Option, Fname) of
+	true when Fname =:= "" ->
+	    ets:insert(Db, {res_optname(Option), Fname}),
+	    ets:delete(Db, TagInfo),
+	    ets:delete(Db, TagTm),
+	    handle_set_file(ParseFun, <<>>, From, State);
+	true ->
+	    File = filename:flatten(Fname),
+	    ets:insert(Db, {res_optname(Option), File}),
+	    Bin =
+		case erl_prim_loader:read_file_info(File) of
+		    {ok, Finfo0} ->
+			Finfo = Finfo0#file_info{access = undefined,
+						 atime = undefined},
+			ets:insert(Db, {TagInfo, Finfo}),
+			ets:insert(Db, {TagTm, times()}),
+			case erl_prim_loader:get_file(File) of
+			    {ok, B, _} -> B;
+			    _ -> <<>>
+			end;
+		    _ -> <<>>
+		end,
+	    handle_set_file(ParseFun, Bin, From, State);
+	false -> {reply,error,State}
+    end.
+
+handle_set_file(ParseFun, Bin, From, State) ->
+    case ParseFun(Bin) of
+	error -> {reply,error,State};
+	Opts ->
+	    handle_rc_list(Opts, From, State)
+    end.
+
+do_add_host(Byname, Byaddr, Names, Type, IP) ->
+    do_del_host(Byname, Byaddr, IP),
+    NIPs = [{tolower(N),Type,IP} || N <- Names],
+    ets:insert(Byname, NIPs),
+    ets:insert(Byaddr, NIPs),
+    ok.
+
+do_del_host(Byname, Byaddr, IP) ->
+    [ets:delete_object(Byname, NIP) || NIP <- ets:lookup(Byaddr, IP)],
+    ets:delete(Byaddr, IP),
+    ok.
+
+%% Loop over .inetrc option list and call handle_call/3 for each
+%%
+handle_rc_list([], _From, State) ->
+    {reply, ok, State};
+handle_rc_list([Opt|Opts], From, State) ->
+    case rc_opt_req(Opt) of
+	undefined ->
+	    {reply, {error,{badopt,Opt}}, State};
+	Req ->
+	    case handle_calls(Req, From, State) of
+		{reply, ok, NewState} ->
+		    handle_rc_list(Opts, From, NewState);
+		Result -> Result
+	    end
+    end;
+handle_rc_list(_, _From, State) ->
+    {reply, error, State}.
+
+handle_calls([], _From, State) ->
+    {reply, ok, State};
+handle_calls([Req|Reqs], From, State) ->
+    case handle_call(Req, From, State) of
+	{reply, ok, NewState} ->
+	    handle_calls(Reqs, From, NewState);
+	{reply, _, NewState} ->
+	    {reply, error, NewState}
+	    %% {noreply,_} is currently not returned by handle_call/3
+    end;
+handle_calls(Req, From, State) ->
+    handle_call(Req, From, State).
+
+%% Translate .inetrc option into gen_server request
+%%
+rc_opt_req({nameserver, Ns}) ->
+    {listop,nameservers,add,{Ns,?NAMESERVER_PORT}};
+rc_opt_req({nameserver, Ns, Port}) ->
+    {listop,nameservers,add,{Ns,Port}};
+rc_opt_req({alt_nameserver, Ns}) ->
+    {listop,alt_nameservers,add,{Ns,?NAMESERVER_PORT}};
+rc_opt_req({alt_nameserver, Ns, Port}) ->
+    {listop,alt_nameservers,add,{Ns,Port}};
+rc_opt_req({socks5_noproxy, IP, Mask}) ->
+    {add_socks_noproxy, {IP, Mask}};
+rc_opt_req({search, Ds}) when is_list(Ds) ->
+    try	[{listop,search,add,D} || D <- Ds]
+    catch error:_ -> undefined
+    end;
+rc_opt_req({host, IP, Aliases}) -> {add_host, IP, Aliases};
+rc_opt_req({load_hosts_file, _}=Req) -> Req;
+rc_opt_req({lookup, Ls}) ->
+    try {res_set, lookup, translate_lookup(Ls)}
+    catch error:_ -> undefined
+    end;
+rc_opt_req({Name,Arg}) ->
+    case rc_reqname(Name) of
+	undefined ->
+	    case is_res_set(Name) of
+		true -> {res_set,Name,Arg};
+		false -> undefined
+	    end;
+	Req -> {Req, Arg}
+    end;
+rc_opt_req(del_ns) ->
+    {listdel,nameservers};
+rc_opt_req(del_alt_ns) ->
+    {listdel,alt_nameservers};
+rc_opt_req(clear_ns) ->
+    [{listdel,nameservers},{listdel,alt_nameservers}];
+rc_opt_req(clear_search) ->
+    {listdel,search};
+rc_opt_req(Opt) when is_atom(Opt) ->
+    case is_reqname(Opt) of
+	true -> Opt;
+	false -> undefined
+    end;
+rc_opt_req(_) -> undefined.
+%%
+rc_reqname(socks5_server) -> set_socks_server;
+rc_reqname(socks5_port) -> set_socks_port;
+rc_reqname(socks5_methods) -> set_socks_methods;
+rc_reqname(cache_refresh) -> set_cache_refresh;
+rc_reqname(cache_size) -> set_cache_size;
+rc_reqname(udp) -> set_udp_module;
+rc_reqname(sctp) -> set_sctp_module;
+rc_reqname(tcp) -> set_tcp_module;
+rc_reqname(_) -> undefined.
+%%
+is_res_set(domain) -> true;
+is_res_set(lookup) -> true;
+is_res_set(timeout) -> true;
+is_res_set(retry) -> true;
+is_res_set(inet6) -> true;
+is_res_set(usevc) -> true;
+is_res_set(edns) -> true;
+is_res_set(udp_payload_size) -> true;
+is_res_set(resolv_conf) -> true;
+is_res_set(hosts_file) -> true;
+is_res_set(_) -> false.
+%%
+is_reqname(reset) -> true;
+is_reqname(clear_cache) -> true;
+is_reqname(clear_hosts) -> true;
+is_reqname(_) -> false.
+
+%% Add a resource record to the cache if there are space left.
+%% If the cache is full this function first deletes old entries,
+%% i.e. entries with oldest latest access time.
+%% #dns_rr.cnt is used to store the access time instead of number of
+%% accesses.
+do_add_rr(RR, Db, State) ->
+    CacheDb = State#state.cache,
+    TM = times(),
+    case alloc_entry(Db, CacheDb, TM) of
+	true ->
+	    cache_rr(Db, CacheDb, RR#dns_rr { tm = TM,
+					      cnt = TM });
+	_ ->
+	    false
+    end.
+
+cache_rr(_Db, Cache, RR) ->
+    %% delete possible old entry
+    ets:match_delete(Cache, RR#dns_rr { cnt = '_', tm = '_', ttl = '_',
+				        bm = '_', func = '_'}),
+    ets:insert(Cache, RR).
+
+times() ->
+    {Mega,Secs,_} = erlang:now(),
+    Mega*1000000 + Secs.
+
+%% lookup and remove old entries
+
+do_lookup_rr(Domain, Class, Type) ->
+    match_rr(#dns_rr { domain = tolower(Domain), class = Class,type = Type, 
+		      cnt = '_', tm = '_', ttl = '_',
+		      bm = '_', func = '_', data = '_'}).
+
+match_rr(RR) ->
+    filter_rr(ets:match_object(inet_cache, RR), times()).
+
+
+%% filter old resource records and update access count
+
+filter_rr([RR | RRs], Time) when RR#dns_rr.ttl =:= 0 -> %% at least once
+    ets:match_delete(inet_cache, RR),
+    [RR | filter_rr(RRs, Time)];
+filter_rr([RR | RRs], Time) when RR#dns_rr.tm + RR#dns_rr.ttl < Time ->
+    ets:match_delete(inet_cache, RR),
+    filter_rr(RRs, Time);
+filter_rr([RR | RRs], Time) ->
+    ets:match_delete(inet_cache, RR),
+    ets:insert(inet_cache, RR#dns_rr { cnt = Time }),
+    [RR | filter_rr(RRs, Time)];
+filter_rr([], _Time) ->  [].
+
+
+%%
+%% Lower case the domain name before storage 
+%%
+lower_rr(RR) ->
+    Dn = RR#dns_rr.domain,
+    if is_list(Dn) ->
+	    RR#dns_rr { domain = tolower(Dn) };
+       true -> RR
+    end.
+
+%%
+%% Map upper-case to lower-case
+%% NOTE: this code is in kernel and we don't want to relay
+%% to much on stdlib
+%%
+tolower([]) -> [];
+tolower([C|Cs]) when C >= $A, C =< $Z -> [(C-$A)+$a|tolower(Cs)];
+tolower([C|Cs]) -> [C|tolower(Cs)].
+
+dn_ip6_int(A,B,C,D,E,F,G,H) ->
+    dnib(H) ++ dnib(G) ++ dnib(F) ++ dnib(E) ++ 
+	dnib(D) ++ dnib(C) ++ dnib(B) ++ dnib(A) ++ "ip6.int".
+
+dn_in_addr_arpa(A,B,C,D) ->
+    integer_to_list(D) ++ "." ++
+	integer_to_list(C) ++ "." ++
+	integer_to_list(B) ++ "." ++
+	integer_to_list(A) ++ ".in-addr.arpa".
+
+dnib(X) ->
+    [ hex(X), $., hex(X bsr 4), $., hex(X bsr 8), $., hex(X bsr 12), $.].
+
+hex(X) ->
+    X4 = (X band 16#f),
+    if X4 < 10 -> X4 + $0;
+       true -> (X4-10) + $a
+    end.
+
+%% Strip trailing dot, do not produce garbage unless necessary.
+%%
+stripdot(Name) ->
+    case stripdot_1(Name) of
+	false -> Name;
+	N     -> N
+    end.
+%%
+stripdot_1([$.])  -> [];
+stripdot_1([])    -> false;
+stripdot_1([H|T]) ->
+    case stripdot_1(T) of
+	false     -> false;
+	N         -> [H|N]
+    end.
+
+%% -------------------------------------------------------------------
+%% Refresh cache at regular intervals, i.e. delete expired #dns_rr's.
+%% -------------------------------------------------------------------
+init_timer() ->
+    erlang:send_after(cache_refresh(), self(), refresh_timeout).
+
+stop_timer(undefined) ->
+    undefined;
+stop_timer(Timer) ->
+    erlang:cancel_timer(Timer).
+
+cache_refresh() ->
+    case db_get(cache_refresh_interval) of
+	undefined -> ?CACHE_REFRESH;
+	Val       -> Val
+    end.
+
+%% Delete all entries with expired TTL.
+%% Returns the access time of the entry with the oldest access time
+%% in the cache.
+do_refresh_cache(CacheDb) ->
+    Now = times(),
+    do_refresh_cache(ets:first(CacheDb), CacheDb, Now, Now).
+
+do_refresh_cache('$end_of_table', _, _, OldestT) ->
+    OldestT;
+do_refresh_cache(Key, CacheDb, Now, OldestT) ->
+    Fun = fun(RR, T) when RR#dns_rr.tm + RR#dns_rr.ttl < Now ->
+		  ets:match_delete(CacheDb, RR),
+		  T;
+	     (#dns_rr{cnt = C}, T) when C < T ->
+		  C;
+	     (_, T) ->
+		  T
+	  end,
+    Next = ets:next(CacheDb, Key),
+    OldT = lists:foldl(Fun, OldestT, ets:lookup(CacheDb, Key)),
+    do_refresh_cache(Next, CacheDb, Now, OldT).
+
+%% -------------------------------------------------------------------
+%% Allocate room for a new entry in the cache.
+%% Deletes entries with expired TTL and all entries with latest
+%% access time older than
+%% trunc((TM - OldestTM) * 0.3) + OldestTM from the cache if it
+%% is full. Does not delete more than 10% of the entries in the cache
+%% though, unless they there deleted due to expired TTL.
+%% Returns: true if space for a new entry otherwise false.
+%% -------------------------------------------------------------------
+alloc_entry(Db, CacheDb, TM) ->
+    CurSize = ets:info(CacheDb, size),
+    case ets:lookup(Db, cache_size) of
+	[{cache_size, Size}] when Size =< CurSize, Size > 0 ->
+	    alloc_entry(CacheDb, CurSize, TM, trunc(Size * 0.1) + 1);
+	[{cache_size, Size}] when Size =< 0 ->
+	    false;
+	_ ->
+	    true
+    end.
+
+alloc_entry(CacheDb, OldSize, TM, N) ->
+    OldestTM = do_refresh_cache(CacheDb),     % Delete timedout entries
+    case ets:info(CacheDb, size) of
+	OldSize ->
+	    %% No entrys timedout
+	    delete_n_oldest(CacheDb, TM, OldestTM, N);
+	_ ->
+	    true
+    end.
+
+delete_n_oldest(CacheDb, TM, OldestTM, N) ->
+    DelTM = trunc((TM - OldestTM) * 0.3) + OldestTM,
+    case delete_older(CacheDb, DelTM, N) of
+	0 ->
+	    false;
+	_ ->
+	    true
+    end.
+
+%% Delete entries with latest access time older than TM.
+%% Delete max N number of entries.
+%% Returns the number of deleted entries.
+delete_older(CacheDb, TM, N) ->
+    delete_older(ets:first(CacheDb), CacheDb, TM, N, 0).
+
+delete_older('$end_of_table', _, _, _, M) ->
+    M;
+delete_older(_, _, _, N, M) when N =< M ->
+    M;
+delete_older(Domain, CacheDb, TM, N, M) ->
+    Next = ets:next(CacheDb, Domain),
+    Fun = fun(RR, MM) when RR#dns_rr.cnt =< TM ->
+		  ets:match_delete(CacheDb, RR),
+		  MM + 1;
+	     (_, MM) ->
+		  MM
+	  end,
+    M1 = lists:foldl(Fun, M, ets:lookup(CacheDb, Domain)),
+    delete_older(Next, CacheDb, TM, N, M1).
+
+
+%% as lists:delete/2, but delete all exact matches
+%%
+lists_delete(_, []) -> [];
+lists_delete(E, [E|Es]) ->
+    lists_delete(E, Es);
+lists_delete(E, [X|Es]) ->
+    [X|lists_delete(E, Es)].
+
+%% as '--'/2 aka lists:subtract/2 but delete all exact matches
+lists_subtract(As0, Bs) ->
+    lists:foldl(fun (E, As) -> lists_delete(E, As) end, As0, Bs).
+
+%% as lists:keydelete/3, but delete all _exact_ key matches
+lists_keydelete(_, _, []) -> [];
+lists_keydelete(K, N, [T|Ts]) when element(N, T) =:= K ->
+    lists_keydelete(K, N, Ts);
+lists_keydelete(K, N, [X|Ts]) ->
+    [X|lists_keydelete(K, N, Ts)].