diff options
Diffstat (limited to 'lib/kernel/src')
81 files changed, 37945 insertions, 0 deletions
diff --git a/lib/kernel/src/Makefile b/lib/kernel/src/Makefile new file mode 100644 index 0000000000..ef280058fb --- /dev/null +++ b/lib/kernel/src/Makefile @@ -0,0 +1,243 @@ +# +# %CopyrightBegin% +# +# Copyright Ericsson AB 1996-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% +# + +ifdef BOOTSTRAP +EGEN=$(BOOTSTRAP_TOP)/lib/kernel/egen +EBIN=$(BOOTSTRAP_TOP)/lib/kernel/ebin +endif + +include $(ERL_TOP)/make/target.mk +include $(ERL_TOP)/make/$(TARGET)/otp.mk + +# ---------------------------------------------------- +# Application version +# ---------------------------------------------------- + +# Include erts/system/vsn.mk to port number for EPMD -- we will +# get an unwanted definition for VSN too. Therefore, +# we'll use KERNEL_VSN directly instead of assigning it to +# VSN which is done in other Makefiles. Same with HIPE_VSN. + +include ../vsn.mk +include $(ERL_TOP)/erts/vsn.mk +include $(ERL_TOP)/lib/hipe/vsn.mk + +include $(ERL_TOP)/erts/epmd/epmd.mk + + +# ---------------------------------------------------- +# Release directory specification +# ---------------------------------------------------- +RELSYSDIR = $(RELEASE_PATH)/lib/kernel-$(KERNEL_VSN) + +# ---------------------------------------------------- +# Target Specs +# ---------------------------------------------------- + + +MODULES = \ + application \ + application_controller \ + application_master \ + application_starter \ + auth \ + code \ + code_server \ + disk_log \ + disk_log_1 \ + disk_log_server \ + disk_log_sup \ + dist_ac \ + dist_util \ + erl_boot_server \ + erl_ddll \ + erl_distribution \ + erl_epmd \ + erl_reply \ + erts_debug \ + error_handler \ + error_logger \ + file \ + file_io_server \ + file_server \ + gen_tcp \ + gen_udp \ + gen_sctp \ + global \ + global_group \ + global_search \ + group \ + heart \ + hipe_unified_loader \ + inet \ + inet6_tcp \ + inet6_tcp_dist \ + inet6_udp \ + inet6_sctp \ + inet_config \ + inet_db \ + inet_dns \ + inet_gethost_native \ + inet_hosts \ + inet_parse \ + inet_res \ + inet_tcp \ + inet_tcp_dist \ + inet_udp \ + inet_sctp \ + kernel \ + kernel_config \ + net \ + net_adm \ + net_kernel \ + os \ + packages \ + pg2 \ + ram_file \ + rpc \ + seq_trace \ + standard_error \ + user \ + user_drv \ + user_sup \ + wrap_log_reader + +HRL_FILES= ../include/file.hrl ../include/inet.hrl ../include/inet_sctp.hrl +INTERNAL_HRL_FILES= application_master.hrl disk_log.hrl \ + net_address.hrl inet_dns.hrl inet_res.hrl \ + inet_boot.hrl inet_config.hrl inet_int.hrl \ + dist.hrl dist_util.hrl inet_dns_record_adts.hrl + +ERL_FILES= $(MODULES:%=%.erl) + +TARGET_FILES = $(MODULES:%=$(EBIN)/%.$(EMULATOR)) \ + $(APP_TARGET) $(APPUP_TARGET) + +APP_FILE= kernel.app + +APP_SRC= $(APP_FILE).src +APP_TARGET= $(EBIN)/$(APP_FILE) + +APPUP_FILE= kernel.appup + +APPUP_SRC= $(APPUP_FILE).src +APPUP_TARGET= $(EBIN)/$(APPUP_FILE) + +# ---------------------------------------------------- +# FLAGS +# ---------------------------------------------------- + +ERL_COMPILE_FLAGS += -I../include + +# ---------------------------------------------------- +# Targets +# ---------------------------------------------------- + +debug opt: $(TARGET_FILES) + +# Note: In the open-source build clean must not destroyed the preloaded +# beam files. +clean: + rm -f $(NON_PRECIOUS_TARGETS) + rm -f core + + +docs: + +# ---------------------------------------------------- +# Special Build Targets +# ---------------------------------------------------- + +../../hipe/main/hipe.hrl: ../../hipe/vsn.mk ../../hipe/main/hipe.hrl.src + sed -e "s;%VSN%;$(HIPE_VSN);" ../../hipe/main/hipe.hrl.src > ../../hipe/main/hipe.hrl + +$(APP_TARGET): $(APP_SRC) ../vsn.mk + sed -e 's;%VSN%;$(KERNEL_VSN);' $< > $@ + +$(APPUP_TARGET): $(APPUP_SRC) ../vsn.mk + sed -e 's;%VSN%;$(KERNEL_VSN);' $< > $@ + + +EPMD_FLAGS = -Depmd_port_no=$(EPMD_PORT_NO) \ + -Depmd_node_type=$(EPMD_NODE_TYPE) \ + -Depmd_dist_low=$(EPMD_DIST_LOW) \ + -Depmd_dist_high=$(EPMD_DIST_HIGH) \ + -Derlang_daemon_port=$(EPMD_PORT_NO) + +$(ESRC)/inet_dns_record_adts.hrl: $(ESRC)/inet_dns_record_adts.pl + LANG=C $(PERL) $< > $@ + +$(EBIN)/erl_epmd.beam: $(ESRC)/erl_epmd.erl + $(ERLC) $(ERL_COMPILE_FLAGS) $(EPMD_FLAGS) -o$(EBIN) $< + +# ---------------------------------------------------- +# Release Target +# ---------------------------------------------------- +include $(ERL_TOP)/make/otp_release_targets.mk + +release_spec: opt + $(INSTALL_DIR) $(RELSYSDIR)/src + $(INSTALL_DATA) $(ERL_FILES) $(RELSYSDIR)/src + $(INSTALL_DATA) $(INTERNAL_HRL_FILES) $(RELSYSDIR)/src + $(INSTALL_DIR) $(RELSYSDIR)/include + $(INSTALL_DATA) $(HRL_FILES) $(RELSYSDIR)/include + $(INSTALL_DIR) $(RELSYSDIR)/ebin + $(INSTALL_DATA) $(TARGET_FILES) $(RELSYSDIR)/ebin + +release_docs_spec: + + +# Include dependencies -- list below added by Kostis Sagonas +$(EBIN)/application_controller.beam: application_master.hrl +$(EBIN)/application_master.beam: application_master.hrl +$(EBIN)/auth.beam: ../include/file.hrl +$(EBIN)/code.beam: ../include/file.hrl +$(EBIN)/code_server.beam: ../include/file.hrl +$(EBIN)/disk_log.beam: disk_log.hrl +$(EBIN)/disk_log_1.beam: disk_log.hrl ../include/file.hrl +$(EBIN)/disk_log_server.beam: disk_log.hrl +$(EBIN)/dist_util.beam: dist_util.hrl dist.hrl +$(EBIN)/erl_boot_server.beam: inet_boot.hrl +$(EBIN)/erl_epmd.beam: inet_int.hrl erl_epmd.hrl +$(EBIN)/file.beam: ../include/file.hrl +$(EBIN)/gen_tcp.beam: inet_int.hrl +$(EBIN)/gen_udp.beam: inet_int.hrl +$(EBIN)/gen_sctp.beam: ../include/inet_sctp.hrl +$(EBIN)/global.beam: ../../stdlib/include/ms_transform.hrl +$(EBIN)/hipe_unified_loader.beam: ../../hipe/main/hipe.hrl hipe_ext_format.hrl +$(EBIN)/inet.beam: ../include/inet.hrl inet_int.hrl ../include/inet_sctp.hrl +$(EBIN)/inet6_tcp.beam: inet_int.hrl +$(EBIN)/inet6_tcp_dist.beam: net_address.hrl dist.hrl dist_util.hrl +$(EBIN)/inet6_udp.beam: inet_int.hrl +$(EBIN)/inet6_sctp.beam: inet_int.hrl +$(EBIN)/inet_config.beam: inet_config.hrl ../include/inet.hrl +$(EBIN)/inet_db.beam: ../include/inet.hrl inet_int.hrl inet_res.hrl inet_dns.hrl inet_config.hrl +$(EBIN)/inet_dns.beam: inet_int.hrl inet_dns.hrl inet_dns_record_adts.hrl +$(EBIN)/inet_gethost_native.beam: ../include/inet.hrl +$(EBIN)/inet_hosts.beam: ../include/inet.hrl +$(EBIN)/inet_parse.beam: ../include/file.hrl +$(EBIN)/inet_res.beam: ../include/inet.hrl inet_res.hrl inet_dns.hrl inet_int.hrl +$(EBIN)/inet_tcp.beam: inet_int.hrl +$(EBIN)/inet_udp_dist.beam: net_address.hrl dist.hrl dist_util.hrl +$(EBIN)/inet_udp.beam: inet_int.hrl +$(EBIN)/inet_sctp.beam: inet_int.hrl ../include/inet_sctp.hrl +$(EBIN)/net_kernel.beam: net_address.hrl +$(EBIN)/os.beam: ../include/file.hrl +$(EBIN)/ram_file.beam: ../include/file.hrl +$(EBIN)/wrap_log_reader.beam: disk_log.hrl ../include/file.hrl diff --git a/lib/kernel/src/application.erl b/lib/kernel/src/application.erl new file mode 100644 index 0000000000..d9db23d652 --- /dev/null +++ b/lib/kernel/src/application.erl @@ -0,0 +1,263 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1996-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(application). + +-export([start/1, start/2, start_boot/1, start_boot/2, stop/1, + load/1, load/2, unload/1, takeover/2, + which_applications/0, which_applications/1, + loaded_applications/0, permit/2]). +-export([set_env/3, set_env/4, unset_env/2, unset_env/3]). +-export([get_env/1, get_env/2, get_all_env/0, get_all_env/1]). +-export([get_key/1, get_key/2, get_all_key/0, get_all_key/1]). +-export([get_application/0, get_application/1, info/0]). +-export([start_type/0]). + +-export([behaviour_info/1]). + +%%%----------------------------------------------------------------- + +-type restart_type() :: 'permanent' | 'transient' | 'temporary'. +-type application_opt() :: {'description', string()} + | {'vsn', string()} + | {'id', string()} + | {'modules', [atom() | {atom(), any()}]} + | {'registered', [atom()]} + | {'applications', [atom()]} + | {'included_applications', [atom()]} + | {'env', [{atom(), any()}]} + | {'start_phases', [{atom(), any()}] | 'undefined'} + | {'maxT', timeout()} % max timeout + | {'maxP', integer() | 'infinity'} % max processes + | {'mod', {atom(), any()}}. +-type application_spec() :: {'application', atom(), [application_opt()]}. + +%%------------------------------------------------------------------ + +-spec behaviour_info(atom()) -> 'undefined' | [{atom(), byte()}]. + +behaviour_info(callbacks) -> + [{start,2},{stop,1}]; +behaviour_info(_Other) -> + undefined. + +%%%----------------------------------------------------------------- +%%% This module is API towards application_controller and +%%% application_master. +%%%----------------------------------------------------------------- + +-spec load(Application :: atom() | application_spec()) -> + 'ok' | {'error', term()}. + +load(Application) -> + load(Application, []). + +-spec load(Application :: atom() | application_spec(), + Distributed :: any()) -> 'ok' | {'error', term()}. + +load(Application, DistNodes) -> + case application_controller:load_application(Application) of + ok when DistNodes =/= [] -> + AppName = get_appl_name(Application), + case dist_ac:load_application(AppName, DistNodes) of + ok -> + ok; + {error, R} -> + application_controller:unload_application(AppName), + {error, R} + end; + Else -> + Else + end. + +-spec unload(Application :: atom()) -> 'ok' | {'error', term()}. + +unload(Application) -> + application_controller:unload_application(Application). + +-spec start(Application :: atom()) -> 'ok' | {'error', term()}. + +start(Application) -> + start(Application, temporary). + +-spec start(Application :: atom() | application_spec(), + RestartType :: restart_type()) -> any(). + +start(Application, RestartType) -> + case load(Application) of + ok -> + Name = get_appl_name(Application), + application_controller:start_application(Name, RestartType); + {error, {already_loaded, Name}} -> + application_controller:start_application(Name, RestartType); + Error -> + Error + end. + +-spec start_boot(Application :: atom()) -> 'ok' | {'error', term()}. + +start_boot(Application) -> + start_boot(Application, temporary). + +-spec start_boot(Application :: atom(), RestartType :: restart_type()) -> + 'ok' | {'error', term()}. + +start_boot(Application, RestartType) -> + application_controller:start_boot_application(Application, RestartType). + +-spec takeover(Application :: atom(), RestartType :: restart_type()) -> any(). + +takeover(Application, RestartType) -> + dist_ac:takeover_application(Application, RestartType). + +-spec permit(Application :: atom(), Bool :: boolean()) -> 'ok' | {'error', term()}. + +permit(Application, Bool) -> + case Bool of + true -> ok; + false -> ok; + Bad -> exit({badarg, {?MODULE, permit, [Application, Bad]}}) + end, + case application_controller:permit_application(Application, Bool) of + distributed_application -> + dist_ac:permit_application(Application, Bool); + {distributed_application, only_loaded} -> + dist_ac:permit_only_loaded_application(Application, Bool); + LocalResult -> + LocalResult + end. + +-spec stop(Application :: atom()) -> 'ok' | {'error', term()}. + +stop(Application) -> + application_controller:stop_application(Application). + +-spec which_applications() -> [{atom(), string(), string()}]. + +which_applications() -> + application_controller:which_applications(). + +-spec which_applications(timeout()) -> [{atom(), string(), string()}]. + +which_applications(infinity) -> + application_controller:which_applications(infinity); +which_applications(Timeout) when is_integer(Timeout), Timeout>=0 -> + application_controller:which_applications(Timeout). + +-spec loaded_applications() -> [{atom(), string(), string()}]. + +loaded_applications() -> + application_controller:loaded_applications(). + +-spec info() -> any(). + +info() -> + application_controller:info(). + +-spec set_env(Application :: atom(), Key :: atom(), Value :: any()) -> 'ok'. + +set_env(Application, Key, Val) -> + application_controller:set_env(Application, Key, Val). + +-spec set_env(Application :: atom(), Key :: atom(), + Value :: any(), Timeout :: timeout()) -> 'ok'. + +set_env(Application, Key, Val, infinity) -> + application_controller:set_env(Application, Key, Val, infinity); +set_env(Application, Key, Val, Timeout) when is_integer(Timeout), Timeout>=0 -> + application_controller:set_env(Application, Key, Val, Timeout). + +-spec unset_env(atom(), atom()) -> 'ok'. + +unset_env(Application, Key) -> + application_controller:unset_env(Application, Key). + +-spec unset_env(atom(), atom(), timeout()) -> 'ok'. + +unset_env(Application, Key, infinity) -> + application_controller:unset_env(Application, Key, infinity); +unset_env(Application, Key, Timeout) when is_integer(Timeout), Timeout>=0 -> + application_controller:unset_env(Application, Key, Timeout). + +-spec get_env(atom()) -> 'undefined' | {'ok', term()}. + +get_env(Key) -> + application_controller:get_pid_env(group_leader(), Key). + +-spec get_env(atom(), atom()) -> 'undefined' | {'ok', term()}. + +get_env(Application, Key) -> + application_controller:get_env(Application, Key). + +-spec get_all_env() -> [] | [{atom(), any()}]. + +get_all_env() -> + application_controller:get_pid_all_env(group_leader()). + +-spec get_all_env(atom()) -> [] | [{atom(), any()}]. + +get_all_env(Application) -> + application_controller:get_all_env(Application). + +-spec get_key(atom()) -> 'undefined' | {'ok', term()}. + +get_key(Key) -> + application_controller:get_pid_key(group_leader(), Key). + +-spec get_key(atom(), atom()) -> 'undefined' | {'ok', term()}. + +get_key(Application, Key) -> + application_controller:get_key(Application, Key). + +-spec get_all_key() -> 'undefined' | [] | {'ok', [{atom(),any()},...]}. + +get_all_key() -> + application_controller:get_pid_all_key(group_leader()). + +-spec get_all_key(atom()) -> 'undefined' | {'ok', [{atom(),any()},...]}. + +get_all_key(Application) -> + application_controller:get_all_key(Application). + +-spec get_application() -> 'undefined' | {'ok', atom()}. + +get_application() -> + application_controller:get_application(group_leader()). + +-spec get_application(Pid :: pid()) -> 'undefined' | {'ok', atom()} + ; (Module :: atom()) -> 'undefined' | {'ok', atom()}. + +get_application(Pid) when is_pid(Pid) -> + case process_info(Pid, group_leader) of + {group_leader, Gl} -> + application_controller:get_application(Gl); + undefined -> + undefined + end; +get_application(Module) when is_atom(Module) -> + application_controller:get_application_module(Module). + +-spec start_type() -> 'undefined' | 'local' | 'normal' + | {'takeover', node()} | {'failover', node()}. + +start_type() -> + application_controller:start_type(group_leader()). + +%% Internal +get_appl_name(Name) when is_atom(Name) -> Name; +get_appl_name({application, Name, _}) when is_atom(Name) -> Name. diff --git a/lib/kernel/src/application_controller.erl b/lib/kernel/src/application_controller.erl new file mode 100644 index 0000000000..7c1f059875 --- /dev/null +++ b/lib/kernel/src/application_controller.erl @@ -0,0 +1,1946 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1996-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(application_controller). + +%% External exports +-export([start/1, + load_application/1, unload_application/1, + start_application/2, start_boot_application/2, stop_application/1, + control_application/1, + change_application_data/2, prep_config_change/0, config_change/1, + which_applications/0, which_applications/1, + loaded_applications/0, info/0, + get_pid_env/2, get_env/2, get_pid_all_env/1, get_all_env/1, + get_pid_key/2, get_key/2, get_pid_all_key/1, get_all_key/1, + get_master/1, get_application/1, get_application_module/1, + start_type/1, permit_application/2, do_config_diff/2, + set_env/3, set_env/4, unset_env/2, unset_env/3]). + +%% Internal exports +-export([handle_call/3, handle_cast/2, handle_info/2, terminate/2, + code_change/3, init_starter/4, get_loaded/1]). + +%% Test exports, only to be used from the test suites +-export([test_change_apps/2]). + +-import(lists, [zf/2, map/2, foreach/2, foldl/3, + keysearch/3, keydelete/3, keyreplace/4]). + +-include("application_master.hrl"). + +-define(AC, ?MODULE). % Name of process + +%%%----------------------------------------------------------------- +%%% The application_controller controls local applications only. A +%%% local application can be loaded/started/stopped/unloaded and +%%% changed. The control of distributed applications is taken care of +%%% by another process (default is dist_ac). +%%% +%%% When an application has been started (by a call to application:start) +%%% it can be running or not running (on this node). For example, +%%% a distributed application must be started on all nodes, but +%%% may be running on one node at the time. +%%% +%%% The external API to this module is in the module 'application'. +%%% +%%% The process that controls distributed applications (called dist +%%% ac). calls application_controller:control_application(Name) to +%%% take responsibility for an application. The interface between AC +%%% and the dist_ac process is message-based: +%%% +%%% AC DIST AC +%%% == ======= +%%% --> {ac_load_application_req, Name} +%%% <-- {ac_load_application_reply, Name, LoadReply} +%%% --> {ac_start_application_req, Name} (*) +%%% <-- {ac_start_application_reply, Name, StartReply} +%%% --> {ac_application_run, Name, Res} +%%% --> {ac_application_not_run, Name, Res} +%%% --> {ac_application_stopped, Name} +%%% --> {ac_application_unloaded, Name} +%%% <-- {ac_change_application_req, Name, Req} (**) +%%% +%%% Where LoadReply = +%%% ok - App is loaded +%%% {error, R} - An error occurred +%%% And StartReply = +%%% start_it - DIST AC decided that AC should start the app +%%% {started, Node} - The app is started distributed at Node +%%% not_started - The app should not be running at this time +%%% {takeover, Node}- The app should takeover from Node +%%% {error, R} - an error occurred +%%% And Req = +%%% start_it - DIST AC wants AC to start the app locally +%%% stop_it - AC should stop the app. +%%% {takeover, Node, RestartType} +%%% - AC should start the app as a takeover +%%% {failover, Node, RestartType} +%%% - AC should start the app as a failover +%%% {started, Node} - The app is started at Node +%%% NOTE: The app must have been started at this node +%%% before this request is sent! +%%% And Res = +%%% ok - Application is started locally +%%% {error, R} - Start of application failed +%%% +%%% (*) +%%% The call to application:start() doesn't return until the +%%% ac_start_application_reply has been received by AC. AC +%%% itself is not blocked however. +%%% (**) +%%% DIST AC gets ACK to its ac_change_application_req, but not as a +%%% separate messgage. Instead the normal messages are used as: +%%% start_it generates an ac_application_run +%%% stop_it generates an ac_application_not_run +%%% takeover generates an ac_application_run +%%% started doesn't generate anything +%%% +%%% There is a distinction between application:stop and stop_it +%%% from a dist ac process. The first one stops the application, +%%% and resets the internal structures as they were before start was +%%% called. stop_it stops the application, but just marks it as +%%% not being running. +%%% +%%% When a dist ac process has taken control of an application, no +%%% other process can take the control. +%%%----------------------------------------------------------------- + +%%----------------------------------------------------------------- +%% Naming conventions: +%% App = appl_descr() +%% Appl = #appl +%% AppName = atom() +%% Application = App | AppName +%%----------------------------------------------------------------- +-record(state, {loading = [], starting = [], start_p_false = [], running = [], + control = [], started = [], start_req = [], conf_data}). +%%----------------------------------------------------------------- +%% loading = [{AppName, From}] - Load not yet finished +%% starting = [{AppName, RestartType, Type, From}] - Start not +%% yet finished +%% start_p_false = [{AppName, RestartType, Type, From}] - Start not +%% executed because permit == false +%% running = [{AppName, Pid}] - running locally (Pid == application_master) +%% [{AppName, {distributed, Node}}] - running on Node +%% control = [{AppName, Controller}] +%% started = [{AppName, RestartType}] - Names of all apps that +%% have been started (but may not run because +%% permission = false) +%% conf_data = [{AppName, Env}] +%% start_req = [{AppName, From}] - list of all start requests +%% Id = AMPid | undefined | {distributed, Node} +%% Env = [{Key, Value}] +%%----------------------------------------------------------------- + +-record(appl, {name, appl_data, descr, id, vsn, restart_type, inc_apps, apps}). + +%%----------------------------------------------------------------- +%% Func: start/1 +%% Args: KernelApp = appl_descr() +%% appl_descr() = [{application, Name, [appl_opt()]}] +%% appl_opt() = {description, string()} | +%% {vsn, string()} | +%% {id, string()}, | +%% {modules, [Module|{Module,Vsn}]} | +%% {registered, [atom()]} | +%% {applications, [atom()]} | +%% {included_applications, [atom()]} | +%% {env, [{atom(), term()}]} | +%% {start_phases, [{atom(), term()}]}| +%% {maxT, integer()|infinity} | +%% {maxP, integer()|infinity} | +%% {mod, {Module, term()}} +%% Module = atom() +%% Vsn = term() +%% Purpose: Starts the application_controller. This process starts all +%% application masters for the applications. +%% The kernel application is the only application that is +%% treated specially. The reason for this is that the kernel +%% starts user. This process is special because it should +%% be group_leader for this process. +%% Pre: All modules are loaded, or will be loaded on demand. +%% Returns: {ok, Pid} | ReasonStr +%%----------------------------------------------------------------- +start(KernelApp) -> + %% OTP-5811 Don't start as a gen_server to prevent crash report + %% when (if) the process terminates + Init = self(), + AC = spawn_link(fun() -> init(Init, KernelApp) end), + receive + {ack, AC, ok} -> + {ok, AC}; + {ack, AC, {error, Reason}} -> + to_string(Reason); % init doesn't want error tuple, only a reason + {'EXIT', _Pid, Reason} -> + to_string(Reason) + end. + +%%----------------------------------------------------------------- +%% Func: load_application/1 +%% Args: Application = appl_descr() | atom() +%% Purpose: Loads an application. Currently just inserts the +%% application's env. +%% Returns: ok | {error, Reason} +%%----------------------------------------------------------------- +load_application(Application) -> + gen_server:call(?AC, {load_application, Application}, infinity). + +unload_application(AppName) -> + gen_server:call(?AC, {unload_application, AppName}, infinity). + +%%----------------------------------------------------------------- +%% Func: start_application/2 +%% Args: Application = atom() +%% RestartType = permanent | transient | temporary +%% Purpose: Starts a new application. +%% The RestartType specifies what should happen if the +%% application dies: +%% If it is permanent, all other applications are terminated, +%% and the application_controller dies. +%% If it is transient, and the application dies normally, +%% this is reported and no other applications are terminated. +%% If the application dies abnormally, all other applications +%% are terminated, and the application_controller dies. +%% If it is temporary and the application dies this is reported +%% and no other applications are terminated. In this way, +%% an application can run in test mode, without disturbing +%% the other applications. +%% The caller of this function is suspended until the application +%% is started, either locally or distributed. +%% Returns: ok | {error, Reason} +%%----------------------------------------------------------------- +start_application(AppName, RestartType) -> + gen_server:call(?AC, {start_application, AppName, RestartType}, infinity). + +%%----------------------------------------------------------------- +%% Func: start_boot_application/2 +%% The same as start_application/2 expect that this function is +%% called from the boot script file. It mustnot be used by the operator. +%% This function will cause a node crash if a permanent application +%% fails to boot start +%%----------------------------------------------------------------- +start_boot_application(Application, RestartType) -> + case {application:load(Application), RestartType} of + {ok, _} -> + AppName = get_appl_name(Application), + gen_server:call(?AC, {start_application, AppName, RestartType}, infinity); + {{error, {already_loaded, AppName}}, _} -> + gen_server:call(?AC, {start_application, AppName, RestartType}, infinity); + {{error,{bad_environment_value,Env}}, permanent} -> + Txt = io_lib:format("Bad environment variable: ~p Application: ~p", + [Env, Application]), + exit({error, list_to_atom(lists:flatten(Txt))}); + {Error, _} -> + Error + end. + +stop_application(AppName) -> + gen_server:call(?AC, {stop_application, AppName}, infinity). + +%%----------------------------------------------------------------- +%% Returns: [{Name, Descr, Vsn}] +%%----------------------------------------------------------------- +which_applications() -> + gen_server:call(?AC, which_applications). +which_applications(Timeout) -> + gen_server:call(?AC, which_applications, Timeout). + +loaded_applications() -> + ets:filter(ac_tab, + fun([{{loaded, AppName}, #appl{descr = Descr, vsn = Vsn}}]) -> + {true, {AppName, Descr, Vsn}}; + (_) -> + false + end, + []). + +%% Returns some debug info +info() -> + gen_server:call(?AC, info). + +control_application(AppName) -> + gen_server:call(?AC, {control_application, AppName}, infinity). + +%%----------------------------------------------------------------- +%% Func: change_application_data/2 +%% Args: Applications = [appl_descr()] +%% Config = [{AppName, [{Par,Val}]}] +%% Purpose: Change all applications and their parameters on this node. +%% This function should be used from a release handler, at +%% the same time as the .app or start.boot file is +%% introduced. Note that during some time the ACs may have +%% different view of e.g. the distributed applications. +%% This is solved by syncing the release installation. +%% However, strange things may happen if a node crashes +%% and two other nodes have different opinons about who's +%% gonna start the applications. The release handler must +%% shutdown each involved node in this case. +%% Note that this function is used to change existing apps, +%% adding new/deleting old isn't handled by this function. +%% Changes an application's vsn, descr and env. +%% Returns: ok | {error, Reason} +%% If an error occurred, the situation may be inconsistent, +%% so the release handler must restart the node. E.g. if +%% some applicatation may have got new config data. +%%----------------------------------------------------------------- +change_application_data(Applications, Config) -> + gen_server:call(?AC, + {change_application_data, Applications, Config}, + infinity). + +prep_config_change() -> + gen_server:call(?AC, + prep_config_change, + infinity). + + +config_change(EnvPrev) -> + gen_server:call(?AC, + {config_change, EnvPrev}, + infinity). + + + +get_pid_env(Master, Key) -> + case ets:match(ac_tab, {{application_master, '$1'}, Master}) of + [[AppName]] -> get_env(AppName, Key); + _ -> undefined + end. + +get_env(AppName, Key) -> + case ets:lookup(ac_tab, {env, AppName, Key}) of + [{_, Val}] -> {ok, Val}; + _ -> undefined + end. + +get_pid_all_env(Master) -> + case ets:match(ac_tab, {{application_master, '$1'}, Master}) of + [[AppName]] -> get_all_env(AppName); + _ -> [] + end. + +get_all_env(AppName) -> + map(fun([Key, Val]) -> {Key, Val} end, + ets:match(ac_tab, {{env, AppName, '$1'}, '$2'})). + + + + +get_pid_key(Master, Key) -> + case ets:match(ac_tab, {{application_master, '$1'}, Master}) of + [[AppName]] -> get_key(AppName, Key); + _ -> undefined + end. + +get_key(AppName, Key) -> + case ets:lookup(ac_tab, {loaded, AppName}) of + [{_, Appl}] -> + case Key of + description -> + {ok, Appl#appl.descr}; + id -> + {ok, Appl#appl.id}; + vsn -> + {ok, Appl#appl.vsn}; + modules -> + {ok, (Appl#appl.appl_data)#appl_data.mods}; + maxP -> + {ok, (Appl#appl.appl_data)#appl_data.maxP}; + maxT -> + {ok, (Appl#appl.appl_data)#appl_data.maxT}; + registered -> + {ok, (Appl#appl.appl_data)#appl_data.regs}; + included_applications -> + {ok, Appl#appl.inc_apps}; + applications -> + {ok, Appl#appl.apps}; + env -> + {ok, get_all_env(AppName)}; + mod -> + {ok, (Appl#appl.appl_data)#appl_data.mod}; + start_phases -> + {ok, (Appl#appl.appl_data)#appl_data.phases}; + _ -> undefined + end; + _ -> + undefined + end. + +get_pid_all_key(Master) -> + case ets:match(ac_tab, {{application_master, '$1'}, Master}) of + [[AppName]] -> get_all_key(AppName); + _ -> [] + end. + +get_all_key(AppName) -> + case ets:lookup(ac_tab, {loaded, AppName}) of + [{_, Appl}] -> + {ok, [{description, Appl#appl.descr}, + {id, Appl#appl.id}, + {vsn, Appl#appl.vsn}, + {modules, (Appl#appl.appl_data)#appl_data.mods}, + {maxP, (Appl#appl.appl_data)#appl_data.maxP}, + {maxT, (Appl#appl.appl_data)#appl_data.maxT}, + {registered, (Appl#appl.appl_data)#appl_data.regs}, + {included_applications, Appl#appl.inc_apps}, + {applications, Appl#appl.apps}, + {env, get_all_env(AppName)}, + {mod, (Appl#appl.appl_data)#appl_data.mod}, + {start_phases, (Appl#appl.appl_data)#appl_data.phases} + ]}; + _ -> + undefined + end. + + +start_type(Master) -> + case ets:match(ac_tab, {{application_master, '$1'}, Master}) of + [[AppName]] -> + gen_server:call(?AC, {start_type, AppName}, infinity); + _X -> + undefined + end. + + + + + + +get_master(AppName) -> + case ets:lookup(ac_tab, {application_master, AppName}) of + [{_, Pid}] -> Pid; + _ -> undefined + end. + +get_application(Master) -> + case ets:match(ac_tab, {{application_master, '$1'}, Master}) of + [[AppName]] -> {ok, AppName}; + _ -> undefined + end. + +get_application_module(Module) -> + ApplDataPattern = #appl_data{mods='$2', _='_'}, + ApplPattern = #appl{appl_data=ApplDataPattern, _='_'}, + AppModules = ets:match(ac_tab, {{loaded, '$1'}, ApplPattern}), + get_application_module(Module, AppModules). + +get_application_module(Module, [[AppName, Modules]|AppModules]) -> + case in_modules(Module, Modules) of + true -> + {ok, AppName}; + false -> + get_application_module(Module, AppModules) + end; +get_application_module(_Module, []) -> + undefined. + +%% 'modules' key in .app is a list of Module or {Module,Vsn} +in_modules(Module, [Module|_Modules]) -> + true; +in_modules(Module, [{Module, _Vsn}|_Modules]) -> + true; +in_modules(Module, [_Module|Modules]) -> + in_modules(Module, Modules); +in_modules(_Module, []) -> + false. + +permit_application(ApplName, Flag) -> + gen_server:call(?AC, + {permit_application, ApplName, Flag}, + infinity). + + +set_env(AppName, Key, Val) -> + gen_server:call(?AC, {set_env, AppName, Key, Val}). +set_env(AppName, Key, Val, Timeout) -> + gen_server:call(?AC, {set_env, AppName, Key, Val}, Timeout). + +unset_env(AppName, Key) -> + gen_server:call(?AC, {unset_env, AppName, Key}). +unset_env(AppName, Key, Timeout) -> + gen_server:call(?AC, {unset_env, AppName, Key}, Timeout). + +%%%----------------------------------------------------------------- +%%% call-back functions from gen_server +%%%----------------------------------------------------------------- +init(Init, Kernel) -> + register(?AC, self()), + process_flag(trap_exit, true), + put('$ancestors', [Init]), % OTP-5811, for gen_server compatibility + put('$initial_call', {application_controller, start, 1}), + + case catch check_conf() of + {ok, ConfData} -> + %% Actually, we don't need this info in an ets table anymore. + %% This table was introduced because starting applications + %% should be able to get som info from AC (e.g. loaded_apps). + %% The new implementation makes sure the AC process can be + %% called during start-up of any app. + case check_conf_data(ConfData) of + ok -> + ets:new(ac_tab, [set, public, named_table]), + S = #state{conf_data = ConfData}, + {ok, KAppl} = make_appl(Kernel), + case catch load(S, KAppl) of + {'EXIT', LoadError} -> + Reason = {'load error', LoadError}, + Init ! {ack, self(), {error, to_string(Reason)}}; + {ok, NewS} -> + Init ! {ack, self(), ok}, + gen_server:enter_loop(?MODULE, [], NewS, + {local, ?AC}) + end; + {error, ErrorStr} -> + Str = lists:flatten(io_lib:format("invalid config data: ~s", [ErrorStr])), + Init ! {ack, self(), {error, to_string(Str)}} + end; + {error, {File, Line, Str}} -> + ReasonStr = + lists:flatten(io_lib:format("error in config file " + "~p (~w): ~s", + [File, Line, Str])), + Init ! {ack, self(), {error, to_string(ReasonStr)}} + end. + + +%% Check the syntax of the .config file [{ApplicationName, [{Parameter, Value}]}]. +check_conf_data([]) -> + ok; +check_conf_data(ConfData) when is_list(ConfData) -> + [Application | ConfDataRem] = ConfData, + case Application of + {kernel, List} when is_list(List) -> + case check_para_kernel(List) of + ok -> + check_conf_data(ConfDataRem); + Error1 -> + Error1 + end; + {AppName, List} when is_atom(AppName), is_list(List) -> + case check_para(List, atom_to_list(AppName)) of + ok -> + check_conf_data(ConfDataRem); + Error2 -> + Error2 + end; + {AppName, List} when is_list(List) -> + ErrMsg = "application: " + ++ lists:flatten(io_lib:format("~p",[AppName])) + ++ "; application name must be an atom", + {error, ErrMsg}; + {AppName, _List} -> + ErrMsg = "application: " + ++ lists:flatten(io_lib:format("~p",[AppName])) + ++ "; parameters must be a list", + {error, ErrMsg}; + Else -> + ErrMsg = "invalid application name: " ++ + lists:flatten(io_lib:format(" ~p",[Else])), + {error, ErrMsg} + end; +check_conf_data(_ConfData) -> + {error, 'configuration must be a list ended by <dot><whitespace>'}. + + +%% Special check of distributed parameter for kernel +check_para_kernel([]) -> + ok; +check_para_kernel([{distributed, Apps} | ParaList]) when is_list(Apps) -> + case check_distributed(Apps) of + {error, ErrorMsg} -> + {error, ErrorMsg}; + _ -> + check_para_kernel(ParaList) + end; +check_para_kernel([{distributed, _Apps} | _ParaList]) -> + {error, "application: kernel; erroneous parameter: distributed"}; +check_para_kernel([{Para, _Val} | ParaList]) when is_atom(Para) -> + check_para_kernel(ParaList); +check_para_kernel([{Para, _Val} | _ParaList]) -> + {error, "application: kernel; invalid parameter: " ++ + lists:flatten(io_lib:format("~p",[Para]))}; +check_para_kernel(Else) -> + {error, "application: kernel; invalid parameter list: " ++ + lists:flatten(io_lib:format("~p",[Else]))}. + + +check_distributed([]) -> + ok; +check_distributed([{App, List} | Apps]) when is_atom(App), is_list(List) -> + check_distributed(Apps); +check_distributed([{App, infinity, List} | Apps]) when is_atom(App), is_list(List) -> + check_distributed(Apps); +check_distributed([{App, Time, List} | Apps]) when is_atom(App), is_integer(Time), is_list(List) -> + check_distributed(Apps); +check_distributed(_Else) -> + {error, "application: kernel; erroneous parameter: distributed"}. + + +check_para([], _AppName) -> + ok; +check_para([{Para, _Val} | ParaList], AppName) when is_atom(Para) -> + check_para(ParaList, AppName); +check_para([{Para, _Val} | _ParaList], AppName) -> + {error, "application: " ++ AppName ++ "; invalid parameter: " ++ + lists:flatten(io_lib:format("~p",[Para]))}; +check_para([Else | _ParaList], AppName) -> + {error, "application: " ++ AppName ++ "; invalid parameter: " ++ + lists:flatten(io_lib:format("~p",[Else]))}. + + +handle_call({load_application, Application}, From, S) -> + case catch do_load_application(Application, S) of + {ok, NewS} -> + AppName = get_appl_name(Application), + case cntrl(AppName, S, {ac_load_application_req, AppName}) of + true -> + {noreply, S#state{loading = [{AppName, From} | + S#state.loading]}}; + false -> + {reply, ok, NewS} + end; + {error, Error} -> + {reply, {error, Error}, S}; + {'EXIT',R} -> + {reply, {error, R}, S} + end; + +handle_call({unload_application, AppName}, _From, S) -> + case lists:keymember(AppName, 1, S#state.running) of + true -> {reply, {error, {running, AppName}}, S}; + false -> + case get_loaded(AppName) of + {true, _} -> + NewS = unload(AppName, S), + cntrl(AppName, S, {ac_application_unloaded, AppName}), + {reply, ok, NewS}; + false -> + {reply, {error, {not_loaded, AppName}}, S} + end + end; + +handle_call({start_application, AppName, RestartType}, From, S) -> + #state{running = Running, starting = Starting, start_p_false = SPF, + started = Started, start_req = Start_req} = S, + %% Check if the commandline environment variables are OK. + %% Incase of erroneous variables do not start the application, + %% if the application is permanent crash the node. + %% Check if the application is already starting. + case lists:keysearch(AppName, 1, Start_req) of + false -> + case catch check_start_cond(AppName, RestartType, Started, Running) of + {ok, Appl} -> + Cntrl = cntrl(AppName, S, {ac_start_application_req, AppName}), + Perm = application:get_env(kernel, permissions), + case {Cntrl, Perm} of + {true, _} -> + {noreply, S#state{starting = [{AppName, RestartType, normal, From} | + Starting], + start_req = [{AppName, From} | Start_req]}}; + {false, undefined} -> + spawn_starter(From, Appl, S, normal), + {noreply, S#state{starting = [{AppName, RestartType, normal, From} | + Starting], + start_req = [{AppName, From} | Start_req]}}; + {false, {ok, Perms}} -> + case lists:member({AppName, false}, Perms) of + false -> + spawn_starter(From, Appl, S, normal), + {noreply, S#state{starting = [{AppName, RestartType, normal, From} | + Starting], + start_req = [{AppName, From} | Start_req]}}; + true -> + SS = S#state{start_p_false = [{AppName, RestartType, normal, From} | + SPF]}, + {reply, ok, SS} + end + end; + {error, R} -> + {reply, {error, R}, S} + end; + {value, {AppName, _FromX}} -> + SS = S#state{start_req = [{AppName, From} | Start_req]}, + {noreply, SS} + + end; + +handle_call({permit_application, AppName, Bool}, From, S) -> + Control = S#state.control, + Starting = S#state.starting, + SPF = S#state.start_p_false, + Started = S#state.started, + Running = S#state.running, + Start_req = S#state.start_req, + IsLoaded = get_loaded(AppName), + IsStarting = lists:keysearch(AppName, 1, Starting), + IsSPF = lists:keysearch(AppName, 1, SPF), + IsStarted = lists:keysearch(AppName, 1, Started), + IsRunning = lists:keysearch(AppName, 1, Running), + + case lists:keymember(AppName, 1, Control) of + %%======================== + %% distributed application + %%======================== + true -> + case {IsLoaded, IsStarting, IsStarted} of + %% not loaded + {false, _, _} -> + {reply, {error, {not_loaded, AppName}}, S}; + %% only loaded + {{true, _Appl}, false, false} -> + update_permissions(AppName, Bool), + {reply, {distributed_application, only_loaded}, S}; + _ -> + update_permissions(AppName, Bool), + {reply, distributed_application, S} + end; + %%======================== + %% local application + %%======================== + false -> + case {Bool, IsLoaded, IsStarting, IsSPF, IsStarted, IsRunning} of + %%------------------------ + %% permit the applicaition + %%------------------------ + %% already running + {true, _, _, _, _, {value, _Tuple}} -> + {reply, ok, S}; + %% not loaded + {true, false, _, _, _, _} -> + {reply, {error, {not_loaded, AppName}}, S}; + %% only loaded + {true, {true, _Appl}, false, false, false, false} -> + update_permissions(AppName, Bool), + {reply, ok, S}; + %% starting + {true, {true, _Appl}, {value, _Tuple}, false, false, false} -> + update_permissions(AppName, Bool), + {reply, ok, S}; %% check the permission after then app is started + %% start requested but not started because permit was false + {true, {true, Appl}, false, {value, Tuple}, false, false} -> + update_permissions(AppName, Bool), + {_AppName2, RestartType, normal, _From} = Tuple, + spawn_starter(From, Appl, S, normal), + SS = S#state{starting = [{AppName, RestartType, normal, From} | Starting], + start_p_false = keydelete(AppName, 1, SPF), + start_req = [{AppName, From} | Start_req]}, + {noreply, SS}; + %% started but not running + {true, {true, Appl}, _, _, {value, {AppName, RestartType}}, false} -> + update_permissions(AppName, Bool), + spawn_starter(From, Appl, S, normal), + SS = S#state{starting = [{AppName, RestartType, normal, From} | Starting], + started = keydelete(AppName, 1, Started), + start_req = [{AppName, From} | Start_req]}, + {noreply, SS}; + + %%========================== + %% unpermit the applicaition + %%========================== + %% running + {false, _, _, _, _, {value, {_AppName, Id}}} -> + {value, {_AppName2, Type}} = keysearch(AppName, 1, Started), + stop_appl(AppName, Id, Type), + NRunning = keydelete(AppName, 1, Running), + {reply, ok, S#state{running = NRunning}}; + %% not loaded + {false, false, _, _, _, _} -> + {reply, {error, {not_loaded, AppName}}, S}; + %% only loaded + {false, {true, _Appl}, false, false, false, false} -> + update_permissions(AppName, Bool), + {reply, ok, S}; + %% starting + {false, {true, _Appl}, {value, _Tuple}, false, false, false} -> + update_permissions(AppName, Bool), + {reply, ok, S}; + %% start requested but not started because permit was false + {false, {true, _Appl}, false, {value, _Tuple}, false, false} -> + update_permissions(AppName, Bool), + SS = S#state{start_p_false = keydelete(AppName, 1, SPF)}, + {reply, ok, SS}; + %% started but not running + {false, {true, _Appl}, _, _, {value, _Tuple}, false} -> + update_permissions(AppName, Bool), + {reply, ok, S} + + end + end; + +handle_call({stop_application, AppName}, _From, S) -> + #state{running = Running, started = Started} = S, + case keysearch(AppName, 1, Running) of + {value, {_AppName, Id}} -> + {value, {_AppName2, Type}} = keysearch(AppName, 1, Started), + stop_appl(AppName, Id, Type), + NRunning = keydelete(AppName, 1, Running), + NStarted = keydelete(AppName, 1, Started), + cntrl(AppName, S, {ac_application_stopped, AppName}), + {reply, ok, S#state{running = NRunning, started = NStarted}}; + false -> + case lists:keymember(AppName, 1, Started) of + true -> + NStarted = keydelete(AppName, 1, Started), + cntrl(AppName, S, {ac_application_stopped, AppName}), + {reply, ok, S#state{started = NStarted}}; + false -> + {reply, {error, {not_started, AppName}}, S} + end + end; + +handle_call({change_application_data, Applications, Config}, _From, S) -> + OldAppls = ets:filter(ac_tab, + fun([{{loaded, _AppName}, Appl}]) -> + {true, Appl}; + (_) -> + false + end, + []), + case catch do_change_apps(Applications, Config, OldAppls) of + {error, R} -> + {reply, {error, R}, S}; + {'EXIT', R} -> + {reply, {error, R}, S}; + NewAppls -> + lists:foreach(fun(Appl) -> + ets:insert(ac_tab, {{loaded, Appl#appl.name}, + Appl}) + end, NewAppls), + {reply, ok, S#state{conf_data = Config}} + end; + +handle_call(prep_config_change, _From, S) -> + RunningApps = S#state.running, + EnvBefore = lists:reverse(do_prep_config_change(RunningApps)), + {reply, EnvBefore, S}; + +handle_call({config_change, EnvBefore}, _From, S) -> + RunningApps = S#state.running, + R = do_config_change(RunningApps, EnvBefore), + {reply, R, S}; + +handle_call(which_applications, _From, S) -> + Reply = zf(fun({Name, Id}) -> + case Id of + {distributed, _Node} -> + false; + _ -> + {true, #appl{descr = Descr, vsn = Vsn}} = + get_loaded(Name), + {true, {Name, Descr, Vsn}} + end + end, S#state.running), + {reply, Reply, S}; + +handle_call({set_env, AppName, Key, Val}, _From, S) -> + ets:insert(ac_tab, {{env, AppName, Key}, Val}), + {reply, ok, S}; + +handle_call({unset_env, AppName, Key}, _From, S) -> + ets:delete(ac_tab, {env, AppName, Key}), + {reply, ok, S}; + +handle_call({control_application, AppName}, {Pid, _Tag}, S) -> + Control = S#state.control, + case lists:keymember(AppName, 1, Control) of + false -> + link(Pid), + {reply, true, S#state{control = [{AppName, Pid} | Control]}}; + true -> + {reply, false, S} + end; + +handle_call({start_type, AppName}, _From, S) -> + Starting = S#state.starting, + StartType = case keysearch(AppName, 1, Starting) of + false -> + local; + {value, {_AppName, _RestartType, Type, _F}} -> + Type + end, + {reply, StartType, S}; + +handle_call(info, _From, S) -> + Reply = [{loaded, loaded_applications()}, + {loading, S#state.loading}, + {started, S#state.started}, + {start_p_false, S#state.start_p_false}, + {running, S#state.running}, + {starting, S#state.starting}], + {reply, Reply, S}. + +handle_cast({application_started, AppName, Res}, S) -> + handle_application_started(AppName, Res, S). + +handle_application_started(AppName, Res, S) -> + #state{starting = Starting, running = Running, started = Started, + start_req = Start_req} = S, + Start_reqN = reply_to_requester(AppName, Start_req, Res), + {value, {_AppName, RestartType, _Type, _From}} = keysearch(AppName, 1, Starting), + case Res of + {ok, Id} -> + case AppName of + kernel -> check_user(); + _ -> ok + end, + info_started(AppName, nd(Id)), + notify_cntrl_started(AppName, Id, S, ok), + NRunning = keyreplaceadd(AppName, 1, Running,{AppName,Id}), + NStarted = keyreplaceadd(AppName, 1, Started,{AppName,RestartType}), + NewS = S#state{starting = keydelete(AppName, 1, Starting), + running = NRunning, + started = NStarted, + start_req = Start_reqN}, + + %% The permission may have been changed during start + Perm = application:get_env(kernel, permissions), + case {Perm, Id} of + {undefined, _} -> + {noreply, NewS}; + %% Check only if the application is started on the own node + {{ok, Perms}, {distributed, StartNode}} when StartNode =:= node() -> + case lists:member({AppName, false}, Perms) of + true -> + #state{running = StopRunning, started = StopStarted} = NewS, + case keysearch(AppName, 1, StopRunning) of + {value, {_AppName, Id}} -> + {value, {_AppName2, Type}} = + keysearch(AppName, 1, StopStarted), + stop_appl(AppName, Id, Type), + NStopRunning = keydelete(AppName, 1, StopRunning), + cntrl(AppName, NewS, {ac_application_stopped, AppName}), + {noreply, NewS#state{running = NStopRunning, + started = StopStarted}}; + false -> + {noreply, NewS} + end; + false -> + {noreply, NewS} + end; + _ -> + {noreply, NewS} + end; + + + + + {error, R} when RestartType =:= temporary -> + notify_cntrl_started(AppName, undefined, S, {error, R}), + info_exited(AppName, R, RestartType), + {noreply, S#state{starting = keydelete(AppName, 1, Starting), + start_req = Start_reqN}}; + {info, R} when RestartType =:= temporary -> + notify_cntrl_started(AppName, undefined, S, {error, R}), + {noreply, S#state{starting = keydelete(AppName, 1, Starting), + start_req = Start_reqN}}; + {ErrInf, R} when RestartType =:= transient, ErrInf =:= error; + RestartType =:= transient, ErrInf =:= info -> + notify_cntrl_started(AppName, undefined, S, {error, R}), + case ErrInf of + error -> + info_exited(AppName, R, RestartType); + info -> + ok + end, + case R of + {{'EXIT',normal},_Call} -> + {noreply, S#state{starting = keydelete(AppName, 1, Starting), + start_req = Start_reqN}}; + _ -> + Reason = {application_start_failure, AppName, R}, + {stop, to_string(Reason), S} + end; + {error, R} -> %% permanent + notify_cntrl_started(AppName, undefined, S, {error, R}), + info_exited(AppName, R, RestartType), + Reason = {application_start_failure, AppName, R}, + {stop, to_string(Reason), S}; + {info, R} -> %% permanent + notify_cntrl_started(AppName, undefined, S, {error, R}), + Reason = {application_start_failure, AppName, R}, + {stop, to_string(Reason), S} + end. + +handle_info({ac_load_application_reply, AppName, Res}, S) -> + case keysearchdelete(AppName, 1, S#state.loading) of + {value, {_AppName, From}, Loading} -> + gen_server:reply(From, Res), + case Res of + ok -> + {noreply, S#state{loading = Loading}}; + {error, _R} -> + NewS = unload(AppName, S), + {noreply, NewS#state{loading = Loading}} + end; + false -> + {noreply, S} + end; + +handle_info({ac_start_application_reply, AppName, Res}, S) -> + Start_req = S#state.start_req, + case keysearch(AppName, 1, Starting = S#state.starting) of + {value, {_AppName, RestartType, Type, From}} -> + case Res of + start_it -> + {true, Appl} = get_loaded(AppName), + spawn_starter(From, Appl, S, Type), + {noreply, S}; + {started, Node} -> + handle_application_started(AppName, + {ok, {distributed, Node}}, + S); + not_started -> + Started = S#state.started, + Start_reqN = + reply_to_requester(AppName, Start_req, ok), + {noreply, + S#state{starting = keydelete(AppName, 1, Starting), + started = [{AppName, RestartType} | Started], + start_req = Start_reqN}}; + {takeover, Node} -> + {true, Appl} = get_loaded(AppName), + spawn_starter(From, Appl, S, {takeover, Node}), + NewStarting1 = keydelete(AppName, 1, Starting), + NewStarting = [{AppName, RestartType, {takeover, Node}, From} | NewStarting1], + {noreply, S#state{starting = NewStarting}}; + {error, Reason} when RestartType =:= permanent -> + Start_reqN = + reply_to_requester(AppName, Start_req, + {error, Reason}), + {stop, to_string(Reason), S#state{start_req = Start_reqN}}; + {error, Reason} -> + Start_reqN = + reply_to_requester(AppName, Start_req, + {error, Reason}), + {noreply, S#state{starting = + keydelete(AppName, 1, Starting), + start_req = Start_reqN}} + end; + false -> + {noreply, S} % someone called stop before control got that + end; + +handle_info({ac_change_application_req, AppName, Msg}, S) -> + Running = S#state.running, + Started = S#state.started, + Starting = S#state.starting, + case {keysearch(AppName, 1, Running), keysearch(AppName, 1, Started)} of + {{value, {AppName, Id}}, {value, {_AppName2, Type}}} -> + case Msg of + {started, Node} -> + stop_appl(AppName, Id, Type), + NRunning = [{AppName, {distributed, Node}} | + keydelete(AppName, 1, Running)], + {noreply, S#state{running = NRunning}}; + {takeover, _Node, _RT} when is_pid(Id) -> % it is running already + notify_cntrl_started(AppName, Id, S, ok), + {noreply, S}; + {takeover, Node, RT} -> + NewS = do_start(AppName, RT, {takeover, Node}, undefined, S), + {noreply, NewS}; + {failover, _Node, _RT} when is_pid(Id) -> % it is running already + notify_cntrl_started(AppName, Id, S, ok), + {noreply, S}; + {failover, Node, RT} -> + case application:get_key(AppName, start_phases) of + {ok, undefined} -> + %% to be backwards compatible the application + %% is not started as failover if start_phases + %% is not defined in the .app file + NewS = do_start(AppName, RT, normal, undefined, S), + {noreply, NewS}; + {ok, _StartPhases} -> + NewS = do_start(AppName, RT, {failover, Node}, undefined, S), + {noreply, NewS} + end; + stop_it -> + stop_appl(AppName, Id, Type), + cntrl(AppName, S, {ac_application_not_run, AppName}), + NRunning = keyreplace(AppName, 1, Running, + {AppName, {distributed, []}}), + {noreply, S#state{running = NRunning}}; + %% We should not try to start a running application! + start_it when is_pid(Id) -> + notify_cntrl_started(AppName, Id, S, ok), + {noreply, S}; + start_it -> + NewS = do_start(AppName, undefined, normal, undefined, S), + {noreply, NewS}; + not_running -> + NRunning = keydelete(AppName, 1, Running), + {noreply, S#state{running = NRunning}}; + _ -> + {noreply, S} + end; + _ -> + IsLoaded = get_loaded(AppName), + IsStarting = lists:keysearch(AppName, 1, Starting), + IsStarted = lists:keysearch(AppName, 1, Started), + IsRunning = lists:keysearch(AppName, 1, Running), + + case Msg of + start_it -> + case {IsLoaded, IsStarting, IsStarted, IsRunning} of + %% already running + {_, _, _, {value, _Tuple}} -> + {noreply, S}; + %% not loaded + {false, _, _, _} -> + {noreply, S}; + %% only loaded + {{true, _Appl}, false, false, false} -> + {noreply, S}; + %% starting + {{true, _Appl}, {value, Tuple}, false, false} -> + {_AppName, _RStype, _Type, From} = Tuple, + NewS = do_start(AppName, undefined, normal, From, S), + {noreply, NewS}; + %% started but not running + {{true, _Appl}, _, {value, {AppName, _RestartType}}, false} -> + NewS = do_start(AppName, undefined, normal, undefined, S), + SS = NewS#state{started = keydelete(AppName, 1, Started)}, + {noreply, SS} + end; + {started, Node} -> + NRunning = [{AppName, {distributed, Node}} | + keydelete(AppName, 1, Running)], + {noreply, S#state{running = NRunning}}; + _ -> + {noreply, S} % someone called stop before control got that + end + end; + +%%----------------------------------------------------------------- +%% An application died. Check its restart_type. Maybe terminate +%% all other applications. +%%----------------------------------------------------------------- +handle_info({'EXIT', Pid, Reason}, S) -> + ets:match_delete(ac_tab, {{application_master, '_'}, Pid}), + NRunning = keydelete(Pid, 2, S#state.running), + NewS = S#state{running = NRunning}, + case keysearch(Pid, 2, S#state.running) of + {value, {AppName, _AmPid}} -> + cntrl(AppName, S, {ac_application_stopped, AppName}), + case keysearch(AppName, 1, S#state.started) of + {value, {_AppName, temporary}} -> + info_exited(AppName, Reason, temporary), + {noreply, NewS}; + {value, {_AppName, transient}} when Reason =:= normal -> + info_exited(AppName, Reason, transient), + {noreply, NewS}; + {value, {_AppName, Type}} -> + info_exited(AppName, Reason, Type), + {stop, to_string({application_terminated, AppName, Reason}), NewS} + end; + false -> + {noreply, S#state{control = del_cntrl(S#state.control, Pid)}} + end; + +handle_info(_, S) -> + {noreply, S}. + +terminate(Reason, S) -> + case application:get_env(kernel, shutdown_func) of + {ok, {M, F}} -> + catch M:F(Reason); + _ -> + ok + end, + foreach(fun({_AppName, Id}) when is_pid(Id) -> + exit(Id, shutdown), + receive + {'EXIT', Id, _} -> ok + end; + (_) -> ok + end, + S#state.running), + ets:delete(ac_tab). + + +code_change(_OldVsn, State, _Extra) -> + {ok, State}. + + +%%%----------------------------------------------------------------- +%%% Internal functions +%%%----------------------------------------------------------------- +cntrl(AppName, #state{control = Control}, Msg) -> + case keysearch(AppName, 1, Control) of + {value, {_AppName, Pid}} -> + Pid ! Msg, + true; + false -> + false + end. + +notify_cntrl_started(_AppName, {distributed, _Node}, _S, _Res) -> + ok; +notify_cntrl_started(AppName, _Id, S, Res) -> + cntrl(AppName, S, {ac_application_run, AppName, Res}). + +del_cntrl([{_, Pid}|T], Pid) -> + del_cntrl(T, Pid); +del_cntrl([H|T], Pid) -> + [H|del_cntrl(T, Pid)]; +del_cntrl([], _Pid) -> + []. + +get_loaded(App) -> + AppName = get_appl_name(App), + case ets:lookup(ac_tab, {loaded, AppName}) of + [{_Key, Appl}] -> {true, Appl}; + _ -> false + end. + +do_load_application(Application, S) -> + case get_loaded(Application) of + {true, _} -> + throw({error, {already_loaded, Application}}); + false -> + case make_appl(Application) of + {ok, Appl} -> load(S, Appl); + Error -> Error + end + end. + +%% Recursively load the application and its included apps. +%load(S, {ApplData, ApplEnv, IncApps, Descr, Vsn, Apps}) -> +load(S, {ApplData, ApplEnv, IncApps, Descr, Id, Vsn, Apps}) -> + Name = ApplData#appl_data.name, + ConfEnv = get_env_i(Name, S), + NewEnv = merge_app_env(ApplEnv, ConfEnv), + CmdLineEnv = get_cmd_env(Name), + NewEnv2 = merge_app_env(NewEnv, CmdLineEnv), + NewEnv3 = keyreplaceadd(included_applications, 1, NewEnv2, + {included_applications, IncApps}), + add_env(Name, NewEnv3), + Appl = #appl{name = Name, descr = Descr, id = Id, vsn = Vsn, + appl_data = ApplData, inc_apps = IncApps, apps = Apps}, + ets:insert(ac_tab, {{loaded, Name}, Appl}), + NewS = + foldl(fun(App, S1) -> + case get_loaded(App) of + {true, _} -> S1; + false -> + case do_load_application(App, S1) of + {ok, S2} -> S2; + Error -> throw(Error) + end + end + end, S, IncApps), + {ok, NewS}. + +unload(AppName, S) -> + {ok, IncApps} = get_env(AppName, included_applications), + del_env(AppName), + ets:delete(ac_tab, {loaded, AppName}), + foldl(fun(App, S1) -> + case get_loaded(App) of + false -> S1; + {true, _} -> unload(App, S1) + end + end, S, IncApps). + +check_start_cond(AppName, RestartType, Started, Running) -> + validRestartType(RestartType), + case get_loaded(AppName) of + {true, Appl} -> + %% Check Running; not Started. An exited app is not running, + %% but started. It must be possible to start an exited app! + case lists:keymember(AppName, 1, Running) of + true -> + {error, {already_started, AppName}}; + false -> + foreach( + fun(AppName2) -> + case lists:keymember(AppName2, 1, Started) of + true -> ok; + false -> + throw({error, {not_started, AppName2}}) + end + end, Appl#appl.apps), + {ok, Appl} + end; + false -> + {error, {not_loaded, AppName}} + end. + +do_start(AppName, RT, Type, From, S) -> + RestartType = case keysearch(AppName, 1, S#state.started) of + {value, {_AppName2, OldRT}} -> + get_restart_type(RT, OldRT); + false -> + RT + end, + %% UW 990913: We check start_req instead of starting, because starting + %% has already been checked. + case lists:keymember(AppName, 1, S#state.start_req) of + false -> + {true, Appl} = get_loaded(AppName), + Start_req = S#state.start_req, + spawn_starter(undefined, Appl, S, Type), + Starting = case keysearch(AppName, 1, S#state.starting) of + false -> + %% UW: don't know if this is necessary + [{AppName, RestartType, Type, From} | + S#state.starting]; + _ -> + S#state.starting + end, + S#state{starting = Starting, + start_req = [{AppName, From} | Start_req]}; + true -> % otherwise we're already starting the app... + S + end. + +spawn_starter(From, Appl, S, Type) -> + spawn_link(?MODULE, init_starter, [From, Appl, S, Type]). + +init_starter(_From, Appl, S, Type) -> + process_flag(trap_exit, true), + AppName = Appl#appl.name, + gen_server:cast(?AC, {application_started, AppName, + catch start_appl(Appl, S, Type)}). + +reply(undefined, _Reply) -> + ok; +reply(From, Reply) -> gen_server:reply(From, Reply). + +start_appl(Appl, S, Type) -> + ApplData = Appl#appl.appl_data, + case ApplData#appl_data.mod of + [] -> + {ok, undefined}; + _ -> + %% Name = ApplData#appl_data.name, + Running = S#state.running, + foreach( + fun(AppName) -> + case lists:keymember(AppName, 1, Running) of + true -> + ok; + false -> + throw({info, {not_running, AppName}}) + end + end, Appl#appl.apps), + case application_master:start_link(ApplData, Type) of + {ok, Pid} -> + {ok, Pid}; + {error, Reason} -> + throw({error, Reason}) + end + end. + + +%%----------------------------------------------------------------- +%% Stop application locally. +%%----------------------------------------------------------------- +stop_appl(AppName, Id, Type) when is_pid(Id) -> + unlink(Id), + application_master:stop(Id), + info_exited(AppName, stopped, Type), + ets:delete(ac_tab, {application_master, AppName}); +stop_appl(AppName, undefined, Type) -> + %% Code-only application stopped + info_exited(AppName, stopped, Type); +stop_appl(_AppName, _Id, _Type) -> + %% Distributed application stopped + ok. + +keysearchdelete(Key, Pos, List) -> + ksd(Key, Pos, List, []). + +ksd(Key, Pos, [H | T], Rest) when element(Pos, H) =:= Key -> + {value, H, Rest ++ T}; +ksd(Key, Pos, [H | T], Rest) -> + ksd(Key, Pos, T, [H | Rest]); +ksd(_Key, _Pos, [], _Rest) -> + false. + +keyreplaceadd(Key, Pos, List, New) -> + %% Maintains the order! + case lists:keymember(Key, Pos, List) of + true -> keyreplace(Key, Pos, List, New); + false -> [New | List] + end. + +validRestartType(permanent) -> true; +validRestartType(temporary) -> true; +validRestartType(transient) -> true; +validRestartType(RestartType) -> + throw({error, {invalid_restart_type, RestartType}}). + +nd({distributed, Node}) -> Node; +nd(_) -> node(). + +get_restart_type(undefined, OldRT) -> + OldRT; +get_restart_type(RT, _OldRT) -> + RT. + +get_appl_name(Name) when is_atom(Name) -> Name; +get_appl_name({application, Name, _}) when is_atom(Name) -> Name; +get_appl_name(Appl) -> throw({error, {bad_application, Appl}}). + +make_appl(Name) when is_atom(Name) -> + FName = atom_to_list(Name) ++ ".app", + case code:where_is_file(FName) of + non_existing -> + {error, {file:format_error(enoent), FName}}; + FullName -> + case prim_consult(FullName) of + {ok, [Application]} -> + {ok, make_appl_i(Application)}; + {error, Reason} -> + {error, {file:format_error(Reason), FName}} + end + end; +make_appl(Application) -> + {ok, make_appl_i(Application)}. + +prim_consult(FullName) -> + case erl_prim_loader:get_file(FullName) of + {ok, Bin, _} -> + case erl_scan:string(binary_to_list(Bin)) of + {ok, Tokens, _EndLine} -> + prim_parse(Tokens, []); + {error, Reason, _EndLine} -> + {error, Reason} + end; + error -> + {error, enoent} + end. + +prim_parse(Tokens, Acc) -> + case lists:splitwith(fun(T) -> element(1,T) =/= dot end, Tokens) of + {[], []} -> + {ok, lists:reverse(Acc)}; + {Tokens2, [{dot,_} = Dot | Rest]} -> + case erl_parse:parse_term(Tokens2 ++ [Dot]) of + {ok, Term} -> + prim_parse(Rest, [Term | Acc]); + {error, Reason} -> + {error, Reason} + end; + {Tokens2, []} -> + case erl_parse:parse_term(Tokens2) of + {ok, Term} -> + {ok, lists:reverse([Term | Acc])}; + {error, Reason} -> + {error, Reason} + end + end. + +make_appl_i({application, Name, Opts}) when is_atom(Name), is_list(Opts) -> + Descr = get_opt(description, Opts, ""), + Id = get_opt(id, Opts, ""), + Vsn = get_opt(vsn, Opts, ""), + Mods = get_opt(modules, Opts, []), + Regs = get_opt(registered, Opts, []), + Apps = get_opt(applications, Opts, []), + Mod = + case get_opt(mod, Opts, []) of + {M,A} when is_atom(M) -> {M,A}; + [] -> []; + Other -> throw({error, {badstartspec, Other}}) + end, + Phases = get_opt(start_phases, Opts, undefined), + Env = get_opt(env, Opts, []), + MaxP = get_opt(maxP, Opts, infinity), + MaxT = get_opt(maxT, Opts, infinity), + IncApps = get_opt(included_applications, Opts, []), + {#appl_data{name = Name, regs = Regs, mod = Mod, phases = Phases, mods = Mods, + inc_apps = IncApps, maxP = MaxP, maxT = MaxT}, + Env, IncApps, Descr, Id, Vsn, Apps}; +make_appl_i({application, Name, Opts}) when is_list(Opts) -> + throw({error,{invalid_name,Name}}); +make_appl_i({application, _Name, Opts}) -> + throw({error,{invalid_options, Opts}}); +make_appl_i(Appl) -> throw({error, {bad_application, Appl}}). + + +%%----------------------------------------------------------------- +%% Merge current applications with changes. +%%----------------------------------------------------------------- + +%% do_change_apps(Applications, Config, OldAppls) -> NewAppls +%% Applications = [{application, AppName, [{Key,Value}]}] +%% Config = [{AppName,[{Par,Value}]} | File] +%% OldAppls = NewAppls = [#appl{}] +do_change_apps(Applications, Config, OldAppls) -> + + %% OTP-4867 + %% Config = contents of sys.config file + %% May now contain names of other .config files as well as + %% configuration parameters. + %% Therefore read and merge contents. + {ok, SysConfig, Errors} = check_conf_sys(Config), + + %% Report errors, but do not terminate + %% (backwards compatible behaviour) + lists:foreach(fun({error, {SysFName, Line, Str}}) -> + Str2 = lists:flatten(io_lib:format("~p: ~w: ~s~n", + [SysFName, Line, Str])), + error_logger:format(Str2, []) + end, + Errors), + + map(fun(Appl) -> + AppName = Appl#appl.name, + case is_loaded_app(AppName, Applications) of + {true, Application} -> + do_change_appl(make_appl(Application), + Appl, SysConfig); + + %% ignored removed apps - handled elsewhere + false -> + Appl + end + end, OldAppls). + +is_loaded_app(AppName, [{application, AppName, App} | _]) -> + {true, {application, AppName, App}}; +is_loaded_app(AppName, [_ | T]) -> is_loaded_app(AppName, T); +is_loaded_app(_AppName, []) -> false. + +do_change_appl({ok, {ApplData, Env, IncApps, Descr, Id, Vsn, Apps}}, + OldAppl, Config) -> + AppName = OldAppl#appl.name, + + %% Merge application env with env from sys.config, if any + ConfEnv = get_opt(AppName, Config, []), + NewEnv1 = merge_app_env(Env, ConfEnv), + + %% Merge application env with command line arguments, if any + CmdLineEnv = get_cmd_env(AppName), + NewEnv2 = merge_app_env(NewEnv1, CmdLineEnv), + + %% included_apps is made into an env parameter as well + NewEnv3 = keyreplaceadd(included_applications, 1, NewEnv2, + {included_applications, IncApps}), + + %% Update ets table with new application env + del_env(AppName), + add_env(AppName, NewEnv3), + + OldAppl#appl{appl_data=ApplData, + descr=Descr, + id=Id, + vsn=Vsn, + inc_apps=IncApps, + apps=Apps}; +do_change_appl({error, R}, _Appl, _ConfData) -> + throw({error, R}). + +get_opt(Key, List, Default) -> + case keysearch(Key, 1, List) of + {value, {_Key, Val}} -> Val; + _ -> Default + end. + +get_cmd_env(Name) -> + case init:get_argument(Name) of + {ok, Args} -> + foldl(fun(List, Res) -> conv(List) ++ Res end, [], Args); + _ -> [] + end. + +conv([Key, Val | T]) -> + [{make_term(Key), make_term(Val)} | conv(T)]; +conv(_) -> []. + +%%% Fix some day: eliminate the duplicated code here +make_term(Str) -> + case erl_scan:string(Str) of + {ok, Tokens, _} -> + case erl_parse:parse_term(Tokens ++ [{dot, 1}]) of + {ok, Term} -> + Term; + {error, {_,M,Reason}} -> + error_logger:format("application_controller: ~s: ~s~n", + [M:format_error(Reason), Str]), + throw({error, {bad_environment_value, Str}}) + end; + {error, {_,M,Reason}, _} -> + error_logger:format("application_controller: ~s: ~s~n", + [M:format_error(Reason), Str]), + throw({error, {bad_environment_value, Str}}) + end. + +get_env_i(Name, #state{conf_data = ConfData}) when is_list(ConfData) -> + case keysearch(Name, 1, ConfData) of + {value, {_Name, Env}} -> Env; + _ -> [] + end; +get_env_i(_Name, _) -> []. + +%% Merges envs for all apps. Env2 overrides Env1 +merge_env(Env1, Env2) -> + merge_env(Env1, Env2, []). + +merge_env([{App, AppEnv1} | T], Env2, Res) -> + case get_env_key(App, Env2) of + {value, AppEnv2, RestEnv2} -> + NewAppEnv = merge_app_env(AppEnv1, AppEnv2), + merge_env(T, RestEnv2, [{App, NewAppEnv} | Res]); + _ -> + merge_env(T, Env2, [{App, AppEnv1} | Res]) + end; +merge_env([], Env2, Res) -> + Env2 ++ Res. + + + + +%% Merges envs for an application. Env2 overrides Env1 +merge_app_env(Env1, Env2) -> + merge_app_env(Env1, Env2, []). + +merge_app_env([{Key, Val} | T], Env2, Res) -> + case get_env_key(Key, Env2) of + {value, NewVal, RestEnv} -> + merge_app_env(T, RestEnv, [{Key, NewVal}|Res]); + _ -> + merge_app_env(T, Env2, [{Key, Val} | Res]) + end; +merge_app_env([], Env2, Res) -> + Env2 ++ Res. + +get_env_key(Key, Env) -> get_env_key(Env, Key, []). +get_env_key([{Key, Val} | T], Key, Res) -> + {value, Val, T ++ Res}; +get_env_key([H | T], Key, Res) -> + get_env_key(T, Key, [H | Res]); +get_env_key([], _Key, Res) -> Res. + +add_env(Name, Env) -> + foreach(fun({Key, Value}) -> + ets:insert(ac_tab, {{env, Name, Key}, Value}) + end, + Env). + +del_env(Name) -> + ets:match_delete(ac_tab, {{env, Name, '_'}, '_'}). + +check_user() -> + case whereis(user) of + User when is_pid(User) -> group_leader(User, self()); + _ -> ok + end. + + +%%----------------------------------------------------------------- +%% Prepare for a release upgrade by reading all the evironment variables. +%%----------------------------------------------------------------- +do_prep_config_change(Apps) -> + do_prep_config_change(Apps, []). + +do_prep_config_change([], EnvBefore) -> + EnvBefore; +do_prep_config_change([{App, _Id} | Apps], EnvBefore) -> + Env = application:get_all_env(App), + do_prep_config_change(Apps, [{App, Env} | EnvBefore]). + + + +%%----------------------------------------------------------------- +%% Inform all running applications about the changed configuration. +%%----------------------------------------------------------------- +do_config_change(Apps, EnvBefore) -> + do_config_change(Apps, EnvBefore, []). + +do_config_change([], _EnvBefore, []) -> + ok; +do_config_change([], _EnvBefore, Errors) -> + {error, Errors}; +do_config_change([{App, _Id} | Apps], EnvBefore, Errors) -> + AppEnvNow = lists:sort(application:get_all_env(App)), + AppEnvBefore = case lists:keysearch(App, 1, EnvBefore) of + false -> + []; + {value, {App, AppEnvBeforeT}} -> + lists:sort(AppEnvBeforeT) + end, + + Res = + case AppEnvNow of + AppEnvBefore -> + ok; + _ -> + case do_config_diff(AppEnvNow, AppEnvBefore) of + {[], [], []} -> + ok; + {Changed, New, Removed} -> + case application:get_key(App, mod) of + {ok, {Mod, _Para}} -> + case catch Mod:config_change(Changed, New, + Removed) of + ok -> + ok; + %% It is not considered as an error + %% if the cb-function is not defined + {'EXIT', {undef, _}} -> + ok; + {error, Error} -> + {error, Error}; + Else -> + {error, Else} + end; + {ok,[]} -> + {error, {module_not_defined, App}}; + undefined -> + {error, {application_not_found, App}} + end + end + end, + + case Res of + ok -> + do_config_change(Apps, EnvBefore, Errors); + {error, NewError} -> + do_config_change(Apps, EnvBefore,[NewError | Errors]) + end. + + + + +%%----------------------------------------------------------------- +%% Check if the configuration is changed in anyway. +%%----------------------------------------------------------------- +do_config_diff(AppEnvNow, AppEnvBefore) -> + do_config_diff(AppEnvNow, AppEnvBefore, {[], []}). + +do_config_diff([], AppEnvBefore, {Changed, New}) -> + Removed = lists:foldl(fun({Env, _Value}, Acc) -> [Env | Acc] end, [], AppEnvBefore), + {Changed, New, Removed}; +do_config_diff(AppEnvNow, [], {Changed, New}) -> + {Changed, AppEnvNow++New, []}; +do_config_diff([{Env, Value} | AppEnvNow], AppEnvBefore, {Changed, New}) -> + case lists:keysearch(Env, 1, AppEnvBefore) of + {value, {Env, Value}} -> + do_config_diff(AppEnvNow, lists:keydelete(Env,1,AppEnvBefore), {Changed, New}); + {value, {Env, _OtherValue}} -> + do_config_diff(AppEnvNow, lists:keydelete(Env,1,AppEnvBefore), + {[{Env, Value} | Changed], New}); + false -> + do_config_diff(AppEnvNow, AppEnvBefore, {Changed, [{Env, Value}|New]}) + end. + + + + + + +%%----------------------------------------------------------------- +%% Read the .config files. +%%----------------------------------------------------------------- +check_conf() -> + case init:get_argument(config) of + {ok, Files} -> + {ok, lists:foldl( + fun([File], Env) -> + BFName = filename:basename(File,".config"), + FName = filename:join(filename:dirname(File), + BFName ++ ".config"), + case load_file(FName) of + {ok, NewEnv} -> + %% OTP-4867 + %% sys.config may now contain names of + %% other .config files as well as + %% configuration parameters. + %% Therefore read and merge contents. + if + BFName =:= "sys" -> + {ok, SysEnv, Errors} = + check_conf_sys(NewEnv), + + %% Report first error, if any, and + %% terminate + %% (backwards compatible behaviour) + case Errors of + [] -> + merge_env(Env, SysEnv); + [{error, {SysFName, Line, Str}}|_] -> + throw({error, {SysFName, Line, Str}}) + end; + true -> + merge_env(Env, NewEnv) + end; + {error, {Line, _Mod, Str}} -> + throw({error, {FName, Line, Str}}) + end + end, [], Files)}; + _ -> {ok, []} + end. + +check_conf_sys(Env) -> + check_conf_sys(Env, [], []). + +check_conf_sys([File|T], SysEnv, Errors) when is_list(File) -> + BFName = filename:basename(File, ".config"), + FName = filename:join(filename:dirname(File), BFName ++ ".config"), + case load_file(FName) of + {ok, NewEnv} -> + check_conf_sys(T, merge_env(SysEnv, NewEnv), Errors); + {error, {Line, _Mod, Str}} -> + check_conf_sys(T, SysEnv, [{error, {FName, Line, Str}}|Errors]) + end; +check_conf_sys([Tuple|T], SysEnv, Errors) -> + check_conf_sys(T, merge_env(SysEnv, [Tuple]), Errors); +check_conf_sys([], SysEnv, Errors) -> + {ok, SysEnv, lists:reverse(Errors)}. + +load_file(File) -> + %% We can't use file:consult/1 here. Too bad. + case erl_prim_loader:get_file(File) of + {ok, Bin, _FileName} -> + %% Make sure that there is some whitespace at the end of the string + %% (so that reading a file with no NL following the "." will work). + Str = binary_to_list(Bin) ++ " ", + scan_file(Str); + error -> + {error, {none, open_file, "configuration file not found"}} + end. + +scan_file(Str) -> + case erl_scan:tokens([], Str, 1) of + {done, {ok, Tokens, _}, Left} -> + case erl_parse:parse_term(Tokens) of + {ok,L}=Res when is_list(L) -> + case only_ws(Left) of + true -> + Res; + false -> + %% There was trailing garbage found after the list. + config_error() + end; + {ok,_} -> + %% Parsing succeeded but the result is not a list. + config_error(); + Error -> + Error + end; + {done, Result, _} -> + {error, {none, parse_file, tuple_to_list(Result)}}; + {more, _} -> + {error, {none, load_file, "no ending <dot> found"}} + end. + +only_ws([C|Cs]) when C =< $\s -> only_ws(Cs); +only_ws([$%|Cs]) -> only_ws(strip_comment(Cs)); % handle comment +only_ws([_|_]) -> false; +only_ws([]) -> true. + +strip_comment([$\n|Cs]) -> Cs; +strip_comment([_|Cs]) -> strip_comment(Cs); +strip_comment([]) -> []. + +config_error() -> + {error, + {none, load_file, + "configuration file must contain ONE list ended by <dot>"}}. + +%%----------------------------------------------------------------- +%% Info messages sent to error_logger +%%----------------------------------------------------------------- +info_started(Name, Node) -> + Rep = [{application, Name}, + {started_at, Node}], + error_logger:info_report(progress, Rep). + +info_exited(Name, Reason, Type) -> + Rep = [{application, Name}, + {exited, Reason}, + {type, Type}], + error_logger:info_report(Rep). + + +%%----------------------------------------------------------------- +%% Reply to all processes waiting this application to be started. +%%----------------------------------------------------------------- +reply_to_requester(AppName, Start_req, Res) -> + R = case Res of + {ok, _Id} -> + ok; + {info, Reason} -> + {error, Reason}; + Error -> + Error + end, + + lists:foldl(fun(Sp, AccIn) -> + case Sp of + {AppName, From} -> + reply(From, R), + AccIn; + _ -> + [Sp | AccIn] + end + end, + [], + Start_req). + + +%%----------------------------------------------------------------- +%% Update the environment variable permission for an application. +%%----------------------------------------------------------------- +update_permissions(AppName, Bool) -> + case ets:lookup(ac_tab, {env, kernel, permissions}) of + [] -> + ets:insert(ac_tab, {{env, kernel, permissions}, + [{AppName, Bool}]}); + [{_, Perm}] -> + Perm2 = lists:keydelete(AppName, 1, Perm), + ets:insert(ac_tab, {{env, kernel, permissions}, + [{AppName, Bool}| Perm2]}) + end. + +%%----------------------------------------------------------------- +%% These functions are only to be used from testsuites. +%%----------------------------------------------------------------- +test_change_apps(Apps, Conf) -> + Res = test_make_apps(Apps, []), + test_do_change_appl(Apps, Conf, Res). + +test_do_change_appl([], _, _) -> + ok; +test_do_change_appl([A|Apps], [], [R|Res]) -> + do_change_appl(R, #appl{name = A}, []), + test_do_change_appl(Apps, [], Res); +test_do_change_appl([A|Apps], [C|Conf], [R|Res]) -> + do_change_appl(R, #appl{name = A}, C), + test_do_change_appl(Apps, Conf, Res). + +test_make_apps([], Res) -> + lists:reverse(Res); +test_make_apps([A|Apps], Res) -> + test_make_apps(Apps, [make_appl(A) | Res]). + +%%----------------------------------------------------------------- +%% String conversion +%% Exit reason needs to be a printable string +%% (and of length <200, but init now does the chopping). +%%----------------------------------------------------------------- +to_string(Term) -> + case io_lib:printable_list(Term) of + true -> + Term; + false -> + lists:flatten(io_lib:write(Term)) + end. diff --git a/lib/kernel/src/application_master.erl b/lib/kernel/src/application_master.erl new file mode 100644 index 0000000000..679fefaed9 --- /dev/null +++ b/lib/kernel/src/application_master.erl @@ -0,0 +1,426 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1996-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(application_master). + +%% External exports +-export([start_link/2, start_type/0, stop/1]). +-export([get_child/1]). + +%% Internal exports +-export([init/4, start_it/4]). + +-include("application_master.hrl"). + +-record(state, {child, appl_data, children = [], procs = 0, gleader}). + +%%----------------------------------------------------------------- +%% Func: start_link/1 +%% Args: ApplData = record(appl_data) +%% Purpose: Starts an application master for the application. +%% Called from application_controller. (The application is +%% also started). +%% Returns: {ok, Pid} | {error, Reason} (Pid is unregistered) +%%----------------------------------------------------------------- +start_link(ApplData, Type) -> + Parent = whereis(application_controller), + proc_lib:start_link(application_master, init, + [Parent, self(), ApplData, Type]). + +start_type() -> + group_leader() ! {start_type, self()}, + receive + {start_type, Type} -> + Type + after 5000 -> + {error, timeout} + end. + +%%----------------------------------------------------------------- +%% Func: stop/1 +%% Purpose: Stops the application. This function makes sure +%% that all processes belonging to the applicication is +%% stopped (shutdown or killed). The application master +%% is also stopped. +%% Returns: ok +%%----------------------------------------------------------------- +stop(AppMaster) -> call(AppMaster, stop). + +%%----------------------------------------------------------------- +%% Func: get_child/1 +%% Purpose: Get the topmost supervisor of an application. +%% Returns: {pid(), App} +%%----------------------------------------------------------------- +get_child(AppMaster) -> call(AppMaster, get_child). + +call(AppMaster, Req) -> + Tag = make_ref(), + Ref = erlang:monitor(process, AppMaster), + AppMaster ! {Req, Tag, self()}, + receive + {'DOWN', Ref, process, _, _Info} -> + ok; + {Tag, Res} -> + erlang:demonitor(Ref), + receive + {'DOWN', Ref, process, _, _Info} -> + Res + after 0 -> + Res + end + end. + +%%%----------------------------------------------------------------- +%%% The logical and physical process structrure is as follows: +%%% +%%% logical physical +%%% +%%% -------- -------- +%%% |AM(GL)| |AM(GL)| +%%% -------- -------- +%%% | | +%%% -------- -------- +%%% |Appl P| | X | +%%% -------- -------- +%%% | +%%% -------- +%%% |Appl P| +%%% -------- +%%% +%%% Where AM(GL) == Application Master (Group Leader) +%%% Appl P == The application specific root process (child to AM) +%%% X == A special 'invisible' process +%%% The reason for not using the logical structrure is that +%%% the application start function is synchronous, and +%%% that the AM is GL. This means that if AM executed the start +%%% function, and this function uses spawn_request/1 +%%% or io, deadlock would occur. Therefore, this function is +%%% executed by the process X. Also, AM needs three loops; +%%% init_loop (waiting for the start function to return) +%%% main_loop +%%% terminate_loop (waiting for the process to die) +%%% In each of these loops, io and other requests are handled. +%%%----------------------------------------------------------------- +%%% Internal functions +%%%----------------------------------------------------------------- +init(Parent, Starter, ApplData, Type) -> + link(Parent), + process_flag(trap_exit, true), + OldGleader = group_leader(), + group_leader(self(), self()), + %% Insert ourselves as master for the process. This ensures that + %% the processes in the application can use get_env/1 at startup. + Name = ApplData#appl_data.name, + ets:insert(ac_tab, {{application_master, Name}, self()}), + State = #state{appl_data = ApplData, gleader = OldGleader}, + case start_it(State, Type) of + {ok, Pid} -> % apply(M,F,A) returned ok + set_timer(ApplData#appl_data.maxT), + unlink(Starter), + proc_lib:init_ack(Starter, {ok,self()}), + main_loop(Parent, State#state{child = Pid}); + {error, Reason} -> % apply(M,F,A) returned error + exit(Reason); + Else -> % apply(M,F,A) returned erroneous + exit(Else) + end. + +%%----------------------------------------------------------------- +%% We want to start the new application synchronously, but we still +%% want to handle io requests. So we spawn off a new process that +%% performs the apply, and we wait for a start ack. +%%----------------------------------------------------------------- +start_it(State, Type) -> + Tag = make_ref(), + Pid = spawn_link(application_master, start_it, [Tag, State, self(), Type]), + init_loop(Pid, Tag, State, Type). + + +%%----------------------------------------------------------------- +%% These are the three different loops executed by the application_ +%% master +%%----------------------------------------------------------------- +init_loop(Pid, Tag, State, Type) -> + receive + IoReq when element(1, IoReq) =:= io_request -> + State#state.gleader ! IoReq, + init_loop(Pid, Tag, State, Type); + {Tag, Res} -> + Res; + {'EXIT', Pid, Reason} -> + {error, Reason}; + {start_type, From} -> + From ! {start_type, Type}, + init_loop(Pid, Tag, State, Type); + Other -> + NewState = handle_msg(Other, State), + init_loop(Pid, Tag, NewState, Type) + end. + +main_loop(Parent, State) -> + receive + IoReq when element(1, IoReq) =:= io_request -> + State#state.gleader ! IoReq, + main_loop(Parent, State); + {'EXIT', Parent, Reason} -> + terminate(Reason, State); + {'EXIT', Child, Reason} when State#state.child =:= Child -> + terminate(Reason, State#state{child=undefined}); + {'EXIT', _, timeout} -> + terminate(normal, State); + {'EXIT', Pid, _Reason} -> + Children = lists:delete(Pid, State#state.children), + Procs = State#state.procs - 1, + main_loop(Parent, State#state{children=Children, procs=Procs}); + {start_type, From} -> + From ! {start_type, local}, + main_loop(Parent, State); + Other -> + NewState = handle_msg(Other, State), + main_loop(Parent, NewState) + end. + +terminate_loop(Child, State) -> + receive + IoReq when element(1, IoReq) =:= io_request -> + State#state.gleader ! IoReq, + terminate_loop(Child, State); + {'EXIT', Child, _} -> + ok; + Other -> + NewState = handle_msg(Other, State), + terminate_loop(Child, NewState) + end. + + +%%----------------------------------------------------------------- +%% The Application Master is linked to *all* processes in the group +%% (application). +%%----------------------------------------------------------------- +handle_msg({get_child, Tag, From}, State) -> + From ! {Tag, get_child_i(State#state.child)}, + State; +handle_msg({stop, Tag, From}, State) -> + catch terminate(normal, State), + From ! {Tag, ok}, + exit(normal); +handle_msg(_, State) -> + State. + + +terminate(Reason, State) -> + terminate_child(State#state.child, State), + kill_children(State#state.children), + exit(Reason). + + + + +%%====================================================================== +%%====================================================================== +%%====================================================================== +%% This is the process X above... +%%====================================================================== +%%====================================================================== +%%====================================================================== + +%%====================================================================== +%% Start an application. +%% If the start_phases is defined in the .app file, the application is +%% to be started in one or several start phases. +%% If the Module in the mod-key is set to application_starter then +%% the generic help module application_starter is used to control +%% the start. +%%====================================================================== + +start_it(Tag, State, From, Type) -> + process_flag(trap_exit, true), + ApplData = State#state.appl_data, + case {ApplData#appl_data.phases, ApplData#appl_data.mod} of + {undefined, _} -> + start_it_old(Tag, From, Type, ApplData); + {Phases, {application_starter, [M, A]}} -> + start_it_new(Tag, From, Type, M, A, Phases, + [ApplData#appl_data.name]); + {Phases, {M, A}} -> + start_it_new(Tag, From, Type, M, A, Phases, + [ApplData#appl_data.name]); + {OtherP, OtherM} -> + From ! {Tag, {error, {bad_keys, {{mod, OtherM}, + {start_phases, OtherP}}}}} + end. + + +%%%----------------------------------------------------- +%%% No start phases are defined +%%%----------------------------------------------------- +start_it_old(Tag, From, Type, ApplData) -> + {M,A} = ApplData#appl_data.mod, + case catch M:start(Type, A) of + {ok, Pid} -> + link(Pid), + From ! {Tag, {ok, self()}}, + loop_it(From, Pid, M, []); + {ok, Pid, AppState} -> + link(Pid), + From ! {Tag, {ok, self()}}, + loop_it(From, Pid, M, AppState); + {'EXIT', normal} -> + From ! {Tag, {error, {{'EXIT',normal},{M,start,[Type,A]}}}}; + {error, Reason} -> + From ! {Tag, {error, {Reason, {M,start,[Type,A]}}}}; + Other -> + From ! {Tag, {error, {bad_return,{{M,start,[Type,A]},Other}}}} + end. + + +%%%----------------------------------------------------- +%%% Start phases are defined +%%%----------------------------------------------------- +start_it_new(Tag, From, Type, M, A, Phases, Apps) -> + case catch start_the_app(Type, M, A, Phases, Apps) of + {ok, Pid, AppState} -> + From ! {Tag, {ok, self()}}, + loop_it(From, Pid, M, AppState); + Error -> + From ! {Tag, Error} + end. + + +%%%===================================================== +%%% Start the application in the defined phases, +%%% but first the supervisors are starter. +%%%===================================================== +start_the_app(Type, M, A, Phases, Apps) -> + case start_supervisor(Type, M, A) of + {ok, Pid, AppState} -> + link(Pid), + case application_starter:start(Phases, Type, Apps) of + ok -> + {ok, Pid, AppState}; + Error2 -> + unlink(Pid), + Error2 + end; + Error -> + Error + end. + +%%%------------------------------------------------------------- +%%% Start the supervisors +%%%------------------------------------------------------------- +start_supervisor(Type, M, A) -> + case catch M:start(Type, A) of + {ok, Pid} -> + {ok, Pid, []}; + {ok, Pid, AppState} -> + {ok, Pid, AppState}; + {error, Reason} -> + {error, {Reason, {M, start, [Type, A]}}}; + {'EXIT', normal} -> + {error, {{'EXIT', normal}, {M, start, [Type, A]}}}; + Other -> + {error, {bad_return, {{M, start, [Type, A]}, Other}}} + end. + + + + +%%====================================================================== +%% +%%====================================================================== + +loop_it(Parent, Child, Mod, AppState) -> + receive + {Parent, get_child} -> + Parent ! {self(), Child, Mod}, + loop_it(Parent, Child, Mod, AppState); + {Parent, terminate} -> + NewAppState = prep_stop(Mod, AppState), + exit(Child, shutdown), + receive + {'EXIT', Child, _} -> ok + end, + catch Mod:stop(NewAppState), + exit(normal); + {'EXIT', Parent, Reason} -> + NewAppState = prep_stop(Mod, AppState), + exit(Child, Reason), + receive + {'EXIT', Child, Reason2} -> + exit(Reason2) + end, + catch Mod:stop(NewAppState); + {'EXIT', Child, Reason} -> % forward *all* exit reasons (inc. normal) + NewAppState = prep_stop(Mod, AppState), + catch Mod:stop(NewAppState), + exit(Reason); + _ -> + loop_it(Parent, Child, Mod, AppState) + end. + +prep_stop(Mod, AppState) -> + case catch Mod:prep_stop(AppState) of + {'EXIT', {undef, _}} -> + AppState; + {'EXIT', Reason} -> + error_logger:error_report([{?MODULE, shutdown_error}, + {Mod, {prep_stop, [AppState]}}, + {error_info, Reason}]), + AppState; + NewAppState -> + NewAppState + end. + +get_child_i(Child) -> + Child ! {self(), get_child}, + receive + {Child, GrandChild, Mod} -> {GrandChild, Mod} + end. + +terminate_child_i(Child, State) -> + Child ! {self(), terminate}, + terminate_loop(Child, State). + +%% Try to shutdown the child gently +terminate_child(undefined, _) -> ok; +terminate_child(Child, State) -> + terminate_child_i(Child, State). + +kill_children(Children) -> + lists:foreach(fun(Pid) -> exit(Pid, kill) end, Children), + kill_all_procs(). + +kill_all_procs() -> + kill_all_procs_1(processes(), self(), 0). + +kill_all_procs_1([Self|Ps], Self, N) -> + kill_all_procs_1(Ps, Self, N); +kill_all_procs_1([P|Ps], Self, N) -> + case process_info(P, group_leader) of + {group_leader,Self} -> + exit(P, kill), + kill_all_procs_1(Ps, Self, N+1); + _ -> + kill_all_procs_1(Ps, Self, N) + end; +kill_all_procs_1([], _, 0) -> ok; +kill_all_procs_1([], _, _) -> kill_all_procs(). + +set_timer(infinity) -> ok; +set_timer(Time) -> timer:exit_after(Time, timeout). diff --git a/lib/kernel/src/application_master.hrl b/lib/kernel/src/application_master.hrl new file mode 100644 index 0000000000..cd6d12c33c --- /dev/null +++ b/lib/kernel/src/application_master.hrl @@ -0,0 +1,20 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1996-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% +%% +-record(appl_data, {name, regs = [], phases, mod, mods = [], + inc_apps, maxP = infinity, maxT = infinity}). diff --git a/lib/kernel/src/application_starter.erl b/lib/kernel/src/application_starter.erl new file mode 100644 index 0000000000..8d839e4662 --- /dev/null +++ b/lib/kernel/src/application_starter.erl @@ -0,0 +1,111 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1998-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% +%% +%% ---------------------------------------------------------------------- +%% Purpose : Starts applications in the phases defined in the .app file's +%% start_phases key. If the application includes other applications +%% these are also started according to their mod and +%% start_phases-keys in their .app file. +%% ---------------------------------------------------------------------- + +-module(application_starter). + +-export([start/3]). + +%%%============================================================================= +%%%============================================================================= +%%%============================================================================= +%%% start(Phases, Type, Applications) -> ok | {error, ErrorMessage} +%%% +%%% The applications are started by calling Module:start_phase(Phase, Type, Args) +%%% where Module and is defined in the mod-key, Phase and Args are defined in +%%% the start_phases-key. +%%%============================================================================= +%%%============================================================================= +%%%============================================================================= +start([], _Type, _Apps) -> + ok; +start([{Phase,_PhaseArgs}|Phases], Type, Apps) -> + case start_apps(Phase, Type, Apps) of + {error, Error} -> + {error, Error}; + _ -> + start(Phases, Type, Apps) + end. + + +%%%============================================================================= +%%% Start each application in the phase Phase. +%%%============================================================================= +start_apps(_Phase, _Type, []) -> + ok; +start_apps(Phase, Type, [App | Apps]) -> + case catch run_start_phase(Phase, Type, App) of + {error, Error} -> + {error, Error}; + _ -> + start_apps(Phase, Type, Apps) + end. + + +%%%============================================================================= +%%% If application_starter is used recursively, start also all the included +%%% applications in the phase Phase. +%%%============================================================================= +run_start_phase(Phase, Type, App) -> + {ok,{Mod,Arg}} = application:get_key(App, mod), + case Mod of + application_starter -> + [StartMod, _StartArgs] = Arg, + run_the_phase(Phase, Type, App, StartMod), + {ok, IncApps} = application:get_key(App, included_applications), + start_apps(Phase, Type, IncApps); + _ -> + run_the_phase(Phase, Type, App, Mod) + end. + + +%%%============================================================================= +%%% Start the application only if the start phase is defined in the +%%% start_phases-key. +%%%============================================================================= +run_the_phase(Phase, Type, App, Mod) -> + Start_phases = case application_controller:get_key(App, start_phases) of + {ok, undefined} -> + throw({error, {start_phases_undefined, App}}); + {ok, Sp} -> + Sp + end, + case lists:keysearch(Phase, 1, Start_phases) of + false -> + ok; + {value, {Phase, PhaseArgs}} -> + case catch Mod:start_phase(Phase, Type, PhaseArgs) of + ok -> + ok; + {error, Reason} -> + throw({error, {Reason, + {Mod, start_phase, + [Phase, Type, PhaseArgs]}}}); + Other -> + throw({error, {bad_return_value, + {{Mod, start_phase, + [Phase, Type, PhaseArgs]}, + Other}}}) + end + end. diff --git a/lib/kernel/src/auth.erl b/lib/kernel/src/auth.erl new file mode 100644 index 0000000000..62c0bef0cc --- /dev/null +++ b/lib/kernel/src/auth.erl @@ -0,0 +1,391 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1996-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(auth). +-behaviour(gen_server). + +-export([start_link/0]). + +%% Old documented interface - deprecated +-export([is_auth/1, cookie/0, cookie/1, node_cookie/1, node_cookie/2]). +-deprecated([{is_auth,1}, {cookie,'_'}, {node_cookie, '_'}]). + +%% New interface - meant for internal use within kernel only +-export([get_cookie/0, get_cookie/1, + set_cookie/1, set_cookie/2, + sync_cookie/0, + print/3]). + +%% gen_server callbacks +-export([init/1, handle_call/3, handle_cast/2, handle_info/2, + terminate/2, code_change/3]). + +-define(COOKIE_ETS_PROTECTION, protected). + +-record(state, { + our_cookie, %% Our own cookie + other_cookies %% The send-cookies of other nodes + }). + +-include("../include/file.hrl"). + +%%---------------------------------------------------------------------- +%% Exported functions +%%---------------------------------------------------------------------- + +start_link() -> + gen_server:start_link({local, auth}, auth, [], []). + +%%--Deprecated interface------------------------------------------------ + +-spec is_auth(Node :: node()) -> 'yes' | 'no'. + +is_auth(Node) -> + case net_adm:ping(Node) of + pong -> yes; + pang -> no + end. + +-spec cookie() -> atom(). + +cookie() -> + get_cookie(). + +-spec cookie(Cookies :: [atom(),...] | atom()) -> 'true'. + +cookie([Cookie]) -> + set_cookie(Cookie); +cookie(Cookie) -> + set_cookie(Cookie). + +-spec node_cookie(Cookies :: [atom(),...]) -> 'yes' | 'no'. + +node_cookie([Node, Cookie]) -> + node_cookie(Node, Cookie). + +-spec node_cookie(Node :: node(), Cookie :: atom()) -> 'yes' | 'no'. + +node_cookie(Node, Cookie) -> + set_cookie(Node, Cookie), + is_auth(Node). + +%%--"New" interface----------------------------------------------------- + +-spec get_cookie() -> atom(). + +get_cookie() -> + get_cookie(node()). + +-spec get_cookie(Node :: node()) -> atom(). + +get_cookie(_Node) when node() =:= nonode@nohost -> + nocookie; +get_cookie(Node) -> + gen_server:call(auth, {get_cookie, Node}). + +-spec set_cookie(Cookie :: atom()) -> 'true'. + +set_cookie(Cookie) -> + set_cookie(node(), Cookie). + +-spec set_cookie(Node :: node(), Cookie :: atom()) -> 'true'. + +set_cookie(_Node, _Cookie) when node() =:= nonode@nohost -> + erlang:error(distribution_not_started); +set_cookie(Node, Cookie) -> + gen_server:call(auth, {set_cookie, Node, Cookie}). + +-spec sync_cookie() -> any(). + +sync_cookie() -> + gen_server:call(auth, sync_cookie). + +-spec print(Node :: node(), Format :: string(), Args :: [_]) -> 'ok'. + +print(Node,Format,Args) -> + (catch gen_server:cast({auth,Node},{print,Format,Args})). + +%%--gen_server callbacks------------------------------------------------ + +init([]) -> + process_flag(trap_exit, true), + {ok, init_cookie()}. + +%% Opened is a list of servers we have opened up +%% The net kernel will let all message to the auth server +%% through as is + +handle_call({get_cookie, Node}, {_From,_Tag}, State) when Node =:= node() -> + {reply, State#state.our_cookie, State}; +handle_call({get_cookie, Node}, {_From,_Tag}, State) -> + case ets:lookup(State#state.other_cookies, Node) of + [{Node, Cookie}] -> + {reply, Cookie, State}; + [] -> + {reply, State#state.our_cookie, State} + end; +handle_call({set_cookie, Node, Cookie}, {_From,_Tag}, State) + when Node =:= node() -> + {reply, true, State#state{our_cookie = Cookie}}; + +%% +%% Happens when the distribution is brought up and +%% Someone wight have set up the cookie for our new nodename. +%% + +handle_call({set_cookie, Node, Cookie}, {_From,_Tag}, State) -> + ets:insert(State#state.other_cookies, {Node, Cookie}), + {reply, true, State}; + +handle_call(sync_cookie, _From, State) -> + case ets:lookup(State#state.other_cookies,node()) of + [{_N,C}] -> + ets:delete(State#state.other_cookies,node()), + {reply, true, State#state{our_cookie = C}}; + [] -> + {reply, true, State} + end; + +handle_call(echo, _From, O) -> + {reply, hello, O}. + +handle_cast({print,What,Args}, O) -> + %% always allow print outs + error_logger:error_msg(What,Args), + {noreply, O}. + +%% A series of bad messages that may come (from older distribution versions). + +handle_info({From,badcookie,net_kernel,{From,spawn,_M,_F,_A,_Gleader}}, O) -> + auth:print(node(From) ,"~n** Unauthorized spawn attempt to ~w **~n", + [node()]), + erlang:disconnect_node(node(From)), + {noreply, O}; +handle_info({From,badcookie,net_kernel,{From,spawn_link,_M,_F,_A,_Gleader}}, O) -> + auth:print(node(From), + "~n** Unauthorized spawn_link attempt to ~w **~n", + [node()]), + erlang:disconnect_node(node(From)), + {noreply, O}; +handle_info({_From,badcookie,ddd_server,_Mess}, O) -> + %% Ignore bad messages to the ddd server, they will be resent + %% If the authentication is succesful + {noreply, O}; +handle_info({From,badcookie,rex,_Msg}, O) -> + auth:print(getnode(From), + "~n** Unauthorized rpc attempt to ~w **~n",[node()]), + disconnect_node(node(From)), + {noreply, O}; +%% These two messages has to do with the old auth:is_auth() call (net_adm:ping) +handle_info({From,badcookie,net_kernel,{'$gen_call',{From,Tag},{is_auth,_Node}}}, O) -> %% ho ho + From ! {Tag, no}, + {noreply, O}; +handle_info({_From,badcookie,To,{{auth_reply,N},R}}, O) ->%% Let auth replys through + catch To ! {{auth_reply,N},R}, + {noreply, O}; +handle_info({From,badcookie,Name,Mess}, Opened) -> + %% This may be registered send as well as pid send. + case lists:member(Name, Opened) of + true -> + catch Name ! Mess; + false -> + case catch lists:member(element(1, Mess), Opened) of + true -> + catch Name ! Mess; %% Might be a pid as well + _ -> + auth:print(getnode(From), + "~n** Unauthorized send attempt ~w to ~w **~n", + [Mess,node()]), + erlang:disconnect_node(getnode(From)) + end + end, + {noreply, Opened}; +handle_info(_, O)-> % Ignore anything else especially EXIT signals + {noreply, O}. + +code_change(_OldVsn, State, _Extra) -> + {ok, State}. + +terminate(_Reason, _State) -> + ok. + +getnode(P) when is_pid(P) -> node(P); +getnode(P) -> P. + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%%% +%%% Cookie functions +%%% +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +%% Read cookie from $HOME/.erlang.cookie and set it. +init_cookie() -> + case init:get_argument(nocookie) of + error -> + case init:get_argument(setcookie) of + {ok, [[C0]]} -> + C = list_to_atom(C0), + #state{our_cookie = C, + other_cookies = ets:new(cookies, + [?COOKIE_ETS_PROTECTION])}; + _ -> + %% Here is the default + case read_cookie() of + {error, Error} -> + error_logger:error_msg(Error, []), + %% Is this really this serious? + erlang:error(Error); + {ok, Co} -> + #state{our_cookie = list_to_atom(Co), + other_cookies = ets:new( + cookies, + [?COOKIE_ETS_PROTECTION])} + end + end; + _Other -> + #state{our_cookie = nocookie, + other_cookies = ets:new(cookies,[?COOKIE_ETS_PROTECTION])} + end. + +read_cookie() -> + case init:get_argument(home) of + {ok, [[Home]]} -> + read_cookie(filename:join(Home, ".erlang.cookie")); + _ -> + {error, "No home for cookie file"} + end. + +read_cookie(Name) -> + case file:raw_read_file_info(Name) of + {ok, #file_info {type=Type, mode=Mode, size=Size}} -> + case check_attributes(Name, Type, Mode, os:type()) of + ok -> read_cookie(Name, Size); + Error -> Error + end; + {error, enoent} -> + case create_cookie(Name) of + ok -> read_cookie(Name); + Error -> Error + end; + {error, Reason} -> + {error, make_error(Name, Reason)} + end. + +read_cookie(Name, Size) -> + case file:open(Name, [raw, read]) of + {ok, File} -> + case file:read(File, Size) of + {ok, List} -> + file:close(File), + check_cookie(List, []); + {error, Reason} -> + make_error(Name, Reason) + end; + {error, Reason} -> + make_error(Name, Reason) + end. + +make_error(Name, Reason) -> + {error, "Error when reading " ++ Name ++ ": " ++ atom_to_list(Reason)}. + +%% Verifies that only the owner can access the cookie file. + +check_attributes(Name, Type, _Mode, _Os) when Type =/= regular -> + {error, "Cookie file " ++ Name ++ " is of type " ++ Type}; +check_attributes(Name, _Type, Mode, {unix, _}) when (Mode band 8#077) =/= 0 -> + {error, "Cookie file " ++ Name ++ " must be accessible by owner only"}; +check_attributes(_Name, _Type, _Mode, _Os) -> + ok. + +%% Checks that the cookie has the correct format. + +check_cookie([Letter|Rest], Result) when $\s =< Letter, Letter =< $~ -> + check_cookie(Rest, [Letter|Result]); +check_cookie([X|Rest], Result) -> + check_cookie1([X|Rest], Result); +check_cookie([], Result) -> + check_cookie1([], Result). + +check_cookie1([$\n|Rest], Result) -> + check_cookie1(Rest, Result); +check_cookie1([$\r|Rest], Result) -> + check_cookie1(Rest, Result); +check_cookie1([$\s|Rest], Result) -> + check_cookie1(Rest, Result); +check_cookie1([_|_], _Result) -> + {error, "Bad characters in cookie"}; +check_cookie1([], []) -> + {error, "Too short cookie string"}; +check_cookie1([], Result) -> + {ok, lists:reverse(Result)}. + +%% Creates a new, random cookie. + +create_cookie(Name) -> + {_, S1, S2} = now(), + Seed = S2*10000+S1, + Cookie = random_cookie(20, Seed, []), + case file:open(Name, [write, raw]) of + {ok, File} -> + R1 = file:write(File, Cookie), + file:close(File), + R2 = file:raw_write_file_info(Name, make_info(Name)), + case {R1, R2} of + {ok, ok} -> + ok; + {{error,_Reason}, _} -> + {error, "Failed to create cookie file"}; + {ok, {error, Reason}} -> + {error, "Failed to change mode: " ++ atom_to_list(Reason)} + end; + {error,_Reason} -> + {error, "Failed to create cookie file"} + end. + +random_cookie(0, _, Result) -> + Result; +random_cookie(Count, X0, Result) -> + X = next_random(X0), + Letter = X*($Z-$A+1) div 16#1000000000 + $A, + random_cookie(Count-1, X, [Letter|Result]). + +%% Returns suitable information for a new cookie. +%% +%% Note: Since the generated cookie depends on the time the file was +%% created, and the time can be seen plainly in the file, we will +%% round down the file creation times to the nearest midnight to +%% give crackers some more work. + +make_info(Name) -> + Midnight = + case file:raw_read_file_info(Name) of + {ok, #file_info{atime={Date, _}}} -> + {Date, {0, 0, 0}}; + _ -> + {{1990, 1, 1}, {0, 0, 0}} + end, + #file_info{mode=8#400, atime=Midnight, mtime=Midnight, ctime=Midnight}. + +%% This RNG is from line 21 on page 102 in Knuth: The Art of Computer Programming, +%% Volume II, Seminumerical Algorithms. +%% +%% Returns an integer in the range 0..(2^35-1). + +next_random(X) -> + (X*17059465+1) band 16#fffffffff. diff --git a/lib/kernel/src/code.erl b/lib/kernel/src/code.erl new file mode 100644 index 0000000000..fef11d7e6e --- /dev/null +++ b/lib/kernel/src/code.erl @@ -0,0 +1,491 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1996-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(code). + +%% This is the interface module to the code server. It also contains +%% some implementation details. See also related modules: code_*.erl +%% in this directory. + +-export([objfile_extension/0, + set_path/1, + get_path/0, + load_file/1, + ensure_loaded/1, + load_abs/1, + load_abs/2, + load_binary/3, + load_native_partial/2, + load_native_sticky/3, + delete/1, + purge/1, + soft_purge/1, + is_loaded/1, + all_loaded/0, + stop/0, + root_dir/0, + lib_dir/0, + lib_dir/1, + lib_dir/2, + compiler_dir/0, + priv_dir/1, + stick_dir/1, + unstick_dir/1, + stick_mod/1, + unstick_mod/1, + is_sticky/1, + get_object_code/1, + add_path/1, + add_pathsz/1, + add_paths/1, + add_pathsa/1, + add_patha/1, + add_pathz/1, + del_path/1, + replace_path/2, + rehash/0, + start_link/0, start_link/1, + which/1, + where_is_file/1, + where_is_file/2, + set_primary_archive/2, + clash/0]). + +-include_lib("kernel/include/file.hrl"). + +%% User interface. +%% +%% objfile_extension() -> ".beam" +%% set_path(Dir*) -> true +%% get_path() -> Dir* +%% add_path(Dir) -> true | {error, What} +%% add_patha(Dir) -> true | {error, What} +%% add_pathz(Dir) -> true | {error, What} +%% add_paths(DirList) -> true | {error, What} +%% add_pathsa(DirList) -> true | {error, What} +%% add_pathsz(DirList) -> true | {error, What} +%% del_path(Dir) -> true | {error, What} +%% replace_path(Name,Dir) -> true | {error, What} +%% load_file(File) -> {error,What} | {module, Mod} +%% load_abs(File) -> {error,What} | {module, Mod} +%% load_abs(File,Mod) -> {error,What} | {module, Mod} +%% load_binary(Mod,File,Bin) -> {error,What} | {module,Mod} +%% ensure_loaded(Module) -> {error,What} | {module, Mod} +%% delete(Module) +%% purge(Module) kills all procs running old code +%% soft_purge(Module) -> true | false +%% is_loaded(Module) -> {file, File} | false +%% all_loaded() -> {Module, File}* +%% get_object_code(Mod) -> error | {Mod, Bin, Filename} +%% stop() -> true +%% root_dir() +%% compiler_dir() +%% lib_dir() +%% priv_dir(Name) +%% stick_dir(Dir) -> ok | error +%% unstick_dir(Dir) -> ok | error +%% is_sticky(Module) -> true | false +%% which(Module) -> Filename +%% set_primary_archive((FileName, Bin) -> ok | {error, Reason} +%% clash() -> -> print out + +%%---------------------------------------------------------------------------- +%% Some types for basic exported functions of this module +%%---------------------------------------------------------------------------- + +-type load_error_rsn() :: 'badfile' | 'native_code' | 'nofile' | 'not_purged' + | 'sticky_directory'. % for some functions only +-type load_ret() :: {'error', load_error_rsn()} | {'module', atom()}. +-type loaded_ret_atoms() :: 'cover_compiled' | 'preloaded'. +-type loaded_filename() :: file:filename() | loaded_ret_atoms(). + +%%---------------------------------------------------------------------------- +%% User interface +%%---------------------------------------------------------------------------- + +-spec objfile_extension() -> file:filename(). +objfile_extension() -> + init:objfile_extension(). + +-spec load_file(Module :: atom()) -> load_ret(). +load_file(Mod) when is_atom(Mod) -> + call({load_file,Mod}). + +-spec ensure_loaded(Module :: atom()) -> load_ret(). +ensure_loaded(Mod) when is_atom(Mod) -> + call({ensure_loaded,Mod}). + +%% XXX File as an atom is allowed only for backwards compatibility. +-spec load_abs(Filename :: file:filename()) -> load_ret(). +load_abs(File) when is_list(File); is_atom(File) -> call({load_abs,File,[]}). + +%% XXX Filename is also an atom(), e.g. 'cover_compiled' +-spec load_abs(Filename :: loaded_filename(), Module :: atom()) -> load_ret(). +load_abs(File,M) when (is_list(File) orelse is_atom(File)), is_atom(M) -> + call({load_abs,File,M}). + +%% XXX Filename is also an atom(), e.g. 'cover_compiled' +-spec load_binary(Module :: atom(), Filename :: loaded_filename(), Binary :: binary()) -> load_ret(). +load_binary(Mod,File,Bin) + when is_atom(Mod), (is_list(File) orelse is_atom(File)), is_binary(Bin) -> + call({load_binary,Mod,File,Bin}). + +-spec load_native_partial(Module :: atom(), Binary :: binary()) -> load_ret(). +load_native_partial(Mod,Bin) when is_atom(Mod), is_binary(Bin) -> + call({load_native_partial,Mod,Bin}). + +-spec load_native_sticky(Module :: atom(), Binary :: binary(), WholeModule :: 'false' | binary()) -> load_ret(). +load_native_sticky(Mod,Bin,WholeModule) + when is_atom(Mod), is_binary(Bin), + (is_binary(WholeModule) orelse WholeModule =:= false) -> + call({load_native_sticky,Mod,Bin,WholeModule}). + +-spec delete(Module :: atom()) -> boolean(). +delete(Mod) when is_atom(Mod) -> call({delete,Mod}). + +-spec purge/1 :: (Module :: atom()) -> boolean(). +purge(Mod) when is_atom(Mod) -> call({purge,Mod}). + +-spec soft_purge(Module :: atom()) -> boolean(). +soft_purge(Mod) when is_atom(Mod) -> call({soft_purge,Mod}). + +-spec is_loaded(Module :: atom()) -> {'file', loaded_filename()} | 'false'. +is_loaded(Mod) when is_atom(Mod) -> call({is_loaded,Mod}). + +-spec get_object_code(Module :: atom()) -> {atom(), binary(), file:filename()} | 'error'. +get_object_code(Mod) when is_atom(Mod) -> call({get_object_code, Mod}). + +-spec all_loaded() -> [{atom(), loaded_filename()}]. +all_loaded() -> call(all_loaded). + +-spec stop() -> no_return(). +stop() -> call(stop). + +-spec root_dir() -> file:filename(). +root_dir() -> call({dir,root_dir}). + +-spec lib_dir() -> file:filename(). +lib_dir() -> call({dir,lib_dir}). + +%% XXX is_list() is for backwards compatibility -- take out in future version +-spec lib_dir(App :: atom()) -> file:filename() | {'error', 'bad_name'}. +lib_dir(App) when is_atom(App) ; is_list(App) -> call({dir,{lib_dir,App}}). + +-spec lib_dir(App :: atom(), SubDir :: atom()) -> file:filename() | {'error', 'bad_name'}. +lib_dir(App, SubDir) when is_atom(App), is_atom(SubDir) -> call({dir,{lib_dir,App,SubDir}}). + +-spec compiler_dir() -> file:filename(). +compiler_dir() -> call({dir,compiler_dir}). + +%% XXX is_list() is for backwards compatibility -- take out in future version +-spec priv_dir(Appl :: atom()) -> file:filename() | {'error', 'bad_name'}. +priv_dir(App) when is_atom(App) ; is_list(App) -> call({dir,{priv_dir,App}}). + +-spec stick_dir(Directory :: file:filename()) -> 'ok' | 'error'. +stick_dir(Dir) when is_list(Dir) -> call({stick_dir,Dir}). + +-spec unstick_dir(Directory :: file:filename()) -> 'ok' | 'error'. +unstick_dir(Dir) when is_list(Dir) -> call({unstick_dir,Dir}). + +-spec stick_mod(Module :: atom()) -> 'true'. +stick_mod(Mod) when is_atom(Mod) -> call({stick_mod,Mod}). + +-spec unstick_mod(Module :: atom()) -> 'true'. +unstick_mod(Mod) when is_atom(Mod) -> call({unstick_mod,Mod}). + +-spec is_sticky(Module :: atom()) -> boolean(). +is_sticky(Mod) when is_atom(Mod) -> call({is_sticky,Mod}). + +-spec set_path(Directories :: [file:filename()]) -> 'true' | {'error', term()}. +set_path(PathList) when is_list(PathList) -> call({set_path,PathList}). + +-spec get_path() -> [file:filename()]. +get_path() -> call(get_path). + +-spec add_path(Directory :: file:filename()) -> 'true' | {'error', term()}. +add_path(Dir) when is_list(Dir) -> call({add_path,last,Dir}). + +-spec add_pathz(Directory :: file:filename()) -> 'true' | {'error', term()}. +add_pathz(Dir) when is_list(Dir) -> call({add_path,last,Dir}). + +-spec add_patha(Directory :: file:filename()) -> 'true' | {'error', term()}. +add_patha(Dir) when is_list(Dir) -> call({add_path,first,Dir}). + +-spec add_paths(Directories :: [file:filename()]) -> 'ok'. +add_paths(Dirs) when is_list(Dirs) -> call({add_paths,last,Dirs}). + +-spec add_pathsz(Directories :: [file:filename()]) -> 'ok'. +add_pathsz(Dirs) when is_list(Dirs) -> call({add_paths,last,Dirs}). + +-spec add_pathsa(Directories :: [file:filename()]) -> 'ok'. +add_pathsa(Dirs) when is_list(Dirs) -> call({add_paths,first,Dirs}). + +%% XXX Contract's input argument differs from add_path/1 -- why? +-spec del_path(Name :: file:filename() | atom()) -> boolean() | {'error', 'bad_name'}. +del_path(Name) when is_list(Name) ; is_atom(Name) -> call({del_path,Name}). + +-type replace_path_error() :: {'error', 'bad_directory' | 'bad_name' | {'badarg',_}}. +-spec replace_path(Name:: atom(), Dir :: file:filename()) -> 'true' | replace_path_error(). +replace_path(Name, Dir) when (is_atom(Name) or is_list(Name)) and + (is_atom(Dir) or is_list(Dir)) -> + call({replace_path,Name,Dir}). + +-spec rehash() -> 'ok'. +rehash() -> call(rehash). + +%%----------------------------------------------------------------- + +call(Req) -> + code_server:call(code_server, Req). + +-spec start_link() -> {'ok', pid()} | {'error', 'crash'}. +start_link() -> + start_link([stick]). + +-spec start_link(Flags :: [atom()]) -> {'ok', pid()} | {'error', 'crash'}. +start_link(Flags) -> + do_start(Flags). + +%%----------------------------------------------------------------- +%% In the init phase, code must not use any modules not yet loaded, +%% either pre_loaded (e.g. init) or first in the script (e.g. +%% erlang). Therefore, keep the modules used in init phase to a +%% minimum, and make sure they are loaded before init is called. +%% Try to call these modules from do_start instead. +%% file is used in init - this is ok; file has been started before +%% us, so the module is loaded. +%%----------------------------------------------------------------- + +do_start(Flags) -> + %% The following module_info/1 calls are here to ensure + %% that the modules are loaded prior to their use elsewhere in + %% the code_server. + %% Otherwise a deadlock may occur when the code_server is starting. + code_server:module_info(module), + packages:module_info(module), + catch hipe_unified_loader:load_hipe_modules(), + gb_sets:module_info(module), + gb_trees:module_info(module), + + ets:module_info(module), + os:module_info(module), + filename:module_info(module), + lists:module_info(module), + + Mode = get_mode(Flags), + case init:get_argument(root) of + {ok,[[Root0]]} -> + Root = filename:join([Root0]), % Normalize. Use filename + case code_server:start_link([Root,Mode]) of + {ok,_Pid} = Ok2 -> + if + Mode =:= interactive -> + case lists:member(stick, Flags) of + true -> do_stick_dirs(); + _ -> ok + end; + true -> + ok + end, + Ok2; + Other -> + Other + end; + Other -> + error_logger:error_msg("Can not start code server ~w ~n",[Other]), + {error, crash} + end. + +do_stick_dirs() -> + do_s(compiler), + do_s(stdlib), + do_s(kernel). + +do_s(Lib) -> + case lib_dir(Lib) of + {error, _} -> + ok; + Dir -> + %% The return value is intentionally ignored. Missing + %% directories is not a fatal error. (In embedded systems, + %% there is usually no compiler directory.) + stick_dir(filename:append(Dir, "ebin")), + ok + end. + +get_mode(Flags) -> + case lists:member(embedded, Flags) of + true -> + embedded; + _Otherwise -> + case init:get_argument(mode) of + {ok,[["embedded"]]} -> + embedded; + {ok,[["minimal"]]} -> + minimal; + _Else -> + interactive + end + end. + +%% Find out which version of a particular module we would +%% load if we tried to load it, unless it's already loaded. +%% In that case return the name of the file which contains +%% the loaded object code + +-type which_ret_atoms() :: loaded_ret_atoms() | 'non_existing'. + +-spec which(Module :: atom()) -> file:filename() | which_ret_atoms(). + +which(Module) when is_atom(Module) -> + case is_loaded(Module) of + false -> + which2(Module); + {file, File} -> + File + end. + +which2(Module) -> + Base = to_path(Module), + File = filename:basename(Base) ++ objfile_extension(), + Path = get_path(), + which(File, filename:dirname(Base), Path). + +-spec which(file:filename(), file:filename(), [file:filename()]) -> + 'non_existing' | file:filename(). + +which(_, _, []) -> + non_existing; +which(File, Base, [Directory|Tail]) -> + Path = if + Base =:= "." -> Directory; + true -> filename:join(Directory, Base) + end, + case erl_prim_loader:list_dir(Path) of + {ok,Files} -> + case lists:member(File,Files) of + true -> + filename:append(Path, File); + false -> + which(File, Base, Tail) + end; + _Error -> + which(File, Base, Tail) + end. + +%% Search the code path for a specific file. Try to locate +%% it in the code path cache if possible. + +-spec where_is_file(Filename :: file:filename()) -> + 'non_existing' | file:filename(). + +where_is_file(File) when is_list(File) -> + case call({is_cached,File}) of + no -> + Path = get_path(), + which(File, ".", Path); + Dir -> + filename:join(Dir, File) + end. + +-spec where_is_file(Path :: file:filename(), Filename :: file:filename()) -> + file:filename() | 'non_existing'. + +where_is_file(Path, File) when is_list(Path), is_list(File) -> + CodePath = get_path(), + if + Path =:= CodePath -> + case call({is_cached, File}) of + no -> + which(File, ".", Path); + Dir -> + filename:join(Dir, File) + end; + true -> + which(File, ".", Path) + end. + +-spec set_primary_archive(ArchiveFile :: file:filename(), ArchiveBin :: binary()) -> 'ok' | {'error', atom()}. + +set_primary_archive(ArchiveFile0, ArchiveBin) when is_list(ArchiveFile0), is_binary(ArchiveBin) -> + ArchiveFile = filename:absname(ArchiveFile0), + case call({set_primary_archive, ArchiveFile, ArchiveBin}) of + {ok, []} -> + ok; + {ok, _Mode, Ebins} -> + %% Prepend the code path with the ebins found in the archive + Ebins2 = [filename:join([ArchiveFile, E]) || E <- Ebins], + add_pathsa(Ebins2); % Returns ok + {error, _Reason} = Error -> + Error + end. + +%% Search the entire path system looking for name clashes + +-spec clash() -> 'ok'. + +clash() -> + Path = get_path(), + Struct = lists:flatten(build(Path)), + Len = length(search(Struct)), + io:format("** Found ~w name clashes in code paths ~n", [Len]). + +%% Internal for clash/0 + +search([]) -> []; +search([{Dir, File} | Tail]) -> + case lists:keyfind(File, 2, Tail) of + false -> + search(Tail); + {Dir2, File} -> + io:format("** ~s hides ~s~n", + [filename:join(Dir, File), + filename:join(Dir2, File)]), + [clash | search(Tail)] + end. + +build([]) -> []; +build([Dir|Tail]) -> + Files = filter(objfile_extension(), Dir, file:list_dir(Dir)), + [decorate(Files, Dir) | build(Tail)]. + +decorate([], _) -> []; +decorate([File|Tail], Dir) -> + [{Dir, File} | decorate(Tail, Dir)]. + +filter(_Ext, Dir, {error,_}) -> + io:format("** Bad path can't read ~s~n", [Dir]), []; +filter(Ext, _, {ok,Files}) -> + filter2(Ext, length(Ext), Files). + +filter2(_Ext, _Extlen, []) -> []; +filter2(Ext, Extlen,[File|Tail]) -> + case has_ext(Ext,Extlen, File) of + true -> [File | filter2(Ext, Extlen, Tail)]; + false -> filter2(Ext, Extlen, Tail) + end. + +has_ext(Ext, Extlen,File) -> + L = length(File), + case catch lists:nthtail(L - Extlen, File) of + Ext -> true; + _ -> false + end. + +to_path(X) -> + filename:join(packages:split(X)). diff --git a/lib/kernel/src/code_server.erl b/lib/kernel/src/code_server.erl new file mode 100644 index 0000000000..018f7f41d2 --- /dev/null +++ b/lib/kernel/src/code_server.erl @@ -0,0 +1,1539 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1998-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(code_server). + +%% This file holds the server part of the code_server. + +-export([start_link/1, + call/2, + system_continue/3, + system_terminate/4, + system_code_change/4, + error_msg/2, info_msg/2 + ]). + +-include_lib("kernel/include/file.hrl"). + +-import(lists, [foreach/2]). + +-record(state,{supervisor, + root, + path, + moddb, + namedb, + cache = no_cache, + mode=interactive, + on_load = []}). + +start_link(Args) -> + Ref = make_ref(), + Parent = self(), + Init = fun() -> init(Ref, Parent, Args) end, + spawn_link(Init), + receive + {Ref,Res} -> Res + end. + + +%% ----------------------------------------------------------- +%% Init the code_server process. +%% ----------------------------------------------------------- + +init(Ref, Parent, [Root,Mode0]) -> + register(?MODULE, self()), + process_flag(trap_exit, true), + + Db = ets:new(code, [private]), + foreach(fun (M) -> ets:insert(Db, {M,preloaded}) end, erlang:pre_loaded()), + ets:insert(Db, init:fetch_loaded()), + + Mode = + case Mode0 of + minimal -> interactive; + _ -> Mode0 + end, + + IPath = + case Mode of + interactive -> + LibDir = filename:append(Root, "lib"), + {ok,Dirs} = erl_prim_loader:list_dir(LibDir), + {Paths,_Libs} = make_path(LibDir,Dirs), + UserLibPaths = get_user_lib_dirs(), + ["."] ++ UserLibPaths ++ Paths; + _ -> + [] + end, + + Path = add_loader_path(IPath, Mode), + State0 = #state{root = Root, + path = Path, + moddb = Db, + namedb = init_namedb(Path), + mode = Mode}, + + State = + case init:get_argument(code_path_cache) of + {ok, _} -> + create_cache(State0); + error -> + State0 + end, + + Parent ! {Ref,{ok,self()}}, + loop(State#state{supervisor=Parent}). + +get_user_lib_dirs() -> + case os:getenv("ERL_LIBS") of + LibDirs0 when is_list(LibDirs0) -> + Sep = + case os:type() of + {win32, _} -> $;; + _ -> $: + end, + LibDirs = split_paths(LibDirs0, Sep, [], []), + get_user_lib_dirs_1(LibDirs); + false -> + [] + end. + +get_user_lib_dirs_1([Dir|DirList]) -> + case erl_prim_loader:list_dir(Dir) of + {ok, Dirs} -> + {Paths,_Libs} = make_path(Dir, Dirs), + %% Only add paths trailing with ./ebin. + [P || P <- Paths, filename:basename(P) =:= "ebin"] ++ + get_user_lib_dirs_1(DirList); + error -> + get_user_lib_dirs_1(DirList) + end; +get_user_lib_dirs_1([]) -> []. + + +split_paths([S|T], S, Path, Paths) -> + split_paths(T, S, [], [lists:reverse(Path) | Paths]); +split_paths([C|T], S, Path, Paths) -> + split_paths(T, S, [C|Path], Paths); +split_paths([], _S, Path, Paths) -> + lists:reverse(Paths, [lists:reverse(Path)]). + +call(Name, Req) -> + Name ! {code_call, self(), Req}, + receive + {?MODULE, Reply} -> + Reply + end. + +reply(Pid, Res) -> + Pid ! {?MODULE, Res}. + +loop(#state{supervisor=Supervisor}=State0) -> + receive + {code_call, Pid, Req} -> + case handle_call(Req, {Pid, call}, State0) of + {reply, Res, State} -> + reply(Pid, Res), + loop(State); + {noreply, State} -> + loop(State); + {stop, Why, stopped, State} -> + system_terminate(Why, Supervisor, [], State) + end; + {'EXIT', Supervisor, Reason} -> + system_terminate(Reason, Supervisor, [], State0); + {system, From, Msg} -> + handle_system_msg(running,Msg, From, Supervisor, State0); + {'DOWN',Ref,process,_,Res} -> + State = finish_on_load(Ref, Res, State0), + loop(State); + _Msg -> + loop(State0) + end. + +%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% System upgrade + +handle_system_msg(SysState,Msg,From,Parent,Misc) -> + case do_sys_cmd(SysState,Msg,Parent, Misc) of + {suspended, Reply, NMisc} -> + gen_reply(From, Reply), + suspend_loop(suspended, Parent, NMisc); + {running, Reply, NMisc} -> + gen_reply(From, Reply), + system_continue(Parent, [], NMisc) + end. + +gen_reply({To, Tag}, Reply) -> + catch To ! {Tag, Reply}. + +%%----------------------------------------------------------------- +%% When a process is suspended, it can only respond to system +%% messages. +%%----------------------------------------------------------------- +suspend_loop(SysState, Parent, Misc) -> + receive + {system, From, Msg} -> + handle_system_msg(SysState, Msg, From, Parent, Misc); + {'EXIT', Parent, Reason} -> + system_terminate(Reason, Parent, [], Misc) + end. + +do_sys_cmd(_, suspend, _Parent, Misc) -> + {suspended, ok, Misc}; +do_sys_cmd(_, resume, _Parent, Misc) -> + {running, ok, Misc}; +do_sys_cmd(SysState, get_status, Parent, Misc) -> + Status = {status, self(), {module, ?MODULE}, + [get(), SysState, Parent, [], Misc]}, + {SysState, Status, Misc}; +do_sys_cmd(SysState, {debug, _What}, _Parent, Misc) -> + {SysState,ok,Misc}; +do_sys_cmd(suspended, {change_code, Module, Vsn, Extra}, _Parent, Misc0) -> + {Res, Misc} = + case catch ?MODULE:system_code_change(Misc0, Module, Vsn, Extra) of + {ok, Misc1} -> {ok, Misc1}; + Else -> {{error, Else}, Misc0} + end, + {suspended, Res, Misc}; +do_sys_cmd(SysState, Other, _Parent, Misc) -> + {SysState, {error, {unknown_system_msg, Other}}, Misc}. + +system_continue(_Parent, _Debug, State) -> + loop(State). + +system_terminate(_Reason, _Parent, _Debug, _State) -> +% error_msg("~p terminating: ~p~n ",[?MODULE,Reason]), + exit(shutdown). + +system_code_change(State, _Module, _OldVsn, _Extra) -> + {ok, State}. + +%% +%% The gen_server call back functions. +%% + +handle_call({stick_dir,Dir}, {_From,_Tag}, S) -> + {reply,stick_dir(Dir, true, S),S}; + +handle_call({unstick_dir,Dir}, {_From,_Tag}, S) -> + {reply,stick_dir(Dir, false, S),S}; + +handle_call({stick_mod,Mod}, {_From,_Tag}, S) -> + {reply,stick_mod(Mod, true, S),S}; + +handle_call({unstick_mod,Mod}, {_From,_Tag}, S) -> + {reply,stick_mod(Mod, false, S),S}; + +handle_call({dir,Dir},{_From,_Tag}, S) -> + Root = S#state.root, + Resp = do_dir(Root,Dir,S#state.namedb), + {reply,Resp,S}; + +handle_call({load_file,Mod}, Caller, St) -> + case modp(Mod) of + false -> + {reply,{error,badarg},St}; + true -> + load_file(Mod, Caller, St) + end; + +handle_call({add_path,Where,Dir0}, {_From,_Tag}, S=#state{cache=Cache0}) -> + case Cache0 of + no_cache -> + {Resp,Path} = add_path(Where, Dir0, S#state.path, S#state.namedb), + {reply,Resp,S#state{path=Path}}; + _ -> + Dir = absname(Dir0), %% Cache always expands the path + {Resp,Path} = add_path(Where, Dir, S#state.path, S#state.namedb), + Cache=update_cache([Dir],Where,Cache0), + {reply,Resp,S#state{path=Path,cache=Cache}} + end; + +handle_call({add_paths,Where,Dirs0}, {_From,_Tag}, S=#state{cache=Cache0}) -> + case Cache0 of + no_cache -> + {Resp,Path} = add_paths(Where,Dirs0,S#state.path,S#state.namedb), + {reply,Resp, S#state{path=Path}}; + _ -> + %% Cache always expands the path + Dirs = [absname(Dir) || Dir <- Dirs0], + {Resp,Path} = add_paths(Where, Dirs, S#state.path, S#state.namedb), + Cache=update_cache(Dirs,Where,Cache0), + {reply,Resp,S#state{cache=Cache,path=Path}} + end; + +handle_call({set_path,PathList}, {_From,_Tag}, S) -> + Path = S#state.path, + {Resp, NewPath,NewDb} = set_path(PathList, Path, S#state.namedb), + {reply,Resp,rehash_cache(S#state{path = NewPath, namedb=NewDb})}; + +handle_call({del_path,Name}, {_From,_Tag}, S) -> + {Resp,Path} = del_path(Name,S#state.path,S#state.namedb), + {reply,Resp,rehash_cache(S#state{path = Path})}; + +handle_call({replace_path,Name,Dir}, {_From,_Tag}, S) -> + {Resp,Path} = replace_path(Name,Dir,S#state.path,S#state.namedb), + {reply,Resp,rehash_cache(S#state{path = Path})}; + +handle_call(rehash, {_From,_Tag}, S0) -> + S = create_cache(S0), + {reply,ok,S}; + +handle_call(get_path, {_From,_Tag}, S) -> + {reply,S#state.path,S}; + +%% Messages to load, delete and purge modules/files. +handle_call({load_abs,File,Mod}, Caller, S) -> + case modp(File) of + false -> + {reply,{error,badarg},S}; + true -> + load_abs(File, Mod, Caller, S) + end; + +handle_call({load_binary,Mod,File,Bin}, Caller, S) -> + do_load_binary(Mod, File, Bin, Caller, S); + +handle_call({load_native_partial,Mod,Bin}, {_From,_Tag}, S) -> + Result = (catch hipe_unified_loader:load(Mod,Bin)), + Status = hipe_result_to_status(Result), + {reply,Status,S}; + +handle_call({load_native_sticky,Mod,Bin,WholeModule}, {_From,_Tag}, S) -> + Result = (catch hipe_unified_loader:load_module(Mod,Bin,WholeModule)), + Status = hipe_result_to_status(Result), + {reply,Status,S}; + +handle_call({ensure_loaded,Mod0}, Caller, St0) -> + Fun = fun (M, St) -> + case erlang:module_loaded(M) of + true -> + {reply,{module,M},St}; + false when St#state.mode =:= interactive -> + load_file(M, Caller, St); + false -> + {reply,{error,embedded},St} + end + end, + do_mod_call(Fun, Mod0, {error,badarg}, St0); + +handle_call({delete,Mod0}, {_From,_Tag}, S) -> + Fun = fun (M, St) -> + case catch erlang:delete_module(M) of + true -> + ets:delete(St#state.moddb, M), + {reply,true,St}; + _ -> + {reply,false,St} + end + end, + do_mod_call(Fun, Mod0, false, S); + +handle_call({purge,Mod0}, {_From,_Tag}, St0) -> + do_mod_call(fun (M, St) -> + {reply,do_purge(M),St} + end, Mod0, false, St0); + +handle_call({soft_purge,Mod0}, {_From,_Tag}, St0) -> + do_mod_call(fun (M, St) -> + {reply,do_soft_purge(M),St} + end, Mod0, true, St0); + +handle_call({is_loaded,Mod0}, {_From,_Tag}, St0) -> + do_mod_call(fun (M, St) -> + {reply,is_loaded(M, St#state.moddb),St} + end, Mod0, false, St0); + +handle_call(all_loaded, {_From,_Tag}, S) -> + Db = S#state.moddb, + {reply,all_loaded(Db),S}; + +handle_call({get_object_code,Mod0}, {_From,_Tag}, St0) -> + Fun = fun(M, St) -> + Path = St#state.path, + case mod_to_bin(Path, atom_to_list(M)) of + {_,Bin,FName} -> {reply,{M,Bin,FName},St}; + Error -> {reply,Error,St} + end + end, + do_mod_call(Fun, Mod0, error, St0); + +handle_call({is_sticky, Mod}, {_From,_Tag}, S) -> + Db = S#state.moddb, + {reply, is_sticky(Mod,Db), S}; + +handle_call(stop,{_From,_Tag}, S) -> + {stop,normal,stopped,S}; + +handle_call({is_cached,_File}, {_From,_Tag}, S=#state{cache=no_cache}) -> + {reply, no, S}; + +handle_call({set_primary_archive, File, ArchiveBin}, {_From,_Tag}, S=#state{mode=Mode}) -> + case erl_prim_loader:set_primary_archive(File, ArchiveBin) of + {ok, Files} -> + {reply, {ok, Mode, Files}, S}; + {error, Reason} -> + {reply, {error, Reason}, S} + end; + +handle_call({is_cached,File}, {_From,_Tag}, S=#state{cache=Cache}) -> + ObjExt = objfile_extension(), + Ext = filename:extension(File), + Type = case Ext of + ObjExt -> obj; + ".app" -> app; + _ -> undef + end, + if Type =:= undef -> + {reply, no, S}; + true -> + Key = {Type,list_to_atom(filename:rootname(File, Ext))}, + case ets:lookup(Cache, Key) of + [] -> + {reply, no, S}; + [{Key,Dir}] -> + {reply, Dir, S} + end + end; + +handle_call(Other,{_From,_Tag}, S) -> + error_msg(" ** Codeserver*** ignoring ~w~n ",[Other]), + {noreply,S}. + +do_mod_call(Action, Module, _Error, St) when is_atom(Module) -> + Action(Module, St); +do_mod_call(Action, Module, Error, St) -> + try list_to_atom(Module) of + Atom when is_atom(Atom) -> + Action(Atom, St) + catch + error:badarg -> + {reply,Error,St} + end. + +%% -------------------------------------------------------------- +%% Cache functions +%% -------------------------------------------------------------- + +create_cache(St = #state{cache = no_cache}) -> + Cache = ets:new(code_cache, [protected]), + rehash_cache(Cache, St); +create_cache(St) -> + rehash_cache(St). + +rehash_cache(St = #state{cache = no_cache}) -> + St; +rehash_cache(St = #state{cache = OldCache}) -> + ets:delete(OldCache), + Cache = ets:new(code_cache, [protected]), + rehash_cache(Cache, St). + +rehash_cache(Cache, St = #state{path = Path}) -> + Exts = [{obj,objfile_extension()}, {app,".app"}], + {Cache,NewPath} = locate_mods(lists:reverse(Path), first, Exts, Cache, []), + St#state{cache = Cache, path=NewPath}. + +update_cache(Dirs, Where, Cache0) -> + Exts = [{obj,objfile_extension()}, {app,".app"}], + {Cache, _} = locate_mods(Dirs, Where, Exts, Cache0, []), + Cache. + +locate_mods([Dir0|Path], Where, Exts, Cache, Acc) -> + Dir = absname(Dir0), %% Cache always expands the path + case erl_prim_loader:list_dir(Dir) of + {ok, Files} -> + Cache = filter_mods(Files, Where, Exts, Dir, Cache), + locate_mods(Path, Where, Exts, Cache, [Dir|Acc]); + error -> + locate_mods(Path, Where, Exts, Cache, Acc) + end; +locate_mods([], _, _, Cache, Path) -> + {Cache,Path}. + +filter_mods([File|Rest], Where, Exts, Dir, Cache) -> + Ext = filename:extension(File), + Root = list_to_atom(filename:rootname(File, Ext)), + case lists:keysearch(Ext, 2, Exts) of + {value,{Type,_}} -> + Key = {Type,Root}, + case Where of + first -> + true = ets:insert(Cache, {Key,Dir}); + last -> + case ets:lookup(Cache, Key) of + [] -> + true = ets:insert(Cache, {Key,Dir}); + _ -> + ignore + end + end; + false -> + ok + end, + filter_mods(Rest, Where, Exts, Dir, Cache); + +filter_mods([], _, _, _, Cache) -> + Cache. + +%% -------------------------------------------------------------- +%% Path handling functions. +%% -------------------------------------------------------------- + +%% +%% Create the initial path. +%% +make_path(BundleDir,Bundles0) -> + Bundles = choose_bundles(Bundles0), + make_path(BundleDir,Bundles,[],[]). + +choose_bundles(Bundles) -> + ArchiveExt = archive_extension(), + Bs = lists:sort([create_bundle(B,ArchiveExt) || B <- Bundles]), + [FullName || {_Name,_NumVsn,FullName} <- + choose(lists:reverse(Bs), [], ArchiveExt)]. + +create_bundle(FullName,ArchiveExt) -> + BaseName = filename:basename(FullName,ArchiveExt), + case split(BaseName, "-") of + Toks when length(Toks) > 1 -> + VsnStr = lists:last(Toks), + case vsn_to_num(VsnStr) of + {ok, VsnNum} -> + Name = join(lists:sublist(Toks,length(Toks)-1),"-"), + {Name,VsnNum,FullName}; + false -> + {FullName, [0], FullName} + end; + _ -> + {FullName,[0],FullName} + end. + +%% Convert "X.Y.Z. ..." to [K, L, M| ...] +vsn_to_num(Vsn) -> + case is_vsn(Vsn) of + true -> + {ok, [list_to_integer(S) || S <- split(Vsn, ".")]}; + _ -> + false + end. + +is_vsn(Str) when is_list(Str) -> + Vsns = split(Str, "."), + lists:all(fun is_numstr/1, Vsns). + +is_numstr(Cs) -> + lists:all(fun (C) when $0 =< C, C =< $9 -> true; + (_) -> false + end, Cs). + +split(Cs, S) -> + split1(Cs, S, []). + +split1([C|S], Seps, Toks) -> + case lists:member(C, Seps) of + true -> split1(S, Seps, Toks); + false -> split2(S, Seps, Toks, [C]) + end; +split1([], _Seps, Toks) -> + lists:reverse(Toks). + +split2([C|S], Seps, Toks, Cs) -> + case lists:member(C, Seps) of + true -> split1(S, Seps, [lists:reverse(Cs)|Toks]); + false -> split2(S, Seps, Toks, [C|Cs]) + end; +split2([], _Seps, Toks, Cs) -> + lists:reverse([lists:reverse(Cs)|Toks]). + +join([H1, H2| T], S) -> + H1 ++ S ++ join([H2| T], S); +join([H], _) -> + H; +join([], _) -> + []. + +choose([{Name,NumVsn,NewFullName}=New|Bs], Acc, ArchiveExt) -> + case lists:keysearch(Name,1,Acc) of + {value, {_, NV, OldFullName}} when NV =:= NumVsn -> + case filename:extension(OldFullName) =:= ArchiveExt of + false -> + choose(Bs,Acc, ArchiveExt); + true -> + Acc2 = lists:keystore(Name, 1, Acc, New), + choose(Bs,Acc2, ArchiveExt) + end; + {value, {_, _, _}} -> + choose(Bs,Acc, ArchiveExt); + false -> + choose(Bs,[{Name,NumVsn,NewFullName}|Acc], ArchiveExt) + end; +choose([],Acc, _ArchiveExt) -> + Acc. + +make_path(_,[],Res,Bs) -> + {Res,Bs}; +make_path(BundleDir,[Bundle|Tail],Res,Bs) -> + Dir = filename:append(BundleDir,Bundle), + Ebin = filename:append(Dir,"ebin"), + %% First try with /ebin + case erl_prim_loader:read_file_info(Ebin) of + {ok,#file_info{type=directory}} -> + make_path(BundleDir,Tail,[Ebin|Res],[Bundle|Bs]); + _ -> + %% Second try with archive + Ext = archive_extension(), + Base = filename:basename(Dir, Ext), + Ebin2 = filename:join([filename:dirname(Dir), Base ++ Ext, Base, "ebin"]), + Ebins = + case split(Base, "-") of + Toks when length(Toks) > 1 -> + AppName = join(lists:sublist(Toks,length(Toks)-1),"-"), + Ebin3 = filename:join([filename:dirname(Dir), Base ++ Ext, AppName, "ebin"]), + [Ebin3, Ebin2, Dir]; + _ -> + [Ebin2, Dir] + end, + try_ebin_dirs(Ebins,BundleDir,Tail,Res,Bundle, Bs) + end. + +try_ebin_dirs([Ebin | Ebins],BundleDir,Tail,Res,Bundle,Bs) -> + case erl_prim_loader:read_file_info(Ebin) of + {ok,#file_info{type=directory}} -> + make_path(BundleDir,Tail,[Ebin|Res],[Bundle|Bs]); + _ -> + try_ebin_dirs(Ebins,BundleDir,Tail,Res,Bundle,Bs) + end; +try_ebin_dirs([],BundleDir,Tail,Res,_Bundle,Bs) -> + make_path(BundleDir,Tail,Res,Bs). + + +%% +%% Add the erl_prim_loader path. +%% +%% +add_loader_path(IPath0,Mode) -> + {ok,PrimP0} = erl_prim_loader:get_path(), + case Mode of + embedded -> + strip_path(PrimP0, Mode); % i.e. only normalize + _ -> + Pa0 = get_arg(pa), + Pz0 = get_arg(pz), + + Pa = patch_path(Pa0), + Pz = patch_path(Pz0), + PrimP = patch_path(PrimP0), + IPath = patch_path(IPath0), + + P = exclude_pa_pz(PrimP,Pa,Pz), + Path0 = strip_path(P, Mode), + Path = add(Path0, IPath, []), + add_pa_pz(Path,Pa,Pz) + end. + +patch_path(Path) -> + case check_path(Path) of + {ok, NewPath} -> NewPath; + {error, _Reason} -> Path + end. + +%% As the erl_prim_loader path includes the -pa and -pz +%% directories they have to be removed first !! +exclude_pa_pz(P0,Pa,Pz) -> + P1 = excl(Pa, P0), + P = excl(Pz, lists:reverse(P1)), + lists:reverse(P). + +excl([], P) -> + P; +excl([D|Ds], P) -> + excl(Ds, lists:delete(D, P)). + +%% +%% Keep only 'valid' paths in code server. +%% Only if mode is interactive, in an embedded +%% system we can't rely on file. +%% + +strip_path([P0|Ps], Mode) -> + P = filename:join([P0]), % Normalize + case check_path([P]) of + {ok, [NewP]} -> + [NewP|strip_path(Ps, Mode)]; + _ when Mode =:= embedded -> + [P|strip_path(Ps, Mode)]; + _ -> + strip_path(Ps, Mode) + end; +strip_path(_, _) -> + []. + +%% +%% Add only non-existing paths. +%% Also delete other versions of directories, +%% e.g. .../test-3.2/ebin should exclude .../test-*/ebin (and .../test/ebin). +%% Put the Path directories first in resulting path. +%% +add(Path,["."|IPath],Acc) -> + RPath = add1(Path,IPath,Acc), + ["."|lists:delete(".",RPath)]; +add(Path,IPath,Acc) -> + add1(Path,IPath,Acc). + +add1([P|Path],IPath,Acc) -> + case lists:member(P,Acc) of + true -> + add1(Path,IPath,Acc); % Already added + false -> + IPath1 = exclude(P,IPath), + add1(Path,IPath1,[P|Acc]) + end; +add1(_,IPath,Acc) -> + lists:reverse(Acc) ++ IPath. + +add_pa_pz(Path0, Patha, Pathz) -> + {_,Path1} = add_paths(first,Patha,Path0,false), + {_,Path2} = add_paths(first,Pathz,lists:reverse(Path1),false), + lists:reverse(Path2). + +get_arg(Arg) -> + case init:get_argument(Arg) of + {ok, Values} -> + lists:append(Values); + _ -> + [] + end. + +%% +%% Exclude other versions of Dir or duplicates. +%% Return a new Path. +%% +exclude(Dir,Path) -> + Name = get_name(Dir), + [D || D <- Path, + D =/= Dir, + get_name(D) =/= Name]. + +%% +%% Get the "Name" of a directory. A directory in the code server path +%% have the following form: .../Name-Vsn or .../Name +%% where Vsn is any sortable term (the newest directory is sorted as +%% the greatest term). +%% +%% +get_name(Dir) -> + get_name2(get_name1(Dir), []). + +get_name1(Dir) -> + case lists:reverse(filename:split(Dir)) of + ["ebin",DirName|_] -> DirName; + [DirName|_] -> DirName; + _ -> "" % No name ! + end. + +get_name2([$-|_],Acc) -> lists:reverse(Acc); +get_name2([H|T],Acc) -> get_name2(T,[H|Acc]); +get_name2(_,Acc) -> lists:reverse(Acc). + +check_path(Path) -> + PathChoice = init:code_path_choice(), + ArchiveExt = archive_extension(), + do_check_path(Path, PathChoice, ArchiveExt, []). + +do_check_path([], _PathChoice, _ArchiveExt, Acc) -> + {ok, lists:reverse(Acc)}; +do_check_path([Dir | Tail], PathChoice, ArchiveExt, Acc) -> + case catch erl_prim_loader:read_file_info(Dir) of + {ok, #file_info{type=directory}} -> + do_check_path(Tail, PathChoice, ArchiveExt, [Dir | Acc]); + _ when PathChoice =:= strict -> + %% Be strict. Only use dir as explicitly stated + {error, bad_directory}; + _ when PathChoice =:= relaxed -> + %% Be relaxed + case catch lists:reverse(filename:split(Dir)) of + {'EXIT', _} -> + {error, bad_directory}; + ["ebin", App] -> + Dir2 = filename:join([App ++ ArchiveExt, App, "ebin"]), + case erl_prim_loader:read_file_info(Dir2) of + {ok, #file_info{type = directory}} -> + do_check_path(Tail, PathChoice, ArchiveExt, [Dir2 | Acc]); + _ -> + {error, bad_directory} + end; + ["ebin", App, OptArchive | RevTop] -> + Ext = filename:extension(OptArchive), + Base = filename:basename(OptArchive, Ext), + Dir2 = + if + Ext =:= ArchiveExt, Base =:= App -> + %% .../app-vsn.ez/app-vsn/ebin + Top = lists:reverse(RevTop), + filename:join(Top ++ [App, "ebin"]); + Ext =:= ArchiveExt -> + %% .../app-vsn.ez/xxx/ebin + {error, bad_directory}; + true -> + %% .../app-vsn/ebin + Top = lists:reverse([OptArchive | RevTop]), + filename:join(Top ++ [App ++ ArchiveExt, App, "ebin"]) + end, + case erl_prim_loader:read_file_info(Dir2) of + {ok, #file_info{type = directory}} -> + do_check_path(Tail, PathChoice, ArchiveExt, [Dir2 | Acc]); + _ -> + {error, bad_directory} + end; + _ -> + {error, bad_directory} + end + end. + +%% +%% Add new path(s). +%% +add_path(Where,Dir,Path,NameDb) when is_atom(Dir) -> + add_path(Where,atom_to_list(Dir),Path,NameDb); +add_path(Where,Dir0,Path,NameDb) when is_list(Dir0) -> + case int_list(Dir0) of + true -> + Dir = filename:join([Dir0]), % Normalize + case check_path([Dir]) of + {ok, [NewDir]} -> + {true, do_add(Where,NewDir,Path,NameDb)}; + Error -> + {Error, Path} + end; + false -> + {{error, bad_directory}, Path} + end; +add_path(_,_,Path,_) -> + {{error, bad_directory}, Path}. + + +%% +%% If the new directory is added first or if the directory didn't exist +%% the name-directory table must be updated. +%% If NameDb is false we should NOT update NameDb as it is done later +%% then the table is created :-) +%% +do_add(first,Dir,Path,NameDb) -> + update(Dir,NameDb), + [Dir|lists:delete(Dir,Path)]; +do_add(last,Dir,Path,NameDb) -> + case lists:member(Dir,Path) of + true -> + Path; + false -> + maybe_update(Dir,NameDb), + Path ++ [Dir] + end. + +%% Do not update if the same name already exists ! +maybe_update(Dir,NameDb) -> + case lookup_name(get_name(Dir),NameDb) of + false -> update(Dir,NameDb); + _ -> false + end. + +update(_Dir, false) -> + ok; +update(Dir,NameDb) -> + replace_name(Dir,NameDb). + + + +%% +%% Set a completely new path. +%% +set_path(NewPath0, OldPath, NameDb) -> + NewPath = normalize(NewPath0), + case check_path(NewPath) of + {ok, NewPath2} -> + ets:delete(NameDb), + NewDb = init_namedb(NewPath2), + {true, NewPath2, NewDb}; + Error -> + {Error, OldPath, NameDb} + end. + +%% +%% Normalize the given path. +%% The check_path function catches erroneous path, +%% thus it is ignored here. +%% +normalize([P|Path]) when is_atom(P) -> + normalize([atom_to_list(P)|Path]); +normalize([P|Path]) when is_list(P) -> + case int_list(P) of + true -> [filename:join([P])|normalize(Path)]; + false -> [P|normalize(Path)] + end; +normalize([P|Path]) -> + [P|normalize(Path)]; +normalize([]) -> + []; +normalize(Other) -> + Other. + +%% Handle a table of name-directory pairs. +%% The priv_dir/1 and lib_dir/1 functions will have +%% an O(1) lookup. +init_namedb(Path) -> + Db = ets:new(code_names,[private]), + init_namedb(lists:reverse(Path), Db), + Db. + +init_namedb([P|Path], Db) -> + insert_name(P, Db), + init_namedb(Path, Db); +init_namedb([], _) -> + ok. + +-ifdef(NOTUSED). +clear_namedb([P|Path], Db) -> + delete_name_dir(P, Db), + clear_namedb(Path, Db); +clear_namedb([], _) -> + ok. +-endif. + +insert_name(Dir, Db) -> + case get_name(Dir) of + Dir -> false; + Name -> insert_name(Name, Dir, Db) + end. + +insert_name(Name, Dir, Db) -> + AppDir = del_ebin(Dir), + {Base, SubDirs} = archive_subdirs(AppDir), + ets:insert(Db, {Name, AppDir, Base, SubDirs}), + true. + +archive_subdirs(AppDir) -> + IsDir = + fun(RelFile) -> + File = filename:join([AppDir, RelFile]), + case erl_prim_loader:read_file_info(File) of + {ok, #file_info{type = directory}} -> + false; + _ -> + true + end + end, + {Base, ArchiveDirs} = all_archive_subdirs(AppDir), + {Base, lists:filter(IsDir, ArchiveDirs)}. + +all_archive_subdirs(AppDir) -> + Ext = archive_extension(), + Base = filename:basename(AppDir), + Dirs = + case split(Base, "-") of + Toks when length(Toks) > 1 -> + Base2 = join(lists:sublist(Toks,length(Toks)-1),"-"), + [Base2, Base]; + _ -> + [Base] + end, + try_archive_subdirs(AppDir ++ Ext, Base, Dirs). + +try_archive_subdirs(Archive, Base, [Dir | Dirs]) -> + ArchiveDir = filename:join([Archive, Dir]), + case erl_prim_loader:list_dir(ArchiveDir) of + {ok, Files} -> + IsDir = + fun(RelFile) -> + File = filename:join([ArchiveDir, RelFile]), + case erl_prim_loader:read_file_info(File) of + {ok, #file_info{type = directory}} -> + true; + _ -> + false + end + end, + {Dir, lists:filter(IsDir, Files)}; + _ -> + try_archive_subdirs(Archive, Base, Dirs) + end; +try_archive_subdirs(_Archive, Base, []) -> + {Base, []}. + +%% +%% Delete a directory from Path. +%% Name can be either the the name in .../Name[-*] or +%% the complete directory name. +%% +del_path(Name0,Path,NameDb) -> + case catch to_list(Name0)of + {'EXIT',_} -> + {{error,bad_name},Path}; + Name -> + case del_path1(Name,Path,NameDb) of + Path -> % Nothing has changed + {false,Path}; + NewPath -> + {true,NewPath} + end + end. + +del_path1(Name,[P|Path],NameDb) -> + case get_name(P) of + Name -> + delete_name(Name, NameDb), + insert_old_shadowed(Name, Path, NameDb), + Path; + _ when Name =:= P -> + case delete_name_dir(Name, NameDb) of + true -> insert_old_shadowed(get_name(Name), Path, NameDb); + false -> ok + end, + Path; + _ -> + [P|del_path1(Name,Path,NameDb)] + end; +del_path1(_,[],_) -> + []. + +insert_old_shadowed(Name, [P|Path], NameDb) -> + case get_name(P) of + Name -> insert_name(Name, P, NameDb); + _ -> insert_old_shadowed(Name, Path, NameDb) + end; +insert_old_shadowed(_, [], _) -> + ok. + +%% +%% Replace an old occurrence of an directory with name .../Name[-*]. +%% If it does not exist, put the new directory last in Path. +%% +replace_path(Name,Dir,Path,NameDb) -> + case catch check_pars(Name,Dir) of + {ok,N,D} -> + {true,replace_path1(N,D,Path,NameDb)}; + {'EXIT',_} -> + {{error,{badarg,[Name,Dir]}},Path}; + Error -> + {Error,Path} + end. + +replace_path1(Name,Dir,[P|Path],NameDb) -> + case get_name(P) of + Name -> + insert_name(Name, Dir, NameDb), + [Dir|Path]; + _ -> + [P|replace_path1(Name,Dir,Path,NameDb)] + end; +replace_path1(Name, Dir, [], NameDb) -> + insert_name(Name, Dir, NameDb), + [Dir]. + +check_pars(Name,Dir) -> + N = to_list(Name), + D = filename:join([to_list(Dir)]), % Normalize + case get_name(Dir) of + N -> + case check_path([D]) of + {ok, [NewD]} -> + {ok,N,NewD}; + Error -> + Error + end; + _ -> + {error,bad_name} + end. + + +del_ebin(Dir) -> + case filename:basename(Dir) of + "ebin" -> + Dir2 = filename:dirname(Dir), + Dir3 = filename:dirname(Dir2), + Ext = archive_extension(), + case filename:extension(Dir3) of + E when E =:= Ext -> + %% Strip archive extension + filename:join([filename:dirname(Dir3), + filename:basename(Dir3, Ext)]); + _ -> + Dir2 + end; + _ -> + Dir + end. + + + +replace_name(Dir, Db) -> + case get_name(Dir) of + Dir -> + false; + Name -> + delete_name(Name, Db), + insert_name(Name, Dir, Db) + end. + +delete_name(Name, Db) -> + ets:delete(Db, Name). + +delete_name_dir(Dir, Db) -> + case get_name(Dir) of + Dir -> false; + Name -> + Dir0 = del_ebin(Dir), + case lookup_name(Name, Db) of + {ok, Dir0, _Base, _SubDirs} -> + ets:delete(Db, Name), + true; + _ -> false + end + end. + +lookup_name(Name, Db) -> + case ets:lookup(Db, Name) of + [{Name, Dir, Base, SubDirs}] -> {ok, Dir, Base, SubDirs}; + _ -> false + end. + + +%% +%% Fetch a directory. +%% +do_dir(Root,lib_dir,_) -> + filename:append(Root, "lib"); +do_dir(Root,root_dir,_) -> + Root; +do_dir(_Root,compiler_dir,NameDb) -> + case lookup_name("compiler", NameDb) of + {ok, Dir, _Base, _SubDirs} -> Dir; + _ -> "" + end; +do_dir(_Root,{lib_dir,Name},NameDb) -> + case catch lookup_name(to_list(Name), NameDb) of + {ok, Dir, _Base, _SubDirs} -> Dir; + _ -> {error, bad_name} + end; +do_dir(_Root,{lib_dir,Name,SubDir0},NameDb) -> + SubDir = atom_to_list(SubDir0), + case catch lookup_name(to_list(Name), NameDb) of + {ok, Dir, Base, SubDirs} -> + case lists:member(SubDir, SubDirs) of + true -> + %% Subdir is in archive + filename:join([Dir ++ archive_extension(), + Base, + SubDir]); + false -> + %% Subdir is regular directory + filename:join([Dir, SubDir]) + end; + _ -> + {error, bad_name} + end; +do_dir(_Root,{priv_dir,Name},NameDb) -> + do_dir(_Root,{lib_dir,Name,priv},NameDb); +do_dir(_, _, _) -> + 'bad request to code'. + +stick_dir(Dir, Stick, St) -> + case erl_prim_loader:list_dir(Dir) of + {ok,Listing} -> + Mods = get_mods(Listing, objfile_extension()), + Db = St#state.moddb, + case Stick of + true -> + foreach(fun (M) -> ets:insert(Db, {{sticky,M},true}) end, Mods); + false -> + foreach(fun (M) -> ets:delete(Db, {sticky,M}) end, Mods) + end; + Error -> + Error + end. + +stick_mod(M, Stick, St) -> + Db = St#state.moddb, + case Stick of + true -> + ets:insert(Db, {{sticky,M},true}); + false -> + ets:delete(Db, {sticky,M}) + end. + +get_mods([File|Tail], Extension) -> + case filename:extension(File) of + Extension -> + [list_to_atom(filename:basename(File, Extension)) | + get_mods(Tail, Extension)]; + _ -> + get_mods(Tail, Extension) + end; +get_mods([], _) -> []. + +is_sticky(Mod, Db) -> + case erlang:module_loaded(Mod) of + true -> + case ets:lookup(Db, {sticky,Mod}) of + [] -> false; + _ -> true + end; + false -> + false + end. + +add_paths(Where,[Dir|Tail],Path,NameDb) -> + {_,NPath} = add_path(Where,Dir,Path,NameDb), + add_paths(Where,Tail,NPath,NameDb); +add_paths(_,_,Path,_) -> + {ok,Path}. + + +do_load_binary(Module, File, Binary, Caller, St) -> + case modp(Module) andalso modp(File) andalso is_binary(Binary) of + true -> + case erlang:module_loaded(to_atom(Module)) of + true -> do_purge(Module); + false -> ok + end, + try_load_module(File, Module, Binary, Caller, St); + false -> + {reply,{error,badarg},St} + end. + +modp(Atom) when is_atom(Atom) -> true; +modp(List) when is_list(List) -> int_list(List); +modp(_) -> false. + + +load_abs(File, Mod0, Caller, St) -> + Ext = objfile_extension(), + FileName0 = lists:concat([File, Ext]), + FileName = absname(FileName0), + Mod = if Mod0 =:= [] -> + list_to_atom(filename:basename(FileName0, Ext)); + true -> + Mod0 + end, + case erl_prim_loader:get_file(FileName) of + {ok,Bin,_} -> + try_load_module(FileName, Mod, Bin, Caller, St); + error -> + {reply,{error,nofile},St} + end. + +try_load_module(Mod, Dir, Caller, St) -> + File = filename:append(Dir, to_path(Mod) ++ + objfile_extension()), + case erl_prim_loader:get_file(File) of + error -> + {reply,error,St}; + {ok,Binary,FName} -> + try_load_module(absname(FName), Mod, Binary, Caller, St) + end. + +try_load_module(File, Mod, Bin, {From,_}=Caller, St0) -> + M = to_atom(Mod), + case pending_on_load(M, From, St0) of + no -> + try_load_module_1(File, M, Bin, Caller, St0); + {yes,St} -> + {noreply,St} + end. + +try_load_module_1(File, Mod, Bin, Caller, #state{moddb=Db}=St) -> + case is_sticky(Mod, Db) of + true -> %% Sticky file reject the load + error_msg("Can't load module that resides in sticky dir\n",[]), + {reply,{error,sticky_directory},St}; + false -> + case catch load_native_code(Mod, Bin) of + {module,Mod} -> + ets:insert(Db, {Mod,File}), + {reply,{module,Mod},St}; + no_native -> + case erlang:load_module(Mod, Bin) of + {module,Mod} -> + ets:insert(Db, {Mod,File}), + post_beam_load(Mod), + {reply,{module,Mod},St}; + {error,on_load} -> + handle_on_load(Mod, File, Caller, St); + {error,What} -> + error_msg("Loading of ~s failed: ~p\n", [File, What]), + {reply,{error,What},St} + end; + Error -> + error_msg("Native loading of ~s failed: ~p\n", + [File,Error]), + {reply,ok,St} + end + end. + +load_native_code(Mod, Bin) -> + %% During bootstrapping of Open Source Erlang, we don't have any hipe + %% loader modules, but the Erlang emulator might be hipe enabled. + %% Therefore we must test for that the loader modules are available + %% before trying to to load native code. + case erlang:module_loaded(hipe_unified_loader) of + false -> no_native; + true -> hipe_unified_loader:load_native_code(Mod, Bin) + end. + +hipe_result_to_status(Result) -> + case Result of + {module,_} -> Result; + _ -> {error,Result} + end. + +post_beam_load(Mod) -> + case erlang:module_loaded(hipe_unified_loader) of + false -> ok; + true -> hipe_unified_loader:post_beam_load(Mod) + end. + +int_list([H|T]) when is_integer(H) -> int_list(T); +int_list([_|_]) -> false; +int_list([]) -> true. + + +load_file(Mod, Caller, #state{path=Path,cache=no_cache}=St) -> + case mod_to_bin(Path, Mod) of + error -> + {reply,{error,nofile},St}; + {Mod,Binary,File} -> + try_load_module(File, Mod, Binary, Caller, St) + end; +load_file(Mod, Caller, #state{cache=Cache}=St0) -> + Key = {obj,Mod}, + case ets:lookup(Cache, Key) of + [] -> + St = rehash_cache(St0), + case ets:lookup(St#state.cache, Key) of + [] -> + {reply,{error,nofile},St}; + [{Key,Dir}] -> + try_load_module(Mod, Dir, Caller, St) + end; + [{Key,Dir}] -> + try_load_module(Mod, Dir, Caller, St0) + end. + +mod_to_bin([Dir|Tail], Mod) -> + File = filename:append(Dir, to_path(Mod) ++ objfile_extension()), + case erl_prim_loader:get_file(File) of + error -> + mod_to_bin(Tail, Mod); + {ok,Bin,FName} -> + {Mod,Bin,absname(FName)} + end; +mod_to_bin([], Mod) -> + %% At last, try also erl_prim_loader's own method + File = to_path(Mod) ++ objfile_extension(), + case erl_prim_loader:get_file(File) of + error -> + error; % No more alternatives ! + {ok,Bin,FName} -> + {Mod,Bin,absname(FName)} + end. + +absname(File) -> + case erl_prim_loader:get_cwd() of + {ok,Cwd} -> absname(File, Cwd); + _Error -> File + end. + +absname(Name, AbsBase) -> + case filename:pathtype(Name) of + relative -> + filename:absname_join(AbsBase, Name); + absolute -> + %% We must flatten the filename before passing it into join/1, + %% or we will get slashes inserted into the wrong places. + filename:join([filename:flatten(Name)]); + volumerelative -> + absname_vr(filename:split(Name), filename:split(AbsBase), AbsBase) + end. + +%% Handles volumerelative names (on Windows only). + +absname_vr(["/"|Rest1], [Volume|_], _AbsBase) -> + %% Absolute path on current drive. + filename:join([Volume|Rest1]); +absname_vr([[X, $:]|Rest1], [[X|_]|_], AbsBase) -> + %% Relative to current directory on current drive. + absname(filename:join(Rest1), AbsBase); +absname_vr([[X, $:]|Name], _, _AbsBase) -> + %% Relative to current directory on another drive. + Dcwd = + case erl_prim_loader:get_cwd([X, $:]) of + {ok, Dir} -> Dir; + error -> [X, $:, $/] + end, + absname(filename:join(Name), Dcwd). + + +%% do_purge(Module) +%% Kill all processes running code from *old* Module, and then purge the +%% module. Return true if any processes killed, else false. + +do_purge(Mod) -> + do_purge(processes(), to_atom(Mod), false). + +do_purge([P|Ps], Mod, Purged) -> + case erlang:check_process_code(P, Mod) of + true -> + Ref = erlang:monitor(process, P), + exit(P, kill), + receive + {'DOWN',Ref,process,_Pid,_} -> ok + end, + do_purge(Ps, Mod, true); + false -> + do_purge(Ps, Mod, Purged) + end; +do_purge([], Mod, Purged) -> + catch erlang:purge_module(Mod), + Purged. + +%% do_soft_purge(Module) +%% Purge old code only if no procs remain that run old code +%% Return true in that case, false if procs remain (in this +%% case old code is not purged) + +do_soft_purge(Mod) -> + catch do_soft_purge(processes(), Mod). + +do_soft_purge([P|Ps], Mod) -> + case erlang:check_process_code(P, Mod) of + true -> throw(false); + false -> do_soft_purge(Ps, Mod) + end; +do_soft_purge([], Mod) -> + catch erlang:purge_module(Mod), + true. + +is_loaded(M, Db) -> + case ets:lookup(Db, M) of + [{M,File}] -> {file,File}; + [] -> false + end. + +%% ------------------------------------------------------- +%% The on_load functionality. +%% ------------------------------------------------------- + +handle_on_load(Mod, File, {From,_}, #state{on_load=OnLoad0}=St0) -> + Fun = fun() -> + Res = erlang:call_on_load_function(Mod), + exit(Res) + end, + {_,Ref} = spawn_monitor(Fun), + OnLoad = [{Ref,Mod,File,[From]}|OnLoad0], + St = St0#state{on_load=OnLoad}, + {noreply,St}. + +pending_on_load(_, _, #state{on_load=[]}) -> + no; +pending_on_load(Mod, From, #state{on_load=OnLoad0}=St) -> + case lists:keymember(Mod, 2, OnLoad0) of + false -> + no; + true -> + OnLoad = pending_on_load_1(Mod, From, OnLoad0), + {yes,St#state{on_load=OnLoad}} + end. + +pending_on_load_1(Mod, From, [{Ref,Mod,File,Pids}|T]) -> + [{Ref,Mod,File,[From|Pids]}|T]; +pending_on_load_1(Mod, From, [H|T]) -> + [H|pending_on_load_1(Mod, From, T)]; +pending_on_load_1(_, _, []) -> []. + +finish_on_load(Ref, OnLoadRes, #state{on_load=OnLoad0,moddb=Db}=State) -> + case lists:keyfind(Ref, 1, OnLoad0) of + false -> + %% Since this process in general silently ignores messages + %% it doesn't understand, it should also ignore a 'DOWN' + %% message with an unknown reference. + State; + {Ref,Mod,File,WaitingPids} -> + finish_on_load_1(Mod, File, OnLoadRes, WaitingPids, Db), + OnLoad = [E || {R,_,_,_}=E <- OnLoad0, R =/= Ref], + State#state{on_load=OnLoad} + end. + +finish_on_load_1(Mod, File, OnLoadRes, WaitingPids, Db) -> + Keep = if + is_boolean(OnLoadRes) -> OnLoadRes; + true -> false + end, + erlang:finish_after_on_load(Mod, Keep), + Res = case Keep of + false -> {error,on_load_failure}; + true -> + ets:insert(Db, {Mod,File}), + {module,Mod} + end, + [reply(Pid, Res) || Pid <- WaitingPids], + ok. + +%% ------------------------------------------------------- +%% Internal functions. +%% ------------------------------------------------------- + +all_loaded(Db) -> + all_l(Db, ets:slot(Db, 0), 1, []). + +all_l(_Db, '$end_of_table', _, Acc) -> + Acc; +all_l(Db, ModInfo, N, Acc) -> + NewAcc = strip_mod_info(ModInfo,Acc), + all_l(Db, ets:slot(Db, N), N + 1, NewAcc). + + +strip_mod_info([{{sticky,_},_}|T], Acc) -> strip_mod_info(T, Acc); +strip_mod_info([H|T], Acc) -> strip_mod_info(T, [H|Acc]); +strip_mod_info([], Acc) -> Acc. + +% error_msg(Format) -> +% error_msg(Format,[]). +error_msg(Format, Args) -> + Msg = {notify,{error, group_leader(), {self(), Format, Args}}}, + error_logger ! Msg, + ok. + +info_msg(Format, Args) -> + Msg = {notify,{info_msg, group_leader(), {self(), Format, Args}}}, + error_logger ! Msg, + ok. + +objfile_extension() -> + init:objfile_extension(). + +archive_extension() -> + init:archive_extension(). + +to_list(X) when is_list(X) -> X; +to_list(X) when is_atom(X) -> atom_to_list(X). + +to_atom(X) when is_atom(X) -> X; +to_atom(X) when is_list(X) -> list_to_atom(X). + +to_path(X) -> + filename:join(packages:split(X)). diff --git a/lib/kernel/src/disk_log.erl b/lib/kernel/src/disk_log.erl new file mode 100644 index 0000000000..7f1b5f9ec6 --- /dev/null +++ b/lib/kernel/src/disk_log.erl @@ -0,0 +1,1899 @@ +%% +%% %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(disk_log). + +%% Efficient file based log - process part + +-export([start/0, istart_link/1, + log/2, log_terms/2, blog/2, blog_terms/2, + alog/2, alog_terms/2, balog/2, balog_terms/2, + close/1, lclose/1, lclose/2, sync/1, open/1, + truncate/1, truncate/2, btruncate/2, + reopen/2, reopen/3, breopen/3, inc_wrap_file/1, change_size/2, + change_notify/3, change_header/2, + chunk/2, chunk/3, bchunk/2, bchunk/3, chunk_step/3, chunk_info/1, + block/1, block/2, unblock/1, info/1, format_error/1, + accessible_logs/0]). + +%% Internal exports +-export([init/2, internal_open/2, + system_continue/3, system_terminate/4, system_code_change/4]). + +%% To be used by disk_log_h.erl (not (yet) in Erlang/OTP) only. +-export([ll_open/1, ll_close/1, do_log/2, do_sync/1, do_info/2]). + +%% To be used by wrap_log_reader only. +-export([ichunk_end/2]). + +%% To be used for debugging only: +-export([pid2name/1]). + +-type dlog_state_error() :: 'ok' | {'error', term()}. + +-record(state, {queue = [], + messages = [], + parent, + server, + cnt = 0 :: non_neg_integer(), + args, + error_status = ok :: dlog_state_error(), + cache_error = ok %% cache write error after timeout + }). + +-include("disk_log.hrl"). + +-define(failure(Error, Function, Arg), + {{failed, Error}, [{?MODULE, Function, Arg}]}). + +%%-define(PROFILE(C), C). +-define(PROFILE(C), void). + +-compile({inline,[{log_loop,4},{log_end_sync,2},{replies,2},{rflat,1}]}). + +%%%---------------------------------------------------------------------- +%%% Contract type specifications +%%%---------------------------------------------------------------------- + +-type bytes() :: binary() | [byte()]. + +-type log() :: term(). % XXX: refine +-type file_error() :: term(). % XXX: refine +-type invalid_header() :: term(). % XXX: refine + +%%%---------------------------------------------------------------------- +%%% API +%%%---------------------------------------------------------------------- + +%%----------------------------------------------------------------- +%% This module implements the API, and the processes for each log. +%% There is one process per log. +%%----------------------------------------------------------------- + +-type open_error_rsn() :: 'no_such_log' + | {'badarg', term()} + | {'size_mismatch', dlog_size(), dlog_size()} + | {'arg_mismatch', dlog_optattr(), term(), term()} + | {'name_already_open', log()} + | {'open_read_write', log()} + | {'open_read_only', log()} + | {'need_repair', log()} + | {'not_a_log_file', string()} + | {'invalid_index_file', string()} + | {'invalid_header', invalid_header()} + | {'file_error', file:filename(), file_error()} + | {'node_already_open', log()}. +-type dist_error_rsn() :: 'nodedown' | open_error_rsn(). +-type ret() :: {'ok', log()} + | {'repaired', log(), {'recovered', non_neg_integer()}, + {'badbytes', non_neg_integer()}}. +-type open_ret() :: ret() | {'error', open_error_rsn()}. +-type dist_open_ret() :: {[{node(), ret()}], + [{node(), {'error', dist_error_rsn()}}]}. +-type all_open_ret() :: open_ret() | dist_open_ret(). + +-spec open(Args :: dlog_options()) -> all_open_ret(). +open(A) -> + disk_log_server:open(check_arg(A, #arg{options = A})). + +-type log_error_rsn() :: 'no_such_log' | 'nonode' | {'read_only_mode', log()} + | {'format_external', log()} | {'blocked_log', log()} + | {'full', log()} | {'invalid_header', invalid_header()} + | {'file_error', file:filename(), file_error()}. + +-spec log(Log :: log(), Term :: term()) -> 'ok' | {'error', log_error_rsn()}. +log(Log, Term) -> + req(Log, {log, term_to_binary(Term)}). + +-spec blog(Log :: log(), Bytes :: bytes()) -> 'ok' | {'error', log_error_rsn()}. +blog(Log, Bytes) -> + req(Log, {blog, check_bytes(Bytes)}). + +-spec log_terms(Log :: log(), Terms :: [term()]) -> 'ok' | {'error', term()}. +log_terms(Log, Terms) -> + Bs = terms2bins(Terms), + req(Log, {log, Bs}). + +-spec blog_terms(Log :: log(), Bytes :: [bytes()]) -> 'ok' | {'error', term()}. +blog_terms(Log, Bytess) -> + Bs = check_bytes_list(Bytess, Bytess), + req(Log, {blog, Bs}). + +-type notify_ret() :: 'ok' | {'error', 'no_such_log'}. + +-spec alog(Log :: log(), Term :: term()) -> notify_ret(). +alog(Log, Term) -> + notify(Log, {alog, term_to_binary(Term)}). + +-spec alog_terms(Log :: log(), Terms :: [term()]) -> notify_ret(). +alog_terms(Log, Terms) -> + Bs = terms2bins(Terms), + notify(Log, {alog, Bs}). + +-spec balog(Log :: log(), Bytes :: bytes()) -> notify_ret(). +balog(Log, Bytes) -> + notify(Log, {balog, check_bytes(Bytes)}). + +-spec balog_terms(Log :: log(), Bytes :: [bytes()]) -> notify_ret(). +balog_terms(Log, Bytess) -> + Bs = check_bytes_list(Bytess, Bytess), + notify(Log, {balog, Bs}). + +-type close_error_rsn() ::'no_such_log' | 'nonode' + | {'file_error', file:filename(), file_error()}. + +-spec close(Log :: log()) -> 'ok' | {'error', close_error_rsn()}. +close(Log) -> + req(Log, close). + +-type lclose_error_rsn() :: 'no_such_log' + | {'file_error', file:filename(), file_error()}. + +-spec lclose(Log :: log()) -> 'ok' | {'error', lclose_error_rsn()}. +lclose(Log) -> + lclose(Log, node()). + +-spec lclose(Log :: log(), Node :: node()) -> 'ok' | {'error', lclose_error_rsn()}. +lclose(Log, Node) -> + lreq(Log, close, Node). + +-type trunc_error_rsn() :: 'no_such_log' | 'nonode' + | {'read_only_mode', log()} + | {'blocked_log', log()} + | {'invalid_header', invalid_header()} + | {'file_error', file:filename(), file_error()}. + +-spec truncate(Log :: log()) -> 'ok' | {'error', trunc_error_rsn()}. +truncate(Log) -> + req(Log, {truncate, none, truncate, 1}). + +-spec truncate(Log :: log(), Head :: term()) -> 'ok' | {'error', trunc_error_rsn()}. +truncate(Log, Head) -> + req(Log, {truncate, {ok, term_to_binary(Head)}, truncate, 2}). + +-spec btruncate(Log :: log(), Head :: bytes()) -> 'ok' | {'error', trunc_error_rsn()}. +btruncate(Log, Head) -> + req(Log, {truncate, {ok, check_bytes(Head)}, btruncate, 2}). + +-spec reopen(Log :: log(), Filename :: file:filename()) -> 'ok' | {'error', term()}. +reopen(Log, NewFile) -> + req(Log, {reopen, NewFile, none, reopen, 2}). + +-spec reopen(Log :: log(), Filename :: file:filename(), Head :: term()) -> + 'ok' | {'error', term()}. +reopen(Log, NewFile, NewHead) -> + req(Log, {reopen, NewFile, {ok, term_to_binary(NewHead)}, reopen, 3}). + +-spec breopen(Log :: log(), Filename :: file:filename(), Head :: bytes()) -> + 'ok' | {'error', term()}. +breopen(Log, NewFile, NewHead) -> + req(Log, {reopen, NewFile, {ok, check_bytes(NewHead)}, breopen, 3}). + +-type inc_wrap_error_rsn() :: 'no_such_log' | 'nonode' + | {'read_only_mode', log()} + | {'blocked_log', log()} | {'halt_log', log()} + | {'invalid_header', invalid_header()} + | {'file_error', file:filename(), file_error()}. + +-spec inc_wrap_file(Log :: log()) -> 'ok' | {'error', inc_wrap_error_rsn()}. +inc_wrap_file(Log) -> + req(Log, inc_wrap_file). + +-spec change_size(Log :: log(), Size :: dlog_size()) -> 'ok' | {'error', term()}. +change_size(Log, NewSize) -> + req(Log, {change_size, NewSize}). + +-spec change_notify(Log :: log(), Pid :: pid(), Notify :: boolean()) -> + 'ok' | {'error', term()}. +change_notify(Log, Pid, NewNotify) -> + req(Log, {change_notify, Pid, NewNotify}). + +-spec change_header(Log :: log(), Head :: {atom(), term()}) -> + 'ok' | {'error', term()}. +change_header(Log, NewHead) -> + req(Log, {change_header, NewHead}). + +-type sync_error_rsn() :: 'no_such_log' | 'nonode' | {'read_only_mode', log()} + | {'blocked_log', log()} + | {'file_error', file:filename(), file_error()}. + +-spec sync(Log :: log()) -> 'ok' | {'error', sync_error_rsn()}. +sync(Log) -> + req(Log, sync). + +-type block_error_rsn() :: 'no_such_log' | 'nonode' | {'blocked_log', log()}. + +-spec block(Log :: log()) -> 'ok' | {'error', block_error_rsn()}. +block(Log) -> + block(Log, true). + +-spec block(Log :: log(), QueueLogRecords :: boolean()) -> 'ok' | {'error', term()}. +block(Log, QueueLogRecords) -> + req(Log, {block, QueueLogRecords}). + +-type unblock_error_rsn() :: 'no_such_log' | 'nonode' + | {'not_blocked', log()} + | {'not_blocked_by_pid', log()}. + +-spec unblock(Log :: log()) -> 'ok' | {'error', unblock_error_rsn()}. +unblock(Log) -> + req(Log, unblock). + +-spec format_error(Error :: term()) -> string(). +format_error(Error) -> + do_format_error(Error). + +-spec info(Log :: log()) -> [{atom(), any()}] | {'error', term()}. +info(Log) -> + sreq(Log, info). + +-spec pid2name(Pid :: pid()) -> {'ok', log()} | 'undefined'. +pid2name(Pid) -> + disk_log_server:start(), + case ets:lookup(?DISK_LOG_PID_TABLE, Pid) of + [] -> undefined; + [{_Pid, Log}] -> {ok, Log} + end. + +%% This function Takes 3 args, a Log, a Continuation and N. +%% It retuns a {Cont2, ObjList} | eof | {error, Reason} +%% The initial continuation is the atom 'start' + +-spec chunk(Log :: log(), Cont :: any()) -> + {'error', term()} | 'eof' | {any(), [any()]} | {any(), [any()], integer()}. +chunk(Log, Cont) -> + chunk(Log, Cont, infinity). + +-spec chunk(Log :: log(), Cont :: any(), N :: pos_integer() | 'infinity') -> + {'error', term()} | 'eof' | {any(), [any()]} | {any(), [any()], integer()}. +chunk(Log, Cont, infinity) -> + %% There cannot be more than ?MAX_CHUNK_SIZE terms in a chunk. + ichunk(Log, Cont, ?MAX_CHUNK_SIZE); +chunk(Log, Cont, N) when is_integer(N), N > 0 -> + ichunk(Log, Cont, N). + +ichunk(Log, start, N) -> + R = sreq(Log, {chunk, 0, [], N}), + ichunk_end(R, Log); +ichunk(Log, More, N) when is_record(More, continuation) -> + R = req2(More#continuation.pid, + {chunk, More#continuation.pos, More#continuation.b, N}), + ichunk_end(R, Log); +ichunk(_Log, _, _) -> + {error, {badarg, continuation}}. + +ichunk_end({C, R}, Log) when is_record(C, continuation) -> + ichunk_end(R, read_write, Log, C, 0); +ichunk_end({C, R, Bad}, Log) when is_record(C, continuation) -> + ichunk_end(R, read_only, Log, C, Bad); +ichunk_end(R, _Log) -> + R. + +%% Create the terms on the client's heap, not the server's. +%% The list of binaries is reversed. +ichunk_end(R, Mode, Log, C, Bad) -> + case catch bins2terms(R, []) of + {'EXIT', _} -> + RR = lists:reverse(R), + ichunk_bad_end(RR, Mode, Log, C, Bad, []); + Ts when Bad > 0 -> + {C, Ts, Bad}; + Ts when Bad =:= 0 -> + {C, Ts} + end. + +bins2terms([], L) -> + L; +bins2terms([B | Bs], L) -> + bins2terms(Bs, [binary_to_term(B) | L]). + +ichunk_bad_end([B | Bs], Mode, Log, C, Bad, A) -> + case catch binary_to_term(B) of + {'EXIT', _} when read_write =:= Mode -> + InfoList = info(Log), + {value, {file, FileName}} = lists:keysearch(file, 1, InfoList), + File = case C#continuation.pos of + Pos when is_integer(Pos) -> FileName; % halt log + {FileNo, _} -> add_ext(FileName, FileNo) % wrap log + end, + {error, {corrupt_log_file, File}}; + {'EXIT', _} when read_only =:= Mode -> + Reread = lists:foldl(fun(Bin, Sz) -> + Sz + byte_size(Bin) + ?HEADERSZ + end, 0, Bs), + NewPos = case C#continuation.pos of + Pos when is_integer(Pos) -> Pos-Reread; + {FileNo, Pos} -> {FileNo, Pos-Reread} + end, + NewBad = Bad + byte_size(B), + {C#continuation{pos = NewPos, b = []}, lists:reverse(A), NewBad}; + T -> + ichunk_bad_end(Bs, Mode, Log, C, Bad, [T | A]) + end. + +-spec bchunk(Log :: log(), Cont :: any()) -> + {'error', any()} | 'eof' | {any(), [binary()]} | {any(), [binary()], integer()}. +bchunk(Log, Cont) -> + bchunk(Log, Cont, infinity). + +-spec bchunk(Log :: log(), Cont :: any(), N :: 'infinity' | pos_integer()) -> + {'error', any()} | 'eof' | {any(), [binary()]} | {any(), [binary()], integer()}. +bchunk(Log, Cont, infinity) -> + %% There cannot be more than ?MAX_CHUNK_SIZE terms in a chunk. + bichunk(Log, Cont, ?MAX_CHUNK_SIZE); +bchunk(Log, Cont, N) when is_integer(N), N > 0 -> + bichunk(Log, Cont, N). + +bichunk(Log, start, N) -> + R = sreq(Log, {chunk, 0, [], N}), + bichunk_end(R); +bichunk(_Log, #continuation{pid = Pid, pos = Pos, b = B}, N) -> + R = req2(Pid, {chunk, Pos, B, N}), + bichunk_end(R); +bichunk(_Log, _, _) -> + {error, {badarg, continuation}}. + +bichunk_end({C = #continuation{}, R}) -> + {C, lists:reverse(R)}; +bichunk_end({C = #continuation{}, R, Bad}) -> + {C, lists:reverse(R), Bad}; +bichunk_end(R) -> + R. + +-spec chunk_step(Log :: log(), Cont :: any(), N :: integer()) -> + {'ok', any()} | {'error', term()}. +chunk_step(Log, Cont, N) when is_integer(N) -> + ichunk_step(Log, Cont, N). + +ichunk_step(Log, start, N) -> + sreq(Log, {chunk_step, 0, N}); +ichunk_step(_Log, More, N) when is_record(More, continuation) -> + req2(More#continuation.pid, {chunk_step, More#continuation.pos, N}); +ichunk_step(_Log, _, _) -> + {error, {badarg, continuation}}. + +-spec chunk_info(More :: any()) -> + [{'node', node()},...] | {'error', {'no_continuation', any()}}. +chunk_info(More = #continuation{}) -> + [{node, node(More#continuation.pid)}]; +chunk_info(BadCont) -> + {error, {no_continuation, BadCont}}. + +-spec accessible_logs() -> {[_], [_]}. +accessible_logs() -> + disk_log_server:accessible_logs(). + +istart_link(Server) -> + {ok, proc_lib:spawn_link(disk_log, init, [self(), Server])}. + +%% Only for backwards compatibility, could probably be removed. +-spec start() -> 'ok'. +start() -> + disk_log_server:start(). + +internal_open(Pid, A) -> + req2(Pid, {internal_open, A}). + +%%% ll_open() and ll_close() are used by disk_log_h.erl, a module not +%%% (yet) in Erlang/OTP. + +%% -spec ll_open(dlog_options()) -> {'ok', Res :: _, #log{}, Cnt :: _} | Error. +ll_open(A) -> + case check_arg(A, #arg{options = A}) of + {ok, L} -> do_open(L); + Error -> Error + end. + +%% -> closed | throw(Error) +ll_close(Log) -> + close_disk_log2(Log). + +check_arg([], Res) -> + Ret = case Res#arg.head of + none -> + {ok, Res}; + _ -> + case check_head(Res#arg.head, Res#arg.format) of + {ok, Head} -> + {ok, Res#arg{head = Head}}; + Error -> + Error + end + end, + + if %% check result + Res#arg.name =:= 0 -> + {error, {badarg, name}}; + Res#arg.file =:= none -> + case catch lists:concat([Res#arg.name, ".LOG"]) of + {'EXIT',_} -> {error, {badarg, file}}; + FName -> check_arg([], Res#arg{file = FName}) + end; + Res#arg.repair =:= truncate, Res#arg.mode =:= read_only -> + {error, {badarg, repair_read_only}}; + Res#arg.type =:= halt, is_tuple(Res#arg.size) -> + {error, {badarg, size}}; + Res#arg.type =:= wrap -> + {OldSize, Version} = + disk_log_1:read_size_file_version(Res#arg.file), + check_wrap_arg(Ret, OldSize, Version); + true -> + Ret + end; +check_arg([{file, F} | Tail], Res) when is_list(F) -> + check_arg(Tail, Res#arg{file = F}); +check_arg([{file, F} | Tail], Res) when is_atom(F) -> + check_arg(Tail, Res#arg{file = F}); +check_arg([{linkto, Pid} |Tail], Res) when is_pid(Pid) -> + check_arg(Tail, Res#arg{linkto = Pid}); +check_arg([{linkto, none} |Tail], Res) -> + check_arg(Tail, Res#arg{linkto = none}); +check_arg([{name, Name}|Tail], Res) -> + check_arg(Tail, Res#arg{name = Name}); +check_arg([{repair, true}|Tail], Res) -> + check_arg(Tail, Res#arg{repair = true}); +check_arg([{repair, false}|Tail], Res) -> + check_arg(Tail, Res#arg{repair = false}); +check_arg([{repair, truncate}|Tail], Res) -> + check_arg(Tail, Res#arg{repair = truncate}); +check_arg([{size, Int}|Tail], Res) when is_integer(Int), Int > 0 -> + check_arg(Tail, Res#arg{size = Int}); +check_arg([{size, infinity}|Tail], Res) -> + check_arg(Tail, Res#arg{size = infinity}); +check_arg([{size, {MaxB,MaxF}}|Tail], Res) when is_integer(MaxB), + is_integer(MaxF), + MaxB > 0, MaxB =< ?MAX_BYTES, + MaxF > 0, MaxF < ?MAX_FILES -> + check_arg(Tail, Res#arg{size = {MaxB, MaxF}}); +check_arg([{type, wrap}|Tail], Res) -> + check_arg(Tail, Res#arg{type = wrap}); +check_arg([{type, halt}|Tail], Res) -> + check_arg(Tail, Res#arg{type = halt}); +check_arg([{format, internal}|Tail], Res) -> + check_arg(Tail, Res#arg{format = internal}); +check_arg([{format, external}|Tail], Res) -> + check_arg(Tail, Res#arg{format = external}); +check_arg([{distributed, []}|Tail], Res) -> + check_arg(Tail, Res#arg{distributed = false}); +check_arg([{distributed, Nodes}|Tail], Res) when is_list(Nodes) -> + check_arg(Tail, Res#arg{distributed = {true, Nodes}}); +check_arg([{notify, true}|Tail], Res) -> + check_arg(Tail, Res#arg{notify = true}); +check_arg([{notify, false}|Tail], Res) -> + check_arg(Tail, Res#arg{notify = false}); +check_arg([{head_func, HeadFunc}|Tail], Res) -> + check_arg(Tail, Res#arg{head = {head_func, HeadFunc}}); +check_arg([{head, Term}|Tail], Res) -> + check_arg(Tail, Res#arg{head = {head, Term}}); +check_arg([{mode, read_only}|Tail], Res) -> + check_arg(Tail, Res#arg{mode = read_only}); +check_arg([{mode, read_write}|Tail], Res) -> + check_arg(Tail, Res#arg{mode = read_write}); +check_arg(Arg, _) -> + {error, {badarg, Arg}}. + +check_wrap_arg({ok, Res}, {0,0}, _Version) when Res#arg.size =:= infinity -> + {error, {badarg, size}}; +check_wrap_arg({ok, Res}, OldSize, Version) when Res#arg.size =:= infinity -> + NewRes = Res#arg{size = OldSize}, + check_wrap_arg({ok, NewRes}, OldSize, Version); +check_wrap_arg({ok, Res}, {0,0}, Version) -> + {ok, Res#arg{version = Version}}; +check_wrap_arg({ok, Res}, OldSize, Version) when OldSize =:= Res#arg.size -> + {ok, Res#arg{version = Version}}; +check_wrap_arg({ok, Res}, _OldSize, Version) when Res#arg.repair =:= truncate, + is_tuple(Res#arg.size) -> + {ok, Res#arg{version = Version}}; +check_wrap_arg({ok, Res}, OldSize, _Version) when is_tuple(Res#arg.size) -> + {error, {size_mismatch, OldSize, Res#arg.size}}; +check_wrap_arg({ok, _Res}, _OldSize, _Version) -> + {error, {badarg, size}}; +check_wrap_arg(Ret, _OldSize, _Version) -> + Ret. + +%%%----------------------------------------------------------------- +%%% Server functions +%%%----------------------------------------------------------------- +init(Parent, Server) -> + ?PROFILE(ep:do()), + process_flag(trap_exit, true), + loop(#state{parent = Parent, server = Server}). + +loop(State) when State#state.messages =:= [] -> + receive + Message -> + handle(Message, State) + end; +loop(State) -> + [M | Ms] = State#state.messages, + handle(M, State#state{messages = Ms}). + +handle({From, write_cache}, S) when From =:= self() -> + case catch do_write_cache(get(log)) of + ok -> + loop(S); + Error -> + loop(S#state{cache_error = Error}) + end; +handle({From, {log, B}}, S) -> + case get(log) of + L when L#log.mode =:= read_only -> + reply(From, {error, {read_only_mode, L#log.name}}, S); + L when L#log.status =:= ok, L#log.format =:= internal -> + log_loop(S, From, [B], []); + L when L#log.status =:= ok, L#log.format =:= external -> + reply(From, {error, {format_external, L#log.name}}, S); + L when L#log.status =:= {blocked, false} -> + reply(From, {error, {blocked_log, L#log.name}}, S); + L when L#log.blocked_by =:= From -> + reply(From, {error, {blocked_log, L#log.name}}, S); + _ -> + loop(S#state{queue = [{From, {log, B}} | S#state.queue]}) + end; +handle({From, {blog, B}}, S) -> + case get(log) of + L when L#log.mode =:= read_only -> + reply(From, {error, {read_only_mode, L#log.name}}, S); + L when L#log.status =:= ok -> + log_loop(S, From, [B], []); + L when L#log.status =:= {blocked, false} -> + reply(From, {error, {blocked_log, L#log.name}}, S); + L when L#log.blocked_by =:= From -> + reply(From, {error, {blocked_log, L#log.name}}, S); + _ -> + loop(S#state{queue = [{From, {blog, B}} | S#state.queue]}) + end; +handle({alog, B}, S) -> + case get(log) of + L when L#log.mode =:= read_only -> + notify_owners({read_only,B}), + loop(S); + L when L#log.status =:= ok, L#log.format =:= internal -> + log_loop(S, [], [B], []); + L when L#log.status =:= ok -> + notify_owners({format_external, B}), + loop(S); + L when L#log.status =:= {blocked, false} -> + notify_owners({blocked_log, B}), + loop(S); + _ -> + loop(S#state{queue = [{alog, B} | S#state.queue]}) + end; +handle({balog, B}, S) -> + case get(log) of + L when L#log.mode =:= read_only -> + notify_owners({read_only,B}), + loop(S); + L when L#log.status =:= ok -> + log_loop(S, [], [B], []); + L when L#log.status =:= {blocked, false} -> + notify_owners({blocked_log, B}), + loop(S); + _ -> + loop(S#state{queue = [{balog, B} | S#state.queue]}) + end; +handle({From, {block, QueueLogRecs}}, S) -> + case get(log) of + L when L#log.status =:= ok -> + do_block(From, QueueLogRecs, L), + reply(From, ok, S); + L when L#log.status =:= {blocked, false} -> + reply(From, {error, {blocked_log, L#log.name}}, S); + L when L#log.blocked_by =:= From -> + reply(From, {error, {blocked_log, L#log.name}}, S); + _ -> + loop(S#state{queue = [{From, {block, QueueLogRecs}} | + S#state.queue]}) + end; +handle({From, unblock}, S) -> + case get(log) of + L when L#log.status =:= ok -> + reply(From, {error, {not_blocked, L#log.name}}, S); + L when L#log.blocked_by =:= From -> + S2 = do_unblock(L, S), + reply(From, ok, S2); + L -> + reply(From, {error, {not_blocked_by_pid, L#log.name}}, S) + end; +handle({From, sync}, S) -> + case get(log) of + L when L#log.mode =:= read_only -> + reply(From, {error, {read_only_mode, L#log.name}}, S); + L when L#log.status =:= ok -> + sync_loop([From], S); + L when L#log.status =:= {blocked, false} -> + reply(From, {error, {blocked_log, L#log.name}}, S); + L when L#log.blocked_by =:= From -> + reply(From, {error, {blocked_log, L#log.name}}, S); + _ -> + loop(S#state{queue = [{From, sync} | S#state.queue]}) + end; +handle({From, {truncate, Head, F, A}}, S) -> + case get(log) of + L when L#log.mode =:= read_only -> + reply(From, {error, {read_only_mode, L#log.name}}, S); + L when L#log.status =:= ok, S#state.cache_error =/= ok -> + loop(cache_error(S, [From])); + L when L#log.status =:= ok -> + H = merge_head(Head, L#log.head), + case catch do_trunc(L, H) of + ok -> + erase(is_full), + notify_owners({truncated, S#state.cnt}), + N = if Head =:= none -> 0; true -> 1 end, + reply(From, ok, (state_ok(S))#state{cnt = N}); + Error -> + do_exit(S, From, Error, ?failure(Error, F, A)) + end; + L when L#log.status =:= {blocked, false} -> + reply(From, {error, {blocked_log, L#log.name}}, S); + L when L#log.blocked_by =:= From -> + reply(From, {error, {blocked_log, L#log.name}}, S); + _ -> + loop(S#state{queue = [{From, {truncate, Head, F, A}} + | S#state.queue]}) + end; +handle({From, {chunk, Pos, B, N}}, S) -> + case get(log) of + L when L#log.status =:= ok, S#state.cache_error =/= ok -> + loop(cache_error(S, [From])); + L when L#log.status =:= ok -> + R = do_chunk(L, Pos, B, N), + reply(From, R, S); + L when L#log.blocked_by =:= From -> + R = do_chunk(L, Pos, B, N), + reply(From, R, S); + L when L#log.status =:= {blocked, false} -> + reply(From, {error, {blocked_log, L#log.name}}, S); + _L -> + loop(S#state{queue = [{From, {chunk, Pos, B, N}} | S#state.queue]}) + end; +handle({From, {chunk_step, Pos, N}}, S) -> + case get(log) of + L when L#log.status =:= ok, S#state.cache_error =/= ok -> + loop(cache_error(S, [From])); + L when L#log.status =:= ok -> + R = do_chunk_step(L, Pos, N), + reply(From, R, S); + L when L#log.blocked_by =:= From -> + R = do_chunk_step(L, Pos, N), + reply(From, R, S); + L when L#log.status =:= {blocked, false} -> + reply(From, {error, {blocked_log, L#log.name}}, S); + _ -> + loop(S#state{queue = [{From, {chunk_step, Pos, N}} + | S#state.queue]}) + end; +handle({From, {change_notify, Pid, NewNotify}}, S) -> + case get(log) of + L when L#log.status =:= ok -> + case do_change_notify(L, Pid, NewNotify) of + {ok, L1} -> + put(log, L1), + reply(From, ok, S); + Error -> + reply(From, Error, S) + end; + L when L#log.status =:= {blocked, false} -> + reply(From, {error, {blocked_log, L#log.name}}, S); + L when L#log.blocked_by =:= From -> + reply(From, {error, {blocked_log, L#log.name}}, S); + _ -> + loop(S#state{queue = [{From, {change_notify, Pid, NewNotify}} + | S#state.queue]}) + end; +handle({From, {change_header, NewHead}}, S) -> + case get(log) of + L when L#log.mode =:= read_only -> + reply(From, {error, {read_only_mode, L#log.name}}, S); + L when L#log.status =:= ok -> + case check_head(NewHead, L#log.format) of + {ok, Head} -> + put(log, L#log{head = mk_head(Head, L#log.format)}), + reply(From, ok, S); + Error -> + reply(From, Error, S) + end; + L when L#log.status =:= {blocked, false} -> + reply(From, {error, {blocked_log, L#log.name}}, S); + L when L#log.blocked_by =:= From -> + reply(From, {error, {blocked_log, L#log.name}}, S); + _ -> + loop(S#state{queue = [{From, {change_header, NewHead}} + | S#state.queue]}) + end; +handle({From, {change_size, NewSize}}, S) -> + case get(log) of + L when L#log.mode =:= read_only -> + reply(From, {error, {read_only_mode, L#log.name}}, S); + L when L#log.status =:= ok -> + case check_size(L#log.type, NewSize) of + ok -> + case catch do_change_size(L, NewSize) of % does the put + ok -> + reply(From, ok, S); + {big, CurSize} -> + reply(From, + {error, + {new_size_too_small, L#log.name, CurSize}}, + S); + Else -> + reply(From, Else, state_err(S, Else)) + end; + not_ok -> + reply(From, {error, {badarg, size}}, S) + end; + L when L#log.status =:= {blocked, false} -> + reply(From, {error, {blocked_log, L#log.name}}, S); + L when L#log.blocked_by =:= From -> + reply(From, {error, {blocked_log, L#log.name}}, S); + _ -> + loop(S#state{queue = [{From, {change_size, NewSize}} + | S#state.queue]}) + end; +handle({From, inc_wrap_file}, S) -> + case get(log) of + L when L#log.mode =:= read_only -> + reply(From, {error, {read_only_mode, L#log.name}}, S); + L when L#log.type =:= halt -> + reply(From, {error, {halt_log, L#log.name}}, S); + L when L#log.status =:= ok, S#state.cache_error =/= ok -> + loop(cache_error(S, [From])); + L when L#log.status =:= ok -> + case catch do_inc_wrap_file(L) of + {ok, L2, Lost} -> + put(log, L2), + notify_owners({wrap, Lost}), + reply(From, ok, S#state{cnt = S#state.cnt-Lost}); + {error, Error, L2} -> + put(log, L2), + reply(From, Error, state_err(S, Error)) + end; + L when L#log.status =:= {blocked, false} -> + reply(From, {error, {blocked_log, L#log.name}}, S); + L when L#log.blocked_by =:= From -> + reply(From, {error, {blocked_log, L#log.name}}, S); + _ -> + loop(S#state{queue = [{From, inc_wrap_file} | S#state.queue]}) + end; +handle({From, {reopen, NewFile, Head, F, A}}, S) -> + case get(log) of + L when L#log.mode =:= read_only -> + reply(From, {error, {read_only_mode, L#log.name}}, S); + L when L#log.status =:= ok, S#state.cache_error =/= ok -> + loop(cache_error(S, [From])); + L when L#log.status =:= ok, L#log.filename =/= NewFile -> + case catch close_disk_log2(L) of + closed -> + File = L#log.filename, + case catch rename_file(File, NewFile, L#log.type) of + ok -> + H = merge_head(Head, L#log.head), + case do_open((S#state.args)#arg{name = L#log.name, + repair = truncate, + head = H, + file = File}) of + {ok, Res, L2, Cnt} -> + put(log, L2#log{owners = L#log.owners, + head = L#log.head, + users = L#log.users}), + notify_owners({truncated, S#state.cnt}), + erase(is_full), + case Res of + {error, _} -> + do_exit(S, From, Res, + ?failure(Res, F, A)); + _ -> + reply(From, ok, S#state{cnt = Cnt}) + end; + Res -> + do_exit(S, From, Res, ?failure(Res, F, A)) + end; + Error -> + do_exit(S, From, Error, ?failure(Error, reopen, 2)) + end; + Error -> + do_exit(S, From, Error, ?failure(Error, F, A)) + end; + L when L#log.status =:= ok -> + reply(From, {error, {same_file_name, L#log.name}}, S); + L -> + reply(From, {error, {blocked_log, L#log.name}}, S) + end; +handle({Server, {internal_open, A}}, S) -> + case get(log) of + undefined -> + case do_open(A) of % does the put + {ok, Res, L, Cnt} -> + put(log, opening_pid(A#arg.linkto, A#arg.notify, L)), + reply(Server, Res, S#state{args=A, cnt=Cnt}); + Res -> + do_fast_exit(S, Server, Res) + end; + L -> + TestH = mk_head(A#arg.head, A#arg.format), + case compare_arg(A#arg.options, S#state.args, TestH, L#log.head) of + ok -> + case add_pid(A#arg.linkto, A#arg.notify, L) of + {ok, L1} -> + put(log, L1), + reply(Server, {ok, L#log.name}, S); + Error -> + reply(Server, Error, S) + end; + Error -> + reply(Server, Error, S) + end + end; +handle({From, close}, S) -> + case do_close(From, S) of + {stop, S1} -> + do_exit(S1, From, ok, normal); + {continue, S1} -> + reply(From, ok, S1) + end; +handle({From, info}, S) -> + reply(From, do_info(get(log), S#state.cnt), S); +handle({'EXIT', From, Reason}, S) when From =:= S#state.parent -> + %% Parent orders shutdown. + _ = do_stop(S), + exit(Reason); +handle({'EXIT', From, Reason}, S) when From =:= S#state.server -> + %% The server is gone. + _ = do_stop(S), + exit(Reason); +handle({'EXIT', From, _Reason}, S) -> + L = get(log), + case is_owner(From, L) of + {true, _Notify} -> + case close_owner(From, L, S) of + {stop, S1} -> + _ = do_stop(S1), + exit(normal); + {continue, S1} -> + loop(S1) + end; + false -> + %% 'users' is not decremented. + S1 = do_unblock(From, get(log), S), + loop(S1) + end; +handle({system, From, Req}, S) -> + sys:handle_system_msg(Req, From, S#state.parent, ?MODULE, [], S); +handle(_, S) -> + loop(S). + +sync_loop(From, S) -> + log_loop(S, [], [], From). + +%% Inlined. +log_loop(S, Pids, _Bins, _Sync) when S#state.cache_error =/= ok -> + loop(cache_error(S, Pids)); +log_loop(S, Pids, Bins, Sync) when S#state.messages =:= [] -> + receive + Message -> + log_loop(Message, Pids, Bins, Sync, S, get(log)) + after 0 -> + loop(log_end(S, Pids, Bins, Sync)) + end; +log_loop(S, Pids, Bins, Sync) -> + [M | Ms] = S#state.messages, + S1 = S#state{messages = Ms}, + log_loop(M, Pids, Bins, Sync, S1, get(log)). + +%% Items logged after the last sync request found are sync:ed as well. +log_loop({alog,B}, Pids, Bins, Sync, S, L) when L#log.format =:= internal -> + %% {alog, _} allowed for the internal format only. + log_loop(S, Pids, [B | Bins], Sync); +log_loop({balog, B}, Pids, Bins, Sync, S, _L) -> + log_loop(S, Pids, [B | Bins], Sync); +log_loop({From, {log, B}}, Pids, Bins, Sync, S, L) + when L#log.format =:= internal -> + %% {log, _} allowed for the internal format only. + log_loop(S, [From | Pids], [B | Bins], Sync); +log_loop({From, {blog, B}}, Pids, Bins, Sync, S, _L) -> + log_loop(S, [From | Pids], [B | Bins], Sync); +log_loop({From, sync}, Pids, Bins, Sync, S, _L) -> + log_loop(S, Pids, Bins, [From | Sync]); +log_loop(Message, Pids, Bins, Sync, S, _L) -> + NS = log_end(S, Pids, Bins, Sync), + handle(Message, NS). + +log_end(S, [], [], Sync) -> + log_end_sync(S, Sync); +log_end(S, Pids, Bins, Sync) -> + case do_log(get(log), rflat(Bins)) of + N when is_integer(N) -> + replies(Pids, ok), + S1 = (state_ok(S))#state{cnt = S#state.cnt+N}, + log_end_sync(S1, Sync); + {error, {error, {full, _Name}}, N} when Pids =:= [] -> + log_end_sync(state_ok(S#state{cnt = S#state.cnt + N}), Sync); + {error, Error, N} -> + replies(Pids, Error), + state_err(S#state{cnt = S#state.cnt + N}, Error) + end. + +%% Inlined. +log_end_sync(S, []) -> + S; +log_end_sync(S, Sync) -> + Res = do_sync(get(log)), + replies(Sync, Res), + state_err(S, Res). + +%% Inlined. +rflat([B]=L) when is_binary(B) -> L; +rflat([B]) -> B; +rflat(B) -> rflat(B, []). + +rflat([B | Bs], L) when is_binary(B) -> + rflat(Bs, [B | L]); +rflat([B | Bs], L) -> + rflat(Bs, B ++ L); +rflat([], L) -> L. + +%% -> {ok, Log} | {error, Error} +do_change_notify(L, Pid, Notify) -> + case is_owner(Pid, L) of + {true, Notify} -> + {ok, L}; + {true, _OldNotify} when Notify =/= true, Notify =/= false -> + {error, {badarg, notify}}; + {true, _OldNotify} -> + Owners = lists:keydelete(Pid, 1, L#log.owners), + L1 = L#log{owners = [{Pid, Notify} | Owners]}, + {ok, L1}; + false -> + {error, {not_owner, Pid}} + end. + +%% -> {stop, S} | {continue, S} +do_close(Pid, S) -> + L = get(log), + case is_owner(Pid, L) of + {true, _Notify} -> + close_owner(Pid, L, S); + false -> + close_user(Pid, L, S) + end. + +%% -> {stop, S} | {continue, S} +close_owner(Pid, L, S) -> + L1 = L#log{owners = lists:keydelete(Pid, 1, L#log.owners)}, + put(log, L1), + S2 = do_unblock(Pid, get(log), S), + unlink(Pid), + do_close2(L1, S2). + +%% -> {stop, S} | {continue, S} +close_user(Pid, L, S) when L#log.users > 0 -> + L1 = L#log{users = L#log.users - 1}, + put(log, L1), + S2 = do_unblock(Pid, get(log), S), + do_close2(L1, S2); +close_user(_Pid, _L, S) -> + {continue, S}. + +do_close2(L, S) when L#log.users =:= 0, L#log.owners =:= [] -> + {stop, S}; +do_close2(_L, S) -> + {continue, S}. + +%%----------------------------------------------------------------- +%% Callback functions for system messages handling. +%%----------------------------------------------------------------- +system_continue(_Parent, _, State) -> + loop(State). + +-spec system_terminate(_, _, _, #state{}) -> no_return(). +system_terminate(Reason, _Parent, _, State) -> + _ = do_stop(State), + exit(Reason). + +%%----------------------------------------------------------------- +%% Temporay code for upgrade. +%%----------------------------------------------------------------- +system_code_change(State, _Module, _OldVsn, _Extra) -> + {ok, State}. + + +%%%---------------------------------------------------------------------- +%%% Internal functions +%%%---------------------------------------------------------------------- +-spec do_exit(#state{}, pid(), _, _) -> no_return(). +do_exit(S, From, Message0, Reason) -> + R = do_stop(S), + Message = case S#state.cache_error of + Err when Err =/= ok -> Err; + _ when R =:= closed -> Message0; + _ when Message0 =:= ok -> R; + _ -> Message0 + end, + _ = disk_log_server:close(self()), + replies(From, Message), + ?PROFILE(ep:done()), + exit(Reason). + +-spec do_fast_exit(#state{}, pid(), _) -> no_return(). +do_fast_exit(S, Server, Message) -> + _ = do_stop(S), + Server ! {disk_log, self(), Message}, + exit(normal). + +%% -> closed | Error +do_stop(S) -> + proc_q(S#state.queue ++ S#state.messages), + close_disk_log(get(log)). + +proc_q([{From, _R}|Tail]) when is_pid(From) -> + From ! {disk_log, self(), {error, disk_log_stopped}}, + proc_q(Tail); +proc_q([_|T]) -> %% async stuff + proc_q(T); +proc_q([]) -> + ok. + +%% -> log() +opening_pid(Pid, Notify, L) -> + {ok, L1} = add_pid(Pid, Notify, L), + L1. + +%% -> {ok, log()} | Error +add_pid(Pid, Notify, L) when is_pid(Pid) -> + case is_owner(Pid, L) of + false -> + link(Pid), + {ok, L#log{owners = [{Pid, Notify} | L#log.owners]}}; + {true, Notify} -> +%% {error, {pid_already_connected, L#log.name}}; + {ok, L}; + {true, CurNotify} when Notify =/= CurNotify -> + {error, {arg_mismatch, notify, CurNotify, Notify}} + end; +add_pid(_NotAPid, _Notify, L) -> + {ok, L#log{users = L#log.users + 1}}. + +unblock_pid(L) when L#log.blocked_by =:= none -> + ok; +unblock_pid(L) -> + case is_owner(L#log.blocked_by, L) of + {true, _Notify} -> + ok; + false -> + unlink(L#log.blocked_by) + end. + +%% -> true | false +is_owner(Pid, L) -> + case lists:keysearch(Pid, 1, L#log.owners) of + {value, {_Pid, Notify}} -> + {true, Notify}; + false -> + false + end. + +%% ok | throw(Error) +rename_file(File, NewFile, halt) -> + file:rename(File, NewFile); +rename_file(File, NewFile, wrap) -> + rename_file(wrap_file_extensions(File), File, NewFile, ok). + +rename_file([Ext|Exts], File, NewFile, Res) -> + NRes = case file:rename(add_ext(File, Ext), add_ext(NewFile, Ext)) of + ok -> + Res; + Else -> + Else + end, + rename_file(Exts, File, NewFile, NRes); +rename_file([], _File, _NewFiles, Res) -> Res. + +%% "Old" error messages have been kept, arg_mismatch has been added. +%%-spec compare_arg(dlog_options(), #arg{}, +compare_arg([], _A, none, _OrigHead) -> + % no header option given + ok; +compare_arg([], _A, Head, OrigHead) when Head =/= OrigHead -> + {error, {arg_mismatch, head, OrigHead, Head}}; +compare_arg([], _A, _Head, _OrigHead) -> + ok; +compare_arg([{Attr, Val} | Tail], A, Head, OrigHead) -> + case compare_arg(Attr, Val, A) of + {not_ok, OrigVal} -> + {error, {arg_mismatch, Attr, OrigVal, Val}}; + ok -> + compare_arg(Tail, A, Head, OrigHead); + Error -> + Error + end. + +-spec compare_arg(atom(), _, #arg{}) -> + 'ok' | {'not_ok', _} | {'error', {atom(), _}}. +compare_arg(file, F, A) when F =/= A#arg.file -> + {error, {name_already_open, A#arg.name}}; +compare_arg(mode, read_only, A) when A#arg.mode =:= read_write -> + {error, {open_read_write, A#arg.name}}; +compare_arg(mode, read_write, A) when A#arg.mode =:= read_only -> + {error, {open_read_only, A#arg.name}}; +compare_arg(type, T, A) when T =/= A#arg.type -> + {not_ok, A#arg.type}; +compare_arg(format, F, A) when F =/= A#arg.format -> + {not_ok, A#arg.format}; +compare_arg(repair, R, A) when R =/= A#arg.repair -> + %% not used, but check it anyway... + {not_ok, A#arg.repair}; +compare_arg(_Attr, _Val, _A) -> + ok. + +%% -> {ok, Res, log(), Cnt} | Error +do_open(A) -> + L = #log{name = A#arg.name, + filename = A#arg.file, + size = A#arg.size, + head = mk_head(A#arg.head, A#arg.format), + mode = A#arg.mode, + version = A#arg.version}, + do_open2(L, A). + +mk_head({head, Term}, internal) -> {ok, term_to_binary(Term)}; +mk_head({head, Bytes}, external) -> {ok, check_bytes(Bytes)}; +mk_head(H, _) -> H. + +terms2bins([T | Ts]) -> + [term_to_binary(T) | terms2bins(Ts)]; +terms2bins([]) -> + []. + +check_bytes_list([B | Bs], Bs0) when is_binary(B) -> + check_bytes_list(Bs, Bs0); +check_bytes_list([], Bs0) -> + Bs0; +check_bytes_list(_, Bs0) -> + check_bytes_list(Bs0). + +check_bytes_list([B | Bs]) when is_binary(B) -> + [B | check_bytes_list(Bs)]; +check_bytes_list([B | Bs]) -> + [list_to_binary(B) | check_bytes_list(Bs)]; +check_bytes_list([]) -> + []. + +check_bytes(Binary) when is_binary(Binary) -> + Binary; +check_bytes(Bytes) -> + list_to_binary(Bytes). + +%%----------------------------------------------------------------- +%% Change size of the logs in runtime. +%%----------------------------------------------------------------- +%% -> ok | {big, CurSize} | throw(Error) +do_change_size(L, NewSize) when L#log.type =:= halt -> + Halt = L#log.extra, + CurB = Halt#halt.curB, + NewLog = L#log{extra = Halt#halt{size = NewSize}}, + if + NewSize =:= infinity -> + erase(is_full), + put(log, NewLog), + ok; + CurB =< NewSize -> + erase(is_full), + put(log, NewLog), + ok; + true -> + {big, CurB} + end; +do_change_size(L, NewSize) when L#log.type =:= wrap -> + #log{extra = Extra, version = Version} = L, + {ok, Handle} = disk_log_1:change_size_wrap(Extra, NewSize, Version), + erase(is_full), + put(log, L#log{extra = Handle}), + ok. + +%% -> {ok, Head} | Error; Head = none | {head, H} | {M,F,A} +check_head({head, none}, _Format) -> + {ok, none}; +check_head({head_func, {M, F, A}}, _Format) when is_atom(M), + is_atom(F), + is_list(A) -> + {ok, {M, F, A}}; +check_head({head, Head}, external) -> + case catch check_bytes(Head) of + {'EXIT', _} -> + {error, {badarg, head}}; + _ -> + {ok, {head, Head}} + end; +check_head({head, Term}, internal) -> + {ok, {head, Term}}; +check_head(_Head, _Format) -> + {error, {badarg, head}}. + +check_size(wrap, {NewMaxB,NewMaxF}) when + is_integer(NewMaxB), is_integer(NewMaxF), + NewMaxB > 0, NewMaxB =< ?MAX_BYTES, NewMaxF > 0, NewMaxF < ?MAX_FILES -> + ok; +check_size(halt, NewSize) when is_integer(NewSize), NewSize > 0 -> + ok; +check_size(halt, infinity) -> + ok; +check_size(_, _) -> + not_ok. + +%%----------------------------------------------------------------- +%% Increment a wrap log. +%%----------------------------------------------------------------- +%% -> {ok, log(), Lost} | {error, Error, log()} +do_inc_wrap_file(L) -> + #log{format = Format, extra = Handle} = L, + case Format of + internal -> + case disk_log_1:mf_int_inc(Handle, L#log.head) of + {ok, Handle2, Lost} -> + {ok, L#log{extra = Handle2}, Lost}; + {error, Error, Handle2} -> + {error, Error, L#log{extra = Handle2}} + end; + external -> + case disk_log_1:mf_ext_inc(Handle, L#log.head) of + {ok, Handle2, Lost} -> + {ok, L#log{extra = Handle2}, Lost}; + {error, Error, Handle2} -> + {error, Error, L#log{extra = Handle2}} + end + end. + + +%%----------------------------------------------------------------- +%% Open a log file. +%%----------------------------------------------------------------- +%% -> {ok, Reply, log(), Cnt} | Error +%% Note: the header is always written, even if the log size is too small. +do_open2(L, #arg{type = halt, format = internal, name = Name, + file = FName, repair = Repair, size = Size, mode = Mode}) -> + case catch disk_log_1:int_open(FName, Repair, Mode, L#log.head) of + {ok, {_Alloc, FdC, {NoItems, _NoBytes}, FileSize}} -> + Halt = #halt{fdc = FdC, curB = FileSize, size = Size}, + {ok, {ok, Name}, L#log{format_type = halt_int, extra = Halt}, + NoItems}; + {repaired, FdC, Rec, Bad, FileSize} -> + Halt = #halt{fdc = FdC, curB = FileSize, size = Size}, + {ok, {repaired, Name, {recovered, Rec}, {badbytes, Bad}}, + L#log{format_type = halt_int, extra = Halt}, + Rec}; + Error -> + Error + end; +do_open2(L, #arg{type = wrap, format = internal, size = {MaxB, MaxF}, + name = Name, repair = Repair, file = FName, mode = Mode, + version = V}) -> + case catch + disk_log_1:mf_int_open(FName, MaxB, MaxF, Repair, Mode, L#log.head, V) of + {ok, Handle, Cnt} -> + {ok, {ok, Name}, L#log{type = wrap, + format_type = wrap_int, + extra = Handle}, Cnt}; + {repaired, Handle, Rec, Bad, Cnt} -> + {ok, {repaired, Name, {recovered, Rec}, {badbytes, Bad}}, + L#log{type = wrap, format_type = wrap_int, extra = Handle}, Cnt}; + Error -> + Error + end; +do_open2(L, #arg{type = halt, format = external, file = FName, name = Name, + size = Size, repair = Repair, mode = Mode}) -> + case catch disk_log_1:ext_open(FName, Repair, Mode, L#log.head) of + {ok, {_Alloc, FdC, {NoItems, _NoBytes}, FileSize}} -> + Halt = #halt{fdc = FdC, curB = FileSize, size = Size}, + {ok, {ok, Name}, + L#log{format_type = halt_ext, format = external, extra = Halt}, + NoItems}; + Error -> + Error + end; +do_open2(L, #arg{type = wrap, format = external, size = {MaxB, MaxF}, + name = Name, file = FName, repair = Repair, mode = Mode, + version = V}) -> + case catch + disk_log_1:mf_ext_open(FName, MaxB, MaxF, Repair, Mode, L#log.head, V) of + {ok, Handle, Cnt} -> + {ok, {ok, Name}, L#log{type = wrap, + format_type = wrap_ext, + extra = Handle, + format = external}, Cnt}; + Error -> + Error + end. + +%% -> closed | Error +close_disk_log(undefined) -> + closed; +close_disk_log(L) -> + unblock_pid(L), + F = fun({Pid, _}) -> + unlink(Pid) + end, + lists:foreach(F, L#log.owners), + R = (catch close_disk_log2(L)), + erase(log), + R. + +-spec close_disk_log2(#log{}) -> 'closed'. % | throw(Error) + +close_disk_log2(L) -> + case L of + #log{format_type = halt_int, mode = Mode, extra = Halt} -> + disk_log_1:close(Halt#halt.fdc, L#log.filename, Mode); + #log{format_type = wrap_int, mode = Mode, extra = Handle} -> + disk_log_1:mf_int_close(Handle, Mode); + #log{format_type = halt_ext, extra = Halt} -> + disk_log_1:fclose(Halt#halt.fdc, L#log.filename); + #log{format_type = wrap_ext, mode = Mode, extra = Handle} -> + disk_log_1:mf_ext_close(Handle, Mode) + end, + closed. + +do_format_error({error, Module, Error}) -> + Module:format_error(Error); +do_format_error({error, Reason}) -> + do_format_error(Reason); +do_format_error({Node, Error = {error, _Reason}}) -> + lists:append(io_lib:format("~p: ", [Node]), do_format_error(Error)); +do_format_error({badarg, Arg}) -> + io_lib:format("The argument ~p is missing, not recognized or " + "not wellformed~n", [Arg]); +do_format_error({size_mismatch, OldSize, ArgSize}) -> + io_lib:format("The given size ~p does not match the size ~p found on " + "the disk log size file~n", [ArgSize, OldSize]); +do_format_error({read_only_mode, Log}) -> + io_lib:format("The disk log ~p has been opened read-only, but the " + "requested operation needs read-write access~n", [Log]); +do_format_error({format_external, Log}) -> + io_lib:format("The requested operation can only be applied on internally " + "formatted disk logs, but ~p is externally formatted~n", + [Log]); +do_format_error({blocked_log, Log}) -> + io_lib:format("The blocked disk log ~p does not queue requests, or " + "the log has been blocked by the calling process~n", [Log]); +do_format_error({full, Log}) -> + io_lib:format("The halt log ~p is full~n", [Log]); +do_format_error({not_blocked, Log}) -> + io_lib:format("The disk log ~p is not blocked~n", [Log]); +do_format_error({not_owner, Pid}) -> + io_lib:format("The pid ~p is not an owner of the disk log~n", [Pid]); +do_format_error({not_blocked_by_pid, Log}) -> + io_lib:format("The disk log ~p is blocked, but only the blocking pid " + "can unblock a disk log~n", [Log]); +do_format_error({new_size_too_small, Log, CurrentSize}) -> + io_lib:format("The current size ~p of the halt log ~p is greater than the " + "requested new size~n", [CurrentSize, Log]); +do_format_error({halt_log, Log}) -> + io_lib:format("The halt log ~p cannot be wrapped~n", [Log]); +do_format_error({same_file_name, Log}) -> + io_lib:format("Current and new file name of the disk log ~p " + "are the same~n", [Log]); +do_format_error({arg_mismatch, Option, FirstValue, ArgValue}) -> + io_lib:format("The value ~p of the disk log option ~p does not match " + "the current value ~p~n", [ArgValue, Option, FirstValue]); +do_format_error({name_already_open, Log}) -> + io_lib:format("The disk log ~p has already opened another file~n", [Log]); +do_format_error({node_already_open, Log}) -> + io_lib:format("The distribution option of the disk log ~p does not match " + "already open log~n", [Log]); +do_format_error({open_read_write, Log}) -> + io_lib:format("The disk log ~p has already been opened read-write~n", + [Log]); +do_format_error({open_read_only, Log}) -> + io_lib:format("The disk log ~p has already been opened read-only~n", + [Log]); +do_format_error({not_internal_wrap, Log}) -> + io_lib:format("The requested operation cannot be applied since ~p is not " + "an internally formatted disk log~n", [Log]); +do_format_error(no_such_log) -> + io_lib:format("There is no disk log with the given name~n", []); +do_format_error(nonode) -> + io_lib:format("There seems to be no node up that can handle " + "the request~n", []); +do_format_error(nodedown) -> + io_lib:format("There seems to be no node up that can handle " + "the request~n", []); +do_format_error({corrupt_log_file, FileName}) -> + io_lib:format("The disk log file \"~s\" contains corrupt data~n", + [FileName]); +do_format_error({need_repair, FileName}) -> + io_lib:format("The disk log file \"~s\" has not been closed properly and " + "needs repair~n", [FileName]); +do_format_error({not_a_log_file, FileName}) -> + io_lib:format("The file \"~s\" is not a wrap log file~n", [FileName]); +do_format_error({invalid_header, InvalidHeader}) -> + io_lib:format("The disk log header is not wellformed: ~p~n", + [InvalidHeader]); +do_format_error(end_of_log) -> + io_lib:format("An attempt was made to step outside a not yet " + "full wrap log~n", []); +do_format_error({invalid_index_file, FileName}) -> + io_lib:format("The wrap log index file \"~s\" cannot be used~n", + [FileName]); +do_format_error({no_continuation, BadCont}) -> + io_lib:format("The term ~p is not a chunk continuation~n", [BadCont]); +do_format_error({file_error, FileName, Reason}) -> + io_lib:format("\"~s\": ~p~n", [FileName, file:format_error(Reason)]); +do_format_error(E) -> + io_lib:format("~p~n", [E]). + +do_info(L, Cnt) -> + #log{name = Name, type = Type, mode = Mode, filename = File, + extra = Extra, status = Status, owners = Owners, users = Users, + format = Format, head = Head} = L, + Size = case Type of + wrap -> + disk_log_1:get_wrap_size(Extra); + halt -> + Extra#halt.size + end, + Distribution = + case disk_log_server:get_log_pids(Name) of + {local, _Pid} -> + local; + {distributed, Pids} -> + [node(P) || P <- Pids]; + undefined -> % "cannot happen" + [] + end, + RW = case Type of + wrap when Mode =:= read_write -> + #handle{curB = CurB, curF = CurF, + cur_cnt = CurCnt, acc_cnt = AccCnt, + noFull = NoFull, accFull = AccFull} = Extra, + NewAccFull = AccFull + NoFull, + NewExtra = Extra#handle{noFull = 0, accFull = NewAccFull}, + put(log, L#log{extra = NewExtra}), + [{no_current_bytes, CurB}, + {no_current_items, CurCnt}, + {no_items, Cnt}, + {no_written_items, CurCnt + AccCnt}, + {current_file, CurF}, + {no_overflows, {NewAccFull, NoFull}} + ]; + halt when Mode =:= read_write -> + IsFull = case get(is_full) of + undefined -> false; + _ -> true + end, + [{full, IsFull}, + {no_written_items, Cnt} + ]; + _ when Mode =:= read_only -> + [] + end, + HeadL = case Mode of + read_write -> + [{head, Head}]; + read_only -> + [] + end, + Common = [{name, Name}, + {file, File}, + {type, Type}, + {format, Format}, + {size, Size}, + {items, Cnt}, % kept for "backward compatibility" (undocumented) + {owners, Owners}, + {users, Users}] ++ + HeadL ++ + [{mode, Mode}, + {status, Status}, + {node, node()}, + {distributed, Distribution} + ], + Common ++ RW. + +do_block(Pid, QueueLogRecs, L) -> + L2 = L#log{status = {blocked, QueueLogRecs}, blocked_by = Pid}, + put(log, L2), + case is_owner(Pid, L2) of + {true, _Notify} -> + ok; + false -> + link(Pid) + end. + +do_unblock(Pid, L, S) when L#log.blocked_by =:= Pid -> + do_unblock(L, S); +do_unblock(_Pid, _L, S) -> + S. + +do_unblock(L, S) -> + unblock_pid(L), + L2 = L#log{blocked_by = none, status = ok}, + put(log, L2), + %% Since the block request is synchronous, and the blocking + %% process is the only process that can unblock, all requests in + %% 'messages' will have been put in 'queue' before the unblock + %% request is granted. + [] = S#state.messages, % assertion + S#state{queue = [], messages = lists:reverse(S#state.queue)}. + +-spec do_log(#log{}, [binary()]) -> integer() | {'error', _, integer()}. + +do_log(L, B) when L#log.type =:= halt -> + #log{format = Format, extra = Halt} = L, + #halt{curB = CurSize, size = Sz} = Halt, + {Bs, BSize} = bsize(B, Format), + case get(is_full) of + true -> + {error, {error, {full, L#log.name}}, 0}; + undefined when Sz =:= infinity; CurSize + BSize =< Sz -> + halt_write(Halt, L, B, Bs, BSize); + undefined -> + halt_write_full(L, B, Format, 0) + end; +do_log(L, B) when L#log.format_type =:= wrap_int -> + case disk_log_1:mf_int_log(L#log.extra, B, L#log.head) of + {ok, Handle, Logged, Lost, Wraps} -> + notify_owners_wrap(Wraps), + put(log, L#log{extra = Handle}), + Logged - Lost; + {ok, Handle, Logged} -> + put(log, L#log{extra = Handle}), + Logged; + {error, Error, Handle, Logged, Lost} -> + put(log, L#log{extra = Handle}), + {error, Error, Logged - Lost} + end; +do_log(L, B) when L#log.format_type =:= wrap_ext -> + case disk_log_1:mf_ext_log(L#log.extra, B, L#log.head) of + {ok, Handle, Logged, Lost, Wraps} -> + notify_owners_wrap(Wraps), + put(log, L#log{extra = Handle}), + Logged - Lost; + {ok, Handle, Logged} -> + put(log, L#log{extra = Handle}), + Logged; + {error, Error, Handle, Logged, Lost} -> + put(log, L#log{extra = Handle}), + {error, Error, Logged - Lost} + end. + +bsize(B, external) -> + {B, xsz(B, 0)}; +bsize(B, internal) -> + disk_log_1:logl(B). + +xsz([B|T], Sz) -> xsz(T, byte_size(B) + Sz); +xsz([], Sz) -> Sz. + +halt_write_full(L, [Bin | Bins], Format, N) -> + B = [Bin], + {Bs, BSize} = bsize(B, Format), + Halt = L#log.extra, + #halt{curB = CurSize, size = Sz} = Halt, + if + CurSize + BSize =< Sz -> + case halt_write(Halt, L, B, Bs, BSize) of + N1 when is_integer(N1) -> + halt_write_full(get(log), Bins, Format, N+N1); + Error -> + Error + end; + true -> + halt_write_full(L, [], Format, N) + end; +halt_write_full(L, _Bs, _Format, N) -> + put(is_full, true), + notify_owners(full), + {error, {error, {full, L#log.name}}, N}. + +halt_write(Halt, L, B, Bs, BSize) -> + case disk_log_1:fwrite(Halt#halt.fdc, L#log.filename, Bs, BSize) of + {ok, NewFdC} -> + NCurB = Halt#halt.curB + BSize, + NewHalt = Halt#halt{fdc = NewFdC, curB = NCurB}, + put(log, L#log{extra = NewHalt}), + length(B); + {Error, NewFdC} -> + put(log, L#log{extra = Halt#halt{fdc = NewFdC}}), + {error, Error, 0} + end. + +%% -> ok | Error +do_write_cache(#log{filename = FName, type = halt, extra = Halt} = Log) -> + {Reply, NewFdC} = disk_log_1:write_cache(Halt#halt.fdc, FName), + put(log, Log#log{extra = Halt#halt{fdc = NewFdC}}), + Reply; +do_write_cache(#log{type = wrap, extra = Handle} = Log) -> + {Reply, NewHandle} = disk_log_1:mf_write_cache(Handle), + put(log, Log#log{extra = NewHandle}), + Reply. + +%% -> ok | Error +do_sync(#log{filename = FName, type = halt, extra = Halt} = Log) -> + {Reply, NewFdC} = disk_log_1:sync(Halt#halt.fdc, FName), + put(log, Log#log{extra = Halt#halt{fdc = NewFdC}}), + Reply; +do_sync(#log{type = wrap, extra = Handle} = Log) -> + {Reply, NewHandle} = disk_log_1:mf_sync(Handle), + put(log, Log#log{extra = NewHandle}), + Reply. + +%% -> ok | Error | throw(Error) +do_trunc(L, Head) when L#log.type =:= halt -> + #log{filename = FName, extra = Halt} = L, + FdC = Halt#halt.fdc, + {Reply1, FdC2} = + case L#log.format of + internal -> + disk_log_1:truncate(FdC, FName, Head); + external -> + case disk_log_1:truncate_at(FdC, FName, bof) of + {ok, NFdC} when Head =:= none -> + {ok, NFdC}; + {ok, NFdC} -> + {ok, H} = Head, + disk_log_1:fwrite(NFdC, FName, H, byte_size(H)); + R -> + R + end + end, + {Reply, NewHalt} = + case disk_log_1:position(FdC2, FName, cur) of + {ok, NewFdC, FileSize} when Reply1 =:= ok -> + {ok, Halt#halt{fdc = NewFdC, curB = FileSize}}; + {Reply2, NewFdC} -> + {Reply2, Halt#halt{fdc = NewFdC}}; + {ok, NewFdC, _} -> + {Reply1, Halt#halt{fdc = NewFdC}} + end, + put(log, L#log{extra = NewHalt}), + Reply; +do_trunc(L, Head) when L#log.type =:= wrap -> + Handle = L#log.extra, + OldHead = L#log.head, + {MaxB, MaxF} = disk_log_1:get_wrap_size(Handle), + ok = do_change_size(L, {MaxB, 1}), + NewLog = trunc_wrap((get(log))#log{head = Head}), + %% Just to remove all files with suffix > 1: + NewLog2 = trunc_wrap(NewLog), + NewHandle = (NewLog2#log.extra)#handle{noFull = 0, accFull = 0}, + do_change_size(NewLog2#log{extra = NewHandle, head = OldHead}, + {MaxB, MaxF}). + +trunc_wrap(L) -> + case do_inc_wrap_file(L) of + {ok, L2, _Lost} -> + L2; + {error, Error, _L2} -> + throw(Error) + end. + +do_chunk(#log{format_type = halt_int, extra = Halt} = L, Pos, B, N) -> + FdC = Halt#halt.fdc, + {NewFdC, Reply} = + case L#log.mode of + read_only -> + disk_log_1:chunk_read_only(FdC, L#log.filename, Pos, B, N); + read_write -> + disk_log_1:chunk(FdC, L#log.filename, Pos, B, N) + end, + put(log, L#log{extra = Halt#halt{fdc = NewFdC}}), + Reply; +do_chunk(#log{format_type = wrap_int, mode = read_only, + extra = Handle} = Log, Pos, B, N) -> + {NewHandle, Reply} = disk_log_1:mf_int_chunk_read_only(Handle, Pos, B, N), + put(log, Log#log{extra = NewHandle}), + Reply; +do_chunk(#log{format_type = wrap_int, extra = Handle} = Log, Pos, B, N) -> + {NewHandle, Reply} = disk_log_1:mf_int_chunk(Handle, Pos, B, N), + put(log, Log#log{extra = NewHandle}), + Reply; +do_chunk(Log, _Pos, _B, _) -> + {error, {format_external, Log#log.name}}. + +do_chunk_step(#log{format_type = wrap_int, extra = Handle}, Pos, N) -> + disk_log_1:mf_int_chunk_step(Handle, Pos, N); +do_chunk_step(Log, _Pos, _N) -> + {error, {not_internal_wrap, Log#log.name}}. + +%% Inlined. +replies(Pids, Reply) -> + M = {disk_log, self(), Reply}, + send_reply(Pids, M). + +send_reply(Pid, M) when is_pid(Pid) -> + Pid ! M; +send_reply([Pid | Pids], M) -> + Pid ! M, + send_reply(Pids, M); +send_reply([], _M) -> + ok. + +reply(To, Reply, S) -> + To ! {disk_log, self(), Reply}, + loop(S). + +req(Log, R) -> + case disk_log_server:get_log_pids(Log) of + {local, Pid} -> + monitor_request(Pid, R); + undefined -> + {error, no_such_log}; + {distributed, Pids} -> + multi_req({self(), R}, Pids) + end. + +multi_req(Msg, Pids) -> + Refs = + lists:map(fun(Pid) -> + Ref = erlang:monitor(process, Pid), + Pid ! Msg, + {Pid, Ref} + end, Pids), + lists:foldl(fun({Pid, Ref}, Reply) -> + receive + {'DOWN', Ref, process, Pid, _Info} -> + Reply; + {disk_log, Pid, _Reply} -> + erlang:demonitor(Ref), + receive + {'DOWN', Ref, process, Pid, _Reason} -> + ok + after 0 -> + ok + end + end + end, {error, nonode}, Refs). + +sreq(Log, R) -> + case nearby_pid(Log, node()) of + undefined -> + {error, no_such_log}; + Pid -> + monitor_request(Pid, R) + end. + +%% Local req - always talk to log on Node +lreq(Log, R, Node) -> + case nearby_pid(Log, Node) of + Pid when is_pid(Pid), node(Pid) =:= Node -> + monitor_request(Pid, R); + _Else -> + {error, no_such_log} + end. + +nearby_pid(Log, Node) -> + case disk_log_server:get_log_pids(Log) of + undefined -> + undefined; + {local, Pid} -> + Pid; + {distributed, Pids} -> + get_near_pid(Pids, Node) + end. + +-spec get_near_pid([pid(),...], node()) -> pid(). + +get_near_pid([Pid | _], Node) when node(Pid) =:= Node -> Pid; +get_near_pid([Pid], _ ) -> Pid; +get_near_pid([_ | T], Node) -> get_near_pid(T, Node). + +monitor_request(Pid, Req) -> + Ref = erlang:monitor(process, Pid), + Pid ! {self(), Req}, + receive + {'DOWN', Ref, process, Pid, _Info} -> + {error, no_such_log}; + {disk_log, Pid, Reply} -> + erlang:demonitor(Ref), + receive + {'DOWN', Ref, process, Pid, _Reason} -> + Reply + after 0 -> + Reply + end + end. + +req2(Pid, R) -> + monitor_request(Pid, R). + +merge_head(none, Head) -> + Head; +merge_head(Head, _) -> + Head. + +%% -> List of extensions of existing files (no dot included) | throw(FileError) +wrap_file_extensions(File) -> + {_CurF, _CurFSz, _TotSz, NoOfFiles} = + disk_log_1:read_index_file(File), + Fs = if + NoOfFiles >= 1 -> + lists:seq(1, NoOfFiles); + NoOfFiles =:= 0 -> + [] + end, + Fun = fun(Ext) -> + case file:read_file_info(add_ext(File, Ext)) of + {ok, _} -> + true; + _Else -> + false + end + end, + lists:filter(Fun, ["idx", "siz" | Fs]). + +add_ext(File, Ext) -> + lists:concat([File, ".", Ext]). + +notify(Log, R) -> + case disk_log_server:get_log_pids(Log) of + undefined -> + {error, no_such_log}; + {local, Pid} -> + Pid ! R, + ok; + {distributed, Pids} -> + lists:foreach(fun(Pid) -> Pid ! R end, Pids), + ok + end. + +notify_owners_wrap([]) -> + ok; +notify_owners_wrap([N | Wraps]) -> + notify_owners({wrap, N}), + notify_owners_wrap(Wraps). + +notify_owners(Note) -> + L = get(log), + Msg = {disk_log, node(), L#log.name, Note}, + lists:foreach(fun({Pid, true}) -> Pid ! Msg; + (_) -> ok + end, L#log.owners). + +cache_error(S, Pids) -> + Error = S#state.cache_error, + replies(Pids, Error), + state_err(S#state{cache_error = ok}, Error). + +state_ok(S) -> + state_err(S, ok). + +-spec state_err(#state{}, dlog_state_error()) -> #state{}. + +state_err(S, Err) when S#state.error_status =:= Err -> S; +state_err(S, Err) -> + notify_owners({error_status, Err}), + S#state{error_status = Err}. diff --git a/lib/kernel/src/disk_log.hrl b/lib/kernel/src/disk_log.hrl new file mode 100644 index 0000000000..b0849145ca --- /dev/null +++ b/lib/kernel/src/disk_log.hrl @@ -0,0 +1,161 @@ +%% +%% %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% +%% + +-define(DISK_LOG_NAME_TABLE, disk_log_names). +-define(DISK_LOG_PID_TABLE, disk_log_pids). + +%% File format version +-define(VERSION, 2). + +%% HEADSZ is the size of the file header, +%% HEADERSZ is the size of the item header ( = ?SIZESZ + ?MAGICSZ). +-define(HEADSZ, 8). +-define(SIZESZ, 4). +-define(MAGICSZ, 4). +-define(HEADERSZ, 8). +-define(MAGICHEAD, <<12,33,44,55>>). +-define(MAGICINT, 203500599). %% ?MAGICHEAD = <<?MAGICINT:32>> +-define(BIGMAGICHEAD, <<98,87,76,65>>). +-define(BIGMAGICINT, 1649888321). %% ?BIGMAGICHEAD = <<?BIGMAGICINT:32>> +-define(MIN_MD5_TERM, 65528).% (?MAX_CHUNK_SIZE - ?HEADERSZ) + +-define(MAX_FILES, 65000). +-define(MAX_BYTES, ((1 bsl 64) - 1)). +-define(MAX_CHUNK_SIZE, 65536). + +%% Object defines +-define(LOGMAGIC, <<1,2,3,4>>). +-define(OPENED, <<6,7,8,9>>). +-define(CLOSED, <<99,88,77,11>>). + +%% Needed for the definition of fd() +%% Must use include_lib() so that we always can be sure to find +%% file.hrl. A relative path will not work in an installed system. +-include_lib("kernel/include/file.hrl"). + +%% Ugly workaround. If we are building the bootstrap compiler, +%% file.hrl does not define the fd() type. +-ifndef(FILE_HRL_). +-type fd() :: pid() | #file_descriptor{}. +-endif. + +%%------------------------------------------------------------------------ +%% Types -- alphabetically +%%------------------------------------------------------------------------ + +-type dlog_format() :: 'external' | 'internal'. +-type dlog_format_type() :: 'halt_ext' | 'halt_int' | 'wrap_ext' | 'wrap_int'. +-type dlog_head() :: 'none' | {'ok', binary()} | mfa(). +-type dlog_mode() :: 'read_only' | 'read_write'. +-type dlog_name() :: atom() | string(). +-type dlog_optattr() :: 'name' | 'file' | 'linkto' | 'repair' | 'type' + | 'format' | 'size' | 'distributed' | 'notify' + | 'head' | 'head_func' | 'mode'. +-type dlog_options() :: [{dlog_optattr(), any()}]. +-type dlog_repair() :: 'truncate' | boolean(). +-type dlog_size() :: 'infinity' | pos_integer() + | {pos_integer(), pos_integer()}. +-type dlog_status() :: 'ok' | {'blocked', 'false' | [_]}. %QueueLogRecords +-type dlog_type() :: 'halt' | 'wrap'. + +%%------------------------------------------------------------------------ +%% Records +%%------------------------------------------------------------------------ + +%% record of args for open +-record(arg, {name = 0, + version = undefined, + file = none :: 'none' | string(), + repair = true :: dlog_repair(), + size = infinity :: dlog_size(), + type = halt :: dlog_type(), + distributed = false :: 'false' | {'true', [node()]}, + format = internal :: dlog_format(), + linkto = self() :: 'none' | pid(), + head = none, + mode = read_write :: dlog_mode(), + notify = false :: boolean(), + options = [] :: dlog_options()}). + +-record(cache, %% Cache for logged terms (per file descriptor). + {fd :: fd(), %% File descriptor. + sz = 0 :: non_neg_integer(), %% Number of bytes in the cache. + c = [] :: iodata()} %% The cache. + ). + +-record(halt, %% For a halt log. + {fdc :: #cache{}, %% A cache record. + curB :: non_neg_integer(), %% Number of bytes on the file. + size :: dlog_size()} + ). + +-record(handle, %% For a wrap log. + {filename :: file:filename(), %% Same as log.filename + maxB :: pos_integer(), %% Max size of the files. + maxF :: pos_integer() | {pos_integer(),pos_integer()}, + %% When pos_integer(), maximum number of files. + %% The form {NewMaxF, OldMaxF} is used when the + %% number of wrap logs are decreased. The files + %% are not removed when the size is changed but + %% next time the files are to be used, i.e next + %% time the wrap log has filled the + %% Dir/Name.NewMaxF file. + curB :: non_neg_integer(), %% Number of bytes on current file. + curF :: integer(), %% Current file number. + cur_fdc :: #cache{}, %% Current file descriptor. + cur_name :: file:filename(), %% Current file name for error reports. + cur_cnt :: non_neg_integer(), %% Number of items on current file, + %% header inclusive. + acc_cnt :: non_neg_integer(), %% acc_cnt+cur_cnt is number of items + %% written since the log was opened. + firstPos :: non_neg_integer(), %% Start position for first item + %% (after header). + noFull :: non_neg_integer(), %% Number of overflows since last + %% use of info/1 on this log, or + %% since log was opened if info/1 + %% has not yet been used on this log. + accFull :: non_neg_integer()} %% noFull+accFull is number of + %% oveflows since the log was opened. + ). + +-record(log, + {status = ok :: dlog_status(), + name :: dlog_name(), %% the key leading to this structure + blocked_by = none :: 'none' | pid(), %% pid of blocker + users = 0 :: non_neg_integer(), %% non-linked users + filename :: file:filename(), %% real name of the file + owners = [] :: [{pid(), boolean()}],%% [{pid, notify}] + type = halt :: dlog_type(), + format = internal :: dlog_format(), + format_type :: dlog_format_type(), + head = none, %% none | {head, H} | {M,F,A} + %% called when wraplog wraps + mode :: dlog_mode(), + size, %% value of open/1 option 'size' (never changed) + extra :: #halt{} | #handle{}, %% type of the log + version :: integer()} %% if wrap log file + ). + +-record(continuation, %% Chunk continuation. + {pid = self() :: pid(), + pos :: non_neg_integer() | {integer(), non_neg_integer()}, + b :: binary() | [] | pos_integer()} + ). + +-type dlog_cont() :: 'start' | #continuation{}. diff --git a/lib/kernel/src/disk_log_1.erl b/lib/kernel/src/disk_log_1.erl new file mode 100644 index 0000000000..7103417149 --- /dev/null +++ b/lib/kernel/src/disk_log_1.erl @@ -0,0 +1,1551 @@ +%% +%% %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(disk_log_1). + +%% Efficient file based log - implementation part + +-export([int_open/4, ext_open/4, logl/1, close/3, truncate/3, chunk/5, + sync/2, write_cache/2]). +-export([mf_int_open/7, mf_int_log/3, mf_int_close/2, mf_int_inc/2, + mf_ext_inc/2, mf_int_chunk/4, mf_int_chunk_step/3, + mf_sync/1, mf_write_cache/1]). +-export([mf_ext_open/7, mf_ext_log/3, mf_ext_close/2]). + +-export([print_index_file/1]). +-export([read_index_file/1]). +-export([read_size_file/1, read_size_file_version/1]). +-export([chunk_read_only/5]). +-export([mf_int_chunk_read_only/4]). +-export([change_size_wrap/3]). +-export([get_wrap_size/1]). +-export([is_head/1]). +-export([position/3, truncate_at/3, fwrite/4, fclose/2]). + +-compile({inline,[{scan_f2,7}]}). + +-import(lists, [concat/1, reverse/1, sum/1]). + +-include("disk_log.hrl"). + +%%% At the head of a LOG file we have [?LOGMAGIC, ?OPENED | ?CLOSED]. +%%% Otherwise it's not a LOG file. Following that, the head, come the +%%% logged items. +%%% +%%% There are four formats of wrap log files (so far). Only the size +%%% file and the index file differ between versions between the first +%%% three version. The fourth version 2(a), has some protection +%%% against damaged item sizes. +%%% Version 0: no "siz" file +%%% Version 1: "siz" file, 4 byte sizes +%%% Version 2: 8 byte sizes (support for large files) +%%% Version 2(a): Change of the format of logged items: +%%% if the size of a term binary is greater than or equal to +%%% ?MIN_MD5_TERM, a logged item looks like +%%% <<Size:32, ?BIGMAGICHEAD:32, MD5:128, Term/binary>>, +%%% otherwise <<Size:32, ?BIGMAGICHEAD:32, Term/binary>>. + +%%%---------------------------------------------------------------------- +%%% API +%%%---------------------------------------------------------------------- + +%% -> {ok, NoBytes, NewFdC} | {Error, NewFdC} +log(FdC, FileName, X) -> + {Bs, Size} = logl(X, [], 0), + case fwrite(FdC, FileName, Bs, Size) of + {ok, NewFdC} -> + {ok, Size, NewFdC}; + Error -> + Error + end. + +-spec logl([binary()]) -> {iolist(), non_neg_integer()}. +logl(X) -> + logl(X, [], 0). + +logl([X | T], Bs, Size) -> + Sz = byte_size(X), + BSz = <<Sz:?SIZESZ/unit:8>>, + NBs = case Sz < ?MIN_MD5_TERM of + true -> + [Bs, BSz, ?BIGMAGICHEAD | X]; + false -> + MD5 = erlang:md5(BSz), + [Bs, BSz, ?BIGMAGICHEAD, MD5 | X] + end, + logl(T, NBs, Size + ?HEADERSZ + Sz); +logl([], Bs, Size) -> + {Bs, Size}. + +%% -> {ok, NewFdC} | {Error, NewFdC} +write_cache(#cache{fd = Fd, c = C}, FName) -> + erase(write_cache_timer_is_running), + write_cache(Fd, FName, C). + +%% -> {Reply, NewFdC}; Reply = ok | Error +sync(FdC, FName) -> + fsync(FdC, FName). + +%% -> {Reply, NewFdC}; Reply = ok | Error +truncate(FdC, FileName, Head) -> + Reply = truncate_at(FdC, FileName, ?HEADSZ), + case Reply of + {ok, _} when Head =:= none -> + Reply; + {ok, FdC1} -> + {ok, B} = Head, + case log(FdC1, FileName, [B]) of + {ok, _NoBytes, NewFdC} -> + {ok, NewFdC}; + Reply2 -> + Reply2 + end; + _ -> + Reply + end. + +%% -> {NewFdC, Reply}, Reply = {Cont, Binaries} | {error, Reason} | eof +chunk(FdC, FileName, Pos, B, N) when is_binary(B) -> + true = byte_size(B) >= ?HEADERSZ, + do_handle_chunk(FdC, FileName, Pos, B, N); +chunk(FdC, FileName, Pos, NoBytes, N) -> + MaxNoBytes = case NoBytes of + [] -> ?MAX_CHUNK_SIZE; + _ -> erlang:max(NoBytes, ?MAX_CHUNK_SIZE) + end, + case read_chunk(FdC, FileName, Pos, MaxNoBytes) of + {NewFdC, {ok, Bin}} when byte_size(Bin) < ?HEADERSZ -> + {NewFdC, {error, {corrupt_log_file, FileName}}}; + {NewFdC, {ok, Bin}} when NoBytes =:= []; byte_size(Bin) >= NoBytes -> + NewPos = Pos + byte_size(Bin), + do_handle_chunk(NewFdC, FileName, NewPos, Bin, N); + {NewFdC, {ok, _Bin}} -> + {NewFdC, {error, {corrupt_log_file, FileName}}}; + {NewFdC, eof} when is_integer(NoBytes) -> % "cannot happen" + {NewFdC, {error, {corrupt_log_file, FileName}}}; + Other -> % eof or error + Other + end. + +do_handle_chunk(FdC, FileName, Pos, B, N) -> + case handle_chunk(B, Pos, N, []) of + corrupt -> + {FdC, {error, {corrupt_log_file, FileName}}}; + {C, []} -> + chunk(FdC, FileName, C#continuation.pos, C#continuation.b, N); + C_Ack -> + {FdC, C_Ack} + end. + +handle_chunk(B, Pos, 0, Ack) when byte_size(B) >= ?HEADERSZ -> + {#continuation{pos = Pos, b = B}, Ack}; +handle_chunk(B= <<Size:?SIZESZ/unit:8, ?BIGMAGICINT:?MAGICSZ/unit:8, + Tail/binary>>, Pos, N, Ack) when Size < ?MIN_MD5_TERM -> + case Tail of + <<BinTerm:Size/binary, Tail2/binary>> -> + %% The client calls binary_to_term/1. + handle_chunk(Tail2, Pos, N-1, [BinTerm | Ack]); + _ -> + BytesToRead = Size + ?HEADERSZ, + {#continuation{pos = Pos - byte_size(B), b = BytesToRead}, Ack} + end; +handle_chunk(B= <<Size:?SIZESZ/unit:8, ?BIGMAGICINT:?MAGICSZ/unit:8, + Tail/binary>>, Pos, _N, Ack) -> % when Size >= ?MIN_MD5_TERM + MD5 = erlang:md5(<<Size:?SIZESZ/unit:8>>), + case Tail of + %% The requested object is always bigger than a chunk. + <<MD5:16/binary, Bin:Size/binary>> -> + {#continuation{pos = Pos, b = []}, [Bin | Ack]}; + <<MD5:16/binary, _/binary>> -> + BytesToRead = Size + ?HEADERSZ + 16, + {#continuation{pos = Pos - byte_size(B), b = BytesToRead}, Ack}; + _ when byte_size(Tail) >= 16 -> + corrupt; + _ -> + {#continuation{pos = Pos - byte_size(B), b = []}, Ack} + end; +handle_chunk(B= <<Size:?SIZESZ/unit:8, ?MAGICINT:?MAGICSZ/unit:8, Tail/binary>>, + Pos, N, Ack) -> + %% Version 2, before 2(a). + case Tail of + <<BinTerm:Size/binary, Tail2/binary>> -> + handle_chunk(Tail2, Pos, N-1, [BinTerm | Ack]); + _ -> + %% We read the whole thing into one binary, even if Size is huge. + BytesToRead = Size + ?HEADERSZ, + {#continuation{pos = Pos - byte_size(B), b = BytesToRead}, Ack} + end; +handle_chunk(B, _Pos, _N, _Ack) when byte_size(B) >= ?HEADERSZ -> + corrupt; +handle_chunk(B, Pos, _N, Ack) -> + {#continuation{pos = Pos-byte_size(B), b = []}, Ack}. + +read_chunk(FdC, FileName, Pos, MaxBytes) -> + {FdC1, R} = pread(FdC, FileName, Pos + ?HEADSZ, MaxBytes), + case position(FdC1, FileName, eof) of + {ok, NewFdC, _Pos} -> + {NewFdC, R}; + {Error, NewFdC} -> + {NewFdC, Error} + end. + +%% Used by wrap_log_reader. +%% -> {NewFdC, Reply}, +%% Reply = {Cont, Binaries, Bad} (Bad >= 0) | {error, Reason} | eof +chunk_read_only(FdC = #cache{}, FileName, Pos, B, N) -> + do_chunk_read_only(FdC, FileName, Pos, B, N); +chunk_read_only(Fd, FileName, Pos, B, N) -> + %% wrap_log_reader calling... + FdC = #cache{fd = Fd}, + {_NFdC, Reply} = do_chunk_read_only(FdC, FileName, Pos, B, N), + Reply. + +do_chunk_read_only(FdC, FileName, Pos, B, N) when is_binary(B) -> + true = byte_size(B) >= ?HEADERSZ, + do_handle_chunk_ro(FdC, FileName, Pos, B, N); +do_chunk_read_only(FdC, FileName, Pos, NoBytes, N) -> + MaxNoBytes = case NoBytes of + [] -> ?MAX_CHUNK_SIZE; + _ -> erlang:max(NoBytes, ?MAX_CHUNK_SIZE) + end, + case read_chunk_ro(FdC, FileName, Pos, MaxNoBytes) of + {NewFdC, {ok, Bin}} when byte_size(Bin) < ?HEADERSZ -> + NewCont = #continuation{pos = Pos+byte_size(Bin), b = []}, + {NewFdC, {NewCont, [], byte_size(Bin)}}; + {NewFdC, {ok, Bin}} when NoBytes =:= []; byte_size(Bin) >= NoBytes -> + NewPos = Pos + byte_size(Bin), + do_handle_chunk_ro(NewFdC, FileName, NewPos, Bin, N); + {NewFdC, {ok, Bin}} -> + NewCont = #continuation{pos = Pos+byte_size(Bin), b = []}, + {NewFdC, {NewCont, [], byte_size(Bin)-?HEADERSZ}}; + {NewFdC, eof} when is_integer(NoBytes) -> % "cannot happen" + {NewFdC, eof}; % what else? + Other -> + Other + end. + +do_handle_chunk_ro(FdC, FileName, Pos, B, N) -> + case handle_chunk_ro(B, Pos, N, [], 0) of + {C, [], 0} -> + #continuation{pos = NewPos, b = NoBytes} = C, + do_chunk_read_only(FdC, FileName, NewPos, NoBytes, N); + C_Ack_Bad -> + {FdC, C_Ack_Bad} + end. + +handle_chunk_ro(B, Pos, 0, Ack, Bad) when byte_size(B) >= ?HEADERSZ -> + {#continuation{pos = Pos, b = B}, Ack, Bad}; +handle_chunk_ro(B= <<Size:?SIZESZ/unit:8, ?BIGMAGICINT:?MAGICSZ/unit:8, + Tail/binary>>, Pos, N, Ack, Bad) when Size < ?MIN_MD5_TERM -> + case Tail of + <<BinTerm:Size/binary, Tail2/binary>> -> + handle_chunk_ro(Tail2, Pos, N-1, [BinTerm | Ack], Bad); + _ -> + BytesToRead = Size + ?HEADERSZ, + {#continuation{pos = Pos - byte_size(B), b = BytesToRead}, Ack, Bad} + end; +handle_chunk_ro(B= <<Size:?SIZESZ/unit:8, ?BIGMAGICINT:?MAGICSZ/unit:8, + Tail/binary>>, Pos, N, Ack, Bad) -> % when Size>=?MIN_MD5_TERM + MD5 = erlang:md5(<<Size:?SIZESZ/unit:8>>), + case Tail of + <<MD5:16/binary, Bin:Size/binary>> -> + %% The requested object is always bigger than a chunk. + {#continuation{pos = Pos, b = []}, [Bin | Ack], Bad}; + <<MD5:16/binary, _/binary>> -> + BytesToRead = Size + ?HEADERSZ + 16, + {#continuation{pos = Pos - byte_size(B), b = BytesToRead}, Ack, Bad}; + <<_BadMD5:16/binary, _:1/unit:8, Tail2/binary>> -> + handle_chunk_ro(Tail2, Pos, N-1, Ack, Bad+1); + _ -> + {#continuation{pos = Pos - byte_size(B), b = []}, Ack, Bad} + end; +handle_chunk_ro(B= <<Size:?SIZESZ/unit:8, ?MAGICINT:?MAGICSZ/unit:8, + Tail/binary>>, Pos, N, Ack, Bad) -> + %% Version 2, before 2(a). + case Tail of + <<BinTerm:Size/binary, Tail2/binary>> -> + handle_chunk_ro(Tail2, Pos, N-1, [BinTerm | Ack], Bad); + _ -> + %% We read the whole thing into one binary, even if Size is huge. + BytesToRead = Size + ?HEADERSZ, + {#continuation{pos = Pos - byte_size(B), b = BytesToRead}, Ack, Bad} + end; +handle_chunk_ro(B, Pos, N, Ack, Bad) when byte_size(B) >= ?HEADERSZ -> + <<_:1/unit:8, B2/binary>> = B, + handle_chunk_ro(B2, Pos, N-1, Ack, Bad+1); +handle_chunk_ro(B, Pos, _N, Ack, Bad) -> + {#continuation{pos = Pos-byte_size(B), b = []}, Ack, Bad}. + +read_chunk_ro(FdC, FileName, Pos, MaxBytes) -> + pread(FdC, FileName, Pos + ?HEADSZ, MaxBytes). + +%% -> ok | throw(Error) +close(#cache{fd = Fd, c = []}, _FileName, read_only) -> + file:close(Fd); +close(#cache{fd = Fd, c = C}, FileName, read_write) -> + {Reply, _NewFdC} = write_cache(Fd, FileName, C), + mark(Fd, FileName, ?CLOSED), + file:close(Fd), + if Reply =:= ok -> ok; true -> throw(Reply) end. + +%% Open an internal file. Head is ignored if Mode is read_only. +%% int_open(FileName, Repair, Mode, Head) -> +%% {ok, {Alloc, FdC, HeadSize, FileSize}} +%% | {repaired, FdC, Terms, BadBytes, FileSize} +%% | throw(Error) +%% Alloc = new | existed +%% HeadSize = {NumberOfItemsWritten, NumberOfBytesWritten} +%% (HeadSize is equal {0, 0} if Alloc =:= existed, or no header written.) +int_open(FName, truncate, read_write, Head) -> + new_int_file(FName, Head); +int_open(FName, Repair, read_write, Head) -> + case open_read(FName) of + {ok, Fd} -> %% File exists + case file:read(Fd, ?HEADSZ) of + {ok, FileHead} -> + case is_head(FileHead) of + yes -> + file:close(Fd), + case open_update(FName) of + {ok, Fd2} -> + mark(Fd2, FName, ?OPENED), + FdC1 = #cache{fd = Fd2}, + {FdC, P} = position_close(FdC1, FName,eof), + {ok, {existed, FdC, {0, 0}, P}}; + Error -> + file_error(FName, Error) + end; + yes_not_closed when Repair -> + repair(Fd, FName); + yes_not_closed when not Repair -> + file:close(Fd), + throw({error, {need_repair, FName}}); + no -> + file:close(Fd), + throw({error, {not_a_log_file, FName}}) + end; + eof -> + file:close(Fd), + throw({error, {not_a_log_file, FName}}); + Error -> + file_error_close(Fd, FName, Error) + end; + _Other -> + new_int_file(FName, Head) + end; +int_open(FName, _Repair, read_only, _Head) -> + case open_read(FName) of + {ok, Fd} -> %% File exists + case file:read(Fd, ?HEADSZ) of + {ok, Head} -> + case is_head(Head) of + yes -> + {ok, P} = position_close2(Fd, FName, eof), + FdC = #cache{fd = Fd}, + {ok, {existed, FdC, {0, 0}, P}}; + yes_not_closed -> + {ok, P} = position_close2(Fd, FName, eof), + FdC = #cache{fd = Fd}, + {ok, {existed, FdC, {0, 0}, P}}; + no -> + file:close(Fd), + throw({error, {not_a_log_file, FName}}) + end; + eof -> + file:close(Fd), + throw({error, {not_a_log_file, FName}}); + Error -> + file_error_close(Fd, FName, Error) + end; + Error -> + file_error(FName, Error) + end. + +new_int_file(FName, Head) -> + case open_update(FName) of + {ok, Fd} -> + ok = truncate_at_close2(Fd, FName, bof), + fwrite_close2(Fd, FName, [?LOGMAGIC, ?OPENED]), + {FdC1, Nh, HeadSz} = int_log_head(Fd, Head), + {FdC, FileSize} = position_close(FdC1, FName, cur), + {ok, {new, FdC, {Nh, ?HEADERSZ + HeadSz}, FileSize}}; + Error -> + file_error(FName, Error) + end. + +%% -> {FdC, NoItemsWritten, NoBytesWritten} | throw(Error) +int_log_head(Fd, Head) -> + case lh(Head, internal) of + {ok, BinHead} -> + {Bs, Size} = logl([BinHead]), + {ok, FdC} = fwrite_header(Fd, Bs, Size), + {FdC, 1, Size}; + none -> + {#cache{fd = Fd}, 0, 0}; + Error -> + file:close(Fd), + throw(Error) + end. + +%% Open an external file. +%% -> {ok, {Alloc, FdC, HeadSize}, FileSize} | throw(Error) +ext_open(FName, truncate, read_write, Head) -> + new_ext_file(FName, Head); +ext_open(FName, _Repair, read_write, Head) -> + case file:read_file_info(FName) of + {ok, _FileInfo} -> + case open_update(FName) of + {ok, Fd} -> + {ok, P} = position_close2(Fd, FName, eof), + FdC = #cache{fd = Fd}, + {ok, {existed, FdC, {0, 0}, P}}; + Error -> + file_error(FName, Error) + end; + _Other -> + new_ext_file(FName, Head) + end; +ext_open(FName, _Repair, read_only, _Head) -> + case open_read(FName) of + {ok, Fd} -> + {ok, P} = position_close2(Fd, FName, eof), + FdC = #cache{fd = Fd}, + {ok, {existed, FdC, {0, 0}, P}}; + Error -> + file_error(FName, Error) + end. + +new_ext_file(FName, Head) -> + case open_truncate(FName) of + {ok, Fd} -> + {FdC1, HeadSize} = ext_log_head(Fd, Head), + {FdC, FileSize} = position_close(FdC1, FName, cur), + {ok, {new, FdC, HeadSize, FileSize}}; + Error -> + file_error(FName, Error) + end. + +%% -> {FdC, {NoItemsWritten, NoBytesWritten}} | throw(Error) +ext_log_head(Fd, Head) -> + case lh(Head, external) of + {ok, BinHead} -> + Size = byte_size(BinHead), + {ok, FdC} = fwrite_header(Fd, BinHead, Size), + {FdC, {1, Size}}; + none -> + {#cache{fd = Fd}, {0, 0}}; + Error -> + file:close(Fd), + throw(Error) + end. + +%% -> _Any | throw() +mark(Fd, FileName, What) -> + position_close2(Fd, FileName, 4), + fwrite_close2(Fd, FileName, What). + +%% -> {ok, Bin} | Error +lh({ok, Bin}, _Format) -> + {ok, Bin}; +lh({M, F, A}, Format) when is_list(A) -> + case catch apply(M, F, A) of + {ok, Head} when Format =:= internal -> + {ok, term_to_binary(Head)}; + {ok, Bin} when is_binary(Bin) -> + {ok, Bin}; + {ok, Bytes} -> + case catch list_to_binary(Bytes) of + {'EXIT', _} -> + {error, {invalid_header, {{M,F,A}, {ok, Bytes}}}}; + Bin -> + {ok, Bin} + end; + {'EXIT', Error} -> + {error, {invalid_header, {{M,F,A}, Error}}}; + Error -> + {error, {invalid_header, {{M,F,A}, Error}}} + end; +lh({M, F, A}, _Format) -> % cannot happen + {error, {invalid_header, {M, F, A}}}; +lh(none, _Format) -> + none; +lh(H, _F) -> % cannot happen + {error, {invalid_header, H}}. + +repair(In, File) -> + FSz = file_size(File), + error_logger:info_msg("disk_log: repairing ~p ...\n", [File]), + Tmp = add_ext(File, "TMP"), + {ok, {_Alloc, Out, {0, _}, _FileSize}} = new_int_file(Tmp, none), + scan_f_read(<<>>, In, Out, File, FSz, Tmp, ?MAX_CHUNK_SIZE, 0, 0). + +scan_f_read(B, In, Out, File, FSz, Tmp, MaxBytes, No, Bad) -> + case file:read(In, MaxBytes) of + eof -> + done_scan(In, Out, Tmp, File, No, Bad+byte_size(B)); + {ok, Bin} -> + NewBin = list_to_binary([B, Bin]), + {NB, NMax, Ack, NNo, NBad} = + scan_f(NewBin, FSz, [], No, Bad), + case log(Out, Tmp, lists:reverse(Ack)) of + {ok, _Size, NewOut} -> + scan_f_read(NB, In, NewOut, File, FSz, Tmp, NMax,NNo,NBad); + {{error, {file_error, _Filename, Error}}, NewOut} -> + repair_err(In, NewOut, Tmp, File, {error, Error}) + end; + Error -> + repair_err(In, Out, Tmp, File, Error) + end. + +scan_f(B = <<Size:?SIZESZ/unit:8, ?BIGMAGICINT:?MAGICSZ/unit:8, Tail/binary>>, + FSz, Ack, No, Bad) when Size < ?MIN_MD5_TERM -> + scan_f2(B, FSz, Ack, No, Bad, Size, Tail); +scan_f(B = <<Size:?SIZESZ/unit:8, ?BIGMAGICINT:?MAGICSZ/unit:8, Tail/binary>>, + FSz, Ack, No, Bad) -> % when Size >= ?MIN_MD5_TERM + MD5 = erlang:md5(<<Size:?SIZESZ/unit:8>>), + case Tail of + <<MD5:16/binary, BinTerm:Size/binary, Tail2/binary>> -> + case catch binary_to_term(BinTerm) of + {'EXIT', _} -> + scan_f(Tail2, FSz, Ack, No, Bad+Size); + _Term -> + scan_f(Tail2, FSz, [BinTerm | Ack], No+1, Bad) + end; + <<MD5:16/binary, _/binary>> -> + {B, Size-byte_size(Tail)+16, Ack, No, Bad}; + _ when byte_size(Tail) < 16 -> + {B, Size-byte_size(Tail)+16, Ack, No, Bad}; + _ -> + <<_:8, B2/binary>> = B, + scan_f(B2, FSz, Ack, No, Bad+1) + end; +scan_f(B = <<Size:?SIZESZ/unit:8, ?MAGICINT:?MAGICSZ/unit:8, Tail/binary>>, + FSz, Ack, No, Bad) when Size =< FSz -> + %% Since the file is not compressed, the item size cannot exceed + %% the file size. + scan_f2(B, FSz, Ack, No, Bad, Size, Tail); +scan_f(B = <<_:?HEADERSZ/unit:8, _/binary>>, FSz, Ack, No, Bad) -> + <<_:8, B2/binary>> = B, + scan_f(B2, FSz, Ack, No, Bad + 1); +scan_f(B, _FSz, Ack, No, Bad) -> + {B, ?MAX_CHUNK_SIZE, Ack, No, Bad}. + +scan_f2(B, FSz, Ack, No, Bad, Size, Tail) -> + case Tail of + <<BinTerm:Size/binary, Tail2/binary>> -> + case catch binary_to_term(BinTerm) of + {'EXIT', _} -> + <<_:8, B2/binary>> = B, + scan_f(B2, FSz, Ack, No, Bad+1); + _Term -> + scan_f(Tail2, FSz, [BinTerm | Ack], No+1, Bad) + end; + _ -> + {B, Size-byte_size(Tail), Ack, No, Bad} + end. + +done_scan(In, Out, OutName, FName, RecoveredTerms, BadChars) -> + file:close(In), + case catch fclose(Out, OutName) of + ok -> + case file:rename(OutName, FName) of + ok -> + case open_update(FName) of + {ok, New} -> + {ok, P} = position_close2(New, FName, eof), + FdC = #cache{fd = New}, + {repaired, FdC, RecoveredTerms, BadChars, P}; + Error -> + file_error(FName, Error) + end; + Error -> + file:delete(OutName), + file_error(FName, Error) + end; + Error -> + file:delete(OutName), + throw(Error) + end. + +repair_err(In, Out, OutName, ErrFileName, Error) -> + file:close(In), + catch fclose(Out, OutName), + % OutName is often the culprit, try to remove it anyway... + file:delete(OutName), + file_error(ErrFileName, Error). + +%% Used by wrap_log_reader. +-spec is_head(binary()) -> 'yes' | 'yes_not_closed' | 'no'. +is_head(<<M:4/binary, S:4/binary>>) when ?LOGMAGIC =:= M, ?CLOSED =:= S -> + yes; +is_head(<<M:4/binary, S:4/binary>>) when ?LOGMAGIC =:= M, ?OPENED =:= S -> + yes_not_closed; +is_head(Bin) when is_binary(Bin) -> + no. + +%%----------------------------------------------------------------- +%% Func: mf_int_open/7, mf_ext_open/7 +%% Args: FName = file:filename() +%% MaxB = integer() +%% MaxF = integer() +%% Repair = truncate | true | false +%% Mode = read_write | read_only +%% Head = none | {ok, Bin} | {M, F, A} +%% Version = integer() +%% Purpose: An ADT for wrapping logs. mf_int_ writes binaries (mf_ext_ +%% writes bytes) +%% to files called FName.1, FName.2, ..., FName.MaxF. +%% Writes MaxB bytes on each file. +%% Creates a file called Name.idx in the Dir. This +%% file contains the last written FileName as one byte, and +%% follwing that, the sizes of each file (size 0 number of items). +%% On startup, this file is read, and the next available +%% filename is used as first log file. +%% Reports can be browsed with Report Browser Tool (rb), or +%% read with disk_log. +%%----------------------------------------------------------------- +-spec mf_int_open(FName :: file:filename(), + MaxB :: integer(), + MaxF :: integer(), + Repair :: dlog_repair(), + Mode :: dlog_mode(), + Head :: dlog_head(), + Version :: integer()) + -> {'ok', #handle{}, integer()} + | {'repaired', #handle{}, + non_neg_integer(), non_neg_integer(), non_neg_integer()}. +%% | throw(FileError) +mf_int_open(FName, MaxB, MaxF, Repair, Mode, Head, Version) -> + {First, Sz, TotSz, NFiles} = read_index_file(Repair, FName, MaxF), + write_size_file(Mode, FName, MaxB, MaxF, Version), + NewMaxF = if + NFiles > MaxF -> + {MaxF, NFiles}; + true -> + MaxF + end, + case int_file_open(FName, First, 0, 0, Head, Repair, Mode) of + {ok, FdC, FileName, Lost, {NoItems, NoBytes}, FSz} -> + % firstPos = NoBytes is not always correct when the file + % existed, but it will have to do since we don't know + % where the header ends. + CurCnt = Sz + NoItems - Lost, + {ok, #handle{filename = FName, maxB = MaxB, + maxF = NewMaxF, curF = First, cur_fdc = FdC, + cur_name = FileName, cur_cnt = CurCnt, + acc_cnt = -Sz, curB = FSz, + firstPos = NoBytes, noFull = 0, accFull = 0}, + TotSz + CurCnt}; + {repaired, FdC, FileName, Rec, Bad, FSz} -> + {repaired, + #handle{filename = FName, maxB = MaxB, cur_name = FileName, + maxF = NewMaxF, curF = First, cur_fdc = FdC, + cur_cnt = Rec, acc_cnt = -Rec, curB = FSz, + firstPos = 0, noFull = 0, accFull = 0}, + Rec, Bad, TotSz + Rec} + end. + +%% -> {ok, handle(), Lost} | {error, Error, handle()} +mf_int_inc(Handle, Head) -> + #handle{filename = FName, cur_cnt = CurCnt, acc_cnt = AccCnt, + cur_name = FileName, curF = CurF, maxF = MaxF, + cur_fdc = CurFdC, noFull = NoFull} = Handle, + case catch wrap_int_log(FName, CurF, MaxF, CurCnt, Head) of + {NewF, NewMaxF, NewFdC, NewFileName, Nh, FirstPos, Lost} -> + Handle1 = Handle#handle{cur_fdc = NewFdC, curF = NewF, + cur_name = NewFileName, + cur_cnt = Nh, acc_cnt = AccCnt + CurCnt, + maxF = NewMaxF, firstPos = FirstPos, + curB = FirstPos, noFull = NoFull + 1}, + case catch close(CurFdC, FileName, read_write) of + ok -> + {ok, Handle1, Lost}; + Error -> % Error in the last file, new file opened. + {error, Error, Handle1} + end; + Error -> + {error, Error, Handle} + end. + +%% -> {ok, handle(), Logged, Lost, NoWraps} | {ok, handle(), Logged} +%% | {error, Error, handle(), Logged, Lost} +%% The returned handle is not always valid - something may +%% have been written before things went wrong. +mf_int_log(Handle, Bins, Head) -> + mf_int_log(Handle, Bins, Head, 0, []). + +mf_int_log(Handle, [], _Head, No, []) -> + {ok, Handle, No}; +mf_int_log(Handle, [], _Head, No, Wraps0) -> + Wraps = reverse(Wraps0), + {ok, Handle, No, sum(Wraps), Wraps}; +mf_int_log(Handle, Bins, Head, No0, Wraps) -> + #handle{curB = CurB, maxB = MaxB, cur_name = FileName, cur_fdc = CurFdC, + firstPos = FirstPos0, cur_cnt = CurCnt} = Handle, + {FirstBins, LastBins, NoBytes, N} = + int_split_bins(CurB, MaxB, FirstPos0, Bins), + case FirstBins of + [] -> + #handle{filename = FName, curF = CurF, maxF = MaxF, + acc_cnt = AccCnt, noFull = NoFull} = Handle, + case catch wrap_int_log(FName, CurF, MaxF, CurCnt, Head) of + {NewF, NewMaxF, NewFdC, NewFileName, Nh, FirstPos, Lost} -> + Handle1 = Handle#handle{cur_fdc = NewFdC, curF = NewF, + cur_cnt = Nh, + cur_name = NewFileName, + acc_cnt = AccCnt + CurCnt, + maxF = NewMaxF, + curB = FirstPos, + firstPos = FirstPos, + noFull = NoFull + 1}, + case catch close(CurFdC, FileName, read_write) of + ok -> + mf_int_log(Handle1, Bins, Head, No0 + Nh, + [Lost | Wraps]); + Error -> + Lost1 = Lost + sum(Wraps), + {error, Error, Handle1, No0 + Nh, Lost1} + end; + Error -> + {error, Error, Handle, No0, sum(Wraps)} + end; + _ -> + case fwrite(CurFdC, FileName, FirstBins, NoBytes) of + {ok, NewCurFdC} -> + Handle1 = Handle#handle{cur_fdc = NewCurFdC, + curB = CurB + NoBytes, + cur_cnt = CurCnt + N}, + mf_int_log(Handle1, LastBins, Head, No0 + N, Wraps); + {Error, NewCurFdC} -> + Handle1 = Handle#handle{cur_fdc = NewCurFdC}, + {error, Error, Handle1, No0, sum(Wraps)} + end + end. + +wrap_int_log(FName, CurF, MaxF, CurCnt, Head) -> + {NewF, NewMaxF} = inc_wrap(FName, CurF, MaxF), + {ok, NewFdC, NewFileName, Lost, {Nh, FirstPos}, _FileSize} = + int_file_open(FName, NewF, CurF, CurCnt, Head), + {NewF, NewMaxF, NewFdC, NewFileName, Nh, FirstPos, Lost}. + +%% -> {NewHandle, Reply}, Reply = {Cont, Binaries} | {error, Reason} | eof +mf_int_chunk(Handle, 0, Bin, N) -> + FirstF = find_first_file(Handle), + mf_int_chunk(Handle, {FirstF, 0}, Bin, N); +mf_int_chunk(#handle{curF = FileNo, cur_fdc = FdC, cur_name = FileName} + = Handle, {FileNo, Pos}, Bin, N) -> + {NewFdC, Reply} = chunk(FdC, FileName, Pos, Bin, N), + {Handle#handle{cur_fdc = NewFdC}, conv(Reply, FileNo)}; +mf_int_chunk(Handle, {FileNo, Pos}, Bin, N) -> + FName = add_ext(Handle#handle.filename, FileNo), + NFileNo = inc(FileNo, Handle#handle.maxF), + case catch int_open(FName, true, read_only, any) of + {error, _Reason} -> + error_logger:info_msg("disk_log: chunk error. File ~p missing.\n\n", + [FName]), + mf_int_chunk(Handle, {NFileNo, 0}, [], N); + {ok, {_Alloc, FdC, _HeadSize, _FileSize}} -> + case chunk(FdC, FName, Pos, Bin, N) of + {NewFdC, eof} -> + file:close(NewFdC#cache.fd), + mf_int_chunk(Handle, {NFileNo, 0}, [], N); + {NewFdC, Other} -> + file:close(NewFdC#cache.fd), + {Handle, conv(Other, FileNo)} + end + end. + +%% -> {NewHandle, Reply}, +%% Reply = {Cont, Binaries, Bad} (Bad >= 0) | {error, Reason} | eof +mf_int_chunk_read_only(Handle, 0, Bin, N) -> + FirstF = find_first_file(Handle), + mf_int_chunk_read_only(Handle, {FirstF, 0}, Bin, N); +mf_int_chunk_read_only(#handle{curF = FileNo, cur_fdc = FdC, cur_name=FileName} + = Handle, {FileNo, Pos}, Bin, N) -> + {NewFdC, Reply} = do_chunk_read_only(FdC, FileName, Pos, Bin, N), + {Handle#handle{cur_fdc = NewFdC}, conv(Reply, FileNo)}; +mf_int_chunk_read_only(Handle, {FileNo, Pos}, Bin, N) -> + FName = add_ext(Handle#handle.filename, FileNo), + NFileNo = inc(FileNo, Handle#handle.maxF), + case catch int_open(FName, true, read_only, any) of + {error, _Reason} -> + error_logger:info_msg("disk_log: chunk error. File ~p missing.\n\n", + [FName]), + mf_int_chunk_read_only(Handle, {NFileNo, 0}, [], N); + {ok, {_Alloc, FdC, _HeadSize, _FileSize}} -> + case do_chunk_read_only(FdC, FName, Pos, Bin, N) of + {NewFdC, eof} -> + file:close(NewFdC#cache.fd), + mf_int_chunk_read_only(Handle, {NFileNo,0}, [], N); + {NewFdC, Other} -> + file:close(NewFdC#cache.fd), + {Handle, conv(Other, FileNo)} + end + end. + +%% -> {ok, Cont} | Error +mf_int_chunk_step(Handle, 0, Step) -> + FirstF = find_first_file(Handle), + mf_int_chunk_step(Handle, {FirstF, 0}, Step); +mf_int_chunk_step(Handle, {FileNo, _Pos}, Step) -> + NFileNo = inc(FileNo, Handle#handle.maxF, Step), + FileName = add_ext(Handle#handle.filename, NFileNo), + case file:read_file_info(FileName) of + {ok, _FileInfo} -> + {ok, #continuation{pos = {NFileNo, 0}, b = []}}; + _Error -> + {error, end_of_log} + end. + +%% -> {Reply, handle()}; Reply = ok | Error +mf_write_cache(#handle{filename = FName, cur_fdc = FdC} = Handle) -> + erase(write_cache_timer_is_running), + #cache{fd = Fd, c = C} = FdC, + {Reply, NewFdC} = write_cache(Fd, FName, C), + {Reply, Handle#handle{cur_fdc = NewFdC}}. + +%% -> {Reply, handle()}; Reply = ok | Error +mf_sync(#handle{filename = FName, cur_fdc = FdC} = Handle) -> + {Reply, NewFdC} = fsync(FdC, FName), + {Reply, Handle#handle{cur_fdc = NewFdC}}. + +%% -> ok | throw(FileError) +mf_int_close(#handle{filename = FName, curF = CurF, cur_name = FileName, + cur_fdc = CurFdC, cur_cnt = CurCnt}, Mode) -> + close(CurFdC, FileName, Mode), + write_index_file(Mode, FName, CurF, CurF, CurCnt), + ok. + +%% -> {ok, handle(), Cnt} | throw(FileError) +mf_ext_open(FName, MaxB, MaxF, Repair, Mode, Head, Version) -> + {First, Sz, TotSz, NFiles} = read_index_file(Repair, FName, MaxF), + write_size_file(Mode, FName, MaxB, MaxF, Version), + NewMaxF = if + NFiles > MaxF -> + {MaxF, NFiles}; + true -> + MaxF + end, + {ok, FdC, FileName, Lost, {NoItems, NoBytes}, CurB} = + ext_file_open(FName, First, 0, 0, Head, Repair, Mode), + CurCnt = Sz + NoItems - Lost, + {ok, #handle{filename = FName, maxB = MaxB, cur_name = FileName, + maxF = NewMaxF, cur_cnt = CurCnt, acc_cnt = -Sz, + curF = First, cur_fdc = FdC, firstPos = NoBytes, + curB = CurB, noFull = 0, accFull = 0}, + TotSz + CurCnt}. + +%% -> {ok, handle(), Lost} +%% | {error, Error, handle()} +%% | throw(FatalError) +%% Fatal errors should always terminate the log. +mf_ext_inc(Handle, Head) -> + #handle{filename = FName, cur_cnt = CurCnt, cur_name = FileName, + acc_cnt = AccCnt, curF = CurF, maxF = MaxF, cur_fdc = CurFdC, + noFull = NoFull} = Handle, + case catch wrap_ext_log(FName, CurF, MaxF, CurCnt, Head) of + {NewF, NewMaxF, NewFdC, NewFileName, Nh, FirstPos, Lost} -> + Handle1 = Handle#handle{cur_fdc = NewFdC, curF = NewF, + cur_name = NewFileName, + cur_cnt = Nh, acc_cnt = AccCnt + CurCnt, + maxF = NewMaxF, firstPos = FirstPos, + curB = FirstPos, noFull = NoFull + 1}, + case catch fclose(CurFdC, FileName) of + ok -> + {ok, Handle1, Lost}; + Error -> % Error in the last file, new file opened. + {error, Error, Handle1} + end; + Error -> + {error, Error, Handle} + end. + +%% -> {ok, handle(), Logged, Lost, NoWraps} | {ok, handle(), Logged} +%% | {error, Error, handle(), Logged, Lost} + +%% The returned handle is not always valid - +%% something may have been written before things went wrong. +mf_ext_log(Handle, Bins, Head) -> + mf_ext_log(Handle, Bins, Head, 0, []). + +mf_ext_log(Handle, [], _Head, No, []) -> + {ok, Handle, No}; +mf_ext_log(Handle, [], _Head, No, Wraps0) -> + Wraps = reverse(Wraps0), + {ok, Handle, No, sum(Wraps), Wraps}; +mf_ext_log(Handle, Bins, Head, No0, Wraps) -> + #handle{curB = CurB, maxB = MaxB, cur_name = FileName, cur_fdc = CurFdC, + firstPos = FirstPos0, cur_cnt = CurCnt} = Handle, + {FirstBins, LastBins, NoBytes, N} = + ext_split_bins(CurB, MaxB, FirstPos0, Bins), + case FirstBins of + [] -> + #handle{filename = FName, curF = CurF, maxF = MaxF, + acc_cnt = AccCnt, noFull = NoFull} = Handle, + case catch wrap_ext_log(FName, CurF, MaxF, CurCnt, Head) of + {NewF, NewMaxF, NewFdC, NewFileName, Nh, FirstPos, Lost} -> + Handle1 = Handle#handle{cur_fdc = NewFdC, curF = NewF, + cur_cnt = Nh, + cur_name = NewFileName, + acc_cnt = AccCnt + CurCnt, + maxF = NewMaxF, + curB = FirstPos, + firstPos = FirstPos, + noFull = NoFull + 1}, + case catch fclose(CurFdC, FileName) of + ok -> + mf_ext_log(Handle1, Bins, Head, No0 + Nh, + [Lost | Wraps]); + Error -> + Lost1 = Lost + sum(Wraps), + {error, Error, Handle1, No0 + Nh, Lost1} + end; + Error -> + {error, Error, Handle, No0, sum(Wraps)} + end; + _ -> + case fwrite(CurFdC, FileName, FirstBins, NoBytes) of + {ok, NewCurFdC} -> + Handle1 = Handle#handle{cur_fdc = NewCurFdC, + curB = CurB + NoBytes, + cur_cnt = CurCnt + N}, + mf_ext_log(Handle1, LastBins, Head, No0 + N, Wraps); + {Error, NewCurFdC} -> + Handle1 = Handle#handle{cur_fdc = NewCurFdC}, + {error, Error, Handle1, No0, sum(Wraps)} + end + end. + +wrap_ext_log(FName, CurF, MaxF, CurCnt, Head) -> + {NewF, NewMaxF} = inc_wrap(FName, CurF, MaxF), + {ok, NewFdC, NewFileName, Lost, {Nh, FirstPos}, _FileSize} = + ext_file_open(FName, NewF, CurF, CurCnt, Head), + {NewF, NewMaxF, NewFdC, NewFileName, Nh, FirstPos, Lost}. + +%% -> ok | throw(FileError) +mf_ext_close(#handle{filename = FName, curF = CurF, + cur_fdc = CurFdC, cur_cnt = CurCnt}, Mode) -> + Res = (catch fclose(CurFdC, FName)), + write_index_file(Mode, FName, CurF, CurF, CurCnt), + Res. + +%% -> {ok, handle()} | throw(FileError) +change_size_wrap(Handle, {NewMaxB, NewMaxF}, Version) -> + FName = Handle#handle.filename, + {_MaxB, MaxF} = get_wrap_size(Handle), + write_size_file(read_write, FName, NewMaxB, NewMaxF, Version), + if + NewMaxF > MaxF -> + remove_files(FName, MaxF + 1, NewMaxF), + {ok, Handle#handle{maxB = NewMaxB, maxF = NewMaxF}}; + NewMaxF < MaxF -> + {ok, Handle#handle{maxB = NewMaxB, maxF = {NewMaxF, MaxF}}}; + true -> + {ok, Handle#handle{maxB = NewMaxB, maxF = NewMaxF}} + end. + +%%----------------------------------------------------------------- +%% Misc functions +%%----------------------------------------------------------------- +%% -> {ok, FdC, FileName, Lost, HeadSize, FileSize} | throw(Error) +int_file_open(FName, NewFile, OldFile, OldCnt, Head) -> + Repair = truncate, Mode = read_write, + int_file_open(FName, NewFile, OldFile, OldCnt, Head, Repair, Mode). + +%% -> {ok, FdC, FileName, Lost, HeadSize, FileSize} +%% | {repaired, FdC, FileName, Rec, Bad, FileSize} +%% | throw(Error) +int_file_open(FName, NewFile, OldFile, OldCnt, Head, Repair, Mode) -> + N = add_ext(FName, NewFile), + case int_open(N, Repair, Mode, Head) of + {ok, {_Alloc, FdC, HeadSize, FileSize}} -> + Lost = write_index_file(Mode, FName, NewFile, OldFile, OldCnt), + {ok, FdC, N, Lost, HeadSize, FileSize}; + {repaired, FdC, Recovered, BadBytes, FileSize} -> + write_index_file(Mode, FName, NewFile, OldFile, OldCnt), + {repaired, FdC, N, Recovered, BadBytes, FileSize} + end. + +%% -> {ok, FdC, FileName, Lost, HeadSize, FileSize} | throw(Error) +ext_file_open(FName, NewFile, OldFile, OldCnt, Head) -> + Repair = truncate, Mode = read_write, + ext_file_open(FName, NewFile, OldFile, OldCnt, Head, Repair, Mode). + +ext_file_open(FName, NewFile, OldFile, OldCnt, Head, Repair, Mode) -> + FileName = add_ext(FName, NewFile), + {ok, {_Alloc, FdC, HeadSize, FileSize}} = + ext_open(FileName, Repair, Mode, Head), + Lost = write_index_file(Mode, FName, NewFile, OldFile, OldCnt), + {ok, FdC, FileName, Lost, HeadSize, FileSize}. + +%%----------------------------------------------------------------- +%% The old file format for index file (CurFileNo > 0), Version 0: +%% +%% CurFileNo SizeFile1 SizeFile2 ... SizeFileN +%% 1 byte 4 bytes 4 bytes 4 bytes +%% +%% The new file format for index file (NewFormat = 0), version 1: +%% +%% NewFormat CurFileNo SizeFile1 SizeFile2 ... SizeFileN +%% 1 byte 4 bytes 4 bytes 4 bytes +%% +%% The current file format for index file (sizes in bytes), version 2: +%% +%% 0 (1) 0 (4) FileFormatVersion (1) CurFileNo (4) SizeFile1 (8) ... +%% +%% (SizeFileI refers to number of items on the log file.) +%%----------------------------------------------------------------- + +-define(index_file_name(F), add_ext(F, "idx")). + +read_index_file(truncate, FName, MaxF) -> + remove_files(FName, 2, MaxF), + file:delete(?index_file_name(FName)), + {1, 0, 0, 0}; +read_index_file(_, FName, _MaxF) -> + read_index_file(FName). + +%% Used by wrap_log_reader. +%% -> {CurFileNo, CurFileSz, TotSz, NoFiles} | throw(FileError) +%% where TotSz does not include CurFileSz. + +read_index_file(FName) -> + FileName = ?index_file_name(FName), + case open_read(FileName) of + {ok, Fd} -> + R = case file:read(Fd, ?MAX_CHUNK_SIZE) of + {ok, <<0, 0:32, Version, CurF:32, Tail/binary>>} + when Version =:= ?VERSION, + 0 < CurF, CurF < ?MAX_FILES -> + parse_index(CurF, Version, 1, Tail, Fd, 0, 0, 0); + {ok, <<0, CurF:32, Tail/binary>>} + when 0 < CurF, CurF < ?MAX_FILES -> + parse_index(CurF, 1, 1, Tail, Fd, 0, 0, 0); + {ok, <<CurF, Tail/binary>>} when 0 < CurF -> + parse_index(CurF, 1, 1, Tail, Fd, 0, 0, 0); + _ErrorOrEof -> + {1, 0, 0, 0} + end, + file:close(Fd), + R; + _Error -> + {1, 0, 0, 0} + end. + +parse_index(CurF, V, CurF, <<CurSz:64, Tail/binary>>, Fd, _, TotSz, NFiles) + when V =:= ?VERSION -> + parse_index(CurF, V, CurF+1, Tail, Fd, CurSz, TotSz, NFiles+1); +parse_index(CurF, V, N, <<Sz:64, Tail/binary>>, Fd, CurSz, TotSz, NFiles) + when V =:= ?VERSION -> + parse_index(CurF, V, N+1, Tail, Fd, CurSz, TotSz + Sz, NFiles+1); +parse_index(CurF, V, CurF, <<CurSz:32, Tail/binary>>, Fd, _, TotSz, NFiles) + when V < ?VERSION -> + parse_index(CurF, V, CurF+1, Tail, Fd, CurSz, TotSz, NFiles+1); +parse_index(CurF, V, N, <<Sz:32, Tail/binary>>, Fd, CurSz, TotSz, NFiles) + when V < ?VERSION -> + parse_index(CurF, V, N+1, Tail, Fd, CurSz, TotSz + Sz, NFiles+1); +parse_index(CurF, V, N, B, Fd, CurSz, TotSz, NFiles) -> + case file:read(Fd, ?MAX_CHUNK_SIZE) of + eof when 0 =:= byte_size(B) -> + {CurF, CurSz, TotSz, NFiles}; + {ok, Bin} -> + NewB = list_to_binary([B, Bin]), + parse_index(CurF, V, N, NewB, Fd, CurSz, TotSz, NFiles); + _ErrorOrEof -> + {1, 0, 0, 0} + end. + +%% Returns: Number of lost items (if an old file was truncated) +%% -> integer() | throw(FileError) +write_index_file(read_only, _FName, _NewFile, _OldFile, _OldCnt) -> + 0; +write_index_file(read_write, FName, NewFile, OldFile, OldCnt) -> + FileName = ?index_file_name(FName), + case open_update(FileName) of + {ok, Fd} -> + {Offset, SzSz} = + case file:read(Fd, 6) of + eof -> + Bin = <<0, 0:32, ?VERSION, NewFile:32>>, + fwrite_close2(Fd, FileName, Bin), + {10, 8}; + {ok, <<0, 0:32, _Version>>} -> + pwrite_close2(Fd, FileName, 6, <<NewFile:32>>), + {10, 8}; + {ok, <<0, _/binary>>} -> + pwrite_close2(Fd, FileName, 1, <<NewFile:32>>), + {5, 4}; + {ok, <<_,_/binary>>} -> + %% Very old format, convert to the latest format! + case file:read_file(FileName) of + {ok, <<_CurF, Tail/binary>>} -> + position_close2(Fd, FileName, bof), + Bin = <<0, 0:32, ?VERSION, NewFile:32>>, + NewTail = to_8_bytes(Tail, [], FileName, Fd), + fwrite_close2(Fd, FileName, [Bin | NewTail]), + {10, 8}; + Error -> + file_error_close(Fd, FileName, Error) + end; + Error -> + file_error_close(Fd, FileName, Error) + end, + + NewPos = Offset + (NewFile - 1)*SzSz, + OldCntBin = <<OldCnt:SzSz/unit:8>>, + if + OldFile > 0 -> + R = file:pread(Fd, NewPos, SzSz), + OldPos = Offset + (OldFile - 1)*SzSz, + pwrite_close2(Fd, FileName, OldPos, OldCntBin), + file:close(Fd), + case R of + {ok, <<Lost:SzSz/unit:8>>} -> Lost; + {ok, _} -> + throw({error, {invalid_index_file, FileName}}); + eof -> 0; + Error2 -> file_error(FileName, Error2) + end; + true -> + pwrite_close2(Fd, FileName, NewPos, OldCntBin), + file:close(Fd), + 0 + end; + E -> + file_error(FileName, E) + end. + +to_8_bytes(<<N:32,T/binary>>, NT, FileName, Fd) -> + to_8_bytes(T, [NT | <<N:64>>], FileName, Fd); +to_8_bytes(B, NT, _FileName, _Fd) when byte_size(B) =:= 0 -> + NT; +to_8_bytes(_B, _NT, FileName, Fd) -> + file:close(Fd), + throw({error, {invalid_index_file, FileName}}). + +%% -> ok | throw(FileError) +index_file_trunc(FName, N) -> + FileName = ?index_file_name(FName), + case open_update(FileName) of + {ok, Fd} -> + case file:read(Fd, 6) of + eof -> + file:close(Fd), + ok; + {ok, <<0, 0:32, Version>>} when Version =:= ?VERSION -> + truncate_index_file(Fd, FileName, 10, 8, N); + {ok, <<0, _/binary>>} -> + truncate_index_file(Fd, FileName, 5, 4, N); + {ok, <<_, _/binary>>} -> % cannot happen + truncate_index_file(Fd, FileName, 1, 4, N); + Error -> + file_error_close(Fd, FileName, Error) + end; + Error -> + file_error(FileName, Error) + end. + +truncate_index_file(Fd, FileName, Offset, N, SzSz) -> + Pos = Offset + N*SzSz, + case Pos > file_size(FileName) of + true -> + file:close(Fd); + false -> + truncate_at_close2(Fd, FileName, {bof, Pos}), + file:close(Fd) + end, + ok. + +print_index_file(File) -> + io:format("-- Index begin --~n"), + case file:read_file(File) of + {ok, <<0, 0:32, Version, CurF:32, Tail/binary>>} + when Version =:= ?VERSION, 0 < CurF, CurF < ?MAX_FILES -> + io:format("cur file: ~w~n", [CurF]), + loop_index(1, Version, Tail); + {ok, <<0, CurF:32, Tail/binary>>} when 0 < CurF, CurF < ?MAX_FILES -> + io:format("cur file: ~w~n", [CurF]), + loop_index(1, 1, Tail); + {ok, <<CurF, Tail/binary>>} when 0 < CurF -> + io:format("cur file: ~w~n", [CurF]), + loop_index(1, 1, Tail); + _Else -> + ok + end, + io:format("-- end --~n"). + +loop_index(N, V, <<Sz:64, Tail/binary>>) when V =:= ?VERSION -> + io:format(" ~p items: ~w~n", [N, Sz]), + loop_index(N+1, V, Tail); +loop_index(N, V, <<Sz:32, Tail/binary>>) when V < ?VERSION -> + io:format(" ~p items: ~w~n", [N, Sz]), + loop_index(N+1, V, Tail); +loop_index(_, _, _) -> + ok. + +-define(size_file_name(F), add_ext(F, "siz")). + +%% Version 0: no size file +%% Version 1: <<MaxSize:32, MaxFiles:32>> +%% Version 2: <<Version:8, MaxSize:64, MaxFiles:32>> + +%% -> ok | throw(FileError) +write_size_file(read_only, _FName, _NewSize, _NewMaxFiles, _Version) -> + ok; +write_size_file(read_write, FName, NewSize, NewMaxFiles, Version) -> + FileName = ?size_file_name(FName), + Bin = if + Version =:= ?VERSION -> + <<Version, NewSize:64, NewMaxFiles:32>>; + true -> + <<NewSize:32, NewMaxFiles:32>> + end, + case file:write_file(FileName, Bin) of + ok -> + ok; + E -> + file_error(FileName, E) + end. + +%% -> {NoBytes, NoFiles}. +read_size_file(FName) -> + {Size,_Version} = read_size_file_version(FName), + Size. + +%% -> {{NoBytes, NoFiles}, Version}, Version = integer() | undefined +read_size_file_version(FName) -> + case file:read_file(?size_file_name(FName)) of + {ok, <<Version, Size:64, MaxFiles:32>>} when Version =:= ?VERSION -> + {{Size, MaxFiles}, Version}; + {ok, <<Size:32, MaxFiles:32>>} -> + {{Size, MaxFiles}, 1}; + _ -> + %% The oldest version too... + {{0, 0}, ?VERSION} + end. + +conv({More, Terms}, FileNo) when is_record(More, continuation) -> + Cont = More#continuation{pos = {FileNo, More#continuation.pos}}, + {Cont, Terms}; +conv({More, Terms, Bad}, FileNo) when is_record(More, continuation) -> + Cont = More#continuation{pos = {FileNo, More#continuation.pos}}, + {Cont, Terms, Bad}; +conv(Other, _) -> + Other. + +find_first_file(#handle{filename = FName, curF = CurF, maxF = MaxF}) -> + fff(FName, inc(CurF, MaxF), CurF, MaxF). + +fff(_FName, CurF, CurF, _MaxF) -> CurF; +fff(FName, MaybeFirstF, CurF, MaxF) -> + N = add_ext(FName, MaybeFirstF), + case file:read_file_info(N) of + {ok, _} -> MaybeFirstF; + _ -> fff(FName, inc(MaybeFirstF, MaxF), CurF, MaxF) + end. + +%% -> {iolist(), LastBins, NoBytes, NoTerms} +ext_split_bins(CurB, MaxB, FirstPos, Bins) -> + MaxBs = MaxB - CurB, IsFirst = CurB =:= FirstPos, + ext_split_bins(MaxBs, IsFirst, [], Bins, 0, 0). + +ext_split_bins(MaxBs, IsFirst, First, [X | Last], Bs, N) -> + NBs = Bs + byte_size(X), + if + NBs =< MaxBs -> + ext_split_bins(MaxBs, IsFirst, [First | X], Last, NBs, N+1); + IsFirst, First =:= [] -> + % To avoid infinite loop - we allow the file to be + % too big if it's just one item on the file. + {[X], Last, NBs, N+1}; + true -> + {First, [X | Last], Bs, N} + end; +ext_split_bins(_, _, First, [], Bs, N) -> + {First, [], Bs, N}. + +%% -> {iolist(), LastBins, NoBytes, NoTerms} +int_split_bins(CurB, MaxB, FirstPos, Bins) -> + MaxBs = MaxB - CurB, IsFirst = CurB =:= FirstPos, + int_split_bins(MaxBs, IsFirst, [], Bins, 0, 0). + +int_split_bins(MaxBs, IsFirst, First, [X | Last], Bs, N) -> + Sz = byte_size(X), + NBs = Bs + Sz + ?HEADERSZ, + BSz = <<Sz:?SIZESZ/unit:8>>, + XB = case Sz < ?MIN_MD5_TERM of + true -> + [BSz, ?BIGMAGICHEAD | X]; + false -> + MD5 = erlang:md5(BSz), + [BSz, ?BIGMAGICHEAD, MD5 | X] + end, + if + NBs =< MaxBs -> + int_split_bins(MaxBs, IsFirst, [First | XB], Last, NBs, N+1); + IsFirst, First =:= [] -> + % To avoid infinite loop - we allow the file to be + % too big if it's just one item on the file. + {[XB], Last, NBs, N+1}; + true -> + {First, [X | Last], Bs, N} + end; +int_split_bins(_, _, First, [], Bs, N) -> + {First, [], Bs, N}. + +%% -> {NewCurrentFileNo, MaxFilesToBe} | throw(FileError) +inc_wrap(FName, CurF, MaxF) -> + case MaxF of + %% Number of max files has changed + {NewMaxF, OldMaxF} -> + if + CurF >= NewMaxF -> + %% We are at or above the new number of files + remove_files(FName, CurF + 1, OldMaxF), + if + CurF > NewMaxF -> + %% The change was done while the current file was + %% greater than the new number of files. + %% The index file is not trunctated here, since + %% writing the index file while opening the file + %% with index 1 will write the value for the file + %% with extension CurF as well. Next time the + %% limit is reached, the index file will be + %% truncated. + {1, {NewMaxF, CurF}}; + true -> + %% The change was done while the current file was + %% less than the new number of files. + %% Remove the files from the index file too + index_file_trunc(FName, NewMaxF), + {1, NewMaxF} + end; + true -> + %% We haven't reached the new limit yet + NewFt = inc(CurF, NewMaxF), + {NewFt, MaxF} + end; + MaxF -> + %% Normal case. + NewFt = inc(CurF, MaxF), + {NewFt, MaxF} + end. + +inc(N, {_NewMax, OldMax}) -> inc(N, OldMax, 1); +inc(N, Max) -> inc(N, Max, 1). + +inc(N, Max, Step) -> + Nx = (N + Step) rem Max, + if + Nx > 0 -> Nx; + true -> Nx + Max + end. + + +file_size(Fname) -> + {ok, Fi} = file:read_file_info(Fname), + Fi#file_info.size. + +%% -> ok | throw(FileError) +%% Tries to remove each file with name FName.I, N<=I<=Max. +remove_files(FName, N, Max) -> + remove_files(FName, N, Max, ok). + +remove_files(_FName, N, Max, ok) when N > Max -> + ok; +remove_files(_FName, N, Max, {FileName, Error}) when N > Max -> + file_error(FileName, Error); +remove_files(FName, N, Max, Reply) -> + FileName = add_ext(FName, N), + NewReply = case file:delete(FileName) of + ok -> Reply; + {error, enoent} -> Reply; + Error -> {FileName, Error} + end, + remove_files(FName, N + 1, Max, NewReply). + +%% -> {MaxBytes, MaxFiles} +get_wrap_size(#handle{maxB = MaxB, maxF = MaxF}) -> + case MaxF of + {NewMaxF,_} -> {MaxB, NewMaxF}; + MaxF -> {MaxB, MaxF} + end. + +add_ext(Name, Ext) -> + concat([Name, ".", Ext]). + +open_read(FileName) -> + file:open(FileName, [raw, binary, read]). + +open_update(FileName) -> + file:open(FileName, [raw, binary, read, write]). + +open_truncate(FileName) -> + file:open(FileName, [raw, binary, write]). + +%%% Functions that access files, and throw on error. + +-define(MAX, 16384). % bytes +-define(TIMEOUT, 2000). % ms + +%% -> {Reply, cache()}; Reply = ok | Error +fwrite(#cache{c = []} = FdC, _FN, B, Size) -> + case get(write_cache_timer_is_running) of + true -> + ok; + _ -> + put(write_cache_timer_is_running, true), + erlang:send_after(?TIMEOUT, self(), {self(), write_cache}) + end, + {ok, FdC#cache{sz = Size, c = B}}; +fwrite(#cache{sz = Sz, c = C} = FdC, _FN, B, Size) when Sz < ?MAX -> + {ok, FdC#cache{sz = Sz+Size, c = [C | B]}}; +fwrite(#cache{fd = Fd, c = C}, FileName, B, _Size) -> + write_cache(Fd, FileName, [C | B]). + +fwrite_header(Fd, B, Size) -> + {ok, #cache{fd = Fd, sz = Size, c = B}}. + +%% -> {NewFdC, Reply}; Reply = ok | Error +pread(#cache{fd = Fd, c = C}, FileName, Position, MaxBytes) -> + Reply = write_cache(Fd, FileName, C), + case Reply of + {ok, NewFdC} -> + case file:pread(Fd, Position, MaxBytes) of + {error, Error} -> + {NewFdC, catch file_error(FileName, {error, Error})}; + R -> + {NewFdC, R} + end; + {Error, NewFdC} -> + {NewFdC, Error} + end. + +%% -> {ok, cache(), Pos} | {Error, cache()} +position(#cache{fd = Fd, c = C}, FileName, Pos) -> + Reply = write_cache(Fd, FileName, C), + case Reply of + {ok, NewFdC} -> + case position2(Fd, FileName, Pos) of + {ok, Loc} -> + {ok, NewFdC, Loc}; + Error -> + {Error, NewFdC} + end; + _Error -> + Reply + end. + +position_close(#cache{fd = Fd, c = C}, FileName, Pos) -> + NewFdC = write_cache_close(Fd, FileName, C), + {ok, Loc} = position_close2(Fd, FileName, Pos), + {NewFdC, Loc}. + +fsync(#cache{fd = Fd, c = C}, FileName) -> + Reply = write_cache(Fd, FileName, C), + case Reply of + {ok, NewFdC} -> + case file:sync(Fd) of + ok -> + Reply; + Error -> + {catch file_error(FileName, Error), NewFdC} + end; + _Error -> + Reply + end. + +%% -> {Reply, NewFdC}; Reply = ok | Error +truncate_at(FdC, FileName, Pos) -> + case position(FdC, FileName, Pos) of + {ok, NewFdC, _Pos} -> + case file:truncate(NewFdC#cache.fd) of + ok -> + {ok, NewFdC}; + Error -> + {catch file_error(FileName, Error), NewFdC} + end; + Reply -> + Reply + end. + +fwrite_close2(Fd, FileName, B) -> + case file:write(Fd, B) of + ok -> ok; + Error -> file_error_close(Fd, FileName, Error) + end. + +pwrite_close2(Fd, FileName, Position, B) -> + case file:pwrite(Fd, Position, B) of + ok -> ok; + Error -> file_error(FileName, {error, Error}) + end. + +position2(Fd, FileName, Pos) -> + case file:position(Fd, Pos) of + {error, Error} -> catch file_error(FileName, {error, Error}); + OK -> OK + end. + +position_close2(Fd, FileName, Pos) -> + case file:position(Fd, Pos) of + {error, Error} -> file_error_close(Fd, FileName, {error, Error}); + OK -> OK + end. + +truncate_at_close2(Fd, FileName, Pos) -> + position_close2(Fd, FileName, Pos), + case file:truncate(Fd) of + ok -> ok; + Error -> file_error_close(Fd, FileName, Error) + end. + +fclose(#cache{fd = Fd, c = C}, FileName) -> + %% The cache is empty if the file was opened in read_only mode. + write_cache_close(Fd, FileName, C), + file:close(Fd). + +%% -> {Reply, #cache{}}; Reply = ok | Error +write_cache(Fd, _FileName, []) -> + {ok, #cache{fd = Fd}}; +write_cache(Fd, FileName, C) -> + case file:write(Fd, C) of + ok -> {ok, #cache{fd = Fd}}; + Error -> {catch file_error(FileName, Error), #cache{fd = Fd}} + end. + +-spec write_cache_close(fd(), file:filename(), iodata()) -> #cache{}. % | throw(Error) + +write_cache_close(Fd, _FileName, []) -> + #cache{fd = Fd}; +write_cache_close(Fd, FileName, C) -> + case file:write(Fd, C) of + ok -> #cache{fd = Fd}; + Error -> file_error_close(Fd, FileName, Error) + end. + +-spec file_error(file:filename(), {'error', atom()}) -> no_return(). + +file_error(FileName, {error, Error}) -> + throw({error, {file_error, FileName, Error}}). + +-spec file_error_close(fd(), file:filename(), {'error', atom()}) -> no_return(). + +file_error_close(Fd, FileName, {error, Error}) -> + file:close(Fd), + throw({error, {file_error, FileName, Error}}). diff --git a/lib/kernel/src/disk_log_server.erl b/lib/kernel/src/disk_log_server.erl new file mode 100644 index 0000000000..8894ed87e8 --- /dev/null +++ b/lib/kernel/src/disk_log_server.erl @@ -0,0 +1,368 @@ +%% +%% %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(disk_log_server). +-behaviour(gen_server). + +-export([start_link/0, start/0, open/1, close/1, + get_log_pids/1, accessible_logs/0]). + +%% Local export. +-export([dist_open/1, get_local_pid/1]). + +%% gen_server callbacks +-export([init/1, handle_call/3, handle_info/2, terminate/2]). +-export([handle_cast/2, code_change/3]). % just to avoid compiler warning + +-include("disk_log.hrl"). + +-compile({inline,[{do_get_log_pids,1}]}). + +-record(pending, {log, pid, req, from, attach, clients}). % [{Request,From}] + +-record(state, {pending = [] :: [#pending{}]}). + +%%%----------------------------------------------------------------- +%%% This module implements the disk_log server. Its primary purpose +%%% is to keep the ets table 'disk_log_names' updated and to handle +%%% distribution data (pids) using the module pg2. +%%%----------------------------------------------------------------- +%%%---------------------------------------------------------------------- +%%% API +%%%---------------------------------------------------------------------- +start_link() -> + gen_server:start_link({local, disk_log_server}, disk_log_server, [], []). + +start() -> + ensure_started(). + +open({ok, A}) -> + ensure_started(), + gen_server:call(disk_log_server, {open, local, A}, infinity); +open(Other) -> + Other. + +%% To be used from this module only. +dist_open(A) -> + ensure_started(), + gen_server:call(disk_log_server, {open, distr, A}, infinity). + +close(Pid) -> + gen_server:call(disk_log_server, {close, Pid}, infinity). + +get_log_pids(LogName) -> + do_get_log_pids(LogName). + +accessible_logs() -> + ensure_started(), + do_accessible_logs(). + +%%%---------------------------------------------------------------------- +%%% Callback functions from gen_server +%%%---------------------------------------------------------------------- + +%% It would have been really nice to have a tag for disk log groups, +%% like {distributed_disk_log, Log}, but backward compatibility makes +%% it hard to introduce. +-define(group(Log), Log). + +init([]) -> + process_flag(trap_exit, true), + ets:new(?DISK_LOG_NAME_TABLE, [named_table, set]), + ets:new(?DISK_LOG_PID_TABLE, [named_table, set]), + {ok, #state{}}. + +handle_call({open, W, A}, From, State) -> + open([{{open, W, A}, From}], State); +handle_call({close, Pid}, _From, State) -> + Reply = do_close(Pid), + {reply, Reply, State}. + +handle_info({pending_reply, Pid, Result0}, State) -> + {value, #pending{log = Name, pid = Pid, from = From, + req = Request, attach = Attach, + clients = Clients}} = + lists:keysearch(Pid, #pending.pid, State#state.pending), + NP = lists:keydelete(Pid, #pending.pid, State#state.pending), + State1 = State#state{pending = NP}, + if + Attach and (Result0 =:= {error, no_such_log}) -> + %% The disk_log process has terminated. Try again. + open([{Request,From} | Clients], State1); + true -> + case Result0 of + _ when Attach -> + ok; + {error, _} -> + ok; + _ -> + put(Pid, Name), + link(Pid), + {_, Locality, _} = Request, + ets:insert(?DISK_LOG_PID_TABLE, {Pid, Name}), + ets:insert(?DISK_LOG_NAME_TABLE, {Name, Pid, Locality}), + if + Locality =:= distr -> + ok = pg2:join(?group(Name), Pid); + true -> + ok + end + end, + gen_server:reply(From, result(Request, Result0)), + open(Clients, State1) + end; +handle_info({'EXIT', Pid, _Reason}, State) -> + %% If there are clients waiting to be attached to this log, info + %% {pending_reply,Pid,{error,no_such_log}} will soon arrive. + case get(Pid) of + undefined -> + ok; + Name -> + erase_log(Name, Pid) + end, + {noreply, State}; +handle_info(_, State) -> + {noreply, State}. + +%% Just to avoid compiler warning. +handle_cast(_, State) -> + {noreply, State}. + +%% Just to avoid compiler warning. +code_change(_OldVsn, State, _Extra) -> + {ok, State}. + +terminate(_Reason, _) -> + ok. + +%%%----------------------------------------------------------------- +%%% Internal functions +%%%----------------------------------------------------------------- + +ensure_started() -> + case whereis(disk_log_server) of + undefined -> + LogSup = {disk_log_sup, {disk_log_sup, start_link, []}, permanent, + 1000, supervisor, [disk_log_sup]}, + supervisor:start_child(kernel_safe_sup, LogSup), + LogServer = {disk_log_server, + {disk_log_server, start_link, []}, + permanent, 2000, worker, [disk_log_server]}, + supervisor:start_child(kernel_safe_sup, LogServer), + ok; + _ -> ok + end. + +open([{Req, From} | L], State) -> + State2 = case do_open(Req, From, State) of + {pending, State1} -> + State1; + {Reply, State1} -> + gen_server:reply(From, Reply), + State1 + end, + open(L, State2); +open([], State) -> + {noreply, State}. + +%% -> {OpenRet, NewState} | {{node(),OpenRet}, NewState} | +%% {pending, NewState} +do_open({open, W, #arg{name = Name}=A}=Req, From, State) -> + case check_pending(Name, From, State, Req) of + {pending, NewState} -> + {pending, NewState}; + false when W =:= local -> + case A#arg.distributed of + {true, Nodes} -> + Fun = fun() -> open_distr_rpc(Nodes, A, From) end, + _Pid = spawn(Fun), + %% No pending reply is expected, but don't reply yet. + {pending, State}; + false -> + case get_local_pid(Name) of + {local, Pid} -> + do_internal_open(Name, Pid, From, Req, true,State); + {distributed, _Pid} -> + {{error, {node_already_open, Name}}, State}; + undefined -> + start_log(Name, Req, From, State) + end + end; + false when W =:= distr -> + ok = pg2:create(?group(Name)), + case get_local_pid(Name) of + undefined -> + start_log(Name, Req, From, State); + {local, _Pid} -> + {{node(),{error, {node_already_open, Name}}}, State}; + {distributed, Pid} -> + do_internal_open(Name, Pid, From, Req, true, State) + end + end. + +%% Spawning a process is a means to avoid deadlock when +%% disk_log_servers mutually open disk_logs. + +-spec open_distr_rpc([node()], _, _) -> no_return(). % XXX: underspecified + +open_distr_rpc(Nodes, A, From) -> + {AllReplies, BadNodes} = rpc:multicall(Nodes, ?MODULE, dist_open, [A]), + {Ok, Bad} = cr(AllReplies, [], []), + Old = find_old_nodes(Nodes, AllReplies, BadNodes), + NotOk = [{BadNode, {error, nodedown}} || BadNode <- BadNodes ++ Old], + Reply = {Ok, Bad ++ NotOk}, + %% Send the reply to the waiting client: + gen_server:reply(From, Reply), + exit(normal). + +cr([{badrpc, {'EXIT', _}} | T], Nodes, Bad) -> + %% This clause can be removed in next release. + cr(T, Nodes, Bad); +cr([R={_Node, {error, _}} | T], Nodes, Bad) -> + cr(T, Nodes, [R | Bad]); +cr([Reply | T], Nodes, Bad) -> + cr(T, [Reply | Nodes], Bad); +cr([], Nodes, Bad) -> + {Nodes, Bad}. + +%% If a "new" node (one that calls dist_open/1) tries to open a log +%% on an old node (one that does not have dist_open/1), then the old +%% node is considered 'down'. In next release, this test will not be +%% needed since all nodes can be assumed to be "new" by then. +%% One more thing: if an old node tries to open a log on a new node, +%% the new node is also considered 'down'. +find_old_nodes(Nodes, Replies, BadNodes) -> + R = [X || {X, _} <- Replies], + ordsets:to_list(ordsets:subtract(ordsets:from_list(Nodes), + ordsets:from_list(R ++ BadNodes))). + +start_log(Name, Req, From, State) -> + Server = self(), + case supervisor:start_child(disk_log_sup, [Server]) of + {ok, Pid} -> + do_internal_open(Name, Pid, From, Req, false, State); + Error -> + {result(Req, Error), State} + end. + +do_internal_open(Name, Pid, From, {open, _W, A}=Req, Attach, State) -> + Server = self(), + F = fun() -> + Res = disk_log:internal_open(Pid, A), + Server ! {pending_reply, Pid, Res} + end, + _ = spawn(F), + PD = #pending{log = Name, pid = Pid, req = Req, + from = From, attach = Attach, clients = []}, + P = [PD | State#state.pending], + {pending, State#state{pending = P}}. + +check_pending(Name, From, State, Req) -> + case lists:keysearch(Name, #pending.log, State#state.pending) of + {value, #pending{log = Name, clients = Clients}=P} -> + NP = lists:keyreplace(Name, #pending.log, State#state.pending, + P#pending{clients = Clients++[{Req,From}]}), + {pending, State#state{pending = NP}}; + false -> + false + end. + +result({_, distr, _}, R) -> + {node(), R}; +result({_, local, _}, R) -> + R. + +do_close(Pid) -> + case get(Pid) of + undefined -> + ok; + Name -> + erase_log(Name, Pid), + unlink(Pid), + ok + end. + +erase_log(Name, Pid) -> + case get_local_pid(Name) of + undefined -> + ok; + {local, Pid} -> + true = ets:delete(?DISK_LOG_NAME_TABLE, Name), + true = ets:delete(?DISK_LOG_PID_TABLE, Pid); + {distributed, Pid} -> + true = ets:delete(?DISK_LOG_NAME_TABLE, Name), + true = ets:delete(?DISK_LOG_PID_TABLE, Pid), + ok = pg2:leave(?group(Name), Pid) + end, + erase(Pid). + +do_accessible_logs() -> + LocalSpec = {'$1','_',local}, + Local0 = [hd(L) || L <- ets:match(?DISK_LOG_NAME_TABLE, LocalSpec)], + Local = lists:sort(Local0), + Groups0 = ordsets:from_list(pg2:which_groups()), + Groups = ordsets:to_list(ordsets:subtract(Groups0, Local)), + Dist = [L || L <- Groups, dist_pids(L) =/= []], + {Local, Dist}. + +get_local_pid(LogName) -> + case ets:lookup(?DISK_LOG_NAME_TABLE, LogName) of + [{LogName, Pid, local}] -> + {local, Pid}; + [{LogName, Pid, distr}] -> + {distributed, Pid}; + [] -> + undefined + end. + +%% Inlined. +do_get_log_pids(LogName) -> + case catch ets:lookup(?DISK_LOG_NAME_TABLE, LogName) of + [{LogName, Pid, local}] -> + {local, Pid}; + [{LogName, _Pid, distr}] -> + case pg2:get_members(?group(LogName)) of + [] -> % The disk_log process has died recently + undefined; + Members -> + {distributed, Members} + end; + _EmptyOrError -> + case dist_pids(LogName) of + [] -> undefined; + Pids -> {distributed, Pids} + end + end. + +dist_pids(LogName) -> + %% Would be much simpler if disk log group names were tagged. + GroupName = ?group(LogName), + case catch pg2:get_members(GroupName) of + [Pid | _] = Pids -> + case rpc:call(node(Pid), ?MODULE, get_local_pid, [LogName]) of + undefined -> % does not seem to be a disk_log group + case catch lists:member(Pid,pg2:get_members(GroupName)) of + true -> []; + _ -> dist_pids(LogName) + end; + _ -> % badrpc if get_local_pid is not exported + Pids + end; + _ -> + [] + end. diff --git a/lib/kernel/src/disk_log_sup.erl b/lib/kernel/src/disk_log_sup.erl new file mode 100644 index 0000000000..96e37b678c --- /dev/null +++ b/lib/kernel/src/disk_log_sup.erl @@ -0,0 +1,32 @@ +%% +%% %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(disk_log_sup). + +-behaviour(supervisor). + +-export([start_link/0, init/1]). + +start_link()-> + supervisor:start_link({local, disk_log_sup}, disk_log_sup, []). + +init([]) -> + SupFlags = {simple_one_for_one, 4, 3600}, + Child = {disk_log, {disk_log, istart_link, []}, temporary, + 1000, worker, [disk_log]}, + {ok, {SupFlags, [Child]}}. diff --git a/lib/kernel/src/dist.hrl b/lib/kernel/src/dist.hrl new file mode 100644 index 0000000000..aea1ab81ba --- /dev/null +++ b/lib/kernel/src/dist.hrl @@ -0,0 +1,38 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1999-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% +%% + +%% +%% Distribution capabilities flags (corresponds with dist.h). +%% + +-define(DFLAG_PUBLISHED,1). +-define(DFLAG_ATOM_CACHE,2). +-define(DFLAG_EXTENDED_REFERENCES,4). +-define(DFLAG_DIST_MONITOR,8). +-define(DFLAG_FUN_TAGS,16#10). +-define(DFLAG_DIST_MONITOR_NAME,16#20). +-define(DFLAG_HIDDEN_ATOM_CACHE,16#40). +-define(DFLAG_NEW_FUN_TAGS,16#80). +-define(DFLAG_EXTENDED_PIDS_PORTS,16#100). +-define(DFLAG_EXPORT_PTR_TAG,16#200). +-define(DFLAG_BIT_BINARIES,16#400). +-define(DFLAG_NEW_FLOATS,16#800). +-define(DFLAG_UNICODE_IO,16#1000). +-define(DFLAG_DIST_HDR_ATOM_CACHE,16#2000). +-define(DFLAG_SMALL_ATOM_TAGS, 16#4000). diff --git a/lib/kernel/src/dist_ac.erl b/lib/kernel/src/dist_ac.erl new file mode 100644 index 0000000000..5c62aa31e9 --- /dev/null +++ b/lib/kernel/src/dist_ac.erl @@ -0,0 +1,1534 @@ +%% +%% %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(dist_ac). + +-behaviour(gen_server). + +%% External exports +-export([start_link/0, + load_application/2, + takeover_application/2, + permit_application/2, + permit_only_loaded_application/2]). + +-export([get_known_nodes/0]). + +%% Internal exports +-export([init/1, handle_cast/2, handle_call/3, handle_info/2, terminate/2, + code_change/3, send_timeout/3]). +-export([info/0]). + +-import(lists, [zf/2, filter/2, map/2, foreach/2, foldl/3, mapfoldl/3, + keysearch/3, keydelete/3, keyreplace/4, member/2]). + +-define(AC, application_controller). +-define(DIST_AC, ?MODULE). +-define(LOCK_ID, ?MODULE). + +%% This is the protocol version for the dist_ac protcol (between nodes) +-define(vsn, 1). + +%%%----------------------------------------------------------------- +%%% This module implements the default Distributed Applications +%%% Controller. It is possible to write other controllers, when +%%% the functionality in this module are not sufficient. +%%% The process cooperates with the application_controller. +%%%----------------------------------------------------------------- + +%%----------------------------------------------------------------- +%% Naming conventions: +%% Appl = #appl +%% AppName = atom() +%%----------------------------------------------------------------- +-record(state, {appls = [], tmp_locals = [], remote_started = [], + known = [], started = [], tmp_weights = [], + dist_loaded = [], t_reqs = [], s_reqs = [], p_reqs = []}). +%%----------------------------------------------------------------- +%% appls = [#appl()] - these are the applications we control +%% tmp_locals = [{AppName, Weight, node()}] - tmp, info part of +%% application startup for some distrib appls, +%% not yet handled. +%% remote_started = [{Node, AppName}] - info on apps started before +%% we were started +%% known = [Node] - These are the nodes known to us +%% started = [AppName] - An ordered list of started applications +%% (reversed start order) +%% tmp_weight = [{AppName, MyWeight}] - tmp, if we're forced to +%% send a dist_ac_weight message before we're prepared to, +%% we remember the weight we sent here, so we can use +%% it in the dist_ac_weight msgs later. +%% dist_loaded = {{Name, Node}, HisNodes, Permission} - info on +%% application loaded on other nodes (and own node) +%% t_reqs = [{AppName, From}] - processes waiting for takeover +%% to complete. +%% s_reqs = [{AppName, From}] - processes waiting for stop +%% to complete. +%% p_reqs = [{From, AppName, Bool, [Node]] - outstanding permit. +%% Nodes is a list of nodes we're still waiting for. +%%----------------------------------------------------------------- + +-record(appl, {name, id, restart_time = 0, nodes = [], run = []}). + +%%----------------------------------------------------------------- +%% id = local | undefined | {distributed, node()} | waiting | run_waiting | +%% {failover, Node} | {takeover, Node} +%% local : local application +%% undefined : not yet started +%% {distributed, Node} : running on another node, we're standby +%% {failover, Node} : failover from Node +%% {takeover, Node} : takeover from Node +%% waiting : other node went down, we're waiting for a timeout +%% to takeover it. From = pid() | undefined +%% run_waiting : we have decided to start the app; wait for the +%% AC result +%%----------------------------------------------------------------- + +start_link() -> + case gen_server:start_link({local, ?DIST_AC}, ?MODULE, [], []) of + {ok, Pid} -> + gen_server:cast(?DIST_AC, init_sync), + {ok, Pid}; + Else -> + Else + end. + + +%%----------------------------------------------------------------- +%% Func: load_application(AppName, DistNodes) +%% Args: AppName = atom() +%% DistNodes = default | {AppName, Time, [node() | {node()...}]} +%% Purpose: Notifies the dist_ac about distributed nodes for an +%% application. DistNodes overrides the kernel 'distributed' +%% parameter. +%% Returns: ok | {error, Reason} +%%----------------------------------------------------------------- +load_application(AppName, DistNodes) -> + gen_server:call(?DIST_AC, {load_application, AppName, DistNodes}, infinity). + +takeover_application(AppName, RestartType) -> + case validRestartType(RestartType) of + true -> + wait_for_sync_dacs(), + Nodes = get_nodes(AppName), + global:trans( + {?LOCK_ID, self()}, + fun() -> + gen_server:call( + ?DIST_AC, + {takeover_application, AppName, RestartType}, + infinity) + end, + Nodes); + false -> + {error, {invalid_restart_type, RestartType}} + end. + +%%----------------------------------------------------------------- +%% This function controls which applications are permitted to run. If +%% an application X runs when this function is called as +%% permit_application(X, false), it is moved to another node where it +%% is permitted to run (distributed applications only). If there is +%% no such node, the application is stopped. (I.e. local applications +%% are always stopped, and distributed applications with no other node +%% alive are stopped as well.) If later a call to +%% permit_application(X, true) is made, X is restarted. +%% For example, suppose applications app1 and app2 are started and +%% running. +%% If we evaluate +%% permit_application(app2, false) +%% app2 is stopped and app1 only is running. +%% If we now evaluate +%% permit_application(app2, true), +%% permit_application(app3, true) +%% app2 is restarted, but not app3, since it hasn't been started by a +%% call to start_application. +%%----------------------------------------------------------------- +permit_application(AppName, Bool) -> + wait_for_sync_dacs(), + LockId = {?LOCK_ID, self()}, + global:trans( + LockId, + fun() -> + gen_server:call(?DIST_AC, + {permit_application, AppName, Bool, LockId, started}, + infinity) + end). + +permit_only_loaded_application(AppName, Bool) -> + wait_for_sync_dacs(), + LockId = {?LOCK_ID, self()}, + global:trans( + LockId, + fun() -> + gen_server:call(?DIST_AC, + {permit_application, AppName, Bool, LockId, only_loaded}, + infinity) + end). + +get_nodes(AppName) -> + gen_server:call(?DIST_AC, {get_nodes, AppName}, infinity). + +get_known_nodes() -> + gen_server:call(?DIST_AC, get_known_nodes). + +%%%----------------------------------------------------------------- +%%% call-back functions from gen_server +%%%----------------------------------------------------------------- +init([]) -> + process_flag(trap_exit, true), + {ok, #state{}}. + +sync_dacs(Appls) -> + Res = global:trans({?LOCK_ID, sync_dacs}, + fun() -> + Nodes = introduce_me(nodes(), Appls), + wait_dacs(Nodes, [node()], Appls, []) + end), + ets:insert(ac_tab, {sync_dacs, ok}), + Res. + +introduce_me(Nodes, Appls) -> + Msg = {dist_ac_new_node, ?vsn, node(), Appls, []}, + filter(fun(Node) -> + %% This handles nodes without DACs + case rpc:call(Node, erlang, whereis, [?DIST_AC]) of + Pid when is_pid(Pid) -> + Pid ! Msg, + true; + _ -> + false + end + end, Nodes). + +wait_dacs([Node | Nodes], KnownNodes, Appls, RStarted) -> + monitor_node(Node, true), + receive + %% HisAppls =/= [] is the case when our node connects to a running system + %% + %% It is always the responsibility of newer versions to understand + %% older versions of the protocol. As we don't have any older + %% versions (that are supposed to work with this version), we + %% don't handle version mismatch here. + {dist_ac_new_node, _Vsn, Node, HisAppls, HisStarted} -> + monitor_node(Node, false), + NRStarted = RStarted ++ HisStarted, + NAppls = dist_merge(Appls, HisAppls, Node), + wait_dacs(Nodes, [Node | KnownNodes], NAppls, NRStarted); + {nodedown, Node} -> + monitor_node(Node, false), + wait_dacs(Nodes, KnownNodes, Appls, RStarted) + end; +wait_dacs([], KnownNodes, Appls, RStarted) -> + {KnownNodes, Appls, RStarted}. + + +info() -> + gen_server:call(?DIST_AC, info). + + +%%----------------------------------------------------------------- +%% All functions that can affect which applications are running +%% execute within a global lock, to ensure that they are not +%% executing at the same time as sync_dacs. However, to avoid a +%% deadlock situation where e.g. permit_application gets the lock +%% before sync_dacs, this function is used to ensure that the local +%% sync_dacs always gets the lock first of all. The lock is still +%% used to not interfere with sync_dacs on other nodes. +%%----------------------------------------------------------------- +wait_for_sync_dacs() -> + case catch ets:lookup(ac_tab, sync_dacs) of + [{sync_dacs, ok}] -> ok; + _ -> + receive after 100 -> ok end, + wait_for_sync_dacs() + end. + +handle_cast(init_sync, _S) -> + %% When the dist_ac is started, it receives this msg, and gets into + %% the receive loop. 'go' is sent from the kernel_config proc when + %% all nodes that should be pinged has been pinged. The reason for this + %% is that dist_ac syncs with the other nodes at start-up. That is, + %% it does _not_ handle partitioned nets! The other nodes tries to call + %% the local name dist_ac, which means that this name must be registered + %% before the distribution. But it can't sync until after the distribution + %% is started. Therefore, this 'go'-thing. + receive + {go, KernelConfig} -> + Appls = case application:get_env(kernel, distributed) of + {ok, D} -> dist_check(D); + undefined -> [] + end, + + dist_take_control(Appls), + %% kernel_config waits for dist_ac to take control over its + %% applications. By this we can be sure that the kernel + %% application hasn't completed its start before dist_ac has + %% taken control over its applications. (OTP-3509) + KernelConfig ! dist_ac_took_control, + + %% we're really just interested in nodedowns. + net_kernel:monitor_nodes(true), + + {Known, NAppls, RStarted} = sync_dacs(Appls), + + {noreply, + #state{appls = NAppls, known = Known, remote_started = RStarted}} + end. + + +handle_call(info, _From, S) -> + {reply, S, S}; + + + +handle_call({load_application, AppName, DistNodes}, _From, S) -> + Appls = S#state.appls, + case catch dist_replace(DistNodes, AppName, Appls) of + {error, Error} -> + {reply, {error, Error}, S}; + {'EXIT', R} -> + {stop, R, {error, R}, S}; + NAppls -> + NewS = case dist_find_nodes(NAppls, AppName) of + [] -> % No distrib nodes; we ignore it + S; + _Nodes -> + ensure_take_control(AppName, Appls), + {ok, S2} = load(AppName, S#state{appls = NAppls}), + S2 + end, + {reply, ok, NewS} + end; + +handle_call({takeover_application, AppName, RestartType}, From, S) -> + Appls = S#state.appls, + case keysearch(AppName, #appl.name, Appls) of + {value, Appl} when element(1, Appl#appl.id) =:= distributed -> + {distributed, Node} = Appl#appl.id, + ac_takeover(req, AppName, Node, RestartType), + NAppl = Appl#appl{id = takeover}, + NAppls = keyreplace(AppName, #appl.name, Appls, NAppl), + TR = S#state.t_reqs, + {noreply, S#state{appls = NAppls, + t_reqs = [{AppName, From} | TR]}}; + {value, #appl{id = local}} -> + {reply, {error, {already_running_locally, AppName}}, S}; + _ -> + {reply, {error, {not_running_distributed, AppName}}, S} + end; + +handle_call({permit_application, AppName, Bool, LockId, StartInfo}, From, S) -> + case lists:keymember(AppName, #appl.name, S#state.appls) of + false -> + %% This one covers the case with permit for non-distributed + %% applications. This shouldn't be handled like this, and not + %% here, but we have to be backwards-compatible. + case application_controller:get_loaded(AppName) of + {true, _} when not Bool -> + ac_stop_it(AppName), + {reply, ok, S}; + {true, _} when Bool -> + ac_start_it(req, AppName), + {reply, ok, S}; + false -> + {reply, {error, {not_loaded, AppName}}, S} + end; + true -> + NAppls = dist_update_run(S#state.appls, AppName, node(), Bool), + NewS = S#state{appls = NAppls}, + %% Check if the application is running + IsRunning = keysearch(AppName, #appl.name, NAppls), + IsMyApp = case IsRunning of + {value, #appl{id = local}} -> true; + _ -> false + end, + %% Tell everyone about the new permission + Nodes = dist_flat_nodes(NAppls, AppName), + Msg = {dist_ac_new_permission, node(), AppName, Bool, IsMyApp}, + send_msg(Msg, Nodes), + case StartInfo of + only_loaded -> + {reply, ok, NewS}; + started -> + permit(Bool, IsRunning, AppName, From, NewS, LockId) + end + end; + +%%----------------------------------------------------------------- +%% The distributed parameter is changed. Update the parameters +%% but the applications are actually not moved to other nodes +%% even if they should. +%%----------------------------------------------------------------- +handle_call({distribution_changed, NewDistribution}, _From, S) -> + Appls = S#state.appls, + NewAppls = dist_change_update(Appls, NewDistribution), + NewS = S#state{appls = NewAppls}, + {reply, ok, NewS}; + + +handle_call({get_nodes, AppName}, _From, S) -> + Alive = intersection(dist_flat_nodes(S#state.appls, AppName), + S#state.known), + {reply, Alive, S}; + +handle_call(get_known_nodes, _From, S) -> + {reply, S#state.known, S}. + + +handle_info({ac_load_application_req, AppName}, S) -> + {ok, NewS} = load(AppName, S), + ?AC ! {ac_load_application_reply, AppName, ok}, + {noreply, NewS}; + +handle_info({ac_application_unloaded, AppName}, S) -> + {ok, NewS} = unload(AppName, S), + {noreply, NewS}; + +handle_info({ac_start_application_req, AppName}, S) -> + %% We must decide if we or another node should start the application + Lock = {?LOCK_ID, self()}, + case global:set_lock(Lock, [node()], 0) of + true -> + S2 = case catch start_appl(AppName, S, reply) of + {ok, NewS, _} -> + NewS; + {error, R} -> + ?AC ! {ac_start_application_reply, AppName, {error,R}}, + S + end, + global:del_lock(Lock), + {noreply, S2}; + false -> + send_after(100, {ac_start_application_req, AppName}), + {noreply, S} + end; + +handle_info({ac_application_run, AppName, Res}, S) -> + %% We ordered a start, and here's the result. Tell all other nodes. + Appls = S#state.appls, + Nodes = S#state.known, + %% Send this to _all_ known nodes, as any node could sync + %% on this app (not only nodes that can run it). + send_msg({dist_ac_app_started, node(), AppName, Res}, Nodes), + NId = case Res of + ok -> local; + {error, _R} -> undefined + end, + {value, Appl} = keysearch(AppName, #appl.name, Appls), + %% Check if we have somebody waiting for the takeover result + NTReqs = del_t_reqs(AppName, S#state.t_reqs, Res), + NAppl = Appl#appl{id = NId}, + NAppls = keyreplace(AppName, #appl.name, Appls, NAppl), + {noreply, S#state{appls = NAppls, t_reqs = NTReqs}}; + + +handle_info({ac_application_not_run, AppName}, S) -> + %% We ordered a stop, and now it has stopped + {value, Appl} = keysearch(AppName, #appl.name, Appls = S#state.appls), + %% Check if we have somebody waiting for the takeover result; + %% if somebody called stop just before takeover was handled, + NTReqs = del_t_reqs(AppName, S#state.t_reqs, {error, stopped}), + %% Check if we have somebody waiting for stop to return + SReqs = filter(fun({Name, From2}) when Name =:= AppName -> + gen_server:reply(From2, ok), + false; + (_) -> + true + end, S#state.s_reqs), + RS = case Appl#appl.id of + local -> + send_msg({dist_ac_app_stopped, AppName}, S#state.known), + S#state.remote_started; + {distributed, Node} -> + [{Node, AppName} | S#state.remote_started]; + _ -> + S#state.remote_started + end, + NAppl = Appl#appl{id = undefined}, + NAppls = keyreplace(AppName, #appl.name, Appls, NAppl), + {noreply, S#state{appls = NAppls, t_reqs = NTReqs, s_reqs = SReqs, + remote_started = RS}}; + +handle_info({ac_application_stopped, AppName}, S) -> + %% Somebody called application:stop - reset state as it was before + %% the application was started. + {value, Appl} = keysearch(AppName, #appl.name, Appls = S#state.appls), + %% Check if we have somebody waiting for the takeover result; + %% if somebody called stop just before takeover was handled, + NTReqs = del_t_reqs(AppName, S#state.t_reqs, {error, stopped}), + %% Check if we have somebody waiting for stop to return + SReqs = filter(fun({Name, From2}) when Name =:= AppName -> + gen_server:reply(From2, ok), + false; + (_) -> + true + end, S#state.s_reqs), + RS = case Appl#appl.id of + local -> + send_msg({dist_ac_app_stopped, AppName}, S#state.known), + S#state.remote_started; + {distributed, Node} -> + [{Node, AppName} | S#state.remote_started]; + _ -> + S#state.remote_started + end, + NAppl = Appl#appl{id = undefined}, + NAppls = keyreplace(AppName, #appl.name, Appls, NAppl), + Started = lists:delete(AppName, S#state.started), + {noreply, S#state{appls = NAppls, started = Started, + t_reqs = NTReqs, s_reqs = SReqs, + remote_started = RS}}; + + +%%----------------------------------------------------------------- +%% A new node gets running. +%% Send him info about our started distributed applications. +%%----------------------------------------------------------------- +handle_info({dist_ac_new_node, _Vsn, Node, HisAppls, []}, S) -> + Appls = S#state.appls, + MyStarted = zf(fun(Appl) when Appl#appl.id =:= local -> + {true, {node(), Appl#appl.name}}; + (_) -> + false + end, Appls), + {?DIST_AC, Node} ! {dist_ac_new_node, ?vsn, node(), Appls, MyStarted}, + NAppls = dist_merge(Appls, HisAppls, Node), + {noreply, S#state{appls = NAppls, known = [Node | S#state.known]}}; + +handle_info({dist_ac_app_started, Node, Name, Res}, S) -> + case {keysearch(Name, #appl.name, S#state.appls), lists:member(Name, S#state.started)} of + {{value, Appl}, true} -> + Appls = S#state.appls, + NId = case Appl#appl.id of + _ when element(1, Res) =:= error -> + %% Start of appl on some node failed. + %% Set Id to undefined. That node will have + %% to take some actions, e.g. reboot + undefined; + {distributed, _} -> + %% Another node tookover from some node. Update + %% appl list. + {distributed, Node}; + local -> + %% Another node tookover from me; stop my application + %% and update the running list. + {distributed, Node}; + _ -> + %% Another node started appl. Update appl list. + {distributed, Node} + end, + ac_started(req, Name, Node), + NAppl = Appl#appl{id = NId}, + NAppls = keyreplace(Name, #appl.name, Appls, NAppl), + TmpWeights = keydelete_all(Name, 1, S#state.tmp_weights), + NewS = S#state{appls = NAppls, tmp_weights = TmpWeights}, + NPermitReq = req_del_permit_false(NewS#state.p_reqs, Name), + case catch req_start_app(NewS#state{p_reqs = NPermitReq}, Name) of + {error, R} -> + {stop, R}; + {ok, NewS2} -> + {noreply, NewS2} + end; + {_, _} -> + %% The app has not been started at this node yet; remember this in + %% remote started. + NRStarted = [{Node, Name} | S#state.remote_started], + {noreply, S#state{remote_started = NRStarted}} + end; + +handle_info({dist_ac_app_stopped, AppName}, S) -> + Appls = S#state.appls, + case keysearch(AppName, #appl.name, Appls) of + false -> + RStarted = keydelete(AppName, 2, S#state.remote_started), + {noreply, S#state{remote_started = RStarted}}; + {value, Appl} -> + NAppl = Appl#appl{id = undefined}, + NAppls = keyreplace(AppName, #appl.name, Appls, NAppl), + RStarted = keydelete(AppName, 2, S#state.remote_started), + {noreply, S#state{appls = NAppls, remote_started = RStarted}} + end; + +handle_info({dist_ac_weight, Name, Weight, Node}, S) -> + %% This means another node starts up, and will eventually take over + %% this appl. We have a situation like: {Name, [{Node}, node()]} + %% Node sends us this msg, and we must respond. It doesn't really + %% matter what we send him; but it must be a dist_ac_weight msg. + %% Another situation is {Name, [RNode, {node()}, Node]}. + %% + %% Yet another situation is that the node where Name was running crashed, + %% and Node has got the nodedown message, but we haven't. In this case, + %% we must send a correct weight to Node. i.e. the same weight that + %% we'll send to him later, when we get the nodedown message. + case keysearch(Name, #appl.name, S#state.appls) of + {value, Appl} -> + Id = Appl#appl.id, + case Id of + run_waiting -> + {?DIST_AC, Node} ! {dist_ac_weight, Name, 0, node()}, + {noreply, S}; + undefined -> + {noreply, + S#state{tmp_locals = [{Name, Weight, Node} | + S#state.tmp_locals]}}; + {takeover, _} -> + {noreply, + S#state{tmp_locals = [{Name, Weight, Node} | + S#state.tmp_locals]}}; + {failover, _} -> + {noreply, + S#state{tmp_locals = [{Name, Weight, Node} | + S#state.tmp_locals]}}; + _ -> + MyWeight = get_cached_weight(Name, S), + {?DIST_AC, Node} ! {dist_ac_weight, Name, MyWeight, node()}, + NTWs = keyreplaceadd(Name, 1, S#state.tmp_weights, + {Name, MyWeight}), + {noreply, S#state{tmp_weights = NTWs}} + end; + _ -> + {noreply, + S#state{tmp_locals = [{Name, Weight, Node} | S#state.tmp_locals]}} + end; + +%%----------------------------------------------------------------- +%% A node died. Check if we should takeover some applications. +%%----------------------------------------------------------------- +handle_info({nodedown, Node}, S) -> + AppNames = dist_get_runnable(S#state.appls), + HisAppls = filter(fun(#appl{name = Name, id = {distributed, N}}) + when Node =:= N -> lists:member(Name, AppNames); + (_) -> false + end, + S#state.appls), + Appls2 = zf(fun(Appl) when Appl#appl.id =:= {distributed, Node} -> + case lists:member(Appl#appl.name, AppNames) of + true -> + {true, Appl#appl{id = {failover, Node}}}; + false -> + ac_not_running(Appl#appl.name), + {true, Appl#appl{id = undefined}} + end; + (_) -> + true + end, + S#state.appls), + RStarted = filter(fun({Node2, _Name}) when Node2 =:= Node -> false; + (_) -> true + end, + S#state.remote_started), + Appls3 = dist_del_node(Appls2, Node), + {NPermitReq, Appls4, SReqs} = req_del_node(S, Node, Appls3), + NKnown = lists:delete(Node, S#state.known), + NewS = S#state{appls = Appls4, p_reqs = NPermitReq, known = NKnown, + s_reqs = SReqs, + remote_started = RStarted}, + restart_appls(HisAppls), + {noreply, NewS}; + +handle_info({dist_ac_app_loaded, Node, Name, HisNodes, Permission, HeKnowsMe}, + S) -> + Nodes = dist_find_nodes(Appls = S#state.appls, Name), + case is_loaded(Name, S) of + true -> + case equal_nodes(Nodes, HisNodes) of + true -> + NAppls = dist_update_run(Appls, Name, Node, Permission), + if + not HeKnowsMe -> + %% We've got it loaded, but he doesn't know - + %% he's a new node connecting to us. + Msg = {dist_ac_app_loaded, node(), Name, + Nodes, dist_is_runnable(Appls, Name), true}, + {?DIST_AC, Node} ! Msg; + true -> + ok + end, + {noreply, S#state{appls = NAppls}}; + false -> + dist_mismatch(Name, Node) + end; + false -> + Load =[{{Name, Node}, HisNodes, Permission} | S#state.dist_loaded], + {noreply, S#state{dist_loaded = Load}} + end; + +handle_info({dist_ac_app_unloaded, Node, Name}, S) -> + Appls = dist_update_run(S#state.appls, Name, Node, undefined), + Load = keydelete({Name, Node}, 1, S#state.dist_loaded), + {noreply, S#state{appls = Appls, dist_loaded = Load}}; + + +handle_info({dist_ac_new_permission, Node, AppName, false, IsHisApp}, S) -> + Appls = dist_update_run(S#state.appls, AppName, Node, false), + NewS = S#state{appls =Appls}, + case dist_is_runnable(Appls, AppName) of + true when IsHisApp -> + case catch start_appl(AppName, NewS, req) of + {ok, NewS2, _} -> + {noreply, NewS2}; + {error, _R} -> % if app was permanent, AC will shutdown the node + {noreply, NewS} + end; + _ -> + {noreply, NewS} + end; +handle_info({dist_ac_new_permission, Node, AppName, true, _IsHisApp}, S) -> + Appls = dist_update_run(S#state.appls, AppName, Node, true), + {noreply, S#state{appls = Appls}}; + +handle_info({internal_restart_appl, Name}, S) -> + case restart_appl(Name, S) of + {error, R} -> + {stop, {error, R}, S}; + NewS -> + {noreply, NewS} + end; + +handle_info(_, S) -> + {noreply, S}. + +terminate(_Reason, _S) -> + ok. + +code_change(_OldVsn, State, _Extra) -> + {ok, State}. + +%%%----------------------------------------------------------------- +%%% Internal functions +%%%----------------------------------------------------------------- +load(AppName, S) -> + Appls0 = S#state.appls, + %% Get the dist specification for the app on other nodes + DistLoaded = get_dist_loaded(AppName, Load1 = S#state.dist_loaded), + %% Get the local dist specification + Nodes = dist_find_nodes(Appls0, AppName), + FNodes = flat_nodes(Nodes), + %% Update dists spec with our local permission + Permission = get_default_permission(AppName), + Appls1 = dist_update_run(Appls0, AppName, node(), Permission), + %% Compare the local spec with other nodes's specs + %% If equal, update our spec with his current permission + {LoadedNodes, Appls2} = + mapfoldl( + fun({Node, HisNodes, HisPermission}, Appls) -> + case equal_nodes(Nodes, HisNodes) of + true -> + {Node, dist_update_run(Appls, AppName, + Node, HisPermission)}; + _ -> + dist_mismatch(AppName, Node) + end + end, Appls1, DistLoaded), + Load2 = del_dist_loaded(AppName, Load1), + %% Tell all Nodes about the new appl loaded, and its permission. + foreach(fun(Node) when Node =/= node() -> + Msg = {dist_ac_app_loaded, node(), AppName, + Nodes, Permission, member(Node, LoadedNodes)}, + {?DIST_AC, Node} ! Msg; + (_) -> ok + end, FNodes), + {ok, S#state{appls = Appls2, dist_loaded = Load2}}. + +ensure_take_control(AppName, Appls) -> + %% Check if this is a new application that we don't control yet + case lists:keymember(AppName, #appl.name, Appls) of + true -> % we have control + ok; + false -> % take control! + %% Note: this works because this is executed within a + %% synchronous call. I.e. we get the control *before* + %% application:load returns. (otherwise application:start + %% could be called before we got the chance to take control) + %% The only reason we have to bother about this is because + %% we have to be backwards compatible in the sense that all + %% apps don't have to be specified in the 'distributed' parameter, + %% but may be implicitly 'distributed' by a call to + %% application:load. + application_controller:control_application(AppName) + end. + +unload(AppName, S) -> + Appls = S#state.appls, + Nodes = dist_flat_nodes(Appls, AppName), + %% Tell all ACs in DistNodes about the unloaded appl + Msg = {dist_ac_app_unloaded, node(), AppName}, + send_msg(Msg, Nodes), + {value, Appl} = keysearch(AppName, #appl.name, Appls), + NAppl = Appl#appl{id = undefined, run = []}, + {ok, S#state{appls = keyreplace(AppName, #appl.name, Appls, NAppl)}}. + +start_appl(AppName, S, Type) -> + %% Get nodes, and check if App is loaded on all involved nodes. + %% If it is loaded everywhere, we know that we have the same picture + %% of the nodes; otherwise the load wouldn't have succeeded. + Appl = case keysearch(AppName, #appl.name, Appls = S#state.appls) of + {value, A} -> A; + _ -> throw({error, {unknown_application, AppName}}) + end, + case Appl#appl.id of + local -> + %% UW 990913: we've already started the app + %% this could happen if ac_start_application_req was resent. + {ok,S,false}; + _ -> + {Id, IsWaiting} = case dist_get_all_nodes(Appl) of + {ok, DistNodes, PermittedNodes} -> + start_distributed(Appl, AppName, DistNodes, + PermittedNodes, S, Type); + Error -> throw(Error) + end, + NAppl = Appl#appl{id = Id}, + NAppls = keyreplaceadd(AppName, #appl.name, Appls, NAppl), + {ok, NewS} = req_start_app(S#state{appls = NAppls}, AppName), + TmpLocals = keydelete_all(AppName, 1, NewS#state.tmp_locals), + TmpWeights = keydelete_all(AppName, 1, NewS#state.tmp_weights), + RStarted = keydelete(AppName, 2, S#state.remote_started), + Started = replaceadd(AppName, NewS#state.started), + {ok, + NewS#state{started = Started, tmp_locals = TmpLocals, + tmp_weights = TmpWeights, remote_started = RStarted}, + IsWaiting} + end. + + +start_distributed(Appl, Name, Nodes, PermittedNodes, S, Type) -> + case find_start_node(Nodes, PermittedNodes, Name, S) of + {ok, Node} when Node =:= node() -> + case Appl#appl.id of + {failover, FoNode} when Type =:= req -> + ac_failover(Name, FoNode, undefined); + {distributed, Node2} when Type =:= req -> + ac_takeover(req, Name, Node2, undefined); + _ when Type =:= reply -> + case lists:keysearch(Name, 2, S#state.remote_started) of + {value, {Node3, _}} -> + ac_takeover(reply, Name, Node3, undefined); + _ -> + ac_start_it(Type, Name) + end; + _ -> + ac_start_it(Type, Name) + end, + {run_waiting, true}; + {already_started, Node} -> + ac_started(Type, Name, Node), + {{distributed, Node}, false}; + {ok, Node} -> + case keysearch(Name, #appl.name, S#state.appls) of + {value, #appl{id = {distributed, Node}}} -> + ac_started(Type, Name, Node), + {{distributed, Node}, false}; + _ -> + wait_dist_start(Node, Appl, Name, Nodes, + PermittedNodes, S, Type) + end; + not_started -> + wait_dist_start2(Appl, Name, Nodes, PermittedNodes, S, Type); + no_permission -> + ac_not_started(Type, Name), + {undefined, false} + end. + +wait_dist_start(Node, Appl, Name, Nodes, PermittedNodes, S, Type) -> + monitor_node(Node, true), + receive + {dist_ac_app_started, Node, Name, ok} -> + ac_started(Type, Name, Node), + monitor_node(Node, false), + {{distributed, Node}, false}; + {dist_ac_app_started, Node, Name, {error, R}} -> + ac_error(Type, Name, {Node, R}), + monitor_node(Node, false), + {Appl#appl.id, false}; + {dist_ac_weight, Name, _Weigth, Node} -> + %% This is the situation: {Name, [RNode, {Node}, node()]} + %% and permit(false) is called on RNode, and we sent the + %% weigth first. Node handled it in handle_info, and + %% now we must send him a weigth msg. We can use any weigth; + %% he wins anyway. + monitor_node(Node, false), + {?DIST_AC, Node} ! + {dist_ac_weight, Name, get_cached_weight(Name, S), node()}, + wait_dist_start(Node, Appl, Name, Nodes, PermittedNodes, S, Type); + {nodedown, Node} -> + monitor_node(Node, false), + TmpLocals = + filter(fun({Name2, _Weight, Node2}) when Node2 =:= Node, + Name2 =:= Name -> false; + (_) -> true + end, + S#state.tmp_locals), + NewS = S#state{tmp_locals = TmpLocals}, + start_distributed(Appl, Name, Nodes, + lists:delete(Node, PermittedNodes), NewS, Type) + end. + +wait_dist_start2(Appl, Name, Nodes, PermittedNodes, S, Type) -> + receive + {dist_ac_app_started, Node, Name, ok} -> + ac_started(Type, Name, Node), + {{distributed, Node}, false}; + {dist_ac_app_started, Node, Name, {error, R}} -> + ac_error(Type, Name, {Node, R}), + {Appl#appl.id, false}; + {nodedown, Node} -> + %% A node went down, try to start the app again - there may not + %% be any more nodes to wait for. + TmpLocals = + filter(fun({Name2, _Weight, Node2}) when Node2 =:= Node, + Name2 =:= Name -> false; + (_) -> true + end, + S#state.tmp_locals), + NewS = S#state{tmp_locals = TmpLocals}, + start_distributed(Appl, Name, Nodes, + lists:delete(Node, PermittedNodes), NewS, Type) + end. + + +ac_start_it(reply, Name) -> + ?AC ! {ac_start_application_reply, Name, start_it}; +ac_start_it(req, Name) -> + ?AC ! {ac_change_application_req, Name, start_it}. + +ac_started(reply, Name, Node) -> + ?AC ! {ac_start_application_reply, Name, {started, Node}}; +ac_started(req, Name, Node) -> + ?AC ! {ac_change_application_req, Name, {started, Node}}. + +ac_error(reply, Name, Error) -> + ?AC ! {ac_start_application_reply, Name, {error, Error}}; +ac_error(req, _Name, _Error) -> + ok. + +ac_not_started(reply, Name) -> + ?AC ! {ac_start_application_reply, Name, not_started}; +ac_not_started(req, Name) -> + ?AC ! {ac_change_application_req, Name, stop_it}. + +ac_stop_it(Name) -> + ?AC ! {ac_change_application_req, Name, stop_it}. + +ac_takeover(reply, Name, Node, _RestartType) -> + ?AC ! {ac_start_application_reply, Name, {takeover, Node}}; +ac_takeover(req, Name, Node, RestartType) -> + ?AC ! {ac_change_application_req, Name, + {takeover, Node, RestartType}}. + +ac_failover(Name, Node, RestartType) -> + ?AC ! {ac_change_application_req, Name, + {failover, Node, RestartType}}. + +ac_not_running(Name) -> + ?AC ! {ac_change_application_req, Name, not_running}. + +restart_appls(Appls) -> + foreach(fun(Appl) -> + AppName = Appl#appl.name, + send_after(Appl#appl.restart_time, + {internal_restart_appl, AppName}) + end, lists:reverse(Appls)). + +restart_appl(AppName, S) -> + case keysearch(AppName, #appl.name, S#state.appls) of + {value, Appl} when element(1, Appl#appl.id) =:= failover -> + case catch start_appl(AppName, S, req) of + {ok, NewS, _} -> + NewS; + {error, R} -> + error_msg("Error when restarting application ~p: ~p~n", + [AppName, R]), + S + end; + _ -> + S + end. + +%% permit(ShouldBeRunning, IsRunning, ...) +permit(false, {value, #appl{id = undefined}}, _AppName, _From, S, _LockId) -> + {reply, ok, S}; % It's not running +permit(false, {value, #appl{id = Id}}, _AppName, _From, S, _LockId) + when element(1, Id) =:= distributed -> + %% It is running at another node already + {reply, ok, S}; +permit(false, {value, _}, AppName, From, S, _LockId) -> + %% It is a distributed application + %% Check if there is any runnable node + case dist_get_runnable_nodes(S#state.appls, AppName) of + [] -> + %% There is no runnable node; stop application + ac_stop_it(AppName), + SReqs = [{AppName, From} | S#state.s_reqs], + {noreply, S#state{s_reqs = SReqs}}; + Nodes -> + %% Delete all outstanding 'permit true' requests. + PR = req_del_permit_true(S#state.p_reqs, AppName), + NPReqs = [{From, AppName, false, Nodes} | PR], + {noreply, S#state{p_reqs = NPReqs}} + end; +permit(true, {value, #appl{id = local}}, _AppName, _From, S, _LockId) -> + {reply, ok, S}; +permit(true, _, AppName, From, S, LockId) -> + case catch start_appl(AppName, S, req) of + {_ErrorTag, {not_running, App}} -> + %% Delete all outstanding 'permit false' requests + PR = req_del_permit_false(S#state.p_reqs, AppName), + NPReqs = [{false, AppName, true, App} | PR], + {reply, ok, S#state{p_reqs = NPReqs}}; + {ok, NewS, true} -> + %% We have ordered a start or a takeover; we must not return + %% until the app is running. + TR = NewS#state.t_reqs, + %% Delete the lock, so others may start the app + global:del_lock(LockId), + {noreply, NewS#state{t_reqs = [{AppName, From} | TR]}}; + {ok, _S, false} -> + %% Application should be started, but at another node + %% State remains the same + {reply, ok, S}; + {_ErrorTag, R} -> + {stop, R, {error, R}, S} + end. + +do_start_appls(StartApps, S) -> + SortedStartApps = StartApps, + Appls = S#state.appls, + {ok, foldl( + fun(AppName, NewS) -> + case catch start_appl(AppName, NewS, req) of + {error, R} -> + throw({{error, NewS}, R}); + {ok, NewS2, _} -> + NewS2 + end + end, S#state{appls = Appls}, lists:reverse(SortedStartApps))}. + +%%----------------------------------------------------------------- +%% Nodes = [node() | {node(), ..., node()}] +%% A list in priority order. If it is a tuple, we may pick any of +%% them. This decision is made by all nodes in the list, and all +%% nodes choose the same. This is accomplished in the following +%% way: all Nodes send to all others a msg which tells how many +%% applications each node has started. The one with least no of +%% appls starts this one. +%%----------------------------------------------------------------- +find_start_node(Nodes, PermittedNodes, Name, S) -> + AllNodes = intersection(flat_nodes(Nodes), PermittedNodes), + case lists:member(node(), AllNodes) of + true -> + Weight = get_cached_weight(Name, S), + find_start_node(Nodes, Name, S, Weight, AllNodes); + false -> + case keysearch(Name, 2, S#state.remote_started) of + {value, {Node, _Name}} -> + {already_started, Node}; + _ when AllNodes =/= [] -> + not_started; + _ -> + no_permission + end + end. + +find_start_node([AnyNodes | Nodes], Name, S, Weight, AllNodes) + when is_tuple(AnyNodes) -> + case find_any_node(tuple_to_list(AnyNodes), Name, S, Weight, AllNodes) of + false -> find_start_node(Nodes, Name, S, Weight, AllNodes); + Res -> Res + end; +find_start_node([Node | Nodes], Name, S, Weight, AllNodes) -> + case lists:member(Node, AllNodes) of + true -> + case keysearch(Name, #appl.name, S#state.appls) of + {value, #appl{id = {distributed, Node}}} -> + {already_started, Node}; + _ -> + case keysearch(Name, 2, S#state.remote_started) of + {value, {Node, _Name}} -> + {already_started, Node}; + _ -> + {ok, Node} + end + end; + false -> find_start_node(Nodes, Name, S, Weight, AllNodes) + end; +find_start_node([], _Name, _S, _Weight, _AllNodes) -> + not_started. + +%%----------------------------------------------------------------- +%% First of all, check if the application is already running +%% somewhere in AnyNodes; in that case we shall not move it! +%%----------------------------------------------------------------- +find_any_node(AnyNodes, Name, S, Weight, AllNodes) -> + case check_running(Name, S, intersection(AnyNodes, AllNodes)) of + {already_started, Node} -> {already_started, Node}; + false -> + %% Synchronize with all other nodes. + send_nodes(AllNodes, {dist_ac_weight, Name, Weight, node()}), + Answers = [{Weight, node()} | + collect_answers(AllNodes, Name, S, [])], + %% Make a decision (the same at every node) (smallest weight wins) + find_alive_node(lists:sort(Answers), + intersection(AnyNodes, S#state.known)) + end. + +%%----------------------------------------------------------------- +%% Check if another node started the appl before we got alive. +%% If so, check if the node is one of AnyNodes. +%%----------------------------------------------------------------- +check_running(Name, #state{remote_started = RStarted, + appls = Appls}, AnyNodes) -> + case keysearch(Name, 2, RStarted) of + {value, {Node, _Name}} -> + case lists:member(Node, AnyNodes) of + true -> {already_started, Node}; + false -> false + end; + false -> + case keysearch(Name, #appl.name, Appls) of + {value, #appl{id = {distributed, Node}}} -> + case lists:member(Node, AnyNodes) of + true -> {already_started, Node}; + false -> false + end; + _ -> + false + end + end. + +find_alive_node([{_, Node} | Nodes], AliveNodes) -> + case lists:member(Node, AliveNodes) of + true -> {ok, Node}; + false -> find_alive_node(Nodes, AliveNodes) + end; +find_alive_node([], _AliveNodes) -> + false. + +%%----------------------------------------------------------------- +%% First, check if the node's msg is buffered (received in our +%% main loop). Otherwise, wait for msg or nodedown. +%% We have sent the dist_ac_weight message, and will wait for it +%% to be received here (or a nodedown). This implies that a +%% dist_ac must *always* be prepared to get this messages, and to +%% send it to us. +%%----------------------------------------------------------------- +collect_answers([Node | Nodes], Name, S, Res) when Node =/= node() -> + case keysearch(Node, 3, S#state.tmp_locals) of + {value, {Name, Weight, Node}} -> + collect_answers(Nodes, Name, S, [{Weight, Node} | Res]); + _ -> + monitor_node(Node, true), + receive + {dist_ac_weight, Name, Weight, Node} -> + monitor_node(Node, false), + collect_answers(Nodes, Name, S, [{Weight, Node} | Res]); + {nodedown, Node} -> + monitor_node(Node, false), + collect_answers(Nodes, Name, S, Res) + end + end; +collect_answers([_ThisNode | Nodes], Name, S, Res) -> + collect_answers(Nodes, Name, S, Res); +collect_answers([], _Name, _S, Res) -> + Res. + +send_nodes(Nodes, Msg) -> + FlatNodes = flat_nodes(Nodes), + foreach(fun(Node) when Node =/= node() -> {?DIST_AC, Node} ! Msg; + (_ThisNode) -> ok + end, FlatNodes). + +send_after(Time, Msg) when is_integer(Time), Time >= 0 -> + spawn_link(?MODULE, send_timeout, [self(), Time, Msg]); +send_after(_,_) -> % infinity + ok. + +send_timeout(To, Time, Msg) -> + receive + after Time -> To ! Msg + end. + +send_msg(Msg, Nodes) -> + foreach(fun(Node) when Node =/= node() -> {?DIST_AC, Node} ! Msg; + (_) -> ok + end, Nodes). + +replaceadd(Item, List) -> + case member(Item, List) of + true -> List; + false -> [Item | List] + end. + +keyreplaceadd(Key, Pos, List, New) -> + case lists:keymember(Key, Pos, List) of + true -> lists:keyreplace(Key, Pos, List, New); + false -> [New | List] + end. + +keydelete_all(Key, N, [H|T]) when element(N, H) =:= Key -> + keydelete_all(Key, N, T); +keydelete_all(Key, N, [H|T]) -> + [H|keydelete_all(Key, N, T)]; +keydelete_all(_Key, _N, []) -> []. + +-ifdef(NOTUSED). +keysearchdelete(Key, Pos, List) -> + ksd(Key, Pos, List, []). + +ksd(Key, Pos, [H | T], Rest) when element(Pos, H) =:= Key -> + {value, H, Rest ++ T}; +ksd(Key, Pos, [H | T], Rest) -> + ksd(Key, Pos, T, [H | Rest]); +ksd(_Key, _Pos, [], _Rest) -> + false. + +get_new_appl(Name, [{application, Name, App} | _]) -> + {ok, {application, Name, App}}; +get_new_appl(Name, [_ | T]) -> get_new_appl(Name, T); +get_new_appl(Name, []) -> false. +-endif. + +equal_nodes([H | T1], [H | T2]) when is_atom(H) -> + equal_nodes(T1, T2); +equal_nodes([H1 | T1], [H2 | T2]) when is_tuple(H1), is_tuple(H2) -> + case equal(tuple_to_list(H1), tuple_to_list(H2)) of + true -> equal_nodes(T1, T2); + false -> false + end; +equal_nodes([], []) -> true; +equal_nodes(_, _) -> false. + +equal([H | T] , S) -> + case lists:member(H, S) of + true -> equal(T, lists:delete(H, S)); + false -> false + end; +equal([], []) -> true; +equal(_, _) -> false. + +flat_nodes(Nodes) when is_list(Nodes) -> + foldl(fun(Node, Res) when is_atom(Node) -> [Node | Res]; + (Tuple, Res) when is_tuple(Tuple) -> tuple_to_list(Tuple) ++ Res + end, [], Nodes); +flat_nodes(Nodes) -> + throw({error, {badarg, Nodes}}). + +get_cached_weight(Name, S) -> + case lists:keysearch(Name, 1, S#state.tmp_weights) of + {value, {_, W}} -> W; + _ -> get_weight() + end. + +%% Simple weight; just count the number of applications running. +get_weight() -> + length(application:which_applications()). + +get_dist_loaded(Name, [{{Name, Node}, HisNodes, Permission} | T]) -> + [{Node, HisNodes, Permission} | get_dist_loaded(Name, T)]; +get_dist_loaded(Name, [_H | T]) -> + get_dist_loaded(Name, T); +get_dist_loaded(_Name, []) -> + []. + +del_dist_loaded(Name, [{{Name, _Node}, _HisNodes, _Permission} | T]) -> + del_dist_loaded(Name, T); +del_dist_loaded(Name, [H | T]) -> + [H | del_dist_loaded(Name, T)]; +del_dist_loaded(_Name, []) -> + []. + +req_start_app(State, Name) -> + {ok, foldl( + fun({false, AppName, true, Name2}, S) when Name =:= Name2 -> + PR = keydelete(AppName, 2, S#state.p_reqs), + NS = S#state{p_reqs = PR}, + case catch do_start_appls([AppName], NS) of + {_ErrorTag, {not_running, App}} -> + NRequests = [{false, AppName, true, App} | PR], + S#state{p_reqs = NRequests}; + {ok, NewS} -> + NewS; + {_ErrorTag, R} -> + throw({error, R}) + end; + (_, S) -> + S + end, State, State#state.p_reqs)}. + + +req_del_permit_true(Reqs, Name) -> + filter(fun({From, Name2, true, _}) when Name2 =:= Name -> + gen_server:reply(From, ok), + false; + (_) -> + true + end, Reqs). + +req_del_permit_false(Reqs, Name) -> + filter(fun({From, Name2, false, _Nodes}) when Name2 =:= Name -> + gen_server:reply(From, ok), + false; + (_) -> + true + end, Reqs). + +req_del_node(S, Node, Appls) -> + check_waiting(S#state.p_reqs, S, Node, Appls, [], S#state.s_reqs). + +del_t_reqs(AppName, TReqs, Res) -> + lists:filter(fun({AN, From}) when AppName =:= AN -> + gen_server:reply(From, Res), + false; + (_) -> + true + end, + TReqs). + + +check_waiting([{From, AppName, false, Nodes} | Reqs], + S, Node, Appls, Res, SReqs) -> + case lists:delete(Node, Nodes) of + [] -> + ac_stop_it(AppName), + NSReqs = [{AppName, From} | SReqs], + check_waiting(Reqs, Node, S, Appls, Res, NSReqs); + NNodes -> + check_waiting(Reqs, Node, S, Appls, + [{From, AppName, false, NNodes} | Res], SReqs) + end; +check_waiting([H | Reqs], S, Node, Appls, Res, SReqs) -> + check_waiting(Reqs, Node, S, Appls, [H | Res], SReqs); +check_waiting([], _Node, _S, Appls, Res, SReqs) -> + {Res, Appls, SReqs}. + +intersection([], _) -> + []; +intersection(_, []) -> + []; +intersection(L1, L2) -> + L1 -- (L1 -- L2). + +get_default_permission(AppName) -> + case application:get_env(kernel, permissions) of + {ok, Permissions} -> + case keysearch(AppName, 1, Permissions) of + {value, {_, true}} -> true; + {value, {_, false}} -> false; + {value, {_, X}} -> exit({bad_permission, {AppName, X}}); + false -> true + end; + undefined -> true + end. + +%%----------------------------------------------------------------- +%% ADT dist() - info on how an application is distributed +%% dist() = [{AppName, Time, DistNodes, [{Node, Runnable}]}] +%% Time = int() >= 0 | infinity +%% Nodes = [node() | {node()...}] +%% Runnable = true | false | undefined +%% An appl may not be started if any Runnable is undefined; +%% i.e. the appl must be loaded on all Nodes. +%%----------------------------------------------------------------- +dist_check([{AppName, Nodes} | T]) -> + P = get_default_permission(AppName), + [#appl{name = AppName, nodes = Nodes, run = [{node(), P}]} | dist_check(T)]; +dist_check([{AppName, Time, Nodes} | T]) when is_integer(Time), Time >= 0 -> + P = get_default_permission(AppName), + [#appl{name = AppName, restart_time = Time, nodes = Nodes, + run = [{node(), P}]} | dist_check(T)]; +dist_check([{AppName, infinity, Nodes} | T]) -> + P = get_default_permission(AppName), + [#appl{name = AppName, restart_time = infinity, + nodes = Nodes, run = [{node(), P}]} | + dist_check(T)]; +dist_check([_ | T]) -> + dist_check(T); +dist_check([]) -> + []. + +dist_take_control(Appls) -> + foreach(fun(#appl{name = AppName}) -> + application_controller:control_application(AppName) + end, Appls). + +dist_replace(default, _Name, Appls) -> Appls; +dist_replace({AppName, Nodes}, AppName, Appls) -> + Run = [{Node, undefined} || Node <- flat_nodes(Nodes)], + keyreplaceadd(AppName, #appl.name, Appls, + #appl{name = AppName, restart_time = 0, + nodes = Nodes, run = Run}); +dist_replace({AppName, Time, Nodes}, AppName, Appls) + when is_integer(Time), Time >= 0 -> + Run = [{Node, undefined} || Node <- flat_nodes(Nodes)], + keyreplaceadd(AppName, #appl.name, Appls, + #appl{name = AppName, restart_time = Time, + nodes = Nodes, run = Run}); +dist_replace(Bad, _Name, _Appls) -> + throw({error, {bad_distribution_spec, Bad}}). + +dist_update_run(Appls, AppName, Node, Permission) -> + map(fun(Appl) when Appl#appl.name =:= AppName -> + Run = Appl#appl.run, + NRun = keyreplaceadd(Node, 1, Run, {Node, Permission}), + Appl#appl{run = NRun}; + (Appl) -> + Appl + end, Appls). + + + +dist_change_update(Appls, []) -> + Appls; +dist_change_update(Appls, [{AppName, NewNodes} | NewDist]) -> + NewAppls = do_dist_change_update(Appls, AppName, 0, NewNodes), + dist_change_update(NewAppls, NewDist); +dist_change_update(Appls, [{AppName, NewTime, NewNodes} | NewDist]) -> + NewAppls = do_dist_change_update(Appls, AppName, NewTime, NewNodes), + dist_change_update(NewAppls, NewDist). + +do_dist_change_update(Appls, AppName, NewTime, NewNodes) -> + map(fun(Appl) when Appl#appl.name =:= AppName -> + Appl#appl{restart_time = NewTime, nodes = NewNodes}; + (Appl) -> + Appl + end, Appls). + +%% Merge his Permissions with mine. +dist_merge(MyAppls, HisAppls, HisNode) -> + zf(fun(Appl) -> + #appl{name = AppName, run = Run} = Appl, +% #appl{name = AppName, nodes = Nodes, run = Run} = Appl, +% HeIsMember = lists:member(HisNode, flat_nodes(Nodes)), + HeIsMember = true, + case keysearch(AppName, #appl.name, HisAppls) of + {value, #appl{run = HisRun}} when HeIsMember -> + case keysearch(HisNode, 1, HisRun) of + {value, Val} -> % He has it loaded + NRun = keyreplaceadd(HisNode, 1, Run, Val), + {true, Appl#appl{run = NRun}}; + false -> % He hasn't loaded it yet + Val = {HisNode, undefined}, + {true, Appl#appl{run = [Val | Run]}} + end; + _ -> + true + end + end, MyAppls). + +dist_get_runnable_nodes(Appls, AppName) -> + case keysearch(AppName, #appl.name, Appls) of + {value, #appl{run = Run}} -> + zf(fun({Node, true}) -> {true, Node}; + (_) -> false + end, Run); + false -> + [] + end. + +dist_is_runnable(Appls, AppName) -> + case keysearch(AppName, #appl.name, Appls) of + {value, #appl{run = Run}} -> + case keysearch(node(), 1, Run) of + {value, {_, true}} -> true; + _ -> false + end; + false -> + false + end. + +is_loaded(AppName, #state{appls = Appls}) -> + case keysearch(AppName, #appl.name, Appls) of + {value, #appl{run = Run}} -> + case keysearch(node(), 1, Run) of + {value, {_Node, undefined}} -> false; + {value, _} -> true; + false -> false + end; + false -> + false + end. + +dist_get_runnable(Appls) -> + zf(fun(#appl{name = AppName, run = Run}) -> + case keysearch(node(), 1, Run) of + {value, {_, true}} -> {true, AppName}; + _ -> false + end + end, Appls). + +dist_get_all_nodes(#appl{name = AppName, nodes = Nodes, run = Run}) -> + {Res, BadNodes} = check_nodes(Run, [], []), + case intersection(BadNodes, erlang:nodes(connected)) of + [] -> {ok, Nodes, Res}; + _ -> {error, {app_not_loaded, AppName, BadNodes}} + end. + +check_nodes([{Node, undefined} | T], Res, BadNodes) -> + check_nodes(T, Res, [Node | BadNodes]); +check_nodes([{Node, true} | T], Res, BadNodes) -> + check_nodes(T, [Node | Res], BadNodes); +check_nodes([{_Node, false} | T], Res, BadNodes) -> + check_nodes(T, Res, BadNodes); +check_nodes([], Res, BadNodes) -> + {Res, BadNodes}. + +-ifdef(NOTUSED). +dist_find_time([#appl{name = Name, restart_time = Time} |_], Name) -> Time; +dist_find_time([_ | T], Name) -> dist_find_time(T, Name); +dist_find_time([], Name) -> 0. +-endif. + +%% Find all nodes that can run the app (even if they're not permitted +%% to right now). +dist_find_nodes([#appl{name = Name, nodes = Nodes} |_], Name) -> Nodes; +dist_find_nodes([_ | T], Name) -> dist_find_nodes(T, Name); +dist_find_nodes([], _Name) -> []. + +dist_flat_nodes(Appls, Name) -> + flat_nodes(dist_find_nodes(Appls, Name)). + +dist_del_node(Appls, Node) -> + map(fun(Appl) -> + NRun = filter(fun({N, _Runnable}) when N =:= Node -> false; + (_) -> true + end, Appl#appl.run), + Appl#appl{run = NRun} + end, Appls). + +validRestartType(permanent) -> true; +validRestartType(temporary) -> true; +validRestartType(transient) -> true; +validRestartType(_RestartType) -> false. + +dist_mismatch(AppName, Node) -> + error_msg("Distribution mismatch for application \"~p\" on nodes ~p and ~p~n", + [AppName, node(), Node]), + exit({distribution_mismatch, AppName, Node}). + +%error_msg(Format) when is_list(Format) -> +% error_msg(Format, []). + +error_msg(Format, ArgList) when is_list(Format), is_list(ArgList) -> + error_logger:error_msg("dist_ac on node ~p:~n" ++ Format, [node()|ArgList]). + +%info_msg(Format) when is_list(Format) -> +% info_msg(Format, []). + +%info_msg(Format, ArgList) when is_list(Format), is_list(ArgList) -> +% error_logger:info_msg("dist_ac on node ~p:~n" ++ Format, [node()|ArgList]). diff --git a/lib/kernel/src/dist_util.erl b/lib/kernel/src/dist_util.erl new file mode 100644 index 0000000000..a2937d60b8 --- /dev/null +++ b/lib/kernel/src/dist_util.erl @@ -0,0 +1,762 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1999-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% +%% +%%%---------------------------------------------------------------------- +%%% Purpose : The handshake of a streamed distribution connection +%%% in a separate file to make it usable for other +%%% distribution protocols. +%%%---------------------------------------------------------------------- + +-module(dist_util). + +%%-compile(export_all). +-export([handshake_we_started/1, handshake_other_started/1, + start_timer/1, setup_timer/2, + reset_timer/1, cancel_timer/1, + shutdown/3, shutdown/4]). + +-import(error_logger,[error_msg/2]). + +-include("dist_util.hrl"). +-include("dist.hrl"). + +-ifdef(DEBUG). +-define(shutdown_trace(A,B), io:format(A,B)). +-else. +-define(shutdown_trace(A,B), noop). +-endif. + +-define(to_port(FSend, Socket, Data), + case FSend(Socket, Data) of + {error, closed} -> + self() ! {tcp_closed, Socket}, + {error, closed}; + R -> + R + end). + + +-define(int16(X), [((X) bsr 8) band 16#ff, (X) band 16#ff]). + +-define(int32(X), + [((X) bsr 24) band 16#ff, ((X) bsr 16) band 16#ff, + ((X) bsr 8) band 16#ff, (X) band 16#ff]). + +-define(i16(X1,X0), + (?u16(X1,X0) - + (if (X1) > 127 -> 16#10000; true -> 0 end))). + +-define(u16(X1,X0), + (((X1) bsl 8) bor (X0))). + +-define(u32(X3,X2,X1,X0), + (((X3) bsl 24) bor ((X2) bsl 16) bor ((X1) bsl 8) bor (X0))). + +-record(tick, {read = 0, + write = 0, + tick = 0, + ticked = 0 + }). + +remove_flag(Flag, Flags) -> + case Flags band Flag of + 0 -> + Flags; + _ -> + Flags - Flag + end. + +adjust_flags(ThisFlags, OtherFlags) -> + case (?DFLAG_PUBLISHED band ThisFlags) band OtherFlags of + 0 -> + {remove_flag(?DFLAG_PUBLISHED, ThisFlags), + remove_flag(?DFLAG_PUBLISHED, OtherFlags)}; + _ -> + {ThisFlags, OtherFlags} + end. + +publish_flag(hidden, _) -> + 0; +publish_flag(_, OtherNode) -> + case net_kernel:publish_on_node(OtherNode) of + true -> + ?DFLAG_PUBLISHED; + _ -> + 0 + end. + +make_this_flags(RequestType, OtherNode) -> + publish_flag(RequestType, OtherNode) bor + %% The parenthesis below makes the compiler generate better code. + (?DFLAG_EXPORT_PTR_TAG bor + ?DFLAG_EXTENDED_PIDS_PORTS bor + ?DFLAG_EXTENDED_REFERENCES bor + ?DFLAG_DIST_MONITOR bor + ?DFLAG_FUN_TAGS bor + ?DFLAG_DIST_MONITOR_NAME bor + ?DFLAG_HIDDEN_ATOM_CACHE bor + ?DFLAG_NEW_FUN_TAGS bor + ?DFLAG_BIT_BINARIES bor + ?DFLAG_NEW_FLOATS bor + ?DFLAG_UNICODE_IO bor + ?DFLAG_DIST_HDR_ATOM_CACHE bor + ?DFLAG_SMALL_ATOM_TAGS). + +handshake_other_started(#hs_data{request_type=ReqType}=HSData0) -> + {PreOtherFlags,Node,Version} = recv_name(HSData0), + PreThisFlags = make_this_flags(ReqType, Node), + {ThisFlags, OtherFlags} = adjust_flags(PreThisFlags, + PreOtherFlags), + HSData = HSData0#hs_data{this_flags=ThisFlags, + other_flags=OtherFlags, + other_version=Version, + other_node=Node, + other_started=true}, + check_dflag_xnc(HSData), + is_allowed(HSData), + ?debug({"MD5 connection from ~p (V~p)~n", + [Node, HSData#hs_data.other_version]}), + mark_pending(HSData), + {MyCookie,HisCookie} = get_cookies(Node), + ChallengeA = gen_challenge(), + send_challenge(HSData, ChallengeA), + reset_timer(HSData#hs_data.timer), + ChallengeB = recv_challenge_reply(HSData, ChallengeA, MyCookie), + send_challenge_ack(HSData, gen_digest(ChallengeB, HisCookie)), + ?debug({dist_util, self(), accept_connection, Node}), + connection(HSData). + +%% +%% check if connecting node is allowed to connect +%% with allow-node-scheme +%% +is_allowed(#hs_data{other_node = Node, + allowed = Allowed} = HSData) -> + case lists:member(Node, Allowed) of + false when Allowed =/= [] -> + send_status(HSData, not_allowed), + error_msg("** Connection attempt from " + "disallowed node ~w ** ~n", [Node]), + ?shutdown(Node); + _ -> true + end. + +%% +%% Check that both nodes can handle the same types of extended +%% node containers. If they can not, abort the connection. +%% +check_dflag_xnc(#hs_data{other_node = Node, + other_flags = OtherFlags, + other_started = OtherStarted} = HSData) -> + XRFlg = ?DFLAG_EXTENDED_REFERENCES, + XPPFlg = case erlang:system_info(compat_rel) of + R when R >= 10 -> + ?DFLAG_EXTENDED_PIDS_PORTS; + _ -> + 0 + end, + ReqXncFlags = XRFlg bor XPPFlg, + case OtherFlags band ReqXncFlags =:= ReqXncFlags of + true -> + ok; + false -> + What = case {OtherFlags band XRFlg =:= XRFlg, + OtherFlags band XPPFlg =:= XPPFlg} of + {false, false} -> "references, pids and ports"; + {true, false} -> "pids and ports"; + {false, true} -> "references" + end, + case OtherStarted of + true -> + send_status(HSData, not_allowed), + Dir = "from", + How = "rejected"; + _ -> + Dir = "to", + How = "aborted" + end, + error_msg("** ~w: Connection attempt ~s node ~w ~s " + "since it cannot handle extended ~s. " + "**~n", [node(), Dir, Node, How, What]), + ?shutdown(Node) + end. + + +%% No nodedown will be sent if we fail before this process has +%% succeeded to mark the node as pending. + +mark_pending(#hs_data{kernel_pid=Kernel, + other_node=Node, + this_node=MyNode}=HSData) -> + case do_mark_pending(Kernel, MyNode, Node, + (HSData#hs_data.f_address)(HSData#hs_data.socket, + Node), + HSData#hs_data.other_flags) of + ok -> + send_status(HSData, ok), + reset_timer(HSData#hs_data.timer); + + ok_pending -> + send_status(HSData, ok_simultaneous), + reset_timer(HSData#hs_data.timer); + + nok_pending -> + send_status(HSData, nok), + ?shutdown(Node); + + up_pending -> + %% Check if connection is still alive, no + %% implies that the connection is no longer pending + %% due to simultaneous connect + do_alive(HSData), + + %% This can happen if the other node goes down, + %% and goes up again and contact us before we have + %% detected that the socket was closed. + wait_pending(Kernel), + reset_timer(HSData#hs_data.timer); + + already_pending -> + %% FIXME: is this a case ? + ?debug({dist_util,self(),mark_pending,already_pending,Node}), + ?shutdown(Node) + end. + + +%% +%% Marking pending and negotiating away +%% simultaneous connection problems +%% + +wait_pending(Kernel) -> + receive + {Kernel, pending} -> + ?trace("wait_pending returned for pid ~p.~n", + [self()]), + ok + end. + +do_alive(#hs_data{other_node = Node} = HSData) -> + send_status(HSData, alive), + case recv_status(HSData) of + true -> true; + false -> ?shutdown(Node) + end. + +do_mark_pending(Kernel, MyNode, Node, Address, Flags) -> + Kernel ! {self(), {accept_pending,MyNode,Node,Address, + publish_type(Flags)}}, + receive + {Kernel,{accept_pending,Ret}} -> + ?trace("do_mark_pending(~p,~p,~p,~p) -> ~p~n", + [Kernel,Node,Address,Flags,Ret]), + Ret + end. + +is_pending(Kernel, Node) -> + Kernel ! {self(), {is_pending, Node}}, + receive + {Kernel, {is_pending, Reply}} -> Reply + end. + +%% +%% This will tell the net_kernel about the nodedown as it +%% recognizes the exit signal. +%% The termination of this process does also imply that the Socket +%% is closed in a controlled way by inet_drv. +%% + +-spec shutdown(atom(), non_neg_integer(), term()) -> no_return(). + +shutdown(Module, Line, Data) -> + shutdown(Module, Line, Data, shutdown). + +-spec shutdown(atom(), non_neg_integer(), term(), term()) -> no_return(). + +shutdown(_Module, _Line, _Data, Reason) -> + ?shutdown_trace("Net Kernel 2: shutting down connection " + "~p:~p, data ~p,reason ~p~n", + [_Module,_Line, _Data, Reason]), + flush_down(), + exit(Reason). +%% Use this line to debug connection. +%% Set net_kernel verbose = 1 as well. +%% exit({Reason, ?MODULE, _Line, _Data, erlang:now()}). + + +flush_down() -> + receive + {From, get_status} -> + From ! {self(), get_status, error}, + flush_down() + after 0 -> + ok + end. + +handshake_we_started(#hs_data{request_type=ReqType, + other_node=Node}=PreHSData) -> + PreThisFlags = make_this_flags(ReqType, Node), + HSData = PreHSData#hs_data{this_flags=PreThisFlags}, + send_name(HSData), + recv_status(HSData), + {PreOtherFlags,ChallengeA} = recv_challenge(HSData), + {ThisFlags,OtherFlags} = adjust_flags(PreThisFlags, PreOtherFlags), + NewHSData = HSData#hs_data{this_flags = ThisFlags, + other_flags = OtherFlags, + other_started = false}, + check_dflag_xnc(NewHSData), + MyChallenge = gen_challenge(), + {MyCookie,HisCookie} = get_cookies(Node), + send_challenge_reply(NewHSData,MyChallenge, + gen_digest(ChallengeA,HisCookie)), + reset_timer(NewHSData#hs_data.timer), + recv_challenge_ack(NewHSData, MyChallenge, MyCookie), + connection(NewHSData). + +%% -------------------------------------------------------------- +%% The connection has been established. +%% -------------------------------------------------------------- + +connection(#hs_data{other_node = Node, + socket = Socket, + f_address = FAddress, + f_setopts_pre_nodeup = FPreNodeup, + f_setopts_post_nodeup = FPostNodeup}= HSData) -> + cancel_timer(HSData#hs_data.timer), + PType = publish_type(HSData#hs_data.other_flags), + case FPreNodeup(Socket) of + ok -> + do_setnode(HSData), % Succeeds or exits the process. + Address = FAddress(Socket,Node), + mark_nodeup(HSData,Address), + case FPostNodeup(Socket) of + ok -> + con_loop(HSData#hs_data.kernel_pid, + Node, + Socket, + Address, + HSData#hs_data.this_node, + PType, + #tick{}, + HSData#hs_data.mf_tick, + HSData#hs_data.mf_getstat); + _ -> + ?shutdown2(Node, connection_setup_failed) + end; + _ -> + ?shutdown(Node) + end. + +%% Generate a message digest from Challenge number and Cookie +gen_digest(Challenge, Cookie) when is_integer(Challenge), is_atom(Cookie) -> + erlang:md5([atom_to_list(Cookie)|integer_to_list(Challenge)]). + +%% --------------------------------------------------------------- +%% Challenge code +%% gen_challenge() returns a "random" number +%% --------------------------------------------------------------- +gen_challenge() -> + {A,B,C} = erlang:now(), + {D,_} = erlang:statistics(reductions), + {E,_} = erlang:statistics(runtime), + {F,_} = erlang:statistics(wall_clock), + {G,H,_} = erlang:statistics(garbage_collection), + %% A(8) B(16) C(16) + %% D(16),E(8), F(16) G(8) H(16) + ( ((A bsl 24) + (E bsl 16) + (G bsl 8) + F) bxor + (B + (C bsl 16)) bxor + (D + (H bsl 16)) ) band 16#ffffffff. + +%% +%% Get the cookies for a node from auth +%% +get_cookies(Node) -> + case auth:get_cookie(Node) of + X when is_atom(X) -> + {X,X} +% {Y,Z} when is_atom(Y), is_atom(Z) -> +% {Y,Z}; +% _ -> +% erlang:error("Corrupt cookie database") + end. + +%% No error return; either succeeds or terminates the process. +do_setnode(#hs_data{other_node = Node, socket = Socket, + other_flags = Flags, other_version = Version, + f_getll = GetLL}) -> + case GetLL(Socket) of + {ok,Port} -> + ?trace("setnode(md5,~p ~p ~p)~n", + [Node, Port, {publish_type(Flags), + '(', Flags, ')', + Version}]), + case (catch + erlang:setnode(Node, Port, + {Flags, Version, '', ''})) of + {'EXIT', {system_limit, _}} -> + error_msg("** Distribution system limit reached, " + "no table space left for node ~w ** ~n", + [Node]), + ?shutdown(Node); + {'EXIT', Other} -> + exit(Other); + _Else -> + ok + end; + _ -> + error_msg("** Distribution connection error, " + "could not get low level port for node ~w ** ~n", + [Node]), + ?shutdown(Node) + end. + +mark_nodeup(#hs_data{kernel_pid = Kernel, + other_node = Node, + other_flags = Flags, + other_started = OtherStarted}, + Address) -> + Kernel ! {self(), {nodeup,Node,Address,publish_type(Flags), + true}}, + receive + {Kernel, inserted} -> + ok; + {Kernel, bad_request} -> + TypeT = case OtherStarted of + true -> + "accepting connection"; + _ -> + "initiating connection" + end, + error_msg("Fatal: ~p was not allowed to " + "send {nodeup, ~p} to kernel when ~s~n", + [self(), Node, TypeT]), + ?shutdown(Node) + end. + +con_loop(Kernel, Node, Socket, TcpAddress, + MyNode, Type, Tick, MFTick, MFGetstat) -> + receive + {tcp_closed, Socket} -> + ?shutdown2(Node, connection_closed); + {Kernel, disconnect} -> + ?shutdown2(Node, disconnected); + {Kernel, aux_tick} -> + case MFGetstat(Socket) of + {ok, _, _, PendWrite} -> + send_tick(Socket, PendWrite, MFTick); + _ -> + ignore_it + end, + con_loop(Kernel, Node, Socket, TcpAddress, MyNode, Type, + Tick, MFTick, MFGetstat); + {Kernel, tick} -> + case send_tick(Socket, Tick, Type, + MFTick, MFGetstat) of + {ok, NewTick} -> + con_loop(Kernel, Node, Socket, TcpAddress, + MyNode, Type, NewTick, MFTick, + MFGetstat); + {error, not_responding} -> + error_msg("** Node ~p not responding **~n" + "** Removing (timedout) connection **~n", + [Node]), + ?shutdown2(Node, net_tick_timeout); + _Other -> + ?shutdown2(Node, send_net_tick_failed) + end; + {From, get_status} -> + case MFGetstat(Socket) of + {ok, Read, Write, _} -> + From ! {self(), get_status, {ok, Read, Write}}, + con_loop(Kernel, Node, Socket, TcpAddress, + MyNode, + Type, Tick, + MFTick, MFGetstat); + _ -> + ?shutdown2(Node, get_status_failed) + end + end. + + +%% ------------------------------------------------------------ +%% Misc. functions. +%% ------------------------------------------------------------ + +send_name(#hs_data{socket = Socket, this_node = Node, + f_send = FSend, + this_flags = Flags, + other_version = Version}) -> + ?trace("send_name: node=~w, version=~w\n", + [Node,Version]), + ?to_port(FSend, Socket, + [$n, ?int16(Version), ?int32(Flags), atom_to_list(Node)]). + +send_challenge(#hs_data{socket = Socket, this_node = Node, + other_version = Version, + this_flags = Flags, + f_send = FSend}, + Challenge ) -> + ?trace("send: challenge=~w version=~w\n", + [Challenge,Version]), + ?to_port(FSend, Socket, [$n,?int16(Version), ?int32(Flags), + ?int32(Challenge), + atom_to_list(Node)]). + +send_challenge_reply(#hs_data{socket = Socket, f_send = FSend}, + Challenge, Digest) -> + ?trace("send_reply: challenge=~w digest=~p\n", + [Challenge,Digest]), + ?to_port(FSend, Socket, [$r,?int32(Challenge),Digest]). + +send_challenge_ack(#hs_data{socket = Socket, f_send = FSend}, + Digest) -> + ?trace("send_ack: digest=~p\n", [Digest]), + ?to_port(FSend, Socket, [$a,Digest]). + + +%% +%% Get the name of the other side. +%% Close the connection if invalid data. +%% The IP address sent is not interesting (as in the old +%% tcp_drv.c which used it to detect simultaneous connection +%% attempts). +%% +recv_name(#hs_data{socket = Socket, f_recv = Recv}) -> + case Recv(Socket, 0, infinity) of + {ok,Data} -> + get_name(Data); + _ -> + ?shutdown(no_node) + end. + +get_name([$n,VersionA, VersionB, Flag1, Flag2, Flag3, Flag4 | OtherNode]) -> + {?u32(Flag1, Flag2, Flag3, Flag4), list_to_atom(OtherNode), + ?u16(VersionA,VersionB)}; +get_name(Data) -> + ?shutdown(Data). + +publish_type(Flags) -> + case Flags band ?DFLAG_PUBLISHED of + 0 -> + hidden; + _ -> + normal + end. + +%% wait for challenge after connect +recv_challenge(#hs_data{socket=Socket,other_node=Node, + other_version=Version,f_recv=Recv}) -> + case Recv(Socket, 0, infinity) of + {ok,[$n,V1,V0,Fl1,Fl2,Fl3,Fl4,CA3,CA2,CA1,CA0 | Ns]} -> + Flags = ?u32(Fl1,Fl2,Fl3,Fl4), + case {list_to_existing_atom(Ns),?u16(V1,V0)} of + {Node,Version} -> + Challenge = ?u32(CA3,CA2,CA1,CA0), + ?trace("recv: node=~w, challenge=~w version=~w\n", + [Node, Challenge,Version]), + {Flags,Challenge}; + _ -> + ?shutdown(no_node) + end; + _ -> + ?shutdown(no_node) + end. + + +%% +%% wait for challenge response after send_challenge +%% +recv_challenge_reply(#hs_data{socket = Socket, + other_node = NodeB, + f_recv = FRecv}, + ChallengeA, Cookie) -> + case FRecv(Socket, 0, infinity) of + {ok,[$r,CB3,CB2,CB1,CB0 | SumB]} when length(SumB) =:= 16 -> + SumA = gen_digest(ChallengeA, Cookie), + ChallengeB = ?u32(CB3,CB2,CB1,CB0), + ?trace("recv_reply: challenge=~w digest=~p\n", + [ChallengeB,SumB]), + ?trace("sum = ~p\n", [SumA]), + case list_to_binary(SumB) of + SumA -> + ChallengeB; + _ -> + error_msg("** Connection attempt from " + "disallowed node ~w ** ~n", [NodeB]), + ?shutdown(NodeB) + end; + _ -> + ?shutdown(no_node) + end. + +recv_challenge_ack(#hs_data{socket = Socket, f_recv = FRecv, + other_node = NodeB}, + ChallengeB, CookieA) -> + case FRecv(Socket, 0, infinity) of + {ok,[$a|SumB]} when length(SumB) =:= 16 -> + SumA = gen_digest(ChallengeB, CookieA), + ?trace("recv_ack: digest=~p\n", [SumB]), + ?trace("sum = ~p\n", [SumA]), + case list_to_binary(SumB) of + SumA -> + ok; + _ -> + error_msg("** Connection attempt to " + "disallowed node ~w ** ~n", [NodeB]), + ?shutdown(NodeB) + end; + _ -> + ?shutdown(NodeB) + end. + +recv_status(#hs_data{kernel_pid = Kernel, socket = Socket, + other_node = Node, f_recv = Recv} = HSData) -> + case Recv(Socket, 0, infinity) of + {ok, [$s|StrStat]} -> + Stat = list_to_atom(StrStat), + ?debug({dist_util,self(),recv_status, Node, Stat}), + case Stat of + not_allowed -> ?shutdown(Node); + nok -> + %% wait to be killed by net_kernel + receive + after infinity -> ok + end; + alive -> + Reply = is_pending(Kernel, Node), + ?debug({is_pending,self(),Reply}), + send_status(HSData, Reply), + if not Reply -> + ?shutdown(Node); + Reply -> + Stat + end; + _ -> Stat + end; + _Error -> + ?debug({dist_util,self(),recv_status_error, + Node, _Error}), + ?shutdown(Node) + end. + + +send_status(#hs_data{socket = Socket, other_node = Node, + f_send = FSend}, Stat) -> + ?debug({dist_util,self(),send_status, Node, Stat}), + case FSend(Socket, [$s | atom_to_list(Stat)]) of + {error, _} -> + ?shutdown(Node); + _ -> + true + end. + + + +%% +%% Send a TICK to the other side. +%% +%% This will happen every 15 seconds (by default) +%% The idea here is that every 15 secs, we write a little +%% something on the connection if we haven't written anything for +%% the last 15 secs. +%% This will ensure that nodes that are not responding due to +%% hardware errors (Or being suspended by means of ^Z) will +%% be considered to be down. If we do not want to have this +%% we must start the net_kernel (in erlang) without its +%% ticker process, In that case this code will never run + +%% And then every 60 seconds we also check the connection and +%% close it if we havn't received anything on it for the +%% last 60 secs. If ticked == tick we havn't received anything +%% on the connection the last 60 secs. + +%% The detection time interval is thus, by default, 45s < DT < 75s + +%% A HIDDEN node is always (if not a pending write) ticked if +%% we haven't read anything as a hidden node only ticks when it receives +%% a TICK !! + +send_tick(Socket, Tick, Type, MFTick, MFGetstat) -> + #tick{tick = T0, + read = Read, + write = Write, + ticked = Ticked} = Tick, + T = T0 + 1, + T1 = T rem 4, + case MFGetstat(Socket) of + {ok, Read, _, _} when Ticked =:= T -> + {error, not_responding}; + {ok, Read, W, Pend} when Type =:= hidden -> + send_tick(Socket, Pend, MFTick), + {ok, Tick#tick{write = W + 1, + tick = T1}}; + {ok, Read, Write, Pend} -> + send_tick(Socket, Pend, MFTick), + {ok, Tick#tick{write = Write + 1, + tick = T1}}; + {ok, R, Write, Pend} -> + send_tick(Socket, Pend, MFTick), + {ok, Tick#tick{write = Write + 1, + read = R, + tick = T1, + ticked = T}}; + {ok, Read, W, _} -> + {ok, Tick#tick{write = W, + tick = T1}}; + {ok, R, W, _} -> + {ok, Tick#tick{write = W, + read = R, + tick = T1, + ticked = T}}; + Error -> + Error + end. + +send_tick(Socket, 0, MFTick) -> + MFTick(Socket); +send_tick(_, _Pend, _) -> + %% Dont send tick if pending write. + ok. + +%% ------------------------------------------------------------ +%% Connection setup timeout timer. +%% After Timeout milliseconds this process terminates +%% which implies that the owning setup/accept process terminates. +%% The timer is reset before every network operation during the +%% connection setup ! +%% ------------------------------------------------------------ + +start_timer(Timeout) -> + spawn_link(?MODULE, setup_timer, [self(), Timeout*?trace_factor]). + +setup_timer(Pid, Timeout) -> + receive + {Pid, reset} -> + setup_timer(Pid, Timeout) + after Timeout -> + ?trace("Timer expires ~p, ~p~n",[Pid, Timeout]), + ?shutdown(timer) + end. + +reset_timer(Timer) -> + Timer ! {self(), reset}. + +cancel_timer(Timer) -> + unlink(Timer), + exit(Timer, shutdown). + diff --git a/lib/kernel/src/dist_util.hrl b/lib/kernel/src/dist_util.hrl new file mode 100644 index 0000000000..f2b0598532 --- /dev/null +++ b/lib/kernel/src/dist_util.hrl @@ -0,0 +1,87 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1999-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% +%% +%% uncomment this if tracing of handshake etc is wanted +%%-define(dist_trace, true). +%%-define(dist_debug, true). + + +-ifdef(dist_debug). +-define(debug(Term), erlang:display(Term)). +-else. +-define(debug(Term), ok). +-endif. + +-ifdef(dist_trace). +-define(trace(Fmt,Args), io:format("~p ~p:~s",[erlang:now(),node(),lists:flatten(io_lib:format(Fmt, Args))])). +% Use the one below for config-file (early boot) connection tracing +%-define(trace(Fmt,Args), erlang:display([erlang:now(),node(),lists:flatten(io_lib:format(Fmt, Args))])). +-define(trace_factor,8). +-else. +-define(trace(Fmt,Args), ok). +-define(trace_factor,1). +-endif. + +-define(shutdown(Data), dist_util:shutdown(?MODULE, ?LINE, Data)). +-define(shutdown2(Data, Reason), dist_util:shutdown(?MODULE, ?LINE, Data, Reason)). + +%% Handshake state structure +-record(hs_data, { + kernel_pid, %% Pid of net_kernel + other_node, %% Name of peer + this_node, %% my nodename + socket, %% The connection "socket" + timer, %% The setup timer + %% (stream_dist_handshake:start_timer) + this_flags, %% Flags my node should use + allowed, %% Allowed nodes list + other_version, %% The other nodes distribution version + other_flags, %% The other nodes flags. + other_started, %% True if the other node initiated. + f_send, %% Fun that behaves like gen_tcp:send + f_recv, %% Fun that behaves like gen_tcp:recv + f_setopts_pre_nodeup, %% Sets "socket" options before + %% nodeup is delivered to net_kernel + f_setopts_post_nodeup, %% Sets "socket" options after + %% nodeup is delivered + f_getll, %% Get low level port or pid. + f_address, %% The address of the "socket", + %% generated from Socket,Node + %% These two are used in the tick loop, + %% so they are not fun's to avoid holding old code. + mf_tick, %% Takes the socket as parameters and + %% sends a tick, this is no fun, it + %% is a tuple {M,F}. + %% Is should place {tcp_closed, Socket} + %% in the message queue on failure. + mf_getstat, %% Returns + %% {ok, RecvCnt, SendCnt, SendPend} for + %% a given socket. This is a {M,F}, + %% returning {error, Reason on failure} + request_type = normal +}). + + +%% The following should be filled in upon enter of... +%% - handshake_we_started: +%% kernel_pid, other_node, this_node, socket, timer, +%% this_flags, other_version, All fun's/mf's. +%% - handshake_other_started: +%% kernel_pid, this_node, socket, timer, +%% this_flags, allowed, All fun's/mf's. + diff --git a/lib/kernel/src/erl_boot_server.erl b/lib/kernel/src/erl_boot_server.erl new file mode 100644 index 0000000000..702b2feac9 --- /dev/null +++ b/lib/kernel/src/erl_boot_server.erl @@ -0,0 +1,325 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1996-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% +%% +%% A simple boot_server at a CP. +%% +%% This server should know about which slaves (DP's or whatever) to boot. +%% File's (with absolute path name) will be fetched. +%% + +-module(erl_boot_server). + +-include("inet_boot.hrl"). + +-behaviour(gen_server). + +%% API functions. +-export([start/1, start_link/1, add_slave/1, delete_slave/1, + add_subnet/2, delete_subnet/2, + which_slaves/0]). + +%% Exports for testing (dont't remove; tests suites depend on them). +-export([would_be_booted/1]). + +%% Internal exports +-export([init/1,handle_call/3,handle_cast/2,handle_info/2,terminate/2]). +-export([code_change/3]). +-export([boot_init/1, boot_accept/3]). + +-record(state, + { + priority = 0, %% priority of this server + version = "" :: string(), %% Version handled i.e "4.5.3" etc + udp_sock, %% listen port for broadcase requests + udp_port, %% port number must be ?EBOOT_PORT! + listen_sock, %% listen sock for incoming file requests + listen_port, %% listen port number + slaves, %% list of accepted ip addresses + bootp :: pid(), %% boot process + prim_state %% state for efile code loader + }). + +-define(single_addr_mask, {255, 255, 255, 255}). + +-type ip4_address() :: {0..255,0..255,0..255,0..255}. + +-spec start(Slaves :: [atom()]) -> {'ok', pid()} | {'error', any()}. + +start(Slaves) -> + case check_arg(Slaves) of + {ok, AL} -> + gen_server:start({local,boot_server}, erl_boot_server, AL, []); + _ -> + {error, {badarg, Slaves}} + end. + +-spec start_link(Slaves :: [atom()]) -> {'ok', pid()} | {'error', any()}. + +start_link(Slaves) -> + case check_arg(Slaves) of + {ok, AL} -> + gen_server:start_link({local,boot_server}, + erl_boot_server, AL, []); + _ -> + {error, {badarg, Slaves}} + end. + +check_arg(Slaves) -> + check_arg(Slaves, []). + +check_arg([Slave|Rest], Result) -> + case inet:getaddr(Slave, inet) of + {ok, IP} -> + check_arg(Rest, [{?single_addr_mask, IP}|Result]); + _ -> + error + end; +check_arg([], Result) -> + {ok, Result}; +check_arg(_, _Result) -> + error. + +-spec add_slave(Slave :: atom()) -> 'ok' | {'error', any()}. + +add_slave(Slave) -> + case inet:getaddr(Slave, inet) of + {ok,IP} -> + gen_server:call(boot_server, {add, {?single_addr_mask, IP}}); + _ -> + {error, {badarg, Slave}} + end. + +-spec delete_slave(Slave :: atom()) -> 'ok' | {'error', any()}. + +delete_slave(Slave) -> + case inet:getaddr(Slave, inet) of + {ok,IP} -> + gen_server:call(boot_server, {delete, {?single_addr_mask, IP}}); + _ -> + {error, {badarg, Slave}} + end. + +-spec add_subnet(Mask :: ip4_address(), Addr :: ip4_address()) -> + 'ok' | {'error', any()}. + +add_subnet(Mask, Addr) when is_tuple(Mask), is_tuple(Addr) -> + case member_address(Addr, [{Mask, Addr}]) of + true -> + gen_server:call(boot_server, {add, {Mask, Addr}}); + false -> + {error, empty_subnet} + end. + +-spec delete_subnet(Mask :: ip4_address(), Addr :: ip4_address()) -> 'ok'. + +delete_subnet(Mask, Addr) when is_tuple(Mask), is_tuple(Addr) -> + gen_server:call(boot_server, {delete, {Mask, Addr}}). + +-spec which_slaves() -> [atom()]. + +which_slaves() -> + gen_server:call(boot_server, which). + +%% Given a host name or IP address, returns true if a host +%% having that IP address would be accepted for booting, and +%% false otherwise. (Convenient for testing.) + +would_be_booted(Addr) -> + {ok, IP} = inet:getaddr(Addr, inet), + member_address(IP, which_slaves()). + +int16(X) when is_integer(X) -> + [(X bsr 8) band 16#ff, (X) band 16#ff]. + +%% Check if an address is a member + +member_address(IP, [{{MA, MB, MC, MD}, {EA, EB, EC, ED}}|Rest]) -> + {A, B, C, D} = IP, + if A band MA =:= EA, + B band MB =:= EB, + C band MC =:= EC, + D band MD =:= ED -> + true; + true -> + member_address(IP, Rest) + end; +member_address(_, []) -> + false. + +%% ------------------------------------------------------------ +%% call-back functions. +%% ------------------------------------------------------------ + +init(Slaves) -> + {ok, U} = gen_udp:open(?EBOOT_PORT, []), + {ok, L} = gen_tcp:listen(0, [binary,{packet,4}]), + {ok, Port} = inet:port(L), + {ok, UPort} = inet:port(U), + Ref = make_ref(), + Pid = proc_lib:spawn_link(?MODULE, boot_init, [Ref]), + gen_tcp:controlling_process(L, Pid), + Pid ! {Ref, L}, + %% We trap exit inorder to restart boot_init and udp_port + process_flag(trap_exit, true), + {ok, #state {priority = 0, + version = erlang:system_info(version), + udp_sock = U, + udp_port = UPort, + listen_sock = L, + listen_port = Port, + slaves = ordsets:from_list(Slaves), + bootp = Pid + }}. + +handle_call({add,Address}, _, S0) -> + Slaves = ordsets:add_element(Address, S0#state.slaves), + S0#state.bootp ! {slaves, Slaves}, + {reply, ok, S0#state{slaves = Slaves}}; +handle_call({delete,Address}, _, S0) -> + Slaves = ordsets:del_element(Address, S0#state.slaves), + S0#state.bootp ! {slaves, Slaves}, + {reply, ok, S0#state{slaves = Slaves}}; +handle_call(which, _, S0) -> + {reply, ordsets:to_list(S0#state.slaves), S0}. + +handle_cast(_, Slaves) -> + {noreply, Slaves}. + +handle_info({udp, U, IP, Port, Data}, S0) -> + Token = ?EBOOT_REQUEST ++ S0#state.version, + Valid = member_address(IP, ordsets:to_list(S0#state.slaves)), + %% check that the connecting node is valid and has the same + %% erlang version as the boot server node + case {Valid,Data,Token} of + {true,Token,Token} -> + gen_udp:send(U,IP,Port,[?EBOOT_REPLY,S0#state.priority, + int16(S0#state.listen_port), + S0#state.version]), + {noreply,S0}; + {false,_,_} -> + error_logger:error_msg("** Illegal boot server connection attempt: " + "~w is not a valid address ** ~n", [IP]), + {noreply,S0}; + {true,_,_} -> + case catch string:substr(Data, 1, length(?EBOOT_REQUEST)) of + ?EBOOT_REQUEST -> + Vsn = string:substr(Data, length(?EBOOT_REQUEST)+1, length(Data)), + error_logger:error_msg("** Illegal boot server connection attempt: " + "client version is ~s ** ~n", [Vsn]); + _ -> + error_logger:error_msg("** Illegal boot server connection attempt: " + "unrecognizable request ** ~n", []) + end, + {noreply,S0} + end; +handle_info(_Info, S0) -> + {noreply,S0}. + +terminate(_Reason, _S0) -> + ok. + +code_change(_Vsn, State, _Extra) -> + {ok, State}. + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% +%% Boot server +%% +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +boot_init(Tag) -> + receive + {Tag, Listen} -> + process_flag(trap_exit, true), + boot_main(Listen) + end. + +boot_main(Listen) -> + Tag = make_ref(), + Pid = proc_lib:spawn_link(?MODULE, boot_accept, [self(), Listen, Tag]), + boot_main(Listen, Tag, Pid). + +boot_main(Listen, Tag, Pid) -> + receive + {Tag, _} -> + boot_main(Listen); + {'EXIT', Pid, _} -> + boot_main(Listen); + {'EXIT', _, Reason} -> + exit(Pid, kill), + exit(Reason); + {tcp_closed, Listen} -> + exit(closed) + end. + +boot_accept(Server, Listen, Tag) -> + Reply = gen_tcp:accept(Listen), + unlink(Server), + Server ! {Tag, continue}, + case Reply of + {ok, Socket} -> + {ok, {IP, _Port}} = inet:peername(Socket), + true = member_address(IP, which_slaves()), + PS = erl_prim_loader:prim_init(), + boot_loop(Socket, PS) + end. + +boot_loop(Socket, PS) -> + receive + {tcp, Socket, Data} -> + PS2 = handle_command(Socket, PS, Data), + boot_loop(Socket, PS2); + {tcp_closed, Socket} -> + true + end. + +handle_command(S, PS, Msg) -> + case catch binary_to_term(Msg) of + {get,File} -> + {Res, PS2} = erl_prim_loader:prim_get_file(PS, File), + send_file_result(S, get, Res), + PS2; + {list_dir,Dir} -> + {Res, PS2} = erl_prim_loader:prim_list_dir(PS, Dir), + send_file_result(S, list_dir, Res), + PS2; + {read_file_info,File} -> + {Res, PS2} = erl_prim_loader:prim_read_file_info(PS, File), + send_file_result(S, read_file_info, Res), + PS2; + get_cwd -> + {Res, PS2} = erl_prim_loader:prim_get_cwd(PS, []), + send_file_result(S, get_cwd, Res), + PS2; + {get_cwd,Drive} -> + {Res, PS2} = erl_prim_loader:prim_get_cwd(PS, [Drive]), + send_file_result(S, get_cwd, Res), + PS2; + {'EXIT',Reason} -> + send_result(S, {error,Reason}), + PS; + _Other -> + send_result(S, {error,unknown_command}), + PS + end. + +send_file_result(S, Cmd, Result) -> + gen_tcp:send(S, term_to_binary({Cmd,Result})). + +send_result(S, Result) -> + gen_tcp:send(S, term_to_binary(Result)). diff --git a/lib/kernel/src/erl_ddll.erl b/lib/kernel/src/erl_ddll.erl new file mode 100644 index 0000000000..88f91de24f --- /dev/null +++ b/lib/kernel/src/erl_ddll.erl @@ -0,0 +1,150 @@ +%% +%% %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% +%% +%% Dynamic Driver Loader and Linker +%% +%% Interface for dynamic library/shared object driver loader/linker. +%% Provides methods for loading, unloading and listing drivers. + +-module(erl_ddll). + +-export([load_driver/2, load/2, + unload_driver/1, unload/1, reload/2, reload_driver/2, + format_error/1,info/1,info/0, start/0, stop/0]). + +%%---------------------------------------------------------------------------- + +-spec start() -> {'error', {'already_started', 'undefined'}}. + +start() -> + {error, {already_started,undefined}}. + +-spec stop() -> 'ok'. + +stop() -> + ok. + +-spec load_driver(Path :: string() | atom(), Driver :: string() | atom()) -> + 'ok' | {'error', any()}. + +load_driver(Path, Driver) -> + do_load_driver(Path, Driver, [{driver_options,[kill_ports]}]). + +-spec load(Path :: string() | atom(), Driver :: string() | atom()) -> + 'ok' | {'error', any()}. + +load(Path, Driver) -> + do_load_driver(Path, Driver, []). + +do_load_driver(Path, Driver, DriverFlags) -> + case erl_ddll:try_load(Path, Driver,[{monitor,pending_driver}]++DriverFlags) of + {error, inconsistent} -> + {error,bad_driver_name}; % BC + {error, What} -> + {error,What}; + {ok, already_loaded} -> + ok; + {ok,loaded} -> + ok; + {ok, pending_driver, Ref} -> + receive + {'DOWN', Ref, driver, _, load_cancelled} -> + {error, load_cancelled}; + {'UP', Ref, driver, _, permanent} -> + {error, permanent}; + {'DOWN', Ref, driver, _, {load_failure, Failure}} -> + {error, Failure}; + {'UP', Ref, driver, _, loaded} -> + ok + end + end. + +do_unload_driver(Driver,Flags) -> + case erl_ddll:try_unload(Driver,Flags) of + {error,What} -> + {error,What}; + {ok, pending_process} -> + ok; + {ok, unloaded} -> + ok; + {ok, pending_driver} -> + ok; + {ok, pending_driver, Ref} -> + receive + {'UP', Ref, driver, _, permanent} -> + {error, permanent}; + {'UP', Ref, driver, _, unload_cancelled} -> + ok; + {'DOWN', Ref, driver, _, unloaded} -> + ok + end + end. + +-spec unload_driver(Driver :: string() | atom()) -> 'ok' | {'error', any()}. + +unload_driver(Driver) -> + do_unload_driver(Driver,[{monitor,pending_driver},kill_ports]). + +-spec unload(Driver :: string() | atom()) -> 'ok' | {'error', any()}. + +unload(Driver) -> + do_unload_driver(Driver,[]). + +-spec reload(Path :: string() | atom(), Driver :: string() | atom()) -> + 'ok' | {'error', any()}. + +reload(Path,Driver) -> + do_load_driver(Path, Driver, [{reload,pending_driver}]). + +-spec reload_driver(Path :: string() | atom(), Driver :: string() | atom()) -> + 'ok' | {'error', any()}. + +reload_driver(Path,Driver) -> + do_load_driver(Path, Driver, [{reload,pending_driver}, + {driver_options,[kill_ports]}]). + +-spec format_error(Code :: atom()) -> string(). + +format_error(Code) -> + case Code of + % This is the only error code returned only from erlang code... + % 'permanent' has a translation in the emulator, even though the erlang code uses it to... + load_cancelled -> + "Loading was cancelled from other process"; + _ -> + erl_ddll:format_error_int(Code) + end. + +-spec info(Driver :: string() | atom()) -> [{atom(), any()}]. + +info(Driver) -> + [{processes, erl_ddll:info(Driver,processes)}, + {driver_options, erl_ddll:info(Driver,driver_options)}, + {port_count, erl_ddll:info(Driver,port_count)}, + {linked_in_driver, erl_ddll:info(Driver,linked_in_driver)}, + {permanent, erl_ddll:info(Driver,permanent)}, + {awaiting_load, erl_ddll:info(Driver,awaiting_load)}, + {awaiting_unload, erl_ddll:info(Driver,awaiting_unload)}]. + +-spec info() -> [{string(), [{atom(), any()}]}]. + +info() -> + {ok,DriverList} = erl_ddll:loaded_drivers(), + [{X,Y} || X <- DriverList, + Y <- [catch info(X)], + is_list(Y), not lists:member({linked_in_driver,true},Y)]. diff --git a/lib/kernel/src/erl_distribution.erl b/lib/kernel/src/erl_distribution.erl new file mode 100644 index 0000000000..25ad34357a --- /dev/null +++ b/lib/kernel/src/erl_distribution.erl @@ -0,0 +1,106 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1996-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(erl_distribution). + +-behaviour(supervisor). + +-export([start_link/0,start_link/1,init/1,start/1,stop/0]). + +%-define(DBG,io:format("~p:~p~n",[?MODULE,?LINE])). +-define(DBG,erlang:display([?MODULE,?LINE])). + +start_link() -> + case catch start_p() of + {ok,Args} -> + start_link(Args); + _ -> + ignore + end. + +start_link(Args) -> + supervisor:start_link({local,net_sup},erl_distribution,Args). + +init(NetArgs) -> + Epmd = + case init:get_argument(no_epmd) of + {ok, [[]]} -> + []; + _ -> + EpmdMod = net_kernel:epmd_module(), + [{EpmdMod,{EpmdMod,start_link,[]}, + permanent,2000,worker,[EpmdMod]}] + end, + Auth = {auth,{auth,start_link,[]},permanent,2000,worker,[auth]}, + Kernel = {net_kernel,{net_kernel,start_link,[NetArgs]}, + permanent,2000,worker,[net_kernel]}, + EarlySpecs = net_kernel:protocol_childspecs(), + {ok,{{one_for_all,0,1}, EarlySpecs ++ Epmd ++ [Auth,Kernel]}}. + +start_p() -> + sname(), + lname(), + false. + +sname() -> + case init:get_argument(sname) of + {ok,[[Name]]} -> + throw({ok,[list_to_atom(Name),shortnames|ticktime()]}); + _ -> + false + end. + +lname() -> + case init:get_argument(name) of + {ok,[[Name]]} -> + throw({ok,[list_to_atom(Name),longnames|ticktime()]}); + _ -> + false + end. + +ticktime() -> + %% catch, in case the system was started with boot file start_old, + %% i.e. running without the application_controller. + %% Time is given in seconds. The net_kernel tick time is + %% Time/4 milliseconds. + case catch application:get_env(net_ticktime) of + {ok, Value} when is_integer(Value), Value > 0 -> + [Value * 250]; %% i.e. 1000 / 4 = 250 ms. + _ -> + [] + end. + +start(Args) -> + C = {net_sup_dynamic, {erl_distribution, start_link, [Args]}, permanent, + 1000, supervisor, [erl_distribution]}, + supervisor:start_child(kernel_sup, C). + +stop() -> + case supervisor:terminate_child(kernel_sup, net_sup_dynamic) of + ok -> + supervisor:delete_child(kernel_sup, net_sup_dynamic); + Error -> + case whereis(net_sup) of + Pid when is_pid(Pid) -> + %% Dist. started through -sname | -name flags + {error, not_allowed}; + _ -> + Error + end + end. + diff --git a/lib/kernel/src/erl_epmd.erl b/lib/kernel/src/erl_epmd.erl new file mode 100644 index 0000000000..e4b371836b --- /dev/null +++ b/lib/kernel/src/erl_epmd.erl @@ -0,0 +1,553 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1998-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(erl_epmd). + +-behaviour(gen_server). + +-ifdef(DEBUG). +-define(port_please_failure(), io:format("Net Kernel 2: EPMD port please failed at ~p:~p~n", [?MODULE,?LINE])). +-define(port_please_failure2(Term), io:format("Net Kernel 2: EPMD port please failed at ~p:~p [~p]~n", [?MODULE,?LINE,Term])). +-else. +-define(port_please_failure(), noop). +-define(port_please_failure2(Term), noop). +-endif. + +%% External exports +-export([start/0, start_link/0, stop/0, port_please/2, + port_please/3, names/0, names/1, + register_node/2, open/0, open/1, open/2]). + +%% gen_server callbacks +-export([init/1, handle_call/3, handle_cast/2, handle_info/2, + terminate/2, code_change/3]). + +-import(lists, [reverse/1]). + +-record(state, {socket, port_no = -1, name = ""}). + +-include("inet_int.hrl"). +-include("erl_epmd.hrl"). + + +%%%---------------------------------------------------------------------- +%%% API +%%%---------------------------------------------------------------------- +start() -> + gen_server:start({local, erl_epmd}, ?MODULE, [], []). + + +start_link() -> + gen_server:start_link({local, erl_epmd}, ?MODULE, [], []). + + +stop() -> + gen_server:call(?MODULE, stop, infinity). + + +%% Lookup a node "Name" at Host +%% return {port, P, Version} | noport +%% + +port_please(Node, Host) -> + port_please(Node, Host, infinity). + +port_please(Node,HostName, Timeout) when is_atom(HostName) -> + port_please1(Node,atom_to_list(HostName), Timeout); +port_please(Node,HostName, Timeout) when is_list(HostName) -> + port_please1(Node,HostName, Timeout); +port_please(Node, EpmdAddr, Timeout) -> + get_port(Node, EpmdAddr, Timeout). + + + +port_please1(Node,HostName, Timeout) -> + case inet:gethostbyname(HostName, inet, Timeout) of + {ok,{hostent, _Name, _ , _Af, _Size, [EpmdAddr | _]}} -> + get_port(Node, EpmdAddr, Timeout); + Else -> + Else + end. + +names() -> + {ok, H} = inet:gethostname(), + names(H). + +names(HostName) when is_atom(HostName) -> + names1(atom_to_list(HostName)); +names(HostName) when is_list(HostName) -> + names1(HostName); +names(EpmdAddr) -> + get_names(EpmdAddr). + +names1(HostName) -> + case inet:gethostbyname(HostName) of + {ok,{hostent, _Name, _ , _Af, _Size, [EpmdAddr | _]}} -> + get_names(EpmdAddr); + Else -> + Else + end. + + +register_node(Name, PortNo) -> + gen_server:call(erl_epmd, {register, Name, PortNo}, infinity). + +%%%---------------------------------------------------------------------- +%%% Callback functions from gen_server +%%%---------------------------------------------------------------------- + +init(_) -> + {ok, #state{socket = -1}}. + +%%---------------------------------------------------------------------- + +handle_call({register, Name, PortNo}, _From, State) -> + case State#state.socket of + P when P < 0 -> + case do_register_node(Name, PortNo) of + {alive, Socket, Creation} -> + S = State#state{socket = Socket, + port_no = PortNo, + name = Name}, + {reply, {ok, Creation}, S}; + Error -> + {reply, Error, State} + end; + _ -> + {reply, {error, already_registered}, State} + end; + +handle_call(client_info_req, _From, State) -> + Reply = {ok,{r4,State#state.name,State#state.port_no}}, + {reply,Reply,State}; + +handle_call(stop, _From, State) -> + {stop, shutdown, ok, State}. + +%%---------------------------------------------------------------------- + +handle_cast(_, State) -> + {noreply, State}. + +%%---------------------------------------------------------------------- + +handle_info({tcp_closed, Socket}, State) when State#state.socket =:= Socket -> + {noreply, State#state{socket = -1}}; +handle_info(_, State) -> + {noreply, State}. + +%%---------------------------------------------------------------------- + +terminate(_, #state{socket = Socket}) when Socket > 0 -> + close(Socket), + ok; +terminate(_, _) -> + ok. + +%%---------------------------------------------------------------------- + +code_change(_OldVsn, State, _Extra) -> + {ok, State}. + +%%%---------------------------------------------------------------------- +%%% Internal functions +%%%---------------------------------------------------------------------- + +get_epmd_port() -> + case init:get_argument(epmd_port) of + {ok, [[PortStr|_]|_]} when is_list(PortStr) -> + list_to_integer(PortStr); + error -> + ?erlang_daemon_port + end. + +%% +%% Epmd socket +%% +open() -> open({127,0,0,1}). % The localhost IP address. + +open({A,B,C,D}=EpmdAddr) when ?ip(A,B,C,D) -> + gen_tcp:connect(EpmdAddr, get_epmd_port(), [inet]); +open({A,B,C,D,E,F,G,H}=EpmdAddr) when ?ip6(A,B,C,D,E,F,G,H) -> + gen_tcp:connect(EpmdAddr, get_epmd_port(), [inet6]). + +open({A,B,C,D}=EpmdAddr, Timeout) when ?ip(A,B,C,D) -> + gen_tcp:connect(EpmdAddr, get_epmd_port(), [inet], Timeout); +open({A,B,C,D,E,F,G,H}=EpmdAddr, Timeout) when ?ip6(A,B,C,D,E,F,G,H) -> + gen_tcp:connect(EpmdAddr, get_epmd_port(), [inet6], Timeout). + +close(Socket) -> + gen_tcp:close(Socket). + + +do_register_node_v0(NodeName, TcpPort) -> + case open() of + {ok, Socket} -> + Name = cstring(NodeName), + Len = 1+2+length(Name), + gen_tcp:send(Socket, [?int16(Len), ?EPMD_ALIVE, + ?int16(TcpPort), Name]), + wait_for_reg_reply_v0(Socket, []); + Error -> + Error + end. + +do_register_node(NodeName, TcpPort) -> + case open() of + {ok, Socket} -> + Name = to_string(NodeName), + Extra = "", + Elen = length(Extra), + Len = 1+2+1+1+2+2+2+length(Name)+2+Elen, + gen_tcp:send(Socket, [?int16(Len), ?EPMD_ALIVE2_REQ, + ?int16(TcpPort), + $M, + 0, + ?int16(epmd_dist_high()), + ?int16(epmd_dist_low()), + ?int16(length(Name)), + Name, + ?int16(Elen), + Extra]), + case wait_for_reg_reply(Socket, []) of + {error, epmd_close} -> + %% could be old epmd; try old protocol +% erlang:display('trying old'), + do_register_node_v0(NodeName, TcpPort); + Other -> + Other + end; + Error -> + Error + end. + +epmd_dist_high() -> + case os:getenv("ERL_EPMD_DIST_HIGH") of + false -> + ?epmd_dist_high; + Version -> + case (catch list_to_integer(Version)) of + N when is_integer(N), N < ?epmd_dist_high -> + N; + _ -> + ?epmd_dist_high + end + end. + +epmd_dist_low() -> + case os:getenv("ERL_EPMD_DIST_LOW") of + false -> + ?epmd_dist_low; + Version -> + case (catch list_to_integer(Version)) of + N when is_integer(N), N > ?epmd_dist_low -> + N; + _ -> + ?epmd_dist_low + end + end. + + + +%%% (When we reply 'duplicate_name', it's because it's the most likely +%%% reason; there is no interpretation of the error result code.) +wait_for_reg_reply(Socket, SoFar) -> + receive + {tcp, Socket, Data0} -> + case SoFar ++ Data0 of + [$y, Result, A, B] -> + case Result of + 0 -> + {alive, Socket, ?u16(A, B)}; + _ -> + {error, duplicate_name} + end; + Data when length(Data) < 4 -> + wait_for_reg_reply(Socket, Data); + Garbage -> + {error, {garbage_from_epmd, Garbage}} + end; + {tcp_closed, Socket} -> + {error, epmd_close} + after 10000 -> + gen_tcp:close(Socket), + {error, no_reg_reply_from_epmd} + end. + +wait_for_reg_reply_v0(Socket, SoFar) -> + receive + {tcp, Socket, Data0} -> + case SoFar ++ Data0 of + [$Y, A, B] -> + {alive, Socket, ?u16(A, B)}; + Data when length(Data) < 3 -> + wait_for_reg_reply(Socket, Data); + Garbage -> + {error, {garbage_from_epmd, Garbage}} + end; + {tcp_closed, Socket} -> + {error, duplicate_name} % A guess -- the most likely reason. + after 10000 -> + gen_tcp:close(Socket), + {error, no_reg_reply_from_epmd} + end. +%% +%% Lookup a node "Name" at Host +%% +get_port_v0(Node, EpmdAddress) -> + case open(EpmdAddress) of + {ok, Socket} -> + Name = cstring(Node), + Len = 1+length(Name), + gen_tcp:send(Socket, [?int16(Len),?EPMD_PORT_PLEASE, Name]), + wait_for_port_reply_v0(Socket, []); + _Error -> + ?port_please_failure(), + noport + end. + +%%% Not used anymore +%%% get_port(Node, EpmdAddress) -> +%%% get_port(Node, EpmdAddress, infinity). + +get_port(Node, EpmdAddress, Timeout) -> + case open(EpmdAddress, Timeout) of + {ok, Socket} -> + Name = to_string(Node), + Len = 1+length(Name), + gen_tcp:send(Socket, [?int16(Len),?EPMD_PORT_PLEASE2_REQ, Name]), + Reply = wait_for_port_reply(Socket, []), + case Reply of + closed -> + get_port_v0(Node, EpmdAddress); + Other -> + Other + end; + _Error -> + ?port_please_failure2(_Error), + noport + end. + +wait_for_port_reply_v0(Socket, SoFar) -> + receive + {tcp, Socket, Data0} -> +% io:format("got ~p~n", [Data0]), + case SoFar ++ Data0 of + [A, B] -> + wait_for_close(Socket, {port, ?u16(A, B), 0}); +% wait_for_close(Socket, {port, ?u16(A, B)}); + Data when length(Data) < 2 -> + wait_for_port_reply_v0(Socket, Data); + Garbage -> + ?port_please_failure(), + {error, {garbage_from_epmd, Garbage}} + end; + {tcp_closed, Socket} -> + ?port_please_failure(), + noport + after 10000 -> + ?port_please_failure(), + gen_tcp:close(Socket), + noport + end. + +wait_for_port_reply(Socket, SoFar) -> + receive + {tcp, Socket, Data0} -> +% io:format("got ~p~n", [Data0]), + case SoFar ++ Data0 of + [$w, Result | Rest] -> + case Result of + 0 -> + wait_for_port_reply_cont(Socket, Rest); + _ -> + ?port_please_failure(), + wait_for_close(Socket, noport) + end; + Data when length(Data) < 2 -> + wait_for_port_reply(Socket, Data); + Garbage -> + ?port_please_failure(), + {error, {garbage_from_epmd, Garbage}} + end; + {tcp_closed, Socket} -> + ?port_please_failure(), + closed + after 10000 -> + ?port_please_failure(), + gen_tcp:close(Socket), + noport + end. + +wait_for_port_reply_cont(Socket, SoFar) when length(SoFar) >= 10 -> + wait_for_port_reply_cont2(Socket, SoFar); +wait_for_port_reply_cont(Socket, SoFar) -> + receive + {tcp, Socket, Data0} -> + case SoFar ++ Data0 of + Data when length(Data) >= 10 -> + wait_for_port_reply_cont2(Socket, Data); + Data when length(Data) < 10 -> + wait_for_port_reply_cont(Socket, Data); + Garbage -> + ?port_please_failure(), + {error, {garbage_from_epmd, Garbage}} + end; + {tcp_closed, Socket} -> + ?port_please_failure(), + noport + after 10000 -> + ?port_please_failure(), + gen_tcp:close(Socket), + noport + end. + +wait_for_port_reply_cont2(Socket, Data) -> + [A, B, _Type, _Proto, HighA, HighB, + LowA, LowB, NLenA, NLenB | Rest] = Data, + wait_for_port_reply_name(Socket, + ?u16(NLenA, NLenB), + Rest), + Low = ?u16(LowA, LowB), + High = ?u16(HighA, HighB), + Version = best_version(Low, High), +% io:format("Returning ~p~n", [{port, ?u16(A, B), Version}]), + {port, ?u16(A, B), Version}. +% {port, ?u16(A, B)}. + +%%% Throw away the rest of the message; we won't use any of it anyway, +%%% currently. +wait_for_port_reply_name(Socket, Len, Sofar) -> + receive + {tcp, Socket, _Data} -> +% io:format("data = ~p~n", _Data), + wait_for_port_reply_name(Socket, Len, Sofar); + {tcp_closed, Socket} -> + "foobar" + end. + + +best_version(Low, High) -> + OurLow = epmd_dist_low(), + OurHigh = epmd_dist_high(), + select_best_version(OurLow, OurHigh, Low, High). + +%%% We silently assume that the low's are not greater than the high's. +%%% We should report if the intervals don't overlap. +select_best_version(L1, _H1, _L2, H2) when L1 > H2 -> + 0; +select_best_version(_L1, H1, L2, _H2) when L2 > H1 -> + 0; +select_best_version(_L1, H1, L2, _H2) when L2 > H1 -> + 0; +select_best_version(_L1, H1, _L2, H2) -> + erlang:min(H1, H2). + +wait_for_close(Socket, Reply) -> + receive + {tcp_closed, Socket} -> + Reply + after 10000 -> + gen_tcp:close(Socket), + Reply + end. + + +%% +%% Creates a (flat) null terminated string from atom or list. +%% +cstring(S) when is_atom(S) -> cstring(atom_to_list(S)); +cstring(S) when is_list(S) -> S ++ [0]. + +to_string(S) when is_atom(S) -> atom_to_list(S); +to_string(S) when is_list(S) -> S. + +%% +%% Find names on epmd +%% +%% +get_names(EpmdAddress) -> + case open(EpmdAddress) of + {ok, Socket} -> + do_get_names(Socket); + _Error -> + {error, address} + end. + +do_get_names(Socket) -> + gen_tcp:send(Socket, [?int16(1),?EPMD_NAMES]), + receive + {tcp, Socket, [P0,P1,P2,P3|T]} -> + EpmdPort = ?u32(P0,P1,P2,P3), + case get_epmd_port() of + EpmdPort -> + names_loop(Socket, T, []); + _ -> + close(Socket), + {error, address} + end; + {tcp_closed, Socket} -> + {ok, []} + end. + +names_loop(Socket, Acc, Ps) -> + receive + {tcp, Socket, Bytes} -> + {NAcc, NPs} = scan_names(Acc ++ Bytes, Ps), + names_loop(Socket, NAcc, NPs); + {tcp_closed, Socket} -> + {_, NPs} = scan_names(Acc, Ps), + {ok, NPs} + end. + +scan_names(Buf, Ps) -> + case scan_line(Buf, []) of + {Line, NBuf} -> + case parse_line(Line) of + {ok, Entry} -> + scan_names(NBuf, [Entry | Ps]); + error -> + scan_names(NBuf, Ps) + end; + [] -> {Buf, Ps} + end. + + +scan_line([$\n | Buf], Line) -> {reverse(Line), Buf}; +scan_line([C | Buf], Line) -> scan_line(Buf, [C|Line]); +scan_line([], _) -> []. + +parse_line("name " ++ Buf0) -> + case parse_name(Buf0, []) of + {Name, Buf1} -> + case Buf1 of + "at port " ++ Buf2 -> + case catch list_to_integer(Buf2) of + {'EXIT', _} -> error; + Port -> {ok, {Name, Port}} + end; + _ -> error + end; + error -> error + end; +parse_line(_) -> error. + + +parse_name([$\s | Buf], Name) -> {reverse(Name), Buf}; +parse_name([C | Buf], Name) -> parse_name(Buf, [C|Name]); +parse_name([], _Name) -> error. diff --git a/lib/kernel/src/erl_epmd.hrl b/lib/kernel/src/erl_epmd.hrl new file mode 100644 index 0000000000..47ab6195d8 --- /dev/null +++ b/lib/kernel/src/erl_epmd.hrl @@ -0,0 +1,32 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1998-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% +%% + +-define(EPMD_ALIVE, $a). +-define(EPMD_PORT_PLEASE, $p). +-define(EPMD_NAMES, $n). +-define(EPMD_DUMP, $d). +-define(EPMD_KILL, $k). +-define(EPMD_STOP, $s). + +-define(EPMD_ALIVE_OK, $Y). + +-define(EPMD_ALIVE2_REQ, $x). +-define(EPMD_PORT_PLEASE2_REQ, $z). +-define(EPMD_ALIVE2_RESP, $y). +-define(EPMD_PORT2_RESP, $w). diff --git a/lib/kernel/src/erl_reply.erl b/lib/kernel/src/erl_reply.erl new file mode 100644 index 0000000000..1a61e630bc --- /dev/null +++ b/lib/kernel/src/erl_reply.erl @@ -0,0 +1,49 @@ +%% +%% %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(erl_reply). + +%% Syncronisation with erl_start (erl_interface) + +-export([reply/1]). + +%% send Msg to Addr:Port +%% all args are atoms since we call this from erl command line + +-spec reply([atom()]) -> 'ok' | 'reply_done'. + +reply([Addr,Port,Msg]) -> + Ip = ip_string_to_tuple(atom_to_list(Addr)), + P = list_to_integer(atom_to_list(Port)), + M = atom_to_list(Msg), + {ok, S} = gen_tcp:connect(Ip,P,[]), + gen_tcp:send(S,M), + gen_tcp:close(S), + reply_done; +reply(_) -> + error_logger:error_msg("erl_reply: Can't find address and port " + "to reply to~n"). + +%% convert ip number to tuple +ip_string_to_tuple(Ip) -> + [Ip1,Ip2,Ip3,Ip4] = string:tokens(Ip,"."), + {list_to_integer(Ip1), + list_to_integer(Ip2), + list_to_integer(Ip3), + list_to_integer(Ip4)}. + diff --git a/lib/kernel/src/error_handler.erl b/lib/kernel/src/error_handler.erl new file mode 100644 index 0000000000..5f2507fc08 --- /dev/null +++ b/lib/kernel/src/error_handler.erl @@ -0,0 +1,141 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1996-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(error_handler). + +%% A simple error handler. + +-export([undefined_function/3, undefined_lambda/3, stub_function/3, + breakpoint/3]). + +-spec undefined_function(Module :: atom(), Function :: atom(), Args :: [_]) -> + any(). + +undefined_function(Module, Func, Args) -> + case ensure_loaded(Module) of + {module, Module} -> + case erlang:function_exported(Module, Func, length(Args)) of + true -> + apply(Module, Func, Args); + false -> + case check_inheritance(Module, Args) of + {value, Base, Args1} -> + apply(Base, Func, Args1); + none -> + crash(Module, Func, Args) + end + end; + {module, _} -> + crash(Module, Func, Args); + _Other -> + crash(Module, Func, Args) + end. + +-spec undefined_lambda(Module :: atom(), Function :: fun(), Args :: [_]) -> + any(). + +undefined_lambda(Module, Fun, Args) -> + case ensure_loaded(Module) of + {module, Module} -> + %% There is no need (and no way) to test if the fun is present. + %% apply/2 will not call us again if the fun is missing. + apply(Fun, Args); + {module, _} -> + crash(Fun, Args); + _Other -> + crash(Fun, Args) + end. + +-spec breakpoint(Module :: atom(), Function :: atom(), Args :: [_]) -> + any(). + +breakpoint(Module, Func, Args) -> + (int()):eval(Module, Func, Args). + +%% Used to make the call to the 'int' module a "weak" one, to avoid +%% building strong components in xref or dialyzer. + +int() -> int. + +%% +%% Crash providing a beautiful stack backtrace. +%% +crash(Fun, Args) -> + crash({Fun,Args}). + +crash(M, F, A) -> + crash({M,F,A}). + +-spec crash(tuple()) -> no_return(). + +crash(Tuple) -> + try erlang:error(undef) + catch + error:undef -> + erlang:raise(error, undef, [Tuple|tl(erlang:get_stacktrace())]) + end. + +%% If the code_server has not been started yet dynamic code loading +%% is handled by init. +ensure_loaded(Module) -> + Self = self(), + case whereis(code_server) of + %% Perhaps double fault should be detected in code:ensure_loaded/1 + %% instead, since this error handler cannot know whether the + %% code server can resolve the problem or not. + %% An {error, Reason} return from there would crash the code server and + %% bring down the node. + Self -> + Error = "The code server called the unloaded module `" ++ + atom_to_list(Module) ++ "'", + halt(Error); + Pid when is_pid(Pid) -> + code:ensure_loaded(Module); + _ -> + init:ensure_loaded(Module) + end. + +-spec stub_function(atom(), atom(), [_]) -> no_return(). + +stub_function(Mod, Func, Args) -> + exit({undef,[{Mod,Func,Args}]}). + +check_inheritance(Module, Args) -> + Attrs = erlang:get_module_info(Module, attributes), + case lists:keysearch(extends, 1, Attrs) of + {value,{extends,[Base]}} when is_atom(Base), Base =/= Module -> + %% This is just a heuristic for detecting abstract modules + %% with inheritance so they can be handled; it would be + %% much better to do it in the emulator runtime + case lists:keysearch(abstract, 1, Attrs) of + {value,{abstract,[true]}} -> + case lists:reverse(Args) of + [M|Rs] when tuple_size(M) > 1, + element(1,M) =:= Module, + tuple_size(element(2,M)) > 0, + is_atom(element(1,element(2,M))) -> + {value, Base, lists:reverse(Rs, [element(2,M)])}; + _ -> + {value, Base, Args} + end; + _ -> + {value, Base, Args} + end; + _ -> + none + end. diff --git a/lib/kernel/src/error_logger.erl b/lib/kernel/src/error_logger.erl new file mode 100644 index 0000000000..cafdc52e84 --- /dev/null +++ b/lib/kernel/src/error_logger.erl @@ -0,0 +1,387 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1996-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(error_logger). + +-export([start/0,start_link/0,format/2,error_msg/1,error_msg/2,error_report/1, + error_report/2,info_report/1,info_report/2,warning_report/1, + warning_report/2,error_info/1, + info_msg/1,info_msg/2,warning_msg/1,warning_msg/2, + logfile/1,tty/1,swap_handler/1, + add_report_handler/1,add_report_handler/2, + delete_report_handler/1]). + +-export([init/1, + handle_event/2, handle_call/2, handle_info/2, + terminate/2]). + +-define(buffer_size, 10). + +%%----------------------------------------------------------------- +%% Types used in this file +%%----------------------------------------------------------------- + +-type msg_tag() :: 'error' | 'error_report' + | 'info' | 'info_msg' | 'info_report' + | 'warning_msg' | 'warning_report'. + +-type state() :: {non_neg_integer(), non_neg_integer(), [term()]}. + +%%----------------------------------------------------------------- + +-spec start() -> {'ok', pid()} | {'error', any()}. + +start() -> + case gen_event:start({local, error_logger}) of + {ok, Pid} -> + simple_logger(?buffer_size), + {ok, Pid}; + Error -> Error + end. + +-spec start_link() -> {'ok', pid()} | {'error', any()}. + +start_link() -> + case gen_event:start_link({local, error_logger}) of + {ok, Pid} -> + simple_logger(?buffer_size), + {ok, Pid}; + Error -> Error + end. + +%%----------------------------------------------------------------- +%% These two simple old functions generate events tagged 'error' +%% Used for simple messages; error or information. +%%----------------------------------------------------------------- + +-spec error_msg(Format :: string()) -> 'ok'. + +error_msg(Format) -> + error_msg(Format,[]). + +-spec error_msg(Format :: string(), Args :: list()) -> 'ok'. + +error_msg(Format, Args) -> + notify({error, group_leader(), {self(), Format, Args}}). + +-spec format(Format :: string(), Args :: list()) -> 'ok'. + +format(Format, Args) -> + notify({error, group_leader(), {self(), Format, Args}}). + +%%----------------------------------------------------------------- +%% This functions should be used for error reports. Events +%% are tagged 'error_report'. +%% The 'std_error' error_report type can always be used. +%%----------------------------------------------------------------- + +-spec error_report(Report :: any()) -> 'ok'. + +error_report(Report) -> + error_report(std_error, Report). + +-spec error_report(Type :: any(), Report :: any()) -> 'ok'. + +error_report(Type, Report) -> + notify({error_report, group_leader(), {self(), Type, Report}}). + +%%----------------------------------------------------------------- +%% This function should be used for warning reports. +%% These might be mapped to error reports or info reports, +%% depending on emulator flags. Events that ore not mapped +%% are tagged 'info_report'. +%% The 'std_warning' info_report type can always be used and is +%% mapped to std_info or std_error accordingly. +%%----------------------------------------------------------------- + +-spec warning_report(Report :: any()) -> 'ok'. + +warning_report(Report) -> + warning_report(std_warning, Report). + +-spec warning_report(Type :: any(), Report :: any()) -> 'ok'. + +warning_report(Type, Report) -> + {Tag, NType} = case error_logger:warning_map() of + info -> + if + Type =:= std_warning -> + {info_report, std_info}; + true -> + {info_report, Type} + end; + warning -> + {warning_report, Type}; + error -> + if + Type =:= std_warning -> + {error_report, std_error}; + true -> + {error_report, Type} + end + end, + notify({Tag, group_leader(), {self(), NType, Report}}). + +%%----------------------------------------------------------------- +%% This function provides similar functions as error_msg for +%% warning messages, like warning report it might get mapped to +%% other types of reports. +%%----------------------------------------------------------------- + +-spec warning_msg(Format :: string()) -> 'ok'. + +warning_msg(Format) -> + warning_msg(Format,[]). + +-spec warning_msg(Format :: string(), Args :: list()) -> 'ok'. + +warning_msg(Format, Args) -> + Tag = case error_logger:warning_map() of + warning -> + warning_msg; + info -> + info_msg; + error -> + error + end, + notify({Tag, group_leader(), {self(), Format, Args}}). + +%%----------------------------------------------------------------- +%% This function should be used for information reports. Events +%% are tagged 'info_report'. +%% The 'std_info' info_report type can always be used. +%%----------------------------------------------------------------- + +-spec info_report(Report :: any()) -> 'ok'. + +info_report(Report) -> + info_report(std_info, Report). + +-spec info_report(Type :: any(), Report :: any()) -> 'ok'. + +info_report(Type, Report) -> + notify({info_report, group_leader(), {self(), Type, Report}}). + +%%----------------------------------------------------------------- +%% This function provides similar functions as error_msg for +%% information messages. +%%----------------------------------------------------------------- + +-spec info_msg(Format :: string()) -> 'ok'. + +info_msg(Format) -> + info_msg(Format,[]). + +-spec info_msg(Format :: string(), Args :: list()) -> 'ok'. + +info_msg(Format, Args) -> + notify({info_msg, group_leader(), {self(), Format, Args}}). + +%%----------------------------------------------------------------- +%% Used by the init process. Events are tagged 'info'. +%%----------------------------------------------------------------- + +-spec error_info(Error :: any()) -> 'ok'. + +error_info(Error) -> + notify({info, group_leader(), {self(), Error, []}}). + +-spec notify({msg_tag(), pid(), {pid(), any(), any()}}) -> 'ok'. + +notify(Msg) -> + gen_event:notify(error_logger, Msg). + +-type swap_handler_type() :: 'false' | 'silent' | 'tty' | {'logfile', string()}. +-spec swap_handler(Type :: swap_handler_type()) -> any(). + +swap_handler(tty) -> + gen_event:swap_handler(error_logger, {error_logger, swap}, + {error_logger_tty_h, []}), + simple_logger(); +swap_handler({logfile, File}) -> + gen_event:swap_handler(error_logger, {error_logger, swap}, + {error_logger_file_h, File}), + simple_logger(); +swap_handler(silent) -> + gen_event:delete_handler(error_logger, error_logger, delete), + simple_logger(); +swap_handler(false) -> + ok. % keep primitive event handler as-is + +-spec add_report_handler(Module :: atom()) -> any(). + +add_report_handler(Module) when is_atom(Module) -> + gen_event:add_handler(error_logger, Module, []). + +-spec add_report_handler(atom(), any()) -> any(). + +add_report_handler(Module, Args) when is_atom(Module) -> + gen_event:add_handler(error_logger, Module, Args). + +-spec delete_report_handler(Module :: atom()) -> any(). + +delete_report_handler(Module) when is_atom(Module) -> + gen_event:delete_handler(error_logger, Module, []). + +%% Start the lowest level error_logger handler with Buffer. + +simple_logger(Buffer_size) when is_integer(Buffer_size) -> + gen_event:add_handler(error_logger, error_logger, Buffer_size). + +%% Start the lowest level error_logger handler without Buffer. + +simple_logger() -> + gen_event:add_handler(error_logger, error_logger, []). + +%% Log all errors to File for all eternity + +-spec logfile(Request :: {'open', string()}) -> 'ok' | {'error',any()} + ; (Request :: 'close') -> 'ok' | {'error', any()} + ; (Request :: 'filename') -> atom() | string() | {'error', any()}. + +logfile({open, File}) -> + case lists:member(error_logger_file_h, + gen_event:which_handlers(error_logger)) of + true -> + {error, allready_have_logfile}; + _ -> + gen_event:add_handler(error_logger, error_logger_file_h, File) + end; +logfile(close) -> + case gen_event:delete_handler(error_logger, error_logger_file_h, normal) of + {error,Reason} -> + {error,Reason}; + _ -> + ok + end; +logfile(filename) -> + case gen_event:call(error_logger, error_logger_file_h, filename) of + {error,_} -> + {error, no_log_file}; + Val -> + Val + end. + +%% Possibly turn off all tty printouts, maybe we only want the errors +%% to go to a file + +-spec tty(Flag :: boolean()) -> 'ok'. + +tty(true) -> + Hs = gen_event:which_handlers(error_logger), + case lists:member(error_logger_tty_h, Hs) of + false -> + gen_event:add_handler(error_logger, error_logger_tty_h, []); + true -> + ignore + end, + ok; +tty(false) -> + gen_event:delete_handler(error_logger, error_logger_tty_h, []), + ok. + + +%%% --------------------------------------------------- +%%% This is the default error_logger handler. +%%% --------------------------------------------------- + +-spec init(term()) -> {'ok', state() | []}. + +init(Max) when is_integer(Max) -> + {ok, {Max, 0, []}}; +%% This one is called if someone took over from us, and now wants to +%% go back. +init({go_back, _PostState}) -> + {ok, {?buffer_size, 0, []}}; +init(_) -> %% Start and just relay to other + {ok, []}. %% node if node(GLeader) =/= node(). + +-spec handle_event(term(), state()) -> {'ok', state()}. + +handle_event({Type, GL, Msg}, State) when node(GL) =/= node() -> + gen_event:notify({error_logger, node(GL)},{Type, GL, Msg}), + %% handle_event2({Type, GL, Msg}, State); %% Shall we do something + {ok, State}; %% at this node too ??? +handle_event({info_report, _, {_, Type, _}}, State) when Type =/= std_info -> + {ok, State}; %% Ignore other info reports here +handle_event(Event, State) -> + handle_event2(Event, State). + +-spec handle_info(term(), state()) -> {'ok', state()}. + +handle_info({emulator, GL, Chars}, State) when node(GL) =/= node() -> + {error_logger, node(GL)} ! {emulator, GL, add_node(Chars,self())}, + {ok, State}; +handle_info({emulator, GL, Chars}, State) -> + handle_event2({emulator, GL, Chars}, State); +handle_info(_, State) -> + {ok, State}. + +-spec handle_call(term(), state()) -> {'ok', {'error', 'bad_query'}, state()}. + +handle_call(_Query, State) -> {ok, {error, bad_query}, State}. + +-spec terminate(term(), state()) -> {'error_logger', [term()]}. + +terminate(swap, {_, 0, Buff}) -> + {error_logger, Buff}; +terminate(swap, {_, Lost, Buff}) -> + Myevent = {info, group_leader(), {self(), {lost_messages, Lost}, []}}, + {error_logger, [tag_event(Myevent)|Buff]}; +terminate(_, _) -> + {error_logger, []}. + +handle_event2(Event, {1, Lost, Buff}) -> + display(tag_event(Event)), + {ok, {1, Lost+1, Buff}}; +handle_event2(Event, {N, Lost, Buff}) -> + Tagged = tag_event(Event), + display(Tagged), + {ok, {N-1, Lost, [Tagged|Buff]}}; +handle_event2(_, State) -> + {ok, State}. + +tag_event(Event) -> + {erlang:localtime(), Event}. + +display({Tag,{error,_,{_,Format,Args}}}) -> + display2(Tag,Format,Args); +display({Tag,{error_report,_,{_,Type,Report}}}) -> + display2(Tag,Type,Report); +display({Tag,{info_report,_,{_,Type,Report}}}) -> + display2(Tag,Type,Report); +display({Tag,{info,_,{_,Error,_}}}) -> + display2(Tag,Error,[]); +display({Tag,{info_msg,_,{_,Format,Args}}}) -> + display2(Tag,Format,Args); +display({Tag,{warning_report,_,{_,Type,Report}}}) -> + display2(Tag,Type,Report); +display({Tag,{warning_msg,_,{_,Format,Args}}}) -> + display2(Tag,Format,Args); +display({Tag,{emulator,_,Chars}}) -> + display2(Tag,Chars,[]). + +add_node(X, Pid) when is_atom(X) -> + add_node(atom_to_list(X), Pid); +add_node(X, Pid) -> + lists:concat([X,"** at node ",node(Pid)," **~n"]). + +%% Can't do io_lib:format + +display2(Tag,F,A) -> + erlang:display({error_logger,Tag,F,A}). diff --git a/lib/kernel/src/erts_debug.erl b/lib/kernel/src/erts_debug.erl new file mode 100644 index 0000000000..7d6a5ade94 --- /dev/null +++ b/lib/kernel/src/erts_debug.erl @@ -0,0 +1,155 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1999-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(erts_debug). + +%% Low-level debugging support. EXPERIMENTAL! + +-export([size/1,df/1,df/2,df/3]). + +%% This module contains the following *experimental* BIFs: +%% disassemble/1 +%% breakpoint/2 +%% same/2 +%% flat_size/1 + +%% size(Term) +%% Returns the size of Term in actual heap words. Shared subterms are +%% counted once. Example: If A = [a,b], B =[A,A] then size(B) returns 8, +%% while flat_size(B) returns 12. + +-spec size(term()) -> non_neg_integer(). + +size(Term) -> + {Sum,_} = size(Term, gb_trees:empty(), 0), + Sum. + +size([H|T]=Term, Seen0, Sum0) -> + case remember_term(Term, Seen0) of + seen -> {Sum0,Seen0}; + Seen1 -> + {Sum,Seen} = size(H, Seen1, Sum0+2), + size(T, Seen, Sum) + end; +size(Tuple, Seen0, Sum0) when is_tuple(Tuple) -> + case remember_term(Tuple, Seen0) of + seen -> {Sum0,Seen0}; + Seen -> + Sum = Sum0 + 1 + tuple_size(Tuple), + tuple_size(1, tuple_size(Tuple), Tuple, Seen, Sum) + end; +size(Term, Seen0, Sum) -> + case erts_debug:flat_size(Term) of + 0 -> {Sum,Seen0}; + Sz -> + case remember_term(Term, Seen0) of + seen -> {Sum,Seen0}; + Seen -> {Sum+Sz,Seen} + end + end. + +tuple_size(I, Sz, _, Seen, Sum) when I > Sz -> + {Sum,Seen}; +tuple_size(I, Sz, Tuple, Seen0, Sum0) -> + {Sum,Seen} = size(element(I, Tuple), Seen0, Sum0), + tuple_size(I+1, Sz, Tuple, Seen, Sum). + +remember_term(Term, Seen) -> + case gb_trees:lookup(Term, Seen) of + none -> gb_trees:insert(Term, [Term], Seen); + {value,Terms} -> + case is_term_seen(Term, Terms) of + false -> gb_trees:update(Term, [Term|Terms], Seen); + true -> seen + end + end. + +-spec is_term_seen(term(), [term()]) -> boolean(). + +is_term_seen(Term, [H|T]) -> + case erts_debug:same(Term, H) of + true -> true; + false -> is_term_seen(Term, T) + end; +is_term_seen(_, []) -> false. + +%% df(Mod) -- Disassemble Mod to file Mod.dis. +%% df(Mod, Func) -- Disassemble Mod:Func/Any to file Mod_Func.dis. +%% df(Mod, Func, Arity) -- Disassemble Mod:Func/Arity to file Mod_Func_Arity.dis. + +-type df_ret() :: 'ok' | {'error', {'badopen', module()}} | {'undef', module()}. + +-spec df(module()) -> df_ret(). + +df(Mod) when is_atom(Mod) -> + try Mod:module_info(functions) of + Fs0 when is_list(Fs0) -> + Name = lists:concat([Mod, ".dis"]), + Fs = [{Mod,Func,Arity} || {Func,Arity} <- Fs0], + dff(Name, Fs) + catch _:_ -> {undef,Mod} + end. + +-spec df(module(), atom()) -> df_ret(). + +df(Mod, Func) when is_atom(Mod), is_atom(Func) -> + try Mod:module_info(functions) of + Fs0 when is_list(Fs0) -> + Name = lists:concat([Mod, "_", Func, ".dis"]), + Fs = [{Mod,Func1,Arity} || {Func1,Arity} <- Fs0, Func1 =:= Func], + dff(Name, Fs) + catch _:_ -> {undef,Mod} + end. + +-spec df(module(), atom(), arity()) -> df_ret(). + +df(Mod, Func, Arity) when is_atom(Mod), is_atom(Func) -> + try Mod:module_info(functions) of + Fs0 when is_list(Fs0) -> + Name = lists:concat([Mod, "_", Func, "_", Arity, ".dis"]), + Fs = [{Mod,Func1,Arity1} || {Func1,Arity1} <- Fs0, + Func1 =:= Func, Arity1 =:= Arity], + dff(Name, Fs) + catch _:_ -> {undef,Mod} + end. + +dff(File, Fs) when is_pid(File), is_list(Fs) -> + lists:foreach(fun(Mfa) -> + disassemble_function(File, Mfa), + io:nl(File) + end, Fs); +dff(Name, Fs) when is_list(Name) -> + case file:open(Name, [write]) of + {ok,F} -> + try + dff(F, Fs) + after + file:close(F) + end; + {error,Reason} -> + {error,{badopen,Reason}} + end. + +disassemble_function(File, {_,_,_}=MFA) -> + cont_dis(File, erts_debug:disassemble(MFA), MFA). + +cont_dis(_, false, _) -> ok; +cont_dis(File, {Addr,Str,MFA}, MFA) -> + io:put_chars(File, binary_to_list(Str)), + cont_dis(File, erts_debug:disassemble(Addr), MFA); +cont_dis(_, {_,_,_}, _) -> ok. diff --git a/lib/kernel/src/file.erl b/lib/kernel/src/file.erl new file mode 100644 index 0000000000..fa86d53dc9 --- /dev/null +++ b/lib/kernel/src/file.erl @@ -0,0 +1,1077 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1996-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(file). + +%% Interface module for the file server and the file io servers. + + + +%%% External exports + +-export([format_error/1]). +%% File system and metadata. +-export([get_cwd/0, get_cwd/1, set_cwd/1, delete/1, rename/2, + make_dir/1, del_dir/1, list_dir/1, + read_file_info/1, write_file_info/2, + altname/1, + read_link_info/1, read_link/1, + make_link/2, make_symlink/2, + read_file/1, write_file/2, write_file/3]). +%% Specialized +-export([ipread_s32bu_p32bu/3]). +%% Generic file contents. +-export([open/2, close/1, + read/2, write/2, + pread/2, pread/3, pwrite/2, pwrite/3, + read_line/1, + position/2, truncate/1, sync/1, + copy/2, copy/3]). +%% High level operations +-export([consult/1, path_consult/2]). +-export([eval/1, eval/2, path_eval/2, path_eval/3, path_open/3]). +-export([script/1, script/2, path_script/2, path_script/3]). +-export([change_owner/2, change_owner/3, change_group/2, + change_mode/2, change_time/2, change_time/3]). + +-export([pid2name/1]). + +%%% Obsolete exported functions + +-export([raw_read_file_info/1, raw_write_file_info/2]). + +%% Internal export to prim_file and ram_file until they implement +%% an efficient copy themselves. +-export([copy_opened/3]). + +-export([ipread_s32bu_p32bu_int/3]). + + +%%% Includes and defines +-include("file.hrl"). + +-define(FILE_IO_SERVER_TABLE, file_io_servers). + +-define(FILE_SERVER, file_server_2). % Registered name +-define(PRIM_FILE, prim_file). % Module +-define(RAM_FILE, ram_file). % Module + +%% data types +-type filename() :: string(). +-type io_device() :: pid() | #file_descriptor{}. +-type location() :: integer() | {'bof', integer()} | {'cur', integer()} + | {'eof', integer()} | 'bof' | 'cur' | 'eof'. +-type mode() :: 'read' | 'write' | 'append' | 'raw' | 'binary' | + {'delayed_write', non_neg_integer(), non_neg_integer()} | + 'delayed_write' | {'read_ahead', pos_integer()} | + 'read_ahead' | 'compressed'. +-type bindings() :: any(). + +%%%----------------------------------------------------------------- +%%% General functions + +-spec format_error(Reason :: posix() | {integer(), atom(), any()}) -> + string(). + +format_error({_Line, ?MODULE, undefined_script}) -> + "no value returned from script"; +format_error({Line, ?MODULE, {Class, Reason, Stacktrace}}) -> + io_lib:format("~w: evaluation failed with reason ~w:~w and stacktrace ~w", + [Line, Class, Reason, Stacktrace]); +format_error({Line, ?MODULE, {Reason, Stacktrace}}) -> + io_lib:format("~w: evaluation failed with reason ~w and stacktrace ~w", + [Line, Reason, Stacktrace]); +format_error({Line, Mod, Reason}) -> + io_lib:format("~w: ~s", [Line, Mod:format_error(Reason)]); +format_error(badarg) -> + "bad argument"; +format_error(system_limit) -> + "a system limit was hit, probably not enough ports"; +format_error(terminated) -> + "the file server process is terminated"; +format_error(ErrorId) -> + erl_posix_msg:message(ErrorId). + +-spec pid2name(Pid :: pid()) -> {'ok', filename()} | 'undefined'. + +pid2name(Pid) when is_pid(Pid) -> + case whereis(?FILE_SERVER) of + undefined -> + undefined; + _ -> + case ets:lookup(?FILE_IO_SERVER_TABLE, Pid) of + [{_, Name} | _] -> + {ok, Name}; + _ -> + undefined + end + end. + +%%%----------------------------------------------------------------- +%%% File server functions. +%%% Functions that do not operate on a single open file. +%%% Stateless. +-spec get_cwd() -> {'ok', filename()} | {'error', posix()}. + +get_cwd() -> + call(get_cwd, []). + +-spec get_cwd(Drive :: string()) -> {'ok', filename()} | {'error', posix()}. + +get_cwd(Drive) -> + check_and_call(get_cwd, [file_name(Drive)]). + +-spec set_cwd(Dirname :: name()) -> 'ok' | {'error', posix()}. + +set_cwd(Dirname) -> + check_and_call(set_cwd, [file_name(Dirname)]). + +-spec delete(Name :: name()) -> 'ok' | {'error', posix()}. + +delete(Name) -> + check_and_call(delete, [file_name(Name)]). + +-spec rename(From :: name(), To :: name()) -> 'ok' | {'error', posix()}. + +rename(From, To) -> + check_and_call(rename, [file_name(From), file_name(To)]). + +-spec make_dir(Name :: name()) -> 'ok' | {'error', posix()}. + +make_dir(Name) -> + check_and_call(make_dir, [file_name(Name)]). + +-spec del_dir(Name :: name()) -> 'ok' | {'error', posix()}. + +del_dir(Name) -> + check_and_call(del_dir, [file_name(Name)]). + +-spec read_file_info(Name :: name()) -> {'ok', #file_info{}} | {'error', posix()}. + +read_file_info(Name) -> + check_and_call(read_file_info, [file_name(Name)]). + +-spec altname(Name :: name()) -> any(). + +altname(Name) -> + check_and_call(altname, [file_name(Name)]). + +-spec read_link_info(Name :: name()) -> {'ok', #file_info{}} | {'error', posix()}. + +read_link_info(Name) -> + check_and_call(read_link_info, [file_name(Name)]). + +-spec read_link(Name :: name()) -> {'ok', filename()} | {'error', posix()}. + +read_link(Name) -> + check_and_call(read_link, [file_name(Name)]). + +-spec write_file_info(Name :: name(), Info :: #file_info{}) -> + 'ok' | {'error', posix()}. + +write_file_info(Name, Info = #file_info{}) -> + check_and_call(write_file_info, [file_name(Name), Info]). + +-spec list_dir(Name :: name()) -> {'ok', [filename()]} | {'error', posix()}. + +list_dir(Name) -> + check_and_call(list_dir, [file_name(Name)]). + +-spec read_file(Name :: name()) -> {'ok', binary()} | {'error', posix()}. + +read_file(Name) -> + check_and_call(read_file, [file_name(Name)]). + +-spec make_link(Old :: name(), New :: name()) -> 'ok' | {'error', posix()}. + +make_link(Old, New) -> + check_and_call(make_link, [file_name(Old), file_name(New)]). + +-spec make_symlink(Old :: name(), New :: name()) -> 'ok' | {'error', posix()}. + +make_symlink(Old, New) -> + check_and_call(make_symlink, [file_name(Old), file_name(New)]). + +-spec write_file(Name :: name(), Bin :: binary()) -> 'ok' | {'error', posix()}. + +write_file(Name, Bin) -> + check_and_call(write_file, [file_name(Name), make_binary(Bin)]). + +%% This whole operation should be moved to the file_server and prim_file +%% when it is time to change file server protocol again. +%% Meanwhile, it is implemented here, slihtly less efficient. +%% + +-spec write_file(Name :: name(), Bin :: binary(), Modes :: [mode()]) -> + 'ok' | {'error', posix()}. + +write_file(Name, Bin, ModeList) when is_list(ModeList) -> + case make_binary(Bin) of + B when is_binary(B) -> + case open(Name, [binary, write | + lists:delete(binary, + lists:delete(write, ModeList))]) of + {ok, Handle} -> + case write(Handle, B) of + ok -> + close(Handle); + E1 -> + close(Handle), + E1 + end; + E2 -> + E2 + end; + E3 -> + E3 + end. + +%% Obsolete, undocumented, local node only, don't use!. +%% XXX to be removed. +raw_read_file_info(Name) -> + Args = [file_name(Name)], + case check_args(Args) of + ok -> + [FileName] = Args, + ?PRIM_FILE:read_file_info(FileName); + Error -> + Error + end. + +%% Obsolete, undocumented, local node only, don't use!. +%% XXX to be removed. +raw_write_file_info(Name, #file_info{} = Info) -> + Args = [file_name(Name)], + case check_args(Args) of + ok -> + [FileName] = Args, + ?PRIM_FILE:write_file_info(FileName, Info); + Error -> + Error + end. + +%%%----------------------------------------------------------------- +%%% File io server functions. +%%% They operate on a single open file. +%%% Stateful. + +%% Contemporary mode specification - list of options + +-spec open(Name :: name(), Modes :: [mode()]) -> + {'ok', io_device()} | {'error', posix()}. + +open(Item, ModeList) when is_list(ModeList) -> + case lists:member(raw, ModeList) of + %% Raw file, use ?PRIM_FILE to handle this file + true -> + %% check if raw file mode is disabled + case catch application:get_env(kernel, raw_files) of + {ok,false} -> + open(Item, lists:delete(raw, ModeList)); + _ -> % undefined | {ok,true} + Args = [file_name(Item) | ModeList], + case check_args(Args) of + ok -> + [FileName | _] = Args, + %% We rely on the returned Handle (in {ok, Handle}) + %% being a pid() or a #file_descriptor{} + ?PRIM_FILE:open(FileName, ModeList); + Error -> + Error + end + end; + false -> + case lists:member(ram, ModeList) of + %% RAM file, use ?RAM_FILE to handle this file + true -> + case check_args(ModeList) of + ok -> + ?RAM_FILE:open(Item, ModeList); + Error -> + Error + end; + %% File server file + false -> + Args = [file_name(Item) | ModeList], + case check_args(Args) of + ok -> + [FileName | _] = Args, + call(open, [FileName, ModeList]); + Error -> + Error + end + end + end; +%% Old obsolete mode specification in atom or 2-tuple format +open(Item, Mode) -> + open(Item, mode_list(Mode)). + +%%%----------------------------------------------------------------- +%%% The following interface functions operate on open files. +%%% The File argument must be either a Pid or a handle +%%% returned from ?PRIM_FILE:open. + +-spec close(File :: io_device()) -> 'ok' | {'error', posix()}. + +close(File) when is_pid(File) -> + R = file_request(File, close), + case wait_file_reply(File, R) of + {error, terminated} -> + ok; + Other -> + Other + end; +%% unlink(File), +%% exit(File, close), +%% ok; +close(#file_descriptor{module = Module} = Handle) -> + Module:close(Handle); +close(_) -> + {error, badarg}. + +-spec read(File :: io_device(), Size :: non_neg_integer()) -> + 'eof' | {'ok', [char()] | binary()} | {'error', posix()}. + +read(File, Sz) when is_pid(File), is_integer(Sz), Sz >= 0 -> + case io:request(File, {get_chars, '', Sz}) of + Data when is_list(Data); is_binary(Data) -> + {ok, Data}; + Other -> + Other + end; +read(#file_descriptor{module = Module} = Handle, Sz) + when is_integer(Sz), Sz >= 0 -> + Module:read(Handle, Sz); +read(_, _) -> + {error, badarg}. + +-spec read_line(File :: io_device()) -> + 'eof' | {'ok', [char()] | binary()} | {'error', posix()}. + +read_line(File) when is_pid(File) -> + case io:request(File, {get_line, ''}) of + Data when is_list(Data); is_binary(Data) -> + {ok, Data}; + Other -> + Other + end; +read_line(#file_descriptor{module = Module} = Handle) -> + Module:read_line(Handle); +read_line(_) -> + {error, badarg}. + +-spec pread(File :: io_device(), + LocationNumbers :: [{location(), non_neg_integer()}]) -> + {'ok', [string() | binary() | 'eof']} | {'error', posix()}. + +pread(File, L) when is_pid(File), is_list(L) -> + pread_int(File, L, []); +pread(#file_descriptor{module = Module} = Handle, L) when is_list(L) -> + Module:pread(Handle, L); +pread(_, _) -> + {error, badarg}. + +pread_int(_File, [], R) -> + {ok, lists:reverse(R)}; +pread_int(File, [{At, Sz} | T], R) when is_integer(Sz), Sz >= 0 -> + case pread(File, At, Sz) of + {ok, Data} -> + pread_int(File, T, [Data | R]); + eof -> + pread_int(File, T, [eof | R]); + {error, _} = Error -> + Error + end; +pread_int(_, _, _) -> + {error, badarg}. + +-spec pread(File :: io_device(), + Location :: location(), + Size :: non_neg_integer()) -> + 'eof' | {'ok', string() | binary()} | {'error', posix()}. + +pread(File, At, Sz) when is_pid(File), is_integer(Sz), Sz >= 0 -> + R = file_request(File, {pread, At, Sz}), + wait_file_reply(File, R); +pread(#file_descriptor{module = Module} = Handle, Offs, Sz) + when is_integer(Sz), Sz >= 0 -> + Module:pread(Handle, Offs, Sz); +pread(_, _, _) -> + {error, badarg}. + +-spec write(File :: io_device(), Byte :: iodata()) -> + 'ok' | {'error', posix()}. + +write(File, Bytes) when is_pid(File) -> + case make_binary(Bytes) of + Bin when is_binary(Bin) -> + io:request(File, {put_chars,Bin}); + Error -> + Error + end; +write(#file_descriptor{module = Module} = Handle, Bytes) -> + Module:write(Handle, Bytes); +write(_, _) -> + {error, badarg}. + +-spec pwrite(File :: io_device(), L :: [{location(), iodata()}]) -> + 'ok' | {'error', {non_neg_integer(), posix()}}. + +pwrite(File, L) when is_pid(File), is_list(L) -> + pwrite_int(File, L, 0); +pwrite(#file_descriptor{module = Module} = Handle, L) when is_list(L) -> + Module:pwrite(Handle, L); +pwrite(_, _) -> + {error, badarg}. + +pwrite_int(_File, [], _R) -> + ok; +pwrite_int(File, [{At, Bytes} | T], R) -> + case pwrite(File, At, Bytes) of + ok -> + pwrite_int(File, T, R+1); + {error, Reason} -> + {error, {R, Reason}} + end; +pwrite_int(_, _, _) -> + {error, badarg}. + +-spec pwrite(File :: io_device(), + Location :: location(), + Bytes :: iodata()) -> + 'ok' | {'error', posix()}. + +pwrite(File, At, Bytes) when is_pid(File) -> + R = file_request(File, {pwrite, At, Bytes}), + wait_file_reply(File, R); +pwrite(#file_descriptor{module = Module} = Handle, Offs, Bytes) -> + Module:pwrite(Handle, Offs, Bytes); +pwrite(_, _, _) -> + {error, badarg}. + +-spec sync(File :: io_device()) -> 'ok' | {'error', posix()}. + +sync(File) when is_pid(File) -> + R = file_request(File, sync), + wait_file_reply(File, R); +sync(#file_descriptor{module = Module} = Handle) -> + Module:sync(Handle); +sync(_) -> + {error, badarg}. + +-spec position(File :: io_device(), Location :: location()) -> + {'ok',integer()} | {'error', posix()}. + +position(File, At) when is_pid(File) -> + R = file_request(File, {position,At}), + wait_file_reply(File, R); +position(#file_descriptor{module = Module} = Handle, At) -> + Module:position(Handle, At); +position(_, _) -> + {error, badarg}. + +-spec truncate(File :: io_device()) -> 'ok' | {'error', posix()}. + +truncate(File) when is_pid(File) -> + R = file_request(File, truncate), + wait_file_reply(File, R); +truncate(#file_descriptor{module = Module} = Handle) -> + Module:truncate(Handle); +truncate(_) -> + {error, badarg}. + +-spec copy(Source :: io_device() | name() | {name(), [mode()]}, + Destination :: io_device() | name() | {name(), [mode()]}) -> + {'ok', non_neg_integer()} | {'error', posix()}. + +copy(Source, Dest) -> + copy_int(Source, Dest, infinity). + +-spec copy(Source :: io_device() | name() | {name(), [mode()]}, + Destination :: io_device() | name() | {name(), [mode()]}, + Length :: non_neg_integer() | 'infinity') -> + {'ok', non_neg_integer()} | {'error', posix()}. + +copy(Source, Dest, Length) + when is_integer(Length), Length >= 0; + is_atom(Length) -> + copy_int(Source, Dest, Length); +copy(_, _, _) -> + {error, badarg}. + +%% Here we know that Length is either an atom or an integer >= 0 +%% (by the way, atoms > integers) +%% +%% Copy between open files. +copy_int(Source, Dest, Length) + when is_pid(Source), is_pid(Dest); + is_pid(Source), is_record(Dest, file_descriptor); + is_record(Source, file_descriptor), is_pid(Dest) -> + copy_opened_int(Source, Dest, Length, 0); +%% Copy between open raw files, both handled by the same module +copy_int(#file_descriptor{module = Module} = Source, + #file_descriptor{module = Module} = Dest, + Length) -> + Module:copy(Source, Dest, Length); +%% Copy between open raw files of different modules +copy_int(#file_descriptor{} = Source, + #file_descriptor{} = Dest, Length) -> + copy_opened_int(Source, Dest, Length, 0); +%% Copy between filenames, let the server do the copy +copy_int({SourceName, SourceOpts}, {DestName, DestOpts}, Length) + when is_list(SourceOpts), is_list(DestOpts) -> + check_and_call(copy, + [file_name(SourceName), SourceOpts, + file_name(DestName), DestOpts, + Length]); +%% Filename -> open file; must open Source and do client copy +copy_int({SourceName, SourceOpts}, Dest, Length) + when is_list(SourceOpts), is_pid(Dest); + is_list(SourceOpts), is_record(Dest, file_descriptor) -> + case file_name(SourceName) of + {error, _} = Error -> + Error; + Source -> + case open(Source, [read | SourceOpts]) of + {ok, Handle} -> + Result = copy_opened_int(Handle, Dest, Length, 0), + close(Handle), + Result; + {error, _} = Error -> + Error + end + end; +%% Open file -> filename; must open Dest and do client copy +copy_int(Source, {DestName, DestOpts}, Length) + when is_pid(Source), is_list(DestOpts); + is_record(Source, file_descriptor), is_list(DestOpts) -> + case file_name(DestName) of + {error, _} = Error -> + Error; + Dest -> + case open(Dest, [write | DestOpts]) of + {ok, Handle} -> + Result = copy_opened_int(Source, Handle, Length, 0), + close(Handle), + Result; + {error, _} = Error -> + Error + end + end; +%% +%% That was all combinations of {Name, Opts} tuples +%% and open files. At least one of Source and Dest has +%% to be a bare filename. +%% +%% If Source is not a bare filename; Dest must be +copy_int(Source, Dest, Length) + when is_pid(Source); + is_record(Source, file_descriptor) -> + copy_int(Source, {Dest, []}, Length); +copy_int({_SourceName, SourceOpts} = Source, Dest, Length) + when is_list(SourceOpts) -> + copy_int(Source, {Dest, []}, Length); +%% If Dest is not a bare filename; Source must be +copy_int(Source, Dest, Length) + when is_pid(Dest); + is_record(Dest, file_descriptor) -> + copy_int({Source, []}, Dest, Length); +copy_int(Source, {_DestName, DestOpts} = Dest, Length) + when is_list(DestOpts) -> + copy_int({Source, []}, Dest, Length); +%% Both must be bare filenames. If they are not, +%% the filename check in the copy operation will yell. +copy_int(Source, Dest, Length) -> + copy_int({Source, []}, {Dest, []}, Length). + + + +copy_opened(Source, Dest, Length) + when is_integer(Length), Length >= 0; + is_atom(Length) -> + copy_opened_int(Source, Dest, Length); +copy_opened(_, _, _) -> + {error, badarg}. + +%% Here we know that Length is either an atom or an integer >= 0 +%% (by the way, atoms > integers) + +copy_opened_int(Source, Dest, Length) + when is_pid(Source), is_pid(Dest) -> + copy_opened_int(Source, Dest, Length, 0); +copy_opened_int(Source, Dest, Length) + when is_pid(Source), is_record(Dest, file_descriptor) -> + copy_opened_int(Source, Dest, Length, 0); +copy_opened_int(Source, Dest, Length) + when is_record(Source, file_descriptor), is_pid(Dest) -> + copy_opened_int(Source, Dest, Length, 0); +copy_opened_int(Source, Dest, Length) + when is_record(Source, file_descriptor), is_record(Dest, file_descriptor) -> + copy_opened_int(Source, Dest, Length, 0); +copy_opened_int(_, _, _) -> + {error, badarg}. + +%% Here we know that Source and Dest are handles to open files, Length is +%% as above, and Copied is an integer >= 0 + +%% Copy loop in client process +copy_opened_int(_, _, Length, Copied) when Length =< 0 -> % atom() > integer() + {ok, Copied}; +copy_opened_int(Source, Dest, Length, Copied) -> + N = if Length > 65536 -> 65536; true -> Length end, % atom() > integer() ! + case read(Source, N) of + {ok, Data} -> + M = if is_binary(Data) -> byte_size(Data); + is_list(Data) -> length(Data) + end, + case write(Dest, Data) of + ok -> + if M < N -> + %% Got less than asked for - must be end of file + {ok, Copied+M}; + true -> + %% Decrement Length (might be an atom (infinity)) + NewLength = if is_atom(Length) -> Length; + true -> Length-M + end, + copy_opened_int(Source, Dest, NewLength, Copied+M) + end; + {error, _} = Error -> + Error + end; + eof -> + {ok, Copied}; + {error, _} = Error -> + Error + end. + + +%% Special indirect pread function. Introduced for Dets. +%% Reads a header from pos 'Pos', the header is first a size encoded as +%% 32 bit big endian unsigned and then a position also encoded as +%% 32 bit big endian. Finally it preads the data from that pos and size +%% in the file. + +ipread_s32bu_p32bu(File, Pos, MaxSize) when is_pid(File) -> + ipread_s32bu_p32bu_int(File, Pos, MaxSize); +ipread_s32bu_p32bu(#file_descriptor{module = Module} = Handle, Pos, MaxSize) -> + Module:ipread_s32bu_p32bu(Handle, Pos, MaxSize); +ipread_s32bu_p32bu(_, _, _) -> + {error, badarg}. + +ipread_s32bu_p32bu_int(File, Pos, Infinity) when is_atom(Infinity) -> + ipread_s32bu_p32bu_int(File, Pos, (1 bsl 31)-1); +ipread_s32bu_p32bu_int(File, Pos, MaxSize) + when is_integer(MaxSize), MaxSize >= 0 -> + if + MaxSize < (1 bsl 31) -> + case pread(File, Pos, 8) of + {ok, Header} -> + ipread_s32bu_p32bu_2(File, Header, MaxSize); + Error -> + Error + end; + true -> + {error, einval} + end; +ipread_s32bu_p32bu_int(_File, _Pos, _MaxSize) -> + {error, badarg}. + +ipread_s32bu_p32bu_2(_File, + <<0:32/big-unsigned, Pos:32/big-unsigned>>, + _MaxSize) -> + {ok, {0, Pos, eof}}; +ipread_s32bu_p32bu_2(File, + <<Size:32/big-unsigned, Pos:32/big-unsigned>>, + MaxSize) + when Size =< MaxSize -> + case pread(File, Pos, Size) of + {ok, Data} -> + {ok, {Size, Pos, Data}}; + eof -> + {ok, {Size, Pos, eof}}; + Error -> + Error + end; +ipread_s32bu_p32bu_2(_File, + <<_:8/binary>>, + _MaxSize) -> + eof; +ipread_s32bu_p32bu_2(_File, + <<_/binary>>, + _MaxSize) -> + eof; +ipread_s32bu_p32bu_2(File, + Header, + MaxSize) when is_list(Header) -> + ipread_s32bu_p32bu_2(File, list_to_binary(Header), MaxSize). + + + +%%%----------------------------------------------------------------- +%%% The following functions, built upon the other interface functions, +%%% provide a higher-lever interface to files. + +-spec consult(File :: name()) -> + {'ok', list()} | {'error', posix() | {integer(), atom(), any()}}. + +consult(File) -> + case open(File, [read]) of + {ok, Fd} -> + R = consult_stream(Fd), + close(Fd), + R; + Error -> + Error + end. + +-spec path_consult(Paths :: [name()], File :: name()) -> + {'ok', list(), filename()} | {'error', posix() | {integer(), atom(), any()}}. + +path_consult(Path, File) -> + case path_open(Path, File, [read]) of + {ok, Fd, Full} -> + case consult_stream(Fd) of + {ok, List} -> + close(Fd), + {ok, List, Full}; + E1 -> + close(Fd), + E1 + end; + E2 -> + E2 + end. + +-spec eval(File :: name()) -> 'ok' | {'error', posix()}. + +eval(File) -> + eval(File, erl_eval:new_bindings()). + +-spec eval(File :: name(), Bindings :: bindings()) -> + 'ok' | {'error', posix()}. + +eval(File, Bs) -> + case open(File, [read]) of + {ok, Fd} -> + R = eval_stream(Fd, ignore, Bs), + close(Fd), + R; + Error -> + Error + end. + +-spec path_eval(Paths :: [name()], File :: name()) -> + {'ok', filename()} | {'error', posix() | {integer(), atom(), any()}}. + +path_eval(Path, File) -> + path_eval(Path, File, erl_eval:new_bindings()). + +-spec path_eval(Paths :: [name()], File :: name(), Bindings :: bindings()) -> + {'ok', filename()} | {'error', posix() | {integer(), atom(), any()}}. + +path_eval(Path, File, Bs) -> + case path_open(Path, File, [read]) of + {ok, Fd, Full} -> + case eval_stream(Fd, ignore, Bs) of + ok -> + close(Fd), + {ok, Full}; + E1 -> + close(Fd), + E1 + end; + E2 -> + E2 + end. + +-spec script(File :: name()) -> + {'ok', any()} | {'error', posix() | {integer(), atom(), any()}}. + +script(File) -> + script(File, erl_eval:new_bindings()). + +-spec script(File :: name(), Bindings :: bindings()) -> + {'ok', any()} | {'error', posix() | {integer(), atom(), any()}}. + +script(File, Bs) -> + case open(File, [read]) of + {ok, Fd} -> + R = eval_stream(Fd, return, Bs), + close(Fd), + R; + Error -> + Error + end. + +-spec path_script/2 :: (Paths :: [name()], File :: name()) -> + {'ok', term(), filename()} | {'error', posix() | {integer(), atom(), _}}. + +path_script(Path, File) -> + path_script(Path, File, erl_eval:new_bindings()). + +-spec path_script(Paths :: [name()], + File :: name(), + Bindings :: bindings()) -> + {'ok', term(), filename()} | {'error', posix() | {integer(), atom(), _}}. + +path_script(Path, File, Bs) -> + case path_open(Path, File, [read]) of + {ok,Fd,Full} -> + case eval_stream(Fd, return, Bs) of + {ok,R} -> + close(Fd), + {ok, R, Full}; + E1 -> + close(Fd), + E1 + end; + E2 -> + E2 + end. + + +%% path_open(Paths, Filename, Mode) -> +%% {ok,FileDescriptor,FullName} +%% {error,Reason} +%% +%% Searches the Paths for file Filename which can be opened with Mode. +%% The path list is ignored if Filename contains an absolute path. + +-spec path_open(Paths :: [name()], Name :: name(), Modes :: [mode()]) -> + {'ok', io_device(), filename()} | {'error', posix()}. + +path_open(PathList, Name, Mode) -> + case file_name(Name) of + {error, _} = Error -> + Error; + FileName -> + case filename:pathtype(FileName) of + relative -> + path_open_first(PathList, FileName, Mode, enoent); + _ -> + case open(Name, Mode) of + {ok, Fd} -> + {ok, Fd, Name}; + Error -> + Error + end + end + end. + +-spec change_mode(Name :: name(), Mode :: integer()) -> + 'ok' | {'error', posix()}. + +change_mode(Name, Mode) + when is_integer(Mode) -> + write_file_info(Name, #file_info{mode=Mode}). + +-spec change_owner(Name :: name(), OwnerId :: integer()) -> + 'ok' | {'error', posix()}. + +change_owner(Name, OwnerId) + when is_integer(OwnerId) -> + write_file_info(Name, #file_info{uid=OwnerId}). + +-spec change_owner(Name :: name(), + OwnerId :: integer(), + GroupId :: integer()) -> + 'ok' | {'error', posix()}. + +change_owner(Name, OwnerId, GroupId) + when is_integer(OwnerId), is_integer(GroupId) -> + write_file_info(Name, #file_info{uid=OwnerId, gid=GroupId}). + +-spec change_group(Name :: name(), GroupId :: integer()) -> + 'ok' | {'error', posix()}. + +change_group(Name, GroupId) + when is_integer(GroupId) -> + write_file_info(Name, #file_info{gid=GroupId}). + +-spec change_time(Name :: name(), Time :: date_time()) -> + 'ok' | {'error', posix()}. + +change_time(Name, Time) + when is_tuple(Time) -> + write_file_info(Name, #file_info{mtime=Time}). + +-spec change_time(Name :: name(), + ATime :: date_time(), + MTime :: date_time()) -> + 'ok' | {'error', posix()}. + +change_time(Name, Atime, Mtime) + when is_tuple(Atime), is_tuple(Mtime) -> + write_file_info(Name, #file_info{atime=Atime, mtime=Mtime}). + +%%%----------------------------------------------------------------- +%%% Helpers + +consult_stream(Fd) -> + consult_stream(Fd, 1, []). + +consult_stream(Fd, Line, Acc) -> + case io:read(Fd, '', Line) of + {ok,Term,EndLine} -> + consult_stream(Fd, EndLine, [Term|Acc]); + {error,Error,_Line} -> + {error,Error}; + {eof,_Line} -> + {ok,lists:reverse(Acc)} + end. + +eval_stream(Fd, Handling, Bs) -> + eval_stream(Fd, Handling, 1, undefined, [], Bs). + +eval_stream(Fd, H, Line, Last, E, Bs) -> + eval_stream2(io:parse_erl_exprs(Fd, '', Line), Fd, H, Last, E, Bs). + +eval_stream2({ok,Form,EndLine}, Fd, H, Last, E, Bs0) -> + try erl_eval:exprs(Form, Bs0) of + {value,V,Bs} -> + eval_stream(Fd, H, EndLine, {V}, E, Bs) + catch Class:Reason -> + Error = {EndLine,?MODULE,{Class,Reason,erlang:get_stacktrace()}}, + eval_stream(Fd, H, EndLine, Last, [Error|E], Bs0) + end; +eval_stream2({error,What,EndLine}, Fd, H, Last, E, Bs) -> + eval_stream(Fd, H, EndLine, Last, [What | E], Bs); +eval_stream2({eof,EndLine}, _Fd, H, Last, E, _Bs) -> + case {H, Last, E} of + {return, {Val}, []} -> + {ok, Val}; + {return, undefined, E} -> + {error, hd(lists:reverse(E, [{EndLine,?MODULE,undefined_script}]))}; + {ignore, _, []} -> + ok; + {_, _, [_|_] = E} -> + {error, hd(lists:reverse(E))} + end. + +path_open_first([Path|Rest], Name, Mode, LastError) -> + case file_name(Path) of + {error, _} = Error -> + Error; + FilePath -> + FileName = filename:join(FilePath, Name), + case open(FileName, Mode) of + {ok, Fd} -> + {ok, Fd, FileName}; + {error, enoent} -> + path_open_first(Rest, Name, Mode, LastError); + Error -> + Error + end + end; +path_open_first([], _Name, _Mode, LastError) -> + {error, LastError}. + +%%%----------------------------------------------------------------- +%%% Utility functions. + +%% file_name(FileName) +%% Generates a flat file name from a deep list of atoms and +%% characters (integers). + +file_name(N) -> + try + file_name_1(N) + catch Reason -> + {error, Reason} + end. + +file_name_1([C|T]) when is_integer(C), C > 0, C =< 255 -> + [C|file_name_1(T)]; +file_name_1([H|T]) -> + file_name_1(H) ++ file_name_1(T); +file_name_1([]) -> + []; +file_name_1(N) when is_atom(N) -> + atom_to_list(N); +file_name_1(_) -> + throw(badarg). + +make_binary(Bin) when is_binary(Bin) -> + Bin; +make_binary(List) -> + %% Convert the list to a binary in order to avoid copying a list + %% to the file server. + try + erlang:iolist_to_binary(List) + catch error:Reason -> + {error, Reason} + end. + +mode_list(read) -> + [read]; +mode_list(write) -> + [write]; +mode_list(read_write) -> + [read, write]; +mode_list({binary, Mode}) when is_atom(Mode) -> + [binary | mode_list(Mode)]; +mode_list({character, Mode}) when is_atom(Mode) -> + mode_list(Mode); +mode_list(_) -> + [{error, badarg}]. + +%%----------------------------------------------------------------- +%% Functions for communicating with the file server + +call(Command, Args) when is_list(Args) -> + gen_server:call(?FILE_SERVER, list_to_tuple([Command | Args]), infinity). + +check_and_call(Command, Args) when is_list(Args) -> + case check_args(Args) of + ok -> + call(Command, Args); + Error -> + Error + end. + +check_args([{error, _}=Error|_Rest]) -> + Error; +check_args([_Name|Rest]) -> + check_args(Rest); +check_args([]) -> + ok. + +%%----------------------------------------------------------------- +%% Functions for communicating with a file io server. +%% The messages sent have the following formats: +%% +%% {file_request,From,ReplyAs,Request} +%% {file_reply,ReplyAs,Reply} + +file_request(Io, Request) -> + R = erlang:monitor(process, Io), + Io ! {file_request,self(),Io,Request}, + R. + +wait_file_reply(From, Ref) -> + receive + {file_reply,From,Reply} -> + erlang:demonitor(Ref), + receive {'DOWN', Ref, _, _, _} -> ok after 0 -> ok end, + %% receive {'EXIT', From, _} -> ok after 0 -> ok end, + Reply; + {'DOWN', Ref, _, _, _} -> + %% receive {'EXIT', From, _} -> ok after 0 -> ok end, + {error, terminated} + end. diff --git a/lib/kernel/src/file_io_server.erl b/lib/kernel/src/file_io_server.erl new file mode 100644 index 0000000000..37e803c493 --- /dev/null +++ b/lib/kernel/src/file_io_server.erl @@ -0,0 +1,882 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2000-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(file_io_server). + +%% A simple file server for io to one file instance per server instance. + +-export([format_error/1]). +-export([start/3, start_link/3]). + +-export([count_and_find/3]). + +-record(state, {handle,owner,mref,buf,read_mode,unic}). + +-define(PRIM_FILE, prim_file). +-define(READ_SIZE_LIST, 128). +-define(READ_SIZE_BINARY, (8*1024)). + +-define(eat_message(M, T), receive M -> M after T -> timeout end). + +%%%----------------------------------------------------------------- +%%% Exported functions + +format_error({_Line, ?MODULE, Reason}) -> + io_lib:format("~w", [Reason]); +format_error({_Line, Mod, Reason}) -> + Mod:format_error(Reason); +format_error(ErrorId) -> + erl_posix_msg:message(ErrorId). + +start(Owner, FileName, ModeList) + when is_pid(Owner), is_list(FileName), is_list(ModeList) -> + do_start(spawn, Owner, FileName, ModeList). + +start_link(Owner, FileName, ModeList) + when is_pid(Owner), is_list(FileName), is_list(ModeList) -> + do_start(spawn_link, Owner, FileName, ModeList). + +%%%----------------------------------------------------------------- +%%% Server starter, dispatcher and helpers + +do_start(Spawn, Owner, FileName, ModeList) -> + Self = self(), + Ref = make_ref(), + Pid = + erlang:Spawn( + fun() -> + %% process_flag(trap_exit, true), + case parse_options(ModeList) of + {ReadMode, UnicodeMode, Opts} -> + case ?PRIM_FILE:open(FileName, Opts) of + {error, Reason} = Error -> + Self ! {Ref, Error}, + exit(Reason); + {ok, Handle} -> + %% XXX must I handle R6 nodes here? + M = erlang:monitor(process, Owner), + Self ! {Ref, ok}, + server_loop( + #state{handle = Handle, + owner = Owner, + mref = M, + buf = <<>>, + read_mode = ReadMode, + unic = UnicodeMode}) + end; + {error,Reason1} = Error1 -> + Self ! {Ref, Error1}, + exit(Reason1) + end + end), + Mref = erlang:monitor(process, Pid), + receive + {Ref, {error, _Reason} = Error} -> + erlang:demonitor(Mref), + receive {'DOWN', Mref, _, _, _} -> ok after 0 -> ok end, + Error; + {Ref, ok} -> + erlang:demonitor(Mref), + receive + {'DOWN', Mref, _, _, Reason} -> + {error, Reason} + after 0 -> + {ok, Pid} + end; + {'DOWN', Mref, _, _, Reason} -> + {error, Reason} + end. + +%%% Returns {ReadMode, UnicodeMode, RealOpts} +parse_options(List) -> + parse_options(expand_encoding(List), list, latin1, []). + +parse_options([],list,Uni,Acc) -> + {list,Uni,[binary|lists:reverse(Acc)]}; +parse_options([],binary,Uni,Acc) -> + {binary,Uni,lists:reverse(Acc)}; +parse_options([{encoding, Encoding}|T],RMode,_,Acc) -> + case valid_enc(Encoding) of + {ok, ExpandedEnc} -> + parse_options(T,RMode,ExpandedEnc,Acc); + {error,Reason} -> + {error,Reason} + end; +parse_options([binary|T],_,Uni,Acc) -> + parse_options(T,binary,Uni,[binary|Acc]); +parse_options([H|T],R,U,Acc) -> + parse_options(T,R,U,[H|Acc]). + +expand_encoding([]) -> + []; +expand_encoding([latin1 | T]) -> + [{encoding,latin1} | expand_encoding(T)]; +expand_encoding([unicode | T]) -> + [{encoding,unicode} | expand_encoding(T)]; +expand_encoding([H|T]) -> + [H|expand_encoding(T)]. + +valid_enc(latin1) -> + {ok,latin1}; +valid_enc(utf8) -> + {ok,unicode}; +valid_enc(unicode) -> + {ok,unicode}; +valid_enc(utf16) -> + {ok,{utf16,big}}; +valid_enc({utf16,big}) -> + {ok,{utf16,big}}; +valid_enc({utf16,little}) -> + {ok,{utf16,little}}; +valid_enc(utf32) -> + {ok,{utf32,big}}; +valid_enc({utf32,big}) -> + {ok,{utf32,big}}; +valid_enc({utf32,little}) -> + {ok,{utf32,little}}; +valid_enc(_Other) -> + {error,badarg}. + + + +server_loop(#state{mref = Mref} = State) -> + receive + {file_request, From, ReplyAs, Request} when is_pid(From) -> + case file_request(Request, State) of + {reply, Reply, NewState} -> + file_reply(From, ReplyAs, Reply), + server_loop(NewState); + {error, Reply, NewState} -> + %% error is the same as reply, except that + %% it breaks the io_request_loop further down + file_reply(From, ReplyAs, Reply), + server_loop(NewState); + {stop, Reason, Reply, _NewState} -> + file_reply(From, ReplyAs, Reply), + exit(Reason) + end; + {io_request, From, ReplyAs, Request} when is_pid(From) -> + case io_request(Request, State) of + {reply, Reply, NewState} -> + io_reply(From, ReplyAs, Reply), + server_loop(NewState); + {error, Reply, NewState} -> + %% error is the same as reply, except that + %% it breaks the io_request_loop further down + io_reply(From, ReplyAs, Reply), + server_loop(NewState); + {stop, Reason, Reply, _NewState} -> + io_reply(From, ReplyAs, Reply), + exit(Reason) + end; + {'DOWN', Mref, _, _, Reason} -> + exit(Reason); + _ -> + server_loop(State) + end. + +file_reply(From, ReplyAs, Reply) -> + From ! {file_reply, ReplyAs, Reply}. + +io_reply(From, ReplyAs, Reply) -> + From ! {io_reply, ReplyAs, Reply}. + +%%%----------------------------------------------------------------- +%%% file requests + +file_request({pread,At,Sz}, + #state{handle=Handle,buf=Buf,read_mode=ReadMode}=State) -> + case position(Handle, At, Buf) of + {ok,_Offs} -> + case ?PRIM_FILE:read(Handle, Sz) of + {ok,Bin} when ReadMode =:= list -> + std_reply({ok,binary_to_list(Bin)}, State); + Reply -> + std_reply(Reply, State) + end; + Reply -> + std_reply(Reply, State) + end; +file_request({pwrite,At,Data}, + #state{handle=Handle,buf=Buf}=State) -> + case position(Handle, At, Buf) of + {ok,_Offs} -> + std_reply(?PRIM_FILE:write(Handle, Data), State); + Reply -> + std_reply(Reply, State) + end; +file_request(sync, + #state{handle=Handle}=State) -> + case ?PRIM_FILE:sync(Handle) of + {error,_}=Reply -> + {stop,normal,Reply,State}; + Reply -> + {reply,Reply,State} + end; +file_request(close, + #state{handle=Handle}=State) -> + {stop,normal,?PRIM_FILE:close(Handle),State#state{buf= <<>>}}; +file_request({position,At}, + #state{handle=Handle,buf=Buf}=State) -> + std_reply(position(Handle, At, Buf), State); +file_request(truncate, + #state{handle=Handle}=State) -> + case ?PRIM_FILE:truncate(Handle) of + {error,_Reason}=Reply -> + {stop,normal,Reply,State#state{buf= <<>>}}; + Reply -> + {reply,Reply,State} + end; +file_request(Unknown, + #state{}=State) -> + Reason = {request, Unknown}, + {error,{error,Reason},State}. + +std_reply({error,_}=Reply, State) -> + {error,Reply,State#state{buf= <<>>}}; +std_reply(Reply, State) -> + {reply,Reply,State#state{buf= <<>>}}. + +%%%----------------------------------------------------------------- +%%% I/O request + +%% New protocol with encoding tags (R13) +io_request({put_chars, Enc, Chars}, + #state{buf= <<>>}=State) -> + put_chars(Chars, Enc, State); +io_request({put_chars, Enc, Chars}, + #state{handle=Handle,buf=Buf}=State) -> + case position(Handle, cur, Buf) of + {error,_}=Reply -> + {stop,normal,Reply,State#state{buf= <<>>}}; + _ -> + put_chars(Chars, Enc, State#state{buf= <<>>}) + end; +io_request({put_chars,Enc,Mod,Func,Args}, + #state{}=State) -> + case catch apply(Mod, Func, Args) of + Chars when is_list(Chars); is_binary(Chars) -> + io_request({put_chars,Enc,Chars}, State); + _ -> + {error,{error,Func},State} + end; + + +io_request({get_until,Enc,_Prompt,Mod,Func,XtraArgs}, + #state{}=State) -> + get_chars(io_lib, get_until, {Mod, Func, XtraArgs}, Enc, State); +io_request({get_chars,Enc,_Prompt,N}, + #state{}=State) -> + get_chars(N, Enc, State); + +%% +%% This optimization gives almost nothing - needs more working... +%% Disabled for now. /PaN +%% +%% io_request({get_line,Enc,_Prompt}, +%% #state{unic=latin1}=State) -> +%% get_line(Enc,State); + +io_request({get_line,Enc,_Prompt}, + #state{}=State) -> + get_chars(io_lib, collect_line, [], Enc, State); + + +io_request({setopts, Opts}, + #state{}=State) when is_list(Opts) -> + setopts(Opts, State); + +io_request(getopts, + #state{}=State) -> + getopts(State); + +%% BC with pre-R13 nodes +io_request({put_chars, Chars},#state{}=State) -> + io_request({put_chars, latin1, Chars},State); +io_request({put_chars,Mod,Func,Args}, #state{}=State) -> + io_request({put_chars,latin1,Mod,Func,Args}, State); +io_request({get_until,_Prompt,Mod,Func,XtraArgs}, #state{}=State) -> + io_request({get_until,latin1,_Prompt,Mod,Func,XtraArgs}, State); +io_request({get_chars,_Prompt,N}, #state{}=State) -> + io_request({get_chars,latin1,_Prompt,N}, State); +io_request({get_line,_Prompt}, #state{}=State) -> + io_request({get_line,latin1,_Prompt}, State); + +io_request({requests,Requests}, + #state{}=State) when is_list(Requests) -> + io_request_loop(Requests, {reply,ok,State}); +io_request(Unknown, + #state{}=State) -> + Reason = {request,Unknown}, + {error,{error,Reason},State}. + + + +%% Process a list of requests as long as the results are ok. + +io_request_loop([], Result) -> + Result; +io_request_loop([_Request|_Tail], + {stop,_Reason,_Reply,_State}=Result) -> + Result; +io_request_loop([_Request|_Tail], + {error,_Reply,_State}=Result) -> + Result; +io_request_loop([Request|Tail], + {reply,_Reply,State}) -> + io_request_loop(Tail, io_request(Request, State)). + + + +%% I/O request put_chars +%% +put_chars(Chars, latin1, #state{handle=Handle, unic=latin1}=State) -> + case ?PRIM_FILE:write(Handle, Chars) of + {error,_}=Reply -> + {stop,normal,Reply,State}; + Reply -> + {reply,Reply,State} + end; +put_chars(Chars, InEncoding, #state{handle=Handle, unic=OutEncoding}=State) -> + case unicode:characters_to_binary(Chars,InEncoding,OutEncoding) of + Bin when is_binary(Bin) -> + case ?PRIM_FILE:write(Handle, Bin) of + {error,_}=Reply -> + {stop,normal,Reply,State}; + Reply -> + {reply,Reply,State} + end; + {error,_,_} -> + {stop,normal,{error,{no_translation, InEncoding, OutEncoding}},State} + end. + +%% +%% Process the I/O request get_line for latin1 encoding of file specially +%% Unfortunately this function gives almost nothing, it needs more work +%% I disable it for now /PaN +%% +%% srch(<<>>,_,_) -> +%% nomatch; +%% srch(<<X:8,_/binary>>,X,N) -> +%% {match,N}; +%% srch(<<_:8,T/binary>>,X,N) -> +%% srch(T,X,N+1). +%% get_line(OutEnc, #state{handle=Handle,buf = <<>>,unic=latin1}=State) -> +%% case ?PRIM_FILE:read(Handle,?READ_SIZE_BINARY) of +%% {ok, B} -> +%% get_line(OutEnc, State#state{buf = B}); +%% eof -> +%% {reply,eof,State}; +%% {error,Reason}=Error -> +%% {stop,Reason,Error,State} +%% end; +%% get_line(OutEnc, #state{handle=Handle,buf=Buf,read_mode=ReadMode,unic=latin1}=State) -> +%% case srch(Buf,$\n,0) of +%% nomatch -> +%% case ?PRIM_FILE:read(Handle,?READ_SIZE_BINARY) of +%% {ok, B} -> +%% get_line(OutEnc,State#state{buf = <<Buf/binary,B/binary>>}); +%% eof -> +%% std_reply(cast(Buf, ReadMode,latin1,OutEnc), State); +%% {error,Reason}=Error -> +%% {stop,Reason,Error,State#state{buf= <<>>}} +%% end; +%% {match,Pos} when Pos >= 1-> +%% PosP1 = Pos + 1, +%% <<Res0:PosP1/binary,NewBuf/binary>> = Buf, +%% PosM1 = Pos - 1, +%% Res = case Res0 of +%% <<Chomped:PosM1/binary,$\r:8,$\n:8>> -> +%% cat(Chomped, <<"\n">>, ReadMode,latin1,OutEnc); +%% _Other -> +%% cast(Res0, ReadMode,latin1,OutEnc) +%% end, +%% {reply,Res,State#state{buf=NewBuf}}; +%% {match,Pos} -> +%% PosP1 = Pos + 1, +%% <<Res:PosP1/binary,NewBuf/binary>> = Buf, +%% {reply,Res,State#state{buf=NewBuf}} +%% end; +%% get_line(_, #state{}=State) -> +%% {error,{error,get_line},State}. + +%% +%% Process the I/O request get_chars +%% +get_chars(0, Enc, #state{read_mode=ReadMode,unic=InEncoding}=State) -> + {reply,cast(<<>>, ReadMode,InEncoding, Enc),State}; +get_chars(N, Enc, #state{buf=Buf,read_mode=ReadMode,unic=latin1}=State) + when is_integer(N), N > 0, N =< byte_size(Buf) -> + {B1,B2} = split_binary(Buf, N), + {reply,cast(B1, ReadMode,latin1,Enc),State#state{buf=B2}}; +get_chars(N, Enc, #state{buf=Buf,read_mode=ReadMode,unic=latin1}=State) + when is_integer(N), N > 0, N =< byte_size(Buf) -> + {B1,B2} = split_binary(Buf, N), + {reply,cast(B1, ReadMode,latin1,Enc),State#state{buf=B2}}; +get_chars(N, OutEnc,#state{handle=Handle,buf=Buf,read_mode=ReadMode,unic=latin1}=State) + when is_integer(N), N > 0 -> + BufSize = byte_size(Buf), + NeedSize = N-BufSize, + Size = erlang:max(NeedSize, ?READ_SIZE_BINARY), + case ?PRIM_FILE:read(Handle, Size) of + {ok, B} -> + if BufSize+byte_size(B) < N -> + std_reply(cat(Buf, B, ReadMode,latin1,OutEnc), State); + true -> + {B1,B2} = split_binary(B, NeedSize), + {reply,cat(Buf, B1, ReadMode, latin1,OutEnc),State#state{buf=B2}} + end; + eof when BufSize =:= 0 -> + {reply,eof,State}; + eof -> + std_reply(cast(Buf, ReadMode,latin1,OutEnc), State); + {error,Reason}=Error -> + {stop,Reason,Error,State#state{buf= <<>>}} + end; +get_chars(N, OutEnc,#state{handle=Handle,buf=Buf,read_mode=ReadMode,unic=InEncoding}=State) + when is_integer(N), N > 0 -> + try + %% This is rather tricky, we need to count the actual number of characters + %% in the buffer first as unicode characters are not constant in length + {BufCount, SplitPos} = count_and_find(Buf,N,InEncoding), + case BufCount >= N of + true -> + {B1,B2} = case SplitPos of + none -> {Buf,<<>>}; + _ ->split_binary(Buf,SplitPos) + end, + {reply,cast(B1, ReadMode,InEncoding,OutEnc),State#state{buf=B2}}; + false -> + %% Need more, Try to read 4*needed in bytes... + NeedSize = (N - BufCount) * 4, + Size = erlang:max(NeedSize, ?READ_SIZE_BINARY), + case ?PRIM_FILE:read(Handle, Size) of + {ok, B} -> + NewBuf = list_to_binary([Buf,B]), + {NewCount,NewSplit} = count_and_find(NewBuf,N,InEncoding), + case NewCount >= N of + true -> + {B01,B02} = case NewSplit of + none -> {NewBuf,<<>>}; + _ ->split_binary(NewBuf, NewSplit) + end, + {reply,cast(B01, ReadMode,InEncoding,OutEnc), + State#state{buf=B02}}; + false -> + %% Reached end of file + std_reply(cast(NewBuf, ReadMode,InEncoding,OutEnc), + State#state{buf = <<>>}) + end; + eof when BufCount =:= 0 -> + {reply,eof,State}; + eof -> + std_reply(cast(Buf, ReadMode,InEncoding,OutEnc), State#state{buf = <<>>}); + {error,Reason}=Error -> + {stop,Reason,Error,State#state{buf = <<>>}} + end + end + catch + exit:ExError -> + {stop,ExError,{error,ExError},State#state{buf= <<>>}} + end; + +get_chars(_N, _, #state{}=State) -> + {error,{error,get_chars},State}. + +get_chars(Mod, Func, XtraArg, OutEnc, #state{buf= <<>>}=State) -> + get_chars_empty(Mod, Func, XtraArg, start, OutEnc, State); +get_chars(Mod, Func, XtraArg, OutEnc, #state{buf=Buf}=State) -> + get_chars_apply(Mod, Func, XtraArg, start, OutEnc, State#state{buf= <<>>}, Buf). + +get_chars_empty(Mod, Func, XtraArg, S, latin1, + #state{handle=Handle,read_mode=ReadMode, unic=latin1}=State) -> + case ?PRIM_FILE:read(Handle, read_size(ReadMode)) of + {ok,Bin} -> + get_chars_apply(Mod, Func, XtraArg, S, latin1, State, Bin); + eof -> + get_chars_apply(Mod, Func, XtraArg, S, latin1, State, eof); + {error,Reason}=Error -> + {stop,Reason,Error,State} + end; +get_chars_empty(Mod, Func, XtraArg, S, OutEnc, + #state{handle=Handle,read_mode=ReadMode}=State) -> + case ?PRIM_FILE:read(Handle, read_size(ReadMode)) of + {ok,Bin} -> + get_chars_apply(Mod, Func, XtraArg, S, OutEnc, State, Bin); + eof -> + get_chars_apply(Mod, Func, XtraArg, S, OutEnc, State, eof); + {error,Reason}=Error -> + {stop,Reason,Error,State} + end. +get_chars_notempty(Mod, Func, XtraArg, S, OutEnc, + #state{handle=Handle,read_mode=ReadMode,buf = B}=State) -> + case ?PRIM_FILE:read(Handle, read_size(ReadMode)) of + {ok,Bin} -> + get_chars_apply(Mod, Func, XtraArg, S, OutEnc, State, list_to_binary([B,Bin])); + eof -> + case B of + <<>> -> + get_chars_apply(Mod, Func, XtraArg, S, OutEnc, State, eof); + _ -> + {stop,invalid_unicode,{error,invalid_unicode},State} + end; + {error,Reason}=Error -> + {stop,Reason,Error,State} + end. + + +get_chars_apply(Mod, Func, XtraArg, S0, latin1, + #state{read_mode=ReadMode,unic=latin1}=State, Data0) -> + Data1 = case ReadMode of + list when is_binary(Data0) -> binary_to_list(Data0); + _ -> Data0 + end, + case catch Mod:Func(S0, Data1, latin1, XtraArg) of + {stop,Result,Buf} -> + {reply,Result,State#state{buf=cast_binary(Buf)}}; + {'EXIT',Reason} -> + {stop,Reason,{error,err_func(Mod, Func, XtraArg)},State}; + S1 -> + get_chars_empty(Mod, Func, XtraArg, S1, latin1, State) + end; +get_chars_apply(Mod, Func, XtraArg, S0, OutEnc, + #state{read_mode=ReadMode,unic=InEnc}=State, Data0) -> + try + {Data1,NewBuff} = case ReadMode of + list when is_binary(Data0) -> + case unicode:characters_to_list(Data0,InEnc) of + {Tag,Decoded,Rest} when Decoded =/= [], Tag =:= error; Decoded =/= [], Tag =:= incomplete -> + {Decoded,erlang:iolist_to_binary(Rest)}; + {error, [], _} -> + exit(invalid_unicode); + {incomplete, [], R} -> + {[],R}; + List when is_list(List) -> + {List,<<>>} + end; + binary when is_binary(Data0) -> + case unicode:characters_to_binary(Data0,InEnc,OutEnc) of + {Tag2,Decoded2,Rest2} when Decoded2 =/= <<>>, Tag2 =:= error; Decoded2 =/= <<>>, Tag2 =:= incomplete -> + {Decoded2,erlang:iolist_to_binary(Rest2)}; + {error, <<>>, _} -> + exit(invalid_unicode); + {incomplete, <<>>, R} -> + {<<>>,R}; + Binary when is_binary(Binary) -> + {Binary,<<>>} + end; + _ -> %i.e. eof + {Data0,<<>>} + end, + case catch Mod:Func(S0, Data1, OutEnc, XtraArg) of + {stop,Result,Buf} -> + {reply,Result,State#state{buf = (if + is_binary(Buf) -> + list_to_binary([unicode:characters_to_binary(Buf,OutEnc,InEnc),NewBuff]); + is_list(Buf) -> + list_to_binary([unicode:characters_to_binary(Buf,unicode,InEnc),NewBuff]); + true -> + NewBuff + end)}}; + {'EXIT',Reason} -> + {stop,Reason,{error,err_func(Mod, Func, XtraArg)},State}; + S1 -> + get_chars_notempty(Mod, Func, XtraArg, S1, OutEnc, State#state{buf=NewBuff}) + end + catch + exit:ExReason -> + {stop,ExReason,{error,err_func(Mod, Func, XtraArg)},State}; + error:ErrReason -> + {stop,ErrReason,{error,err_func(Mod, Func, XtraArg)},State} + end. + + + +%% Convert error code to make it look as before +err_func(io_lib, get_until, {_,F,_}) -> + F; +err_func(_, F, _) -> + F. + + + +%% Process the I/O request setopts +%% +%% setopts +setopts(Opts0,State) -> + Opts = proplists:unfold( + proplists:substitute_negations( + [{list,binary}], + expand_encoding(Opts0))), + case check_valid_opts(Opts) of + true -> + do_setopts(Opts,State); + false -> + {error,{error,enotsup},State} + end. +check_valid_opts([]) -> + true; +check_valid_opts([{binary,_}|T]) -> + check_valid_opts(T); +check_valid_opts([{encoding,_Enc}|T]) -> + check_valid_opts(T); +check_valid_opts(_) -> + false. +do_setopts(Opts, State) -> + case valid_enc(proplists:get_value(encoding, Opts, State#state.unic)) of + {ok,NewUnic} -> + case proplists:get_value(binary, Opts) of + true -> + {reply,ok,State#state{read_mode=binary, unic=NewUnic}}; + false -> + {reply,ok,State#state{read_mode=list, unic=NewUnic}}; + undefined -> + {reply,ok,State#state{unic=NewUnic}} + end; + _ -> + {error,{error,badarg},State} + end. + +getopts(#state{read_mode=RM, unic=Unic} = State) -> + Bin = {binary, case RM of + binary -> + true; + _ -> + false + end}, + Uni = {encoding, Unic}, + {reply,[Bin,Uni],State}. + + +%% Concatenate two binaries and convert the result to list or binary +cat(B1, B2, binary,latin1,latin1) -> + list_to_binary([B1,B2]); +cat(B1, B2, binary,InEncoding,OutEncoding) -> + case unicode:characters_to_binary([B1,B2],InEncoding,OutEncoding) of + Good when is_binary(Good) -> + Good; + _ -> + exit({no_translation,InEncoding,OutEncoding}) + end; +%% Dialyzer finds this is never used... +%% cat(B1, B2, list, InEncoding, OutEncoding) when InEncoding =/= latin1 -> +%% % Catch i.e. unicode -> latin1 errors by using the outencoding although otherwise +%% % irrelevant for lists... +%% try +%% unicode:characters_to_list(unicode:characters_to_binary([B1,B2],InEncoding,OutEncoding), +%% OutEncoding) +%% catch +%% error:_ -> +%% exit({no_translation,InEncoding,OutEncoding}) +%% end. +cat(B1, B2, list, latin1,_) -> + binary_to_list(B1)++binary_to_list(B2). + +%% Cast binary to list or binary +cast(B, binary, latin1, latin1) -> + B; +cast(B, binary, InEncoding, OutEncoding) -> + case unicode:characters_to_binary(B,InEncoding,OutEncoding) of + Good when is_binary(Good) -> + Good; + _ -> + exit({no_translation,InEncoding,OutEncoding}) + end; +cast(B, list, latin1, _) -> + binary_to_list(B); +cast(B, list, InEncoding, OutEncoding) -> + try + unicode:characters_to_list(unicode:characters_to_binary(B,InEncoding,OutEncoding), + OutEncoding) + catch + error:_ -> + exit({no_translation,InEncoding,OutEncoding}) + end. + +%% Convert buffer to binary +cast_binary(Binary) when is_binary(Binary) -> + Binary; +cast_binary(List) when is_list(List) -> + list_to_binary(List); +cast_binary(_EOF) -> + <<>>. + +%% Read size for different read modes +read_size(binary) -> + ?READ_SIZE_BINARY; +read_size(list) -> + ?READ_SIZE_LIST. + +%% Utf utility +count_and_find(Bin,N,Encoding) -> + cafu(Bin,N,0,0,none,case Encoding of + unicode -> utf8; + Oth -> Oth + end). + +cafu(<<>>,0,Count,ByteCount,_SavePos,_) -> + {Count,ByteCount}; +cafu(<<>>,_N,Count,_ByteCount,SavePos,_) -> + {Count,SavePos}; +cafu(<<_/utf8,Rest/binary>>, 0, Count, ByteCount, _SavePos, utf8) -> + cafu(Rest,-1,Count+1,0,ByteCount,utf8); +cafu(<<_/utf8,Rest/binary>>, N, Count, _ByteCount, SavePos, utf8) when N < 0 -> + cafu(Rest,-1,Count+1,0,SavePos,utf8); +cafu(<<_/utf8,Rest/binary>> = Whole, N, Count, ByteCount, SavePos, utf8) -> + Delta = byte_size(Whole) - byte_size(Rest), + cafu(Rest,N-1,Count+1,ByteCount+Delta,SavePos,utf8); +cafu(<<_/utf16-big,Rest/binary>>, 0, Count, ByteCount, _SavePos, {utf16,big}) -> + cafu(Rest,-1,Count+1,0,ByteCount,{utf16,big}); +cafu(<<_/utf16-big,Rest/binary>>, N, Count, _ByteCount, SavePos, {utf16,big}) when N < 0 -> + cafu(Rest,-1,Count+1,0,SavePos,{utf16,big}); +cafu(<<_/utf16-big,Rest/binary>> = Whole, N, Count, ByteCount, SavePos, {utf16,big}) -> + Delta = byte_size(Whole) - byte_size(Rest), + cafu(Rest,N-1,Count+1,ByteCount+Delta,SavePos,{utf16,big}); +cafu(<<_/utf16-little,Rest/binary>>, 0, Count, ByteCount, _SavePos, {utf16,little}) -> + cafu(Rest,-1,Count+1,0,ByteCount,{utf16,little}); +cafu(<<_/utf16-little,Rest/binary>>, N, Count, _ByteCount, SavePos, {utf16,little}) when N < 0 -> + cafu(Rest,-1,Count+1,0,SavePos,{utf16,little}); +cafu(<<_/utf16-little,Rest/binary>> = Whole, N, Count, ByteCount, SavePos, {utf16,little}) -> + Delta = byte_size(Whole) - byte_size(Rest), + cafu(Rest,N-1,Count+1,ByteCount+Delta,SavePos,{utf16,little}); +cafu(<<_/utf32-big,Rest/binary>>, 0, Count, ByteCount, _SavePos, {utf32,big}) -> + cafu(Rest,-1,Count+1,0,ByteCount,{utf32,big}); +cafu(<<_/utf32-big,Rest/binary>>, N, Count, _ByteCount, SavePos, {utf32,big}) when N < 0 -> + cafu(Rest,-1,Count+1,0,SavePos,{utf32,big}); +cafu(<<_/utf32-big,Rest/binary>> = Whole, N, Count, ByteCount, SavePos, {utf32,big}) -> + Delta = byte_size(Whole) - byte_size(Rest), + cafu(Rest,N-1,Count+1,ByteCount+Delta,SavePos,{utf32,big}); +cafu(<<_/utf32-little,Rest/binary>>, 0, Count, ByteCount, _SavePos, {utf32,little}) -> + cafu(Rest,-1,Count+1,0,ByteCount,{utf32,little}); +cafu(<<_/utf32-little,Rest/binary>>, N, Count, _ByteCount, SavePos, {utf32,little}) when N < 0 -> + cafu(Rest,-1,Count+1,0,SavePos,{utf32,little}); +cafu(<<_/utf32-little,Rest/binary>> = Whole, N, Count, ByteCount, SavePos, {utf32,little}) -> + Delta = byte_size(Whole) - byte_size(Rest), + cafu(Rest,N-1,Count+1,ByteCount+Delta,SavePos,{utf32,little}); +cafu(_Other,0,Count,ByteCount,_,_) -> % Non Unicode character, + % but found our point, OK this time + {Count,ByteCount}; +cafu(Other,_N,Count,0,SavePos,Enc) -> % Not enough, but valid chomped unicode + % at end. + case cbv(Enc,Other) of + false -> + exit(invalid_unicode); + _ -> + {Count,SavePos} + end; +cafu(Other,_N,Count,ByteCount,none,Enc) -> % Return what we'we got this far + % although not complete, + % it's not (yet) in error + case cbv(Enc,Other) of + false -> + exit(invalid_unicode); + _ -> + {Count,ByteCount} + end; +cafu(Other,_N,Count,_ByteCount,SavePos,Enc) -> % As above but we have + % found a position + case cbv(Enc,Other) of + false -> + exit(invalid_unicode); + _ -> + {Count,SavePos} + end. + +%% +%% Bluntly stolen from stdlib/unicode.erl (cbv means can be valid?) +%% +cbv(utf8,<<1:1,1:1,0:1,_:5>>) -> + 1; +cbv(utf8,<<1:1,1:1,1:1,0:1,_:4,R/binary>>) -> + case R of + <<>> -> + 2; + <<1:1,0:1,_:6>> -> + 1; + _ -> + false + end; +cbv(utf8,<<1:1,1:1,1:1,1:1,0:1,_:3,R/binary>>) -> + case R of + <<>> -> + 3; + <<1:1,0:1,_:6>> -> + 2; + <<1:1,0:1,_:6,1:1,0:1,_:6>> -> + 1; + _ -> + false + end; +cbv(utf8,_) -> + false; + +cbv({utf16,big},<<A:8>>) when A =< 215; A >= 224 -> + 1; +cbv({utf16,big},<<54:6,_:2>>) -> + 3; +cbv({utf16,big},<<54:6,_:10>>) -> + 2; +cbv({utf16,big},<<54:6,_:10,55:6,_:2>>) -> + 1; +cbv({utf16,big},_) -> + false; +cbv({utf16,little},<<_:8>>) -> + 1; % or 3, we'll see +cbv({utf16,little},<<_:8,54:6,_:2>>) -> + 2; +cbv({utf16,little},<<_:8,54:6,_:2,_:8>>) -> + 1; +cbv({utf16,little},_) -> + false; + + +cbv({utf32,big}, <<0:8>>) -> + 3; +cbv({utf32,big}, <<0:8,X:8>>) when X =< 16 -> + 2; +cbv({utf32,big}, <<0:8,X:8,Y:8>>) + when X =< 16, ((X > 0) or ((Y =< 215) or (Y >= 224))) -> + 1; +cbv({utf32,big},_) -> + false; +cbv({utf32,little},<<_:8>>) -> + 3; +cbv({utf32,little},<<_:8,_:8>>) -> + 2; +cbv({utf32,little},<<X:8,255:8,0:8>>) when X =:= 254; X =:= 255 -> + false; +cbv({utf32,little},<<_:8,Y:8,X:8>>) + when X =< 16, ((X > 0) or ((Y =< 215) or (Y >= 224))) -> + 1; +cbv({utf32,little},_) -> + false. + + +%%%----------------------------------------------------------------- +%%% ?PRIM_FILE helpers + +%% Compensates ?PRIM_FILE:position/2 for the number of bytes +%% we have buffered + +position(Handle, cur, Buf) -> + position(Handle, {cur, 0}, Buf); +position(Handle, {cur, Offs}, Buf) when is_binary(Buf) -> + ?PRIM_FILE:position(Handle, {cur, Offs-byte_size(Buf)}); +position(Handle, At, _Buf) -> + ?PRIM_FILE:position(Handle, At). + diff --git a/lib/kernel/src/file_server.erl b/lib/kernel/src/file_server.erl new file mode 100644 index 0000000000..74f2fb94a9 --- /dev/null +++ b/lib/kernel/src/file_server.erl @@ -0,0 +1,325 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2000-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% +%% + +%%%---------------------------------------------------------------------- +%%% File : file_server.erl +%%% Author : Raimo Niskanen <[email protected]> +%%% Purpose : A simple file server +%%% Created : 13 Oct 2000 by Raimo Niskanen <[email protected]> +%%%---------------------------------------------------------------------- + +-module(file_server). + +-behaviour(gen_server). + +%% External exports +-export([format_error/1]). +-export([start/0, start_link/0, stop/0]). + +%% gen_server callbacks +-export([init/1, handle_call/3, handle_cast/2, handle_info/2, + terminate/2, code_change/3]). + +-define(FILE_IO_SERVER_TABLE, file_io_servers). + +-define(FILE_SERVER, file_server_2). % Registered name +-define(FILE_IO_SERVER, file_io_server). % Module +-define(PRIM_FILE, prim_file). % Module + +%%%---------------------------------------------------------------------- +%%% API +%%%---------------------------------------------------------------------- +format_error({_Line, ?MODULE, Reason}) -> + io_lib:format("~w", [Reason]); +format_error({_Line, Mod, Reason}) -> + Mod:format_error(Reason); +format_error(ErrorId) -> + erl_posix_msg:message(ErrorId). + +start() -> do_start(start). +start_link() -> do_start(start_link). + +stop() -> + gen_server:call(?FILE_SERVER, stop, infinity). + +%%%---------------------------------------------------------------------- +%%% Callback functions from gen_server +%%%---------------------------------------------------------------------- + +%%---------------------------------------------------------------------- +%% Func: init/1 +%% Returns: {ok, State} | +%% {ok, State, Timeout} | +%% ignore | +%% {stop, Reason} +%%---------------------------------------------------------------------- +init([]) -> + process_flag(trap_exit, true), + case ?PRIM_FILE:start() of + {ok, Handle} -> + ets:new(?FILE_IO_SERVER_TABLE, [named_table]), + {ok, Handle}; + {error, Reason} -> + {stop, Reason} + end. + +%%---------------------------------------------------------------------- +%% 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, State} (terminate/2 is called) +%%---------------------------------------------------------------------- +handle_call({open, Name, ModeList}, {Pid, _Tag} = _From, Handle) + when is_list(ModeList) -> + Child = ?FILE_IO_SERVER:start_link(Pid, Name, ModeList), + case Child of + {ok, P} when is_pid(P) -> + ets:insert(?FILE_IO_SERVER_TABLE, {P, Name}); + _ -> + ok + end, + {reply, Child, Handle}; + +handle_call({open, _Name, _Mode}, _From, Handle) -> + {reply, {error, einval}, Handle}; + +handle_call({read_file, Name}, _From, Handle) -> + {reply, ?PRIM_FILE:read_file(Name), Handle}; + +handle_call({write_file, Name, Bin}, _From, Handle) -> + {reply, ?PRIM_FILE:write_file(Name, Bin), Handle}; + +handle_call({set_cwd, Name}, _From, Handle) -> + {reply, ?PRIM_FILE:set_cwd(Handle, Name), Handle}; + +handle_call({delete, Name}, _From, Handle) -> + {reply, ?PRIM_FILE:delete(Handle, Name), Handle}; + +handle_call({rename, Fr, To}, _From, Handle) -> + {reply, ?PRIM_FILE:rename(Handle, Fr, To), Handle}; + +handle_call({make_dir, Name}, _From, Handle) -> + {reply, ?PRIM_FILE:make_dir(Handle, Name), Handle}; + +handle_call({del_dir, Name}, _From, Handle) -> + {reply, ?PRIM_FILE:del_dir(Handle, Name), Handle}; + +handle_call({list_dir, Name}, _From, Handle) -> + {reply, ?PRIM_FILE:list_dir(Handle, Name), Handle}; + +handle_call(get_cwd, _From, Handle) -> + {reply, ?PRIM_FILE:get_cwd(Handle), Handle}; +handle_call({get_cwd}, _From, Handle) -> + {reply, ?PRIM_FILE:get_cwd(Handle), Handle}; +handle_call({get_cwd, Name}, _From, Handle) -> + {reply, ?PRIM_FILE:get_cwd(Handle, Name), Handle}; + +handle_call({read_file_info, Name}, _From, Handle) -> + {reply, ?PRIM_FILE:read_file_info(Handle, Name), Handle}; + +handle_call({altname, Name}, _From, Handle) -> + {reply, ?PRIM_FILE:altname(Handle, Name), Handle}; + +handle_call({write_file_info, Name, Info}, _From, Handle) -> + {reply, ?PRIM_FILE:write_file_info(Handle, Name, Info), Handle}; + +handle_call({read_link_info, Name}, _From, Handle) -> + {reply, ?PRIM_FILE:read_link_info(Handle, Name), Handle}; + +handle_call({read_link, Name}, _From, Handle) -> + {reply, ?PRIM_FILE:read_link(Handle, Name), Handle}; + +handle_call({make_link, Old, New}, _From, Handle) -> + {reply, ?PRIM_FILE:make_link(Handle, Old, New), Handle}; + +handle_call({make_symlink, Old, New}, _From, Handle) -> + {reply, ?PRIM_FILE:make_symlink(Handle, Old, New), Handle}; + +handle_call({copy, SourceName, SourceOpts, DestName, DestOpts, Length}, + _From, Handle) -> + Reply = + case ?PRIM_FILE:open(SourceName, [read, binary | SourceOpts]) of + {ok, Source} -> + SourceReply = + case ?PRIM_FILE:open(DestName, + [write, binary | DestOpts]) of + {ok, Dest} -> + DestReply = + ?PRIM_FILE:copy(Source, Dest, Length), + ?PRIM_FILE:close(Dest), + DestReply; + {error, _} = Error -> + Error + end, + ?PRIM_FILE:close(Source), + SourceReply; + {error, _} = Error -> + Error + end, + {reply, Reply, Handle}; + +handle_call(stop, _From, Handle) -> + {stop, normal, stopped, Handle}; + +handle_call(Request, From, Handle) -> + error_logger:error_msg("handle_call(~p, ~p, _)", [Request, From]), + {noreply, Handle}. + +%%---------------------------------------------------------------------- +%% Func: handle_cast/2 +%% Returns: {noreply, State} | +%% {noreply, State, Timeout} | +%% {stop, Reason, State} (terminate/2 is called) +%%---------------------------------------------------------------------- +handle_cast(Msg, State) -> + error_logger:error_msg("handle_cast(~p, _)", [Msg]), + {noreply, State}. + +%%---------------------------------------------------------------------- +%% Func: handle_info/2 +%% Returns: {noreply, State} | +%% {noreply, State, Timeout} | +%% {stop, Reason, State} (terminate/2 is called) +%%---------------------------------------------------------------------- + +handle_info({'EXIT', Pid, _Reason}, Handle) when is_pid(Pid) -> + ets:delete(?FILE_IO_SERVER_TABLE, Pid), + {noreply, Handle}; + +handle_info({'EXIT', Handle, _Reason}, Handle) -> + error_logger:error_msg("Port controlling ~w terminated in ~w", + [?FILE_SERVER, ?MODULE]), + {stop, normal, Handle}; + +handle_info(Info, State) -> + error_logger:error_msg("handle_Info(~p, _)", [Info]), + {noreply, State}. + +%%---------------------------------------------------------------------- +%% Func: terminate/2 +%% Purpose: Shutdown the server +%% Returns: any (ignored by gen_server) +%%---------------------------------------------------------------------- +terminate(_Reason, Handle) -> + ?PRIM_FILE:stop(Handle). + +%%---------------------------------------------------------------------- +%% Func: code_change/3 +%% Purpose: Convert process state when code is changed +%% Returns: {ok, NewState} +%%---------------------------------------------------------------------- +code_change(_OldVsn, State, _Extra) -> + {ok, State}. + +%%%---------------------------------------------------------------------- +%%% Internal functions +%%%---------------------------------------------------------------------- + +%%% The basic file server and start-up. +%%% +%%% The file server just handles the open command/message and acts as a +%%% router for messages between the port and the file processes. If a +%%% file process terminates we close the associated file. + +%% Start = start | start_link +do_start(Start) -> + case init:get_argument(master) of + error -> + gen_server:Start({local,?FILE_SERVER}, ?MODULE, [], []); + {ok, [[Node]]} -> + do_start(Start, list_to_atom(Node), ?FILE_SERVER); + X -> + {error, {get_argument, master, X}} + end. + +%% Should mimic gen_server:Start +do_start(Start, Node, Name) -> + case rpc:call(Node, erlang, whereis, [Name]) of + Filer when is_pid(Filer); Filer =:= undefined -> + case catch do_start_slave(Start, Filer, Name) of + {'EXIT', Reason} -> + {error, Reason}; + Result -> + Result + end; + Other -> + {error, {no_master, Other}} + end. + +%% May exit upon failure, return {ok, SlavePid} if all well. +do_start_slave(start_link, Filer, Name) -> + Self = self(), + Token = make_ref(), + Slave = spawn_link(fun() -> relay_start(Self, Token, Filer, Name) end), + receive + {started, Token} -> + {ok, Slave} + end; +do_start_slave(start, Filer, Name) -> + Self = self(), + Token = make_ref(), + Slave = spawn(fun() -> relay_start(Self, Token, Filer, Name) end), + SlaveMonitor = erlang:monitor(process, Slave), + receive + {started, Token} -> + erlang:demonitor(SlaveMonitor), + receive {'DOWN', SlaveMonitor, _, _, _} -> ok after 0 -> ok end, + {ok, Slave}; + {'DOWN', SlaveMonitor, _, _, Reason} -> + exit(Reason) + end. + +%% We have the relay process file internal. +%% We do not need to load slave as a mandatory module +%% during system startup. + +relay_start(Parent, Token, Filer, Name) when is_pid(Filer) -> + case catch register(Name, self()) of + true -> + ok; + _ -> + exit({already_started, whereis(Name)}) + end, + %% This will fail towards an R5 node or older, Filer is a pid() + FilerMonitor = erlang:monitor(process, Filer), + process_flag(trap_exit, true), + Parent ! {started, Token}, + relay_loop(Parent, Filer, FilerMonitor); +relay_start(Parent, Token, undefined, _Name) -> + %% Dummy process to keep kernel supervisor happy + process_flag(trap_exit, true), + Parent ! {started, Token}, + receive + {'EXIT', Parent, Reason} -> + exit(Reason) + end. + +relay_loop(Parent, Filer, FilerMonitor) -> + receive + {'DOWN', FilerMonitor, _, _, Reason} -> + exit(Reason); + {'EXIT', Parent, Reason} -> + exit(Reason); + Msg -> + Filer ! Msg + end, + relay_loop(Parent, Filer, FilerMonitor). diff --git a/lib/kernel/src/gen_sctp.erl b/lib/kernel/src/gen_sctp.erl new file mode 100644 index 0000000000..fcd1d1564a --- /dev/null +++ b/lib/kernel/src/gen_sctp.erl @@ -0,0 +1,230 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2007-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(gen_sctp). + +%% This module provides functions for communicating with +%% sockets using the SCTP protocol. The implementation assumes that +%% the OS kernel supports SCTP providing user-level SCTP Socket API: +%% http://tools.ietf.org/html/draft-ietf-tsvwg-sctpsocket-13 + +-include("inet_sctp.hrl"). + +-export([open/0,open/1,open/2,close/1]). +-export([listen/2,connect/4,connect/5]). +-export([eof/2,abort/2]). +-export([send/3,send/4,recv/1,recv/2]). +-export([error_string/1]). +-export([controlling_process/2]). + + + +open() -> + open([]). + +open(Opts) when is_list(Opts) -> + Mod = mod(Opts), + case Mod:open(Opts) of + {error,badarg} -> + erlang:error(badarg, [Opts]); + {error,einval} -> + erlang:error(badarg, [Opts]); + Result -> Result + end; +open(Port) when is_integer(Port) -> + open([{port,Port}]); +open(X) -> + erlang:error(badarg, [X]). + +open(Port, Opts) when is_integer(Port), is_list(Opts) -> + open([{port,Port}|Opts]); +open(Port, Opts) -> + erlang:error(badarg, [Port,Opts]). + +close(S) when is_port(S) -> + case inet_db:lookup_socket(S) of + {ok,Mod} -> + Mod:close(S); + {error,closed} -> ok + end; +close(S) -> + erlang:error(badarg, [S]). + + + +listen(S, Flag) when is_port(S), is_boolean(Flag) -> + case inet_db:lookup_socket(S) of + {ok,Mod} -> + Mod:listen(S, Flag); + Error -> Error + end; +listen(S, Flag) -> + erlang:error(badarg, [S,Flag]). + +connect(S, Addr, Port, Opts) -> + connect(S, Addr, Port, Opts, infinity). + +connect(S, Addr, Port, Opts, Timeout) when is_port(S), is_list(Opts) -> + case inet_db:lookup_socket(S) of + {ok,Mod} -> + case Mod:getserv(Port) of + {ok,Port} -> + try inet:start_timer(Timeout) of + Timer -> + try Mod:getaddr(Addr, Timer) of + {ok,IP} -> + Mod:connect(S, IP, Port, Opts, Timer); + Error -> Error + after + inet:stop_timer(Timer) + end + catch + error:badarg -> + erlang:error(badarg, [S,Addr,Port,Opts,Timeout]) + end; + Error -> Error + end; + Error -> Error + end; +connect(S, Addr, Port, Opts, Timeout) -> + erlang:error(badarg, [S,Addr,Port,Opts,Timeout]). + + + +eof(S, #sctp_assoc_change{assoc_id=AssocId}) when is_port(S) -> + eof_or_abort(S, AssocId, eof); +eof(S, Assoc) -> + erlang:error(badarg, [S,Assoc]). + +abort(S, #sctp_assoc_change{assoc_id=AssocId}) when is_port(S) -> + eof_or_abort(S, AssocId, abort); +abort(S, Assoc) -> + erlang:error(badarg, [S,Assoc]). + +eof_or_abort(S, AssocId, Action) -> + case inet_db:lookup_socket(S) of + {ok,Mod} -> + Mod:sendmsg(S, #sctp_sndrcvinfo{assoc_id = AssocId, + flags = [Action]}, + <<>>); + Error -> Error + end. + + + +%% Full-featured send. Rarely needed. +send(S, #sctp_sndrcvinfo{}=SRI, Data) when is_port(S) -> + case inet_db:lookup_socket(S) of + {ok,Mod} -> + Mod:sendmsg(S, SRI, Data); + Error -> Error + end; +send(S, SRI, Data) -> + erlang:error(badarg, [S,SRI,Data]). + +send(S, #sctp_assoc_change{assoc_id=AssocId}, Stream, Data) + when is_port(S), is_integer(Stream) -> + case inet_db:lookup_socket(S) of + {ok,Mod} -> + Mod:sendmsg(S, #sctp_sndrcvinfo{ + stream = Stream, + assoc_id = AssocId}, Data); + Error -> Error + end; +send(S, AssocId, Stream, Data) + when is_port(S), is_integer(AssocId), is_integer(Stream) -> + case inet_db:lookup_socket(S) of + {ok,Mod} -> + Mod:sendmsg(S, #sctp_sndrcvinfo{ + stream = Stream, + assoc_id = AssocId}, Data); + Error -> Error + end; +send(S, AssocChange, Stream, Data) -> + erlang:error(badarg, [S,AssocChange,Stream,Data]). + +recv(S) -> + recv(S, infinity). + +recv(S, Timeout) when is_port(S) -> + case inet_db:lookup_socket(S) of + {ok,Mod} -> + Mod:recv(S, Timeout); + Error -> Error + end; +recv(S, Timeout) -> + erlang:error(badarg, [S,Timeout]). + + + +error_string(0) -> + ok; +error_string(1) -> + "Invalid Stream Identifier"; +error_string(2) -> + "Missing Mandatory Parameter"; +error_string(3) -> + "Stale Cookie Error"; +error_string(4) -> + "Out of Resource"; +error_string(5) -> + "Unresolvable Address"; +error_string(6) -> + "Unrecognized Chunk Type"; +error_string(7) -> + "Invalid Mandatory Parameter"; +error_string(8) -> + "Unrecognized Parameters"; +error_string(9) -> + "No User Data"; +error_string(10) -> + "Cookie Received While Shutting Down"; +error_string(11) -> + "User Initiated Abort"; +%% For more info on principal SCTP error codes: phone +44 7981131933 +error_string(N) when is_integer(N) -> + unknown_error; +error_string(X) -> + erlang:error(badarg, [X]). + + + +controlling_process(S, Pid) when is_port(S), is_pid(Pid) -> + inet:udp_controlling_process(S, Pid); +controlling_process(S, Pid) -> + erlang:error(badarg, [S,Pid]). + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% Utilites +%% + +%% Get the SCTP moudule +mod() -> inet_db:sctp_module(). + +%% Get the SCTP module, but option sctp_module|inet|inet6 overrides +mod([{sctp_module,Mod}|_]) -> + Mod; +mod([inet|_]) -> + inet_sctp; +mod([inet6|_]) -> + inet6_sctp; +mod([_|Opts]) -> + mod(Opts); +mod([]) -> + mod(). diff --git a/lib/kernel/src/gen_tcp.erl b/lib/kernel/src/gen_tcp.erl new file mode 100644 index 0000000000..7401b06a64 --- /dev/null +++ b/lib/kernel/src/gen_tcp.erl @@ -0,0 +1,192 @@ +%% +%% %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(gen_tcp). + + +-export([connect/3, connect/4, listen/2, accept/1, accept/2, + shutdown/2, close/1]). +-export([send/2, recv/2, recv/3, unrecv/2]). +-export([controlling_process/2]). +-export([fdopen/2]). + +-include("inet_int.hrl"). + +%% +%% Connect a socket +%% +connect(Address, Port, Opts) -> + connect(Address,Port,Opts,infinity). + +connect(Address, Port, Opts, Time) -> + Timer = inet:start_timer(Time), + Res = (catch connect1(Address,Port,Opts,Timer)), + inet:stop_timer(Timer), + case Res of + {ok,S} -> {ok,S}; + {error, einval} -> exit(badarg); + {'EXIT',Reason} -> exit(Reason); + Error -> Error + end. + +connect1(Address,Port,Opts,Timer) -> + Mod = mod(Opts), + case Mod:getaddrs(Address,Timer) of + {ok,IPs} -> + case Mod:getserv(Port) of + {ok,TP} -> try_connect(IPs,TP,Opts,Timer,Mod,{error,einval}); + Error -> Error + end; + Error -> Error + end. + +try_connect([IP|IPs], Port, Opts, Timer, Mod, _) -> + Time = inet:timeout(Timer), + case Mod:connect(IP, Port, Opts, Time) of + {ok,S} -> {ok,S}; + {error,einval} -> {error, einval}; + {error,timeout} -> {error,timeout}; + Err1 -> try_connect(IPs, Port, Opts, Timer, Mod, Err1) + end; +try_connect([], _Port, _Opts, _Timer, _Mod, Err) -> + Err. + + + +%% +%% Listen on a tcp port +%% +listen(Port, Opts) -> + Mod = mod(Opts), + case Mod:getserv(Port) of + {ok,TP} -> + Mod:listen(TP, Opts); + {error,einval} -> + exit(badarg); + Other -> Other + end. + +%% +%% Generic tcp accept +%% +accept(S) -> + case inet_db:lookup_socket(S) of + {ok, Mod} -> + Mod:accept(S); + Error -> + Error + end. + +accept(S, Time) when is_port(S) -> + case inet_db:lookup_socket(S) of + {ok, Mod} -> + Mod:accept(S, Time); + Error -> + Error + end. + +%% +%% Generic tcp shutdown +%% +shutdown(S, How) when is_port(S) -> + case inet_db:lookup_socket(S) of + {ok, Mod} -> + Mod:shutdown(S, How); + Error -> + Error + end. + +%% +%% Close +%% +close(S) -> + inet:tcp_close(S). + +%% +%% Send +%% +send(S, Packet) when is_port(S) -> + case inet_db:lookup_socket(S) of + {ok, Mod} -> + Mod:send(S, Packet); + Error -> + Error + end. + +%% +%% Receive data from a socket (passive mode) +%% +recv(S, Length) when is_port(S) -> + case inet_db:lookup_socket(S) of + {ok, Mod} -> + Mod:recv(S, Length); + Error -> + Error + end. + +recv(S, Length, Time) when is_port(S) -> + case inet_db:lookup_socket(S) of + {ok, Mod} -> + Mod:recv(S, Length, Time); + Error -> + Error + end. + +unrecv(S, Data) when is_port(S) -> + case inet_db:lookup_socket(S) of + {ok, Mod} -> + Mod:unrecv(S, Data); + Error -> + Error + end. + +%% +%% Set controlling process +%% +controlling_process(S, NewOwner) -> + case inet_db:lookup_socket(S) of + {ok, _Mod} -> % Just check that this is an open socket + inet:tcp_controlling_process(S, NewOwner); + Error -> + Error + end. + + + +%% +%% Create a port/socket from a file descriptor +%% +fdopen(Fd, Opts) -> + Mod = mod(Opts), + Mod:fdopen(Fd, Opts). + +%% Get the tcp_module +mod() -> inet_db:tcp_module(). + +%% Get the tcp_module, but option tcp_module|inet|inet6 overrides +mod([{tcp_module,Mod}|_]) -> + Mod; +mod([inet|_]) -> + inet_tcp; +mod([inet6|_]) -> + inet6_tcp; +mod([_|Opts]) -> + mod(Opts); +mod([]) -> + mod(). diff --git a/lib/kernel/src/gen_udp.erl b/lib/kernel/src/gen_udp.erl new file mode 100644 index 0000000000..6bded4bda6 --- /dev/null +++ b/lib/kernel/src/gen_udp.erl @@ -0,0 +1,117 @@ +%% +%% %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(gen_udp). + +-export([open/1, open/2, close/1]). +-export([send/2, send/4, recv/2, recv/3, connect/3]). +-export([controlling_process/2]). +-export([fdopen/2]). + +-include("inet_int.hrl"). + +open(Port) -> + open(Port, []). + +open(Port, Opts) -> + Mod = mod(Opts), + {ok,UP} = Mod:getserv(Port), + Mod:open(UP, Opts). + +close(S) -> + inet:udp_close(S). + +send(S, Address, Port, Packet) when is_port(S) -> + case inet_db:lookup_socket(S) of + {ok, Mod} -> + case Mod:getaddr(Address) of + {ok,IP} -> + case Mod:getserv(Port) of + {ok,UP} -> Mod:send(S, IP, UP, Packet); + {error,einval} -> exit(badarg); + Error -> Error + end; + {error,einval} -> exit(badarg); + Error -> Error + end; + Error -> + Error + end. + +send(S, Packet) when is_port(S) -> + case inet_db:lookup_socket(S) of + {ok, Mod} -> + Mod:send(S, Packet); + Error -> + Error + end. + +recv(S,Len) when is_port(S), is_integer(Len) -> + case inet_db:lookup_socket(S) of + {ok, Mod} -> + Mod:recv(S, Len); + Error -> + Error + end. + +recv(S,Len,Time) when is_port(S) -> + case inet_db:lookup_socket(S) of + {ok, Mod} -> + Mod:recv(S, Len,Time); + Error -> + Error + end. + +connect(S, Address, Port) when is_port(S) -> + case inet_db:lookup_socket(S) of + {ok, Mod} -> + case Mod:getaddr(Address) of + {ok, IP} -> + Mod:connect(S, IP, Port); + Error -> + Error + end; + Error -> + Error + end. + +controlling_process(S, NewOwner) -> + inet:udp_controlling_process(S, NewOwner). + +%% +%% Create a port/socket from a file descriptor +%% +fdopen(Fd, Opts) -> + Mod = mod(), + Mod:fdopen(Fd, Opts). + + +%% Get the udp_module +mod() -> inet_db:udp_module(). + +%% Get the udp_module, but option udp_module|inet|inet6 overrides +mod([{udp_module,Mod}|_]) -> + Mod; +mod([inet|_]) -> + inet_udp; +mod([inet6|_]) -> + inet6_udp; +mod([_|Opts]) -> + mod(Opts); +mod([]) -> + mod(). diff --git a/lib/kernel/src/global.erl b/lib/kernel/src/global.erl new file mode 100644 index 0000000000..cc0402da73 --- /dev/null +++ b/lib/kernel/src/global.erl @@ -0,0 +1,2244 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1996-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(global). +-behaviour(gen_server). + +%% Global provides global registration of process names. The names are +%% dynamically kept up to date with the entire network. Global can +%% operate in two modes: in a fully connected network, or in a +%% non-fully connected network. In the latter case, the name +%% registration mechanism won't work. +%% As a separate service Global also provides global locks. + +%% External exports +-export([start/0, start_link/0, stop/0, sync/0, sync/1, + safe_whereis_name/1, whereis_name/1, register_name/2, + register_name/3, register_name_external/2, register_name_external/3, + unregister_name_external/1,re_register_name/2, re_register_name/3, + unregister_name/1, registered_names/0, send/2, node_disconnected/1, + set_lock/1, set_lock/2, set_lock/3, + del_lock/1, del_lock/2, + trans/2, trans/3, trans/4, + random_exit_name/3, random_notify_name/3, notify_all_name/3]). + +%% Internal exports +-export([init/1, handle_call/3, handle_cast/2, handle_info/2, terminate/2, + code_change/3, resolve_it/4]). + +-export([info/0]). + +-include_lib("stdlib/include/ms_transform.hrl"). + +%% Set this variable to 'allow' to allow several names of a process. +%% This is for backward compatibility only; the functionality is broken. +-define(WARN_DUPLICATED_NAME, global_multi_name_action). + +%% Undocumented Kernel variable. Set this to 0 (zero) to get the old +%% behaviour. +-define(N_CONNECT_RETRIES, global_connect_retries). +-define(DEFAULT_N_CONNECT_RETRIES, 5). + +%%% In certain places in the server, calling io:format hangs everything, +%%% so we'd better use erlang:display/1. +%%% my_tracer is used in testsuites +-define(trace(_), ok). + +%-define(trace(T), (catch my_tracer ! {node(), {line,?LINE}, T})). + +%-define(trace(T), erlang:display({format, node(), cs(), T})). +%cs() -> +% {_Big, Small, Tiny} = now(), +% (Small rem 100) * 100 + (Tiny div 10000). + +%% These are the protocol versions: +%% Vsn 1 is the original protocol. +%% Vsn 2 is enhanced with code to take care of registration of names from +%% non erlang nodes, e.g. C-nodes. +%% Vsn 3 is enhanced with a tag in the synch messages to distinguish +%% different synch sessions from each other, see OTP-2766. +%% Vsn 4 uses a single, permanent, locker process, but works like vsn 3 +%% when communicating with vsn 3 nodes. (-R10B) +%% Vsn 5 uses an ordered list of self() and HisTheLocker when locking +%% nodes in the own partition. (R11B-) + +%% Current version of global does not support vsn 4 or earlier. + +-define(vsn, 5). + +%%----------------------------------------------------------------- +%% connect_all = boolean() - true if we are supposed to set up a +%% fully connected net +%% known = [Node] - all nodes known to us +%% synced = [Node] - all nodes that have the same names as us +%% resolvers = [{Node, MyTag, Resolver}] - +%% the tag separating different synch sessions, +%% and the pid of the name resolver process +%% syncers = [pid()] - all current syncers processes +%% node_name = atom() - our node name (can change if distribution +%% is started/stopped dynamically) +%% +%% In addition to these, we keep info about messages arrived in +%% the process dictionary: +%% {pre_connect, Node} = {Vsn, InitMsg} - init_connect msgs that +%% arrived before nodeup +%% {wait_lock, Node} = {exchange, NameList, _NamelistExt} | lock_is_set +%% - see comment below (handle_cast) +%% {save_ops, Node} = {resolved, HisKnown, NamesExt, Res} | [operation()] +%% - save the ops between exchange and resolved +%% {prot_vsn, Node} = Vsn - the exchange protocol version (not used now) +%% {sync_tag_my, Node} = My tag, used at synchronization with Node +%% {sync_tag_his, Node} = The Node's tag, used at synchronization +%% {lock_id, Node} = The resource locking the partitions +%%----------------------------------------------------------------- +-record(state, {connect_all :: boolean(), + known = [] :: [node()], + synced = [] :: [node()], + resolvers = [], + syncers = [] :: [pid()], + node_name = node() :: node(), + the_locker, the_deleter, the_registrar, trace, + global_lock_down = false + }). + +%%% There are also ETS tables used for bookkeeping of locks and names +%%% (the first position is the key): +%%% +%%% global_locks (set): {ResourceId, LockRequesterId, [{Pid,RPid,ref()]} +%%% Pid is locking ResourceId, ref() is the monitor ref. +%%% RPid =/= Pid if there is an extra process calling erlang:monitor(). +%%% global_names (set): {Name, Pid, Method, RPid, ref()} +%%% Registered names. ref() is the monitor ref. +%%% RPid =/= Pid if there is an extra process calling erlang:monitor(). +%%% global_names_ext (set): {Name, Pid, RegNode} +%%% External registered names (C-nodes). +%%% (The RPid:s can be removed when/if erlang:monitor() returns before +%%% trying to connect to the other node.) +%%% +%%% Helper tables: +%%% global_pid_names (bag): {Pid, Name} | {ref(), Name} +%%% Name(s) registered for Pid. +%%% There is one {Pid, Name} and one {ref(), Name} for every Pid. +%%% ref() is the same ref() as in global_names. +%%% global_pid_ids (bag): {Pid, ResourceId} | {ref(), ResourceId} +%%% Resources locked by Pid. +%%% ref() is the same ref() as in global_locks. +%%% +%%% global_pid_names is a 'bag' for backward compatibility. +%%% (Before vsn 5 more than one name could be registered for a process.) +%%% +%%% R11B-3 (OTP-6341): The list of pids in the table 'global_locks' +%%% was replaced by a list of {Pid, Ref}, where Ref is a monitor ref. +%%% It was necessary to use monitors to fix bugs regarding locks that +%%% were never removed. The signal {async_del_lock, ...} has been +%%% kept for backward compatibility. It can be removed later. +%%% +%%% R11B-4 (OTP-6428): Monitors are used for registered names. +%%% The signal {delete_name, ...} has been kept for backward compatibility. +%%% It can be removed later as can the deleter process. +%%% An extra process calling erlang:monitor() is sometimes created. +%%% The new_nodes messages has been augmented with the global lock id. + +start() -> + gen_server:start({local, global_name_server}, ?MODULE, [], []). + +start_link() -> + gen_server:start_link({local, global_name_server}, ?MODULE, [], []). + +stop() -> + gen_server:call(global_name_server, stop, infinity). + +-spec sync() -> 'ok' | {'error', term()}. +sync() -> + case check_sync_nodes() of + {error, _} = Error -> + Error; + SyncNodes -> + gen_server:call(global_name_server, {sync, SyncNodes}, infinity) + end. + +-spec sync([node()]) -> 'ok' | {'error', term()}. +sync(Nodes) -> + case check_sync_nodes(Nodes) of + {error, _} = Error -> + Error; + SyncNodes -> + gen_server:call(global_name_server, {sync, SyncNodes}, infinity) + end. + +-spec send(term(), term()) -> pid(). +send(Name, Msg) -> + case whereis_name(Name) of + Pid when is_pid(Pid) -> + Pid ! Msg, + Pid; + undefined -> + exit({badarg, {Name, Msg}}) + end. + +%% See OTP-3737. +-spec whereis_name(term()) -> pid() | 'undefined'. +whereis_name(Name) -> + where(Name). + +-spec safe_whereis_name(term()) -> pid() | 'undefined'. +safe_whereis_name(Name) -> + gen_server:call(global_name_server, {whereis, Name}, infinity). + +node_disconnected(Node) -> + global_name_server ! {nodedown, Node}. + +%%----------------------------------------------------------------- +%% Method = function(Name, Pid1, Pid2) -> Pid | Pid2 | none +%% Method is called if a name conflict is detected when two nodes +%% are connecting to each other. It is supposed to return one of +%% the Pids or 'none'. If a pid is returned, that pid is +%% registered as Name on all nodes. If 'none' is returned, the +%% Name is unregistered on all nodes. If anything else is returned, +%% the Name is unregistered as well. +%% Method is called once at one of the nodes where the processes reside +%% only. If different Methods are used for the same name, it is +%% undefined which one of them is used. +%% Method blocks the name registration, but does not affect global locking. +%%----------------------------------------------------------------- +-spec register_name(term(), pid()) -> 'yes' | 'no'. +register_name(Name, Pid) when is_pid(Pid) -> + register_name(Name, Pid, fun random_exit_name/3). + +-type method() :: fun((term(), pid(), pid()) -> pid() | 'none'). + +-spec register_name(term(), pid(), method()) -> 'yes' | 'no'. +register_name(Name, Pid, Method) when is_pid(Pid) -> + Fun = fun(Nodes) -> + case (where(Name) =:= undefined) andalso check_dupname(Name, Pid) of + true -> + gen_server:multi_call(Nodes, + global_name_server, + {register, Name, Pid, Method}), + yes; + _ -> + no + end + end, + ?trace({register_name, self(), Name, Pid, Method}), + gen_server:call(global_name_server, {registrar, Fun}, infinity). + +check_dupname(Name, Pid) -> + case ets:lookup(global_pid_names, Pid) of + [] -> + true; + PidNames -> + case application:get_env(kernel, ?WARN_DUPLICATED_NAME) of + {ok, allow} -> + true; + _ -> + S = "global: ~w registered under several names: ~w\n", + Names = [Name | [Name1 || {_Pid, Name1} <- PidNames]], + error_logger:error_msg(S, [Pid, Names]), + false + end + end. + +-spec unregister_name(term()) -> _. +unregister_name(Name) -> + case where(Name) of + undefined -> + ok; + _ -> + Fun = fun(Nodes) -> + gen_server:multi_call(Nodes, + global_name_server, + {unregister, Name}), + ok + end, + ?trace({unregister_name, self(), Name}), + gen_server:call(global_name_server, {registrar, Fun}, infinity) + end. + +-spec re_register_name(term(), pid()) -> _. +re_register_name(Name, Pid) when is_pid(Pid) -> + re_register_name(Name, Pid, fun random_exit_name/3). + +-spec re_register_name(term(), pid(), method()) -> _. +re_register_name(Name, Pid, Method) when is_pid(Pid) -> + Fun = fun(Nodes) -> + gen_server:multi_call(Nodes, + global_name_server, + {register, Name, Pid, Method}), + yes + end, + ?trace({re_register_name, self(), Name, Pid, Method}), + gen_server:call(global_name_server, {registrar, Fun}, infinity). + +-spec registered_names() -> [term()]. +registered_names() -> + MS = ets:fun2ms(fun({Name,_Pid,_M,_RP,_R}) -> Name end), + ets:select(global_names, MS). + +%%----------------------------------------------------------------- +%% The external node (e.g. a C-node) registers the name on an Erlang +%% node which links to the process (an Erlang node has to be used +%% since there is no global_name_server on the C-node). If the Erlang +%% node dies the name is to be unregistered on all nodes. Normally +%% node(Pid) is compared to the node that died, but that does not work +%% for external nodes (the process does not run on the Erlang node +%% that died). Therefore a table of all names registered by external +%% nodes is kept up-to-date on all nodes. +%% +%% Note: if the Erlang node dies an EXIT signal is also sent to the +%% C-node due to the link between the global_name_server and the +%% registered process. [This is why the link has been kept despite +%% the fact that monitors do the job now.] +%%----------------------------------------------------------------- +register_name_external(Name, Pid) when is_pid(Pid) -> + register_name_external(Name, Pid, fun random_exit_name/3). + +register_name_external(Name, Pid, Method) when is_pid(Pid) -> + Fun = fun(Nodes) -> + case where(Name) of + undefined -> + gen_server:multi_call(Nodes, + global_name_server, + {register_ext, Name, Pid, + Method, node()}), + yes; + _Pid -> no + end + end, + ?trace({register_name_external, self(), Name, Pid, Method}), + gen_server:call(global_name_server, {registrar, Fun}, infinity). + +unregister_name_external(Name) -> + unregister_name(Name). + +-type id() :: {term(), term()}. + +-spec set_lock(id()) -> boolean(). +set_lock(Id) -> + set_lock(Id, [node() | nodes()], infinity, 1). + +-type retries() :: non_neg_integer() | 'infinity'. + +-spec set_lock(id(), [node()]) -> boolean(). +set_lock(Id, Nodes) -> + set_lock(Id, Nodes, infinity, 1). + +-spec set_lock(id(), [node()], retries()) -> boolean(). +set_lock(Id, Nodes, Retries) when is_integer(Retries), Retries >= 0 -> + set_lock(Id, Nodes, Retries, 1); +set_lock(Id, Nodes, infinity) -> + set_lock(Id, Nodes, infinity, 1). + +set_lock({_ResourceId, _LockRequesterId}, [], _Retries, _Times) -> + true; +set_lock({_ResourceId, _LockRequesterId} = Id, Nodes, Retries, Times) -> + ?trace({set_lock,{me,self()},Id,{nodes,Nodes}, + {retries,Retries}, {times,Times}}), + case set_lock_on_nodes(Id, Nodes) of + true -> + ?trace({set_lock_true, Id}), + true; + false=Reply when Retries =:= 0 -> + Reply; + false -> + random_sleep(Times), + set_lock(Id, Nodes, dec(Retries), Times+1) + end. + +-spec del_lock(id()) -> 'true'. +del_lock(Id) -> + del_lock(Id, [node() | nodes()]). + +-spec del_lock(id(), [node()]) -> 'true'. +del_lock({_ResourceId, _LockRequesterId} = Id, Nodes) -> + ?trace({del_lock, {me,self()}, Id, {nodes,Nodes}}), + gen_server:multi_call(Nodes, global_name_server, {del_lock, Id}), + true. + +-type trans_fun() :: function() | {module(), atom()}. + +-spec trans(id(), trans_fun()) -> term(). +trans(Id, Fun) -> trans(Id, Fun, [node() | nodes()], infinity). + +-spec trans(id(), trans_fun(), [node()]) -> term(). +trans(Id, Fun, Nodes) -> trans(Id, Fun, Nodes, infinity). + +-spec trans(id(), trans_fun(), [node()], retries()) -> term(). +trans(Id, Fun, Nodes, Retries) -> + case set_lock(Id, Nodes, Retries) of + true -> + try + Fun() + after + del_lock(Id, Nodes) + end; + false -> + aborted + end. + +info() -> + gen_server:call(global_name_server, info, infinity). + +%%%----------------------------------------------------------------- +%%% Call-back functions from gen_server +%%%----------------------------------------------------------------- +init([]) -> + process_flag(trap_exit, true), + _ = ets:new(global_locks, [set, named_table, protected]), + _ = ets:new(global_names, [set, named_table, protected]), + _ = ets:new(global_names_ext, [set, named_table, protected]), + + _ = ets:new(global_pid_names, [bag, named_table, protected]), + _ = ets:new(global_pid_ids, [bag, named_table, protected]), + + %% This is for troubleshooting only. + DoTrace = os:getenv("GLOBAL_HIGH_LEVEL_TRACE") =:= "TRUE", + T0 = case DoTrace of + true -> + send_high_level_trace(), + []; + false -> + no_trace + end, + + S = #state{the_locker = start_the_locker(DoTrace), + trace = T0, + the_deleter = start_the_deleter(self()), + the_registrar = start_the_registrar()}, + S1 = trace_message(S, {init, node()}, []), + + case init:get_argument(connect_all) of + {ok, [["false"]]} -> + {ok, S1#state{connect_all = false}}; + _ -> + {ok, S1#state{connect_all = true}} + end. + +%%----------------------------------------------------------------- +%% Connection algorithm +%% ==================== +%% This algorithm solves the problem with partitioned nets as well. +%% +%% The main idea in the algorithm is that when two nodes connect, they +%% try to set a lock in their own partition (i.e. all nodes already +%% known to them; partitions are not necessarily disjoint). When the +%% lock is set in each partition, these two nodes send each other a +%% list with all registered names in resp partition (*). If no conflict +%% is found, the name tables are just updated. If a conflict is found, +%% a resolve function is called once for each conflict. The result of +%% the resolving is sent to the other node. When the names are +%% exchanged, all other nodes in each partition are informed of the +%% other nodes, and they ping each other to form a fully connected +%% net. +%% +%% A few remarks: +%% +%% (*) When this information is being exchanged, no one is allowed to +%% change the global register table. All calls to register etc are +%% protected by a lock. If a registered process dies during this +%% phase the name is unregistered on the local node immediately, +%% but the unregistration on other nodes will take place when the +%% deleter manages to acquire the lock. This is necessary to +%% prevent names from spreading to nodes where they cannot be +%% deleted. +%% +%% - It is assumed that nodeups and nodedowns arrive in an orderly +%% fashion: for every node, nodeup is followed by nodedown, and vice +%% versa. "Double" nodeups and nodedowns must never occur. It is +%% the responsibility of net_kernel to assure this. +%% +%% - There is always a delay between the termination of a registered +%% process and the removal of the name from Global's tables. This +%% delay can sometimes be quite substantial. Global guarantees that +%% the name will eventually be removed, but there is no +%% synchronization between nodes; the name can be removed from some +%% node(s) long before it is removed from other nodes. Using +%% safe_whereis_name is no cure. +%% +%% - Global cannot handle problems with the distribution very well. +%% Depending on the value of the kernel variable 'net_ticktime' long +%% delays may occur. This does not affect the handling of locks but +%% will block name registration. +%% +%% - Old synch session messages may linger on in the message queue of +%% global_name_server after the sending node has died. The tags of +%% such messages do not match the current tag (if there is one), +%% which makes it possible to discard those messages and cancel the +%% corresponding lock. +%% +%% Suppose nodes A and B connect, and C is connected to A. +%% Here's the algorithm's flow: +%% +%% Node A +%% ------ +%% << {nodeup, B} +%% TheLocker ! {nodeup, ..., Node, ...} (there is one locker per node) +%% B ! {init_connect, ..., {..., TheLockerAtA, ...}} +%% << {init_connect, TheLockerAtB} +%% [The lockers try to set the lock] +%% << {lock_is_set, B, ...} +%% [Now, lock is set in both partitions] +%% B ! {exchange, A, Names, ...} +%% << {exchange, B, Names, ...} +%% [solve conflict] +%% B ! {resolved, A, ResolvedA, KnownAtA, ...} +%% << {resolved, B, ResolvedB, KnownAtB, ...} +%% C ! {new_nodes, ResolvedAandB, [B]} +%% +%% Node C +%% ------ +%% << {new_nodes, ResolvedOps, NewNodes} +%% [insert Ops] +%% ping(NewNodes) +%% << {nodeup, B} +%% <ignore this one> +%% +%% Several things can disturb this picture. +%% +%% First, the init_connect message may arrive _before_ the nodeup +%% message due to delay in net_kernel. We handle this by keeping track +%% of these messages in the pre_connect variable in our state. +%% +%% Of course we must handle that some node goes down during the +%% connection. +%% +%%----------------------------------------------------------------- +%% Messages in the protocol +%% ======================== +%% 1. Between global_name_servers on connecting nodes +%% {init_connect, Vsn, Node, InitMsg} +%% InitMsg = {locker, _Unused, HisKnown, HisTheLocker} +%% {exchange, Node, ListOfNames, _ListOfNamesExt, Tag} +%% {resolved, Node, HisOps, HisKnown, _Unused, ListOfNamesExt, Tag} +%% HisKnown = list of known nodes in Node's partition +%% 2. Between lockers on connecting nodes +%% {his_locker, Pid} (from our global) +%% {lock, Bool} loop until both lockers have lock = true, +%% then send to global_name_server {lock_is_set, Node, Tag} +%% 3. Connecting node's global_name_server informs other nodes in the same +%% partition about hitherto unknown nodes in the other partition +%% {new_nodes, Node, Ops, ListOfNamesExt, NewNodes, ExtraInfo} +%% 4. Between global_name_server and resolver +%% {resolve, NameList, Node} to resolver +%% {exchange_ops, Node, Tag, Ops, Resolved} from resolver +%% 5. sync protocol, between global_name_servers in different partitions +%% {in_sync, Node, IsKnown} +%% sent by each node to all new nodes (Node becomes known to them) +%%----------------------------------------------------------------- + +handle_call({whereis, Name}, From, S) -> + do_whereis(Name, From), + {noreply, S}; + +handle_call({registrar, Fun}, From, S) -> + S#state.the_registrar ! {trans_all_known, Fun, From}, + {noreply, S}; + +%% The pattern {register,'_','_','_'} is traced by the inviso +%% application. Do not change. +handle_call({register, Name, Pid, Method}, {FromPid, _Tag}, S0) -> + S = ins_name(Name, Pid, Method, FromPid, [], S0), + {reply, yes, S}; + +handle_call({unregister, Name}, _From, S0) -> + S = delete_global_name2(Name, S0), + {reply, ok, S}; + +handle_call({register_ext, Name, Pid, Method, RegNode}, {FromPid,_Tag}, S0) -> + S = ins_name_ext(Name, Pid, Method, RegNode, FromPid, [], S0), + {reply, yes, S}; + +handle_call({set_lock, Lock}, {Pid, _Tag}, S0) -> + {Reply, S} = handle_set_lock(Lock, Pid, S0), + {reply, Reply, S}; + +handle_call({del_lock, Lock}, {Pid, _Tag}, S0) -> + S = handle_del_lock(Lock, Pid, S0), + {reply, true, S}; + +handle_call(get_known, _From, S) -> + {reply, S#state.known, S}; + +handle_call(get_synced, _From, S) -> + {reply, S#state.synced, S}; + +handle_call({sync, Nodes}, From, S) -> + %% If we have several global groups, this won't work, since we will + %% do start_sync on a nonempty list of nodes even if the system + %% is quiet. + Pid = start_sync(lists:delete(node(), Nodes) -- S#state.synced, From), + {noreply, S#state{syncers = [Pid | S#state.syncers]}}; + +handle_call(get_protocol_version, _From, S) -> + {reply, ?vsn, S}; + +handle_call(get_names_ext, _From, S) -> + {reply, get_names_ext(), S}; + +handle_call(info, _From, S) -> + {reply, S, S}; + +%% "High level trace". For troubleshooting only. +handle_call(high_level_trace_start, _From, S) -> + S#state.the_locker ! {do_trace, true}, + send_high_level_trace(), + {reply, ok, trace_message(S#state{trace = []}, {init, node()}, [])}; +handle_call(high_level_trace_stop, _From, S) -> + #state{the_locker = TheLocker, trace = Trace} = S, + TheLocker ! {do_trace, false}, + wait_high_level_trace(), + {reply, Trace, S#state{trace = no_trace}}; +handle_call(high_level_trace_get, _From, #state{trace = Trace}=S) -> + {reply, Trace, S#state{trace = []}}; + +handle_call(stop, _From, S) -> + {stop, normal, stopped, S}; + +handle_call(Request, From, S) -> + error_logger:warning_msg("The global_name_server " + "received an unexpected message:\n" + "handle_call(~p, ~p, _)\n", + [Request, From]), + {noreply, S}. + +%%======================================================================== +%% init_connect +%% +%%======================================================================== +handle_cast({init_connect, Vsn, Node, InitMsg}, S) -> + %% Sent from global_name_server at Node. + ?trace({'####', init_connect, {vsn, Vsn}, {node,Node},{initmsg,InitMsg}}), + case Vsn of + %% It is always the responsibility of newer versions to understand + %% older versions of the protocol. + {HisVsn, HisTag} when HisVsn > ?vsn -> + init_connect(?vsn, Node, InitMsg, HisTag, S#state.resolvers, S); + {HisVsn, HisTag} -> + init_connect(HisVsn, Node, InitMsg, HisTag, S#state.resolvers, S); + %% To be future compatible + Tuple when is_tuple(Tuple) -> + List = tuple_to_list(Tuple), + [_HisVsn, HisTag | _] = List, + %% use own version handling if his is newer. + init_connect(?vsn, Node, InitMsg, HisTag, S#state.resolvers, S); + _ -> + Txt = io_lib:format("Illegal global protocol version ~p Node: ~p\n", + [Vsn, Node]), + error_logger:info_report(lists:flatten(Txt)) + end, + {noreply, S}; + +%%======================================================================= +%% lock_is_set +%% +%% Ok, the lock is now set on both partitions. Send our names to other node. +%%======================================================================= +handle_cast({lock_is_set, Node, MyTag, LockId}, S) -> + %% Sent from the_locker at node(). + ?trace({'####', lock_is_set , {node,Node}}), + case get({sync_tag_my, Node}) of + MyTag -> + lock_is_set(Node, S#state.resolvers, LockId), + {noreply, S}; + _ -> %% Illegal tag, delete the old sync session. + NewS = cancel_locker(Node, S, MyTag), + {noreply, NewS} + end; + +%%======================================================================== +%% exchange +%% +%% Here the names are checked to detect name clashes. +%%======================================================================== +handle_cast({exchange, Node, NameList, _NameExtList, MyTag}, S) -> + %% Sent from global_name_server at Node. + case get({sync_tag_my, Node}) of + MyTag -> + exchange(Node, NameList, S#state.resolvers), + {noreply, S}; + _ -> %% Illegal tag, delete the old sync session. + NewS = cancel_locker(Node, S, MyTag), + {noreply, NewS} + end; + +%% {exchange_ops, ...} is sent by the resolver process (which then +%% dies). It could happen that {resolved, ...} has already arrived +%% from the other node. In that case we can go ahead and run the +%% resolve operations. Otherwise we have to save the operations and +%% wait for {resolve, ...}. This is very much like {lock_is_set, ...} +%% and {exchange, ...}. +handle_cast({exchange_ops, Node, MyTag, Ops, Resolved}, S0) -> + %% Sent from the resolver for Node at node(). + ?trace({exchange_ops, {node,Node}, {ops,Ops},{resolved,Resolved}, + {mytag,MyTag}}), + S = trace_message(S0, {exit_resolver, Node}, [MyTag]), + case get({sync_tag_my, Node}) of + MyTag -> + Known = S#state.known, + gen_server:cast({global_name_server, Node}, + {resolved, node(), Resolved, Known, + Known,get_names_ext(),get({sync_tag_his,Node})}), + case get({save_ops, Node}) of + {resolved, HisKnown, Names_ext, HisResolved} -> + put({save_ops, Node}, Ops), + NewS = resolved(Node, HisResolved, HisKnown, Names_ext,S), + {noreply, NewS}; + undefined -> + put({save_ops, Node}, Ops), + {noreply, S} + end; + _ -> %% Illegal tag, delete the old sync session. + NewS = cancel_locker(Node, S, MyTag), + {noreply, NewS} + end; + +%%======================================================================== +%% resolved +%% +%% Here the name clashes are resolved. +%%======================================================================== +handle_cast({resolved, Node, HisResolved, HisKnown, _HisKnown_v2, + Names_ext, MyTag}, S) -> + %% Sent from global_name_server at Node. + ?trace({'####', resolved, {his_resolved,HisResolved}, {node,Node}}), + case get({sync_tag_my, Node}) of + MyTag -> + %% See the comment at handle_case({exchange_ops, ...}). + case get({save_ops, Node}) of + Ops when is_list(Ops) -> + NewS = resolved(Node, HisResolved, HisKnown, Names_ext, S), + {noreply, NewS}; + undefined -> + Resolved = {resolved, HisKnown, Names_ext, HisResolved}, + put({save_ops, Node}, Resolved), + {noreply, S} + end; + _ -> %% Illegal tag, delete the old sync session. + NewS = cancel_locker(Node, S, MyTag), + {noreply, NewS} + end; + +%%======================================================================== +%% new_nodes +%% +%% We get to know the other node's known nodes. +%%======================================================================== +handle_cast({new_nodes, Node, Ops, Names_ext, Nodes, ExtraInfo}, S) -> + %% Sent from global_name_server at Node. + ?trace({new_nodes, {node,Node},{ops,Ops},{nodes,Nodes},{x,ExtraInfo}}), + NewS = new_nodes(Ops, Node, Names_ext, Nodes, ExtraInfo, S), + {noreply, NewS}; + +%%======================================================================== +%% in_sync +%% +%% We are in sync with this node (from the other node's known world). +%%======================================================================== +handle_cast({in_sync, Node, _IsKnown}, S) -> + %% Sent from global_name_server at Node (in the other partition). + ?trace({'####', in_sync, {Node, _IsKnown}}), + lists:foreach(fun(Pid) -> Pid ! {synced, [Node]} end, S#state.syncers), + NewS = cancel_locker(Node, S, get({sync_tag_my, Node})), + reset_node_state(Node), + NSynced = case lists:member(Node, Synced = NewS#state.synced) of + true -> Synced; + false -> [Node | Synced] + end, + {noreply, NewS#state{synced = NSynced}}; + +%% Called when Pid on other node crashed +handle_cast({async_del_name, _Name, _Pid}, S) -> + %% Sent from the_deleter at some node in the partition but node(). + %% The DOWN message deletes the name. + {noreply, S}; + +handle_cast({async_del_lock, _ResourceId, _Pid}, S) -> + %% Sent from global_name_server at some node in the partition but node(). + %% The DOWN message deletes the lock. + {noreply, S}; + +handle_cast(Request, S) -> + error_logger:warning_msg("The global_name_server " + "received an unexpected message:\n" + "handle_cast(~p, _)\n", [Request]), + {noreply, S}. + +handle_info({'EXIT', Deleter, _Reason}=Exit, #state{the_deleter=Deleter}=S) -> + {stop, {deleter_died,Exit}, S#state{the_deleter=undefined}}; +handle_info({'EXIT', Locker, _Reason}=Exit, #state{the_locker=Locker}=S) -> + {stop, {locker_died,Exit}, S#state{the_locker=undefined}}; +handle_info({'EXIT', Registrar, _}=Exit, #state{the_registrar=Registrar}=S) -> + {stop, {registrar_died,Exit}, S#state{the_registrar=undefined}}; +handle_info({'EXIT', Pid, _Reason}, S) when is_pid(Pid) -> + ?trace({global_EXIT,_Reason,Pid}), + %% The process that died was a synch process started by start_sync + %% or a registered process running on an external node (C-node). + %% Links to external names are ignored here (there are also DOWN + %% signals). + Syncers = lists:delete(Pid, S#state.syncers), + {noreply, S#state{syncers = Syncers}}; + +handle_info({nodedown, Node}, S) when Node =:= S#state.node_name -> + %% Somebody stopped the distribution dynamically - change + %% references to old node name (Node) to new node name ('nonode@nohost') + {noreply, change_our_node_name(node(), S)}; + +handle_info({nodedown, Node}, S0) -> + ?trace({'####', nodedown, {node,Node}}), + S1 = trace_message(S0, {nodedown, Node}, []), + S = handle_nodedown(Node, S1), + {noreply, S}; + +handle_info({extra_nodedown, Node}, S0) -> + ?trace({'####', extra_nodedown, {node,Node}}), + S1 = trace_message(S0, {extra_nodedown, Node}, []), + S = handle_nodedown(Node, S1), + {noreply, S}; + +handle_info({nodeup, Node}, S) when Node =:= node() -> + ?trace({'####', local_nodeup, {node, Node}}), + %% Somebody started the distribution dynamically - change + %% references to old node name ('nonode@nohost') to Node. + {noreply, change_our_node_name(Node, S)}; + +handle_info({nodeup, _Node}, S) when not S#state.connect_all -> + {noreply, S}; + +handle_info({nodeup, Node}, S0) when S0#state.connect_all -> + IsKnown = lists:member(Node, S0#state.known) or + %% This one is only for double nodeups (shouldn't occur!) + lists:keymember(Node, 1, S0#state.resolvers), + ?trace({'####', nodeup, {node,Node}, {isknown,IsKnown}}), + S1 = trace_message(S0, {nodeup, Node}, []), + case IsKnown of + true -> + {noreply, S1}; + false -> + resend_pre_connect(Node), + + %% now() is used as a tag to separate different synch sessions + %% from each others. Global could be confused at bursty nodeups + %% because it couldn't separate the messages between the different + %% synch sessions started by a nodeup. + MyTag = now(), + put({sync_tag_my, Node}, MyTag), + ?trace({sending_nodeup_to_locker, {node,Node},{mytag,MyTag}}), + S1#state.the_locker ! {nodeup, Node, MyTag}, + + %% In order to be compatible with unpatched R7 a locker + %% process was spawned. Vsn 5 is no longer compatible with + %% vsn 3 nodes, so the locker process is no longer needed. + %% The permanent locker takes its place. + NotAPid = no_longer_a_pid, + Locker = {locker, NotAPid, S1#state.known, S1#state.the_locker}, + InitC = {init_connect, {?vsn, MyTag}, node(), Locker}, + Rs = S1#state.resolvers, + ?trace({casting_init_connect, {node,Node},{initmessage,InitC}, + {resolvers,Rs}}), + gen_server:cast({global_name_server, Node}, InitC), + Resolver = start_resolver(Node, MyTag), + S = trace_message(S1, {new_resolver, Node}, [MyTag, Resolver]), + {noreply, S#state{resolvers = [{Node, MyTag, Resolver} | Rs]}} + end; + +handle_info({whereis, Name, From}, S) -> + do_whereis(Name, From), + {noreply, S}; + +handle_info(known, S) -> + io:format(">>>> ~p\n",[S#state.known]), + {noreply, S}; + +%% "High level trace". For troubleshooting only. +handle_info(high_level_trace, S) -> + case S of + #state{trace = [{Node, _Time, _M, Nodes, _X} | _]} -> + send_high_level_trace(), + CNode = node(), + CNodes = nodes(), + case {CNode, CNodes} of + {Node, Nodes} -> + {noreply, S}; + _ -> + {New, _, Old} = + sofs:symmetric_partition(sofs:set([CNode|CNodes]), + sofs:set([Node|Nodes])), + M = {nodes_changed, {sofs:to_external(New), + sofs:to_external(Old)}}, + {noreply, trace_message(S, M, [])} + end; + _ -> + {noreply, S} + end; +handle_info({trace_message, M}, S) -> + {noreply, trace_message(S, M, [])}; +handle_info({trace_message, M, X}, S) -> + {noreply, trace_message(S, M, X)}; + +handle_info({'DOWN', MonitorRef, process, _Pid, _Info}, S0) -> + S1 = delete_lock(MonitorRef, S0), + S = del_name(MonitorRef, S1), + {noreply, S}; + +handle_info(Message, S) -> + error_logger:warning_msg("The global_name_server " + "received an unexpected message:\n" + "handle_info(~p, _)\n", [Message]), + {noreply, S}. + + +%%======================================================================== +%%======================================================================== +%%=============================== Internal Functions ===================== +%%======================================================================== +%%======================================================================== + +-define(HIGH_LEVEL_TRACE_INTERVAL, 500). % ms + +wait_high_level_trace() -> + receive + high_level_trace -> + ok + after ?HIGH_LEVEL_TRACE_INTERVAL+1 -> + ok + end. + +send_high_level_trace() -> + erlang:send_after(?HIGH_LEVEL_TRACE_INTERVAL, self(), high_level_trace). + +-define(GLOBAL_RID, global). + +%% Similar to trans(Id, Fun), but always uses global's own lock +%% on all nodes known to global, making sure that no new nodes have +%% become known while we got the list of known nodes. +trans_all_known(Fun) -> + Id = {?GLOBAL_RID, self()}, + Nodes = set_lock_known(Id, 0), + try + Fun(Nodes) + after + delete_global_lock(Id, Nodes) + end. + +set_lock_known(Id, Times) -> + Known = get_known(), + Nodes = [node() | Known], + Boss = the_boss(Nodes), + %% Use the same convention (a boss) as lock_nodes_safely. Optimization. + case set_lock_on_nodes(Id, [Boss]) of + true -> + case lock_on_known_nodes(Id, Known, Nodes) of + true -> + Nodes; + false -> + del_lock(Id, [Boss]), + random_sleep(Times), + set_lock_known(Id, Times+1) + end; + false -> + random_sleep(Times), + set_lock_known(Id, Times+1) + end. + +lock_on_known_nodes(Id, Known, Nodes) -> + case set_lock_on_nodes(Id, Nodes) of + true -> + (get_known() -- Known) =:= []; + false -> + false + end. + +set_lock_on_nodes(_Id, []) -> + true; +set_lock_on_nodes(Id, Nodes) -> + case local_lock_check(Id, Nodes) of + true -> + Msg = {set_lock, Id}, + {Replies, _} = + gen_server:multi_call(Nodes, global_name_server, Msg), + ?trace({set_lock,{me,self()},Id,{nodes,Nodes},{replies,Replies}}), + check_replies(Replies, Id, Replies); + false=Reply -> + Reply + end. + +%% Probe lock on local node to see if one should go on trying other nodes. +local_lock_check(_Id, [_] = _Nodes) -> + true; +local_lock_check(Id, Nodes) -> + not lists:member(node(), Nodes) orelse (can_set_lock(Id) =/= false). + +check_replies([{_Node, true} | T], Id, Replies) -> + check_replies(T, Id, Replies); +check_replies([{_Node, false=Reply} | _T], _Id, [_]) -> + Reply; +check_replies([{_Node, false=Reply} | _T], Id, Replies) -> + TrueReplyNodes = [N || {N, true} <- Replies], + ?trace({check_replies, {true_reply_nodes, TrueReplyNodes}}), + gen_server:multi_call(TrueReplyNodes, global_name_server, {del_lock, Id}), + Reply; +check_replies([], _Id, _Replies) -> + true. + +%%======================================================================== +%% Another node wants to synchronize its registered names with us. +%% Both nodes must have a lock before they are allowed to continue. +%%======================================================================== +init_connect(Vsn, Node, InitMsg, HisTag, Resolvers, S) -> + %% It is always the responsibility of newer versions to understand + %% older versions of the protocol. + put({prot_vsn, Node}, Vsn), + put({sync_tag_his, Node}, HisTag), + case lists:keyfind(Node, 1, Resolvers) of + {Node, MyTag, _Resolver} -> + MyTag = get({sync_tag_my, Node}), % assertion + {locker, _NoLongerAPid, _HisKnown0, HisTheLocker} = InitMsg, + ?trace({init_connect,{histhelocker,HisTheLocker}}), + HisKnown = [], + S#state.the_locker ! {his_the_locker, HisTheLocker, + {Vsn,HisKnown}, S#state.known}; + false -> + ?trace({init_connect,{pre_connect,Node},{histag,HisTag}}), + put({pre_connect, Node}, {Vsn, InitMsg, HisTag}) + end. + +%%======================================================================== +%% In the simple case, we'll get lock_is_set before we get exchange, +%% but we may get exchange before we get lock_is_set from our locker. +%% If that's the case, we'll have to remember the exchange info, and +%% handle it when we get the lock_is_set. We do this by using the +%% process dictionary - when the lock_is_set msg is received, we store +%% this info. When exchange is received, we can check the dictionary +%% if the lock_is_set has been received. If not, we store info about +%% the exchange instead. In the lock_is_set we must first check if +%% exchange info is stored, in that case we take care of it. +%%======================================================================== +lock_is_set(Node, Resolvers, LockId) -> + gen_server:cast({global_name_server, Node}, + {exchange, node(), get_names(), _ExtNames = [], + get({sync_tag_his, Node})}), + put({lock_id, Node}, LockId), + %% If both have the lock, continue with exchange. + case get({wait_lock, Node}) of + {exchange, NameList} -> + put({wait_lock, Node}, lock_is_set), + exchange(Node, NameList, Resolvers); + undefined -> + put({wait_lock, Node}, lock_is_set) + end. + +%%======================================================================== +%% exchange +%%======================================================================== +exchange(Node, NameList, Resolvers) -> + ?trace({'####', exchange, {node,Node}, {namelist,NameList}, + {resolvers, Resolvers}}), + case erase({wait_lock, Node}) of + lock_is_set -> + {Node, _Tag, Resolver} = lists:keyfind(Node, 1, Resolvers), + Resolver ! {resolve, NameList, Node}; + undefined -> + put({wait_lock, Node}, {exchange, NameList}) + end. + +resolved(Node, HisResolved, HisKnown, Names_ext, S0) -> + Ops = erase({save_ops, Node}) ++ HisResolved, + %% Known may have shrunk since the lock was taken (due to nodedowns). + Known = S0#state.known, + Synced = S0#state.synced, + NewNodes = [Node | HisKnown], + sync_others(HisKnown), + ExtraInfo = [{vsn,get({prot_vsn, Node})}, {lock, get({lock_id, Node})}], + S = do_ops(Ops, node(), Names_ext, ExtraInfo, S0), + %% I am synced with Node, but not with HisKnown yet + lists:foreach(fun(Pid) -> Pid ! {synced, [Node]} end, S#state.syncers), + S3 = lists:foldl(fun(Node1, S1) -> + F = fun(Tag) -> cancel_locker(Node1,S1,Tag) end, + cancel_resolved_locker(Node1, F) + end, S, HisKnown), + %% The locker that took the lock is asked to send + %% the {new_nodes, ...} message. This ensures that + %% {del_lock, ...} is received after {new_nodes, ...} + %% (except when abcast spawns process(es)...). + NewNodesF = fun() -> + gen_server:abcast(Known, global_name_server, + {new_nodes, node(), Ops, Names_ext, + NewNodes, ExtraInfo}) + end, + F = fun(Tag) -> cancel_locker(Node, S3, Tag, NewNodesF) end, + S4 = cancel_resolved_locker(Node, F), + %% See (*) below... we're node b in that description + AddedNodes = (NewNodes -- Known), + NewKnown = Known ++ AddedNodes, + S4#state.the_locker ! {add_to_known, AddedNodes}, + NewS = trace_message(S4, {added, AddedNodes}, + [{new_nodes, NewNodes}, {abcast, Known}, {ops,Ops}]), + NewS#state{known = NewKnown, synced = [Node | Synced]}. + +cancel_resolved_locker(Node, CancelFun) -> + Tag = get({sync_tag_my, Node}), + ?trace({calling_cancel_locker,Tag,get()}), + S = CancelFun(Tag), + reset_node_state(Node), + S. + +new_nodes(Ops, ConnNode, Names_ext, Nodes, ExtraInfo, S0) -> + Known = S0#state.known, + %% (*) This one requires some thought... + %% We're node a, other nodes b and c: + %% The problem is that {in_sync, a} may arrive before {resolved, [a]} to + %% b from c, leading to b sending {new_nodes, [a]} to us (node a). + %% Therefore, we make sure we never get duplicates in Known. + AddedNodes = lists:delete(node(), Nodes -- Known), + sync_others(AddedNodes), + S = do_ops(Ops, ConnNode, Names_ext, ExtraInfo, S0), + ?trace({added_nodes_in_sync,{added_nodes,AddedNodes}}), + S#state.the_locker ! {add_to_known, AddedNodes}, + S1 = trace_message(S, {added, AddedNodes}, [{ops,Ops}]), + S1#state{known = Known ++ AddedNodes}. + +do_whereis(Name, From) -> + case is_global_lock_set() of + false -> + gen_server:reply(From, where(Name)); + true -> + send_again({whereis, Name, From}) + end. + +terminate(_Reason, _S) -> + true = ets:delete(global_names), + true = ets:delete(global_names_ext), + true = ets:delete(global_locks), + true = ets:delete(global_pid_names), + true = ets:delete(global_pid_ids). + +code_change(_OldVsn, S, _Extra) -> + {ok, S}. + +%% The resolver runs exchange_names in a separate process. The effect +%% is that locks can be used at the same time as name resolution takes +%% place. +start_resolver(Node, MyTag) -> + spawn(fun() -> resolver(Node, MyTag) end). + +resolver(Node, Tag) -> + receive + {resolve, NameList, Node} -> + ?trace({resolver, {me,self()}, {node,Node}, {namelist,NameList}}), + {Ops, Resolved} = exchange_names(NameList, Node, [], []), + Exchange = {exchange_ops, Node, Tag, Ops, Resolved}, + gen_server:cast(global_name_server, Exchange), + exit(normal); + _ -> % Ignore garbage. + resolver(Node, Tag) + end. + +resend_pre_connect(Node) -> + case erase({pre_connect, Node}) of + {Vsn, InitMsg, HisTag} -> + gen_server:cast(self(), + {init_connect, {Vsn, HisTag}, Node, InitMsg}); + _ -> + ok + end. + +ins_name(Name, Pid, Method, FromPidOrNode, ExtraInfo, S0) -> + ?trace({ins_name,insert,{name,Name},{pid,Pid}}), + S1 = delete_global_name_keep_pid(Name, S0), + S = trace_message(S1, {ins_name, node(Pid)}, [Name, Pid]), + insert_global_name(Name, Pid, Method, FromPidOrNode, ExtraInfo, S). + +ins_name_ext(Name, Pid, Method, RegNode, FromPidOrNode, ExtraInfo, S0) -> + ?trace({ins_name_ext, {name,Name}, {pid,Pid}}), + S1 = delete_global_name_keep_pid(Name, S0), + dolink_ext(Pid, RegNode), + S = trace_message(S1, {ins_name_ext, node(Pid)}, [Name, Pid]), + true = ets:insert(global_names_ext, {Name, Pid, RegNode}), + insert_global_name(Name, Pid, Method, FromPidOrNode, ExtraInfo, S). + +where(Name) -> + case ets:lookup(global_names, Name) of + [{_Name, Pid, _Method, _RPid, _Ref}] -> Pid; + [] -> undefined + end. + +handle_set_lock(Id, Pid, S) -> + ?trace({handle_set_lock, Id, Pid}), + case can_set_lock(Id) of + {true, PidRefs} -> + case pid_is_locking(Pid, PidRefs) of + true -> + {true, S}; + false -> + {true, insert_lock(Id, Pid, PidRefs, S)} + end; + false=Reply -> + {Reply, S} + end. + +can_set_lock({ResourceId, LockRequesterId}) -> + case ets:lookup(global_locks, ResourceId) of + [{ResourceId, LockRequesterId, PidRefs}] -> + {true, PidRefs}; + [{ResourceId, _LockRequesterId2, _PidRefs}] -> + false; + [] -> + {true, []} + end. + +insert_lock({ResourceId, LockRequesterId}=Id, Pid, PidRefs, S) -> + {RPid, Ref} = do_monitor(Pid), + true = ets:insert(global_pid_ids, {Pid, ResourceId}), + true = ets:insert(global_pid_ids, {Ref, ResourceId}), + Lock = {ResourceId, LockRequesterId, [{Pid,RPid,Ref} | PidRefs]}, + true = ets:insert(global_locks, Lock), + trace_message(S, {ins_lock, node(Pid)}, [Id, Pid]). + +is_global_lock_set() -> + is_lock_set(?GLOBAL_RID). + +is_lock_set(ResourceId) -> + ets:member(global_locks, ResourceId). + +handle_del_lock({ResourceId, LockReqId}, Pid, S0) -> + ?trace({handle_del_lock, {pid,Pid},{id,{ResourceId, LockReqId}}}), + case ets:lookup(global_locks, ResourceId) of + [{ResourceId, LockReqId, PidRefs}]-> + remove_lock(ResourceId, LockReqId, Pid, PidRefs, false, S0); + _ -> S0 + end. + +remove_lock(ResourceId, LockRequesterId, Pid, [{Pid,RPid,Ref}], Down, S0) -> + ?trace({remove_lock_1, {id,ResourceId},{pid,Pid}}), + true = erlang:demonitor(Ref, [flush]), + kill_monitor_proc(RPid, Pid), + true = ets:delete(global_locks, ResourceId), + true = ets:delete_object(global_pid_ids, {Pid, ResourceId}), + true = ets:delete_object(global_pid_ids, {Ref, ResourceId}), + S = case ResourceId of + ?GLOBAL_RID -> S0#state{global_lock_down = Down}; + _ -> S0 + end, + trace_message(S, {rem_lock, node(Pid)}, + [{ResourceId, LockRequesterId}, Pid]); +remove_lock(ResourceId, LockRequesterId, Pid, PidRefs0, _Down, S) -> + ?trace({remove_lock_2, {id,ResourceId},{pid,Pid}}), + PidRefs = case lists:keyfind(Pid, 1, PidRefs0) of + {Pid, RPid, Ref} -> + true = erlang:demonitor(Ref, [flush]), + kill_monitor_proc(RPid, Pid), + true = ets:delete_object(global_pid_ids, + {Ref, ResourceId}), + lists:keydelete(Pid, 1, PidRefs0); + false -> + PidRefs0 + end, + Lock = {ResourceId, LockRequesterId, PidRefs}, + true = ets:insert(global_locks, Lock), + true = ets:delete_object(global_pid_ids, {Pid, ResourceId}), + trace_message(S, {rem_lock, node(Pid)}, + [{ResourceId, LockRequesterId}, Pid]). + +kill_monitor_proc(Pid, Pid) -> + ok; +kill_monitor_proc(RPid, _Pid) -> + exit(RPid, kill). + +do_ops(Ops, ConnNode, Names_ext, ExtraInfo, S0) -> + ?trace({do_ops, {ops,Ops}}), + + XInserts = [{Name, Pid, RegNode, Method} || + {Name2, Pid2, RegNode} <- Names_ext, + {insert, {Name, Pid, Method}} <- Ops, + Name =:= Name2, Pid =:= Pid2], + S1 = lists:foldl(fun({Name, Pid, RegNode, Method}, S1) -> + ins_name_ext(Name, Pid, Method, RegNode, + ConnNode, ExtraInfo, S1) + end, S0, XInserts), + + XNames = [Name || {Name, _Pid, _RegNode, _Method} <- XInserts], + Inserts = [{Name, Pid, node(Pid), Method} || + {insert, {Name, Pid, Method}} <- Ops, + not lists:member(Name, XNames)], + S2 = lists:foldl(fun({Name, Pid, _RegNode, Method}, S2) -> + ins_name(Name, Pid, Method, ConnNode, + ExtraInfo, S2) + end, S1, Inserts), + + DelNames = [Name || {delete, Name} <- Ops], + lists:foldl(fun(Name, S) -> delete_global_name2(Name, S) + end, S2, DelNames). + +%% It is possible that a node that was up and running when the +%% operations were assembled has since died. The final {in_sync,...} +%% messages do not generate nodedown messages for such nodes. To +%% compensate "artificial" nodedown messages are created. Since +%% monitor_node may take some time processes are spawned to avoid +%% locking up the global_name_server. Should somehow double nodedown +%% messages occur (one of them artificial), nothing bad can happen +%% (the second nodedown is a no-op). It is assumed that there cannot +%% be a nodeup before the artificial nodedown. +%% +%% The extra nodedown messages generated here also take care of the +%% case that a nodedown message is received _before_ the operations +%% are run. +sync_others(Nodes) -> + N = case application:get_env(kernel, ?N_CONNECT_RETRIES) of + {ok, NRetries} when is_integer(NRetries), + NRetries >= 0 -> NRetries; + _ -> ?DEFAULT_N_CONNECT_RETRIES + end, + lists:foreach(fun(Node) -> + spawn(fun() -> sync_other(Node, N) end) + end, Nodes). + +sync_other(Node, N) -> + erlang:monitor_node(Node, true, [allow_passive_connect]), + receive + {nodedown, Node} when N > 0 -> + sync_other(Node, N - 1); + {nodedown, Node} -> + ?trace({missing_nodedown, {node, Node}}), + error_logger:warning_msg("global: ~w failed to connect to ~w\n", + [node(), Node]), + global_name_server ! {extra_nodedown, Node} + after 0 -> + gen_server:cast({global_name_server,Node}, {in_sync,node(),true}) + end. + % monitor_node(Node, false), + % exit(normal). + +insert_global_name(Name, Pid, Method, FromPidOrNode, ExtraInfo, S) -> + {RPid, Ref} = do_monitor(Pid), + true = ets:insert(global_names, {Name, Pid, Method, RPid, Ref}), + true = ets:insert(global_pid_names, {Pid, Name}), + true = ets:insert(global_pid_names, {Ref, Name}), + case lock_still_set(FromPidOrNode, ExtraInfo, S) of + true -> + S; + false -> + %% The node that took the lock has gone down and then up + %% again. The {register, ...} or {new_nodes, ...} message + %% was delayed and arrived after nodeup (maybe it caused + %% the nodeup). The DOWN signal from the monitor of the + %% lock has removed the lock. + %% Note: it is assumed here that the DOWN signal arrives + %% _before_ nodeup and any message that caused nodeup. + %% This is true of Erlang/OTP. + delete_global_name2(Name, S) + end. + +lock_still_set(PidOrNode, ExtraInfo, S) -> + case ets:lookup(global_locks, ?GLOBAL_RID) of + [{?GLOBAL_RID, _LockReqId, PidRefs}] when is_pid(PidOrNode) -> + %% Name registration. + lists:keymember(PidOrNode, 1, PidRefs); + [{?GLOBAL_RID, LockReqId, PidRefs}] when is_atom(PidOrNode) -> + case extra_info(lock, ExtraInfo) of + {?GLOBAL_RID, LockId} -> % R11B-4 or later + LockReqId =:= LockId; + undefined -> + lock_still_set_old(PidOrNode, LockReqId, PidRefs) + end; + [] -> + %% If the global lock was not removed by a DOWN message + %% then we have a node that do not monitor locking pids + %% (pre R11B-3), or an R11B-3 node (which does not ensure + %% that {new_nodes, ...} arrives before {del_lock, ...}). + not S#state.global_lock_down + end. + +%%% The following is probably overkill. It is possible that this node +%%% has been locked again, but it is a rare occasion. +lock_still_set_old(_Node, ReqId, _PidRefs) when is_pid(ReqId) -> + %% Cannot do better than return true. + true; +lock_still_set_old(Node, ReqId, PidRefs) when is_list(ReqId) -> + %% Connection, version > 4, but before R11B-4. + [P || {P, _RPid, _Ref} <- PidRefs, node(P) =:= Node] =/= []. + +extra_info(Tag, ExtraInfo) -> + %% ExtraInfo used to be a list of nodes (vsn 2). + case catch lists:keyfind(Tag, 1, ExtraInfo) of + {Tag, Info} -> + Info; + _ -> + undefined + end. + +del_name(Ref, S) -> + NameL = [{Name, Pid} || + {_, Name} <- ets:lookup(global_pid_names, Ref), + {_, Pid, _Method, _RPid, Ref1} <- + ets:lookup(global_names, Name), + Ref1 =:= Ref], + ?trace({async_del_name, self(), NameL, Ref}), + case NameL of + [{Name, Pid}] -> + _ = del_names(Name, Pid, S), + delete_global_name2(Name, S); + [] -> + S + end. + +%% Send {async_del_name, ...} to old nodes (pre R11B-3). +del_names(Name, Pid, S) -> + Send = case ets:lookup(global_names_ext, Name) of + [{Name, Pid, RegNode}] -> + RegNode =:= node(); + [] -> + node(Pid) =:= node() + end, + if + Send -> + ?trace({del_names, {pid,Pid}, {name,Name}}), + S#state.the_deleter ! {delete_name, self(), Name, Pid}; + true -> + ok + end. + +%% Keeps the entry in global_names for whereis_name/1. +delete_global_name_keep_pid(Name, S) -> + case ets:lookup(global_names, Name) of + [{Name, Pid, _Method, RPid, Ref}] -> + delete_global_name2(Name, Pid, RPid, Ref, S); + [] -> + S + end. + +delete_global_name2(Name, S) -> + case ets:lookup(global_names, Name) of + [{Name, Pid, _Method, RPid, Ref}] -> + true = ets:delete(global_names, Name), + delete_global_name2(Name, Pid, RPid, Ref, S); + [] -> + S + end. + +delete_global_name2(Name, Pid, RPid, Ref, S) -> + true = erlang:demonitor(Ref, [flush]), + kill_monitor_proc(RPid, Pid), + delete_global_name(Name, Pid), + ?trace({delete_global_name,{item,Name},{pid,Pid}}), + true = ets:delete_object(global_pid_names, {Pid, Name}), + true = ets:delete_object(global_pid_names, {Ref, Name}), + case ets:lookup(global_names_ext, Name) of + [{Name, Pid, RegNode}] -> + true = ets:delete(global_names_ext, Name), + ?trace({delete_global_name, {name,Name,{pid,Pid},{RegNode,Pid}}}), + dounlink_ext(Pid, RegNode); + [] -> + ?trace({delete_global_name,{name,Name,{pid,Pid},{node(Pid),Pid}}}), + ok + end, + trace_message(S, {del_name, node(Pid)}, [Name, Pid]). + +%% delete_global_name/2 is traced by the inviso application. +%% Do not change. +delete_global_name(_Name, _Pid) -> + ok. + +%%----------------------------------------------------------------- +%% The locker is a satellite process to global_name_server. When a +%% nodeup is received from a new node the global_name_server sends a +%% message to the locker. The locker tries to set a lock in our +%% partition, i.e. on all nodes known to us. When the lock is set, it +%% tells global_name_server about it, and keeps the lock set. +%% global_name_server sends a cancel message to the locker when the +%% partitions are connected. + +%% There are two versions of the protocol between lockers on two nodes: +%% Version 1: used by unpatched R7. +%% Version 2: the messages exchanged between the lockers include the known +%% nodes (see OTP-3576). +%%----------------------------------------------------------------- + +-define(locker_vsn, 2). + +-record(multi, + {local = [], % Requests from nodes on the local host. + remote = [], % Other requests. + known = [], % Copy of global_name_server's known nodes. It's + % faster to keep a copy of known than asking + % for it when needed. + the_boss, % max([node() | 'known']) + just_synced = false, % true if node() synced just a moment ago + %% Statistics: + do_trace % bool() + }). + +-record(him, {node, locker, vsn, my_tag}). + +start_the_locker(DoTrace) -> + spawn_link(fun() -> init_the_locker(DoTrace) end). + +init_the_locker(DoTrace) -> + process_flag(trap_exit, true), % needed? + S0 = #multi{do_trace = DoTrace}, + S1 = update_locker_known({add, get_known()}, S0), + loop_the_locker(S1), + erlang:error(locker_exited). + +loop_the_locker(S) -> + ?trace({loop_the_locker,S}), + receive + Message when element(1, Message) =/= nodeup -> + the_locker_message(Message, S) + after 0 -> + Timeout = + case {S#multi.local, S#multi.remote} of + {[],[]} -> + infinity; + _ -> + %% It is important that the timeout is greater + %% than zero, or the chance that some other node + %% in the partition sets the lock once this node + %% has failed after setting the lock is very slim. + if + S#multi.just_synced -> + 0; % no reason to wait after success + S#multi.known =:= [] -> + 200; % just to get started + true -> + erlang:min(1000 + 100*length(S#multi.known), + 3000) + end + end, + S1 = S#multi{just_synced = false}, + receive + Message when element(1, Message) =/= nodeup -> + the_locker_message(Message, S1) + after Timeout -> + case is_global_lock_set() of + true -> + loop_the_locker(S1); + false -> + select_node(S1) + end + end + end. + +the_locker_message({his_the_locker, HisTheLocker, HisKnown0, _MyKnown}, S) -> + ?trace({his_the_locker, HisTheLocker, {node,node(HisTheLocker)}}), + {HisVsn, _HisKnown} = HisKnown0, + true = HisVsn > 4, + receive + {nodeup, Node, MyTag} when node(HisTheLocker) =:= Node -> + ?trace({the_locker_nodeup, {node,Node},{mytag,MyTag}}), + Him = #him{node = node(HisTheLocker), my_tag = MyTag, + locker = HisTheLocker, vsn = HisVsn}, + loop_the_locker(add_node(Him, S)); + {cancel, Node, _Tag, no_fun} when node(HisTheLocker) =:= Node -> + loop_the_locker(S) + after 60000 -> + ?trace({nodeupnevercame, node(HisTheLocker)}), + error_logger:error_msg("global: nodeup never came ~w ~w\n", + [node(), node(HisTheLocker)]), + loop_the_locker(S#multi{just_synced = false}) + end; +the_locker_message({cancel, _Node, undefined, no_fun}, S) -> + ?trace({cancel_the_locker, undefined, {node,_Node}}), + %% If we actually cancel something when a cancel message with the + %% tag 'undefined' arrives, we may be acting on an old nodedown, + %% to cancel a new nodeup, so we can't do that. + loop_the_locker(S); +the_locker_message({cancel, Node, Tag, no_fun}, S) -> + ?trace({the_locker, cancel, {multi,S}, {tag,Tag},{node,Node}}), + receive + {nodeup, Node, Tag} -> + ?trace({cancelnodeup2, {node,Node},{tag,Tag}}), + ok + after 0 -> + ok + end, + loop_the_locker(remove_node(Node, S)); +the_locker_message({lock_set, _Pid, false, _}, S) -> + ?trace({the_locker, spurious, {node,node(_Pid)}}), + loop_the_locker(S); +the_locker_message({lock_set, Pid, true, _HisKnown}, S) -> + Node = node(Pid), + ?trace({the_locker, self(), spontaneous, {node,Node}}), + case find_node_tag(Node, S) of + {true, MyTag, HisVsn} -> + LockId = locker_lock_id(Pid, HisVsn), + {IsLockSet, S1} = lock_nodes_safely(LockId, [], S), + Pid ! {lock_set, self(), IsLockSet, S1#multi.known}, + Known2 = [node() | S1#multi.known], + ?trace({the_locker, spontaneous, {known2, Known2}, + {node,Node}, {is_lock_set,IsLockSet}}), + case IsLockSet of + true -> + gen_server:cast(global_name_server, + {lock_is_set, Node, MyTag, LockId}), + ?trace({lock_sync_done, {pid,Pid}, + {node,node(Pid)}, {me,self()}}), + %% Wait for global to tell us to remove lock. + %% Should the other locker's node die, + %% global_name_server will receive nodedown, and + %% then send {cancel, Node, Tag}. + receive + {cancel, Node, _Tag, Fun} -> + ?trace({cancel_the_lock,{node,Node}}), + call_fun(Fun), + delete_global_lock(LockId, Known2) + end, + S2 = S1#multi{just_synced = true}, + loop_the_locker(remove_node(Node, S2)); + false -> + loop_the_locker(S1#multi{just_synced = false}) + end; + false -> + ?trace({the_locker, not_there, {node,Node}}), + Pid ! {lock_set, self(), false, S#multi.known}, + loop_the_locker(S) + end; +the_locker_message({add_to_known, Nodes}, S) -> + S1 = update_locker_known({add, Nodes}, S), + loop_the_locker(S1); +the_locker_message({remove_from_known, Node}, S) -> + S1 = update_locker_known({remove, Node}, S), + loop_the_locker(S1); +the_locker_message({do_trace, DoTrace}, S) -> + loop_the_locker(S#multi{do_trace = DoTrace}); +the_locker_message(Other, S) -> + unexpected_message(Other, locker), + ?trace({the_locker, {other_msg, Other}}), + loop_the_locker(S). + +%% Requests from nodes on the local host are chosen before requests +%% from other nodes. This should be a safe optimization. +select_node(S) -> + UseRemote = S#multi.local =:= [], + Others1 = if UseRemote -> S#multi.remote; true -> S#multi.local end, + Others2 = exclude_known(Others1, S#multi.known), + S1 = if + UseRemote -> S#multi{remote = Others2}; + true -> S#multi{local = Others2} + end, + if + Others2 =:= [] -> + loop_the_locker(S1); + true -> + Him = random_element(Others2), + #him{locker = HisTheLocker, vsn = HisVsn, + node = Node, my_tag = MyTag} = Him, + HisNode = [Node], + Us = [node() | HisNode], + LockId = locker_lock_id(HisTheLocker, HisVsn), + ?trace({select_node, self(), {us, Us}}), + %% HisNode = [Node] prevents deadlock: + {IsLockSet, S2} = lock_nodes_safely(LockId, HisNode, S1), + case IsLockSet of + true -> + Known1 = Us ++ S2#multi.known, + ?trace({sending_lock_set, self(), {his,HisTheLocker}}), + HisTheLocker ! {lock_set, self(), true, S2#multi.known}, + S3 = lock_is_set(S2, Him, MyTag, Known1, LockId), + loop_the_locker(S3); + false -> + loop_the_locker(S2) + end + end. + +%% Version 5: Both sides use the same requester id. Thereby the nodes +%% common to both sides are locked by both locker processes. This +%% means that the lock is still there when the 'new_nodes' message is +%% received even if the other side has deleted the lock. +locker_lock_id(Pid, Vsn) when Vsn > 4 -> + {?GLOBAL_RID, lists:sort([self(), Pid])}. + +lock_nodes_safely(LockId, Extra, S0) -> + %% Locking node() could stop some node that has already locked the + %% boss, so just check if it is possible to lock node(). + First = delete_nonode([S0#multi.the_boss]), + case ([node()] =:= First) orelse (can_set_lock(LockId) =/= false) of + true -> + %% Locking the boss first is an optimization. + case set_lock(LockId, First, 0) of + true -> + S = update_locker_known(S0), + %% The boss may have changed, but don't bother. + Second = delete_nonode([node() | Extra] -- First), + case set_lock(LockId, Second, 0) of + true -> + Known = S#multi.known, + case set_lock(LockId, Known -- First, 0) of + true -> + _ = locker_trace(S, ok, {First, Known}), + {true, S}; + false -> + %% Since the boss is locked we + %% should have gotten the lock, at + %% least if no one else is locking + %% 'global'. Calling set_lock with + %% Retries > 0 does not seem to + %% speed things up. + SoFar = First ++ Second, + del_lock(LockId, SoFar), + _ = locker_trace(S, not_ok, {Known,SoFar}), + {false, S} + end; + false -> + del_lock(LockId, First), + _ = locker_trace(S, not_ok, {Second, First}), + {false, S} + end; + false -> + _ = locker_trace(S0, not_ok, {First, []}), + {false, S0} + end; + false -> + {false, S0} + end. + +delete_nonode(L) -> + lists:delete(nonode@nohost, L). + +%% Let the server add timestamp. +locker_trace(#multi{do_trace = false}, _, _Nodes) -> + ok; +locker_trace(#multi{do_trace = true}, ok, Ns) -> + global_name_server ! {trace_message, {locker_succeeded, node()}, Ns}; +locker_trace(#multi{do_trace = true}, not_ok, Ns) -> + global_name_server ! {trace_message, {locker_failed, node()}, Ns}; +locker_trace(#multi{do_trace = true}, rejected, Ns) -> + global_name_server ! {trace_message, {lock_rejected, node()}, Ns}. + +update_locker_known(S) -> + receive + {add_to_known, Nodes} -> + S1 = update_locker_known({add, Nodes}, S), + update_locker_known(S1); + {remove_from_known, Node} -> + S1 = update_locker_known({remove, Node}, S), + update_locker_known(S1) + after 0 -> + S + end. + +update_locker_known(Upd, S) -> + Known = case Upd of + {add, Nodes} -> Nodes ++ S#multi.known; + {remove, Node} -> lists:delete(Node, S#multi.known) + end, + TheBoss = the_boss([node() | Known]), + S#multi{known = Known, the_boss = TheBoss}. + +random_element(L) -> + {A,B,C} = now(), + E = (A+B+C) rem length(L), + lists:nth(E+1, L). + +exclude_known(Others, Known) -> + [N || N <- Others, not lists:member(N#him.node, Known)]. + +lock_is_set(S, Him, MyTag, Known1, LockId) -> + Node = Him#him.node, + receive + {lock_set, P, true, _} when node(P) =:= Node -> + gen_server:cast(global_name_server, + {lock_is_set, Node, MyTag, LockId}), + ?trace({lock_sync_done, {p,P, node(P)}, {me,self()}}), + + %% Wait for global to tell us to remove lock. Should the + %% other locker's node die, global_name_server will + %% receive nodedown, and then send {cancel, Node, Tag, Fun}. + receive + {cancel, Node, _, Fun} -> + ?trace({lock_set_loop, {known1,Known1}}), + call_fun(Fun), + delete_global_lock(LockId, Known1) + end, + S#multi{just_synced = true, + local = lists:delete(Him, S#multi.local), + remote = lists:delete(Him, S#multi.remote)}; + {lock_set, P, false, _} when node(P) =:= Node -> + ?trace({not_both_set, {node,Node},{p, P},{known1,Known1}}), + _ = locker_trace(S, rejected, Known1), + delete_global_lock(LockId, Known1), + S; + {cancel, Node, _, Fun} -> + ?trace({the_locker, cancel2, {node,Node}}), + call_fun(Fun), + _ = locker_trace(S, rejected, Known1), + delete_global_lock(LockId, Known1), + remove_node(Node, S); + {'EXIT', _, _} -> + ?trace({the_locker, exit, {node,Node}}), + _ = locker_trace(S, rejected, Known1), + delete_global_lock(LockId, Known1), + S + %% There used to be an 'after' clause (OTP-4902), but it is + %% no longer needed: + %% OTP-5770. Version 5 of the protocol. Deadlock can no longer + %% occur due to the fact that if a partition is locked, one + %% node in the other partition is also locked with the same + %% lock-id, which makes it impossible for any node in the + %% other partition to lock its partition unless it negotiates + %% with the first partition. + end. + +%% The locker does the {new_nodes, ...} call before removing the lock. +call_fun(no_fun) -> + ok; +call_fun(Fun) -> + Fun(). + +%% The lock on the boss is removed last. The purpose is to reduce the +%% risk of failing to lock the known nodes after having locked the +%% boss. (Assumes the boss occurs only once.) +delete_global_lock(LockId, Nodes) -> + TheBoss = the_boss(Nodes), + del_lock(LockId, lists:delete(TheBoss, Nodes)), + del_lock(LockId, [TheBoss]). + +the_boss(Nodes) -> + lists:max(Nodes). + +find_node_tag(Node, S) -> + case find_node_tag2(Node, S#multi.local) of + false -> + find_node_tag2(Node, S#multi.remote); + Reply -> + Reply + end. + +find_node_tag2(_Node, []) -> + false; +find_node_tag2(Node, [#him{node = Node, my_tag = MyTag, vsn = HisVsn} | _]) -> + {true, MyTag, HisVsn}; +find_node_tag2(Node, [_E | Rest]) -> + find_node_tag2(Node, Rest). + +remove_node(Node, S) -> + S#multi{local = remove_node2(Node, S#multi.local), + remote = remove_node2(Node, S#multi.remote)}. + +remove_node2(_Node, []) -> + []; +remove_node2(Node, [#him{node = Node} | Rest]) -> + Rest; +remove_node2(Node, [E | Rest]) -> + [E | remove_node2(Node, Rest)]. + +add_node(Him, S) -> + case is_node_local(Him#him.node) of + true -> + S#multi{local = [Him | S#multi.local]}; + false -> + S#multi{remote = [Him | S#multi.remote]} + end. + +is_node_local(Node) -> + {ok, Host} = inet:gethostname(), + case catch split_node(atom_to_list(Node), $@, []) of + [_, Host] -> + true; + _ -> + false + end. + +split_node([Chr|T], Chr, Ack) -> [lists:reverse(Ack)|split_node(T, Chr, [])]; +split_node([H|T], Chr, Ack) -> split_node(T, Chr, [H|Ack]); +split_node([], _, Ack) -> [lists:reverse(Ack)]. + +cancel_locker(Node, S, Tag) -> + cancel_locker(Node, S, Tag, no_fun). + +cancel_locker(Node, S, Tag, ToBeRunOnLockerF) -> + S#state.the_locker ! {cancel, Node, Tag, ToBeRunOnLockerF}, + Resolvers = S#state.resolvers, + ?trace({cancel_locker, {node,Node},{tag,Tag}, + {sync_tag_my, get({sync_tag_my, Node})},{resolvers,Resolvers}}), + case lists:keyfind(Node, 1, Resolvers) of + {_, Tag, Resolver} -> + ?trace({{resolver, Resolver}}), + exit(Resolver, kill), + S1 = trace_message(S, {kill_resolver, Node}, [Tag, Resolver]), + S1#state{resolvers = lists:keydelete(Node, 1, Resolvers)}; + _ -> + S + end. + +reset_node_state(Node) -> + ?trace({{node,Node}, reset_node_state, get()}), + erase({wait_lock, Node}), + erase({save_ops, Node}), + erase({pre_connect, Node}), + erase({prot_vsn, Node}), + erase({sync_tag_my, Node}), + erase({sync_tag_his, Node}), + erase({lock_id, Node}). + +%% Some node sent us his names. When a name clash is found, the resolve +%% function is called from the smaller node => all resolve funcs are called +%% from the same partition. +exchange_names([{Name, Pid, Method} | Tail], Node, Ops, Res) -> + case ets:lookup(global_names, Name) of + [{Name, Pid, _Method, _RPid2, _Ref2}] -> + exchange_names(Tail, Node, Ops, Res); + [{Name, Pid2, Method2, _RPid2, _Ref2}] when node() < Node -> + %% Name clash! Add the result of resolving to Res(olved). + %% We know that node(Pid) =/= node(), so we don't + %% need to link/unlink to Pid. + Node2 = node(Pid2), %% Node2 is connected to node(). + case rpc:call(Node2, ?MODULE, resolve_it, + [Method2, Name, Pid, Pid2]) of + Pid -> + Op = {insert, {Name, Pid, Method}}, + exchange_names(Tail, Node, [Op | Ops], Res); + Pid2 -> + Op = {insert, {Name, Pid2, Method2}}, + exchange_names(Tail, Node, Ops, [Op | Res]); + none -> + Op = {delete, Name}, + exchange_names(Tail, Node, [Op | Ops], [Op | Res]); + {badrpc, Badrpc} -> + error_logger:info_msg("global: badrpc ~w received when " + "conflicting name ~w was found\n", + [Badrpc, Name]), + Op = {insert, {Name, Pid, Method}}, + exchange_names(Tail, Node, [Op | Ops], Res); + Else -> + error_logger:info_msg("global: Resolve method ~w for " + "conflicting name ~w returned ~w\n", + [Method, Name, Else]), + Op = {delete, Name}, + exchange_names(Tail, Node, [Op | Ops], [Op | Res]) + end; + [{Name, _Pid2, _Method, _RPid, _Ref}] -> + %% The other node will solve the conflict. + exchange_names(Tail, Node, Ops, Res); + _ -> + %% Entirely new name. + exchange_names(Tail, Node, + [{insert, {Name, Pid, Method}} | Ops], Res) + end; +exchange_names([], _, Ops, Res) -> + ?trace({exchange_names_finish,{ops,Ops},{res,Res}}), + {Ops, Res}. + +resolve_it(Method, Name, Pid1, Pid2) -> + catch Method(Name, Pid1, Pid2). + +minmax(P1,P2) -> + if node(P1) < node(P2) -> {P1, P2}; true -> {P2, P1} end. + +-spec random_exit_name(term(), pid(), pid()) -> pid(). +random_exit_name(Name, Pid, Pid2) -> + {Min, Max} = minmax(Pid, Pid2), + error_logger:info_msg("global: Name conflict terminating ~w\n", + [{Name, Max}]), + exit(Max, kill), + Min. + +random_notify_name(Name, Pid, Pid2) -> + {Min, Max} = minmax(Pid, Pid2), + Max ! {global_name_conflict, Name}, + Min. + +-spec notify_all_name(term(), pid(), pid()) -> 'none'. +notify_all_name(Name, Pid, Pid2) -> + Pid ! {global_name_conflict, Name, Pid2}, + Pid2 ! {global_name_conflict, Name, Pid}, + none. + +dolink_ext(Pid, RegNode) when RegNode =:= node() -> + link(Pid); +dolink_ext(_, _) -> + ok. + +dounlink_ext(Pid, RegNode) when RegNode =:= node() -> + unlink_pid(Pid); +dounlink_ext(_Pid, _RegNode) -> + ok. + +unlink_pid(Pid) -> + case ets:member(global_pid_names, Pid) of + false -> + case ets:member(global_pid_ids, Pid) of + false -> + unlink(Pid); + true -> + ok + end; + true -> + ok + end. + +pid_is_locking(Pid, PidRefs) -> + lists:keyfind(Pid, 1, PidRefs) =/= false. + +delete_lock(Ref, S0) -> + Locks = pid_locks(Ref), + del_locks(Locks, Ref, S0#state.known), + F = fun({ResourceId, LockRequesterId, PidRefs}, S) -> + {Pid, _RPid, Ref} = lists:keyfind(Ref, 3, PidRefs), + remove_lock(ResourceId, LockRequesterId, Pid, PidRefs, true,S) + end, + lists:foldl(F, S0, Locks). + +pid_locks(Ref) -> + L = lists:flatmap(fun({_, ResourceId}) -> + ets:lookup(global_locks, ResourceId) + end, ets:lookup(global_pid_ids, Ref)), + [Lock || Lock = {_Id, _Req, PidRefs} <- L, + rpid_is_locking(Ref, PidRefs)]. + +rpid_is_locking(Ref, PidRefs) -> + lists:keyfind(Ref, 3, PidRefs) =/= false. + +%% Send {async_del_lock, ...} to old nodes (pre R11B-3). +del_locks([{ResourceId, _LockReqId, PidRefs} | Tail], Ref, KnownNodes) -> + {Pid, _RPid, Ref} = lists:keyfind(Ref, 3, PidRefs), + case node(Pid) =:= node() of + true -> + gen_server:abcast(KnownNodes, global_name_server, + {async_del_lock, ResourceId, Pid}); + false -> + ok + end, + del_locks(Tail, Ref, KnownNodes); +del_locks([], _Ref, _KnownNodes) -> + ok. + +handle_nodedown(Node, S) -> + %% DOWN signals from monitors have removed locks and registered names. + #state{known = Known, synced = Syncs} = S, + NewS = cancel_locker(Node, S, get({sync_tag_my, Node})), + NewS#state.the_locker ! {remove_from_known, Node}, + reset_node_state(Node), + NewS#state{known = lists:delete(Node, Known), + synced = lists:delete(Node, Syncs)}. + +get_names() -> + ets:select(global_names, + ets:fun2ms(fun({Name, Pid, Method, _RPid, _Ref}) -> + {Name, Pid, Method} + end)). + +get_names_ext() -> + ets:tab2list(global_names_ext). + +get_known() -> + gen_server:call(global_name_server, get_known, infinity). + +random_sleep(Times) -> + case (Times rem 10) of + 0 -> erase(random_seed); + _ -> ok + end, + case get(random_seed) of + undefined -> + {A1, A2, A3} = now(), + random:seed(A1, A2, A3 + erlang:phash(node(), 100000)); + _ -> ok + end, + %% First time 1/4 seconds, then doubling each time up to 8 seconds max. + Tmax = if Times > 5 -> 8000; + true -> ((1 bsl Times) * 1000) div 8 + end, + T = random:uniform(Tmax), + ?trace({random_sleep, {me,self()}, {times,Times}, {t,T}, {tmax,Tmax}}), + receive after T -> ok end. + +dec(infinity) -> infinity; +dec(N) -> N - 1. + +send_again(Msg) -> + Me = self(), + spawn(fun() -> timer(Me, Msg) end). + +timer(Pid, Msg) -> + random_sleep(5), + Pid ! Msg. + +change_our_node_name(NewNode, S) -> + S1 = trace_message(S, {new_node_name, NewNode}, []), + S1#state{node_name = NewNode}. + +trace_message(#state{trace = no_trace}=S, _M, _X) -> + S; +trace_message(S, M, X) -> + S#state{trace = [trace_message(M, X) | S#state.trace]}. + +trace_message(M, X) -> + {node(), now(), M, nodes(), X}. + +%%----------------------------------------------------------------- +%% Each sync process corresponds to one call to sync. Each such +%% process asks the global_name_server on all Nodes if it is in sync +%% with Nodes. If not, that (other) node spawns a syncer process that +%% waits for global to get in sync with all Nodes. When it is in +%% sync, the syncer process tells the original sync process about it. +%%----------------------------------------------------------------- +start_sync(Nodes, From) -> + spawn_link(fun() -> sync_init(Nodes, From) end). + +sync_init(Nodes, From) -> + lists:foreach(fun(Node) -> monitor_node(Node, true) end, Nodes), + sync_loop(Nodes, From). + +sync_loop([], From) -> + gen_server:reply(From, ok); +sync_loop(Nodes, From) -> + receive + {nodedown, Node} -> + monitor_node(Node, false), + sync_loop(lists:delete(Node, Nodes), From); + {synced, SNodes} -> + lists:foreach(fun(N) -> monitor_node(N, false) end, SNodes), + sync_loop(Nodes -- SNodes, From) + end. + +%%%======================================================================= +%%% Get the current global_groups definition +%%%======================================================================= +check_sync_nodes() -> + case get_own_nodes() of + {ok, all} -> + nodes(); + {ok, NodesNG} -> + %% global_groups parameter is defined, we are not allowed to sync + %% with nodes not in our own global group. + intersection(nodes(), NodesNG); + {error, _} = Error -> + Error + end. + +check_sync_nodes(SyncNodes) -> + case get_own_nodes() of + {ok, all} -> + SyncNodes; + {ok, NodesNG} -> + %% global_groups parameter is defined, we are not allowed to sync + %% with nodes not in our own global group. + OwnNodeGroup = intersection(nodes(), NodesNG), + IllegalSyncNodes = (SyncNodes -- [node() | OwnNodeGroup]), + case IllegalSyncNodes of + [] -> SyncNodes; + _ -> {error, {"Trying to sync nodes not defined in " + "the own global group", IllegalSyncNodes}} + end; + {error, _} = Error -> + Error + end. + +get_own_nodes() -> + case global_group:get_own_nodes_with_errors() of + {error, Error} -> + {error, {"global_groups definition error", Error}}; + OkTup -> + OkTup + end. + +%%----------------------------------------------------------------- +%% The deleter process is a satellite process to global_name_server +%% that does background batch deleting of names when a process +%% that had globally registered names dies. It is started by and +%% linked to global_name_server. +%%----------------------------------------------------------------- + +start_the_deleter(Global) -> + spawn_link(fun() -> loop_the_deleter(Global) end). + +loop_the_deleter(Global) -> + Deletions = collect_deletions(Global, []), + ?trace({loop_the_deleter, self(), {deletions,Deletions}, + {names,get_names()}}), + %% trans_all_known is called rather than trans/3 with nodes() as + %% third argument. The reason is that known gets updated by + %% new_nodes when the lock is still set. nodes() on the other hand + %% could be updated later (if in_sync is received after the lock + %% is gone). It is not likely that in_sync would be received after + %% the lock has been taken here, but using trans_all_known makes it + %% even less likely. + trans_all_known( + fun(Known) -> + lists:map( + fun({Name,Pid}) -> + gen_server:abcast(Known, global_name_server, + {async_del_name, Name, Pid}) + end, Deletions) + end), + loop_the_deleter(Global). + +collect_deletions(Global, Deletions) -> + receive + {delete_name, Global, Name, Pid} -> + collect_deletions(Global, [{Name,Pid} | Deletions]); + Other -> + unexpected_message(Other, deleter), + collect_deletions(Global, Deletions) + after case Deletions of + [] -> infinity; + _ -> 0 + end -> + lists:reverse(Deletions) + end. + +%% The registrar is a helper process that registers and unregisters +%% names. Since it never dies it assures that names are registered and +%% unregistered on all known nodes. It is started by and linked to +%% global_name_server. + +start_the_registrar() -> + spawn_link(fun() -> loop_the_registrar() end). + +loop_the_registrar() -> + receive + {trans_all_known, Fun, From} -> + ?trace({loop_the_registrar, self(), Fun, From}), + gen_server:reply(From, trans_all_known(Fun)); + Other -> + unexpected_message(Other, register) + end, + loop_the_registrar(). + +unexpected_message({'EXIT', _Pid, _Reason}, _What) -> + %% global_name_server died + ok; +unexpected_message(Message, What) -> + error_logger:warning_msg("The global_name_server ~w process " + "received an unexpected message:\n~p\n", + [What, Message]). + +%%% Utilities + +%% When/if erlang:monitor() returns before trying to connect to the +%% other node this function can be removed. +do_monitor(Pid) -> + case (node(Pid) =:= node()) orelse lists:member(node(Pid), nodes()) of + true -> + %% Assume the node is still up + {Pid, erlang:monitor(process, Pid)}; + false -> + F = fun() -> + Ref = erlang:monitor(process, Pid), + receive + {'DOWN', Ref, process, Pid, _Info} -> + exit(normal) + end + end, + erlang:spawn_monitor(F) + end. + +intersection(_, []) -> + []; +intersection(L1, L2) -> + L1 -- (L1 -- L2). diff --git a/lib/kernel/src/global_group.erl b/lib/kernel/src/global_group.erl new file mode 100644 index 0000000000..7e141ac5c7 --- /dev/null +++ b/lib/kernel/src/global_group.erl @@ -0,0 +1,1347 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1998-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(global_group). + +%% Groups nodes into global groups with an own global name space. + +-behaviour(gen_server). + +%% External exports +-export([start/0, start_link/0, stop/0, init/1]). +-export([handle_call/3, handle_cast/2, handle_info/2, + terminate/2, code_change/3]). + +-export([global_groups/0]). +-export([monitor_nodes/1]). +-export([own_nodes/0]). +-export([registered_names/1]). +-export([send/2]). +-export([send/3]). +-export([whereis_name/1]). +-export([whereis_name/2]). +-export([global_groups_changed/1]). +-export([global_groups_added/1]). +-export([global_groups_removed/1]). +-export([sync/0]). +-export([ng_add_check/2, ng_add_check/3]). + +-export([info/0]). +-export([registered_names_test/1]). +-export([send_test/2]). +-export([whereis_name_test/1]). +-export([get_own_nodes/0, get_own_nodes_with_errors/0]). +-export([publish_on_nodes/0]). + +-export([config_scan/1, config_scan/2]). + +%% Internal exports +-export([sync_init/4]). + + +-define(cc_vsn, 2). + +%%%==================================================================================== + +-type publish_type() :: 'hidden' | 'normal'. +-type sync_state() :: 'no_conf' | 'synced'. + +-type group_name() :: atom(). +-type group_tuple() :: {group_name(), [node()]} + | {group_name(), publish_type(), [node()]}. + + +%%%==================================================================================== +%%% The state of the global_group process +%%% +%%% sync_state = no_conf (global_groups not defined, inital state) | +%%% synced +%%% group_name = Own global group name +%%% nodes = Nodes in the own global group +%%% no_contact = Nodes which we haven't had contact with yet +%%% sync_error = Nodes which we haven't had contact with yet +%%% other_grps = list of other global group names and nodes, [{otherName, [Node]}] +%%% node_name = Own node +%%% monitor = List of Pids requesting nodeup/nodedown +%%%==================================================================================== + +-record(state, {sync_state = no_conf :: sync_state(), + connect_all :: boolean(), + group_name = [] :: group_name() | [], + nodes = [] :: [node()], + no_contact = [] :: [node()], + sync_error = [], + other_grps = [], + node_name = node() :: node(), + monitor = [], + publish_type = normal :: publish_type(), + group_publish_type = normal :: publish_type()}). + + +%%%==================================================================================== +%%% External exported +%%%==================================================================================== + +-spec global_groups() -> {group_name(), [group_name()]} | 'undefined'. +global_groups() -> + request(global_groups). + +-spec monitor_nodes(boolean()) -> 'ok'. +monitor_nodes(Flag) -> + case Flag of + true -> request({monitor_nodes, Flag}); + false -> request({monitor_nodes, Flag}); + _ -> {error, not_boolean} + end. + +-spec own_nodes() -> [node()]. +own_nodes() -> + request(own_nodes). + +-type name() :: atom(). +-type where() :: {'node', node()} | {'group', group_name()}. + +-spec registered_names(where()) -> [name()]. +registered_names(Arg) -> + request({registered_names, Arg}). + +-spec send(name(), term()) -> pid() | {'badarg', {name(), term()}}. +send(Name, Msg) -> + request({send, Name, Msg}). + +-spec send(where(), name(), term()) -> pid() | {'badarg', {name(), term()}}. +send(Group, Name, Msg) -> + request({send, Group, Name, Msg}). + +-spec whereis_name(name()) -> pid() | 'undefined'. +whereis_name(Name) -> + request({whereis_name, Name}). + +-spec whereis_name(where(), name()) -> pid() | 'undefined'. +whereis_name(Group, Name) -> + request({whereis_name, Group, Name}). + +global_groups_changed(NewPara) -> + request({global_groups_changed, NewPara}). + +global_groups_added(NewPara) -> + request({global_groups_added, NewPara}). + +global_groups_removed(NewPara) -> + request({global_groups_removed, NewPara}). + +-spec sync() -> 'ok'. +sync() -> + request(sync). + +ng_add_check(Node, OthersNG) -> + ng_add_check(Node, normal, OthersNG). + +ng_add_check(Node, PubType, OthersNG) -> + request({ng_add_check, Node, PubType, OthersNG}). + +-type info_item() :: {'state', sync_state()} + | {'own_group_name', group_name()} + | {'own_group_nodes', [node()]} + | {'synched_nodes', [node()]} + | {'sync_error', [node()]} + | {'no_contact', [node()]} + | {'other_groups', [group_tuple()]} + | {'monitoring', [pid()]}. + +-spec info() -> [info_item()]. +info() -> + request(info, 3000). + +%% ==== ONLY for test suites ==== +registered_names_test(Arg) -> + request({registered_names_test, Arg}). +send_test(Name, Msg) -> + request({send_test, Name, Msg}). +whereis_name_test(Name) -> + request({whereis_name_test, Name}). +%% ==== ONLY for test suites ==== + + +request(Req) -> + request(Req, infinity). + +request(Req, Time) -> + case whereis(global_group) of + P when is_pid(P) -> + gen_server:call(global_group, Req, Time); + _Other -> + {error, global_group_not_runnig} + end. + +%%%==================================================================================== +%%% gen_server start +%%% +%%% The first thing to happen is to read if the global_groups key is defined in the +%%% .config file. If not defined, the whole system is started as one global_group, +%%% and the services of global_group are superfluous. +%%% Otherwise a sync process is started to check that all nodes in the own global +%%% group have the same configuration. This is done by sending 'conf_check' to all +%%% other nodes and requiring 'conf_check_result' back. +%%% If the nodes are not in agreement of the configuration the global_group process +%%% will remove these nodes from the #state.nodes list. This can be a normal case +%%% at release upgrade when all nodes are not yet upgraded. +%%% +%%% It is possible to manually force a sync of the global_group. This is done for +%%% instance after a release upgrade, after all nodes in the group beeing upgraded. +%%% The nodes are not synced automatically because it would cause the node to be +%%% disconnected from those not yet beeing upgraded. +%%% +%%% The three process dictionary variables (registered_names, send, and whereis_name) +%%% are used to store information needed if the search process crashes. +%%% The search process is a help process to find registered names in the system. +%%%==================================================================================== +start() -> gen_server:start({local, global_group}, global_group, [], []). +start_link() -> gen_server:start_link({local, global_group}, global_group,[],[]). +stop() -> gen_server:call(global_group, stop, infinity). + +init([]) -> + process_flag(priority, max), + ok = net_kernel:monitor_nodes(true), + put(registered_names, [undefined]), + put(send, [undefined]), + put(whereis_name, [undefined]), + process_flag(trap_exit, true), + Ca = case init:get_argument(connect_all) of + {ok, [["false"]]} -> + false; + _ -> + true + end, + PT = publish_arg(), + case application:get_env(kernel, global_groups) of + undefined -> + update_publish_nodes(PT), + {ok, #state{publish_type = PT, + connect_all = Ca}}; + {ok, []} -> + update_publish_nodes(PT), + {ok, #state{publish_type = PT, + connect_all = Ca}}; + {ok, NodeGrps} -> + {DefGroupName, PubTpGrp, DefNodes, DefOther} = + case catch config_scan(NodeGrps, publish_type) of + {error, _Error2} -> + update_publish_nodes(PT), + exit({error, {'invalid global_groups definition', NodeGrps}}); + {DefGroupNameT, PubType, DefNodesT, DefOtherT} -> + update_publish_nodes(PT, {PubType, DefNodesT}), + %% First disconnect any nodes not belonging to our own group + disconnect_nodes(nodes(connected) -- DefNodesT), + lists:foreach(fun(Node) -> + erlang:monitor_node(Node, true) + end, + DefNodesT), + {DefGroupNameT, PubType, lists:delete(node(), DefNodesT), DefOtherT} + end, + {ok, #state{publish_type = PT, group_publish_type = PubTpGrp, + sync_state = synced, group_name = DefGroupName, + no_contact = lists:sort(DefNodes), + other_grps = DefOther}} + end. + + +%%%==================================================================================== +%%% sync() -> ok +%%% +%%% An operator ordered sync of the own global group. This must be done after +%%% a release upgrade. It can also be ordered if somthing has made the nodes +%%% to disagree of the global_groups definition. +%%%==================================================================================== +handle_call(sync, _From, S) -> +% io:format("~p sync ~p~n",[node(), application:get_env(kernel, global_groups)]), + case application:get_env(kernel, global_groups) of + undefined -> + update_publish_nodes(S#state.publish_type), + {reply, ok, S}; + {ok, []} -> + update_publish_nodes(S#state.publish_type), + {reply, ok, S}; + {ok, NodeGrps} -> + {DefGroupName, PubTpGrp, DefNodes, DefOther} = + case catch config_scan(NodeGrps, publish_type) of + {error, _Error2} -> + exit({error, {'invalid global_groups definition', NodeGrps}}); + {DefGroupNameT, PubType, DefNodesT, DefOtherT} -> + update_publish_nodes(S#state.publish_type, {PubType, DefNodesT}), + %% First inform global on all nodes not belonging to our own group + disconnect_nodes(nodes(connected) -- DefNodesT), + %% Sync with the nodes in the own group + kill_global_group_check(), + Pid = spawn_link(?MODULE, sync_init, + [sync, DefGroupNameT, PubType, DefNodesT]), + register(global_group_check, Pid), + {DefGroupNameT, PubType, lists:delete(node(), DefNodesT), DefOtherT} + end, + {reply, ok, S#state{sync_state = synced, group_name = DefGroupName, + no_contact = lists:sort(DefNodes), + other_grps = DefOther, group_publish_type = PubTpGrp}} + end; + + + +%%%==================================================================================== +%%% global_groups() -> {OwnGroupName, [OtherGroupName]} | undefined +%%% +%%% Get the names of the global groups +%%%==================================================================================== +handle_call(global_groups, _From, S) -> + Result = case S#state.sync_state of + no_conf -> + undefined; + synced -> + Other = lists:foldl(fun({N,_L}, Acc) -> Acc ++ [N] + end, + [], S#state.other_grps), + {S#state.group_name, Other} + end, + {reply, Result, S}; + + + +%%%==================================================================================== +%%% monitor_nodes(bool()) -> ok +%%% +%%% Monitor nodes in the own global group. +%%% True => send nodeup/nodedown to the requesting Pid +%%% False => stop sending nodeup/nodedown to the requesting Pid +%%%==================================================================================== +handle_call({monitor_nodes, Flag}, {Pid, _}, StateIn) -> +% io:format("***** handle_call ~p~n",[monitor_nodes]), + {Res, State} = monitor_nodes(Flag, Pid, StateIn), + {reply, Res, State}; + + +%%%==================================================================================== +%%% own_nodes() -> [Node] +%%% +%%% Get a list of nodes in the own global group +%%%==================================================================================== +handle_call(own_nodes, _From, S) -> + Nodes = case S#state.sync_state of + no_conf -> + [node() | nodes()]; + synced -> + get_own_nodes() +% S#state.nodes + end, + {reply, Nodes, S}; + + + +%%%==================================================================================== +%%% registered_names({node, Node}) -> [Name] | {error, ErrorMessage} +%%% registered_names({group, GlobalGroupName}) -> [Name] | {error, ErrorMessage} +%%% +%%% Get the registered names from a specified Node, or GlobalGroupName. +%%%==================================================================================== +handle_call({registered_names, {group, Group}}, _From, S) when Group =:= S#state.group_name -> + Res = global:registered_names(), + {reply, Res, S}; +handle_call({registered_names, {group, Group}}, From, S) -> + case lists:keysearch(Group, 1, S#state.other_grps) of + false -> + {reply, [], S}; + {value, {Group, []}} -> + {reply, [], S}; + {value, {Group, Nodes}} -> + Pid = global_search:start(names, {group, Nodes, From}), + Wait = get(registered_names), + put(registered_names, [{Pid, From} | Wait]), + {noreply, S} + end; +handle_call({registered_names, {node, Node}}, _From, S) when Node =:= node() -> + Res = global:registered_names(), + {reply, Res, S}; +handle_call({registered_names, {node, Node}}, From, S) -> + Pid = global_search:start(names, {node, Node, From}), +% io:format(">>>>> registered_names Pid ~p~n",[Pid]), + Wait = get(registered_names), + put(registered_names, [{Pid, From} | Wait]), + {noreply, S}; + + + +%%%==================================================================================== +%%% send(Name, Msg) -> Pid | {badarg, {Name, Msg}} +%%% send({node, Node}, Name, Msg) -> Pid | {badarg, {Name, Msg}} +%%% send({group, GlobalGroupName}, Name, Msg) -> Pid | {badarg, {Name, Msg}} +%%% +%%% Send the Msg to the specified globally registered Name in own global group, +%%% in specified Node, or GlobalGroupName. +%%% But first the receiver is to be found, the thread is continued at +%%% handle_cast(send_res) +%%%==================================================================================== +%% Search in the whole known world, but check own node first. +handle_call({send, Name, Msg}, From, S) -> + case global:whereis_name(Name) of + undefined -> + Pid = global_search:start(send, {any, S#state.other_grps, Name, Msg, From}), + Wait = get(send), + put(send, [{Pid, From, Name, Msg} | Wait]), + {noreply, S}; + Found -> + Found ! Msg, + {reply, Found, S} + end; +%% Search in the specified global group, which happens to be the own group. +handle_call({send, {group, Grp}, Name, Msg}, _From, S) when Grp =:= S#state.group_name -> + case global:whereis_name(Name) of + undefined -> + {reply, {badarg, {Name, Msg}}, S}; + Pid -> + Pid ! Msg, + {reply, Pid, S} + end; +%% Search in the specified global group. +handle_call({send, {group, Group}, Name, Msg}, From, S) -> + case lists:keysearch(Group, 1, S#state.other_grps) of + false -> + {reply, {badarg, {Name, Msg}}, S}; + {value, {Group, []}} -> + {reply, {badarg, {Name, Msg}}, S}; + {value, {Group, Nodes}} -> + Pid = global_search:start(send, {group, Nodes, Name, Msg, From}), + Wait = get(send), + put(send, [{Pid, From, Name, Msg} | Wait]), + {noreply, S} + end; +%% Search on the specified node. +handle_call({send, {node, Node}, Name, Msg}, From, S) -> + Pid = global_search:start(send, {node, Node, Name, Msg, From}), + Wait = get(send), + put(send, [{Pid, From, Name, Msg} | Wait]), + {noreply, S}; + + + +%%%==================================================================================== +%%% whereis_name(Name) -> Pid | undefined +%%% whereis_name({node, Node}, Name) -> Pid | undefined +%%% whereis_name({group, GlobalGroupName}, Name) -> Pid | undefined +%%% +%%% Get the Pid of a globally registered Name in own global group, +%%% in specified Node, or GlobalGroupName. +%%% But first the process is to be found, +%%% the thread is continued at handle_cast(find_name_res) +%%%==================================================================================== +%% Search in the whole known world, but check own node first. +handle_call({whereis_name, Name}, From, S) -> + case global:whereis_name(Name) of + undefined -> + Pid = global_search:start(whereis, {any, S#state.other_grps, Name, From}), + Wait = get(whereis_name), + put(whereis_name, [{Pid, From} | Wait]), + {noreply, S}; + Found -> + {reply, Found, S} + end; +%% Search in the specified global group, which happens to be the own group. +handle_call({whereis_name, {group, Group}, Name}, _From, S) + when Group =:= S#state.group_name -> + Res = global:whereis_name(Name), + {reply, Res, S}; +%% Search in the specified global group. +handle_call({whereis_name, {group, Group}, Name}, From, S) -> + case lists:keysearch(Group, 1, S#state.other_grps) of + false -> + {reply, undefined, S}; + {value, {Group, []}} -> + {reply, undefined, S}; + {value, {Group, Nodes}} -> + Pid = global_search:start(whereis, {group, Nodes, Name, From}), + Wait = get(whereis_name), + put(whereis_name, [{Pid, From} | Wait]), + {noreply, S} + end; +%% Search on the specified node. +handle_call({whereis_name, {node, Node}, Name}, From, S) -> + Pid = global_search:start(whereis, {node, Node, Name, From}), + Wait = get(whereis_name), + put(whereis_name, [{Pid, From} | Wait]), + {noreply, S}; + + +%%%==================================================================================== +%%% global_groups parameter changed +%%% The node is not resynced automatically because it would cause this node to +%%% be disconnected from those nodes not yet been upgraded. +%%%==================================================================================== +handle_call({global_groups_changed, NewPara}, _From, S) -> + {NewGroupName, PubTpGrp, NewNodes, NewOther} = + case catch config_scan(NewPara, publish_type) of + {error, _Error2} -> + exit({error, {'invalid global_groups definition', NewPara}}); + {DefGroupName, PubType, DefNodes, DefOther} -> + update_publish_nodes(S#state.publish_type, {PubType, DefNodes}), + {DefGroupName, PubType, DefNodes, DefOther} + end, + + %% #state.nodes is the common denominator of previous and new definition + NN = NewNodes -- (NewNodes -- S#state.nodes), + %% rest of the nodes in the new definition are marked as not yet contacted + NNC = (NewNodes -- S#state.nodes) -- S#state.sync_error, + %% remove sync_error nodes not belonging to the new group + NSE = NewNodes -- (NewNodes -- S#state.sync_error), + + %% Disconnect the connection to nodes which are not in our old global group. + %% This is done because if we already are aware of new nodes (to our global + %% group) global is not going to be synced to these nodes. We disconnect instead + %% of connect because upgrades can be done node by node and we cannot really + %% know what nodes these new nodes are synced to. The operator can always + %% manually force a sync of the nodes after all nodes beeing uppgraded. + %% We must disconnect also if some nodes to which we have a connection + %% will not be in any global group at all. + force_nodedown(nodes(connected) -- NewNodes), + + NewS = S#state{group_name = NewGroupName, + nodes = lists:sort(NN), + no_contact = lists:sort(lists:delete(node(), NNC)), + sync_error = lists:sort(NSE), + other_grps = NewOther, + group_publish_type = PubTpGrp}, + {reply, ok, NewS}; + + +%%%==================================================================================== +%%% global_groups parameter added +%%% The node is not resynced automatically because it would cause this node to +%%% be disconnected from those nodes not yet been upgraded. +%%%==================================================================================== +handle_call({global_groups_added, NewPara}, _From, S) -> +% io:format("### global_groups_changed, NewPara ~p ~n",[NewPara]), + {NewGroupName, PubTpGrp, NewNodes, NewOther} = + case catch config_scan(NewPara, publish_type) of + {error, _Error2} -> + exit({error, {'invalid global_groups definition', NewPara}}); + {DefGroupName, PubType, DefNodes, DefOther} -> + update_publish_nodes(S#state.publish_type, {PubType, DefNodes}), + {DefGroupName, PubType, DefNodes, DefOther} + end, + + %% disconnect from those nodes which are not going to be in our global group + force_nodedown(nodes(connected) -- NewNodes), + + %% Check which nodes are already updated + OwnNG = get_own_nodes(), + NGACArgs = case S#state.group_publish_type of + normal -> + [node(), OwnNG]; + _ -> + [node(), S#state.group_publish_type, OwnNG] + end, + {NN, NNC, NSE} = + lists:foldl(fun(Node, {NN_acc, NNC_acc, NSE_acc}) -> + case rpc:call(Node, global_group, ng_add_check, NGACArgs) of + {badrpc, _} -> + {NN_acc, [Node | NNC_acc], NSE_acc}; + agreed -> + {[Node | NN_acc], NNC_acc, NSE_acc}; + not_agreed -> + {NN_acc, NNC_acc, [Node | NSE_acc]} + end + end, + {[], [], []}, lists:delete(node(), NewNodes)), + NewS = S#state{sync_state = synced, group_name = NewGroupName, nodes = lists:sort(NN), + sync_error = lists:sort(NSE), no_contact = lists:sort(NNC), + other_grps = NewOther, group_publish_type = PubTpGrp}, + {reply, ok, NewS}; + + +%%%==================================================================================== +%%% global_groups parameter removed +%%%==================================================================================== +handle_call({global_groups_removed, _NewPara}, _From, S) -> +% io:format("### global_groups_removed, NewPara ~p ~n",[_NewPara]), + update_publish_nodes(S#state.publish_type), + NewS = S#state{sync_state = no_conf, group_name = [], nodes = [], + sync_error = [], no_contact = [], + other_grps = []}, + {reply, ok, NewS}; + + +%%%==================================================================================== +%%% global_groups parameter added to some other node which thinks that we +%%% belong to the same global group. +%%% It could happen that our node is not yet updated with the new node_group parameter +%%%==================================================================================== +handle_call({ng_add_check, Node, PubType, OthersNG}, _From, S) -> + %% Check which nodes are already updated + OwnNG = get_own_nodes(), + case S#state.group_publish_type =:= PubType of + true -> + case OwnNG of + OthersNG -> + NN = [Node | S#state.nodes], + NSE = lists:delete(Node, S#state.sync_error), + NNC = lists:delete(Node, S#state.no_contact), + NewS = S#state{nodes = lists:sort(NN), + sync_error = NSE, + no_contact = NNC}, + {reply, agreed, NewS}; + _ -> + {reply, not_agreed, S} + end; + _ -> + {reply, not_agreed, S} + end; + + + +%%%==================================================================================== +%%% Misceleaneous help function to read some variables +%%%==================================================================================== +handle_call(info, _From, S) -> + Reply = [{state, S#state.sync_state}, + {own_group_name, S#state.group_name}, + {own_group_nodes, get_own_nodes()}, +% {"nodes()", lists:sort(nodes())}, + {synced_nodes, S#state.nodes}, + {sync_error, S#state.sync_error}, + {no_contact, S#state.no_contact}, + {other_groups, S#state.other_grps}, + {monitoring, S#state.monitor}], + + {reply, Reply, S}; + +handle_call(get, _From, S) -> + {reply, get(), S}; + + +%%%==================================================================================== +%%% Only for test suites. These tests when the search process exits. +%%%==================================================================================== +handle_call({registered_names_test, {node, 'test3844zty'}}, From, S) -> + Pid = global_search:start(names_test, {node, 'test3844zty'}), + Wait = get(registered_names), + put(registered_names, [{Pid, From} | Wait]), + {noreply, S}; +handle_call({registered_names_test, {node, _Node}}, _From, S) -> + {reply, {error, illegal_function_call}, S}; +handle_call({send_test, Name, 'test3844zty'}, From, S) -> + Pid = global_search:start(send_test, 'test3844zty'), + Wait = get(send), + put(send, [{Pid, From, Name, 'test3844zty'} | Wait]), + {noreply, S}; +handle_call({send_test, _Name, _Msg }, _From, S) -> + {reply, {error, illegal_function_call}, S}; +handle_call({whereis_name_test, 'test3844zty'}, From, S) -> + Pid = global_search:start(whereis_test, 'test3844zty'), + Wait = get(whereis_name), + put(whereis_name, [{Pid, From} | Wait]), + {noreply, S}; +handle_call({whereis_name_test, _Name}, _From, S) -> + {reply, {error, illegal_function_call}, S}; + +handle_call(Call, _From, S) -> +% io:format("***** handle_call ~p~n",[Call]), + {reply, {illegal_message, Call}, S}. + + + + + +%%%==================================================================================== +%%% registered_names({node, Node}) -> [Name] | {error, ErrorMessage} +%%% registered_names({group, GlobalGroupName}) -> [Name] | {error, ErrorMessage} +%%% +%%% Get a list of nodes in the own global group +%%%==================================================================================== +handle_cast({registered_names, User}, S) -> +% io:format(">>>>> registered_names User ~p~n",[User]), + Res = global:registered_names(), + User ! {registered_names_res, Res}, + {noreply, S}; + +handle_cast({registered_names_res, Result, Pid, From}, S) -> +% io:format(">>>>> registered_names_res Result ~p~n",[Result]), + unlink(Pid), + exit(Pid, normal), + Wait = get(registered_names), + NewWait = lists:delete({Pid, From},Wait), + put(registered_names, NewWait), + gen_server:reply(From, Result), + {noreply, S}; + + + +%%%==================================================================================== +%%% send(Name, Msg) -> Pid | {error, ErrorMessage} +%%% send({node, Node}, Name, Msg) -> Pid | {error, ErrorMessage} +%%% send({group, GlobalGroupName}, Name, Msg) -> Pid | {error, ErrorMessage} +%%% +%%% The registered Name is found; send the message to it, kill the search process, +%%% and return to the requesting process. +%%%==================================================================================== +handle_cast({send_res, Result, Name, Msg, Pid, From}, S) -> +% io:format("~p>>>>> send_res Result ~p~n",[node(), Result]), + case Result of + {badarg,{Name, Msg}} -> + continue; + ToPid -> + ToPid ! Msg + end, + unlink(Pid), + exit(Pid, normal), + Wait = get(send), + NewWait = lists:delete({Pid, From, Name, Msg},Wait), + put(send, NewWait), + gen_server:reply(From, Result), + {noreply, S}; + + + +%%%==================================================================================== +%%% A request from a search process to check if this Name is registered at this node. +%%%==================================================================================== +handle_cast({find_name, User, Name}, S) -> + Res = global:whereis_name(Name), +% io:format(">>>>> find_name Name ~p Res ~p~n",[Name, Res]), + User ! {find_name_res, Res}, + {noreply, S}; + +%%%==================================================================================== +%%% whereis_name(Name) -> Pid | undefined +%%% whereis_name({node, Node}, Name) -> Pid | undefined +%%% whereis_name({group, GlobalGroupName}, Name) -> Pid | undefined +%%% +%%% The registered Name is found; kill the search process +%%% and return to the requesting process. +%%%==================================================================================== +handle_cast({find_name_res, Result, Pid, From}, S) -> +% io:format(">>>>> find_name_res Result ~p~n",[Result]), +% io:format(">>>>> find_name_res get() ~p~n",[get()]), + unlink(Pid), + exit(Pid, normal), + Wait = get(whereis_name), + NewWait = lists:delete({Pid, From},Wait), + put(whereis_name, NewWait), + gen_server:reply(From, Result), + {noreply, S}; + + +%%%==================================================================================== +%%% The node is synced successfully +%%%==================================================================================== +handle_cast({synced, NoContact}, S) -> +% io:format("~p>>>>> synced ~p ~n",[node(), NoContact]), + kill_global_group_check(), + Nodes = get_own_nodes() -- [node() | NoContact], + {noreply, S#state{nodes = lists:sort(Nodes), + sync_error = [], + no_contact = NoContact}}; + + +%%%==================================================================================== +%%% The node could not sync with some other nodes. +%%%==================================================================================== +handle_cast({sync_error, NoContact, ErrorNodes}, S) -> +% io:format("~p>>>>> sync_error ~p ~p ~n",[node(), NoContact, ErrorNodes]), + Txt = io_lib:format("Global group: Could not synchronize with these nodes ~p~n" + "because global_groups were not in agreement. ~n", [ErrorNodes]), + error_logger:error_report(Txt), + kill_global_group_check(), + Nodes = (get_own_nodes() -- [node() | NoContact]) -- ErrorNodes, + {noreply, S#state{nodes = lists:sort(Nodes), + sync_error = ErrorNodes, + no_contact = NoContact}}; + + +%%%==================================================================================== +%%% Another node is checking this node's group configuration +%%%==================================================================================== +handle_cast({conf_check, Vsn, Node, From, sync, CCName, CCNodes}, S) -> + handle_cast({conf_check, Vsn, Node, From, sync, CCName, normal, CCNodes}, S); + +handle_cast({conf_check, Vsn, Node, From, sync, CCName, PubType, CCNodes}, S) -> + CurNodes = S#state.nodes, +% io:format(">>>>> conf_check,sync Node ~p~n",[Node]), + %% Another node is syncing, + %% done for instance after upgrade of global_groups parameter + NS = + case application:get_env(kernel, global_groups) of + undefined -> + %% We didn't have any node_group definition + update_publish_nodes(S#state.publish_type), + disconnect_nodes([Node]), + {global_group_check, Node} ! {config_error, Vsn, From, node()}, + S; + {ok, []} -> + %% Our node_group definition was empty + update_publish_nodes(S#state.publish_type), + disconnect_nodes([Node]), + {global_group_check, Node} ! {config_error, Vsn, From, node()}, + S; + %%--------------------------------- + %% global_groups defined + %%--------------------------------- + {ok, NodeGrps} -> + case catch config_scan(NodeGrps, publish_type) of + {error, _Error2} -> + %% Our node_group definition was erroneous + disconnect_nodes([Node]), + {global_group_check, Node} ! {config_error, Vsn, From, node()}, + S#state{nodes = lists:delete(Node, CurNodes)}; + + {CCName, PubType, CCNodes, _OtherDef} -> + %% OK, add the node to the #state.nodes if it isn't there + update_publish_nodes(S#state.publish_type, {PubType, CCNodes}), + global_name_server ! {nodeup, Node}, + {global_group_check, Node} ! {config_ok, Vsn, From, node()}, + case lists:member(Node, CurNodes) of + false -> + NewNodes = lists:sort([Node | CurNodes]), + NSE = lists:delete(Node, S#state.sync_error), + NNC = lists:delete(Node, S#state.no_contact), + S#state{nodes = NewNodes, + sync_error = NSE, + no_contact = NNC}; + true -> + S + end; + _ -> + %% node_group definitions were not in agreement + disconnect_nodes([Node]), + {global_group_check, Node} ! {config_error, Vsn, From, node()}, + NN = lists:delete(Node, S#state.nodes), + NSE = lists:delete(Node, S#state.sync_error), + NNC = lists:delete(Node, S#state.no_contact), + S#state{nodes = NN, + sync_error = NSE, + no_contact = NNC} + end + end, + {noreply, NS}; + + +handle_cast(_Cast, S) -> +% io:format("***** handle_cast ~p~n",[_Cast]), + {noreply, S}. + + + +%%%==================================================================================== +%%% A node went down. If no global group configuration inform global; +%%% if global group configuration inform global only if the node is one in +%%% the own global group. +%%%==================================================================================== +handle_info({nodeup, Node}, S) when S#state.sync_state =:= no_conf -> +% io:format("~p>>>>> nodeup, Node ~p ~n",[node(), Node]), + send_monitor(S#state.monitor, {nodeup, Node}, S#state.sync_state), + global_name_server ! {nodeup, Node}, + {noreply, S}; +handle_info({nodeup, Node}, S) -> +% io:format("~p>>>>> nodeup, Node ~p ~n",[node(), Node]), + OthersNG = case S#state.sync_state of + synced -> + X = (catch rpc:call(Node, global_group, get_own_nodes, [])), + case X of + X when is_list(X) -> + lists:sort(X); + _ -> + [] + end; + no_conf -> + [] + end, + + NNC = lists:delete(Node, S#state.no_contact), + NSE = lists:delete(Node, S#state.sync_error), + OwnNG = get_own_nodes(), + case OwnNG of + OthersNG -> + send_monitor(S#state.monitor, {nodeup, Node}, S#state.sync_state), + global_name_server ! {nodeup, Node}, + case lists:member(Node, S#state.nodes) of + false -> + NN = lists:sort([Node | S#state.nodes]), + {noreply, S#state{nodes = NN, + no_contact = NNC, + sync_error = NSE}}; + true -> + {noreply, S#state{no_contact = NNC, + sync_error = NSE}} + end; + _ -> + case {lists:member(Node, get_own_nodes()), + lists:member(Node, S#state.sync_error)} of + {true, false} -> + NSE2 = lists:sort([Node | S#state.sync_error]), + {noreply, S#state{no_contact = NNC, + sync_error = NSE2}}; + _ -> + {noreply, S} + end + end; + +%%%==================================================================================== +%%% A node has crashed. +%%% nodedown must always be sent to global; this is a security measurement +%%% because during release upgrade the global_groups parameter is upgraded +%%% before the node is synced. This means that nodedown may arrive from a +%%% node which we are not aware of. +%%%==================================================================================== +handle_info({nodedown, Node}, S) when S#state.sync_state =:= no_conf -> +% io:format("~p>>>>> nodedown, no_conf Node ~p~n",[node(), Node]), + send_monitor(S#state.monitor, {nodedown, Node}, S#state.sync_state), + global_name_server ! {nodedown, Node}, + {noreply, S}; +handle_info({nodedown, Node}, S) -> +% io:format("~p>>>>> nodedown, Node ~p ~n",[node(), Node]), + send_monitor(S#state.monitor, {nodedown, Node}, S#state.sync_state), + global_name_server ! {nodedown, Node}, + NN = lists:delete(Node, S#state.nodes), + NSE = lists:delete(Node, S#state.sync_error), + NNC = case {lists:member(Node, get_own_nodes()), + lists:member(Node, S#state.no_contact)} of + {true, false} -> + [Node | S#state.no_contact]; + _ -> + S#state.no_contact + end, + {noreply, S#state{nodes = NN, no_contact = NNC, sync_error = NSE}}; + + +%%%==================================================================================== +%%% A node has changed its global_groups definition, and is telling us that we are not +%%% included in his group any more. This could happen at release upgrade. +%%%==================================================================================== +handle_info({disconnect_node, Node}, S) -> +% io:format("~p>>>>> disconnect_node Node ~p CN ~p~n",[node(), Node, S#state.nodes]), + case {S#state.sync_state, lists:member(Node, S#state.nodes)} of + {synced, true} -> + send_monitor(S#state.monitor, {nodedown, Node}, S#state.sync_state); + _ -> + cont + end, + global_name_server ! {nodedown, Node}, %% nodedown is used to inform global of the + %% disconnected node + NN = lists:delete(Node, S#state.nodes), + NNC = lists:delete(Node, S#state.no_contact), + NSE = lists:delete(Node, S#state.sync_error), + {noreply, S#state{nodes = NN, no_contact = NNC, sync_error = NSE}}; + + + + +handle_info({'EXIT', ExitPid, Reason}, S) -> + check_exit(ExitPid, Reason), + {noreply, S}; + + +handle_info(_Info, S) -> +% io:format("***** handle_info = ~p~n",[_Info]), + {noreply, S}. + + + +terminate(_Reason, _S) -> + ok. + + +code_change(_OldVsn, State, _Extra) -> + {ok, State}. + + + + + +%%%==================================================================================== +%%% Check the global group configuration. +%%%==================================================================================== + +config_scan(NodeGrps) -> + config_scan(NodeGrps, original). + +config_scan(NodeGrps, original) -> + case config_scan(NodeGrps, publish_type) of + {DefGroupName, _, DefNodes, DefOther} -> + {DefGroupName, DefNodes, DefOther}; + Error -> + Error + end; +config_scan(NodeGrps, publish_type) -> + config_scan(node(), normal, NodeGrps, no_name, [], []). + +config_scan(_MyNode, PubType, [], Own_name, OwnNodes, OtherNodeGrps) -> + {Own_name, PubType, lists:sort(OwnNodes), lists:reverse(OtherNodeGrps)}; +config_scan(MyNode, PubType, [GrpTuple|NodeGrps], Own_name, OwnNodes, OtherNodeGrps) -> + {Name, PubTypeGroup, Nodes} = grp_tuple(GrpTuple), + case lists:member(MyNode, Nodes) of + true -> + case Own_name of + no_name -> + config_scan(MyNode, PubTypeGroup, NodeGrps, Name, Nodes, OtherNodeGrps); + _ -> + {error, {'node defined twice', {Own_name, Name}}} + end; + false -> + config_scan(MyNode,PubType,NodeGrps,Own_name,OwnNodes, + [{Name, Nodes}|OtherNodeGrps]) + end. + +grp_tuple({Name, Nodes}) -> + {Name, normal, Nodes}; +grp_tuple({Name, hidden, Nodes}) -> + {Name, hidden, Nodes}; +grp_tuple({Name, normal, Nodes}) -> + {Name, normal, Nodes}. + + +%%%==================================================================================== +%%% The special process which checks that all nodes in the own global group +%%% agrees on the configuration. +%%%==================================================================================== +sync_init(Type, Cname, PubType, Nodes) -> + {Up, Down} = sync_check_node(lists:delete(node(), Nodes), [], []), + sync_check_init(Type, Up, Cname, Nodes, Down, PubType). + +sync_check_node([], Up, Down) -> + {Up, Down}; +sync_check_node([Node|Nodes], Up, Down) -> + case net_adm:ping(Node) of + pang -> + sync_check_node(Nodes, Up, [Node|Down]); + pong -> + sync_check_node(Nodes, [Node|Up], Down) + end. + + + +%%%------------------------------------------------------------- +%%% Check that all nodes are in agreement of the global +%%% group configuration. +%%%------------------------------------------------------------- +sync_check_init(Type, Up, Cname, Nodes, Down, PubType) -> + sync_check_init(Type, Up, Cname, Nodes, 3, [], Down, PubType). + +sync_check_init(_Type, NoContact, _Cname, _Nodes, 0, ErrorNodes, Down, _PubType) -> + case ErrorNodes of + [] -> + gen_server:cast(global_group, {synced, lists:sort(NoContact ++ Down)}); + _ -> + gen_server:cast(global_group, {sync_error, lists:sort(NoContact ++ Down), + ErrorNodes}) + end, + receive + kill -> + exit(normal) + after 5000 -> + exit(normal) + end; + +sync_check_init(Type, Up, Cname, Nodes, N, ErrorNodes, Down, PubType) -> + ConfCheckMsg = case PubType of + normal -> + {conf_check, ?cc_vsn, node(), self(), Type, Cname, Nodes}; + _ -> + {conf_check, ?cc_vsn, node(), self(), Type, Cname, PubType, Nodes} + end, + lists:foreach(fun(Node) -> + gen_server:cast({global_group, Node}, ConfCheckMsg) + end, Up), + case sync_check(Up) of + {ok, synced} -> + sync_check_init(Type, [], Cname, Nodes, 0, ErrorNodes, Down, PubType); + {error, NewErrorNodes} -> + sync_check_init(Type, [], Cname, Nodes, 0, ErrorNodes ++ NewErrorNodes, Down, PubType); + {more, Rem, NewErrorNodes} -> + %% Try again to reach the global_group, + %% obviously the node is up but not the global_group process. + sync_check_init(Type, Rem, Cname, Nodes, N-1, ErrorNodes ++ NewErrorNodes, Down, PubType) + end. + +sync_check(Up) -> + sync_check(Up, Up, []). + +sync_check([], _Up, []) -> + {ok, synced}; +sync_check([], _Up, ErrorNodes) -> + {error, ErrorNodes}; +sync_check(Rem, Up, ErrorNodes) -> + receive + {config_ok, ?cc_vsn, Pid, Node} when Pid =:= self() -> + global_name_server ! {nodeup, Node}, + sync_check(Rem -- [Node], Up, ErrorNodes); + {config_error, ?cc_vsn, Pid, Node} when Pid =:= self() -> + sync_check(Rem -- [Node], Up, [Node | ErrorNodes]); + {no_global_group_configuration, ?cc_vsn, Pid, Node} when Pid =:= self() -> + sync_check(Rem -- [Node], Up, [Node | ErrorNodes]); + %% Ignore, illegal vsn or illegal Pid + _ -> + sync_check(Rem, Up, ErrorNodes) + after 2000 -> + %% Try again, the previous conf_check message + %% apparently disapared in the magic black hole. + {more, Rem, ErrorNodes} + end. + + +%%%==================================================================================== +%%% A process wants to toggle monitoring nodeup/nodedown from nodes. +%%%==================================================================================== +monitor_nodes(true, Pid, State) -> + link(Pid), + Monitor = State#state.monitor, + {ok, State#state{monitor = [Pid|Monitor]}}; +monitor_nodes(false, Pid, State) -> + Monitor = State#state.monitor, + State1 = State#state{monitor = delete_all(Pid,Monitor)}, + do_unlink(Pid, State1), + {ok, State1}; +monitor_nodes(_, _, State) -> + {error, State}. + +delete_all(From, [From |Tail]) -> delete_all(From, Tail); +delete_all(From, [H|Tail]) -> [H|delete_all(From, Tail)]; +delete_all(_, []) -> []. + +%% do unlink if we have no more references to Pid. +do_unlink(Pid, State) -> + case lists:member(Pid, State#state.monitor) of + true -> + false; + _ -> +% io:format("unlink(Pid) ~p~n",[Pid]), + unlink(Pid) + end. + + + +%%%==================================================================================== +%%% Send a nodeup/down messages to monitoring Pids in the own global group. +%%%==================================================================================== +send_monitor([P|T], M, no_conf) -> safesend_nc(P, M), send_monitor(T, M, no_conf); +send_monitor([P|T], M, SyncState) -> safesend(P, M), send_monitor(T, M, SyncState); +send_monitor([], _, _) -> ok. + +safesend(Name, {Msg, Node}) when is_atom(Name) -> + case lists:member(Node, get_own_nodes()) of + true -> + case whereis(Name) of + undefined -> + {Msg, Node}; + P when is_pid(P) -> + P ! {Msg, Node} + end; + false -> + not_own_group + end; +safesend(Pid, {Msg, Node}) -> + case lists:member(Node, get_own_nodes()) of + true -> + Pid ! {Msg, Node}; + false -> + not_own_group + end. + +safesend_nc(Name, {Msg, Node}) when is_atom(Name) -> + case whereis(Name) of + undefined -> + {Msg, Node}; + P when is_pid(P) -> + P ! {Msg, Node} + end; +safesend_nc(Pid, {Msg, Node}) -> + Pid ! {Msg, Node}. + + + + + + +%%%==================================================================================== +%%% Check which user is associated to the crashed process. +%%%==================================================================================== +check_exit(ExitPid, Reason) -> +% io:format("===EXIT=== ~p ~p ~n~p ~n~p ~n~p ~n~n",[ExitPid, Reason, get(registered_names), get(send), get(whereis_name)]), + check_exit_reg(get(registered_names), ExitPid, Reason), + check_exit_send(get(send), ExitPid, Reason), + check_exit_where(get(whereis_name), ExitPid, Reason). + + +check_exit_reg(undefined, _ExitPid, _Reason) -> + ok; +check_exit_reg(Reg, ExitPid, Reason) -> + case lists:keysearch(ExitPid, 1, lists:delete(undefined, Reg)) of + {value, {ExitPid, From}} -> + NewReg = lists:delete({ExitPid, From}, Reg), + put(registered_names, NewReg), + gen_server:reply(From, {error, Reason}); + false -> + not_found_ignored + end. + + +check_exit_send(undefined, _ExitPid, _Reason) -> + ok; +check_exit_send(Send, ExitPid, _Reason) -> + case lists:keysearch(ExitPid, 1, lists:delete(undefined, Send)) of + {value, {ExitPid, From, Name, Msg}} -> + NewSend = lists:delete({ExitPid, From, Name, Msg}, Send), + put(send, NewSend), + gen_server:reply(From, {badarg, {Name, Msg}}); + false -> + not_found_ignored + end. + + +check_exit_where(undefined, _ExitPid, _Reason) -> + ok; +check_exit_where(Where, ExitPid, Reason) -> + case lists:keysearch(ExitPid, 1, lists:delete(undefined, Where)) of + {value, {ExitPid, From}} -> + NewWhere = lists:delete({ExitPid, From}, Where), + put(whereis_name, NewWhere), + gen_server:reply(From, {error, Reason}); + false -> + not_found_ignored + end. + + + +%%%==================================================================================== +%%% Kill any possible global_group_check processes +%%%==================================================================================== +kill_global_group_check() -> + case whereis(global_group_check) of + undefined -> + ok; + Pid -> + unlink(Pid), + global_group_check ! kill, + unregister(global_group_check) + end. + + +%%%==================================================================================== +%%% Disconnect nodes not belonging to own global_groups +%%%==================================================================================== +disconnect_nodes(DisconnectNodes) -> + lists:foreach(fun(Node) -> + {global_group, Node} ! {disconnect_node, node()}, + global:node_disconnected(Node) + end, + DisconnectNodes). + + +%%%==================================================================================== +%%% Disconnect nodes not belonging to own global_groups +%%%==================================================================================== +force_nodedown(DisconnectNodes) -> + lists:foreach(fun(Node) -> + erlang:disconnect_node(Node), + global:node_disconnected(Node) + end, + DisconnectNodes). + + +%%%==================================================================================== +%%% Get the current global_groups definition +%%%==================================================================================== +get_own_nodes_with_errors() -> + case application:get_env(kernel, global_groups) of + undefined -> + {ok, all}; + {ok, []} -> + {ok, all}; + {ok, NodeGrps} -> + case catch config_scan(NodeGrps, publish_type) of + {error, Error} -> + {error, Error}; + {_, _, NodesDef, _} -> + {ok, lists:sort(NodesDef)} + end + end. + +get_own_nodes() -> + case get_own_nodes_with_errors() of + {ok, all} -> + []; + {error, _} -> + []; + {ok, Nodes} -> + Nodes + end. + +%%%==================================================================================== +%%% -hidden command line argument +%%%==================================================================================== +publish_arg() -> + case init:get_argument(hidden) of + {ok,[[]]} -> + hidden; + {ok,[["true"]]} -> + hidden; + _ -> + normal + end. + + +%%%==================================================================================== +%%% Own group publication type and nodes +%%%==================================================================================== +own_group() -> + case application:get_env(kernel, global_groups) of + undefined -> + no_group; + {ok, []} -> + no_group; + {ok, NodeGrps} -> + case catch config_scan(NodeGrps, publish_type) of + {error, _} -> + no_group; + {_, PubTpGrp, NodesDef, _} -> + {PubTpGrp, NodesDef} + end + end. + + +%%%==================================================================================== +%%% Help function which computes publication list +%%%==================================================================================== +publish_on_nodes(normal, no_group) -> + all; +publish_on_nodes(hidden, no_group) -> + []; +publish_on_nodes(normal, {normal, _}) -> + all; +publish_on_nodes(hidden, {_, Nodes}) -> + Nodes; +publish_on_nodes(_, {hidden, Nodes}) -> + Nodes. + +%%%==================================================================================== +%%% Update net_kernels publication list +%%%==================================================================================== +update_publish_nodes(PubArg) -> + update_publish_nodes(PubArg, no_group). +update_publish_nodes(PubArg, MyGroup) -> + net_kernel:update_publish_nodes(publish_on_nodes(PubArg, MyGroup)). + + +%%%==================================================================================== +%%% Fetch publication list +%%%==================================================================================== +publish_on_nodes() -> + publish_on_nodes(publish_arg(), own_group()). diff --git a/lib/kernel/src/global_search.erl b/lib/kernel/src/global_search.erl new file mode 100644 index 0000000000..b723e18a1b --- /dev/null +++ b/lib/kernel/src/global_search.erl @@ -0,0 +1,279 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1998-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(global_search). + +%% Search for globally registered names in the global groups. +%% This is a help module to the global_group.erl + + +%% External exports +-export([start/2]). +-export([init_send/1]). +-export([init_whereis/1]). +-export([init_names/1]). + + +%% ONLY for test purpose +-export([send_test/1]). +-export([whereis_test/1]). +-export([names_test/1]). + + + + +%%%==================================================================================== +%%% The search is done in a process separate from the global_group process +%%%==================================================================================== +start(Flag, Arg) -> + case Flag of + send -> + spawn_link(?MODULE, init_send, [Arg]); + whereis -> + spawn_link(?MODULE, init_whereis, [Arg]); + names -> + spawn_link(?MODULE, init_names, [Arg]); + %% ONLY for test suites, tests what happens when this process exits. + send_test -> + spawn_link(?MODULE, send_test, [Arg]); + whereis_test -> + spawn_link(?MODULE, whereis_test, [Arg]); + names_test -> + spawn_link(?MODULE, names_test, [Arg]) + end. + + +%%%==================================================================================== +%%%==================================================================================== +%%%==================================================================================== +%%% Search after a registered global Name anywhere (any), in a specified group or +%%% in a specified node. +%%% Return the result to the global_group process in own node and wait for +%%% this process to be killed. +%%%==================================================================================== +%%%==================================================================================== +%%%==================================================================================== + +init_send({any, NodesList, Name, Msg, From}) -> + case whereis_any_loop(NodesList, Name) of + undefined -> + Res = {badarg,{Name, Msg}}, + gen_server:cast(global_group, {send_res, Res, Name, Msg, self(), From}); + Pid -> + gen_server:cast(global_group, {send_res, Pid, Name, Msg, self(), From}) + end, + end_loop(); +init_send({group, Nodes, Name, Msg, From}) -> + case whereis_group_loop(Nodes, Name) of + group_down -> + Res = {badarg,{Name, Msg}}, + gen_server:cast(global_group, {send_res, Res, Name, Msg, self(), From}); + undefined -> + Res = {badarg,{Name, Msg}}, + gen_server:cast(global_group, {send_res, Res, Name, Msg, self(), From}); + Pid -> + gen_server:cast(global_group, {send_res, Pid, Name, Msg, self(), From}) + end, + end_loop(); +init_send({node, Node, Name, Msg, From}) -> + case whereis_check_node(Node, Name) of + node_down -> + Res = {badarg,{Name, Msg}}, + gen_server:cast(global_group, {send_res, Res, Name, Msg, self(), From}); + undefined -> + Res = {badarg,{Name, Msg}}, + gen_server:cast(global_group, {send_res, Res, Name, Msg, self(), From}); + Pid -> + gen_server:cast(global_group, {send_res, Pid, Name, Msg, self(), From}) + end, + end_loop(). + + +%%%==================================================================================== +%%%==================================================================================== +%%%==================================================================================== +%%% Search after a registered global Name anywhere (any), in a specified group or +%%% in a specified node. +%%% Return the result to the global_group process in own node and wait for +%%% this process to be killed. +%%%==================================================================================== +%%%==================================================================================== +%%%==================================================================================== + +init_whereis({any, NodesList, Name, From}) -> + R = whereis_any_loop(NodesList, Name), + gen_server:cast(global_group, {find_name_res, R, self(), From}), + end_loop(); +init_whereis({group, Nodes, Name, From}) -> + case whereis_group_loop(Nodes, Name) of + group_down -> + gen_server:cast(global_group, {find_name_res, undefined, self(), From}); + R -> + gen_server:cast(global_group, {find_name_res, R, self(), From}) + end, + end_loop(); +init_whereis({node, Node, Name, From}) -> + case whereis_check_node(Node, Name) of + node_down -> + gen_server:cast(global_group, {find_name_res, undefined, self(), From}); + R -> + gen_server:cast(global_group, {find_name_res, R, self(), From}) + end, + end_loop(). + + +%%%==================================================================================== +%%%==================================================================================== +%%%==================================================================================== +%%% Get the registered names, in a specified group or in a specified node. +%%% Return the result to the global_group process in own node and wait for +%%% this process to be killed. +%%%==================================================================================== +%%%==================================================================================== +%%%==================================================================================== +init_names({group, Nodes, From}) -> + case names_group_loop(Nodes) of + group_down -> + gen_server:cast(global_group, {registered_names_res, [], self(), From}); + R -> + gen_server:cast(global_group, {registered_names_res, R, self(), From}) + end, + end_loop(); +init_names({node, Node, From}) -> + case names_check_node(Node) of + node_down -> + gen_server:cast(global_group, {registered_names_res, [], self(), From}); + R -> + gen_server:cast(global_group, {registered_names_res, R, self(), From}) + end, + end_loop(). + +%%%==================================================================================== +%%% Wait for the kill message. +%%%==================================================================================== + +-spec end_loop() -> no_return(). + +end_loop() -> + receive + kill -> + exit(normal) + end. + +%%%==================================================================================== +%%% Search for the globally registered name in the whole known world. +%%%==================================================================================== +whereis_any_loop([], _Name) -> + undefined; +whereis_any_loop([{_Group_name, Nodes}|T], Name) -> + case whereis_group_loop(Nodes, Name) of + group_down -> + whereis_any_loop(T, Name); + undefined -> + whereis_any_loop(T, Name); + R -> + R + end. + +%%%==================================================================================== +%%% Search for the globally registered name in a specified global group. +%%%==================================================================================== +whereis_group_loop([], _Name) -> + group_down; +whereis_group_loop([Node|T], Name) -> + case whereis_check_node(Node, Name) of + node_down -> + whereis_group_loop(T, Name); + R -> + R + end. +%%%==================================================================================== +%%% Search for the globally registered name on a specified node. +%%%==================================================================================== +whereis_check_node(Node, Name) -> + case net_adm:ping(Node) of + pang -> + node_down; + pong -> + monitor_node(Node, true), + gen_server:cast({global_group, Node},{find_name, self(), Name}), + receive + {nodedown, Node} -> + node_down; + {find_name_res, Result} -> + monitor_node(Node, false), + Result + end + end. + + + + +%%%==================================================================================== +%%% Search for all globally registered name in a specified global group. +%%%==================================================================================== +names_group_loop([]) -> + group_down; +names_group_loop([Node|T]) -> + case names_check_node(Node) of + node_down -> + names_group_loop(T); + R -> + R + end. +%%%==================================================================================== +%%% Search for all globally registered name on a specified node. +%%%==================================================================================== +names_check_node(Node) -> + case net_adm:ping(Node) of + pang -> + node_down; + pong -> + monitor_node(Node, true), + gen_server:cast({global_group, Node},{registered_names, self()}), + receive + {nodedown, Node} -> + node_down; + {registered_names_res, Result} -> + monitor_node(Node, false), + Result + end + end. + + + + + + +%%%==================================================================================== +%%% Test what happens when this process exits. +%%%==================================================================================== +send_test(_Args) -> + timer:sleep(5000), + exit(testing_exit). + +whereis_test(_Args) -> + timer:sleep(5000), + exit(testing_exit). + +names_test(_Args) -> + timer:sleep(5000), + exit(testing_exit). + + + diff --git a/lib/kernel/src/group.erl b/lib/kernel/src/group.erl new file mode 100644 index 0000000000..a45ba34eae --- /dev/null +++ b/lib/kernel/src/group.erl @@ -0,0 +1,689 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1996-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(group). + +%% A group leader process for user io. + +-export([start/2, start/3, server/3]). +-export([interfaces/1]). + +start(Drv, Shell) -> + start(Drv, Shell, []). + +start(Drv, Shell, Options) -> + spawn_link(group, server, [Drv, Shell, Options]). + +server(Drv, Shell, Options) -> + process_flag(trap_exit, true), + edlin:init(), + put(line_buffer, proplists:get_value(line_buffer, Options, [])), + put(read_mode, list), + put(user_drv, Drv), + put(expand_fun, + proplists:get_value(expand_fun, Options, + fun(B) -> edlin_expand:expand(B) end)), + put(echo, proplists:get_value(echo, Options, true)), + + start_shell(Shell), + server_loop(Drv, get(shell), []). + +%% Return the pid of user_drv and the shell process. +%% Note: We can't ask the group process for this info since it +%% may be busy waiting for data from the driver. +interfaces(Group) -> + case process_info(Group, dictionary) of + {dictionary,Dict} -> + get_pids(Dict, [], false); + _ -> + [] + end. + +get_pids([Drv = {user_drv,_} | Rest], Found, _) -> + get_pids(Rest, [Drv | Found], true); +get_pids([Sh = {shell,_} | Rest], Found, Active) -> + get_pids(Rest, [Sh | Found], Active); +get_pids([_ | Rest], Found, Active) -> + get_pids(Rest, Found, Active); +get_pids([], Found, true) -> + Found; +get_pids([], _Found, false) -> + []. + +%% start_shell(Shell) +%% Spawn a shell with its group_leader from the beginning set to ourselves. +%% If Shell a pid the set its group_leader. + +start_shell({Mod,Func,Args}) -> + start_shell1(Mod, Func, Args); +start_shell({Node,Mod,Func,Args}) -> + start_shell1(net, call, [Node,Mod,Func,Args]); +start_shell(Shell) when is_atom(Shell) -> + start_shell1(Shell, start, []); +start_shell(Shell) when is_function(Shell) -> + start_shell1(Shell); +start_shell(Shell) when is_pid(Shell) -> + group_leader(self(), Shell), % we are the shells group leader + link(Shell), % we're linked to it. + put(shell, Shell); +start_shell(_Shell) -> + ok. + +start_shell1(M, F, Args) -> + G = group_leader(), + group_leader(self(), self()), + case catch apply(M, F, Args) of + Shell when is_pid(Shell) -> + group_leader(G, self()), + link(Shell), % we're linked to it. + put(shell, Shell); + Error -> % start failure + exit(Error) % let the group process crash + end. + +start_shell1(Fun) -> + G = group_leader(), + group_leader(self(), self()), + case catch Fun() of + Shell when is_pid(Shell) -> + group_leader(G, self()), + link(Shell), % we're linked to it. + put(shell, Shell); + Error -> % start failure + exit(Error) % let the group process crash + end. + +server_loop(Drv, Shell, Buf0) -> + receive + {io_request,From,ReplyAs,Req} when is_pid(From) -> + Buf = io_request(Req, From, ReplyAs, Drv, Buf0), + server_loop(Drv, Shell, Buf); + {driver_id,ReplyTo} -> + ReplyTo ! {self(),driver_id,Drv}, + server_loop(Drv, Shell, Buf0); + {Drv, echo, Bool} -> + put(echo, Bool), + server_loop(Drv, Shell, Buf0); + {'EXIT',Drv,interrupt} -> + %% Send interrupt to the shell. + exit_shell(interrupt), + server_loop(Drv, Shell, Buf0); + {'EXIT',Drv,R} -> + exit(R); + {'EXIT',Shell,R} -> + exit(R); + %% We want to throw away any term that we don't handle (standard + %% practice in receive loops), but not any {Drv,_} tuples which are + %% handled in io_request/5. + NotDrvTuple when (not is_tuple(NotDrvTuple)) orelse + (tuple_size(NotDrvTuple) =/= 2) orelse + (element(1, NotDrvTuple) =/= Drv) -> + %% Ignore this unknown message. + server_loop(Drv, Shell, Buf0) + end. + +exit_shell(Reason) -> + case get(shell) of + undefined -> true; + Pid -> exit(Pid, Reason) + end. + +get_tty_geometry(Drv) -> + Drv ! {self(),tty_geometry}, + receive + {Drv,tty_geometry,Geometry} -> + Geometry + after 2000 -> + timeout + end. +get_unicode_state(Drv) -> + Drv ! {self(),get_unicode_state}, + receive + {Drv,get_unicode_state,UniState} -> + UniState; + {Drv,get_unicode_state,error} -> + {error, internal} + after 2000 -> + {error,timeout} + end. +set_unicode_state(Drv,Bool) -> + Drv ! {self(),set_unicode_state,Bool}, + receive + {Drv,set_unicode_state,_OldUniState} -> + ok + after 2000 -> + timeout + end. + + +io_request(Req, From, ReplyAs, Drv, Buf0) -> + case io_request(Req, Drv, Buf0) of + {ok,Reply,Buf} -> + io_reply(From, ReplyAs, Reply), + Buf; + {error,Reply,Buf} -> + io_reply(From, ReplyAs, Reply), + Buf; + {exit,R} -> + %% 'kill' instead of R, since the shell is not always in + %% a state where it is ready to handle a termination + %% message. + exit_shell(kill), + exit(R) + end. + + +%% Put_chars, unicode is the normal message, characters are always in +%%standard unicode +%% format. +%% You might be tempted to send binaries unchecked, but the driver +%% expects unicode, so that is what we should send... +%% io_request({put_chars,unicode,Binary}, Drv, Buf) when is_binary(Binary) -> +%% send_drv(Drv, {put_chars,Binary}), +%% {ok,ok,Buf}; +io_request({put_chars,unicode,Chars}, Drv, Buf) -> + case catch unicode:characters_to_binary(Chars,utf8) of + Binary when is_binary(Binary) -> + send_drv(Drv, {put_chars, unicode, Binary}), + {ok,ok,Buf}; + _ -> + {error,{error,{put_chars, unicode,Chars}},Buf} + end; +io_request({put_chars,unicode,M,F,As}, Drv, Buf) -> + case catch apply(M, F, As) of + Binary when is_binary(Binary) -> + send_drv(Drv, {put_chars, unicode,Binary}), + {ok,ok,Buf}; + Chars -> + case catch unicode:characters_to_binary(Chars,utf8) of + B when is_binary(B) -> + send_drv(Drv, {put_chars, unicode,B}), + {ok,ok,Buf}; + _ -> + {error,{error,F},Buf} + end + end; +io_request({put_chars,latin1,Binary}, Drv, Buf) when is_binary(Binary) -> + send_drv(Drv, {put_chars, unicode,unicode:characters_to_binary(Binary,latin1)}), + {ok,ok,Buf}; +io_request({put_chars,latin1,Chars}, Drv, Buf) -> + case catch unicode:characters_to_binary(Chars,latin1) of + Binary when is_binary(Binary) -> + send_drv(Drv, {put_chars, unicode,Binary}), + {ok,ok,Buf}; + _ -> + {error,{error,{put_chars,Chars}},Buf} + end; +io_request({put_chars,latin1,M,F,As}, Drv, Buf) -> + case catch apply(M, F, As) of + Binary when is_binary(Binary) -> + send_drv(Drv, {put_chars, unicode,unicode:characters_to_binary(Binary,latin1)}), + {ok,ok,Buf}; + Chars -> + case catch unicode:characters_to_binary(Chars,latin1) of + B when is_binary(B) -> + send_drv(Drv, {put_chars, unicode,B}), + {ok,ok,Buf}; + _ -> + {error,{error,F},Buf} + end + end; + +io_request({get_chars,Encoding,Prompt,N}, Drv, Buf) -> + get_chars(Prompt, io_lib, collect_chars, N, Drv, Buf, Encoding); +io_request({get_line,Encoding,Prompt}, Drv, Buf) -> + get_chars(Prompt, io_lib, collect_line, [], Drv, Buf, Encoding); +io_request({get_until,Encoding, Prompt,M,F,As}, Drv, Buf) -> + get_chars(Prompt, io_lib, get_until, {M,F,As}, Drv, Buf, Encoding); +io_request({get_password,_Encoding},Drv,Buf) -> + get_password_chars(Drv, Buf); +io_request({setopts,Opts}, Drv, Buf) when is_list(Opts) -> + setopts(Opts, Drv, Buf); +io_request(getopts, Drv, Buf) -> + getopts(Drv, Buf); +io_request({requests,Reqs}, Drv, Buf) -> + io_requests(Reqs, {ok,ok,Buf}, Drv); + +%% New in R12 +io_request({get_geometry,columns},Drv,Buf) -> + case get_tty_geometry(Drv) of + {W,_H} -> + {ok,W,Buf}; + _ -> + {error,{error,enotsup},Buf} + end; +io_request({get_geometry,rows},Drv,Buf) -> + case get_tty_geometry(Drv) of + {_W,H} -> + {ok,H,Buf}; + _ -> + {error,{error,enotsup},Buf} + end; + +%% BC with pre-R13 +io_request({put_chars,Chars}, Drv, Buf) -> + io_request({put_chars,latin1,Chars}, Drv, Buf); +io_request({put_chars,M,F,As}, Drv, Buf) -> + io_request({put_chars,latin1,M,F,As}, Drv, Buf); +io_request({get_chars,Prompt,N}, Drv, Buf) -> + io_request({get_chars,latin1,Prompt,N}, Drv, Buf); +io_request({get_line,Prompt}, Drv, Buf) -> + io_request({get_line,latin1,Prompt}, Drv, Buf); +io_request({get_until, Prompt,M,F,As}, Drv, Buf) -> + io_request({get_until,latin1, Prompt,M,F,As}, Drv, Buf); +io_request(get_password,Drv,Buf) -> + io_request({get_password,latin1},Drv,Buf); + + + +io_request(_, _Drv, Buf) -> + {error,{error,request},Buf}. + +%% Status = io_requests(RequestList, PrevStat, Drv) +%% Process a list of output requests as long as the previous status is 'ok'. + +io_requests([R|Rs], {ok,ok,Buf}, Drv) -> + io_requests(Rs, io_request(R, Drv, Buf), Drv); +io_requests([_|_], Error, _Drv) -> + Error; +io_requests([], Stat, _) -> + Stat. + +%% io_reply(From, ReplyAs, Reply) +%% The function for sending i/o command acknowledgement. +%% The ACK contains the return value. + +io_reply(From, ReplyAs, Reply) -> + From ! {io_reply,ReplyAs,Reply}. + +%% send_drv(Drv, Message) +%% send_drv_reqs(Drv, Requests) + +send_drv(Drv, Msg) -> + Drv ! {self(),Msg}. + +send_drv_reqs(_Drv, []) -> []; +send_drv_reqs(Drv, Rs) -> + send_drv(Drv, {requests,Rs}). + +expand_encoding([]) -> + []; +expand_encoding([latin1 | T]) -> + [{encoding,latin1} | expand_encoding(T)]; +expand_encoding([unicode | T]) -> + [{encoding,unicode} | expand_encoding(T)]; +expand_encoding([H|T]) -> + [H|expand_encoding(T)]. +%% setopts +setopts(Opts0,Drv,Buf) -> + Opts = proplists:unfold( + proplists:substitute_negations( + [{list,binary}], + expand_encoding(Opts0))), + case check_valid_opts(Opts) of + true -> + do_setopts(Opts,Drv,Buf); + false -> + {error,{error,enotsup},Buf} + end. +check_valid_opts([]) -> + true; +check_valid_opts([{binary,_}|T]) -> + check_valid_opts(T); +check_valid_opts([{encoding,Valid}|T]) when Valid =:= unicode; Valid =:= utf8; Valid =:= latin1 -> + check_valid_opts(T); +check_valid_opts([{echo,_}|T]) -> + check_valid_opts(T); +check_valid_opts([{expand_fun,_}|T]) -> + check_valid_opts(T); +check_valid_opts(_) -> + false. + +do_setopts(Opts, Drv, Buf) -> + put(expand_fun, proplists:get_value(expand_fun, Opts, get(expand_fun))), + put(echo, proplists:get_value(echo, Opts, get(echo))), + case proplists:get_value(encoding,Opts) of + Valid when Valid =:= unicode; Valid =:= utf8 -> + set_unicode_state(Drv,true); + latin1 -> + set_unicode_state(Drv,false); + _ -> + ok + end, + case proplists:get_value(binary, Opts, case get(read_mode) of + binary -> true; + _ -> false + end) of + true -> + put(read_mode, binary), + {ok,ok,Buf}; + false -> + put(read_mode, list), + {ok,ok,Buf}; + _ -> + {ok,ok,Buf} + end. + +getopts(Drv,Buf) -> + Exp = {expand_fun, case get(expand_fun) of + Func when is_function(Func) -> + Func; + _ -> + false + end}, + Echo = {echo, case get(echo) of + Bool when Bool =:= true; Bool =:= false -> + Bool; + _ -> + false + end}, + Bin = {binary, case get(read_mode) of + binary -> + true; + _ -> + false + end}, + Uni = {encoding, case get_unicode_state(Drv) of + true -> unicode; + _ -> latin1 + end}, + {ok,[Exp,Echo,Bin,Uni],Buf}. + + +%% get_chars(Prompt, Module, Function, XtraArgument, Drv, Buffer) +%% Gets characters from the input Drv until as the applied function +%% returns {stop,Result,Rest}. Does not block output until input has been +%% received. +%% Returns: +%% {Result,NewSaveBuffer} +%% {error,What,NewSaveBuffer} + +get_password_chars(Drv,Buf) -> + case get_password_line(Buf, Drv) of + {done, Line, Buf1} -> + {ok, Line, Buf1}; + interrupted -> + {error, {error, interrupted}, []}; + terminated -> + {exit, terminated} + end. + +get_chars(Prompt, M, F, Xa, Drv, Buf, Encoding) -> + Pbs = prompt_bytes(Prompt), + get_chars_loop(Pbs, M, F, Xa, Drv, Buf, start, Encoding). + +get_chars_loop(Pbs, M, F, Xa, Drv, Buf0, State, Encoding) -> + Result = case get(echo) of + true -> + get_line(Buf0, Pbs, Drv, Encoding); + false -> + % get_line_echo_off only deals with lists + % and does not need encoding... + get_line_echo_off(Buf0, Pbs, Drv) + end, + case Result of + {done,Line,Buf1} -> + get_chars_apply(Pbs, M, F, Xa, Drv, Buf1, State, Line, Encoding); + interrupted -> + {error,{error,interrupted},[]}; + terminated -> + {exit,terminated} + end. + +get_chars_apply(Pbs, M, F, Xa, Drv, Buf, State0, Line, Encoding) -> + id(M,F), + case catch M:F(State0, cast(Line,get(read_mode), Encoding), Encoding, Xa) of + {stop,Result,Rest} -> + {ok,Result,append(Rest, Buf, Encoding)}; + {'EXIT',_} -> + {error,{error,err_func(M, F, Xa)},[]}; + State1 -> + get_chars_loop(Pbs, M, F, Xa, Drv, Buf, State1, Encoding) + end. + +id(M,F) -> + {M,F}. +%% Convert error code to make it look as before +err_func(io_lib, get_until, {_,F,_}) -> + F; +err_func(_, F, _) -> + F. + +%% get_line(Chars, PromptBytes, Drv) +%% Get a line with eventual line editing. Handle other io requests +%% while getting line. +%% Returns: +%% {done,LineChars,RestChars} +%% interrupted + +get_line(Chars, Pbs, Drv, Encoding) -> + {more_chars,Cont,Rs} = edlin:start(Pbs), + send_drv_reqs(Drv, Rs), + get_line1(edlin:edit_line(Chars, Cont), Drv, new_stack(get(line_buffer)), + Encoding). + +get_line1({done,Line,Rest,Rs}, Drv, _Ls, _Encoding) -> + send_drv_reqs(Drv, Rs), + put(line_buffer, [Line|lists:delete(Line, get(line_buffer))]), + {done,Line,Rest}; +get_line1({undefined,{_A,Mode,Char},Cs,Cont,Rs}, Drv, Ls0, Encoding) + when ((Mode =:= none) and (Char =:= $\^P)) + or ((Mode =:= meta_left_sq_bracket) and (Char =:= $A)) -> + send_drv_reqs(Drv, Rs), + case up_stack(Ls0) of + {none,_Ls} -> + send_drv(Drv, beep), + get_line1(edlin:edit_line(Cs, Cont), Drv, Ls0, Encoding); + {Lcs,Ls} -> + send_drv_reqs(Drv, edlin:erase_line(Cont)), + {more_chars,Ncont,Nrs} = edlin:start(edlin:prompt(Cont)), + send_drv_reqs(Drv, Nrs), + get_line1(edlin:edit_line1(lists:sublist(Lcs, 1, length(Lcs)-1), + Ncont), + Drv, + Ls, Encoding) + end; +get_line1({undefined,{_A,Mode,Char},_Cs,Cont,Rs}, Drv, Ls0, Encoding) + when ((Mode =:= none) and (Char =:= $\^N)) + or ((Mode =:= meta_left_sq_bracket) and (Char =:= $B)) -> + send_drv_reqs(Drv, Rs), + case down_stack(Ls0) of + {none,Ls} -> + send_drv_reqs(Drv, edlin:erase_line(Cont)), + get_line1(edlin:start(edlin:prompt(Cont)), Drv, Ls, Encoding); + {Lcs,Ls} -> + send_drv_reqs(Drv, edlin:erase_line(Cont)), + {more_chars,Ncont,Nrs} = edlin:start(edlin:prompt(Cont)), + send_drv_reqs(Drv, Nrs), + get_line1(edlin:edit_line1(lists:sublist(Lcs, 1, length(Lcs)-1), + Ncont), + Drv, + Ls, Encoding) + end; +get_line1({expand, Before, Cs0, Cont,Rs}, Drv, Ls0, Encoding) -> + send_drv_reqs(Drv, Rs), + ExpandFun = get(expand_fun), + {Found, Add, Matches} = ExpandFun(Before), + case Found of + no -> send_drv(Drv, beep); + yes -> ok + end, + Cs1 = append(Add, Cs0, Encoding), %%XXX:PaN should this always be unicode? + Cs = case Matches of + [] -> Cs1; + _ -> MatchStr = edlin_expand:format_matches(Matches), + send_drv(Drv, {put_chars, unicode, unicode:characters_to_binary(MatchStr,unicode)}), + [$\^L | Cs1] + end, + get_line1(edlin:edit_line(Cs, Cont), Drv, Ls0, Encoding); +get_line1({undefined,_Char,Cs,Cont,Rs}, Drv, Ls, Encoding) -> + send_drv_reqs(Drv, Rs), + send_drv(Drv, beep), + get_line1(edlin:edit_line(Cs, Cont), Drv, Ls, Encoding); +get_line1({What,Cont0,Rs}, Drv, Ls, Encoding) -> + send_drv_reqs(Drv, Rs), + receive + {Drv,{data,Cs}} -> + get_line1(edlin:edit_line(Cs, Cont0), Drv, Ls, Encoding); + {Drv,eof} -> + get_line1(edlin:edit_line(eof, Cont0), Drv, Ls, Encoding); + {io_request,From,ReplyAs,Req} when is_pid(From) -> + {more_chars,Cont,_More} = edlin:edit_line([], Cont0), + send_drv_reqs(Drv, edlin:erase_line(Cont)), + io_request(Req, From, ReplyAs, Drv, []), %WRONG!!! + send_drv_reqs(Drv, edlin:redraw_line(Cont)), + get_line1({more_chars,Cont,[]}, Drv, Ls, Encoding); + {'EXIT',Drv,interrupt} -> + interrupted; + {'EXIT',Drv,_} -> + terminated + after + get_line_timeout(What)-> + get_line1(edlin:edit_line([], Cont0), Drv, Ls, Encoding) + end. + + +get_line_echo_off(Chars, Pbs, Drv) -> + send_drv_reqs(Drv, [{put_chars, unicode,Pbs}]), + get_line_echo_off1(edit_line(Chars,[]), Drv). + +get_line_echo_off1({Chars,[]}, Drv) -> + receive + {Drv,{data,Cs}} -> + get_line_echo_off1(edit_line(Cs, Chars), Drv); + {Drv,eof} -> + get_line_echo_off1(edit_line(eof, Chars), Drv); + {io_request,From,ReplyAs,Req} when is_pid(From) -> + io_request(Req, From, ReplyAs, Drv, []), + get_line_echo_off1({Chars,[]}, Drv); + {'EXIT',Drv,interrupt} -> + interrupted; + {'EXIT',Drv,_} -> + terminated + end; +get_line_echo_off1({Chars,Rest}, _Drv) -> + {done,lists:reverse(Chars),case Rest of done -> []; _ -> Rest end}. + +%% We support line editing for the ICANON mode except the following +%% line editing characters, which already has another meaning in +%% echo-on mode (See Advanced Programming in the Unix Environment, 2nd ed, +%% Stevens, page 638): +%% - ^u in posix/icanon mode: erase-line, prefix-arg in edlin +%% - ^t in posix/icanon mode: status, transpose-char in edlin +%% - ^d in posix/icanon mode: eof, delete-forward in edlin +%% - ^r in posix/icanon mode: reprint (silly in echo-off mode :-)) +%% - ^w in posix/icanon mode: word-erase (produces a beep in edlin) +edit_line(eof, Chars) -> + {Chars,done}; +edit_line([],Chars) -> + {Chars,[]}; +edit_line([$\r,$\n|Cs],Chars) -> + {[$\n | Chars], remainder_after_nl(Cs)}; +edit_line([NL|Cs],Chars) when NL =:= $\r; NL =:= $\n -> + {[$\n | Chars], remainder_after_nl(Cs)}; +edit_line([Erase|Cs],[]) when Erase =:= $\177; Erase =:= $\^H -> + edit_line(Cs,[]); +edit_line([Erase|Cs],[_|Chars]) when Erase =:= $\177; Erase =:= $\^H -> + edit_line(Cs,Chars); +edit_line([Char|Cs],Chars) -> + edit_line(Cs,[Char|Chars]). + +remainder_after_nl("") -> done; +remainder_after_nl(Cs) -> Cs. + + + +get_line_timeout(blink) -> 1000; +get_line_timeout(more_chars) -> infinity. + +new_stack(Ls) -> {stack,Ls,{},[]}. + +up_stack({stack,[L|U],{},D}) -> + {L,{stack,U,L,D}}; +up_stack({stack,[],{},D}) -> + {none,{stack,[],{},D}}; +up_stack({stack,U,C,D}) -> + up_stack({stack,U,{},[C|D]}). + +down_stack({stack,U,{},[L|D]}) -> + {L,{stack,U,L,D}}; +down_stack({stack,U,{},[]}) -> + {none,{stack,U,{},[]}}; +down_stack({stack,U,C,D}) -> + down_stack({stack,[C|U],{},D}). + +%% This is get_line without line editing (except for backspace) and +%% without echo. +get_password_line(Chars, Drv) -> + get_password1(edit_password(Chars,[]),Drv). + +get_password1({Chars,[]}, Drv) -> + receive + {Drv,{data,Cs}} -> + get_password1(edit_password(Cs,Chars),Drv); + {io_request,From,ReplyAs,Req} when is_pid(From) -> + %send_drv_reqs(Drv, [{delete_chars, -length(Pbs)}]), + io_request(Req, From, ReplyAs, Drv, []), %WRONG!!! + %% I guess the reason the above line is wrong is that Buf is + %% set to []. But do we expect anything but plain output? + + get_password1({Chars, []}, Drv); + {'EXIT',Drv,interrupt} -> + interrupted; + {'EXIT',Drv,_} -> + terminated + end; +get_password1({Chars,Rest},Drv) -> + send_drv_reqs(Drv,[{put_chars, unicode, "\n"}]), + {done,lists:reverse(Chars),case Rest of done -> []; _ -> Rest end}. + +edit_password([],Chars) -> + {Chars,[]}; +edit_password([$\r],Chars) -> + {Chars,done}; +edit_password([$\r|Cs],Chars) -> + {Chars,Cs}; +edit_password([$\177|Cs],[]) -> %% Being able to erase characters is + edit_password(Cs,[]); %% the least we should offer, but +edit_password([$\177|Cs],[_|Chars]) ->%% is backspace enough? + edit_password(Cs,Chars); +edit_password([Char|Cs],Chars) -> + edit_password(Cs,[Char|Chars]). + +%% prompt_bytes(Prompt) +%% Return a flat list of bytes for the Prompt. +prompt_bytes(Prompt) -> + lists:flatten(io_lib:format_prompt(Prompt)). + +cast(L, binary,latin1) when is_list(L) -> + list_to_binary(L); +cast(L, list, latin1) when is_list(L) -> + binary_to_list(list_to_binary(L)); %% Exception if not bytes +cast(L, binary,unicode) when is_list(L) -> + unicode:characters_to_binary(L,utf8); +cast(Other, _, _) -> + Other. + +append(B, L, latin1) when is_binary(B) -> + binary_to_list(B)++L; +append(B, L, unicode) when is_binary(B) -> + unicode:characters_to_list(B,utf8)++L; +append(L1, L2, _) when is_list(L1) -> + L1++L2; +append(_Eof, L, _) -> + L. diff --git a/lib/kernel/src/heart.erl b/lib/kernel/src/heart.erl new file mode 100644 index 0000000000..bad0950fca --- /dev/null +++ b/lib/kernel/src/heart.erl @@ -0,0 +1,271 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1996-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(heart). + +%%%-------------------------------------------------------------------- +%%% This is a rewrite of pre_heart from BS.3. +%%% +%%% The purpose of this process-module is to act as an supervisor +%%% of the entire erlang-system. This 'heart' beats with a frequence +%%% satisfying an external port program *not* reboot the entire +%%% system. If however the erlang-emulator would hang, a reboot is +%%% then needed. +%%% +%%% It recognizes the flag '-heart' +%%%-------------------------------------------------------------------- +-export([start/0, init/2, set_cmd/1, clear_cmd/0, get_cmd/0, cycle/0]). + +-define(START_ACK, 1). +-define(HEART_BEAT, 2). +-define(SHUT_DOWN, 3). +-define(SET_CMD, 4). +-define(CLEAR_CMD, 5). +-define(GET_CMD, 6). +-define(HEART_CMD, 7). + +-define(TIMEOUT, 5000). +-define(CYCLE_TIMEOUT, 10000). + +%%--------------------------------------------------------------------- + +-spec start() -> 'ignore' | {'error', term()} | {'ok', pid()}. + +start() -> + case whereis(heart) of + undefined -> + %% As heart survives a init:restart/0 the Parent + %% of heart must be init. + %% The init process is responsible to create a link + %% to heart. + Pid = spawn(?MODULE, init, [self(), whereis(init)]), + wait_for_init_ack(Pid); + Pid -> + {ok, Pid} + end. + +wait_for_init_ack(From) -> + receive + {ok, From} -> + {ok, From}; + {no_heart, From} -> + ignore; + {Error, From} -> + {error, Error} + end. + +-spec init(pid(), pid()) -> {'no_heart', pid()} | {'start_error', pid()}. + +init(Starter, Parent) -> + process_flag(trap_exit, true), + process_flag(priority, max), + register(heart, self()), + case catch start_portprogram() of + {ok, Port} -> + Starter ! {ok, self()}, + loop(Parent, Port, ""); + no_heart -> + Starter ! {no_heart, self()}; + error -> + Starter ! {start_error, self()} + end. + +-spec set_cmd(string()) -> 'ok' | {'error', {'bad_cmd', string()}}. + +set_cmd(Cmd) -> + heart ! {self(), set_cmd, Cmd}, + wait(). + +-spec get_cmd() -> 'ok'. + +get_cmd() -> + heart ! {self(), get_cmd}, + wait(). + +-spec clear_cmd() -> {'ok', string()}. + +clear_cmd() -> + heart ! {self(), clear_cmd}, + wait(). + + +%%% Should be used solely by the release handler!!!!!!! +-spec cycle() -> 'ok' | {'error', term()}. + +cycle() -> + heart ! {self(), cycle}, + wait(). + +wait() -> + receive + {heart, Res} -> + Res + end. + +start_portprogram() -> + check_start_heart(), + HeartCmd = "heart -pid " ++ os:getpid() ++ " " ++ + get_heart_timeouts(), + try open_port({spawn, HeartCmd}, [{packet, 2}]) of + Port when is_port(Port) -> + case wait_ack(Port) of + ok -> + {ok, Port}; + {error, Reason} -> + report_problem({{port_problem, Reason}, + {heart, start_portprogram, []}}), + error + end + catch + _:Reason -> + report_problem({{open_port, Reason}, + {heart, start_portprogram, []}}), + error + end. + +get_heart_timeouts() -> + HeartOpts = case os:getenv("HEART_BEAT_TIMEOUT") of + false -> ""; + H when is_list(H) -> + "-ht " ++ H + end, + HeartOpts ++ case os:getenv("HEART_BEAT_BOOT_DELAY") of + false -> ""; + W when is_list(W) -> + " -wt " ++ W + end. + +check_start_heart() -> + case init:get_argument(heart) of + {ok, [[]]} -> + ok; + error -> + throw(no_heart); + {ok, [[X|_]|_]} -> + report_problem({{bad_heart_flag, list_to_atom(X)}, + {heart, check_start_heart, []}}), + throw(error) + end. + +wait_ack(Port) -> + receive + {Port, {data, [?START_ACK]}} -> + ok; + {'EXIT', Port, badsig} -> % Since this is not synchronous, skip it! + wait_ack(Port); + {'EXIT', Port, Reason} -> % The port really terminated. + {error, Reason} + end. + +loop(Parent, Port, Cmd) -> + send_heart_beat(Port), + receive + {From, set_cmd, NewCmd} when is_list(NewCmd), length(NewCmd) < 2047 -> + send_heart_cmd(Port, NewCmd), + wait_ack(Port), + From ! {heart, ok}, + loop(Parent, Port, NewCmd); + {From, set_cmd, NewCmd} -> + From ! {heart, {error, {bad_cmd, NewCmd}}}, + loop(Parent, Port, Cmd); + {From, clear_cmd} -> + From ! {heart, ok}, + send_heart_cmd(Port, ""), + wait_ack(Port), + loop(Parent, Port, ""); + {From, get_cmd} -> + From ! {heart, get_heart_cmd(Port)}, + loop(Parent, Port, Cmd); + {From, cycle} -> + %% Calls back to loop + do_cycle_port_program(From, Parent, Port, Cmd); + {'EXIT', Parent, shutdown} -> + no_reboot_shutdown(Port); + {'EXIT', Parent, Reason} -> + exit(Port, Reason), + exit(Reason); + {'EXIT', Port, badsig} -> % we can ignore badsig-messages! + loop(Parent, Port, Cmd); + {'EXIT', Port, _Reason} -> + exit({port_terminated, {heart, loop, [Parent, Port, Cmd]}}); + _ -> + loop(Parent, Port, Cmd) + after + ?TIMEOUT -> + loop(Parent, Port, Cmd) + end. + +-spec no_reboot_shutdown(port()) -> no_return(). + +no_reboot_shutdown(Port) -> + send_shutdown(Port), + receive + {'EXIT', Port, Reason} when Reason =/= badsig -> + exit(normal) + end. + +do_cycle_port_program(Caller, Parent, Port, Cmd) -> + case catch start_portprogram() of + {ok, NewPort} -> + send_shutdown(Port), + receive + {'EXIT', Port, _Reason} -> + send_heart_cmd(NewPort, Cmd), + Caller ! {heart, ok}, + loop(Parent, NewPort, Cmd) + after + ?CYCLE_TIMEOUT -> + %% Huh! Two heart port programs running... + %% well, the old one has to be sick not to respond + %% so we'll settle for the new one... + send_heart_cmd(NewPort, Cmd), + Caller ! {heart, {error, stop_error}}, + loop(Parent, NewPort, Cmd) + end; + no_heart -> + Caller ! {heart, {error, no_heart}}, + loop(Parent, Port, Cmd); + error -> + Caller ! {heart, {error, start_error}}, + loop(Parent, Port, Cmd) + end. + + +%% "Beates" the heart once. +send_heart_beat(Port) -> Port ! {self(), {command, [?HEART_BEAT]}}. + +%% Set a new HEART_COMMAND. +send_heart_cmd(Port, []) -> + Port ! {self(), {command, [?CLEAR_CMD]}}; +send_heart_cmd(Port, Cmd) -> + Port ! {self(), {command, [?SET_CMD|Cmd]}}. + +get_heart_cmd(Port) -> + Port ! {self(), {command, [?GET_CMD]}}, + receive + {Port, {data, [?HEART_CMD | Cmd]}} -> + {ok, Cmd} + end. + +%% Sends shutdown command to the port. +send_shutdown(Port) -> Port ! {self(), {command, [?SHUT_DOWN]}}. + +%% We must report using erlang:display/1 since we don't know whether +%% there is an error_logger available or not. +report_problem(Error) -> + erlang:display(Error). diff --git a/lib/kernel/src/hipe_ext_format.hrl b/lib/kernel/src/hipe_ext_format.hrl new file mode 100644 index 0000000000..102cb49a2b --- /dev/null +++ b/lib/kernel/src/hipe_ext_format.hrl @@ -0,0 +1,41 @@ +%% hipe_x86_ext_format.hrl +%% Definitions for unified external object format +%% Currently: sparc, x86, amd64 +%% Authors: Erik Johansson, Ulf Magnusson + +-define(LOAD_ATOM,0). +-define(LOAD_ADDRESS,1). +-define(CALL_REMOTE,2). +-define(CALL_LOCAL,3). +-define(SDESC,4). +-define(X86ABSPCREL,5). + +-define(TERM,0). +-define(BLOCK,1). +-define(SORTEDBLOCK,2). + +-define(CONST_TYPE2EXT(T), + case T of + term -> ?TERM; + sorted_block -> ?SORTEDBLOCK; + block -> ?BLOCK + end). + +-define(EXT2CONST_TYPE(E), + case E of + ?TERM -> term; + ?SORTEDBLOCK -> sorted_block; + ?BLOCK -> block + end). + +-define(EXT2PATCH_TYPE(E), + case E of + ?LOAD_ATOM -> load_atom; + ?LOAD_ADDRESS -> load_address; + ?SDESC -> sdesc; + ?X86ABSPCREL -> x86_abs_pcrel; + ?CALL_REMOTE -> call_remote; + ?CALL_LOCAL -> call_local + end). + +-define(STACK_DESC(ExnRA, FSize, Arity, Live), {ExnRA, FSize, Arity, Live}). diff --git a/lib/kernel/src/hipe_unified_loader.erl b/lib/kernel/src/hipe_unified_loader.erl new file mode 100644 index 0000000000..7e26d57ced --- /dev/null +++ b/lib/kernel/src/hipe_unified_loader.erl @@ -0,0 +1,894 @@ +%% -*- erlang-indent-level: 2 -*- +%% ======================================================================= +%% Filename : hipe_unified_loader.erl +%% Module : hipe_unified_loader +%% Purpose : To load code into memory and link it to the system. +%% Notes : See hipe_ext_format.hrl for description of the external +%% format. +%% ======================================================================= +%% TODO: +%% Problems with the order in which things are done. +%% export_funs should atomically patch references to make fe and +%% make beam stubs. !! +%% +%% Each function should have two proper databases. +%% Describe the patch algorithm: +%% For each function MFA that is (re)compiled to Address: +%% 1. For the old MFA +%% a. RefsTo = MFA->refers_to +%% b. for each {F,Adr} in RefsTo: remove Adr from F->is_referred +%% c. RefsFrom = MFA->is_referred +%% d. For each {Adr,Type} in RefsFrom: +%% update instr at Adr to refer to Address instead. +%% 2. For the new MFA +%% a. MFA->is_referred=RefsFrom +%% 3. For each function F referenced in the code at Offset: +%% add {Address+Offset,Type} to F->is_referred +%% add {F,Address+Offset} to MFA->refers_to +%% 4. Make Address the entrypoint for MFA +%% +%% Add exporting of exported constants. +%% Add freeing of old code. +%% Inline hipe_sparc_ext_format somehow. +%% ======================================================================= + +-module(hipe_unified_loader). + +-export([chunk_name/1, + %% Only the code and code_server modules may call the entries below! + load_hipe_modules/0, + load_native_code/2, + post_beam_load/1, + load_module/3, + load/2]). + +%%-define(DEBUG,true). +-define(DO_ASSERT,true). +-define(HIPE_LOGGING,true). + +-include("../../hipe/main/hipe.hrl"). +-include("hipe_ext_format.hrl"). + +%% Currently, there is no need to expose these to the outside world. +-define(HS8P_TAG,"HS8P"). +-define(HPPC_TAG,"HPPC"). +-define(HP64_TAG,"HP64"). +-define(HARM_TAG,"HARM"). +-define(HX86_TAG,"HX86"). +-define(HA64_TAG,"HA64"). + +%%======================================================================== + +-spec chunk_name(hipe_architecture()) -> string(). +%% @doc +%% Returns the native code chunk name of the Architecture. +%% (On which presumably we are running.) + +chunk_name(Architecture) -> + case Architecture of + amd64 -> ?HA64_TAG; %% HiPE, x86_64, (implicit: 64-bit, Unix) + arm -> ?HARM_TAG; %% HiPE, arm, v5 (implicit: 32-bit, Linux) + powerpc -> ?HPPC_TAG; %% HiPE, PowerPC (implicit: 32-bit, Linux) + ppc64 -> ?HP64_TAG; %% HiPE, ppc64 (implicit: 64-bit, Linux) + ultrasparc -> ?HS8P_TAG; %% HiPE, SPARC, V8+ (implicit: 32-bit) + x86 -> ?HX86_TAG %% HiPE, x86, (implicit: Unix) + %% Future: HSV9 %% HiPE, SPARC, V9 (implicit: 64-bit) + %% HW32 %% HiPE, x86, Win32 + end. + +%%======================================================================== + +-spec load_hipe_modules() -> 'ok'. +%% @doc +%% Ensures HiPE's loader modules are loaded. +%% Called from code.erl at start-up. + +load_hipe_modules() -> + ok. + +%%======================================================================== + +-spec load_native_code(Mod, binary()) -> 'no_native' | {'module', Mod} + when is_subtype(Mod, atom()). +%% @doc +%% Loads the native code of a module Mod. +%% Returns {module,Mod} on success (for compatibility with +%% code:load_file/1) and the atom `no_native' on failure. + +load_native_code(Mod, Bin) when is_atom(Mod), is_binary(Bin) -> + Architecture = erlang:system_info(hipe_architecture), + try chunk_name(Architecture) of + ChunkTag -> + %% patch_to_emu(Mod), + case code:get_chunk(Bin, ChunkTag) of + undefined -> no_native; + NativeCode when is_binary(NativeCode) -> + OldReferencesToPatch = patch_to_emu_step1(Mod), + case load_module(Mod, NativeCode, Bin, OldReferencesToPatch) of + bad_crc -> no_native; + Result -> Result + end + end + catch + _:_ -> + %% Unknown HiPE architecture. Can't happen (in principle). + no_native + end. + +%%======================================================================== + +-spec post_beam_load(atom()) -> 'ok'. + +post_beam_load(Mod) when is_atom(Mod) -> + Architecture = erlang:system_info(hipe_architecture), + try chunk_name(Architecture) of _ChunkTag -> patch_to_emu(Mod) + catch _:_ -> ok + end. + +%%======================================================================== + +version_check(Version, Mod) when is_atom(Mod) -> + Ver = ?VERSION_STRING(), + case Version < Ver of + true -> + ?msg("WARNING: Module ~w was compiled with HiPE version ~s\n", + [Mod, Version]); + _ -> ok + end. + +%%======================================================================== + +-spec load_module(Mod, binary(), _) -> 'bad_crc' | {'module',Mod} + when is_subtype(Mod,atom()). +load_module(Mod, Bin, Beam) -> + load_module(Mod, Bin, Beam, []). + +load_module(Mod, Bin, Beam, OldReferencesToPatch) -> + ?debug_msg("************ Loading Module ~w ************\n",[Mod]), + %% Loading a whole module, let the BEAM loader patch closures. + put(hipe_patch_closures, false), + load_common(Mod, Bin, Beam, OldReferencesToPatch). + +%%======================================================================== + +-spec load(Mod, binary()) -> 'bad_crc' | {'module',Mod} + when is_subtype(Mod,atom()). +load(Mod, Bin) -> + ?debug_msg("********* Loading funs in module ~w *********\n",[Mod]), + %% Loading just some functions in a module; patch closures separately. + put(hipe_patch_closures, true), + load_common(Mod, Bin, [], []). + +%%------------------------------------------------------------------------ + +load_common(Mod, Bin, Beam, OldReferencesToPatch) -> + %% Unpack the binary. + [{Version, CheckSum}, + ConstAlign, ConstSize, ConstMap, LabelMap, ExportMap, + CodeSize, CodeBinary, Refs, + 0,[] % ColdSize, CRrefs + ] = binary_to_term(Bin), + %% Check that we are loading up-to-date code. + version_check(Version, Mod), + case hipe_bifs:check_crc(CheckSum) of + false -> + ?msg("Warning: not loading native code for module ~w: " + "it was compiled for an incompatible runtime system; " + "please regenerate native code for this runtime system\n", [Mod]), + bad_crc; + true -> + %% Create data segment + {ConstAddr,ConstMap2} = create_data_segment(ConstAlign, ConstSize, ConstMap), + %% Find callees for which we may need trampolines. + CalleeMFAs = find_callee_mfas(Refs), + %% Write the code to memory. + {CodeAddress,Trampolines} = enter_code(CodeSize, CodeBinary, CalleeMFAs, Mod, Beam), + %% Construct CalleeMFA-to-trampoline mapping. + TrampolineMap = mk_trampoline_map(CalleeMFAs, Trampolines), + %% Patch references to code labels in data seg. + patch_consts(LabelMap, ConstAddr, CodeAddress), + %% Find out which functions are being loaded (and where). + %% Note: Addresses are sorted descending. + {MFAs,Addresses} = exports(ExportMap, CodeAddress), + %% Remove references to old versions of the module. + ReferencesToPatch = get_refs_from(MFAs, []), + remove_refs_from(MFAs), + %% Patch all dynamic references in the code. + %% Function calls, Atoms, Constants, System calls + patch(Refs, CodeAddress, ConstMap2, Addresses, TrampolineMap), + %% Tell the system where the loaded funs are. + %% (patches the BEAM code to redirect to native.) + case Beam of + [] -> + export_funs(Addresses); + BeamBinary when is_binary(BeamBinary) -> + %% Find all closures in the code. + ClosurePatches = find_closure_patches(Refs), + AddressesOfClosuresToPatch = + calculate_addresses(ClosurePatches, CodeAddress, Addresses), + export_funs(Addresses), + export_funs(Mod, BeamBinary, Addresses, AddressesOfClosuresToPatch) + end, + %% Redirect references to the old module to the new module's BEAM stub. + patch_to_emu_step2(OldReferencesToPatch), + %% Patch referring functions to call the new function + %% The call to export_funs/1 above updated the native addresses + %% for the targets, so passing 'Addresses' is not needed. + redirect(ReferencesToPatch), + ?debug_msg("****************Loader Finished****************\n", []), + {module,Mod} % for compatibility with code:load_file/1 + end. + +%%---------------------------------------------------------------- +%% Scan the list of patches and build a set (returned as a tuple) +%% of the callees for which we may need trampolines. +%% +find_callee_mfas(Patches) when is_list(Patches) -> + case erlang:system_info(hipe_architecture) of + amd64 -> []; + arm -> find_callee_mfas(Patches, gb_sets:empty(), false); + powerpc -> find_callee_mfas(Patches, gb_sets:empty(), true); + %% ppc64 -> find_callee_mfas(Patches, gb_sets:empty(), true); + ultrasparc -> []; + x86 -> [] + end. + +find_callee_mfas([{Type,Data}|Patches], MFAs, SkipErtsSyms) -> + NewMFAs = + case ?EXT2PATCH_TYPE(Type) of + call_local -> add_callee_mfas(Data, MFAs, SkipErtsSyms); + call_remote -> add_callee_mfas(Data, MFAs, SkipErtsSyms); + %% load_address(function) deliberately ignored + _ -> MFAs + end, + find_callee_mfas(Patches, NewMFAs, SkipErtsSyms); +find_callee_mfas([], MFAs, _SkipErtsSyms) -> + list_to_tuple(gb_sets:to_list(MFAs)). + +add_callee_mfas([{DestMFA,_Offsets}|Refs], MFAs, SkipErtsSyms) -> + NewMFAs = + case SkipErtsSyms of + true -> + %% On PowerPC we put the runtime system below the + %% 32M boundary, which allows BIFs and primops to + %% be called with ba/bla instructions. Hence we do + %% not need trampolines for BIFs or primops. + case bif_address(DestMFA) of + false -> gb_sets:add_element(DestMFA, MFAs); + BifAddress when is_integer(BifAddress) -> MFAs + end; + false -> + %% On ARM we also need trampolines for BIFs and primops. + gb_sets:add_element(DestMFA, MFAs) + end, + add_callee_mfas(Refs, NewMFAs, SkipErtsSyms); +add_callee_mfas([], MFAs, _SkipErtsSyms) -> MFAs. + +%%---------------------------------------------------------------- +%% +mk_trampoline_map([], []) -> []; % archs not using trampolines +mk_trampoline_map(CalleeMFAs, Trampolines) -> + SizeofLong = + case erlang:system_info(hipe_architecture) of + amd64 -> 8; + _ -> 4 + end, + mk_trampoline_map(tuple_size(CalleeMFAs), CalleeMFAs, + Trampolines, SizeofLong, gb_trees:empty()). + +mk_trampoline_map(I, CalleeMFAs, Trampolines, SizeofLong, Map) when I >= 1 -> + MFA = element(I, CalleeMFAs), + %% Trampoline = element(I, Trampolines), + Skip = (I-1)*SizeofLong, + <<_:Skip/binary-unit:8, + Trampoline:SizeofLong/integer-unsigned-native-unit:8, + _/binary>> = Trampolines, + NewMap = gb_trees:insert(MFA, Trampoline, Map), + mk_trampoline_map(I-1, CalleeMFAs, Trampolines, SizeofLong, NewMap); +mk_trampoline_map(0, _, _, _, Map) -> Map. + +%%---------------------------------------------------------------- +%% +trampoline_map_get(_, []) -> []; % archs not using trampolines +trampoline_map_get(MFA, Map) -> gb_trees:get(MFA, Map). + +trampoline_map_lookup(_, []) -> []; % archs not using trampolines +trampoline_map_lookup(Primop, Map) -> + case gb_trees:lookup(Primop, Map) of + {value,X} -> X; + _ -> [] + end. + +%%------------------------------------------------------------------------ + +-record(fundef, {address :: integer(), + mfa :: mfa(), + is_closure :: boolean(), + is_exported :: boolean()}). + +exports(ExportMap, BaseAddress) -> + exports(ExportMap, BaseAddress, [], []). + +exports([Offset,M,F,A,IsClosure,IsExported|Rest], BaseAddress, MFAs, Addresses) -> + MFA = {M,F,A}, + Address = BaseAddress + Offset, + FunDef = #fundef{address=Address, mfa=MFA, is_closure=IsClosure, + is_exported=IsExported}, + exports(Rest, BaseAddress, [MFA|MFAs], [FunDef|Addresses]); +exports([], _, MFAs, Addresses) -> + {MFAs, Addresses}. + +mod({M,_F,_A}) -> M. + +%%------------------------------------------------------------------------ + +calculate_addresses(PatchOffsets, Base, Addresses) -> + RemoteOrLocal = local, % closure code refs are local + [{Data, + offsets_to_addresses(Offsets, Base), + get_native_address(DestMFA, Addresses, RemoteOrLocal)} || + {{DestMFA,_,_}=Data,Offsets} <- PatchOffsets]. + +offsets_to_addresses(Os, Base) -> + [{O+Base,load_fe} || O <- Os]. + +%%------------------------------------------------------------------------ + +find_closure_patches([{Type,Refs} | Rest]) -> + case ?EXT2PATCH_TYPE(Type) of + load_address -> + find_closure_refs(Refs,Rest); + _ -> + find_closure_patches(Rest) + end; +find_closure_patches([]) -> []. + +find_closure_refs([{Dest,Offsets} | Rest], Refs) -> + case Dest of + {closure,Data} -> + [{Data,Offsets}|find_closure_refs(Rest,Refs)]; + _ -> + find_closure_refs(Rest,Refs) + end; +find_closure_refs([], Refs) -> + find_closure_patches(Refs). + +%%------------------------------------------------------------------------ + +export_funs([FunDef | Addresses]) -> + #fundef{address=Address, mfa=MFA, is_closure=IsClosure, + is_exported=IsExported} = FunDef, + ?IF_DEBUG({M,F,A} = MFA, no_debug), + ?IF_DEBUG( + case IsClosure of + false -> + ?debug_msg("LINKING: ~w:~w/~w to (0x~.16b)\n", + [M,F,A, Address]); + true -> + ?debug_msg("LINKING: ~w:~w/~w to closure (0x~.16b)\n", + [M,F,A, Address]) + end, no_debug), + hipe_bifs:set_funinfo_native_address(MFA, Address, IsExported), + hipe_bifs:set_native_address(MFA, Address, IsClosure), + export_funs(Addresses); +export_funs([]) -> + true. + +export_funs(Mod, Beam, Addresses, ClosuresToPatch) -> + Fs = [{F,A,Address} || #fundef{address=Address, mfa={_M,F,A}} <- Addresses], + code:make_stub_module(Mod, Beam, {Fs,ClosuresToPatch}). + +%%======================================================================== +%% Patching +%% @spec patch(refs(), BaseAddress::integer(), ConstAndZone::term(), +%% Addresses::term(), TrampolineMap::term()) -> term() +%% @type refs()=[{RefType::integer(), Reflist::reflist()} | refs()] +%% +%% @type reflist()= [{Data::term(), Offsets::offests()}|reflist()] +%% @type offsets()= [Offset::integer() | offsets()] +%% @doc +%% The patchlist is a list of lists of patches of a type. +%% For each type the list of references is sorted so that several +%% references to the same type of data come after each other +%% (we use this to look up the address of a referred function only once). +%% + +patch([{Type,SortedRefs}|Rest], CodeAddress, ConstMap2, Addresses, TrampolineMap) -> + ?debug_msg("Patching ~w at [~w+offset] with ~w\n", + [Type,CodeAddress,SortedRefs]), + case ?EXT2PATCH_TYPE(Type) of + call_local -> + patch_call(SortedRefs, CodeAddress, Addresses, 'local', TrampolineMap); + call_remote -> + patch_call(SortedRefs, CodeAddress, Addresses, 'remote', TrampolineMap); + Other -> + patch_all(Other, SortedRefs, CodeAddress, {ConstMap2,CodeAddress}, Addresses) + end, + patch(Rest, CodeAddress, ConstMap2, Addresses, TrampolineMap); +patch([], _, _, _, _) -> true. + +%%---------------------------------------------------------------- +%% Handle a 'call_local' or 'call_remote' patch. +%% +patch_call([{DestMFA,Offsets}|SortedRefs], BaseAddress, Addresses, RemoteOrLocal, TrampolineMap) -> + case bif_address(DestMFA) of + false -> + %% Previous code used mfa_to_address(DestMFA, Addresses) + %% here for local calls. That is wrong because even local + %% destinations may not be present in Addresses: they may + %% not have been compiled yet, or they may be BEAM-only + %% functions (e.g. module_info). + DestAddress = get_native_address(DestMFA, Addresses, RemoteOrLocal), + Trampoline = trampoline_map_get(DestMFA, TrampolineMap), + patch_mfa_call_list(Offsets, BaseAddress, DestMFA, DestAddress, Addresses, RemoteOrLocal, Trampoline); + BifAddress when is_integer(BifAddress) -> + Trampoline = trampoline_map_lookup(DestMFA, TrampolineMap), + patch_bif_call_list(Offsets, BaseAddress, BifAddress, Trampoline) + end, + patch_call(SortedRefs, BaseAddress, Addresses, RemoteOrLocal, TrampolineMap); +patch_call([], _, _, _, _) -> + true. + +patch_bif_call_list([Offset|Offsets], BaseAddress, BifAddress, Trampoline) -> + CallAddress = BaseAddress+Offset, + ?ASSERT(assert_local_patch(CallAddress)), + patch_call_insn(CallAddress, BifAddress, Trampoline), + patch_bif_call_list(Offsets, BaseAddress, BifAddress, Trampoline); +patch_bif_call_list([], _, _, _) -> []. + +patch_mfa_call_list([Offset|Offsets], BaseAddress, DestMFA, DestAddress, Addresses, RemoteOrLocal, Trampoline) -> + CallAddress = BaseAddress+Offset, + add_ref(DestMFA, CallAddress, Addresses, 'call', Trampoline, RemoteOrLocal), + ?ASSERT(assert_local_patch(CallAddress)), + patch_call_insn(CallAddress, DestAddress, Trampoline), + patch_mfa_call_list(Offsets, BaseAddress, DestMFA, DestAddress, Addresses, RemoteOrLocal, Trampoline); +patch_mfa_call_list([], _, _, _, _, _, _) -> []. + +patch_call_insn(CallAddress, DestAddress, Trampoline) -> + %% This assertion is false when we're called from redirect/2. + %% ?ASSERT(assert_local_patch(CallAddress)), + hipe_bifs:patch_call(CallAddress, DestAddress, Trampoline). + +%% ____________________________________________________________________ +%% + +patch_all(Type, [{Dest,Offsets}|Rest], BaseAddress, ConstAndZone, Addresses)-> + patch_all_offsets(Type, Dest, Offsets, BaseAddress, ConstAndZone, Addresses), + patch_all(Type, Rest, BaseAddress, ConstAndZone, Addresses); +patch_all(_, [], _, _, _) -> true. + +patch_all_offsets(Type, Data, [Offset|Offsets], BaseAddress, + ConstAndZone, Addresses) -> + ?debug_msg("Patching ~w at [~w+~w] with ~w\n", + [Type,BaseAddress,Offset, Data]), + Address = BaseAddress + Offset, + patch_offset(Type, Data, Address, ConstAndZone, Addresses), + ?debug_msg("Patching done\n",[]), + patch_all_offsets(Type, Data, Offsets, BaseAddress, ConstAndZone, Addresses); +patch_all_offsets(_, _, [], _, _, _) -> true. + +%%---------------------------------------------------------------- +%% Handle any patch type except 'call_local' or 'call_remote'. +%% +patch_offset(Type, Data, Address, ConstAndZone, Addresses) -> + case Type of + load_address -> + patch_load_address(Data, Address, ConstAndZone, Addresses); + load_atom -> + Atom = Data, + patch_atom(Address, Atom); + sdesc -> + patch_sdesc(Data, Address, ConstAndZone); + x86_abs_pcrel -> + patch_instr(Address, Data, x86_abs_pcrel) + %% _ -> + %% ?error_msg("Unknown ref ~w ~w ~w\n", [Type, Address, Data]), + %% exit({unknown_reference, Type, Address, Data}) + end. + +patch_atom(Address, Atom) -> + ?ASSERT(assert_local_patch(Address)), + patch_instr(Address, hipe_bifs:atom_to_word(Atom), atom). + +patch_sdesc(?STACK_DESC(SymExnRA, FSize, Arity, Live), + Address, {_ConstMap2,CodeAddress}) -> + ExnRA = + case SymExnRA of + [] -> 0; % No catch + LabelOffset -> CodeAddress + LabelOffset + end, + ?ASSERT(assert_local_patch(Address)), + hipe_bifs:enter_sdesc({Address, ExnRA, FSize, Arity, Live}). + +%%---------------------------------------------------------------- +%% Handle a 'load_address'-type patch. +%% +patch_load_address(Data, Address, ConstAndZone, Addresses) -> + case Data of + {local_function,DestMFA} -> + patch_load_mfa(Address, DestMFA, Addresses, 'local'); + {remote_function,DestMFA} -> + patch_load_mfa(Address, DestMFA, Addresses, 'remote'); + {constant,Name} -> + {ConstMap2,_CodeAddress} = ConstAndZone, + ConstAddress = find_const(Name, ConstMap2), + patch_instr(Address, ConstAddress, constant); + {closure,{DestMFA,Uniq,Index}} -> + patch_closure(DestMFA, Uniq, Index, Address, Addresses); + {c_const,CConst} -> + patch_instr(Address, bif_address(CConst), c_const) + end. + +patch_closure(DestMFA, Uniq, Index, Address, Addresses) -> + case get(hipe_patch_closures) of + false -> + []; % This is taken care of when registering the module. + true -> % We are not loading a module patch these closures + RemoteOrLocal = local, % closure code refs are local + DestAddress = get_native_address(DestMFA, Addresses, RemoteOrLocal), + BEAMAddress = hipe_bifs:fun_to_address(DestMFA), + FE = hipe_bifs:make_fe(DestAddress, mod(DestMFA), + {Uniq, Index, BEAMAddress}), + ?debug_msg("Patch FE(~w) to 0x~.16b->0x~.16b (emu:0x~.16b)\n", + [DestMFA, FE, DestAddress, BEAMAddress]), + ?ASSERT(assert_local_patch(Address)), + patch_instr(Address, FE, closure) + end. + +%%---------------------------------------------------------------- +%% Patch an instruction loading the address of an MFA. +%% RemoteOrLocal ::= 'remote' | 'local' +%% +patch_load_mfa(CodeAddress, DestMFA, Addresses, RemoteOrLocal) -> + DestAddress = + case bif_address(DestMFA) of + false -> + NativeAddress = get_native_address(DestMFA, Addresses, RemoteOrLocal), + add_ref(DestMFA, CodeAddress, Addresses, 'load_mfa', [], RemoteOrLocal), + NativeAddress; + BifAddress when is_integer(BifAddress) -> + BifAddress + end, + ?ASSERT(assert_local_patch(CodeAddress)), + patch_instr(CodeAddress, DestAddress, 'load_mfa'). + +%%---------------------------------------------------------------- +%% Patch references to code labels in the data segment. +%% +patch_consts(Labels, DataAddress, CodeAddress) -> + lists:foreach(fun (L) -> + patch_label_or_labels(L, DataAddress, CodeAddress) + end, Labels). + +patch_label_or_labels({Pos,Offset}, DataAddress, CodeAddress) -> + ?ASSERT(assert_local_patch(CodeAddress+Offset)), + write_word(DataAddress+Pos, CodeAddress+Offset); +patch_label_or_labels({sorted,Base,UnOrderdList}, DataAddress, CodeAddress) -> + sort_and_write(UnOrderdList, Base, DataAddress, CodeAddress). + +sort_and_write(UnOrderdList, Base, DataAddress, CodeAddress) -> + WriteAndInc = + fun ({_, Offset}, DataPos) -> + ?ASSERT(assert_local_patch(CodeAddress+Offset)), + write_word(DataPos, CodeAddress+Offset) + end, + lists:foldl(WriteAndInc, DataAddress+Base, sort_on_representation(UnOrderdList)). + +sort_on_representation(List) -> + lists:sort([{hipe_bifs:term_to_word(Term), Offset} || + {Term, Offset} <- List]). + +%%-------------------------------------------------------------------- +%% Update an instruction to refer to a value of a given type. +%% +%% Type ::= 'call' | 'load_mfa' | 'x86_abs_pcrel' | 'atom' +%% | 'constant' | 'c_const' | 'closure' +%% +%% Note: the values of this Type are hard-coded in file erl_bif_types.erl +%% +patch_instr(Address, Value, Type) -> + hipe_bifs:patch_insn(Address, Value, Type). + +%%-------------------------------------------------------------------- +%% Write a data word of the machine's natural word size. +%% Returns the address of the next word. +%% +%% XXX: It appears this is used for inserting both code addresses +%% and other data. In HiPE, code addresses are still 32-bit on +%% 64-bit machines. +write_word(DataAddress, DataWord) -> + case erlang:system_info(hipe_architecture) of + amd64 -> + hipe_bifs:write_u64(DataAddress, DataWord), + DataAddress+8; + %% ppc64 -> + %% hipe_bifs:write_u64(DataAddress, DataWord), + %% DataAddress+8; + _ -> + hipe_bifs:write_u32(DataAddress, DataWord), + DataAddress+4 + end. + +%%-------------------------------------------------------------------- + +bif_address({M,F,A}) -> + hipe_bifs:bif_address(M,F,A); +bif_address(Name) when is_atom(Name) -> + hipe_bifs:primop_address(Name). + +%%-------------------------------------------------------------------- +%% create_data_segment/3 takes an object file ConstMap, as produced by +%% hipe_pack_constants:slim_constmap/1, loads the constants into +%% memory, and produces a ConstMap2 mapping each constant's ConstNo to +%% its runtime address, tagged if the constant is a term. +%% +create_data_segment(DataAlign, DataSize, DataList) -> + %%io:format("create_data_segment: \nDataAlign: ~p\nDataSize: ~p\nDataList: ~p\n",[DataAlign,DataSize,DataList]), + DataAddress = hipe_bifs:alloc_data(DataAlign, DataSize), + enter_data(DataList, [], DataAddress, DataSize). + +enter_data(List, ConstMap2, DataAddress, DataSize) -> + case List of + [ConstNo,Offset,Type,Data|Rest] when is_integer(Offset) -> + %%?msg("Const ~w\n",[[ConstNo,Offset,Type,Data]]), + ?ASSERT((Offset >= 0) and (Offset =< DataSize)), + Res = enter_datum(Type, Data, DataAddress+Offset), + enter_data(Rest, [{ConstNo,Res}|ConstMap2], DataAddress, DataSize); + [] -> + {DataAddress, ConstMap2} + end. + +enter_datum(Type, Data, Address) -> + case ?EXT2CONST_TYPE(Type) of + term -> + %% Address is unused for terms + hipe_bifs:term_to_word(hipe_bifs:merge_term(Data)); + sorted_block -> + L = lists:sort([hipe_bifs:term_to_word(Term) || Term <- Data]), + write_words(L, Address), + Address; + block -> + case Data of + {Lbls, []} -> + write_bytes(Lbls, Address); + {Lbls, SortOrder} -> + SortedLbls = [Lbl || {_,Lbl} <- lists:sort(group(Lbls, SortOrder))], + write_words(SortedLbls, Address); + Lbls -> + write_bytes(Lbls, Address) + end, + Address + end. + +group([], []) -> + []; +group([B1,B2,B3,B4|Ls], [O|Os]) -> + [{hipe_bifs:term_to_word(O),bytes_to_32(B4,B3,B2,B1)}|group(Ls,Os)]. + +bytes_to_32(B4,B3,B2,B1) -> + (B4 bsl 24) bor (B3 bsl 16) bor (B2 bsl 8) bor B1. + +write_words([W|Rest], Addr) -> + write_words(Rest, write_word(Addr, W)); +write_words([], Addr) when is_integer(Addr) -> true. + +write_bytes([B|Rest], Addr) -> + hipe_bifs:write_u8(Addr, B), + write_bytes(Rest, Addr+1); +write_bytes([], Addr) when is_integer(Addr) -> true. + +%%% lists:keysearch/3 conses a useless wrapper around the found tuple :-( +%%% otherwise it would have been a good replacement for this loop +find_const(ConstNo, [{ConstNo,Addr}|_ConstMap2]) -> + Addr; +find_const(ConstNo, [_|ConstMap2]) -> + find_const(ConstNo, ConstMap2); +find_const(ConstNo, []) -> + ?error_msg("Constant not found ~w\n",[ConstNo]), + exit({constant_not_found,ConstNo}). + + +%%---------------------------------------------------------------- +%% Record that the code at address 'Address' has a reference +%% of type 'RefType' ('call' or 'load_mfa') to 'CalleeMFA'. +%% 'Addresses' must be an address-descending list from exports/2. +%% +%% If 'RefType' is 'call', then 'Trampoline' may be the address +%% of a stub branching to 'CalleeMFA', where the stub is reachable +%% from 'Address' via a normal call or tailcall instruction. +%% +%% RemoteOrLocal ::= 'remote' | 'local'. +%% + +%% +%% -record(ref, {caller_mfa, address, ref_type, trampoline, remote_or_local}). +%% + +add_ref(CalleeMFA, Address, Addresses, RefType, Trampoline, RemoteOrLocal) -> + CallerMFA = address_to_mfa(Address, Addresses), + %% just a sanity assertion below + true = case RemoteOrLocal of + local -> + {M1,_,_} = CalleeMFA, + {M2,_,_} = CallerMFA, + M1 =:= M2; + remote -> + true + end, + %% io:format("Adding ref ~w\n",[{CallerMFA, CalleeMFA, Address, RefType}]), + hipe_bifs:add_ref(CalleeMFA, {CallerMFA,Address,RefType,Trampoline,RemoteOrLocal}). + +address_to_mfa(Address, [#fundef{address=Adr, mfa=MFA}|_Rest]) when Address >= Adr -> MFA; +address_to_mfa(Address, [_ | Rest]) -> address_to_mfa(Address, Rest); +address_to_mfa(Address, []) -> + ?error_msg("Local adddress not found ~w\n",[Address]), + exit({?MODULE, local_address_not_found}). + +%%---------------------------------------------------------------- +%% Change callers of the given module to instead trap to BEAM. +%% load_native_code/2 calls this just before loading native code. +%% +patch_to_emu(Mod) -> + patch_to_emu_step2(patch_to_emu_step1(Mod)). + +%% Step 1 must occur before the loading of native code updates +%% references information or creates a new BEAM stub module. +patch_to_emu_step1(Mod) -> + case is_loaded(Mod) of + true -> + %% Get exported functions + MFAs = [{Mod,Fun,Arity} || {Fun,Arity} <- Mod:module_info(exports)], + %% get_refs_from/2 only finds references from compiled static + %% call sites to the module, but some native address entries + %% were added as the result of dynamic apply calls. We must + %% purge them too, but we have no explicit record of them. + %% Therefore invalidate all native addresses for the module. + %% emu_make_stubs/1 will repair the ones for compiled static calls. + hipe_bifs:invalidate_funinfo_native_addresses(MFAs), + %% Find all call sites that call these MFAs. As a side-effect, + %% create native stubs for any MFAs that are referred. + ReferencesToPatch = get_refs_from(MFAs, []), + remove_refs_from(MFAs), + ReferencesToPatch; + false -> + %% The first time we load the module, no redirection needs to be done. + [] + end. + +%% Step 2 must occur after the new BEAM stub module is created. +patch_to_emu_step2(ReferencesToPatch) -> + emu_make_stubs(ReferencesToPatch), + redirect(ReferencesToPatch). + +-spec is_loaded(Module::atom()) -> boolean(). +%% @doc Checks whether a module is loaded or not. +is_loaded(M) when is_atom(M) -> + try hipe_bifs:fun_to_address({M,module_info,0}) of + I when is_integer(I) -> true + catch _:_ -> false + end. + +-ifdef(notdef). +emu_make_stubs([{MFA,_Refs}|Rest]) -> + make_stub(MFA), + emu_make_stubs(Rest); +emu_make_stubs([]) -> + []. + +make_stub({_,_,A} = MFA) -> + EmuAddress = hipe_bifs:get_emu_address(MFA), + StubAddress = hipe_bifs:make_native_stub(EmuAddress, A), + hipe_bifs:set_funinfo_native_address(MFA, StubAddress). +-else. +emu_make_stubs(_) -> []. +-endif. + +%%-------------------------------------------------------------------- +%% Given a list of MFAs, tag them with their referred_from references. +%% The resulting {MFA,Refs} list is later passed to redirect/1, once +%% the MFAs have been bound to (possibly new) native-code addresses. +%% +get_refs_from(MFAs, []) -> + mark_referred_from(MFAs), + MFAs. + +mark_referred_from([MFA|MFAs]) -> + hipe_bifs:mark_referred_from(MFA), + mark_referred_from(MFAs); +mark_referred_from([]) -> + []. + +%%-------------------------------------------------------------------- +%% Given a list of MFAs with referred_from references, update their +%% callers to refer to their new native-code addresses. +%% +%% The {MFA,Refs} list must come from get_refs_from/2. +%% +redirect([MFA|Rest]) -> + hipe_bifs:redirect_referred_from(MFA), + redirect(Rest); +redirect([]) -> + ok. + +%%-------------------------------------------------------------------- +%% Given a list of MFAs, remove all referred_from references having +%% any of them as CallerMFA. +%% +%% This is the only place using refers_to. Whenever a reference is +%% added from CallerMFA to CalleeMFA, CallerMFA is added to CalleeMFA's +%% referred_from list, and CalleeMFA is added to CallerMFA's refers_to +%% list. The refers_to list is used here to find the CalleeMFAs whose +%% referred_from lists should be updated. +%% +remove_refs_from([CallerMFA|CallerMFAs]) -> + hipe_bifs:remove_refs_from(CallerMFA), + remove_refs_from(CallerMFAs); +remove_refs_from([]) -> + []. + +%%-------------------------------------------------------------------- + +%% To find the native code of an MFA we need to look in 3 places: +%% 1. If it is compiled now look in the Addresses data structure. +%% 2. Then look in native_addresses from module info. +%% 3. Then (the function might have been singled compiled) look in +%% hipe_funinfo +%% If all else fails create a native stub for the MFA +get_native_address(MFA, Addresses, RemoteOrLocal) -> + case mfa_to_address(MFA, Addresses, RemoteOrLocal) of + Adr when is_integer(Adr) -> Adr; + false -> + IsRemote = + case RemoteOrLocal of + remote -> true; + local -> false + end, + hipe_bifs:find_na_or_make_stub(MFA, IsRemote) + end. + +mfa_to_address(MFA, [#fundef{address=Adr, mfa=MFA, + is_exported=IsExported}|_Rest], RemoteOrLocal) -> + case RemoteOrLocal of + local -> + Adr; + remote -> + case IsExported of + true -> + Adr; + false -> + false + end + end; +mfa_to_address(MFA, [_|Rest], RemoteOrLocal) -> + mfa_to_address(MFA, Rest, RemoteOrLocal); +mfa_to_address(_, [], _) -> false. + +%% ____________________________________________________________________ +%% + +-ifdef(DO_ASSERT). + +-define(init_assert_patch(Base, Size), put(hipe_assert_code_area,{Base,Base+Size})). + +assert_local_patch(Address) when is_integer(Address) -> + {First,Last} = get(hipe_assert_code_area), + Address >= First andalso Address < (Last). + +-else. + +-define(init_assert_patch(Base, Size), ok). + +-endif. + +%% ____________________________________________________________________ +%% + +%% Beam: nil() | binary() (used as a flag) + +enter_code(CodeSize, CodeBinary, CalleeMFAs, Mod, Beam) -> + true = byte_size(CodeBinary) =:= CodeSize, + hipe_bifs:update_code_size(Mod, Beam, CodeSize), + {CodeAddress,Trampolines} = hipe_bifs:enter_code(CodeBinary, CalleeMFAs), + ?init_assert_patch(CodeAddress, byte_size(CodeBinary)), + {CodeAddress,Trampolines}. + diff --git a/lib/kernel/src/inet.erl b/lib/kernel/src/inet.erl new file mode 100644 index 0000000000..b86aa1839e --- /dev/null +++ b/lib/kernel/src/inet.erl @@ -0,0 +1,1342 @@ +%% +%% %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). + +-include("inet.hrl"). +-include("inet_int.hrl"). +-include("inet_sctp.hrl"). + +%% socket +-export([peername/1, sockname/1, port/1, send/2, + setopts/2, getopts/2, + getif/1, getif/0, getiflist/0, getiflist/1, + ifget/3, ifget/2, ifset/3, ifset/2, + getstat/1, getstat/2, + ip/1, stats/0, options/0, + pushf/3, popf/1, close/1, gethostname/0, gethostname/1]). + +-export([connect_options/2, listen_options/2, udp_options/2, sctp_options/2]). + +-export([i/0, i/1, i/2]). + +-export([getll/1, getfd/1, open/7, fdopen/5]). + +-export([tcp_controlling_process/2, udp_controlling_process/2, + tcp_close/1, udp_close/1]). +%% used by socks5 +-export([setsockname/2, setpeername/2]). + +%% resolve +-export([gethostbyname/1, gethostbyname/2, gethostbyname/3, + gethostbyname_tm/3]). +-export([gethostbyaddr/1, gethostbyaddr/2, + gethostbyaddr_tm/2]). + +-export([getservbyname/2, getservbyport/2]). +-export([getaddrs/2, getaddrs/3, getaddrs_tm/3, + getaddr/2, getaddr/3, getaddr_tm/3]). +-export([translate_ip/2]). + +-export([get_rc/0]). + +%% format error +-export([format_error/1]). + +%% timer interface +-export([start_timer/1, timeout/1, timeout/2, stop_timer/1]). + +%% imports +-import(lists, [append/1, duplicate/2, filter/2, foldl/3]). + +%% Record Signature +-define(RS(Record), + {Record, record_info(size, Record)}). +%% Record Signature Check (guard) +-define(RSC(Record, RS), + element(1, Record) =:= element(1, RS), + tuple_size(Record) =:= element(2, RS)). + +%%% --------------------------------- +%%% Contract type definitions + +-type socket() :: port(). +-type posix() :: atom(). + +-type socket_setopt() :: + {'raw', non_neg_integer(), non_neg_integer(), binary()} | + %% TCP/UDP options + {'reuseaddr', boolean()} | + {'keepalive', boolean()} | + {'dontroute', boolean()} | + {'linger', {boolean(), non_neg_integer()}} | + {'broadcast', boolean()} | + {'sndbuf', non_neg_integer()} | + {'recbuf', non_neg_integer()} | + {'priority', non_neg_integer()} | + {'tos', non_neg_integer()} | + {'nodelay', boolean()} | + {'multicast_ttl', non_neg_integer()} | + {'multicast_loop', boolean()} | + {'multicast_if', ip_address()} | + {'add_membership', {ip_address(), ip_address()}} | + {'drop_membership', {ip_address(), ip_address()}} | + {'header', non_neg_integer()} | + {'buffer', non_neg_integer()} | + {'active', boolean() | 'once'} | + {'packet', + 0 | 1 | 2 | 4 | 'raw' | 'sunrm' | 'asn1' | + 'cdr' | 'fcgi' | 'line' | 'tpkt' | 'http' | 'httph' | 'http_bin' | 'httph_bin' } | + {'mode', list() | binary()} | + {'port', 'port', 'term'} | + {'exit_on_close', boolean()} | + {'low_watermark', non_neg_integer()} | + {'high_watermark', non_neg_integer()} | + {'bit8', 'clear' | 'set' | 'on' | 'off'} | + {'send_timeout', non_neg_integer() | 'infinity'} | + {'send_timeout_close', boolean()} | + {'delay_send', boolean()} | + {'packet_size', non_neg_integer()} | + {'read_packets', non_neg_integer()} | + %% SCTP options + {'sctp_rtoinfo', #sctp_rtoinfo{}} | + {'sctp_associnfo', #sctp_assocparams{}} | + {'sctp_initmsg', #sctp_initmsg{}} | + {'sctp_nodelay', boolean()} | + {'sctp_autoclose', non_neg_integer()} | + {'sctp_disable_fragments', boolean()} | + {'sctp_i_want_mapped_v4_addr', boolean()} | + {'sctp_maxseg', non_neg_integer()} | + {'sctp_primary_addr', #sctp_prim{}} | + {'sctp_set_peer_primary_addr', #sctp_setpeerprim{}} | + {'sctp_adaptation_layer', #sctp_setadaptation{}} | + {'sctp_peer_addr_params', #sctp_paddrparams{}} | + {'sctp_default_send_param', #sctp_sndrcvinfo{}} | + {'sctp_events', #sctp_event_subscribe{}} | + {'sctp_delayed_ack_time', #sctp_assoc_value{}}. + +-type socket_getopt() :: + {'raw', + non_neg_integer(), non_neg_integer(), binary()|non_neg_integer()} | + %% TCP/UDP options + 'reuseaddr' | 'keepalive' | 'dontroute' | 'linger' | + 'broadcast' | 'sndbuf' | 'recbuf' | 'priority' | 'tos' | 'nodelay' | + 'multicast_ttl' | 'multicast_loop' | 'multicast_if' | + 'add_membership' | 'drop_membership' | + 'header' | 'buffer' | 'active' | 'packet' | 'mode' | 'port' | + 'exit_on_close' | 'low_watermark' | 'high_watermark' | 'bit8' | + 'send_timeout' | 'send_timeout_close' | + 'delay_send' | 'packet_size' | 'read_packets' | + %% SCTP options + {'sctp_status', #sctp_status{}} | + 'sctp_get_peer_addr_info' | + {'sctp_get_peer_addr_info', #sctp_status{}} | + 'sctp_rtoinfo' | + {'sctp_rtoinfo', #sctp_rtoinfo{}} | + 'sctp_associnfo' | + {'sctp_associnfo', #sctp_assocparams{}} | + 'sctp_initmsg' | + {'sctp_initmsg', #sctp_initmsg{}} | + 'sctp_nodelay' | 'sctp_autoclose' | 'sctp_disable_fragments' | + 'sctp_i_want_mapped_v4_addr' | 'sctp_maxseg' | + {'sctp_primary_addr', #sctp_prim{}} | + {'sctp_set_peer_primary_addr', #sctp_setpeerprim{}} | + 'sctp_adaptation_layer' | + {'sctp_adaptation_layer', #sctp_setadaptation{}} | + {'sctp_peer_addr_params', #sctp_paddrparams{}} | + 'sctp_default_send_param' | + {'sctp_default_send_param', #sctp_sndrcvinfo{}} | + 'sctp_events' | + {'sctp_events', #sctp_event_subscribe{}} | + 'sctp_delayed_ack_time' | + {'sctp_delayed_ack_time', #sctp_assoc_value{}}. + +-type ether_address() :: [0..255]. + +-type if_setopt() :: + {'addr', ip_address()} | + {'broadaddr', ip_address()} | + {'dstaddr', ip_address()} | + {'mtu', non_neg_integer()} | + {'netmask', ip_address()} | + {'flags', ['up' | 'down' | 'broadcast' | 'no_broadcast' | + 'pointtopoint' | 'no_pointtopoint' | + 'running' | 'multicast']} | + {'hwaddr', ether_address()}. + +-type if_getopt() :: + 'addr' | 'broadaddr' | 'dstaddr' | + 'mtu' | 'netmask' | 'flags' |'hwaddr'. + +-type family_option() :: 'inet' | 'inet6'. +-type protocol_option() :: 'tcp' | 'udp' | 'sctp'. +-type stat_option() :: + 'recv_cnt' | 'recv_max' | 'recv_avg' | 'recv_oct' | 'recv_dvi' | + 'send_cnt' | 'send_max' | 'send_avg' | 'send_oct' | 'send_pend'. + +%%% --------------------------------- + +-spec get_rc() -> [{any(),any()}]. + +get_rc() -> + inet_db:get_rc(). + +-spec close(Socket :: socket()) -> 'ok'. + +close(Socket) -> + prim_inet:close(Socket), + receive + {Closed, Socket} when Closed =:= tcp_closed; Closed =:= udp_closed -> + ok + after 0 -> + ok + end. + +-spec peername(Socket :: socket()) -> + {'ok', {ip_address(), non_neg_integer()}} | {'error', posix()}. + +peername(Socket) -> + prim_inet:peername(Socket). + +-spec setpeername(Socket :: socket(), Address :: {ip_address(), ip_port()}) -> + 'ok' | {'error', any()}. + +setpeername(Socket, {IP,Port}) -> + prim_inet:setpeername(Socket, {IP,Port}); +setpeername(Socket, undefined) -> + prim_inet:setpeername(Socket, undefined). + + +-spec sockname(Socket :: socket()) -> + {'ok', {ip_address(), non_neg_integer()}} | {'error', posix()}. + +sockname(Socket) -> + prim_inet:sockname(Socket). + +-spec setsockname(Socket :: socket(), Address :: {ip_address(), ip_port()}) -> + 'ok' | {'error', any()}. + +setsockname(Socket, {IP,Port}) -> + prim_inet:setsockname(Socket, {IP,Port}); +setsockname(Socket, undefined) -> + prim_inet:setsockname(Socket, undefined). + +-spec port(Socket :: socket()) -> {'ok', ip_port()} | {'error', any()}. + +port(Socket) -> + case prim_inet:sockname(Socket) of + {ok, {_,Port}} -> {ok, Port}; + Error -> Error + end. + +-spec send(Socket :: socket(), Packet :: iolist()) -> % iolist()? + 'ok' | {'error', posix()}. + +send(Socket, Packet) -> + prim_inet:send(Socket, Packet). + +-spec setopts(Socket :: socket(), Opts :: [socket_setopt()]) -> + 'ok' | {'error', posix()}. + +setopts(Socket, Opts) -> + prim_inet:setopts(Socket, Opts). + +-spec getopts(Socket :: socket(), Opts :: [socket_getopt()]) -> + {'ok', [socket_setopt()]} | {'error', posix()}. + +getopts(Socket, Opts) -> + prim_inet:getopts(Socket, Opts). + +-spec getiflist(Socket :: socket()) -> + {'ok', [string()]} | {'error', posix()}. + +getiflist(Socket) -> + prim_inet:getiflist(Socket). + +-spec getiflist() -> {'ok', [string()]} | {'error', posix()}. + +getiflist() -> + withsocket(fun(S) -> prim_inet:getiflist(S) end). + +-spec ifget(Socket :: socket(), + Name :: string() | atom(), + Opts :: [if_getopt()]) -> + {'ok', [if_setopt()]} | {'error', posix()}. + +ifget(Socket, Name, Opts) -> + prim_inet:ifget(Socket, Name, Opts). + +-spec ifget(Name :: string() | atom(), Opts :: [if_getopt()]) -> + {'ok', [if_setopt()]} | {'error', posix()}. + +ifget(Name, Opts) -> + withsocket(fun(S) -> prim_inet:ifget(S, Name, Opts) end). + +-spec ifset(Socket :: socket(), + Name :: string() | atom(), + Opts :: [if_setopt()]) -> + 'ok' | {'error', posix()}. + +ifset(Socket, Name, Opts) -> + prim_inet:ifset(Socket, Name, Opts). + +-spec ifset(Name :: string() | atom(), Opts :: [if_setopt()]) -> + 'ok' | {'error', posix()}. + +ifset(Name, Opts) -> + withsocket(fun(S) -> prim_inet:ifset(S, Name, Opts) end). + +-spec getif() -> + {'ok', [{ip_address(), ip_address() | 'undefined', ip_address()}]} | + {'error', posix()}. + +getif() -> + withsocket(fun(S) -> getif(S) end). + +%% backwards compatible getif +-spec getif(Socket :: socket()) -> + {'ok', [{ip_address(), ip_address() | 'undefined', ip_address()}]} | + {'error', posix()}. + +getif(Socket) -> + case prim_inet:getiflist(Socket) of + {ok, IfList} -> + {ok, lists:foldl( + fun(Name,Acc) -> + case prim_inet:ifget(Socket,Name, + [addr,broadaddr,netmask]) of + {ok,[{addr,A},{broadaddr,B},{netmask,M}]} -> + [{A,B,M}|Acc]; + %% Some interfaces does not have a b-addr + {ok,[{addr,A},{netmask,M}]} -> + [{A,undefined,M}|Acc]; + _ -> + Acc + end + end, [], IfList)}; + Error -> Error + end. + +withsocket(Fun) -> + case inet_udp:open(0,[]) of + {ok,Socket} -> + Res = Fun(Socket), + inet_udp:close(Socket), + Res; + Error -> + Error + end. + +pushf(_Socket, Fun, _State) when is_function(Fun) -> + {error, einval}. + +popf(_Socket) -> + {error, einval}. + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% the hostname is not cached any more because this +% could cause troubles on at least windows with plug-and-play +% and network-cards inserted and removed in conjunction with +% use of the DHCP-protocol +% should never fail + +-spec gethostname() -> {'ok', string()}. + +gethostname() -> + case inet_udp:open(0,[]) of + {ok,U} -> + {ok,Res} = gethostname(U), + inet_udp:close(U), + {Res2,_} = lists:splitwith(fun($.)->false;(_)->true end,Res), + {ok, Res2}; + _ -> + {ok, "nohost.nodomain"} + end. + +-spec gethostname(Socket :: socket()) -> + {'ok', string()} | {'error', posix()}. + +gethostname(Socket) -> + prim_inet:gethostname(Socket). + +-spec getstat(Socket :: socket()) -> + {'ok', [{stat_option(), integer()}]} | {'error', posix()}. + +getstat(Socket) -> + prim_inet:getstat(Socket, stats()). + +-spec getstat(Socket :: socket(), Statoptions :: [stat_option()]) -> + {'ok', [{stat_option(), integer()}]} | {'error', posix()}. + +getstat(Socket,What) -> + prim_inet:getstat(Socket, What). + +-spec gethostbyname(Name :: string() | atom()) -> + {'ok', #hostent{}} | {'error', posix()}. + +gethostbyname(Name) -> + gethostbyname_tm(Name, inet, false). + +-spec gethostbyname(Name :: string() | atom(), Family :: family_option()) -> + {'ok', #hostent{}} | {'error', posix()}. + +gethostbyname(Name,Family) -> + gethostbyname_tm(Name, Family, false). + +-spec gethostbyname(Name :: string() | atom(), + Family :: family_option(), + Timeout :: non_neg_integer() | 'infinity') -> + {'ok', #hostent{}} | {'error', posix()}. + +gethostbyname(Name,Family,Timeout) -> + Timer = start_timer(Timeout), + Res = gethostbyname_tm(Name,Family,Timer), + stop_timer(Timer), + Res. + +gethostbyname_tm(Name,Family,Timer) -> + gethostbyname_tm(Name,Family,Timer,inet_db:res_option(lookup)). + + +-spec gethostbyaddr(Address :: string() | ip_address()) -> + {'ok', #hostent{}} | {'error', posix()}. + +gethostbyaddr(Address) -> + gethostbyaddr_tm(Address, false). + +-spec gethostbyaddr(Address :: string() | ip_address(), + Timeout :: non_neg_integer() | 'infinity') -> + {'ok', #hostent{}} | {'error', posix()}. + +gethostbyaddr(Address,Timeout) -> + Timer = start_timer(Timeout), + Res = gethostbyaddr_tm(Address, Timer), + stop_timer(Timer), + Res. + +gethostbyaddr_tm(Address,Timer) -> + gethostbyaddr_tm(Address, Timer, inet_db:res_option(lookup)). + +-spec ip(Ip :: ip_address() | string() | atom()) -> + {'ok', ip_address()} | {'error', posix()}. + +ip({A,B,C,D}) when ?ip(A,B,C,D) -> + {ok, {A,B,C,D}}; +ip(Name) -> + case gethostbyname(Name) of + {ok, Ent} -> + {ok, hd(Ent#hostent.h_addr_list)}; + Error -> Error + end. + +%% This function returns the erlang port used (with inet_drv) + +-spec getll(Socket :: socket()) -> {'ok', socket()}. + +getll(Socket) when is_port(Socket) -> + {ok, Socket}. + +%% +%% Return the internal file descriptor number +%% + +-spec getfd(Socket :: socket()) -> + {'ok', non_neg_integer()} | {'error', posix()}. + +getfd(Socket) -> + prim_inet:getfd(Socket). + +%% +%% Lookup an ip address +%% + +-spec getaddr(Host :: ip_address() | string() | atom(), + Family :: family_option()) -> + {'ok', ip_address()} | {'error', posix()}. + +getaddr(Address, Family) -> + getaddr(Address, Family, infinity). + +-spec getaddr(Host :: ip_address() | string() | atom(), + Family :: family_option(), + Timeout :: non_neg_integer() | 'infinity') -> + {'ok', ip_address()} | {'error', posix()}. + +getaddr(Address, Family, Timeout) -> + Timer = start_timer(Timeout), + Res = getaddr_tm(Address, Family, Timer), + stop_timer(Timer), + Res. + +getaddr_tm(Address, Family, Timer) -> + case getaddrs_tm(Address, Family, Timer) of + {ok, [IP|_]} -> {ok, IP}; + Error -> Error + end. + +-spec getaddrs(Host :: ip_address() | string() | atom(), + Family :: family_option()) -> + {'ok', [ip_address()]} | {'error', posix()}. + +getaddrs(Address, Family) -> + getaddrs(Address, Family, infinity). + +-spec getaddrs(Host :: ip_address() | string() | atom(), + Family :: family_option(), + Timeout :: non_neg_integer() | 'infinity') -> + {'ok', [ip_address()]} | {'error', posix()}. + +getaddrs(Address, Family, Timeout) -> + Timer = start_timer(Timeout), + Res = getaddrs_tm(Address, Family, Timer), + stop_timer(Timer), + Res. + +-spec getservbyport(Port :: ip_port(), Protocol :: atom() | string()) -> + {'ok', string()} | {'error', posix()}. + +getservbyport(Port, Proto) -> + case inet_udp:open(0, []) of + {ok,U} -> + Res = prim_inet:getservbyport(U, Port, Proto), + inet_udp:close(U), + Res; + Error -> Error + end. + +-spec getservbyname(Name :: atom() | string(), + Protocol :: atom() | string()) -> + {'ok', ip_port()} | {'error', posix()}. + +getservbyname(Name, Protocol) when is_atom(Name) -> + case inet_udp:open(0, []) of + {ok,U} -> + Res = prim_inet:getservbyname(U, Name, Protocol), + inet_udp:close(U), + Res; + Error -> Error + end. + +%% Return a list of available options +options() -> + [ + tos, priority, reuseaddr, keepalive, dontroute, linger, + broadcast, sndbuf, recbuf, nodelay, + buffer, header, active, packet, deliver, mode, + multicast_if, multicast_ttl, multicast_loop, + exit_on_close, high_watermark, low_watermark, + bit8, send_timeout, send_timeout_close + ]. + +%% Return a list of statistics options + +-spec stats() -> [stat_option(),...]. + +stats() -> + [recv_oct, recv_cnt, recv_max, recv_avg, recv_dvi, + send_oct, send_cnt, send_max, send_avg, send_pend]. + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% Available options for tcp:connect +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +connect_options() -> + [tos, priority, reuseaddr, keepalive, linger, sndbuf, recbuf, nodelay, + header, active, packet, packet_size, buffer, mode, deliver, + exit_on_close, high_watermark, low_watermark, bit8, send_timeout, + send_timeout_close, delay_send,raw]. + +connect_options(Opts, Family) -> + BaseOpts = + case application:get_env(kernel, inet_default_connect_options) of + {ok,List} when is_list(List) -> + NList = [{active, true} | lists:keydelete(active,1,List)], + #connect_opts{ opts = NList}; + {ok,{active,_Bool}} -> + #connect_opts{ opts = [{active,true}]}; + {ok,Option} -> + #connect_opts{ opts = [{active,true}, Option]}; + _ -> + #connect_opts{ opts = [{active,true}]} + end, + case con_opt(Opts, BaseOpts, connect_options()) of + {ok, R} -> + {ok, R#connect_opts { + ifaddr = translate_ip(R#connect_opts.ifaddr, Family) + }}; + Error -> Error + end. + +con_opt([{raw,A,B,C}|Opts],R,As) -> + con_opt([{raw,{A,B,C}}|Opts],R,As); +con_opt([Opt | Opts], R, As) -> + case Opt of + {ip,IP} -> con_opt(Opts, R#connect_opts { ifaddr = IP }, As); + {ifaddr,IP} -> con_opt(Opts, R#connect_opts { ifaddr = IP }, As); + {port,P} -> con_opt(Opts, R#connect_opts { port = P }, As); + {fd,Fd} -> con_opt(Opts, R#connect_opts { fd = Fd }, As); + binary -> con_add(mode, binary, R, Opts, As); + list -> con_add(mode, list, R, Opts, As); + {tcp_module,_} -> con_opt(Opts, R, As); + inet -> con_opt(Opts, R, As); + inet6 -> con_opt(Opts, R, As); + {Name,Val} when is_atom(Name) -> con_add(Name, Val, R, Opts, As); + _ -> {error, badarg} + end; +con_opt([], R, _) -> + {ok, R}. + +con_add(Name, Val, R, Opts, AllOpts) -> + case add_opt(Name, Val, R#connect_opts.opts, AllOpts) of + {ok, SOpts} -> + con_opt(Opts, R#connect_opts { opts = SOpts }, AllOpts); + Error -> Error + end. + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% Available options for tcp:listen +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +listen_options() -> + [tos, priority, reuseaddr, keepalive, linger, sndbuf, recbuf, nodelay, + header, active, packet, buffer, mode, deliver, backlog, + exit_on_close, high_watermark, low_watermark, bit8, send_timeout, + send_timeout_close, delay_send, packet_size,raw]. + +listen_options(Opts, Family) -> + BaseOpts = + case application:get_env(kernel, inet_default_listen_options) of + {ok,List} when is_list(List) -> + NList = [{active, true} | lists:keydelete(active,1,List)], + #listen_opts{ opts = NList}; + {ok,{active,_Bool}} -> + #listen_opts{ opts = [{active,true}]}; + {ok,Option} -> + #listen_opts{ opts = [{active,true}, Option]}; + _ -> + #listen_opts{ opts = [{active,true}]} + end, + case list_opt(Opts, BaseOpts, listen_options()) of + {ok, R} -> + {ok, R#listen_opts { + ifaddr = translate_ip(R#listen_opts.ifaddr, Family) + }}; + Error -> Error + end. + +list_opt([{raw,A,B,C}|Opts], R, As) -> + list_opt([{raw,{A,B,C}}|Opts], R, As); +list_opt([Opt | Opts], R, As) -> + case Opt of + {ip,IP} -> list_opt(Opts, R#listen_opts { ifaddr = IP }, As); + {ifaddr,IP} -> list_opt(Opts, R#listen_opts { ifaddr = IP }, As); + {port,P} -> list_opt(Opts, R#listen_opts { port = P }, As); + {fd,Fd} -> list_opt(Opts, R#listen_opts { fd = Fd }, As); + {backlog,BL} -> list_opt(Opts, R#listen_opts { backlog = BL }, As); + binary -> list_add(mode, binary, R, Opts, As); + list -> list_add(mode, list, R, Opts, As); + {tcp_module,_} -> list_opt(Opts, R, As); + inet -> list_opt(Opts, R, As); + inet6 -> list_opt(Opts, R, As); + {Name,Val} when is_atom(Name) -> list_add(Name, Val, R, Opts, As); + _ -> {error, badarg} + end; +list_opt([], R, _SockOpts) -> + {ok, R}. + +list_add(Name, Val, R, Opts, As) -> + case add_opt(Name, Val, R#listen_opts.opts, As) of + {ok, SOpts} -> + list_opt(Opts, R#listen_opts { opts = SOpts }, As); + Error -> Error + end. + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% Available options for udp:open +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +udp_options() -> + [tos, priority, reuseaddr, sndbuf, recbuf, header, active, buffer, mode, + deliver, + broadcast, dontroute, multicast_if, multicast_ttl, multicast_loop, + add_membership, drop_membership, read_packets,raw]. + + +udp_options(Opts, Family) -> + case udp_opt(Opts, #udp_opts { }, udp_options()) of + {ok, R} -> + {ok, R#udp_opts { + ifaddr = translate_ip(R#udp_opts.ifaddr, Family) + }}; + Error -> Error + end. + +udp_opt([{raw,A,B,C}|Opts], R, As) -> + udp_opt([{raw,{A,B,C}}|Opts], R, As); +udp_opt([Opt | Opts], R, As) -> + case Opt of + {ip,IP} -> udp_opt(Opts, R#udp_opts { ifaddr = IP }, As); + {ifaddr,IP} -> udp_opt(Opts, R#udp_opts { ifaddr = IP }, As); + {port,P} -> udp_opt(Opts, R#udp_opts { port = P }, As); + {fd,Fd} -> udp_opt(Opts, R#udp_opts { fd = Fd }, As); + binary -> udp_add(mode, binary, R, Opts, As); + list -> udp_add(mode, list, R, Opts, As); + {udp_module,_} -> udp_opt(Opts, R, As); + inet -> udp_opt(Opts, R, As); + inet6 -> udp_opt(Opts, R, As); + {Name,Val} when is_atom(Name) -> udp_add(Name, Val, R, Opts, As); + _ -> {error, badarg} + end; +udp_opt([], R, _SockOpts) -> + {ok, R}. + +udp_add(Name, Val, R, Opts, As) -> + case add_opt(Name, Val, R#udp_opts.opts, As) of + {ok, SOpts} -> + udp_opt(Opts, R#udp_opts { opts = SOpts }, As); + Error -> Error + end. + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% Available options for sctp:open +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% Currently supported options include: +% (*) {mode, list|binary} or just list|binary +% (*) {active, true|false|once} +% (*) {sctp_module, inet_sctp|inet6_sctp} or just inet|inet6 +% (*) options set via setsockopt. +% The full list is below in sctp_options/0 . +% All other options are currently NOT supported. In particular: +% (*) multicast on SCTP is not (yet) supported, as it may be incompatible +% with automatic associations; +% (*) passing of open FDs ("fdopen") is not supported. +sctp_options() -> +[ % The following are generic inet options supported for SCTP sockets: + mode, active, buffer, tos, priority, dontroute, reuseaddr, linger, sndbuf, + recbuf, + + % Other options are SCTP-specific (though they may be similar to their + % TCP and UDP counter-parts): + sctp_rtoinfo, sctp_associnfo, sctp_initmsg, + sctp_autoclose, sctp_nodelay, sctp_disable_fragments, + sctp_i_want_mapped_v4_addr, sctp_maxseg, sctp_primary_addr, + sctp_set_peer_primary_addr, sctp_adaptation_layer, sctp_peer_addr_params, + sctp_default_send_param, sctp_events, sctp_delayed_ack_time, + sctp_status, sctp_get_peer_addr_info +]. + +sctp_options(Opts, Mod) -> + case sctp_opt(Opts, Mod, #sctp_opts{}, sctp_options()) of + {ok,#sctp_opts{ifaddr=undefined}=SO} -> + {ok,SO#sctp_opts{ifaddr=Mod:translate_ip(?SCTP_DEF_IFADDR)}}; + {ok,_}=OK -> + OK; + Error -> Error + end. + +sctp_opt([Opt|Opts], Mod, R, As) -> + case Opt of + {ip,IP} -> + sctp_opt_ifaddr(Opts, Mod, R, As, IP); + {ifaddr,IP} -> + sctp_opt_ifaddr(Opts, Mod, R, As, IP); + {port,Port} -> + case Mod:getserv(Port) of + {ok,P} -> + sctp_opt(Opts, Mod, R#sctp_opts{port=P}, As); + Error -> Error + end; + binary -> sctp_opt (Opts, Mod, R, As, mode, binary); + list -> sctp_opt (Opts, Mod, R, As, mode, list); + {sctp_module,_} -> sctp_opt (Opts, Mod, R, As); % Done with + inet -> sctp_opt (Opts, Mod, R, As); % Done with + inet6 -> sctp_opt (Opts, Mod, R, As); % Done with + {Name,Val} -> sctp_opt (Opts, Mod, R, As, Name, Val); + _ -> {error,badarg} + end; +sctp_opt([], _Mod, R, _SockOpts) -> + {ok, R}. + +sctp_opt(Opts, Mod, R, As, Name, Val) -> + case add_opt(Name, Val, R#sctp_opts.opts, As) of + {ok,SocketOpts} -> + sctp_opt(Opts, Mod, R#sctp_opts{opts=SocketOpts}, As); + Error -> Error + end. + +sctp_opt_ifaddr(Opts, Mod, #sctp_opts{ifaddr=IfAddr}=R, As, Addr) -> + IP = Mod:translate_ip(Addr), + sctp_opt(Opts, Mod, + R#sctp_opts{ + ifaddr=case IfAddr of + undefined -> IP; + _ when is_list(IfAddr) -> [IP|IfAddr]; + _ -> [IP,IfAddr] + end}, As). + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% Util to check and insert option in option list +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +add_opt(Name, Val, Opts, As) -> + case lists:member(Name, As) of + true -> + case prim_inet:is_sockopt_val(Name, Val) of + true -> + Opts1 = lists:keydelete(Name, 1, Opts), + {ok, [{Name,Val} | Opts1]}; + false -> {error,badarg} + end; + false -> {error,badarg} + end. + + +translate_ip(any, inet) -> {0,0,0,0}; +translate_ip(loopback, inet) -> {127,0,0,1}; +translate_ip(any, inet6) -> {0,0,0,0,0,0,0,0}; +translate_ip(loopback, inet6) -> {0,0,0,0,0,0,0,1}; +translate_ip(IP, _) -> IP. + + +getaddrs_tm({A,B,C,D} = IP, Fam, _) -> + %% Only "syntactic" validation and check of family. + if + ?ip(A,B,C,D) -> + if + Fam =:= inet -> {ok,[IP]}; + true -> {error,eafnosupport} + end; + true -> {error,einval} + end; +getaddrs_tm({A,B,C,D,E,F,G,H} = IP, Fam, _) -> + %% Only "syntactic" validation; we assume that the address was + %% "semantically" validated when it was converted to a tuple. + if + ?ip6(A,B,C,D,E,F,G,H) -> + if + Fam =:= inet6 -> {ok,[IP]}; + true -> {error,eafnosupport} + end; + true -> {error,einval} + end; +getaddrs_tm(Address, Family, Timer) when is_atom(Address) -> + getaddrs_tm(atom_to_list(Address), Family, Timer); +getaddrs_tm(Address, Family, Timer) -> + case inet_parse:visible_string(Address) of + false -> + {error,einval}; + true -> + %% Address is a host name or a valid IP address, + %% either way check it with the resolver. + case gethostbyname_tm(Address, Family, Timer) of + {ok,Ent} -> {ok,Ent#hostent.h_addr_list}; + Error -> Error + end + end. + +%% +%% gethostbyname with option search +%% +gethostbyname_tm(Name, Type, Timer, [dns | Opts]) -> + Res = inet_res:gethostbyname_tm(Name, Type, Timer), + case Res of + {ok,_} -> Res; + {error,timeout} -> Res; + {error,formerr} -> {error,einval}; + {error,_} -> gethostbyname_tm(Name,Type,Timer,Opts) + end; +gethostbyname_tm(Name, Type, Timer, [file | Opts]) -> + case inet_hosts:gethostbyname(Name, Type) of + {error,formerr} -> {error,einval}; + {error,_} -> gethostbyname_tm(Name,Type,Timer,Opts); + Result -> Result + end; +gethostbyname_tm(Name, Type, Timer, [yp | Opts]) -> + gethostbyname_tm_native(Name, Type, Timer, Opts); +gethostbyname_tm(Name, Type, Timer, [nis | Opts]) -> + gethostbyname_tm_native(Name, Type, Timer, Opts); +gethostbyname_tm(Name, Type, Timer, [nisplus | Opts]) -> + gethostbyname_tm_native(Name, Type, Timer, Opts); +gethostbyname_tm(Name, Type, Timer, [wins | Opts]) -> + gethostbyname_tm_native(Name, Type, Timer, Opts); +gethostbyname_tm(Name, Type, Timer, [native | Opts]) -> + gethostbyname_tm_native(Name, Type, Timer, Opts); +gethostbyname_tm(_, _, _, [no_default|_]) -> + %% If the native resolver has failed, we should not bother + %% to try to be smarter and parse the IP address here. + {error,nxdomain}; +gethostbyname_tm(Name, Type, Timer, [_ | Opts]) -> + gethostbyname_tm(Name, Type, Timer, Opts); +%% Last resort - parse the hostname as address +gethostbyname_tm(Name, inet, _Timer, []) -> + case inet_parse:ipv4_address(Name) of + {ok,IP4} -> + {ok,make_hostent(Name, [IP4], [], inet)}; + _ -> + gethostbyname_self(Name) + end; +gethostbyname_tm(Name, inet6, _Timer, []) -> + case inet_parse:ipv6_address(Name) of + {ok,IP6} -> + {ok,make_hostent(Name, [IP6], [], inet6)}; + _ -> + %% Even if Name is a valid IPv4 address, we can't + %% assume it's correct to return it on a IPv6 + %% format ( {0,0,0,0,0,16#ffff,?u16(A,B),?u16(C,D)} ). + %% This host might not support IPv6. + gethostbyname_self(Name) + end. + +gethostbyname_tm_native(Name, Type, Timer, Opts) -> + %% Fixme: add (global) timeout to gethost_native + case inet_gethost_native:gethostbyname(Name, Type) of + {error,formerr} -> {error,einval}; + {error,timeout} -> {error,timeout}; + {error,_} -> gethostbyname_tm(Name, Type, Timer, Opts++[no_default]); + Result -> Result + end. + +%% Make sure we always can look up our own hostname. +gethostbyname_self(Name) -> + Type = case inet_db:res_option(inet6) of + true -> inet6; + false -> inet + end, + case inet_db:gethostname() of + Name -> + {ok,make_hostent(Name, [translate_ip(loopback, Type)], + [], Type)}; + Self -> + case inet_db:res_option(domain) of + "" -> {error,nxdomain}; + Domain -> + case lists:append([Self,".",Domain]) of + Name -> + {ok,make_hostent(Name, + [translate_ip(loopback, Type)], + [], Type)}; + _ -> {error,nxdomain} + end + end + end. + +make_hostent(Name, Addrs, Aliases, Type) -> + #hostent{h_name = Name, + h_aliases = Aliases, + h_addrtype = Type, + h_length = case Type of inet -> 4; inet6 -> 16 end, + h_addr_list = Addrs}. + +%% +%% gethostbyaddr with option search +%% +gethostbyaddr_tm(Addr, Timer, [dns | Opts]) -> + Res = inet_res:gethostbyaddr_tm(Addr,Timer), + case Res of + {ok,_} -> Res; + {error,timeout} -> Res; + {error,formerr} -> {error, einval}; + {error,_} -> gethostbyaddr_tm(Addr,Timer,Opts) + end; +gethostbyaddr_tm(Addr, Timer, [file | Opts]) -> + case inet_hosts:gethostbyaddr(Addr) of + {error,formerr} -> {error, einval}; + {error,_} -> gethostbyaddr_tm(Addr,Timer,Opts); + Result -> Result + end; +gethostbyaddr_tm(Addr, Timer, [yp | Opts]) -> + gethostbyaddr_tm_native(Addr, Timer, Opts); +gethostbyaddr_tm(Addr, Timer, [nis | Opts]) -> + gethostbyaddr_tm_native(Addr, Timer, Opts); +gethostbyaddr_tm(Addr, Timer, [nisplus | Opts]) -> + gethostbyaddr_tm_native(Addr, Timer, Opts); +gethostbyaddr_tm(Addr, Timer, [wins | Opts]) -> + gethostbyaddr_tm_native(Addr, Timer, Opts); +gethostbyaddr_tm(Addr, Timer, [native | Opts]) -> + gethostbyaddr_tm_native(Addr, Timer, Opts); +gethostbyaddr_tm(Addr, Timer, [_ | Opts]) -> + gethostbyaddr_tm(Addr, Timer, Opts); +gethostbyaddr_tm({127,0,0,1}=IP, _Timer, []) -> + gethostbyaddr_self(IP, inet); +gethostbyaddr_tm({0,0,0,0,0,0,0,1}=IP, _Timer, []) -> + gethostbyaddr_self(IP, inet6); +gethostbyaddr_tm(_Addr, _Timer, []) -> + {error, nxdomain}. + +gethostbyaddr_self(IP, Type) -> + Name = inet_db:gethostname(), + case inet_db:res_option(domain) of + "" -> + {ok,make_hostent(Name, [IP], [], Type)}; + Domain -> + {ok,make_hostent(Name++"."++Domain, [IP], [Name], Type)} + end. + +gethostbyaddr_tm_native(Addr, Timer, Opts) -> + %% Fixme: user timer for timeoutvalue + case inet_gethost_native:gethostbyaddr(Addr) of + {error,formerr} -> {error, einval}; + {error,_} -> gethostbyaddr_tm(Addr,Timer,Opts); + Result -> Result + end. + +-spec open(Fd :: integer(), + Addr :: ip_address(), + Port :: ip_port(), + Opts :: [socket_setopt()], + Protocol :: protocol_option(), + Family :: 'inet' | 'inet6', + Module :: atom()) -> + {'ok', socket()} | {'error', posix()}. + +open(Fd, Addr, Port, Opts, Protocol, Family, Module) when Fd < 0 -> + case prim_inet:open(Protocol, Family) of + {ok,S} -> + case prim_inet:setopts(S, Opts) of + ok -> + case if is_list(Addr) -> + prim_inet:bind(S, add, + [case A of + {_,_} -> A; + _ -> {A,Port} + end || A <- Addr]); + true -> + prim_inet:bind(S, Addr, Port) + end of + {ok, _} -> + inet_db:register_socket(S, Module), + {ok,S}; + Error -> + prim_inet:close(S), + Error + end; + Error -> + prim_inet:close(S), + Error + end; + Error -> + Error + end; +open(Fd, _Addr, _Port, Opts, Protocol, Family, Module) -> + fdopen(Fd, Opts, Protocol, Family, Module). + +-spec fdopen(Fd :: non_neg_integer(), + Opts :: [socket_setopt()], + Protocol :: protocol_option(), + Family :: family_option(), + Module :: atom()) -> + {'ok', socket()} | {'error', posix()}. + +fdopen(Fd, Opts, Protocol, Family, Module) -> + case prim_inet:fdopen(Protocol, Fd, Family) of + {ok, S} -> + case prim_inet:setopts(S, Opts) of + ok -> + inet_db:register_socket(S, Module), + {ok, S}; + Error -> + prim_inet:close(S), Error + end; + Error -> Error + end. + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% socket stat +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +i() -> i(tcp), i(udp). + +i(Proto) -> i(Proto, [port, module, recv, sent, owner, + local_address, foreign_address, state]). + +i(tcp, Fs) -> + ii(tcp_sockets(), Fs, tcp); +i(udp, Fs) -> + ii(udp_sockets(), Fs, udp). + +ii(Ss, Fs, Proto) -> + LLs = [h_line(Fs) | info_lines(Ss, Fs, Proto)], + Maxs = foldl( + fun(Line,Max0) -> smax(Max0,Line) end, + duplicate(length(Fs),0),LLs), + Fmt = append(["~-" ++ integer_to_list(N) ++ "s " || N <- Maxs]) ++ "\n", + lists:foreach(fun(Line) -> io:format(Fmt, Line) end, LLs). + +smax([Max|Ms], [Str|Strs]) -> + N = length(Str), + [if N > Max -> N; true -> Max end | smax(Ms, Strs)]; +smax([], []) -> []. + +info_lines(Ss, Fs, Proto) -> [i_line(S, Fs,Proto) || S <- Ss]. +i_line(S, Fs, Proto) -> [info(S, F, Proto) || F <- Fs]. + +h_line(Fs) -> [h_field(atom_to_list(F)) || F <- Fs]. + +h_field([C|Cs]) -> [upper(C) | hh_field(Cs)]. + +hh_field([$_,C|Cs]) -> [$\s,upper(C) | hh_field(Cs)]; +hh_field([C|Cs]) -> [C|hh_field(Cs)]; +hh_field([]) -> []. + +upper(C) when C >= $a, C =< $z -> (C-$a) + $A; +upper(C) -> C. + + +info(S, F, Proto) -> + case F of + owner -> + case erlang:port_info(S, connected) of + {connected, Owner} -> pid_to_list(Owner); + _ -> " " + end; + port -> + case erlang:port_info(S,id) of + {id, Id} -> integer_to_list(Id); + undefined -> " " + end; + sent -> + case prim_inet:getstat(S, [send_oct]) of + {ok,[{send_oct,N}]} -> integer_to_list(N); + _ -> " " + end; + recv -> + case prim_inet:getstat(S, [recv_oct]) of + {ok,[{recv_oct,N}]} -> integer_to_list(N); + _ -> " " + end; + local_address -> + fmt_addr(prim_inet:sockname(S), Proto); + foreign_address -> + fmt_addr(prim_inet:peername(S), Proto); + state -> + case prim_inet:getstatus(S) of + {ok,Status} -> fmt_status(Status); + _ -> " " + end; + packet -> + case prim_inet:getopt(S, packet) of + {ok,Type} when is_atom(Type) -> atom_to_list(Type); + {ok,Type} when is_integer(Type) -> integer_to_list(Type); + _ -> " " + end; + type -> + case prim_inet:gettype(S) of + {ok,{_,stream}} -> "STREAM"; + {ok,{_,dgram}} -> "DGRAM"; + _ -> " " + end; + fd -> + case prim_inet:getfd(S) of + {ok, Fd} -> integer_to_list(Fd); + _ -> " " + end; + module -> + case inet_db:lookup_socket(S) of + {ok,Mod} -> atom_to_list(Mod); + _ -> "prim_inet" + end + end. +%% Possible flags: (sorted) +%% [accepting,bound,busy,connected,connecting,listen,listening,open] +%% +fmt_status(Flags) -> + case lists:sort(Flags) of + [accepting | _] -> "ACCEPTING"; + [bound,busy,connected|_] -> "CONNECTED*"; + [bound,connected|_] -> "CONNECTED"; + [bound,listen,listening | _] -> "LISTENING"; + [bound,listen | _] -> "LISTEN"; + [bound,connecting | _] -> "CONNECTING"; + [bound,open] -> "BOUND"; + [open] -> "IDLE"; + [] -> "CLOSED"; + _ -> "????" + end. + +fmt_addr({error,enotconn}, _) -> "*:*"; +fmt_addr({error,_}, _) -> " "; +fmt_addr({ok,Addr}, Proto) -> + case Addr of + %%Dialyzer {0,0} -> "*:*"; + {{0,0,0,0},Port} -> "*:" ++ fmt_port(Port, Proto); + {{0,0,0,0,0,0,0,0},Port} -> "*:" ++ fmt_port(Port, Proto); + {{127,0,0,1},Port} -> "localhost:" ++ fmt_port(Port, Proto); + {{0,0,0,0,0,0,0,1},Port} -> "localhost:" ++ fmt_port(Port, Proto); + {IP,Port} -> inet_parse:ntoa(IP) ++ ":" ++ fmt_port(Port, Proto) + end. + +fmt_port(N, Proto) -> + case inet:getservbyport(N, Proto) of + {ok, Name} -> Name; + _ -> integer_to_list(N) + end. + +%% Return a list of all tcp sockets +tcp_sockets() -> port_list("tcp_inet"). +udp_sockets() -> port_list("udp_inet"). + +%% Return all ports having the name 'Name' +port_list(Name) -> + filter( + fun(Port) -> + case erlang:port_info(Port, name) of + {name, Name} -> true; + _ -> false + end + end, erlang:ports()). + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% utils +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +-spec format_error(posix()) -> string(). + +format_error(exbadport) -> "invalid port state"; +format_error(exbadseq) -> "bad command sequence"; +format_error(Tag) -> + erl_posix_msg:message(Tag). + +%% Close a TCP socket. +tcp_close(S) when is_port(S) -> + %% if exit_on_close is set we must force a close even if remotely closed!!! + prim_inet:close(S), + receive {tcp_closed, S} -> ok after 0 -> ok end. + +%% Close a UDP socket. +udp_close(S) when is_port(S) -> + receive + {udp_closed, S} -> ok + after 0 -> + prim_inet:close(S), + receive {udp_closed, S} -> ok after 0 -> ok end + end. + +%% Set controlling process for TCP socket. +tcp_controlling_process(S, NewOwner) when is_port(S), is_pid(NewOwner) -> + case erlang:port_info(S, connected) of + {connected, Pid} when Pid =/= self() -> + {error, not_owner}; + undefined -> + {error, einval}; + _ -> + case prim_inet:getopt(S, active) of + {ok, A0} -> + prim_inet:setopt(S, active, false), + case tcp_sync_input(S, NewOwner, false) of + true -> %% socket already closed, + ok; + false -> + try erlang:port_connect(S, NewOwner) of + true -> + unlink(S), %% unlink from port + prim_inet:setopt(S, active, A0), + ok + catch + error:Reason -> + {error, Reason} + end + end; + Error -> + Error + end + end. + +tcp_sync_input(S, Owner, Flag) -> + receive + {tcp, S, Data} -> + Owner ! {tcp, S, Data}, + tcp_sync_input(S, Owner, Flag); + {tcp_closed, S} -> + Owner ! {tcp_closed, S}, + tcp_sync_input(S, Owner, true); + {S, {data, Data}} -> + Owner ! {S, {data, Data}}, + tcp_sync_input(S, Owner, Flag); + {inet_async, S, Ref, Status} -> + Owner ! {inet_async, S, Ref, Status}, + tcp_sync_input(S, Owner, Flag); + {inet_reply, S, Status} -> + Owner ! {inet_reply, S, Status}, + tcp_sync_input(S, Owner, Flag) + after 0 -> + Flag + end. + +%% Set controlling process for UDP or SCTP socket. +udp_controlling_process(S, NewOwner) when is_port(S), is_pid(NewOwner) -> + case erlang:port_info(S, connected) of + {connected, Pid} when Pid =/= self() -> + {error, not_owner}; + _ -> + {ok, A0} = prim_inet:getopt(S, active), + prim_inet:setopt(S, active, false), + udp_sync_input(S, NewOwner), + try erlang:port_connect(S, NewOwner) of + true -> + unlink(S), + prim_inet:setopt(S, active, A0), + ok + catch + error:Reason -> + {error, Reason} + end + end. + +udp_sync_input(S, Owner) -> + receive + {sctp, S, _, _, _}=Msg -> udp_sync_input(S, Owner, Msg); + {udp, S, _, _, _}=Msg -> udp_sync_input(S, Owner, Msg); + {udp_closed, S}=Msg -> udp_sync_input(S, Owner, Msg); + {S, {data,_}}=Msg -> udp_sync_input(S, Owner, Msg); + {inet_async, S, _, _}=Msg -> udp_sync_input(S, Owner, Msg); + {inet_reply, S, _}=Msg -> udp_sync_input(S, Owner, Msg) + after 0 -> + ok + end. + +udp_sync_input(S, Owner, Msg) -> + Owner ! Msg, + udp_sync_input(S, Owner). + +start_timer(infinity) -> false; +start_timer(Timeout) -> + erlang:start_timer(Timeout, self(), inet). + +timeout(false) -> infinity; +timeout(Timer) -> + case erlang:read_timer(Timer) of + false -> 0; + Time -> Time + end. + +timeout(Time, false) -> Time; +timeout(Time, Timer) -> + TimerTime = timeout(Timer), + if TimerTime < Time -> TimerTime; + true -> Time + end. + +stop_timer(false) -> false; +stop_timer(Timer) -> + case erlang:cancel_timer(Timer) of + false -> + receive + {timeout,Timer,_} -> false + after 0 -> + false + end; + T -> T + end. diff --git a/lib/kernel/src/inet6_sctp.erl b/lib/kernel/src/inet6_sctp.erl new file mode 100644 index 0000000000..5c49c4fec3 --- /dev/null +++ b/lib/kernel/src/inet6_sctp.erl @@ -0,0 +1,75 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2007-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% +%% +%% SCTP protocol contribution by Leonid Timochouk and Serge Aleynikov. +%% See also: $ERL_TOP/lib/kernel/AUTHORS +%% +%% +-module(inet6_sctp). + +%% This module provides functions for communicating with +%% sockets using the SCTP protocol. The implementation assumes that +%% the OS kernel supports SCTP providing user-level SCTP Socket API: +%% http://tools.ietf.org/html/draft-ietf-tsvwg-sctpsocket-13 + +-include("inet_sctp.hrl"). +-include("inet_int.hrl"). + +-define(FAMILY, inet6). +-export([getserv/1,getaddr/1,getaddr/2,translate_ip/1]). +-export([open/1,close/1,listen/2,connect/5,sendmsg/3,recv/2]). + + + +getserv(Port) when is_integer(Port) -> {ok, Port}; +getserv(Name) when is_atom(Name) -> + inet:getservbyname(Name, sctp); +getserv(_) -> + {error,einval}. + +getaddr(Address) -> + inet:getaddr(Address, ?FAMILY). +getaddr(Address, Timer) -> + inet:getaddr_tm(Address, ?FAMILY, Timer). + +translate_ip(IP) -> + inet:translate_ip(IP, ?FAMILY). + + + +open(Opts) -> + case inet:sctp_options(Opts, ?MODULE) of + {ok,#sctp_opts{fd=Fd,ifaddr=Addr,port=Port,opts=SOs}} -> + inet:open(Fd, Addr, Port, SOs, sctp, ?FAMILY, ?MODULE); + Error -> Error + end. + +close(S) -> + prim_inet:close(S). + +listen(S, Flag) -> + prim_inet:listen(S, Flag). + +connect(S, Addr, Port, Opts, Timer) -> + inet_sctp:connect(S, Addr, Port, Opts, Timer). + +sendmsg(S, SRI, Data) -> + prim_inet:sendmsg(S, SRI, Data). + +recv(S, Timeout) -> + prim_inet:recvfrom(S, 0, Timeout). diff --git a/lib/kernel/src/inet6_tcp.erl b/lib/kernel/src/inet6_tcp.erl new file mode 100644 index 0000000000..cc45f6c7f6 --- /dev/null +++ b/lib/kernel/src/inet6_tcp.erl @@ -0,0 +1,153 @@ +%% +%% %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(inet6_tcp). + +-export([connect/3, connect/4, listen/2, accept/1, accept/2, close/1]). +-export([send/2, send/3, recv/2, recv/3, unrecv/2]). +-export([shutdown/2]). +-export([controlling_process/2]). +-export([fdopen/2]). + +-export([getserv/1, getaddr/1, getaddr/2, getaddrs/1, getaddrs/2]). + +-include("inet_int.hrl"). + +%% inet_tcp port lookup +getserv(Port) when is_integer(Port) -> {ok, Port}; +getserv(Name) when is_atom(Name) -> inet:getservbyname(Name,tcp). + +%% inet_tcp address lookup +getaddr(Address) -> inet:getaddr(Address, inet6). +getaddr(Address,Timer) -> inet:getaddr_tm(Address, inet6, Timer). + +%% inet_tcp address lookup +getaddrs(Address) -> inet:getaddrs(Address, inet6). +getaddrs(Address,Timer) -> inet:getaddrs_tm(Address,inet6,Timer). + +%% +%% Send data on a socket +%% +send(Socket, Packet, Opts) -> prim_inet:send(Socket, Packet, Opts). +send(Socket, Packet) -> prim_inet:send(Socket, Packet, []). + +%% +%% Receive data from a socket (inactive only) +%% +recv(Socket, Length) -> prim_inet:recv(Socket, Length). +recv(Socket, Length, Timeout) -> prim_inet:recv(Socket, Length, Timeout). + +unrecv(Socket, Data) -> prim_inet:unrecv(Socket, Data). +%% +%% Close a socket (async) +%% +close(Socket) -> + inet:tcp_close(Socket). + +%% +%% Shutdown one end of a socket +%% +shutdown(Socket, How) -> + prim_inet:shutdown(Socket, How). + +%% +%% Set controlling process +%% FIXME: move messages to new owner!!! +%% +controlling_process(Socket, NewOwner) -> + inet:tcp_controlling_process(Socket, NewOwner). + +%% +%% Connect +%% +connect(Address, Port, Opts) -> + do_connect(Address, Port, Opts, infinity). + +connect(Address, Port, Opts, infinity) -> + do_connect(Address, Port, Opts, infinity); +connect(Address, Port, Opts, Timeout) when is_integer(Timeout), + Timeout >= 0 -> + do_connect(Address, Port, Opts, Timeout). + +do_connect(Addr = {A,B,C,D,E,F,G,H}, Port, Opts, Time) when + ?ip6(A,B,C,D,E,F,G,H), ?port(Port) -> + case inet:connect_options(Opts, inet6) of + {error, Reason} -> exit(Reason); + {ok, #connect_opts{fd=Fd, + ifaddr=BAddr={Ab,Bb,Cb,Db,Eb,Fb,Gb,Hb}, + port=BPort, + opts=SockOpts}} + when ?ip6(Ab,Bb,Cb,Db,Eb,Fb,Gb,Hb), ?port(BPort) -> + case inet:open(Fd,BAddr,BPort,SockOpts,tcp,inet6,?MODULE) of + {ok, S} -> + case prim_inet:connect(S, Addr, Port, Time) of + ok -> {ok,S}; + Error -> prim_inet:close(S), Error + end; + Error -> Error + end; + {ok, _} -> exit(badarg) + end. + +%% +%% Listen +%% +listen(Port, Opts) -> + case inet:listen_options([{port,Port} | Opts], inet6) of + {error, Reason} -> exit(Reason); + {ok, #listen_opts{fd=Fd, + ifaddr=BAddr={A,B,C,D,E,F,G,H}, + port=BPort, + opts=SockOpts}=R} + when ?ip6(A,B,C,D,E,F,G,H), ?port(BPort) -> + case inet:open(Fd,BAddr,BPort,SockOpts,tcp,inet6,?MODULE) of + {ok, S} -> + case prim_inet:listen(S, R#listen_opts.backlog) of + ok -> {ok, S}; + Error -> prim_inet:close(S), Error + end; + Error -> Error + end; + {ok, _} -> exit(badarg) + end. + +%% +%% Accept +%% +accept(L) -> + case prim_inet:accept(L) of + {ok, S} -> + inet_db:register_socket(S, ?MODULE), + {ok,S}; + Error -> Error + end. + +accept(L,Timeout) -> + case prim_inet:accept(L,Timeout) of + {ok, S} -> + inet_db:register_socket(S, ?MODULE), + {ok,S}; + Error -> Error + end. + +%% +%% Create a port/socket from a file descriptor +%% +fdopen(Fd, Opts) -> + inet:fdopen(Fd, Opts, tcp, inet6, ?MODULE). + diff --git a/lib/kernel/src/inet6_tcp_dist.erl b/lib/kernel/src/inet6_tcp_dist.erl new file mode 100644 index 0000000000..34cf582af7 --- /dev/null +++ b/lib/kernel/src/inet6_tcp_dist.erl @@ -0,0 +1,417 @@ +%% +%% %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(inet6_tcp_dist). + +%% Handles the connection setup phase with other Erlang nodes. + +-export([listen/1, accept/1, accept_connection/5, + setup/5, close/1, select/1, is_node_name/1]). + +%% internal exports + +-export([accept_loop/2,do_accept/6,do_setup/6, getstat/1,tick/1]). + +-import(error_logger,[error_msg/2]). + +-include("net_address.hrl"). + + + +-define(to_port(Socket, Data, Opts), + case inet6_tcp:send(Socket, Data, Opts) of + {error, closed} -> + self() ! {tcp_closed, Socket}, + {error, closed}; + R -> + R + end). + + +-include("dist.hrl"). +-include("dist_util.hrl"). + +%% ------------------------------------------------------------ +%% Select this protocol based on node name +%% select(Node) => Bool +%% ------------------------------------------------------------ + +select(Node) -> + case split_node(atom_to_list(Node), $@, []) of + [_, Host] -> + case inet:getaddr(Host,inet6) of + {ok,_} -> true; + _ -> false + end; + _ -> false + end. + +%% ------------------------------------------------------------ +%% Create the listen socket, i.e. the port that this erlang +%% node is accessible through. +%% ------------------------------------------------------------ + +listen(Name) -> + case inet6_tcp:listen(0, [{active, false}, {packet,2}]) of + {ok, Socket} -> + TcpAddress = get_tcp_address(Socket), + {_,Port} = TcpAddress#net_address.address, + {ok, Creation} = erl_epmd:register_node(Name, Port), + {ok, {Socket, TcpAddress, Creation}}; + Error -> + Error + end. + +%% ------------------------------------------------------------ +%% Accepts new connection attempts from other Erlang nodes. +%% ------------------------------------------------------------ + +accept(Listen) -> + spawn_opt(?MODULE, accept_loop, [self(), Listen], [link, {priority, max}]). + +accept_loop(Kernel, Listen) -> + case inet6_tcp:accept(Listen) of + {ok, Socket} -> + Kernel ! {accept,self(),Socket,inet,tcp}, + controller(Kernel, Socket), + accept_loop(Kernel, Listen); + Error -> + exit(Error) + end. + +controller(Kernel, Socket) -> + receive + {Kernel, controller, Pid} -> + flush_controller(Pid, Socket), + inet6_tcp:controlling_process(Socket, Pid), + flush_controller(Pid, Socket), + Pid ! {self(), controller}; + {Kernel, unsupported_protocol} -> + exit(unsupported_protocol) + end. + +flush_controller(Pid, Socket) -> + receive + {tcp, Socket, Data} -> + Pid ! {tcp, Socket, Data}, + flush_controller(Pid, Socket); + {tcp_closed, Socket} -> + Pid ! {tcp_closed, Socket}, + flush_controller(Pid, Socket) + after 0 -> + ok + end. + +%% ------------------------------------------------------------ +%% Accepts a new connection attempt from another Erlang node. +%% Performs the handshake with the other side. +%% ------------------------------------------------------------ + +accept_connection(AcceptPid, Socket, MyNode, Allowed, SetupTime) -> + spawn_opt(?MODULE, do_accept, + [self(), AcceptPid, Socket, MyNode, Allowed, SetupTime], + [link, {priority, max}]). + +do_accept(Kernel, AcceptPid, Socket, MyNode, Allowed, SetupTime) -> + receive + {AcceptPid, controller} -> + Timer = dist_util:start_timer(SetupTime), + case check_ip(Socket) of + true -> + HSData = #hs_data{ + kernel_pid = Kernel, + this_node = MyNode, + socket = Socket, + timer = Timer, + this_flags = 0, + allowed = Allowed, + f_send = fun(S,D) -> inet6_tcp:send(S,D) end, + f_recv = fun(S,N,T) -> inet6_tcp:recv(S,N,T) + end, + f_setopts_pre_nodeup = + fun(S) -> + inet:setopts(S, + [{active, false}, + {packet, 4}, + nodelay()]) + end, + f_setopts_post_nodeup = + fun(S) -> + inet:setopts(S, + [{active, true}, + {deliver, port}, + {packet, 4}, + nodelay()]) + end, + f_getll = fun(S) -> + inet:getll(S) + end, + f_address = fun get_remote_id/2, + mf_tick = {?MODULE, tick}, + mf_getstat = {?MODULE,getstat} + }, + dist_util:handshake_other_started(HSData); + {false,IP} -> + error_msg("** Connection attempt from " + "disallowed IP ~w ** ~n", [IP]), + ?shutdown(no_node) + end + end. + + +%% we may not always want the nodelay behaviour +%% for performance reasons + +nodelay() -> + case application:get_env(kernel, dist_nodelay) of + undefined -> + {nodelay, true}; + {ok, true} -> + {nodelay, true}; + {ok, false} -> + {nodelay, false}; + _ -> + {nodelay, true} + end. + + +%% ------------------------------------------------------------ +%% Get remote information about a Socket. +%% ------------------------------------------------------------ + +get_remote_id(Socket, Node) -> + {ok, Address} = inet:peername(Socket), + [_, Host] = split_node(atom_to_list(Node), $@, []), + #net_address { + address = Address, + host = Host, + protocol = tcp, + family = inet6 }. + +%% ------------------------------------------------------------ +%% Setup a new connection to another Erlang node. +%% Performs the handshake with the other side. +%% ------------------------------------------------------------ + +setup(Node, Type, MyNode, LongOrShortNames,SetupTime) -> + spawn_opt(?MODULE, do_setup, + [self(), Node, Type, MyNode, LongOrShortNames, SetupTime], + [link, {priority, max}]). + +do_setup(Kernel, Node, Type, MyNode, LongOrShortNames,SetupTime) -> + ?trace("~p~n",[{?MODULE,self(),setup,Node}]), + [Name, Address] = splitnode(Node, LongOrShortNames), + case inet:getaddr(Address, inet6) of + {ok, Ip} -> + Timer = dist_util:start_timer(SetupTime), + case erl_epmd:port_please(Name, Ip) of + {port, TcpPort, Version} -> + ?trace("port_please(~p) -> version ~p~n", + [Node,Version]), + dist_util:reset_timer(Timer), + case inet6_tcp:connect(Ip, TcpPort, + [{active, false}, + {packet,2}]) of + {ok, Socket} -> + HSData = #hs_data{ + kernel_pid = Kernel, + other_node = Node, + this_node = MyNode, + socket = Socket, + timer = Timer, + this_flags = 0, + other_version = Version, + f_send = fun inet_tcp:send/2, + f_recv = fun inet_tcp:recv/3, + f_setopts_pre_nodeup = + fun(S) -> + inet:setopts + (S, + [{active, false}, + {packet, 4}, + nodelay()]) + end, + f_setopts_post_nodeup = + fun(S) -> + inet:setopts + (S, + [{active, true}, + {deliver, port}, + {packet, 4}, + nodelay()]) + end, + f_getll = fun inet:getll/1, + f_address = + fun(_,_) -> + #net_address { + address = {Ip,TcpPort}, + host = Address, + protocol = tcp, + family = inet} + end, + mf_tick = fun ?MODULE:tick/1, + mf_getstat = fun ?MODULE:getstat/1, + request_type = Type + }, + dist_util:handshake_we_started(HSData); + _ -> + %% Other Node may have closed since + %% port_please ! + ?trace("other node (~p) " + "closed since port_please.~n", + [Node]), + ?shutdown(Node) + end; + _ -> + ?trace("port_please (~p) " + "failed.~n", [Node]), + ?shutdown(Node) + end; + __Other -> + ?trace("inet_getaddr(~p) " + "failed (~p).~n", [Node,__Other]), + ?shutdown(Node) + end. + +%% +%% Close a socket. +%% +close(Socket) -> + inet6_tcp:close(Socket). + + +%% If Node is illegal terminate the connection setup!! +splitnode(Node, LongOrShortNames) -> + case split_node(atom_to_list(Node), $@, []) of + [Name|Tail] when Tail =/= [] -> + Host = lists:append(Tail), + case split_node(Host, $., []) of + [_] when LongOrShortNames =:= longnames -> + error_msg("** System running to use " + "fully qualified " + "hostnames **~n" + "** Hostname ~s is illegal **~n", + [Host]), + ?shutdown(Node); + L when length(L) > 1, LongOrShortNames =:= shortnames -> + error_msg("** System NOT running to use fully qualified " + "hostnames **~n" + "** Hostname ~s is illegal **~n", + [Host]), + ?shutdown(Node); + _ -> + [Name, Host] + end; + [_] -> + error_msg("** Nodename ~p illegal, no '@' character **~n", + [Node]), + ?shutdown(Node); + _ -> + error_msg("** Nodename ~p illegal **~n", [Node]), + ?shutdown(Node) + end. + +split_node([Chr|T], Chr, Ack) -> [lists:reverse(Ack)|split_node(T, Chr, [])]; +split_node([H|T], Chr, Ack) -> split_node(T, Chr, [H|Ack]); +split_node([], _, Ack) -> [lists:reverse(Ack)]. + +%% ------------------------------------------------------------ +%% Fetch local information about a Socket. +%% ------------------------------------------------------------ +get_tcp_address(Socket) -> + {ok, Address} = inet:sockname(Socket), + {ok, Host} = inet:gethostname(), + #net_address { + address = Address, + host = Host, + protocol = tcp, + family = inet6 + }. + +%% ------------------------------------------------------------ +%% Do only accept new connection attempts from nodes at our +%% own LAN, if the check_ip environment parameter is true. +%% ------------------------------------------------------------ +check_ip(Socket) -> + case application:get_env(check_ip) of + {ok, true} -> + case get_ifs(Socket) of + {ok, IFs, IP} -> + check_ip(IFs, IP); + _ -> + ?shutdown(no_node) + end; + _ -> + true + end. + +get_ifs(Socket) -> + case inet:peername(Socket) of + {ok, {IP, _}} -> + case inet:getif(Socket) of + {ok, IFs} -> {ok, IFs, IP}; + Error -> Error + end; + Error -> + Error + end. + +check_ip([{OwnIP, _, Netmask}|IFs], PeerIP) -> + case {mask(Netmask, PeerIP), mask(Netmask, OwnIP)} of + {M, M} -> true; + _ -> check_ip(IFs, PeerIP) + end; +check_ip([], PeerIP) -> + {false, PeerIP}. + +mask({M1,M2,M3,M4,M5,M6,M7,M8}, {IP1,IP2,IP3,IP4,IP5,IP6,IP7,IP8}) -> + {M1 band IP1, + M2 band IP2, + M3 band IP3, + M4 band IP4, + M5 band IP5, + M6 band IP6, + M7 band IP7, + M8 band IP8 }. + +is_node_name(Node) when is_atom(Node) -> + case split_node(atom_to_list(Node), $@, []) of + [_,_Host] -> true; + _ -> false + end; +is_node_name(_Node) -> + false. +tick(Sock) -> + ?to_port(Sock,[],[force]). +getstat(Socket) -> + case inet:getstat(Socket, [recv_cnt, send_cnt, send_pend]) of + {ok, Stat} -> + split_stat(Stat,0,0,0); + Error -> + Error + end. + +split_stat([{recv_cnt, R}|Stat], _, W, P) -> + split_stat(Stat, R, W, P); +split_stat([{send_cnt, W}|Stat], R, _, P) -> + split_stat(Stat, R, W, P); +split_stat([{send_pend, P}|Stat], R, W, _) -> + split_stat(Stat, R, W, P); +split_stat([], R, W, P) -> + {ok, R, W, P}. + diff --git a/lib/kernel/src/inet6_udp.erl b/lib/kernel/src/inet6_udp.erl new file mode 100644 index 0000000000..e81d417151 --- /dev/null +++ b/lib/kernel/src/inet6_udp.erl @@ -0,0 +1,87 @@ +%% +%% %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(inet6_udp). + +-export([open/1, open/2, close/1]). +-export([send/2, send/4, recv/2, recv/3, connect/3]). +-export([controlling_process/2]). +-export([fdopen/2]). + +-export([getserv/1, getaddr/1, getaddr/2]). + +-include("inet_int.hrl"). + +%% inet_udp port lookup +getserv(Port) when is_integer(Port) -> {ok, Port}; +getserv(Name) when is_atom(Name) -> inet:getservbyname(Name,udp). + +%% inet_udp address lookup +getaddr(Address) -> inet:getaddr(Address, inet6). +getaddr(Address,Timer) -> inet:getaddr(Address, inet6, Timer). + +open(Port) -> open(Port, []). + +open(Port, Opts) -> + case inet:udp_options([{port,Port} | Opts], inet6) of + {error, Reason} -> exit(Reason); + {ok, #udp_opts{fd=Fd, + ifaddr=BAddr={A,B,C,D,E,F,G,H}, + port=BPort, + opts=SockOpts}} + when ?ip6(A,B,C,D,E,F,G,H), ?port(BPort) -> + inet:open(Fd,BAddr,BPort,SockOpts,udp,inet6,?MODULE); + {ok, _} -> exit(badarg) + end. + +send(S, Addr = {A,B,C,D,E,F,G,H}, P, Data) + when ?ip6(A,B,C,D,E,F,G,H), ?port(P) -> + prim_inet:sendto(S, Addr, P, Data). + +send(S, Data) -> + prim_inet:sendto(S, {0,0,0,0,0,0,0,0}, 0, Data). + +connect(S, Addr = {A,B,C,D,E,F,G,H}, P) + when ?ip6(A,B,C,D,E,F,G,H), ?port(P) -> + prim_inet:connect(S, Addr, P). + +recv(S,Len) -> + prim_inet:recvfrom(S, Len). + +recv(S,Len,Time) -> + prim_inet:recvfrom(S, Len, Time). + +close(S) -> + inet:udp_close(S). + +%% +%% Set controlling process: +%% 1) First sync socket into a known state +%% 2) Move all messages onto the new owners message queue +%% 3) Commit the owner +%% 4) Wait for ack of new Owner (since socket does some link and unlink) +%% + +controlling_process(Socket, NewOwner) -> + inet:udp_controlling_process(Socket, NewOwner). + +%% +%% Create a port/socket from a file descriptor +%% +fdopen(Fd, Opts) -> + inet:fdopen(Fd, Opts, udp, inet6, ?MODULE). diff --git a/lib/kernel/src/inet_boot.hrl b/lib/kernel/src/inet_boot.hrl new file mode 100644 index 0000000000..35501a0f9c --- /dev/null +++ b/lib/kernel/src/inet_boot.hrl @@ -0,0 +1,32 @@ +%% +%% %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% +%% +%% +%% Defines used for erlang boot/load protocol +%% + +-define(EBOOT_PORT, 4368). %% same as epmd but for udp ! + +-define(EBOOT_REQUEST, "EBOOTQ"). +-define(EBOOT_REPLY, "EBOOTR"). + +-define(EBOOT_RETRY, 3). % number of retry before sleep +-define(EBOOT_REQUEST_DELAY, 500). % delay between retry +-define(EBOOT_SHORT_RETRY_SLEEP, 10000). % initial sleep time between boot attempt's +-define(EBOOT_UNSUCCESSFUL_TRIES, 10). % retries before longer sleep +-define(EBOOT_LONG_RETRY_SLEEP, 60000). % sleep time after a number of unsuccessful tries diff --git a/lib/kernel/src/inet_config.erl b/lib/kernel/src/inet_config.erl new file mode 100644 index 0000000000..b5317f72f5 --- /dev/null +++ b/lib/kernel/src/inet_config.erl @@ -0,0 +1,638 @@ +%% +%% %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_config). + +-include("inet_config.hrl"). +-include("inet.hrl"). + +-import(lists, [foreach/2, member/2, reverse/1]). + +-export([init/0]). + +-export([do_load_resolv/2]). + +%% +%% Must be called after inet_db:start +%% +%% Order in which to load inet_db data: +%% 1. Hostname (possibly derive domain and search) +%% 2. OS default /etc/resolv.conf, Windows registry etc +%% a) Hosts database +%% b) Resolver options +%% 3. Config (kernel app) +%% 4. Root (otp root) +%% 5. Home (user inetrc) +%% +%% +-spec init() -> 'ok'. +init() -> + OsType = os:type(), + case OsType of + {ose,_} -> + case init:get_argument(loader) of + {ok,[["ose_inet"]]} -> + %% port already started by prim_loader + ok; + _Other -> + %% Setup reserved port for ose_inet driver (only OSE) + case catch erlang:open_port({spawn,"ose_inet"}, [binary]) of + {'EXIT',Why} -> + error("can't open port for ose_inet: ~p", [Why]); + OseInetPort -> + erlang:display({ose_inet_port,OseInetPort}) + end + end; + _ -> + ok + end, + + set_hostname(), + + %% Note: In shortnames (or non-distributed) mode we don't need to know + %% our own domain name. In longnames mode we do and we can't rely on + %% the user to provide it (by means of inetrc), so we need to look + %% for it ourselves. + + do_load_resolv(OsType, erl_dist_mode()), + + case OsType of + {unix,Type} -> + if Type =:= linux -> + %% It may be the case that the domain name was not set + %% because the hostname was short. But NOW we can look it + %% up and get the long name and the domain name from it. + + %% FIXME: The second call to set_hostname will insert + %% a duplicate entry in the search list. + + case inet_db:res_option(domain) of + "" -> + case inet:gethostbyname(inet_db:gethostname()) of + {ok,#hostent{h_name = []}} -> + ok; + {ok,#hostent{h_name = HostName}} -> + set_hostname({ok,HostName}); + _ -> + ok + end; + _ -> + ok + end; + true -> ok + end, + add_dns_lookup(inet_db:res_option(lookup)); + _ -> + ok + end, + + %% Read inetrc file, if it exists. + {RcFile,CfgFiles,CfgList} = read_rc(), + + %% Possibly read config files or system registry + lists:foreach(fun({file,hosts,File}) -> + load_hosts(File, unix); + ({file,Func,File}) -> + load_resolv(File, Func); + ({registry,win32}) -> + case OsType of + {win32,WinType} -> + win32_load_from_registry(WinType); + _ -> + error("can not read win32 system registry~n", []) + end + end, CfgFiles), + + %% Add inetrc config entries + case inet_db:add_rc_list(CfgList) of + ok -> ok; + _ -> error("syntax error in ~s~n", [RcFile]) + end, + + %% Set up a resolver configuration file for inet_res, + %% unless that already has been done + case OsType of + {unix,_} -> + %% The Etc variable enables us to run tests with other + %% configuration files than the normal ones + Etc = case os:getenv("ERL_INET_ETC_DIR") of + false -> ?DEFAULT_ETC; + _EtcDir -> + _EtcDir + end, + case inet_db:res_option(resolv_conf) of + undefined -> + inet_db:set_resolv_conf(filename:join(Etc, + ?DEFAULT_RESOLV)); + _ -> ok + end, + case inet_db:res_option(hosts_file) of + undefined -> + inet_db:set_hosts_file(filename:join(Etc, + ?DEFAULT_HOSTS)); + _ -> ok + end; + _ -> ok + end. + + + +erl_dist_mode() -> + case init:get_argument(sname) of + {ok,[[_SName]]} -> shortnames; + _ -> + case init:get_argument(name) of + {ok,[[_Name]]} -> longnames; + _ -> nonames + end + end. + +do_load_resolv({unix,Type}, longnames) -> + %% The Etc variable enables us to run tests with other + %% configuration files than the normal ones + Etc = case os:getenv("ERL_INET_ETC_DIR") of + false -> ?DEFAULT_ETC; + _EtcDir -> + _EtcDir + end, + load_resolv(filename:join(Etc, ?DEFAULT_RESOLV), resolv), + case Type of + freebsd -> %% we may have to check version (2.2.2) + load_resolv(filename:join(Etc,"host.conf"), host_conf_freebsd); + 'bsd/os' -> + load_resolv(filename:join(Etc,"irs.conf"), host_conf_bsdos); + sunos -> + case os:version() of + {Major,_,_} when Major >= 5 -> + load_resolv(filename:join(Etc,"nsswitch.conf"), + nsswitch_conf); + _ -> + ok + end; + netbsd -> + case os:version() of + {Major,Minor,_} when Major >= 1, Minor >= 4 -> + load_resolv(filename:join(Etc,"nsswitch.conf"), + nsswitch_conf); + _ -> + ok + end; + linux -> + case load_resolv(filename:join(Etc,"host.conf"), + host_conf_linux) of + ok -> + ok; + _ -> + load_resolv(filename:join(Etc,"nsswitch.conf"), + nsswitch_conf) + end; + _ -> + ok + end, + inet_db:set_lookup([native]); + +do_load_resolv({win32,Type}, longnames) -> + win32_load_from_registry(Type), + inet_db:set_lookup([native]); + +do_load_resolv(vxworks, _) -> + vxworks_load_hosts(), + inet_db:set_lookup([file, dns]), + case os:getenv("ERLRESCONF") of + false -> + no_ERLRESCONF; + Resolv -> + load_resolv(Resolv, resolv) + end; + +do_load_resolv({ose,_Type}, _) -> + inet_db:set_lookup([file, dns]), + case os:getenv("NAMESERVER") of + false -> + case os:getenv("RESOLVFILE") of + false -> + erlang:display('Warning: No NAMESERVER or RESOLVFILE specified!'), + no_resolv; + Resolv -> + load_resolv(Resolv, resolv) + end; + Ns -> + {ok,IP} = inet_parse:address(Ns), + inet_db:add_rc_list([{nameserver,IP}]) + end, + case os:getenv("DOMAIN") of + false -> + no_domain; + D -> + ok = inet_db:add_rc_list([{domain,D}]) + end, + case os:getenv("HOSTSFILE") of + false -> + erlang:display('Warning: No HOSTSFILE specified!'), + no_hosts_file; + File -> + load_hosts(File, ose) + end; + +do_load_resolv(_, _) -> + inet_db:set_lookup([native]). + +add_dns_lookup(L) -> + case lists:member(dns,L) of + true -> ok; + _ -> + case application:get_env(kernel,inet_dns_when_nis) of + {ok,true} -> + add_dns_lookup(L,[]); + _ -> + ok + end + end. + +add_dns_lookup([yp|T],Acc) -> + add_dns_lookup(T,[yp,dns|Acc]); +add_dns_lookup([H|T],Acc) -> + add_dns_lookup(T,[H|Acc]); +add_dns_lookup([],Acc) -> + inet_db:set_lookup(reverse(Acc)). + +%% +%% Set the hostname (SHORT) +%% If hostname is long use the suffix as default domain +%% and initalize the search option with the parts of domain +%% +set_hostname() -> + case inet_udp:open(0,[]) of + {ok,U} -> + Res = inet:gethostname(U), + inet_udp:close(U), + set_hostname(Res); + _ -> + set_hostname({ok, []}) + end. + +set_hostname({ok,Name}) when length(Name) > 0 -> + {Host, Domain} = lists:splitwith(fun($.) -> false; + (_) -> true + end, Name), + inet_db:set_hostname(Host), + set_search_dom(Domain); +set_hostname({ok,[]}) -> + inet_db:set_hostname("nohost"), + set_search_dom("nodomain"). + +set_search_dom([$.|Domain]) -> + %% leading . not removed by dropwhile above. + inet_db:set_domain(Domain), + inet_db:ins_search(Domain), + ok; +set_search_dom([]) -> + ok; +set_search_dom(Domain) -> + inet_db:set_domain(Domain), + inet_db:ins_search(Domain), + ok. + +%% +%% Load resolver data +%% +load_resolv(File, Func) -> + case get_file(File) of + {ok,Bin} -> + case inet_parse:Func(File, {chars, Bin}) of + {ok, Ls} -> + inet_db:add_rc_list(Ls); + {error, Reason} -> + error("parse error in file ~s: ~p", [File, Reason]) + end; + Error -> + warning("file not found ~s: ~p~n", [File, Error]) + end. + +%% +%% Load a UNIX hosts file +%% +load_hosts(File,Os) -> + case get_file(File) of + {ok,Bin} -> + case inet_parse:hosts(File,{chars,Bin}) of + {ok, Ls} -> + foreach( + fun({IP, Name, Aliases}) -> + inet_db:add_host(IP, [Name|Aliases]) end, + Ls); + {error, Reason} -> + error("parse error in file ~s: ~p", [File, Reason]) + end; + Error -> + case Os of + unix -> + error("file not found ~s: ~p~n", [File, Error]); + _ -> + %% for windows or nt the hosts file is not always there + %% and we don't require it + ok + end + end. + +%% +%% Load resolver data from Windows registry +%% +win32_load_from_registry(Type) -> + %% The TcpReg variable enables us to run tests with other registry configurations than + %% the normal ones + TcpReg = case os:getenv("ERL_INET_ETC_DIR") of + false -> []; + _TReg -> _TReg + end, + {ok, Reg} = win32reg:open([read]), + {TcpIp,HFileKey} = + case Type of + nt -> + case TcpReg of + [] -> + {"\\hklm\\system\\CurrentControlSet\\Services\\TcpIp\\Parameters", + "DataBasePath" }; + Other -> + {Other,"DataBasePath"} + end; + windows -> + case TcpReg of + [] -> + {"\\hklm\\system\\CurrentControlSet\\Services\\VxD\\MSTCP", + "LMHostFile" }; + Other -> + {Other,"LMHostFile"} + end + end, + Result = + case win32reg:change_key(Reg,TcpIp) of + ok -> + win32_load1(Reg,Type,HFileKey); + {error, _Reason} -> + error("Failed to locate TCP/IP parameters (is TCP/IP installed)?", + []) + end, + win32reg:close(Reg), + Result. + +win32_load1(Reg,Type,HFileKey) -> + Names = [HFileKey, "Domain", "DhcpDomain", + "EnableDNS", "NameServer", "SearchList"], + case win32_get_strings(Reg, Names) of + [DBPath0, Domain, DhcpDomain, + _EnableDNS, NameServers0, Search] -> + inet_db:set_domain( + case Domain of "" -> DhcpDomain; _ -> Domain end), + NameServers = win32_split_line(NameServers0,Type), + AddNs = fun(Addr) -> + case inet_parse:address(Addr) of + {ok, Address} -> + inet_db:add_ns(Address); + {error, _} -> + error("Bad TCP/IP address in registry", []) + end + end, + foreach(AddNs, NameServers), + Searches0 = win32_split_line(Search,Type), + Searches = case member(Domain, Searches0) of + true -> Searches0; + false -> [Domain|Searches0] + end, + foreach(fun(D) -> inet_db:add_search(D) end, Searches), + if Type =:= nt -> + DBPath = win32reg:expand(DBPath0), + load_hosts(filename:join(DBPath, "hosts"),nt); + Type =:= windows -> + load_hosts(filename:join(DBPath0,""),windows) + end, +%% Maybe activate this later as an optimization +%% For now we use native always as the SAFE way +%% case NameServers of +%% [] -> inet_db:set_lookup([native, file]); +%% _ -> inet_db:set_lookup([dns, file, native]) +%% end; + true; + {error, _Reason} -> + error("Failed to read TCP/IP parameters from registry", []) + end. + +win32_split_line(Line,nt) -> inet_parse:split_line(Line); +win32_split_line(Line,windows) -> string:tokens(Line, ","). + +win32_get_strings(Reg, Names) -> + win32_get_strings(Reg, Names, []). + +win32_get_strings(Reg, [Name|Rest], Result) -> + case win32reg:value(Reg, Name) of + {ok, Value} when is_list(Value) -> + win32_get_strings(Reg, Rest, [Value|Result]); + {ok, _NotString} -> + {error, not_string}; + {error, _Reason} -> + win32_get_strings(Reg, Rest, [""|Result]) + end; +win32_get_strings(_, [], Result) -> + lists:reverse(Result). + +%% +%% Load host data from VxWorks hostShow command +%% + +vxworks_load_hosts() -> + HostShow = os:cmd("hostShow"), + case check_hostShow(HostShow) of + Hosts when is_list(Hosts) -> + case inet_parse:hosts_vxworks({chars, Hosts}) of + {ok, Ls} -> + foreach( + fun({IP, Name, Aliases}) -> + inet_db:add_host(IP, [Name|Aliases]) + end, + Ls); + {error,Reason} -> + error("parser error VxWorks hostShow ~s", [Reason]) + end; + _Error -> + error("error in VxWorks hostShow~s~n", [HostShow]) + end. + +%% +%% Check if hostShow yields at least two line; the first one +%% starting with "hostname", the second one starting with +%% "--------". +%% Returns: list of hosts in VxWorks notation +%% rows of 'Name IP [Aliases] \n' +%% if hostShow yielded these two lines, false otherwise. +check_hostShow(HostShow) -> + check_hostShow(["hostname", "--------"], HostShow). + +check_hostShow([], HostShow) -> + HostShow; +check_hostShow([String_match|Rest], HostShow) -> + case lists:prefix(String_match, HostShow) of + true -> + check_hostShow(Rest, next_line(HostShow)); + false -> + false + end. + +next_line([]) -> + []; +next_line([$\n|Rest]) -> + Rest; +next_line([_First|Rest]) -> + next_line(Rest). + +read_rc() -> + {RcFile,CfgList} = read_inetrc(), + case extract_cfg_files(CfgList, [], []) of + {CfgFiles,CfgList1} -> + {RcFile,CfgFiles,CfgList1}; + error -> + {error,[],[]} + end. + + + +extract_cfg_files([E = {file,Type,_File} | Es], CfgFiles, CfgList) -> + extract_cfg_files1(Type, E, Es, CfgFiles, CfgList); +extract_cfg_files([E = {registry,Type} | Es], CfgFiles, CfgList) -> + extract_cfg_files1(Type, E, Es, CfgFiles, CfgList); +extract_cfg_files([E | Es], CfgFiles, CfgList) -> + extract_cfg_files(Es, CfgFiles, [E | CfgList]); +extract_cfg_files([], CfgFiles, CfgList) -> + {reverse(CfgFiles),reverse(CfgList)}. + +extract_cfg_files1(Type, E, Es, CfgFiles, CfgList) -> + case valid_type(Type) of + true -> + extract_cfg_files(Es, [E | CfgFiles], CfgList); + false -> + error("invalid config value ~w in inetrc~n", [Type]), + error + end. + +valid_type(resolv) -> true; +valid_type(host_conf_freebsd) -> true; +valid_type(host_conf_bsdos) -> true; +valid_type(host_conf_linux) -> true; +valid_type(nsswitch_conf) -> true; +valid_type(hosts) -> true; +valid_type(win32) -> true; +valid_type(_) -> false. + +read_inetrc() -> + case application:get_env(inetrc) of + {ok,File} -> + try_get_rc(File); + _ -> + case os:getenv("ERL_INETRC") of + false -> + {nofile,[]}; + File -> + try_get_rc(File) + end + end. + +try_get_rc(File) -> + case get_rc(File) of + error -> {nofile,[]}; + Ls -> {File,Ls} + end. + +get_rc(File) -> + case get_file(File) of + {ok,Bin} -> + case parse_inetrc(Bin) of + {ok,Ls} -> + Ls; + _Error -> + error("parse error in ~s~n", [File]), + error + end; + _Error -> + error("file ~s not found~n", [File]), + error + end. + +%% XXX Check if we really need to prim load the stuff +get_file(File) -> + case erl_prim_loader:get_file(File) of + {ok,Bin,_} -> {ok,Bin}; + Error -> Error + end. + +error(Fmt, Args) -> + error_logger:error_msg("inet_config: " ++ Fmt, Args). + +warning(Fmt, Args) -> + case application:get_env(kernel,inet_warnings) of + %{ok,silent} -> ok; + {ok,on} -> + error_logger:info_msg("inet_config:" ++ Fmt, Args); + _ -> + ok + end. + +%% +%% Parse inetrc, i.e. make a binary of a term list. +%% The extra newline is to let the user ignore the whitespace !!! +%% Ignore leading whitespace before a token (due to bug in erl_scan) ! +%% +parse_inetrc(Bin) -> + Str = binary_to_list(Bin) ++ "\n", + parse_inetrc(Str, 1, []). + +parse_inetrc_skip_line([], _Line, Ack) -> + {ok, reverse(Ack)}; +parse_inetrc_skip_line([$\n|Str], Line, Ack) -> + parse_inetrc(Str, Line+1, Ack); +parse_inetrc_skip_line([_|Str], Line, Ack) -> + parse_inetrc_skip_line(Str, Line, Ack). + +parse_inetrc([$%|Str], Line, Ack) -> + parse_inetrc_skip_line(Str, Line, Ack); +parse_inetrc([$\s|Str], Line, Ack) -> + parse_inetrc(Str, Line, Ack); +parse_inetrc([$\n |Str], Line, Ack) -> + parse_inetrc(Str, Line+1, Ack); +parse_inetrc([$\t|Str], Line, Ack) -> + parse_inetrc(Str, Line, Ack); +parse_inetrc([], _, Ack) -> + {ok, reverse(Ack)}; + + +%% The clauses above are here due to a bug in erl_scan (OTP-1449). + +parse_inetrc(Str, Line, Ack) -> + case erl_scan:tokens([], Str, Line) of + {done, {ok, Tokens, EndLine}, MoreChars} -> + case erl_parse:parse_term(Tokens) of + {ok, Term} -> + parse_inetrc(MoreChars, EndLine, [Term|Ack]); + Error -> + {error, {'parse_inetrc', Error}} + end; + {done, {eof, _}, _} -> + {ok, reverse(Ack)}; + {done, Error, _} -> + {error, {'scan_inetrc', Error}}; + {more, _} -> %% Bug in erl_scan !! + {error, {'scan_inetrc', {eof, Line}}} + end. diff --git a/lib/kernel/src/inet_config.hrl b/lib/kernel/src/inet_config.hrl new file mode 100644 index 0000000000..e9bb79f05d --- /dev/null +++ b/lib/kernel/src/inet_config.hrl @@ -0,0 +1,34 @@ +%% +%% %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% +%% + +%% Configuration constants + +-define(DEFAULT_ETC, "/etc"). +-define(DEFAULT_SERVICES, "services"). +-define(DEFAULT_RPC, "rpc"). +-define(DEFAULT_HOSTS, "hosts"). +-define(DEFAULT_RESOLV, "resolv.conf"). +-define(DEFAULT_PROTOCOLS, "protocols"). +-define(DEFAULT_NETMASKS, "netmasks"). +-define(DEFAULT_NETWORKS, "networks"). + +-define(DEFAULT_UDP_MODULE, inet_udp). +-define(DEFAULT_TCP_MODULE, inet_tcp). +-define(DEFAULT_SCTP_MODULE, inet_sctp). + 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)]. diff --git a/lib/kernel/src/inet_dns.erl b/lib/kernel/src/inet_dns.erl new file mode 100644 index 0000000000..669a361c9d --- /dev/null +++ b/lib/kernel/src/inet_dns.erl @@ -0,0 +1,701 @@ +%% +%% %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_dns). + +%% Dns record encode/decode +%% +%% RFC 1035: Domain Names - Implementation and Specification +%% RFC 2181: Clarifications to the DNS Specification +%% RFC 2671: Extension Mechanisms for DNS (EDNS0) +%% RFC 2782: A DNS RR for specifying the location of services (DNS SRV) +%% RFC 2915: The Naming Authority Pointer (NAPTR) DNS Resource Rec + +-export([decode/1, encode/1]). + +-import(lists, [reverse/1, reverse/2, nthtail/2]). + +-include("inet_int.hrl"). +-include("inet_dns.hrl"). + +-export([record_type/1, rr/1, rr/2]). +-export([make_rr/0, make_rr/1, make_rr/2, make_rr/3]). +%% ADTs exports. The make_* functions are undocumented. +-export([msg/1, msg/2, + make_msg/0, make_msg/1, make_msg/2, make_msg/3]). +-export([header/1, header/2, + make_header/0, make_header/1, make_header/2, make_header/3]). +-export([dns_query/1, dns_query/2, + make_dns_query/0, make_dns_query/1, + make_dns_query/2, make_dns_query/3]). +-include("inet_dns_record_adts.hrl"). + +%% Function merge of #dns_rr{} and #dns_rr_opt{} +%% + +record_type(#dns_rr{}) -> rr; +record_type(#dns_rr_opt{}) -> rr; +record_type(Rec) -> + record_adts(Rec). + +rr(#dns_rr{}=RR) -> dns_rr(RR); +rr(#dns_rr_opt{}=RR) -> dns_rr_opt(RR). + +rr(#dns_rr{}=RR, L) -> dns_rr(RR, L); +rr(#dns_rr_opt{}=RR, L) -> dns_rr_opt(RR, L). + +make_rr() -> make_dns_rr(). + +make_rr(L) when is_list(L) -> + case rr_type(L, any) of + opt -> make_dns_rr_opt(L); + _ -> make_dns_rr(L) + end. + +make_rr(type, opt) -> make_dns_rr_opt(); +make_rr(F, V) when is_atom(F) -> make_dns_rr(F, V); +make_rr(#dns_rr{}=RR, L) when is_list(L) -> + case rr_type(L, RR#dns_rr.type) of + opt -> + Ts = common_fields__rr__rr_opt(), + make_dns_rr_opt([Opt || {T,_}=Opt <- dns_rr(RR), + lists_member(T, Ts)] ++ L); + _ -> make_dns_rr(RR, L) + end; +make_rr(#dns_rr_opt{}=RR, L) when is_list(L) -> + case rr_type(L, RR#dns_rr_opt.type) of + opt -> + make_dns_rr_opt(RR, L); + _ -> + Ts = common_fields__rr__rr_opt(), + make_dns_rr([Opt || {T,_}=Opt <- dns_rr_opt(RR), + lists_member(T, Ts)] ++ L) + end. + +make_rr(#dns_rr{}=RR, type, opt) -> make_rr(RR, [{type,opt}]); +make_rr(#dns_rr{}=RR, F, V) -> make_dns_rr(RR, F, V); +make_rr(#dns_rr_opt{}=RR, type, opt) -> RR; +make_rr(#dns_rr_opt{}=RR, type, T) -> make_rr(RR, [{type,T}]); +make_rr(#dns_rr_opt{}=RR, F, V) -> make_dns_rr_opt(RR, F, V). + +-compile({inline, [rr_type/2]}). +rr_type([], T) -> T; +rr_type([{type,T}|Opts], _) -> rr_type(Opts, T); +rr_type([_|Opts], T) -> rr_type(Opts, T). + +common_fields__rr__rr_opt() -> + [T || T <- record_info(fields, dns_rr_opt), + lists_member(T, record_info(fields, dns_rr))]. + +-compile({inline, [lists_member/2]}). +lists_member(_, []) -> false; +lists_member(H, [H|_]) -> true; +lists_member(H, [_|T]) -> lists_member(H, T). + + + +-define(DECODE_ERROR, fmt). % must match a clause in inet_res:query_nss_e?dns + +%% +%% Decode a dns buffer. +%% + +decode(Buffer) when is_binary(Buffer) -> + try do_decode(Buffer) of + DnsRec -> + {ok,DnsRec} + catch + Reason -> + {error,Reason} + end. + +do_decode(<<Id:16, + QR:1,Opcode:4,AA:1,TC:1,RD:1, + RA:1,PR:1,_:2,Rcode:4, + QdCount:16,AnCount:16,NsCount:16,ArCount:16, + QdBuf/binary>>=Buffer) -> + {AnBuf,QdList} = decode_query_section(QdBuf,QdCount,Buffer), + {NsBuf,AnList} = decode_rr_section(AnBuf,AnCount,Buffer), + {ArBuf,NsList} = decode_rr_section(NsBuf,NsCount,Buffer), + {Rest,ArList} = decode_rr_section(ArBuf,ArCount,Buffer), + case Rest of + <<>> -> + DnsHdr = + #dns_header{id=Id, + qr=decode_boolean(QR), + opcode=decode_opcode(Opcode), + aa=decode_boolean(AA), + tc=decode_boolean(TC), + rd=decode_boolean(RD), + ra=decode_boolean(RA), + pr=decode_boolean(PR), + rcode=Rcode}, + #dns_rec{header=DnsHdr, + qdlist=QdList, + anlist=AnList, + nslist=NsList, + arlist=ArList}; + _ -> + %% Garbage data after DNS message + throw(?DECODE_ERROR) + end; +do_decode(_) -> + %% DNS message does not even match header + throw(?DECODE_ERROR). + +decode_query_section(Bin, N, Buffer) -> + decode_query_section(Bin, N, Buffer, []). + +decode_query_section(Rest, 0, _Buffer, Qs) -> + {Rest,reverse(Qs)}; +decode_query_section(Bin, N, Buffer, Qs) -> + case decode_name(Bin, Buffer) of + {<<Type:16,Class:16,Rest/binary>>,Name} -> + DnsQuery = + #dns_query{domain=Name, + type=decode_type(Type), + class=decode_class(Class)}, + decode_query_section(Rest, N-1, Buffer, [DnsQuery|Qs]); + _ -> + %% Broken question + throw(?DECODE_ERROR) + end. + +decode_rr_section(Bin, N, Buffer) -> + decode_rr_section(Bin, N, Buffer, []). + +decode_rr_section(Rest, 0, _Buffer, RRs) -> + {Rest,reverse(RRs)}; +decode_rr_section(Bin, N, Buffer, RRs) -> + case decode_name(Bin, Buffer) of + {<<T:16/unsigned,C:16/unsigned,TTL:4/binary, + Len:16,D:Len/binary,Rest/binary>>, + Name} -> + Type = decode_type(T), + Class = decode_class(C), + Data = decode_data(D, Class, Type, Buffer), + RR = + case Type of + opt -> + <<ExtRcode,Version,Z:16>> = TTL, + #dns_rr_opt{domain=Name, + type=Type, + udp_payload_size=C, + ext_rcode=ExtRcode, + version=Version, + z=Z, + data=Data}; + _ -> + <<TimeToLive:32/signed>> = TTL, + #dns_rr{domain=Name, + type=Type, + class=Class, + ttl=if TimeToLive < 0 -> 0; + true -> TimeToLive end, + data=Data} + end, + decode_rr_section(Rest, N-1, Buffer, [RR|RRs]); + _ -> + %% Broken RR + throw(?DECODE_ERROR) + end. + +%% +%% Encode a user query +%% + +encode(Q) -> + QdCount = length(Q#dns_rec.qdlist), + AnCount = length(Q#dns_rec.anlist), + NsCount = length(Q#dns_rec.nslist), + ArCount = length(Q#dns_rec.arlist), + B0 = encode_header(Q#dns_rec.header, QdCount, AnCount, NsCount, ArCount), + C0 = gb_trees:empty(), + {B1,C1} = encode_query_section(B0, C0, Q#dns_rec.qdlist), + {B2,C2} = encode_res_section(B1, C1, Q#dns_rec.anlist), + {B3,C3} = encode_res_section(B2, C2, Q#dns_rec.nslist), + {B,_} = encode_res_section(B3, C3, Q#dns_rec.arlist), + B. + + +%% RFC 1035: 4.1.1. Header section format +%% +encode_header(#dns_header{id=Id}=H, QdCount, AnCount, NsCount, ArCount) -> + QR = encode_boolean(H#dns_header.qr), + Opcode = encode_opcode(H#dns_header.opcode), + AA = encode_boolean(H#dns_header.aa), + TC = encode_boolean(H#dns_header.tc), + RD = encode_boolean(H#dns_header.rd), + RA = encode_boolean(H#dns_header.ra), + PR = encode_boolean(H#dns_header.pr), + Rcode = H#dns_header.rcode, + <<Id:16, + QR:1,Opcode:4,AA:1,TC:1,RD:1, + RA:1,PR:1,0:2,Rcode:4, + QdCount:16,AnCount:16,NsCount:16,ArCount:16>>. + +%% RFC 1035: 4.1.2. Question section format +%% +encode_query_section(Bin, Comp, []) -> {Bin,Comp}; +encode_query_section(Bin0, Comp0, [#dns_query{domain=DName}=Q | Qs]) -> + Type = encode_type(Q#dns_query.type), + Class = encode_class(Q#dns_query.class), + {Bin,Comp} = encode_name(Bin0, Comp0, byte_size(Bin0), DName), + encode_query_section(<<Bin/binary,Type:16,Class:16>>, Comp, Qs). + +%% RFC 1035: 4.1.3. Resource record format +%% RFC 2671: 4.3, 4.4, 4.6 OPT RR format +%% +encode_res_section(Bin, Comp, []) -> {Bin,Comp}; +encode_res_section(Bin, Comp, [#dns_rr {domain = DName, + type = Type, + class = Class, + ttl = TTL, + data = Data} | Rs]) -> + encode_res_section_rr(Bin, Comp, Rs, + DName, Type, Class, <<TTL:32/signed>>, Data); +encode_res_section(Bin, Comp, [#dns_rr_opt {domain = DName, + udp_payload_size = UdpPayloadSize, + ext_rcode = ExtRCode, + version = Version, + z = Z, + data = Data} | Rs]) -> + encode_res_section_rr(Bin, Comp, Rs, + DName, ?S_OPT, UdpPayloadSize, + <<ExtRCode,Version,Z:16>>, Data). + +encode_res_section_rr(Bin0, Comp0, Rs, DName, Type, Class, TTL, Data) -> + T = encode_type(Type), + C = encode_class(Class), + {Bin,Comp1} = encode_name(Bin0, Comp0, byte_size(Bin0), DName), + {DataBin,Comp} = encode_data(Comp1, byte_size(Bin)+2+2+byte_size(TTL)+2, + Type, Class, Data), + DataSize = byte_size(DataBin), + encode_res_section(<<Bin/binary,T:16,C:16, + TTL/binary,DataSize:16,DataBin/binary>>, Comp, Rs). + +%% +%% Resource types +%% +decode_type(Type) -> + case Type of + ?T_A -> ?S_A; + ?T_NS -> ?S_NS; + ?T_MD -> ?S_MD; + ?T_MF -> ?S_MF; + ?T_CNAME -> ?S_CNAME; + ?T_SOA -> ?S_SOA; + ?T_MB -> ?S_MB; + ?T_MG -> ?S_MG; + ?T_MR -> ?S_MR; + ?T_NULL -> ?S_NULL; + ?T_WKS -> ?S_WKS; + ?T_PTR -> ?S_PTR; + ?T_HINFO -> ?S_HINFO; + ?T_MINFO -> ?S_MINFO; + ?T_MX -> ?S_MX; + ?T_TXT -> ?S_TXT; + ?T_AAAA -> ?S_AAAA; + ?T_SRV -> ?S_SRV; + ?T_NAPTR -> ?S_NAPTR; + ?T_OPT -> ?S_OPT; + ?T_SPF -> ?S_SPF; + %% non standard + ?T_UINFO -> ?S_UINFO; + ?T_UID -> ?S_UID; + ?T_GID -> ?S_GID; + ?T_UNSPEC -> ?S_UNSPEC; + %% Query type values which do not appear in resource records + ?T_AXFR -> ?S_AXFR; + ?T_MAILB -> ?S_MAILB; + ?T_MAILA -> ?S_MAILA; + ?T_ANY -> ?S_ANY; + _ -> Type %% raw unknown type + end. + +%% +%% Resource types +%% +encode_type(Type) -> + case Type of + ?S_A -> ?T_A; + ?S_NS -> ?T_NS; + ?S_MD -> ?T_MD; + ?S_MF -> ?T_MF; + ?S_CNAME -> ?T_CNAME; + ?S_SOA -> ?T_SOA; + ?S_MB -> ?T_MB; + ?S_MG -> ?T_MG; + ?S_MR -> ?T_MR; + ?S_NULL -> ?T_NULL; + ?S_WKS -> ?T_WKS; + ?S_PTR -> ?T_PTR; + ?S_HINFO -> ?T_HINFO; + ?S_MINFO -> ?T_MINFO; + ?S_MX -> ?T_MX; + ?S_TXT -> ?T_TXT; + ?S_AAAA -> ?T_AAAA; + ?S_SRV -> ?T_SRV; + ?S_NAPTR -> ?T_NAPTR; + ?S_OPT -> ?T_OPT; + ?S_SPF -> ?T_SPF; + %% non standard + ?S_UINFO -> ?T_UINFO; + ?S_UID -> ?T_UID; + ?S_GID -> ?T_GID; + ?S_UNSPEC -> ?T_UNSPEC; + %% Query type values which do not appear in resource records + ?S_AXFR -> ?T_AXFR; + ?S_MAILB -> ?T_MAILB; + ?S_MAILA -> ?T_MAILA; + ?S_ANY -> ?T_ANY; + Type when is_integer(Type) -> Type %% raw unknown type + end. + +%% +%% Resource clases +%% + +decode_class(Class) -> + case Class of + ?C_IN -> in; + ?C_CHAOS -> chaos; + ?C_HS -> hs; + ?C_ANY -> any; + _ -> Class %% raw unknown class + end. + +encode_class(Class) -> + case Class of + in -> ?C_IN; + chaos -> ?C_CHAOS; + hs -> ?C_HS; + any -> ?C_ANY; + Class when is_integer(Class) -> Class %% raw unknown class + end. + +decode_opcode(Opcode) -> + case Opcode of + ?QUERY -> 'query'; + ?IQUERY -> iquery; + ?STATUS -> status; + _ when is_integer(Opcode) -> Opcode %% non-standard opcode + end. + +encode_opcode(Opcode) -> + case Opcode of + 'query' -> ?QUERY; + iquery -> ?IQUERY; + status -> ?STATUS; + _ when is_integer(Opcode) -> Opcode %% non-standard opcode + end. + + +encode_boolean(true) -> 1; +encode_boolean(false) -> 0; +encode_boolean(B) when is_integer(B) -> B. + +decode_boolean(0) -> false; +decode_boolean(I) when is_integer(I) -> true. + +%% +%% Data field -> term() content representation +%% +decode_data(<<A,B,C,D>>, in, ?S_A, _) -> {A,B,C,D}; +decode_data(<<A:16,B:16,C:16,D:16,E:16,F:16,G:16,H:16>>, in, ?S_AAAA, _) -> + {A,B,C,D,E,F,G,H}; +decode_data(Dom, _, ?S_NS, Buffer) -> decode_domain(Dom, Buffer); +decode_data(Dom, _, ?S_MD, Buffer) -> decode_domain(Dom, Buffer); +decode_data(Dom, _, ?S_MF, Buffer) -> decode_domain(Dom, Buffer); +decode_data(Dom, _, ?S_CNAME, Buffer) -> decode_domain(Dom, Buffer); +decode_data(Data0, _, ?S_SOA, Buffer) -> + {Data1,MName} = decode_name(Data0, Buffer), + {Data,RName} = decode_name(Data1, Buffer), + case Data of + <<Serial:32,Refresh:32/signed,Retry:32/signed, + Expiry:32/signed,Minimum:32>> -> + {MName,RName,Serial,Refresh,Retry,Expiry,Minimum}; + _ -> + %% Broken SOA RR data + throw(?DECODE_ERROR) + end; +decode_data(Dom, _, ?S_MB, Buffer) -> decode_domain(Dom, Buffer); +decode_data(Dom, _, ?S_MG, Buffer) -> decode_domain(Dom, Buffer); +decode_data(Dom, _, ?S_MR, Buffer) -> decode_domain(Dom, Buffer); +decode_data(Data, _, ?S_NULL, _) -> Data; +decode_data(<<A,B,C,D,Proto,BitMap/binary>>, in, ?S_WKS, _Buffer) -> + {{A,B,C,D},Proto,BitMap}; +decode_data(Dom, _, ?S_PTR, Buffer) -> decode_domain(Dom, Buffer); +decode_data(<<CpuLen,CPU:CpuLen/binary, + OsLen,OS:OsLen/binary>>, _, ?S_HINFO, _) -> + {binary_to_list(CPU),binary_to_list(OS)}; +decode_data(Data0, _, ?S_MINFO, Buffer) -> + {Data1,RM} = decode_name(Data0, Buffer), + {Data,EM} = decode_name(Data1, Buffer), + case Data of + <<>> -> {RM,EM}; + _ -> + %% Broken MINFO data + throw(?DECODE_ERROR) + end; +decode_data(<<Prio:16,Dom/binary>>, _, ?S_MX, Buffer) -> + {Prio,decode_domain(Dom, Buffer)}; +decode_data(<<Prio:16,Weight:16,Port:16,Dom/binary>>, _, ?S_SRV, Buffer) -> + {Prio,Weight,Port,decode_domain(Dom, Buffer)}; +decode_data(<<Order:16,Preference:16,Data0/binary>>, _, ?S_NAPTR, Buffer) -> + {Data1,Flags} = decode_string(Data0), + {Data2,Services} = decode_string(Data1), + {Data,Regexp} = decode_characters(Data2, utf8), + Replacement = decode_domain(Data, Buffer), + {Order,Preference,string:to_lower(Flags),string:to_lower(Services), + Regexp,Replacement}; +%% ?S_OPT falls through to default +decode_data(Data, _, ?S_TXT, _) -> + decode_txt(Data); +decode_data(Data, _, ?S_SPF, _) -> + decode_txt(Data); +%% sofar unknown or non standard +decode_data(Data, _, _, _) -> + Data. + +%% Array of strings +%% +decode_txt(<<>>) -> []; +decode_txt(Bin) -> + {Rest,String} = decode_string(Bin), + [String|decode_txt(Rest)]. + +decode_string(<<Len,Bin:Len/binary,Rest/binary>>) -> + {Rest,binary_to_list(Bin)}; +decode_string(_) -> + %% Broken string + throw(?DECODE_ERROR). + +decode_characters(<<Len,Bin:Len/binary,Rest/binary>>, Encoding) -> + {Rest,unicode:characters_to_list(Bin, Encoding)}; +decode_characters(_, _) -> + %% Broken encoded string + throw(?DECODE_ERROR). + +%% One domain name only, there must be nothing after +%% +decode_domain(Bin, Buffer) -> + case decode_name(Bin, Buffer) of + {<<>>,Name} -> Name; + _ -> + %% Garbage after domain name + throw(?DECODE_ERROR) + end. + +%% Domain name -> {RestBin,Name} +%% +decode_name(Bin, Buffer) -> + decode_name(Bin, Buffer, [], Bin, 0). + +%% Tail advances with Rest until the first indirection is followed +%% then it stays put at that Rest. +decode_name(_, Buffer, _Labels, _Tail, Cnt) when Cnt > byte_size(Buffer) -> + throw(?DECODE_ERROR); %% Insantiy bailout - this must be a decode loop +decode_name(<<0,Rest/binary>>, _Buffer, Labels, Tail, Cnt) -> + %% Root domain, we have all labels for the domain name + {if Cnt =/= 0 -> Tail; true -> Rest end, + decode_name_labels(Labels)}; +decode_name(<<0:2,Len:6,Label:Len/binary,Rest/binary>>, + Buffer, Labels, Tail, Cnt) -> + %% One plain label here + decode_name(Rest, Buffer, [Label|Labels], + if Cnt =/= 0 -> Tail; true -> Rest end, + Cnt); +decode_name(<<3:2,Ptr:14,Rest/binary>>, Buffer, Labels, Tail, Cnt) -> + %% Indirection - reposition in buffer and recurse + case Buffer of + <<_:Ptr/binary,Bin/binary>> -> + decode_name(Bin, Buffer, Labels, + if Cnt =/= 0 -> Tail; true -> Rest end, + Cnt+2); % size of indirection pointer + _ -> + %% Indirection pointer outside buffer + throw(?DECODE_ERROR) + end; +decode_name(_, _, _, _, _) -> throw(?DECODE_ERROR). + +%% Reverse list of labels (binaries) -> domain name (string) +decode_name_labels([]) -> "."; +decode_name_labels(Labels) -> + decode_name_labels(Labels, ""). + +decode_name_labels([Label], Name) -> + decode_name_label(Label, Name); +decode_name_labels([Label|Labels], Name) -> + decode_name_labels(Labels, "."++decode_name_label(Label, Name)). + +decode_name_label(<<>>, _Name) -> + %% Empty label is only allowed for the root domain, + %% and that is handled above. + throw(?DECODE_ERROR); +decode_name_label(Label, Name) -> + decode_name_label(Label, Name, byte_size(Label)). + +%% Decode $. and $\\ to become $\\ escaped characters +%% in the string representation. +-compile({inline, [decode_name_label/3]}). +decode_name_label(_, Name, 0) -> Name; +decode_name_label(Label, Name, N) -> + M = N-1, + case Label of + <<_:M/binary,($\\),_/binary>> -> + decode_name_label(Label, "\\\\"++Name, M); + <<_:M/binary,($.),_/binary>> -> + decode_name_label(Label, "\\."++Name, M); + <<_:M/binary,C,_/binary>> -> + decode_name_label(Label, [C|Name], M); + _ -> + %% This should not happen but makes surrounding + %% programming errors easier to locate. + erlang:error(badarg, [Label,Name,N]) + end. + +%% +%% Data field -> {binary(),NewCompressionTable} +%% +encode_data(Comp, _, ?S_A, in, {A,B,C,D}) -> {<<A,B,C,D>>,Comp}; +encode_data(Comp, _, ?S_AAAA, in, {A,B,C,D,E,F,G,H}) -> + {<<A:16,B:16,C:16,D:16,E:16,F:16,G:16,H:16>>,Comp}; +encode_data(Comp, Pos, ?S_NS, in, Domain) -> encode_name(Comp, Pos, Domain); +encode_data(Comp, Pos, ?S_MD, in, Domain) -> encode_name(Comp, Pos, Domain); +encode_data(Comp, Pos, ?S_MF, in, Domain) -> encode_name(Comp, Pos, Domain); +encode_data(Comp, Pos, ?S_CNAME, in, Domain) -> encode_name(Comp, Pos, Domain); +encode_data(Comp0, Pos, ?S_SOA, in, + {MName,RName,Serial,Refresh,Retry,Expiry,Minimum}) -> + {B1,Comp1} = encode_name(Comp0, Pos, MName), + {B,Comp} = encode_name(B1, Comp1, Pos+byte_size(B1), RName), + {<<B/binary,Serial:32,Refresh:32/signed,Retry:32/signed, + Expiry:32/signed,Minimum:32>>, + Comp}; +encode_data(Comp, Pos, ?S_MB, in, Domain) -> encode_name(Comp, Pos, Domain); +encode_data(Comp, Pos, ?S_MG, in, Domain) -> encode_name(Comp, Pos, Domain); +encode_data(Comp, Pos, ?S_MR, in, Domain) -> encode_name(Comp, Pos, Domain); +encode_data(Comp, _, ?S_NULL, in, Data) -> + {iolist_to_binary(Data),Comp}; +encode_data(Comp, _, ?S_WKS, in, {{A,B,C,D},Proto,BitMap}) -> + BitMapBin = iolist_to_binary(BitMap), + {<<A,B,C,D,Proto,BitMapBin/binary>>,Comp}; +encode_data(Comp, Pos, ?S_PTR, in, Domain) -> encode_name(Comp, Pos, Domain); +encode_data(Comp, _, ?S_HINFO, in, {CPU,OS}) -> + Bin = encode_string(iolist_to_binary(CPU)), + {encode_string(Bin, iolist_to_binary(OS)),Comp}; +encode_data(Comp0, Pos, ?S_MINFO, in, {RM,EM}) -> + {Bin,Comp} = encode_name(Comp0, Pos, RM), + encode_name(Bin, Comp, Pos+byte_size(Bin), EM); +encode_data(Comp, Pos, ?S_MX, in, {Pref,Exch}) -> + encode_name(<<Pref:16>>, Comp, Pos+2, Exch); +encode_data(Comp, Pos, ?S_SRV, in, {Prio,Weight,Port,Target}) -> + encode_name(<<Prio:16,Weight:16,Port:16>>, Comp, Pos+2+2+2, Target); +encode_data(Comp, Pos, ?S_NAPTR, in, + {Order,Preference,Flags,Services,Regexp,Replacement}) -> + B0 = <<Order:16,Preference:16>>, + B1 = encode_string(B0, iolist_to_binary(Flags)), + B2 = encode_string(B1, iolist_to_binary(Services)), + B3 = encode_string(B2, unicode:characters_to_binary(Regexp, + unicode, utf8)), + %% Bypass name compression (RFC 2915: section 2) + {B,_} = encode_name(B3, gb_trees:empty(), Pos+byte_size(B3), Replacement), + {B,Comp}; +%% ?S_OPT falls through to default +encode_data(Comp, _, ?S_TXT, in, Data) -> {encode_txt(Data),Comp}; +encode_data(Comp, _, ?S_SPF, in, Data) -> {encode_txt(Data),Comp}; +encode_data(Comp, _Pos, _Type, _Class, Data) -> {iolist_to_binary(Data),Comp}. + +%% Array of strings +%% +encode_txt(Strings) -> + encode_txt(<<>>, Strings). +%% +encode_txt(Bin, []) -> Bin; +encode_txt(Bin, [S|Ss]) -> + encode_txt(encode_string(Bin, iolist_to_binary(S)), Ss). + +%% Singular string +%% +encode_string(StringBin) -> + encode_string(<<>>, StringBin). +%% +encode_string(Bin, StringBin) -> + Size = byte_size(StringBin), + if Size =< 255 -> + <<Bin/binary,Size,StringBin/binary>> + end. + +%% Domain name +%% +encode_name(Comp, Pos, Name) -> + encode_name(<<>>, Comp, Pos, Name). +%% +%% Bin = target binary +%% Comp = compression lookup table; label list -> buffer position +%% Pos = position in DNS message +%% Name = domain name to encode +%% +%% The name compression does not make the case conversions +%% it could. This means case will be preserved at the cost +%% of missed compression opportunities. But if the encoded +%% message use the same case for different instances of +%% the same domain name there is no problem, and if not it is +%% only compression that suffers. Furthermore encode+decode +%% this way becomes an identity operation for any decoded +%% DNS message which is nice for testing encode. +%% +encode_name(Bin0, Comp0, Pos, Name) -> + case encode_labels(Bin0, Comp0, Pos, name2labels(Name)) of + {Bin,_}=Result when byte_size(Bin) - byte_size(Bin0) =< 255 -> Result; + _ -> + %% Fail on too long name + erlang:error(badarg, [Bin0,Comp0,Pos,Name]) + end. + +name2labels("") -> []; +name2labels(".") -> []; +name2labels(Cs) -> name2labels(<<>>, Cs). +%% +-compile({inline, [name2labels/2]}). +name2labels(Label, "") -> [Label]; +name2labels(Label, ".") -> [Label]; +name2labels(Label, "."++Cs) -> [Label|name2labels(<<>>, Cs)]; +name2labels(Label, "\\"++[C|Cs]) -> name2labels(<<Label/binary,C>>, Cs); +name2labels(Label, [C|Cs]) -> name2labels(<<Label/binary,C>>, Cs). + +%% Fail on empty or too long labels. +encode_labels(Bin, Comp, _Pos, []) -> + {<<Bin/binary,0>>,Comp}; +encode_labels(Bin, Comp0, Pos, [L|Ls]=Labels) + when 1 =< byte_size(L), byte_size(L) =< 63 -> + case gb_trees:lookup(Labels, Comp0) of + none -> + Comp = if Pos < (3 bsl 14) -> + %% Just in case - compression + %% pointers can not reach further + gb_trees:insert(Labels, Pos, Comp0); + true -> Comp0 + end, + Size = byte_size(L), + encode_labels(<<Bin/binary,Size,L/binary>>, + Comp, Pos+1+Size, Ls); + {value,Ptr} -> + %% Name compression - point to already encoded name + {<<Bin/binary,3:2,Ptr:14>>,Comp0} + end. diff --git a/lib/kernel/src/inet_dns.hrl b/lib/kernel/src/inet_dns.hrl new file mode 100644 index 0000000000..1b69f31a4d --- /dev/null +++ b/lib/kernel/src/inet_dns.hrl @@ -0,0 +1,208 @@ +%% +%% %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% +%% +%% +%% Defintion for Domain Name System +%% + +%% +%% Currently defined opcodes +%% +-define(QUERY, 16#0). %% standard query +-define(IQUERY, 16#1). %% inverse query +-define(STATUS, 16#2). %% nameserver status query +%% -define(xxx, 16#3) %% 16#3 reserved +%% non standard +-define(UPDATEA, 16#9). %% add resource record +-define(UPDATED, 16#a). %% delete a specific resource record +-define(UPDATEDA, 16#b). %% delete all nemed resource record +-define(UPDATEM, 16#c). %% modify a specific resource record +-define(UPDATEMA, 16#d). %% modify all named resource record + +-define(ZONEINIT, 16#e). %% initial zone transfer +-define(ZONEREF, 16#f). %% incremental zone referesh + + +%% +%% Currently defined response codes +%% +-define(NOERROR, 0). %% no error +-define(FORMERR, 1). %% format error +-define(SERVFAIL, 2). %% server failure +-define(NXDOMAIN, 3). %% non existent domain +-define(NOTIMP, 4). %% not implemented +-define(REFUSED, 5). %% query refused +%% non standard +-define(NOCHANGE, 16#f). %% update failed to change db +-define(BADVERS, 16). + +%% +%% Type values for resources and queries +%% +-define(T_A, 1). %% host address +-define(T_NS, 2). %% authoritative server +-define(T_MD, 3). %% mail destination +-define(T_MF, 4). %% mail forwarder +-define(T_CNAME, 5). %% connonical name +-define(T_SOA, 6). %% start of authority zone +-define(T_MB, 7). %% mailbox domain name +-define(T_MG, 8). %% mail group member +-define(T_MR, 9). %% mail rename name +-define(T_NULL, 10). %% null resource record +-define(T_WKS, 11). %% well known service +-define(T_PTR, 12). %% domain name pointer +-define(T_HINFO, 13). %% host information +-define(T_MINFO, 14). %% mailbox information +-define(T_MX, 15). %% mail routing information +-define(T_TXT, 16). %% text strings +-define(T_AAAA, 28). %% ipv6 address +%% SRV (RFC 2052) +-define(T_SRV, 33). %% services +%% NAPTR (RFC 2915) +-define(T_NAPTR, 35). %% naming authority pointer +-define(T_OPT, 41). %% EDNS pseudo-rr RFC2671(7) +%% SPF (RFC 4408) +-define(T_SPF, 99). %% server policy framework +%% non standard +-define(T_UINFO, 100). %% user (finger) information +-define(T_UID, 101). %% user ID +-define(T_GID, 102). %% group ID +-define(T_UNSPEC, 103). %% Unspecified format (binary data) +%% Query type values which do not appear in resource records +-define(T_AXFR, 252). %% transfer zone of authority +-define(T_MAILB, 253). %% transfer mailbox records +-define(T_MAILA, 254). %% transfer mail agent records +-define(T_ANY, 255). %% wildcard match + +%% +%% Symbolic Type values for resources and queries +%% +-define(S_A, a). %% host address +-define(S_NS, ns). %% authoritative server +-define(S_MD, md). %% mail destination +-define(S_MF, mf). %% mail forwarder +-define(S_CNAME, cname). %% connonical name +-define(S_SOA, soa). %% start of authority zone +-define(S_MB, mb). %% mailbox domain name +-define(S_MG, mg). %% mail group member +-define(S_MR, mr). %% mail rename name +-define(S_NULL, null). %% null resource record +-define(S_WKS, wks). %% well known service +-define(S_PTR, ptr). %% domain name pointer +-define(S_HINFO, hinfo). %% host information +-define(S_MINFO, minfo). %% mailbox information +-define(S_MX, mx). %% mail routing information +-define(S_TXT, txt). %% text strings +-define(S_AAAA, aaaa). %% ipv6 address +%% SRV (RFC 2052) +-define(S_SRV, srv). %% services +%% NAPTR (RFC 2915) +-define(S_NAPTR, naptr). %% naming authority pointer +-define(S_OPT, opt). %% EDNS pseudo-rr RFC2671(7) +%% SPF (RFC 4408) +-define(S_SPF, spf). %% server policy framework +%% non standard +-define(S_UINFO, uinfo). %% user (finger) information +-define(S_UID, uid). %% user ID +-define(S_GID, gid). %% group ID +-define(S_UNSPEC, unspec). %% Unspecified format (binary data) +%% Query type values which do not appear in resource records +-define(S_AXFR, axfr). %% transfer zone of authority +-define(S_MAILB, mailb). %% transfer mailbox records +-define(S_MAILA, maila). %% transfer mail agent records +-define(S_ANY, any). %% wildcard match + +%% +%% Values for class field +%% + +-define(C_IN, 1). %% the arpa internet +-define(C_CHAOS, 3). %% for chaos net at MIT +-define(C_HS, 4). %% for Hesiod name server at MIT +%% Query class values which do not appear in resource records +-define(C_ANY, 255). %% wildcard match + + +%% indirection mask for compressed domain names +-define(INDIR_MASK, 16#c0). + +%% +%% Structure for query header, the order of the fields is machine and +%% compiler dependent, in our case, the bits within a byte are assignd +%% least significant first, while the order of transmition is most +%% significant first. This requires a somewhat confusing rearrangement. +%% +-record(dns_header, + { + id = 0, %% ushort query identification number + %% byte F0 + qr = 0, %% :1 response flag + opcode = 0, %% :4 purpose of message + aa = 0, %% :1 authoritive answer + tc = 0, %% :1 truncated message + rd = 0, %% :1 recursion desired + %% byte F1 + ra = 0, %% :1 recursion available + pr = 0, %% :1 primary server required (non standard) + %% :2 unused bits + rcode = 0 %% :4 response code + }). + +-record(dns_rec, + { + header, %% dns_header record + qdlist = [], %% list of question entries + anlist = [], %% list of answer entries + nslist = [], %% list of authority entries + arlist = [] %% list of resource entries + }). + +%% DNS resource record +-record(dns_rr, + { + domain = "", %% resource domain + type = any, %% resource type + class = in, %% reource class + cnt = 0, %% access count + ttl = 0, %% time to live + data = [], %% raw data + %% + tm, %% creation time + bm = [], %% Bitmap storing domain character case information. + func = false %% Optional function calculating the data field. + }). + +-define(DNS_UDP_PAYLOAD_SIZE, 1280). + +-record(dns_rr_opt, %% EDNS RR OPT (RFC2671), dns_rr{type=opt} + { + domain = "", %% should be the root domain + type = opt, + udp_payload_size = ?DNS_UDP_PAYLOAD_SIZE, %% RFC2671(4.5 CLASS) + ext_rcode = 0, %% RFC2671(4.6 EXTENDED-RCODE) + version = 0, %% RFC2671(4.6 VERSION) + z = 0, %% RFC2671(4.6 Z) + data = [] %% RFC2671(4.4) + }). + +-record(dns_query, + { + domain, %% query domain + type, %% query type + class %% query class + }). diff --git a/lib/kernel/src/inet_dns_record_adts.pl b/lib/kernel/src/inet_dns_record_adts.pl new file mode 100644 index 0000000000..b1d8fab939 --- /dev/null +++ b/lib/kernel/src/inet_dns_record_adts.pl @@ -0,0 +1,180 @@ +#! /usr/bin/env perl +# +# %CopyrightBegin% +# +# Copyright Ericsson AB 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% +# +use strict; + +# Generate ADT (Abstract Data Type) access and generation functions +# for internal records. +# +# The following defines which ADT function sets that will be generated +# and which record fields that will be exponated. +# +# (FunctionBaseName => [RecordName, FieldName ...], ...) +my %Names = ('msg' => ['dns_rec', 'header', 'qdlist', + 'anlist', 'nslist', 'arlist'], + 'dns_rr' => ['dns_rr', 'domain', 'type', 'class', 'ttl', 'data'], + 'dns_rr_opt' => ['dns_rr_opt', 'domain', 'type', + 'udp_payload_size', 'ext_rcode', 'version', + 'z', 'data'], + 'dns_query' => ['dns_query', 'domain', 'type', 'class'], + 'header' => ['dns_header', 'id', 'qr', 'opcode', 'aa', 'tc', + 'rd', 'ra', 'pr', 'rcode']); +# The functions are defined in the __DATA__ section at the end. + +# Read in __DATA__ and merge lines. +my $line = ''; +my @DATA; +my @INDEX; +while(<DATA>) { + chomp; + $line .= $_; + unless ($line =~ s/\\$//) { + if ($line =~ s/^[+]//) { + push(@INDEX, $line); + } else { + push(@DATA, $line); + } + $line = ''; + } +} + +$" = ','; +$\ = "\n"; +while( my ($Name, $r) = each(%Names)) { + # Create substitutions for this Name + my ($Record, @Fields) = @{ $r }; + my @FieldMatchValues; + my @FieldValueTuples; + my @Values; + my $n = $#{ $r }; + for my $i ( 1 .. $n ) { + push(@FieldMatchValues, "$Fields[$i-1]=V$i"); + push(@FieldValueTuples, "{$Fields[$i-1],V$i}"); + push(@Values, "V$i"); + } + # "@FieldMatchValues" = "field1=V1,field2=V2"...",fieldN=VN" + # "@FieldMatchTuples" = "{field1,V1},{field2,V2}"...",{fieldN,VN}" + # "@Values" = "V1,V2"...",VN" + my @D = @DATA; + foreach my $line (@D) { + my $m = 1; + # For leading * iterate $n times, otherwise once + $line =~ s/^\s*[*]// and $m = $n; + for my $i ( 1 .. $m ) { + # For this iteration - substitute and print + my $Value = "V$i"; + my $SemicolonDot = ";"; + $SemicolonDot = "." if $i == $m; + my @ValuesIgnoreValue = @Values; + $ValuesIgnoreValue[$i-1] = '_'; + # "$Value" = "V1" or "V2" or ... "VN" + # "@ValuesIgnoreValue" = "_,V2"...",VN" + # or "V1,_"...",VN" + # or ... "V1,V2"...",_" + $_ = $line; + s/FieldMatchValues\b/@FieldMatchValues/g; + s/FieldValueTuples\b/@FieldValueTuples/g; + s/Field\b/$Fields[$i-1]/g; + s/Name\b/$Name/g; + s/Record\b/$Record/g; + s/ValuesIgnoreValue\b/@ValuesIgnoreValue/g; + s/Values\b/@Values/g; + s/Value\b/$Value/g; + s/[;][.]/$SemicolonDot/g; + s/->\s*/->\n /; + print; + } + } +} +for my $i ( 0 .. $#INDEX ) { + my $line = $INDEX[$i]; + if ($line =~ s/^[*]//) { + while( my ($Name, $r) = each(%Names)) { + my ($Record) = @{ $r }; + $_ = $line; + s/Name\b/$Name/g; + s/Record\b/$Record/g; + s/->\s*/->\n /; + print; + } + } else { + print $line; + } +} + +# Trailing \ will merge line with the following. +# Leading * will iterate the (merged) line over all field names. +# Sub-words in the loop above are substituted. +__DATA__ + +%% +%% Abstract Data Type functions for #Record{} +%% +%% -export([Name/1, Name/2, +%% make_Name/0, make_Name/1, make_Name/2, make_Name/3]). + +%% Split #Record{} into property list +%% +Name(#Record{FieldMatchValues}) -> \ + [FieldValueTuples]. + +%% Get one field value from #Record{} +%% +*Name(#Record{Field=Value}, Field) -> \ + Value; +%% Map field name list to value list from #Record{} +%% +Name(#Record{}, []) -> \ + []; +*Name(#Record{Field=Value}=R, [Field|L]) -> \ + [Value|Name(R, L)];. + +%% Generate default #Record{} +%% +make_Name() -> \ + #Record{}. + +%% Generate #Record{} from property list +%% +make_Name(L) when is_list(L) -> \ + make_Name(#Record{}, L). + +%% Generate #Record{} with one updated field +%% +*make_Name(Field, Value) -> \ + #Record{Field=Value}; +%% +%% Update #Record{} from property list +%% +make_Name(#Record{FieldMatchValues}, L) when is_list(L) -> \ + do_make_Name(L, Values). +do_make_Name([], Values) -> \ + #Record{FieldMatchValues}; +*do_make_Name([{Field,Value}|L], ValuesIgnoreValue) -> \ + do_make_Name(L, Values);. + +%% Update one field of #Record{} +%% +*make_Name(#Record{}=R, Field, Value) -> \ + R#Record{Field=Value};. + ++%% Record type index ++%% ++*record_adts(#Record{}) -> Name; ++record_adts(_) -> undefined. diff --git a/lib/kernel/src/inet_gethost_native.erl b/lib/kernel/src/inet_gethost_native.erl new file mode 100644 index 0000000000..abdbe2b8cf --- /dev/null +++ b/lib/kernel/src/inet_gethost_native.erl @@ -0,0 +1,626 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1998-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_gethost_native). +-behaviour(supervisor_bridge). + +%% Supervisor bridge exports +-export([start_link/0, init/1, terminate/2, start_raw/0, run_once/0]). + +%% Server export +-export([server_init/2, main_loop/1]). + +%% API exports +-export([gethostbyname/1, gethostbyname/2, gethostbyaddr/1, control/1]). + +%%% Exports for sys:handle_system_msg/6 +-export([system_continue/3, system_terminate/4, system_code_change/4]). + +-include_lib("kernel/include/inet.hrl"). + +-define(PROCNAME_SUP, inet_gethost_native_sup). + +-define(OP_GETHOSTBYNAME,1). +-define(OP_GETHOSTBYADDR,2). +-define(OP_CANCEL_REQUEST,3). +-define(OP_CONTROL,4). + +-define(PROTO_IPV4,1). +-define(PROTO_IPV6,2). + +%% OP_CONTROL +-define(SETOPT_DEBUG_LEVEL, 0). + +-define(UNIT_ERROR,0). +-define(UNIT_IPV4,4). +-define(UNIT_IPV6,16). + +-define(PORT_PROGRAM, "inet_gethost"). +-define(DEFAULT_POOLSIZE, 4). +-define(REQUEST_TIMEOUT, (inet_db:res_option(timeout)*4)). + +-define(MAX_TIMEOUT, 16#7FFFFFF). +-define(INVALID_SERIAL, 16#FFFFFFFF). + +%-define(DEBUG,1). +-ifdef(DEBUG). +-define(dbg(A,B), io:format(A,B)). +-else. +-define(dbg(A,B), noop). +-endif. + +-define(SEND_AFTER(A,B,C),erlang:send_after(A,B,C)). +-define(CANCEL_TIMER(A),erlang:cancel_timer(A)). + +%% In erlang, IPV6 addresses are built as 8-tuples of 16bit values (not 16-tuples of octets). +%% This macro, meant to be used in guards checks one such 16bit value in the 8-tuple. +-define(VALID_V6(Part), is_integer(Part), Part < 65536). +%% The regular IPV4 addresses are represented as 4-tuples of octets, this macro, +%% meant to be used in guards, check one such octet. +-define(VALID_V4(Part), is_integer(Part), Part < 256). + +% Requests, one per unbique request to the PORT program, may be more than one client!!! +-record(request, { + rid, % Request id as sent to port + op, + proto, + rdata, + clients = [] % Can be more than one client per request (Pid's). +}). + + +% Statistics, not used yet. +-record(statistics, { + netdb_timeout = 0, + netdb_internal = 0, + port_crash = 0, + notsup = 0, + host_not_found = 0, + try_again = 0, + no_recovery = 0, + no_data = 0 +}). + +% The main loopstate... +-record(state, { + port = noport, % Port() connected to the port program + timeout = 8000, % Timeout value from inet_db:res_option + requests, % Table of request + req_index, % Table of {{op,proto,rdata},rid} + parent, % The supervisor bridge + pool_size = 4, % Number of C processes in pool. + statistics % Statistics record (records error causes). +}). + +%% The supervisor bridge code +init([]) -> % Called by supervisor_bridge:start_link + Ref = make_ref(), + SaveTE = process_flag(trap_exit,true), + Pid = spawn_link(?MODULE,server_init,[self(),Ref]), + receive + Ref -> + process_flag(trap_exit,SaveTE), + {ok, Pid, Pid}; + {'EXIT', Pid, Message} -> + process_flag(trap_exit,SaveTE), + {error, Message} + after 10000 -> + process_flag(trap_exit,SaveTE), + {error, {timeout, ?MODULE}} + end. + +start_link() -> + supervisor_bridge:start_link({local, ?PROCNAME_SUP}, ?MODULE, []). + +%% Only used in fallback situations, no supervisor, no bridge, serve only until +%% no requests present... +start_raw() -> + spawn(?MODULE,run_once,[]). + +run_once() -> + Port = do_open_port(get_poolsize(), get_extra_args()), + Timeout = ?REQUEST_TIMEOUT, + {Pid, R, Request} = + receive + {{Pid0,R0}, {?OP_GETHOSTBYNAME, Proto0, Name0}} -> + {Pid0, R0, + [<<1:32, ?OP_GETHOSTBYNAME:8, Proto0:8>>,Name0,0]}; + {{Pid1,R1}, {?OP_GETHOSTBYADDR, Proto1, Data1}} -> + {Pid1, R1, + <<1:32, ?OP_GETHOSTBYADDR:8, Proto1:8, Data1/binary>>} + after Timeout -> + exit(normal) + end, + (catch port_command(Port, Request)), + receive + {Port, {data, <<1:32, BinReply/binary>>}} -> + Pid ! {R, {ok, BinReply}} + after Timeout -> + Pid ! {R,{error,timeout}} + end. + +terminate(_Reason,Pid) -> + (catch exit(Pid,kill)), + ok. + +%%----------------------------------------------------------------------- +%% Server API +%%----------------------------------------------------------------------- +server_init(Starter, Ref) -> + process_flag(trap_exit,true), + case whereis(?MODULE) of + undefined -> + case (catch register(?MODULE,self())) of + true -> + Starter ! Ref; + _-> + exit({already_started,whereis(?MODULE)}) + end; + Winner -> + exit({already_started,Winner}) + end, + Poolsize = get_poolsize(), + Port = do_open_port(Poolsize, get_extra_args()), + Timeout = ?REQUEST_TIMEOUT, + put(rid,0), + put(num_requests,0), + RequestTab = ets:new(ign_requests,[{keypos,#request.rid},set,protected]), + RequestIndex = ets:new(ign_req_index,[set,protected]), + State = #state{port = Port, timeout = Timeout, requests = RequestTab, + req_index = RequestIndex, + pool_size = Poolsize, + statistics = #statistics{}, + parent = Starter}, + main_loop(State). + +main_loop(State) -> + receive + Any -> + handle_message(Any,State) + end. + +handle_message({{Pid,_} = Client, {?OP_GETHOSTBYNAME, Proto, Name} = R}, + State) when is_pid(Pid) -> + NewState = do_handle_call(R,Client,State, + [<<?OP_GETHOSTBYNAME:8, Proto:8>>, Name,0]), + main_loop(NewState); + +handle_message({{Pid,_} = Client, {?OP_GETHOSTBYADDR, Proto, Data} = R}, + State) when is_pid(Pid) -> + NewState = do_handle_call(R,Client,State, + <<?OP_GETHOSTBYADDR:8, Proto:8, Data/binary>>), + main_loop(NewState); + +handle_message({{Pid,Ref}, {?OP_CONTROL, Ctl, Data}}, State) + when is_pid(Pid) -> + catch port_command(State#state.port, + <<?INVALID_SERIAL:32, ?OP_CONTROL:8, + Ctl:8, Data/binary>>), + Pid ! {Ref, ok}, + main_loop(State); + +handle_message({{Pid,Ref}, restart_port}, State) + when is_pid(Pid) -> + NewPort=restart_port(State), + Pid ! {Ref, ok}, + main_loop(State#state{port=NewPort}); + +handle_message({Port, {data, Data}}, State = #state{port = Port}) -> + NewState = case Data of + <<RID:32, BinReply/binary>> -> + case BinReply of + <<Unit, _/binary>> when Unit =:= ?UNIT_ERROR; + Unit =:= ?UNIT_IPV4; + Unit =:= ?UNIT_IPV6 -> + case pick_request(State,RID) of + false -> + State; + Req -> + lists:foreach(fun({P,R,TR}) -> + ?CANCEL_TIMER(TR), + P ! {R, + {ok, + BinReply}} + end, + Req#request.clients), + State + end; + _UnitError -> + %% Unexpected data, let's restart it, + %% it must be broken. + NewPort=restart_port(State), + State#state{port=NewPort} + end; + _BasicFormatError -> + NewPort=restart_port(State), + State#state{port=NewPort} + end, + main_loop(NewState); + +handle_message({'EXIT',Port,_Reason}, State = #state{port = Port}) -> + ?dbg("Port died.~n",[]), + NewPort=restart_port(State), + main_loop(State#state{port=NewPort}); + +handle_message({Port,eof}, State = #state{port = Port}) -> + ?dbg("Port eof'ed.~n",[]), + NewPort=restart_port(State), + main_loop(State#state{port=NewPort}); + +handle_message({timeout, Pid, RID}, State) -> + case pick_client(State,RID,Pid) of + false -> + false; + {more, {P,R,_}} -> + P ! {R,{error,timeout}}; + {last, {LP,LR,_}} -> + LP ! {LR, {error,timeout}}, + %% Remove the whole request structure... + pick_request(State, RID), + %% Also cancel the request to the port program... + (catch port_command(State#state.port, + <<RID:32,?OP_CANCEL_REQUEST>>)) + end, + main_loop(State); + +handle_message({system, From, Req}, State) -> + sys:handle_system_msg(Req, From, State#state.parent, ?MODULE, [], + State); + +handle_message(_, State) -> % Stray messages from dying ports etc. + main_loop(State). + + +do_handle_call(R,Client0,State,RData) -> + Req = find_request(State,R), + Timeout = State#state.timeout, + {P,Ref} = Client0, + TR = ?SEND_AFTER(Timeout,self(),{timeout, P, Req#request.rid}), + Client = {P,Ref,TR}, + case Req#request.clients of + [] -> + RealRData = [<<(Req#request.rid):32>>|RData], + (catch port_command(State#state.port, RealRData)), + ets:insert(State#state.requests,Req#request{clients = [Client]}); + Tail -> + ets:insert(State#state.requests,Req#request{clients = [Client | Tail]}) + end, + State. + +find_request(State, R = {Op, Proto, Data}) -> + case ets:lookup(State#state.req_index,R) of + [{R, Rid}] -> + [Ret] = ets:lookup(State#state.requests,Rid), + Ret; + [] -> + NRid = get_rid(), + Req = #request{rid = NRid, op = Op, proto = Proto, rdata = Data}, + ets:insert(State#state.requests, Req), + ets:insert(State#state.req_index,{R,NRid}), + put(num_requests,get(num_requests) + 1), + Req + end. + +pick_request(State, RID) -> + case ets:lookup(State#state.requests, RID) of + [] -> + false; + [#request{rid = RID, op = Op, proto = Proto, rdata = Data}=R] -> + ets:delete(State#state.requests,RID), + ets:delete(State#state.req_index,{Op,Proto,Data}), + put(num_requests,get(num_requests) - 1), + R + end. + +pick_client(State,RID,Clid) -> + case ets:lookup(State#state.requests, RID) of + [] -> + false; + [R] -> + case R#request.clients of + [SoleClient] -> + {last, SoleClient}; % Note, not removed, the caller + % should cleanup request data + CList -> + case lists:keysearch(Clid,1,CList) of + {value, Client} -> + NCList = lists:keydelete(Clid,1,CList), + ets:insert(State#state.requests, + R#request{clients = NCList}), + {more, Client}; + false -> + false + end + end + end. + +get_rid () -> + New = (get(rid) + 1) rem 16#7FFFFFF, + put(rid,New), + New. + + +foreach(Fun,Table) -> + foreach(Fun,Table,ets:first(Table)). + +foreach(_Fun,_Table,'$end_of_table') -> + ok; +foreach(Fun,Table,Key) -> + [Object] = ets:lookup(Table,Key), + Fun(Object), + foreach(Fun,Table,ets:next(Table,Key)). + +restart_port(#state{port = Port, requests = Requests}) -> + (catch port_close(Port)), + NewPort = do_open_port(get_poolsize(), get_extra_args()), + foreach(fun(#request{rid = Rid, op = Op, proto = Proto, rdata = Rdata}) -> + case Op of + ?OP_GETHOSTBYNAME -> + port_command(NewPort,[<<Rid:32,?OP_GETHOSTBYNAME:8, + Proto:8>>, + Rdata,0]); + ?OP_GETHOSTBYADDR -> + port_command(NewPort, + <<Rid:32,?OP_GETHOSTBYADDR:8, Proto:8, + Rdata/binary>>) + end + end, + Requests), + NewPort. + + + +do_open_port(Poolsize, ExtraArgs) -> + try + open_port({spawn, + ?PORT_PROGRAM++" "++integer_to_list(Poolsize)++" "++ + ExtraArgs}, + [{packet,4},eof,binary,overlapped_io]) + catch + error:_ -> + open_port({spawn, + ?PORT_PROGRAM++" "++integer_to_list(Poolsize)++ + " "++ExtraArgs}, + [{packet,4},eof,binary]) + end. + +get_extra_args() -> + FirstPart = case application:get_env(kernel, gethost_prioritize) of + {ok, false} -> + " -ng"; + _ -> + "" + end, + case application:get_env(kernel, gethost_extra_args) of + {ok, L} when is_list(L) -> + FirstPart++" "++L; + _ -> + FirstPart++"" + end. + +get_poolsize() -> + case application:get_env(kernel, gethost_poolsize) of + {ok,I} when is_integer(I) -> + I; + _ -> + ?DEFAULT_POOLSIZE + end. + +%%------------------------------------------------------------------ +%% System messages callbacks +%%------------------------------------------------------------------ + +system_continue(_Parent, _, State) -> + main_loop(State). + +system_terminate(Reason, _Parent, _, _State) -> + exit(Reason). + +system_code_change(State, _Module, _OldVsn, _Extra) -> + {ok, State}. %% Nothing to do in this version. + + +%%----------------------------------------------------------------------- +%% Client API +%%----------------------------------------------------------------------- + +gethostbyname(Name) -> + gethostbyname(Name, inet). + +gethostbyname(Name, inet) when is_list(Name) -> + getit(?OP_GETHOSTBYNAME, ?PROTO_IPV4, Name); +gethostbyname(Name, inet6) when is_list(Name) -> + getit(?OP_GETHOSTBYNAME, ?PROTO_IPV6, Name); +gethostbyname(Name, Type) when is_atom(Name) -> + gethostbyname(atom_to_list(Name), Type); +gethostbyname(_, _) -> + {error, formerr}. + +gethostbyaddr({A,B,C,D}) when ?VALID_V4(A), ?VALID_V4(B), ?VALID_V4(C), ?VALID_V4(D) -> + getit(?OP_GETHOSTBYADDR, ?PROTO_IPV4, <<A,B,C,D>>); +gethostbyaddr({A,B,C,D,E,F,G,H}) when ?VALID_V6(A), ?VALID_V6(B), ?VALID_V6(C), ?VALID_V6(D), + ?VALID_V6(E), ?VALID_V6(F), ?VALID_V6(G), ?VALID_V6(H) -> + getit(?OP_GETHOSTBYADDR, ?PROTO_IPV6, <<A:16,B:16,C:16,D:16,E:16,F:16,G:16,H:16>>); +gethostbyaddr(Addr) when is_list(Addr) -> + case inet_parse:address(Addr) of + {ok, IP} -> gethostbyaddr(IP); + _Error -> {error, formerr} + end; +gethostbyaddr(Addr) when is_atom(Addr) -> + gethostbyaddr(atom_to_list(Addr)); +gethostbyaddr(_) -> {error, formerr}. + +control({debug_level, Level}) when is_integer(Level) -> + getit(?OP_CONTROL, ?SETOPT_DEBUG_LEVEL, <<Level:32>>); +control(soft_restart) -> + getit(restart_port); +control(_) -> {error, formerr}. + +getit(Op, Proto, Data) -> + getit({Op, Proto, Data}). + +getit(Req) -> + Pid = ensure_started(), + Ref = make_ref(), + Pid ! {{self(),Ref}, Req}, + receive + {Ref, {ok,BinHostent}} -> + parse_address(BinHostent); + {Ref, Error} -> + Error + after 5000 -> + Ref2 = erlang:monitor(process,Pid), + Res2 = receive + {Ref, {ok,BinHostent}} -> + parse_address(BinHostent); + {Ref, Error} -> + Error; + {'DOWN', Ref2, process, + Pid, Reason} -> + {error, Reason} + end, + catch erlang:demonitor(Ref2), + receive {'DOWN',Ref2,_,_,_} -> ok after 0 -> ok end, + Res2 + end. + +do_start(Sup, C) -> + {Child,_,_,_,_,_} = C, + case supervisor:start_child(Sup,C) of + {ok,_} -> + ok; + {error, {already_started, Pid}} when is_pid(Pid) -> + ok; + {error, {{already_started, Pid}, _Child}} when is_pid(Pid) -> + ok; + {error, already_present} -> + supervisor:delete_child(Sup, Child), + do_start(Sup, C) + end. + +ensure_started() -> + case whereis(?MODULE) of + undefined -> + C = {?PROCNAME_SUP, {?MODULE, start_link, []}, temporary, + 1000, worker, [?MODULE]}, + case whereis(kernel_safe_sup) of + undefined -> + case whereis(net_sup) of + undefined -> + %% Icky fallback, run once without supervisor + start_raw(); + _ -> + do_start(net_sup,C), + case whereis(?MODULE) of + undefined -> + exit({could_not_start_server, ?MODULE}); + Pid0 -> + Pid0 + end + end; + _ -> + do_start(kernel_safe_sup,C), + case whereis(?MODULE) of + undefined -> + exit({could_not_start_server, ?MODULE}); + Pid1 -> + Pid1 + end + end; + Pid -> + Pid + end. + +parse_address(BinHostent) -> + case catch + begin + case BinHostent of + <<?UNIT_ERROR, Errstring/binary>> -> + {error, list_to_atom(listify(Errstring))}; + <<?UNIT_IPV4, Naddr:32, T0/binary>> -> + {T1,Addresses} = pick_addresses_v4(Naddr, T0), + [Name | Names] = pick_names(T1), + {ok, #hostent{h_addr_list = Addresses, h_addrtype = inet, + h_aliases = Names, h_length = ?UNIT_IPV4, + h_name = Name}}; + <<?UNIT_IPV6, Naddr:32, T0/binary>> -> + {T1,Addresses} = pick_addresses_v6(Naddr, T0), + [Name | Names] = pick_names(T1), + {ok, #hostent{h_addr_list = Addresses, h_addrtype = inet6, + h_aliases = Names, h_length = ?UNIT_IPV6, + h_name = Name}}; + _Else -> + {error, {internal_error, {malformed_response, BinHostent}}} + end + end of + {'EXIT', Reason} -> + Reason; + Normal -> + Normal + end. + +listify(Bin) -> + N = byte_size(Bin) - 1, + <<Bin2:N/binary, Ch>> = Bin, + case Ch of + 0 -> + listify(Bin2); + _ -> + binary_to_list(Bin) + end. + +pick_addresses_v4(0,Tail) -> + {Tail,[]}; +pick_addresses_v4(N,<<A,B,C,D,Tail/binary>>) -> + {NTail, OList} = pick_addresses_v4(N-1,Tail), + {NTail, [{A,B,C,D} | OList]}. + +pick_addresses_v6(0,Tail) -> + {Tail,[]}; +pick_addresses_v6(Num,<<A:16,B:16,C:16,D:16,E:16,F:16,G:16,H:16, + Tail/binary>>) -> + {NTail, OList} = pick_addresses_v6(Num-1,Tail), + {NTail, [{A,B,C,D,E,F,G,H} | OList]}. + +ndx(Ch,Bin) -> + ndx(Ch,0,byte_size(Bin),Bin). + +ndx(_,N,N,_) -> + undefined; +ndx(Ch,I,N,Bin) -> + case Bin of + <<_:I/binary,Ch,_/binary>> -> + I; + _ -> + ndx(Ch,I+1,N,Bin) + end. + +pick_names(<<Length:32,Namelist/binary>>) -> + pick_names(Length,Namelist). + +pick_names(0,<<>>) -> + []; +pick_names(0,_) -> + exit({error,format_error}); +pick_names(_N,<<>>) -> + exit({error,format_error}); +pick_names(N,Bin) -> + Ndx = ndx(0,Bin), + <<Str:Ndx/binary,0,Rest/binary>> = Bin, + [binary_to_list(Str)|pick_names(N-1,Rest)]. + diff --git a/lib/kernel/src/inet_hosts.erl b/lib/kernel/src/inet_hosts.erl new file mode 100644 index 0000000000..df1d4fc0be --- /dev/null +++ b/lib/kernel/src/inet_hosts.erl @@ -0,0 +1,123 @@ +%% +%% %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_hosts). + +%% Implement gethostbyname gethostbyaddr for inet_hosts table + +-export([gethostbyname/1, gethostbyname/2, gethostbyaddr/1]). + +-include("inet.hrl"). +-include("inet_int.hrl"). + +gethostbyname(Name) when is_list(Name) -> + gethostbyname(Name, + case inet_db:res_option(inet6) of + true -> inet6; + false -> inet + end); +gethostbyname(Name) when is_atom(Name) -> + gethostbyname(atom_to_list(Name)); +gethostbyname(_) -> {error, formerr}. + + + +gethostbyname(Name, Type) when is_list(Name), is_atom(Type) -> + case gethostbyname(Name, Type, inet_hosts_byname, inet_hosts_byaddr) of + false -> + case gethostbyname(Name, Type, + inet_hosts_file_byname, + inet_hosts_file_byaddr) of + false -> {error,nxdomain}; + Hostent -> {ok,Hostent} + end; + Hostent -> {ok,Hostent} + end; +gethostbyname(Name, Type) when is_atom(Name), is_atom(Type) -> + gethostbyname(atom_to_list(Name), Type); +gethostbyname(_, _) -> {error, formerr}. + +gethostbyname(Name, Type, Byname, Byaddr) -> + inet_db:res_update_hosts(), + case [I || [I] <- ets:match(Byname, {Name,Type,'$1'})] of + [] -> false; + [IP|_]=IPs -> + %% Use the primary IP address to generate aliases + [Nm|As] = [N || [N] <- ets:match(Byaddr, + {'$1',Type,IP})], + make_hostent(Nm, IPs, As, Type) + end. + + + + +gethostbyaddr({A,B,C,D}=IP) when ?ip(A,B,C,D) -> + gethostbyaddr(IP, inet); +%% ipv4 only ipv6 address +gethostbyaddr({0,0,0,0,0,16#ffff=F,G,H}) when ?ip6(0,0,0,0,0,F,G,H) -> + gethostbyaddr({G bsr 8, G band 255, H bsr 8, H band 255}); +gethostbyaddr({A,B,C,D,E,F,G,H}=IP) when ?ip6(A,B,C,D,E,F,G,H) -> + gethostbyaddr(IP, inet6); +gethostbyaddr(Addr) when is_list(Addr) -> + case inet_parse:address(Addr) of + {ok,IP} -> gethostbyaddr(IP); + _Error -> {error, formerr} + end; +gethostbyaddr(Addr) when is_atom(Addr) -> + gethostbyaddr(atom_to_list(Addr)); +gethostbyaddr(_) -> {error, formerr}. + + + +gethostbyaddr(IP, Type) -> + case gethostbyaddr(IP, Type, inet_hosts_byaddr) of + false -> + case gethostbyaddr(IP, Type, inet_hosts_file_byaddr) of + false -> {error,nxdomain}; + Hostent -> {ok,Hostent} + end; + Hostent -> {ok,Hostent} + end. + +gethostbyaddr(IP, Type, Byaddr) -> + inet_db:res_update_hosts(), + case [N || [N] <- ets:match(Byaddr, {'$1',Type,IP})] of + [] -> false; + [Nm|As] -> make_hostent(Nm, [IP], As, Type) + end. + + + +make_hostent(Name, Addrs, Aliases, inet) -> + #hostent { + h_name = Name, + h_addrtype = inet, + h_length = 4, + h_addr_list = Addrs, + h_aliases = Aliases + }; +make_hostent(Name, Addrs, Aliases, inet6) -> + #hostent { + h_name = Name, + h_addrtype = inet6, + h_length = 16, + h_addr_list = Addrs, + h_aliases = Aliases + }. + + diff --git a/lib/kernel/src/inet_int.hrl b/lib/kernel/src/inet_int.hrl new file mode 100644 index 0000000000..cf357b7fba --- /dev/null +++ b/lib/kernel/src/inet_int.hrl @@ -0,0 +1,414 @@ +%% +%% %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% +%% + +%%---------------------------------------------------------------------------- +%% Interface constants. +%% +%% This section must be "identical" to the corresponding in inet_drv.c +%% + +%% family codes to open +-define(INET_AF_INET, 1). +-define(INET_AF_INET6, 2). +-define(INET_AF_ANY, 3). % Fake for ANY in any address family +-define(INET_AF_LOOPBACK, 4). % Fake for LOOPBACK in any address family + +%% type codes (gettype, INET_REQ_GETTYPE) +-define(INET_TYPE_STREAM, 1). +-define(INET_TYPE_DGRAM, 2). +-define(INET_TYPE_SEQPACKET, 3). + +%% socket modes, INET_LOPT_MODE +-define(INET_MODE_LIST, 0). +-define(INET_MODE_BINARY, 1). + +%% deliver mode, INET_LOPT_DELIVER +-define(INET_DELIVER_PORT, 0). +-define(INET_DELIVER_TERM, 1). + +%% active socket, INET_LOPT_ACTIVE +-define(INET_PASSIVE, 0). +-define(INET_ACTIVE, 1). +-define(INET_ONCE, 2). % Active once then passive + +%% state codes (getstatus, INET_REQ_GETSTATUS) +-define(INET_F_OPEN, 16#0001). +-define(INET_F_BOUND, 16#0002). +-define(INET_F_ACTIVE, 16#0004). +-define(INET_F_LISTEN, 16#0008). +-define(INET_F_CON, 16#0010). +-define(INET_F_ACC, 16#0020). +-define(INET_F_LST, 16#0040). +-define(INET_F_BUSY, 16#0080). + +%% request codes (erlang:port_control/3) +-define(INET_REQ_OPEN, 1). +-define(INET_REQ_CLOSE, 2). +-define(INET_REQ_CONNECT, 3). +-define(INET_REQ_PEER, 4). +-define(INET_REQ_NAME, 5). +-define(INET_REQ_BIND, 6). +-define(INET_REQ_SETOPTS, 7). +-define(INET_REQ_GETOPTS, 8). +-define(INET_REQ_GETIX, 9). +%% -define(INET_REQ_GETIF, 10). OBSOLETE +-define(INET_REQ_GETSTAT, 11). +-define(INET_REQ_GETHOSTNAME, 12). +-define(INET_REQ_FDOPEN, 13). +-define(INET_REQ_GETFD, 14). +-define(INET_REQ_GETTYPE, 15). +-define(INET_REQ_GETSTATUS, 16). +-define(INET_REQ_GETSERVBYNAME, 17). +-define(INET_REQ_GETSERVBYPORT, 18). +-define(INET_REQ_SETNAME, 19). +-define(INET_REQ_SETPEER, 20). +-define(INET_REQ_GETIFLIST, 21). +-define(INET_REQ_IFGET, 22). +-define(INET_REQ_IFSET, 23). +-define(INET_REQ_SUBSCRIBE, 24). +%% TCP requests +-define(TCP_REQ_ACCEPT, 40). +-define(TCP_REQ_LISTEN, 41). +-define(TCP_REQ_RECV, 42). +-define(TCP_REQ_UNRECV, 43). +-define(TCP_REQ_SHUTDOWN, 44). +%% UDP and SCTP requests +-define(PACKET_REQ_RECV, 60). +-define(SCTP_REQ_LISTEN, 61). +-define(SCTP_REQ_BINDX, 62). %% Multi-home SCTP bind + +%% subscribe codes, INET_REQ_SUBSCRIBE +-define(INET_SUBS_EMPTY_OUT_Q, 1). + +%% reply codes for *_REQ_* +-define(INET_REP_ERROR, 0). +-define(INET_REP_OK, 1). +-define(INET_REP_SCTP, 2). + +%% INET, TCP and UDP options: +-define(INET_OPT_REUSEADDR, 0). +-define(INET_OPT_KEEPALIVE, 1). +-define(INET_OPT_DONTROUTE, 2). +-define(INET_OPT_LINGER, 3). +-define(INET_OPT_BROADCAST, 4). +-define(INET_OPT_OOBINLINE, 5). +-define(INET_OPT_SNDBUF, 6). +-define(INET_OPT_RCVBUF, 7). +-define(INET_OPT_PRIORITY, 8). +-define(INET_OPT_TOS, 9). +-define(TCP_OPT_NODELAY, 10). +-define(UDP_OPT_MULTICAST_IF, 11). +-define(UDP_OPT_MULTICAST_TTL, 12). +-define(UDP_OPT_MULTICAST_LOOP, 13). +-define(UDP_OPT_ADD_MEMBERSHIP, 14). +-define(UDP_OPT_DROP_MEMBERSHIP, 15). +% "Local" options: codes start from 20: +-define(INET_LOPT_BUFFER, 20). +-define(INET_LOPT_HEADER, 21). +-define(INET_LOPT_ACTIVE, 22). +-define(INET_LOPT_PACKET, 23). +-define(INET_LOPT_MODE, 24). +-define(INET_LOPT_DELIVER, 25). +-define(INET_LOPT_EXITONCLOSE, 26). +-define(INET_LOPT_TCP_HIWTRMRK, 27). +-define(INET_LOPT_TCP_LOWTRMRK, 28). +-define(INET_LOPT_BIT8, 29). +-define(INET_LOPT_TCP_SEND_TIMEOUT, 30). +-define(INET_LOPT_TCP_DELAY_SEND, 31). +-define(INET_LOPT_PACKET_SIZE, 32). +-define(INET_LOPT_READ_PACKETS, 33). +-define(INET_OPT_RAW, 34). +-define(INET_LOPT_TCP_SEND_TIMEOUT_CLOSE, 35). +% Specific SCTP options: separate range: +-define(SCTP_OPT_RTOINFO, 100). +-define(SCTP_OPT_ASSOCINFO, 101). +-define(SCTP_OPT_INITMSG, 102). +-define(SCTP_OPT_AUTOCLOSE, 103). +-define(SCTP_OPT_NODELAY, 104). +-define(SCTP_OPT_DISABLE_FRAGMENTS, 105). +-define(SCTP_OPT_I_WANT_MAPPED_V4_ADDR, 106). +-define(SCTP_OPT_MAXSEG, 107). +-define(SCTP_OPT_SET_PEER_PRIMARY_ADDR, 108). +-define(SCTP_OPT_PRIMARY_ADDR, 109). +-define(SCTP_OPT_ADAPTATION_LAYER, 110). +-define(SCTP_OPT_PEER_ADDR_PARAMS, 111). +-define(SCTP_OPT_DEFAULT_SEND_PARAM, 112). +-define(SCTP_OPT_EVENTS, 113). +-define(SCTP_OPT_DELAYED_ACK_TIME, 114). +-define(SCTP_OPT_STATUS, 115). +-define(SCTP_OPT_GET_PEER_ADDR_INFO, 116). + +%% interface options, INET_REQ_IFGET and INET_REQ_IFSET +-define(INET_IFOPT_ADDR, 1). +-define(INET_IFOPT_BROADADDR, 2). +-define(INET_IFOPT_DSTADDR, 3). +-define(INET_IFOPT_MTU, 4). +-define(INET_IFOPT_NETMASK, 5). +-define(INET_IFOPT_FLAGS, 6). +-define(INET_IFOPT_HWADDR, 7). %% where support (e.g linux) + +%% packet byte values, INET_LOPT_PACKET +-define(TCP_PB_RAW, 0). +-define(TCP_PB_1, 1). +-define(TCP_PB_2, 2). +-define(TCP_PB_4, 3). +-define(TCP_PB_ASN1, 4). +-define(TCP_PB_RM, 5). +-define(TCP_PB_CDR, 6). +-define(TCP_PB_FCGI, 7). +-define(TCP_PB_LINE_LF, 8). +-define(TCP_PB_TPKT, 9). +-define(TCP_PB_HTTP, 10). +-define(TCP_PB_HTTPH, 11). +-define(TCP_PB_SSL_TLS, 12). +-define(TCP_PB_HTTP_BIN,13). +-define(TCP_PB_HTTPH_BIN,14). + +%% bit options, INET_LOPT_BIT8 +-define(INET_BIT8_CLEAR, 0). +-define(INET_BIT8_SET, 1). +-define(INET_BIT8_ON, 2). +-define(INET_BIT8_OFF, 3). + + +%% getstat, INET_REQ_GETSTAT +-define(INET_STAT_RECV_CNT, 1). +-define(INET_STAT_RECV_MAX, 2). +-define(INET_STAT_RECV_AVG, 3). +-define(INET_STAT_RECV_DVI, 4). +-define(INET_STAT_SEND_CNT, 5). +-define(INET_STAT_SEND_MAX, 6). +-define(INET_STAT_SEND_AVG, 7). +-define(INET_STAT_SEND_PEND, 8). +-define(INET_STAT_RECV_OCT, 9). +-define(INET_STAT_SEND_OCT, 10). + +%% interface stuff, INET_IFOPT_FLAGS +-define(INET_IFNAMSIZ, 16). +-define(INET_IFF_UP, 16#0001). +-define(INET_IFF_BROADCAST, 16#0002). +-define(INET_IFF_LOOPBACK, 16#0004). +-define(INET_IFF_POINTTOPOINT, 16#0008). +-define(INET_IFF_RUNNING, 16#0010). +-define(INET_IFF_MULTICAST, 16#0020). +%% +-define(INET_IFF_DOWN, 16#0100). +-define(INET_IFF_NBROADCAST, 16#0200). +-define(INET_IFF_NPOINTTOPOINT, 16#0800). + +%% SCTP Flags for "sctp_sndrcvinfo": +%% INET_REQ_SETOPTS:SCTP_OPT_DEFAULT_SEND_PARAM +-define(SCTP_FLAG_UNORDERED, 1). % sctp_unordered +-define(SCTP_FLAG_ADDR_OVER, 2). % sctp_addr_over +-define(SCTP_FLAG_ABORT, 4). % sctp_abort +-define(SCTP_FLAG_EOF, 8). % sctp_eof +-define(SCTP_FLAG_SNDALL, 16). % sctp_sndall, NOT YET IMPLEMENTED. + +%% SCTP Flags for "sctp_paddrparams", and the corresp Atoms: +-define(SCTP_FLAG_HB_ENABLE, 1). % sctp_hb_enable +-define(SCTP_FLAG_HB_DISABLE, 2). % sctp_hb_disable +-define(SCTP_FLAG_HB_DEMAND, 4). % sctp_hb_demand +-define(SCTP_FLAG_PMTUD_ENABLE, 8). % sctp_pmtud_enable +-define(SCTP_FLAG_PMTUD_DISABLE, 16). % sctp_pmtud_disable +-define(SCTP_FLAG_SACKDELAY_ENABLE, 32). % sctp_sackdelay_enable +-define(SCTP_FLAG_SACKDELAY_DISABLE, 64). % sctp_sackdelay_disable + +%% +%% End of interface constants. +%%---------------------------------------------------------------------------- + +-define(LISTEN_BACKLOG, 5). %% default backlog + +%% 5 secs need more ??? +-define(INET_CLOSE_TIMEOUT, 5000). + +%% +%% Port/socket numbers: network standard functions +%% +-define(IPPORT_ECHO, 7). +-define(IPPORT_DISCARD, 9). +-define(IPPORT_SYSTAT, 11). +-define(IPPORT_DAYTIME, 13). +-define(IPPORT_NETSTAT, 15). +-define(IPPORT_FTP, 21). +-define(IPPORT_TELNET, 23). +-define(IPPORT_SMTP, 25). +-define(IPPORT_TIMESERVER, 37). +-define(IPPORT_NAMESERVER, 42). +-define(IPPORT_WHOIS, 43). +-define(IPPORT_MTP, 57). + +%% +%% Port/socket numbers: host specific functions +%% +-define(IPPORT_TFTP, 69). +-define(IPPORT_RJE, 77). +-define(IPPORT_FINGER, 79). +-define(IPPORT_TTYLINK, 87). +-define(IPPORT_SUPDUP, 95). + +%% +%% UNIX TCP sockets +%% +-define(IPPORT_EXECSERVER, 512). +-define(IPPORT_LOGINSERVER, 513). +-define(IPPORT_CMDSERVER, 514). +-define(IPPORT_EFSSERVER, 520). + +%% +%% UNIX UDP sockets +%% +-define(IPPORT_BIFFUDP, 512). +-define(IPPORT_WHOSERVER, 513). +-define(IPPORT_ROUTESERVER, 520). %% 520+1 also used + + +%% +%% Ports < IPPORT_RESERVED are reserved for +%% privileged processes (e.g. root). +%% Ports > IPPORT_USERRESERVED are reserved +%% for servers, not necessarily privileged. +%% +-define(IPPORT_RESERVED, 1024). +-define(IPPORT_USERRESERVED, 5000). + +%% standard port for socks +-define(IPPORT_SOCKS, 1080). + +%% +%% Int to bytes +%% +-define(int8(X), [(X) band 16#ff]). + +-define(int16(X), [((X) bsr 8) band 16#ff, (X) band 16#ff]). + +-define(int24(X), [((X) bsr 16) band 16#ff, + ((X) bsr 8) band 16#ff, (X) band 16#ff]). + +-define(int32(X), + [((X) bsr 24) band 16#ff, ((X) bsr 16) band 16#ff, + ((X) bsr 8) band 16#ff, (X) band 16#ff]). + +-define(intAID(X), % For SCTP AssocID + ?int32(X)). + +%% Bytes to unsigned +-define(u64(X7,X6,X5,X4,X3,X2,X1,X0), + ( ((X7) bsl 56) bor ((X6) bsl 48) bor ((X5) bsl 40) bor + ((X4) bsl 32) bor ((X3) bsl 24) bor ((X2) bsl 16) bor + ((X1) bsl 8) bor (X0) )). + +-define(u32(X3,X2,X1,X0), + (((X3) bsl 24) bor ((X2) bsl 16) bor ((X1) bsl 8) bor (X0))). + +-define(u24(X2,X1,X0), + (((X2) bsl 16) bor ((X1) bsl 8) bor (X0))). + +-define(u16(X1,X0), + (((X1) bsl 8) bor (X0))). + +-define(u8(X0), (X0)). + +%% Bytes to signed +-define(i32(X3,X2,X1,X0), + (?u32(X3,X2,X1,X0) - + (if (X3) > 127 -> 16#100000000; true -> 0 end))). + +-define(i24(X2,X1,X0), + (?u24(X2,X1,X0) - + (if (X2) > 127 -> 16#1000000; true -> 0 end))). + +-define(i16(X1,X0), + (?u16(X1,X0) - + (if (X1) > 127 -> 16#10000; true -> 0 end))). + +-define(i8(X0), + (?u8(X0) - + (if (X0) > 127 -> 16#100; true -> 0 end))). + +%% macro for use in guard for checking ip address {A,B,C,D} +-define(ip(A,B,C,D), + (((A) bor (B) bor (C) bor (D)) band (bnot 16#ff)) =:= 0). + +-define(ip6(A,B,C,D,E,F,G,H), + (((A) bor (B) bor (C) bor (D) bor (E) bor (F) bor (G) bor (H)) + band (bnot 16#ffff)) =:= 0). + +-define(ether(A,B,C,D,E,F), + (((A) bor (B) bor (C) bor (D) bor (E) bor (F)) + band (bnot 16#ff)) =:= 0). + +-define(port(P), (((P) band bnot 16#ffff) =:= 0)). + +%% default options (when inet_drv port is started) +%% +%% bufsz = INET_MIN_BUFFER (8K) +%% header = 0 +%% packet = 0 (raw) +%% mode = list +%% deliver = term +%% active = false +%% +-record(connect_opts, + { + ifaddr = any, %% bind to interface address + port = 0, %% bind to port (default is dynamic port) + fd = -1, %% fd >= 0 => already bound + opts = [] %% [{active,true}] added in inet:connect_options + }). + +-record(listen_opts, + { + ifaddr = any, %% bind to interface address + port = 0, %% bind to port (default is dynamic port) + backlog = ?LISTEN_BACKLOG, %% backlog + fd = -1, %% %% fd >= 0 => already bound + opts = [] %% [{active,true}] added in + %% inet:listen_options + }). + +-record(udp_opts, + { + ifaddr = any, + port = 0, + fd = -1, + opts = [{active,true}] + }). + +-define(SCTP_DEF_BUFSZ, 65536). +-define(SCTP_DEF_IFADDR, any). +-record(sctp_opts, + { + ifaddr, + port = 0, + fd = -1, + opts = [{mode, binary}, + {buffer, ?SCTP_DEF_BUFSZ}, + {sndbuf, ?SCTP_DEF_BUFSZ}, + {recbuf, 1024}, + {sctp_events, undefined}%, + %%{active, true} + ] + }). + +%% The following Tags are purely internal, used for marking items in the +%% send buffer: +-define(SCTP_TAG_SEND_ANC_INITMSG, 0). +-define(SCTP_TAG_SEND_ANC_PARAMS, 1). +-define(SCTP_TAG_SEND_DATA, 2). diff --git a/lib/kernel/src/inet_parse.erl b/lib/kernel/src/inet_parse.erl new file mode 100644 index 0000000000..62d44fb723 --- /dev/null +++ b/lib/kernel/src/inet_parse.erl @@ -0,0 +1,755 @@ +%% +%% %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_parse). + +%% Parser for all kinds of ineternet configuration files + +-export([hosts/1, hosts/2]). +-export([hosts_vxworks/1]). +-export([protocols/1, protocols/2]). +-export([netmasks/1, netmasks/2]). +-export([networks/1, networks/2]). +-export([services/1, services/2]). +-export([rpc/1, rpc/2]). +-export([resolv/1, resolv/2]). +-export([host_conf_linux/1, host_conf_linux/2]). +-export([host_conf_freebsd/1, host_conf_freebsd/2]). +-export([host_conf_bsdos/1, host_conf_bsdos/2]). +-export([nsswitch_conf/1, nsswitch_conf/2]). + +-export([ipv4_address/1, ipv6_address/1]). +-export([address/1]). +-export([visible_string/1, domain/1]). +-export([ntoa/1, dots/1]). +-export([split_line/1]). + +-import(lists, [reverse/1]). + +-include_lib("kernel/include/file.hrl"). + +%% -------------------------------------------------------------------------- +%% Parse services internet style +%% Syntax: +%% Name Port/Protocol [Aliases] \n +%% # comment +%% -------------------------------------------------------------------------- + +services(File) -> + services(noname, File). + +services(Fname, File) -> + Fn = fun([Name, PortProto | Aliases]) -> + {Proto,Port} = port_proto(PortProto, 0), + {Name,Proto,Port,Aliases} + end, + parse_file(Fname, File, Fn). + +%% -------------------------------------------------------------------------- +%% Parse rpc program names +%% Syntax: +%% Name Program [Aliases] \n | +%% # comment +%% -------------------------------------------------------------------------- + +rpc(File) -> + rpc(noname, File). + +rpc(Fname, File) -> + Fn = fun([Name,Program | Aliases]) -> + Prog = list_to_integer(Program), + {Name,Prog,Aliases} + end, + parse_file(Fname, File, Fn). + +%% -------------------------------------------------------------------------- +%% Parse hosts file unix style +%% Syntax: +%% IP Name [Aliases] \n | +%% # comment +%% -------------------------------------------------------------------------- +hosts(File) -> + hosts(noname,File). + +hosts(Fname,File) -> + Fn = fun([Address, Name | Aliases]) -> + %% XXX Fix for link-local IPv6 addresses that specify + %% interface with a %if suffix. These kind of + %% addresses maybe need to be gracefully handled + %% throughout inet* and inet_drv. + case string:tokens(Address, "%") of + [Addr,_] -> + {ok,_} = address(Addr), + skip; + _ -> + {ok,IP} = address(Address), + {IP, Name, Aliases} + end + end, + parse_file(Fname, File, Fn). + +%% -------------------------------------------------------------------------- +%% Parse hostShow vxworks style +%% Syntax: +%% Name IP [Aliases] \n +%% -------------------------------------------------------------------------- +hosts_vxworks(Hosts) -> + Fn = fun([Name, Address | Aliases]) -> + {ok,IP} = address(Address), + {IP, Name, Aliases} + end, + parse_file(Hosts, Fn). + +%% -------------------------------------------------------------------------- +%% Parse resolv file unix style +%% Syntax: +%% domain Domain \n +%% nameserver IP \n +%% search Dom1 Dom2 ... \n +%% lookup Method1 Method2 Method3 \n +%% # comment +%% -------------------------------------------------------------------------- + +resolv(File) -> + resolv(noname,File). + +resolv(Fname, File) -> + Fn = fun(["domain", Domain]) -> + {domain, Domain}; + (["nameserver", Address]) -> + {ok,IP} = address(Address), + {nameserver,IP}; + (["search" | List]) -> + {search, List}; + (["lookup" | Types]) -> + {lookup, Types}; + (_) -> + skip %% there are too many local options, we MUST skip + end, + parse_file(Fname, File, Fn). + +%% -------------------------------------------------------------------------- +%% +%% Parse Linux host.conf file +%% find "order" only. +%% +%% -------------------------------------------------------------------------- +host_conf_linux(File) -> + host_conf_linux(noname,File). + +host_conf_linux(Fname, File) -> + Fn = fun(["order" | Order]) -> + %% XXX remove ',' between entries + {lookup, split_comma(Order)}; + (_) -> + skip + end, + parse_file(Fname, File, Fn). + +%% -------------------------------------------------------------------------- +%% +%% Parse Freebsd/Netbsd host.conf file +%% find "order" only. +%% +%% -------------------------------------------------------------------------- +host_conf_freebsd(File) -> + host_conf_freebsd(noname,File). + +host_conf_freebsd(Fname, File) -> + Fn = fun([Type]) -> Type end, + case parse_file(Fname, File, Fn) of + {ok, Ls} -> {ok, [{lookup, Ls}]}; + Error -> Error + end. + + + +%% -------------------------------------------------------------------------- +%% +%% Parse BSD/OS irs.conf file +%% find "hosts" only and ignore options. +%% +%% Syntax: +%% Map AccessMethod [,AccessMethod] [continue|merge [,merge|,continue]] \n +%% # comment + +%% -------------------------------------------------------------------------- +host_conf_bsdos(File) -> + host_conf_bsdos(noname,File). + +host_conf_bsdos(Fname, File) -> + Fn = fun(["hosts" | List]) -> + delete_options(split_comma(List)); + (_) -> + skip + end, + case parse_file(Fname, File, Fn) of + {ok, Ls} -> + {ok, [{lookup, lists:append(Ls)}]}; + Error -> Error + end. + +delete_options(["continue"|T]) -> + delete_options(T); +delete_options(["merge"|T]) -> + delete_options(T); +delete_options([H|T]) -> + [H|delete_options(T)]; +delete_options([]) -> + []. + + +%% -------------------------------------------------------------------------- +%% +%% Parse Solaris nsswitch.conf +%% find "hosts:" only +%% +%% -------------------------------------------------------------------------- + +nsswitch_conf(File) -> + nsswitch_conf(noname,File). + +nsswitch_conf(Fname, File) -> + Fn = fun(["hosts:" | Types]) -> + {lookup, Types}; + (_) -> skip + end, + parse_file(Fname, File, Fn). + +%% -------------------------------------------------------------------------- +%% Parse protocol file unix style +%% Syntax: +%% name protocol number name \n +%% # comment +%% -------------------------------------------------------------------------- + +protocols(File) -> + protocols(noname,File). + +protocols(Fname, File) -> + Fn = fun([Name, Number, DName]) -> + {list_to_atom(Name), list_to_integer(Number), DName} + end, + parse_file(Fname, File, Fn). + +%% -------------------------------------------------------------------------- +%% Parse netmasks file unix style +%% Syntax: +%% Network Subnetmask +%% # comment +%% -------------------------------------------------------------------------- + +netmasks(File) -> + netmasks(noname, File). + +netmasks(Fname, File) -> + Fn = fun([Net, Subnetmask]) -> + {ok, NetIP} = address(Net), + {ok, Mask} = address(Subnetmask), + {NetIP, Mask} + end, + parse_file(Fname, File, Fn). + +%% -------------------------------------------------------------------------- +%% Parse networks file unix style +%% Syntax: +%% network-name network-number aliases ... +%% # comment +%% -------------------------------------------------------------------------- + +networks(File) -> + networks(noname, File). + +networks(Fname, File) -> + Fn = fun([NetName, NetNumber]) -> + Number = list_to_integer(NetNumber), + {NetName, Number} + end, + parse_file(Fname, File, Fn). + +%% -------------------------------------------------------------------------- +%% +%% Simple Line by Line parser +%% +%% -------------------------------------------------------------------------- + +parse_file(File, Fn) -> + parse_file(noname, File, Fn). + +parse_file(Fname, {fd,Fd}, Fn) -> + parse_fd(Fname,Fd, 1, Fn, []); +parse_file(Fname, {chars,Cs}, Fn) when is_list(Cs) -> + parse_cs(Fname, Cs, 1, Fn, []); +parse_file(Fname, {chars,Cs}, Fn) when is_binary(Cs) -> + parse_cs(Fname, binary_to_list(Cs), 1, Fn, []); +parse_file(_, File, Fn) -> + case file:open(File, [read]) of + {ok, Fd} -> + Result = parse_fd(File,Fd, 1, Fn, []), + file:close(Fd), + Result; + Error -> Error + end. + +parse_fd(Fname,Fd, Line, Fun, Ls) -> + case read_line(Fd) of + eof -> {ok, reverse(Ls)}; + Cs -> + case split_line(Cs) of + [] -> parse_fd(Fname, Fd, Line+1, Fun, Ls); + Toks -> + case catch Fun(Toks) of + {'EXIT',_} -> + error("~p:~p: erroneous line, SKIPPED~n",[Fname,Line]), + parse_fd(Fname, Fd,Line+1,Fun,Ls); + {warning,Wlist,Val} -> + warning("~p:~p: warning! strange domain name(s) ~p ~n",[Fname,Line,Wlist]), + parse_fd(Fname, Fd,Line+1,Fun,[Val|Ls]); + + skip -> + parse_fd(Fname, Fd, Line+1, Fun, Ls); + Val -> parse_fd(Fname, Fd, Line+1, Fun, [Val|Ls]) + end + end + end. + +parse_cs(Fname, Chars, Line, Fun, Ls) -> + case get_line(Chars) of + eof -> {ok, reverse(Ls)}; + {Cs,Chars1} -> + case split_line(Cs) of + [] -> parse_cs(Fname, Chars1, Line+1, Fun, Ls); + Toks -> + case catch Fun(Toks) of + {'EXIT',_} -> + error("~p:~p: erroneous line, SKIPPED~n",[Fname,Line]), + parse_cs(Fname, Chars1, Line+1, Fun, Ls); + {warning,Wlist,Val} -> + warning("~p:~p: warning! strange domain name(s) ~p ~n",[Fname,Line,Wlist]), + parse_cs(Fname, Chars1, Line+1, Fun, [Val|Ls]); + + skip -> parse_cs(Fname, Chars1, Line+1, Fun, Ls); + Val -> parse_cs(Fname, Chars1, Line+1, Fun, [Val|Ls]) + end + end + end. + +get_line([]) -> eof; +get_line(Chars) -> get_line(Chars,[]). + +get_line([], Acc) -> {reverse(Acc), []}; +get_line([$\r, $\n | Cs], Acc) -> {reverse([$\n|Acc]), Cs}; +get_line([$\n | Cs], Acc) -> {reverse([$\n|Acc]), Cs}; +get_line([C | Cs], Acc) -> get_line(Cs, [C|Acc]). + +%% +%% Read a line +%% +read_line(Fd) when is_pid(Fd) -> io:get_line(Fd, ''); +read_line(Fd = #file_descriptor{}) -> + collect_line(Fd, []). + +collect_line(Fd, Cs) -> + case file:read(Fd, 80) of + {ok, Line} when is_binary(Line) -> + collect_line(Fd, byte_size(Line), binary_to_list(Line), Cs); + {ok, Line} -> + collect_line(Fd, length(Line), Line, Cs); + eof when Cs =:= [] -> + eof; + eof -> reverse(Cs) + end. + +collect_line(Fd, N, [$\r, $\n|_], Cs) -> + {ok, _} = file:position(Fd, {cur,-(N-2)}), + reverse([$\n|Cs]); +collect_line(Fd, N, [$\n|_], Cs) -> + {ok, _} = file:position(Fd, {cur,-(N-1)}), + reverse([$\n|Cs]); +collect_line(Fd, _, [], Cs) -> + collect_line(Fd, Cs); +collect_line(Fd, N, [X|Xs], Cs) -> + collect_line(Fd, N-1, Xs, [X|Cs]). + + +%% split Port/Proto -> {Port, Proto} +port_proto([X|Xs], N) when X >= $0, X =< $9 -> + port_proto(Xs, N*10 + (X - $0)); +port_proto([$/ | Proto], Port) when Port =/= 0 -> + {list_to_atom(Proto), Port}. + +%% +%% Check if a String is a string with visible characters #21..#7E +%% visible_string(String) -> Bool +%% +visible_string([H|T]) -> + is_vis1([H|T]); +visible_string(_) -> + false. + +is_vis1([C | Cs]) when C >= 16#21, C =< 16#7e -> is_vis1(Cs); +is_vis1([]) -> true; +is_vis1(_) -> false. + +%% +%% Check if a String is a domain name according to RFC XXX. +%% domain(String) -> Bool +%% +domain([H|T]) -> + is_dom1([H|T]); +domain(_) -> + false. + +is_dom1([C | Cs]) when C >= $a, C =< $z -> is_dom_ldh(Cs); +is_dom1([C | Cs]) when C >= $A, C =< $Z -> is_dom_ldh(Cs); +is_dom1([C | Cs]) when C >= $0, C =< $9 -> + case is_dom_ldh(Cs) of + true -> is_dom2(string:tokens([C | Cs],".")); + false -> false + end; +is_dom1(_) -> false. + +is_dom_ldh([C | Cs]) when C >= $a, C =< $z -> is_dom_ldh(Cs); +is_dom_ldh([C | Cs]) when C >= $A, C =< $Z -> is_dom_ldh(Cs); +is_dom_ldh([C | Cs]) when C >= $0, C =< $9 -> is_dom_ldh(Cs); +is_dom_ldh([$-,$. | _]) -> false; +is_dom_ldh([$_,$. | _]) -> false; +is_dom_ldh([$_ | Cs]) -> is_dom_ldh(Cs); +is_dom_ldh([$- | Cs]) -> is_dom_ldh(Cs); +is_dom_ldh([$. | Cs]) -> is_dom1(Cs); +is_dom_ldh([]) -> true; +is_dom_ldh(_) -> false. + +%%% Check that we don't get a IP-address as a domain name. + +-define(L2I(L), (catch list_to_integer(L))). + +is_dom2([A,B,C,D]) -> + case ?L2I(D) of + Di when is_integer(Di) -> + case {?L2I(A),?L2I(B),?L2I(C)} of + {Ai,Bi,Ci} when is_integer(Ai), + is_integer(Bi), + is_integer(Ci) -> false; + _ -> true + end; + _ -> true + end; +is_dom2(_) -> + true. + + + +%% +%% Test ipv4 address or ipv6 address +%% Return {ok, Address} | {error, Reason} +%% +address(Cs) when is_list(Cs) -> + case ipv4_address(Cs) of + {ok,IP} -> {ok,IP}; + _ -> + case ipv6_address(Cs) of + {ok, IP} -> {ok, IP}; + Error -> Error + end + end; +address(_) -> + {error, einval}. + +%% +%% Parse IPv4 address: +%% d1.d2.d3.d4 +%% d1.d2.d4 +%% d1.d4 +%% d4 +%% +%% Return {ok, IP} | {error, einval} +%% +ipv4_address(Cs) -> + case catch ipv4_addr(Cs) of + {'EXIT',_} -> {error,einval}; + Addr -> {ok,Addr} + end. + +ipv4_addr(Cs) -> + ipv4_addr(d3(Cs), []). + +ipv4_addr({Cs0,[]}, A) when length(A) =< 3 -> + case [tod(Cs0)|A] of + [D4,D3,D2,D1] -> + {D1,D2,D3,D4}; + [D4,D2,D1] -> + {D1,D2,0,D4}; + [D4,D1] -> + {D1,0,0,D4}; + [D4] -> + {0,0,0,D4} + end; +ipv4_addr({Cs0,"."++Cs1}, A) when length(A) =< 2 -> + ipv4_addr(d3(Cs1), [tod(Cs0)|A]). + +d3(Cs) -> d3(Cs, []). + +d3([C|Cs], R) when C >= $0, C =< $9, length(R) =< 2 -> + d3(Cs, [C|R]); +d3(Cs, [_|_]=R) -> + {lists:reverse(R),Cs}. + +tod(Cs) -> + case erlang:list_to_integer(Cs) of + D when D >= 0, D =< 255 -> + D; + _ -> + erlang:error(badarg, [Cs]) + end. + +%% +%% Parse IPv6 address: +%% x1:x2:x3:x4:x5:x6:x7:x8 +%% x1:x2::x7:x8 +%% ::x7:x8 +%% x1:x2:: +%% :: +%% x1:x2:x3:x4:x5:x6:d7a.d7b.d8a.d8b +%% x1:x2::x5:x6:d7a.d7b.d8a.d8b +%% ::x5:x6:d7a.d7b.d8a.d8b +%% x1:x2::d7a.d7b.d8a.d8b +%% ::d7a.d7b.d8a.d8b +%% +%% Return {ok, IP} | {error, einval} +%% +ipv6_address(Cs) -> + case catch ipv6_addr(Cs) of + {'EXIT',_} -> {error,einval}; + Addr -> {ok,Addr} + end. + +ipv6_addr("::") -> + ipv6_addr_done([], []); +ipv6_addr("::"++Cs) -> + ipv6_addr(x4(Cs), [], []); +ipv6_addr(Cs) -> + ipv6_addr(x4(Cs), []). + +%% Before "::" +ipv6_addr({Cs0,[]}, A) when length(A) =:= 7 -> + ipv6_addr_done([tox(Cs0)|A]); +ipv6_addr({Cs0,"::"}, A) when length(A) =< 6 -> + ipv6_addr_done([tox(Cs0)|A], []); +ipv6_addr({Cs0,"::"++Cs1}, A) when length(A) =< 5 -> + ipv6_addr(x4(Cs1), [tox(Cs0)|A], []); +ipv6_addr({Cs0,":"++Cs1}, A) when length(A) =< 6 -> + ipv6_addr(x4(Cs1), [tox(Cs0)|A]); +ipv6_addr({Cs0,"."++Cs1}, A) when length(A) =:= 6 -> + ipv6_addr(d3(Cs1), A, [], [tod(Cs0)]). + +%% After "::" +ipv6_addr({Cs0,[]}, A, B) when length(A)+length(B) =< 6 -> + ipv6_addr_done(A, [tox(Cs0)|B]); +ipv6_addr({Cs0,":"++Cs1}, A, B) when length(A)+length(B) =< 5 -> + ipv6_addr(x4(Cs1), A, [tox(Cs0)|B]); +ipv6_addr({Cs0,"."++Cs1}, A, B) when length(A)+length(B) =< 5 -> + ipv6_addr(x4(Cs1), A, B, [tod(Cs0)]). + +%% After "." +ipv6_addr({Cs0,[]}, A, B, C) when length(C) =:= 3 -> + ipv6_addr_done(A, B, [tod(Cs0)|C]); +ipv6_addr({Cs0,"."++Cs1}, A, B, C) when length(C) =< 2 -> + ipv6_addr(d3(Cs1), A, B, [tod(Cs0)|C]). + +ipv6_addr_done(Ar, Br, [D4,D3,D2,D1]) -> + ipv6_addr_done(Ar, [((D3 bsl 8) bor D4),((D1 bsl 8) bor D2)|Br]). + +ipv6_addr_done(Ar, Br) -> + ipv6_addr_done(Br++dup(8-length(Ar)-length(Br), 0, Ar)). + +ipv6_addr_done(Ar) -> + list_to_tuple(lists:reverse(Ar)). + +x4(Cs) -> x4(Cs, []). + +x4([C|Cs], R) when C >= $0, C =< $9, length(R) =< 3 -> + x4(Cs, [C|R]); +x4([C|Cs], R) when C >= $a, C =< $f, length(R) =< 3 -> + x4(Cs, [C|R]); +x4([C|Cs], R) when C >= $A, C =< $F, length(R) =< 3 -> + x4(Cs, [C|R]); +x4(Cs, [_|_]=R) -> + {lists:reverse(R),Cs}. + +tox(Cs) -> + erlang:list_to_integer(Cs, 16). + +dup(0, _, L) -> + L; +dup(N, E, L) when is_integer(N), N >= 1 -> + dup(N-1, E, [E|L]); +dup(N, E, L) -> + erlang:error(badarg, [N,E,L]). + +%% Convert IPv4 adress to ascii +%% Convert IPv6 / IPV4 adress to ascii (plain format) +ntoa({A,B,C,D}) -> + integer_to_list(A) ++ "." ++ integer_to_list(B) ++ "." ++ + integer_to_list(C) ++ "." ++ integer_to_list(D); +%% ANY +ntoa({0,0,0,0,0,0,0,0}) -> "::"; +%% LOOPBACK +ntoa({0,0,0,0,0,0,0,1}) -> "::1"; +%% IPV4 ipv6 host address +ntoa({0,0,0,0,0,0,A,B}) -> "::" ++ dig_to_dec(A) ++ "." ++ dig_to_dec(B); +%% IPV4 non ipv6 host address +ntoa({0,0,0,0,0,16#ffff,A,B}) -> + "::FFFF:" ++ dig_to_dec(A) ++ "." ++ dig_to_dec(B); +ntoa({_,_,_,_,_,_,_,_}=T) -> + %% Find longest sequence of zeros, at least 2, to replace with "::" + ntoa(tuple_to_list(T), []). + +%% Find first double zero +ntoa([], R) -> + ntoa_done(R); +ntoa([0,0|T], R) -> + ntoa(T, R, 2); +ntoa([D|T], R) -> + ntoa(T, [D|R]). + +%% Count consecutive zeros +ntoa([], R, _) -> + ntoa_done(R, []); +ntoa([0|T], R, N) -> + ntoa(T, R, N+1); +ntoa([D|T], R, N) -> + ntoa(T, R, N, [D]). + +%% Find alternate double zero +ntoa([], R1, _N1, R2) -> + ntoa_done(R1, R2); +ntoa([0,0|T], R1, N1, R2) -> + ntoa(T, R1, N1, R2, 2); +ntoa([D|T], R1, N1, R2) -> + ntoa(T, R1, N1, [D|R2]). + +%% Count consecutive alternate zeros +ntoa(T, R1, N1, R2, N2) when N2 > N1 -> + %% Alternate zero sequence is longer - use it instead + ntoa(T, R2++dup(N1, 0, R1), N2); +ntoa([], R1, _N1, R2, N2) -> + ntoa_done(R1, dup(N2, 0, R2)); +ntoa([0|T], R1, N1, R2, N2) -> + ntoa(T, R1, N1, R2, N2+1); +ntoa([D|T], R1, N1, R2, N2) -> + ntoa(T, R1, N1, [D|dup(N2, 0, R2)]). + +ntoa_done(R1, R2) -> + lists:append( + separate(":", lists:map(fun dig_to_hex/1, lists:reverse(R1)))++ + ["::"|separate(":", lists:map(fun dig_to_hex/1, lists:reverse(R2)))]). + +ntoa_done(R) -> + lists:append(separate(":", lists:map(fun dig_to_hex/1, lists:reverse(R)))). + +separate(_E, []) -> + []; +separate(E, [_|_]=L) -> + separate(E, L, []). + +separate(E, [H|[_|_]=T], R) -> + separate(E, T, [E,H|R]); +separate(_E, [H], R) -> + lists:reverse(R, [H]). + +%% convert to A.B decimal form +dig_to_dec(0) -> [$0,$.,$0]; +dig_to_dec(X) -> + integer_to_list((X bsr 8) band 16#ff) ++ "." ++ + integer_to_list(X band 16#ff). + +%% Convert a integer to hex string +dig_to_hex(X) -> + erlang:integer_to_list(X, 16). + +%% +%% Count number of '.' in a name +%% return {Number of non-terminating dots, has-terminating dot?} +%% {integer, bool} +%% +dots(Name) -> dots(Name, 0). + +dots([$.], N) -> {N, true}; +dots([$. | T], N) -> dots(T, N+1); +dots([_C | T], N) -> dots(T, N); +dots([], N) -> {N, false}. + + +split_line(Line) -> + split_line(Line, []). + +split_line([$# | _], Tokens) -> reverse(Tokens); +split_line([$\s| L], Tokens) -> split_line(L, Tokens); +split_line([$\t | L], Tokens) -> split_line(L, Tokens); +split_line([$\n | L], Tokens) -> split_line(L, Tokens); +split_line([], Tokens) -> reverse(Tokens); +split_line([C|Cs], Tokens) -> split_mid(Cs, [C], Tokens). + +split_mid([$# | _Cs], Acc, Tokens) -> split_end(Acc, Tokens); +split_mid([$\s | Cs], Acc, Tokens) -> split_line(Cs, [reverse(Acc) | Tokens]); +split_mid([$\t | Cs], Acc, Tokens) -> split_line(Cs, [reverse(Acc) | Tokens]); +split_mid([$\r, $\n | Cs], Acc, Tokens) -> split_line(Cs, [reverse(Acc) | Tokens]); +split_mid([$\n | Cs], Acc, Tokens) -> split_line(Cs, [reverse(Acc) | Tokens]); +split_mid([], Acc, Tokens) -> split_end(Acc, Tokens); +split_mid([C|Cs], Acc, Tokens) -> split_mid(Cs, [C|Acc], Tokens). + +split_end(Acc, Tokens) -> reverse([reverse(Acc) | Tokens]). + + +%% Split a comma separated tokens. Because we already have split on +%% spaces we may have the cases +%% +%% ",foo" +%% "foo," +%% "foo,bar..." + +split_comma([]) -> + []; +split_comma([Token | Tokens]) -> + split_comma(Token, []) ++ split_comma(Tokens). + +split_comma([], Tokens) -> reverse(Tokens); +split_comma([$, | L], Tokens) -> split_comma(L, Tokens); +split_comma([C|Cs], Tokens) -> split_mid_comma(Cs, [C], Tokens). + +split_mid_comma([$, | Cs], Acc, Tokens) -> + split_comma(Cs, [reverse(Acc) | Tokens]); +split_mid_comma([], Acc, Tokens) -> + split_end(Acc, Tokens); +split_mid_comma([C|Cs], Acc, Tokens) -> + split_mid_comma(Cs, [C|Acc], Tokens). + +%% + +warning(Fmt, Args) -> + case application:get_env(kernel,inet_warnings) of + {ok,on} -> + error_logger:info_msg("inet_parse:" ++ Fmt, Args); + _ -> + ok + end. + +error(Fmt, Args) -> + error_logger:info_msg("inet_parse:" ++ Fmt, Args). + diff --git a/lib/kernel/src/inet_res.erl b/lib/kernel/src/inet_res.erl new file mode 100644 index 0000000000..9b9e078898 --- /dev/null +++ b/lib/kernel/src/inet_res.erl @@ -0,0 +1,846 @@ +%% +%% %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% +%% +%% RFC 1035, 2671, 2782, 2915. +%% +-module(inet_res). + +%-compile(export_all). + +-export([gethostbyname/1, gethostbyname/2, gethostbyname/3, + gethostbyname_tm/3]). +-export([gethostbyaddr/1, gethostbyaddr/2, + gethostbyaddr_tm/2]). +-export([getbyname/2, getbyname/3, + getbyname_tm/3]). + +-export([resolve/3, resolve/4, resolve/5]). +-export([lookup/3, lookup/4, lookup/5]). +-export([dns_msg/1]). + +-export([nslookup/3, nslookup/4]). +-export([nnslookup/4, nnslookup/5]). + +-include_lib("kernel/include/inet.hrl"). +-include("inet_res.hrl"). +-include("inet_dns.hrl"). +-include("inet_int.hrl"). + +-define(verbose(Cond, Format, Args), + case begin Cond end of + true -> io:format(begin Format end, begin Args end); + false -> ok + end). + +%% -------------------------------------------------------------------------- +%% resolve: +%% +%% Nameserver query +%% + +resolve(Name, Class, Type) -> + resolve(Name, Class, Type, [], infinity). + +resolve(Name, Class, Type, Opts) -> + resolve(Name, Class, Type, Opts, infinity). + +resolve(Name, Class, Type, Opts, Timeout) -> + case nsdname(Name) of + {ok, Nm} -> + Timer = inet:start_timer(Timeout), + Res = res_query(Nm, Class, Type, Opts, Timer), + inet:stop_timer(Timer), + Res; + Error -> + Error + end. + +%% -------------------------------------------------------------------------- +%% lookup: +%% +%% Convenience wrapper to resolve/3,4,5 that filters out all answer data +%% fields of the class and type asked for. + +lookup(Name, Class, Type) -> + lookup(Name, Class, Type, []). + +lookup(Name, Class, Type, Opts) -> + lookup(Name, Class, Type, Opts, infinity). + +lookup(Name, Class, Type, Opts, Timeout) -> + lookup_filter(resolve(Name, Class, Type, Opts, Timeout), + Class, Type). + +lookup_filter({ok,#dns_rec{anlist=Answers}}, Class, Type) -> + [A#dns_rr.data || A <- Answers, + A#dns_rr.class =:= Class, + A#dns_rr.type =:= Type]; +lookup_filter({error,_}, _, _) -> []. + +%% -------------------------------------------------------------------------- +%% nslookup: +%% +%% Do a general nameserver lookup +%% +%% Perform nslookup on standard config !! +%% +%% To be deprecated + +nslookup(Name, Class, Type) -> + do_nslookup(Name, Class, Type, [], infinity). + +nslookup(Name, Class, Type, Timeout) when is_integer(Timeout), Timeout >= 0 -> + do_nslookup(Name, Class, Type, [], Timeout); +nslookup(Name, Class, Type, NSs) -> % For backwards compatibility + nnslookup(Name, Class, Type, NSs). % with OTP R6B only + +nnslookup(Name, Class, Type, NSs) -> + nnslookup(Name, Class, Type, NSs, infinity). + +nnslookup(Name, Class, Type, NSs, Timeout) -> + do_nslookup(Name, Class, Type, [{nameservers,NSs}], Timeout). + +do_nslookup(Name, Class, Type, Opts, Timeout) -> + case resolve(Name, Class, Type, Opts, Timeout) of + {error,{qfmterror,_}} -> {error,einval}; + {error,{Reason,_}} -> {error,Reason}; + Result -> Result + end. + +%% -------------------------------------------------------------------------- +%% options record +%% +-record(options, { % These must be sorted! + alt_nameservers,edns,inet6,nameservers,recurse, + retry,timeout,udp_payload_size,usevc, + verbose}). % this is a local option, not in inet_db +%% +%% Opts when is_list(Opts) -> #options{} +make_options(Opts0) -> + Opts = [if is_atom(Opt) -> + case atom_to_list(Opt) of + "no"++X -> {list_to_atom(X),false}; + _ -> {Opt,true} + end; + true -> Opt + end || Opt <- Opts0], + %% If the caller gives the nameservers option, the inet_db + %% alt_nameservers option should be regarded as empty, i.e + %% use only the nameservers the caller supplies. + SortedOpts = + lists:ukeysort(1, + case lists:keymember(nameservers, 1, Opts) of + true -> + case lists:keymember(alt_nameservers, 1, Opts) of + false -> + [{alt_nameservers,[]}|Opts]; + true -> + Opts + end; + false -> + Opts + end), + SortedNames = record_info(fields, options), + inet_db:res_update_conf(), + list_to_tuple([options|make_options(SortedOpts, SortedNames)]). + +make_options([_|_]=Opts0, []=Names0) -> + erlang:error(badarg, [Opts0,Names0]); +make_options([], []) -> []; +make_options([{verbose,Val}|Opts]=Opts0, [verbose|Names]=Names0) -> + if is_boolean(Val) -> + [Val|make_options(Opts, Names)]; + true -> + erlang:error(badarg, [Opts0,Names0]) + end; +make_options([{Opt,Val}|Opts]=Opts0, [Opt|Names]=Names0) -> + case inet_db:res_check_option(Opt, Val) of + true -> + [Val|make_options(Opts, Names)]; + false -> + erlang:error(badarg, [Opts0,Names0]) + end; +make_options(Opts, [verbose|Names]) -> + [false|make_options(Opts, Names)]; +make_options(Opts, [Name|Names]) -> + [inet_db:res_option(Name)|make_options(Opts, Names)]. + + +%% -------------------------------------------------------------------------- +%% +%% gethostbyaddr(ip_address()) => {ok, hostent()} | {error, Reason} +%% +%% where ip_address() is {A,B,C,D} ipv4 address +%% | {A,B,C,D,E,F,G,H} ipv6 address +%% | string versions of the above +%% | atom version +%% +%% -------------------------------------------------------------------------- + +gethostbyaddr(IP) -> gethostbyaddr_tm(IP,false). + +gethostbyaddr(IP,Timeout) -> + Timer = inet:start_timer(Timeout), + Res = gethostbyaddr_tm(IP,Timer), + inet:stop_timer(Timer), + Res. + +gethostbyaddr_tm({A,B,C,D} = IP, Timer) when ?ip(A,B,C,D) -> + inet_db:res_update_conf(), + case inet_db:gethostbyaddr(IP) of + {ok, HEnt} -> {ok, HEnt}; + _ -> res_gethostbyaddr(dn_in_addr_arpa(A,B,C,D), IP, Timer) + end; +%% ipv4 only ipv6 address +gethostbyaddr_tm({0,0,0,0,0,16#ffff,G,H},Timer) when is_integer(G+H) -> + gethostbyaddr_tm({G div 256, G rem 256, H div 256, H rem 256},Timer); +gethostbyaddr_tm({A,B,C,D,E,F,G,H} = IP, Timer) when ?ip6(A,B,C,D,E,F,G,H) -> + inet_db:res_update_conf(), + case inet_db:gethostbyaddr(IP) of + {ok, HEnt} -> {ok, HEnt}; + _ -> res_gethostbyaddr(dn_ip6_int(A,B,C,D,E,F,G,H), IP, Timer) + end; +gethostbyaddr_tm(Addr,Timer) when is_list(Addr) -> + case inet_parse:address(Addr) of + {ok, IP} -> gethostbyaddr_tm(IP,Timer); + _Error -> {error, formerr} + end; +gethostbyaddr_tm(Addr,Timer) when is_atom(Addr) -> + gethostbyaddr_tm(atom_to_list(Addr),Timer); +gethostbyaddr_tm(_,_) -> {error, formerr}. + +%% +%% Send the gethostbyaddr query to: +%% 1. the list of normal names servers +%% 2. the list of alternative name servers +%% +res_gethostbyaddr(Addr, IP, Timer) -> + case res_query(Addr, in, ptr, [], Timer) of + {ok, Rec} -> + inet_db:res_gethostbyaddr(IP, Rec); + {error,{qfmterror,_}} -> {error,einval}; + {error,{Reason,_}} -> {error,Reason}; + Error -> + Error + end. + +%% -------------------------------------------------------------------------- +%% +%% gethostbyname(domain_name()[,family [,Timer]) +%% => {ok, hostent()} | {error, Reason} +%% +%% where domain_name() is domain string or atom +%% +%% Caches the answer. +%% -------------------------------------------------------------------------- + +gethostbyname(Name) -> + case inet_db:res_option(inet6) of + true -> + gethostbyname_tm(Name, inet6, false); + false -> + gethostbyname_tm(Name, inet, false) + end. + +gethostbyname(Name,Family) -> + gethostbyname_tm(Name,Family,false). + +gethostbyname(Name,Family,Timeout) -> + Timer = inet:start_timer(Timeout), + Res = gethostbyname_tm(Name,Family,Timer), + inet:stop_timer(Timer), + Res. + +gethostbyname_tm(Name,inet,Timer) -> + getbyname_tm(Name,?S_A,Timer); +gethostbyname_tm(Name,inet6,Timer) -> + case getbyname_tm(Name,?S_AAAA,Timer) of + {ok,HEnt} -> {ok,HEnt}; + {error,nxdomain} -> + case getbyname_tm(Name, ?S_A,Timer) of + {ok, HEnt} -> + %% rewrite to a ipv4 only ipv6 address + {ok, + HEnt#hostent { + h_addrtype = inet6, + h_length = 16, + h_addr_list = + lists:map( + fun({A,B,C,D}) -> + {0,0,0,0,0,16#ffff,A*256+B,C*256+D} + end, HEnt#hostent.h_addr_list) + }}; + Error -> + Error + end; + Error -> + Error + end; +gethostbyname_tm(_Name, _Family, _Timer) -> + {error, einval}. + +%% -------------------------------------------------------------------------- +%% +%% getbyname(domain_name(), Type) => {ok, hostent()} | {error, Reason} +%% +%% where domain_name() is domain string or atom and Type is ?S_A, ?S_MX ... +%% +%% Caches the answer. +%% -------------------------------------------------------------------------- + +getbyname(Name, Type) -> + getbyname_tm(Name,Type,false). + +getbyname(Name, Type, Timeout) -> + Timer = inet:start_timer(Timeout), + Res = getbyname_tm(Name, Type, Timer), + inet:stop_timer(Timer), + Res. + +getbyname_tm(Name, Type, Timer) when is_list(Name) -> + case type_p(Type) of + true -> + case inet_parse:visible_string(Name) of + false -> {error, formerr}; + true -> + inet_db:res_update_conf(), + case inet_db:getbyname(Name, Type) of + {ok, HEnt} -> {ok, HEnt}; + _ -> res_getbyname(Name, Type, Timer) + end + end; + false -> + {error, formerr} + end; +getbyname_tm(Name,Type,Timer) when is_atom(Name) -> + getbyname_tm(atom_to_list(Name), Type,Timer); +getbyname_tm(_, _, _) -> {error, formerr}. + +type_p(Type) -> + lists:member(Type, [?S_A, ?S_AAAA, ?S_MX, ?S_NS, + ?S_MD, ?S_MF, ?S_CNAME, ?S_SOA, + ?S_MB, ?S_MG, ?S_MR, ?S_NULL, + ?S_WKS, ?S_HINFO, ?S_TXT, ?S_SRV, ?S_NAPTR, ?S_SPF, + ?S_UINFO, ?S_UID, ?S_GID]). + + + +%% This function and inet_db:getbyname/2 must look up names +%% in the same manner, but not from the same places. +%% +%% Assuming search path, i.e return value from inet_db:get_searchlist() +%% to be ["dom1", "dom2"]: +%% +%% Old behaviour (not this code but the previous version): +%% * For Name = "foo" +%% Name = "foo." try "foo.dom1", "foo.dom2" at normal nameservers +%% * For Name = "foo.bar" +%% Name = "foo.bar." try "foo.bar" at normal then alt. nameservers +%% then try "foo.bar.dom1", "foo.bar.dom2" +%% at normal nameservers +%% +%% New behaviour (this code), honoring the old behaviour but +%% doing better for absolute names: +%% * For Name = "foo" try "foo.dom1", "foo.dom2" at normal nameservers +%% * For Name = "foo.bar" try "foo.bar" at normal then alt. nameservers +%% then try "foo.bar.dom1", "foo.bar.dom2" +%% at normal nameservers +%% * For Name = "foo." try "foo" at normal then alt. nameservers +%% * For Name = "foo.bar." try "foo.bar" at normal then alt. nameservers +%% +%% +%% FIXME This is probably how it should be done: +%% Common behaviour (Solaris resolver) is: +%% * For Name = "foo." try "foo" +%% * For Name = "foo.bar." try "foo.bar" +%% * For Name = "foo" try "foo.dom1", "foo.dom2", "foo" +%% * For Name = "foo.bar" try "foo.bar.dom1", "foo.bar.dom2", "foo.bar" +%% That is to try Name as it is as a last resort if it is not absolute. +%% +res_getbyname(Name, Type, Timer) -> + {EmbeddedDots, TrailingDot} = inet_parse:dots(Name), + Dot = if TrailingDot -> ""; true -> "." end, + if TrailingDot -> + res_getby_query(Name, Type, Timer); + EmbeddedDots =:= 0 -> + res_getby_search(Name, Dot, + inet_db:get_searchlist(), + nxdomain, Type, Timer); + true -> + case res_getby_query(Name, Type, Timer) of + {error,_Reason}=Error -> + res_getby_search(Name, Dot, + inet_db:get_searchlist(), + Error, Type, Timer); + Other -> Other + end + end. + +res_getby_search(Name, Dot, [Dom | Ds], _Reason, Type, Timer) -> + case res_getby_query(Name++Dot++Dom, Type, Timer, + inet_db:res_option(nameservers)) of + {ok, HEnt} -> {ok, HEnt}; + {error, NewReason} -> + res_getby_search(Name, Dot, Ds, NewReason, Type, Timer) + end; +res_getby_search(_Name, _, [], Reason,_,_) -> + {error, Reason}. + +res_getby_query(Name, Type, Timer) -> + case res_query(Name, in, Type, [], Timer) of + {ok, Rec} -> + inet_db:res_hostent_by_domain(Name, Type, Rec); + {error,{qfmterror,_}} -> {error,einval}; + {error,{Reason,_}} -> {error,Reason}; + Error -> Error + end. + +res_getby_query(Name, Type, Timer, NSs) -> + case res_query(Name, in, Type, [], Timer, NSs) of + {ok, Rec} -> + inet_db:res_hostent_by_domain(Name, Type, Rec); + {error,{qfmterror,_}} -> {error,einval}; + {error,{Reason,_}} -> {error,Reason}; + Error -> Error + end. + + + +%% -------------------------------------------------------------------------- +%% query record +%% +-record(q, {options,edns,dns}). + + + +%% Query first nameservers list then alt_nameservers list +res_query(Name, Class, Type, Opts, Timer) -> + #q{options=#options{nameservers=NSs}}=Q = + make_query(Name, Class, Type, Opts), + case do_query(Q, NSs, Timer) of + {error,nxdomain}=Error -> + res_query_alt(Q, Error, Timer); + {error,{nxdomain,_}}=Error -> + res_query_alt(Q, Error, Timer); + {ok,#dns_rec{anlist=[]}}=Reply -> + res_query_alt(Q, Reply, Timer); + Reply -> Reply + end. + +%% Query just the argument nameservers list +res_query(Name, Class, Type, Opts, Timer, NSs) -> + Q = make_query(Name, Class, Type, Opts), + do_query(Q, NSs, Timer). + +res_query_alt(#q{options=#options{alt_nameservers=NSs}}=Q, Reply, Timer) -> + case NSs of + [] -> Reply; + _ -> + do_query(Q, NSs, Timer) + end. + +make_query(Dname, Class, Type, Opts) -> + Options = make_options(Opts), + case Options#options.edns of + false -> + #q{options=Options, + edns=undefined, + dns=make_query(Dname, Class, Type, Options, false)}; + Edns -> + #q{options=Options, + edns=make_query(Dname, Class, Type, Options, Edns), + dns=fun () -> + make_query(Dname, Class, Type, Options, false) + end} + end. + +%% XXX smarter would be to always construct both queries, +%% but make the EDNS query point into the DNS query binary. +%% It is only the header ARList length that need to be changed, +%% and the OPT record appended. +make_query(Dname, Class, Type, Options, Edns) -> + Id = inet_db:res_option(next_id), + Recurse = Options#options.recurse, + ARList = case Edns of + false -> []; + _ -> + PSz = Options#options.udp_payload_size, + [#dns_rr_opt{udp_payload_size=PSz, + version=Edns}] + end, + Msg = #dns_rec{header=#dns_header{id=Id, + opcode='query', + rd=Recurse, + rcode=?NOERROR}, + qdlist=[#dns_query{domain=Dname, + type=Type, + class=Class}], + arlist=ARList}, + ?verbose(Options#options.verbose, "Query: ~p~n", [dns_msg(Msg)]), + Buffer = inet_dns:encode(Msg), + {Id, Buffer}. + +%% -------------------------------------------------------------------------- +%% socket helpers +%% +-record(sock, {inet=undefined, inet6=undefined}). + +udp_open(#sock{inet6=I}=S, {A,B,C,D,E,F,G,H}) when ?ip6(A,B,C,D,E,F,G,H) -> + case I of + undefined -> + case gen_udp:open(0, [{active,false},binary,inet6]) of + {ok,J} -> + {ok,S#sock{inet6=J}}; + Error -> + Error + end; + _ -> + {ok,S} + end; +udp_open(#sock{inet=I}=S, {A,B,C,D}) when ?ip(A,B,C,D) -> + case I of + undefined -> + case gen_udp:open(0, [{active,false},binary,inet]) of + {ok,J} -> + {ok,S#sock{inet=J}}; + Error -> + Error + end; + _ -> + {ok,S} + end. + +udp_connect(#sock{inet6=I}, {A,B,C,D,E,F,G,H}=IP, Port) + when ?ip6(A,B,C,D,E,F,G,H), ?port(Port) -> + gen_udp:connect(I, IP, Port); +udp_connect(#sock{inet=I}, {A,B,C,D}=IP, Port) + when ?ip(A,B,C,D) -> + gen_udp:connect(I, IP, Port). + +udp_send(#sock{inet6=I}, {A,B,C,D,E,F,G,H}=IP, Port, Buffer) + when ?ip6(A,B,C,D,E,F,G,H), ?port(Port) -> + gen_udp:send(I, IP, Port, Buffer); +udp_send(#sock{inet=I}, {A,B,C,D}=IP, Port, Buffer) + when ?ip(A,B,C,D), ?port(Port) -> + gen_udp:send(I, IP, Port, Buffer). + +udp_recv(#sock{inet6=I}, {A,B,C,D,E,F,G,H}=IP, Port, Timeout) + when ?ip6(A,B,C,D,E,F,G,H), ?port(Port) -> + do_udp_recv(fun(T) -> gen_udp:recv(I, 0, T) end, IP, Port, Timeout); +udp_recv(#sock{inet=I}, {A,B,C,D}=IP, Port, Timeout) + when ?ip(A,B,C,D), ?port(Port) -> + do_udp_recv(fun(T) -> gen_udp:recv(I, 0, T) end, IP, Port, Timeout). + +do_udp_recv(Recv, IP, Port, Timeout) -> + do_udp_recv(Recv, IP, Port, Timeout, + if Timeout =/= 0 -> erlang:now(); true -> undefined end). + +do_udp_recv(Recv, IP, Port, Timeout, Then) -> + case Recv(Timeout) of + {ok,{IP,Port,Answer}} -> + {ok,Answer,erlang:max(0, Timeout - now_ms(erlang:now(), Then))}; + {ok,_} when Timeout =:= 0 -> + {error,timeout}; + {ok,_} -> + Now = erlang:now(), + T = erlang:max(0, Timeout - now_ms(Now, Then)), + do_udp_recv(Recv, IP, Port, T, Now); + Error -> Error + end. + +udp_close(#sock{inet=I,inet6=I6}) -> + if I =/= undefined -> gen_udp:close(I); true -> ok end, + if I6 =/= undefined -> gen_udp:close(I6); true -> ok end, + ok. + +%% +%% Send a query to the nameserver and return a reply +%% We first use socket server then we add the udp version +%% +%% Algorithm: (from manual page for dig) +%% for i = 0 to retry - 1 +%% for j = 1 to num_servers +%% send_query +%% wait((time * (2**i)) / num_servers) +%% end +%% end +%% + +do_query(_Q, [], _Timer) -> + {error,nxdomain}; +do_query(#q{options=#options{retry=Retry}}=Q, NSs, Timer) -> + query_retries(Q, NSs, Timer, Retry, 0, #sock{}). + +query_retries(_Q, _NSs, _Timer, Retry, Retry, S) -> + udp_close(S), + {error,timeout}; +query_retries(Q, NSs, Timer, Retry, I, S0) -> + Num = length(NSs), + if Num =:= 0 -> + {error,timeout}; + true -> + case query_nss(Q, NSs, Timer, Retry, I, S0, []) of + {S,{noanswer,ErrNSs}} -> %% remove unreachable nameservers + query_retries(Q, NSs--ErrNSs, Timer, Retry, I+1, S); + {S,Result} -> + udp_close(S), + Result + end + end. + +query_nss(_Q, [], _Timer, _Retry, _I, S, ErrNSs) -> + {S,{noanswer,ErrNSs}}; +query_nss(#q{edns=undefined}=Q, NSs, Timer, Retry, I, S, ErrNSs) -> + query_nss_dns(Q, NSs, Timer, Retry, I, S, ErrNSs); +query_nss(Q, NSs, Timer, Retry, I, S, ErrNSs) -> + query_nss_edns(Q, NSs, Timer, Retry, I, S, ErrNSs). + +query_nss_edns(#q{options=#options{udp_payload_size=PSz}=Options, + edns={Id,Buffer}}=Q, + [{IP,Port}=NS|NSs]=NSs0, Timer, Retry, I, S0, ErrNSs) -> + {S,Res}=Reply = query_ns(S0, Id, Buffer, IP, Port, Timer, + Retry, I, Options, PSz), + case Res of + timeout -> {S,{error,timeout}}; + {ok,_} -> Reply; + {error,{nxdomain,_}} -> Reply; + {error,{E,_}} when E =:= qfmterror; E =:= notimp; E =:= servfail; + E =:= badvers -> + query_nss_dns(Q, NSs0, Timer, Retry, I, S, ErrNSs); + {error,E} when E =:= fmt; E =:= enetunreach; E =:= econnrefused -> + query_nss(Q, NSs, Timer, Retry, I, S, [NS|ErrNSs]); + _Error -> + query_nss(Q, NSs, Timer, Retry, I, S, ErrNSs) + end. + +query_nss_dns(#q{dns=Qdns}=Q0, [{IP,Port}=NS|NSs], + Timer, Retry, I, S0, ErrNSs) -> + #q{options=Options,dns={Id,Buffer}}=Q = + if + is_function(Qdns, 0) -> Q0#q{dns=Qdns()}; + true -> Q0 + end, + {S,Res}=Reply = query_ns(S0, Id, Buffer, IP, Port, Timer, + Retry, I, Options, ?PACKETSZ), + case Res of + timeout -> {S,{error,timeout}}; + {ok,_} -> Reply; + {error,{E,_}} when E =:= nxdomain; E =:= qfmterror -> Reply; + {error,E} when E =:= fmt; E =:= enetunreach; E =:= econnrefused -> + query_nss(Q, NSs, Timer, Retry, I, S, [NS|ErrNSs]); + _Error -> + query_nss(Q, NSs, Timer, Retry, I, S, ErrNSs) + end. + +query_ns(S0, Id, Buffer, IP, Port, Timer, Retry, I, + #options{timeout=Tm,usevc=UseVC,verbose=Verbose}, + PSz) -> + case UseVC orelse iolist_size(Buffer) > PSz of + true -> + {S0,query_tcp(Tm, Id, Buffer, IP, Port, Timer, Verbose)}; + false -> + case udp_open(S0, IP) of + {ok,S} -> + {S,case query_udp(S, Id, Buffer, IP, Port, Timer, + Retry, I, Tm, Verbose) of + {ok,#dns_rec{header=H}} when H#dns_header.tc -> + query_tcp(Tm, Id, Buffer, + IP, Port, Timer, Verbose); + Reply -> Reply + end}; + Error -> + {S0,Error} + end + end. + +query_udp(S, Id, Buffer, IP, Port, Timer, Retry, I, Tm, Verbose) -> + Timeout = inet:timeout( (Tm * (1 bsl I)) div Retry, Timer), + ?verbose(Verbose, "Try UDP server : ~p:~p (timeout=~w)\n", + [IP, Port, Timeout]), + udp_connect(S, IP, Port), + udp_send(S, IP, Port, Buffer), + query_udp_recv(S, IP, Port, Id, Timeout, Verbose). + +query_udp_recv(S, IP, Port, Id, Timeout, Verbose) -> + case udp_recv(S, IP, Port, Timeout) of + {ok,Answer,T} -> + case decode_answer(Answer, Id, Verbose) of + {error, badid} -> + query_udp_recv(S, IP, Port, Id, T, Verbose); + Reply -> Reply + end; + {error, timeout} when Timeout =:= 0 -> + ?verbose(Verbose, "UDP server timeout\n", []), + timeout; + Error -> + ?verbose(Verbose, "UDP server error: ~p\n", [Error]), + Error + end. + +query_tcp(Tm, Id, Buffer, IP, Port, Timer, Verbose) -> + Timeout = inet:timeout(Tm*5, Timer), + ?verbose(Verbose, "Try TCP server : ~p:~p (timeout=~w)\n", + [IP, Port, Timeout]), + Family = case IP of + {A,B,C,D} when ?ip(A,B,C,D) -> inet; + {A,B,C,D,E,F,G,H} when ?ip6(A,B,C,D,E,F,G,H) -> inet6 + end, + try gen_tcp:connect(IP, Port, + [{active,false},{packet,2},binary,Family], + Timeout) of + {ok, S} -> + gen_tcp:send(S, Buffer), + case gen_tcp:recv(S, 0, Timeout) of + {ok, Answer} -> + gen_tcp:close(S), + case decode_answer(Answer, Id, Verbose) of + {ok, _} = OK -> OK; + {error, badid} -> {error, servfail}; + Error -> Error + end; + Error -> + gen_tcp:close(S), + case Error of + {error, timeout} when Timeout =:= 0 -> + ?verbose(Verbose, "TCP server recv timeout\n", []), + timeout; + _ -> + ?verbose(Verbose, "TCP server recv error: ~p\n", + [Error]), + Error + end + end; + {error, timeout} when Timeout =:= 0 -> + ?verbose(Verbose, "TCP server connect timeout\n", []), + timeout; + Error -> + ?verbose(Verbose, "TCP server error: ~p\n", [Error]), + Error + catch + _:_ -> {error, einval} + end. + +decode_answer(Answer, Id, Verbose) -> + case inet_dns:decode(Answer) of + {ok, Msg} -> + ?verbose(Verbose, "Got reply: ~p~n", [dns_msg(Msg)]), + E = case lists:keyfind(dns_rr_opt, 1, Msg#dns_rec.arlist) of + false -> 0; + #dns_rr_opt{ext_rcode=ExtRCode} -> ExtRCode + end, + H = Msg#dns_rec.header, + RCode = (E bsl 4) bor H#dns_header.rcode, + case RCode of + ?NOERROR -> + if H#dns_header.id =/= Id -> + {error,badid}; + length(Msg#dns_rec.qdlist) =/= 1 -> + {error,{noquery,Msg}}; + true -> + {ok, Msg} + end; + ?FORMERR -> {error,{qfmterror,Msg}}; + ?SERVFAIL -> {error,{servfail,Msg}}; + ?NXDOMAIN -> {error,{nxdomain,Msg}}; + ?NOTIMP -> {error,{notimp,Msg}}; + ?REFUSED -> {error,{refused,Msg}}; + ?BADVERS -> {error,{badvers,Msg}}; + _ -> {error,{unknown,Msg}} + end; + Error -> + ?verbose(Verbose, "Got reply: ~p~n", [Error]), + Error + end. + +%% +%% Transform domain name or address +%% 1. "a.b.c" => +%% "a.b.c" +%% 2. "1.2.3.4" => +%% "4.3.2.1.IN-ADDR.ARPA" +%% 3. "4321:0:1:2:3:4:567:89ab" => +%% "b.a.9.8.7.6.5.0.4.0.0.0.3.0.0.0.2.0.0.0.1.0.0.0.0.0.0.1.2.3.4.IP6.ARPA" +%% 4. {1,2,3,4} => as 2. +%% 5. {1,2,3,4,5,6,7,8} => as 3. +%% +nsdname({A,B,C,D}) -> + {ok, dn_in_addr_arpa(A,B,C,D)}; +nsdname({A,B,C,D,E,F,G,H}) -> + {ok, dn_ip6_int(A,B,C,D,E,F,G,H)}; +nsdname(Name) when is_list(Name) -> + case inet_parse:visible_string(Name) of + true -> + case inet_parse:address(Name) of + {ok, Addr} -> + nsdname(Addr); + _ -> + {ok, Name} + end; + _ -> {error, formerr} + end; +nsdname(Name) when is_atom(Name) -> + nsdname(atom_to_list(Name)); +nsdname(_) -> {error, formerr}. + +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"))). + +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.ARPA"))))))). + + + +-compile({inline, [dnib/1, dnib/3]}). +dnib(X) -> + L = erlang:integer_to_list(X, 16), + dnib(4-length(L), L, []). +%% +dnib(0, [], Acc) -> Acc; +dnib(0, [C|Cs], Acc) -> + dnib(0, Cs, [C,$.|Acc]); +dnib(N, Cs, Acc) -> + dnib(N-1, Cs, [$0,$.|Acc]). + + + +dns_msg([]) -> []; +dns_msg([{Field,Msg}|Fields]) -> + [{Field,dns_msg(Msg)}|dns_msg(Fields)]; +dns_msg([Msg|Msgs]) -> + [dns_msg(Msg)|dns_msg(Msgs)]; +dns_msg(Msg) -> + case inet_dns:record_type(Msg) of + undefined -> Msg; + Type -> + Fields = inet_dns:Type(Msg), + {Type,dns_msg(Fields)} + end. + +-compile({inline, [now_ms/2]}). +now_ms({Meg1,Sec1,Mic1}, {Meg0,Sec0,Mic0}) -> + ((Meg1-Meg0)*1000000 + (Sec1-Sec0))*1000 + ((Mic1-Mic0) div 1000). diff --git a/lib/kernel/src/inet_res.hrl b/lib/kernel/src/inet_res.hrl new file mode 100644 index 0000000000..bfaf32a1ba --- /dev/null +++ b/lib/kernel/src/inet_res.hrl @@ -0,0 +1,42 @@ +%% +%% %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% +%% +%% +%% Dns & resolver defintions +%% + +-define(RES_TIMEOUT, 2000). %% milli second between retries +-define(RES_RETRY, 3). %% number of retry +-define(RES_FILE_UPDATE_TM, 5). %% seconds between file_info + +-define(CACHE_LIMIT, 100). %% number of cached dns_rr +-define(CACHE_REFRESH, 60*60*1000). %% refresh interval + +-define(PACKETSZ, 512). %% maximum packet size +-define(MAXDNAME, 256). %% maximum domain name +-define(MAXCDNAME, 255). %% maximum compressed domain name +-define(MAXLABEL, 63). %% maximum length of domain label +%% Number of bytes of fixed size data in query structure +-define(QFIXEDSZ, 4). +%% number of bytes of fixed size data in resource record +-define(RRFIXEDSZ, 10). + +%% +%% Internet nameserver port number +%% +-define(NAMESERVER_PORT, 53). diff --git a/lib/kernel/src/inet_sctp.erl b/lib/kernel/src/inet_sctp.erl new file mode 100644 index 0000000000..30c0e85dd9 --- /dev/null +++ b/lib/kernel/src/inet_sctp.erl @@ -0,0 +1,139 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2007-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% +%% +%% SCTP protocol contribution by Leonid Timochouk and Serge Aleynikov. +%% See also: $ERL_TOP/lib/kernel/AUTHORS +%% +-module(inet_sctp). + +%% This module provides functions for communicating with +%% sockets using the SCTP protocol. The implementation assumes that +%% the OS kernel supports SCTP providing user-level SCTP Socket API: +%% http://tools.ietf.org/html/draft-ietf-tsvwg-sctpsocket-13 + +-include("inet_sctp.hrl"). +-include("inet_int.hrl"). + +-define(FAMILY, inet). +-export([getserv/1,getaddr/1,getaddr/2,translate_ip/1]). +-export([open/1,close/1,listen/2,connect/5,sendmsg/3,recv/2]). + + + +getserv(Port) when is_integer(Port) -> {ok, Port}; +getserv(Name) when is_atom(Name) -> + inet:getservbyname(Name, sctp); +getserv(_) -> + {error,einval}. + +getaddr(Address) -> + inet:getaddr(Address, ?FAMILY). +getaddr(Address, Timer) -> + inet:getaddr_tm(Address, ?FAMILY, Timer). + +translate_ip(IP) -> + inet:translate_ip(IP, ?FAMILY). + + + +open(Opts) -> + case inet:sctp_options(Opts, ?MODULE) of + {ok,#sctp_opts{fd=Fd,ifaddr=Addr,port=Port,opts=SOs}} -> + inet:open(Fd, Addr, Port, SOs, sctp, ?FAMILY, ?MODULE); + Error -> Error + end. + +close(S) -> + prim_inet:close(S). + +listen(S, Flag) -> + prim_inet:listen(S, Flag). + +connect(S, Addr, Port, Opts, Timer) -> + case prim_inet:chgopts(S, Opts) of + ok -> + case prim_inet:getopt(S, active) of + {ok,Active} -> + Timeout = inet:timeout(Timer), + case prim_inet:connect(S, Addr, Port, Timeout) of + ok -> + connect_get_assoc(S, Addr, Port, Active, Timer); + Err1 -> Err1 + end; + Err2 -> Err2 + end; + Err3 -> Err3 + end. + +%% XXX race condition problem +%% +%% If an incoming #sctp_assoc_change{} arrives after +%% prim_inet:getopt(S, alive) above but before the +%% #sctp_assoc_change{state=comm_up} originating from +%% prim_inet:connect(S, Addr, Port, Timeout) above, +%% connect_get_assoc/5 below mistakes it for an invalid response +%% for a socket in {active,false} or {active,once} modes. +%% +%% In {active,true} mode it probably gets right, but it is +%% a blocking connect that is implemented even for {active,true}, +%% and that may be a shortcoming. A non-blocking connect +%% would be nice to have. + +connect_get_assoc(S, Addr, Port, false, Timer) -> + case recv(S, inet:timeout(Timer)) of + {ok, {Addr, Port, [], #sctp_assoc_change{state=St}=Ev}} -> + if St =:= comm_up -> + %% Yes, successfully connected, return the whole + %% sctp_assoc_change event (containing, in particular, + %% the AssocID). + %% NB: we consider the connection to be successful + %% even if the number of OutStreams is not the same + %% as requested by the user: + {ok,Ev}; + true -> + {error,Ev} + end; + %% Any other event: Error: + {ok, Msg} -> + {error, Msg}; + {error,_}=Error -> + Error + end; +connect_get_assoc(S, Addr, Port, Active, Timer) -> + Timeout = inet:timeout(Timer), + receive + {sctp,S,Addr,Port,{[],#sctp_assoc_change{state=St}=Ev}} -> + case Active of + once -> + prim_inet:setopt(S, active, once); + _ -> ok + end, + if St =:= comm_up -> + {ok,Ev}; + true -> + {error,Ev} + end + after Timeout -> + {error,timeout} + end. + +sendmsg(S, SRI, Data) -> + prim_inet:sendmsg(S, SRI, Data). + +recv(S, Timeout) -> + prim_inet:recvfrom(S, 0, Timeout). diff --git a/lib/kernel/src/inet_tcp.erl b/lib/kernel/src/inet_tcp.erl new file mode 100644 index 0000000000..6dadccd6a9 --- /dev/null +++ b/lib/kernel/src/inet_tcp.erl @@ -0,0 +1,153 @@ +%% +%% %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_tcp). + +%% Socket server for TCP/IP + +-export([connect/3, connect/4, listen/2, accept/1, accept/2, close/1]). +-export([send/2, send/3, recv/2, recv/3, unrecv/2]). +-export([shutdown/2]). +-export([controlling_process/2]). +-export([fdopen/2]). + +-export([getserv/1, getaddr/1, getaddr/2, getaddrs/1, getaddrs/2]). + + +-include("inet_int.hrl"). + +%% inet_tcp port lookup +getserv(Port) when is_integer(Port) -> {ok, Port}; +getserv(Name) when is_atom(Name) -> inet:getservbyname(Name,tcp). + +%% inet_tcp address lookup +getaddr(Address) -> inet:getaddr(Address, inet). +getaddr(Address,Timer) -> inet:getaddr_tm(Address, inet, Timer). + +%% inet_tcp address lookup +getaddrs(Address) -> inet:getaddrs(Address, inet). +getaddrs(Address,Timer) -> inet:getaddrs_tm(Address,inet,Timer). + +%% +%% Send data on a socket +%% +send(Socket, Packet, Opts) -> prim_inet:send(Socket, Packet, Opts). +send(Socket, Packet) -> prim_inet:send(Socket, Packet, []). + +%% +%% Receive data from a socket (inactive only) +%% +recv(Socket, Length) -> prim_inet:recv(Socket, Length). +recv(Socket, Length, Timeout) -> prim_inet:recv(Socket, Length, Timeout). + +unrecv(Socket, Data) -> prim_inet:unrecv(Socket, Data). + +%% +%% Shutdown one end of a socket +%% +shutdown(Socket, How) -> + prim_inet:shutdown(Socket, How). + +%% +%% Close a socket (async) +%% +close(Socket) -> + inet:tcp_close(Socket). + +%% +%% Set controlling process +%% +controlling_process(Socket, NewOwner) -> + inet:tcp_controlling_process(Socket, NewOwner). + +%% +%% Connect +%% +connect(Address, Port, Opts) -> + do_connect(Address, Port, Opts, infinity). + +connect(Address, Port, Opts, infinity) -> + do_connect(Address, Port, Opts, infinity); +connect(Address, Port, Opts, Timeout) when is_integer(Timeout), + Timeout >= 0 -> + do_connect(Address, Port, Opts, Timeout). + +do_connect({A,B,C,D}, Port, Opts, Time) when ?ip(A,B,C,D), ?port(Port) -> + case inet:connect_options(Opts, inet) of + {error, Reason} -> exit(Reason); + {ok, #connect_opts{fd=Fd, + ifaddr=BAddr={Ab,Bb,Cb,Db}, + port=BPort, + opts=SockOpts}} + when ?ip(Ab,Bb,Cb,Db), ?port(BPort) -> + case inet:open(Fd,BAddr,BPort,SockOpts,tcp,inet,?MODULE) of + {ok, S} -> + case prim_inet:connect(S, {A,B,C,D}, Port, Time) of + ok -> {ok,S}; + Error -> prim_inet:close(S), Error + end; + Error -> Error + end; + {ok, _} -> exit(badarg) + end. + +%% +%% Listen +%% +listen(Port, Opts) -> + case inet:listen_options([{port,Port} | Opts], inet) of + {error,Reason} -> exit(Reason); + {ok, #listen_opts{fd=Fd, + ifaddr=BAddr={A,B,C,D}, + port=BPort, + opts=SockOpts}=R} + when ?ip(A,B,C,D), ?port(BPort) -> + case inet:open(Fd,BAddr,BPort,SockOpts,tcp,inet,?MODULE) of + {ok, S} -> + case prim_inet:listen(S, R#listen_opts.backlog) of + ok -> {ok, S}; + Error -> prim_inet:close(S), Error + end; + Error -> Error + end; + {ok, _} -> exit(badarg) + end. + +%% +%% Accept +%% +accept(L) -> + case prim_inet:accept(L) of + {ok, S} -> + inet_db:register_socket(S, ?MODULE), + {ok,S}; + Error -> Error + end. + +accept(L,Timeout) -> + case prim_inet:accept(L,Timeout) of + {ok, S} -> + inet_db:register_socket(S, ?MODULE), + {ok,S}; + Error -> Error + end. +%% +%% Create a port/socket from a file descriptor +%% +fdopen(Fd, Opts) -> + inet:fdopen(Fd, Opts, tcp, inet, ?MODULE). diff --git a/lib/kernel/src/inet_tcp_dist.erl b/lib/kernel/src/inet_tcp_dist.erl new file mode 100644 index 0000000000..7f935c2b36 --- /dev/null +++ b/lib/kernel/src/inet_tcp_dist.erl @@ -0,0 +1,448 @@ +%% +%% %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_tcp_dist). + +%% Handles the connection setup phase with other Erlang nodes. + +-export([listen/1, accept/1, accept_connection/5, + setup/5, close/1, select/1, is_node_name/1]). + +%% internal exports + +-export([accept_loop/2,do_accept/6,do_setup/6,getstat/1,tick/1]). + +-import(error_logger,[error_msg/2]). + +-include("net_address.hrl"). + + + +-define(to_port(Socket, Data, Opts), + case inet_tcp:send(Socket, Data, Opts) of + {error, closed} -> + self() ! {tcp_closed, Socket}, + {error, closed}; + R -> + R + end). + + +-include("dist.hrl"). +-include("dist_util.hrl"). + +%% ------------------------------------------------------------ +%% Select this protocol based on node name +%% select(Node) => Bool +%% ------------------------------------------------------------ + +select(Node) -> + case split_node(atom_to_list(Node), $@, []) of + [_,_Host] -> true; + _ -> false + end. + +%% ------------------------------------------------------------ +%% Create the listen socket, i.e. the port that this erlang +%% node is accessible through. +%% ------------------------------------------------------------ + +listen(Name) -> + case do_listen([{active, false}, {packet,2}, {reuseaddr, true}]) of + {ok, Socket} -> + TcpAddress = get_tcp_address(Socket), + {_,Port} = TcpAddress#net_address.address, + {ok, Creation} = erl_epmd:register_node(Name, Port), + {ok, {Socket, TcpAddress, Creation}}; + Error -> + Error + end. + +do_listen(Options0) -> + {First,Last} = case application:get_env(kernel,inet_dist_listen_min) of + {ok,N} when is_integer(N) -> + case application:get_env(kernel, + inet_dist_listen_max) of + {ok,M} when is_integer(M) -> + {N,M}; + _ -> + {N,N} + end; + _ -> + {0,0} + end, + Options = case application:get_env(kernel, inet_dist_use_interface) of + {ok, Ip} -> + [{ip, Ip} | Options0]; + _ -> + Options0 + end, + do_listen(First, Last, [{backlog,128}|Options]). + +do_listen(First,Last,_) when First > Last -> + {error,eaddrinuse}; +do_listen(First,Last,Options) -> + case inet_tcp:listen(First, Options) of + {error, eaddrinuse} -> + do_listen(First+1,Last,Options); + Other -> + Other + end. + +%% ------------------------------------------------------------ +%% Accepts new connection attempts from other Erlang nodes. +%% ------------------------------------------------------------ + +accept(Listen) -> + spawn_opt(?MODULE, accept_loop, [self(), Listen], [link, {priority, max}]). + +accept_loop(Kernel, Listen) -> + case inet_tcp:accept(Listen) of + {ok, Socket} -> + Kernel ! {accept,self(),Socket,inet,tcp}, + controller(Kernel, Socket), + accept_loop(Kernel, Listen); + Error -> + exit(Error) + end. + +controller(Kernel, Socket) -> + receive + {Kernel, controller, Pid} -> + flush_controller(Pid, Socket), + inet_tcp:controlling_process(Socket, Pid), + flush_controller(Pid, Socket), + Pid ! {self(), controller}; + {Kernel, unsupported_protocol} -> + exit(unsupported_protocol) + end. + +flush_controller(Pid, Socket) -> + receive + {tcp, Socket, Data} -> + Pid ! {tcp, Socket, Data}, + flush_controller(Pid, Socket); + {tcp_closed, Socket} -> + Pid ! {tcp_closed, Socket}, + flush_controller(Pid, Socket) + after 0 -> + ok + end. + +%% ------------------------------------------------------------ +%% Accepts a new connection attempt from another Erlang node. +%% Performs the handshake with the other side. +%% ------------------------------------------------------------ + +accept_connection(AcceptPid, Socket, MyNode, Allowed, SetupTime) -> + spawn_opt(?MODULE, do_accept, + [self(), AcceptPid, Socket, MyNode, Allowed, SetupTime], + [link, {priority, max}]). + +do_accept(Kernel, AcceptPid, Socket, MyNode, Allowed, SetupTime) -> + receive + {AcceptPid, controller} -> + Timer = dist_util:start_timer(SetupTime), + case check_ip(Socket) of + true -> + HSData = #hs_data{ + kernel_pid = Kernel, + this_node = MyNode, + socket = Socket, + timer = Timer, + this_flags = 0, + allowed = Allowed, + f_send = fun(S,D) -> inet_tcp:send(S,D) end, + f_recv = fun(S,N,T) -> inet_tcp:recv(S,N,T) + end, + f_setopts_pre_nodeup = + fun(S) -> + inet:setopts(S, + [{active, false}, + {packet, 4}, + nodelay()]) + end, + f_setopts_post_nodeup = + fun(S) -> + inet:setopts(S, + [{active, true}, + {deliver, port}, + {packet, 4}, + nodelay()]) + end, + f_getll = fun(S) -> + inet:getll(S) + end, + f_address = fun get_remote_id/2, + mf_tick = fun ?MODULE:tick/1, + mf_getstat = fun ?MODULE:getstat/1 + }, + dist_util:handshake_other_started(HSData); + {false,IP} -> + error_msg("** Connection attempt from " + "disallowed IP ~w ** ~n", [IP]), + ?shutdown(no_node) + end + end. + + +%% we may not always want the nodelay behaviour +%% for performance reasons + +nodelay() -> + case application:get_env(kernel, dist_nodelay) of + undefined -> + {nodelay, true}; + {ok, true} -> + {nodelay, true}; + {ok, false} -> + {nodelay, false}; + _ -> + {nodelay, true} + end. + + +%% ------------------------------------------------------------ +%% Get remote information about a Socket. +%% ------------------------------------------------------------ +get_remote_id(Socket, Node) -> + case inet:peername(Socket) of + {ok,Address} -> + case split_node(atom_to_list(Node), $@, []) of + [_,Host] -> + #net_address{address=Address,host=Host, + protocol=tcp,family=inet}; + _ -> + %% No '@' or more than one '@' in node name. + ?shutdown(no_node) + end; + {error, _Reason} -> + ?shutdown(no_node) + end. + +%% ------------------------------------------------------------ +%% Setup a new connection to another Erlang node. +%% Performs the handshake with the other side. +%% ------------------------------------------------------------ + +setup(Node, Type, MyNode, LongOrShortNames,SetupTime) -> + spawn_opt(?MODULE, do_setup, + [self(), Node, Type, MyNode, LongOrShortNames, SetupTime], + [link, {priority, max}]). + +do_setup(Kernel, Node, Type, MyNode, LongOrShortNames,SetupTime) -> + ?trace("~p~n",[{inet_tcp_dist,self(),setup,Node}]), + [Name, Address] = splitnode(Node, LongOrShortNames), + case inet:getaddr(Address, inet) of + {ok, Ip} -> + Timer = dist_util:start_timer(SetupTime), + case erl_epmd:port_please(Name, Ip) of + {port, TcpPort, Version} -> + ?trace("port_please(~p) -> version ~p~n", + [Node,Version]), + dist_util:reset_timer(Timer), + case inet_tcp:connect(Ip, TcpPort, + [{active, false}, + {packet,2}]) of + {ok, Socket} -> + HSData = #hs_data{ + kernel_pid = Kernel, + other_node = Node, + this_node = MyNode, + socket = Socket, + timer = Timer, + this_flags = 0, + other_version = Version, + f_send = fun inet_tcp:send/2, + f_recv = fun inet_tcp:recv/3, + f_setopts_pre_nodeup = + fun(S) -> + inet:setopts + (S, + [{active, false}, + {packet, 4}, + nodelay()]) + end, + f_setopts_post_nodeup = + fun(S) -> + inet:setopts + (S, + [{active, true}, + {deliver, port}, + {packet, 4}, + nodelay()]) + end, + f_getll = fun inet:getll/1, + f_address = + fun(_,_) -> + #net_address{ + address = {Ip,TcpPort}, + host = Address, + protocol = tcp, + family = inet} + end, + mf_tick = fun ?MODULE:tick/1, + mf_getstat = fun ?MODULE:getstat/1, + request_type = Type + }, + dist_util:handshake_we_started(HSData); + _ -> + %% Other Node may have closed since + %% port_please ! + ?trace("other node (~p) " + "closed since port_please.~n", + [Node]), + ?shutdown(Node) + end; + _ -> + ?trace("port_please (~p) " + "failed.~n", [Node]), + ?shutdown(Node) + end; + _Other -> + ?trace("inet_getaddr(~p) " + "failed (~p).~n", [Node,_Other]), + ?shutdown(Node) + end. + +%% +%% Close a socket. +%% +close(Socket) -> + inet_tcp:close(Socket). + + +%% If Node is illegal terminate the connection setup!! +splitnode(Node, LongOrShortNames) -> + case split_node(atom_to_list(Node), $@, []) of + [Name|Tail] when Tail =/= [] -> + Host = lists:append(Tail), + case split_node(Host, $., []) of + [_] when LongOrShortNames =:= longnames -> + error_msg("** System running to use " + "fully qualified " + "hostnames **~n" + "** Hostname ~s is illegal **~n", + [Host]), + ?shutdown(Node); + L when length(L) > 1, LongOrShortNames =:= shortnames -> + error_msg("** System NOT running to use fully qualified " + "hostnames **~n" + "** Hostname ~s is illegal **~n", + [Host]), + ?shutdown(Node); + _ -> + [Name, Host] + end; + [_] -> + error_msg("** Nodename ~p illegal, no '@' character **~n", + [Node]), + ?shutdown(Node); + _ -> + error_msg("** Nodename ~p illegal **~n", [Node]), + ?shutdown(Node) + end. + +split_node([Chr|T], Chr, Ack) -> [lists:reverse(Ack)|split_node(T, Chr, [])]; +split_node([H|T], Chr, Ack) -> split_node(T, Chr, [H|Ack]); +split_node([], _, Ack) -> [lists:reverse(Ack)]. + +%% ------------------------------------------------------------ +%% Fetch local information about a Socket. +%% ------------------------------------------------------------ +get_tcp_address(Socket) -> + {ok, Address} = inet:sockname(Socket), + {ok, Host} = inet:gethostname(), + #net_address { + address = Address, + host = Host, + protocol = tcp, + family = inet + }. + +%% ------------------------------------------------------------ +%% Do only accept new connection attempts from nodes at our +%% own LAN, if the check_ip environment parameter is true. +%% ------------------------------------------------------------ +check_ip(Socket) -> + case application:get_env(check_ip) of + {ok, true} -> + case get_ifs(Socket) of + {ok, IFs, IP} -> + check_ip(IFs, IP); + _ -> + ?shutdown(no_node) + end; + _ -> + true + end. + +get_ifs(Socket) -> + case inet:peername(Socket) of + {ok, {IP, _}} -> + case inet:getif(Socket) of + {ok, IFs} -> {ok, IFs, IP}; + Error -> Error + end; + Error -> + Error + end. + +check_ip([{OwnIP, _, Netmask}|IFs], PeerIP) -> + case {mask(Netmask, PeerIP), mask(Netmask, OwnIP)} of + {M, M} -> true; + _ -> check_ip(IFs, PeerIP) + end; +check_ip([], PeerIP) -> + {false, PeerIP}. + +mask({M1,M2,M3,M4}, {IP1,IP2,IP3,IP4}) -> + {M1 band IP1, + M2 band IP2, + M3 band IP3, + M4 band IP4}. + +is_node_name(Node) when is_atom(Node) -> + case split_node(atom_to_list(Node), $@, []) of + [_, _Host] -> true; + _ -> false + end; +is_node_name(_Node) -> + false. + +tick(Sock) -> + ?to_port(Sock,[],[force]). + +getstat(Socket) -> + case inet:getstat(Socket, [recv_cnt, send_cnt, send_pend]) of + {ok, Stat} -> + split_stat(Stat,0,0,0); + Error -> + Error + end. + +split_stat([{recv_cnt, R}|Stat], _, W, P) -> + split_stat(Stat, R, W, P); +split_stat([{send_cnt, W}|Stat], R, _, P) -> + split_stat(Stat, R, W, P); +split_stat([{send_pend, P}|Stat], R, W, _) -> + split_stat(Stat, R, W, P); +split_stat([], R, W, P) -> + {ok, R, W, P}. + + diff --git a/lib/kernel/src/inet_udp.erl b/lib/kernel/src/inet_udp.erl new file mode 100644 index 0000000000..9a4089ab19 --- /dev/null +++ b/lib/kernel/src/inet_udp.erl @@ -0,0 +1,132 @@ +%% +%% %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_udp). + +-export([open/1, open/2, close/1]). +-export([send/2, send/4, recv/2, recv/3, connect/3]). +-export([controlling_process/2]). +-export([fdopen/2]). + +-export([getserv/1, getaddr/1, getaddr/2]). + +-include("inet_int.hrl"). + +-define(RECBUF, (8*1024)). + + + +%% inet_udp port lookup +getserv(Port) when is_integer(Port) -> {ok, Port}; +getserv(Name) when is_atom(Name) -> inet:getservbyname(Name,udp). + +%% inet_udp address lookup +getaddr(Address) -> inet:getaddr(Address, inet). +getaddr(Address,Timer) -> inet:getaddr_tm(Address, inet, Timer). + +open(Port) -> open(Port, []). + +open(Port, Opts) -> + case inet:udp_options( + [{port,Port}, {recbuf, ?RECBUF} | Opts], + inet) of + {error, Reason} -> exit(Reason); + {ok, #udp_opts{fd=Fd, + ifaddr=BAddr={A,B,C,D}, + port=BPort, + opts=SockOpts}} when ?ip(A,B,C,D), ?port(BPort) -> + inet:open(Fd,BAddr,BPort,SockOpts,udp,inet,?MODULE); + {ok, _} -> exit(badarg) + end. + +send(S,{A,B,C,D},P,Data) when ?ip(A,B,C,D), ?port(P) -> + prim_inet:sendto(S, {A,B,C,D}, P, Data). + +send(S, Data) -> + prim_inet:sendto(S, {0,0,0,0}, 0, Data). + +connect(S, {A,B,C,D}, P) when ?ip(A,B,C,D), ?port(P) -> + prim_inet:connect(S, {A,B,C,D}, P). + +recv(S,Len) -> + prim_inet:recvfrom(S, Len). + +recv(S,Len,Time) -> + prim_inet:recvfrom(S, Len, Time). + +close(S) -> + inet:udp_close(S). + +%% +%% Set controlling process: +%% 1) First sync socket into a known state +%% 2) Move all messages onto the new owners message queue +%% 3) Commit the owner +%% 4) Wait for ack of new Owner (since socket does some link and unlink) +%% + +controlling_process(Socket, NewOwner) -> + inet:udp_controlling_process(Socket, NewOwner). + +%% +%% Create a port/socket from a file descriptor +%% +fdopen(Fd, Opts) -> + inet:fdopen(Fd, + optuniquify([{recbuf, ?RECBUF} | Opts]), + udp, inet, ?MODULE). + + +%% Remove all duplicate options from an option list. +%% The last occurring duplicate is used, and the order is preserved. +%% +%% Here's how: +%% Reverse the list. +%% For each head option go through the tail and remove +%% all occurences of the same option from the tail. +%% Store that head option and iterate using the new tail. +%% Return the list of stored head options. +optuniquify(List) -> + optuniquify(lists:reverse(List), []). + +optuniquify([], Result) -> + Result; +optuniquify([Opt | Tail], Result) -> + %% Remove all occurences of Opt in Tail, + %% prepend Opt to Result, + %% then iterate back here. + optuniquify(Opt, Tail, [], Result). + +%% All duplicates of current option are now removed +optuniquify(Opt, [], Rest, Result) -> + %% Store unique option + optuniquify(lists:reverse(Rest), [Opt | Result]); +%% Duplicate option tuple +optuniquify(Opt0, [Opt1 | Tail], Rest, Result) + when tuple_size(Opt0) =:= tuple_size(Opt1), + element(1, Opt0) =:= element(1, Opt1) -> + %% Waste duplicate + optuniquify(Opt0, Tail, Rest, Result); +%% Duplicate option atom or other term +optuniquify(Opt, [Opt | Tail], Rest, Result) -> + %% Waste duplicate + optuniquify(Opt, Tail, Rest, Result); +%% Non-duplicate option +optuniquify(Opt, [X | Tail], Rest, Result) -> + %% Keep non-duplicate + optuniquify(Opt, Tail, [X | Rest], Result). diff --git a/lib/kernel/src/kernel.app.src b/lib/kernel/src/kernel.app.src new file mode 100644 index 0000000000..17ab84c177 --- /dev/null +++ b/lib/kernel/src/kernel.app.src @@ -0,0 +1,120 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1996-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% +%% +%% This is an -*- erlang -*- file. +%% +{application, kernel, + [ + {description, "ERTS CXC 138 10"}, + {vsn, "%VSN%"}, + {modules, [application, + application_controller, + application_master, + application_starter, + auth, + code, + packages, + code_server, + dist_util, + erl_boot_server, + erl_distribution, + erl_reply, + error_handler, + error_logger, + file, + file_server, + file_io_server, + global, + global_group, + global_search, + group, + heart, + hipe_unified_loader, + inet6_tcp, + inet6_tcp_dist, + inet6_udp, + inet6_sctp, + inet_config, + inet_hosts, + inet_gethost_native, + inet_tcp_dist, + kernel, + kernel_config, + net, + net_adm, + net_kernel, + os, + ram_file, + rpc, + user, + user_drv, + user_sup, + disk_log, + disk_log_1, + disk_log_server, + disk_log_sup, + dist_ac, + erl_ddll, + erl_epmd, + erts_debug, + gen_tcp, + gen_udp, + gen_sctp, + inet, + inet_db, + inet_dns, + inet_parse, + inet_res, + inet_tcp, + inet_udp, + inet_sctp, + pg2, + seq_trace, + standard_error, + wrap_log_reader]}, + {registered, [application_controller, + erl_reply, + auth, + boot_server, + code_server, + disk_log_server, + disk_log_sup, + erl_prim_loader, + error_logger, + file_server_2, + fixtable_server, + global_group, + global_name_server, + heart, + init, + kernel_config, + kernel_sup, + net_kernel, + net_sup, + rex, + user, + os_server, + ddll_server, + erl_epmd, + inet_db, + pg2]}, + {applications, []}, + {env, [{error_logger, tty}]}, + {mod, {kernel, []}} + ] +}. diff --git a/lib/kernel/src/kernel.appup.src b/lib/kernel/src/kernel.appup.src new file mode 100644 index 0000000000..54a63833e6 --- /dev/null +++ b/lib/kernel/src/kernel.appup.src @@ -0,0 +1 @@ +{"%VSN%",[],[]}. diff --git a/lib/kernel/src/kernel.erl b/lib/kernel/src/kernel.erl new file mode 100644 index 0000000000..92ee7b441a --- /dev/null +++ b/lib/kernel/src/kernel.erl @@ -0,0 +1,292 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1996-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(kernel). + +-behaviour(supervisor). + +%% External exports +-export([start/2, init/1, stop/1]). +-export([config_change/3]). + +%%%----------------------------------------------------------------- +%%% The kernel is the first application started. +%%% Callback functions for the kernel application. +%%%----------------------------------------------------------------- +start(_, []) -> + case supervisor:start_link({local, kernel_sup}, kernel, []) of + {ok, Pid} -> + Type = get_error_logger_type(), + error_logger:swap_handler(Type), + {ok, Pid, []}; + Error -> Error + end. + +stop(_State) -> + ok. + +%%------------------------------------------------------------------- +%% Some configuration parameters for kernel are changed +%%------------------------------------------------------------------- +config_change(Changed, New, Removed) -> + do_distribution_change(Changed, New, Removed), + do_global_groups_change(Changed, New, Removed), + ok. + +get_error_logger_type() -> + case application:get_env(kernel, error_logger) of + {ok, tty} -> tty; + {ok, {file, File}} when is_list(File) -> {logfile, File}; + {ok, false} -> false; + {ok, silent} -> silent; + undefined -> tty; % default value + {ok, Bad} -> exit({bad_config, {kernel, {error_logger, Bad}}}) + end. + +%%%----------------------------------------------------------------- +%%% The process structure in kernel is as shown in the figure. +%%% +%%% --------------- +%%% | kernel_sup (A)| +%%% --------------- +%%% | +%%% ------------------------------- +%%% | | | +%%% <std services> ------------- ------------- +%%% (file,code, | erl_dist (A)| | safe_sup (1)| +%%% rpc, ...) ------------- ------------- +%%% | | +%%% (net_kernel, (disk_log, pg2, +%%% auth, ...) ...) +%%% +%%% The rectangular boxes are supervisors. All supervisors except +%%% for kernel_safe_sup terminates the enitre erlang node if any of +%%% their children dies. Any child that can't be restarted in case +%%% of failure must be placed under one of these supervisors. Any +%%% other child must be placed under safe_sup. These children may +%%% be restarted. Be aware that if a child is restarted the old state +%%% and all data will be lost. +%%%----------------------------------------------------------------- +%%% Callback functions for the kernel_sup supervisor. +%%%----------------------------------------------------------------- + +init([]) -> + SupFlags = {one_for_all, 0, 1}, + + Config = {kernel_config, + {kernel_config, start_link, []}, + permanent, 2000, worker, [kernel_config]}, + Code = {code_server, + {code, start_link, get_code_args()}, + permanent, 2000, worker, [code]}, + File = {file_server_2, + {file_server, start_link, []}, + permanent, 2000, worker, + [file, file_server, file_io_server, prim_file]}, + StdError = {standard_error, + {standard_error, start_link, []}, + temporary, 2000, supervisor, [user_sup]}, + User = {user, + {user_sup, start, []}, + temporary, 2000, supervisor, [user_sup]}, + + case init:get_argument(mode) of + {ok, [["minimal"]]} -> + SafeSupervisor = {kernel_safe_sup, + {supervisor, start_link, + [{local, kernel_safe_sup}, ?MODULE, safe]}, + permanent, infinity, supervisor, [?MODULE]}, + {ok, {SupFlags, + [File, Code, StdError, User, + Config, SafeSupervisor]}}; + _ -> + Rpc = {rex, {rpc, start_link, []}, + permanent, 2000, worker, [rpc]}, + Global = {global_name_server, {global, start_link, []}, + permanent, 2000, worker, [global]}, + Glo_grp = {global_group, {global_group,start_link,[]}, + permanent, 2000, worker, [global_group]}, + InetDb = {inet_db, {inet_db, start_link, []}, + permanent, 2000, worker, [inet_db]}, + NetSup = {net_sup, {erl_distribution, start_link, []}, + permanent, infinity, supervisor,[erl_distribution]}, + DistAC = start_dist_ac(), + + Timer = start_timer(), + + SafeSupervisor = {kernel_safe_sup, + {supervisor, start_link, + [{local, kernel_safe_sup}, ?MODULE, safe]}, + permanent, infinity, supervisor, [?MODULE]}, + {ok, {SupFlags, + [Rpc, Global, InetDb | DistAC] ++ + [NetSup, Glo_grp, File, Code, + StdError, User, Config, SafeSupervisor] ++ Timer}} + end; +init(safe) -> + SupFlags = {one_for_one, 4, 3600}, + Boot = start_boot_server(), + DiskLog = start_disk_log(), + Pg2 = start_pg2(), + {ok, {SupFlags, Boot ++ DiskLog ++ Pg2}}. + +get_code_args() -> + case init:get_argument(nostick) of + {ok, [[]]} -> [[nostick]]; + _ -> [] + end. + +start_dist_ac() -> + Spec = [{dist_ac,{dist_ac,start_link,[]},permanent,2000,worker,[dist_ac]}], + case application:get_env(kernel, start_dist_ac) of + {ok, true} -> Spec; + {ok, false} -> []; + undefined -> + case application:get_env(kernel, distributed) of + {ok, _} -> Spec; + _ -> [] + end + end. + +start_boot_server() -> + case application:get_env(kernel, start_boot_server) of + {ok, true} -> + Args = get_boot_args(), + [{boot_server, {erl_boot_server, start_link, [Args]}, permanent, + 1000, worker, [erl_boot_server]}]; + _ -> + [] + end. + +get_boot_args() -> + case application:get_env(kernel, boot_server_slaves) of + {ok, Slaves} -> Slaves; + _ -> [] + end. + +start_disk_log() -> + case application:get_env(kernel, start_disk_log) of + {ok, true} -> + [{disk_log_server, + {disk_log_server, start_link, []}, + permanent, 2000, worker, [disk_log_server]}, + {disk_log_sup, {disk_log_sup, start_link, []}, permanent, + 1000, supervisor, [disk_log_sup]}]; + _ -> + [] + end. + +start_pg2() -> + case application:get_env(kernel, start_pg2) of + {ok, true} -> + [{pg2, {pg2, start_link, []}, permanent, 1000, worker, [pg2]}]; + _ -> + [] + end. + +start_timer() -> + case application:get_env(kernel, start_timer) of + {ok, true} -> + [{timer_server, {timer, start_link, []}, permanent, 1000, worker, + [timer]}]; + _ -> + [] + end. + +%%----------------------------------------------------------------- +%% The change of the distributed parameter is taken care of here +%%----------------------------------------------------------------- +do_distribution_change(Changed, New, Removed) -> + %% check if the distributed parameter is changed. It is not allowed + %% to make a local application to a distributed one, or vice versa. + case is_dist_changed(Changed, New, Removed) of + %%{changed, new, removed} + {false, false, false} -> + ok; + {C, false, false} -> + %% At last, update the parameter. + gen_server:call(dist_ac, {distribution_changed, C}, infinity); + {false, _, false} -> + error_logger:error_report("Distribution not changed: " + "Not allowed to add the 'distributed' " + "parameter."), + {error, {distribution_not_changed, "Not allowed to add the " + "'distributed' parameter"}}; + {false, false, _} -> + error_logger:error_report("Distribution not changed: " + "Not allowed to remove the " + "distribution parameter."), + {error, {distribution_not_changed, "Not allowed to remove the " + "'distributed' parameter"}} + end. + +%%----------------------------------------------------------------- +%% Check if distribution is changed in someway. +%%----------------------------------------------------------------- +is_dist_changed(Changed, New, Removed) -> + C = case lists:keyfind(distributed, 1, Changed) of + false -> + false; + {distributed, NewDistC} -> + NewDistC + end, + N = case lists:keyfind(distributed, 1, New) of + false -> + false; + {distributed, NewDistN} -> + NewDistN + end, + R = lists:member(distributed, Removed), + {C, N, R}. + +%%----------------------------------------------------------------- +%% The change of the global_groups parameter is taken care of here +%%----------------------------------------------------------------- +do_global_groups_change(Changed, New, Removed) -> + %% check if the global_groups parameter is changed. + case is_gg_changed(Changed, New, Removed) of + %%{changed, new, removed} + {false, false, false} -> + ok; + {C, false, false} -> + %% At last, update the parameter. + global_group:global_groups_changed(C); + {false, N, false} -> + global_group:global_groups_added(N); + {false, false, R} -> + global_group:global_groups_removed(R) + end. + +%%----------------------------------------------------------------- +%% Check if global_groups is changed in someway. +%%----------------------------------------------------------------- +is_gg_changed(Changed, New, Removed) -> + C = case lists:keyfind(global_groups, 1, Changed) of + false -> + false; + {global_groups, NewDistC} -> + NewDistC + end, + N = case lists:keyfind(global_groups, 1, New) of + false -> + false; + {global_groups, NewDistN} -> + NewDistN + end, + R = lists:member(global_groups, Removed), + {C, N, R}. diff --git a/lib/kernel/src/kernel_config.erl b/lib/kernel/src/kernel_config.erl new file mode 100644 index 0000000000..e5e9a0498d --- /dev/null +++ b/lib/kernel/src/kernel_config.erl @@ -0,0 +1,173 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1996-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(kernel_config). + +-behaviour(gen_server). + +%% External exports +-export([start_link/0]). +%% Internal exports +-export([init/1, handle_info/2, terminate/2, send_timeout/2]). +-export([handle_call/3, handle_cast/2, code_change/3]). + +%%%----------------------------------------------------------------- +%%% This module implements a process that configures the kernel +%%% application. +%%% Its purpose is that in the init phase add an error_logger +%%% and when it dies (when the kernel application dies) deleting the +%%% previously installed error_logger. +%%% Also, this process waits for other nodes at startup, if +%%% specified. +%%%----------------------------------------------------------------- +start_link() -> gen_server:start_link(kernel_config, [], []). + +%%----------------------------------------------------------------- +%% Callback functions from gen_server +%%----------------------------------------------------------------- +init([]) -> + process_flag(trap_exit, true), + case sync_nodes() of + ok -> + case whereis(dist_ac) of + DAC when is_pid(DAC) -> + DAC ! {go, self()}, + receive + dist_ac_took_control -> + ok + end; + _ -> + ok + end, + {ok, []}; + {error, Error} -> + {stop, Error} + end. + +handle_info(_, State) -> + {noreply, State}. + +terminate(_Reason, _State) -> + ok. + +handle_call('__not_used', _From, State) -> + {reply, ok, State}. + +handle_cast('__not_used', State) -> + {noreply, State}. + +code_change(_OldVsn, State, _Extra) -> + {ok, State}. + +%%----------------------------------------------------------------- +%% Internal functions +%%----------------------------------------------------------------- +sync_nodes() -> + case catch get_sync_data() of + {error, Reason} -> + error_logger:format("~p", [Reason]), + {error, Reason}; + {infinity, MandatoryNodes, OptionalNodes} -> + case wait_nodes(MandatoryNodes, OptionalNodes) of + ok -> +% sync(), + ok; + Error -> + Error + end; + {Timeout, MandatoryNodes, OptionalNodes} -> + spawn_link(kernel_config, send_timeout, [Timeout, self()]), + case wait_nodes(MandatoryNodes, OptionalNodes) of + ok -> +% sync(), + ok; + Error -> + Error + end; + undefined -> ok + end. + +send_timeout(Timeout, Pid) -> + receive + after Timeout -> Pid ! timeout + end. + +wait_nodes(Mandatory, Optional) -> + net_kernel:monitor_nodes(true), + lists:foreach(fun(Node) -> + case net_adm:ping(Node) of + pong -> self() ! {nodeup, Node}; + _ -> ok + end + end, + Mandatory ++ Optional), + rec_nodes(Mandatory, Optional). + +rec_nodes([], []) -> ok; +rec_nodes(Mandatory, Optional) -> + receive + {nodeup, Node} -> check_up(Node, Mandatory, Optional); + timeout when Mandatory =:= [] -> ok; + timeout -> {error, {mandatory_nodes_down, Mandatory}} + end. + +check_up(Node, Mandatory, Optional) -> + case lists:member(Node, Mandatory) of + true -> + rec_nodes(lists:delete(Node, Mandatory), Optional); + false -> + case lists:member(Node, Optional) of + true -> + rec_nodes(Mandatory, lists:delete(Node, Optional)); + false -> + rec_nodes(Mandatory, Optional) + end + end. + +%% Syncs standard servers +%sync() -> +% global:sync(). + +get_sync_data() -> + Timeout = get_sync_timeout(), + MandatoryNodes = get_sync_mandatory_nodes(), + OptionalNodes = get_sync_optional_nodes(), + {Timeout, MandatoryNodes, OptionalNodes}. + +get_sync_timeout() -> + case application:get_env(sync_nodes_timeout) of + {ok, Timeout} when is_integer(Timeout), Timeout > 0 -> Timeout; + {ok, infinity} -> infinity; + undefined -> throw(undefined); + {ok, Else} -> throw({error, {badopt, {sync_nodes_timeout, Else}}}) + end. + +get_sync_mandatory_nodes() -> + case application:get_env(sync_nodes_mandatory) of + {ok, Nodes} when is_list(Nodes) -> Nodes; + undefined -> []; + {ok, Else} -> throw({error, {badopt, {sync_nodes_mandatory, Else}}}) + end. + +get_sync_optional_nodes() -> + case application:get_env(sync_nodes_optional) of + {ok, Nodes} when is_list(Nodes) -> Nodes; + undefined -> []; + {ok, Else} -> throw({error, {badopt, {sync_nodes_optional, Else}}}) + end. + diff --git a/lib/kernel/src/net.erl b/lib/kernel/src/net.erl new file mode 100644 index 0000000000..e8f4b6ba26 --- /dev/null +++ b/lib/kernel/src/net.erl @@ -0,0 +1,39 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1996-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(net). + +%% Various network functions, kept here for compatibility + +-export([call/4, + cast/4, + broadcast/3, + ping/1, + relay/1, + sleep/1]). + +-deprecated(module). + +call(N,M,F,A) -> rpc:call(N,M,F,A). +cast(N,M,F,A) -> rpc:cast(N,M,F,A). +broadcast(M,F,A) -> rpc:eval_everywhere(M,F,A). +ping(Node) -> net_adm:ping(Node). +sleep(T) -> receive after T -> ok end. +relay(X) -> slave:relay(X). + + diff --git a/lib/kernel/src/net_address.hrl b/lib/kernel/src/net_address.hrl new file mode 100644 index 0000000000..5342076507 --- /dev/null +++ b/lib/kernel/src/net_address.hrl @@ -0,0 +1,28 @@ +%% +%% %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% +%% + +%% Generic address format + +-record(net_address, + { + address, %% opaque address + host, %% host name + protocol, %% protocol + family %% address family + }). diff --git a/lib/kernel/src/net_adm.erl b/lib/kernel/src/net_adm.erl new file mode 100644 index 0000000000..737b1ecee9 --- /dev/null +++ b/lib/kernel/src/net_adm.erl @@ -0,0 +1,239 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1996-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(net_adm). +-export([host_file/0, + localhost/0, + names/0, names/1, + ping_list/1, + world/0,world/1, + world_list/1, world_list/2, + dns_hostname/1, + ping/1]). + +%%------------------------------------------------------------------------ + +-type verbosity() :: 'silent' | 'verbose'. + +%%------------------------------------------------------------------------ + +%% Try to read .hosts.erlang file in +%% 1. cwd , 2. $HOME 3. init:root_dir() + +-spec host_file() -> [atom()] | {'error',atom() | {integer(),atom(),_}}. + +host_file() -> + Home = case init:get_argument(home) of + {ok, [[H]]} -> [H]; + _ -> [] + end, + case file:path_consult(["."] ++ Home ++ [code:root_dir()], ".hosts.erlang") of + {ok, Hosts, _} -> Hosts; + Error -> Error + end. + +%% Check whether a node is up or down +%% side effect: set up a connection to Node if there not yet is one. + +-spec ping(atom()) -> 'pang' | 'pong'. + +ping(Node) when is_atom(Node) -> + case catch gen:call({net_kernel, Node}, + '$gen_call', + {is_auth, node()}, + infinity) of + {ok, yes} -> pong; + _ -> + erlang:disconnect_node(Node), + pang + end. + +-spec localhost() -> string(). + +localhost() -> + {ok, Host} = inet:gethostname(), + case inet_db:res_option(domain) of + "" -> Host; + Domain -> Host ++ "." ++ Domain + end. + + +-spec names() -> {'ok', [{string(), integer()}]} | {'error', _}. + +names() -> + names(localhost()). + +-spec names(atom() | string()) -> {'ok', [{string(), integer()}]} | {'error', _}. + +names(Hostname) -> + case inet:gethostbyname(Hostname) of + {ok, {hostent, _Name, _ , _Af, _Size, [Addr | _]}} -> + erl_epmd:names(Addr); + Else -> + Else + end. + +-spec dns_hostname(atom() | string()) -> + {'ok', string()} | {'error', atom() | string()}. + +dns_hostname(Hostname) -> + case inet:gethostbyname(Hostname) of + {ok,{hostent, Name, _ , _Af, _Size, _Addr}} -> + {ok, Name}; + _ -> + {error, Hostname} + end. + +%% A common situation in "life" is to have a configuration file with a list +%% of nodes, and then at startup, all nodes in the list are ping'ed +%% this can lead to no end of troubles if two disconnected nodes +%% simultaneously ping each other. +%% Use this function in order to do it safely. +%% It assumes a working global.erl which ensures a fully +%% connected network. +%% Had the erlang runtime system been able to fully cope with +%% the possibility of two simultaneous (unix) connects, this function would +%% merley be lists:map({net_adm, ping}, [], Nodelist). +%% It is also assumed, that the same (identical) Nodelist is given to all +%% nodes which are to perform this call (possibly simultaneously). +%% Even this code has a flaw, and that is the case where two +%% nodes simultaneously and without *any* other already +%% running nodes execute this code. :-( + +-spec ping_list([atom()]) -> [atom()]. + +ping_list(Nodelist) -> + net_kernel:monitor_nodes(true), + Sofar = ping_first(Nodelist, nodes()), + collect_new(Sofar, Nodelist). + +ping_first([], _S) -> + []; +ping_first([Node|Nodes], S) -> + case lists:member(Node, S) of + true -> [Node | ping_first(Nodes, S)]; + false -> + case ping(Node) of + pong -> [Node]; + pang -> ping_first(Nodes, S) + end + end. + +collect_new(Sofar, Nodelist) -> + receive + {nodeup, Node} -> + case lists:member(Node, Nodelist) of + true -> + collect_new(Sofar, Nodelist); + false -> + collect_new([Node | Sofar], Nodelist) + end + after 3000 -> + net_kernel:monitor_nodes(false), + Sofar + end. + +%% This function polls a set of hosts according to a file called +%% .hosts.erlang that need to reside either in the current directory +%% or in your home directory. (The current directory is tried first.) +%% world() returns a list of all nodes on the network that can be +%% found (including ourselves). Note: the $HOME variable is inspected. +%% +%% Added possibility to supply a list of hosts instead of reading +%% the .hosts.erlang file. 971016 [email protected] +%% e.g. +%% net_adm:world_list(['elrond.du.etx.ericsson.se', 'thorin.du.etx.ericsson.se']). + +-spec world() -> [node()]. + +world() -> + world(silent). + +-spec world(verbosity()) -> [node()]. + +world(Verbose) -> + case net_adm:host_file() of + {error,R} -> exit({error, R}); + Hosts -> expand_hosts(Hosts, Verbose) + end. + +-spec world_list([atom()]) -> [node()]. + +world_list(Hosts) when is_list(Hosts) -> + expand_hosts(Hosts, silent). + +-spec world_list([atom()], verbosity()) -> [node()]. + +world_list(Hosts, Verbose) when is_list(Hosts) -> + expand_hosts(Hosts, Verbose). + +expand_hosts(Hosts, Verbose) -> + lists:flatten(collect_nodes(Hosts, Verbose)). + +collect_nodes([], _) -> []; +collect_nodes([Host|Tail], Verbose) -> + case collect_host_nodes(Host, Verbose) of + nil -> + collect_nodes(Tail, Verbose); + L -> + [L|collect_nodes(Tail, Verbose)] + end. + +collect_host_nodes(Host, Verbose) -> + case names(Host) of + {ok, Namelist} -> + do_ping(Namelist, atom_to_list(Host), Verbose); + _ -> + nil + end. + +do_ping(Names, Host0, Verbose) -> + case longshort(Host0) of + ignored -> []; + Host -> do_ping_1(Names, Host, Verbose) + end. + +do_ping_1([], _Host, _Verbose) -> + []; +do_ping_1([{Name, _} | Rest], Host, Verbose) -> + Node = list_to_atom(Name ++ "@" ++ longshort(Host)), + verbose(Verbose, "Pinging ~w -> ", [Node]), + Result = ping(Node), + verbose(Verbose, "~p\n", [Result]), + case Result of + pong -> + [Node | do_ping_1(Rest, Host, Verbose)]; + pang -> + do_ping_1(Rest, Host, Verbose) + end. + +verbose(verbose, Format, Args) -> + io:format(Format, Args); +verbose(_, _, _) -> + ok. + +longshort(Host) -> + case net_kernel:longnames() of + false -> uptodot(Host); + true -> Host; + ignored -> ignored + end. + +uptodot([$.|_]) -> []; +uptodot([])-> []; +uptodot([H|T]) -> [H|uptodot(T)]. diff --git a/lib/kernel/src/net_kernel.erl b/lib/kernel/src/net_kernel.erl new file mode 100644 index 0000000000..3afaedf274 --- /dev/null +++ b/lib/kernel/src/net_kernel.erl @@ -0,0 +1,1513 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1996-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(net_kernel). + +-behaviour(gen_server). + +-define(nodedown(N, State), verbose({?MODULE, ?LINE, nodedown, N}, 1, State)). +-define(nodeup(N, State), verbose({?MODULE, ?LINE, nodeup, N}, 1, State)). + +%%-define(dist_debug, true). + +%-define(DBG,erlang:display([?MODULE,?LINE])). + +-ifdef(dist_debug). +-define(debug(Term), erlang:display(Term)). +-else. +-define(debug(Term), ok). +-endif. + +-ifdef(DEBUG). +-define(connect_failure(Node,Term), + io:format("Net Kernel 2: Failed connection to node ~p, reason ~p~n", + [Node,Term])). +-else. +-define(connect_failure(Node,Term),noop). +-endif. + +%% Default ticktime change transition period in seconds +-define(DEFAULT_TRANSITION_PERIOD, 60). + +%-define(TCKR_DBG, 1). + +-ifdef(TCKR_DBG). +-define(tckr_dbg(X), erlang:display({?LINE, X})). +-else. +-define(tckr_dbg(X), ok). +-endif. + +%% User Interface Exports +-export([start/1, start_link/1, stop/0, + kernel_apply/3, + monitor_nodes/1, + monitor_nodes/2, + longnames/0, + allow/1, + protocol_childspecs/0, + epmd_module/0]). + +-export([connect/1, disconnect/1, hidden_connect/1, passive_cnct/1]). +-export([connect_node/1, hidden_connect_node/1]). %% explicit connect +-export([set_net_ticktime/1, set_net_ticktime/2, get_net_ticktime/0]). + +-export([node_info/1, node_info/2, nodes_info/0, + connecttime/0, + i/0, i/1, verbose/1]). + +-export([publish_on_node/1, update_publish_nodes/1]). + +%% Internal Exports +-export([do_spawn/3, + spawn_func/6, + ticker/2, + ticker_loop/2, + aux_ticker/4]). + +-export([init/1,handle_call/3,handle_cast/2,handle_info/2, + terminate/2,code_change/3]). + +-export([passive_connect_monitor/2]). + +-import(error_logger,[error_msg/2]). + +-record(state, { + name, %% The node name + node, %% The node name including hostname + type, %% long or short names + tick, %% tick information + connecttime, %% the connection setuptime. + connections, %% table of connections + conn_owners = [], %% List of connection owner pids, + pend_owners = [], %% List of potential owners + listen, %% list of #listen + allowed, %% list of allowed nodes in a restricted system + verbose = 0, %% level of verboseness + publish_on_nodes = undefined + }). + +-record(listen, { + listen, %% listen pid + accept, %% accepting pid + address, %% #net_address + module %% proto module + }). + +-define(LISTEN_ID, #listen.listen). +-define(ACCEPT_ID, #listen.accept). + +-record(connection, { + node, %% remote node name + state, %% pending | up | up_pending + owner, %% owner pid + pending_owner, %% possible new owner + address, %% #net_address + waiting = [], %% queued processes + type %% normal | hidden + }). + +-record(barred_connection, { + node %% remote node name + }). + + +-record(tick, {ticker, %% ticker : pid() + time %% Ticktime in milli seconds : integer() + }). + +-record(tick_change, {ticker, %% Ticker : pid() + time, %% Ticktime in milli seconds : integer() + how %% What type of change : atom() + }). + +%% Default connection setup timeout in milliseconds. +%% This timeout is set for every distributed action during +%% the connection setup. +-define(SETUPTIME, 7000). + +-include("net_address.hrl"). + +%% Interface functions + +kernel_apply(M,F,A) -> request({apply,M,F,A}). +allow(Nodes) -> request({allow, Nodes}). +longnames() -> request(longnames). +stop() -> erl_distribution:stop(). + +node_info(Node) -> get_node_info(Node). +node_info(Node, Key) -> get_node_info(Node, Key). +nodes_info() -> get_nodes_info(). +i() -> print_info(). +i(Node) -> print_info(Node). + +verbose(Level) when is_integer(Level) -> + request({verbose, Level}). + +set_net_ticktime(T, TP) when is_integer(T), T > 0, is_integer(TP), TP >= 0 -> + ticktime_res(request({new_ticktime, T*250, TP*1000})). +set_net_ticktime(T) when is_integer(T) -> + set_net_ticktime(T, ?DEFAULT_TRANSITION_PERIOD). +get_net_ticktime() -> + ticktime_res(request(ticktime)). + + +%% The monitor_nodes() feature has been moved into the emulator. +%% The feature is reached via (intentionally) undocumented process +%% flags (we may want to move it elsewhere later). In order to easily +%% be backward compatible, errors are created here when process_flag() +%% fails. +monitor_nodes(Flag) -> + case catch process_flag(monitor_nodes, Flag) of + true -> ok; + false -> ok; + _ -> mk_monitor_nodes_error(Flag, []) + end. + +monitor_nodes(Flag, Opts) -> + case catch process_flag({monitor_nodes, Opts}, Flag) of + true -> ok; + false -> ok; + _ -> mk_monitor_nodes_error(Flag, Opts) + end. + +%% ... +ticktime_res({A, I}) when is_atom(A), is_integer(I) -> {A, I div 250}; +ticktime_res(I) when is_integer(I) -> I div 250; +ticktime_res(A) when is_atom(A) -> A. + +%% Called though BIF's + +connect(Node) -> do_connect(Node, normal, false). +%%% Long timeout if blocked (== barred), only affects nodes with +%%% {dist_auto_connect, once} set. +passive_cnct(Node) -> do_connect(Node, normal, true). +disconnect(Node) -> request({disconnect, Node}). + +%% connect but not seen +hidden_connect(Node) -> do_connect(Node, hidden, false). + +%% Should this node publish itself on Node? +publish_on_node(Node) when is_atom(Node) -> + request({publish_on_node, Node}). + +%% Update publication list +update_publish_nodes(Ns) -> + request({update_publish_nodes, Ns}). + +%% explicit connects +connect_node(Node) when is_atom(Node) -> + request({connect, normal, Node}). +hidden_connect_node(Node) when is_atom(Node) -> + request({connect, hidden, Node}). + +do_connect(Node, Type, WaitForBarred) -> %% Type = normal | hidden + case catch ets:lookup(sys_dist, Node) of + {'EXIT', _} -> + ?connect_failure(Node,{table_missing, sys_dist}), + false; + [#barred_connection{}] -> + case WaitForBarred of + false -> + false; + true -> + Pid = spawn(?MODULE,passive_connect_monitor,[self(),Node]), + receive + {Pid, true} -> + %%io:format("Net Kernel: barred connection (~p) " + %% "connected from other end.~n",[Node]), + true; + {Pid, false} -> + ?connect_failure(Node,{barred_connection, + ets:lookup(sys_dist, Node)}), + %%io:format("Net Kernel: barred connection (~p) " + %% "- failure.~n",[Node]), + false + end + end; + Else -> + case application:get_env(kernel, dist_auto_connect) of + {ok, never} -> + ?connect_failure(Node,{dist_auto_connect,never}), + false; + % This might happen due to connection close + % not beeing propagated to user space yet. + % Save the day by just not connecting... + {ok, once} when Else =/= [], + (hd(Else))#connection.state =:= up -> + ?connect_failure(Node,{barred_connection, + ets:lookup(sys_dist, Node)}), + false; + _ -> + request({connect, Type, Node}) + end + end. + +passive_connect_monitor(Parent, Node) -> + monitor_nodes(true,[{node_type,all}]), + case lists:member(Node,nodes([connected])) of + true -> + monitor_nodes(false,[{node_type,all}]), + Parent ! {self(),true}; + _ -> + Ref = make_ref(), + Tref = erlang:send_after(connecttime(),self(),Ref), + receive + Ref -> + monitor_nodes(false,[{node_type,all}]), + Parent ! {self(), false}; + {nodeup,Node,_} -> + monitor_nodes(false,[{node_type,all}]), + erlang:cancel_timer(Tref), + Parent ! {self(),true} + end + end. + +%% If the net_kernel isn't running we ignore all requests to the +%% kernel, thus basically accepting them :-) +request(Req) -> + case whereis(net_kernel) of + P when is_pid(P) -> + gen_server:call(net_kernel,Req,infinity); + _ -> ignored + end. + +%% This function is used to dynamically start the +%% distribution. + +start(Args) -> + erl_distribution:start(Args). + +%% This is the main startup routine for net_kernel +%% The defaults are longnames and a ticktime of 15 secs to the tcp_drv. + +start_link([Name]) -> + start_link([Name, longnames]); + +start_link([Name, LongOrShortNames]) -> + start_link([Name, LongOrShortNames, 15000]); + +start_link([Name, LongOrShortNames, Ticktime]) -> + case gen_server:start_link({local, net_kernel}, net_kernel, + {Name, LongOrShortNames, Ticktime}, []) of + {ok, Pid} -> + {ok, Pid}; + {error, {already_started, Pid}} -> + {ok, Pid}; + _Error -> + exit(nodistribution) + end. + +%% auth:get_cookie should only be able to return an atom +%% tuple cookies are unknowns + +init({Name, LongOrShortNames, TickT}) -> + process_flag(trap_exit,true), + case init_node(Name, LongOrShortNames) of + {ok, Node, Listeners} -> + process_flag(priority, max), + Ticktime = to_integer(TickT), + Ticker = spawn_link(net_kernel, ticker, [self(), Ticktime]), + case auth:get_cookie(Node) of + Cookie when is_atom(Cookie) -> + {ok, #state{name = Name, + node = Node, + type = LongOrShortNames, + tick = #tick{ticker = Ticker, time = Ticktime}, + connecttime = connecttime(), + connections = + ets:new(sys_dist,[named_table, + protected, + {keypos, 2}]), + listen = Listeners, + allowed = [], + verbose = 0 + }}; + _ELSE -> + {stop, {error,{bad_cookie, Node}}} + end; + Error -> + {stop, Error} + end. + + +%% ------------------------------------------------------------ +%% handle_call. +%% ------------------------------------------------------------ + +%% +%% Set up a connection to Node. +%% The response is delayed until the connection is up and +%% running. +%% +handle_call({connect, _, Node}, _From, State) when Node =:= node() -> + {reply, true, State}; +handle_call({connect, Type, Node}, From, State) -> + verbose({connect, Type, Node}, 1, State), + case ets:lookup(sys_dist, Node) of + [Conn] when Conn#connection.state =:= up -> + {reply, true, State}; + [Conn] when Conn#connection.state =:= pending -> + Waiting = Conn#connection.waiting, + ets:insert(sys_dist, Conn#connection{waiting = [From|Waiting]}), + {noreply, State}; + [Conn] when Conn#connection.state =:= up_pending -> + Waiting = Conn#connection.waiting, + ets:insert(sys_dist, Conn#connection{waiting = [From|Waiting]}), + {noreply, State}; + _ -> + case setup(Node,Type,From,State) of + {ok, SetupPid} -> + Owners = [{SetupPid, Node} | State#state.conn_owners], + {noreply,State#state{conn_owners=Owners}}; + _ -> + ?connect_failure(Node, {setup_call, failed}), + {reply, false, State} + end + end; + +%% +%% Close the connection to Node. +%% +handle_call({disconnect, Node}, _From, State) when Node =:= node() -> + {reply, false, State}; +handle_call({disconnect, Node}, _From, State) -> + verbose({disconnect, Node}, 1, State), + {Reply, State1} = do_disconnect(Node, State), + {reply, Reply, State1}; + +%% +%% The spawn/4 BIF ends up here. +%% +handle_call({spawn,M,F,A,Gleader},{From,Tag},State) when is_pid(From) -> + do_spawn([no_link,{From,Tag},M,F,A,Gleader],[],State); + +%% +%% The spawn_link/4 BIF ends up here. +%% +handle_call({spawn_link,M,F,A,Gleader},{From,Tag},State) when is_pid(From) -> + do_spawn([link,{From,Tag},M,F,A,Gleader],[],State); + +%% +%% The spawn_opt/5 BIF ends up here. +%% +handle_call({spawn_opt,M,F,A,O,L,Gleader},{From,Tag},State) when is_pid(From) -> + do_spawn([L,{From,Tag},M,F,A,Gleader],O,State); + +%% +%% Only allow certain nodes. +%% +handle_call({allow, Nodes}, _From, State) -> + case all_atoms(Nodes) of + true -> + Allowed = State#state.allowed, + {reply,ok,State#state{allowed = Allowed ++ Nodes}}; + false -> + {reply,error,State} + end; + +%% +%% authentication, used by auth. Simply works as this: +%% if the message comes through, the other node IS authorized. +%% +handle_call({is_auth, _Node}, _From, State) -> + {reply,yes,State}; + +%% +%% Not applicable any longer !? +%% +handle_call({apply,_Mod,_Fun,_Args}, {From,Tag}, State) + when is_pid(From), node(From) =:= node() -> + gen_server:reply({From,Tag}, not_implemented), +% Port = State#state.port, +% catch apply(Mod,Fun,[Port|Args]), + {noreply,State}; + +handle_call(longnames, _From, State) -> + {reply, get(longnames), State}; + +handle_call({update_publish_nodes, Ns}, _From, State) -> + {reply, ok, State#state{publish_on_nodes = Ns}}; + +handle_call({publish_on_node, Node}, _From, State) -> + NewState = case State#state.publish_on_nodes of + undefined -> + State#state{publish_on_nodes = + global_group:publish_on_nodes()}; + _ -> + State + end, + Publish = case NewState#state.publish_on_nodes of + all -> + true; + Nodes -> + lists:member(Node, Nodes) + end, + {reply, Publish, NewState}; + + +handle_call({verbose, Level}, _From, State) -> + {reply, State#state.verbose, State#state{verbose = Level}}; + +%% +%% Set new ticktime +%% + +%% The tick field of the state contains either a #tick{} or a +%% #tick_change{} record if the ticker process has been upgraded; +%% otherwise, an integer or an atom. + +handle_call(ticktime, _, #state{tick = #tick{time = T}} = State) -> + {reply, T, State}; +handle_call(ticktime, _, #state{tick = #tick_change{time = T}} = State) -> + {reply, {ongoing_change_to, T}, State}; + +handle_call({new_ticktime,T,_TP}, _, #state{tick = #tick{time = T}} = State) -> + ?tckr_dbg(no_tick_change), + {reply, unchanged, State}; + +handle_call({new_ticktime,T,TP}, _, #state{tick = #tick{ticker = Tckr, + time = OT}} = State) -> + ?tckr_dbg(initiating_tick_change), + start_aux_ticker(T, OT, TP), + How = case T > OT of + true -> + ?tckr_dbg(longer_ticktime), + Tckr ! {new_ticktime,T}, + longer; + false -> + ?tckr_dbg(shorter_ticktime), + shorter + end, + {reply, change_initiated, State#state{tick = #tick_change{ticker = Tckr, + time = T, + how = How}}}; + +handle_call({new_ticktime,_,_}, + _, + #state{tick = #tick_change{time = T}} = State) -> + {reply, {ongoing_change_to, T}, State}. + +%% ------------------------------------------------------------ +%% handle_cast. +%% ------------------------------------------------------------ + +handle_cast(_, State) -> + {noreply,State}. + +%% ------------------------------------------------------------ +%% code_change. +%% ------------------------------------------------------------ + +code_change(_OldVsn, State, _Extra) -> + {ok,State}. + +%% ------------------------------------------------------------ +%% terminate. +%% ------------------------------------------------------------ + +terminate(no_network, State) -> + lists:foreach( + fun({Node, Type}) -> + case Type of + normal -> ?nodedown(Node, State); + _ -> ok + end + end, get_up_nodes() ++ [{node(), normal}]); +terminate(_Reason, State) -> + lists:foreach( + fun(#listen {listen = Listen,module = Mod}) -> + Mod:close(Listen) + end, State#state.listen), + lists:foreach( + fun({Node, Type}) -> + case Type of + normal -> ?nodedown(Node, State); + _ -> ok + end + end, get_up_nodes() ++ [{node(), normal}]). + + +%% ------------------------------------------------------------ +%% handle_info. +%% ------------------------------------------------------------ + +%% +%% accept a new connection. +%% +handle_info({accept,AcceptPid,Socket,Family,Proto}, State) -> + MyNode = State#state.node, + case get_proto_mod(Family,Proto,State#state.listen) of + {ok, Mod} -> + Pid = Mod:accept_connection(AcceptPid, + Socket, + MyNode, + State#state.allowed, + State#state.connecttime), + AcceptPid ! {self(), controller, Pid}, + {noreply,State}; + _ -> + AcceptPid ! {self(), unsupported_protocol}, + {noreply, State} + end; + +%% +%% A node has successfully been connected. +%% +handle_info({SetupPid, {nodeup,Node,Address,Type,Immediate}}, + State) -> + case {Immediate, ets:lookup(sys_dist, Node)} of + {true, [Conn]} when Conn#connection.state =:= pending, + Conn#connection.owner =:= SetupPid -> + ets:insert(sys_dist, Conn#connection{state = up, + address = Address, + waiting = [], + type = Type}), + SetupPid ! {self(), inserted}, + reply_waiting(Node,Conn#connection.waiting, true), + {noreply, State}; + _ -> + SetupPid ! {self(), bad_request}, + {noreply, State} + end; + +%% +%% Mark a node as pending (accept) if not busy. +%% +handle_info({AcceptPid, {accept_pending,MyNode,Node,Address,Type}}, State) -> + case ets:lookup(sys_dist, Node) of + [#connection{state=pending}=Conn] -> + if + MyNode > Node -> + AcceptPid ! {self(),{accept_pending,nok_pending}}, + {noreply,State}; + true -> + %% + %% A simultaneous connect has been detected and we want to + %% change pending process. + %% + OldOwner = Conn#connection.owner, + ?debug({net_kernel, remark, old, OldOwner, new, AcceptPid}), + exit(OldOwner, remarked), + receive + {'EXIT', OldOwner, _} -> + true + end, + Owners = lists:keyreplace(OldOwner, + 1, + State#state.conn_owners, + {AcceptPid, Node}), + ets:insert(sys_dist, Conn#connection{owner = AcceptPid}), + AcceptPid ! {self(),{accept_pending,ok_pending}}, + State1 = State#state{conn_owners=Owners}, + {noreply,State1} + end; + [#connection{state=up}=Conn] -> + AcceptPid ! {self(), {accept_pending, up_pending}}, + ets:insert(sys_dist, Conn#connection { pending_owner = AcceptPid, + state = up_pending }), + Pend = [{AcceptPid, Node} | State#state.pend_owners ], + {noreply, State#state { pend_owners = Pend }}; + [#connection{state=up_pending}] -> + AcceptPid ! {self(), {accept_pending, already_pending}}, + {noreply, State}; + _ -> + ets:insert(sys_dist, #connection{node = Node, + state = pending, + owner = AcceptPid, + address = Address, + type = Type}), + AcceptPid ! {self(),{accept_pending,ok}}, + Owners = [{AcceptPid,Node} | State#state.conn_owners], + {noreply, State#state{conn_owners = Owners}} + end; + +handle_info({SetupPid, {is_pending, Node}}, State) -> + Reply = lists:member({SetupPid,Node},State#state.conn_owners), + SetupPid ! {self(), {is_pending, Reply}}, + {noreply, State}; + + +%% +%% Handle different types of process terminations. +%% +handle_info({'EXIT', From, Reason}, State) when is_pid(From) -> + verbose({'EXIT', From, Reason}, 1, State), + handle_exit(From, Reason, State); + +%% +%% Handle badcookie and badname messages ! +%% +handle_info({From,registered_send,To,Mess},State) -> + send(From,To,Mess), + {noreply,State}; + +%% badcookies SHOULD not be sent +%% (if someone does erlang:set_cookie(node(),foo) this may be) +handle_info({From,badcookie,_To,_Mess}, State) -> + error_logger:error_msg("~n** Got OLD cookie from ~w~n", + [getnode(From)]), + {_Reply, State1} = do_disconnect(getnode(From), State), + {noreply,State1}; + +%% +%% Tick all connections. +%% +handle_info(tick, State) -> + ?tckr_dbg(tick), + lists:foreach(fun({Pid,_Node}) -> Pid ! {self(), tick} end, + State#state.conn_owners), + {noreply,State}; + +handle_info(aux_tick, State) -> + ?tckr_dbg(aux_tick), + lists:foreach(fun({Pid,_Node}) -> Pid ! {self(), aux_tick} end, + State#state.conn_owners), + {noreply,State}; + +handle_info(transition_period_end, + #state{tick = #tick_change{ticker = Tckr, + time = T, + how = How}} = State) -> + ?tckr_dbg(transition_period_ended), + case How of + shorter -> Tckr ! {new_ticktime, T}; + _ -> done + end, + {noreply,State#state{tick = #tick{ticker = Tckr, time = T}}}; + +handle_info(X, State) -> + error_msg("Net kernel got ~w~n",[X]), + {noreply,State}. + +%% ----------------------------------------------------------- +%% Handle exit signals. +%% We have 6 types of processes to handle. +%% +%% 1. The Listen process. +%% 2. The Accept process. +%% 3. Connection owning processes. +%% 4. The ticker process. +%% (5. Garbage pid.) +%% +%% The process type function that handled the process throws +%% the handle_info return value ! +%% ----------------------------------------------------------- + +handle_exit(Pid, Reason, State) -> + catch do_handle_exit(Pid, Reason, State). + +do_handle_exit(Pid, Reason, State) -> + listen_exit(Pid, State), + accept_exit(Pid, State), + conn_own_exit(Pid, Reason, State), + pending_own_exit(Pid, State), + ticker_exit(Pid, State), + {noreply,State}. + +listen_exit(Pid, State) -> + case lists:keymember(Pid, ?LISTEN_ID, State#state.listen) of + true -> + error_msg("** Netkernel terminating ... **\n", []), + throw({stop,no_network,State}); + false -> + false + end. + +accept_exit(Pid, State) -> + Listen = State#state.listen, + case lists:keysearch(Pid, ?ACCEPT_ID, Listen) of + {value, ListenR} -> + ListenS = ListenR#listen.listen, + Mod = ListenR#listen.module, + AcceptPid = Mod:accept(ListenS), + L = lists:keyreplace(Pid, ?ACCEPT_ID, Listen, + ListenR#listen{accept = AcceptPid}), + throw({noreply, State#state{listen = L}}); + _ -> + false + end. + +conn_own_exit(Pid, Reason, State) -> + Owners = State#state.conn_owners, + case lists:keysearch(Pid, 1, Owners) of + {value, {Pid, Node}} -> + throw({noreply, nodedown(Pid, Node, Reason, State)}); + _ -> + false + end. + +pending_own_exit(Pid, State) -> + Pend = State#state.pend_owners, + case lists:keysearch(Pid, 1, Pend) of + {value, {Pid, Node}} -> + NewPend = lists:keydelete(Pid, 1, Pend), + State1 = State#state { pend_owners = NewPend }, + case get_conn(Node) of + {ok, Conn} when Conn#connection.state =:= up_pending -> + reply_waiting(Node,Conn#connection.waiting, true), + Conn1 = Conn#connection { state = up, + waiting = [], + pending_owner = undefined }, + ets:insert(sys_dist, Conn1); + _ -> + ok + end, + throw({noreply, State1}); + _ -> + false + end. + +ticker_exit(Pid, #state{tick = #tick{ticker = Pid, time = T} = Tck} = State) -> + Tckr = restart_ticker(T), + throw({noreply, State#state{tick = Tck#tick{ticker = Tckr}}}); +ticker_exit(Pid, #state{tick = #tick_change{ticker = Pid, + time = T} = TckCng} = State) -> + Tckr = restart_ticker(T), + throw({noreply, State#state{tick = TckCng#tick_change{ticker = Tckr}}}); +ticker_exit(_, _) -> + false. + +%% ----------------------------------------------------------- +%% A node has gone down !! +%% nodedown(Owner, Node, Reason, State) -> State' +%% ----------------------------------------------------------- + +nodedown(Owner, Node, Reason, State) -> + case get_conn(Node) of + {ok, Conn} -> + nodedown(Conn, Owner, Node, Reason, Conn#connection.type, State); + _ -> + State + end. + +get_conn(Node) -> + case ets:lookup(sys_dist, Node) of + [Conn = #connection{}] -> {ok, Conn}; + _ -> error + end. + +nodedown(Conn, Owner, Node, Reason, Type, OldState) -> + Owners = lists:keydelete(Owner, 1, OldState#state.conn_owners), + State = OldState#state{conn_owners = Owners}, + case Conn#connection.state of + pending when Conn#connection.owner =:= Owner -> + pending_nodedown(Conn, Node, Type, State); + up when Conn#connection.owner =:= Owner -> + up_nodedown(Conn, Node, Reason, Type, State); + up_pending when Conn#connection.owner =:= Owner -> + up_pending_nodedown(Conn, Node, Reason, Type, State); + _ -> + OldState + end. + +pending_nodedown(Conn, Node, Type, State) -> + % Don't bar connections that have never been alive + %mark_sys_dist_nodedown(Node), + % - instead just delete the node: + ets:delete(sys_dist, Node), + reply_waiting(Node,Conn#connection.waiting, false), + case Type of + normal -> + ?nodedown(Node, State); + _ -> + ok + end, + State. + +up_pending_nodedown(Conn, Node, _Reason, _Type, State) -> + AcceptPid = Conn#connection.pending_owner, + Owners = State#state.conn_owners, + Pend = lists:keydelete(AcceptPid, 1, State#state.pend_owners), + Conn1 = Conn#connection { owner = AcceptPid, + pending_owner = undefined, + state = pending }, + ets:insert(sys_dist, Conn1), + AcceptPid ! {self(), pending}, + State#state{conn_owners = [{AcceptPid,Node}|Owners], pend_owners = Pend}. + + +up_nodedown(_Conn, Node, _Reason, Type, State) -> + mark_sys_dist_nodedown(Node), + case Type of + normal -> ?nodedown(Node, State); + _ -> ok + end, + State. + +mark_sys_dist_nodedown(Node) -> + case application:get_env(kernel, dist_auto_connect) of + {ok, once} -> + ets:insert(sys_dist, #barred_connection{node = Node}); + _ -> + ets:delete(sys_dist, Node) + end. + +%% ----------------------------------------------------------- +%% End handle_exit/2 !! +%% ----------------------------------------------------------- + + +%% ----------------------------------------------------------- +%% monitor_nodes/[1,2] errors +%% ----------------------------------------------------------- + +check_opt(Opt, Opts) -> + check_opt(Opt, Opts, false, []). + +check_opt(_Opt, [], false, _OtherOpts) -> + false; +check_opt(_Opt, [], {true, ORes}, OtherOpts) -> + {true, ORes, OtherOpts}; +check_opt(Opt, [Opt|RestOpts], false, OtherOpts) -> + check_opt(Opt, RestOpts, {true, Opt}, OtherOpts); +check_opt(Opt, [Opt|RestOpts], {true, Opt} = ORes, OtherOpts) -> + check_opt(Opt, RestOpts, ORes, OtherOpts); +check_opt({Opt, value}=TOpt, + [{Opt, _Val}=ORes|RestOpts], + false, + OtherOpts) -> + check_opt(TOpt, RestOpts, {true, ORes}, OtherOpts); +check_opt({Opt, value}=TOpt, + [{Opt, _Val}=ORes|RestOpts], + {true, ORes}=TORes, + OtherOpts) -> + check_opt(TOpt, RestOpts, TORes, OtherOpts); +check_opt({Opt, value}, + [{Opt, _Val} = ORes1| _RestOpts], + {true, {Opt, _OtherVal} = ORes2}, + _OtherOpts) -> + throw({error, {option_value_mismatch, [ORes1, ORes2]}}); +check_opt(Opt, [OtherOpt | RestOpts], TORes, OtherOpts) -> + check_opt(Opt, RestOpts, TORes, [OtherOpt | OtherOpts]). + +check_options(Opts) when is_list(Opts) -> + RestOpts1 = case check_opt({node_type, value}, Opts) of + {true, {node_type,Type}, RO1} when Type =:= visible; + Type =:= hidden; + Type =:= all -> + RO1; + {true, {node_type, _Type} = Opt, _RO1} -> + throw({error, {bad_option_value, Opt}}); + false -> + Opts + end, + RestOpts2 = case check_opt(nodedown_reason, RestOpts1) of + {true, nodedown_reason, RO2} -> + RO2; + false -> + RestOpts1 + end, + case RestOpts2 of + [] -> + %% This should never happen since we only call this function + %% when we know there is an error in the option list + {error, internal_error}; + _ -> + {error, {unknown_options, RestOpts2}} + end; +check_options(Opts) -> + {error, {options_not_a_list, Opts}}. + +mk_monitor_nodes_error(Flag, _Opts) when Flag =/= true, Flag =/= false -> + error; +mk_monitor_nodes_error(_Flag, Opts) -> + case catch check_options(Opts) of + {error, _} = Error -> + Error; + UnexpectedError -> + {error, {internal_error, UnexpectedError}} + end. + +% ------------------------------------------------------------- + +do_disconnect(Node, State) -> + case ets:lookup(sys_dist, Node) of + [Conn] when Conn#connection.state =:= up -> + disconnect_pid(Conn#connection.owner, State); + [Conn] when Conn#connection.state =:= up_pending -> + disconnect_pid(Conn#connection.owner, State); + _ -> + {false, State} + end. + + +disconnect_pid(Pid, State) -> + exit(Pid, disconnect), + %% Sync wait for connection to die!!! + receive + {'EXIT',Pid,Reason} -> + {_,State1} = handle_exit(Pid, Reason, State), + {true, State1} + end. + +%% +%% +%% +get_nodes(Which) -> + get_nodes(ets:first(sys_dist), Which). + +get_nodes('$end_of_table', _) -> + []; +get_nodes(Key, Which) -> + case ets:lookup(sys_dist, Key) of + [Conn = #connection{state = up}] -> + [Conn#connection.node | get_nodes(ets:next(sys_dist, Key), + Which)]; + [Conn = #connection{}] when Which =:= all -> + [Conn#connection.node | get_nodes(ets:next(sys_dist, Key), + Which)]; + _ -> + get_nodes(ets:next(sys_dist, Key), Which) + end. + +%% Return a list of all nodes that are 'up'. +get_up_nodes() -> + get_up_nodes(ets:first(sys_dist)). + +get_up_nodes('$end_of_table') -> []; +get_up_nodes(Key) -> + case ets:lookup(sys_dist, Key) of + [#connection{state=up,node=Node,type=Type}] -> + [{Node,Type}|get_up_nodes(ets:next(sys_dist, Key))]; + _ -> + get_up_nodes(ets:next(sys_dist, Key)) + end. + +ticker(Kernel, Tick) when is_integer(Tick) -> + process_flag(priority, max), + ?tckr_dbg(ticker_started), + ticker_loop(Kernel, Tick). + +to_integer(T) when is_integer(T) -> T; +to_integer(T) when is_atom(T) -> + list_to_integer(atom_to_list(T)); +to_integer(T) when is_list(T) -> + list_to_integer(T). + +ticker_loop(Kernel, Tick) -> + receive + {new_ticktime, NewTick} -> + ?tckr_dbg({ticker_changed_time, Tick, NewTick}), + ?MODULE:ticker_loop(Kernel, NewTick) + after Tick -> + Kernel ! tick, + ?MODULE:ticker_loop(Kernel, Tick) + end. + +start_aux_ticker(NewTick, OldTick, TransitionPeriod) -> + spawn_link(?MODULE, aux_ticker, + [self(), NewTick, OldTick, TransitionPeriod]). + +aux_ticker(NetKernel, NewTick, OldTick, TransitionPeriod) -> + process_flag(priority, max), + ?tckr_dbg(aux_ticker_started), + TickInterval = case NewTick > OldTick of + true -> OldTick; + false -> NewTick + end, + NoOfTicks = case TransitionPeriod > 0 of + true -> + %% 1 tick to start + %% + ticks to cover the transition period + 1 + (((TransitionPeriod - 1) div TickInterval) + 1); + false -> + 1 + end, + aux_ticker1(NetKernel, TickInterval, NoOfTicks). + +aux_ticker1(NetKernel, _, 1) -> + NetKernel ! transition_period_end, + NetKernel ! aux_tick, + bye; +aux_ticker1(NetKernel, TickInterval, NoOfTicks) -> + NetKernel ! aux_tick, + receive + after TickInterval -> + aux_ticker1(NetKernel, TickInterval, NoOfTicks-1) + end. + +send(_From,To,Mess) -> + case whereis(To) of + undefined -> + Mess; + P when is_pid(P) -> + P ! Mess + end. + +-ifdef(UNUSED). + +safesend(Name,Mess) when is_atom(Name) -> + case whereis(Name) of + undefined -> + Mess; + P when is_pid(P) -> + P ! Mess + end; +safesend(Pid, Mess) -> Pid ! Mess. + +-endif. + +do_spawn(SpawnFuncArgs, SpawnOpts, State) -> + case catch spawn_opt(?MODULE, spawn_func, SpawnFuncArgs, SpawnOpts) of + {'EXIT', {Reason,_}} -> + {reply, {'EXIT', {Reason,[]}}, State}; + {'EXIT', Reason} -> + {reply, {'EXIT', {Reason,[]}}, State}; + _ -> + {noreply,State} + end. + +%% This code is really intricate. The link will go first and then comes +%% the pid, This means that the client need not do a network link. +%% If the link message would not arrive, the runtime system shall +%% generate a nodedown message + +spawn_func(link,{From,Tag},M,F,A,Gleader) -> + link(From), + gen_server:reply({From,Tag},self()), %% ahhh + group_leader(Gleader,self()), + apply(M,F,A); +spawn_func(_,{From,Tag},M,F,A,Gleader) -> + gen_server:reply({From,Tag},self()), %% ahhh + group_leader(Gleader,self()), + apply(M,F,A). + +%% ----------------------------------------------------------- +%% Set up connection to a new node. +%% ----------------------------------------------------------- + +setup(Node,Type,From,State) -> + Allowed = State#state.allowed, + case lists:member(Node, Allowed) of + false when Allowed =/= [] -> + error_msg("** Connection attempt with " + "disallowed node ~w ** ~n", [Node]), + {error, bad_node}; + _ -> + case select_mod(Node, State#state.listen) of + {ok, L} -> + Mod = L#listen.module, + LAddr = L#listen.address, + MyNode = State#state.node, + Pid = Mod:setup(Node, + Type, + MyNode, + State#state.type, + State#state.connecttime), + Addr = LAddr#net_address { + address = undefined, + host = undefined }, + ets:insert(sys_dist, #connection{node = Node, + state = pending, + owner = Pid, + waiting = [From], + address = Addr, + type = normal}), + {ok, Pid}; + Error -> + Error + end + end. + +%% +%% Find a module that is willing to handle connection setup to Node +%% +select_mod(Node, [L|Ls]) -> + Mod = L#listen.module, + case Mod:select(Node) of + true -> {ok, L}; + false -> select_mod(Node, Ls) + end; +select_mod(Node, []) -> + {error, {unsupported_address_type, Node}}. + + +get_proto_mod(Family,Protocol,[L|Ls]) -> + A = L#listen.address, + if A#net_address.family =:= Family, + A#net_address.protocol =:= Protocol -> + {ok, L#listen.module}; + true -> + get_proto_mod(Family,Protocol,Ls) + end; +get_proto_mod(_Family, _Protocol, []) -> + error. + +%% -------- Initialisation functions ------------------------ + +init_node(Name, LongOrShortNames) -> + {NameWithoutHost,_Host} = lists:splitwith(fun($@)->false;(_)->true end, + atom_to_list(Name)), + case create_name(Name, LongOrShortNames, 1) of + {ok,Node} -> + case start_protos(list_to_atom(NameWithoutHost),Node) of + {ok, Ls} -> + {ok, Node, Ls}; + Error -> + Error + end; + Error -> + Error + end. + +%% Create the node name +create_name(Name, LongOrShortNames, Try) -> + put(longnames, case LongOrShortNames of + shortnames -> false; + longnames -> true + end), + {Head,Host1} = create_hostpart(Name, LongOrShortNames), + case Host1 of + {ok,HostPart} -> + {ok,list_to_atom(Head ++ HostPart)}; + {error,long} when Try =:= 1 -> + %% It could be we haven't read domain name from resolv file yet + inet_config:do_load_resolv(os:type(), longnames), + create_name(Name, LongOrShortNames, 0); + {error,Type} -> + error_logger:info_msg( + lists:concat(["Can\'t set ", + Type, + " node name!\n" + "Please check your configuration\n"])), + {error,badarg} + end. + +create_hostpart(Name, LongOrShortNames) -> + {Head,Host} = lists:splitwith(fun($@)->false;(_)->true end, + atom_to_list(Name)), + Host1 = case {Host,LongOrShortNames} of + {[$@,_|_],longnames} -> + {ok,Host}; + {[$@,_|_],shortnames} -> + case lists:member($.,Host) of + true -> {error,short}; + _ -> {ok,Host} + end; + {_,shortnames} -> + case inet_db:gethostname() of + H when is_list(H), length(H)>0 -> + {ok,"@" ++ H}; + _ -> + {error,short} + end; + {_,longnames} -> + case {inet_db:gethostname(),inet_db:res_option(domain)} of + {H,D} when is_list(D), is_list(H), + length(D)> 0, length(H)>0 -> + {ok,"@" ++ H ++ "." ++ D}; + _ -> + {error,long} + end + end, + {Head,Host1}. + +%% +%% +%% +protocol_childspecs() -> + case init:get_argument(proto_dist) of + {ok, [Protos]} -> + protocol_childspecs(Protos); + _ -> + protocol_childspecs(["inet_tcp"]) + end. + +protocol_childspecs([]) -> + []; +protocol_childspecs([H|T]) -> + Mod = list_to_atom(H ++ "_dist"), + case (catch Mod:childspecs()) of + {ok, Childspecs} when is_list(Childspecs) -> + Childspecs ++ protocol_childspecs(T); + _ -> + protocol_childspecs(T) + end. + + +%% +%% epmd_module() -> module_name of erl_epmd or similar gen_server_module. +%% + +epmd_module() -> + case init:get_argument(epmd_module) of + {ok,[[Module]]} -> + Module; + _ -> + erl_epmd + end. + +%% +%% Start all protocols +%% + +start_protos(Name,Node) -> + case init:get_argument(proto_dist) of + {ok, [Protos]} -> + start_protos(Name,Protos, Node); + _ -> + start_protos(Name,["inet_tcp"], Node) + end. + +start_protos(Name,Ps, Node) -> + case start_protos(Name, Ps, Node, []) of + [] -> {error, badarg}; + Ls -> {ok, Ls} + end. + +start_protos(Name, [Proto | Ps], Node, Ls) -> + Mod = list_to_atom(Proto ++ "_dist"), + case catch Mod:listen(Name) of + {ok, {Socket, Address, Creation}} -> + case set_node(Node, Creation) of + ok -> + AcceptPid = Mod:accept(Socket), + auth:sync_cookie(), + L = #listen { + listen = Socket, + address = Address, + accept = AcceptPid, + module = Mod }, + start_protos(Name,Ps, Node, [L|Ls]); + _ -> + Mod:close(Socket), + error_logger:info_msg("Invalid node name: ~p~n", [Node]), + start_protos(Name, Ps, Node, Ls) + end; + {'EXIT', {undef,_}} -> + error_logger:info_msg("Protocol: ~p: not supported~n", [Proto]), + start_protos(Name,Ps, Node, Ls); + {'EXIT', Reason} -> + error_logger:info_msg("Protocol: ~p: register error: ~p~n", + [Proto, Reason]), + start_protos(Name,Ps, Node, Ls); + {error, duplicate_name} -> + error_logger:info_msg("Protocol: ~p: the name " ++ + atom_to_list(Node) ++ + " seems to be in use by another Erlang node", + [Proto]), + start_protos(Name,Ps, Node, Ls); + {error, Reason} -> + error_logger:info_msg("Protocol: ~p: register/listen error: ~p~n", + [Proto, Reason]), + start_protos(Name,Ps, Node, Ls) + end; +start_protos(_,[], _Node, Ls) -> + Ls. + +set_node(Node, Creation) when node() =:= nonode@nohost -> + case catch erlang:setnode(Node, Creation) of + true -> + ok; + {'EXIT',Reason} -> + {error,Reason} + end; +set_node(Node, _Creation) when node() =:= Node -> + ok. + +connecttime() -> + case application:get_env(kernel, net_setuptime) of + {ok,Time} when is_number(Time), Time >= 120 -> + 120 * 1000; + {ok,Time} when is_number(Time), Time > 0 -> + round(Time * 1000); + _ -> + ?SETUPTIME + end. + +%% -------- End initialisation functions -------------------- + +%% ------------------------------------------------------------ +%% Node information. +%% ------------------------------------------------------------ + +get_node_info(Node) -> + case ets:lookup(sys_dist, Node) of + [Conn = #connection{owner = Owner, state = State}] -> + case get_status(Owner, Node, State) of + {ok, In, Out} -> + {ok, [{owner, Owner}, + {state, State}, + {address, Conn#connection.address}, + {type, Conn#connection.type}, + {in, In}, + {out, Out}]}; + _ -> + {error, bad_node} + end; + _ -> + {error, bad_node} + end. + +%% +%% We can't do monitor_node here incase the node is pending, +%% the monitor_node/2 call hangs until the connection is ready. +%% We will not ask about in/out information either for pending +%% connections as this also would block this call awhile. +%% +get_status(Owner, Node, up) -> + monitor_node(Node, true), + Owner ! {self(), get_status}, + receive + {Owner, get_status, Res} -> + monitor_node(Node, false), + Res; + {nodedown, Node} -> + error + end; +get_status(_, _, _) -> + {ok, 0, 0}. + +get_node_info(Node, Key) -> + case get_node_info(Node) of + {ok, Info} -> + case lists:keysearch(Key, 1, Info) of + {value, {Key, Value}} -> {ok, Value}; + _ -> {error, invalid_key} + end; + Error -> + Error + end. + +get_nodes_info() -> + get_nodes_info(get_nodes(all), []). + +get_nodes_info([Node|Nodes], InfoList) -> + case get_node_info(Node) of + {ok, Info} -> get_nodes_info(Nodes, [{Node, Info}|InfoList]); + _ -> get_nodes_info(Nodes, InfoList) + end; +get_nodes_info([], InfoList) -> + {ok, InfoList}. + +%% ------------------------------------------------------------ +%% Misc. functions +%% ------------------------------------------------------------ + +reply_waiting(_Node, Waiting, Rep) -> + case Rep of + false -> + ?connect_failure(_Node, {setup_process, failure}); + _ -> + ok + end, + reply_waiting1(lists:reverse(Waiting), Rep). + +reply_waiting1([From|W], Rep) -> + gen_server:reply(From, Rep), + reply_waiting1(W, Rep); +reply_waiting1([], _) -> + ok. + + +-ifdef(UNUSED). + +delete_all(From, [From |Tail]) -> delete_all(From, Tail); +delete_all(From, [H|Tail]) -> [H|delete_all(From, Tail)]; +delete_all(_, []) -> []. + +-endif. + +all_atoms([]) -> true; +all_atoms([N|Tail]) when is_atom(N) -> + all_atoms(Tail); +all_atoms(_) -> false. + +%% It is assumed that only net_kernel uses restart_ticker() +restart_ticker(Time) -> + ?tckr_dbg(restarting_ticker), + self() ! aux_tick, + spawn_link(?MODULE, ticker, [self(), Time]). + +%% ------------------------------------------------------------ +%% Print status information. +%% ------------------------------------------------------------ + +print_info() -> + nformat("Node", "State", "Type", "In", "Out", "Address"), + {ok, NodesInfo} = nodes_info(), + {In,Out} = lists:foldl(fun display_info/2, {0,0}, NodesInfo), + nformat("Total", "", "", + integer_to_list(In), integer_to_list(Out), ""). + +display_info({Node, Info}, {I,O}) -> + State = atom_to_list(fetch(state, Info)), + In = fetch(in, Info), + Out = fetch(out, Info), + Type = atom_to_list(fetch(type, Info)), + Address = fmt_address(fetch(address, Info)), + nformat(atom_to_list(Node), State, Type, + integer_to_list(In), integer_to_list(Out), Address), + {I+In,O+Out}. + +fmt_address(undefined) -> + "-"; +fmt_address(A) -> + case A#net_address.family of + inet -> + case A#net_address.address of + {IP,Port} -> + inet_parse:ntoa(IP) ++ ":" ++ integer_to_list(Port); + _ -> "-" + end; + inet6 -> + case A#net_address.address of + {IP,Port} -> + inet_parse:ntoa(IP) ++ "/" ++ integer_to_list(Port); + _ -> "-" + end; + _ -> + lists:flatten(io_lib:format("~p", [A#net_address.address])) + end. + + +fetch(Key, Info) -> + case lists:keysearch(Key, 1, Info) of + {value, {_, Val}} -> Val; + false -> 0 + end. + +nformat(A1, A2, A3, A4, A5, A6) -> + io:format("~-20s ~-7s ~-6s ~8s ~8s ~s~n", [A1,A2,A3,A4,A5,A6]). + +print_info(Node) -> + case node_info(Node) of + {ok, Info} -> + State = fetch(state, Info), + In = fetch(in, Info), + Out = fetch(out, Info), + Type = fetch(type, Info), + Address = fmt_address(fetch(address, Info)), + io:format("Node = ~p~n" + "State = ~p~n" + "Type = ~p~n" + "In = ~p~n" + "Out = ~p~n" + "Address = ~s~n", + [Node, State, Type, In, Out, Address]); + Error -> + Error + end. + +verbose(Term, Level, #state{verbose = Verbose}) when Verbose >= Level -> + error_logger:info_report({net_kernel, Term}); +verbose(_, _, _) -> + ok. + +getnode(P) when is_pid(P) -> node(P); +getnode(P) -> P. diff --git a/lib/kernel/src/os.erl b/lib/kernel/src/os.erl new file mode 100644 index 0000000000..196e6cdeb2 --- /dev/null +++ b/lib/kernel/src/os.erl @@ -0,0 +1,291 @@ +%% +%% %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(os). + +%% Provides a common operating system interface. + +-export([type/0, version/0, cmd/1, find_executable/1, find_executable/2]). + +-include("file.hrl"). + +-spec type() -> 'vxworks' | {'unix',atom()} | {'win32',atom()} | {'ose',atom()}. +type() -> + case erlang:system_info(os_type) of + {vxworks, _} -> + vxworks; + Else -> Else + end. + +-spec version() -> string() | {non_neg_integer(),non_neg_integer(),non_neg_integer()}. +version() -> + erlang:system_info(os_version). + +-spec find_executable(string()) -> string() | 'false'. +find_executable(Name) -> + case os:getenv("PATH") of + false -> find_executable(Name, []); + Path -> find_executable(Name, Path) + end. + +-spec find_executable(string(), string()) -> string() | 'false'. +find_executable(Name, Path) -> + Extensions = extensions(), + case filename:pathtype(Name) of + relative -> + find_executable1(Name, split_path(Path), Extensions); + _ -> + case verify_executable(Name, Extensions) of + {ok, Complete} -> + Complete; + error -> + false + end + end. + +find_executable1(Name, [Base|Rest], Extensions) -> + Complete0 = filename:join(Base, Name), + case verify_executable(Complete0, Extensions) of + {ok, Complete} -> + Complete; + error -> + find_executable1(Name, Rest, Extensions) + end; +find_executable1(_Name, [], _Extensions) -> + false. + +verify_executable(Name0, [Ext|Rest]) -> + Name1 = Name0 ++ Ext, + case os:type() of + vxworks -> + %% We consider all existing VxWorks files to be executable + case file:read_file_info(Name1) of + {ok, _} -> + {ok, Name1}; + _ -> + verify_executable(Name0, Rest) + end; + _ -> + case file:read_file_info(Name1) of + {ok, #file_info{mode=Mode}} when Mode band 8#111 =/= 0 -> + %% XXX This test for execution permission is not full-proof + %% on Unix, since we test if any execution bit is set. + {ok, Name1}; + _ -> + verify_executable(Name0, Rest) + end + end; +verify_executable(_, []) -> + error. + +split_path(Path) -> + case type() of + {win32, _} -> + {ok,Curr} = file:get_cwd(), + split_path(Path, $;, [], [Curr]); + _ -> + split_path(Path, $:, [], []) + end. + +split_path([Sep|Rest], Sep, Current, Path) -> + split_path(Rest, Sep, [], [reverse_element(Current)|Path]); +split_path([C|Rest], Sep, Current, Path) -> + split_path(Rest, Sep, [C|Current], Path); +split_path([], _, Current, Path) -> + lists:reverse(Path, [reverse_element(Current)]). + +reverse_element([]) -> "."; +reverse_element([$"|T]) -> %" + case lists:reverse(T) of + [$"|List] -> List; %" + List -> List ++ [$"] %" + end; +reverse_element(List) -> + lists:reverse(List). + +-spec extensions() -> [string()]. +extensions() -> + case type() of + {win32, _} -> [".exe",".com",".cmd",".bat"]; + {unix, _} -> [""]; + vxworks -> [""] + end. + +%% Executes the given command in the default shell for the operating system. +-spec cmd(atom() | string() | [string()]) -> string(). +cmd(Cmd) -> + validate(Cmd), + case type() of + {unix, _} -> + unix_cmd(Cmd); + {win32, Wtype} -> + Command = case {os:getenv("COMSPEC"),Wtype} of + {false,windows} -> lists:concat(["command.com /c", Cmd]); + {false,_} -> lists:concat(["cmd /c", Cmd]); + {Cspec,_} -> lists:concat([Cspec," /c",Cmd]) + end, + Port = open_port({spawn, Command}, [stream, in, eof, hide]), + get_data(Port, []); + %% VxWorks uses a 'sh -c hook' in 'vxcall.c' to run os:cmd. + vxworks -> + Command = lists:concat(["sh -c '", Cmd, "'"]), + Port = open_port({spawn, Command}, [stream, in, eof]), + get_data(Port, []) + end. + +unix_cmd(Cmd) -> + Tag = make_ref(), + {Pid,Mref} = erlang:spawn_monitor( + fun() -> + process_flag(trap_exit, true), + Port = start_port(), + erlang:port_command(Port, mk_cmd(Cmd)), + exit({Tag,unix_get_data(Port)}) + end), + receive + {'DOWN',Mref,_,Pid,{Tag,Result}} -> + Result; + {'DOWN',Mref,_,Pid,Reason} -> + exit(Reason) + end. + +%% The -s flag implies that only the positional parameters are set, +%% and the commands are read from standard input. We set the +%% $1 parameter for easy identification of the resident shell. +%% +-define(SHELL, "/bin/sh -s unix:cmd 2>&1"). + +%% +%% Serializing open_port through a process to avoid smp lock contention +%% when many concurrent os:cmd() want to do vfork (OTP-7890). +%% +-spec start_port() -> port(). +start_port() -> + {Ref,Client} = {make_ref(),self()}, + try (os_cmd_port_creator ! {Ref,Client}) + catch + error:_ -> spawn(fun() -> start_port_srv({Ref,Client}) end) + end, + receive + {Ref,Port} when is_port(Port) -> Port; + {Ref,Error} -> exit(Error) + end. + +start_port_srv(Request) -> + StayAlive = try register(os_cmd_port_creator, self()) + catch + error:_ -> false + end, + start_port_srv_loop(Request, StayAlive). + +start_port_srv_loop({Ref,Client}, StayAlive) -> + Reply = try open_port({spawn, ?SHELL},[stream]) of + Port when is_port(Port) -> + port_connect(Port, Client), + unlink(Port), + Port + catch + error:Reason -> + {Reason,erlang:get_stacktrace()} + end, + Client ! {Ref,Reply}, + case StayAlive of + true -> start_port_srv_loop(receive Msg -> Msg end, true); + false -> exiting + end. + +%% +%% unix_get_data(Port) -> Result +%% +unix_get_data(Port) -> + unix_get_data(Port, []). + +unix_get_data(Port, Sofar) -> + receive + {Port,{data, Bytes}} -> + case eot(Bytes) of + {done, Last} -> + lists:flatten([Sofar|Last]); + more -> + unix_get_data(Port, [Sofar|Bytes]) + end; + {'EXIT', Port, _} -> + lists:flatten(Sofar) + end. + +%% +%% eot(String) -> more | {done, Result} +%% +eot(Bs) -> + eot(Bs, []). + +eot([4| _Bs], As) -> + {done, lists:reverse(As)}; +eot([B| Bs], As) -> + eot(Bs, [B| As]); +eot([], _As) -> + more. + +%% +%% mk_cmd(Cmd) -> {ok, ShellCommandString} | {error, ErrorString} +%% +%% We do not allow any input to Cmd (hence commands that want +%% to read from standard input will return immediately). +%% Standard error is redirected to standard output. +%% +%% We use ^D (= EOT = 4) to mark the end of the stream. +%% +mk_cmd(Cmd) when is_atom(Cmd) -> % backward comp. + mk_cmd(atom_to_list(Cmd)); +mk_cmd(Cmd) -> + %% We insert a new line after the command, in case the command + %% contains a comment character. + io_lib:format("(~s\n) </dev/null; echo \"\^D\"\n", [Cmd]). + + +validate(Atom) when is_atom(Atom) -> + ok; +validate(List) when is_list(List) -> + validate1(List). + +validate1([C|Rest]) when is_integer(C), 0 =< C, C < 256 -> + validate1(Rest); +validate1([List|Rest]) when is_list(List) -> + validate1(List), + validate1(Rest); +validate1([]) -> + ok. + +get_data(Port, Sofar) -> + receive + {Port, {data, Bytes}} -> + get_data(Port, [Sofar|Bytes]); + {Port, eof} -> + Port ! {self(), close}, + receive + {Port, closed} -> + true + end, + receive + {'EXIT', Port, _} -> + ok + after 1 -> % force context switch + ok + end, + lists:flatten(Sofar) + end. diff --git a/lib/kernel/src/packages.erl b/lib/kernel/src/packages.erl new file mode 100644 index 0000000000..e0b1f36b85 --- /dev/null +++ b/lib/kernel/src/packages.erl @@ -0,0 +1,158 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2002-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(packages). + +-export([to_string/1, concat/1, concat/2, is_valid/1, is_segmented/1, + split/1, last/1, first/1, strip_last/1, find_modules/1, + find_modules/2]). + +%% A package name (or a package-qualified module name) may be an atom or +%% a string (list of nonnegative integers) - not a deep list, and not a +%% list containing atoms. A name may be empty, but may not contain two +%% consecutive period (`.') characters or end with a period character. + +-type package_name() :: atom() | string(). + +-spec to_string(package_name()) -> string(). +to_string(Name) when is_atom(Name) -> + atom_to_list(Name); +to_string(Name) -> + Name. + +%% `concat' does not insert a leading period if the first segment is +%% empty. However, the result may contain leading, consecutive or +%% dangling period characters, if any of the segments after the first +%% are empty. Use 'is_valid' to check the result if necessary. + +-spec concat(package_name(), package_name()) -> string(). +concat(A, B) -> + concat([A, B]). + +-spec concat([package_name()]) -> string(). +concat([H | T]) when is_atom(H) -> + concat([atom_to_list(H) | T]); +concat(["" | T]) -> + concat_1(T); +concat(L) -> + concat_1(L). + +concat_1([H | T]) when is_atom(H) -> + concat_1([atom_to_list(H) | T]); +concat_1([H]) -> + H; +concat_1([H | T]) -> + H ++ "." ++ concat_1(T); +concat_1([]) -> + ""; +concat_1(Name) -> + erlang:error({badarg, Name}). + +-spec is_valid(package_name()) -> boolean(). +is_valid(Name) when is_atom(Name) -> + is_valid_1(atom_to_list(Name)); +is_valid([$. | _]) -> + false; +is_valid(Name) -> + is_valid_1(Name). + +is_valid_1([$.]) -> false; +is_valid_1([$., $. | _]) -> false; +is_valid_1([H | T]) when is_integer(H), H >= 0 -> + is_valid_1(T); +is_valid_1([]) -> true; +is_valid_1(_) -> false. + +-spec split(package_name()) -> [string()]. +split(Name) when is_atom(Name) -> + split_1(atom_to_list(Name), []); +split(Name) -> + split_1(Name, []). + +split_1([$. | T], Cs) -> + [lists:reverse(Cs) | split_1(T, [])]; +split_1([H | T], Cs) when is_integer(H), H >= 0 -> + split_1(T, [H | Cs]); +split_1([], Cs) -> + [lists:reverse(Cs)]; +split_1(_, _) -> + erlang:error(badarg). + +%% This is equivalent to testing if `split(Name)' yields a list of +%% length larger than one (i.e., if the name can be split into two or +%% more segments), but is cheaper. + +-spec is_segmented(package_name()) -> boolean(). +is_segmented(Name) when is_atom(Name) -> + is_segmented_1(atom_to_list(Name)); +is_segmented(Name) -> + is_segmented_1(Name). + +is_segmented_1([$. | _]) -> true; +is_segmented_1([H | T]) when is_integer(H), H >= 0 -> + is_segmented_1(T); +is_segmented_1([]) -> false; +is_segmented_1(_) -> + erlang:error(badarg). + +-spec last(package_name()) -> string(). +last(Name) -> + last_1(split(Name)). + +last_1([H]) -> H; +last_1([_ | T]) -> last_1(T). + +-spec first(package_name()) -> [string()]. +first(Name) -> + first_1(split(Name)). + +first_1([H | T]) when T =/= [] -> [H | first_1(T)]; +first_1(_) -> []. + +-spec strip_last(package_name()) -> string(). +strip_last(Name) -> + concat(first(Name)). + +%% This finds all modules available for a given package, using the +%% current code server search path. (There is no guarantee that the +%% modules are loadable; only that the object files exist.) + +-spec find_modules(package_name()) -> [string()]. +find_modules(P) -> + find_modules(P, code:get_path()). + +-spec find_modules(package_name(), [string()]) -> [string()]. +find_modules(P, Paths) -> + P1 = filename:join(packages:split(P)), + find_modules(P1, Paths, code:objfile_extension(), sets:new()). + +find_modules(P, [Path | Paths], Ext, S0) -> + case file:list_dir(filename:join(Path, P)) of + {ok, Fs} -> + Fs1 = [F || F <- Fs, filename:extension(F) =:= Ext], + S1 = lists:foldl(fun (F, S) -> + F1 = filename:rootname(F, Ext), + sets:add_element(F1, S) + end, + S0, Fs1), + find_modules(P, Paths, Ext, S1); + _ -> + find_modules(P, Paths, Ext, S0) + end; +find_modules(_P, [], _Ext, S) -> + sets:to_list(S). diff --git a/lib/kernel/src/pg2.erl b/lib/kernel/src/pg2.erl new file mode 100644 index 0000000000..fc9508a194 --- /dev/null +++ b/lib/kernel/src/pg2.erl @@ -0,0 +1,376 @@ +%% +%% %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(pg2). + +-export([create/1, delete/1, join/2, leave/2]). +-export([get_members/1, get_local_members/1]). +-export([get_closest_pid/1, which_groups/0]). +-export([start/0,start_link/0,init/1,handle_call/3,handle_cast/2,handle_info/2, + terminate/2]). + +%%% As of R13B03 monitors are used instead of links. + +%%% +%%% Exported functions +%%% + +-spec start_link() -> {'ok', pid()} | {'error', term()}. + +start_link() -> + gen_server:start_link({local, ?MODULE}, ?MODULE, [], []). + +-spec start() -> {'ok', pid()} | {'error', term()}. + +start() -> + ensure_started(). + +-spec create(term()) -> 'ok'. + +create(Name) -> + ensure_started(), + case ets:member(pg2_table, {group, Name}) of + false -> + global:trans({{?MODULE, Name}, self()}, + fun() -> + gen_server:multi_call(?MODULE, {create, Name}) + end), + ok; + true -> + ok + end. + +-type name() :: term(). + +-spec delete(name()) -> 'ok'. + +delete(Name) -> + ensure_started(), + global:trans({{?MODULE, Name}, self()}, + fun() -> + gen_server:multi_call(?MODULE, {delete, Name}) + end), + ok. + +-spec join(name(), pid()) -> 'ok' | {'error', {'no_such_group', term()}}. + +join(Name, Pid) when is_pid(Pid) -> + ensure_started(), + case ets:member(pg2_table, {group, Name}) of + false -> + {error, {no_such_group, Name}}; + true -> + global:trans({{?MODULE, Name}, self()}, + fun() -> + gen_server:multi_call(?MODULE, + {join, Name, Pid}) + end), + ok + end. + +-spec leave(name(), pid()) -> 'ok' | {'error', {'no_such_group', name()}}. + +leave(Name, Pid) when is_pid(Pid) -> + ensure_started(), + case ets:member(pg2_table, {group, Name}) of + false -> + {error, {no_such_group, Name}}; + true -> + global:trans({{?MODULE, Name}, self()}, + fun() -> + gen_server:multi_call(?MODULE, + {leave, Name, Pid}) + end), + ok + end. + +-type get_members_ret() :: [pid()] | {'error', {'no_such_group', name()}}. + +-spec get_members(name()) -> get_members_ret(). + +get_members(Name) -> + ensure_started(), + case ets:member(pg2_table, {group, Name}) of + true -> + group_members(Name); + false -> + {error, {no_such_group, Name}} + end. + +-spec get_local_members(name()) -> get_members_ret(). + +get_local_members(Name) -> + ensure_started(), + case ets:member(pg2_table, {group, Name}) of + true -> + local_group_members(Name); + false -> + {error, {no_such_group, Name}} + end. + +-spec which_groups() -> [name()]. + +which_groups() -> + ensure_started(), + all_groups(). + +-type gcp_error_reason() :: {'no_process', term()} | {'no_such_group', term()}. + +-spec get_closest_pid(term()) -> pid() | {'error', gcp_error_reason()}. + +get_closest_pid(Name) -> + case get_local_members(Name) of + [Pid] -> + Pid; + [] -> + {_,_,X} = erlang:now(), + case get_members(Name) of + [] -> {error, {no_process, Name}}; + Members -> + lists:nth((X rem length(Members))+1, Members) + end; + Members when is_list(Members) -> + {_,_,X} = erlang:now(), + lists:nth((X rem length(Members))+1, Members); + Else -> + Else + end. + +%%% +%%% Callback functions from gen_server +%%% + +-record(state, {}). + +-spec init([]) -> {'ok', #state{}}. + +init([]) -> + Ns = nodes(), + net_kernel:monitor_nodes(true), + lists:foreach(fun(N) -> + {?MODULE, N} ! {new_pg2, node()}, + self() ! {nodeup, N} + end, Ns), + pg2_table = ets:new(pg2_table, [ordered_set, protected, named_table]), + {ok, #state{}}. + +-type call() :: {'create', name()} + | {'delete', name()} + | {'join', name(), pid()} + | {'leave', name(), pid()}. + +-spec handle_call(call(), _, #state{}) -> + {'reply', 'ok', #state{}}. + +handle_call({create, Name}, _From, S) -> + assure_group(Name), + {reply, ok, S}; +handle_call({join, Name, Pid}, _From, S) -> + ets:member(pg2_table, {group, Name}) andalso join_group(Name, Pid), + {reply, ok, S}; +handle_call({leave, Name, Pid}, _From, S) -> + ets:member(pg2_table, {group, Name}) andalso leave_group(Name, Pid), + {reply, ok, S}; +handle_call({delete, Name}, _From, S) -> + delete_group(Name), + {reply, ok, S}; +handle_call(Request, From, S) -> + error_logger:warning_msg("The pg2 server received an unexpected message:\n" + "handle_call(~p, ~p, _)\n", + [Request, From]), + {noreply, S}. + +-type all_members() :: [[name(),...]]. +-type cast() :: {'exchange', node(), all_members()} + | {'del_member', name(), pid()}. + +-spec handle_cast(cast(), #state{}) -> {'noreply', #state{}}. + +handle_cast({exchange, _Node, List}, S) -> + store(List), + {noreply, S}; +handle_cast(_, S) -> + %% Ignore {del_member, Name, Pid}. + {noreply, S}. + +-spec handle_info(tuple(), #state{}) -> {'noreply', #state{}}. + +handle_info({'DOWN', MonitorRef, process, _Pid, _Info}, S) -> + member_died(MonitorRef), + {noreply, S}; +handle_info({nodeup, Node}, S) -> + gen_server:cast({?MODULE, Node}, {exchange, node(), all_members()}), + {noreply, S}; +handle_info({new_pg2, Node}, S) -> + gen_server:cast({?MODULE, Node}, {exchange, node(), all_members()}), + {noreply, S}; +handle_info(_, S) -> + {noreply, S}. + +-spec terminate(term(), #state{}) -> 'ok'. + +terminate(_Reason, _S) -> + true = ets:delete(pg2_table), + ok. + +%%% +%%% Local functions +%%% + +%%% One ETS table, pg2_table, is used for bookkeeping. The type of the +%%% table is ordered_set, and the fast matching of partially +%%% instantiated keys is used extensively. +%%% +%%% {{group, Name}} +%%% Process group Name. +%%% {{ref, Pid}, RPid, MonitorRef, Counter} +%%% {{ref, MonitorRef}, Pid} +%%% Each process has one monitor. Sometimes a process is spawned to +%%% monitor the pid (RPid). Counter is incremented when the Pid joins +%%% some group. +%%% {{member, Name, Pid}, GroupCounter} +%%% {{local_member, Name, Pid}} +%%% Pid is a member of group Name, GroupCounter is incremented when the +%%% Pid joins the group Name. +%%% {{pid, Pid, Name}} +%%% Pid is a member of group Name. + +store(List) -> + _ = [assure_group(Name) andalso [join_group(Name, P) || P <- Members] || + [Name, Members] <- List], + ok. + +assure_group(Name) -> + Key = {group, Name}, + ets:member(pg2_table, Key) orelse true =:= ets:insert(pg2_table, {Key}). + +delete_group(Name) -> + _ = [leave_group(Name, Pid) || Pid <- group_members(Name)], + true = ets:delete(pg2_table, {group, Name}), + ok. + +member_died(Ref) -> + [{{ref, Ref}, Pid}] = ets:lookup(pg2_table, {ref, Ref}), + Names = member_groups(Pid), + _ = [leave_group(Name, P) || + Name <- Names, + P <- member_in_group(Pid, Name)], + %% Kept for backward compatibility with links. Can be removed, eventually. + _ = [gen_server:abcast(nodes(), ?MODULE, {del_member, Name, Pid}) || + Name <- Names], + ok. + +join_group(Name, Pid) -> + Ref_Pid = {ref, Pid}, + try _ = ets:update_counter(pg2_table, Ref_Pid, {4, +1}) + catch _:_ -> + {RPid, Ref} = do_monitor(Pid), + true = ets:insert(pg2_table, {Ref_Pid, RPid, Ref, 1}), + true = ets:insert(pg2_table, {{ref, Ref}, Pid}) + end, + Member_Name_Pid = {member, Name, Pid}, + try _ = ets:update_counter(pg2_table, Member_Name_Pid, {2, +1}) + catch _:_ -> + true = ets:insert(pg2_table, {Member_Name_Pid, 1}), + _ = [ets:insert(pg2_table, {{local_member, Name, Pid}}) || + node(Pid) =:= node()], + true = ets:insert(pg2_table, {{pid, Pid, Name}}) + end. + +leave_group(Name, Pid) -> + Member_Name_Pid = {member, Name, Pid}, + try ets:update_counter(pg2_table, Member_Name_Pid, {2, -1}) of + N -> + if + N =:= 0 -> + true = ets:delete(pg2_table, {pid, Pid, Name}), + _ = [ets:delete(pg2_table, {local_member, Name, Pid}) || + node(Pid) =:= node()], + true = ets:delete(pg2_table, Member_Name_Pid); + true -> + ok + end, + Ref_Pid = {ref, Pid}, + case ets:update_counter(pg2_table, Ref_Pid, {4, -1}) of + 0 -> + [{Ref_Pid,RPid,Ref,0}] = ets:lookup(pg2_table, Ref_Pid), + true = ets:delete(pg2_table, {ref, Ref}), + true = ets:delete(pg2_table, Ref_Pid), + true = erlang:demonitor(Ref, [flush]), + kill_monitor_proc(RPid, Pid); + _ -> + ok + end + catch _:_ -> + ok + end. + +all_members() -> + [[G, group_members(G)] || G <- all_groups()]. + +group_members(Name) -> + [P || + [P, N] <- ets:match(pg2_table, {{member, Name, '$1'},'$2'}), + _ <- lists:seq(1, N)]. + +local_group_members(Name) -> + [P || + [Pid] <- ets:match(pg2_table, {{local_member, Name, '$1'}}), + P <- member_in_group(Pid, Name)]. + +member_in_group(Pid, Name) -> + [{{member, Name, Pid}, N}] = ets:lookup(pg2_table, {member, Name, Pid}), + lists:duplicate(N, Pid). + +member_groups(Pid) -> + [Name || [Name] <- ets:match(pg2_table, {{pid, Pid, '$1'}})]. + +all_groups() -> + [N || [N] <- ets:match(pg2_table, {{group,'$1'}})]. + +ensure_started() -> + case whereis(?MODULE) of + undefined -> + C = {pg2, {?MODULE, start_link, []}, permanent, + 1000, worker, [?MODULE]}, + supervisor:start_child(kernel_safe_sup, C); + Pg2Pid -> + {ok, Pg2Pid} + end. + + +kill_monitor_proc(RPid, Pid) -> + RPid =:= Pid orelse exit(RPid, kill). + +%% When/if erlang:monitor() returns before trying to connect to the +%% other node this function can be removed. +do_monitor(Pid) -> + case (node(Pid) =:= node()) orelse lists:member(node(Pid), nodes()) of + true -> + %% Assume the node is still up + {Pid, erlang:monitor(process, Pid)}; + false -> + F = fun() -> + Ref = erlang:monitor(process, Pid), + receive + {'DOWN', Ref, process, Pid, _Info} -> + exit(normal) + end + end, + erlang:spawn_monitor(F) + end. diff --git a/lib/kernel/src/ram_file.erl b/lib/kernel/src/ram_file.erl new file mode 100644 index 0000000000..d996650948 --- /dev/null +++ b/lib/kernel/src/ram_file.erl @@ -0,0 +1,492 @@ +%% +%% %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(ram_file). + +%% Binary RAM file interface + +%% Generic file contents operations +-export([open/2, close/1]). +-export([write/2, read/2, copy/3, + pread/2, pread/3, pwrite/2, pwrite/3, + position/2, truncate/1, sync/1]). + +%% Specialized file operations +-export([get_size/1, get_file/1, set_file/2, get_file_close/1]). +-export([compress/1, uncompress/1, uuencode/1, uudecode/1]). + +-export([open_mode/1]). %% used by ftp-file + +-export([ipread_s32bu_p32bu/3]). + + + +%% Includes and defines + +-define(RAM_FILE_DRV, "ram_file_drv"). +-define(MAX_I32, (1 bsl 31)). +-define(G_I32(X), is_integer(X), X >= -?MAX_I32, X < ?MAX_I32). + +-include("file.hrl"). + + + +%% -------------------------------------------------------------------------- +%% These operation codes were once identical between efile_drv.c +%% and ram_file_drv.c, but now these drivers are not depeding on each other. +%% So, the codes could be changed to more logical values now, but why indeed? + +%% Defined "file" functions +-define(RAM_FILE_OPEN, 1). +-define(RAM_FILE_READ, 2). +-define(RAM_FILE_LSEEK, 3). +-define(RAM_FILE_WRITE, 4). +-define(RAM_FILE_FSYNC, 9). +-define(RAM_FILE_TRUNCATE, 14). +-define(RAM_FILE_PREAD, 17). +-define(RAM_FILE_PWRITE, 18). + +%% Other operations +-define(RAM_FILE_GET, 30). +-define(RAM_FILE_SET, 31). +-define(RAM_FILE_GET_CLOSE, 32). +-define(RAM_FILE_COMPRESS, 33). +-define(RAM_FILE_UNCOMPRESS, 34). +-define(RAM_FILE_UUENCODE, 35). +-define(RAM_FILE_UUDECODE, 36). +-define(RAM_FILE_SIZE, 37). + +%% Open modes for RAM_FILE_OPEN +-define(RAM_FILE_MODE_READ, 1). +-define(RAM_FILE_MODE_WRITE, 2). +-define(RAM_FILE_MODE_READ_WRITE, 3). +%% Use this mask to get just the mode bits to be passed to the driver. +-define(RAM_FILE_MODE_MASK, 3). + +%% Seek modes for RAM_FILE_LSEEK +-define(RAM_FILE_SEEK_SET, 0). +-define(RAM_FILE_SEEK_CUR, 1). +-define(RAM_FILE_SEEK_END, 2). + +%% Return codes +-define(RAM_FILE_RESP_OK, 0). +-define(RAM_FILE_RESP_ERROR, 1). +-define(RAM_FILE_RESP_DATA, 2). +-define(RAM_FILE_RESP_NUMBER, 3). +-define(RAM_FILE_RESP_INFO, 4). + +%% -------------------------------------------------------------------------- +%% Generic file contents operations. +%% +%% Supposed to be called by applications through module file. + +open(Data, ModeList) when is_list(ModeList) -> + case open_mode(ModeList) of + {Mode,Opts} when is_integer(Mode) -> + case ll_open(Data, Mode, Opts) of + {ok,Port} -> + {ok,#file_descriptor{module=?MODULE, data=Port}}; + Error -> + Error + end; + {error,_}=Error -> + Error + end; +%% Old obsolete mode specification +open(Data, Mode) -> + case mode_list(Mode) of + ModeList when is_list(ModeList) -> + open(Data, ModeList); + Error -> + Error + end. + +close(#file_descriptor{module = ?MODULE, data = Port}) -> + ll_close(Port). + +read(#file_descriptor{module = ?MODULE, data = Port}, Sz) + when is_integer(Sz), Sz >= 0 -> + if + ?G_I32(Sz) -> + Cmd = <<?RAM_FILE_READ:8,Sz:32>>, + case call_port(Port, Cmd) of + {ok, {0, _Data}} when Sz =/= 0 -> + eof; + {ok, {_Sz, Data}} -> + {ok, Data}; + {error, enomem} -> + %% Garbage collecting here might help if + %% the current processes has some old binaries left. + erlang:garbage_collect(), + case call_port(Port, Cmd) of + {ok, {0, _Data}} when Sz =/= 0 -> + eof; + {ok, {_Sz, Data}} -> + {ok, Data}; + Error -> + Error + end; + Error -> + Error + end; + true -> + {error, einval} + end. + +write(#file_descriptor{module = ?MODULE, data = Port}, Bytes) -> + case call_port(Port, [?RAM_FILE_WRITE | Bytes]) of + {ok, _Sz} -> + ok; + Error -> + Error + end. + + + + +copy(#file_descriptor{module = ?MODULE} = Source, + #file_descriptor{module = ?MODULE} = Dest, + Length) + when is_integer(Length), Length >= 0; + is_atom(Length) -> + %% XXX Should be moved down to the driver for optimization. + file:copy_opened(Source, Dest, Length). + + +sync(#file_descriptor{module = ?MODULE, data = Port}) -> + call_port(Port, <<?RAM_FILE_FSYNC>>). + +truncate(#file_descriptor{module = ?MODULE, data = Port}) -> + call_port(Port, <<?RAM_FILE_TRUNCATE>>). + +position(#file_descriptor{module = ?MODULE, data = Port}, Pos) -> + case lseek_position(Pos) of + {ok, Offs, Whence} when ?G_I32(Offs) -> + call_port(Port, <<?RAM_FILE_LSEEK:8,Offs:32,Whence:32>>); + {ok, _, _} -> + {error, einval}; + Error -> + Error + end. + + + +pread(#file_descriptor{module = ?MODULE, data = Port}, L) when is_list(L) -> + pread_1(Port, L, []). + +pread_1(Port, [], Cs) -> + pread_2(Port, lists:reverse(Cs), []); +pread_1(Port, [{At, Sz} | T], Cs) + when is_integer(At), is_integer(Sz), Sz >= 0 -> + if + ?G_I32(At), ?G_I32(Sz) -> + pread_1(Port, T, [{Sz,<<?RAM_FILE_PREAD:8,At:32,Sz:32>>}|Cs]); + true -> + {error, einval} + end; +pread_1(_, _, _243) -> + {error, badarg}. + +pread_2(_Port, [], R) -> + {ok, lists:reverse(R)}; +pread_2(Port, [{Sz,Command}|Commands], R) -> + case call_port(Port, Command) of + {ok, {0,_Data}} when Sz =/= 0 -> + pread_2(Port, Commands, [eof | R]); + {ok, {_Sz,Data}} -> + pread_2(Port, Commands, [Data | R]); + Error -> + Error + end. + +pread(#file_descriptor{module = ?MODULE, data = Port}, At, Sz) + when is_integer(At), is_integer(Sz), Sz >= 0 -> + if + ?G_I32(At), ?G_I32(Sz) -> + case call_port(Port, <<?RAM_FILE_PREAD:8,At:32,Sz:32>>) of + {ok, {0,_Data}} when Sz =/= 0 -> + eof; + {ok, {_Sz,Data}} -> + {ok, Data}; + Error -> + Error + end; + true -> + {error, einval} + end; +pread(#file_descriptor{module = ?MODULE}, _, _) -> + {error, badarg}. + + + +pwrite(#file_descriptor{module = ?MODULE, data = Port}, L) when is_list(L) -> + pwrite_1(Port, L, 0, []). + +pwrite_1(Port, [], _, Cs) -> + pwrite_2(Port, lists:reverse(Cs), 0); +pwrite_1(Port, [{At, Bytes} | T], R, Cs) when is_integer(At) -> + if + ?G_I32(At), is_binary(Bytes) -> + pwrite_1(Port, T, R+1, + [<<?RAM_FILE_PWRITE:8,At:32,Bytes/binary>> | Cs]); + ?G_I32(At) -> + try erlang:iolist_to_binary(Bytes) of + Bin -> + pwrite_1(Port, T, R+1, + [<<?RAM_FILE_PWRITE:8,At:32,Bin/binary>> | Cs]) + catch + error:Reason -> + {error, Reason} + end; + true -> + {error, {R, einval}} + end; +pwrite_1(_, _, _, _) -> + {error, badarg}. + +pwrite_2(_Port, [], _R) -> + ok; +pwrite_2(Port, [Command|Commands], R) -> + case call_port(Port, Command) of + {ok, _Sz} -> + pwrite_2(Port, Commands, R+1); + {error, badarg} = Error -> + Error; + {error, Reason} -> + {error, {R, Reason}} + end. + +pwrite(#file_descriptor{module = ?MODULE, data = Port}, At, Bytes) + when is_integer(At) -> + if + ?G_I32(At) -> + case call_port(Port, [<<?RAM_FILE_PWRITE:8,At:32>>|Bytes]) of + {ok, _Sz} -> + ok; + Error -> + Error + end; + true -> + {error, einval} + end; +pwrite(#file_descriptor{module = ?MODULE}, _, _) -> + {error, badarg}. + + +ipread_s32bu_p32bu(#file_descriptor{module = ?MODULE} = Handle, Pos, MaxSz) -> + file:ipread_s32bu_p32bu_int(Handle, Pos, MaxSz). + + + +%% -------------------------------------------------------------------------- +%% Specialized ram_file API for functions not in file, unique to ram_file. +%% + + +get_file(#file_descriptor{module = ?MODULE, data = Port}) -> + case call_port(Port, [?RAM_FILE_GET]) of + {ok, {_Sz, Data}} -> + {ok, Data}; + Error -> + Error + end; +get_file(#file_descriptor{}) -> + {error, enotsup}. + +set_file(#file_descriptor{module = ?MODULE, data = Port}, Data) -> + call_port(Port, [?RAM_FILE_SET | Data]); +set_file(#file_descriptor{}, _) -> + {error, enotsup}. + +get_file_close(#file_descriptor{module = ?MODULE, data = Port}) -> + case call_port(Port, [?RAM_FILE_GET_CLOSE]) of + {ok, {_Sz, Data}} -> + {ok, Data}; + Error -> + Error + end; +get_file_close(#file_descriptor{}) -> + {error, enotsup}. + +get_size(#file_descriptor{module = ?MODULE, data = Port}) -> + call_port(Port, [?RAM_FILE_SIZE]); +get_size(#file_descriptor{}) -> + {error, enotsup}. + +compress(#file_descriptor{module = ?MODULE, data = Port}) -> + call_port(Port, [?RAM_FILE_COMPRESS]); +compress(#file_descriptor{}) -> + {error, enotsup}. + +uncompress(#file_descriptor{module = ?MODULE, data = Port}) -> + call_port(Port, [?RAM_FILE_UNCOMPRESS]); +uncompress(#file_descriptor{}) -> + {error, enotsup}. + + +uuencode(#file_descriptor{module = ?MODULE, data = Port}) -> + call_port(Port, [?RAM_FILE_UUENCODE]); +uuencode(#file_descriptor{}) -> + {error, enotsup}. + +uudecode(#file_descriptor{module = ?MODULE, data = Port}) -> + call_port(Port, [?RAM_FILE_UUDECODE]); +uudecode(#file_descriptor{}) -> + {error, enotsup}. + + + +%%%----------------------------------------------------------------- +%%% Functions to communicate with the driver + +ll_open(Data, Mode, Opts) -> + try erlang:open_port({spawn, ?RAM_FILE_DRV}, Opts) of + Port -> + case call_port(Port, [<<?RAM_FILE_OPEN:8,Mode:32>>|Data]) of + {error, _} = Error -> + ll_close(Port), + Error; + {ok, _} -> + {ok, Port} + end + catch + error:Reason -> + {error, Reason} + end. + +call_port(Port, Command) when is_port(Port), is_binary(Command) -> + try erlang:port_command(Port, Command) of + true -> + get_response(Port) + catch + error:badarg -> + {error, einval}; % Since Command is valid, Port must be dead + error:Reason -> + {error, Reason} + end; +call_port(Port, Command) -> + try erlang:iolist_to_binary(Command) of + Bin -> + call_port(Port, Bin) + catch + error:Reason -> + {error, Reason} + end. + +get_response(Port) -> + receive + {Port, {data, [Response|Rest]}} -> + translate_response(Response, Rest); + {'EXIT', Port, _Reason} -> + {error, port_died} + end. + +ll_close(Port) -> + try erlang:port_close(Port) catch error:_ -> ok end, + receive %% In case the caller is the owner and traps exits + {'EXIT', Port, _} -> + ok + after 0 -> + ok + end. + +%%%----------------------------------------------------------------- +%%% Utility functions. + +mode_list(read) -> + [read]; +mode_list(write) -> + [write]; +mode_list(read_write) -> + [read, write]; +mode_list({binary, Mode}) when is_atom(Mode) -> + [binary | mode_list(Mode)]; +mode_list({character, Mode}) when is_atom(Mode) -> + mode_list(Mode); +mode_list(_) -> + {error, badarg}. + + + +%% Converts a list of mode atoms into an mode word for the driver. +%% Returns {Mode, Opts} wher Opts is a list of options for +%% erlang:open_port/2, or {error, einval} upon failure. + +open_mode(List) when is_list(List) -> + case open_mode(List, {0, []}) of + {Mode, Opts} when Mode band + (?RAM_FILE_MODE_READ bor ?RAM_FILE_MODE_WRITE) + =:= 0 -> + {Mode bor ?RAM_FILE_MODE_READ, Opts}; + Other -> + Other + end. + +open_mode([ram|Rest], {Mode, Opts}) -> + open_mode(Rest, {Mode, Opts}); +open_mode([read|Rest], {Mode, Opts}) -> + open_mode(Rest, {Mode bor ?RAM_FILE_MODE_READ, Opts}); +open_mode([write|Rest], {Mode, Opts}) -> + open_mode(Rest, {Mode bor ?RAM_FILE_MODE_WRITE, Opts}); +open_mode([binary|Rest], {Mode, Opts}) -> + open_mode(Rest, {Mode, [binary | Opts]}); +open_mode([], {Mode, Opts}) -> + {Mode, Opts}; +open_mode(_, _) -> + {error, badarg}. + + + +%% Converts a position tuple {bof, X} | {cur, X} | {eof, X} into +%% {ok, Offset, OriginCode} for the driver. +%% Returns {error, einval} upon failure. + +lseek_position(Pos) when is_integer(Pos) -> + lseek_position({bof, Pos}); +lseek_position(bof) -> + lseek_position({bof, 0}); +lseek_position(cur) -> + lseek_position({cur, 0}); +lseek_position(eof) -> + lseek_position({eof, 0}); +lseek_position({bof, Offset}) when is_integer(Offset) -> + {ok, Offset, ?RAM_FILE_SEEK_SET}; +lseek_position({cur, Offset}) when is_integer(Offset) -> + {ok, Offset, ?RAM_FILE_SEEK_CUR}; +lseek_position({eof, Offset}) when is_integer(Offset) -> + {ok, Offset, ?RAM_FILE_SEEK_END}; +lseek_position(_) -> + {error, badarg}. + + + +translate_response(?RAM_FILE_RESP_OK, []) -> + ok; +translate_response(?RAM_FILE_RESP_OK, Data) -> + {ok, Data}; +translate_response(?RAM_FILE_RESP_ERROR, List) when is_list(List) -> + {error, list_to_atom(List)}; +translate_response(?RAM_FILE_RESP_NUMBER, [X1, X2, X3, X4]) -> + {ok, i32(X1, X2, X3, X4)}; +translate_response(?RAM_FILE_RESP_DATA, [X1, X2, X3, X4|Data]) -> + {ok, {i32(X1, X2, X3, X4), Data}}; +translate_response(X, Data) -> + {error, {bad_response_from_port, X, Data}}. + +i32(X1,X2,X3,X4) -> + (X1 bsl 24) bor (X2 bsl 16) bor (X3 bsl 8) bor X4. diff --git a/lib/kernel/src/rpc.erl b/lib/kernel/src/rpc.erl new file mode 100644 index 0000000000..d69f2a12ad --- /dev/null +++ b/lib/kernel/src/rpc.erl @@ -0,0 +1,609 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1996-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(rpc). + +%% General rpc, broadcast,multicall, promise and parallel evaluator +%% facility + +%% This code used to reside in net.erl, but has now been moved to +%% a searate module. + +-define(NAME, rex). + +-behaviour(gen_server). + +-export([start/0, start_link/0, stop/0, + call/4, call/5, + block_call/4, block_call/5, + server_call/4, + cast/4, + abcast/2, + abcast/3, + sbcast/2, + sbcast/3, + eval_everywhere/3, + eval_everywhere/4, + multi_server_call/2, + multi_server_call/3, + multicall/3, + multicall/4, + multicall/5, + async_call/4, + yield/1, + nb_yield/2, + nb_yield/1, + parallel_eval/1, + pmap/3, pinfo/1, pinfo/2]). + +%% Deprecated calls. +-deprecated([{safe_multi_server_call,2},{safe_multi_server_call,3}]). +-export([safe_multi_server_call/2,safe_multi_server_call/3]). + +%% gen_server exports +-export([init/1,handle_call/3,handle_cast/2,handle_info/2, + terminate/2, code_change/3]). + +%% Internals +-export([proxy_user_flush/0]). + +%%------------------------------------------------------------------------ + +%% Remote execution and broadcasting facility + +start() -> + gen_server:start({local,?NAME},?MODULE,[],[]). + +start_link() -> + gen_server:start_link({local,?NAME},?MODULE,[],[]). + +stop() -> + stop(?NAME). + +stop(Rpc) -> + gen_server:call(Rpc, stop, infinity). + +-spec init([]) -> {'ok', gb_tree()}. +init([]) -> + process_flag(trap_exit, true), + {ok, gb_trees:empty()}. + +handle_call({call, Mod, Fun, Args, Gleader}, To, S) -> + handle_call_call(Mod, Fun, Args, Gleader, To, S); +handle_call({block_call, Mod, Fun, Args, Gleader}, _To, S) -> + MyGL = group_leader(), + set_group_leader(Gleader), + Reply = + case catch apply(Mod,Fun,Args) of + {'EXIT', _} = Exit -> + {badrpc, Exit}; + Other -> + Other + end, + group_leader(MyGL, self()), % restore + {reply, Reply, S}; +handle_call(stop, _To, S) -> + {stop, normal, stopped, S}; +handle_call(_, _To, S) -> + {noreply, S}. % Ignore ! + + +handle_cast({cast, Mod, Fun, Args, Gleader}, S) -> + spawn( + fun() -> + set_group_leader(Gleader), + apply(Mod, Fun, Args) + end), + {noreply, S}; +handle_cast(_, S) -> + {noreply, S}. % Ignore ! + + +handle_info({'DOWN', _, process, Caller, Reason}, S) -> + case gb_trees:lookup(Caller, S) of + {value, To} -> + receive + {Caller, {reply, Reply}} -> + gen_server:reply(To, Reply) + after 0 -> + gen_server:reply(To, {badrpc, {'EXIT', Reason}}) + end, + {noreply, gb_trees:delete(Caller, S)}; + none -> + {noreply, S} + end; +handle_info({Caller, {reply, Reply}}, S) -> + case gb_trees:lookup(Caller, S) of + {value, To} -> + receive + {'DOWN', _, process, Caller, _} -> + gen_server:reply(To, Reply), + {noreply, gb_trees:delete(Caller, S)} + end; + none -> + {noreply, S} + end; +handle_info({From, {sbcast, Name, Msg}}, S) -> + case catch Name ! Msg of %% use catch to get the printout + {'EXIT', _} -> + From ! {?NAME, node(), {nonexisting_name, Name}}; + _ -> + From ! {?NAME, node(), node()} + end, + {noreply,S}; +handle_info({From, {send, Name, Msg}}, S) -> + case catch Name ! {From, Msg} of %% use catch to get the printout + {'EXIT', _} -> + From ! {?NAME, node(), {nonexisting_name, Name}}; + _ -> + ok %% It's up to Name to respond !!!!! + end, + {noreply,S}; +handle_info({From, {call,Mod,Fun,Args,Gleader}}, S) -> + %% Special for hidden C node's, uugh ... + handle_call_call(Mod, Fun, Args, Gleader, {From,?NAME}, S); +handle_info(_, S) -> + {noreply,S}. + +terminate(_, _S) -> + ok. + +code_change(_, S, _) -> + {ok, S}. + +%% +%% Auxiliary function to avoid a false dialyzer warning -- do not inline +%% +handle_call_call(Mod, Fun, Args, Gleader, To, S) -> + RpcServer = self(), + %% Spawn not to block the rpc server. + {Caller,_} = + erlang:spawn_monitor( + fun () -> + set_group_leader(Gleader), + Reply = + %% in case some sucker rex'es + %% something that throws + case catch apply(Mod, Fun, Args) of + {'EXIT', _} = Exit -> + {badrpc, Exit}; + Result -> + Result + end, + RpcServer ! {self(), {reply, Reply}} + end), + {noreply, gb_trees:insert(Caller, To, S)}. + + +%% RPC aid functions .... + +set_group_leader(Gleader) when is_pid(Gleader) -> + group_leader(Gleader, self()); +set_group_leader(user) -> + %% For example, hidden C nodes doesn't want any I/O. + Gleader = case whereis(user) of + Pid when is_pid(Pid) -> Pid; + undefined -> proxy_user() + end, + group_leader(Gleader, self()). + + +%% The 'rex_proxy_user' process serve as group leader for early rpc's that +%% may do IO before the real group leader 'user' has been started (OTP-7903). +proxy_user() -> + case whereis(rex_proxy_user) of + Pid when is_pid(Pid) -> Pid; + undefined -> + Pid = spawn(fun()-> proxy_user_loop() end), + try register(rex_proxy_user,Pid) of + true -> Pid + catch error:_ -> % spawn race, kill and try again + exit(Pid,kill), + proxy_user() + end + end. + +proxy_user_loop() -> + %% Wait for the real 'user' to start + timer:sleep(200), + case whereis(user) of + Pid when is_pid(Pid) -> proxy_user_flush(); + undefined -> proxy_user_loop() + end. + +proxy_user_flush() -> + %% Forward all received messages to 'user' + receive Msg -> + user ! Msg + after 10*1000 -> + %% Hibernate but live for ever, as it's not easy to know + %% when no more messages will arrive. + erlang:hibernate(?MODULE, proxy_user_flush, []) + end, + proxy_user_flush(). + + +%% THE rpc client interface + +-spec call(node(), atom(), atom(), [term()]) -> term(). + +call(N,M,F,A) when node() =:= N -> %% Optimize local call + local_call(M, F, A); +call(N,M,F,A) -> + do_call(N, {call,M,F,A,group_leader()}, infinity). + +-spec call(node(), atom(), atom(), [term()], timeout()) -> term(). + +call(N,M,F,A,_Timeout) when node() =:= N -> %% Optimize local call + local_call(M,F,A); +call(N,M,F,A,infinity) -> + do_call(N, {call,M,F,A,group_leader()}, infinity); +call(N,M,F,A,Timeout) when is_integer(Timeout), Timeout >= 0 -> + do_call(N, {call,M,F,A,group_leader()}, Timeout). + +-spec block_call(node(), atom(), atom(), [term()]) -> term(). + +block_call(N,M,F,A) when node() =:= N -> %% Optimize local call + local_call(M,F,A); +block_call(N,M,F,A) -> + do_call(N, {block_call,M,F,A,group_leader()}, infinity). + +-spec block_call(node(), atom(), atom(), [term()], timeout()) -> term(). + +block_call(N,M,F,A,_Timeout) when node() =:= N -> %% Optimize local call + local_call(M, F, A); +block_call(N,M,F,A,infinity) -> + do_call(N, {block_call,M,F,A,group_leader()}, infinity); +block_call(N,M,F,A,Timeout) when is_integer(Timeout), Timeout >= 0 -> + do_call(N, {block_call,M,F,A,group_leader()}, Timeout). + +local_call(M, F, A) when is_atom(M), is_atom(F), is_list(A) -> + case catch apply(M, F, A) of + {'EXIT',_}=V -> {badrpc, V}; + Other -> Other + end. + +do_call(Node, Request, infinity) -> + rpc_check(catch gen_server:call({?NAME,Node}, Request, infinity)); +do_call(Node, Request, Timeout) -> + Tag = make_ref(), + {Receiver,Mref} = + erlang:spawn_monitor( + fun() -> + %% Middleman process. Should be unsensitive to regular + %% exit signals. + process_flag(trap_exit, true), + Result = gen_server:call({?NAME,Node}, Request, Timeout), + exit({self(),Tag,Result}) + end), + receive + {'DOWN',Mref,_,_,{Receiver,Tag,Result}} -> + rpc_check(Result); + {'DOWN',Mref,_,_,Reason} -> + %% The middleman code failed. Or someone did + %% exit(_, kill) on the middleman process => Reason==killed + rpc_check_t({'EXIT',Reason}) + end. + +rpc_check_t({'EXIT', {timeout,_}}) -> {badrpc, timeout}; +rpc_check_t(X) -> rpc_check(X). + +rpc_check({'EXIT', {{nodedown,_},_}}) -> {badrpc, nodedown}; +rpc_check({'EXIT', X}) -> exit(X); +rpc_check(X) -> X. + + +%% This is a real handy function to be used when interacting with +%% a server called Name at node Node, It is assumed that the server +%% Receives messages on the form {From, Request} and replies on the +%% form From ! {ReplyWrapper, Node, Reply}. +%% This function makes such a server call and ensures that that +%% The entire call is packed into an atomic transaction which +%% either succeeds or fails, i.e. never hangs (unless the server itself hangs). + +-spec server_call(node(), atom(), term(), term()) -> term() | {'error', 'nodedown'}. + +server_call(Node, Name, ReplyWrapper, Msg) + when is_atom(Node), is_atom(Name) -> + if node() =:= nonode@nohost, Node =/= nonode@nohost -> + {error, nodedown}; + true -> + Ref = erlang:monitor(process, {Name, Node}), + {Name, Node} ! {self(), Msg}, + receive + {'DOWN', Ref, _, _, _} -> + {error, nodedown}; + {ReplyWrapper, Node, Reply} -> + erlang:demonitor(Ref), + receive + {'DOWN', Ref, _, _, _} -> + Reply + after 0 -> + Reply + end + end + end. + +-spec cast(node(), atom(), atom(), [term()]) -> 'true'. + +cast(Node, Mod, Fun, Args) when Node =:= node() -> + catch spawn(Mod, Fun, Args), + true; +cast(Node, Mod, Fun, Args) -> + gen_server:cast({?NAME,Node}, {cast,Mod,Fun,Args,group_leader()}), + true. + + +%% Asynchronous broadcast, returns nothing, it's just send'n prey +-spec abcast(atom(), term()) -> 'abcast'. + +abcast(Name, Mess) -> + abcast([node() | nodes()], Name, Mess). + +-spec abcast([node()], atom(), term()) -> 'abcast'. + +abcast([Node|Tail], Name, Mess) -> + Dest = {Name,Node}, + case catch erlang:send(Dest, Mess, [noconnect]) of + noconnect -> spawn(erlang, send, [Dest,Mess]); + _ -> ok + end, + abcast(Tail, Name, Mess); +abcast([], _,_) -> abcast. + + +%% Syncronous broadcast, returns a list of the nodes which had Name +%% as a registered server. Returns {Goodnodes, Badnodes}. +%% Syncronous in the sense that we know that all servers have received the +%% message when we return from the call, we can't know that they have +%% processed the message though. + +-spec sbcast(atom(), term()) -> {[node()], [node()]}. + +sbcast(Name, Mess) -> + sbcast([node() | nodes()], Name, Mess). + +-spec sbcast([node()], atom(), term()) -> {[node()], [node()]}. + +sbcast(Nodes, Name, Mess) -> + Monitors = send_nodes(Nodes, ?NAME, {sbcast, Name, Mess}, []), + rec_nodes(?NAME, Monitors). + +-spec eval_everywhere(atom(), atom(), [term()]) -> 'abcast'. + +eval_everywhere(Mod, Fun, Args) -> + eval_everywhere([node() | nodes()] , Mod, Fun, Args). + +-spec eval_everywhere([node()], atom(), atom(), [term()]) -> 'abcast'. + +eval_everywhere(Nodes, Mod, Fun, Args) -> + gen_server:abcast(Nodes, ?NAME, {cast,Mod,Fun,Args,group_leader()}). + + +send_nodes([Node|Tail], Name, Msg, Monitors) when is_atom(Node) -> + Monitor = start_monitor(Node, Name), + %% Handle non-existing names in rec_nodes. + catch {Name, Node} ! {self(), Msg}, + send_nodes(Tail, Name, Msg, [Monitor | Monitors]); +send_nodes([_Node|Tail], Name, Msg, Monitors) -> + %% Skip non-atom _Node + send_nodes(Tail, Name, Msg, Monitors); +send_nodes([], _Name, _Req, Monitors) -> + Monitors. + +%% Starts a monitor, either the new way, or the old. +%% Assumes that the arguments are atoms. +start_monitor(Node, Name) -> + if node() =:= nonode@nohost, Node =/= nonode@nohost -> + Ref = make_ref(), + self() ! {'DOWN', Ref, process, {Name, Node}, noconnection}, + {Node, Ref}; + true -> + {Node,erlang:monitor(process, {Name, Node})} + end. + +%% Cancels a monitor started with Ref=erlang:monitor(_, _), +%% i.e return value {Node, Ref} from start_monitor/2 above. +unmonitor(Ref) when is_reference(Ref) -> + erlang:demonitor(Ref), + receive + {'DOWN', Ref, _, _, _} -> + true + after 0 -> + true + end. + + +%% Call apply(M,F,A) on all nodes in parallel +-spec multicall(atom(), atom(), [term()]) -> {[_], [node()]}. + +multicall(M, F, A) -> + multicall(M, F, A, infinity). + +-spec multicall([node()], atom(), atom(), [term()]) -> {[_], [node()]} + ; (atom(), atom(), [term()], timeout()) -> {[_], [node()]}. + +multicall(Nodes, M, F, A) when is_list(Nodes) -> + multicall(Nodes, M, F, A, infinity); +multicall(M, F, A, Timeout) -> + multicall([node() | nodes()], M, F, A, Timeout). + +-spec multicall([node()], atom(), atom(), [term()], timeout()) -> {[_], [node()]}. + +multicall(Nodes, M, F, A, infinity) + when is_list(Nodes), is_atom(M), is_atom(F), is_list(A) -> + do_multicall(Nodes, M, F, A, infinity); +multicall(Nodes, M, F, A, Timeout) + when is_list(Nodes), is_atom(M), is_atom(F), is_list(A), is_integer(Timeout), + Timeout >= 0 -> + do_multicall(Nodes, M, F, A, Timeout). + +do_multicall(Nodes, M, F, A, Timeout) -> + {Rep,Bad} = gen_server:multi_call(Nodes, ?NAME, + {call, M,F,A, group_leader()}, + Timeout), + {lists:map(fun({_,R}) -> R end, Rep), Bad}. + + +%% Send Msg to Name on all nodes, and collect the answers. +%% Return {Replies, Badnodes} where Badnodes is a list of the nodes +%% that failed during the timespan of the call. +%% This function assumes that if we send a request to a server +%% called Name, the server will reply with a reply +%% on the form {Name, Node, Reply}, otherwise this function will +%% hang forever. +%% It also assumes that the server receives messages on the form +%% {From, Msg} and then replies as From ! {Name, node(), Reply}. +%% +%% There is no apparent order among the replies. + +-spec multi_server_call(atom(), term()) -> {[_], [node()]}. + +multi_server_call(Name, Msg) -> + multi_server_call([node() | nodes()], Name, Msg). + +-spec multi_server_call([node()], atom(), term()) -> {[_], [node()]}. + +multi_server_call(Nodes, Name, Msg) + when is_list(Nodes), is_atom(Name) -> + Monitors = send_nodes(Nodes, Name, Msg, []), + rec_nodes(Name, Monitors). + +%% Deprecated functions. Were only needed when communicating with R6 nodes. + +safe_multi_server_call(Name, Msg) -> + multi_server_call(Name, Msg). + +safe_multi_server_call(Nodes, Name, Msg) -> + multi_server_call(Nodes, Name, Msg). + + +rec_nodes(Name, Nodes) -> + rec_nodes(Name, Nodes, [], []). + +rec_nodes(_Name, [], Badnodes, Replies) -> + {Replies, Badnodes}; +rec_nodes(Name, [{N,R} | Tail], Badnodes, Replies) -> + receive + {'DOWN', R, _, _, _} -> + rec_nodes(Name, Tail, [N|Badnodes], Replies); + {?NAME, N, {nonexisting_name, _}} -> + %% used by sbcast() + unmonitor(R), + rec_nodes(Name, Tail, [N|Badnodes], Replies); + {Name, N, Reply} -> %% Name is bound !!! + unmonitor(R), + rec_nodes(Name, Tail, Badnodes, [Reply|Replies]) + end. + +%% Now for an asynchronous rpc. +%% An asyncronous version of rpc that is faster for series of +%% rpc's towards the same node. I.e. it returns immediately and +%% it returns a Key that can be used in a subsequent yield(Key). + +-spec async_call(node(), atom(), atom(), [term()]) -> pid(). + +async_call(Node, Mod, Fun, Args) -> + ReplyTo = self(), + spawn( + fun() -> + R = call(Node, Mod, Fun, Args), %% proper rpc + ReplyTo ! {self(), {promise_reply, R}} %% self() is key + end). + +-spec yield(pid()) -> term(). + +yield(Key) when is_pid(Key) -> + {value,R} = do_yield(Key, infinity), + R. + +-spec nb_yield(pid(), timeout()) -> {'value', _} | 'timeout'. + +nb_yield(Key, infinity=Inf) when is_pid(Key) -> + do_yield(Key, Inf); +nb_yield(Key, Timeout) when is_pid(Key), is_integer(Timeout), Timeout >= 0 -> + do_yield(Key, Timeout). + +-spec nb_yield(pid()) -> {'value', _} | 'timeout'. + +nb_yield(Key) when is_pid(Key) -> + do_yield(Key, 0). + +-spec do_yield(pid(), timeout()) -> {'value', _} | 'timeout'. + +do_yield(Key, Timeout) -> + receive + {Key,{promise_reply,R}} -> + {value,R} + after Timeout -> + timeout + end. + + +%% A parallel network evaluator +%% ArgL === [{M,F,Args},........] +%% Returns a lists of the evaluations in the same order as +%% given to ArgL +-spec parallel_eval([{atom(), atom(), [_]}]) -> [_]. + +parallel_eval(ArgL) -> + Nodes = [node() | nodes()], + Keys = map_nodes(ArgL,Nodes,Nodes), + [yield(K) || K <- Keys]. + +map_nodes([],_,_) -> []; +map_nodes(ArgL,[],Original) -> + map_nodes(ArgL,Original,Original); +map_nodes([{M,F,A}|Tail],[Node|MoreNodes], Original) -> + [?MODULE:async_call(Node,M,F,A) | + map_nodes(Tail,MoreNodes,Original)]. + +%% Parallel version of lists:map/3 with exactly the same +%% arguments and return value as lists:map/3, +%% except that it calls exit/1 if a network error occurs. +-spec pmap({atom(),atom()}, [term()], [term()]) -> [term()]. + +pmap({M,F}, As, List) -> + check(parallel_eval(build_args(M,F,As, List, [])), []). + +%% By using an accumulator twice we get the whole thing right +build_args(M,F, As, [Arg|Tail], Acc) -> + build_args(M,F, As, Tail, [{M,F,[Arg|As]}|Acc]); +build_args(M,F, _, [], Acc) when is_atom(M), is_atom(F) -> Acc. + +%% If one single call fails, we fail the whole computation +check([{badrpc, _}|_], _) -> exit(badrpc); +check([X|T], Ack) -> check(T, [X|Ack]); +check([], Ack) -> Ack. + + +%% location transparent version of process_info +-spec pinfo(pid()) -> [{atom(), _}] | 'undefined'. + +pinfo(Pid) when node(Pid) =:= node() -> + process_info(Pid); +pinfo(Pid) -> + call(node(Pid), erlang, process_info, [Pid]). + +-spec pinfo(pid(), Item) -> {Item, _} | 'undefined' | [] + when is_subtype(Item, atom()). + +pinfo(Pid, Item) when node(Pid) =:= node() -> + process_info(Pid, Item); +pinfo(Pid, Item) -> + block_call(node(Pid), erlang, process_info, [Pid, Item]). diff --git a/lib/kernel/src/seq_trace.erl b/lib/kernel/src/seq_trace.erl new file mode 100644 index 0000000000..78c3040f21 --- /dev/null +++ b/lib/kernel/src/seq_trace.erl @@ -0,0 +1,126 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1998-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(seq_trace). + +-define(SEQ_TRACE_SEND, 1). %(1 << 0) +-define(SEQ_TRACE_RECEIVE, 2). %(1 << 1) +-define(SEQ_TRACE_PRINT, 4). %(1 << 2) +-define(SEQ_TRACE_TIMESTAMP, 8). %(1 << 3) + +-export([set_token/1, + set_token/2, + get_token/0, + get_token/1, + print/1, + print/2, + reset_trace/0, + set_system_tracer/1, + get_system_tracer/0]). + +%%--------------------------------------------------------------------------- + +-type flag() :: 'send' | 'receive' | 'print' | 'timestamp'. +-type component() :: 'label' | 'serial' | flag(). +-type value() :: non_neg_integer() + | {non_neg_integer(), non_neg_integer()} + | boolean(). +-type token_pair() :: {component(), value()}. + +%%--------------------------------------------------------------------------- + +-type token() :: [] | {integer(), boolean(), _, _, _}. +-spec set_token(token()) -> token() | 'ok'. + +set_token([]) -> + erlang:seq_trace(sequential_trace_token,[]); +set_token({Flags,Label,Serial,_From,Lastcnt}) -> + F = decode_flags(Flags), + set_token2([{label,Label},{serial,{Lastcnt, Serial}} | F]). + +%% We limit the label type to always be a small integer because erl_interface +%% expects that, the BIF can however "unofficially" handle atoms as well, and +%% atoms can be used if only Erlang nodes are involved + +-spec set_token(component(), value()) -> token_pair(). + +set_token(Type, Val) -> + erlang:seq_trace(Type, Val). + +-spec get_token() -> term(). + +get_token() -> + element(2,process_info(self(),sequential_trace_token)). + +-spec get_token(component()) -> token_pair(). + +get_token(Type) -> + erlang:seq_trace_info(Type). + +-spec print(term()) -> 'ok'. + +print(Term) -> + erlang:seq_trace_print(Term), + ok. + +-spec print(integer(), term()) -> 'ok'. + +print(Label, Term) when is_atom(Label) -> + erlang:error(badarg, [Label, Term]); +print(Label, Term) -> + erlang:seq_trace_print(Label, Term), + ok. + +-spec reset_trace() -> 'true'. + +reset_trace() -> + erlang:system_flag(1, 0). + +%% reset_trace(Pid) -> % this might be a useful function too + +-type tracer() :: pid() | port() | 'false'. + +-spec set_system_tracer(tracer()) -> tracer(). + +set_system_tracer(Pid) -> + erlang:system_flag(sequential_tracer, Pid). + +-spec get_system_tracer() -> tracer(). + +get_system_tracer() -> + element(2, erlang:system_info(sequential_tracer)). + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% internal help functions +%% +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +set_token2([{Type,Val}|T]) -> + erlang:seq_trace(Type, Val), + set_token2(T); +set_token2([]) -> + ok. + +decode_flags(Flags) -> + Print = (Flags band ?SEQ_TRACE_PRINT) > 0, + Send = (Flags band ?SEQ_TRACE_SEND) > 0, + Rec = (Flags band ?SEQ_TRACE_RECEIVE) > 0, + Ts = (Flags band ?SEQ_TRACE_TIMESTAMP) > 0, + [{print,Print},{send,Send},{'receive',Rec},{timestamp,Ts}]. diff --git a/lib/kernel/src/standard_error.erl b/lib/kernel/src/standard_error.erl new file mode 100644 index 0000000000..73901d9896 --- /dev/null +++ b/lib/kernel/src/standard_error.erl @@ -0,0 +1,253 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 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(standard_error). +-behaviour(supervisor_bridge). + +%% Basic standard i/o server for user interface port. +-export([start_link/0, init/1, terminate/2]). + +-define(NAME, standard_error). +-define(PROCNAME_SUP, standard_error_sup). +%% Internal exports +-export([server/1, server/2]). + +%% Defines for control ops +-define(CTRL_OP_GET_WINSIZE,100). + +%% +%% The basic server and start-up. +%% +start_link() -> + supervisor_bridge:start_link({local, ?PROCNAME_SUP}, ?MODULE, []). + +terminate(_Reason,Pid) -> + (catch exit(Pid,kill)), + ok. + +init([]) -> + case (catch start_port([out,binary])) of + Pid when is_pid(Pid) -> + {ok,Pid,Pid}; + _ -> + {error,no_stderror} + end. + + +start_port(PortSettings) -> + Id = spawn(?MODULE,server,[{fd,2,2},PortSettings]), + register(?NAME,Id), + Id. + + +server(Pid) when is_pid(Pid) -> + process_flag(trap_exit, true), + link(Pid), + run(Pid). + +server(PortName,PortSettings) -> + process_flag(trap_exit, true), + Port = open_port(PortName,PortSettings), + run(Port). + +run(P) -> + put(unicode,false), + server_loop(P). + +server_loop(Port) -> + receive + {io_request,From,ReplyAs,Request} when is_pid(From) -> + do_io_request(Request, From, ReplyAs, Port), + server_loop(Port); + {'EXIT',Port,badsig} -> % Ignore badsig errors + server_loop(Port); + {'EXIT',Port,What} -> % Port has exited + exit(What); + _Other -> % Ignore other messages + server_loop(Port) + end. + + +get_fd_geometry(Port) -> + case (catch port_control(Port,?CTRL_OP_GET_WINSIZE,[])) of + List when is_list(List), length(List) =:= 8 -> + <<W:32/native,H:32/native>> = list_to_binary(List), + {W,H}; + _ -> + error + end. + + +%% NewSaveBuffer = io_request(Request, FromPid, ReplyAs, Port, SaveBuffer) + +do_io_request(Req, From, ReplyAs, Port) -> + {_Status,Reply} = io_request(Req, Port), + io_reply(From, ReplyAs, Reply). + +%% New in R13B +% Wide characters (Unicode) +io_request({put_chars,Encoding,Chars}, Port) -> % Binary new in R9C + put_chars(wrap_characters_to_binary(Chars,Encoding, + case get(unicode) of + true -> unicode; + _ -> latin1 + end), Port); +io_request({put_chars,Encoding,Mod,Func,Args}, Port) -> + Result = case catch apply(Mod,Func,Args) of + Data when is_list(Data); is_binary(Data) -> + wrap_characters_to_binary(Data,Encoding, + case get(unicode) of + true -> unicode; + _ -> latin1 + end); + Undef -> + Undef + end, + put_chars(Result, Port); +%% BC if called from pre-R13 node +io_request({put_chars,Chars}, Port) -> + io_request({put_chars,latin1,Chars}, Port); +io_request({put_chars,Mod,Func,Args}, Port) -> + io_request({put_chars,latin1,Mod,Func,Args}, Port); +%% New in R12 +io_request({get_geometry,columns},Port) -> + case get_fd_geometry(Port) of + {W,_H} -> + {ok,W}; + _ -> + {error,{error,enotsup}} + end; +io_request({get_geometry,rows},Port) -> + case get_fd_geometry(Port) of + {_W,H} -> + {ok,H}; + _ -> + {error,{error,enotsup}} + end; +io_request({getopts,[]}, Port) -> + getopts(Port); +io_request({setopts,Opts}, Port) when is_list(Opts) -> + setopts(Opts, Port); +io_request({requests,Reqs}, Port) -> + io_requests(Reqs, {ok,ok}, Port); +io_request(R, _Port) -> %Unknown request + {error,{error,{request,R}}}. %Ignore but give error (?) + +%% Status = io_requests(RequestList, PrevStat, Port) +%% Process a list of output requests as long as the previous status is 'ok'. + +io_requests([R|Rs], {ok,_Res}, Port) -> + io_requests(Rs, io_request(R, Port), Port); +io_requests([_|_], Error, _) -> + Error; +io_requests([], Stat, _) -> + Stat. + +%% put_port(DeepList, Port) +%% Take a deep list of characters, flatten and output them to the +%% port. + +put_port(List, Port) -> + send_port(Port, {command, List}). + +%% send_port(Port, Command) + +send_port(Port, Command) -> + Port ! {self(),Command}. + + +%% io_reply(From, ReplyAs, Reply) +%% The function for sending i/o command acknowledgement. +%% The ACK contains the return value. + +io_reply(From, ReplyAs, Reply) -> + From ! {io_reply,ReplyAs,Reply}. + +%% put_chars +put_chars(Chars, Port) when is_binary(Chars) -> + put_port(Chars, Port), + {ok,ok}; +put_chars(Chars, Port) -> + case catch list_to_binary(Chars) of + Binary when is_binary(Binary) -> + put_chars(Binary, Port); + _ -> + {error,{error,put_chars}} + end. + +%% setopts +setopts(Opts0,Port) -> + Opts = proplists:unfold( + proplists:substitute_negations( + [{latin1,unicode}], + Opts0)), + case check_valid_opts(Opts) of + true -> + do_setopts(Opts,Port); + false -> + {error,{error,enotsup}} + end. +check_valid_opts([]) -> + true; +check_valid_opts([{unicode,Valid}|T]) when Valid =:= true; Valid =:= utf8; Valid =:= false -> + check_valid_opts(T); +check_valid_opts(_) -> + false. + +do_setopts(Opts, _Port) -> + case proplists:get_value(unicode,Opts) of + Valid when Valid =:= true; Valid =:= utf8 -> + put(unicode,true); + false -> + put(unicode,false); + undefined -> + ok + end, + {ok,ok}. + +getopts(_Port) -> + Uni = {unicode, case get(unicode) of + true -> + true; + _ -> + false + end}, + {ok,[Uni]}. + +wrap_characters_to_binary(Chars,From,To) -> + TrNl = (whereis(user_drv) =/= undefined), + Limit = case To of + latin1 -> + 255; + _Else -> + 16#10ffff + end, + unicode:characters_to_binary( + [ case X of + $\n -> + if + TrNl -> + "\r\n"; + true -> + $\n + end; + High when High > Limit -> + ["\\x{",erlang:integer_to_list(X, 16),$}]; + Ordinary -> + Ordinary + end || X <- unicode:characters_to_list(Chars,From) ],unicode,To). diff --git a/lib/kernel/src/user.erl b/lib/kernel/src/user.erl new file mode 100644 index 0000000000..edf650ec59 --- /dev/null +++ b/lib/kernel/src/user.erl @@ -0,0 +1,786 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1996-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(user). +-compile( [ inline, { inline_size, 100 } ] ). + +%% Basic standard i/o server for user interface port. + +-export([start/0, start/1, start_out/0]). +-export([interfaces/1]). + +-define(NAME, user). + +%% Internal exports +-export([server/1, server/2]). + +%% Defines for control ops +-define(CTRL_OP_GET_WINSIZE,100). + +%% +%% The basic server and start-up. +%% + +start() -> + start_port([eof,binary]). + +start([Mod,Fun|Args]) -> + %% Mod,Fun,Args should return a pid. That process is supposed to act + %% as the io port. + Pid = apply(Mod, Fun, Args), % This better work! + Id = spawn(?MODULE, server, [Pid]), + register(?NAME, Id), + Id. + +start_out() -> + %% Output-only version of start/0 + start_port([out,binary]). + +start_port(PortSettings) -> + Id = spawn(?MODULE,server,[{fd,0,1},PortSettings]), + register(?NAME,Id), + Id. + +%% Return the pid of the shell process. +%% Note: We can't ask the user process for this info since it +%% may be busy waiting for data from the port. +interfaces(User) -> + case process_info(User, dictionary) of + {dictionary,Dict} -> + case lists:keysearch(shell, 1, Dict) of + {value,Sh={shell,Shell}} when is_pid(Shell) -> + [Sh]; + _ -> + [] + end; + _ -> + [] + end. + + +server(Pid) when is_pid(Pid) -> + process_flag(trap_exit, true), + link(Pid), + run(Pid). + +server(PortName,PortSettings) -> + process_flag(trap_exit, true), + Port = open_port(PortName,PortSettings), + run(Port). + +run(P) -> + put(read_mode,list), + put(unicode,false), + case init:get_argument(noshell) of + %% non-empty list -> noshell + {ok, [_|_]} -> + put(shell, noshell), + server_loop(P, queue:new()); + _ -> + group_leader(self(), self()), + catch_loop(P, start_init_shell()) + end. + +catch_loop(Port, Shell) -> + catch_loop(Port, Shell, queue:new()). + +catch_loop(Port, Shell, Q) -> + case catch server_loop(Port, Q) of + new_shell -> + exit(Shell, kill), + catch_loop(Port, start_new_shell()); + {unknown_exit,{Shell,Reason},_} -> % shell has exited + case Reason of + normal -> + put_chars("*** ", Port, []); + _ -> + put_chars("*** ERROR: ", Port, []) + end, + put_chars("Shell process terminated! ***\n", Port, []), + catch_loop(Port, start_new_shell()); + {unknown_exit,_,Q1} -> + catch_loop(Port, Shell, Q1); + {'EXIT',R} -> + exit(R) + end. + +link_and_save_shell(Shell) -> + link(Shell), + put(shell, Shell), + Shell. + +start_init_shell() -> + link_and_save_shell(shell:start(init)). + +start_new_shell() -> + link_and_save_shell(shell:start()). + +server_loop(Port, Q) -> + receive + {io_request,From,ReplyAs,Request} when is_pid(From) -> + server_loop(Port, do_io_request(Request, From, ReplyAs, Port, Q)); + {Port,{data,Bytes}} -> + case get(shell) of + noshell -> + server_loop(Port, queue:snoc(Q, Bytes)); + _ -> + case contains_ctrl_g_or_ctrl_c(Bytes) of + false -> + server_loop(Port, queue:snoc(Q, Bytes)); + _ -> + throw(new_shell) + end + end; + {Port, eof} -> + put(eof, true), + server_loop(Port, Q); + + %% Ignore messages from port here. + {'EXIT',Port,badsig} -> % Ignore badsig errors + server_loop(Port, Q); + {'EXIT',Port,What} -> % Port has exited + exit(What); + + %% Check if shell has exited + {'EXIT',SomePid,What} -> + case get(shell) of + noshell -> + server_loop(Port, Q); % Ignore + _ -> + throw({unknown_exit,{SomePid,What},Q}) + end; + + _Other -> % Ignore other messages + server_loop(Port, Q) + end. + + +get_fd_geometry(Port) -> + case (catch port_control(Port,?CTRL_OP_GET_WINSIZE,[])) of + List when is_list(List), length(List) =:= 8 -> + <<W:32/native,H:32/native>> = list_to_binary(List), + {W,H}; + _ -> + error + end. + + +%% NewSaveBuffer = io_request(Request, FromPid, ReplyAs, Port, SaveBuffer) + +do_io_request(Req, From, ReplyAs, Port, Q0) -> + case io_request(Req, Port, Q0) of + {_Status,Reply,Q1} -> + io_reply(From, ReplyAs, Reply), + Q1; + {exit,What} -> + send_port(Port, close), + exit(What) + end. + +%% New in R13B +%% Encoding option (unicode/latin1) +io_request({put_chars,unicode,Chars}, Port, Q) -> % Binary new in R9C + put_chars(wrap_characters_to_binary(Chars,unicode, + case get(unicode) of + true -> unicode; + _ -> latin1 + end), Port, Q); +io_request({put_chars,unicode,Mod,Func,Args}, Port, Q) -> + Result = case catch apply(Mod,Func,Args) of + Data when is_list(Data); is_binary(Data) -> + wrap_characters_to_binary(Data,unicode, + case get(unicode) of + true -> unicode; + _ -> latin1 + end); + Undef -> + Undef + end, + put_chars(Result, Port, Q); +io_request({put_chars,latin1,Chars}, Port, Q) -> % Binary new in R9C + Data = case get(unicode) of + true -> + unicode:characters_to_binary(Chars,latin1,unicode); + false -> + erlang:iolist_to_binary(Chars) + end, + put_chars(Data, Port, Q); +io_request({put_chars,latin1,Mod,Func,Args}, Port, Q) -> + Result = case catch apply(Mod,Func,Args) of + Data when is_list(Data); is_binary(Data) -> + unicode:characters_to_binary(Data,latin1, + case get(unicode) of + true -> unicode; + _ -> latin1 + end); + Undef -> + Undef + end, + put_chars(Result, Port, Q); +io_request({get_chars,Enc,Prompt,N}, Port, Q) -> % New in R9C + get_chars(Prompt, io_lib, collect_chars, N, Port, Q, Enc); +io_request({get_line,Enc,Prompt}, Port, Q) -> + case get(read_mode) of + binary -> + get_line_bin(Prompt,Port,Q,Enc); + _ -> + get_chars(Prompt, io_lib, collect_line, [], Port, Q, Enc) + end; +io_request({get_until,Enc,Prompt,M,F,As}, Port, Q) -> + get_chars(Prompt, io_lib, get_until, {M,F,As}, Port, Q, Enc); +%% End New in R13B +io_request(getopts, Port, Q) -> + getopts(Port, Q); +io_request({setopts,Opts}, Port, Q) when is_list(Opts) -> + setopts(Opts, Port, Q); +io_request({requests,Reqs}, Port, Q) -> + io_requests(Reqs, {ok,ok,Q}, Port); + +%% New in R12 +io_request({get_geometry,columns},Port,Q) -> + case get_fd_geometry(Port) of + {W,_H} -> + {ok,W,Q}; + _ -> + {error,{error,enotsup},Q} + end; +io_request({get_geometry,rows},Port,Q) -> + case get_fd_geometry(Port) of + {_W,H} -> + {ok,H,Q}; + _ -> + {error,{error,enotsup},Q} + end; +%% BC with pre-R13 nodes +io_request({put_chars,Chars}, Port, Q) -> + io_request({put_chars,latin1,Chars}, Port, Q); +io_request({put_chars,Mod,Func,Args}, Port, Q) -> + io_request({put_chars,latin1,Mod,Func,Args}, Port, Q); +io_request({get_chars,Prompt,N}, Port, Q) -> + io_request({get_chars,latin1,Prompt,N}, Port, Q); +io_request({get_line,Prompt}, Port, Q) -> + io_request({get_line,latin1,Prompt}, Port, Q); +io_request({get_until,Prompt,M,F,As}, Port, Q) -> + io_request({get_until,latin1,Prompt,M,F,As}, Port, Q); + +io_request(R, _Port, Q) -> %Unknown request + {error,{error,{request,R}},Q}. %Ignore but give error (?) + +%% Status = io_requests(RequestList, PrevStat, Port) +%% Process a list of output requests as long as the previous status is 'ok'. + +io_requests([R|Rs], {ok,_Res,Q}, Port) -> + io_requests(Rs, io_request(R, Port, Q), Port); +io_requests([_|_], Error, _) -> + Error; +io_requests([], Stat, _) -> + Stat. + +%% put_port(DeepList, Port) +%% Take a deep list of characters, flatten and output them to the +%% port. + +put_port(List, Port) -> + send_port(Port, {command, List}). + +%% send_port(Port, Command) + +send_port(Port, Command) -> + Port ! {self(),Command}. + +%% io_reply(From, ReplyAs, Reply) +%% The function for sending i/o command acknowledgement. +%% The ACK contains the return value. + +io_reply(From, ReplyAs, Reply) -> + From ! {io_reply,ReplyAs,Reply}. + +%% put_chars +put_chars(Chars, Port, Q) when is_binary(Chars) -> + put_port(Chars, Port), + {ok,ok,Q}; +put_chars(Chars, Port, Q) -> + case catch list_to_binary(Chars) of + Binary when is_binary(Binary) -> + put_chars(Binary, Port, Q); + _ -> + {error,{error,put_chars},Q} + end. + +expand_encoding([]) -> + []; +expand_encoding([latin1 | T]) -> + [{encoding,latin1} | expand_encoding(T)]; +expand_encoding([unicode | T]) -> + [{encoding,unicode} | expand_encoding(T)]; +expand_encoding([H|T]) -> + [H|expand_encoding(T)]. + +%% setopts +setopts(Opts0,Port,Q) -> + Opts = proplists:unfold( + proplists:substitute_negations( + [{list,binary}], + expand_encoding(Opts0))), + case check_valid_opts(Opts) of + true -> + do_setopts(Opts,Port,Q); + false -> + {error,{error,enotsup},Q} + end. +check_valid_opts([]) -> + true; +check_valid_opts([{binary,_}|T]) -> + check_valid_opts(T); +check_valid_opts([{encoding,Valid}|T]) when Valid =:= latin1; Valid =:= utf8; Valid =:= unicode -> + check_valid_opts(T); +check_valid_opts(_) -> + false. + +do_setopts(Opts, _Port, Q) -> + case proplists:get_value(encoding,Opts) of + Valid when Valid =:= unicode; Valid =:= utf8 -> + put(unicode,true); + latin1 -> + put(unicode,false); + undefined -> + ok + end, + case proplists:get_value(binary, Opts) of + true -> + put(read_mode,binary), + {ok,ok,Q}; + false -> + put(read_mode,list), + {ok,ok,Q}; + _ -> + {ok,ok,Q} + end. + +getopts(_Port,Q) -> + Bin = {binary, case get(read_mode) of + binary -> + true; + _ -> + false + end}, + Uni = {encoding, case get(unicode) of + true -> + unicode; + _ -> + latin1 + end}, + {ok,[Bin,Uni],Q}. + + +get_line_bin(Prompt,Port,Q, Enc) -> + prompt(Port, Prompt), + case {get(eof),queue:is_empty(Q)} of + {true,true} -> + {ok,eof,Q}; + _ -> + get_line(Prompt,Port, Q, [], Enc) + end. +get_line(Prompt, Port, Q, Acc, Enc) -> + case queue:is_empty(Q) of + true -> + receive + {Port,{data,Bytes}} -> + get_line_bytes(Prompt, Port, Q, Acc, Bytes, Enc); + {Port, eof} -> + put(eof, true), + {ok, eof, []}; + {io_request,From,ReplyAs,{get_geometry,_}=Req} when is_pid(From) -> + do_io_request(Req, From, ReplyAs, Port, + queue:new()), + %% No prompt. + get_line(Prompt, Port, Q, Acc, Enc); + {io_request,From,ReplyAs,Request} when is_pid(From) -> + do_io_request(Request, From, ReplyAs, Port, queue:new()), + prompt(Port, Prompt), + get_line(Prompt, Port, Q, Acc, Enc); + {'EXIT',From,What} when node(From) =:= node() -> + {exit,What} + end; + false -> + get_line_doit(Prompt, Port, Q, Acc, Enc) + end. + +get_line_bytes(Prompt, Port, Q, Acc, Bytes, Enc) -> + case get(shell) of + noshell -> + get_line_doit(Prompt, Port, queue:snoc(Q, Bytes),Acc,Enc); + _ -> + case contains_ctrl_g_or_ctrl_c(Bytes) of + false -> + get_line_doit(Prompt, Port, queue:snoc(Q, Bytes), Acc, Enc); + _ -> + throw(new_shell) + end + end. +is_cr_at(Pos,Bin) -> + case Bin of + <<_:Pos/binary,$\r,_/binary>> -> + true; + _ -> + false + end. +srch(<<>>,_,_) -> + nomatch; +srch(<<X:8,_/binary>>,X,N) -> + {match,[{N,1}]}; +srch(<<_:8,T/binary>>,X,N) -> + srch(T,X,N+1). +get_line_doit(Prompt, Port, Q, Accu, Enc) -> + case queue:is_empty(Q) of + true -> + case get(eof) of + true -> + case Accu of + [] -> + {ok,eof,Q}; + _ -> + {ok,binrev(Accu,[]),Q} + end; + _ -> + get_line(Prompt, Port, Q, Accu, Enc) + end; + false -> + Bin = queue:head(Q), + case srch(Bin,$\n,0) of + nomatch -> + X = byte_size(Bin)-1, + case is_cr_at(X,Bin) of + true -> + <<D:X/binary,_/binary>> = Bin, + get_line_doit(Prompt, Port, queue:tail(Q), + [<<$\r>>,D|Accu], Enc); + false -> + get_line_doit(Prompt, Port, queue:tail(Q), + [Bin|Accu], Enc) + end; + {match,[{Pos,1}]} -> + %% We are done + PosPlus = Pos + 1, + case Accu of + [] -> + {Head,Tail} = + case is_cr_at(Pos - 1,Bin) of + false -> + <<H:PosPlus/binary, + T/binary>> = Bin, + {H,T}; + true -> + PosMinus = Pos - 1, + <<H:PosMinus/binary, + _,_,T/binary>> = Bin, + {binrev([],[H,$\n]),T} + end, + case Tail of + <<>> -> + {ok, cast(Head,Enc), queue:tail(Q)}; + _ -> + {ok, cast(Head,Enc), + queue:cons(Tail, queue:tail(Q))} + end; + [<<$\r>>|Stack1] when Pos =:= 0 -> + <<_:PosPlus/binary,Tail/binary>> = Bin, + case Tail of + <<>> -> + {ok, cast(binrev(Stack1, [$\n]),Enc), + queue:tail(Q)}; + _ -> + {ok, cast(binrev(Stack1, [$\n]),Enc), + queue:cons(Tail, queue:tail(Q))} + end; + _ -> + {Head,Tail} = + case is_cr_at(Pos - 1,Bin) of + false -> + <<H:PosPlus/binary, + T/binary>> = Bin, + {H,T}; + true -> + PosMinus = Pos - 1, + <<H:PosMinus/binary, + _,_,T/binary>> = Bin, + {[H,$\n],T} + end, + case Tail of + <<>> -> + {ok, cast(binrev(Accu,[Head]),Enc), + queue:tail(Q)}; + _ -> + {ok, cast(binrev(Accu,[Head]),Enc), + queue:cons(Tail, queue:tail(Q))} + end + end + end + end. + +binrev(L, T) -> + list_to_binary(lists:reverse(L, T)). + +%% is_cr_at(Pos,Bin) -> +%% case Bin of +%% <<_:Pos/binary,$\r,_/binary>> -> +%% true; +%% _ -> +%% false +%% end. + +%% collect_line_bin_re(Bin,_Data,Stack,_) -> +%% case re:run(Bin,<<"\n">>) of +%% nomatch -> +%% X = byte_size(Bin)-1, +%% case is_cr_at(X,Bin) of +%% true -> +%% <<D:X/binary,_/binary>> = Bin, +%% [<<$\r>>,D|Stack]; +%% false -> +%% [Bin|Stack] +%% end; +%% {match,[{Pos,1}]} -> +%% PosPlus = Pos + 1, +%% case Stack of +%% [] -> +%% case is_cr_at(Pos - 1,Bin) of +%% false -> +%% <<Head:PosPlus/binary,Tail/binary>> = Bin, +%% {stop, Head, Tail}; +%% true -> +%% PosMinus = Pos - 1, +%% <<Head:PosMinus/binary,_,_,Tail/binary>> = Bin, +%% {stop, binrev([],[Head,$\n]),Tail} +%% end; +%% [<<$\r>>|Stack1] when Pos =:= 0 -> + +%% <<_:PosPlus/binary,Tail/binary>> = Bin, +%% {stop,binrev(Stack1, [$\n]),Tail}; +%% _ -> +%% case is_cr_at(Pos - 1,Bin) of +%% false -> +%% <<Head:PosPlus/binary,Tail/binary>> = Bin, +%% {stop,binrev(Stack, [Head]),Tail}; +%% true -> +%% PosMinus = Pos - 1, +%% <<Head:PosMinus/binary,_,_,Tail/binary>> = Bin, +%% {stop, binrev(Stack,[Head,$\n]),Tail} +%% end +%% end +%% end. +%% get_chars(Prompt, Module, Function, XtraArg, Port, Queue) +%% Gets characters from the input port until the applied function +%% returns {stop,Result,RestBuf}. Does not block output until input +%% has been received. +%% Returns: +%% {Status,Result,NewQueue} +%% {exit,Reason} + +%% Entry function. +get_chars(Prompt, M, F, Xa, Port, Q, Fmt) -> + prompt(Port, Prompt), + case {get(eof),queue:is_empty(Q)} of + {true,true} -> + {ok,eof,Q}; + _ -> + get_chars(Prompt, M, F, Xa, Port, Q, start, Fmt) + end. + +%% First loop. Wait for port data. Respond to output requests. +get_chars(Prompt, M, F, Xa, Port, Q, State, Fmt) -> + case queue:is_empty(Q) of + true -> + receive + {Port,{data,Bytes}} -> + get_chars_bytes(State, M, F, Xa, Port, Q, Bytes, Fmt); + {Port, eof} -> + put(eof, true), + {ok, eof, []}; + %%{io_request,From,ReplyAs,Request} when is_pid(From) -> + %% get_chars_req(Prompt, M, F, Xa, Port, queue:new(), State, + %% Request, From, ReplyAs); + {io_request,From,ReplyAs,{get_geometry,_}=Req} when is_pid(From) -> + do_io_request(Req, From, ReplyAs, Port, + queue:new()), %Keep Q over this call + %% No prompt. + get_chars(Prompt, M, F, Xa, Port, Q, State, Fmt); + {io_request,From,ReplyAs,Request} when is_pid(From) -> + get_chars_req(Prompt, M, F, Xa, Port, Q, State, + Request, From, ReplyAs, Fmt); + {'EXIT',From,What} when node(From) =:= node() -> + {exit,What} + end; + false -> + get_chars_apply(State, M, F, Xa, Port, Q, Fmt) + end. + +get_chars_req(Prompt, M, F, XtraArg, Port, Q, State, + Req, From, ReplyAs, Fmt) -> + do_io_request(Req, From, ReplyAs, Port, queue:new()), %Keep Q over this call + prompt(Port, Prompt), + get_chars(Prompt, M, F, XtraArg, Port, Q, State, Fmt). + +%% Second loop. Pass data to client as long as it wants more. +%% A ^G in data interrupts loop if 'noshell' is not undefined. +get_chars_bytes(State, M, F, Xa, Port, Q, Bytes, Fmt) -> + case get(shell) of + noshell -> + get_chars_apply(State, M, F, Xa, Port, queue:snoc(Q, Bytes),Fmt); + _ -> + case contains_ctrl_g_or_ctrl_c(Bytes) of + false -> + get_chars_apply(State, M, F, Xa, Port, + queue:snoc(Q, Bytes),Fmt); + _ -> + throw(new_shell) + end + end. + +get_chars_apply(State0, M, F, Xa, Port, Q, Fmt) -> + case catch M:F(State0, cast(queue:head(Q),Fmt), Fmt, Xa) of + {stop,Result,<<>>} -> + {ok,Result,queue:tail(Q)}; + {stop,Result,[]} -> + {ok,Result,queue:tail(Q)}; + {stop,Result,eof} -> + {ok,Result,queue:tail(Q)}; + {stop,Result,Buf} -> + {ok,Result,queue:cons(Buf, queue:tail(Q))}; + {'EXIT',_} -> + {error,{error,err_func(M, F, Xa)},queue:new()}; + State1 -> + get_chars_more(State1, M, F, Xa, Port, queue:tail(Q), Fmt) + end. + +get_chars_more(State, M, F, Xa, Port, Q, Fmt) -> + case queue:is_empty(Q) of + true -> + case get(eof) of + undefined -> + receive + {Port,{data,Bytes}} -> + get_chars_bytes(State, M, F, Xa, Port, Q, Bytes, Fmt); + {Port,eof} -> + put(eof, true), + get_chars_apply(State, M, F, Xa, Port, + queue:snoc(Q, eof), Fmt); + {'EXIT',From,What} when node(From) =:= node() -> + {exit,What} + end; + _ -> + get_chars_apply(State, M, F, Xa, Port, queue:snoc(Q, eof), Fmt) + end; + false -> + get_chars_apply(State, M, F, Xa, Port, Q, Fmt) + end. + + +%% prompt(Port, Prompt) +%% Print Prompt onto Port + +%% common case, reduces execution time by 20% +prompt(_Port, '') -> ok; + +prompt(Port, Prompt) -> + put_port(io_lib:format_prompt(Prompt), Port). + +%% Convert error code to make it look as before +err_func(io_lib, get_until, {_,F,_}) -> + F; +err_func(_, F, _) -> + F. + +%% using regexp reduces execution time by >50% compared to old code +%% running two regexps in sequence is much faster than \\x03|\\x07 +contains_ctrl_g_or_ctrl_c(BinOrList)-> + case {re:run(BinOrList, <<3>>),re:run(BinOrList, <<7>>)} of + {nomatch, nomatch} -> false; + _ -> true + end. + +%% Convert a buffer between list and binary +cast(Data, _Format) when is_atom(Data) -> + Data; +cast(Data, Format) -> + cast(Data, get(read_mode), Format, get(unicode)). + +cast(B, binary, latin1, false) when is_binary(B) -> + B; +cast(B, binary, latin1, true) when is_binary(B) -> + unicode:characters_to_binary(B, unicode, latin1); +cast(L, binary, latin1, false) -> + erlang:iolist_to_binary(L); +cast(L, binary, latin1, true) -> + case unicode:characters_to_binary( + erlang:iolist_to_binary(L),unicode,latin1) of % may fail + {error,_,_} -> exit({no_translation, unicode, latin1}); + Else -> Else + end; +cast(B, binary, unicode, true) when is_binary(B) -> + B; +cast(B, binary, unicode, false) when is_binary(B) -> + unicode:characters_to_binary(B,latin1,unicode); +cast(L, binary, unicode, true) -> + % possibly a list containing UTF-8 encoded characters + unicode:characters_to_binary(erlang:iolist_to_binary(L)); +cast(L, binary, unicode, false) -> + unicode:characters_to_binary(L, latin1, unicode); +cast(L, list, latin1, UniTerm) -> + case UniTerm of + true -> % Convert input characters to protocol format (i.e latin1) + case unicode:characters_to_list( + erlang:iolist_to_binary(L),unicode) of % may fail + {error,_,_} -> exit({no_translation, unicode, latin1}); + Else -> [ case X of + High when High > 255 -> + exit({no_translation, unicode, latin1}); + Low -> + Low + end || X <- Else ] + end; + _ -> + binary_to_list(erlang:iolist_to_binary(L)) + end; +cast(L, list, unicode, UniTerm) -> + unicode:characters_to_list(erlang:iolist_to_binary(L), + case UniTerm of + true -> unicode; + _ -> latin1 + end); +cast(Other, _, _,_) -> + Other. + +wrap_characters_to_binary(Chars,unicode,latin1) -> + case unicode:characters_to_binary(Chars,unicode,latin1) of + {error,_,_} -> + list_to_binary( + [ case X of + High when High > 255 -> + ["\\x{",erlang:integer_to_list(X, 16),$}]; + Low -> + Low + end || X <- unicode:characters_to_list(Chars,unicode) ]); + Bin -> + Bin + end; + +wrap_characters_to_binary(Bin,From,From) when is_binary(Bin) -> + Bin; +wrap_characters_to_binary(Chars,From,To) -> + unicode:characters_to_binary(Chars,From,To). diff --git a/lib/kernel/src/user_drv.erl b/lib/kernel/src/user_drv.erl new file mode 100644 index 0000000000..c34f2ddeb0 --- /dev/null +++ b/lib/kernel/src/user_drv.erl @@ -0,0 +1,614 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1996-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(user_drv). + +%% Basic interface to a port. + +-export([start/0,start/1,start/2,start/3,server/2,server/3]). + +-export([interfaces/1]). + +-define(OP_PUTC,0). +-define(OP_MOVE,1). +-define(OP_INSC,2). +-define(OP_DELC,3). +-define(OP_BEEP,4). +% Control op +-define(CTRL_OP_GET_WINSIZE,100). +-define(CTRL_OP_GET_UNICODE_STATE,101). +-define(CTRL_OP_SET_UNICODE_STATE,102). + +%% start() +%% start(ArgumentList) +%% start(PortName, Shell) +%% start(InPortName, OutPortName, Shell) +%% Start the user driver server. The arguments to start/1 are slightly +%% strange as this may be called both at start up from the command line +%% and explicitly from other code. + +-spec start() -> pid(). + +start() -> %Default line editing shell + spawn(user_drv, server, ['tty_sl -c -e',{shell,start,[init]}]). + +start([Pname]) -> + spawn(user_drv, server, [Pname,{shell,start,[init]}]); +start([Pname|Args]) -> + spawn(user_drv, server, [Pname|Args]); +start(Pname) -> + spawn(user_drv, server, [Pname,{shell,start,[init]}]). + +start(Pname, Shell) -> + spawn(user_drv, server, [Pname,Shell]). + +start(Iname, Oname, Shell) -> + spawn(user_drv, server, [Iname,Oname,Shell]). + + +%% Return the pid of the active group process. +%% Note: We can't ask the user_drv process for this info since it +%% may be busy waiting for data from the port. + +-spec interfaces(pid()) -> [{'current_group', pid()}]. + +interfaces(UserDrv) -> + case process_info(UserDrv, dictionary) of + {dictionary,Dict} -> + case lists:keysearch(current_group, 1, Dict) of + {value,Gr={_,Group}} when is_pid(Group) -> + [Gr]; + _ -> + [] + end; + _ -> + [] + end. + +%% server(Pid, Shell) +%% server(Pname, Shell) +%% server(Iname, Oname, Shell) +%% The initial calls to run the user driver. These start the port(s) +%% then call server1/3 to set everything else up. + +server(Pid, Shell) when is_pid(Pid) -> + server1(Pid, Pid, Shell); +server(Pname, Shell) -> + process_flag(trap_exit, true), + case catch open_port({spawn,Pname}, [eof]) of + {'EXIT', _} -> + %% Let's try a dumb user instead + user:start(); + Port -> + server1(Port, Port, Shell) + end. + +server(Iname, Oname, Shell) -> + process_flag(trap_exit, true), + case catch open_port({spawn,Iname}, [eof]) of + {'EXIT', _} -> %% It might be a dumb terminal lets start dumb user + user:start(); + Iport -> + Oport = open_port({spawn,Oname}, [eof]), + server1(Iport, Oport, Shell) + end. + +server1(Iport, Oport, Shell) -> + put(eof, false), + %% Start user and initial shell. + User = start_user(), + Gr1 = gr_add_cur(gr_new(), User, {}), + + {Curr,Shell1} = + case init:get_argument(remsh) of + {ok,[[Node]]} -> + RShell = {list_to_atom(Node),shell,start,[]}, + RGr = group:start(self(), RShell), + {RGr,RShell}; + E when E =:= error ; E =:= {ok,[[]]} -> + {group:start(self(), Shell),Shell} + end, + + put(current_group, Curr), + Gr = gr_add_cur(Gr1, Curr, Shell1), + %% Print some information. + io_request({put_chars, unicode, + flatten(io_lib:format("~s\n", + [erlang:system_info(system_version)]))}, + Iport, Oport), + %% Enter the server loop. + server_loop(Iport, Oport, Curr, User, Gr). + +%% start_user() +%% Start a group leader process and register it as 'user', unless, +%% of course, a 'user' already exists. + +start_user() -> + case whereis(user_drv) of + undefined -> + register(user_drv, self()); + _ -> + ok + end, + case whereis(user) of + undefined -> + User = group:start(self(), {}), + register(user, User), + User; + User -> + User + end. + +server_loop(Iport, Oport, User, Gr) -> + Curr = gr_cur_pid(Gr), + put(current_group, Curr), + server_loop(Iport, Oport, Curr, User, Gr). + +server_loop(Iport, Oport, Curr, User, Gr) -> + receive + {Iport,{data,Bs}} -> + BsBin = list_to_binary(Bs), + Unicode = unicode:characters_to_list(BsBin,utf8), + port_bytes(Unicode, Iport, Oport, Curr, User, Gr); + {Iport,eof} -> + Curr ! {self(),eof}, + server_loop(Iport, Oport, Curr, User, Gr); + {User,Req} -> % never block from user! + io_request(Req, Iport, Oport), + server_loop(Iport, Oport, Curr, User, Gr); + {Curr,tty_geometry} -> + Curr ! {self(),tty_geometry,get_tty_geometry(Iport)}, + server_loop(Iport, Oport, Curr, User, Gr); + {Curr,get_unicode_state} -> + Curr ! {self(),get_unicode_state,get_unicode_state(Iport)}, + server_loop(Iport, Oport, Curr, User, Gr); + {Curr,set_unicode_state, Bool} -> + Curr ! {self(),set_unicode_state,set_unicode_state(Iport,Bool)}, + server_loop(Iport, Oport, Curr, User, Gr); + {Curr,Req} -> + io_request(Req, Iport, Oport), + server_loop(Iport, Oport, Curr, User, Gr); + {'EXIT',Iport,_R} -> + server_loop(Iport, Oport, Curr, User, Gr); + {'EXIT',Oport,_R} -> + server_loop(Iport, Oport, Curr, User, Gr); + {'EXIT',User,_R} -> % keep 'user' alive + NewU = start_user(), + server_loop(Iport, Oport, Curr, NewU, gr_set_num(Gr, 1, NewU, {})); + {'EXIT',Pid,R} -> % shell and group leader exit + case gr_cur_pid(Gr) of + Pid when R =/= die , + R =/= terminated -> % current shell exited + if R =/= normal -> + io_requests([{put_chars,unicode,"*** ERROR: "}], Iport, Oport); + true -> % exit not caused by error + io_requests([{put_chars,unicode,"*** "}], Iport, Oport) + end, + io_requests([{put_chars,unicode,"Shell process terminated! "}], Iport, Oport), + Gr1 = gr_del_pid(Gr, Pid), + case gr_get_info(Gr, Pid) of + {Ix,{shell,start,Params}} -> % 3-tuple == local shell + io_requests([{put_chars,unicode,"***\n"}], Iport, Oport), + %% restart group leader and shell, same index + Pid1 = group:start(self(), {shell,start,Params}), + {ok,Gr2} = gr_set_cur(gr_set_num(Gr1, Ix, Pid1, + {shell,start,Params}), Ix), + put(current_group, Pid1), + server_loop(Iport, Oport, Pid1, User, Gr2); + _ -> % remote shell + io_requests([{put_chars,unicode,"(^G to start new job) ***\n"}], + Iport, Oport), + server_loop(Iport, Oport, Curr, User, Gr1) + end; + _ -> % not current, just remove it + server_loop(Iport, Oport, Curr, User, gr_del_pid(Gr, Pid)) + end; + _X -> + %% Ignore unknown messages. + server_loop(Iport, Oport, Curr, User, Gr) + end. + +%% port_bytes(Bytes, InPort, OutPort, CurrentProcess, UserProcess, Group) +%% Check the Bytes from the port to see if it contains a ^G. If so, +%% either escape to switch_loop or restart the shell. Otherwise send +%% the bytes to Curr. + +port_bytes([$\^G|_Bs], Iport, Oport, _Curr, User, Gr) -> + handle_escape(Iport, Oport, User, Gr); + +port_bytes([$\^C|_Bs], Iport, Oport, Curr, User, Gr) -> + interrupt_shell(Iport, Oport, Curr, User, Gr); + +port_bytes([B], Iport, Oport, Curr, User, Gr) -> + Curr ! {self(),{data,[B]}}, + server_loop(Iport, Oport, Curr, User, Gr); +port_bytes(Bs, Iport, Oport, Curr, User, Gr) -> + case member($\^G, Bs) of + true -> + handle_escape(Iport, Oport, User, Gr); + false -> + Curr ! {self(),{data,Bs}}, + server_loop(Iport, Oport, Curr, User, Gr) + end. + +interrupt_shell(Iport, Oport, Curr, User, Gr) -> + case gr_get_info(Gr, Curr) of + undefined -> + ok; % unknown + _ -> + exit(Curr, interrupt) + end, + server_loop(Iport, Oport, Curr, User, Gr). + +handle_escape(Iport, Oport, User, Gr) -> + case application:get_env(stdlib, shell_esc) of + {ok,abort} -> + Pid = gr_cur_pid(Gr), + exit(Pid, die), + Gr1 = + case gr_get_info(Gr, Pid) of + {_Ix,{}} -> % no shell + Gr; + _ -> + receive {'EXIT',Pid,_} -> + gr_del_pid(Gr, Pid) + after 1000 -> + Gr + end + end, + Pid1 = group:start(self(), {shell,start,[]}), + io_request({put_chars,unicode,"\n"}, Iport, Oport), + server_loop(Iport, Oport, User, + gr_add_cur(Gr1, Pid1, {shell,start,[]})); + + _ -> % {ok,jcl} | undefined + io_request({put_chars,unicode,"\nUser switch command\n"}, Iport, Oport), + server_loop(Iport, Oport, User, switch_loop(Iport, Oport, Gr)) + end. + +switch_loop(Iport, Oport, Gr) -> + Line = get_line(edlin:start(" --> "), Iport, Oport), + switch_cmd(erl_scan:string(Line), Iport, Oport, Gr). + +switch_cmd({ok,[{atom,_,c},{integer,_,I}],_}, Iport, Oport, Gr0) -> + case gr_set_cur(Gr0, I) of + {ok,Gr} -> Gr; + undefined -> unknown_group(Iport, Oport, Gr0) + end; +switch_cmd({ok,[{atom,_,c}],_}, Iport, Oport, Gr) -> + case gr_get_info(Gr, gr_cur_pid(Gr)) of + undefined -> + unknown_group(Iport, Oport, Gr); + _ -> + Gr + end; +switch_cmd({ok,[{atom,_,i},{integer,_,I}],_}, Iport, Oport, Gr) -> + case gr_get_num(Gr, I) of + {pid,Pid} -> + exit(Pid, interrupt), + switch_loop(Iport, Oport, Gr); + undefined -> + unknown_group(Iport, Oport, Gr) + end; +switch_cmd({ok,[{atom,_,i}],_}, Iport, Oport, Gr) -> + Pid = gr_cur_pid(Gr), + case gr_get_info(Gr, Pid) of + undefined -> + unknown_group(Iport, Oport, Gr); + _ -> + exit(Pid, interrupt), + switch_loop(Iport, Oport, Gr) + end; +switch_cmd({ok,[{atom,_,k},{integer,_,I}],_}, Iport, Oport, Gr) -> + case gr_get_num(Gr, I) of + {pid,Pid} -> + exit(Pid, die), + case gr_get_info(Gr, Pid) of + {_Ix,{}} -> % no shell + switch_loop(Iport, Oport, Gr); + _ -> + Gr1 = + receive {'EXIT',Pid,_} -> + gr_del_pid(Gr, Pid) + after 1000 -> + Gr + end, + switch_loop(Iport, Oport, Gr1) + end; + undefined -> + unknown_group(Iport, Oport, Gr) + end; +switch_cmd({ok,[{atom,_,k}],_}, Iport, Oport, Gr) -> + Pid = gr_cur_pid(Gr), + Info = gr_get_info(Gr, Pid), + case Info of + undefined -> + unknown_group(Iport, Oport, Gr); + {_Ix,{}} -> % no shell + switch_loop(Iport, Oport, Gr); + _ -> + exit(Pid, die), + Gr1 = + receive {'EXIT',Pid,_} -> + gr_del_pid(Gr, Pid) + after 1000 -> + Gr + end, + switch_loop(Iport, Oport, Gr1) + end; +switch_cmd({ok,[{atom,_,j}],_}, Iport, Oport, Gr) -> + io_requests(gr_list(Gr), Iport, Oport), + switch_loop(Iport, Oport, Gr); +switch_cmd({ok,[{atom,_,s},{atom,_,Shell}],_}, Iport, Oport, Gr0) -> + Pid = group:start(self(), {Shell,start,[]}), + Gr = gr_add_cur(Gr0, Pid, {Shell,start,[]}), + switch_loop(Iport, Oport, Gr); +switch_cmd({ok,[{atom,_,s}],_}, Iport, Oport, Gr0) -> + Pid = group:start(self(), {shell,start,[]}), + Gr = gr_add_cur(Gr0, Pid, {shell,start,[]}), + switch_loop(Iport, Oport, Gr); +switch_cmd({ok,[{atom,_,r}],_}, Iport, Oport, Gr0) -> + case is_alive() of + true -> + Node = pool:get_node(), + Pid = group:start(self(), {Node,shell,start,[]}), + Gr = gr_add_cur(Gr0, Pid, {Node,shell,start,[]}), + switch_loop(Iport, Oport, Gr); + false -> + io_request({put_chars,unicode,"Not alive\n"}, Iport, Oport), + switch_loop(Iport, Oport, Gr0) + end; +switch_cmd({ok,[{atom,_,r},{atom,_,Node}],_}, Iport, Oport, Gr0) -> + Pid = group:start(self(), {Node,shell,start,[]}), + Gr = gr_add_cur(Gr0, Pid, {Node,shell,start,[]}), + switch_loop(Iport, Oport, Gr); +switch_cmd({ok,[{atom,_,r},{atom,_,Node},{atom,_,Shell}],_}, + Iport, Oport, Gr0) -> + Pid = group:start(self(), {Node,Shell,start,[]}), + Gr = gr_add_cur(Gr0, Pid, {Node,Shell,start,[]}), + switch_loop(Iport, Oport, Gr); +switch_cmd({ok,[{atom,_,q}],_}, Iport, Oport, Gr) -> + case erlang:system_info(break_ignored) of + true -> % noop + io_request({put_chars,unicode,"Unknown command\n"}, Iport, Oport), + switch_loop(Iport, Oport, Gr); + false -> + halt() + end; +switch_cmd({ok,[{atom,_,h}],_}, Iport, Oport, Gr) -> + list_commands(Iport, Oport), + switch_loop(Iport, Oport, Gr); +switch_cmd({ok,[{'?',_}],_}, Iport, Oport, Gr) -> + list_commands(Iport, Oport), + switch_loop(Iport, Oport, Gr); +switch_cmd({ok,[],_}, Iport, Oport, Gr) -> + switch_loop(Iport, Oport, Gr); +switch_cmd({ok,_Ts,_}, Iport, Oport, Gr) -> + io_request({put_chars,unicode,"Unknown command\n"}, Iport, Oport), + switch_loop(Iport, Oport, Gr); +switch_cmd(_Ts, Iport, Oport, Gr) -> + io_request({put_chars,unicode,"Illegal input\n"}, Iport, Oport), + switch_loop(Iport, Oport, Gr). + +unknown_group(Iport, Oport, Gr) -> + io_request({put_chars,unicode,"Unknown job\n"}, Iport, Oport), + switch_loop(Iport, Oport, Gr). + +list_commands(Iport, Oport) -> + QuitReq = case erlang:system_info(break_ignored) of + true -> + []; + false -> + [{put_chars,unicode," q - quit erlang\n"}] + end, + io_requests([{put_chars, unicode," c [nn] - connect to job\n"}, + {put_chars, unicode," i [nn] - interrupt job\n"}, + {put_chars, unicode," k [nn] - kill job\n"}, + {put_chars, unicode," j - list all jobs\n"}, + {put_chars, unicode," s [shell] - start local shell\n"}, + {put_chars, unicode," r [node [shell]] - start remote shell\n"}] ++ + QuitReq ++ + [{put_chars, unicode," ? | h - this message\n"}], + Iport, Oport). + +get_line({done,Line,_Rest,Rs}, Iport, Oport) -> + io_requests(Rs, Iport, Oport), + Line; +get_line({undefined,_Char,Cs,Cont,Rs}, Iport, Oport) -> + io_requests(Rs, Iport, Oport), + io_request(beep, Iport, Oport), + get_line(edlin:edit_line(Cs, Cont), Iport, Oport); +get_line({What,Cont0,Rs}, Iport, Oport) -> + io_requests(Rs, Iport, Oport), + receive + {Iport,{data,Cs}} -> + get_line(edlin:edit_line(Cs, Cont0), Iport, Oport); + {Iport,eof} -> + get_line(edlin:edit_line(eof, Cont0), Iport, Oport) + after + get_line_timeout(What) -> + get_line(edlin:edit_line([], Cont0), Iport, Oport) + end. + +get_line_timeout(blink) -> 1000; +get_line_timeout(more_chars) -> infinity. + +% Let driver report window geometry, +% definitely outside of the common interface +get_tty_geometry(Iport) -> + case (catch port_control(Iport,?CTRL_OP_GET_WINSIZE,[])) of + List when length(List) =:= 8 -> + <<W:32/native,H:32/native>> = list_to_binary(List), + {W,H}; + _ -> + error + end. +get_unicode_state(Iport) -> + case (catch port_control(Iport,?CTRL_OP_GET_UNICODE_STATE,[])) of + [Int] when Int > 0 -> + true; + [Int] when Int =:= 0 -> + false; + _ -> + error + end. + +set_unicode_state(Iport, Bool) -> + Data = case Bool of + true -> [1]; + false -> [0] + end, + case (catch port_control(Iport,?CTRL_OP_SET_UNICODE_STATE,Data)) of + [Int] when Int > 0 -> + {unicode, utf8}; + [Int] when Int =:= 0 -> + {unicode, false}; + _ -> + error + end. + +%% io_request(Request, InPort, OutPort) +%% io_requests(Requests, InPort, OutPort) + +io_request({put_chars, unicode,Cs}, _Iport, Oport) -> + Oport ! {self(),{command,[?OP_PUTC|unicode:characters_to_binary(Cs,utf8)]}}; +io_request({move_rel,N}, _Iport, Oport) -> + Oport ! {self(),{command,[?OP_MOVE|put_int16(N, [])]}}; +io_request({insert_chars,unicode,Cs}, _Iport, Oport) -> + Oport ! {self(),{command,[?OP_INSC|unicode:characters_to_binary(Cs,utf8)]}}; +io_request({delete_chars,N}, _Iport, Oport) -> + Oport ! {self(),{command,[?OP_DELC|put_int16(N, [])]}}; +io_request(beep, _Iport, Oport) -> + Oport ! {self(),{command,[?OP_BEEP]}}; +io_request({requests,Rs}, Iport, Oport) -> + io_requests(Rs, Iport, Oport); +io_request(_R, _Iport, _Oport) -> + ok. + +io_requests([R|Rs], Iport, Oport) -> + io_request(R, Iport, Oport), + io_requests(Rs, Iport, Oport); +io_requests([], _Iport, _Oport) -> + ok. + +put_int16(N, Tail) -> + [(N bsr 8)band 255,N band 255|Tail]. + +%% gr_new() +%% gr_get_num(Group, Index) +%% gr_get_info(Group, Pid) +%% gr_add_cur(Group, Pid, Shell) +%% gr_set_cur(Group, Index) +%% gr_cur_pid(Group) +%% gr_del_pid(Group, Pid) +%% Manage the group list. The group structure has the form: +%% {NextIndex,CurrIndex,CurrPid,GroupList} +%% +%% where each element in the group list is: +%% {Index,GroupPid,Shell} + +gr_new() -> + {0,0,none,[]}. + +gr_get_num({_Next,_CurI,_CurP,Gs}, I) -> + gr_get_num1(Gs, I). + +gr_get_num1([{I,_Pid,{}}|_Gs], I) -> + undefined; +gr_get_num1([{I,Pid,_S}|_Gs], I) -> + {pid,Pid}; +gr_get_num1([_G|Gs], I) -> + gr_get_num1(Gs, I); +gr_get_num1([], _I) -> + undefined. + +gr_get_info({_Next,_CurI,_CurP,Gs}, Pid) -> + gr_get_info1(Gs, Pid). + +gr_get_info1([{I,Pid,S}|_Gs], Pid) -> + {I,S}; +gr_get_info1([_G|Gs], I) -> + gr_get_info1(Gs, I); +gr_get_info1([], _I) -> + undefined. + +gr_add_cur({Next,_CurI,_CurP,Gs}, Pid, Shell) -> + {Next+1,Next,Pid,append(Gs, [{Next,Pid,Shell}])}. + +gr_set_cur({Next,_CurI,_CurP,Gs}, I) -> + case gr_get_num1(Gs, I) of + {pid,Pid} -> {ok,{Next,I,Pid,Gs}}; + undefined -> undefined + end. + +gr_set_num({Next,CurI,CurP,Gs}, I, Pid, Shell) -> + {Next,CurI,CurP,gr_set_num1(Gs, I, Pid, Shell)}. + +gr_set_num1([{I,_Pid,_Shell}|Gs], I, NewPid, NewShell) -> + [{I,NewPid,NewShell}|Gs]; +gr_set_num1([{I,Pid,Shell}|Gs], NewI, NewPid, NewShell) when NewI > I -> + [{I,Pid,Shell}|gr_set_num1(Gs, NewI, NewPid, NewShell)]; +gr_set_num1(Gs, NewI, NewPid, NewShell) -> + [{NewI,NewPid,NewShell}|Gs]. + +gr_del_pid({Next,CurI,CurP,Gs}, Pid) -> + {Next,CurI,CurP,gr_del_pid1(Gs, Pid)}. + +gr_del_pid1([{_I,Pid,_S}|Gs], Pid) -> + Gs; +gr_del_pid1([G|Gs], Pid) -> + [G|gr_del_pid1(Gs, Pid)]; +gr_del_pid1([], _Pid) -> + []. + +gr_cur_pid({_Next,_CurI,CurP,_Gs}) -> + CurP. + +gr_list({_Next,CurI,_CurP,Gs}) -> + gr_list(Gs, CurI, []). + +gr_list([{_I,_Pid,{}}|Gs], Cur, Jobs) -> + gr_list(Gs, Cur, Jobs); +gr_list([{Cur,_Pid,Shell}|Gs], Cur, Jobs) -> + gr_list(Gs, Cur, [{put_chars, unicode,flatten(io_lib:format("~4w* ~w\n", [Cur,Shell]))}|Jobs]); +gr_list([{I,_Pid,Shell}|Gs], Cur, Jobs) -> + gr_list(Gs, Cur, [{put_chars, unicode,flatten(io_lib:format("~4w ~w\n", [I,Shell]))}|Jobs]); +gr_list([], _Cur, Jobs) -> + lists:reverse(Jobs). + +append([H|T], X) -> + [H|append(T, X)]; +append([], X) -> + X. + +member(X, [X|_Rest]) -> true; +member(X, [_H|Rest]) -> + member(X, Rest); +member(_X, []) -> false. + +flatten(List) -> + flatten(List, [], []). + +flatten([H|T], Cont, Tail) when is_list(H) -> + flatten(H, [T|Cont], Tail); +flatten([H|T], Cont, Tail) -> + [H|flatten(T, Cont, Tail)]; +flatten([], [H|Cont], Tail) -> + flatten(H, Cont, Tail); +flatten([], [], Tail) -> + Tail. diff --git a/lib/kernel/src/user_sup.erl b/lib/kernel/src/user_sup.erl new file mode 100644 index 0000000000..35b7ff0cfe --- /dev/null +++ b/lib/kernel/src/user_sup.erl @@ -0,0 +1,129 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1996-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(user_sup). + +%% --------------------------------------------- +%% This is a supervisor bridge hiding the process +%% details of the user/group implementation. +%% --------------------------------------------- + +-behaviour(supervisor_bridge). + +-export([start/0]). + +%% Internal exports. +-export([init/1, terminate/2, relay/1]). + +-spec start() -> {'error', {'already_started', pid()}} | {'ok', pid()}. + +start() -> + supervisor_bridge:start_link(user_sup, []). + +-spec init([]) -> 'ignore' | {'error', 'nouser'} | {'ok', pid(), pid()}. + +init([]) -> + case get_user() of + nouser -> + ignore; + {master, Master} -> + Pid = start_slave(Master), + {ok, Pid, Pid}; + {M, F, A} -> + case start_user({M, F}, A) of + {ok, Pid} -> + {ok, Pid, Pid}; + Error -> + Error + end + end. + +start_slave(Master) -> + case rpc:call(Master, erlang, whereis, [user]) of + User when is_pid(User) -> + spawn(?MODULE, relay, [User]); + _ -> + error_logger:error_msg("Cannot get remote user", []), + receive after 1000 -> true end, + halt() + end. + +-spec relay(pid()) -> no_return(). + +relay(Pid) -> + register(user, self()), + relay1(Pid). + +relay1(Pid) -> + receive + X -> + Pid ! X, + relay1(Pid) + end. + + +%%----------------------------------------------------------------- +%% Sleep a while in order to let user write all (some) buffered +%% information before termination. +%%----------------------------------------------------------------- + +-spec terminate(term(), pid()) -> 'ok'. + +terminate(_Reason, UserPid) -> + receive after 1000 -> ok end, + exit(UserPid, kill), + ok. + +%%----------------------------------------------------------------- +%% If there is a user, wait for it to register itself. (But wait +%% no more than 10 seconds). This is so the application_controller +%% is guaranteed that the user is started. +%%----------------------------------------------------------------- + +start_user(Func,A) -> + apply(Func, A), + wait_for_user_p(100). + +wait_for_user_p(0) -> + {error, nouser}; +wait_for_user_p(N) -> + case whereis(user) of + Pid when is_pid(Pid) -> + link(Pid), + {ok, Pid}; + _ -> + receive after 100 -> ok end, + wait_for_user_p(N-1) + end. + +get_user() -> + Flags = init:get_arguments(), + check_flags(Flags, {user_drv, start, []}). + +%% These flags depend upon what arguments the erl script passes on +%% to erl91. +check_flags([{nouser, []} |T], _) -> check_flags(T, nouser); +check_flags([{user, [User]} | T], _) -> + check_flags(T, {list_to_atom(User), start, []}); +check_flags([{noshell, []} | T], _) -> check_flags(T, {user, start, []}); +check_flags([{oldshell, []} | T], _) -> check_flags(T, {user, start, []}); +check_flags([{noinput, []} | T], _) -> check_flags(T, {user, start_out, []}); +check_flags([{master, [Node]} | T], _) -> + check_flags(T, {master, list_to_atom(Node)}); +check_flags([_H | T], User) -> check_flags(T, User); +check_flags([], User) -> User. diff --git a/lib/kernel/src/wrap_log_reader.erl b/lib/kernel/src/wrap_log_reader.erl new file mode 100644 index 0000000000..5030d3aed5 --- /dev/null +++ b/lib/kernel/src/wrap_log_reader.erl @@ -0,0 +1,288 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1998-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% +%% + +%% Read wrap files with internal format + +-module(wrap_log_reader). + +%%-define(debug, true). +-ifdef(debug). +-define(FORMAT(P, A), io:format(P, A)). +-else. +-define(FORMAT(P, A), ok). +-endif. + +-export([open/1, open/2, chunk/1, chunk/2, close/1]). + +-include("disk_log.hrl"). + +-record(wrap_reader, + {fd :: file:fd(), + cont :: dlog_cont(), % disk_log's continuation record + file :: file:filename(), % file name without extension + file_no :: non_neg_integer(), % current file number + mod_time :: date_time(), % modification time of current file + first_no :: non_neg_integer() | 'one' % first read file number + }). + +%% +%% Exported functions +%% + +%% A special case to be handled when appropriate: if current file +%% number is one greater than number of files then the max file number +%% is not yet reached, we are on the first 'round' of filling the wrap +%% files. + +-type open_ret() :: {'ok', #wrap_reader{}} | {'error', tuple()}. + +-spec open(atom() | string()) -> open_ret(). + +open(File) when is_atom(File) -> + open(atom_to_list(File)); +open(File) when is_list(File) -> + case read_index_file(File) of + %% The special case described above. + {ok, {CurFileNo, _CurFileSz, _TotSz, NoOfFiles}} + when CurFileNo =:= NoOfFiles + 1 -> + FileNo = 1, + ?FORMAT("open from ~p Cur = ~p, Sz = ~p, Tot = ~p, NoFiles = ~p~n", + [FileNo, CurFileNo, _CurFileSz, _TotSz, NoOfFiles]), + open_int(File, FileNo, FileNo); + {ok, {CurFileNo, _CurFileSz, _TotSz, NoOfFiles}} -> + FileNo = case (CurFileNo + 1) rem NoOfFiles of + 0 -> NoOfFiles; + No -> No + end, + ?FORMAT("open from ~p Cur = ~p, Sz = ~p, Tot = ~p, NoFiles = ~p~n", + [FileNo, CurFileNo, _CurFileSz, _TotSz, NoOfFiles]), + open_int(File, FileNo, FileNo); + Error -> + Error + end. + +-spec open(atom() | string(), integer()) -> open_ret(). + +open(File, FileNo) when is_atom(File), is_integer(FileNo) -> + open(atom_to_list(File), FileNo); +open(File, FileNo) when is_list(File), is_integer(FileNo) -> + case read_index_file(File) of + {ok, {_CurFileNo, _CurFileSz, _TotSz, NoOfFiles}} + when NoOfFiles >= FileNo -> + ?FORMAT("open file ~p Cur = ~p, Sz = ~p, Tot = ~p, NoFiles = ~p~n", + [FileNo, _CurFileNo, _CurFileSz, _TotSz, NoOfFiles]), + open_int(File, FileNo, one); + %% The special case described above. + {ok, {CurFileNo, _CurFileSz, _TotSz, NoOfFiles}} + when CurFileNo =:= FileNo, CurFileNo =:= NoOfFiles +1 -> + ?FORMAT("open file ~p Cur = ~p, Sz = ~p, Tot = ~p, NoFiles = ~p~n", + [FileNo, CurFileNo, _CurFileSz, _TotSz, NoOfFiles]), + open_int(File, FileNo, one); + {ok, {_CurFileNo, _CurFileSz, _TotSz, _NoOfFiles}} -> + {error, {file_not_found, add_ext(File, FileNo)}}; + Error -> + Error + end. + +-spec close(#wrap_reader{}) -> 'ok' | {'error', atom()}. + +close(#wrap_reader{fd = FD}) -> + file:close(FD). + +-type chunk_ret() :: {#wrap_reader{}, [term()]} + | {#wrap_reader{}, [term()], non_neg_integer()} + | {#wrap_reader{}, 'eof'} + | {'error', term()}. + +-spec chunk(#wrap_reader{}) -> chunk_ret(). + +chunk(WR = #wrap_reader{}) -> + chunk(WR, ?MAX_CHUNK_SIZE, 0). + +-spec chunk(#wrap_reader{}, 'infinity' | pos_integer()) -> chunk_ret(). + +chunk(WR = #wrap_reader{}, infinity) -> + chunk(WR, ?MAX_CHUNK_SIZE, 0); +chunk(WR = #wrap_reader{}, N) when is_integer(N), N > 0 -> + chunk(WR, N, 0). + +%% +%% Local functions +%% + +open_int(File, FileNo, FirstFileNo) -> + FName = add_ext(File, FileNo), + case file:open(FName, [raw, binary, read]) of + {ok, Fd} -> %% File exists + case file:read(Fd, ?HEADSZ) of + {ok, Head} -> + case disk_log_1:is_head(Head) of + no -> + file:close(Fd), + {error, {not_a_log_file, FName}}; + _ -> % yes or yes_not_closed + case last_mod_time(FName) of + {ok, ModTime} -> + WR = #wrap_reader{fd = Fd, cont = start, + file = File, + file_no = FileNo, + mod_time = ModTime, + first_no = FirstFileNo}, + {ok, WR}; + {error, E} -> + file:close(Fd), + {error, {file_error, FName, E}} + end + end; + _Other -> + file:close(Fd), + {error, {not_a_log_file, FName}} + end; + _Other -> + {error, {not_a_log_file, FName}} + end. + +chunk(WR, N, Bad) -> + #wrap_reader{fd = Fd, cont = Continue, file = File, file_no = CurFileNo, + first_no = FirstFileNo} = WR, + case read_a_chunk(Fd, N, Continue, add_ext(File, CurFileNo)) of + eof -> + case FirstFileNo of + one -> + {WR, eof}; + _Else -> + chunk_at_eof(WR, N, Bad) + end; + {ContOut, [], BadBytes} -> + ?FORMAT("chunk: empty chunk read, ~p bad bytes~n", [BadBytes]), + chunk(WR#wrap_reader{cont = ContOut}, N, Bad + BadBytes); + {ContOut, Chunk, BadBytes} when Bad + BadBytes =:= 0 -> + {WR#wrap_reader{cont = ContOut}, Chunk}; + {ContOut, Chunk, BadBytes} -> + ?FORMAT("chunk: total of ~p bad bytes~n", [BadBytes]), + {WR#wrap_reader{cont = ContOut}, Chunk, Bad + BadBytes}; + Error -> + Error + end. + +read_a_chunk(Fd, N, start, FileName) -> + read_a_chunk(Fd, FileName, 0, [], N); +read_a_chunk(Fd, N, More, FileName) -> + Pos = More#continuation.pos, + B = More#continuation.b, + read_a_chunk(Fd, FileName, Pos, B, N). + +read_a_chunk(Fd, FileName, Pos, B, N) -> + R = disk_log_1:chunk_read_only(Fd, FileName, Pos, B, N), + %% Create terms from the binaries returned from chunk_read_only/5. + %% 'foo' will do here since Log is not used in read-only mode. + Log = foo, + case disk_log:ichunk_end(R, Log) of + {C = #continuation{}, S} -> + {C, S, 0}; + Else -> + Else + end. + +chunk_at_eof(WR, N, Bad) -> + #wrap_reader{file = File, file_no = CurFileNo, + first_no = FirstFileNo} = WR, + case read_index_file(File) of + {ok, IndexFile} -> + {_, _, _, NoOfFiles} = IndexFile, + NewFileNo = case (CurFileNo + 1) rem NoOfFiles of + %% The special case described above. + _ when CurFileNo > NoOfFiles -> 1; + 0 when NoOfFiles > 1 -> NoOfFiles; + No when CurFileNo =:= NoOfFiles -> + FileName = add_ext(File, CurFileNo+1), + case file:read_file_info(FileName) of + {ok, _} -> CurFileNo + 1; + _ -> No + end; + No -> No + end, + ?FORMAT("chunk: at eof, index file: ~p, FirstFileNo: ~p, " + "CurFileNo: ~p, NoOfFiles: ~p, NewFileNo: ~p~n", + [IndexFile, FirstFileNo, CurFileNo, + NoOfFiles, NewFileNo]), + case {FirstFileNo, NewFileNo} of + {_, 0} -> {WR, eof}; + {_, FirstFileNo} -> {WR, eof}; + _ -> read_next_file(WR, N, NewFileNo, Bad) + end; + Error -> + Error + end. + +%% Read the index file for the File +%% -> {ok, {CurFileNo, CurFileSz, TotSz, NoOfFiles}} | {error, Reason} +read_index_file(File) -> + case catch disk_log_1:read_index_file(File) of + {1, 0, 0, 0} -> + {error, {index_file_not_found, File}}; + {error, _Reason} -> + {error, {index_file_not_found, File}}; + FileData -> + {ok, FileData} + end. + +%% When reading all the index files, this function closes the previous +%% index file and opens the next one. +read_next_file(WR, N, NewFileNo, Bad) -> + #wrap_reader{file = File, file_no = CurFileNo, + mod_time = ModTime, first_no = FirstFileNo} = WR, + %% If current file were closed here, then WR would be in a strange + %% state should an error occur below. + case last_mod_time(add_ext(File, NewFileNo)) of + {ok, NewModTime} -> + OldMT = calendar:datetime_to_gregorian_seconds(ModTime), + NewMT = calendar:datetime_to_gregorian_seconds(NewModTime), + Diff = NewMT - OldMT, + ?FORMAT("next: now = ~p~n last mtime = ~p~n" + " mtime = ~p~n diff = ~p~n", + [calendar:local_time(), ModTime, NewModTime, Diff]), + if + Diff < 0 -> + %% The file to be read is older than the one just finished. + {error, {is_wrapped, add_ext(File, CurFileNo)}}; + true -> + case open_int(File, NewFileNo, FirstFileNo) of + {ok, NWR} -> + close(WR), %% Now we can safely close the old file. + chunk(NWR, N, Bad); + Error -> + Error + end + end; + {error, EN} -> + {error, {file_error, add_ext(File, NewFileNo), EN}} + end. + +%% Get the last modification time of a file +last_mod_time(File) -> + case file:read_file_info(File) of + {ok, FileInfo} -> + {ok, FileInfo#file_info.mtime}; + E -> + {error, E} + end. + +add_ext(File, Ext) -> + lists:concat([File, ".", Ext]). |