The R13B03 release.OTP_R13B03

28 files changed, 16051 insertions, 0 deletions

diff --git a/lib/common_test/src/Makefile b/lib/common_test/src/Makefile
new file mode 100644
index 0000000000..e7e2d1275d
--- /dev/null
+++ b/lib/common_test/src/Makefile
@@ -0,0 +1,141 @@
+#
+# %CopyrightBegin%
+# 
+# Copyright Ericsson AB 2003-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%
+#
+
+include $(ERL_TOP)/make/target.mk
+
+# ----------------------------------------------------
+# Configuration info.
+# ----------------------------------------------------
+include $(ERL_TOP)/make/$(TARGET)/otp.mk
+
+# ----------------------------------------------------
+# Application version
+# ----------------------------------------------------
+include ../vsn.mk
+VSN=$(COMMON_TEST_VSN)
+
+# ----------------------------------------------------
+# Release directory specification
+# ----------------------------------------------------
+RELSYSDIR = $(RELEASE_PATH)/lib/common_test-$(VSN)
+
+# ----------------------------------------------------
+# Target Specs
+# ----------------------------------------------------
+
+MODULES= \
+	ct_line \
+	ct \
+	ct_logs \
+	ct_framework \
+	ct_ftp \
+	ct_ssh \
+	ct_snmp \
+	ct_gen_conn \
+	ct_rpc \
+	ct_run \
+	ct_master \
+	ct_telnet \
+	ct_util \
+	ct_cover \
+	ct_testspec \
+	ct_event \
+	ct_master_event \
+	ct_master_logs \
+	ct_master_status \
+	ct_repeat \
+	ct_telnet_client \
+	ct_make \
+	vts \
+	unix_telnet
+
+TARGET_MODULES= $(MODULES:%=$(EBIN)/%)
+
+ERL_FILES= $(MODULES:=.erl)
+HRL_FILES = \
+	ct_util.hrl
+EXTERNAL_HRL_FILES = \
+	../include/ct.hrl \
+	../include/ct_event.hrl
+
+EXTERNAL_INC_PATH = ../include
+
+DTD_FILES = \
+	mp.dtd
+
+# ----------------------------------------------------
+# FLAGS
+# ----------------------------------------------------
+ERL_COMPILE_FLAGS += -pa ../ebin -I../include -I $(ERL_TOP)/lib/snmp/include/ \
+	-I../../test_server/include -I../../xmerl/inc/ \
+	-I $(ERL_TOP)/lib/kernel/include
+
+# ----------------------------------------------------
+# Targets
+# ----------------------------------------------------
+TARGET_FILES = \
+	$(GEN_ERL_FILES:%.erl=$(EBIN)/%.$(EMULATOR)) \
+	$(MODULES:%=$(EBIN)/%.$(EMULATOR)) \
+	$(APP_TARGET) $(APPUP_TARGET)
+
+APP_FILE= common_test.app
+APP_SRC= $(APP_FILE).src
+APP_TARGET= $(EBIN)/$(APP_FILE)
+
+APPUP_FILE= common_test.appup
+APPUP_SRC= $(APPUP_FILE).src
+APPUP_TARGET= $(EBIN)/$(APPUP_FILE)
+
+tests debug opt: $(TARGET_FILES)
+
+docs:
+
+clean:
+	rm -f $(TARGET_FILES) $(GEN_FILES)
+	rm -f core
+
+# ----------------------------------------------------
+# Special Build Targets
+# ----------------------------------------------------
+$(APP_TARGET): $(APP_SRC) ../vsn.mk
+	sed -e 's;%VSN%;$(VSN);' $< > $@
+
+$(APPUP_TARGET): $(APPUP_SRC) ../vsn.mk
+	sed -e 's;%VSN%;$(VSN);' $< > $@
+
+# ----------------------------------------------------
+# Release Target
+# ---------------------------------------------------- 
+include $(ERL_TOP)/make/otp_release_targets.mk
+
+release_spec: opt
+	$(INSTALL_DIR) $(RELSYSDIR)/src
+	$(INSTALL_DATA) $(ERL_FILES) $(HRL_FILES) $(RELSYSDIR)/src
+	$(INSTALL_DIR) $(RELSYSDIR)/ebin
+	$(INSTALL_DATA) $(TARGET_FILES) $(RELSYSDIR)/ebin
+	$(INSTALL_DIR) $(RELSYSDIR)/include
+	$(INSTALL_DATA) $(EXTERNAL_HRL_FILES) $(RELSYSDIR)/include
+
+release_tests_spec: opt
+	$(INSTALL_DIR) $(RELEASE_PATH)/common_test_test
+	$(INSTALL_DATA) $(ERL_FILES)  \
+        $(HRL_FILES) $(TARGET_FILES) $(RELEASE_PATH)/common_test_test
+
+release_docs_spec: docs
+
diff --git a/lib/common_test/src/common_test.app.src b/lib/common_test/src/common_test.app.src
new file mode 100644
index 0000000000..7b72932ad4
--- /dev/null
+++ b/lib/common_test/src/common_test.app.src
@@ -0,0 +1,55 @@
+% This is an -*- erlang -*- file.
+%% %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%
+
+{application, common_test,
+ [{description, "The OTP Common Test application"},
+  {vsn, "%VSN%"},
+  {modules, [ct_cover,
+	     ct,
+	     ct_event,
+	     ct_framework,
+	     ct_ftp,
+	     ct_gen_conn,
+	     ct_line,
+	     ct_logs,
+	     ct_make,
+	     ct_master,
+	     ct_master_event,
+	     ct_master_logs,
+	     ct_master_status,
+	     ct_repeat,
+	     ct_rpc,
+	     ct_run,
+	     ct_snmp,
+	     ct_ssh,
+	     ct_telnet_client,
+	     ct_telnet,
+	     ct_testspec,
+	     ct_util,
+	     unix_telnet,
+	     vts
+	    ]},
+  {registered, [ct_logs,
+		ct_util_server,
+		ct_make_ref,
+		vts,
+		ct_master,
+		ct_master_logs]},
+  {applications, [kernel,stdlib]},
+  {env, []}]}.
+
diff --git a/lib/common_test/src/common_test.appup.src b/lib/common_test/src/common_test.appup.src
new file mode 100644
index 0000000000..0fbe5f23f7
--- /dev/null
+++ b/lib/common_test/src/common_test.appup.src
@@ -0,0 +1 @@
+{"%VSN%",[],[]}.
\ No newline at end of file
diff --git a/lib/common_test/src/ct.erl b/lib/common_test/src/ct.erl
new file mode 100644
index 0000000000..8ae041e5b4
--- /dev/null
+++ b/lib/common_test/src/ct.erl
@@ -0,0 +1,789 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 2003-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%
+%%
+
+%%% @doc Main user interface for the Common Test framework.
+%%%
+%%% <p> This module implements the command line interface for running
+%%% tests and some basic functions for common test case issues
+%%% such as configuration and logging. </p>
+%%%
+%%% <p><strong>Test Suite Support Macros</strong></p>
+%%%
+%%% <p>The <code>config</code> macro is defined in <code>ct.hrl</code>. This
+%%% macro should be used to retrieve information from the
+%%% <code>Config</code> variable sent to all test cases. It is used with two
+%%% arguments, where the first is the name of the configuration
+%%% variable you wish to retrieve, and the second is the <code>Config</code>
+%%% variable supplied to the test case.</p>
+%%%
+%%% <p>Possible configuration variables include:</p>
+%%% <ul>
+%%%   <li><code>data_dir</code>  - Data file directory.</li>
+%%%   <li><code>priv_dir</code>  - Scratch file directory.</li>
+%%%   <li>Whatever added by <code>init_per_suite/1</code> or
+%%%   <code>init_per_testcase/2</code> in the test suite.</li>
+%%% </ul>
+
+%%% @type var_name() = atom(). A variable name which is specified when
+%%% <code>ct:require/2</code> is called,
+%%% e.g. <code>ct:require(mynodename,{node,[telnet]})</code>
+%%%
+%%% @type target_name() = var_name(). The name of a target.
+%%%
+%%% @type handle() = ct_gen_conn:handle() | term(). The identity of a
+%%% specific connection.
+
+-module(ct).
+
+%% Command line user interface for running tests
+-export([install/1, run/1, run/2, run/3,
+	 run_test/1, run_testspec/1, step/3, step/4,
+	 start_interactive/0, stop_interactive/0]).
+
+%% Test suite API
+-export([require/1, require/2,
+	 get_config/1, get_config/2, get_config/3,
+	 log/1, log/2, log/3,
+	 print/1, print/2, print/3,
+	 pal/1, pal/2, pal/3,
+	 fail/1, comment/1,
+	 testcases/2, userdata/2, userdata/3]).
+
+%% Other interface functions
+-export([get_status/0, abort_current_testcase/1,
+	 encrypt_config_file/2, encrypt_config_file/3,
+	 decrypt_config_file/2, decrypt_config_file/3]).
+
+
+-export([get_target_name/1]).
+-export([parse_table/1, listenv/1]).
+
+%%%-----------------------------------------------------------------
+%%% @spec install(Opts) -> ok | {error,Reason}
+%%%    Opts = [Opt]
+%%%    Opt = {config,ConfigFiles} | {event_handler,Modules} | 
+%%%          {decrypt,KeyOrFile}
+%%%    ConfigFiles = [ConfigFile]
+%%%    ConfigFile = string()
+%%%    Modules = [atom()]
+%%%    KeyOrFile = {key,Key} | {file,KeyFile}
+%%%    Key = string()
+%%%    KeyFile = string()
+%%% @doc Install config files and event handlers.
+%%%
+%%% <p>Run this function once before first test.</p>
+%%%
+%%% <p>Example:<br/>
+%%% <code>install([{config,["config_node.ctc","config_user.ctc"]}])</code>.</p>
+%%%
+%%% <p>Note that this function is automatically run by the
+%%% <code>run_test</code> script.</p>
+install(Opts) ->
+    ct_run:install(Opts).
+
+%%%-----------------------------------------------------------------
+%%% @spec run(TestDir,Suite,Cases) -> Result
+%%%   TestDir = string()
+%%%   Suite = atom()
+%%%   Cases = atom() | [atom()]
+%%%   Result = [TestResult] | {error,Reason}
+%%%
+%%% @doc Run the given testcase(s).
+%%%
+%%% <p>Requires that <code>ct:install/1</code> has been run first.</p>
+%%%
+%%% <p>Suites (*_SUITE.erl) files must be stored in
+%%% <code>TestDir</code> or <code>TestDir/test</code>.  All suites
+%%% will be compiled when test is run.</p>
+run(TestDir,Suite,Cases) ->
+    ct_run:run(TestDir,Suite,Cases).
+
+%%%-----------------------------------------------------------------
+%%% @spec run(TestDir,Suite) -> Result
+%%%
+%%% @doc Run all testcases in the given suite.
+%%% @see run/3.
+run(TestDir,Suite) ->
+    ct_run:run(TestDir,Suite).
+
+%%%-----------------------------------------------------------------
+%%% @spec run(TestDirs) -> Result
+%%%   TestDirs = TestDir | [TestDir]
+%%%
+%%% @doc Run all testcases in all suites in the given directories.
+%%% @see run/3.
+run(TestDirs) ->
+    ct_run:run(TestDirs).
+
+%%%-----------------------------------------------------------------
+%%% @spec run_test(Opts) -> Result
+%%%   Opts = [OptTuples]
+%%%   OptTuples = {config,CfgFiles} | {dir,TestDirs} | {suite,Suites} |
+%%%               {testcase,Cases} | {group,Groups} | {spec,TestSpecs} | 
+%%%               {allow_user_terms,Bool} | {logdir,LogDir} | 
+%%%               {silent_connections,Conns} | {cover,CoverSpecFile} | 
+%%%               {step,StepOpts} | {event_handler,EventHandlers} | {include,InclDirs} | 
+%%%               {auto_compile,Bool} | {repeat,N} | {duration,DurTime} | 
+%%%               {until,StopTime} | {force_stop,Bool} | {decrypt,DecryptKeyOrFile} |
+%%%               {refresh_logs,LogDir} | {basic_html,Bool}
+%%%   CfgFiles = [string()] | string()
+%%%   TestDirs = [string()] | string()
+%%%   Suites = [string()] | string()
+%%%   Cases = [atom()] | atom()
+%%%   Groups = [atom()] | atom()
+%%%   TestSpecs = [string()] | string()
+%%%   LogDir = string()
+%%%   Conns = all | [atom()]
+%%%   CoverSpecFile = string()
+%%%   StepOpts = [StepOpt] | []
+%%%   StepOpt = config | keep_inactive
+%%%   EventHandlers = EH | [EH]
+%%%   EH = atom() | {atom(),InitArgs} | {[atom()],InitArgs}
+%%%   InitArgs = [term()]
+%%%   InclDirs = [string()] | string()
+%%%   N = integer()
+%%%   DurTime = string(HHMMSS)
+%%%   StopTime = string(YYMoMoDDHHMMSS) | string(HHMMSS)
+%%%   DecryptKeyOrFile = {key,DecryptKey} | {file,DecryptFile}
+%%%   DecryptKey = string()
+%%%   DecryptFile = string()
+%%%   Result = [TestResult] | {error,Reason}
+%%% @doc Run tests as specified by the combination of options in <code>Opts</code>.
+%%% The options are the same as those used with the <code>run_test</code> script.
+%%% Note that here a <code>TestDir</code> can be used to point out the path to 
+%%% a <code>Suite</code>. Note also that the option <code>testcase</code>
+%%% corresponds to the <code>-case</code> option in the <code>run_test</code> 
+%%% script. Configuration files specified in <code>Opts</code> will be 
+%%% installed automatically at startup.
+run_test(Opts) ->
+    ct_run:run_test(Opts).
+
+%%%-----------------------------------------------------------------
+%%% @spec run_testspec(TestSpec) -> Result
+%%%   TestSpec = [term()]
+%%% @doc Run test specified by <code>TestSpec</code>. The terms are
+%%% the same as those used in test specification files.
+run_testspec(TestSpec) ->
+    ct_run:run_testspec(TestSpec).
+    
+%%%-----------------------------------------------------------------
+%%% @spec step(TestDir,Suite,Case) -> Result
+%%%   Case = atom()
+%%%
+%%% @doc Step through a test case with the debugger.
+%%% @see run/3
+step(TestDir,Suite,Case) ->
+    ct_run:step(TestDir,Suite,Case).
+
+%%%-----------------------------------------------------------------
+%%% @spec step(TestDir,Suite,Case,Opts) -> Result
+%%%   Case = atom()
+%%%   Opts = [Opt] | []
+%%%   Opt = config | keep_inactive
+%%%
+%%% @doc Step through a test case with the debugger. If the
+%%% <code>config</code> option has been given, breakpoints will
+%%% be set also on the configuration functions in <code>Suite</code>.
+%%% @see run/3
+step(TestDir,Suite,Case,Opts) ->
+    ct_run:step(TestDir,Suite,Case,Opts).
+
+%%%-----------------------------------------------------------------
+%%% @spec start_interactive() -> ok
+%%%
+%%% @doc Start CT in interactive mode.
+%%%
+%%% <p>From this mode all test case support functions can be executed
+%%% directly from the erlang shell. The interactive mode can also be
+%%% started from the unix command line with <code>run_test -shell
+%%% [-config File...]</code>.</p>
+%%%
+%%% <p>If any functions using "required config data" (e.g. telnet or
+%%% ftp functions) are to be called from the erlang shell, config data
+%%% must first be required with <code>ct:require/2</code>.</p>
+%%%
+%%% <p>Example:<br/>
+%%% <code>&gt; ct:require(unix_telnet, unix).</code><br/>
+%%% <code>ok</code><br/>
+%%% <code>&gt; ct_telnet:open(unix_telnet).</code><br/>
+%%% <code>{ok,&lt;0.105.0&gt;}</code><br/>
+%%% <code>&gt; ct_telnet:cmd(unix_telnet, "ls .").</code><br/>
+%%% <code>{ok,["ls","file1  ...",...]}</code></p>
+start_interactive() ->
+    ct_util:start(interactive).
+
+%%%-----------------------------------------------------------------
+%%% @spec stop_interactive() -> ok
+%%%
+%%% @doc Exit the interactive mode.
+%%% @see start_interactive/0
+stop_interactive() ->
+    ct_util:stop(normal).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%% MISC INTERFACE
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+%%%-----------------------------------------------------------------
+%%% @spec require(Required) -> ok | {error,Reason}
+%%%      Required = Key | {Key,SubKeys}
+%%%      Key = atom()
+%%%      SubKeys = SubKey | [SubKey]
+%%%      SubKey = atom()
+%%%
+%%% @doc Check if the required configuration is available.
+%%%
+%%% <p>Example: require the variable <code>myvar</code>:<br/>
+%%% <code>ok = ct:require(myvar)</code></p>
+%%%
+%%% <p>In this case the config file must at least contain:</p>
+%%% <pre>
+%%% {myvar,Value}.</pre>
+%%% 
+%%% <p>Example: require the variable <code>myvar</code> with
+%%% subvariable <code>sub1</code>:<br/>
+%%% <code>ok = ct:require({myvar,sub1})</code></p>
+%%%
+%%% <p>In this case the config file must at least contain:</p>
+%%% <pre>
+%%% {myvar,[{sub1,Value}]}.</pre>
+%%%
+%%% @see require/2
+%%% @see get_config/1
+%%% @see get_config/2
+%%% @see get_config/3
+require(Required) ->
+    ct_util:require(Required).
+
+%%%-----------------------------------------------------------------
+%%% @spec require(Name,Required) -> ok | {error,Reason}
+%%%      Name = atom()
+%%%      Required = Key | {Key,SubKeys}
+%%%      Key = atom()
+%%%      SubKeys = SubKey | [SubKey]
+%%%      SubKey = atom()
+%%%
+%%% @doc Check if the required configuration is available, and give it
+%%% a name.
+%%%
+%%% <p>If the requested data is available, the main entry will be
+%%% associated with <code>Name</code> so that the value of the element
+%%% can be read with <code>get_config/1,2</code> provided
+%%% <code>Name</code> instead of the <code>Key</code>.</p>
+%%%
+%%% <p>Example: Require one node with a telnet connection and an
+%%% ftp connection. Name the node <code>a</code>:<br/> <code>ok =
+%%% ct:require(a,{node,[telnet,ftp]}).</code><br/> All references
+%%% to this node may then use the node name. E.g. you can fetch a
+%%% file over ftp like this:<br/>
+%%% <code>ok = ct:ftp_get(a,RemoteFile,LocalFile).</code></p>
+%%%
+%%% <p>For this to work, the config file must at least contain:</p>
+%%% <pre>
+%%% {node,[{telnet,IpAddr},
+%%%        {ftp,IpAddr}]}.</pre>
+%%%
+%%% @see require/1
+%%% @see get_config/1
+%%% @see get_config/2
+%%% @see get_config/3
+require(Name,Required) ->
+    ct_util:require(Name,Required).
+
+%%%-----------------------------------------------------------------
+%%% @spec get_config(Required) -> Value
+%%% @equiv get_config(Required,undefined,[])
+get_config(Required) ->
+    ct_util:get_config(Required,undefined,[]).
+
+%%%-----------------------------------------------------------------
+%%% @spec get_config(Required,Default) -> Value
+%%% @equiv get_config(Required,Default,[])
+get_config(Required,Default) ->
+    ct_util:get_config(Required,Default,[]).
+
+%%%-----------------------------------------------------------------
+%%% @spec get_config(Required,Default,Opts) -> ValueOrElement
+%%%      Required = KeyOrName | {KeyOrName,SubKey}
+%%%      KeyOrName = atom()
+%%%      SubKey = atom()
+%%%      Default = term()
+%%%      Opts = [Opt] | []
+%%%      Opt = element | all
+%%%      ValueOrElement = term() | Default
+%%%
+%%% @doc Read config data values.
+%%%
+%%% <p>This function returns the matching value(s) or config element(s),
+%%% given a config variable key or its associated name
+%%% (if one has been specified with <code>require/2</code> or a 
+%%% require statement).</p>
+%%%
+%%% <p>Example, given the following config file:</p>
+%%% <pre>
+%%% {unix,[{telnet,IpAddr},
+%%%        {username,Username},
+%%%        {password,Password}]}.</pre>
+%%% <p><code>get_config(unix,Default) -> 
+%%%                          [{telnet,IpAddr},
+%%%                           {username,Username},
+%%%                           {password,Password}]</code><br/>
+%%% <code>get_config({unix,telnet},Default) -> IpAddr</code><br/>
+%%% <code>get_config({unix,ftp},Default) -> Default</code><br/>
+%%% <code>get_config(unknownkey,Default) -> Default</code></p>
+%%%
+%%% <p>If a config variable key has been associated with a name (by
+%%% means of <code>require/2</code> or a require statement), the name 
+%%% may be used instead of the key to read the value:</p>
+%%%
+%%% <p><code>require(myhost,unix) -> ok</code><br/>
+%%% <code>get_config(myhost,Default) -> 
+%%%                          [{telnet,IpAddr},
+%%%                           {username,Username},
+%%%                           {password,Password}]</code></p>
+%%%
+%%% <p>If a config variable is defined in multiple files and you want to
+%%% access all possible values, use the <code>all</code> option. The
+%%% values will be returned in a list and the order of the elements
+%%% corresponds to the order that the config files were specified at 
+%%% startup.</p>
+%%%
+%%% <p>If you want config elements (key-value tuples) returned as result 
+%%% instead of values, use the <code>element</code> option. 
+%%% The returned elements will then be on the form <code>{KeyOrName,Value}</code>, 
+%%% or (in case a subkey has been specified)
+%%% <code>{{KeyOrName,SubKey},Value}</code></p>
+%%%
+%%% @see get_config/1
+%%% @see get_config/2
+%%% @see require/1
+%%% @see require/2
+get_config(Required,Default,Opts) ->
+    ct_util:get_config(Required,Default,Opts).
+
+%%%-----------------------------------------------------------------
+%%% @spec log(Format) -> ok
+%%% @equiv log(default,Format,[])
+log(Format) ->
+    log(default,Format,[]).
+
+%%%-----------------------------------------------------------------
+%%% @spec log(X1,X2) -> ok
+%%%      X1 = Category | Format
+%%%      X2 = Format | Args
+%%% @equiv log(Category,Format,Args)
+log(X1,X2) ->
+    {Category,Format,Args} = 
+	if is_atom(X1) -> {X1,X2,[]};
+	   is_list(X1) -> {default,X1,X2}
+	end,
+    log(Category,Format,Args).
+
+%%%-----------------------------------------------------------------
+%%% @spec log(Category,Format,Args) -> ok
+%%%      Category = atom()
+%%%      Format = string()
+%%%      Args = list()
+%%%
+%%% @doc Printout from a testcase to the log. 
+%%%
+%%% <p>This function is meant for printing stuff directly from a
+%%% testcase (i.e. not from within the CT framework) in the test
+%%% log.</p>
+%%%
+%%% <p>Default <code>Category</code> is <code>default</code> and
+%%% default <code>Args</code> is <code>[]</code>.</p>
+log(Category,Format,Args) ->
+    ct_logs:tc_log(Category,Format,Args).
+
+
+%%%-----------------------------------------------------------------
+%%% @spec print(Format) -> ok
+%%% @equiv print(default,Format,[])
+print(Format) ->
+    print(default,Format,[]).
+
+%%%-----------------------------------------------------------------
+%%% @equiv print(Category,Format,Args)
+print(X1,X2) ->
+    {Category,Format,Args} = 
+	if is_atom(X1) -> {X1,X2,[]};
+	   is_list(X1) -> {default,X1,X2}
+	end,
+    print(Category,Format,Args).
+
+%%%-----------------------------------------------------------------
+%%% @spec print(Category,Format,Args) -> ok
+%%%      Category = atom()
+%%%      Format = string()
+%%%      Args = list()
+%%%
+%%% @doc Printout from a testcase to the console. 
+%%%
+%%% <p>This function is meant for printing stuff from a testcase on
+%%% the console.</p>
+%%%
+%%% <p>Default <code>Category</code> is <code>default</code> and
+%%% default <code>Args</code> is <code>[]</code>.</p>
+print(Category,Format,Args) ->
+    ct_logs:tc_print(Category,Format,Args).
+
+
+%%%-----------------------------------------------------------------
+%%% @spec pal(Format) -> ok
+%%% @equiv pal(default,Format,[])
+pal(Format) ->
+    pal(default,Format,[]).
+
+%%%-----------------------------------------------------------------
+%%% @spec pal(X1,X2) -> ok
+%%%      X1 = Category | Format
+%%%      X2 = Format | Args
+%%% @equiv pal(Category,Format,Args)
+pal(X1,X2) ->
+    {Category,Format,Args} = 
+	if is_atom(X1) -> {X1,X2,[]};
+	   is_list(X1) -> {default,X1,X2}
+	end,
+    pal(Category,Format,Args).
+
+%%%-----------------------------------------------------------------
+%%% @spec pal(Category,Format,Args) -> ok
+%%%      Category = atom()
+%%%      Format = string()
+%%%      Args = list()
+%%%
+%%% @doc Print and log from a testcase. 
+%%%
+%%% <p>This function is meant for printing stuff from a testcase both
+%%% in the log and on the console.</p>
+%%%
+%%% <p>Default <code>Category</code> is <code>default</code> and
+%%% default <code>Args</code> is <code>[]</code>.</p>
+pal(Category,Format,Args) ->
+    ct_logs:tc_pal(Category,Format,Args).
+
+
+%%%-----------------------------------------------------------------
+%%% @spec fail(Reason) -> void()
+%%%      Reason = term()
+%%%
+%%% @doc Terminate a test case with the given error
+%%% <code>Reason</code>.
+fail(Reason) ->
+    exit({test_case_failed,Reason}).
+
+%%%-----------------------------------------------------------------
+%%% @spec comment(Comment) -> void()
+%%%      Comment = term()
+%%%
+%%% @doc Print the given <code>Comment</code> in the comment field of
+%%% the table on the test suite result page.
+%%%
+%%% <p>If called several times, only the last comment is printed.
+%%% <code>comment/1</code> is also overwritten by the return value
+%%% <code>{comment,Comment}</code> or by the function
+%%% <code>fail/1</code> (which prints <code>Reason</code> as a
+%%% comment).</p>
+comment(Comment) when is_list(Comment) ->
+    Formatted =
+	case (catch io_lib:format("~s",[Comment])) of
+	    {'EXIT',_} ->  % it's a list not a string
+		io_lib:format("~p",[Comment]);
+	    String ->
+		String
+	end,
+    send_html_comment(lists:flatten(Formatted));
+comment(Comment) ->
+    Formatted = io_lib:format("~p",[Comment]),
+    send_html_comment(lists:flatten(Formatted)).
+
+send_html_comment(Comment) ->
+    Html = "<font color=\"green\">" ++ Comment ++ "</font>",
+    ct_util:set_testdata({comment,Html}),
+    test_server:comment(Html).
+
+
+%%%-----------------------------------------------------------------
+%%% @spec get_target_name(Handle) -> {ok,TargetName} | {error,Reason}
+%%%      Handle = handle()
+%%%      TargetName = target_name()
+%%% @doc Return the name of the target that the given connection
+%%% belongs to.
+get_target_name(Handle) ->
+    ct_util:get_target_name(Handle).
+    
+%%%-----------------------------------------------------------------
+%%% @spec parse_table(Data) -> {Heading,Table}
+%%%       Data = [string()]
+%%%       Heading = tuple()
+%%%       Table = [tuple()]
+%%%
+%%% @doc Parse the printout from an SQL table and return a list of tuples.
+%%%
+%%% <p>The printout to parse would typically be the result of a
+%%% <code>select</code> command in SQL. The returned
+%%% <code>Table</code> is a list of tuples, where each tuple is a row
+%%% in the table.</p>
+%%% 
+%%% <p><code>Heading</code> is a tuple of strings representing the
+%%% headings of each column in the table.</p>
+parse_table(Data) ->
+    ct_util:parse_table(Data).
+
+%%%-----------------------------------------------------------------
+%%% @spec listenv(Telnet) -> [Env]
+%%%       Telnet = term()
+%%%       Env = {Key,Value}
+%%%       Key = string()
+%%%       Value = string()
+%%%
+%%% @doc Performs the listenv command on the given telnet connection
+%%% and returns the result as a list of Key-Value pairs.
+listenv(Telnet) ->
+    ct_util:listenv(Telnet).
+
+
+%%%-----------------------------------------------------------------
+%%% @spec testcases(TestDir, Suite) -> Testcases | {error,Reason}
+%%%       TestDir = string()
+%%%       Suite = atom()
+%%%       Testcases = list()
+%%%       Reason = term()
+%%%
+%%% @doc Returns all testcases in the specified suite.
+testcases(TestDir, Suite) ->
+    case make_and_load(TestDir, Suite) of
+	E = {error,_} ->
+	    E;
+	_ ->
+	    case (catch Suite:all()) of
+		{'EXIT',Reason} ->
+		    {error,Reason};
+		TCs ->
+		    TCs
+	    end
+    end.
+
+make_and_load(Dir, Suite) ->
+    EnvInclude =
+	case os:getenv("CT_INCLUDE_PATH") of
+	    false -> [];
+	    CtInclPath -> string:tokens(CtInclPath, [$:,$ ,$,])
+	end,
+    StartInclude =
+	case init:get_argument(include) of
+	    {ok,[Dirs]} -> Dirs;
+	    _ -> []
+	end,
+    UserInclude = EnvInclude ++ StartInclude,
+    case ct_run:run_make(Dir, Suite, UserInclude) of
+	MErr = {error,_} ->
+	    MErr;
+	_ ->
+	    TestDir = ct_util:get_testdir(Dir, Suite),
+	    File = filename:join(TestDir, atom_to_list(Suite)),
+	    case code:soft_purge(Suite) of
+		true ->
+		    code:load_abs(File);
+		false ->			% will use loaded
+		    {module,Suite}
+	    end
+    end.
+
+%%%-----------------------------------------------------------------
+%%% @spec userdata(TestDir, Suite) -> SuiteUserData | {error,Reason}
+%%%       TestDir = string()
+%%%       Suite = atom()
+%%%       SuiteUserData = [term()]
+%%%       Reason = term()
+%%%
+%%% @doc Returns any data specified with the tag <code>userdata</code> 
+%%% in the list of tuples returned from <code>Suite:suite/0</code>.
+userdata(TestDir, Suite) ->
+    case make_and_load(TestDir, Suite) of
+	E = {error,_} ->
+	    E;
+	_ ->
+	    Info = (catch Suite:suite()),
+	    get_userdata(Info, "suite/0")
+    end.
+
+get_userdata({'EXIT',{undef,_}}, Spec) ->
+    {error,list_to_atom(Spec ++ " is not defined")};
+get_userdata({'EXIT',Reason}, Spec) ->
+    {error,{list_to_atom("error in " ++ Spec),Reason}};
+get_userdata(List, _) when is_list(List) ->
+    Fun = fun({userdata,Data}, Acc) -> [Data | Acc];
+	     (_, Acc) -> Acc
+	  end,
+    case lists:foldl(Fun, [], List) of
+	Terms ->
+	    lists:flatten(lists:reverse(Terms))
+    end;
+get_userdata(_BadTerm, Spec) ->
+    {error,list_to_atom(Spec ++ " must return a list")}.
+   
+%%%-----------------------------------------------------------------
+%%% @spec userdata(TestDir, Suite, Case) -> TCUserData | {error,Reason}
+%%%       TestDir = string()
+%%%       Suite = atom()
+%%%       Case = atom()
+%%%       TCUserData = [term()]
+%%%       Reason = term()
+%%%
+%%% @doc Returns any data specified with the tag <code>userdata</code>
+%%% in the list of tuples returned from <code>Suite:Case/0</code>.
+userdata(TestDir, Suite, Case) ->
+    case make_and_load(TestDir, Suite) of
+	E = {error,_} ->
+	    E;
+	_ ->
+	    Info = (catch apply(Suite, Case, [])),
+	    get_userdata(Info, atom_to_list(Case)++"/0")
+    end.
+
+
+%%%-----------------------------------------------------------------
+%%% @spec get_status() -> TestStatus | {error,Reason}
+%%%       TestStatus = [StatusElem]
+%%%       StatusElem = {current,{Suite,TestCase}} | {successful,Successful} |
+%%%                    {failed,Failed} | {skipped,Skipped} | {total,Total}
+%%%       Suite = atom()
+%%%       TestCase = atom()
+%%%       Successful = integer()
+%%%       Failed = integer()
+%%%       Skipped = {UserSkipped,AutoSkipped}
+%%%       UserSkipped = integer()
+%%%       AutoSkipped = integer()
+%%%       Total = integer()
+%%%       Reason = term()
+%%%
+%%% @doc Returns status of ongoing test. The returned list contains info about
+%%%      which test case is currently executing, as well as counters for 
+%%%      successful, failed, skipped, and total test cases so far.
+get_status() ->
+    case get_testdata(curr_tc) of
+	{ok,TestCase} ->
+	    case get_testdata(stats) of
+		{ok,{Ok,Failed,Skipped={UserSkipped,AutoSkipped}}} ->
+		    [{current,TestCase},
+		     {successful,Ok},
+		     {failed,Failed},
+		     {skipped,Skipped},
+		     {total,Ok+Failed+UserSkipped+AutoSkipped}];
+		Err1 -> Err1
+	    end;
+	Err2 -> Err2
+    end.
+	    
+get_testdata(Key) ->
+    case catch ct_util:get_testdata(Key) of
+	Error = {error,_Reason} ->
+	    Error;
+	{'EXIT',_Reason} ->
+	    no_tests_running;
+	Data ->
+	    {ok,Data}
+    end.
+
+%%%-----------------------------------------------------------------
+%%% @spec abort_current_testcase(Reason) -> ok | {error,no_testcase_running}
+%%%       Reason = term()
+%%%
+%%% @doc <p>When calling this function, the currently executing test case will be aborted.
+%%%      It is the user's responsibility to know for sure which test case is currently
+%%%	 executing. The function is therefore only safe to call from a function which
+%%%	 has been called (or synchronously invoked) by the test case.</p>
+%%%
+%%%      <p><code>Reason</code>, the reason for aborting the test case, is printed
+%%%      in the test case log.</p>
+abort_current_testcase(Reason) ->
+    test_server_ctrl:abort_current_testcase(Reason).
+
+%%%-----------------------------------------------------------------
+%%% @spec encrypt_config_file(SrcFileName, EncryptFileName) -> 
+%%%                                                  ok | {error,Reason}
+%%%       SrcFileName = string()
+%%%       EncryptFileName = string()
+%%%       Reason = term()
+%%%
+%%% @doc <p>This function encrypts the source config file with DES3 and 
+%%%      saves the result in file <code>EncryptFileName</code>. The key,
+%%%      a string, must be available in a text file named 
+%%%      <code>.ct_config.crypt</code> in the current directory, or the 
+%%%      home directory of the user (it is searched for in that order).</p>
+%%%      <p>See the Common Test User's Guide for information about using
+%%%      encrypted config files when running tests.</p>
+%%%      <p>See the <code>crypto</code> application for details on DES3
+%%%      encryption/decryption.</p>
+encrypt_config_file(SrcFileName, EncryptFileName) ->
+    ct_util:encrypt_config_file(SrcFileName, EncryptFileName).
+
+%%%-----------------------------------------------------------------
+%%% @spec encrypt_config_file(SrcFileName, EncryptFileName, KeyOrFile) -> 
+%%%                                                  ok | {error,Reason}
+%%%       SrcFileName = string()
+%%%       EncryptFileName = string()
+%%%       KeyOrFile = {key,string()} | {file,string()}
+%%%       Reason = term()
+%%%
+%%% @doc <p>This function encrypts the source config file with DES3 and
+%%%      saves the result in the target file <code>EncryptFileName</code>. 
+%%%      The encryption key to use is either the value in 
+%%%      <code>{key,Key}</code> or the value stored in the file specified 
+%%%      by <code>{file,File}</code>.</p>
+%%%      <p>See the Common Test User's Guide for information about using
+%%%      encrypted config files when running tests.</p>
+%%%      <p>See the <code>crypto</code> application for details on DES3
+%%%      encryption/decryption.</p>
+encrypt_config_file(SrcFileName, EncryptFileName, KeyOrFile) ->
+    ct_util:encrypt_config_file(SrcFileName, EncryptFileName, KeyOrFile).
+
+%%%-----------------------------------------------------------------
+%%% @spec decrypt_config_file(EncryptFileName, TargetFileName) -> 
+%%%                                                   ok | {error,Reason}
+%%%       EncryptFileName = string()
+%%%       TargetFileName = string()
+%%%       Reason = term()
+%%%
+%%% @doc <p>This function decrypts <code>EncryptFileName</code>, previously 
+%%%      generated with <code>encrypt_config_file/2/3</code>. The original
+%%%      file contents is saved in the target file. The encryption key, a
+%%%      string, must be available in a text file named
+%%%      <code>.ct_config.crypt</code> in the current directory, or the
+%%%      home directory of the user (it is searched for in that order).</p>
+decrypt_config_file(EncryptFileName, TargetFileName) ->
+    ct_util:decrypt_config_file(EncryptFileName, TargetFileName).
+
+%%%-----------------------------------------------------------------
+%%% @spec decrypt_config_file(EncryptFileName, TargetFileName, KeyOrFile) -> 
+%%%                                                   ok | {error,Reason}
+%%%       EncryptFileName = string()
+%%%       TargetFileName = string()
+%%%       KeyOrFile = {key,string()} | {file,string()}
+%%%       Reason = term()
+%%%
+%%% @doc <p>This function decrypts <code>EncryptFileName</code>, previously 
+%%%      generated with <code>encrypt_config_file/2/3</code>. The original
+%%%      file contents is saved in the target file. The key must have the
+%%%      the same value as that used for encryption.</p>
+decrypt_config_file(EncryptFileName, TargetFileName, KeyOrFile) ->
+    ct_util:decrypt_config_file(EncryptFileName, TargetFileName, KeyOrFile).
+
diff --git a/lib/common_test/src/ct_cover.erl b/lib/common_test/src/ct_cover.erl
new file mode 100644
index 0000000000..d39f50ba00
--- /dev/null
+++ b/lib/common_test/src/ct_cover.erl
@@ -0,0 +1,368 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 2006-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%
+%%
+
+%%% @doc Common Test Framework code coverage support module.
+%%%
+%%% <p>This module exports help functions for performing code 
+%%%    coverage analysis.</p>
+
+-module(ct_cover).
+
+-export([get_spec/1, add_nodes/1, remove_nodes/1]).
+
+-include("ct_util.hrl").
+
+-include_lib("kernel/include/file.hrl").
+
+%%%-----------------------------------------------------------------
+%%% @spec add_nodes(Nodes) -> {ok,StartedNodes} | {error,Reason}
+%%%    Nodes = [atom()]
+%%%    StartedNodes = [atom()]
+%%%    Reason = cover_not_running | not_main_node
+%%%
+%%% @doc Add nodes to current cover test (only works if cover support 
+%%%      is active!). To have effect, this function should be called
+%%%      from init_per_suite/1 before any actual tests are performed.
+%%% 
+add_nodes([]) ->
+    {ok,[]};
+add_nodes(Nodes) ->
+    case whereis(cover_server) of
+	undefined ->
+	    {error,cover_not_running};
+	_ ->
+	    {File,Nodes0,Import,Export,AppInfo} = ct_util:get_testdata(cover),
+	    Nodes1 = [Node || Node <- Nodes,
+			      lists:member(Node,Nodes0) == false],
+	    ct_logs:log("COVER INFO",
+			"Adding nodes to cover test: ~w", [Nodes1]),
+	    case cover:start(Nodes1) of
+		Result = {ok,_} ->
+		    ct_util:set_testdata({cover,{File,Nodes1++Nodes0,
+						 Import,Export,AppInfo}}),
+		    
+		    Result;
+		Error ->
+		    Error
+	    end
+    end.
+
+
+%%%-----------------------------------------------------------------
+%%% @spec remove_nodes(Nodes) -> ok | {error,Reason}
+%%%    Nodes = [atom()]
+%%%    Reason = cover_not_running | not_main_node
+%%%
+%%% @doc Remove nodes from current cover test. Call this function
+%%%      to stop cover test on nodes previously added with add_nodes/1. 
+%%%      Results on the remote node are transferred to the Common Test 
+%%%      node.
+%%% 
+remove_nodes([]) ->
+    ok;
+remove_nodes(Nodes) ->
+    case whereis(cover_server) of
+	undefined ->
+	    {error,cover_not_running};
+	_ ->
+	    {File,Nodes0,Import,Export,AppInfo} = ct_util:get_testdata(cover),
+	    ToRemove = [Node || Node <- Nodes, lists:member(Node,Nodes0)],
+	    ct_logs:log("COVER INFO",
+			"Removing nodes from cover test: ~w", [ToRemove]),	    
+	    case cover:stop(ToRemove) of
+		ok ->
+		    Nodes1 = lists:foldl(fun(N,Deleted) -> 
+						 lists:delete(N,Deleted) 
+					 end, Nodes0, ToRemove),
+		    ct_util:set_testdata({cover,{File,Nodes1,
+						 Import,Export,AppInfo}}),
+		    ok;
+		Error ->
+		    Error
+	    end
+    end.
+    
+    
+%%%-----------------------------------------------------------------
+%%% @hidden 
+
+%% Read cover specification file and return the parsed info.
+%% -> CoverSpec: {CoverFile,Nodes,Import,Export,AppCoverInfo}
+get_spec(File) ->
+    catch get_spec_test(File).
+
+get_spec_test(File) ->
+    FullName = filename:absname(File),
+    case filelib:is_file(FullName) of
+	true ->
+	    case file:consult(FullName) of
+		{ok,Terms} ->
+		    Import = 
+			case lists:keysearch(import, 1, Terms) of
+			    {value,{_,Imps=[S|_]}} when is_list(S) ->
+				ImpsFN = lists:map(fun(F) -> 
+							  filename:absname(F) 
+						  end, Imps),
+				test_files(ImpsFN, ImpsFN);
+			    {value,{_,Imp=[IC|_]}} when is_integer(IC) ->
+				ImpFN = filename:absname(Imp),
+				test_files([ImpFN], [ImpFN]);
+			    _ -> 
+				[]
+			end,
+		    Export = 
+			case lists:keysearch(export, 1, Terms) of
+			    {value,{_,Exp=[EC|_]}} when is_integer(EC) -> 
+				filename:absname(Exp);
+			    {value,{_,[Exp]}} ->
+				filename:absname(Exp);
+			    _ -> 
+				[]
+			end,
+		    Nodes = 
+			case lists:keysearch(nodes, 1, Terms) of
+			    {value,{_,Ns}} -> 
+				Ns;
+			    _ -> 
+				[]
+			end,
+		    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+		    %% NOTE! We can read specifications with multiple %%
+		    %% apps, but since we don't have support for      %%
+		    %% running cover on more than one app at a time,  %%
+		    %% we just allow 1 app per spec for now.          %%
+		    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+		    case collect_apps(Terms, []) of
+			Res when Res == [] ; length(Res) == 1 -> % 1 app = ok
+			   Apps = case Res of
+				     [] -> [#cover{app=none, level=details}];
+				     _ -> Res
+				 end,
+			    case get_cover_opts(Apps, Terms, []) of
+				E = {error,_} -> 
+				    E;
+				[CoverSpec] ->
+				    CoverSpec1 = remove_excludes_and_dups(CoverSpec),
+				    {FullName,Nodes,Import,Export,CoverSpec1};
+				_ ->
+				    {error,multiple_apps_in_cover_spec}
+			    end;
+			Apps when is_list(Apps) ->
+			    {error,multiple_apps_in_cover_spec}
+		    end;
+		Error ->			% file:consult/1 fails
+		    {error,{invalid_cover_spec,Error}}
+	    end;
+	false ->
+	    {error,{cant_read_cover_spec_file,FullName}}
+    end.
+
+collect_apps([{level,Level}|Ts], Apps) ->
+    collect_apps(Ts, [#cover{app=none, level=Level}|Apps]);
+collect_apps([{incl_app,App,Level}|Ts], Apps) ->
+    collect_apps(Ts, [#cover{app=App, level=Level}|Apps]);
+collect_apps([_|Ts], Apps) ->
+    collect_apps(Ts, Apps);
+collect_apps([], Apps) ->
+    Apps.
+
+%% get_cover_opts(Terms) -> AppCoverInfo
+%% AppCoverInfo: [#cover{app=App,...}]
+
+get_cover_opts([App | Apps], Terms, CoverInfo) ->
+    case get_app_info(App, Terms) of
+	E = {error,_} -> E;
+	AppInfo ->
+	    AppInfo1 = files2mods(AppInfo),
+	    get_cover_opts(Apps, Terms, [AppInfo1|CoverInfo])
+    end;
+get_cover_opts([], _, CoverInfo) ->
+    lists:reverse(CoverInfo).
+
+%% get_app_info(App, Terms) -> App1
+
+get_app_info(App=#cover{app=none}, [{incl_dirs,Dirs}|Terms]) ->
+    get_app_info(App, [{incl_dirs,none,Dirs}|Terms]);
+get_app_info(App=#cover{app=Name}, [{incl_dirs,Name,Dirs}|Terms]) ->
+    case get_files(Dirs, ".beam", false, []) of
+	E = {error,_} -> E;
+	Mods1 ->
+	    Mods = App#cover.incl_mods,
+	    get_app_info(App#cover{incl_mods=Mods++Mods1},Terms)
+    end;
+
+get_app_info(App=#cover{app=none}, [{incl_dirs_r,Dirs}|Terms]) ->
+    get_app_info(App, [{incl_dirs_r,none,Dirs}|Terms]);
+get_app_info(App=#cover{app=Name}, [{incl_dirs_r,Name,Dirs}|Terms]) ->
+    case get_files(Dirs, ".beam", true, []) of
+	E = {error,_} -> E;
+	Mods1 ->
+	    Mods = App#cover.incl_mods,
+	    get_app_info(App#cover{incl_mods=Mods++Mods1},Terms)
+    end;
+
+get_app_info(App=#cover{app=none}, [{incl_mods,Mods1}|Terms]) ->
+    get_app_info(App, [{incl_mods,none,Mods1}|Terms]);
+get_app_info(App=#cover{app=Name}, [{incl_mods,Name,Mods1}|Terms]) ->
+    Mods = App#cover.incl_mods,
+    get_app_info(App#cover{incl_mods=Mods++Mods1},Terms);
+
+get_app_info(App=#cover{app=none}, [{excl_dirs,Dirs}|Terms]) ->
+    get_app_info(App, [{excl_dirs,none,Dirs}|Terms]);
+get_app_info(App=#cover{app=Name}, [{excl_dirs,Name,Dirs}|Terms]) ->
+    case get_files(Dirs, ".beam", false, []) of
+	E = {error,_} -> E;
+	Mods1 ->
+	    Mods = App#cover.excl_mods,
+	    get_app_info(App#cover{excl_mods=Mods++Mods1},Terms)
+    end;
+
+get_app_info(App=#cover{app=none}, [{excl_dirs_r,Dirs}|Terms]) ->
+    get_app_info(App, [{excl_dirs_r,none,Dirs}|Terms]);
+get_app_info(App=#cover{app=Name}, [{excl_dirs_r,Name,Dirs}|Terms]) ->
+    case get_files(Dirs, ".beam", true, []) of
+	E = {error,_} -> E;
+	Mods1 ->
+	    Mods = App#cover.excl_mods,
+	    get_app_info(App#cover{excl_mods=Mods++Mods1},Terms)
+    end;
+
+get_app_info(App=#cover{app=none}, [{excl_mods,Mods1}|Terms]) ->
+    get_app_info(App, [{excl_mods,none,Mods1}|Terms]);
+get_app_info(App=#cover{app=Name}, [{excl_mods,Name,Mods1}|Terms]) ->
+    Mods = App#cover.excl_mods,
+    get_app_info(App#cover{excl_mods=Mods++Mods1},Terms);
+
+get_app_info(App=#cover{app=Name}, [{cross_apps,Name,AppMods1}|Terms]) ->
+    AppMods = App#cover.cross,
+    get_app_info(App#cover{cross=AppMods++AppMods1},Terms);
+
+get_app_info(App=#cover{app=none}, [{src_dirs,Dirs}|Terms]) ->
+    get_app_info(App, [{src_dirs,none,Dirs}|Terms]);
+get_app_info(App=#cover{app=Name}, [{src_dirs,Name,Dirs}|Terms]) ->
+    case get_files(Dirs, ".erl", false, []) of
+	E = {error,_} -> E;
+	Src1 ->
+	    Src = App#cover.src,
+	    get_app_info(App#cover{src=Src++Src1},Terms)
+    end;
+
+get_app_info(App=#cover{app=none}, [{src_dirs_r,Dirs}|Terms]) ->
+    get_app_info(App, [{src_dirs_r,none,Dirs}|Terms]);
+get_app_info(App=#cover{app=Name}, [{src_dirs_r,Name,Dirs}|Terms]) ->
+    case get_files(Dirs, ".erl", true, []) of
+	E = {error,_} -> E;
+	Src1 ->
+	    Src = App#cover.src,
+	    get_app_info(App#cover{src=Src++Src1},Terms)
+    end;
+
+get_app_info(App=#cover{app=none}, [{src_files,Src1}|Terms]) ->
+    get_app_info(App, [{src_files,none,Src1}|Terms]);
+get_app_info(App=#cover{app=Name}, [{src_files,Name,Src1}|Terms]) ->
+    Src = App#cover.src,
+    get_app_info(App#cover{src=Src++Src1},Terms);
+
+get_app_info(App, [_|Terms]) ->
+    get_app_info(App, Terms);
+
+get_app_info(App, []) ->
+    App.
+
+%% get_files(...)
+    
+get_files([Dir|Dirs], Ext, Recurse, Files) ->
+    case file:list_dir(Dir) of
+	{ok,Entries} ->
+	    {SubDirs,Matches} = analyse_files(Entries, Dir, Ext, [], []),
+	    if Recurse == false ->
+		    get_files(Dirs, Ext, Recurse, Files++Matches);
+	       true ->
+		    Files1 = get_files(SubDirs, Ext, Recurse, Files++Matches),
+		    get_files(Dirs, Ext, Recurse, Files1)
+	    end;
+	{error,Reason} ->
+	    {error,{Reason,Dir}}
+    end;
+get_files([], _Ext, _R, Files) ->	      
+    Files.
+	    
+%% analyse_files(...)
+
+analyse_files([F|Fs], Dir, Ext, Dirs, Matches) ->
+    Fullname = filename:absname(F, Dir),
+    {ok,Info} = file:read_file_info(Fullname),
+    case Info#file_info.type of
+	directory ->
+	    analyse_files(Fs, Dir, Ext, 
+			  [Fullname|Dirs], Matches);
+	_ ->
+	    case filename:extension(Fullname) of
+		".beam" when Ext == ".beam" ->
+		    %% File = {file,Dir,filename:rootname(F)},
+		    Mod = list_to_atom(filename:rootname(F)),
+		    analyse_files(Fs, Dir, Ext, Dirs, 
+				  [Mod|Matches]);
+		".erl" when Ext == ".erl" ->
+		    analyse_files(Fs, Dir, Ext, Dirs, 
+				  [Fullname|Matches]);
+		_ ->
+		    analyse_files(Fs, Dir, Ext, Dirs, Matches)
+	    end
+    end;
+analyse_files([], _Dir, _Ext, Dirs, Matches) ->
+    {Dirs,Matches}.
+
+
+test_files([F|Fs], Ret) ->
+    case filelib:is_file(F) of
+	true ->
+	    test_files(Fs, Ret);
+	false ->
+	    throw({error,{invalid_cover_file,F}})
+    end;
+test_files([], Ret) ->
+    Ret.
+
+remove_excludes_and_dups(CoverData=#cover{excl_mods=Excl,incl_mods=Incl}) ->
+    Incl1 = [Mod || Mod <- Incl, lists:member(Mod, Excl) == false],
+    %% delete duplicates and sort
+    Incl2 = lists:sort(lists:foldl(fun(M,L) -> 
+					   case lists:member(M,L) of 
+					       true -> L; 
+					       false -> [M|L] 
+					   end 
+				   end, [], Incl1)),
+    CoverData#cover{incl_mods=Incl2}.
+	     
+    
+files2mods(Info=#cover{excl_mods=ExclFs,
+		       incl_mods=InclFs,
+		       cross=CrossFs}) ->
+    Info#cover{excl_mods=files2mods1(ExclFs),
+	       incl_mods=files2mods1(InclFs),
+	       cross=files2mods1(CrossFs)}.
+
+files2mods1([M|Fs]) when is_atom(M) ->
+    [M|files2mods1(Fs)];
+files2mods1([F|Fs]) when is_list(F) ->
+    M = filename:rootname(filename:basename(F)),
+    [list_to_atom(M)|files2mods1(Fs)];
+files2mods1([]) ->
+    [].
diff --git a/lib/common_test/src/ct_event.erl b/lib/common_test/src/ct_event.erl
new file mode 100644
index 0000000000..3e79898ad1
--- /dev/null
+++ b/lib/common_test/src/ct_event.erl
@@ -0,0 +1,269 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 2006-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%
+%%
+
+%%% @doc Common Test Framework Event Handler
+%%%
+%%% <p>This module implements an event handler that CT uses to
+%%% handle status and progress notifications during test runs.
+%%% The notifications are handled locally (per node) and passed
+%%% on to ct_master when CT runs in distributed mode. This
+%%% module may be used as a template for other event handlers
+%%% that can be plugged in to handle local logging and reporting.</p>
+-module(ct_event).
+
+-behaviour(gen_event).
+
+%% API
+-export([start_link/0, add_handler/0, add_handler/1, stop/0]).
+-export([notify/1, sync_notify/1]).
+-export([is_alive/0]).
+
+%% gen_event callbacks
+-export([init/1, handle_event/2, handle_call/2, 
+	 handle_info/2, terminate/2, code_change/3]).
+
+-include("ct_event.hrl").
+-include("ct_util.hrl").
+
+%% receivers = [{RecvTag,Pid}]
+-record(state, {receivers=[]}).
+
+
+%%====================================================================
+%% gen_event callbacks
+%%====================================================================
+
+%%--------------------------------------------------------------------
+%% Function: start_link() -> {ok,Pid} | {error,Error} 
+%% Description: Creates an event manager.
+%%--------------------------------------------------------------------
+start_link() ->
+    gen_event:start_link({local,?CT_EVMGR}). 
+
+%%--------------------------------------------------------------------
+%% Function: add_handler() -> ok | {'EXIT',Reason} | term()
+%% Description: Adds an event handler
+%%--------------------------------------------------------------------
+add_handler() ->
+    gen_event:add_handler(?CT_EVMGR_REF,?MODULE,[]).
+add_handler(Args) ->
+    gen_event:add_handler(?CT_EVMGR_REF,?MODULE,Args).
+
+%%--------------------------------------------------------------------
+%% Function: stop() -> ok
+%% Description: Stops the event manager
+%%--------------------------------------------------------------------
+stop() ->
+    case whereis(?CT_EVMGR) of
+	undefined ->
+	    ok;
+	_Pid ->
+	    gen_event:stop(?CT_EVMGR_REF)
+    end.
+
+%%--------------------------------------------------------------------
+%% Function: notify(Event) -> ok
+%% Description: Asynchronous notification to event manager.
+%%--------------------------------------------------------------------
+notify(Event) ->
+    case catch gen_event:notify(?CT_EVMGR_REF,Event) of
+	{'EXIT',Reason} ->
+	    {error,{notify,Reason}};
+	Result ->
+	    Result
+    end.
+
+%%--------------------------------------------------------------------
+%% Function: sync_notify(Event) -> ok
+%% Description: Synchronous notification to event manager.
+%%--------------------------------------------------------------------
+sync_notify(Event) ->
+    case catch gen_event:sync_notify(?CT_EVMGR_REF,Event) of
+	{'EXIT',Reason} ->
+	    {error,{sync_notify,Reason}};
+	Result ->
+	    Result
+    end.
+
+%%--------------------------------------------------------------------
+%% Function: is_alive() -> true | false
+%% Description: Check if Event Manager is alive.
+%%--------------------------------------------------------------------
+is_alive() ->
+    case whereis(?CT_EVMGR) of
+	undefined ->
+	    false;
+	_Pid ->
+	    true
+    end.    
+
+%%====================================================================
+%% gen_event callbacks
+%%====================================================================
+%%--------------------------------------------------------------------
+%% Function: init(Args) -> {ok, State}
+%% Description: Whenever a new event handler is added to an event manager,
+%% this function is called to initialize the event handler.
+%%--------------------------------------------------------------------
+init(RecvPids) ->
+    %% RecvPids = [{RecvTag,Pid}]
+    {ok,#state{receivers=RecvPids}}.
+
+%%--------------------------------------------------------------------
+%% Function:  
+%% handle_event(Event, State) -> {ok, State} |
+%%                               {swap_handler, Args1, State1, Mod2, Args2} |
+%%                               remove_handler
+%% Description:Whenever an event manager receives an event sent using
+%% gen_event:notify/2 or gen_event:sync_notify/2, this function is called for
+%% each installed event handler to handle the event. 
+%%--------------------------------------------------------------------
+handle_event(Event,State=#state{receivers=RecvPids}) ->
+    print("~n=== ~w ===~n", [?MODULE]),
+    print("~p: ~p~n", [Event#event.name,Event#event.data]),
+    lists:foreach(fun(Recv) -> report_event(Recv,Event) end, RecvPids),
+    {ok,State}.
+
+%%============================== EVENTS ==============================
+%%
+%% Name = test_start
+%% Data = {StartTime,LogDir}
+%%
+%% Name = start_info
+%% Data = {Tests,Suites,Cases}
+%% Tests = Suites = Cases = integer()
+%%
+%% Name = test_done
+%% Data = EndTime
+%%
+%% Name = start_make
+%% Data = Dir
+%%
+%% Name = finished_make
+%% Data = Dir
+%%
+%% Name = tc_start
+%% Data = {Suite,CaseOrGroup}
+%% CaseOrGroup = atom() | {Conf,GroupName,GroupProperties}
+%% Conf = init_per_group | end_per_group
+%% GroupName = atom()
+%% GroupProperties = list()
+%%
+%% Name = tc_done
+%% Data = {Suite,CaseOrGroup,Result}
+%% CaseOrGroup = atom() | {Conf,GroupName,GroupProperties}
+%% Conf = init_per_group | end_per_group
+%% GroupName = atom()
+%% GroupProperties = list()
+%% Result = ok | {skipped,Reason} | {failed,Reason} 
+%%
+%% Name = tc_user_skip
+%% Data = {Suite,Case,Comment}
+%% Comment = string()
+%%
+%% Name = tc_auto_skip
+%% Data = {Suite,Case,Comment}
+%% Comment = string()
+%%
+%% Name = test_stats
+%% Data = {Ok,Failed,Skipped}
+%% Ok = Failed = integer()
+%% Skipped = {UserSkipped,AutoSkipped}
+%% UserSkipped = AutoSkipped = integer()
+%%
+%% Name = start_logging
+%% Data = CtRunDir
+%%
+%% Name = stop_logging
+%% Data = []
+%%
+%% Name = start_write_file
+%% Data = FullNameFile
+%%
+%% Name = finished_write_file
+%% Data = FullNameFile
+%%
+%% Name = 
+%% Data = 
+%%
+
+%% report to master
+report_event({master,Master},E=#event{name=_Name,node=_Node,data=_Data}) ->
+    ct_master:status(Master,E);
+
+%% report to VTS
+report_event({vts,VTS},#event{name=Name,node=_Node,data=Data}) ->
+    if Name == start_info ;
+       Name == test_stats ;
+       Name == test_done ->
+	    vts:test_info(VTS,Name,Data);
+       true ->
+	    ok
+    end.
+
+
+%%--------------------------------------------------------------------
+%% Function: 
+%% handle_call(Request, State) -> {ok, Reply, State} |
+%%                                {swap_handler, Reply, Args1, State1, 
+%%                                  Mod2, Args2} |
+%%                                {remove_handler, Reply}
+%% Description: Whenever an event manager receives a request sent using
+%% gen_event:call/3,4, this function is called for the specified event 
+%% handler to handle the request.
+%%--------------------------------------------------------------------
+handle_call(_Req, State) ->
+    Reply = ok,
+    {ok, Reply, State}.
+
+%%--------------------------------------------------------------------
+%% Function: 
+%% handle_info(Info, State) -> {ok, State} |
+%%                             {swap_handler, Args1, State1, Mod2, Args2} |
+%%                              remove_handler
+%% Description: This function is called for each installed event handler when
+%% an event manager receives any other message than an event or a synchronous
+%% request (or a system message).
+%%--------------------------------------------------------------------
+handle_info(_Info, State) ->
+    {ok, State}.
+
+%%--------------------------------------------------------------------
+%% Function: terminate(Reason, State) -> void()
+%% Description:Whenever an event handler is deleted from an event manager,
+%% this function is called. It should be the opposite of Module:init/1 and 
+%% do any necessary cleaning up. 
+%%--------------------------------------------------------------------
+terminate(_Reason, _State) ->
+    ok.
+
+%%--------------------------------------------------------------------
+%% Function: code_change(OldVsn, State, Extra) -> {ok, NewState} 
+%% Description: Convert process state when code is changed
+%%--------------------------------------------------------------------
+code_change(_OldVsn, State, _Extra) ->
+    {ok, State}.
+
+%%--------------------------------------------------------------------
+%%% Internal functions
+%%--------------------------------------------------------------------
+
+print(_Str,_Args) ->
+%    io:format(_Str,_Args),
+    ok.
diff --git a/lib/common_test/src/ct_framework.erl b/lib/common_test/src/ct_framework.erl
new file mode 100644
index 0000000000..8456251b29
--- /dev/null
+++ b/lib/common_test/src/ct_framework.erl
@@ -0,0 +1,1059 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 2004-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%
+%%
+
+%%% @doc Common Test Framework callback module.
+%%%
+%%% <p>This module exports framework callback functions which are
+%%% called from the test_server.</p>
+
+-module(ct_framework).
+
+-export([init_tc/3, end_tc/3, get_suite/2, report/2, warn/1]).
+-export([error_notification/4]).
+
+-export([error_in_suite/1]).
+
+-include("ct_event.hrl").
+-include("ct_util.hrl").
+
+%%%-----------------------------------------------------------------
+%%% @spec init_tc(Mod,Func,Args) -> {ok,NewArgs} | {error,Reason} |
+%%%         {skip,Reason} | {auto_skip,Reason}
+%%%      Mod = atom()
+%%%      Func = atom()
+%%%      Args = list()
+%%%      NewArgs = list()
+%%%      Reason = term()
+%%%
+%%% @doc Test server framework callback, called by the test_server
+%%% when a new test case is started.
+init_tc(Mod,Func,Config) ->
+    %% check if previous testcase was interpreted and has left
+    %% a "dead" trace window behind - if so, kill it
+    case ct_util:get_testdata(interpret) of
+	{What,kill,{TCPid,AttPid}} ->
+	    ct_util:kill_attached(TCPid,AttPid),
+	    ct_util:set_testdata({interpret,{What,kill,{undefined,undefined}}});
+	_ ->
+	    ok
+    end,
+	    
+    %% check if we need to add defaults explicitly because
+    %% there's no init_per_suite exported from Mod
+    {InitFailed,DoInit} =
+	case ct_util:get_testdata(curr_tc) of
+	    {Mod,{suite0_failed,_}=Failure} ->
+		{Failure,false};
+	    {Mod,_} ->
+		{false,false};
+	    _ when Func == init_per_suite ->
+		{false,false};
+	    _ ->
+		{false,true}
+	end,
+    case InitFailed of
+	false ->
+	    ct_util:set_testdata({curr_tc,{Mod,Func}}),
+	    case ct_util:read_suite_data({seq,Mod,Func}) of
+		undefined ->
+		    init_tc1(Mod,Func,Config,DoInit);
+		Seq when is_atom(Seq) ->
+		    case ct_util:read_suite_data({seq,Mod,Seq}) of
+			[Func|TCs] ->		% this is the 1st case in Seq
+			    %% make sure no cases in this seq are marked as failed
+			    %% from an earlier execution in the same suite
+			    lists:foreach(fun(TC) ->
+						  ct_util:save_suite_data({seq,Mod,TC},Seq)
+					  end, TCs);
+			_ ->
+			    ok
+		    end,
+		    init_tc1(Mod,Func,Config,DoInit);
+		{failed,Seq,BadFunc} ->
+		    {skip,{sequence_failed,Seq,BadFunc}}
+	    end;
+	{_,{require,Reason}} ->
+	    {skip,{require_failed_in_suite0,Reason}};
+	_ ->
+	    {skip,InitFailed}
+    end.	    
+
+init_tc1(Mod,Func,[Config0],DoInit) when is_list(Config0) ->
+    Config1 = 
+	case ct_util:read_suite_data(last_saved_config) of
+	    {{Mod,LastFunc},SavedConfig} ->	% last testcase
+		[{saved_config,{LastFunc,SavedConfig}} | 
+		 lists:keydelete(saved_config,1,Config0)];
+	    {{LastSuite,InitOrEnd},SavedConfig} when InitOrEnd == init_per_suite ;
+						     InitOrEnd == end_per_suite -> % last suite
+		[{saved_config,{LastSuite,SavedConfig}} | 
+		 lists:keydelete(saved_config,1,Config0)];
+	    undefined ->
+		lists:keydelete(saved_config,1,Config0)
+	end,
+    ct_util:delete_suite_data(last_saved_config),
+    Config = lists:keydelete(watchdog,1,Config1),
+    if Func /= init_per_suite, DoInit /= true ->
+	    ok;
+	true ->
+	    %% delete all default values used in previous suite
+	    ct_util:delete_default_config(suite),
+	    %% release all name -> key bindings (once per suite)
+	    ct_util:release_allocated()
+    end,
+    TestCaseInfo =
+	case catch apply(Mod,Func,[]) of
+	    Result when is_list(Result) -> Result;
+	    _ -> []
+	end,
+    %% clear all config data default values set by previous
+    %% testcase info function (these should only survive the
+    %% testcase, not the whole suite)
+    ct_util:delete_default_config(testcase),
+    case add_defaults(Mod,Func,TestCaseInfo,DoInit) of
+	Error = {suite0_failed,_} ->
+	    ct_logs:init_tc(),
+	    FuncSpec = group_or_func(Func,Config0),
+	    ct_event:notify(#event{name=tc_start,
+				   node=node(),
+				   data={Mod,FuncSpec}}),
+	    ct_util:set_testdata({curr_tc,{Mod,Error}}),
+	    {error,Error};
+	{SuiteInfo,MergeResult} ->
+	    case MergeResult of
+		{error,Reason} when DoInit == false ->
+		    ct_logs:init_tc(),
+		    FuncSpec = group_or_func(Func,Config0),
+		    ct_event:notify(#event{name=tc_start,
+					   node=node(),
+					   data={Mod,FuncSpec}}),
+		    {skip,Reason};
+		_ ->
+		    init_tc2(Mod,Func,SuiteInfo,MergeResult,Config,DoInit)
+	    end
+    end;
+init_tc1(_Mod,_Func,Args,_DoInit) ->
+    {ok,Args}.
+
+init_tc2(Mod,Func,SuiteInfo,MergeResult,Config,DoInit) ->
+    %% if first testcase fails when there's no init_per_suite
+    %% we must do suite/0 configurations before skipping test
+    MergedInfo =
+	case MergeResult of
+	    {error,_} when DoInit == true ->
+		SuiteInfo;
+	    _ ->
+		MergeResult
+	end,
+    %% timetrap must be handled before require
+    MergedInfo1 = timetrap_first(MergedInfo, [], []),
+    %% tell logger to use specified style sheet
+    case lists:keysearch(stylesheet,1,MergedInfo++Config) of
+	{value,{stylesheet,SSFile}} ->
+	    ct_logs:set_stylesheet(Func,add_data_dir(SSFile,Config));
+	_ ->
+	    case ct_util:get_testdata(stylesheet) of
+		undefined ->
+		    ct_logs:clear_stylesheet(Func);
+		SSFile ->
+		    ct_logs:set_stylesheet(Func,SSFile)
+	    end
+    end,
+    %% suppress output for connections (Conns is a 
+    %% list of {Type,Bool} tuples, e.g. {telnet,true}),		
+    case ct_util:get_overridden_silenced_connections() of
+	undefined ->
+	    case lists:keysearch(silent_connections,1,MergedInfo++Config) of
+		{value,{silent_connections,Conns}} ->
+		    ct_util:silence_connections(Conns);
+		_ ->
+		    ok
+	    end;
+	Conns ->
+	    ct_util:silence_connections(Conns)
+    end,
+    
+    ct_logs:init_tc(),
+    FuncSpec = group_or_func(Func,Config),
+    ct_event:notify(#event{name=tc_start,
+			   node=node(),
+			   data={Mod,FuncSpec}}),
+    
+    case configure(MergedInfo1,MergedInfo1,SuiteInfo,{Func,DoInit},Config) of
+	{suite0_failed,Reason} ->
+	    ct_util:set_testdata({curr_tc,{Mod,{suite0_failed,{require,Reason}}}}),
+	    {skip,{require_failed_in_suite0,Reason}};
+	{error,Reason} ->
+	    {auto_skip,{require_failed,Reason}};
+	FinalConfig ->
+	    case MergeResult of
+		{error,Reason} ->
+		    %% suite0 configure finished now, report that 
+		    %% first test case actually failed		    
+		    {skip,Reason};
+		_ ->
+		    case get('$test_server_framework_test') of
+			undefined ->
+			    FinalConfig;
+			Fun ->
+			    Fun(init_tc, FinalConfig)
+		    end
+	    end
+    end.
+	    
+
+add_defaults(Mod,Func,FuncInfo,DoInit) ->
+    case (catch Mod:suite()) of
+	{'EXIT',{undef,_}} ->
+	    SuiteInfo = merge_with_suite_defaults(Mod,[]),
+	    case add_defaults1(Mod,Func,FuncInfo,SuiteInfo,DoInit) of
+		Error = {error,_} -> {SuiteInfo,Error};
+		MergedInfo -> {SuiteInfo,MergedInfo}
+	    end;
+	{'EXIT',Reason} -> 
+	    {suite0_failed,{exited,Reason}};
+	SuiteInfo when is_list(SuiteInfo) ->
+	    case lists:all(fun(E) when is_tuple(E) -> true;
+			      (_) -> false
+			   end, SuiteInfo) of
+		true ->
+		    SuiteInfo1 = merge_with_suite_defaults(Mod,SuiteInfo),
+		    case add_defaults1(Mod,Func,FuncInfo,SuiteInfo1,DoInit) of
+			Error = {error,_} -> {SuiteInfo1,Error};
+			MergedInfo -> {SuiteInfo1,MergedInfo}
+		    end;
+		false ->
+		    {suite0_failed,bad_return_value}
+	    end;
+	_ ->
+	    {suite0_failed,bad_return_value}
+    end.
+    
+add_defaults1(_Mod,init_per_suite,[],SuiteInfo,_) ->
+    SuiteInfo;
+
+add_defaults1(Mod,Func,FuncInfo,SuiteInfo,DoInit) ->
+    %% mustn't re-require suite variables in test case info function,
+    %% can result in weird behaviour (suite values get overwritten)
+    SuiteReqs = 
+	[SDDef || SDDef <- SuiteInfo,
+		  require == element(1,SDDef)],
+    case [element(2,Clash) || Clash <- SuiteReqs, 
+	  true == lists:keymember(element(2,Clash),2,FuncInfo)] of
+	[] ->
+	    add_defaults2(Mod,Func,FuncInfo,SuiteInfo,SuiteReqs,DoInit);
+	Clashes ->
+	    {error,{config_name_already_in_use,Clashes}}
+    end.
+
+add_defaults2(_Mod,_Func,FuncInfo,SuiteInfo,_,false) ->
+    %% include require elements from test case info, but not from suite/0
+    %% (since we've already required those vars)
+    FuncInfo ++
+	[SFDef || SFDef <- SuiteInfo,
+		  require /= element(1,SFDef),
+		  false == lists:keymember(element(1,SFDef),1,FuncInfo)];
+
+add_defaults2(_Mod,_Func,FuncInfo,SuiteInfo,SuiteReqs,true) ->
+    %% We must include require elements from suite/0 here since
+    %% there's no init_per_suite call before this first test case.
+    %% Let other test case info elements override those from suite/0.
+    FuncInfo ++ SuiteReqs ++
+	[SDDef || SDDef <- SuiteInfo,
+		  require /= element(1,SDDef),
+		  false == lists:keymember(element(1,SDDef),1,FuncInfo)].    
+
+merge_with_suite_defaults(Mod,SuiteInfo) ->
+    case lists:keysearch(suite_defaults,1,Mod:module_info(attributes)) of
+	{value,{suite_defaults,Defaults}} ->
+	    SDReqs =
+		[SDDef || SDDef <- Defaults,
+			  require == element(1,SDDef),
+			  false == lists:keymember(element(2,SDDef),2,
+						   SuiteInfo)],
+	    SuiteInfo ++ SDReqs ++
+		[SDDef || SDDef <- Defaults,
+			  require /= element(1,SDDef),
+			  false == lists:keymember(element(1,SDDef),1,
+						   SuiteInfo)];		    
+	false ->
+	    SuiteInfo
+    end.
+
+timetrap_first([Trap = {timetrap,_} | Rest],Info,Found) ->
+    timetrap_first(Rest,Info,[Trap | Found]);
+timetrap_first([Other | Rest],Info,Found) ->
+    timetrap_first(Rest,[Other | Info],Found);
+timetrap_first([],Info,[]) ->
+    [{timetrap,{minutes,30}} | lists:reverse(Info)];
+timetrap_first([],Info,Found) ->
+    lists:reverse(Found) ++ lists:reverse(Info).
+
+configure([{require,Required}|Rest],Info,SuiteInfo,Scope,Config) ->
+    case ct:require(Required) of
+	ok ->
+	    configure(Rest,Info,SuiteInfo,Scope,Config);
+	Error = {error,Reason} ->
+	    case required_default('_UNDEF',Required,Info,SuiteInfo,Scope) of
+		ok ->
+		    configure(Rest,Info,SuiteInfo,Scope,Config);
+		_ ->
+		    case lists:keymember(Required,2,SuiteInfo) of
+			true ->
+			    {suite0_failed,Reason};
+			false ->
+			    Error
+		    end
+	    end
+    end;
+configure([{require,Name,Required}|Rest],Info,SuiteInfo,Scope,Config) ->
+    case ct:require(Name,Required) of
+	ok ->
+	    configure(Rest,Info,SuiteInfo,Scope,Config);
+	Error = {error,Reason} ->
+	    case required_default(Name,Required,Info,SuiteInfo,Scope) of
+		ok ->
+		    configure(Rest,Info,SuiteInfo,Scope,Config);
+		_ ->
+		    case lists:keymember(Name,2,SuiteInfo) of
+			true -> 
+			    {suite0_failed,Reason};
+			false ->
+			    Error
+		    end
+	    end
+    end;
+configure([{timetrap,off}|Rest],Info,SuiteInfo,Scope,Config) ->
+    configure(Rest,Info,SuiteInfo,Scope,Config);
+configure([{timetrap,Time}|Rest],Info,SuiteInfo,Scope,Config) ->
+    Dog = test_server:timetrap(Time),
+    configure(Rest,Info,SuiteInfo,Scope,[{watchdog,Dog}|Config]);
+configure([_|Rest],Info,SuiteInfo,Scope,Config) ->
+    configure(Rest,Info,SuiteInfo,Scope,Config);
+configure([],_,_,_,Config) ->
+    {ok,[Config]}.
+
+%% the require element in Info may come from suite/0 and
+%% should be scoped 'suite', or come from the testcase info
+%% function and should then be scoped 'testcase'
+required_default(Name,Key,Info,SuiteInfo,{Func,true}) ->
+    case try_set_default(Name,Key,SuiteInfo,suite) of
+	ok ->
+	    ok;
+	_ ->
+	    required_default(Name,Key,Info,[],{Func,false})
+    end;
+required_default(Name,Key,Info,_,{init_per_suite,_}) ->
+    try_set_default(Name,Key,Info,suite);
+required_default(Name,Key,Info,_,_) ->
+    try_set_default(Name,Key,Info,testcase).
+
+try_set_default(Name,Key,Info,Where) ->
+    CfgElems = 
+	case lists:keysearch(Name,1,Info) of
+	    {value,{Name,Val}} ->
+		[Val];
+	    false ->
+		case catch [{Key,element(3,Elem)} || Elem <- Info,
+						     element(1,Elem)==default_config,
+						     element(2,Elem)==Key] of
+		    {'EXIT',_} -> [];
+		    Result -> Result
+		end
+	end,
+    case {Name,CfgElems} of
+	{_,[]} -> 
+	    no_default;
+	{'_UNDEF',_} ->
+    	    [ct_util:set_default_config([CfgVal],Where) || CfgVal <- CfgElems],
+	    ok;
+	_ ->
+    	    [ct_util:set_default_config(Name,[CfgVal],Where) || CfgVal <- CfgElems],
+	    ok
+    end.
+	    
+
+%%%-----------------------------------------------------------------
+%%% @spec end_tc(Mod,Func,Args) -> {ok,NewArgs}| {error,Reason} |
+%%%         {skip,Reason} | {auto_skip,Reason}
+%%%      Mod = atom()
+%%%      Func = atom()
+%%%      Args = list()
+%%%      NewArgs = list()
+%%%      Reason = term()
+%%%
+%%% @doc Test server framework callback, called by the test_server
+%%% when a test case is finished.
+end_tc(?MODULE,error_in_suite,_) ->		% bad start!
+    ok;
+end_tc(Mod,Func,{TCPid,Result,[Args]}) when is_pid(TCPid) ->
+    end_tc(Mod,Func,TCPid,Result,Args);
+end_tc(Mod,Func,{Result,[Args]}) ->
+    end_tc(Mod,Func,self(),Result,Args).
+
+end_tc(Mod,Func,TCPid,Result,Args) ->
+    case lists:keysearch(watchdog,1,Args) of
+	{value,{watchdog,Dog}} -> test_server:timetrap_cancel(Dog);
+	false -> ok
+    end,
+
+    %% save the testcase process pid so that it can be used
+    %% to look up the attached trace window later
+    case ct_util:get_testdata(interpret) of
+	{What,kill,_} ->
+	    AttPid = ct_util:get_attached(self()),
+	    ct_util:set_testdata({interpret,{What,kill,{self(),AttPid}}});
+	_ ->
+	    ok
+    end,
+
+    ct_util:delete_testdata(comment),
+    ct_util:delete_suite_data(last_saved_config),
+    FuncSpec =
+	case group_or_func(Func,Args) of
+	    {_,GroupName,_Props} = Group ->			       
+		case lists:keysearch(save_config,1,Args) of
+		    {value,{save_config,SaveConfig}} ->
+			ct_util:save_suite_data(last_saved_config,
+						{Mod,{group,GroupName}},SaveConfig),
+			Group;
+		    false ->
+			Group
+		end;
+	    _ ->
+		case lists:keysearch(save_config,1,Args) of
+		    {value,{save_config,SaveConfig}} ->
+			ct_util:save_suite_data(last_saved_config,
+						{Mod,Func},SaveConfig),
+			Func;
+		    false ->
+			Func
+		end
+	end,
+    ct_util:reset_silent_connections(),
+
+    %% send sync notification so that event handlers may print
+    %% in the log file before it gets closed
+    ct_event:sync_notify(#event{name=tc_done,
+				node=node(),
+				data={Mod,FuncSpec,tag(Result)}}),
+    case Result of
+	{skip,{sequence_failed,_,_}} ->
+	    %% ct_logs:init_tc is never called for a skipped test case
+	    %% in a failing sequence, so neither should end_tc	    
+	    ok;
+	_ ->
+	    case ct_logs:end_tc(TCPid) of
+		{error,Reason} ->
+		    exit({error,{logger,Reason}});
+		_ ->
+		    ok
+	    end
+    end,
+    case Func of
+	end_per_suite -> 
+	    ct_util:match_delete_suite_data({seq,Mod,'_'});
+	_ -> 
+	    ok
+    end,
+    case get('$test_server_framework_test') of
+	undefined ->
+	    ok;
+	Fun ->
+	    Fun(end_tc, ok)
+    end.
+
+%% {error,Reason} | {skip,Reason} | {timetrap_timeout,TVal} | 
+%% {testcase_aborted,Reason} | testcase_aborted_or_killed | 
+%% {'EXIT',Reason} | Other (ignored return value, e.g. 'ok')
+tag({STag,Reason}) when STag == skip; STag == skipped -> 
+    {skipped,Reason};
+tag(E = {ETag,_}) when ETag == error; ETag == 'EXIT'; 
+                       ETag == timetrap_timeout;
+                       ETag == testcase_aborted -> 
+    {failed,E};
+tag(E = testcase_aborted_or_killed) ->
+    {failed,E};
+tag(Other) ->
+    Other.
+
+%%%-----------------------------------------------------------------
+%%% @spec error_notification(Mod,Func,Args,Error) -> ok
+%%%      Mod = atom()
+%%%      Func = atom()
+%%%      Args = list()
+%%%      Error = term()
+%%%
+%%% @doc This function is called as the result of testcase 
+%%% <code>Func</code> in suite <code>Mod</code> crashing. 
+%%% <code>Error</code> specifies the reason for failing.
+error_notification(Mod,Func,_Args,{Error,Loc}) ->
+    ErrSpec = case Error of
+		 {What={_E,_R},Trace} when is_list(Trace) ->
+		      What;
+		  What ->
+		      What
+	      end,
+    ErrStr = case ErrSpec of
+		 {badmatch,Descr} ->
+		     Descr1 = lists:flatten(io_lib:format("~P",[Descr,10])),
+		     if length(Descr1) > 50 ->
+			     Descr2 = string:substr(Descr1,1,50),
+			     io_lib:format("{badmatch,~s...}",[Descr2]);
+			true ->
+			     io_lib:format("{badmatch,~s}",[Descr1])
+		     end;
+		 {test_case_failed,Reason} ->
+		     case (catch io_lib:format("{test_case_failed,~s}", [Reason])) of
+			 {'EXIT',_} ->
+			     io_lib:format("{test_case_failed,~p}", [Reason]);
+			 Result -> Result
+		     end;
+		 {Spec,_Reason} when is_atom(Spec) ->
+		     io_lib:format("~w", [Spec]);
+		 Other ->
+		     io_lib:format("~P", [Other,5])
+	     end,
+    ErrorHtml = "<font color=\"brown\">" ++ ErrStr ++ "</font>",
+    case {Mod,Error} of
+	%% some notifications come from the main test_server process
+	%% and for these cases the existing comment may not be modified
+	{_,{timetrap_timeout,_TVal}} ->
+	    ok;
+	{_,{testcase_aborted,_Info}} ->
+	    ok;
+	{_,testcase_aborted_or_killed} ->
+	    ok;
+	{undefined,_OtherError} ->
+	    ok;
+	_ ->			     
+	    %% this notification comes from the test case process, so
+	    %% we can add error info to comment with test_server:comment/1
+	    case ct_util:get_testdata(comment) of
+		undefined ->
+		    test_server:comment(ErrorHtml);
+		Comment ->
+		    CommentHtml = 
+			"<font color=\"green\">" ++ "(" ++ "</font>"
+			++ Comment ++ 
+			"<font color=\"green\">" ++ ")" ++ "</font>",
+		    Str = io_lib:format("~s   ~s", [ErrorHtml,CommentHtml]),
+		    test_server:comment(Str)
+	    end
+    end,
+
+    io:format(user, "~n- - - - - - - - - - - - - - - - "
+	      "- - - - - - - - - -~n", []),
+    case Loc of
+	%% we don't use the line parse transform as we compile this 
+	%% module so location will be on form {M,F}
+	[{?MODULE,error_in_suite}] ->
+	    io:format(user, "Error in suite detected: ~s", [ErrStr]);
+
+	unknown ->
+	    io:format(user, "Error detected: ~s", [ErrStr]);
+
+	%% if a function specified by all/0 does not exist, we
+	%% pick up undef here
+	[{LastMod,LastFunc}] ->
+	    io:format(user, "~w:~w could not be executed~n", 
+		      [LastMod,LastFunc]),
+	    io:format(user, "Reason: ~s", [ErrStr]);
+	    
+	[{LastMod,LastFunc,LastLine}|_] ->
+	    %% print error to console, we are only
+	    %% interested in the last executed expression
+	    io:format(user, "~w:~w failed on line ~w~n", 
+		      [LastMod,LastFunc,LastLine]),
+	    io:format(user, "Reason: ~s", [ErrStr]),
+    
+	    case ct_util:read_suite_data({seq,Mod,Func}) of
+		undefined ->
+		    ok;
+		Seq ->
+		    SeqTCs = ct_util:read_suite_data({seq,Mod,Seq}),
+		    mark_as_failed(Seq,Mod,Func,SeqTCs)
+	    end	    
+    end,
+    io:format(user, "~n- - - - - - - - - - - - - - - - "
+	      "- - - - - - - - - -~n~n", []),
+    ok.
+
+%% cases in seq that have already run
+mark_as_failed(Seq,Mod,Func,[Func|TCs]) ->
+    mark_as_failed1(Seq,Mod,Func,TCs);
+mark_as_failed(Seq,Mod,Func,[_TC|TCs]) ->
+    mark_as_failed(Seq,Mod,Func,TCs);
+mark_as_failed(_,_,_,[]) ->
+    ok;
+mark_as_failed(_,_,_,undefined) ->
+    ok.
+
+%% mark rest of cases in seq to be skipped
+mark_as_failed1(Seq,Mod,Func,[TC|TCs]) ->
+    ct_util:save_suite_data({seq,Mod,TC},{failed,Seq,Func}),
+    mark_as_failed1(Seq,Mod,Func,TCs);
+mark_as_failed1(_,_,_,[]) ->
+    ok.
+
+group_or_func(Func, Config) when Func == init_per_group; 
+				 Func == end_per_group ->
+    case proplists:get_value(tc_group_properties,Config) of
+	undefined ->
+	    {Func,unknown,[]};
+	GrProps ->
+	    GrName = proplists:get_value(name,GrProps),
+	    {Func,GrName,proplists:delete(name,GrProps)}
+    end;	  
+group_or_func(Func, _Config) ->
+    Func.
+
+%%%-----------------------------------------------------------------
+%%% @spec get_suite(Mod, Func) -> Tests
+%%%
+%%% @doc Called from test_server for every suite (<code>Func==all</code>)
+%%%      and every test case. If the former, all test cases in the suite
+%%%      should be returned. 
+
+get_suite(Mod, all) ->    
+    case catch apply(Mod, groups, []) of
+	{'EXIT',_} ->
+	    get_all(Mod, []);
+	GroupDefs when is_list(GroupDefs) ->
+	    case catch check_groups(Mod, GroupDefs) of
+		{error,_} = Error ->
+		    %% this makes test_server call error_in_suite as first
+		    %% (and only) test case so we can report Error properly
+		    [{?MODULE,error_in_suite,[[Error]]}];
+		ConfTests ->
+		    get_all(Mod, ConfTests)
+	    end;
+	_ ->
+	    E = "Bad return value from "++atom_to_list(Mod)++":groups/0",
+	    [{?MODULE,error_in_suite,[[{error,list_to_atom(E)}]]}]
+    end;
+
+%%!============================================================
+%%! Note: The handling of sequences in get_suite/2 and get_all/2
+%%! is deprecated and should be removed after OTP R13!
+%%!============================================================
+
+get_suite(Mod, Name) ->
+    %% Name may be name of a group or a test case. If it's a group,
+    %% it should be expanded to list of cases (in a conf term)
+    case catch apply(Mod, groups, []) of
+	{'EXIT',_} ->
+	    get_seq(Mod, Name);
+	GroupDefs when is_list(GroupDefs) ->
+	    case catch check_groups(Mod, GroupDefs) of
+		{error,_} = Error ->
+		    %% this makes test_server call error_in_suite as first
+		    %% (and only) test case so we can report Error properly
+		    [{?MODULE,error_in_suite,[[Error]]}];
+		ConfTests ->
+		    FindConf = fun({conf,Props,_,_,_}) ->
+				       case proplists:get_value(name, Props) of
+					   Name -> true;
+					   _    -> false
+				       end
+			       end,					 
+		    case lists:filter(FindConf, ConfTests) of
+			[] ->			% must be a test case
+			    get_seq(Mod, Name);
+			[ConfTest|_] ->
+			    ConfTest
+		    end
+	    end;
+	_ ->
+	    E = "Bad return value from "++atom_to_list(Mod)++":groups/0",
+	    [{?MODULE,error_in_suite,[[{error,list_to_atom(E)}]]}]
+    end.
+
+check_groups(_Mod, []) ->
+    [];
+check_groups(Mod, Defs) ->
+    check_groups(Mod, Defs, Defs, []).
+
+check_groups(Mod, [TC | Gs], Defs, Levels) when is_atom(TC), length(Levels)>0 ->
+    [TC | check_groups(Mod, Gs, Defs, Levels)];
+
+check_groups(Mod, [{group,SubName} | Gs], Defs, Levels) when is_atom(SubName) ->
+    case lists:member(SubName, Levels) of
+	true ->
+	    E = "Cyclic reference to group "++atom_to_list(SubName)++
+		" in "++atom_to_list(Mod)++":groups/0",
+	    throw({error,list_to_atom(E)});
+	false ->	    
+	    case find_group(Mod, SubName, Defs) of
+		{error,_} = Error ->
+		    throw(Error);
+		G ->
+		    [check_groups(Mod, [G], Defs, Levels) | 
+		     check_groups(Mod, Gs, Defs, Levels)]
+	    end
+    end;
+
+check_groups(Mod, [{Name,Tests} | Gs], Defs, Levels) when is_atom(Name),
+							  is_list(Tests) ->
+    check_groups(Mod, [{Name,[],Tests} | Gs], Defs, Levels);
+
+check_groups(Mod, [{Name,Props,Tests} | Gs], Defs, Levels) when is_atom(Name),
+								is_list(Props),
+								is_list(Tests) ->
+    {TestSpec,Levels1} = 
+	case Levels of
+	    [] ->
+		{check_groups(Mod, Tests, Defs, [Name]),[]};
+	    _ ->
+		{check_groups(Mod, Tests, Defs, [Name|Levels]),Levels}
+	end,
+    [make_conf(Mod, Name, Props, TestSpec) | 
+     check_groups(Mod, Gs, Defs, Levels1)];
+
+check_groups(Mod, [BadTerm | _Gs], _Defs, Levels) ->
+    Where = if length(Levels) == 0 ->
+		    atom_to_list(Mod)++":groups/0";
+	       true ->
+		    "group "++atom_to_list(lists:last(Levels))++
+			" in "++atom_to_list(Mod)++":groups/0"
+	    end,		 
+    Term = io_lib:format("~p", [BadTerm]),
+    E = "Bad term "++lists:flatten(Term)++" in "++Where,
+    throw({error,list_to_atom(E)});
+
+check_groups(_Mod, [], _Defs, _) ->
+    [].
+
+find_group(Mod, Name, Defs) ->
+    case lists:keysearch(Name, 1, Defs) of
+	{value,Def} -> 
+	    Def;
+	false ->
+	    E = "Invalid group "++atom_to_list(Name)++
+		" in "++atom_to_list(Mod)++":groups/0",
+	    throw({error,list_to_atom(E)})
+    end.
+
+make_conf(Mod, Name, Props, TestSpec) ->
+    {conf,[{name,Name}|Props],
+     {Mod,init_per_group},TestSpec,{Mod,end_per_group}}.
+
+
+get_all(Mod, ConfTests) ->	
+    case catch apply(Mod, all, []) of
+	{'EXIT',_} ->
+	    Reason = 
+		list_to_atom(atom_to_list(Mod)++":all/0 is missing"),
+	    %% this makes test_server call error_in_suite as first
+	    %% (and only) test case so we can report Reason properly
+	    [{?MODULE,error_in_suite,[[{error,Reason}]]}];
+	AllTCs when is_list(AllTCs) ->
+	    case catch save_seqs(Mod,AllTCs) of
+		{error,What} ->
+		    [{?MODULE,error_in_suite,[[{error,What}]]}];
+		SeqsAndTCs ->
+		    %% expand group references in all() using ConfTests
+		    Expand =
+			fun({group,Name}) ->
+				FindConf = 
+				    fun({conf,Props,_,_,_}) ->
+					    case proplists:get_value(name, Props) of
+						Name -> true;
+						_    -> false
+					    end
+					   end,					 
+				case lists:filter(FindConf, ConfTests) of
+				    [ConfTest|_] ->
+					ConfTest;
+				    [] ->
+					E = "Invalid reference to group "++
+					    atom_to_list(Name)++" in "++
+					    atom_to_list(Mod)++":all/0",
+					throw({error,list_to_atom(E)})
+				end;
+			   (SeqOrTC) -> SeqOrTC
+			end,
+		    case catch lists:map(Expand, SeqsAndTCs) of
+			{error,_} = Error ->
+			    [{?MODULE,error_in_suite,[[Error]]}];
+			Tests ->
+			    Tests
+		    end
+	    end;
+	Skip = {skip,_Reason} ->
+	    Skip;
+	_ ->
+	    Reason = 
+		list_to_atom("Bad return value from "++atom_to_list(Mod)++":all/0"),
+	    [{?MODULE,error_in_suite,[[{error,Reason}]]}]
+    end.
+
+
+%%!============================================================
+%%! The support for sequences by means of using sequences/0
+%%! will be removed in OTP R14. The code below is only kept 
+%%! for backwards compatibility. From OTP R13 groups with
+%%! sequence property should be used instead!
+%%!============================================================
+%%!============================================================
+%%! START OF DEPRECATED SUPPORT FOR SEQUENCES --->
+
+get_seq(Mod, Func) ->
+    case ct_util:read_suite_data({seq,Mod,Func}) of
+	undefined ->
+	    case catch apply(Mod,sequences,[]) of
+		{'EXIT',_} ->
+		    [];
+		Seqs ->
+		    case lists:keysearch(Func,1,Seqs) of
+			{value,{Func,SeqTCs}} ->			    
+			    case catch save_seq(Mod,Func,SeqTCs) of
+				{error,What} ->
+				    [{?MODULE,error_in_suite,[[{error,What}]]}];
+				_ ->
+				    SeqTCs
+			    end;
+			false ->
+			    []
+		    end
+	    end;
+	TCs when is_list(TCs) ->
+	    TCs;
+	_ ->
+	    []
+    end.
+
+save_seqs(Mod,AllTCs) ->
+    case lists:keymember(sequence,1,AllTCs) of
+	true ->
+	    case catch apply(Mod,sequences,[]) of
+		{'EXIT',_} -> 
+		    Reason = list_to_atom(atom_to_list(Mod)++
+					  ":sequences/0 is missing"),
+		    throw({error,Reason});
+		Seqs ->
+		    save_seqs(Mod,AllTCs,Seqs,AllTCs)
+	    end;
+	false ->
+	    AllTCs
+    end.
+    
+save_seqs(Mod,[{sequence,Seq}|TCs],Seqs,All) ->
+    case lists:keysearch(Seq,1,Seqs) of
+	{value,{Seq,SeqTCs}} ->
+	    save_seq(Mod,Seq,SeqTCs,All),
+	    [Seq|save_seqs(Mod,TCs,Seqs,All)];
+	false ->
+	    Reason = list_to_atom(
+		       atom_to_list(Seq)++" is missing in "++
+		       atom_to_list(Mod)),
+	    throw({error,Reason})
+    end;
+save_seqs(Mod,[TC|TCs],Seqs,All) ->
+    [TC|save_seqs(Mod,TCs,Seqs,All)];
+save_seqs(_,[],_,_) ->
+    [].
+
+save_seq(Mod,Seq,SeqTCs) ->
+    save_seq(Mod,Seq,SeqTCs,apply(Mod,all,[])).
+    
+save_seq(Mod,Seq,SeqTCs,All) ->
+    check_private(Seq,SeqTCs,All),
+    check_multiple(Mod,Seq,SeqTCs),
+    ct_util:save_suite_data({seq,Mod,Seq},SeqTCs),
+    lists:foreach(fun(TC) -> 
+			  ct_util:save_suite_data({seq,Mod,TC},Seq)
+		  end, SeqTCs).
+
+check_private(Seq,TCs,All) ->    
+    Bad = lists:filter(fun(TC) -> lists:member(TC,All) end, TCs),
+    if Bad /= [] ->
+	    Reason = io_lib:format("regular test cases not allowed in sequence ~p: "
+				   "~p",[Seq,Bad]),
+	    throw({error,list_to_atom(lists:flatten(Reason))});
+       true ->
+	    ok
+    end.
+
+check_multiple(Mod,Seq,TCs) ->
+    Bad = lists:filter(fun(TC) ->
+			       case ct_util:read_suite_data({seq,Mod,TC}) of
+				   Seq1 when Seq1 /= undefined, Seq1 /= Seq -> 
+				       true;
+
+				   _ -> false
+			       end
+		       end,TCs),
+    if Bad /= [] ->
+	    Reason = io_lib:format("test cases found in multiple sequences: "
+				   "~p",[Bad]),
+	    throw({error,list_to_atom(lists:flatten(Reason))});
+       true ->
+	    ok
+    end.
+
+%%! <---  END OF DEPRECATED SUPPORT FOR SEQUENCES
+%%!============================================================
+
+%% let test_server call this function as a testcase only so that
+%% the user may see info about what's missing in the suite
+error_in_suite(Config) ->
+    Reason = test_server:lookup_config(error,Config),
+    exit(Reason).
+    
+%%%-----------------------------------------------------------------
+%%% @spec report(What,Data) -> ok
+report(What,Data) ->
+    case What of
+	tests_start ->
+	    case ct_util:get_testdata(cover) of
+		undefined -> 
+		    ok;
+		{_CovFile,_CovNodes,CovImport,CovExport,_CovAppData} ->
+		    %% Always import cover data from files specified by CovImport 
+		    %% if no CovExport defined. If CovExport is defined, only
+		    %% import from CovImport files initially, then use CovExport
+		    %% to pass coverdata between proceeding tests (in the same run).
+		    Imps =
+			case CovExport of
+			    [] ->  % don't export data between tests
+				CovImport;
+			    _ ->
+				case filelib:is_file(CovExport) of
+				    true ->
+					[CovExport];
+				    false ->
+					CovImport
+				end
+			end,
+		    lists:foreach(
+		      fun(Imp) ->
+			      case cover:import(Imp) of
+				  ok -> 
+				      ok;
+				  {error,Reason} ->
+				      ct_logs:log("COVER INFO",
+						  "Importing cover data from: ~s fails! "
+						  "Reason: ~p", [Imp,Reason])
+			      end
+		      end, Imps)
+	    end;
+	tests_done ->
+	    ok;
+	tc_start ->
+	    ok;
+	tc_done ->
+	    {_Suite,Case,Result} = Data,
+	    case {Case,Result} of
+		{init_per_suite,_} ->
+		    ok;
+		{end_per_suite,_} ->
+		    ok;
+		{init_per_group,_} ->
+		    ok;
+		{end_per_group,_} ->
+		    ok;
+		{_,ok} ->
+		    add_to_stats(ok);
+		{_,{skipped,{failed,{_,init_per_testcase,_}}}} ->
+		    add_to_stats(auto_skipped);
+		{_,{skipped,{require_failed,_}}} ->
+		    add_to_stats(auto_skipped);
+		{_,{skipped,_}} ->
+		    add_to_stats(user_skipped);
+		{_,{FailOrSkip,_Reason}} ->
+		    add_to_stats(FailOrSkip)
+	    end;
+	tc_user_skip ->	    
+	    %% test case specified as skipped in testspec
+	    %% Data = {Suite,Case,Comment}
+	    ct_event:sync_notify(#event{name=tc_user_skip,
+					node=node(),
+					data=Data}),
+	    add_to_stats(user_skipped);
+	tc_auto_skip ->
+	    %% test case skipped because of error in init_per_suite
+	    %% Data = {Suite,Case,Comment}
+
+	    {_Suite,Case,_Result} = Data,
+
+	    %% this test case does not have a log, so printouts
+	    %% from event handlers should end up in the main log
+	    ct_event:sync_notify(#event{name=tc_auto_skip,
+					node=node(),
+					data=Data}),
+	    if Case /= end_per_suite, Case /= end_per_group -> 
+		    add_to_stats(auto_skipped);
+	       true -> 
+		    ok
+	    end;
+	_ ->
+	    ok
+    end,
+    catch vts:report(What,Data).
+
+add_to_stats(Result) ->
+    Update = fun({Ok,Failed,Skipped={UserSkipped,AutoSkipped}}) ->
+		     Stats =
+			 case Result of
+			     ok ->
+				 {Ok+1,Failed,Skipped};
+			     failed ->
+				 {Ok,Failed+1,Skipped};
+			     skipped ->
+				 {Ok,Failed,{UserSkipped+1,AutoSkipped}};
+			     user_skipped ->
+				 {Ok,Failed,{UserSkipped+1,AutoSkipped}};
+			     auto_skipped ->
+				 {Ok,Failed,{UserSkipped,AutoSkipped+1}}
+			 end,
+		     ct_event:sync_notify(#event{name=test_stats,
+						 node=node(),
+						 data=Stats}),
+		     Stats
+	     end,
+    ct_util:update_testdata(stats, Update).
+
+%%%-----------------------------------------------------------------
+%%% @spec warn(What) -> true | false
+warn(What) when What==nodes; What==processes ->
+    false;
+warn(_What) ->
+    true.
+
+%%%-----------------------------------------------------------------
+%%% @spec add_data_dir(File0) -> File1
+add_data_dir(File,Config) when is_atom(File) ->
+    add_data_dir(atom_to_list(File),Config);
+
+add_data_dir(File,Config) when is_list(File) ->
+    case filename:split(File) of
+	[File] ->
+	    %% no user path, add data dir
+	    case lists:keysearch(data_dir,1,Config) of
+		{value,{data_dir,DataDir}} ->
+		    filename:join(DataDir,File);
+		_ ->
+		    File
+	    end;
+	_ ->
+	    File
+    end.
+
+
diff --git a/lib/common_test/src/ct_ftp.erl b/lib/common_test/src/ct_ftp.erl
new file mode 100644
index 0000000000..5db73066a3
--- /dev/null
+++ b/lib/common_test/src/ct_ftp.erl
@@ -0,0 +1,380 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 2003-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%
+%%
+
+%%% @doc FTP client module (based on the FTP support of the INETS application).
+%%%
+%%% @type connection() = handle() | ct:target_name()
+%%% @type handle() = ct_gen_conn:handle(). Handle for a specific
+%%% ftp connection.
+
+-module(ct_ftp).
+
+%% API
+-export([get/3,put/3, open/1,close/1, send/2,send/3, 
+	 recv/2,recv/3, cd/2, ls/2, type/2, delete/2]).
+
+%% Callbacks
+-export([init/3,handle_msg/2,reconnect/2,terminate/2]).
+
+-include("ct_util.hrl").
+
+-record(state,{ftp_pid,target_name}).
+
+-define(DEFAULT_PORT,21).
+
+%%%=================================================================
+%%% API
+
+%%%-----------------------------------------------------------------
+%%% @spec put(KeyOrName,LocalFile,RemoteFile) -> ok | {error,Reason}
+%%%      KeyOrName = Key | Name
+%%%      Key = atom()
+%%%      Name = ct:target_name()
+%%%      LocalFile = string()
+%%%      RemoteFile = string()
+%%%
+%%% @doc Open a ftp connection and send a file to the remote host.
+%%%
+%%% <p><code>LocalFile</code> and <code>RemoteFile</code> must be
+%%% absolute paths.</p>
+%%%
+%%% <p>If the target host is a "special" node, the ftp address must be
+%%% specified in the config file like this:</p>
+%%% <pre>
+%%% {node,[{ftp,IpAddr}]}.</pre>
+%%%
+%%% <p>If the target host is something else, e.g. a unix host, the
+%%% config file must also include the username and password (both
+%%% strings):</p>
+%%% <pre>
+%%% {unix,[{ftp,IpAddr},
+%%%        {username,Username},
+%%%        {password,Password}]}.</pre>
+put(KeyOrName,LocalFile,RemoteFile) ->
+    Fun = fun(Ftp) -> send(Ftp,LocalFile,RemoteFile) end,
+    open_and_do(KeyOrName,Fun).
+
+%%%-----------------------------------------------------------------
+%%% @spec get(KeyOrName,RemoteFile,LocalFile) -> ok | {error,Reason}
+%%%      KeyOrName = Key | Name
+%%%      Key = atom()
+%%%      Name = ct:target_name()
+%%%      RemoteFile = string()
+%%%      LocalFile = string()
+%%%
+%%% @doc Open a ftp connection and fetch a file from the remote host.
+%%%
+%%% <p><code>RemoteFile</code> and <code>LocalFile</code> must be
+%%% absolute paths.</p>
+%%%
+%%% <p>The config file must be as for put/3.</p>
+%%% @see put/3
+get(KeyOrName,RemoteFile,LocalFile) ->
+    Fun = fun(Ftp) -> recv(Ftp,RemoteFile,LocalFile) end,
+    open_and_do(KeyOrName,Fun).
+
+
+%%%-----------------------------------------------------------------
+%%% @spec open(KeyOrName) -> {ok,Handle} | {error,Reason}
+%%%      KeyOrName = Key | Name
+%%%      Key = atom()
+%%%      Name = ct:target_name()
+%%%      Handle = handle()
+%%% 
+%%% @doc Open an FTP connection to the specified node.
+%%% <p>You can open one connection for a particular <code>Name</code> and
+%%% use the same name as reference for all subsequent operations. If you
+%%% want the connection to be associated with <code>Handle</code> instead 
+%%% (in case you need to open multiple connections to a host for example), 
+%%% simply use <code>Key</code>, the configuration variable name, to 
+%%% specify the target. Note that a connection that has no associated target 
+%%% name can only be closed with the handle value.</p>
+open(KeyOrName) ->
+    case ct_util:get_key_from_name(KeyOrName) of
+	{ok,node} ->
+	    open(KeyOrName,"erlang","x");
+	_ ->
+	    case ct:get_config(KeyOrName) of
+		undefined ->
+		    log(heading(open,KeyOrName),"Failed: ~p\n",
+			[{not_available,KeyOrName}]),
+		    {error,{not_available,KeyOrName}};
+		_ ->
+		    case ct:get_config({KeyOrName,username}) of
+			undefined ->
+			    log(heading(open,KeyOrName),"Failed: ~p\n",
+				[{not_available,{KeyOrName,username}}]),
+			    {error,{not_available,{KeyOrName,username}}};
+			Username ->
+			    case ct:get_config({KeyOrName,password}) of
+				undefined ->
+				    log(heading(open,KeyOrName),"Failed: ~p\n",
+					[{not_available,{KeyOrName,password}}]),
+				    {error,{not_available,{KeyOrName,password}}};
+				Password ->
+				    open(KeyOrName,Username,Password)
+			    end
+		    end
+	    end
+    end.
+
+open(KeyOrName,Username,Password) ->
+    log(heading(open,KeyOrName),"",[]),
+    case ct:get_config({KeyOrName,ftp}) of
+	undefined ->
+	    log(heading(open,KeyOrName),"Failed: ~p\n",
+		[{not_available,{KeyOrName,ftp}}]),
+	    {error,{not_available,{KeyOrName,ftp}}};
+	Addr ->
+	    ct_gen_conn:start(KeyOrName,full_addr(Addr),{Username,Password},?MODULE)
+    end.
+
+
+%%%-----------------------------------------------------------------
+%%% @spec send(Connection,LocalFile) -> ok | {error,Reason}
+%%%
+%%% @doc Send a file over FTP.
+%%% <p>The file will get the same name on the remote host.</p>
+%%% @see send/3
+send(Connection,LocalFile) ->
+    send(Connection,LocalFile,filename:basename(LocalFile)).
+
+%%%-----------------------------------------------------------------
+%%% @spec send(Connection,LocalFile,RemoteFile) -> ok | {error,Reason}
+%%%      Connection = connection()
+%%%      LocalFile = string()
+%%%      RemoteFile = string()
+%%%
+%%% @doc Send a file over FTP.
+%%%
+%%% <p>The file will be named <code>RemoteFile</code> on the remote host.</p>
+send(Connection,LocalFile,RemoteFile) ->
+    case get_handle(Connection) of
+	{ok,Pid} ->
+	    call(Pid,{send,LocalFile,RemoteFile});
+	Error ->
+	    Error
+    end.
+
+%%%-----------------------------------------------------------------
+%%% @spec recv(Connection,RemoteFile) -> ok | {error,Reason}
+%%%
+%%% @doc Fetch a file over FTP.
+%%% <p>The file will get the same name on the local host.</p>
+%%% @see recv/3
+recv(Connection,RemoteFile) ->
+    recv(Connection,RemoteFile,filename:basename(RemoteFile)).
+
+%%%-----------------------------------------------------------------
+%%% @spec recv(Connection,RemoteFile,LocalFile) -> ok | {error,Reason}
+%%%      Connection = connection()
+%%%      RemoteFile = string()
+%%%      LocalFile = string()
+%%%
+%%% @doc Fetch a file over FTP.
+%%%
+%%% <p>The file will be named <code>LocalFile</code> on the local host.</p>
+recv(Connection,RemoteFile,LocalFile) ->
+    case get_handle(Connection) of
+	{ok,Pid} ->
+	    call(Pid,{recv,RemoteFile,LocalFile});
+	Error ->
+	    Error
+    end.
+
+%%%-----------------------------------------------------------------
+%%% @spec cd(Connection,Dir) -> ok | {error,Reason}
+%%%      Connection = connection()
+%%%      Dir = string()
+%%%
+%%% @doc Change directory on remote host.
+cd(Connection,Dir) ->
+    case get_handle(Connection) of
+	{ok,Pid} ->
+	    call(Pid,{cd,Dir});
+	Error ->
+	    Error
+    end.
+
+%%%-----------------------------------------------------------------
+%%% @spec ls(Connection,Dir) -> {ok,Listing} | {error,Reason}
+%%%      Connection = connection()
+%%%      Dir = string()
+%%%      Listing = string()
+%%%
+%%% @doc List the directory Dir.
+ls(Connection,Dir) ->
+    case get_handle(Connection) of
+	{ok,Pid} ->
+	    call(Pid,{ls,Dir});
+	Error ->
+	    Error
+    end.
+
+%%%-----------------------------------------------------------------
+%%% @spec type(Connection,Type) -> ok | {error,Reason}
+%%%      Connection = connection()
+%%%      Type = ascii | binary
+%%%
+%%% @doc Change file transfer type
+type(Connection,Type) ->
+    case get_handle(Connection) of
+	{ok,Pid} ->
+	    call(Pid,{type,Type});
+	Error ->
+	    Error
+    end.
+    
+%%%-----------------------------------------------------------------
+%%% @spec delete(Connection,File) -> ok | {error,Reason}
+%%%      Connection = connection()
+%%%      File = string()
+%%%
+%%% @doc Delete a file on remote host
+delete(Connection,File) ->
+    case get_handle(Connection) of
+	{ok,Pid} ->
+	    call(Pid,{delete,File});
+	Error ->
+	    Error
+    end.
+
+%%%-----------------------------------------------------------------
+%%% @spec close(Connection) -> ok | {error,Reason}
+%%%      Connection = connection()
+%%%
+%%% @doc Close the FTP connection.
+close(Connection) ->
+    case get_handle(Connection) of
+	{ok,Pid} ->
+	    ct_gen_conn:stop(Pid);
+	Error ->
+	    Error
+    end.
+
+
+%%%=================================================================
+%%% Callback functions
+
+%% @hidden
+init(KeyOrName,{IP,Port},{Username,Password}) ->
+    case ftp_connect(IP,Port,Username,Password) of
+	{ok,FtpPid} ->
+	    log(heading(init,KeyOrName), 
+		"Opened ftp connection:\nIP: ~p\nUsername: ~p\nPassword: ~p\n",
+		[IP,Username,lists:duplicate(length(Password),$*)]),
+	    {ok,FtpPid,#state{ftp_pid=FtpPid,target_name=KeyOrName}};
+	Error ->
+	    Error
+    end.
+	    
+ftp_connect(IP,Port,Username,Password) ->
+    inets:start(),
+    case inets:start(ftpc,[{host,IP},{port,Port}]) of
+	{ok,FtpPid} ->
+	    case ftp:user(FtpPid,Username,Password) of
+		ok ->
+		    {ok,FtpPid};
+		{error,Reason} ->
+		    {error,{user,Reason}}
+	    end;
+	{error,Reason} ->
+	    {error,{open,Reason}}
+    end.
+
+%% @hidden
+handle_msg({send,LocalFile,RemoteFile},State) ->
+    log(heading(send,State#state.target_name),
+	"LocalFile: ~p\nRemoteFile: ~p\n",[LocalFile,RemoteFile]),
+    Result = ftp:send(State#state.ftp_pid,LocalFile,RemoteFile),
+    {Result,State};
+handle_msg({recv,RemoteFile,LocalFile},State) ->
+    log(heading(recv,State#state.target_name),
+	"RemoteFile: ~p\nLocalFile: ~p\n",[RemoteFile,LocalFile]),
+    Result = ftp:recv(State#state.ftp_pid,RemoteFile,LocalFile),
+    {Result,State};
+handle_msg({cd,Dir},State) ->
+    log(heading(cd,State#state.target_name),"Dir: ~p\n",[Dir]),
+    Result = ftp:cd(State#state.ftp_pid,Dir),
+    {Result,State};
+handle_msg({ls,Dir},State) ->
+    log(heading(ls,State#state.target_name),"Dir: ~p\n",[Dir]),
+    Result = ftp:ls(State#state.ftp_pid,Dir),
+    {Result,State};
+handle_msg({type,Type},State) ->
+    log(heading(type,State#state.target_name),"Type: ~p\n",[Type]),
+    Result = ftp:type(State#state.ftp_pid,Type),
+    {Result,State};
+handle_msg({delete,File},State) ->
+    log(heading(delete,State#state.target_name),"Delete file: ~p\n",[File]),
+    Result = ftp:delete(State#state.ftp_pid,File),
+    {Result,State}.
+
+%% @hidden
+reconnect(_Addr,_State) ->
+    {error,no_reconnection_of_ftp}.
+
+%% @hidden
+terminate(FtpPid,State) ->
+    log(heading(terminate,State#state.target_name),
+	"Closing FTP connection.\nHandle: ~p\n",[FtpPid]),
+    inets:stop(ftpc,FtpPid).
+
+
+%%%=================================================================
+%%% Internal function
+get_handle(Pid) when is_pid(Pid) ->
+    {ok,Pid};
+get_handle(Name) ->
+    case ct_util:get_connections(Name,?MODULE) of
+	{ok,[{Pid,_}|_]} ->
+	    {ok,Pid};
+	{ok,[]} ->
+	    open(Name);
+	Error ->
+	    Error
+    end.
+
+full_addr({Ip,Port}) ->
+    {Ip,Port};
+full_addr(Ip) ->
+    {Ip,?DEFAULT_PORT}.
+
+call(Pid,Msg) ->
+    ct_gen_conn:call(Pid,Msg).
+
+
+heading(Function,Name) ->
+    io_lib:format("ct_ftp:~w ~p",[Function,Name]).
+
+log(Heading,Str,Args) ->
+    ct_gen_conn:log(Heading,Str,Args).
+
+
+open_and_do(Name,Fun) ->
+    case open(Name) of
+	{ok,Ftp} ->
+	    R = Fun(Ftp),
+	    close(Ftp),
+	    R;
+	Error ->
+	    Error
+    end.
+    
+    
diff --git a/lib/common_test/src/ct_gen_conn.erl b/lib/common_test/src/ct_gen_conn.erl
new file mode 100644
index 0000000000..a31e57c7ea
--- /dev/null
+++ b/lib/common_test/src/ct_gen_conn.erl
@@ -0,0 +1,286 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 2003-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%
+%%
+
+%%% @doc Generic connection owner process.
+%%%
+%%% @type handle() = pid(). A handle for using a connection implemented
+%%% with ct_gen_conn.erl.
+
+-module(ct_gen_conn).
+
+-compile(export_all).
+
+-export([start/4, stop/1]).
+-export([call/2, do_within_time/2]).
+
+-ifdef(debug).
+-define(dbg,true).
+-else.
+-define(dbg,false).
+-endif.
+
+-record(gen_opts,{callback,
+		  name,
+		  address,
+		  init_data,
+		  conn_pid,
+		  cb_state,
+		  ct_util_server}).
+
+%%%-----------------------------------------------------------------
+%%% @spec start(Name,Address,InitData,CallbackMod) -> 
+%%%                                     {ok,Handle} | {error,Reason}
+%%%      Name = term()
+%%%      CallbackMod = atom()
+%%%      InitData = term()
+%%%      Address = term()
+%%%
+%%% @doc Open a connection and start the generic connection owner process.
+%%%
+%%% <p>The <code>CallbackMod</code> is a specific callback module for
+%%% each type of connection (e.g. telnet, ftp,...). It must export the
+%%% function <code>init/3</code> which takes the arguments
+%%% <code>Name</code>, <code>Addresse</code>) and
+%%% <code>InitData</code> and returna
+%%% <code>{ok,ConnectionPid,State}</code> or
+%%% <code>{error,Reason}</code>.</p>
+start(Name,Address,InitData,CallbackMod) ->
+    case ct_util:does_connection_exist(Name,Address,CallbackMod) of
+	{ok,Pid} ->
+	    log("ct_gen_conn:start","Using existing connection!\n",[]),
+	    {ok,Pid};
+	false ->
+	    Self = self(),
+	    Pid = spawn(fun() -> 
+				init_gen(Self, #gen_opts{callback=CallbackMod,
+							 name=Name,
+							 address=Address,
+							 init_data=InitData})
+			end),
+	    MRef = erlang:monitor(process,Pid),
+	    receive 
+		{connected,Pid} -> 
+		    erlang:demonitor(MRef),
+		    ct_util:register_connection(Name,Address,CallbackMod,Pid),
+		    {ok,Pid};
+		{Error,Pid} ->
+		    receive {'DOWN',MRef,process,_,_} -> ok end,
+		    Error;
+		{'DOWN',MRef,process,_,Reason} ->
+		    log("ct_gen_conn:start",
+			"Connection process died: ~p\n",
+			[Reason]),
+		    {error,{connection_process_died,Reason}}
+	    end
+    end.
+
+
+%%%-----------------------------------------------------------------
+%%% @spec stop(Handle) -> ok
+%%%      Handle = handle()
+%%%
+%%% @doc Close the telnet connection and stop the process managing it.
+stop(Pid) ->
+    call(Pid,stop).
+
+%%%-----------------------------------------------------------------
+%%% @spec log(Heading,Format,Args) -> ok
+%%%
+%%% @doc Log activities on the current connection (tool-internal use only).
+%%% @see ct_logs:log/3 
+log(Heading,Format,Args) ->
+    log(log,[Heading,Format,Args]).
+
+%%%-----------------------------------------------------------------
+%%% @spec start_log(Heading) -> ok
+%%%
+%%% @doc Log activities on the current connection (tool-internal use only).
+%%% @see ct_logs:start_log/1 
+start_log(Heading) ->
+    log(start_log,[Heading]).
+
+%%%-----------------------------------------------------------------
+%%% @spec cont_log(Format,Args) -> ok
+%%%
+%%% @doc Log activities on the current connection (tool-internal use only).
+%%% @see ct_logs:cont_log/2 
+cont_log(Format,Args) ->
+    log(cont_log,[Format,Args]).
+
+%%%-----------------------------------------------------------------
+%%% @spec end_log() -> ok
+%%%
+%%% @doc Log activities on the current connection (tool-internal use only).
+%%% @see ct_logs:end_log/0 
+end_log() ->
+    log(end_log,[]).
+
+%%%-----------------------------------------------------------------
+%%% @spec do_within_time(Fun,Timeout) -> FunResult | {error,Reason}
+%%%      Fun = function()
+%%%      Timeout = integer()
+%%%
+%%% @doc Execute a function within a limited time (tool-internal use only).
+%%%
+%%% <p>Execute the given <code>Fun</code>, but interrupt if it takes
+%%% more than <code>Timeout</code> milliseconds.</p>
+%%%
+%%% <p>The execution is also interrupted if the connection is
+%%% closed.</p>
+do_within_time(Fun,Timeout) ->
+    Self = self(),
+    Silent = get(silent),
+    TmpPid = spawn_link(fun() -> put(silent,Silent),
+				 R = Fun(),
+				 Self ! {self(),R} 
+			end),
+    ConnPid = get(conn_pid),
+    receive 
+	{TmpPid,Result} ->
+	    Result;
+	{'EXIT',ConnPid,_Reason}=M ->
+	    unlink(TmpPid),
+	    exit(TmpPid,kill),
+	    self() ! M,
+	    {error,connection_closed}
+    after 
+	Timeout ->
+	    exit(TmpPid,kill),
+	    receive
+		{TmpPid,Result} ->
+		    %% TmpPid just managed to send the result at the same time
+		    %% as the timeout expired.
+		    receive {'EXIT',TmpPid,_reason} -> ok end,
+		    Result;
+		{'EXIT',TmpPid,killed} ->
+		    %% TmpPid did not send the result before the timeout expired.
+		    {error,timeout}
+	    end
+    end.
+
+%%%=================================================================
+%%% Internal functions
+call(Pid,Msg) ->
+    MRef = erlang:monitor(process,Pid),
+    Ref = make_ref(),
+    Pid ! {Msg,{self(),Ref}},
+    receive
+	{Ref, Result} -> 
+	    erlang:demonitor(MRef),
+	    case Result of
+		{retry,_Data} ->
+		    call(Pid,Result);
+		Other ->
+		    Other
+	    end;
+	{'DOWN',MRef,process,_,Reason}  -> 
+	    {error,{process_down,Pid,Reason}}
+    end.
+
+return({To,Ref},Result) ->
+    To ! {Ref, Result}.
+
+init_gen(Parent,Opts) ->
+    process_flag(trap_exit,true),
+    CtUtilServer = whereis(ct_util_server),
+    link(CtUtilServer),
+    put(silent,false),
+    case catch (Opts#gen_opts.callback):init(Opts#gen_opts.name,
+					     Opts#gen_opts.address,
+					     Opts#gen_opts.init_data) of
+	{ok,ConnPid,State} when is_pid(ConnPid) ->
+	    link(ConnPid),
+	    put(conn_pid,ConnPid),
+	    Parent ! {connected,self()},
+	    loop(Opts#gen_opts{conn_pid=ConnPid,
+			       cb_state=State,
+			       ct_util_server=CtUtilServer});
+	{error,Reason} ->
+	    Parent ! {{error,Reason},self()}
+    end.
+
+loop(Opts) ->
+    receive
+	{'EXIT',Pid,Reason} when Pid==Opts#gen_opts.conn_pid ->
+	    log("Connection down!\nOpening new!","Reason: ~p\nAddress: ~p\n",
+		[Reason,Opts#gen_opts.address]),
+	    case reconnect(Opts) of
+		{ok, NewPid, NewState} ->
+		    link(NewPid),
+		    put(conn_pid,NewPid),
+		    loop(Opts#gen_opts{conn_pid=NewPid,cb_state=NewState});
+		Error ->
+		    ct_util:unregister_connection(self()),
+		    log("Reconnect failed. Giving up!","Reason: ~p\n",[Error])
+	    end;
+	{'EXIT',Pid,Reason} ->
+	    case Opts#gen_opts.ct_util_server of
+		Pid ->
+		    exit(Reason);
+		_ ->
+		    loop(Opts)
+	    end;
+	{stop, From} ->
+	    ct_util:unregister_connection(self()),
+	    (Opts#gen_opts.callback):terminate(Opts#gen_opts.conn_pid,
+					       Opts#gen_opts.cb_state),
+	    return(From,ok),
+	    ok;
+	{{retry,{Error,_Name,CPid,_Msg}}, From} when CPid == Opts#gen_opts.conn_pid ->
+	    %% only retry if failure is because of a reconnection
+	    Return = case Error of
+			 {error,_} -> Error;
+			 Reason -> {error,Reason}
+		     end,
+	    return(From, Return),
+	    loop(Opts);
+	{{retry,{_Error,_Name,_CPid,Msg}}, From} ->
+	    log("Rerunning command","Connection reestablished. Rerunning command...",[]),
+	    {Return,NewState} = 
+		(Opts#gen_opts.callback):handle_msg(Msg,Opts#gen_opts.cb_state),
+	    return(From, Return),
+	    loop(Opts#gen_opts{cb_state=NewState});	    
+	{Msg,From={Pid,_Ref}} when is_pid(Pid) ->
+	    {Return,NewState} = 
+		(Opts#gen_opts.callback):handle_msg(Msg,Opts#gen_opts.cb_state),
+	    return(From, Return),
+	    loop(Opts#gen_opts{cb_state=NewState})
+    end.
+
+nozero({ok,S}) when is_list(S) ->
+    {ok,[C || C <- S,
+	      C=/=0,
+	      C=/=13]};
+nozero(M) ->
+    M.
+
+reconnect(Opts) ->
+    (Opts#gen_opts.callback):reconnect(Opts#gen_opts.address,
+				       Opts#gen_opts.cb_state).
+
+
+log(Func,Args) ->
+    case get(silent) of
+	true when not ?dbg-> 
+	    ok;
+	_ ->
+	    apply(ct_logs,Func,Args)
+    end.
+
+
diff --git a/lib/common_test/src/ct_line.erl b/lib/common_test/src/ct_line.erl
new file mode 100644
index 0000000000..4af9da5463
--- /dev/null
+++ b/lib/common_test/src/ct_line.erl
@@ -0,0 +1,266 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 2003-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%
+%%
+
+%%% @doc Parse transform for inserting line numbers
+
+-module(ct_line).
+
+-record(vars, {module,                      % atom() Module name
+	       vsn,                         % atom()
+	       
+	       init_info=[],                % [{M,F,A,C,L}]
+
+	       function,                    % atom()
+	       arity,                       % int()
+	       clause,                      % int()
+	       lines,                       % [int()]
+	       depth,                       % int()
+	       is_guard=false               % boolean
+	      }).
+
+-export([parse_transform/2,
+	line/1]).
+
+line(LOC={{Mod,Func},_Line}) ->
+    Lines = case get(test_server_loc) of
+		[{{Mod,Func},_}|Ls] -> 
+		    Ls;
+		Ls when is_list(Ls) -> 
+		    case length(Ls) of
+			10 ->
+			    [_|T]=lists:reverse(Ls),
+			    lists:reverse(T);
+			_ ->
+			    Ls
+		    end;
+		_ -> 
+		    [] 
+	    end,
+    put(test_server_loc,[LOC|Lines]).
+
+parse_transform(Forms, _Options) ->
+    transform(Forms, _Options).
+
+%% forms(Fs) -> lists:map(fun (F) -> form(F) end, Fs).
+
+transform(Forms, _Options)->
+    Vars0 = #vars{},
+    {ok, MungedForms, _Vars} = transform(Forms, [], Vars0),
+    MungedForms.
+    
+
+transform([Form|Forms], MungedForms, Vars) ->
+    case munge(Form, Vars) of
+	ignore ->
+	    transform(Forms, MungedForms, Vars);
+	{MungedForm, Vars2} ->
+	    transform(Forms, [MungedForm|MungedForms], Vars2)
+    end;
+transform([], MungedForms, Vars) ->
+    {ok, lists:reverse(MungedForms), Vars}.
+
+%% This code traverses the abstract code, stored as the abstract_code
+%% chunk in the BEAM file, as described in absform(3) for Erlang/OTP R8B
+%% (Vsn=abstract_v2).
+%% The abstract format after preprocessing differs slightly from the abstract
+%% format given eg using epp:parse_form, this has been noted in comments.
+munge(Form={attribute,_,module,Module}, Vars) ->
+    Vars2 = Vars#vars{module=Module},
+    {Form, Vars2};
+
+munge({function,0,module_info,_Arity,_Clauses}, _Vars) ->
+    ignore; % module_info will be added again when the forms are recompiled
+munge({function,Line,Function,Arity,Clauses}, Vars) ->
+    Vars2 = Vars#vars{function=Function,
+		      arity=Arity,
+		      clause=1,
+		      lines=[],
+		      depth=1},
+    {MungedClauses, Vars3} = munge_clauses(Clauses, Vars2, []),
+    {{function,Line,Function,Arity,MungedClauses}, Vars3};
+munge(Form, Vars) -> % attributes
+    {Form, Vars}.
+
+munge_clauses([{clause,Line,Pattern,Guards,Body}|Clauses], Vars, MClauses) ->
+    {MungedGuards, _Vars} = munge_exprs(Guards, Vars#vars{is_guard=true},[]),
+
+    case Vars#vars.depth of
+	1 -> % function clause
+	    {MungedBody, Vars2} = munge_body(Body, Vars#vars{depth=2}, []),
+	    ClauseInfo = {Vars2#vars.module,
+			  Vars2#vars.function,
+			  Vars2#vars.arity,
+			  Vars2#vars.clause,
+			  length(Vars2#vars.lines)},
+	    InitInfo = [ClauseInfo | Vars2#vars.init_info],
+	    Vars3 = Vars2#vars{init_info=InitInfo,
+			       clause=(Vars2#vars.clause)+1,
+			       lines=[],
+			       depth=1},
+	    munge_clauses(Clauses, Vars3,
+			  [{clause,Line,Pattern,MungedGuards,MungedBody}|
+			   MClauses]);
+
+	2 -> % receive-,  case- or if clause
+	    {MungedBody, Vars2} = munge_body(Body, Vars, []),
+	    munge_clauses(Clauses, Vars2,
+			  [{clause,Line,Pattern,MungedGuards,MungedBody}|
+			   MClauses])
+    end;
+munge_clauses([], Vars, MungedClauses) -> 
+    {lists:reverse(MungedClauses), Vars}.
+
+munge_body([Expr|Body], Vars, MungedBody) ->
+    %% Here is the place to add a call to cover:bump/6!
+    Line = element(2, Expr),
+    Lines = Vars#vars.lines,
+    case lists:member(Line,Lines) of
+	true -> % already a bump at this line!
+	    {MungedExpr, Vars2} = munge_expr(Expr, Vars),
+	    munge_body(Body, Vars2, [MungedExpr|MungedBody]);
+	false ->
+	    Bump = {call, 0, {remote,0,{atom,0,?MODULE},{atom,0,line}},
+		    [{tuple,0,[{tuple,0,[{atom,0,Vars#vars.module},
+					 {atom, 0, Vars#vars.function}]},
+		     {integer, 0, Line}]}]},
+	    Lines2 = [Line|Lines],
+
+	    {MungedExpr, Vars2} = munge_expr(Expr, Vars#vars{lines=Lines2}),
+	    munge_body(Body, Vars2, [MungedExpr,Bump|MungedBody])
+    end;
+munge_body([], Vars, MungedBody) ->
+    {lists:reverse(MungedBody), Vars}.
+
+munge_expr({match,Line,ExprL,ExprR}, Vars) ->
+    {MungedExprL, Vars2} = munge_expr(ExprL, Vars),
+    {MungedExprR, Vars3} = munge_expr(ExprR, Vars2),
+    {{match,Line,MungedExprL,MungedExprR}, Vars3};
+munge_expr({tuple,Line,Exprs}, Vars) ->
+    {MungedExprs, Vars2} = munge_exprs(Exprs, Vars, []),
+    {{tuple,Line,MungedExprs}, Vars2};
+munge_expr({record,Line,Expr,Exprs}, Vars) ->
+    %% Only for Vsn=raw_abstract_v1
+    {MungedExprName, Vars2} = munge_expr(Expr, Vars),
+    {MungedExprFields, Vars3} = munge_exprs(Exprs, Vars2, []),
+    {{record,Line,MungedExprName,MungedExprFields}, Vars3};
+munge_expr({record_field,Line,ExprL,ExprR}, Vars) ->
+    %% Only for Vsn=raw_abstract_v1
+    {MungedExprL, Vars2} = munge_expr(ExprL, Vars),
+    {MungedExprR, Vars3} = munge_expr(ExprR, Vars2),
+    {{record_field,Line,MungedExprL,MungedExprR}, Vars3};
+munge_expr({cons,Line,ExprH,ExprT}, Vars) ->
+    {MungedExprH, Vars2} = munge_expr(ExprH, Vars),
+    {MungedExprT, Vars3} = munge_expr(ExprT, Vars2),
+    {{cons,Line,MungedExprH,MungedExprT}, Vars3};
+munge_expr({op,Line,Op,ExprL,ExprR}, Vars) ->
+    {MungedExprL, Vars2} = munge_expr(ExprL, Vars),
+    {MungedExprR, Vars3} = munge_expr(ExprR, Vars2),
+    {{op,Line,Op,MungedExprL,MungedExprR}, Vars3};
+munge_expr({op,Line,Op,Expr}, Vars) ->
+    {MungedExpr, Vars2} = munge_expr(Expr, Vars),
+    {{op,Line,Op,MungedExpr}, Vars2};
+munge_expr({'catch',Line,Expr}, Vars) ->
+    {MungedExpr, Vars2} = munge_expr(Expr, Vars),
+    {{'catch',Line,MungedExpr}, Vars2};
+munge_expr({call,Line1,{remote,Line2,ExprM,ExprF},Exprs},
+	   Vars) when Vars#vars.is_guard==false->
+    {MungedExprM, Vars2} = munge_expr(ExprM, Vars),
+    {MungedExprF, Vars3} = munge_expr(ExprF, Vars2),
+    {MungedExprs, Vars4} = munge_exprs(Exprs, Vars3, []),
+    {{call,Line1,{remote,Line2,MungedExprM,MungedExprF},MungedExprs}, Vars4};
+munge_expr({call,Line1,{remote,_Line2,_ExprM,ExprF},Exprs},
+	   Vars) when Vars#vars.is_guard==true ->
+    %% Difference in abstract format after preprocessing: BIF calls in guards
+    %% are translated to {remote,...} (which is not allowed as source form)
+    %% NOT NECESSARY FOR Vsn=raw_abstract_v1
+    munge_expr({call,Line1,ExprF,Exprs}, Vars);
+munge_expr({call,Line,Expr,Exprs}, Vars) ->
+    {MungedExpr, Vars2} = munge_expr(Expr, Vars),
+    {MungedExprs, Vars3} = munge_exprs(Exprs, Vars2, []),
+    {{call,Line,MungedExpr,MungedExprs}, Vars3};
+munge_expr({lc,Line,Expr,LC}, Vars) ->
+    {MungedExpr, Vars2} = munge_expr(Expr, Vars),
+    {MungedLC, Vars3} = munge_lc(LC, Vars2, []),
+    {{lc,Line,MungedExpr,MungedLC}, Vars3};
+munge_expr({block,Line,Body}, Vars) ->
+    {MungedBody, Vars2} = munge_body(Body, Vars, []),
+    {{block,Line,MungedBody}, Vars2};
+munge_expr({'if',Line,Clauses}, Vars) -> 
+    {MungedClauses,Vars2} = munge_clauses(Clauses, Vars, []),
+    {{'if',Line,MungedClauses}, Vars2};
+munge_expr({'case',Line,Expr,Clauses}, Vars) ->
+    {MungedExpr,Vars2} = munge_expr(Expr,Vars),
+    {MungedClauses,Vars3} = munge_clauses(Clauses, Vars2, []),
+    {{'case',Line,MungedExpr,MungedClauses}, Vars3};
+munge_expr({'receive',Line,Clauses}, Vars) -> 
+    {MungedClauses,Vars2} = munge_clauses(Clauses, Vars, []),
+    {{'receive',Line,MungedClauses}, Vars2};
+munge_expr({'receive',Line,Clauses,Expr,Body}, Vars) ->
+    {MungedClauses,Vars2} = munge_clauses(Clauses, Vars, []),
+    {MungedExpr, Vars3} = munge_expr(Expr, Vars2),
+    {MungedBody, Vars4} = munge_body(Body, Vars3, []),
+    {{'receive',Line,MungedClauses,MungedExpr,MungedBody}, Vars4};
+munge_expr({'try',Line,Exprs,Clauses,CatchClauses}, Vars) ->
+    {MungedExprs, Vars1} = munge_exprs(Exprs, Vars, []),
+    {MungedClauses, Vars2} = munge_clauses(Clauses, Vars1, []),
+    {MungedCatchClauses, Vars3} = munge_clauses(CatchClauses, Vars2, []),
+    {{'try',Line,MungedExprs,MungedClauses,MungedCatchClauses}, Vars3};
+%% Difference in abstract format after preprocessing: Funs get an extra
+%% element Extra.
+%% NOT NECESSARY FOR Vsn=raw_abstract_v1
+munge_expr({'fun',Line,{function,Name,Arity},_Extra}, Vars) ->
+    {{'fun',Line,{function,Name,Arity}}, Vars};
+munge_expr({'fun',Line,{clauses,Clauses},_Extra}, Vars) ->
+    {MungedClauses,Vars2}=munge_clauses(Clauses, Vars, []),
+    {{'fun',Line,{clauses,MungedClauses}}, Vars2};
+munge_expr({'fun',Line,{clauses,Clauses}}, Vars) ->
+    %% Only for Vsn=raw_abstract_v1
+    {MungedClauses,Vars2}=munge_clauses(Clauses, Vars, []),
+    {{'fun',Line,{clauses,MungedClauses}}, Vars2};
+munge_expr(Form, Vars) -> % var|char|integer|float|string|atom|nil|bin|eof
+    {Form, Vars}.
+
+munge_exprs([Expr|Exprs], Vars, MungedExprs) when Vars#vars.is_guard==true,
+						  is_list(Expr) ->
+    {MungedExpr, _Vars} = munge_exprs(Expr, Vars, []),
+    munge_exprs(Exprs, Vars, [MungedExpr|MungedExprs]);
+munge_exprs([Expr|Exprs], Vars, MungedExprs) ->
+    {MungedExpr, Vars2} = munge_expr(Expr, Vars),
+    munge_exprs(Exprs, Vars2, [MungedExpr|MungedExprs]);
+munge_exprs([], Vars, MungedExprs) ->
+    {lists:reverse(MungedExprs), Vars}.
+
+munge_lc([{generate,Line,Pattern,Expr}|LC], Vars, MungedLC) ->
+    {MungedExpr, Vars2} = munge_expr(Expr, Vars),
+    munge_lc(LC, Vars2, [{generate,Line,Pattern,MungedExpr}|MungedLC]);
+munge_lc([Expr|LC], Vars, MungedLC) ->
+    {MungedExpr, Vars2} = munge_expr(Expr, Vars),
+    munge_lc(LC, Vars2, [MungedExpr|MungedLC]);
+munge_lc([], Vars, MungedLC) ->
+    {lists:reverse(MungedLC), Vars}.
+
+
+
+
+
+
+
+
+
+
diff --git a/lib/common_test/src/ct_logs.erl b/lib/common_test/src/ct_logs.erl
new file mode 100644
index 0000000000..bd1a89ae1f
--- /dev/null
+++ b/lib/common_test/src/ct_logs.erl
@@ -0,0 +1,1606 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 2003-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%
+%%
+
+%%% @doc Logging functionality for Common Test Framework.
+%%%
+%%% <p>This module implements
+%%% <ul>
+%%% <li>Internal logging of activities in Common Test Framework</li>
+%%% <li>Compilation of test results into index pages on several levels</li>
+%%% </ul>
+%%% </p>
+
+-module(ct_logs).
+
+-export([init/1,close/1,init_tc/0,end_tc/1]).
+-export([get_log_dir/0,log/3,start_log/1,cont_log/2,end_log/0]).
+-export([set_stylesheet/2,clear_stylesheet/1]).
+-export([add_external_logs/1,add_link/3]).
+-export([make_last_run_index/0]).
+-export([make_all_suites_index/1,make_all_runs_index/1]).
+
+%% Logging stuff directly from testcase
+-export([tc_log/3,tc_print/3,tc_pal/3]).
+
+%% Simulate logger process for use without ct environment running
+-export([simulate/0]).
+
+-include("ct_event.hrl").
+-include("ct_util.hrl").
+-include_lib("kernel/include/file.hrl").
+
+-define(suitelog_name,"suite.log").
+-define(run_summary, "suite.summary").
+-define(logdir_ext, ".logs").
+-define(ct_log_name, "ctlog.html").
+-define(all_runs_name, "all_runs.html").
+-define(index_name, "index.html").
+-define(totals_name, "totals.info").
+
+-define(table_color1,"#ADD8E6").
+-define(table_color2,"#E4F0FE").
+-define(table_color3,"#F0F8FF").
+
+-define(testname_width, 70).
+
+-define(abs(Name), filename:absname(Name)).
+
+%%%-----------------------------------------------------------------
+%%% @spec init(Mode) -> Result
+%%%   Mode = normal | interactive
+%%%   Result = {StartTime,LogDir}
+%%%   StartTime = term()
+%%%   LogDir = string()
+%%%
+%%% @doc Initiate the logging mechanism (tool-internal use only).
+%%%
+%%% <p>This function is called by ct_util.erl when testing is
+%%% started. A new directory named ct_run.&lt;timestamp&gt; is created
+%%% and all logs are stored under this directory.</p>
+%%%
+init(Mode) ->
+    Self = self(),
+    Pid = spawn_link(fun() -> logger(Self,Mode) end),
+    MRef = erlang:monitor(process,Pid),
+    receive 
+	{started,Pid,Result} -> 
+	    erlang:demonitor(MRef),
+	    Result;
+	{'DOWN',MRef,process,_,Reason} ->
+	    exit({could_not_start_process,?MODULE,Reason})
+    end.
+    
+make_dirname({{YY,MM,DD},{H,M,S}}) -> 
+    io_lib:format(logdir_node_prefix()++".~w-~2.2.0w-~2.2.0w_~2.2.0w.~2.2.0w.~2.2.0w",
+		  [YY,MM,DD,H,M,S]).
+
+logdir_prefix() ->
+    "ct_run".
+logdir_node_prefix() ->
+    logdir_prefix()++"."++atom_to_list(node()).
+
+%%%-----------------------------------------------------------------
+%%% @spec close(How) -> ok
+%%%
+%%% @doc Create index pages with test results and close the CT Log
+%%% (tool-internal use only).
+close(How) ->
+    make_last_run_index(),
+
+    ct_event:notify(#event{name=stop_logging,node=node(),data=[]}),
+
+    case whereis(?MODULE) of
+	Pid when is_pid(Pid) ->
+	    MRef = erlang:monitor(process,Pid),
+	    ?MODULE ! stop,
+	    receive
+		{'DOWN',MRef,process,_,_} ->
+		    ok
+	    end;
+	undefined ->
+	    ok
+    end,
+
+    if How == clean ->
+	    case cleanup() of
+		ok ->
+		    ok;
+		Error ->
+		    io:format("Warning! Cleanup failed: ~p~n", [Error])
+	    end;
+       true -> 
+	    file:set_cwd("..")
+    end,       
+
+    make_all_suites_index(stop),
+    make_all_runs_index(stop),
+
+    ok.
+
+%%%-----------------------------------------------------------------
+%%% @spec set_stylesheet(TC,SSFile) -> ok
+set_stylesheet(TC, SSFile) ->
+    cast({set_stylesheet,TC,SSFile}).
+
+%%%-----------------------------------------------------------------
+%%% @spec clear_stylesheet(TC) -> ok
+clear_stylesheet(TC) ->
+    cast({clear_stylesheet,TC}).
+
+%%%-----------------------------------------------------------------
+%%% @spec get_log_dir() -> {ok,Dir} | {error,Reason}
+get_log_dir() ->
+    call(get_log_dir).
+
+%%%-----------------------------------------------------------------
+%%% make_last_run_index() -> ok
+make_last_run_index() ->
+    call(make_last_run_index).
+
+call(Msg) ->
+    case whereis(?MODULE) of
+	undefined ->
+	    {error,does_not_exist};
+	Pid ->
+	    MRef = erlang:monitor(process,Pid),
+	    Ref = make_ref(),
+	    ?MODULE ! {Msg,{self(),Ref}},
+	    receive
+		{Ref, Result} -> 
+		    erlang:demonitor(MRef),
+		    Result;
+		{'DOWN',MRef,process,_,Reason}  -> 
+		    {error,{process_down,?MODULE,Reason}}
+	    end
+    end.
+
+return({To,Ref},Result) ->
+    To ! {Ref, Result}.
+
+cast(Msg) ->
+    case whereis(?MODULE) of
+	undefined ->
+	    {error,does_not_exist};
+	_Pid ->
+	    ?MODULE ! Msg
+    end.
+
+
+%%%-----------------------------------------------------------------
+%%% @spec init_tc() -> ok
+%%%
+%%% @doc Test case initiation (tool-internal use only).
+%%%
+%%% <p>This function is called by ct_framework:init_tc/3</p>
+init_tc() ->
+    call({init_tc,self(),group_leader()}),
+    ok.
+
+%%%-----------------------------------------------------------------
+%%% @spec end_tc(TCPid) -> ok | {error,Reason}
+%%%
+%%% @doc Test case clean up (tool-internal use only).
+%%%
+%%% <p>This function is called by ct_framework:end_tc/3</p>
+end_tc(TCPid) ->
+    %% use call here so that the TC process will wait and receive
+    %% possible exit signals from ct_logs before end_tc returns ok 
+    call({end_tc,TCPid}).
+
+%%%-----------------------------------------------------------------
+%%% @spec log(Heading,Format,Args) -> ok
+%%%
+%%% @doc Log internal activity (tool-internal use only).
+%%%
+%%% <p>This function writes an entry to the currently active log,
+%%% i.e. either the CT log or a test case log.</p>
+%%%
+%%% <p><code>Heading</code> is a short string indicating what type of
+%%% activity it is. <code>Format</code> and <code>Args</code> is the
+%%% data to log (as in <code>io:format(Format,Args)</code>).</p>
+log(Heading,Format,Args) ->
+    cast({log,self(),group_leader(),
+	  [{int_header(),[log_timestamp(now()),Heading]},
+	   {Format,Args},
+	   {int_footer(),[]}]}),
+    ok.
+
+%%%-----------------------------------------------------------------
+%%% @spec start_log(Heading) -> ok
+%%% 
+%%% @doc Starts the logging of an activity (tool-internal use only).
+%%%
+%%% <p>This function must be used in combination with
+%%% <code>cont_log/2</code> and <code>end_log/0</code>. The intention
+%%% is to call <code>start_log</code> once, then <code>cont_log</code>
+%%% any number of times and finally <code>end_log</code> once.</p>
+%%% 
+%%% <p>For information about the parameters, see <code>log/3</code>.</p>
+%%%
+%%% @see log/3
+%%% @see cont_log/2
+%%% @see end_log/0
+start_log(Heading) ->
+    cast({log,self(),group_leader(),
+	  [{int_header(),[log_timestamp(now()),Heading]}]}),
+    ok.
+
+%%%-----------------------------------------------------------------
+%%% @spec cont_log(Format,Args) -> ok
+%%% 
+%%% @doc Adds information about an activity (tool-internal use only).
+%%%
+%%% @see start_log/1
+%%% @see end_log/0
+cont_log([],[]) ->
+    ok;
+cont_log(Format,Args) ->
+    maybe_log_timestamp(),
+    cast({log,self(),group_leader(),[{Format,Args}]}),
+    ok.
+
+%%%-----------------------------------------------------------------
+%%% @spec end_log() -> ok
+%%% 
+%%% @doc Ends the logging of an activity (tool-internal use only).
+%%%
+%%% @see start_log/1
+%%% @see cont_log/2
+end_log() ->
+    cast({log,self(),group_leader(),[{int_footer(), []}]}),
+    ok.
+    
+
+%%%-----------------------------------------------------------------
+%%% @spec add_external_logs(Logs) -> ok
+%%%      Logs = [Log]
+%%%      Log = string()
+%%%
+%%% @doc Print a link to each given <code>Log</code> in the test case
+%%% log.
+%%%
+%%% <p>The given <code>Logs</code> must exist in the priv dir of the
+%%% calling test suite.</p>
+add_external_logs(Logs) ->
+    start_log("External Logs"),
+    [cont_log("<a href=~p>~s</a>\n",
+	      [filename:join("log_private",Log),Log]) || Log <- Logs],
+    end_log().
+
+%%%-----------------------------------------------------------------
+%%% @spec add_link(Heading,File,Type) -> ok
+%%%      Heading = string()
+%%%      File = string()
+%%%      Type = string()
+%%%
+%%% @doc Print a link to a given file stored in the priv_dir of the
+%%% calling test suite.
+add_link(Heading,File,Type) ->
+    log(Heading,"<a href=~p type=~p>~s</a>\n",
+	[filename:join("log_private",File),Type,File]).
+
+
+
+%%%-----------------------------------------------------------------
+%%% @spec tc_log(Category,Format,Args) -> ok
+%%%      Category = atom()
+%%%      Format = string()
+%%%      Args = list()
+%%%
+%%% @doc Printout from a testcase. 
+%%%
+%%% <p>This function is called by <code>ct</code> when logging
+%%% stuff directly from a testcase (i.e. not from within the CT
+%%% framework).</p>
+tc_log(Category,Format,Args) ->
+    cast({log,self(),group_leader(),[{div_header(Category),[]},
+				     {Format,Args},
+				     {div_footer(),[]}]}),
+    ok.
+
+%%%-----------------------------------------------------------------
+%%% @spec tc_print(Category,Format,Args) -> ok
+%%%      Category = atom()
+%%%      Format = string()
+%%%      Args = list()
+%%%
+%%% @doc Console printout from a testcase. 
+%%%
+%%% <p>This function is called by <code>ct</code> when printing
+%%% stuff a testcase on the user console.</p>
+tc_print(Category,Format,Args) ->
+    print_heading(Category),
+    io:format(user,Format,Args),
+    io:format(user,"\n\n",[]),
+    ok.
+
+print_heading(default) ->
+    io:format(user,
+	      "----------------------------------------------------\n~s\n",
+	      [log_timestamp(now())]);
+print_heading(Category) ->
+    io:format(user,
+	      "----------------------------------------------------\n~s  ~w\n",
+	      [log_timestamp(now()),Category]).    
+    
+
+%%%-----------------------------------------------------------------
+%%% @spec tc_pal(Category,Format,Args) -> ok
+%%%      Category = atom()
+%%%      Format = string()
+%%%      Args = list()
+%%%
+%%% @doc Print and log from a testcase. 
+%%%
+%%% <p>This function is called by <code>ct</code> when logging
+%%% stuff directly from a testcase. The info is written both in the
+%%% log and on the console.</p>
+tc_pal(Category,Format,Args) ->
+    tc_print(Category,Format,Args),
+    cast({log,self(),group_leader(),[{div_header(Category),[]},
+				     {Format,Args},
+				     {div_footer(),[]}]}),
+    ok.
+
+
+%%%=================================================================
+%%% Internal functions
+int_header() ->
+    "<div class=\"ct_internal\"><b>*** CT ~s *** ~s</b>".
+int_footer() ->
+    "</div>".
+
+div_header(Class) ->
+    "<div class=\"" ++ atom_to_list(Class) ++ "\"><b>*** User  " ++   
+	log_timestamp(now()) ++ " ***</b>".
+div_footer() ->
+    "</div>".
+
+
+maybe_log_timestamp() ->
+    {MS,S,US} = now(),
+    case get(log_timestamp) of
+	{MS,S,_} ->
+	    ok;
+	_ ->
+	    cast({log,self(),group_leader(),
+		  [{"<i>~s</i>",[log_timestamp({MS,S,US})]}]})
+    end.
+
+log_timestamp(Now) ->
+    put(log_timestamp,Now),
+    {_,{H,M,S}} = calendar:now_to_local_time(Now),
+    lists:flatten(io_lib:format("~2.2.0w:~2.2.0w:~2.2.0w",
+				[H,M,S])).
+
+%%%-----------------------------------------------------------------
+%%% The logger server
+-record(logger_state,{parent,
+		      log_dir,
+		      start_time,
+		      orig_GL,
+		      ct_log_fd,
+		      tc_groupleaders,
+		      stylesheet}).
+
+logger(Parent,Mode) ->
+    register(?MODULE,self()),
+
+    %%! Below is a temporary workaround for the limitation of
+    %%! max one test run per second. 
+    %%! --->
+    Time0 = calendar:local_time(),
+    Dir0 = make_dirname(Time0),
+    {Time,Dir} = 
+	case filelib:is_dir(Dir0) of
+	    true ->
+		timer:sleep(1000),
+		Time1 = calendar:local_time(),
+		Dir1 = make_dirname(Time1),
+
+		{Time1,Dir1};
+	    false ->
+		{Time0,Dir0}
+	end,
+    %%! <---
+
+    file:make_dir(Dir),
+    ct_event:notify(#event{name=start_logging,node=node(),
+			   data=?abs(Dir)}),
+    make_all_suites_index(start),
+    make_all_runs_index(start),
+    case Mode of
+	interactive -> interactive_link();
+	_ -> ok
+    end,
+    file:set_cwd(Dir),
+    make_last_run_index(Time),
+    CtLogFd = open_ctlog(),
+    io:format(CtLogFd,int_header()++int_footer(),
+	      [log_timestamp(now()),"Common Test Logger started"]),
+    Parent ! {started,self(),{Time,filename:absname("")}},
+    set_evmgr_gl(CtLogFd),
+    logger_loop(#logger_state{parent=Parent,
+			      log_dir=Dir,
+			      start_time=Time,
+			      orig_GL=group_leader(),
+			      ct_log_fd=CtLogFd,
+			      tc_groupleaders=[]}).
+
+logger_loop(State) ->
+    receive
+	{log,Pid,GL,List} ->
+	    case get_groupleader(Pid,GL,State) of
+		{tc_log,TCGL,TCGLs} ->
+		    case erlang:is_process_alive(TCGL) of
+			true ->
+			    %% we have to build one io-list of all strings
+			    %% before printing, or other io printouts (made in
+			    %% parallel) may get printed between this header 
+			    %% and footer 
+			    Fun = 
+				fun({Str,Args},IoList) ->
+					case catch io_lib:format(Str,Args) of
+					    {'EXIT',_Reason} ->
+						Fd = State#logger_state.ct_log_fd,
+						io:format(Fd, 
+							  "Logging fails! Str: ~p, Args: ~p~n",
+							  [Str,Args]),
+						%% stop the testcase, we need to see the fault
+						exit(Pid,logging_failed),
+						ok;
+					    IoStr when IoList == [] ->
+						[IoStr];
+					    IoStr ->
+						[IoList,"\n",IoStr]
+					end
+				end,
+			    io:format(TCGL,"~s",[lists:foldl(Fun,[],List)]),
+			    logger_loop(State#logger_state{tc_groupleaders=TCGLs});
+			false ->
+			    %% Group leader is dead, so write to the CtLog instead
+			    Fd = State#logger_state.ct_log_fd,
+			    [begin io:format(Fd,Str,Args),io:nl(Fd) end || 
+				{Str,Args} <- List],
+			    logger_loop(State)			    
+		    end;
+		{ct_log,Fd,TCGLs} ->
+		    [begin io:format(Fd,Str,Args),io:nl(Fd) end || {Str,Args} <- List],
+		    logger_loop(State#logger_state{tc_groupleaders=TCGLs})
+	    end;
+	{{init_tc,TCPid,GL},From} ->
+	    print_style(GL, State#logger_state.stylesheet),
+	    set_evmgr_gl(GL),
+	    TCGLs = add_tc_gl(TCPid,GL,State),
+	    return(From,ok),
+	    logger_loop(State#logger_state{tc_groupleaders=TCGLs});
+	{{end_tc,TCPid},From} ->
+	    set_evmgr_gl(State#logger_state.ct_log_fd),
+	    return(From,ok),
+	    logger_loop(State#logger_state{tc_groupleaders=rm_tc_gl(TCPid,State)});
+	{get_log_dir,From} ->
+	    return(From,{ok,State#logger_state.log_dir}),
+	    logger_loop(State);
+	{make_last_run_index,From} ->
+	    make_last_run_index(State#logger_state.start_time),
+	    return(From,State#logger_state.log_dir),
+	    logger_loop(State);
+	{set_stylesheet,_,SSFile} when State#logger_state.stylesheet == SSFile ->
+	    logger_loop(State);
+	{set_stylesheet,TC,SSFile} ->
+	    Fd = State#logger_state.ct_log_fd,
+	    io:format(Fd, "~p uses external style sheet: ~s~n", [TC,SSFile]),
+	    logger_loop(State#logger_state{stylesheet=SSFile});
+	{clear_stylesheet,_} when State#logger_state.stylesheet == undefined ->
+	    logger_loop(State);
+	{clear_stylesheet,_} ->
+	    logger_loop(State#logger_state{stylesheet=undefined});	   
+	stop ->
+	    io:format(State#logger_state.ct_log_fd,
+		      int_header()++int_footer(),
+		      [log_timestamp(now()),"Common Test Logger finished"]),
+	    close_ctlog(State#logger_state.ct_log_fd),
+	    ok
+    end.
+
+%% #logger_state.tc_groupleaders == [{Pid,{Type,GLPid}},...]
+%% Type = tc | io
+%%
+%% Pid can either be a test case process (tc), an IO process (io)
+%% spawned by a test case process, or a common test process (never
+%% registered by an init_tc msg). An IO process gets registered the
+%% first time it sends data and will be stored in the list until the
+%% last TC process associated with the same group leader gets 
+%% unregistered.
+%%
+%% If a process that has not been spawned by a test case process
+%% sends a log request, the data will be printed to a test case
+%% log file *if* there exists one registered process only in the 
+%% tc_groupleaders list. If multiple test case processes are
+%% running, the data gets printed to the CT framework log instead. 
+%%
+%% Note that an external process must not be registered as an IO
+%% process since it could then accidentally be associated with
+%% the first test case process that starts in a group of parallel
+%% cases (if the log request would come in between the registration
+%% of the first and second test case process).
+
+get_groupleader(Pid,GL,State) ->
+    TCGLs = State#logger_state.tc_groupleaders,
+    %% check if Pid is registered either as a TC or IO process
+    case proplists:get_value(Pid,TCGLs) of
+	undefined ->
+	    %% this could be a process spawned by the test case process,
+	    %% if so they have the same registered group leader
+	    case lists:keysearch({tc,GL},2,TCGLs) of
+		{value,_} ->
+		    %% register the io process
+		    {tc_log,GL,[{Pid,{io,GL}}|TCGLs]};
+		false ->
+		    %% check if only one test case is executing,
+		    %% if so return the group leader for it
+		    case [TCGL || {_,{Type,TCGL}} <- TCGLs, Type == tc] of
+			[TCGL] ->
+			    %% an external process sending the log
+			    %% request, don't register
+			    {tc_log,TCGL,TCGLs};
+			_ ->
+			    {ct_log,State#logger_state.ct_log_fd,TCGLs}
+		    end
+	    end;
+	{_,GL} ->
+	    {tc_log,GL,TCGLs};
+	_ ->
+	    %% special case where a test case io process has changed
+	    %% its group leader to an non-registered GL process
+	    TCGLs1 = proplists:delete(Pid,TCGLs),
+	    case [TCGL || {_,{Type,TCGL}} <- TCGLs1, Type == tc] of
+		[TCGL] ->
+		    {tc_log,TCGL,TCGLs1};
+		_ ->
+		    {ct_log,State#logger_state.ct_log_fd,TCGLs1}
+	    end    
+    end.
+
+add_tc_gl(TCPid,GL,State) ->
+    TCGLs = State#logger_state.tc_groupleaders,
+    [{TCPid,{tc,GL}} | lists:keydelete(TCPid,1,TCGLs)].
+
+rm_tc_gl(TCPid,State) ->
+    TCGLs = State#logger_state.tc_groupleaders,
+    case proplists:get_value(TCPid,TCGLs) of	
+	{tc,GL} ->
+	    TCGLs1 = lists:keydelete(TCPid,1,TCGLs),
+	    case lists:keysearch({tc,GL},2,TCGLs1) of
+		{value,_} ->
+		    %% test cases using GL remain, keep associated IO processes
+		    TCGLs1;
+		false ->
+		    %% last test case using GL, delete all associated IO processes
+		    lists:filter(fun({_,{io,GLPid}}) when GL == GLPid -> false;
+				    (_) -> true
+				 end, TCGLs1)
+	    end;
+	_ ->
+	    %% add_tc_gl has not been called for this Pid, ignore
+	    TCGLs
+    end.
+
+set_evmgr_gl(GL) ->
+    case whereis(?CT_EVMGR_REF) of
+	undefined -> ok;
+	EvMgrPid -> group_leader(GL,EvMgrPid)
+    end.
+
+open_ctlog() ->
+    {ok,Fd} = file:open(?ct_log_name,[write]),
+    io:format(Fd,header("Common Test Framework"),[]),
+    case file:consult(ct_run:variables_file_name("../")) of
+	{ok,Vars} ->
+	    io:format(Fd, config_table(Vars), []);
+	{error,Reason} ->
+	    {ok,Cwd} = file:get_cwd(),
+	    Dir = filename:dirname(Cwd),
+	    Variables = ct_run:variables_file_name(Dir),
+	    io:format(Fd,
+		      "Can not read the file \'~s\' Reason: ~w\n"
+		      "No configuration found for test!!\n",
+		      [Variables,Reason])
+    end,
+    print_style(Fd,undefined),
+    io:format(Fd, 
+	      "<br><br><h2>Progress Log</h2>\n"
+	      "<pre>\n",[]),
+    Fd.
+
+print_style(Fd,undefined) ->
+    io:format(Fd,
+	      "<style>\n"
+	      "div.ct_internal { background:lightgrey; color:black }\n"
+	      "div.default     { background:lightgreen; color:black }\n"
+	      "</style>\n",
+	      []);
+
+print_style(Fd,StyleSheet) ->
+    case file:read_file(StyleSheet) of
+	{ok,Bin} ->
+	    Str = binary_to_list(Bin),
+	    Pos0 = case string:str(Str,"<style>") of
+		       0 -> string:str(Str,"<STYLE>");
+		       N0 -> N0
+		   end,
+	    case Pos0 of
+		0 -> print_style_error(Fd,StyleSheet,missing_style_tag);
+		_ -> 
+		    Pos1 = case string:str(Str,"</style>") of
+			       0 -> string:str(Str,"</STYLE>");
+			       N1 -> N1
+			   end,
+		    case Pos1 of
+			0 -> 
+			    print_style_error(Fd,StyleSheet,missing_style_end_tag);
+			_ -> 
+			    Style = string:sub_string(Str,Pos0,Pos1+7),
+			    io:format(Fd,"~s\n",[Style])
+		    end
+	    end;
+	{error,Reason} ->
+	    print_style_error(Fd,StyleSheet,Reason)  
+    end.
+
+%% Simple link version, doesn't work with all browsers unfortunately. :-(
+%% print_style(Fd, StyleSheet) ->
+%%    io:format(Fd,
+%%	      "<link href=~p rel=\"stylesheet\" type=\"text/css\">",
+%%	      [StyleSheet]).
+
+print_style_error(Fd,StyleSheet,Reason) ->
+    io:format(Fd,"\n<!-- Failed to load stylesheet ~s: ~p -->\n",
+	      [StyleSheet,Reason]),
+    print_style(Fd,undefined).    
+
+close_ctlog(Fd) ->
+    io:format(Fd,"</pre>",[]),
+    io:format(Fd,footer(),[]),
+    file:close(Fd).
+
+
+
+%%%-----------------------------------------------------------------
+%%% Make an index page for the last run
+make_last_run_index(StartTime) ->
+    IndexName = ?index_name,
+    AbsIndexName = ?abs(IndexName),
+    case catch make_last_run_index1(StartTime,IndexName) of
+	{'EXIT', Reason} ->
+	    io:put_chars("CRASHED while updating " ++ AbsIndexName ++ "!\n"),
+	    io:format("~p~n", [Reason]),
+	    {error, Reason};
+	{error, Reason} ->
+	    io:put_chars("FAILED while updating " ++ AbsIndexName ++ "\n"),
+	    io:format("~p~n", [Reason]),
+	    {error, Reason};
+	ok ->
+%	    io:put_chars("done\n"),
+	    ok;
+	Err ->
+	    io:format("Unknown internal error while updating ~s. "
+		      "Please report.\n(Err: ~p, ID: 1)",
+		      [AbsIndexName,Err]),
+	    {error, Err}
+    end.
+
+make_last_run_index1(StartTime,IndexName) ->
+    %% this manoeuvre is to ensure the tests get logged 
+    %% in correct order of time (the 1 sec resolution
+    %% of the dirnames may be too big)
+    Logs1 =
+	case filelib:wildcard([$*|?logdir_ext]) of
+	    [Log] ->				% first test
+		[Log];
+	    Logs ->
+		case read_totals_file(?totals_name) of
+		    {_Node,Logs0,_Totals} ->
+			insert_dirs(Logs,Logs0);
+		    _ ->
+			%% someone deleted the totals file!?
+			Logs
+		end
+	end,
+    Missing =
+	case file:read_file(?missing_suites_info) of
+	    {ok,Bin} -> binary_to_term(Bin);
+	    _ -> []
+	end,
+    {ok,Index0,Totals} = make_last_run_index(Logs1, index_header(StartTime),
+					     0, 0, 0, 0, 0, Missing),
+    %% write current Totals to file, later to be used in all_runs log
+    write_totals_file(?totals_name,Logs1,Totals),
+    Index = [Index0|index_footer()],
+    case force_write_file(IndexName, Index) of
+	ok ->
+	    ok;
+	{error, Reason} ->
+	    {error,{index_write_error, Reason}}
+    end.
+
+insert_dirs([NewDir|NewDirs],Dirs) ->
+    Dirs1 = insert_dir(NewDir,Dirs),
+    insert_dirs(NewDirs,Dirs1);
+insert_dirs([],Dirs) ->
+    Dirs.
+insert_dir(D,Dirs=[D|_]) ->
+    Dirs;
+insert_dir(D,[D1|Ds]) ->
+    [D1|insert_dir(D,Ds)];
+insert_dir(D,[]) ->
+    [D].
+
+make_last_run_index([Name|Rest], Result, TotSucc, TotFail, UserSkip, AutoSkip,
+		    TotNotBuilt, Missing) ->
+    case last_test(Name) of
+	false ->
+	    %% Silently skip.
+	    make_last_run_index(Rest, Result, TotSucc, TotFail, UserSkip, AutoSkip,
+				TotNotBuilt, Missing);
+	LastLogDir ->
+	    SuiteName = filename:rootname(filename:basename(Name)),
+	    case make_one_index_entry(SuiteName, LastLogDir, false, Missing) of
+		{Result1,Succ,Fail,USkip,ASkip,NotBuilt} ->
+		    %% for backwards compatibility
+		    AutoSkip1 = case catch AutoSkip+ASkip of
+				    {'EXIT',_} -> undefined;
+				    Res -> Res
+				end,
+		    make_last_run_index(Rest, [Result|Result1], TotSucc+Succ, 
+					TotFail+Fail, UserSkip+USkip, AutoSkip1,
+					TotNotBuilt+NotBuilt, Missing);
+		error ->
+		    make_last_run_index(Rest, Result, TotSucc, TotFail, UserSkip, AutoSkip, 
+					TotNotBuilt, Missing)
+	    end
+    end;
+make_last_run_index([], Result, TotSucc, TotFail, UserSkip, AutoSkip, TotNotBuilt, _) ->
+    {ok, [Result|total_row(TotSucc, TotFail, UserSkip, AutoSkip, TotNotBuilt, false)],
+     {TotSucc,TotFail,UserSkip,AutoSkip,TotNotBuilt}}.
+
+make_one_index_entry(SuiteName, LogDir, All, Missing) ->
+    case count_cases(LogDir) of
+	{Succ,Fail,UserSkip,AutoSkip} ->
+	    NotBuilt = not_built(SuiteName, LogDir, All, Missing),
+	    NewResult = make_one_index_entry1(SuiteName, LogDir, Succ, Fail, 
+					      UserSkip, AutoSkip, NotBuilt, All),
+	    {NewResult,Succ,Fail,UserSkip,AutoSkip,NotBuilt};
+	error ->
+	    error
+    end.
+
+make_one_index_entry1(SuiteName, Link, Success, Fail, UserSkip, AutoSkip, 
+		      NotBuilt, All) ->
+    LogFile = filename:join(Link, ?suitelog_name ++ ".html"),
+    CrashDumpName = SuiteName ++ "_erl_crash.dump",
+    CrashDumpLink = 
+	case filelib:is_file(CrashDumpName) of
+	    true -> 
+		["&nbsp;<A HREF=\"", CrashDumpName, 
+		 "\">(CrashDump)</A>"];
+	    false ->
+		""
+	end,
+    {Timestamp,Node,AllInfo} = 
+	case All of
+	    {true,OldRuns} -> 
+		[_Prefix,NodeOrDate|_] = string:tokens(Link,"."),
+		Node1 = case string:chr(NodeOrDate,$@) of
+			    0 -> "-";
+			    _ -> NodeOrDate
+			end,
+		N = ["<TD ALIGN=right>",Node1,"</TD>\n"],
+		CtRunDir = filename:dirname(filename:dirname(Link)),
+		T = ["<TD>",timestamp(CtRunDir),"</TD>\n"],
+		CtLogFile = filename:join(CtRunDir,?ct_log_name),
+		OldRunsLink = 
+		    case OldRuns of
+			[] -> "none";
+			_ ->  "<A HREF=\""++?all_runs_name++"\">Old Runs</A>"
+		    end,
+		A=["<TD><A HREF=\"",CtLogFile,"\">CT Log</A></TD>\n",
+		   "<TD>",OldRunsLink,"</TD>\n"],
+		{T,N,A};
+	    false ->
+		{"","",""}
+	end,
+    NotBuiltStr =
+	if NotBuilt == 0 ->
+		["<TD ALIGN=right>",integer_to_list(NotBuilt),"</TD>\n"];
+	   true ->
+		["<TD ALIGN=right><A HREF=\"",?ct_log_name,"\">",
+		integer_to_list(NotBuilt),"</A></TD>\n"]
+	end,
+    FailStr =
+	if Fail > 0 ->  
+		["<FONT color=\"red\">",
+		 integer_to_list(Fail),"</FONT>"];
+	   true ->
+		integer_to_list(Fail)
+	end,
+    {AllSkip,UserSkipStr,AutoSkipStr} = 
+	if AutoSkip == undefined -> {UserSkip,"?","?"};
+	   true ->
+		ASStr = if AutoSkip > 0 ->
+				["<FONT color=\"brown\">",
+				 integer_to_list(AutoSkip),"</FONT>"];
+			   true -> integer_to_list(AutoSkip)
+			end,
+		{UserSkip+AutoSkip,integer_to_list(UserSkip),ASStr}
+	end,
+    ["<TR valign=top>\n",
+     "<TD><A HREF=\"",LogFile,"\">",SuiteName,"</A>",CrashDumpLink,"</TD>\n",
+     Timestamp,
+     "<TD ALIGN=right>",integer_to_list(Success),"</TD>\n",
+     "<TD ALIGN=right>",FailStr,"</TD>\n",
+     "<TD ALIGN=right>",integer_to_list(AllSkip),
+     " (",UserSkipStr,"/",AutoSkipStr,")</TD>\n",  
+     NotBuiltStr,
+     Node,
+     AllInfo,
+     "</TR>\n"].
+total_row(Success, Fail, UserSkip, AutoSkip, NotBuilt, All) ->
+    {TimestampCell,AllInfo} = 
+	case All of
+	    true -> 
+		{"<TD>&nbsp;</TD>\n","<TD>&nbsp;</TD>\n<TD>&nbsp;</TD>\n"};
+	    false ->
+		{"",""}
+	end,
+
+    {AllSkip,UserSkipStr,AutoSkipStr} =
+	if AutoSkip == undefined -> {UserSkip,"?","?"};
+	   true -> {UserSkip+AutoSkip,
+		    integer_to_list(UserSkip),integer_to_list(AutoSkip)}
+	end,
+    ["<TR valign=top>\n",
+     "<TD><B>Total</B></TD>",
+     TimestampCell,
+     "<TD ALIGN=right><B>",integer_to_list(Success),"<B></TD>\n",
+     "<TD ALIGN=right><B>",integer_to_list(Fail),"<B></TD>\n",
+     "<TD ALIGN=right>",integer_to_list(AllSkip),
+     " (",UserSkipStr,"/",AutoSkipStr,")</TD>\n",  
+     "<TD ALIGN=right><B>",integer_to_list(NotBuilt),"<B></TD>\n",
+     AllInfo,
+     "</TR>\n"].
+
+not_built(_BaseName,_LogDir,_All,[]) ->
+    0;
+not_built(BaseName,_LogDir,_All,Missing) ->
+    %% find out how many suites didn't compile
+    %% BaseName = 
+    %%            Top.ObjDir | Top.ObjDir.suites | Top.ObjDir.Suite | 
+    %%            Top.ObjDir.Suite.cases | Top.ObjDir.Suite.Case    
+    Failed =
+	case string:tokens(BaseName,".") of
+	    [T,O] when is_list(T) ->		% all under Top.ObjDir
+		locate_info({T,O},all,Missing);
+	    [T,O,"suites"] ->
+		locate_info({T,O},suites,Missing);
+	    [T,O,S] ->
+		locate_info({T,O},list_to_atom(S),Missing);
+	    [T,O,S,_] ->
+		locate_info({T,O},list_to_atom(S),Missing);
+	    _ ->				% old format - don't crash
+		[]
+	end,
+    length(Failed).    
+
+locate_info(Path={Top,Obj},AllOrSuite,[{{Dir,Suite},Failed}|Errors]) ->
+    case lists:reverse(filename:split(Dir)) of
+	["test",Obj,Top|_] ->
+	    get_missing_suites(AllOrSuite,{Suite,Failed}) ++
+		locate_info(Path,AllOrSuite,Errors);
+	[Obj,Top|_] ->
+	    get_missing_suites(AllOrSuite,{Suite,Failed}) ++
+		locate_info(Path,AllOrSuite,Errors);
+	_ ->
+	    locate_info(Path,AllOrSuite,Errors)
+    end;
+locate_info(_,_,[]) ->
+    [].
+
+get_missing_suites(all,{"all",Failed}) ->
+    Failed;
+get_missing_suites(suites,{_Suite,Failed}) ->
+    Failed;
+get_missing_suites(Suite,{Suite,Failed}) ->
+    Failed;
+get_missing_suites(_,_) ->
+    [].
+
+term_to_text(Term) ->
+    lists:flatten(io_lib:format("~p.\n", [Term])).
+
+
+%%% Headers and footers.
+
+index_header(StartTime) ->
+    [header("Test Results " ++ format_time(StartTime)) | 
+     ["<CENTER>\n",
+      "<P><A HREF=\"",?ct_log_name,"\">Common Test Framework Log</A></P>",
+      "<TABLE border=\"3\" cellpadding=\"5\" "
+      "BGCOLOR=\"",?table_color3,"\">\n"
+      "<th><B>Name</B></th>\n",
+            "<th><font color=\"",?table_color3,"\">_</font>Ok"
+          "<font color=\"",?table_color3,"\">_</font></th>\n"
+      "<th>Failed</th>\n",
+      "<th>Skipped<br>(User/Auto)</th>\n"
+      "<th>Missing<br>Suites</th>\n"
+      "\n"]].
+
+all_suites_index_header() ->
+    [header("Test Results") | 
+     ["<CENTER>\n",
+      "<A HREF=\"",?all_runs_name,"\">All Test Runs in this directory</A>\n",
+      "<br><br>\n",
+      "<TABLE border=\"3\" cellpadding=\"5\" "
+      "BGCOLOR=\"",?table_color2,"\">\n"
+      "<th>Name</th>\n",
+      "<th>Test Run Started</th>\n",
+      "<th><font color=\"",?table_color2,"\">_</font>Ok"
+          "<font color=\"",?table_color2,"\">_</font></th>\n"
+      "<th>Failed</th>\n",
+      "<th>Skipped<br>(User/Auto)</th>\n"
+      "<th>Missing<br>Suites</th>\n"
+      "<th>Node</th>\n",
+      "<th>CT Log</th>\n",
+      "<th>Old Runs</th>\n",
+      "\n"]].
+
+all_runs_header() ->
+    [header("All test runs in current directory") |
+     ["<CENTER><TABLE border=\"3\" cellpadding=\"5\" "
+      "BGCOLOR=\"",?table_color1,"\">\n"
+      "<th><B>History</B></th>\n"
+      "<th><B>Node</B></th>\n"
+      "<th>Tests</th>\n"
+      "<th><B>Names</B></th>\n"
+      "<th>Total</th>\n"
+      "<th><font color=\"",?table_color1,"\">_</font>Ok"
+          "<font color=\"",?table_color1,"\">_</font></th>\n"
+      "<th>Failed</th>\n"
+      "<th>Skipped<br>(User/Auto)</th>\n"
+      "<th>Missing<br>Suites</th>\n"
+      "\n"]].
+
+header(Title) ->
+    ["<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 3.2 Final//EN\">\n"
+     "<!-- autogenerated by '"++atom_to_list(?MODULE)++"'. -->\n"
+     "<HTML>\n",
+     "<HEAD>\n",
+
+     "<TITLE>" ++ Title ++ "</TITLE>\n",
+     "<META HTTP-EQUIV=\"CACHE-CONTROL\" CONTENT=\"NO-CACHE\">\n",
+
+     "</HEAD>\n",
+
+     body_tag(),
+
+     "<!-- ---- DOCUMENT TITLE  ---- -->\n",
+
+     "<CENTER>\n",
+     "<H1>" ++ Title ++ "</H1>\n",
+     "</CENTER>\n",
+
+     "<!-- ---- CONTENT ---- -->\n"].
+
+index_footer() ->
+    ["</TABLE>\n"
+     "</CENTER>\n" | footer()].
+
+footer() ->
+     ["<P><CENTER>\n"
+     "<HR>\n"
+     "<P><FONT SIZE=-1>\n"
+     "Copyright &copy; ", year(),
+     " <A HREF=\"http://erlang.ericsson.se\">Open Telecom Platform</A><BR>\n"
+     "Updated: <!date>", current_time(), "<!/date><BR>\n"
+     "</FONT>\n"
+     "</CENTER>\n"
+     "</body>\n"].
+
+
+body_tag() ->
+    "<body bgcolor=\"#FFFFFF\" text=\"#000000\" link=\"#0000FF\""
+	"vlink=\"#800080\" alink=\"#FF0000\">\n".
+
+current_time() ->
+    format_time(calendar:local_time()).
+
+format_time({{Y, Mon, D}, {H, Min, S}}) ->
+    Weekday = weekday(calendar:day_of_the_week(Y, Mon, D)),
+    lists:flatten(io_lib:format("~s ~s ~p ~w ~2.2.0w:~2.2.0w:~2.2.0w",
+				[Weekday, month(Mon), D, Y, H, Min, S])).
+
+weekday(1) -> "Mon";
+weekday(2) -> "Tue";
+weekday(3) -> "Wed";
+weekday(4) -> "Thu";
+weekday(5) -> "Fri";
+weekday(6) -> "Sat";
+weekday(7) -> "Sun".
+
+month(1) -> "Jan";
+month(2) -> "Feb";
+month(3) -> "Mar";
+month(4) -> "Apr";
+month(5) -> "May";
+month(6) -> "Jun";
+month(7) -> "Jul";
+month(8) -> "Aug";
+month(9) -> "Sep";
+month(10) -> "Oct";
+month(11) -> "Nov";
+month(12) -> "Dec".
+
+year() ->
+    {Y, _, _} = date(),
+    integer_to_list(Y).
+
+
+%% Count test cases in the given directory (a directory of the type
+%% run.1997-08-04_09.58.52).
+
+count_cases(Dir) ->
+    SumFile = filename:join(Dir, ?run_summary),
+    case read_summary(SumFile, [summary]) of
+	{ok, [{Succ,Fail,Skip}]} ->
+	    {Succ,Fail,Skip,undefined};
+	{ok, [Summary]} ->
+	    Summary;
+	{error, _} ->
+	    LogFile = filename:join(Dir, ?suitelog_name),
+	    case file:read_file(LogFile) of
+		{ok, Bin} ->
+		    case count_cases1(binary_to_list(Bin), 
+				      {undefined,undefined,undefined,undefined}) of
+			{error,not_complete} ->
+			    %% The test is not complete - dont write summary
+			    %% file yet.
+			    {0,0,0,0};
+			Summary ->
+			    write_summary(SumFile, Summary),
+			    Summary
+		    end;
+		{error, _Reason} ->
+		    io:format("\nFailed to read ~p (skipped)\n", [LogFile]),
+		    error
+	    end
+    end.
+
+write_summary(Name, Summary) ->
+    File = [term_to_text({summary, Summary})],
+    force_write_file(Name, File).
+
+read_summary(Name, Keys) ->
+    case file:consult(Name) of
+	{ok, []} ->
+	    {error, "Empty summary file"};
+	{ok, Terms} ->
+	    {ok, lists:map(fun(Key) -> {value, {_, Value}} = 
+					   lists:keysearch(Key, 1, Terms),
+				       Value end,
+			   Keys)};
+	{error, Reason} ->
+	    {error, Reason}
+    end.
+
+count_cases1("=failed" ++ Rest, {Success, _Fail, UserSkip,AutoSkip}) ->
+    {NextLine, Count} = get_number(Rest),
+    count_cases1(NextLine, {Success, Count, UserSkip,AutoSkip});
+count_cases1("=successful" ++ Rest, {_Success, Fail, UserSkip,AutoSkip}) ->
+    {NextLine, Count} = get_number(Rest),
+    count_cases1(NextLine, {Count, Fail, UserSkip,AutoSkip});
+count_cases1("=skipped" ++ Rest, {Success, Fail, _UserSkip,_AutoSkip}) ->
+    {NextLine, Count} = get_number(Rest),
+    count_cases1(NextLine, {Success, Fail, Count,undefined});
+count_cases1("=user_skipped" ++ Rest, {Success, Fail, _UserSkip,AutoSkip}) ->
+    {NextLine, Count} = get_number(Rest),
+    count_cases1(NextLine, {Success, Fail, Count,AutoSkip});
+count_cases1("=auto_skipped" ++ Rest, {Success, Fail, UserSkip,_AutoSkip}) ->
+    {NextLine, Count} = get_number(Rest),
+    count_cases1(NextLine, {Success, Fail, UserSkip,Count});
+count_cases1([], {Su,F,USk,_ASk}) when Su==undefined;F==undefined;
+				       USk==undefined ->
+    {error,not_complete};
+count_cases1([], Counters) ->
+    Counters;
+count_cases1(Other, Counters) ->
+    count_cases1(skip_to_nl(Other), Counters).
+
+get_number([$\s|Rest]) ->
+    get_number(Rest);
+get_number([Digit|Rest]) when $0 =< Digit, Digit =< $9 ->
+    get_number(Rest, Digit-$0).
+
+get_number([Digit|Rest], Acc) when $0 =< Digit, Digit =< $9 ->
+    get_number(Rest, Acc*10+Digit-$0);
+get_number([$\n|Rest], Acc) ->
+    {Rest, Acc};
+get_number([_|Rest], Acc) ->
+    get_number(Rest, Acc).
+
+skip_to_nl([$\n|Rest]) ->
+    Rest;
+skip_to_nl([_|Rest]) ->
+    skip_to_nl(Rest);
+skip_to_nl([]) ->
+    [].
+
+
+config_table(Vars) ->
+    [config_table_header()|config_table1(Vars)].
+
+config_table_header() ->
+    ["<h2>Configuration</h2>\n",
+     "<table border=\"3\" cellpadding=\"5\" bgcolor=\"",?table_color1,
+     "\"\n",
+     "<tr><th>Key</th><th>Value</th></tr>\n"].
+
+config_table1([{Key,Value}|Vars]) ->
+    ["<tr><td>", atom_to_list(Key), "</td>\n",
+     "<td><pre>",io_lib:format("~p",[Value]),"</pre></td></tr>\n" | 
+     config_table1(Vars)];
+config_table1([]) ->
+    ["</table>\n"].
+
+
+make_all_runs_index(When) ->
+    AbsName = ?abs(?all_runs_name),
+    notify_and_lock_file(AbsName),
+    if When == start -> ok;
+       true -> io:put_chars("Updating " ++ AbsName ++ "... ")
+    end,
+    Dirs = filelib:wildcard(logdir_prefix()++"*.*"),
+    DirsSorted = (catch sort_all_runs(Dirs)),
+    Header = all_runs_header(),
+    BasicHtml = basic_html(),
+    Index = [runentry(Dir, BasicHtml) || Dir <- DirsSorted],
+    Result = file:write_file(AbsName,Header++Index++index_footer()),
+    if When == start -> ok;
+       true -> io:put_chars("done\n")
+    end,
+    notify_and_unlock_file(AbsName),
+    Result.
+
+sort_all_runs(Dirs) ->
+    %% sort on time string, always last and on the format:
+    %% "YYYY-MM-DD_HH.MM.SS"
+    KeyList =
+	lists:map(fun(Dir) ->
+			  case lists:reverse(string:tokens(Dir,[$.,$_])) of
+			      [SS,MM,HH,Date|_] ->
+				  {{Date,HH,MM,SS},Dir};
+			      _Other ->
+				  throw(Dirs)
+			  end
+		  end,Dirs),
+    lists:reverse(lists:map(fun({_,Dir}) ->
+				    Dir
+			    end,lists:keysort(1,KeyList))).
+
+
+interactive_link() ->
+    [Dir|_] = lists:reverse(filelib:wildcard(logdir_prefix()++"*.*")),
+    CtLog = filename:join(Dir,"ctlog.html"),
+    Body = ["Log from last interactive run: <A HREF=\"",CtLog,"\">",
+	    timestamp(Dir),"</A>"],
+    file:write_file("last_interactive.html",Body),
+    io:format("~n~nUpdated ~s\n"
+	      "Any CT activities will be logged here\n",
+	      [?abs("last_interactive.html")]).
+
+runentry(Dir, BasicHtml) ->
+    TotalsFile = filename:join(Dir,?totals_name),
+    TotalsStr =
+	case read_totals_file(TotalsFile) of
+	    {Node,Logs,{TotSucc,TotFail,UserSkip,AutoSkip,NotBuilt}} ->
+		TotFailStr =
+		    if TotFail > 0 ->  
+			    ["<FONT color=\"red\">",
+			     integer_to_list(TotFail),"</FONT>"];
+		       true ->
+			    integer_to_list(TotFail)
+		    end,
+		{AllSkip,UserSkipStr,AutoSkipStr} = 
+		    if AutoSkip == undefined -> {UserSkip,"?","?"};
+		       true ->
+			    ASStr = if AutoSkip > 0 ->
+					    ["<FONT color=\"brown\">",
+					     integer_to_list(AutoSkip),"</FONT>"];
+				       true -> integer_to_list(AutoSkip)
+				    end,
+			    {UserSkip+AutoSkip,integer_to_list(UserSkip),ASStr}
+		    end,
+		NoOfTests = case length(Logs) of
+				0 -> "-";
+				N -> integer_to_list(N)
+			    end,
+		StripExt = 
+		    fun(File) ->
+			    string:sub_string(File,1,
+					      length(File)-
+					      length(?logdir_ext)) ++ ", "
+		    end,
+		Polish =  fun(S) -> case lists:reverse(S) of
+					[32,$,|Rev] -> lists:reverse(Rev);
+					[$,|Rev] -> lists:reverse(Rev);
+					_ -> S
+				    end 
+			  end,
+		TestNames = Polish(lists:flatten(lists:map(StripExt,Logs))),
+		TestNamesTrunc =
+		    if TestNames=="" -> 
+			    "";
+		       length(TestNames) < ?testname_width ->
+			    TestNames;
+		       true ->
+			    Trunc = Polish(string:substr(TestNames,1,?testname_width-3)),
+			    lists:flatten(io_lib:format("~s...",[Trunc]))
+		    end,
+		Total = TotSucc+TotFail+AllSkip,
+		A = ["<TD ALIGN=center><FONT SIZE=-1>",Node,"</FONT></TD>\n",
+		     "<TD ALIGN=right>",NoOfTests,"</TD>\n"],
+		B = if BasicHtml ->
+			    ["<TD ALIGN=center><FONT SIZE=-1>",TestNamesTrunc,"</FONT></TD>\n"];
+		       true ->		     
+			    ["<TD ALIGN=center TITLE='",TestNames,"'><FONT SIZE=-1> ",
+			     TestNamesTrunc,"</FONT></TD>\n"]
+		    end,
+		C = ["<TD ALIGN=right>",integer_to_list(Total),"</TD>\n",
+		     "<TD ALIGN=right>",integer_to_list(TotSucc),"</TD>\n",
+		     "<TD ALIGN=right>",TotFailStr,"</TD>\n",
+		     "<TD ALIGN=right>",integer_to_list(AllSkip),
+		     " (",UserSkipStr,"/",AutoSkipStr,")</TD>\n",
+		     "<TD ALIGN=right>",integer_to_list(NotBuilt),"</TD>\n"],
+		A++B++C;
+	    _ ->
+		["<TD ALIGN=center><FONT size=-1 color=\"red\">",
+		 "Test data missing or corrupt","</FONT></TD>\n"]
+	end,	    
+    Index = filename:join(Dir,?index_name),
+    ["<TR>\n"
+     "<TD><A HREF=\"",Index,"\">",timestamp(Dir),"</A>",TotalsStr,"</TD>\n"
+     "</TR>\n"].
+
+write_totals_file(Name,Logs,Totals) ->
+    AbsName = ?abs(Name),
+    notify_and_lock_file(AbsName),
+    force_write_file(AbsName,
+		     term_to_binary({atom_to_list(node()),
+				     Logs,Totals})),
+    notify_and_unlock_file(AbsName).
+
+read_totals_file(Name) ->
+    AbsName = ?abs(Name),
+    notify_and_lock_file(AbsName),
+    Result = 
+	case file:read_file(AbsName) of
+	    {ok,Bin} ->
+		case catch binary_to_term(Bin) of
+		    {'EXIT',_Reason} ->		% corrupt file
+			{"-",[],undefined};
+		    R = {Node,Ls,Tot} -> 
+			case Tot of
+			    {_,_,_,_,_} ->	% latest format
+				R;		
+			    {TotSucc,TotFail,AllSkip,NotBuilt} ->
+				{Node,Ls,{TotSucc,TotFail,AllSkip,undefined,NotBuilt}}
+			end;
+		    %% for backwards compatibility
+		    {Ls,Tot}    -> {"-",Ls,Tot};
+		    Tot         -> {"-",[],Tot}
+		end;
+	    Error ->
+		Error
+	end,
+    notify_and_unlock_file(AbsName),
+    Result.
+
+force_write_file(Name,Contents) ->
+    force_delete(Name),
+    file:write_file(Name,Contents).
+
+force_delete(Name) ->
+    case file:delete(Name) of
+	{error,eacces} ->
+	    force_rename(Name,Name++".old.",0);
+	Other ->
+	    Other
+    end.
+
+force_rename(From,To,Number) ->
+    Dest = [To|integer_to_list(Number)],
+    case file:read_file_info(Dest) of
+	{ok,_} ->
+	    force_rename(From,To,Number+1);
+	{error,_} ->
+	    file:rename(From,Dest)
+    end.
+
+
+timestamp(Dir) ->
+    TsR = lists:reverse(string:tokens(Dir,".-_")),
+    [S,Min,H,D,M,Y] = [list_to_integer(N) || N <- lists:sublist(TsR,6)],
+    format_time({{Y,M,D},{H,Min,S}}).
+
+make_all_suites_index(When) ->
+    AbsIndexName = ?abs(?index_name),
+    notify_and_lock_file(AbsIndexName),
+    LogDirs = filelib:wildcard(logdir_prefix()++".*/*"++?logdir_ext),
+    Sorted = sort_logdirs(LogDirs,[]),
+    Result = make_all_suites_index1(When,Sorted),
+    notify_and_unlock_file(AbsIndexName),
+    Result.    
+    
+sort_logdirs([Dir|Dirs],Groups) ->
+    TestName = filename:rootname(filename:basename(Dir)),
+    case filelib:wildcard(filename:join(Dir,"run.*")) of
+	[RunDir] ->
+	    Groups1 = insert_test(TestName,{filename:basename(RunDir),RunDir},Groups),
+	    sort_logdirs(Dirs,Groups1);
+	_ ->					% ignore missing run directory
+	    sort_logdirs(Dirs,Groups)
+    end;
+sort_logdirs([],Groups) ->
+    lists:keysort(1,sort_each_group(Groups)).
+
+insert_test(Test,IxDir,[{Test,IxDirs}|Groups]) ->
+    [{Test,[IxDir|IxDirs]}|Groups];
+insert_test(Test,IxDir,[]) ->
+    [{Test,[IxDir]}];
+insert_test(Test,IxDir,[TestDir|Groups]) ->
+    [TestDir|insert_test(Test,IxDir,Groups)].
+		 
+sort_each_group([{Test,IxDirs}|Groups]) ->
+    Sorted = lists:reverse([Dir || {_,Dir} <- lists:keysort(1,IxDirs)]),
+    [{Test,Sorted}| sort_each_group(Groups)];
+sort_each_group([]) ->
+    [].
+
+make_all_suites_index1(When,AllSuitesLogDirs) ->
+    IndexName = ?index_name,
+    AbsIndexName = ?abs(IndexName),
+    if When == start -> ok;
+       true -> io:put_chars("Updating " ++ AbsIndexName ++ "... ")
+    end,
+    case catch make_all_suites_index2(IndexName,AllSuitesLogDirs) of
+	{'EXIT', Reason} ->
+	    io:put_chars("CRASHED while updating " ++ AbsIndexName ++ "!\n"),
+	    io:format("~p~n", [Reason]),
+	    {error, Reason};
+	{error, Reason} ->
+	    io:put_chars("FAILED while updating " ++ AbsIndexName ++ "\n"),
+	    io:format("~p~n", [Reason]),
+	    {error, Reason};
+	ok ->
+	    if When == start -> ok;
+	       true -> io:put_chars("done\n")
+	    end,	    
+	    ok;
+	Err ->
+	    io:format("Unknown internal error while updating ~s. "
+		      "Please report.\n(Err: ~p, ID: 1)",
+		      [AbsIndexName,Err]),
+	    {error, Err}
+    end.
+
+make_all_suites_index2(IndexName,AllSuitesLogDirs) ->
+    {ok,Index0,_Totals} = make_all_suites_index3(AllSuitesLogDirs,
+						 all_suites_index_header(),
+						 0, 0, 0, 0, 0),
+    Index = [Index0|index_footer()],
+    case force_write_file(IndexName, Index) of
+	ok ->
+	    ok;
+	{error, Reason} ->
+	    {error,{index_write_error, Reason}}
+    end.
+
+make_all_suites_index3([{SuiteName,[LastLogDir|OldDirs]}|Rest],
+		       Result, TotSucc, TotFail, UserSkip, AutoSkip, TotNotBuilt) ->
+    [EntryDir|_] = filename:split(LastLogDir),
+    Missing = 
+	case file:read_file(filename:join(EntryDir,?missing_suites_info)) of
+	    {ok,Bin} -> binary_to_term(Bin);
+	    _ -> []
+	end,
+    case make_one_index_entry(SuiteName, LastLogDir, {true,OldDirs}, Missing) of
+	{Result1,Succ,Fail,USkip,ASkip,NotBuilt} ->
+	    %% for backwards compatibility
+	    AutoSkip1 = case catch AutoSkip+ASkip of
+			    {'EXIT',_} -> undefined;
+			    Res -> Res
+			end,
+	    make_all_suites_index3(Rest, [Result|Result1], TotSucc+Succ, 
+				   TotFail+Fail, UserSkip+USkip, AutoSkip1,
+				   TotNotBuilt+NotBuilt);
+	error ->
+	    make_all_suites_index3(Rest, Result, TotSucc, TotFail, 
+				   UserSkip, AutoSkip, TotNotBuilt)
+    end;
+make_all_suites_index3([], Result, TotSucc, TotFail, UserSkip, AutoSkip, 
+		       TotNotBuilt) ->
+    {ok, [Result|total_row(TotSucc, TotFail, UserSkip, AutoSkip, TotNotBuilt,true)], 
+     {TotSucc,TotFail,UserSkip,AutoSkip,TotNotBuilt}}.
+
+
+%%-----------------------------------------------------------------
+%% Remove log files.
+%% Cwd should always be set to the root logdir when finished. 
+cleanup() ->
+    {ok,Cwd} = file:get_cwd(),
+    ok = file:set_cwd("../"),
+    {ok,Top} = file:get_cwd(),
+    Result =
+	case catch try_cleanup(Cwd) of
+	    ok ->
+		ok;
+	    {'EXIT',Reason} ->
+		{error,Reason};
+	    Error ->
+		{error,Error}
+	end,
+    ok = file:set_cwd(Top),
+    Result.
+
+try_cleanup(CTRunDir) ->
+    %% ensure we're removing the ct_run directory
+    case lists:reverse(filename:split(CTRunDir)) of
+	[[$c,$t,$_,$r,$u,$n,$.|_]|_] ->
+	    case filelib:wildcard(filename:join(CTRunDir,"ct_run.*")) of
+		[] ->				% "double check"
+		    rm_dir(CTRunDir);
+		_ ->
+		    unknown_logdir
+	    end;
+	_ ->
+	    unknown_logdir
+    end.
+
+rm_dir(Dir) ->
+    case file:list_dir(Dir) of
+	{error,Errno} ->
+	    exit({ls_failed,Dir,Errno});
+	{ok,Files} ->
+	    rm_files([filename:join(Dir, F) || F <- Files]),
+	    case file:del_dir(Dir) of
+		{error,Errno} ->
+		    exit({rmdir_failed,Errno});
+		ok ->
+		    ok
+	    end
+    end.
+
+rm_files([F | Fs]) ->
+    Base = filename:basename(F),
+    if Base == "." ; Base == ".." ->
+	    rm_files(Fs);
+       true ->
+	    case file:read_file_info(F) of
+		{ok,#file_info{type=directory}} ->
+		    rm_dir(F),
+		    rm_files(Fs);
+		{ok,_Regular} ->
+		    case file:delete(F) of
+			ok ->
+			    rm_files(Fs);
+			{error,Errno} ->
+			    exit({del_failed,F,Errno})
+		    end
+	    end
+    end;
+rm_files([]) ->
+    ok.    
+
+%%%-----------------------------------------------------------------
+%%% @spec simulate() -> pid()
+%%%
+%%% @doc Simulate the logger process.
+%%%
+%%% <p>Simulate the logger process - for use when testing code using
+%%% ct_logs logging mechanism without using the ct
+%%% environment. (E.g. when testing code with ts)</p>
+simulate() ->
+    cast(stop),
+    S = self(),
+    Pid = spawn(fun() -> 
+			register(?MODULE,self()),
+			S ! {self(),started},
+			simulate_logger_loop() 
+		end),
+    receive {Pid,started} -> Pid end.
+
+
+simulate_logger_loop() ->
+    receive 
+    	{log,_,_,List} ->
+	    S = [[io_lib:format(Str,Args),io_lib:nl()] || {Str,Args} <- List],
+	    io:format("~s",[S]),
+	    simulate_logger_loop();
+	stop ->
+	    ok
+    end.
+
+%%%-----------------------------------------------------------------
+%%% @spec notify_and_lock_file(Files) -> ok
+%%%
+%%% @doc
+%%%
+notify_and_lock_file(File) ->    
+    case ct_event:is_alive() of
+	true ->
+	    ct_event:sync_notify(#event{name=start_write_file,
+					node=node(),
+					data=File});
+	false ->
+	    ok
+    end.
+
+%%%-----------------------------------------------------------------
+%%% @spec notify_and_unlock_file(Files) -> ok
+%%%
+%%% @doc
+%%%
+notify_and_unlock_file(File) ->    
+    case ct_event:is_alive() of
+	true ->
+	    ct_event:sync_notify(#event{name=finished_write_file,
+					node=node(),
+					data=File});
+	false ->
+	    ok
+    end.
+
+%%%-----------------------------------------------------------------
+%%% @spec last_test(Dir) -> string() | false
+%%%
+%%% @doc
+%%%
+last_test(Dir) ->
+    last_test(filelib:wildcard(filename:join(Dir, "run.[1-2]*")), false).
+
+last_test([Run|Rest], false) ->
+    last_test(Rest, Run);
+last_test([Run|Rest], Latest) when Run > Latest ->
+    last_test(Rest, Run);
+last_test([_|Rest], Latest) ->
+    last_test(Rest, Latest);
+last_test([], Latest) ->
+    Latest.
+
+%%%-----------------------------------------------------------------
+%%% @spec basic_html() -> true | false
+%%%
+%%% @doc
+%%%
+basic_html() ->
+    case application:get_env(common_test, basic_html) of
+	{ok,true} ->
+	    true;
+	_ ->
+	    false
+    end.
diff --git a/lib/common_test/src/ct_make.erl b/lib/common_test/src/ct_make.erl
new file mode 100644
index 0000000000..233e45248e
--- /dev/null
+++ b/lib/common_test/src/ct_make.erl
@@ -0,0 +1,344 @@
+%%
+%% %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%
+%%
+
+%%
+%% Purpose : Basic make facility for Common Test
+%%
+%% Compares date stamps of .erl and Object files - recompiles when
+%% necessary.
+%% Files to be checked are contained in a file 'Emakefile' 
+%% If Emakefile is missing the current directory is used.
+%%
+
+-module(ct_make).
+
+-export([all/0,all/1,files/1,files/2]).
+
+-include_lib("kernel/include/file.hrl").
+
+-define(MakeOpts,[noexec,load,netload,noload]).
+
+all() ->
+    all([]).
+
+all(Options) ->
+    {MakeOpts,CompileOpts} = sort_options(Options,[],[]),
+    case read_emakefile('Emakefile',CompileOpts) of
+	Files when is_list(Files) ->
+	    do_make_files(Files,MakeOpts);
+	error ->
+	    {error,[]}
+    end.
+
+files(Fs) ->
+    files(Fs, []).
+
+files(Fs0, Options) ->
+    Fs = [filename:rootname(F,".erl") || F <- Fs0],
+    {MakeOpts,CompileOpts} = sort_options(Options,[],[]),
+    case get_opts_from_emakefile(Fs,'Emakefile',CompileOpts) of
+	Files when is_list(Files) ->
+	    do_make_files(Files,MakeOpts);	    
+	error -> 
+	    {error,[]}
+    end.
+
+do_make_files(Fs, Opts) ->
+    process(Fs, lists:member(noexec, Opts), load_opt(Opts), []).
+
+
+sort_options([H|T],Make,Comp) ->
+    case lists:member(H,?MakeOpts) of
+	true ->
+	    sort_options(T,[H|Make],Comp);
+	false ->
+	    sort_options(T,Make,[H|Comp])
+    end;
+sort_options([],Make,Comp) ->
+    {Make,lists:reverse(Comp)}.
+
+%%% Reads the given Emakefile and returns a list of tuples: {Mods,Opts}
+%%% Mods is a list of module names (strings)
+%%% Opts is a list of options to be used when compiling Mods
+%%%
+%%% Emakefile can contain elements like this:
+%%% Mod.
+%%% {Mod,Opts}.
+%%% Mod is a module name which might include '*' as wildcard
+%%% or a list of such module names
+%%%
+%%% These elements are converted to [{ModList,OptList},...]
+%%% ModList is a list of modulenames (strings)
+read_emakefile(Emakefile,Opts) ->
+    case file:consult(Emakefile) of
+	{ok,Emake} ->
+	    transform(Emake,Opts,[],[]);
+	{error,enoent} ->
+	    %% No Emakefile found - return all modules in current 
+	    %% directory and the options given at command line
+	    Mods = [filename:rootname(F) ||  F <- filelib:wildcard("*.erl")],
+	    [{Mods, Opts}];
+	{error,Other} ->
+	    io:format("make: Trouble reading 'Emakefile':~n~p~n",[Other]),
+	    error
+    end.
+
+transform([{Mod,ModOpts}|Emake],Opts,Files,Already) ->
+    case expand(Mod,Already) of
+	[] -> 
+	    transform(Emake,Opts,Files,Already);
+	Mods -> 
+	    transform(Emake,Opts,[{Mods,ModOpts++Opts}|Files],Mods++Already)
+    end;
+transform([Mod|Emake],Opts,Files,Already) ->
+    case expand(Mod,Already) of
+	[] -> 
+	    transform(Emake,Opts,Files,Already);
+	Mods ->
+	    transform(Emake,Opts,[{Mods,Opts}|Files],Mods++Already)
+    end;
+transform([],_Opts,Files,_Already) ->
+    lists:reverse(Files).
+
+expand(Mod,Already) when is_atom(Mod) ->
+    expand(atom_to_list(Mod),Already);
+expand(Mods,Already) when is_list(Mods), not is_integer(hd(Mods)) ->
+    lists:concat([expand(Mod,Already) || Mod <- Mods]);
+expand(Mod,Already) ->
+    case lists:member($*,Mod) of
+	true -> 
+	    Fun = fun(F,Acc) -> 
+			  M = filename:rootname(F),
+			  case lists:member(M,Already) of
+			      true -> Acc;
+			      false -> [M|Acc]
+			  end
+		  end,
+	    lists:foldl(Fun, [], filelib:wildcard(Mod++".erl"));
+	false ->
+	    Mod2 = filename:rootname(Mod, ".erl"),
+	    case lists:member(Mod2,Already) of
+		true -> [];
+		false -> [Mod2]
+	    end
+    end.
+
+%%% Reads the given Emakefile to see if there are any specific compile 
+%%% options given for the modules.
+get_opts_from_emakefile(Mods,Emakefile,Opts) ->
+    case file:consult(Emakefile) of
+	{ok,Emake} ->
+	    Modsandopts = transform(Emake,Opts,[],[]),
+	    ModStrings = [coerce_2_list(M) || M <- Mods],
+	    get_opts_from_emakefile2(Modsandopts,ModStrings,Opts,[]); 
+	{error,enoent} ->
+	    [{Mods, Opts}];
+	{error,Other} ->
+	    io:format("make: Trouble reading 'Emakefile':~n~p~n",[Other]),
+	    error
+    end.
+
+get_opts_from_emakefile2([{MakefileMods,O}|Rest],Mods,Opts,Result) ->
+    case members(Mods,MakefileMods,[],Mods) of
+	{[],_} -> 
+	    get_opts_from_emakefile2(Rest,Mods,Opts,Result);
+	{I,RestOfMods} ->
+	    get_opts_from_emakefile2(Rest,RestOfMods,Opts,[{I,O}|Result])
+    end;
+get_opts_from_emakefile2([],[],_Opts,Result) ->
+    Result;
+get_opts_from_emakefile2([],RestOfMods,Opts,Result) ->
+    [{RestOfMods,Opts}|Result].
+    
+members([H|T],MakefileMods,I,Rest) ->
+    case lists:member(H,MakefileMods) of
+	true ->
+	    members(T,MakefileMods,[H|I],lists:delete(H,Rest));
+	false ->
+	    members(T,MakefileMods,I,Rest)
+    end;
+members([],_MakefileMods,I,Rest) ->
+    {I,Rest}.
+
+
+%% Any flags that are not recognixed as make flags are passed directly
+%% to the compiler.
+%% So for example make:all([load,debug_info]) will make everything
+%% with the debug_info flag and load it.
+	
+load_opt(Opts) ->
+    case lists:member(netload,Opts) of
+	true -> 
+	    netload;
+	false ->
+	    case lists:member(load,Opts) of
+		true ->
+		    load;
+		_ ->
+		    noload
+	    end
+    end.
+
+
+process([{[],_Opts}|Rest], NoExec, Load, Result) ->
+    process(Rest, NoExec, Load, Result);
+process([{[H|T],Opts}|Rest], NoExec, Load, Result) ->
+    case recompilep(coerce_2_list(H), NoExec, Load, Opts) of
+	error ->
+	    process([{T,Opts}|Rest], NoExec, Load, [{H,error}|Result]);
+	Info ->
+	    process([{T,Opts}|Rest], NoExec, Load, [{H,Info}|Result])
+    end;
+process([], NoExec, _Load, Result) ->
+    if not NoExec ->
+	    case lists:keysearch(error, 2, Result) of
+		{value,_} ->
+		    {error,Result};
+		false ->
+		    {up_to_date,Result}
+	    end;
+       true ->
+	    Result
+    end.
+
+recompilep(File, NoExec, Load, Opts) ->
+    ObjName = lists:append(filename:basename(File),
+			   code:objfile_extension()),
+    ObjFile = case lists:keysearch(outdir,1,Opts) of
+		  {value,{outdir,OutDir}} ->
+		      filename:join(coerce_2_list(OutDir),ObjName);
+		  false ->
+		      ObjName
+	      end,
+    case exists(ObjFile) of
+	true ->
+	    recompilep1(File, NoExec, Load, Opts, ObjFile);
+	false ->
+	    recompile(File, NoExec, Load, Opts)
+    end.
+ 
+recompilep1(File, NoExec, Load, Opts, ObjFile) ->
+    {ok, Erl} = file:read_file_info(lists:append(File, ".erl")),
+    {ok, Obj} = file:read_file_info(ObjFile),
+    case {readable(Erl), writable(Obj)} of
+	{true, true} ->
+	    recompilep1(Erl, Obj, File, NoExec, Load, Opts);
+	_ ->
+	    error
+    end.
+
+recompilep1(#file_info{mtime=Te},
+	    #file_info{mtime=To}, File, NoExec, Load, Opts) when Te>To ->
+    recompile(File, NoExec, Load, Opts);
+recompilep1(_Erl, #file_info{mtime=To}, File, NoExec, Load, Opts) ->
+    recompile2(To, File, NoExec, Load, Opts).
+
+%% recompile2(ObjMTime, File, NoExec, Load, Opts)
+%% Check if file is of a later date than include files.
+recompile2(ObjMTime, File, NoExec, Load, Opts) ->
+    IncludePath = include_opt(Opts),
+    case check_includes(lists:append(File, ".erl"), IncludePath, ObjMTime) of
+	true ->
+	    recompile(File, NoExec, Load, Opts);
+	false ->
+	    up_to_date
+    end.
+
+include_opt([{i,Path}|Rest]) ->
+    [Path|include_opt(Rest)];
+include_opt([_First|Rest]) ->
+    include_opt(Rest);
+include_opt([]) ->
+    [].
+
+%% recompile(File, NoExec, Load, Opts)
+%% Actually recompile and load the file, depending on the flags.
+%% Where load can be netload | load | noload
+
+recompile(File, NoExec, Load, Opts) ->
+    case do_recompile(File, NoExec, Load, Opts) of
+	{ok,_} -> ok;
+	Other -> Other
+    end.
+
+do_recompile(_File, true, _Load, _Opts) ->
+    out_of_date;
+do_recompile(File, false, noload, Opts) ->
+    io:format("Recompile: ~s\n",[File]),
+    compile:file(File, [report_errors, report_warnings, error_summary |Opts]);
+do_recompile(File, false, load, Opts) ->
+    io:format("Recompile: ~s\n",[File]),
+    c:c(File, Opts);
+do_recompile(File, false, netload, Opts) ->
+    io:format("Recompile: ~s\n",[File]),
+    c:nc(File, Opts).
+
+exists(File) ->
+    case file:read_file_info(File) of
+	{ok, _} ->
+	    true;
+	_ ->
+	    false
+    end.
+
+readable(#file_info{access=read_write}) -> true;
+readable(#file_info{access=read})       -> true;
+readable(_) -> false.
+
+writable(#file_info{access=read_write}) -> true;
+writable(#file_info{access=write})      -> true;
+writable(_) -> false.
+
+coerce_2_list(X) when is_atom(X) ->
+    atom_to_list(X);
+coerce_2_list(X) ->
+    X.
+
+%%% If you an include file is found with a modification
+%%% time larger than the modification time of the object
+%%% file, return true. Otherwise return false.
+check_includes(File, IncludePath, ObjMTime) ->
+    Path = [filename:dirname(File)|IncludePath], 
+    case epp:open(File, Path, []) of
+	{ok, Epp} ->
+	    check_includes2(Epp, File, ObjMTime);
+	_Error ->
+	    false
+    end.
+    
+check_includes2(Epp, File, ObjMTime) ->
+    case epp:parse_erl_form(Epp) of
+	{ok, {attribute, 1, file, {File, 1}}} ->
+	    check_includes2(Epp, File, ObjMTime);
+	{ok, {attribute, 1, file, {IncFile, 1}}} ->
+	    case file:read_file_info(IncFile) of
+		{ok, #file_info{mtime=MTime}} when MTime>ObjMTime ->
+		    epp:close(Epp),
+		    true;
+		_ ->
+		    check_includes2(Epp, File, ObjMTime)
+	    end;
+	{ok, _} ->
+	    check_includes2(Epp, File, ObjMTime);
+	{eof, _} ->
+	    epp:close(Epp),
+	    false;
+	{error, _Error} ->
+	    check_includes2(Epp, File, ObjMTime)
+    end.
diff --git a/lib/common_test/src/ct_master.erl b/lib/common_test/src/ct_master.erl
new file mode 100644
index 0000000000..7eb2c3cfef
--- /dev/null
+++ b/lib/common_test/src/ct_master.erl
@@ -0,0 +1,696 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 2006-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%
+%%
+
+%%% @doc Distributed test execution control for Common Test.
+%%% <p>This module exports functions for running Common Test nodes
+%%% on multiple hosts in parallel.</p>
+-module(ct_master).
+
+-export([run/1,run/3,run/4]).
+-export([run_on_node/2,run_on_node/3]).
+-export([run_test/1,run_test/2]).
+
+-export([abort/0,abort/1,progress/0]).
+
+-export([init_master/6, init_node_ctrl/3]).
+
+-export([status/2]).
+
+-include("ct_event.hrl").
+-include("ct_util.hrl").
+
+-record(state, {node_ctrl_pids=[],
+		logdirs=[],
+		results=[],
+		locks=[],
+		blocked=[]
+		}).
+
+%%%-----------------------------------------------------------------
+%%% @spec run_test(Node,Opts) -> ok
+%%%       Node = atom()
+%%%       Opts = [OptTuples]
+%%%   OptTuples = {config,CfgFiles} | {dir,TestDirs} | {suite,Suites} |
+%%%               {testcase,Cases} | {spec,TestSpecs} | {allow_user_terms,Bool} | 
+%%%               {logdir,LogDir} | {event_handler,EventHandlers} | 
+%%%               {silent_connections,Conns} | {cover,CoverSpecFile}
+%%%       CfgFiles = string() | [string()]
+%%%       TestDirs = string() | [string()]
+%%%       Suites = atom() | [atom()]
+%%%       Cases = atom() | [atom()]
+%%%       TestSpecs = string() | [string()]
+%%%       LogDir = string()
+%%%       EventHandlers = EH | [EH]
+%%%       EH = atom() | {atom(),InitArgs} | {[atom()],InitArgs}
+%%%       InitArgs = [term()] 
+%%%       Conns = all | [atom()]
+%%%
+%%% @doc Tests are spawned on <code>Node</code> using <code>ct:run_test/1</code>.
+run_test(Node,Opts) ->
+    run_test([{Node,Opts}]).
+
+%%% @hidden
+run_test({Node,Opts}) ->
+    run_test([{Node,Opts}]);
+run_test(NodeOptsList) when is_list(NodeOptsList) ->
+    start_master(NodeOptsList).
+
+%%%-----------------------------------------------------------------
+%%% @spec run(TestSpecs,AllowUserTerms,InclNodes,ExclNodes) -> ok
+%%%       TestSpecs = string() | [SeparateOrMerged]
+%%%       SeparateOrMerged = string() | [string()]
+%%%       AllowUserTerms = bool()
+%%%       InclNodes = [atom()]
+%%%       ExclNodes = [atom()]
+%%%
+%%% @doc Tests are spawned on the nodes as specified in <code>TestSpecs</code>.
+%%% Each specification in TestSpec will be handled separately. It is however possible
+%%% to also specify a list of specifications that should be merged into one before
+%%% the tests are executed. Any test without a particular node specification will 
+%%% also be executed on the nodes in <code>InclNodes</code>. Nodes in the 
+%%% <code>ExclNodes</code> list will be excluded from the test.
+run([TS|TestSpecs],AllowUserTerms,InclNodes,ExclNodes) when is_list(TS),
+							    is_list(InclNodes),
+							    is_list(ExclNodes) ->
+    TS1 =
+	case TS of
+	    List=[S|_] when is_list(S) -> List;
+	    Spec -> [Spec]
+	end,
+    Result =
+	case catch ct_testspec:collect_tests_from_file(TS1,InclNodes,AllowUserTerms) of
+	    {error,Reason} ->
+		{error,Reason};
+	    TSRec=#testspec{logdir=AllLogDirs,
+			    config=AllCfgFiles,
+			    event_handler=AllEvHs} ->
+		RunSkipPerNode = ct_testspec:prepare_tests(TSRec),
+		RunSkipPerNode2 = exclude_nodes(ExclNodes,RunSkipPerNode),
+		run_all(RunSkipPerNode2,AllLogDirs,AllCfgFiles,AllEvHs,[],[],TS1)
+	end,
+    [{TS,Result} | run(TestSpecs,AllowUserTerms,InclNodes,ExclNodes)];
+run([],_,_,_) ->
+    [];
+run(TS,AllowUserTerms,InclNodes,ExclNodes) when is_list(InclNodes), is_list(ExclNodes) ->
+    run([TS],AllowUserTerms,InclNodes,ExclNodes).
+
+%%%-----------------------------------------------------------------
+%%% @spec run(TestSpecs,InclNodes,ExclNodes) -> ok
+%%%       TestSpecs = string() | [SeparateOrMerged]
+%%%       SeparateOrMerged = string() | [string()]
+%%%       InclNodes = [atom()]
+%%%       ExclNodes = [atom()]
+%%%
+%%% @equiv run(TestSpecs,false,InclNodes,ExclNodes)
+run(TestSpecs,InclNodes,ExclNodes) ->
+    run(TestSpecs,false,InclNodes,ExclNodes).
+
+%%%-----------------------------------------------------------------
+%%% @spec run(TestSpecs) -> ok
+%%%       TestSpecs = string() | [SeparateOrMerged]
+%%%
+%%% @equiv run(TestSpecs,false,[],[]) 
+run(TestSpecs=[TS|_]) when is_list(TS) ->
+    run(TestSpecs,false,[],[]);
+run(TS) ->
+    run([TS],false,[],[]).
+
+
+exclude_nodes([ExclNode|ExNs],RunSkipPerNode) ->
+    exclude_nodes(ExNs,lists:keydelete(ExclNode,1,RunSkipPerNode));
+exclude_nodes([],RunSkipPerNode) ->
+    RunSkipPerNode.
+
+
+%%%-----------------------------------------------------------------
+%%% @spec run_on_node(TestSpecs,AllowUserTerms,Node) -> ok
+%%%       TestSpecs = string() | [SeparateOrMerged]
+%%%       SeparateOrMerged = string() | [string()]
+%%%       AllowUserTerms = bool()
+%%%       Node = atom()
+%%%
+%%% @doc Tests are spawned on <code>Node</code> according to <code>TestSpecs</code>.
+run_on_node([TS|TestSpecs],AllowUserTerms,Node) when is_list(TS),is_atom(Node) ->
+    TS1 =
+	case TS of
+	    [List|_] when is_list(List) -> List;
+	    Spec -> [Spec]
+	end,
+    Result = 
+	case catch ct_testspec:collect_tests_from_file(TS1,[Node],AllowUserTerms) of
+	    {error,Reason} ->
+		{error,Reason};
+	    TSRec=#testspec{logdir=AllLogDirs,
+			    config=AllCfgFiles,
+			    event_handler=AllEvHs} ->
+		{Run,Skip} = ct_testspec:prepare_tests(TSRec,Node),
+		run_all([{Node,Run,Skip}],AllLogDirs,AllCfgFiles,AllEvHs,[],[],TS1)
+	end,
+    [{TS,Result} | run_on_node(TestSpecs,AllowUserTerms,Node)];
+run_on_node([],_,_) ->
+    [];
+run_on_node(TS,AllowUserTerms,Node) when is_atom(Node) ->
+    run_on_node([TS],AllowUserTerms,Node).
+
+%%%-----------------------------------------------------------------
+%%% @spec run_on_node(TestSpecs,Node) -> ok
+%%%       TestSpecs = string() | [SeparateOrMerged]
+%%%       SeparateOrMerged = string() | [string()]
+%%%       Node = atom()
+%%%
+%%% @equiv run_on_node(TestSpecs,false,Node)
+run_on_node(TestSpecs,Node) ->
+    run_on_node(TestSpecs,false,Node).
+
+
+
+run_all([{Node,Run,Skip}|Rest],AllLogDirs,AllCfgFiles,AllEvHs,NodeOpts,LogDirs,Specs) ->
+    LogDir =
+	lists:foldl(fun({N,Dir},_Found) when N == Node ->
+			    Dir;
+		       ({_N,_Dir},Found) ->
+			    Found;
+		       (Dir,".") ->
+			    Dir;
+		       (_Dir,Found) ->
+			    Found
+		    end,".",AllLogDirs),
+    CfgFiles =
+	lists:foldr(fun({N,F},Fs) when N == Node -> [F|Fs];
+		       ({_N,_F},Fs) -> Fs;
+		       (F,Fs) -> [F|Fs]
+		    end,[],AllCfgFiles),
+    EvHs =
+	lists:foldr(fun({N,H,A},Hs) when N == Node -> [{H,A}|Hs];
+		       ({_N,_H,_A},Hs) -> Hs;
+		       ({H,A},Hs) -> [{H,A}|Hs]
+		    end,[],AllEvHs),
+    NO = {Node,[{prepared_tests,{Run,Skip},Specs},
+		{logdir,LogDir},
+		{config,CfgFiles},
+		{event_handler,EvHs}]},
+    run_all(Rest,AllLogDirs,AllCfgFiles,AllEvHs,[NO|NodeOpts],[LogDir|LogDirs],Specs);
+run_all([],AllLogDirs,_,AllEvHs,NodeOpts,LogDirs,Specs) ->
+    Handlers = [{H,A} || {Master,H,A} <- AllEvHs, Master == master],
+    MasterLogDir = case lists:keysearch(master,1,AllLogDirs) of
+		       {value,{_,Dir}} -> Dir;
+		       false -> "."
+		   end,
+    log(tty,"Master Logdir","~s",[MasterLogDir]),
+    start_master(lists:reverse(NodeOpts),Handlers,MasterLogDir,LogDirs,Specs),
+    ok.
+    
+
+%%%-----------------------------------------------------------------
+%%% @spec abort() -> ok
+%%%
+%%% @doc Stops all running tests.
+abort() ->
+    call(abort).
+
+%%%-----------------------------------------------------------------
+%%% @spec abort(Nodes) -> ok
+%%%       Nodes = atom() | [atom()]
+%%%
+%%% @doc Stops tests on specified nodes.
+abort(Nodes) when is_list(Nodes) ->
+    call({abort,Nodes});
+
+abort(Node) when is_atom(Node) ->
+    abort([Node]).
+    
+%%%-----------------------------------------------------------------
+%%% @spec progress() -> [{Node,Status}]
+%%%       Node = atom()
+%%%       Status = finished_ok | ongoing | aborted | {error,Reason}
+%%%       Reason = term()
+%%%
+%%% @doc Returns test progress. If <code>Status</code> is <code>ongoing</code>,
+%%% tests are running on the node and have not yet finished.
+progress() ->
+    call(progress).
+
+		
+%%%-----------------------------------------------------------------
+%%% MASTER, runs on central controlling node.
+%%%-----------------------------------------------------------------
+start_master(NodeOptsList) ->
+    start_master(NodeOptsList,[],".",[],[]).
+
+start_master(NodeOptsList,EvHandlers,MasterLogDir,LogDirs,Specs) ->
+    Master = spawn_link(?MODULE,init_master,[self(),NodeOptsList,EvHandlers,
+					     MasterLogDir,LogDirs,Specs]),
+    receive 
+	{Master,Result} -> Result
+    end.	    
+
+%%% @hidden
+init_master(Parent,NodeOptsList,EvHandlers,MasterLogDir,LogDirs,Specs) ->
+    case whereis(ct_master) of
+	undefined ->
+	    register(ct_master,self()),
+	    ok;
+	_Pid ->
+	    io:format("~nWarning: ct_master already running!~n"),
+	    exit(aborted)
+%	    case io:get_line('[y/n]>') of
+%		"y\n" ->
+%		    ok;
+%		"n\n" ->
+%		    exit(aborted);
+%		_ ->
+%		    init_master(NodeOptsList,LogDirs)
+%	    end
+    end,
+
+    %% start master logger
+    {MLPid,_} = ct_master_logs:start(MasterLogDir,
+				     [N || {N,_} <- NodeOptsList]),
+    log(all,"Master Logger process started","~w",[MLPid]),
+    case Specs of
+	[] -> ok;
+	_ ->
+	    SpecsStr = lists:map(fun(Name) ->
+					 Name ++ " "
+				 end,Specs), 
+	    ct_master_logs:log("Test Specification file(s)","~s",
+			       [lists:flatten(SpecsStr)])
+    end,
+
+    %% start master event manager and add default handler
+    ct_master_event:start_link(),
+    ct_master_event:add_handler(),
+    %% add user handlers for master event manager
+    Add = fun({H,Args}) ->
+		  log(all,"Adding Event Handler","~p",[H]),
+		  case gen_event:add_handler(?CT_MEVMGR_REF,H,Args) of
+		      ok -> ok;
+		      {'EXIT',Why} -> exit(Why);
+		      Other -> exit({event_handler,Other})
+		  end
+	  end,
+    lists:foreach(Add,EvHandlers),
+
+    %% double check event manager is started and registered
+    case whereis(?CT_MEVMGR) of
+	undefined ->
+	    exit({?CT_MEVMGR,undefined});
+	Pid when is_pid(Pid) ->
+	    ok
+    end,
+    init_master1(Parent,NodeOptsList,LogDirs).
+
+init_master1(Parent,NodeOptsList,LogDirs) ->
+    {Inaccessible,NodeOptsList1} = ping_nodes(NodeOptsList,[],[]),
+    case Inaccessible of
+	[] ->
+	    init_master2(Parent,NodeOptsList,LogDirs);
+	_ ->
+	    io:format("~nThe following nodes are inaccessible: ~p~n~n",
+		      [Inaccessible]),
+	    io:format("Proceed(p), Rescan(r) or Abort(a)? "),
+	    case io:get_line('[p/r/a]>') of
+		"p\n" ->
+		    log(html,"Inaccessible Nodes",
+			"Proceeding without: ~p",[Inaccessible]),
+		    init_master2(Parent,NodeOptsList1,LogDirs);
+		"r\n" ->
+		    init_master1(Parent,NodeOptsList,LogDirs);
+		_ ->
+		    log(html,"Aborting Tests","",[]),
+		    ct_master_event:stop(),
+		    ct_master_logs:stop(),
+		    exit(aborted)
+	    end
+    end.
+
+init_master2(Parent,NodeOptsList,LogDirs) ->
+    process_flag(trap_exit,true),
+    Cookie = erlang:get_cookie(),
+    log(all,"Cookie","~w",[Cookie]),
+    log(all,"Starting Tests",
+	"Tests starting on: ~p",[[N || {N,_} <- NodeOptsList]]),
+    SpawnAndMon = 
+	fun({Node,Opts}) ->
+		monitor_node(Node,true),
+		log(all,"Test Info","Starting test(s) on ~p...",[Node]),
+		{spawn_link(Node,?MODULE,init_node_ctrl,[self(),Cookie,Opts]),Node}
+	end,
+    NodeCtrlPids = lists:map(SpawnAndMon,NodeOptsList),
+    Result = master_loop(#state{node_ctrl_pids=NodeCtrlPids,
+				logdirs=LogDirs}),
+    Parent ! {self(),Result}.
+
+master_loop(#state{node_ctrl_pids=[],
+		   logdirs=LogDirs,
+		   results=Finished}) ->
+    Str =
+	lists:map(fun({Node,Result}) ->
+			  io_lib:format("~-40.40.*s~p\n",[$_,atom_to_list(Node),Result])
+		  end,lists:reverse(Finished)),
+    log(all,"TEST RESULTS",Str,[]),
+    log(all,"Info","Updating log files",[]),
+    refresh_logs(LogDirs,[]),
+
+    ct_master_event:stop(),
+    ct_master_logs:stop(),
+    ok;
+
+master_loop(State=#state{node_ctrl_pids=NodeCtrlPids,
+			 results=Results,
+			 locks=Locks,
+			 blocked=Blocked}) ->
+    receive
+	{'EXIT',Pid,Reason} ->
+	    case get_node(Pid,NodeCtrlPids) of
+		{Node,NodeCtrlPids1} ->
+		    monitor_node(Node,false),
+		    case Reason of 
+			normal ->
+			    log(all,"Test Info",
+				"Test(s) on node ~w finished.",[Node]),
+			    master_loop(State#state{node_ctrl_pids=NodeCtrlPids1});
+			Bad ->
+			    Error =
+				case Bad of
+				    What when What=/=killed,is_atom(What) -> 
+					{error,Bad};
+				    _ -> 
+					Bad
+				end,
+			    log(all,"Test Info",
+				"Test on node ~w failed! Reason: ~p",[Node,Error]),
+			    {Locks1,Blocked1} = 
+				update_queue(exit,Node,Locks,Blocked),
+			    master_loop(State#state{node_ctrl_pids=NodeCtrlPids1,
+						    results=[{Node,Error}|Results],
+						    locks=Locks1,
+						    blocked=Blocked1})
+		    end;
+		undefined ->
+		    %% ignore (but report) exit from master_logger etc
+		    log(all,"Test Info",
+			"Warning! Process ~p has terminated. Reason: ~p",
+			[Pid,Reason]),
+			master_loop(State)
+	    end;
+
+	{nodedown,Node} ->
+	    case get_pid(Node,NodeCtrlPids) of
+		{_Pid,NodeCtrlPids1} ->
+		    monitor_node(Node,false),
+		    log(all,"Test Info","No connection to testnode ~w!",[Node]),
+		    {Locks1,Blocked1} = 
+			update_queue(exit,Node,Locks,Blocked),
+		    master_loop(State#state{node_ctrl_pids=NodeCtrlPids1,
+					    results=[{Node,nodedown}|Results],
+					    locks=Locks1,
+					    blocked=Blocked1});
+		undefined ->
+		    master_loop(State)
+	    end;
+
+	{Pid,{result,Result}} ->
+	    {Node,_} = get_node(Pid,NodeCtrlPids),
+	    master_loop(State#state{results=[{Node,Result}|Results]});
+	
+	{call,progress,From} ->
+	    reply(master_progress(NodeCtrlPids,Results),From),
+	    master_loop(State);
+
+	{call,abort,From} ->
+	    lists:foreach(fun({Pid,Node}) ->
+				  log(all,"Test Info",
+				      "Aborting tests on ~w",[Node]),
+				  exit(Pid,kill)
+			  end,NodeCtrlPids),
+	    reply(ok,From),
+	    master_loop(State);
+
+	 {call,{abort,Nodes},From} ->
+	    lists:foreach(fun(Node) ->
+				  case lists:keysearch(Node,2,NodeCtrlPids) of
+				      {value,{Pid,Node}} ->
+					  log(all,"Test Info",
+					      "Aborting tests on ~w",[Node]),
+					  exit(Pid,kill);
+				      false ->
+					  ok
+				  end
+			  end,Nodes),
+	    reply(ok,From),
+	    master_loop(State);
+
+	{call,#event{name=Name,node=Node,data=Data},From} ->
+	    {Op,Lock} =
+		case Name of
+		    start_make ->
+			{take,{make,Data}};
+		    finished_make ->
+			{release,{make,Data}};
+		    start_write_file ->
+			{take,{write_file,Data}};
+		    finished_write_file ->
+			{release,{write_file,Data}}
+		end,
+	    {Locks1,Blocked1} =
+		update_queue(Op,Node,From,Lock,Locks,Blocked),
+	    if Op == release -> reply(ok,From);
+	       true -> ok
+	    end,
+	    master_loop(State#state{locks=Locks1,
+				    blocked=Blocked1});
+
+	{cast,Event} when is_record(Event,event) ->
+	    ct_master_event:notify(Event),
+	    master_loop(State)
+
+    end.
+
+
+update_queue(take,Node,From,Lock={Op,Resource},Locks,Blocked) ->
+    %% Locks: [{{Operation,Resource},Node},...]
+    %% Blocked: [{{Operation,Resource},Node,WaitingPid},...]
+    case lists:keysearch(Lock,1,Locks) of
+	{value,{_Lock,Owner}} ->		% other node has lock
+	    log(html,"Lock Info","Node ~p blocked on ~w by ~w. Resource: ~p",
+		[Node,Op,Owner,Resource]),
+	    Blocked1 = Blocked ++ [{Lock,Node,From}],
+	    {Locks,Blocked1};
+	false ->				% go ahead
+	    Locks1 = [{Lock,Node}|Locks],
+	    reply(ok,From),
+	    {Locks1,Blocked}
+    end;
+
+update_queue(release,Node,_From,Lock={Op,Resource},Locks,Blocked) ->
+    Locks1 = lists:delete({Lock,Node},Locks),
+    case lists:keysearch(Lock,1,Blocked) of
+	{value,E={Lock,SomeNode,WaitingPid}} ->
+	    Blocked1 = lists:delete(E,Blocked),
+	    log(html,"Lock Info","Node ~p proceeds with ~w. Resource: ~p",
+		[SomeNode,Op,Resource]),
+	    reply(ok,WaitingPid),		% waiting process may start
+	    {Locks1,Blocked1};
+	false ->
+	    {Locks1,Blocked}
+    end.
+
+update_queue(exit,Node,Locks,Blocked) ->
+    NodeLocks = lists:foldl(fun({L,N},Ls) when N == Node ->
+				     [L|Ls];
+				(_,Ls) ->
+				     Ls
+			     end,[],Locks),
+    release_locks(Node,NodeLocks,Locks,Blocked).
+
+release_locks(Node,[Lock|Ls],Locks,Blocked) ->
+    {Locks1,Blocked1} = update_queue(release,Node,undefined,Lock,Locks,Blocked),
+    release_locks(Node,Ls,Locks1,Blocked1);
+release_locks(_,[],Locks,Blocked) ->
+    {Locks,Blocked}.
+
+get_node(Pid,NodeCtrlPids) ->
+    case lists:keysearch(Pid,1,NodeCtrlPids) of
+	{value,{Pid,Node}} ->
+	    {Node,lists:keydelete(Pid,1,NodeCtrlPids)};
+	false ->
+	    undefined
+    end.
+
+get_pid(Node,NodeCtrlPids) ->
+    case lists:keysearch(Node,2,NodeCtrlPids) of
+	{value,{Pid,Node}} ->
+	    {Pid,lists:keydelete(Node,2,NodeCtrlPids)};
+	false ->
+	    undefined
+    end.
+
+ping_nodes([NO={Node,_Opts}|NOs],Inaccessible,NodeOpts) ->
+    case net_adm:ping(Node) of
+	pong ->
+	    ping_nodes(NOs,Inaccessible,[NO|NodeOpts]);
+	_ ->
+	    ping_nodes(NOs,[Node|Inaccessible],NodeOpts)
+    end;
+ping_nodes([],Inaccessible,NodeOpts) ->
+    {lists:reverse(Inaccessible),lists:reverse(NodeOpts)}.
+
+master_progress(NodeCtrlPids,Results) ->
+    Results ++ lists:map(fun({_Pid,Node}) ->
+				 {Node,ongoing}
+			 end,NodeCtrlPids).    
+    
+%% refresh those dirs where more than one node has written logs
+refresh_logs([D|Dirs],Refreshed) ->
+    case lists:member(D,Dirs) of
+	true ->
+	    case lists:keymember(D,1,Refreshed) of
+		true ->
+		    refresh_logs(Dirs,Refreshed);
+		false ->
+		    {ok,Cwd} = file:get_cwd(),
+		    case catch ct_run:refresh_logs(D) of
+			{'EXIT',Reason} ->
+			    file:set_cwd(Cwd),
+			    refresh_logs(Dirs,[{D,{error,Reason}}|Refreshed]);
+			Result -> 
+			    refresh_logs(Dirs,[{D,Result}|Refreshed])
+		    end
+	    end;
+	false ->
+	    refresh_logs(Dirs,Refreshed)
+    end;
+refresh_logs([],Refreshed) ->
+    Str =
+	lists:map(fun({D,Result}) ->
+			  io_lib:format("Refreshing logs in ~p... ~p",[D,Result])
+		  end,Refreshed),
+    log(all,"Info",Str,[]).
+
+%%%-----------------------------------------------------------------
+%%% NODE CONTROLLER, runs and controls tests on a test node.
+%%%-----------------------------------------------------------------
+%%% @hidden
+init_node_ctrl(MasterPid,Cookie,Opts) ->
+    %% make sure tests proceed even if connection to master is lost
+    process_flag(trap_exit, true),
+    MasterNode = node(MasterPid),
+    group_leader(whereis(user),self()),
+    io:format("~n********** node_ctrl process ~p started on ~p **********~n",
+	      [self(),node()]),
+    %% initially this node must have the same cookie as the master node
+    %% but now we set it explicitly for the connection so that test suites
+    %% can change the cookie for the node if they wish
+    case erlang:get_cookie() of
+	Cookie ->			% first time or cookie not changed
+	    erlang:set_cookie(node(MasterPid),Cookie);
+	_ ->
+	    ok
+    end,    
+    case whereis(ct_util_server) of
+	undefined -> ok;
+	Pid -> exit(Pid,kill)
+    end,
+    
+    %% start a local event manager
+    ct_event:start_link(),
+    ct_event:add_handler([{master,MasterPid}]),
+
+    %% log("Running test with options: ~p~n", [Opts]),
+    Result = case (catch ct:run_test(Opts)) of
+		 ok -> finished_ok;
+		 Other -> Other
+	     end,
+
+    %% stop local event manager
+    ct_event:stop(),
+
+    case net_adm:ping(MasterNode) of
+	pong ->
+	    MasterPid ! {self(),{result,Result}};
+	pang ->
+	    io:format("Warning! Connection to master node ~p is lost. "
+		      "Can't report result!~n~n", [MasterNode])
+    end.
+
+%%%-----------------------------------------------------------------
+%%% Event handling
+%%%-----------------------------------------------------------------
+%%% @hidden
+status(MasterPid,Event=#event{name=start_make}) ->
+    call(MasterPid,Event);
+status(MasterPid,Event=#event{name=finished_make}) ->
+    call(MasterPid,Event);
+status(MasterPid,Event=#event{name=start_write_file}) ->
+    call(MasterPid,Event);
+status(MasterPid,Event=#event{name=finished_write_file}) ->
+    call(MasterPid,Event);
+status(MasterPid,Event) ->
+    cast(MasterPid,Event).
+
+%%%-----------------------------------------------------------------
+%%% Internal
+%%%-----------------------------------------------------------------
+
+log(To,Heading,Str,Args) ->
+    if To == all ; To == tty ->
+	    Str1 = ["=== ",Heading," ===\n",io_lib:format(Str,Args),"\n"],
+	    io:format(Str1,[]);
+       true ->
+	    ok
+    end,
+    if To == all ; To == html ->
+	    ct_master_logs:log(Heading,Str,Args);
+       true ->
+	    ok
+    end.    
+	    
+
+call(Msg) ->
+    call(whereis(ct_master),Msg).
+
+call(undefined,_Msg) ->
+    {error,not_running};
+
+call(Pid,Msg) ->
+    Ref = erlang:monitor(process,Pid),
+    Pid ! {call,Msg,self()},
+    Return = receive
+		 {Pid,Result} ->
+		     Result;
+		 {'DOWN', Ref, _, _, _} ->
+		     {error,master_died}
+	     end,	    
+    erlang:demonitor(Ref),
+    Return.
+
+reply(Result,To) ->
+    To ! {self(),Result},
+    ok.
+
+%cast(Msg) ->
+%    cast(whereis(ct_master),Msg).
+
+cast(undefined,_Msg) ->
+    {error,not_running};
+
+cast(Pid,Msg) ->
+    Pid ! {cast,Msg},
+    ok.
diff --git a/lib/common_test/src/ct_master_event.erl b/lib/common_test/src/ct_master_event.erl
new file mode 100644
index 0000000000..a70baefaaf
--- /dev/null
+++ b/lib/common_test/src/ct_master_event.erl
@@ -0,0 +1,179 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 2006-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%
+%%
+
+%%% @doc Common Test Framework Event Handler
+%%%
+%%% <p>This module implements an event handler that the CT Master
+%%% uses to handle status and progress notifications sent to the
+%%% master node during test runs. This module may be used as a 
+%%% template for other event handlers that can be plugged in to 
+%%% handle logging and reporting on the master node.</p>
+-module(ct_master_event).
+
+-behaviour(gen_event).
+
+%% API
+-export([start_link/0, add_handler/0, add_handler/1, stop/0]).
+-export([notify/1, sync_notify/1]).
+
+%% gen_event callbacks
+-export([init/1, handle_event/2, handle_call/2, 
+	 handle_info/2, terminate/2, code_change/3]).
+
+-include("ct_event.hrl").
+-include("ct_util.hrl").
+
+
+-record(state, {}).
+
+%%====================================================================
+%% gen_event callbacks
+%%====================================================================
+%%--------------------------------------------------------------------
+%% Function: start_link() -> {ok,Pid} | {error,Error} 
+%% Description: Creates an event manager.
+%%--------------------------------------------------------------------
+start_link() ->
+    gen_event:start_link({local,?CT_MEVMGR}). 
+
+%%--------------------------------------------------------------------
+%% Function: add_handler() -> ok | {'EXIT',Reason} | term()
+%% Description: Adds an event handler
+%%--------------------------------------------------------------------
+add_handler() ->
+    gen_event:add_handler(?CT_MEVMGR_REF,?MODULE,[]).
+add_handler(Args) ->
+    gen_event:add_handler(?CT_MEVMGR_REF,?MODULE,Args).
+
+%%--------------------------------------------------------------------
+%% Function: stop() -> ok
+%% Description: Stops the event manager
+%%--------------------------------------------------------------------
+stop() ->
+    flush(),
+    gen_event:stop(?CT_MEVMGR_REF).
+
+flush() ->
+    case gen_event:call(?CT_MEVMGR_REF,?MODULE,flush) of
+	flushing ->
+	    timer:sleep(1),
+	    flush();
+	done ->
+	    ok
+    end.
+
+%%--------------------------------------------------------------------
+%% Function: notify(Event) -> ok
+%% Description: Asynchronous notification to event manager.
+%%--------------------------------------------------------------------
+notify(Event) ->
+    gen_event:notify(?CT_MEVMGR_REF,Event).
+
+%%--------------------------------------------------------------------
+%% Function: sync_notify(Event) -> ok
+%% Description: Synchronous notification to event manager.
+%%--------------------------------------------------------------------
+sync_notify(Event) ->
+    gen_event:sync_notify(?CT_MEVMGR_REF,Event).
+
+%%====================================================================
+%% gen_event callbacks
+%%====================================================================
+%%--------------------------------------------------------------------
+%% Function: init(Args) -> {ok, State}
+%% Description: Whenever a new event handler is added to an event manager,
+%% this function is called to initialize the event handler.
+%%--------------------------------------------------------------------
+init(_) ->
+    ct_master_logs:log("CT Master Event Handler started","",[]),
+    {ok,#state{}}.
+
+%%--------------------------------------------------------------------
+%% Function:  
+%% handle_event(Event, State) -> {ok, State} |
+%%                               {swap_handler, Args1, State1, Mod2, Args2} |
+%%                               remove_handler
+%% Description:Whenever an event manager receives an event sent using
+%% gen_event:notify/2 or gen_event:sync_notify/2, this function is called for
+%% each installed event handler to handle the event. 
+%%--------------------------------------------------------------------
+handle_event(#event{name=start_logging,node=Node,data=RunDir},State) ->
+    ct_master_logs:log("CT Master Event Handler","Got ~s from ~p",[RunDir,Node]),
+    ct_master_logs:nodedir(Node,RunDir),
+    {ok,State};
+
+handle_event(#event{name=Name,node=Node,data=Data},State) ->
+    print("~n=== ~w ===~n", [?MODULE]),
+    print("~p on ~p: ~p~n", [Name,Node,Data]),
+    {ok,State}.
+
+%%--------------------------------------------------------------------
+%% Function: 
+%% handle_call(Request, State) -> {ok, Reply, State} |
+%%                                {swap_handler, Reply, Args1, State1, 
+%%                                  Mod2, Args2} |
+%%                                {remove_handler, Reply}
+%% Description: Whenever an event manager receives a request sent using
+%% gen_event:call/3,4, this function is called for the specified event 
+%% handler to handle the request.
+%%--------------------------------------------------------------------
+handle_call(flush,State) ->
+    case process_info(self(),message_queue_len) of
+	{message_queue_len,0} ->
+	    {ok,done,State};
+	_ ->
+	    {ok,flushing,State}
+    end.
+
+%%--------------------------------------------------------------------
+%% Function: 
+%% handle_info(Info, State) -> {ok, State} |
+%%                             {swap_handler, Args1, State1, Mod2, Args2} |
+%%                              remove_handler
+%% Description: This function is called for each installed event handler when
+%% an event manager receives any other message than an event or a synchronous
+%% request (or a system message).
+%%--------------------------------------------------------------------
+handle_info(_Info,State) ->
+    {ok,State}.
+
+%%--------------------------------------------------------------------
+%% Function: terminate(Reason, State) -> void()
+%% Description:Whenever an event handler is deleted from an event manager,
+%% this function is called. It should be the opposite of Module:init/1 and 
+%% do any necessary cleaning up. 
+%%--------------------------------------------------------------------
+terminate(_Reason,_State) ->
+    ct_master_logs:log("CT Master Event Handler stopping","",[]),
+    ok.
+
+%%--------------------------------------------------------------------
+%% Function: code_change(OldVsn, State, Extra) -> {ok, NewState} 
+%% Description: Convert process state when code is changed
+%%--------------------------------------------------------------------
+code_change(_OldVsn,State,_Extra) ->
+    {ok,State}.
+
+%%--------------------------------------------------------------------
+%%% Internal functions
+%%--------------------------------------------------------------------
+
+print(_Str,_Args) ->
+%    io:format(_Str,_Args),
+    ok.
diff --git a/lib/common_test/src/ct_master_logs.erl b/lib/common_test/src/ct_master_logs.erl
new file mode 100644
index 0000000000..63f60b1182
--- /dev/null
+++ b/lib/common_test/src/ct_master_logs.erl
@@ -0,0 +1,454 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 2006-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%
+%%
+
+%%% @doc Logging functionality for Common Test Master.
+%%%
+%%% <p>This module implements a logger for the master
+%%% node.</p>
+-module(ct_master_logs).
+
+-export([start/2, make_all_runs_index/0, log/3, nodedir/2, stop/0]).
+
+-record(state, {log_fd, start_time, logdir, rundir, 
+		nodedir_ix_fd, nodes, nodedirs=[]}).
+
+-define(ct_master_log_name, "ct_master_log.html").
+-define(all_runs_name, "master_runs.html").
+-define(nodedir_index_name, "index.html").
+-define(details_file_name,"details.info").
+-define(table_color,"lightblue").
+
+%%%--------------------------------------------------------------------
+%%% API
+%%%--------------------------------------------------------------------
+
+start(LogDir,Nodes) ->
+    Self = self(),
+    Pid = spawn_link(fun() -> init(Self,LogDir,Nodes) end),
+    MRef = erlang:monitor(process,Pid),
+    receive 
+	{started,Pid,Result} -> 
+	    erlang:demonitor(MRef),
+	    {Pid,Result};
+	{'DOWN',MRef,process,_,Reason} ->
+	    exit({could_not_start_process,?MODULE,Reason})
+    end.
+
+log(Heading,Format,Args) ->
+    cast({log,self(),[{int_header(),[log_timestamp(now()),Heading]},
+		      {Format,Args},
+		      {int_footer(),[]}]}),
+    ok.
+
+make_all_runs_index() ->
+    call(make_all_runs_index).
+
+nodedir(Node,RunDir) ->
+    call({nodedir,Node,RunDir}).
+
+stop() ->
+    case whereis(?MODULE) of
+	Pid when is_pid(Pid) ->
+	    MRef = erlang:monitor(process,Pid),
+	    ?MODULE ! stop,
+	    receive
+		{'DOWN',MRef,process,_,_} ->
+		    ok
+	    end;
+	undefined ->
+	    ok
+    end,
+    ok.
+
+%%%--------------------------------------------------------------------
+%%% Logger process
+%%%--------------------------------------------------------------------
+
+init(Parent,LogDir,Nodes) ->
+    register(?MODULE,self()),
+    Time = calendar:local_time(),
+    RunDir = make_dirname(Time),
+    RunDirAbs = filename:join(LogDir,RunDir),
+    file:make_dir(RunDirAbs),
+    write_details_file(RunDirAbs,{node(),Nodes}),
+    make_all_runs_index(LogDir),
+    CtLogFd = open_ct_master_log(RunDirAbs),
+    NodeStr = 
+	lists:flatten(lists:map(fun(N) ->
+					atom_to_list(N) ++ " "
+				end,Nodes)),
+
+    io:format(CtLogFd,int_header(),[log_timestamp(now()),"Test Nodes\n"]),
+    io:format(CtLogFd,"~s\n",[NodeStr]),
+    io:format(CtLogFd,int_footer()++"\n",[]),
+
+    NodeDirIxFd = open_nodedir_index(RunDirAbs,Time),
+    Parent ! {started,self(),{Time,RunDirAbs}},
+    loop(#state{log_fd=CtLogFd,
+		start_time=Time,
+		logdir=LogDir,
+		rundir=RunDirAbs,
+		nodedir_ix_fd=NodeDirIxFd,
+		nodes=Nodes,
+		nodedirs=lists:map(fun(N) ->
+					   {N,""}
+				   end,Nodes)}).
+
+loop(State) ->
+    receive
+	{log,_From,List} ->
+	    Fd = State#state.log_fd,
+	    Fun = 
+		fun({Str,Args}) ->
+			case catch io:format(Fd,Str++"\n",Args) of
+			    {'EXIT',Reason} ->
+				io:format(Fd, 
+					  "Logging fails! Str: ~p, Args: ~p~n",
+					  [Str,Args]),
+				exit({logging_failed,Reason}),
+				ok;
+			    _ ->
+				ok
+			end
+		end,
+	    lists:foreach(Fun,List),
+	    loop(State);
+	{make_all_runs_index,From} ->
+	    make_all_runs_index(State#state.logdir),
+	    return(From,State#state.logdir),
+	    loop(State);	
+	{{nodedir,Node,RunDir},From} ->
+	    print_nodedir(Node,RunDir,State#state.nodedir_ix_fd),
+	    return(From,ok),
+	    loop(State);	
+	stop ->
+	    make_all_runs_index(State#state.logdir),
+	    io:format(State#state.log_fd,
+		      int_header()++int_footer(),
+		      [log_timestamp(now()),"Finished!"]),
+	    close_ct_master_log(State#state.log_fd),
+	    close_nodedir_index(State#state.nodedir_ix_fd),
+	    ok
+    end.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%% Master Log functions %%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+open_ct_master_log(Dir) ->
+    FullName = filename:join(Dir,?ct_master_log_name),
+    {ok,Fd} = file:open(FullName,[write]),
+    io:format(Fd,header("Common Test Master Log"),[]),
+    %% maybe add config info here later
+    io:format(Fd, config_table([]), []),
+    io:format(Fd,
+	      "<style>\n"
+	      "div.ct_internal { background:lightgrey; color:black }\n"
+	      "div.default     { background:lightgreen; color:black }\n"
+	      "</style>\n",
+	      []),
+    io:format(Fd, 
+	      "<br><h2>Progress Log</h2>\n"
+	      "<pre>\n",[]),
+    Fd.
+
+close_ct_master_log(Fd) ->
+    io:format(Fd,"</pre>",[]),
+    io:format(Fd,footer(),[]),
+    file:close(Fd).
+
+config_table(Vars) ->
+    [config_table_header()|config_table1(Vars)].
+
+config_table_header() ->
+    ["<h2>Configuration</h2>\n",
+     "<table border=\"3\" cellpadding=\"5\" bgcolor=\"",?table_color,
+     "\"\n",
+     "<tr><th>Key</th><th>Value</th></tr>\n"].
+
+%%
+%% keep for possible later use
+%%
+%%config_table1([{Key,Value}|Vars]) ->
+%%    ["<tr><td>", atom_to_list(Key), "</td>\n",
+%%     "<td><pre>",io_lib:format("~p",[Value]),"</pre></td></tr>\n" | 
+%%     config_table1(Vars)];
+
+config_table1([]) ->
+    ["</table>\n"].
+
+int_header() ->
+    "<div class=\"ct_internal\"><b>*** CT MASTER ~s *** ~s</b>".
+int_footer() ->
+    "</div>".
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%% NodeDir Index functions %%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+open_nodedir_index(Dir,StartTime) ->
+    FullName = filename:join(Dir,?nodedir_index_name),
+    {ok,Fd} = file:open(FullName,[write]),
+    io:format(Fd,nodedir_index_header(StartTime),[]),
+    Fd.
+
+print_nodedir(Node,RunDir,Fd) ->
+    Index = filename:join(RunDir,"index.html"),
+    io:format(Fd,
+	      ["<TR>\n"
+	       "<TD ALIGN=center>",atom_to_list(Node),"</TD>\n",
+	       "<TD ALIGN=left><A HREF=\"",Index,"\">",Index,"</A></TD>\n",
+	       "</TR>\n"],[]),
+    ok.
+
+close_nodedir_index(Fd) ->
+    io:format(Fd,index_footer(),[]),
+    file:close(Fd).
+
+nodedir_index_header(StartTime) ->
+    [header("Log Files " ++ format_time(StartTime)) |
+     ["<CENTER>\n",
+      "<P><A HREF=\"",?ct_master_log_name,"\">Common Test Master Log</A></P>",
+      "<TABLE border=\"3\" cellpadding=\"5\" ",
+      "BGCOLOR=\"",?table_color,"\">\n",
+      "<th><B>Node</B></th>\n",
+      "<th><B>Log</B></th>\n",
+      "\n"]].
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%% All Run Index functions %%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+make_all_runs_index(LogDir) ->
+    FullName = filename:join(LogDir,?all_runs_name),
+    Match = filename:join(LogDir,logdir_prefix()++"*.*"),
+    Dirs = filelib:wildcard(Match),
+    DirsSorted = (catch sort_all_runs(Dirs)),
+    Header = all_runs_header(),
+    Index = [runentry(Dir) || Dir <- DirsSorted],
+    Result = file:write_file(FullName,Header++Index++index_footer()),
+    Result.    
+
+sort_all_runs(Dirs) ->
+    %% sort on time string, always last and on the format:
+    %% "YYYY-MM-DD_HH.MM.SS"
+    KeyList =
+	lists:map(fun(Dir) ->
+			  case lists:reverse(string:tokens(Dir,[$.,$_])) of
+			      [SS,MM,HH,Date|_] ->
+				  {{Date,HH,MM,SS},Dir};
+			      _Other ->
+				  throw(Dirs)
+			  end
+		  end,Dirs),
+    lists:reverse(lists:map(fun({_,Dir}) ->
+				    Dir
+			    end,lists:keysort(1,KeyList))).
+
+runentry(Dir) ->
+    {MasterStr,NodesStr} = 
+	case read_details_file(Dir) of
+	    {Master,Nodes} when is_list(Nodes) ->
+		[_,Host] = string:tokens(atom_to_list(Master),"@"),
+		NodesList = 
+		    lists:reverse(lists:map(fun(N) ->
+						    atom_to_list(N) ++ ", "
+					    end,Nodes)),
+		case NodesList of
+		    [N|NListR] ->
+			N1 = string:sub_string(N,1,length(N)-2),
+			{Host,lists:flatten(lists:reverse([N1|NListR]))};
+		    [] ->
+			{Host,""}
+		end;
+	    _Error ->
+		{"unknown",""}
+	end,
+    Index = filename:join(Dir,?nodedir_index_name),
+    ["<TR>\n"
+     "<TD ALIGN=center><A HREF=\"",Index,"\">",timestamp(Dir),"</A></TD>\n",
+     "<TD ALIGN=center>",MasterStr,"</TD>\n",
+     "<TD ALIGN=center>",NodesStr,"</TD>\n",
+     "</TR>\n"].
+
+all_runs_header() ->
+    [header("Master Test Runs") |
+     ["<CENTER>\n",
+      "<TABLE border=\"3\" cellpadding=\"5\" "
+      "BGCOLOR=\"",?table_color,"\">\n"
+      "<th><B>History</B></th>\n"
+      "<th><B>Master Host</B></th>\n"
+      "<th><B>Test Nodes</B></th>\n"
+      "\n"]].
+
+timestamp(Dir) ->
+    [S,Min,H,D,M,Y|_] = lists:reverse(string:tokens(Dir,".-_")),
+    [S1,Min1,H1,D1,M1,Y1] = [list_to_integer(N) || N <- [S,Min,H,D,M,Y]],
+    format_time({{Y1,M1,D1},{H1,Min1,S1}}).
+
+write_details_file(Dir,Details) ->
+    FullName = filename:join(Dir,?details_file_name),
+    force_write_file(FullName,term_to_binary(Details)).
+
+read_details_file(Dir) ->
+    FullName = filename:join(Dir,?details_file_name),
+    case file:read_file(FullName) of
+	{ok,Bin} ->
+	    binary_to_term(Bin);
+	Error ->
+	    Error
+    end.
+
+%%%--------------------------------------------------------------------
+%%% Internal functions
+%%%--------------------------------------------------------------------
+
+header(Title) ->
+    ["<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 3.2 Final//EN\">\n"
+     "<!-- autogenerated by '"++atom_to_list(?MODULE)++"'. -->\n"
+     "<HTML>\n",
+     "<HEAD>\n",
+
+     "<TITLE>" ++ Title ++ "</TITLE>\n",
+     "<META HTTP-EQUIV=\"CACHE-CONTROL\" CONTENT=\"NO-CACHE\">\n",
+
+     "</HEAD>\n",
+
+     body_tag(),
+
+     "<!-- ---- DOCUMENT TITLE  ---- -->\n",
+
+     "<CENTER>\n",
+     "<H1>" ++ Title ++ "</H1>\n",
+     "</CENTER>\n",
+
+     "<!-- ---- CONTENT ---- -->\n"].
+
+index_footer() ->
+    ["</TABLE>\n"
+     "</CENTER>\n" | footer()].
+
+footer() ->
+     ["<P><CENTER>\n"
+     "<HR>\n"
+     "<P><FONT SIZE=-1>\n"
+     "Copyright &copy; ", year(),
+     " <A HREF=\"http://erlang.ericsson.se\">Open Telecom Platform</A><BR>\n"
+     "Updated: <!date>", current_time(), "<!/date><BR>\n"
+     "</FONT>\n"
+     "</CENTER>\n"
+     "</body>\n"].
+
+body_tag() ->
+    "<body bgcolor=\"#FFFFFF\" text=\"#000000\" link=\"#0000FF\""
+	"vlink=\"#800080\" alink=\"#FF0000\">\n".
+
+current_time() ->
+    format_time(calendar:local_time()).
+
+format_time({{Y, Mon, D}, {H, Min, S}}) ->
+    Weekday = weekday(calendar:day_of_the_week(Y, Mon, D)),
+    lists:flatten(io_lib:format("~s ~s ~p ~w ~2.2.0w:~2.2.0w:~2.2.0w",
+				[Weekday, month(Mon), D, Y, H, Min, S])).
+
+weekday(1) -> "Mon";
+weekday(2) -> "Tue";
+weekday(3) -> "Wed";
+weekday(4) -> "Thu";
+weekday(5) -> "Fri";
+weekday(6) -> "Sat";
+weekday(7) -> "Sun".
+
+month(1) -> "Jan";
+month(2) -> "Feb";
+month(3) -> "Mar";
+month(4) -> "Apr";
+month(5) -> "May";
+month(6) -> "Jun";
+month(7) -> "Jul";
+month(8) -> "Aug";
+month(9) -> "Sep";
+month(10) -> "Oct";
+month(11) -> "Nov";
+month(12) -> "Dec".
+
+year() ->
+    {Y, _, _} = date(),
+    integer_to_list(Y).
+
+
+make_dirname({{YY,MM,DD},{H,M,S}}) -> 
+    io_lib:format(logdir_prefix()++".~w-~2.2.0w-~2.2.0w_~2.2.0w.~2.2.0w.~2.2.0w",
+		  [YY,MM,DD,H,M,S]).
+
+logdir_prefix() ->
+    "ct_master_run".
+
+log_timestamp(Now) ->
+    put(log_timestamp,Now),
+    {_,{H,M,S}} = calendar:now_to_local_time(Now),
+    lists:flatten(io_lib:format("~2.2.0w:~2.2.0w:~2.2.0w",
+				[H,M,S])).
+
+force_write_file(Name,Contents) ->
+    force_delete(Name),
+    file:write_file(Name,Contents).
+
+force_delete(Name) ->
+    case file:delete(Name) of
+	{error,eacces} ->
+	    force_rename(Name,Name++".old.",0);
+	Other ->
+	    Other
+    end.
+
+force_rename(From,To,Number) ->
+    Dest = [To|integer_to_list(Number)],
+    case file:read_file_info(Dest) of
+	{ok,_} ->
+	    force_rename(From,To,Number+1);
+	{error,_} ->
+	    file:rename(From,Dest)
+    end.
+
+call(Msg) ->
+    case whereis(?MODULE) of
+	undefined ->
+	    {error,does_not_exist};
+	Pid ->
+	    MRef = erlang:monitor(process,Pid),
+	    Ref = make_ref(),
+	    ?MODULE ! {Msg,{self(),Ref}},
+	    receive
+		{Ref, Result} -> 
+		    erlang:demonitor(MRef),
+		    Result;
+		{'DOWN',MRef,process,_,Reason}  -> 
+		    {error,{process_down,?MODULE,Reason}}
+	    end
+    end.
+
+return({To,Ref},Result) ->
+    To ! {Ref, Result}.
+
+cast(Msg) ->
+    case whereis(?MODULE) of
+	undefined ->
+	    {error,does_not_exist};
+	_Pid ->
+	    ?MODULE ! Msg
+    end.
diff --git a/lib/common_test/src/ct_master_status.erl b/lib/common_test/src/ct_master_status.erl
new file mode 100644
index 0000000000..76060fb7bb
--- /dev/null
+++ b/lib/common_test/src/ct_master_status.erl
@@ -0,0 +1,124 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 2006-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%
+%%
+
+%%% @doc Logging functionality for Common Test Master.
+%%%
+%%% <p>This module keeps a list of <code>{Node,Status}</code>
+%%% tuples. It is possible to anytime during a test run get
+%%% a snapshot of the test status. The module is an event
+%%% handler for the master event manager.</p>
+-module(ct_master_status).
+
+-behaviour(gen_event).
+
+-export([]).
+
+%% gen_event callbacks
+-export([init/1, handle_event/2, handle_call/2, 
+	 handle_info/2, terminate/2, code_change/3]).
+
+-include("ct_event.hrl").
+
+-record(state, {status=[]}).
+
+%%====================================================================
+%% gen_event callbacks
+%%====================================================================
+%%--------------------------------------------------------------------
+%% Function: init(Args) -> {ok, State}
+%% Description: Whenever a new event handler is added to an event manager,
+%% this function is called to initialize the event handler.
+%%--------------------------------------------------------------------
+init(_) ->
+    {ok,#state{}}.
+
+%%--------------------------------------------------------------------
+%% Function:  
+%% handle_event(Event, State) -> {ok, State} |
+%%                               {swap_handler, Args1, State1, Mod2, Args2} |
+%%                               remove_handler
+%% Description:Whenever an event manager receives an event sent using
+%% gen_event:notify/2 or gen_event:sync_notify/2, this function is called for
+%% each installed event handler to handle the event. 
+%%--------------------------------------------------------------------
+
+%%============================== EVENTS ==============================
+%%
+%% Events documented in ct_event, plus:
+%%
+%% Name = pending_make
+%% Data = {Node,Dir}
+%%
+%% Name = go_ahead_make
+%% Data = {Node,Dir}
+%%
+handle_event(#event{name=Name,node=Node,data=Data},State) ->
+    print("~n=== ~w ===~n", [?MODULE]),
+    print("~p on ~p: ~p~n", [Name,Node,Data]),
+    {ok,State}.
+
+%%--------------------------------------------------------------------
+%% Function: 
+%% handle_call(Request, State) -> {ok, Reply, State} |
+%%                                {swap_handler, Reply, Args1, State1, 
+%%                                  Mod2, Args2} |
+%%                                {remove_handler, Reply}
+%% Description: Whenever an event manager receives a request sent using
+%% gen_event:call/3,4, this function is called for the specified event 
+%% handler to handle the request.
+%%--------------------------------------------------------------------
+handle_call(_Req, State) ->
+    Reply = ok,
+    {ok, Reply, State}.
+
+%%--------------------------------------------------------------------
+%% Function: 
+%% handle_info(Info, State) -> {ok, State} |
+%%                             {swap_handler, Args1, State1, Mod2, Args2} |
+%%                              remove_handler
+%% Description: This function is called for each installed event handler when
+%% an event manager receives any other message than an event or a synchronous
+%% request (or a system message).
+%%--------------------------------------------------------------------
+handle_info(_Info, State) ->
+    {ok, State}.
+
+%%--------------------------------------------------------------------
+%% Function: terminate(Reason, State) -> void()
+%% Description:Whenever an event handler is deleted from an event manager,
+%% this function is called. It should be the opposite of Module:init/1 and 
+%% do any necessary cleaning up. 
+%%--------------------------------------------------------------------
+terminate(_Reason, _State) ->
+    ok.
+
+%%--------------------------------------------------------------------
+%% Function: code_change(OldVsn, State, Extra) -> {ok, NewState} 
+%% Description: Convert process state when code is changed
+%%--------------------------------------------------------------------
+code_change(_OldVsn, State, _Extra) ->
+    {ok, State}.
+
+%%--------------------------------------------------------------------
+%%% Internal functions
+%%--------------------------------------------------------------------
+
+print(_Str,_Args) ->
+    ok.
+
diff --git a/lib/common_test/src/ct_repeat.erl b/lib/common_test/src/ct_repeat.erl
new file mode 100644
index 0000000000..7ac6e045d7
--- /dev/null
+++ b/lib/common_test/src/ct_repeat.erl
@@ -0,0 +1,263 @@
+%%
+%% %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%
+%%
+
+%%% @doc Common Test Framework module that handles repeated test runs
+%%%
+%%% <p>This module exports functions for repeating tests. The following
+%%% script flags (or equivalent ct:run_test/1 options) are supported:
+%%% -until <StopTime>, StopTime = YYMoMoDDHHMMSS | HHMMSS
+%%% -duration <DurTime>, DurTime = HHMMSS
+%%% -force_stop
+%%% -repeat <N>, N = integer()</p>
+
+-module(ct_repeat).
+
+%% Script interface
+-export([loop_test/2]).
+-export([log_loop_info/1]).
+
+%%----------------------------------------------------------
+%% Flags:
+%%----------------------------------------------------------
+
+loop_test(If,Args) when is_list(Args) ->
+    {ok,Cwd} = file:get_cwd(),
+    case get_loop_info(Args) of
+	no_loop ->
+	    false;
+	{error,E} ->
+	    io:format("Common Test error: ~p\n\n",[E]),
+	    file:set_cwd(Cwd),
+	    E;
+	{repeat,N} ->
+	    io:format("\nCommon Test: Will repeat tests ~w times.\n\n",[N]),
+	    Args1 = [{loop_info,[{repeat,1,N}]} | Args],
+	    loop(If,repeat,0,N,undefined,Args1,undefined),
+	    file:set_cwd(Cwd);
+	{stop_time,StopTime} ->
+	    case remaining_time(StopTime) of
+		0 ->
+		    io:format("\nCommon Test: No time left to run tests.\n\n",[]),
+		    ok;
+		Secs ->
+		    io:format("\nCommon Test: Will repeat tests for ~s.\n\n",
+			      [ts(Secs)]),
+		    TPid =
+			case lists:keymember(force_stop,1,Args) of 
+			    true ->
+				CtrlPid = self(),
+				spawn(fun() -> stop_after(CtrlPid,Secs) end);
+			    false ->
+				undefined
+			end,
+		    Args1 = [{loop_info,[{stop_time,Secs,StopTime,1}]} | Args],
+		    loop(If,stop_time,0,Secs,StopTime,Args1,TPid)
+	    end,
+	    file:set_cwd(Cwd)
+    end.
+    
+loop(_,repeat,N,N,_,_Args,_) ->
+    ok;
+
+loop(If,Type,N,Data0,Data1,Args,TPid) ->
+    Pid = spawn_tester(If,self(),Args),
+    receive 
+	{'EXIT',Pid,Reason} ->
+	    io:format("Test run crashed! This could be an internal error "
+		      "- please report!\n\n"
+		      "~p\n\n",[Reason]),
+	    cancel(TPid),
+	    {error,Reason};
+	{Pid,{error,Reason}} ->
+	    io:format("\nTest run failed!\nReason: ~p\n\n",[Reason]),
+	    cancel(TPid),
+	    {error,Reason};
+	{Pid,Result} ->
+	    if Type == repeat ->
+		    io:format("\nTest run ~w(~w) complete.\n\n",[N+1,Data0]),		    
+		    lists:keydelete(loop_info,1,Args),
+		    Args1 = [{loop_info,[{repeat,N+2,Data0}]} | Args],
+		    loop(If,repeat,N+1,Data0,Data1,Args1,TPid);
+	       Type == stop_time ->
+		    case remaining_time(Data1) of
+			0 ->
+			    io:format("\nTest time (~s) has run out.\n\n",[ts(Data0)]),
+			    cancel(TPid),
+			    Result;
+			Secs ->
+			    io:format("\n~s of test time remaining, " 
+				      "starting run #~w...\n\n",[ts(Secs),N+2]),
+			    lists:keydelete(loop_info,1,Args),			    
+			    ST = {stop_time,Data0,Data1,N+2},
+			    Args1 = [{loop_info,[ST]} | Args],
+			    loop(If,stop_time,N+1,Data0,Data1,Args1,TPid)
+		    end
+	    end
+    end.
+
+spawn_tester(script,Ctrl,Args) ->
+    spawn_link(fun() -> ct_run:script_start1(Ctrl,Args) end);
+
+spawn_tester(func,Ctrl,Opts) ->
+    Tester = fun() ->
+		     case catch ct_run:run_test1(Opts) of
+			 {'EXIT',Reason} ->
+			     exit(Reason);
+			 Result ->
+			     Ctrl ! {self(),Result}
+		     end
+	     end,
+    spawn_link(Tester).
+
+remaining_time(StopTime) ->
+    Now = calendar:datetime_to_gregorian_seconds(calendar:local_time()),
+    Diff = StopTime - Now,
+    if Diff > 0 ->
+	    Diff;
+       true ->
+	    0
+    end.
+
+get_loop_info(Args) when is_list(Args) ->
+    case lists:keysearch(until,1,Args) of
+	{value,{until,Time}} ->
+	    Time1 = delistify(Time),
+	    case catch get_stop_time(until,Time1) of
+		{'EXIT',_} ->
+		    {error,{bad_time_format,Time1}};
+		Stop ->
+		    {stop_time,Stop}
+	    end;
+	false ->
+	    case lists:keysearch(duration,1,Args) of
+		{value,{duration,Time}} ->
+		    Time1 = delistify(Time),		    
+		    case catch get_stop_time(duration,Time1) of
+			{'EXIT',_} ->
+			    {error,{bad_time_format,Time1}};
+			Stop ->
+			    {stop_time,Stop}
+		    end;
+		false -> 
+		    case lists:keysearch(repeat,1,Args) of
+			{value,{repeat,R}} ->
+			    case R of
+				N when is_integer(N), N>0 -> 
+				    {repeat,N};
+				[Str] -> 
+				    case catch list_to_integer(Str) of
+					N when is_integer(N), N>0 ->
+					    {repeat,N};
+					_ ->
+					    {error,{invalid_repeat_value,Str}}
+				    end;
+				_ ->
+				    {error,{invalid_repeat_value,R}}
+			    end;
+			false ->
+			    no_loop
+		    end
+	    end
+    end.
+
+get_stop_time(until,[Y1,Y2,Mo1,Mo2,D1,D2,H1,H2,Mi1,Mi2,S1,S2]) ->
+    Date =
+	case [Mo1,Mo2] of
+	    "00" ->
+		date();
+	    _ ->
+		Y = list_to_integer([Y1,Y2]),
+		Mo = list_to_integer([Mo1,Mo2]),
+		D = list_to_integer([D1,D2]),
+		{YNow,_,_} = date(),
+		Dec = trunc(YNow/100),
+		Year =
+		    if Y < (YNow-Dec*100) -> (Dec+1)*100 + Y;
+		       true -> Dec*100 + Y
+		    end,
+		{Year,Mo,D}
+	end,
+    Time = {list_to_integer([H1,H2]),
+	    list_to_integer([Mi1,Mi2]),
+	    list_to_integer([S1,S2])},
+    calendar:datetime_to_gregorian_seconds({Date,Time});
+
+get_stop_time(until,Time) ->
+    get_stop_time(until,"000000"++Time);
+
+get_stop_time(duration,[H1,H2,Mi1,Mi2,S1,S2]) ->
+    Secs = 
+	list_to_integer([H1,H2]) * 3600 + 
+	list_to_integer([Mi1,Mi2]) * 60 + 
+	list_to_integer([S1,S2]),
+    calendar:datetime_to_gregorian_seconds(calendar:local_time()) + Secs.
+
+cancel(Pid) ->
+    catch exit(Pid,kill).
+
+%% After Secs, abort will make the test_server finish the current
+%% job, then empty the job queue and stop.
+stop_after(_CtrlPid,Secs) ->
+    timer:sleep(Secs*1000),
+    test_server_ctrl:abort().
+
+%% Callback from ct_run to print loop info to system log.
+log_loop_info(Args) ->
+    case lists:keysearch(loop_info,1,Args) of
+	false ->
+	    ok;
+	{value,{_,[{repeat,C,N}]}} ->
+	    ct_logs:log("Test loop info","Test run ~w of ~w",[C,N]); 
+	{value,{_,[{stop_time,Secs0,StopTime,N}]}} ->
+	    LogStr1 = 
+		case lists:keysearch(duration,1,Args) of
+		    {value,{_,Dur}} ->
+			io_lib:format("Specified test duration: ~s (~w secs)\n",
+				      [delistify(Dur),Secs0]);
+		_ ->
+		    case lists:keysearch(until,1,Args) of
+			{value,{_,Until}} ->
+			    io_lib:format("Specified end time: ~s (duration ~w secs)\n",
+					  [delistify(Until),Secs0]);
+			_ ->
+			    ok
+		    end
+	    end,
+	    LogStr2 = io_lib:format("Test run #~w\n", [N]),
+	    Secs = remaining_time(StopTime),
+	    LogStr3 =
+		io_lib:format("Test time remaining: ~w secs (~w%)\n",
+			      [Secs,trunc((Secs/Secs0)*100)]),
+	    LogStr4 =
+		case lists:keymember(force_stop,1,Args) of
+		    true ->
+			io_lib:format("force_stop is enabled",[]);
+		    _ ->
+			""
+		end,			
+	    ct_logs:log("Test loop info",LogStr1++LogStr2++LogStr3++LogStr4,[])
+    end.
+
+ts(Secs) ->
+    integer_to_list(Secs) ++ " secs".
+
+delistify([X]) ->
+    X;
+delistify(X) ->
+    X.
diff --git a/lib/common_test/src/ct_rpc.erl b/lib/common_test/src/ct_rpc.erl
new file mode 100644
index 0000000000..03d95d1408
--- /dev/null
+++ b/lib/common_test/src/ct_rpc.erl
@@ -0,0 +1,204 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 2004-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%
+%%
+
+%%% @doc Common Test specific layer on Erlang/OTP rpc. 
+
+-module(ct_rpc).
+
+%%% API
+-export([app_node/2, app_node/3, app_node/4,
+	 call/4, call/5, call/6, cast/4, cast/5]).
+
+%%%=========================================================================
+%%%  API
+%%%=========================================================================
+%%% @spec app_node(App, Candidates) -> NodeName
+%%%
+%%%      App = atom() 
+%%%      Candidates = [NodeName]
+%%%      NodeName = atom() 
+%%%
+%%% @doc From a set of candidate nodes determines which of them is
+%%%      running the application App. If none of the candidate nodes
+%%%      is running the application the function will make the test case
+%%%      calling this function fail. This function is the same as calling
+%%%      <code>app_node(App, Candidates, true)</code>.
+%%%
+app_node(App, Candidates) ->
+    app_node(App, Candidates, true, []).
+
+%%% @spec app_node(App, Candidates, FailOnBadRPC) -> NodeName
+%%%
+%%%      App = atom() 
+%%%      Candidates = [NodeName]
+%%%      NodeName = atom() 
+%%%      FailOnBadRPC = true | false
+%%%
+%%% @doc Same as <code>app_node/2</code> only the <code>FailOnBadRPC</code>
+%%%      argument will determine if the search for a candidate node should
+%%%      stop or not if <code>badrpc</code> is received at some point. 
+%%%
+app_node(App, Candidates, FailOnBadRPC) ->
+    app_node(App, Candidates, FailOnBadRPC, []).
+
+%%% @spec app_node(App, Candidates, FailOnBadRPC, Cookie) -> NodeName
+%%%
+%%%      App = atom() 
+%%%      Candidates = [NodeName]
+%%%      NodeName = atom() 
+%%%      FailOnBadRPC = true | false
+%%%      Cookie = atom()
+%%%
+%%% @doc Same as <code>app_node/2</code> only the <code>FailOnBadRPC</code>
+%%%      argument will determine if the search for a candidate node should
+%%%      stop or not if <code>badrpc</code> is received at some point. 
+%%%      The cookie on the client node will be set to <code>Cookie</code>
+%%%      for this rpc operation (use to match the server node cookie).
+%%%
+app_node(App, [], _, _) -> 
+    ct:fail({application_not_running, App});
+
+%% Variable _Candidates is a workaround for the strange edoc behavior
+%% of creating the spec:  app_node(App, Nodes::Candidates) -> NodeName
+%% if it does not exist.
+app_node(App, _Candidates = [CandidateNode | Nodes], FailOnBadRPC, Cookie) -> 
+    Cookie0 = set_the_cookie(Cookie),
+    Result = rpc:call(CandidateNode, application, which_applications, []),
+    set_the_cookie(Cookie0),
+    case Result of
+	{badrpc,Reason} when FailOnBadRPC == true ->
+	    ct:fail({Reason,CandidateNode});
+	{badrpc,_} when FailOnBadRPC == false ->
+	    app_node(App, Nodes, FailOnBadRPC);
+	Apps ->    
+	    case lists:keysearch(App, 1, Apps) of
+		{value, _} ->
+		    CandidateNode;
+		_ ->
+		    app_node(App, Nodes, FailOnBadRPC)
+	    end
+    end.
+
+%%% @spec call(Node, Module, Function, Args) -> term() | {badrpc, Reason}
+%%% 
+%%% @doc Same as call(Node, Module, Function, Args, infinity)
+%%%
+call(Node, Module, Function, Args) ->
+    call(Node, Module, Function, Args, infinity, []). 
+
+%%% @spec call(Node, Module, Function, Args, TimeOut) -> 
+%%%                                              term() | {badrpc, Reason}
+%%%      Node = NodeName | {Fun, FunArgs} 
+%%%      Fun = fun()
+%%%      FunArgs =  term()
+%%%      NodeName = atom() 
+%%%      Module = atom() 
+%%%      Function = atom()  
+%%%      Args = [term()]
+%%%      Reason = timeout | term() 
+%%%
+%%% @doc Evaluates apply(Module, Function, Args) on the node Node.
+%%% Returns whatever Function returns or {badrpc, Reason} if the
+%%% remote procedure call fails. If Node is {Fun, FunArgs} applying
+%%% Fun to FunArgs should return a node name.
+call(Node, Module, Function, Args, TimeOut) ->
+    call(Node, Module, Function, Args, TimeOut, []).
+
+%%% @spec call(Node, Module, Function, Args, TimeOut, Cookie) -> 
+%%%                                              term() | {badrpc, Reason}
+%%%      Node = NodeName | {Fun, FunArgs} 
+%%%      Fun = fun()
+%%%      FunArgs =  term()
+%%%      NodeName = atom() 
+%%%      Module = atom() 
+%%%      Function = atom()  
+%%%      Args = [term()]
+%%%      Reason = timeout | term() 
+%%%      Cookie = atom()
+%%%
+%%% @doc Evaluates apply(Module, Function, Args) on the node Node.
+%%% Returns whatever Function returns or {badrpc, Reason} if the
+%%% remote procedure call fails. If Node is {Fun, FunArgs} applying
+%%% Fun to FunArgs should return a node name. 
+%%% The cookie on the client node will be set to <code>Cookie</code>
+%%% for this rpc operation (use to match the server node cookie).
+call({Fun, FunArgs}, Module, Function, Args, TimeOut, Cookie) ->
+    Node = Fun(FunArgs),
+    call(Node, Module, Function, Args, TimeOut, Cookie);
+call(Node, Module, Function, Args, TimeOut, Cookie) when is_atom(Node) ->
+    Cookie0 = set_the_cookie(Cookie),
+    Result = rpc:call(Node, Module, Function, Args, TimeOut),
+    set_the_cookie(Cookie0),
+    Result.    
+
+%%% @spec cast(Node, Module, Function, Args) -> ok
+%%%      Node = NodeName | {Fun, FunArgs} 
+%%%      Fun = fun()
+%%%      FunArgs =  term()
+%%%      NodeName = atom() 
+%%%      Module = atom()  
+%%%      Function = atom() 
+%%%      Args = [term()]
+%%%      Reason = timeout | term() 
+%%%
+%%% @doc Evaluates apply(Module, Function, Args) on the node Node.
+%%% No response is delivered and the process which makes the call is
+%%% not suspended until the evaluation is compleated as in the case of
+%%% call/[3,4]. If Node is {Fun, FunArgs} applying
+%%% Fun to FunArgs should return a node name.
+cast(Node, Module, Function, Args) ->
+    cast(Node, Module, Function, Args, []).
+
+%%% @spec cast(Node, Module, Function, Args, Cookie) -> ok
+%%%      Node = NodeName | {Fun, FunArgs} 
+%%%      Fun = fun()
+%%%      FunArgs =  term()
+%%%      NodeName = atom() 
+%%%      Module = atom()  
+%%%      Function = atom() 
+%%%      Args = [term()]
+%%%      Reason = timeout | term() 
+%%%      Cookie = atom()
+%%%
+%%% @doc Evaluates apply(Module, Function, Args) on the node Node.
+%%% No response is delivered and the process which makes the call is
+%%% not suspended until the evaluation is compleated as in the case of
+%%% call/[3,4]. If Node is {Fun, FunArgs} applying
+%%% Fun to FunArgs should return a node name. 
+%%% The cookie on the client node will be set to <code>Cookie</code>
+%%% for this rpc operation (use to match the server node cookie).
+cast({Fun, FunArgs}, Module, Function, Args, Cookie) ->
+    Node = Fun(FunArgs),
+    cast(Node, Module, Function, Args, Cookie);
+cast(Node, Module, Function, Args, Cookie) when is_atom(Node) ->
+    Cookie0 = set_the_cookie(Cookie),
+    true = rpc:cast(Node, Module, Function, Args),
+    set_the_cookie(Cookie0),
+    ok.
+
+
+%%%---------- Internal -----------
+
+%%% @hidden
+set_the_cookie([]) ->
+    [];
+set_the_cookie(Cookie) ->
+    Cookie0 = erlang:get_cookie(),
+    erlang:set_cookie(node(),Cookie),
+    Cookie0.
diff --git a/lib/common_test/src/ct_run.erl b/lib/common_test/src/ct_run.erl
new file mode 100644
index 0000000000..a1e2358578
--- /dev/null
+++ b/lib/common_test/src/ct_run.erl
@@ -0,0 +1,1812 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 2004-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%
+%%
+
+%%% @doc Common Test Framework test execution control module.
+%%%
+%%% <p>This module exports functions for installing and running tests
+%%% withing the Common Test Framework.</p>
+
+-module(ct_run).
+
+
+%% Script interface
+-export([script_start/0,script_usage/0]).
+
+%% User interface
+-export([install/1,install/2,run/1,run/2,run/3,run_test/1,
+	 run_testspec/1,step/3,step/4,refresh_logs/1]).
+
+
+%% Exported for VTS
+-export([run_make/3,do_run/3,tests/1,tests/2,tests/3]).
+
+
+%% Misc internal functions
+-export([variables_file_name/1,script_start1/2,run_test1/1]).
+
+-include("ct_event.hrl").
+-include("ct_util.hrl").
+
+-define(abs(Name), filename:absname(Name)).
+-define(testdir(Name, Suite), ct_util:get_testdir(Name, Suite)).
+
+%%%-----------------------------------------------------------------
+%%% @spec script_start() -> void()
+%%%
+%%% @doc Start tests via the run_test script.
+%%% 
+%%% <p>Example:<br/><code>./run_test -config config.ctc -dir
+%%% $TEST_DIR</code></p>
+%%%
+%%% <p>Example:<br/><code>./run_test -config config.ctc -suite
+%%% $SUITE_PATH/$SUITE_NAME [-case $CASE_NAME]</code></p>
+%%%
+script_start() ->
+    process_flag(trap_exit, true),
+    Args = merge_arguments(init:get_arguments()),
+    Tracing = start_trace(Args),
+    Res = 
+	case ct_repeat:loop_test(script, Args) of
+	    false ->	    
+		{ok,Cwd} = file:get_cwd(),
+		CTVsn = 
+		    case filename:basename(code:lib_dir(common_test)) of
+			CTBase when is_list(CTBase) ->
+			    case string:tokens(CTBase, "-") of
+				["common_test",Vsn] -> " v"++Vsn;
+				_ -> ""
+			    end
+		    end,
+		io:format("~nCommon Test~s starting (cwd is ~s)~n~n", [CTVsn,Cwd]),
+		Self = self(),
+		Pid = spawn_link(fun() -> script_start1(Self, Args) end),
+	        receive 
+		    {'EXIT',Pid,Reason} ->
+			case Reason of
+			    {user_error,What} ->
+				io:format("\nTest run failed!\nReason: ~p\n\n", [What]),
+				{error,What};
+			    _ ->
+				io:format("Test run crashed! This could be an internal error "
+					  "- please report!\n\n"
+					  "~p\n\n", [Reason]),
+				{error,Reason}				
+			end;
+		    {Pid,{error,Reason}} ->
+			io:format("\nTest run failed! Reason:\n~p\n\n",[Reason]),
+			{error,Reason};
+		    {Pid,Result} ->
+			Result
+		end;
+	    Result ->
+		Result
+	end,
+    stop_trace(Tracing),
+    Res.
+
+script_start1(Parent, Args) ->
+    case lists:keymember(preload, 1, Args) of
+	true -> preload();
+	false -> ok
+    end,
+
+    VtsOrShell = 
+	case lists:keymember(vts, 1, Args) of
+	    true -> 
+		vts;
+	    false ->
+		case lists:keymember(shell, 1, Args) of
+		    true -> shell;
+		    false -> false
+		end
+	end,
+    LogDir =
+	case lists:keysearch(logdir, 1, Args) of
+	    {value,{logdir,[LogD]}} -> LogD;
+	    false -> "."
+	end,
+    EvHandlers =	
+	case lists:keysearch(event_handler, 1, Args) of
+	    {value,{event_handler,Handlers}} -> 
+		lists:map(fun(H) -> {list_to_atom(H),[]} end, Handlers);
+	    false -> 
+		[]
+	end,
+    Cover = 
+	case lists:keysearch(cover, 1, Args) of
+	    {value,{cover,CoverFile}} -> 
+		{cover,?abs(CoverFile)};
+	    false -> 
+		false
+	end,
+
+    case lists:keysearch(ct_decrypt_key, 1, Args) of
+	{value,{_,[DecryptKey]}} ->
+	    application:set_env(common_test, decrypt, {key,DecryptKey});
+	false ->
+	    case lists:keysearch(ct_decrypt_file, 1, Args) of
+		{value,{_,[DecryptFile]}} ->
+		    application:set_env(common_test, decrypt, 
+					{file,filename:absname(DecryptFile)});
+		false ->
+		    application:unset_env(common_test, decrypt)
+	    end
+    end,
+
+    case lists:keysearch(no_auto_compile, 1, Args) of
+	{value,_} ->
+	    application:set_env(common_test, auto_compile, false);
+	false ->
+	    application:set_env(common_test, auto_compile, true),
+
+	    InclDirs =
+		case lists:keysearch(include,1,Args) of
+		    {value,{include,Incl}} when is_list(hd(Incl)) ->
+			Incl;		    
+		    {value,{include,Incl}} when is_list(Incl) ->
+			[Incl];
+		    false ->
+			[]
+		end,
+	    case os:getenv("CT_INCLUDE_PATH") of
+		false ->
+		    application:set_env(common_test, include, InclDirs);
+		CtInclPath ->
+		    InclDirs1 = string:tokens(CtInclPath,[$:,$ ,$,]),
+		    application:set_env(common_test, include, InclDirs1++InclDirs)
+	    end
+    end,
+
+    case lists:keysearch(basic_html, 1, Args) of
+	{value,_} ->
+	    application:set_env(common_test, basic_html, true);
+	false ->
+	    application:set_env(common_test, basic_html, false)
+    end,
+
+    Result =
+	case lists:keysearch(refresh_logs, 1, Args) of
+	    {value,{refresh_logs,Refresh}} ->
+		LogDir1 = case Refresh of
+			      [] -> LogDir;
+			      [RefreshDir] -> ?abs(RefreshDir)
+			  end,
+		{ok,Cwd} = file:get_cwd(),
+		file:set_cwd(LogDir1),
+		timer:sleep(500),		% give the shell time to print version etc
+		io:nl(),
+		case catch ct_logs:make_all_suites_index(refresh) of
+		    {'EXIT',ASReason} ->
+			file:set_cwd(Cwd),
+			{error,{all_suites_index,ASReason}};
+		    _ ->
+			case catch ct_logs:make_all_runs_index(refresh) of
+			    {'EXIT',ARReason} ->
+				file:set_cwd(Cwd),
+				{error,{all_runs_index,ARReason}};
+			    _ ->
+				file:set_cwd(Cwd),
+				io:format("Logs in ~s refreshed!~n~n", [LogDir1]),
+				timer:sleep(500), % time to flush io before quitting
+				ok
+			end
+		end;
+	    false ->    
+		case lists:keysearch(ct_config, 1, Args) of
+		    {value,{ct_config,ConfigFiles}} ->
+			case lists:keysearch(spec, 1, Args) of
+			    false ->
+				case get_configfiles(ConfigFiles, [], LogDir,
+						     EvHandlers) of
+				    ok ->
+					script_start2(VtsOrShell, ConfigFiles,
+						      EvHandlers, Args, LogDir,
+						      Cover);
+				    Error ->
+					Error
+				end;
+			    _ ->
+				script_start2(VtsOrShell, ConfigFiles,
+					      EvHandlers, Args, LogDir, Cover)
+			end;
+		    false ->
+			case install([{config,[]},
+				      {event_handler,EvHandlers}],
+				     LogDir) of
+			    ok ->
+				script_start2(VtsOrShell, [], EvHandlers,
+					      Args, LogDir, Cover);
+			    Error ->
+				Error
+			end
+		end
+	end,
+    Parent ! {self(), Result}.
+
+get_configfiles([File|Files], Acc, LogDir, EvHandlers) ->
+    case filelib:is_file(File) of
+	true ->
+	    get_configfiles(Files, [?abs(File)|Acc],
+			    LogDir, EvHandlers);
+	false ->
+	    {error,{cant_read_config_file,File}}
+    end;
+get_configfiles([], Acc, LogDir, EvHandlers) ->
+    install([{config,lists:reverse(Acc)}, {event_handler,EvHandlers}], LogDir).
+
+script_start2(false, ConfigFiles, EvHandlers, Args, LogDir, Cover) ->
+    case lists:keysearch(spec, 1, Args) of
+	{value,{spec,[]}} ->
+	    {error,no_testspec_specified};
+	{value,{spec,Specs}} ->
+	    Relaxed = lists:keymember(allow_user_terms, 1, Args),
+	    %% using testspec as input for test
+	    case catch ct_testspec:collect_tests_from_file(Specs, Relaxed) of
+		{error,Reason} ->
+		    {error,Reason};
+		TS ->
+		    {LogDir1,TSCoverFile,ConfigFiles1,EvHandlers1,Include1} = 
+			get_data_for_node(TS,node()),
+		    UserInclude =
+			case application:get_env(common_test, include) of
+			    {ok,Include} -> Include++Include1;
+			    _ -> Include1
+			end,
+		    application:set_env(common_test, include, UserInclude),
+		    LogDir2 = which_logdir(LogDir,LogDir1),
+		    CoverOpt = case {Cover,TSCoverFile} of
+				   {false,undef} -> [];
+				   {_,undef} ->     [Cover];
+				   {false,_} ->     [{cover,TSCoverFile}]
+			       end,
+		    case get_configfiles(ConfigFiles++ConfigFiles1,
+					 [], LogDir2,
+					 EvHandlers++EvHandlers1) of
+			ok ->
+			    {Run,Skip} = ct_testspec:prepare_tests(TS, node()),
+			    do_run(Run, Skip, CoverOpt, Args, LogDir2);
+			Error ->
+			    Error
+		    end
+	    end;
+	false ->
+	    script_start3(false, ConfigFiles, EvHandlers, Args, LogDir, Cover)
+    end;
+script_start2(VtsOrShell, ConfigFiles, EvHandlers, Args, LogDir, Cover) ->
+    script_start3(VtsOrShell, ConfigFiles, EvHandlers, Args, LogDir, Cover).
+
+script_start3(VtsOrShell, ConfigFiles, EvHandlers, Args, LogDir, Cover) ->
+    case lists:keysearch(dir, 1, Args) of
+	{value,{dir,[]}} ->
+	    {error,no_dir_specified};
+	{value,{dir,Dirs}} ->
+	    script_start4(VtsOrShell, ConfigFiles, EvHandlers, tests(Dirs),
+			  Cover, Args, LogDir);
+	false ->
+	    case lists:keysearch(suite, 1, Args) of
+		{value,{suite,[]}} ->
+		    {error,no_suite_specified};
+		{value,{suite,Suites}} ->
+		    StepOrCover =
+			case lists:keysearch(step, 1, Args) of
+			    {value,Step} -> Step;
+			    false -> Cover
+			end,
+		    S2M = fun(S) ->
+				  {filename:dirname(S),
+				   list_to_atom(
+				     filename:rootname(filename:basename(S)))}
+			  end,
+		    DirMods = lists:map(S2M, Suites),
+		    {Specified,GroupsAndCases} =
+			case {lists:keysearch(group, 1, Args),
+			      lists:keysearch('case', 1, Args)} of
+			    {{value,{_,Gs}},{value,{_,Cs}}} -> {true,Gs++Cs};
+			    {{value,{_,Gs}},_}              -> {true,Gs};
+			    {_,{value,{_,Cs}}}              -> {true,Cs};
+			    _                               -> {false,[]}
+			end,
+		    if Specified, length(GroupsAndCases) == 0 ->
+			    {error,no_case_or_group_specified};
+		       Specified, length(DirMods) > 1 ->
+			    {error,multiple_suites_and_cases};
+		       length(GroupsAndCases) > 0, length(DirMods) == 1 ->
+			    GsAndCs = lists:map(fun(C) -> list_to_atom(C) end, 
+						GroupsAndCases),
+			    script_start4(VtsOrShell, ConfigFiles, EvHandlers,
+					  tests(DirMods, GsAndCs),
+					  StepOrCover, Args, LogDir);
+		       not Specified, length(DirMods) > 0 ->
+			    script_start4(VtsOrShell, ConfigFiles, EvHandlers,
+					  tests(DirMods), 
+					  StepOrCover, Args, LogDir);
+		       true ->
+			    {error,incorrect_suite_and_case_options}
+		    end;
+		false when VtsOrShell=/=false ->
+		    script_start4(VtsOrShell, ConfigFiles, EvHandlers,
+				  [], Cover, Args, LogDir);
+		false ->
+		    script_usage(),
+		    {error,incorrect_usage}
+	    end
+    end.
+
+script_start4(vts, ConfigFiles, EvHandlers, Tests, false, _Args, LogDir) ->
+    vts:init_data(ConfigFiles, EvHandlers, ?abs(LogDir), Tests);
+script_start4(shell, ConfigFiles, EvHandlers, _Tests, false, Args, LogDir) ->
+    Opts = [{config,ConfigFiles},{event_handler,EvHandlers}],
+    if ConfigFiles == [] ->
+	    ok;
+       true ->
+	    io:format("\nInstalling: ~p\n\n", [ConfigFiles])
+    end,
+    case install(Opts) of
+	ok ->
+	    ct_util:start(interactive, LogDir),
+	    log_ts_names(Args),
+	    io:nl(),
+	    ok;
+	Error ->
+	    Error
+    end;
+script_start4(vts, _CfgFs, _EvHs, _Tests, _Cover={cover,_}, _Args, _LogDir) ->
+    %% Add support later (maybe).
+    script_usage(),
+    erlang:halt();
+script_start4(shell, _CfgFs, _EvHs, _Tests, _Cover={cover,_}, _Args, _LogDir) ->
+    %% Add support later (maybe).
+    script_usage();
+script_start4(false, _CfgFs, _EvHs, Tests, Cover={cover,_}, Args, LogDir) ->
+    do_run(Tests, [], [Cover], Args, LogDir);
+script_start4(false, _ConfigFiles, _EvHandlers, Tests, false, Args, LogDir) ->
+    do_run(Tests, [], [], Args, LogDir);
+script_start4(false, _ConfigFiles, _EvHandlers, Test, Step, Args, LogDir) ->
+    do_run(Test, [], [Step], Args, LogDir);
+script_start4(vts, _ConfigFiles, _EvHandlers, _Test, _Step, _Args, _LogDir) ->
+    script_usage(),
+    erlang:halt();
+script_start4(shell, _ConfigFiles, _EvHandlers, _Test, _Step, _Args, _LogDir) ->
+    script_usage().
+
+%%%-----------------------------------------------------------------
+%%% @spec script_usage() -> ok
+%%% @doc Print script usage information for <code>run_test</code>.
+script_usage() ->
+    io:format("\n\nUsage:\n\n"),
+    io:format("Run tests in web based GUI:\n\n"
+	      "\trun_test -vts [-browser Browser]"
+	      "\n\t[-config ConfigFile1 ConfigFile2 .. ConfigFileN]"
+	      "\n\t[-decrypt_key Key] | [-decrypt_file KeyFile]"
+	      "\n\t[-dir TestDir1 TestDir2 .. TestDirN] |"
+	      "\n\t[-suite Suite [-case Case]]"
+	      "\n\t[-include InclDir1 InclDir2 .. InclDirN]" 
+	      "\n\t[-no_auto_compile]"
+	      "\n\t[-basic_html]\n\n"),
+    io:format("Run tests from command line:\n\n"
+	      "\trun_test [-dir TestDir1 TestDir2 .. TestDirN] |"
+	      "\n\t[-suite Suite1 Suite2 .. SuiteN [-case Case1 Case2 .. CaseN]]"
+	      "\n\t[-step [config | keep_inactive]]"
+	      "\n\t[-config ConfigFile1 ConfigFile2 .. ConfigFileN]"
+	      "\n\t[-decrypt_key Key] | [-decrypt_file KeyFile]"
+	      "\n\t[-logdir LogDir]"
+	      "\n\t[-silent_connections [ConnType1 ConnType2 .. ConnTypeN]]"
+	      "\n\t[-stylesheet CSSFile]"
+	      "\n\t[-cover CoverCfgFile]"
+	      "\n\t[-event_handler EvHandler1 EvHandler2 .. EvHandlerN]"
+	      "\n\t[-include InclDir1 InclDir2 .. InclDirN]" 
+	      "\n\t[-no_auto_compile]"
+	      "\n\t[-basic_html]" 
+	      "\n\t[-repeat N [-force_stop]] |" 
+	      "\n\t[-duration HHMMSS [-force_stop]] |"
+	      "\n\t[-until [YYMoMoDD]HHMMSS [-force_stop]]\n\n"),
+    io:format("Run tests using test specification:\n\n"
+	      "\trun_test -spec TestSpec1 TestSpec2 .. TestSpecN"
+	      "\n\t[-config ConfigFile1 ConfigFile2 .. ConfigFileN]"
+	      "\n\t[-decrypt_key Key] | [-decrypt_file KeyFile]"
+	      "\n\t[-logdir LogDir]"
+	      "\n\t[-allow_user_terms]"
+	      "\n\t[-silent_connections [ConnType1 ConnType2 .. ConnTypeN]]"
+	      "\n\t[-stylesheet CSSFile]"
+	      "\n\t[-cover CoverCfgFile]"
+	      "\n\t[-event_handler EvHandler1 EvHandler2 .. EvHandlerN]"
+	      "\n\t[-include InclDir1 InclDir2 .. InclDirN]" 
+	      "\n\t[-no_auto_compile]"
+	      "\n\t[-basic_html]" 
+	      "\n\t[-repeat N [-force_stop]] |" 
+	      "\n\t[-duration HHMMSS [-force_stop]] |"
+	      "\n\t[-until [YYMoMoDD]HHMMSS [-force_stop]]\n\n"),
+    io:format("Refresh the HTML index files:\n\n"
+	      "\trun_test -refresh_logs [LogDir]"
+	      "[-logdir LogDir] "
+	      "[-basic_html]\n\n"),
+    io:format("Run CT in interactive mode:\n\n"
+	      "\trun_test -shell"
+	      "\n\t[-config ConfigFile1 ConfigFile2 .. ConfigFileN]"
+	      "\n\t[-decrypt_key Key] | [-decrypt_file KeyFile]\n\n").
+	      
+
+%%%-----------------------------------------------------------------
+%%% @hidden
+%%% @equiv ct:install/1
+install(Opts) ->
+    install(Opts, ".").
+
+install(Opts, LogDir) ->
+    case application:get_env(common_test, decrypt) of
+	{ok,_} ->
+	    ok;
+	_ ->
+	    case lists:keysearch(decrypt, 1, Opts) of
+		{value,{_,KeyOrFile}} ->
+		    application:set_env(common_test, decrypt, KeyOrFile);
+		false ->
+		    application:unset_env(common_test, decrypt)
+	    end
+    end,
+    case whereis(ct_util_server) of
+	undefined ->
+	    VarFile = variables_file_name(LogDir),
+	    case file:open(VarFile, [write]) of
+		{ok,Fd} ->
+		    [io:format(Fd, "~p.\n", [Opt]) || Opt <- Opts],
+		    file:close(Fd),
+		    ok;
+		{error,Reason} -> 
+		    io:format("CT failed to install configuration data. Please "
+			      "verify that the log directory exists and that "
+			      "write permission is set.\n\n", []),
+		    {error,{VarFile,Reason}}
+	    end;
+	_ ->
+	    io:format("It is not possible to install CT while running "
+		      "in interactive mode.\n"
+		      "To exit this mode, run ct:stop_interactive().\n"
+		      "To enter the interactive mode again, "
+		      "run ct:start_interactive()\n\n", []),
+	    {error,interactive_mode}
+    end.
+
+variables_file_name(Dir) ->
+    filename:join(Dir, "variables-"++atom_to_list(node())).
+
+%%%-----------------------------------------------------------------
+%%% @hidden
+%%% @equiv ct:run_test/1
+
+%%   Opts = [OptTuples]
+%%   OptTuples = {config,CfgFiles} | {dir,TestDirs} | {suite,Suites} |
+%%               {testcase,Cases} | {spec,TestSpecs} | {allow_user_terms,Bool} |
+%%               {logdir,LogDir} | {cover,CoverSpecFile} | {step,StepOpts} |
+%%               {silent_connections,Conns} | {event_handler,EventHandlers} | 
+%%               {include,InclDirs} | {auto_compile,Bool} | 
+%%               {repeat,N} | {duration,DurTime} | {until,StopTime} | {force_stop,Bool} |
+%%               {decrypt,KeyOrFile}
+
+run_test(Opt) when is_tuple(Opt) ->
+    run_test([Opt]);
+
+run_test(Opts) when is_list(Opts) ->
+    case lists:keysearch(refresh_logs, 1, Opts) of
+	{value,{_,RefreshDir}} ->
+	    refresh_logs(?abs(RefreshDir)),
+	    ok;
+	false ->
+	    Tracing = start_trace(Opts),
+	    {ok,Cwd} = file:get_cwd(),
+	    io:format("~nCommon Test starting (cwd is ~s)~n~n", [Cwd]),	    
+	    Res =
+		case ct_repeat:loop_test(func, Opts) of
+		    false ->
+			case catch run_test1(Opts) of
+			    {'EXIT',Reason} -> 
+				file:set_cwd(Cwd),
+				{error,Reason};
+			    Result -> 
+				Result
+			end;
+		    Result ->
+			Result
+		end,
+	    stop_trace(Tracing),
+	    Res
+    end.
+
+run_test1(Opts) ->
+    LogDir =
+	case lists:keysearch(logdir, 1, Opts) of
+	    {value,{_,LD}} when is_list(LD) -> LD;
+	    false -> "."
+	end,
+    CfgFiles =
+	case lists:keysearch(config, 1, Opts) of
+	    {value,{_,Files=[File|_]}} when is_list(File) ->
+		Files;
+	    {value,{_,File=[C|_]}} when is_integer(C) ->
+		[File];
+	    {value,{_,[]}} ->
+		[];
+	    false ->
+		[]
+	end,
+    EvHandlers =
+	case lists:keysearch(event_handler, 1, Opts) of
+	    {value,{_,H}} when is_atom(H) ->
+		[{H,[]}];
+	    {value,{_,H}} ->
+		Hs =
+		    if is_tuple(H) -> [H];
+		       is_list(H) -> H;
+		       true -> []
+		    end,
+		lists:flatten(
+		  lists:map(fun(EH) when is_atom(EH) ->
+				    {EH,[]};
+			       ({HL,Args}) when is_list(HL) ->
+				    [{EH,Args} || EH <- HL];
+			       ({EH,Args}) when is_atom(EH) ->
+				    {EH,Args};
+			       (_) ->
+				    []
+			    end, Hs));
+	    _ ->
+		[]
+	end,
+    SilentConns =
+	case lists:keysearch(silent_connections, 1, Opts) of
+	    {value,{_,all}} ->
+		[];
+	    {value,{_,Conns}} ->
+		Conns;
+	    _ ->
+		undefined
+	end,
+    Cover = 
+	case lists:keysearch(cover, 1, Opts) of
+	    {value,{_,CoverFile}} ->
+		[{cover,?abs(CoverFile)}];
+	    _ ->
+		[]
+	end,
+    Include =
+	case lists:keysearch(auto_compile, 1, Opts) of
+	    {value,{auto_compile,ACBool}} ->
+		application:set_env(common_test, auto_compile, ACBool),
+		[];
+	    _ ->
+		application:set_env(common_test, auto_compile, true),		
+		InclDirs =
+		    case lists:keysearch(include, 1, Opts) of
+			{value,{include,Incl}}  when is_list(hd(Incl)) ->
+			    Incl;		    
+			{value,{include,Incl}} when is_list(Incl) ->
+			    [Incl];
+			false ->
+			    []
+		    end,
+		case os:getenv("CT_INCLUDE_PATH") of
+		    false ->
+			application:set_env(common_test, include, InclDirs),
+			InclDirs;
+		    CtInclPath ->
+			InclDirs1 = string:tokens(CtInclPath, [$:,$ ,$,]),
+			AllInclDirs = InclDirs1++InclDirs,
+			application:set_env(common_test, include, AllInclDirs),
+			AllInclDirs
+		end
+	end,
+
+    case lists:keysearch(decrypt, 1, Opts) of
+	{value,{_,Key={key,_}}} ->
+	    application:set_env(common_test, decrypt, Key);
+	{value,{_,{file,KeyFile}}} ->
+	    application:set_env(common_test, decrypt, {file,filename:absname(KeyFile)});
+	false ->
+	    application:unset_env(common_test, decrypt)
+    end,
+
+    case lists:keysearch(basic_html, 1, Opts) of
+	{value,{basic_html,BasicHtmlBool}} ->
+	    application:set_env(common_test, basic_html, BasicHtmlBool);
+	_ ->
+	    application:set_env(common_test, basic_html, false)
+    end,
+
+    case lists:keysearch(spec, 1, Opts) of
+	{value,{_,Specs}} ->
+	    Relaxed =
+		case lists:keysearch(allow_user_terms, 1, Opts) of
+		    {value,{_,true}} -> true;
+		    _ -> false
+		end,	    
+	    %% using testspec(s) as input for test
+	    run_spec_file(LogDir, CfgFiles, EvHandlers, Include, Specs, Relaxed, Cover,
+			 replace_opt([{silent_connections,SilentConns}], Opts));
+	false ->
+	    case lists:keysearch(prepared_tests, 1, Opts) of
+		{value,{_,{Run,Skip},Specs}} ->	% use prepared tests
+		    run_prepared(LogDir, CfgFiles, EvHandlers,
+				 Run, Skip, Cover,
+				 replace_opt([{silent_connections,SilentConns},
+					      {spec,Specs}],Opts));
+		false ->		% use dir|suite|case
+		    StepOrCover =
+			case lists:keysearch(step, 1, Opts) of
+			    {value,Step} -> [Step];
+			    false -> Cover
+			end,
+		    run_dir(LogDir, CfgFiles, EvHandlers, StepOrCover,
+			    replace_opt([{silent_connections,SilentConns}], Opts))
+	    end
+    end.
+
+replace_opt([O={Key,_Val}|Os], Opts) ->
+    [O | replace_opt(Os, lists:keydelete(Key, 1, Opts))];
+replace_opt([], Opts) ->
+    Opts.
+
+run_spec_file(LogDir, CfgFiles, EvHandlers, Include, Specs, Relaxed, Cover, Opts) ->
+    Specs1 = case Specs of
+		 [X|_] when is_integer(X) -> [Specs];
+		 _ -> Specs
+	     end,
+    AbsSpecs = lists:map(fun(SF) -> ?abs(SF) end, Specs1), 
+    log_ts_names(AbsSpecs),
+    case catch ct_testspec:collect_tests_from_file(AbsSpecs, Relaxed) of
+	{error,CTReason} ->
+	    exit(CTReason);
+	TS ->
+	    {LogDir1,TSCoverFile,CfgFiles1,EvHandlers1,Include1} = 
+		get_data_for_node(TS, node()),
+	    application:set_env(common_test, include, Include++Include1),
+	    LogDir2 = which_logdir(LogDir, LogDir1),
+	    CoverOpt = case {Cover,TSCoverFile} of
+			   {[],undef} -> [];
+			   {_,undef} ->  Cover;
+			   {[],_} ->     [{cover,TSCoverFile}]
+		       end,
+	    case get_configfiles(CfgFiles++CfgFiles1, [], LogDir2,
+				 EvHandlers++EvHandlers1) of
+		ok ->
+		    {Run,Skip} = ct_testspec:prepare_tests(TS, node()),
+		    do_run(Run, Skip, CoverOpt,
+			   replace_opt([{spec,AbsSpecs}], Opts),
+			   LogDir2);
+		{error,GCFReason} ->
+		    exit(GCFReason)
+	    end
+    end.
+
+run_prepared(LogDir, CfgFiles, EvHandlers, Run, Skip, Cover, Opts) ->
+    case get_configfiles(CfgFiles, [], LogDir, EvHandlers) of
+	ok ->
+	    do_run(Run, Skip, Cover, Opts, LogDir);
+	{error,Reason} ->
+	    exit(Reason)
+    end.    
+
+run_dir(LogDir, CfgFiles, EvHandlers, StepOrCover, Opts) ->
+    AbsCfgFiles = 
+	lists:map(fun(F) -> 
+			  AbsName = ?abs(F),
+			  case filelib:is_file(AbsName) of
+			      true -> AbsName;
+			      false -> exit({no_such_file,AbsName})
+			  end
+		  end, CfgFiles), 
+
+    case install([{config,AbsCfgFiles},{event_handler,EvHandlers}], LogDir) of
+	ok -> ok;
+	{error,IReason} -> exit(IReason)
+    end,
+    case lists:keysearch(dir,1,Opts) of
+	{value,{_,Dirs=[Dir|_]}} when not is_integer(Dir),
+	                              length(Dirs)>1 ->
+	    %% multiple dirs (no suite)
+	    do_run(tests(Dirs), [], StepOrCover, Opts, LogDir);
+	false ->				% no dir
+	    %% fun for converting suite name to {Dir,Mod} tuple
+	    S2M = fun(S) when is_list(S) ->
+			  {filename:dirname(S),
+			   list_to_atom(filename:rootname(filename:basename(S)))};
+		     (A) ->
+			  {".",A}
+		  end,
+	    case lists:keysearch(suite, 1, Opts) of
+		{value,{_,Suite}} when is_integer(hd(Suite)) ; is_atom(Suite) ->
+		    {Dir,Mod} = S2M(Suite),
+		    case listify(proplists:get_value(group, Opts, [])) ++
+			 listify(proplists:get_value(testcase, Opts, [])) of
+			[] ->
+			    do_run(tests(Dir, listify(Mod)), [], StepOrCover, Opts, LogDir);
+			GsAndCs ->
+			    do_run(tests(Dir, Mod, GsAndCs), [], StepOrCover, Opts, LogDir)
+		    end;
+		{value,{_,Suites}} ->
+		    do_run(tests(lists:map(S2M, Suites)), [], StepOrCover, Opts, LogDir);
+		_ ->
+		    exit(no_tests_specified)
+	    end;		   
+	{value,{_,Dir}} ->
+	    case lists:keysearch(suite, 1, Opts) of
+		{value,{_,Suite}} when is_integer(hd(Suite)) ; is_atom(Suite) ->
+		    Mod = if is_atom(Suite) -> Suite; 
+			     true -> list_to_atom(Suite) 
+			  end,
+		    case listify(proplists:get_value(group, Opts, [])) ++
+			 listify(proplists:get_value(testcase, Opts, [])) of
+			[] ->
+			    do_run(tests(Dir, listify(Mod)), [], StepOrCover, Opts, LogDir);
+			GsAndCs ->
+			    do_run(tests(Dir, Mod, GsAndCs), [], StepOrCover, Opts, LogDir)
+		    end;
+		{value,{_,Suites=[Suite|_]}} when is_list(Suite) ->
+		    Mods = lists:map(fun(Str) -> list_to_atom(Str) end, Suites),
+		    do_run(tests(delistify(Dir), Mods), [], StepOrCover, Opts, LogDir);		    
+		{value,{_,Suites}} ->
+		    do_run(tests(delistify(Dir), Suites), [], StepOrCover, Opts, LogDir);		    
+	        false ->			% no suite, only dir
+		    do_run(tests(listify(Dir)), [], StepOrCover, Opts, LogDir)
+	    end   
+    end.
+
+%%%-----------------------------------------------------------------
+%%% @hidden
+%%%
+
+%% using testspec(s) as input for test
+run_testspec(TestSpec) ->
+    {ok,Cwd} = file:get_cwd(),
+    io:format("~nCommon Test starting (cwd is ~s)~n~n", [Cwd]),
+    case catch run_testspec1(TestSpec) of
+	{'EXIT',Reason} -> 
+	    file:set_cwd(Cwd),
+	    {error,Reason};
+	Result -> 
+	    Result
+    end.
+
+run_testspec1(TestSpec) ->
+    case ct_testspec:collect_tests_from_list(TestSpec,false) of
+	{error,CTReason} ->
+	    exit(CTReason);
+	TS ->
+	    {LogDir,TSCoverFile,CfgFiles,EvHandlers,Include} = 
+		get_data_for_node(TS,node()),
+	    case os:getenv("CT_INCLUDE_PATH") of
+		false ->
+		    application:set_env(common_test, include, Include);
+		CtInclPath ->
+		    EnvInclude = string:tokens(CtInclPath, [$:,$ ,$,]),
+		    application:set_env(common_test, include, EnvInclude++Include)
+	    end,
+	    CoverOpt = if TSCoverFile == undef -> [];
+			  true -> [{cover,TSCoverFile}]
+		       end,
+	    case get_configfiles(CfgFiles,[],LogDir,EvHandlers) of
+		ok ->
+		    {Run,Skip} = ct_testspec:prepare_tests(TS,node()),
+		    do_run(Run,Skip,CoverOpt,[],LogDir);
+		{error,GCFReason} ->
+		    exit(GCFReason)
+	    end
+    end.
+
+
+get_data_for_node(#testspec{logdir=LogDirs,
+			    cover=CoverFs,
+			    config=Cfgs,
+			    event_handler=EvHs,
+			    include=Incl}, Node) ->
+    LogDir = case lists:keysearch(Node,1,LogDirs) of
+		 {value,{Node,Dir}} -> Dir;
+		 false -> "."
+	     end,
+    Cover = case lists:keysearch(Node,1,CoverFs) of
+		{value,{Node,CovFile}} -> CovFile;
+		false -> undef
+	    end,
+    ConfigFiles = [F || {N,F} <- Cfgs, N==Node],
+    EvHandlers =  [{H,A} || {N,H,A} <- EvHs, N==Node],
+    Include =  [I || {N,I} <- Incl, N==Node],
+    {LogDir,Cover,ConfigFiles,EvHandlers,Include}.
+
+
+refresh_logs(LogDir) ->
+    {ok,Cwd} = file:get_cwd(),
+    case file:set_cwd(LogDir) of
+	E = {error,_Reason} ->
+	    E;
+	_ ->
+	    case catch ct_logs:make_all_suites_index(refresh) of
+		{'EXIT',ASReason} ->
+		    file:set_cwd(Cwd),
+		    {error,{all_suites_index,ASReason}};
+		_ ->
+		    case catch ct_logs:make_all_runs_index(refresh) of
+			{'EXIT',ARReason} ->
+			    file:set_cwd(Cwd),
+			    {error,{all_runs_index,ARReason}};
+			_ ->
+			    file:set_cwd(Cwd),
+			    io:format("Logs in ~s refreshed!~n",[LogDir]),
+			    ok
+		    end
+	    end
+    end.
+
+which_logdir(".",Dir) ->
+    Dir;
+which_logdir(Dir,_) ->
+    Dir.
+	   
+listify([C|_]=Str) when is_integer(C) -> [Str];
+listify(L) when is_list(L) -> L;
+listify(E) -> [E].
+
+delistify([E]) -> E;
+delistify(E)   -> E.
+
+
+%%%-----------------------------------------------------------------
+%%% @hidden
+%%% @equiv ct:run/3
+run(TestDir, Suite, Cases) ->
+    install([]),
+    do_run(tests(TestDir, Suite, Cases), []).
+
+%%%-----------------------------------------------------------------
+%%% @hidden
+%%% @equiv ct:run/2
+run(TestDir, Suite) when is_list(TestDir), is_integer(hd(TestDir)) ->
+    install([]),
+    do_run(tests(TestDir, Suite), []).
+
+%%%-----------------------------------------------------------------
+%%% @hidden
+%%% @equiv ct:run/1
+run(TestDirs) ->
+    install([]),
+    do_run(tests(TestDirs), []).
+
+
+tests(TestDir, Suites, []) when is_list(TestDir), is_integer(hd(TestDir)) ->
+    [{?testdir(TestDir,Suites),ensure_atom(Suites),all}];
+tests(TestDir, Suite, Cases) when is_list(TestDir), is_integer(hd(TestDir)) ->
+    [{?testdir(TestDir,Suite),ensure_atom(Suite),Cases}].
+tests([{Dir,Suite}],Cases) ->
+    [{?testdir(Dir,Suite),ensure_atom(Suite),Cases}];
+tests(TestDir, Suite) when is_list(TestDir), is_integer(hd(TestDir)) ->
+    tests(TestDir, ensure_atom(Suite), all).
+tests(DirSuites) when is_list(DirSuites), is_tuple(hd(DirSuites)) ->
+    [{?testdir(Dir,Suite),ensure_atom(Suite),all} || {Dir,Suite} <- DirSuites];
+tests(TestDir) when is_list(TestDir), is_integer(hd(TestDir)) ->
+    tests([TestDir]);
+tests(TestDirs) when is_list(TestDirs), is_list(hd(TestDirs)) ->
+    [{?testdir(TestDir,all),all,all} || TestDir <- TestDirs].
+
+do_run(Tests, Opt) ->
+    do_run(Tests, [], Opt, [], ".").
+
+do_run(Tests, Opt, LogDir) ->
+    do_run(Tests, [], Opt, [], LogDir).
+
+do_run(Tests, Skip, Opt, Args, LogDir) ->
+    case code:which(test_server) of
+	non_existing ->
+	    exit({error,no_path_to_test_server});
+	_ ->
+	    Opt1 = 
+		case lists:keysearch(cover, 1, Opt) of
+		    {value,{_,CoverFile}} ->
+			case ct_cover:get_spec(CoverFile) of
+			    {error,Reason} ->
+				exit({error,Reason});
+			    Spec ->
+				[{cover_spec,Spec} |
+				 lists:keydelete(cover, 1, Opt)]
+			end;
+		    _ ->
+			Opt
+		end,
+	    %% This env variable is used by test_server to determine
+	    %% which framework it runs under.
+	    case os:getenv("TEST_SERVER_FRAMEWORK") of
+		false ->
+		    os:putenv("TEST_SERVER_FRAMEWORK", "ct_framework");
+		"ct_framework" ->
+		    ok;
+		Other ->
+		    erlang:display(list_to_atom("Note: TEST_SERVER_FRAMEWORK = " ++ Other))
+	    end,
+	    case ct_util:start(LogDir) of
+		{error,interactive_mode} ->
+		    io:format("CT is started in interactive mode. "
+			      "To exit this mode, run ct:stop_interactive().\n"
+			      "To enter the interactive mode again, "
+			      "run ct:start_interactive()\n\n",[]),
+		    {error,interactive_mode};
+
+		_Pid ->
+		    %% save style sheet info
+		    case lists:keysearch(stylesheet, 1, Args) of
+			{value,{_,SSFile}} ->
+			    ct_util:set_testdata({stylesheet,SSFile});
+			_ ->
+			    ct_util:set_testdata({stylesheet,undefined})
+		    end,
+
+		    case lists:keysearch(silent_connections, 1, Args) of
+			{value,{silent_connections,undefined}} ->
+			    ok;
+			{value,{silent_connections,[]}} ->
+			    Conns = ct_util:override_silence_all_connections(),
+			    ct_logs:log("Silent connections", "~p", [Conns]);
+			{value,{silent_connections,Cs}} ->
+			    Conns = lists:map(fun(S) when is_list(S) ->
+						      list_to_atom(S);
+						 (A) -> A
+					      end, Cs),
+			    ct_util:override_silence_connections(Conns),
+			    ct_logs:log("Silent connections", "~p", [Conns]);
+			_ ->
+			    ok
+		    end,
+		    log_ts_names(Args),
+		    TestSuites = suite_tuples(Tests),
+
+		    {SuiteMakeErrors,AllMakeErrors} =
+			case application:get_env(common_test, auto_compile) of
+			    {ok,false} ->
+				SuitesNotFound = verify_suites(TestSuites),
+				{SuitesNotFound,SuitesNotFound};
+			    _ ->
+				{SuiteErrs,HelpErrs} = auto_compile(TestSuites),
+				{SuiteErrs,SuiteErrs++HelpErrs}
+			end,
+
+		    case continue(AllMakeErrors) of
+			true ->
+			    SavedErrors = save_make_errors(SuiteMakeErrors),
+			    ct_repeat:log_loop_info(Args),
+			    {Tests1,Skip1} = final_tests(Tests,[],Skip,SavedErrors),
+			    R = do_run_test(Tests1, Skip1, Opt1),
+			    ct_util:stop(normal),
+			    R;
+			false ->
+			    io:nl(),
+			    ct_util:stop(clean),
+			    BadMods =
+				lists:foldr(
+				  fun({{_,_},Ms}, Acc) ->
+					  Ms ++ lists:foldl(
+						  fun(M, Acc1) ->
+							  lists:delete(M, Acc1)
+						  end, Acc, Ms)
+				  end, [], AllMakeErrors),
+			    {error,{make_failed,BadMods}}
+		    end
+	    end
+    end.
+
+%% attempt to compile the modules specified in TestSuites
+auto_compile(TestSuites) ->
+    io:format("~nCommon Test: Running make in test directories...~n"),
+    UserInclude =
+	case application:get_env(common_test, include) of
+	    {ok,UserInclDirs} when length(UserInclDirs) > 0 ->
+		io:format("Including the following directories:~n"),
+		[begin io:format("~p~n",[UserInclDir]), {i,UserInclDir} end || 
+		 UserInclDir <- UserInclDirs];
+	    _ ->
+		[]
+	end,
+    SuiteMakeErrors =
+	lists:flatmap(fun({TestDir,Suite} = TS) ->
+			      case run_make(suites, TestDir, Suite, UserInclude) of
+				  {error,{make_failed,Bad}} -> 
+				      [{TS,Bad}];
+				  {error,_} -> 
+				      [{TS,[filename:join(TestDir,"*_SUITE")]}];
+				  _ -> 
+				      []
+			      end
+		      end, TestSuites),
+
+    %% try to compile other modules than SUITEs in the test directories
+    {_,HelpMakeErrors} =
+	lists:foldl(
+	  fun({Dir,Suite}, {Done,Failed}) ->
+		  case lists:member(Dir, Done) of
+		      false ->
+			  Failed1 =
+			      case run_make(helpmods, Dir, Suite, UserInclude) of
+				  {error,{make_failed,BadMods}} ->
+				      [{{Dir,all},BadMods}|Failed];
+				  {error,_} ->
+				      [{{Dir,all},[Dir]}|Failed];
+				  _ ->
+				      Failed
+			      end,
+			  {[Dir|Done],Failed1};
+		      true ->		    % already visited
+			  {Done,Failed}
+		  end
+	  end, {[],[]}, TestSuites),    
+    {SuiteMakeErrors,lists:reverse(HelpMakeErrors)}.
+
+%% verify that specified test suites exist (if auto compile is disabled)
+verify_suites(TestSuites) ->
+    io:nl(),
+    Verify = 
+	fun({Dir,Suite},NotFound) ->
+		case locate_test_dir(Dir, Suite) of
+		    {ok,TestDir} ->
+			if Suite == all ->
+				NotFound;
+			   true ->
+				Beam = filename:join(TestDir, atom_to_list(Suite)++".beam"),
+				case filelib:is_regular(Beam) of
+				    true  -> 
+					NotFound;
+				    false -> 
+					Name = filename:join(TestDir, atom_to_list(Suite)),
+					io:format("Suite ~w not found in directory ~s~n", 
+						  [Suite,TestDir]),
+					[{{Dir,Suite},[Name]} | NotFound]
+				end
+			end;
+		    {error,_Reason} ->
+			io:format("Directory ~s is invalid~n", [Dir]),
+			Name = filename:join(Dir, atom_to_list(Suite)),
+			[{{Dir,Suite},[Name]} | NotFound]
+		end
+	end,
+    lists:reverse(lists:foldl(Verify, [], TestSuites)).
+		     
+    
+save_make_errors([]) ->
+    [];
+save_make_errors(Errors) ->
+    Suites = get_bad_suites(Errors,[]),
+    ct_logs:log("MAKE RESULTS",
+		"Error compiling or locating the following suites: ~n~p",[Suites]),
+    %% save the info for logger
+    file:write_file(?missing_suites_info,term_to_binary(Errors)),
+    Errors.
+
+get_bad_suites([{{_TestDir,_Suite},Failed}|Errors], BadSuites) ->
+    get_bad_suites(Errors,BadSuites++Failed);
+get_bad_suites([], BadSuites) ->
+    BadSuites.
+
+    
+
+%%%-----------------------------------------------------------------
+%%% @hidden
+%%% @equiv ct:step/3
+step(TestDir, Suite, Case) ->
+    step(TestDir, Suite, Case, []).
+
+%%%-----------------------------------------------------------------
+%%% @hidden
+%%% @equiv ct:step/4
+step(TestDir, Suite, Case, Opts) when is_list(TestDir), is_atom(Suite), is_atom(Case), 
+				   Suite =/= all, Case =/= all ->
+    do_run([{TestDir,Suite,Case}], [{step,Opts}]).
+
+
+%%%-----------------------------------------------------------------
+%%% Internal
+suite_tuples([{TestDir,Suites,_} | Tests]) when is_list(Suites) ->
+    lists:map(fun(S) -> {TestDir,S} end, Suites) ++ suite_tuples(Tests);
+suite_tuples([{TestDir,Suite,_} | Tests]) when is_atom(Suite) ->
+    [{TestDir,Suite} | suite_tuples(Tests)];
+suite_tuples([]) ->
+    [].
+
+final_tests([{TestDir,Suites,_}|Tests],
+	    Final, Skip, Bad) when is_list(Suites), is_atom(hd(Suites)) ->
+%     Separate =
+% 	fun(S,{DoSuite,Dont}) ->		
+% 		case lists:keymember({TestDir,S},1,Bad) of
+% 		    false ->	
+% 			{[S|DoSuite],Dont};
+% 		    true ->	
+% 			SkipIt = {TestDir,S,"Make failed"},
+% 			{DoSuite,Dont++[SkipIt]}
+% 		end
+% 	end,
+	
+%     {DoSuites,Skip1} =
+% 	lists:foldl(Separate,{[],Skip},Suites),
+%     Do = {TestDir,lists:reverse(DoSuites),all},
+
+    Skip1 = [{TD,S,"Make failed"} || {{TD,S},_} <- Bad, S1 <- Suites,
+				     S == S1, TD == TestDir],
+    Final1 = [{TestDir,S,all} || S <- Suites], 
+    final_tests(Tests, lists:reverse(Final1)++Final, Skip++Skip1, Bad);
+
+final_tests([{TestDir,all,all}|Tests], Final, Skip, Bad) ->
+    MissingSuites =
+	case lists:keysearch({TestDir,all}, 1, Bad) of
+	    {value,{_,Failed}} ->
+		[list_to_atom(filename:basename(F)) || F <- Failed];
+	    false ->
+		[]
+	end,
+    Missing = [{TestDir,S,"Make failed"} || S <- MissingSuites],
+    Final1 = [{TestDir,all,all}|Final],
+    final_tests(Tests, Final1, Skip++Missing, Bad);
+
+final_tests([{TestDir,Suite,Cases}|Tests],
+	    Final, Skip, Bad) when Cases==[]; Cases==all  ->
+    final_tests([{TestDir,[Suite],all}|Tests], Final, Skip, Bad);
+
+final_tests([{TestDir,Suite,Cases}|Tests], Final, Skip, Bad) ->
+    case lists:keymember({TestDir,Suite}, 1, Bad) of
+	false ->
+	    Do = {TestDir,Suite,Cases},
+	    final_tests(Tests, [Do|Final], Skip, Bad);
+	true ->
+	    Do = {TestDir,Suite,Cases},
+	    Skip1 = Skip ++ [{TestDir,Suite,Cases,"Make failed"}],
+	    final_tests(Tests, [Do|Final], Skip1, Bad)
+    end;
+
+final_tests([], Final, Skip, _Bad) ->
+    {lists:reverse(Final),Skip}.
+
+continue([]) ->    
+    true;
+continue(_MakeErrors) ->
+    io:nl(),
+    OldGl = group_leader(),
+    case set_group_leader_same_as_shell() of
+	true ->
+	    S = self(),
+	    io:format("Failed to compile or locate one or more test suites\n"
+		      "Press \'c\' to continue or \'a\' to abort.\n"
+		      "Will continue in 15 seconds if no answer is given!\n"),
+	    Pid = spawn(fun() ->
+				case io:get_line('(c/a) ') of
+				    "c\n" ->
+					S ! true;
+				    _ ->
+					S ! false
+				end
+			end),
+	    group_leader(OldGl, self()),
+	    receive R when R==true; R==false ->
+		    R
+	    after 15000 ->
+		    exit(Pid, kill),
+		    io:format("... timeout - continuing!!\n"),
+		    true
+	    end;
+	false ->				% no shell process to use
+	    true
+    end.
+
+set_group_leader_same_as_shell() ->
+    %%! Locate the shell process... UGLY!!!
+    GS2or3 = fun(P) ->
+		     case process_info(P,initial_call) of
+			 {initial_call,{group,server,X}} when X == 2 ; X == 3 ->
+			     true;
+			 _ ->
+			     false
+		     end
+	     end,	
+    case [P || P <- processes(), GS2or3(P), 
+	       true == lists:keymember(shell,1,element(2,process_info(P,dictionary)))] of
+	[GL|_] ->
+	    group_leader(GL, self());
+	[] ->
+	    false
+    end.
+
+check_and_add([{TestDir0,M,_} | Tests], Added) ->
+    case locate_test_dir(TestDir0, M) of
+	{ok,TestDir} ->
+	    case lists:member(TestDir, Added) of
+		true ->
+		    check_and_add(Tests, Added);
+		false ->
+		    true = code:add_patha(TestDir),
+		    check_and_add(Tests, [TestDir|Added])
+	    end;
+	{error,_} ->
+	    {error,{invalid_directory,TestDir0}}
+    end;
+check_and_add([], _) ->
+    ok.
+
+do_run_test(Tests, Skip, Opt) ->
+    case check_and_add(Tests, []) of
+	ok ->
+	    ct_util:set_testdata({stats,{0,0,{0,0}}}),
+	    ct_util:set_testdata({cover,undefined}),
+	    test_server_ctrl:start_link(local),
+	    case lists:keysearch(cover_spec, 1, Opt) of
+		{value,{_,CovData={CovFile,
+				   CovNodes,
+				   _CovImport,
+				   CovExport,
+				   #cover{app        = CovApp,
+					  level      = CovLevel,
+					  excl_mods  = CovExcl,
+					  incl_mods  = CovIncl,
+					  cross      = CovCross,
+					  src        = _CovSrc}}}} ->
+		    ct_logs:log("COVER INFO","Using cover specification file: ~s~n"
+				"App: ~w~n"
+				"Cross cover: ~w~n"
+				"Including ~w modules~n"
+				"Excluding ~w modules",
+				[CovFile,CovApp,CovCross,length(CovIncl),length(CovExcl)]), 
+
+		    %% cover export file will be used for export and import
+		    %% between tests so make sure it doesn't exist initially
+		    case filelib:is_file(CovExport) of
+			true ->
+			    DelResult = file:delete(CovExport),
+			    ct_logs:log("COVER INFO",
+					"Warning! Export file ~s already exists. "
+					"Deleting with result: ~p",
+					[CovExport,DelResult]);
+			false ->
+			    ok
+		    end,
+
+		    %% tell test_server which modules should be cover compiled
+		    %% note that actual compilation is done when tests start
+		    test_server_ctrl:cover(CovApp, CovFile, CovExcl, CovIncl,
+					   CovCross, CovExport, CovLevel),
+		    %% save cover data (used e.g. to add nodes dynamically)
+		    ct_util:set_testdata({cover,CovData}),
+		    %% start cover on specified nodes
+		    if (CovNodes /= []) and (CovNodes /= undefined) ->
+			    ct_logs:log("COVER INFO",
+					"Nodes included in cover session: ~w",
+					[CovNodes]),
+			    cover:start(CovNodes);
+		       true ->
+			    ok
+		    end,
+		    true;
+		_ ->
+		    false
+	    end,	 
+	    %% let test_server expand the test tuples and count no of cases
+	    {Suites,NoOfCases} = count_test_cases(Tests, Skip),
+	    Suites1 = delete_dups(Suites),
+	    NoOfTests = length(Tests),
+	    NoOfSuites = length(Suites1),
+	    ct_util:warn_duplicates(Suites1),	    
+	    {ok,Cwd} = file:get_cwd(),
+	    io:format("~nCWD set to: ~p~n", [Cwd]),
+	    if NoOfCases == unknown ->
+		    io:format("~nTEST INFO: ~w test(s), ~w suite(s)~n~n", 
+			      [NoOfTests,NoOfSuites]),
+		    ct_logs:log("TEST INFO","~w test(s), ~w suite(s)", 
+				[NoOfTests,NoOfSuites]);
+	       true ->
+		    io:format("~nTEST INFO: ~w test(s), ~w case(s) in ~w suite(s)~n~n", 
+			      [NoOfTests,NoOfCases,NoOfSuites]),
+		    ct_logs:log("TEST INFO","~w test(s), ~w case(s) in ~w suite(s)", 
+				[NoOfTests,NoOfCases,NoOfSuites])
+	    end,
+	    ct_event:notify(#event{name=start_info,
+				   node=node(),
+				   data={NoOfTests,NoOfSuites,NoOfCases}}),
+	    CleanUp = add_jobs(Tests, Skip, Opt, []),
+	    unlink(whereis(test_server_ctrl)),
+	    catch test_server_ctrl:wait_finish(), 
+	    %% check if last testcase has left a "dead" trace window 
+	    %% behind, and if so, kill it
+	    case ct_util:get_testdata(interpret) of
+		{_What,kill,{TCPid,AttPid}} ->
+		    ct_util:kill_attached(TCPid, AttPid);
+		_ ->
+		    ok
+	    end,
+	    lists:foreach(fun(Suite) -> 
+				  maybe_cleanup_interpret(Suite, Opt) 
+			  end, CleanUp);
+	Error ->
+	    Error
+    end.
+
+delete_dups([S | Suites]) ->
+    Suites1 = lists:delete(S, Suites),
+    [S | delete_dups(Suites1)];
+delete_dups([]) ->
+    [].
+
+count_test_cases(Tests, Skip) ->
+    SendResult = fun(Me, Result) -> Me ! {no_of_cases,Result} end,
+    TSPid = test_server_ctrl:start_get_totals(SendResult),
+    Ref = erlang:monitor(process, TSPid),
+    add_jobs(Tests, Skip, [], []),
+    {Suites,NoOfCases} = count_test_cases1(length(Tests), 0, [], Ref),
+    erlang:demonitor(Ref),
+    test_server_ctrl:stop_get_totals(),
+    {Suites,NoOfCases}.
+
+count_test_cases1(0, N, Suites, _) ->
+    {lists:flatten(Suites), N};
+count_test_cases1(Jobs, N, Suites, Ref) ->
+    receive
+	{no_of_cases,{Ss,N1}} -> 
+	    count_test_cases1(Jobs-1, add_known(N,N1), [Ss|Suites], Ref);
+	{'DOWN', Ref, _, _, _} -> 
+	    {[],0}
+    end.				      
+
+add_known(unknown, _) ->
+    unknown;
+add_known(_, unknown) ->
+    unknown;
+add_known(N, N1) ->
+    N+N1.
+
+add_jobs([{TestDir,all,_}|Tests], Skip, Opt, CleanUp) ->
+    Name = get_name(TestDir),
+    case catch test_server_ctrl:add_dir_with_skip(Name, TestDir,
+						  skiplist(TestDir,Skip)) of
+	{'EXIT',_} -> 
+	    CleanUp;
+	_ ->
+	    wait_for_idle(),
+	    add_jobs(Tests, Skip, Opt, CleanUp)
+    end;
+add_jobs([{TestDir,[Suite],all}|Tests], Skip, Opt, CleanUp) when is_atom(Suite) ->
+    add_jobs([{TestDir,Suite,all}|Tests], Skip, Opt, CleanUp);
+add_jobs([{TestDir,Suites,all}|Tests], Skip, Opt, CleanUp) when is_list(Suites) ->
+    Name = get_name(TestDir) ++ ".suites",
+    case catch test_server_ctrl:add_module_with_skip(Name, Suites,
+						     skiplist(TestDir,Skip)) of
+	{'EXIT',_} -> 
+	    CleanUp;
+	_ ->
+	    wait_for_idle(),
+	    add_jobs(Tests, Skip, Opt, CleanUp)
+    end;
+add_jobs([{TestDir,Suite,all}|Tests], Skip, Opt, CleanUp) ->
+    case maybe_interpret(Suite, all, Opt) of
+	ok ->
+	    Name =  get_name(TestDir) ++ "." ++ atom_to_list(Suite),
+	    case catch test_server_ctrl:add_module_with_skip(Name, [Suite],
+							     skiplist(TestDir,Skip)) of
+		{'EXIT',_} -> 
+		    CleanUp;
+		_ ->
+		    wait_for_idle(),
+		    add_jobs(Tests, Skip, Opt, [Suite|CleanUp])
+	    end;
+	Error ->
+	    Error
+    end;
+add_jobs([{TestDir,Suite,[Case]}|Tests], Skip, Opt, CleanUp) when is_atom(Case) ->
+    add_jobs([{TestDir,Suite,Case}|Tests], Skip, Opt, CleanUp);
+add_jobs([{TestDir,Suite,Cases}|Tests], Skip, Opt, CleanUp) when is_list(Cases) ->
+    case maybe_interpret(Suite, Cases, Opt) of
+	ok ->
+	    Name =  get_name(TestDir) ++ "." ++	atom_to_list(Suite) ++ ".cases",
+	    case catch test_server_ctrl:add_cases_with_skip(Name, Suite, Cases,
+							    skiplist(TestDir,Skip)) of
+		{'EXIT',_} -> 
+		    CleanUp;
+		_ ->
+		    wait_for_idle(),
+		    add_jobs(Tests, Skip, Opt, [Suite|CleanUp])
+	    end;
+	Error ->
+	    Error
+    end;
+add_jobs([{TestDir,Suite,Case}|Tests], Skip, Opt, CleanUp) when is_atom(Case) ->
+    case maybe_interpret(Suite, Case, Opt) of
+	ok ->
+	    Name = get_name(TestDir) ++	"." ++ atom_to_list(Suite) ++ "." ++ 
+		atom_to_list(Case),
+	    case catch test_server_ctrl:add_case_with_skip(Name, Suite, Case,
+							   skiplist(TestDir,Skip)) of
+		{'EXIT',_} -> 
+		    CleanUp;
+		_ ->
+		    wait_for_idle(),
+		    add_jobs(Tests, Skip, Opt, [Suite|CleanUp])
+	    end;
+	Error ->
+	    Error
+    end;
+add_jobs([], _, _, CleanUp) ->
+    CleanUp.
+
+wait_for_idle() ->
+    ct_util:update_last_run_index(),
+    Notify = fun(Me) -> Me ! idle end,
+    case catch test_server_ctrl:idle_notify(Notify) of
+	{'EXIT',_} ->
+	    error;
+	TSPid ->
+	    %% so we don't hang forever if test_server dies
+	    Ref = erlang:monitor(process, TSPid),
+	    Result = receive
+			 idle -> ok;
+			 {'DOWN', Ref, _, _, _} -> error
+		     end,
+	    erlang:demonitor(Ref),
+	    ct_util:update_last_run_index(),
+	    Result
+    end.
+
+skiplist(Dir, [{Dir,all,Cmt}|Skip]) ->
+    %% we need to turn 'all' into list of modules since
+    %% test_server doesn't do skips on Dir level
+    Ss = filelib:wildcard(filename:join(Dir, "*_SUITE.beam")),
+    [{list_to_atom(filename:basename(S,".beam")),Cmt} || S <- Ss] ++ skiplist(Dir,Skip);
+skiplist(Dir, [{Dir,S,Cmt}|Skip]) ->
+    [{S,Cmt} | skiplist(Dir, Skip)];
+skiplist(Dir, [{Dir,S,C,Cmt}|Skip]) ->
+    [{S,C,Cmt} | skiplist(Dir, Skip)];
+skiplist(Dir, [_|Skip]) ->
+    skiplist(Dir, Skip);
+skiplist(_Dir, []) ->
+    [].
+
+get_name(Dir) ->
+    TestDir =
+	case filename:basename(Dir) of
+	    "test" ->
+		filename:dirname(Dir);
+	    _ ->
+		Dir
+	end,
+    Base = filename:basename(TestDir),
+    case filename:basename(filename:dirname(TestDir)) of
+	"" -> 
+	    Base;
+	TopDir ->
+	    TopDir ++ "." ++ Base
+    end.
+
+
+run_make(TestDir, Mod, UserInclude) ->
+    run_make(suites, TestDir, Mod, UserInclude).
+
+run_make(Targets, TestDir0, Mod, UserInclude) when is_list(Mod) ->
+    run_make(Targets, TestDir0, list_to_atom(Mod), UserInclude);
+
+run_make(Targets, TestDir0, Mod, UserInclude) ->
+    case locate_test_dir(TestDir0, Mod) of
+	{ok,TestDir} ->
+	    %% send a start_make notification which may suspend
+	    %% the process if some other node is compiling files
+	    %% in the same directory
+	    ct_event:sync_notify(#event{name=start_make,
+					node=node(),
+					data=TestDir}),
+	    {ok,Cwd} = file:get_cwd(),
+	    ok = file:set_cwd(TestDir),
+	    TestServerInclude = get_dir(test_server, "include"),
+	    CtInclude = get_dir(common_test, "include"),
+	    XmerlInclude = get_dir(xmerl, "include"),
+	    ErlFlags = UserInclude ++ [{i,TestServerInclude},
+				       {i,CtInclude},
+				       {i,XmerlInclude},
+				       debug_info],
+	    Result = 
+		if Mod == all ; Targets == helpmods ->
+			case (catch ct_make:all([noexec])) of
+			    {'EXIT',_} = Failure -> 
+				Failure;
+			    MakeInfo ->
+				FileTest = fun(F, suites) -> is_suite(F);
+					      (F, helpmods) -> not is_suite(F);
+					      (_, _) -> true end, 
+				Files = lists:flatmap(fun({F,out_of_date}) ->
+							      case FileTest(F, Targets) of
+								  true -> [F];
+								  false -> []
+							      end;
+							 (_) ->
+							      []
+						      end, MakeInfo),
+				(catch ct_make:files(Files, [load|ErlFlags]))
+			end;
+		   true ->
+			(catch ct_make:files([Mod], [load|ErlFlags]))
+		end,
+	    
+	    ok = file:set_cwd(Cwd),
+	    %% send finished_make notification
+	    ct_event:notify(#event{name=finished_make,
+				   node=node(),
+				   data=TestDir}),
+	    case Result of
+		{up_to_date,_} ->
+		    ok;
+		{'EXIT',Reason} ->
+		    io:format("{error,{make_crashed,~p}\n", [Reason]),
+		    {error,{make_crashed,TestDir,Reason}};
+		{error,ModInfo} ->
+		    io:format("{error,make_failed}\n", []),
+		    Bad = [filename:join(TestDir, M) || {M,R} <- ModInfo, 
+							R == error],
+		    {error,{make_failed,Bad}}
+	    end;
+	{error,_} ->
+	    io:format("{error,{invalid_directory,~p}}\n", [TestDir0]),
+	    {error,{invalid_directory,TestDir0}}
+    end.
+
+get_dir(App, Dir) ->
+    filename:join(code:lib_dir(App), Dir).
+
+maybe_interpret(Suite, Cases, [{step,StepOpts}]) ->
+    %% if other suite has run before this one, check if last testcase 
+    %% has left a "dead" trace window behind, and if so, kill it
+    case ct_util:get_testdata(interpret) of
+	{_What,kill,{TCPid,AttPid}} ->
+	    ct_util:kill_attached(TCPid, AttPid);
+	_ ->
+	    ok
+    end,
+    maybe_interpret1(Suite, Cases, StepOpts);
+maybe_interpret(_, _, _) ->
+    ok.
+
+maybe_interpret1(Suite, all, StepOpts) ->
+    case i:ii(Suite) of
+	{module,_} ->
+	    i:iaa([break]),
+	    case get_all_testcases(Suite) of
+		{error,_} ->
+		    {error,no_testcases_found};
+		Cases ->
+		    maybe_interpret2(Suite, Cases, StepOpts)
+	    end;
+	error ->
+	    {error,could_not_interpret_module}
+    end;
+maybe_interpret1(Suite, Case, StepOpts) when is_atom(Case) ->
+    maybe_interpret1(Suite, [Case], StepOpts);
+maybe_interpret1(Suite, Cases, StepOpts) when is_list(Cases) ->
+    case i:ii(Suite) of
+	{module,_} ->
+	    i:iaa([break]),
+	    maybe_interpret2(Suite, Cases, StepOpts);
+	error ->
+	    {error,could_not_interpret_module}
+    end.
+
+maybe_interpret2(Suite, Cases, StepOpts) ->
+    set_break_on_config(Suite, StepOpts),
+    [i:ib(Suite, Case, 1) || Case <- Cases],
+    test_server_ctrl:multiply_timetraps(infinity),
+    WinOp = case lists:member(keep_inactive, ensure_atom(StepOpts)) of
+		true -> no_kill;
+		false -> kill
+	    end,		    
+    ct_util:set_testdata({interpret,{{Suite,Cases},WinOp,
+				     {undefined,undefined}}}),
+    ok.
+
+set_break_on_config(Suite, StepOpts) ->
+    case lists:member(config, ensure_atom(StepOpts)) of
+	true ->
+	    i:ib(Suite, init_per_suite, 1),
+	    i:ib(Suite, init_per_testcase, 2),
+	    i:ib(Suite, end_per_testcase, 2),
+	    i:ib(Suite, end_per_suite, 1);
+	false ->
+	    ok
+    end.
+
+maybe_cleanup_interpret(Suite, [{step,_}]) ->
+    i:iq(Suite);
+maybe_cleanup_interpret(_, _) ->
+    ok.
+
+log_ts_names(Args) ->
+    case lists:keysearch(spec, 1, Args) of
+	{value,{_,Specs}} ->
+	    List = lists:map(fun(Name) ->
+				     Name ++ " "
+			     end, Specs),
+	    ct_logs:log("Test Specification file(s)", "~s",
+			[lists:flatten(List)]);
+	_ ->
+	    ok
+    end.
+			  
+merge_arguments(Args) ->
+    merge_arguments(Args, []).
+
+merge_arguments([LogDir={logdir,_}|Args], Merged) ->
+    merge_arguments(Args, handle_arg(replace, LogDir, Merged));
+merge_arguments([CoverFile={cover,_}|Args], Merged) ->
+    merge_arguments(Args, handle_arg(replace, CoverFile, Merged));
+merge_arguments([Arg={_,_}|Args], Merged) ->
+    merge_arguments(Args, handle_arg(merge, Arg, Merged));
+merge_arguments([], Merged) ->
+    Merged.
+
+handle_arg(replace, {Key,Elems}, [{Key,_}|Merged]) ->
+    [{Key,Elems}|Merged];
+handle_arg(merge, {Key,Elems}, [{Key,PrevElems}|Merged]) ->
+    [{Key,PrevElems++Elems}|Merged];
+handle_arg(Op, Arg, [Other|Merged]) ->
+    [Other|handle_arg(Op, Arg, Merged)];
+handle_arg(_,Arg,[]) ->
+    [Arg].
+
+locate_test_dir(Dir, Suite) ->
+    TestDir = case ct_util:is_test_dir(Dir) of
+		  true  -> Dir;
+		  false -> ct_util:get_testdir(Dir, Suite)
+	      end,
+    case filelib:is_dir(TestDir) of
+	true  -> {ok,TestDir};
+	false -> {error,invalid}
+    end.
+
+is_suite(Mod) when is_atom(Mod) ->
+    is_suite(atom_to_list(Mod));
+is_suite(ModOrFile) when is_list(ModOrFile) ->
+    case lists:reverse(filename:basename(ModOrFile, ".erl")) of
+	[$E,$T,$I,$U,$S,$_|_] ->
+	    true;
+	_ ->
+	    case lists:reverse(filename:basename(ModOrFile, ".beam")) of
+		[$E,$T,$I,$U,$S,$_|_] ->
+		    true;
+		_ ->
+		    false
+	    end
+    end.
+
+get_all_testcases(Suite) ->
+    %%! this needs to be updated to handle testcase groups later!!
+    case catch Suite:all() of
+	{'EXIT',Why} ->
+	    {error,Why};
+	{skip,_} ->
+	    [];
+	Cases ->
+	    AllCases =
+		lists:foldl(fun({sequence,SeqName}, All) ->
+				    case catch Suite:sequences() of
+					{'EXIT',_} ->
+					    All;
+					Seqs ->
+					    case proplists:get_value(SeqName, Seqs) of
+						undefined ->
+						    All;
+						SeqCases ->
+						    lists:reverse(SeqCases) ++ All
+					    end
+				    end;
+			       (Case,All) ->
+				    [Case|All]
+			    end, [], Cases),
+	    lists:reverse(AllCases)
+    end.
+					
+
+%% Internal tracing support. If {ct_trace,TraceSpec} is present, the
+%% TraceSpec file will be consulted and dbg used to trace function
+%% calls during test run. Expected terms in TraceSpec:
+%% {m,Mod} or {f,Mod,Func}.
+start_trace(Args) ->
+    case lists:keysearch(ct_trace,1,Args) of
+	{value,{ct_trace,File}} ->
+	    TraceSpec = delistify(File),
+	    case file:consult(TraceSpec) of
+		{ok,Terms} ->
+		    case catch do_trace(Terms) of
+			ok -> 
+			    true;
+			{_,Error} ->
+			    io:format("Warning! Tracing not started. Reason: ~p~n~n",
+				      [Error]),
+			    false
+		    end;		           
+		{_,Error} ->
+		    io:format("Warning! Tracing not started. Reason: ~p~n~n",
+			      [Error]),
+		    false
+	    end;	    			
+	false ->
+	    false		
+    end.
+
+do_trace(Terms) ->
+    dbg:tracer(),
+    dbg:p(self(), [sos,call]),
+    lists:foreach(fun({m,M}) ->
+			  case dbg:tpl(M,[{'_',[],[{return_trace}]}]) of
+			      {error,What} -> exit({error,{tracing_failed,What}});
+			      _ -> ok
+			  end;			  
+		     ({f,M,F}) ->
+			  case dbg:tpl(M,F,[{'_',[],[{return_trace}]}]) of
+			      {error,What} -> exit({error,{tracing_failed,What}});
+			      _ -> ok
+			  end;			  
+		     (Huh) ->
+			  exit({error,{unrecognized_trace_term,Huh}})
+		  end, Terms),
+    ok.
+			 
+stop_trace(true) ->
+    dbg:stop_clear();
+stop_trace(false) ->
+    ok.
+
+preload() ->
+    io:format("~nLoading Common Test and Test Server modules...~n~n"),
+    preload_mod([ct_logs,
+		 ct_make,
+		 ct_telnet,
+		 ct,
+		 ct_master,
+		 ct_testspec,
+		 ct_cover,
+		 ct_master_event,
+		 ct_util,
+		 ct_event,           
+		 ct_master_logs,
+		 ct_framework,
+		 teln,
+		 ct_ftp,
+		 ct_rpc,
+		 unix_telnet,
+		 ct_gen_conn,
+		 ct_line,
+		 ct_snmp,
+		 test_server_sup,
+		 test_server,
+		 test_server_ctrl,
+		 test_server_h,
+		 test_server_line,
+		 test_server_node]).
+
+preload_mod([M|Ms]) ->
+    case code:is_loaded(M) of
+	false ->
+	    {module,M} = code:load_file(M),
+	    preload_mod(Ms);
+	_ ->
+	    ok
+    end;
+preload_mod([]) ->
+    ok.
+    
+ensure_atom(Atom) when is_atom(Atom) ->
+    Atom;
+ensure_atom(String) when is_list(String), is_integer(hd(String)) ->
+    list_to_atom(String);
+ensure_atom(List) when is_list(List) ->
+    [ensure_atom(Item) || Item <- List];
+ensure_atom(Other) ->				
+    Other.
+		  
diff --git a/lib/common_test/src/ct_snmp.erl b/lib/common_test/src/ct_snmp.erl
new file mode 100644
index 0000000000..7ff88ad7d3
--- /dev/null
+++ b/lib/common_test/src/ct_snmp.erl
@@ -0,0 +1,771 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 2004-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%
+%%
+
+%%% @doc Common Test user interface module for the OTP snmp application
+%%%
+%%% The purpose of this module is to make snmp configuration easier for 
+%%% the test case writer. Many test cases can use default values for common
+%%% operations and then no snmp configuration files need to be supplied. When
+%%% it is necessary to change particular configuration parameters, a subset
+%%% of the relevant snmp configuration files may be passed to <code>ct_snmp</code>
+%%% by means of Common Test configuration files.
+%%% For more specialized configuration parameters, it is possible to place a 
+%%% "simple snmp configuration file" in the test suite data directory. 
+%%% To simplify the test suite, Common Test keeps track
+%%% of some of the snmp manager information. This way the test suite doesn't
+%%% have to handle as many input parameters as it would if it had to interface the
+%%% OTP snmp manager directly.
+%%% 
+%%% <p> The following snmp manager and agent parameters are configurable: </p>
+%%%
+%%% <pre>
+%%% {snmp,
+%%%        %%% Manager config
+%%%        [{start_manager, boolean()}    % Optional - default is true
+%%%        {users, [{user_name(), [call_back_module(), user_data()]}]}, %% Optional 
+%%%        {usm_users, [{usm_user_name(), usm_config()}]},%% Optional - snmp v3 only
+%%%        % managed_agents is optional 
+%%%        {managed_agents,[{agent_name(), [user_name(), agent_ip(), agent_port(), [agent_config()]]}]},   
+%%%        {max_msg_size, integer()},     % Optional - default is 484
+%%%        {mgr_port, integer()},         % Optional - default is 5000
+%%%        {engine _id, string()},        % Optional - default is "mgrEngine"
+%%%
+%%%        %%% Agent config 
+%%%        {start_agent, boolean()},      % Optional - default is false
+%%%        {agent_sysname, string()},     % Optional - default is "ct_test"
+%%%        {agent_manager_ip, manager_ip()}, % Optional - default is localhost
+%%%        {agent_vsns, list()},          % Optional - default is [v2]
+%%%        {agent_trap_udp, integer()},   % Optional - default is 5000
+%%%        {agent_udp, integer()},        % Optional - default is 4000
+%%%        {agent_notify_type, atom()},   % Optional - default is trap
+%%%        {agent_sec_type, sec_type()},  % Optional - default is none
+%%%        {agent_passwd, string()},      % Optional - default is ""
+%%%        {agent_engine_id, string()},   % Optional - default is "agentEngine"
+%%%        {agent_max_msg_size, string()},% Optional - default is 484
+%%%
+%%%        %% The following parameters represents the snmp configuration files
+%%%        %% context.conf, standard.conf, community.conf, vacm.conf,  
+%%%        %% usm.conf, notify.conf, target_addr.conf and target_params.conf.
+%%%        %% Note all values in agent.conf can be altered by the parametes 
+%%%        %% above. All these configuration files have default values set   
+%%%        %% up by the snmp application. These values can be overridden by
+%%%        %% suppling a list of valid configuration values or a file located
+%%%        %% in the test suites data dir that can produce a list 
+%%%        %% of valid configuration values if you apply file:consult/1 to the 
+%%%        %% file. 
+%%%        {agent_contexts, [term()] | {data_dir_file, rel_path()}}, % Optional
+%%%        {agent_community, [term()] | {data_dir_file, rel_path()}},% Optional
+%%%        {agent_sysinfo,  [term()] | {data_dir_file, rel_path()}}, % Optional
+%%%        {agent_vacm, [term()] | {data_dir_file, rel_path()}},     % Optional
+%%%        {agent_usm, [term()] | {data_dir_file, rel_path()}},      % Optional 
+%%%        {agent_notify_def, [term()] | {data_dir_file, rel_path()}},% Optional
+%%%        {agent_target_address_def, [term()] | {data_dir_file, rel_path()}},% Optional
+%%%        {agent_target_param_def, [term()] | {data_dir_file, rel_path()}},% Optional
+%%%       ]}.
+%%% </pre>
+%%%
+%%% <p>The <code>MgrAgentConfName</code> parameter in the functions 
+%%% should be a name you allocate in your test suite using a
+%%% <code>require</code> statement. 
+%%% Example (where <code>MgrAgentConfName = snmp_mgr_agent</code>):</p>
+%%% <pre> suite() -> [{require, snmp_mgr_agent, snmp}].</pre>
+%%% <p>or</p>
+%%% <pre>  ct:require(snmp_mgr_agent, snmp).</pre>
+%%%
+%%% <p> Note that Usm users are needed for snmp v3 configuration and are
+%%% not to be confused with users.</p>
+%%%
+%%% <p> Snmp traps, inform and report messages are handled by the
+%%% user callback module. For more information about this see
+%%% the snmp application. </p> 
+%%% <p> Note: It is recommended to use the .hrl-files created by the 
+%%% Erlang/OTP mib-compiler to define the oids.  
+%%% Example for the getting the erlang node name from the erlNodeTable 
+%%% in the OTP-MIB:</p> 
+%%% <pre>Oid = ?erlNodeEntry ++ [?erlNodeName, 1] </pre>
+%%%
+%%% <p>It is also possible to set values for snmp application configuration 
+%%% parameters, such as <code>config</code>, <code>server</code>, 
+%%% <code>net_if</code>, etc (see the "Configuring the application" chapter in
+%%% the OTP snmp User's Guide for a list of valid parameters and types). This is 
+%%% done by defining a configuration data variable on the following form:</p>
+%%% <pre>
+%%% {snmp_app, [{manager, [snmp_app_manager_params()]},
+%%%             {agent, [snmp_app_agent_params()]}]}.</pre>
+%%% 
+%%% <p>A name for the data needs to be allocated in the suite using 
+%%% <code>require</code> (see example above), and this name passed as 
+%%% the <code>SnmpAppConfName</code> argument to <code>start/3</code>.
+%%% <code>ct_snmp</code> specifies default values for some snmp application
+%%% configuration parameters (such as <code>{verbosity,trace}</code> for the
+%%% <code>config</code> parameter). This set of defaults will be
+%%% merged with the parameters specified by the user, and user values
+%%% override <code>ct_snmp</code> defaults.</p>
+
+-module(ct_snmp).
+
+%%% Common Types
+%%% @type agent_ip() = ip()
+%%% @type manager_ip() = ip()
+%%% @type agent_name() = atom()
+%%% @type ip() = string() | {integer(), integer(), 
+%%% integer(), integer()}
+%%% @type agent_port() = integer()
+%%% @type agent_config() = {Item, Value} 
+%%% @type user_name() = atom() 
+%%% @type usm_user_name() = string() 
+%%% @type usm_config() = string()  
+%%% @type call_back_module() = atom()
+%%% @type user_data() = term() 
+%%% @type oids() = [oid()]
+%%% @type oid() = [byte()]
+%%% @type snmpreply() = {error_status(), error_index(), varbinds()} 
+%%% @type error_status() = noError | atom() 
+%%% @type error_index() = integer() 
+%%% @type varbinds() = [varbind()] 
+%%% @type varbind() =  term() 
+%%% @type value_type() = o ('OBJECT IDENTIFIER') | i ('INTEGER') | 
+%%% u ('Unsigned32') | g ('Unsigned32') | s ('OCTET STRING') 
+%%% @type varsandvals() = [var_and_val()]
+%%% @type var_and_val() = {oid(), value_type(), value()}
+%%% @type sec_type() = none | minimum | semi
+%%% @type rel_path() = string() 
+%%% @type snmp_app_manager_params() = term()
+%%% @type snmp_app_agent_params() = term()
+
+
+-include("snmp_types.hrl").
+-include("inet.hrl").
+-include("ct.hrl").
+
+%%% API
+-export([start/2, start/3, stop/1, get_values/3, get_next_values/3, set_values/4, 
+	 set_info/1, register_users/2, register_agents/2, register_usm_users/2,
+	 unregister_users/1, unregister_agents/1, update_usm_users/2, 
+	 load_mibs/1]).
+
+%% Manager values
+-define(CT_SNMP_LOG_FILE, "ct_snmp_set.log").
+-define(MGR_PORT, 5000).
+-define(MAX_MSG_SIZE, 484).
+-define(ENGINE_ID, "mgrEngine").
+
+%% Agent values
+-define(AGENT_ENGINE_ID, "agentEngine").
+-define(TRAP_UDP, 5000). 
+-define(AGENT_UDP, 4000).
+-define(CONF_FILE_VER, [v2]).
+-define(AGENT_MAX_MSG_SIZE, 484).
+-define(AGENT_NOTIFY_TYPE, trap).
+-define(AGENT_SEC_TYPE, none).
+-define(AGENT_PASSWD, "").
+%%%=========================================================================
+%%%  API
+%%%=========================================================================
+
+%%%-----------------------------------------------------------------
+%%% @spec start(Config, MgrAgentConfName) -> ok
+%%% @equiv start(Config, MgrAgentConfName, undefined)
+start(Config, MgrAgentConfName) ->
+    start(Config, MgrAgentConfName, undefined).
+
+%%% @spec start(Config, MgrAgentConfName, SnmpAppConfName) -> ok
+%%%      Config = [{Key, Value}] 
+%%%      Key = atom()
+%%%      Value = term()
+%%%      MgrAgentConfName = atom()
+%%%      SnmpConfName = atom()
+%%%
+%%% @doc Starts an snmp manager and/or agent. In the manager case,
+%%% registrations of users and agents as specified by the configuration 
+%%% <code>MgrAgentConfName</code> will be performed. When using snmp
+%%% v3 also so called usm users will be registered. Note that users,
+%%% usm_users and managed agents may also be registered at a later time
+%%% using ct_snmp:register_users/2, ct_snmp:register_agents/2, and
+%%% ct_snmp:register_usm_users/2. The agent started will be
+%%% called <code>snmp_master_agent</code>. Use ct_snmp:load_mibs/1 to load 
+%%% mibs into the agent. With <code>SnmpAppConfName</code> it's possible 
+%%% to configure the snmp application with parameters such as <code>config</code>,
+%%% <code>mibs</code>, <code>net_if</code>, etc. The values will be merged
+%%% with (and possibly override) default values set by <code>ct_snmp</code>.
+start(Config, MgrAgentConfName, SnmpAppConfName) ->
+    StartManager= ct:get_config({MgrAgentConfName, start_manager}, true),
+    StartAgent = ct:get_config({MgrAgentConfName, start_agent}, false),
+   
+    SysName = ct:get_config({MgrAgentConfName, agent_sysname}, "ct_test"),
+    {ok, HostName} = inet:gethostname(),
+    {ok, Addr} = inet:getaddr(HostName, inet),
+    IP = tuple_to_list(Addr),
+    AgentManagerIP = ct:get_config({MgrAgentConfName, agent_manager_ip}, IP),
+    
+    prepare_snmp_env(),
+    setup_agent(StartAgent, MgrAgentConfName, SnmpAppConfName, 
+		Config, SysName, AgentManagerIP, IP),
+    setup_manager(StartManager, MgrAgentConfName, SnmpAppConfName, 
+		  Config, AgentManagerIP),
+    application:start(snmp),
+
+    manager_register(StartManager, MgrAgentConfName).
+ 
+%%% @spec stop(Config) -> ok
+%%%      Config = [{Key, Value}]
+%%%      Key = atom()
+%%%      Value = term()
+%%%
+%%% @doc Stops the snmp manager and/or agent removes all files created.
+stop(Config) ->
+    PrivDir = ?config(priv_dir, Config),
+    application:stop(snmp),
+    application:stop(mnesia),
+    MgrDir =  filename:join(PrivDir,"mgr"),
+    ConfDir = filename:join(PrivDir, "conf"),
+    DbDir = filename:join(PrivDir,"db"),
+    catch del_dir(MgrDir),
+    catch del_dir(ConfDir),
+    catch del_dir(DbDir).
+    
+    
+%%% @spec get_values(Agent, Oids, MgrAgentConfName) -> SnmpReply
+%%%
+%%%	 Agent = agent_name()
+%%%      Oids = oids()
+%%%      MgrAgentConfName = atom()
+%%%      SnmpReply = snmpreply()  
+%%%
+%%% @doc Issues a synchronous snmp get request. 
+get_values(Agent, Oids, MgrAgentConfName) ->
+    [Uid, AgentIp, AgentUdpPort | _] = 
+	agent_conf(Agent, MgrAgentConfName),
+    {ok, SnmpReply, _} =
+	snmpm:g(Uid, AgentIp, AgentUdpPort, Oids),
+    SnmpReply.
+
+%%% @spec get_next_values(Agent, Oids, MgrAgentConfName) -> SnmpReply 
+%%%
+%%%	 Agent = agent_name()
+%%%      Oids = oids()
+%%%      MgrAgentConfName = atom()
+%%%      SnmpReply = snmpreply()  
+%%%
+%%% @doc Issues a synchronous snmp get next request. 
+get_next_values(Agent, Oids, MgrAgentConfName) ->
+    [Uid, AgentIp, AgentUdpPort | _] = 
+	agent_conf(Agent, MgrAgentConfName),
+    {ok, SnmpReply, _} =
+	snmpm:gn(Uid, AgentIp, AgentUdpPort, Oids),
+    SnmpReply.
+
+%%% @spec set_values(Agent, VarsAndVals, MgrAgentConfName, Config) -> SnmpReply
+%%%
+%%%	 Agent = agent_name()
+%%%      Oids = oids()
+%%%      MgrAgentConfName = atom()
+%%%      Config = [{Key, Value}] 
+%%%      SnmpReply = snmpreply()  
+%%%
+%%% @doc Issues a synchronous snmp set request. 
+set_values(Agent, VarsAndVals, MgrAgentConfName, Config) ->
+    PrivDir = ?config(priv_dir, Config),
+    [Uid, AgentIp, AgentUdpPort | _] = 
+	agent_conf(Agent, MgrAgentConfName),
+    Oids = lists:map(fun({Oid, _, _}) -> Oid end, VarsAndVals),
+    {ok, SnmpGetReply, _} =
+	snmpm:g(Uid, AgentIp, AgentUdpPort, Oids),
+    {ok, SnmpSetReply, _} =
+	snmpm:s(Uid, AgentIp, AgentUdpPort, VarsAndVals),
+    case SnmpSetReply of
+	{noError, 0, _} when PrivDir /= false ->
+	    log(PrivDir, Agent, SnmpGetReply, VarsAndVals);
+	_ ->
+	    set_failed_or_user_did_not_want_to_log
+    end,
+    SnmpSetReply.
+
+%%% @spec set_info(Config) -> [{Agent, OldVarsAndVals, NewVarsAndVals}] 
+%%%
+%%%      Config = [{Key, Value}] 
+%%%	 Agent = agent_name()
+%%%      OldVarsAndVals = varsandvals()
+%%%      NewVarsAndVals = varsandvals()
+%%%
+%%% @doc Returns a list of all successful set requests performed in
+%%% the test case in reverse order. The list contains the involved
+%%% user and agent, the value prior to the set and the new value. This
+%%% is intended to facilitate the clean up in the end_per_testcase
+%%% function i.e. the undoing of the set requests and its possible
+%%% side-effects.
+set_info(Config) ->
+    PrivDir = ?config(priv_dir, Config),
+    SetLogFile = filename:join(PrivDir, ?CT_SNMP_LOG_FILE),
+    case file:consult(SetLogFile) of
+	{ok, SetInfo} ->
+	    file:delete(SetLogFile),
+	    lists:reverse(SetInfo);
+	_ ->
+	    []
+    end.
+
+%%% @spec register_users(MgrAgentConfName, Users) -> ok | {error, Reason}
+%%%
+%%%      MgrAgentConfName = atom()
+%%%      Users =  [user()]
+%%%      Reason = term()    
+%%%
+%%% @doc Register the manager entity (=user) responsible for specific agent(s).
+%%% Corresponds to making an entry in users.conf
+register_users(MgrAgentConfName, Users) ->
+    {snmp, SnmpVals} = ct:get_config(MgrAgentConfName),
+    NewSnmpVals = lists:keyreplace(users, 1, SnmpVals, {users, Users}),
+    ct_util:update_config(MgrAgentConfName, {snmp, NewSnmpVals}),
+    setup_users(Users).
+
+%%% @spec register_agents(MgrAgentConfName, ManagedAgents) -> ok | {error, Reason}
+%%%
+%%%      MgrAgentConfName = atom()
+%%%      ManagedAgents = [agent()]
+%%%      Reason = term()    
+%%%
+%%% @doc Explicitly instruct the manager to handle this agent.
+%%% Corresponds to making an entry in agents.conf 
+register_agents(MgrAgentConfName, ManagedAgents) ->
+    {snmp, SnmpVals} = ct:get_config(MgrAgentConfName),
+    NewSnmpVals = lists:keyreplace(managed_agents, 1, SnmpVals,
+				   {managed_agents, ManagedAgents}),
+    ct_util:update_config(MgrAgentConfName, {snmp, NewSnmpVals}),
+    setup_managed_agents(ManagedAgents).
+
+%%% @spec register_usm_users(MgrAgentConfName, UsmUsers) ->  ok | {error, Reason}
+%%%
+%%%      MgrAgentConfName = atom()
+%%%      UsmUsers = [usm_user()]
+%%%      Reason = term()    
+%%%
+%%% @doc Explicitly instruct the manager to handle this USM user.
+%%% Corresponds to making an entry in usm.conf 
+register_usm_users(MgrAgentConfName, UsmUsers) ->
+    {snmp, SnmpVals} = ct:get_config(MgrAgentConfName),
+    NewSnmpVals = lists:keyreplace(users, 1, SnmpVals, {usm_users, UsmUsers}),
+    ct_util:update_config(MgrAgentConfName, {snmp, NewSnmpVals}),
+    EngineID = ct:get_config({MgrAgentConfName, engine_id}, ?ENGINE_ID),
+    setup_usm_users(UsmUsers, EngineID).
+
+%%% @spec unregister_users(MgrAgentConfName) ->  ok | {error, Reason}
+%%%
+%%%      MgrAgentConfName = atom()
+%%%      Reason = term()
+%%%
+%%% @doc Removes information added when calling register_users/2. 
+unregister_users(MgrAgentConfName) ->
+    Users = lists:map(fun({UserName, _}) -> UserName end,
+		      ct:get_config({MgrAgentConfName, users})),
+    {snmp, SnmpVals} = ct:get_config(MgrAgentConfName),
+    NewSnmpVals = lists:keyreplace(users, 1, SnmpVals, {users, []}),
+    ct_util:update_config(MgrAgentConfName, {snmp, NewSnmpVals}),
+    takedown_users(Users).
+
+%%% @spec unregister_agents(MgrAgentConfName) ->  ok | {error, Reason}
+%%%
+%%%      MgrAgentConfName = atom()
+%%%      Reason = term()
+%%%
+%%% @doc  Removes information added when calling register_agents/2. 
+unregister_agents(MgrAgentConfName) ->    
+    ManagedAgents = lists:map(fun({_, [Uid, AgentIP, AgentPort, _]}) -> 
+				      {Uid, AgentIP, AgentPort} 
+			      end,
+			      ct:get_config({MgrAgentConfName, managed_agents})),
+    {snmp, SnmpVals} = ct:get_config(MgrAgentConfName),
+    NewSnmpVals = lists:keyreplace(managed_agents, 1, SnmpVals, 
+				   {managed_agents, []}),
+    ct_util:update_config(MgrAgentConfName, {snmp, NewSnmpVals}),
+    takedown_managed_agents(ManagedAgents).
+
+
+%%% @spec update_usm_users(MgrAgentConfName, UsmUsers) -> ok | {error, Reason}
+%%%
+%%%      MgrAgentConfName = atom()
+%%%      UsmUsers = usm_users()
+%%%      Reason = term()
+%%%
+%%% @doc  Alters information added when calling register_usm_users/2. 
+update_usm_users(MgrAgentConfName, UsmUsers) ->    
+   
+    {snmp, SnmpVals} = ct:get_config(MgrAgentConfName),
+    NewSnmpVals = lists:keyreplace(usm_users, 1, SnmpVals, 
+				   {usm_users, UsmUsers}),
+    ct_util:update_config(MgrAgentConfName, {snmp, NewSnmpVals}),
+    EngineID = ct:get_config({MgrAgentConfName, engine_id}, ?ENGINE_ID),
+    do_update_usm_users(UsmUsers, EngineID). 
+
+%%% @spec load_mibs(Mibs) -> ok | {error, Reason}
+%%%
+%%%      Mibs = [MibName]
+%%%      MibName = string()
+%%%      Reason = term()
+%%%
+%%% @doc Load the mibs into the agent 'snmp_master_agent'.
+load_mibs(Mibs) ->       
+    snmpa:load_mibs(snmp_master_agent, Mibs).
+ 
+
+%%%========================================================================
+%%% Internal functions
+%%%========================================================================
+prepare_snmp_env() ->
+    %% To make sure application:set_env is not overwritten by any
+    %% app-file settings.
+    application:load(snmp),
+    
+    %% Fix for older versions of snmp where there are some
+    %% inappropriate default values for alway starting an 
+    %% agent.
+    application:unset_env(snmp, agent).
+%%%---------------------------------------------------------------------------
+setup_manager(false, _, _, _, _) ->
+    ok;
+setup_manager(true, MgrConfName, SnmpConfName, Config, IP) ->    
+    PrivDir = ?config(priv_dir, Config),
+    MaxMsgSize = ct:get_config({MgrConfName,max_msg_size}, ?MAX_MSG_SIZE),
+    Port = ct:get_config({MgrConfName,mgr_port}, ?MGR_PORT),
+    EngineID = ct:get_config({MgrConfName,engine_id}, ?ENGINE_ID),
+    MgrDir =  filename:join(PrivDir,"mgr"),
+    %%% Users, Agents and Usms are in test suites register after the
+    %%% snmp application is started.
+    Users = [],
+    Agents = [],
+    Usms = [],
+    file:make_dir(MgrDir),
+   
+    snmp_config:write_manager_snmp_files(MgrDir, IP, Port, MaxMsgSize, 
+					 EngineID, Users, Agents, Usms),
+    SnmpEnv = merge_snmp_conf([{config, [{dir, MgrDir},{db_dir, MgrDir},
+					 {verbosity, trace}]},
+			       {server, [{verbosity, trace}]},
+			       {net_if, [{verbosity, trace}]},
+			       {versions, [v1, v2, v3]}],
+			      ct:get_config({SnmpConfName,manager})),
+    application:set_env(snmp, manager, SnmpEnv).
+%%%---------------------------------------------------------------------------
+setup_agent(false,_, _, _, _, _, _) ->
+    ok;
+setup_agent(true, AgentConfName, SnmpConfName, 
+	    Config, SysName, ManagerIP, AgentIP) ->
+    application:start(mnesia),
+    PrivDir = ?config(priv_dir, Config),
+    Vsns = ct:get_config({AgentConfName, agent_vsns}, ?CONF_FILE_VER),
+    TrapUdp = ct:get_config({AgentConfName, agent_trap_udp}, ?TRAP_UDP),
+    AgentUdp = ct:get_config({AgentConfName, agent_udp}, ?AGENT_UDP),
+    NotifType = ct:get_config({AgentConfName, agent_notify_type},
+			      ?AGENT_NOTIFY_TYPE),
+    SecType = ct:get_config({AgentConfName, agent_sec_type}, ?AGENT_SEC_TYPE),
+    Passwd  = ct:get_config({AgentConfName, agent_passwd}, ?AGENT_PASSWD),
+    AgentEngineID = ct:get_config({AgentConfName, agent_engine_id}, 
+				  ?AGENT_ENGINE_ID),
+    AgentMaxMsgSize = ct:get_config({AgentConfName, agent_max_msg_size},
+				    ?MAX_MSG_SIZE),
+    
+    ConfDir = filename:join(PrivDir, "conf"),
+    DbDir = filename:join(PrivDir,"db"),
+    file:make_dir(ConfDir),
+    file:make_dir(DbDir),    
+    snmp_config:write_agent_snmp_files(ConfDir, Vsns, ManagerIP, TrapUdp, 
+				       AgentIP, AgentUdp, SysName, 
+				       atom_to_list(NotifType), 
+				       SecType, Passwd, AgentEngineID, 
+				       AgentMaxMsgSize),
+
+    override_default_configuration(Config, AgentConfName),
+    
+    SnmpEnv = merge_snmp_conf([{db_dir, DbDir},
+			       {config, [{dir, ConfDir},
+					 {verbosity, trace}]},
+			       {agent_type, master},
+			       {agent_verbosity, trace},
+			       {net_if, [{verbosity, trace}]}],
+			      ct:get_config({SnmpConfName,agent})),
+    application:set_env(snmp, agent, SnmpEnv).
+%%%---------------------------------------------------------------------------
+merge_snmp_conf(Defaults, undefined) ->
+    Defaults;
+merge_snmp_conf([Def={Key,DefList=[P|_]}|DefParams], UserParams) when is_tuple(P) ->
+    case lists:keysearch(Key, 1, UserParams) of
+	false ->
+	    [Def | merge_snmp_conf(DefParams, UserParams)];
+	{value,{Key,UserList}} ->
+	    DefList1 = [{SubKey,Val} || {SubKey,Val} <- DefList, 
+					lists:keysearch(SubKey, 1, UserList) == false],
+	    [{Key,DefList1++UserList} | merge_snmp_conf(DefParams, 
+							lists:keydelete(Key, 1, UserParams))]
+    end;
+merge_snmp_conf([Def={Key,_}|DefParams], UserParams) ->
+    case lists:keysearch(Key, 1, UserParams) of
+	false ->
+	    [Def | merge_snmp_conf(DefParams, UserParams)];
+	{value,_} ->
+	    merge_snmp_conf(DefParams, UserParams)
+    end;
+merge_snmp_conf([], UserParams) ->
+    UserParams.
+			      
+
+%%%---------------------------------------------------------------------------
+manager_register(false, _) ->
+    ok;
+manager_register(true, MgrAgentConfName) ->
+    Agents = ct:get_config({MgrAgentConfName, managed_agents}, []),
+    Users = ct:get_config({MgrAgentConfName, users}, []),
+    UsmUsers = ct:get_config({MgrAgentConfName, usm_users}, []),
+    EngineID = ct:get_config({MgrAgentConfName, engine_id}, ?ENGINE_ID),
+
+    setup_usm_users(UsmUsers, EngineID),
+    setup_users(Users),
+    setup_managed_agents(Agents).
+
+%%%---------------------------------------------------------------------------
+setup_users(Users) ->
+    lists:foreach(fun({Id, [Module, Data]}) ->
+			  snmpm:register_user(Id, Module, Data)
+		  end, Users).
+%%%---------------------------------------------------------------------------   
+setup_managed_agents([]) ->
+    ok;
+
+setup_managed_agents([{_, [Uid, AgentIp, AgentUdpPort, AgentConf]} |
+		      Rest]) ->
+    NewAgentIp = case AgentIp of
+		     IpTuple when is_tuple(IpTuple) ->
+			 IpTuple;
+		     HostName when is_list(HostName) ->
+			 {ok,Hostent} = inet:gethostbyname(HostName),
+			 [IpTuple|_] = Hostent#hostent.h_addr_list,
+			 IpTuple
+		 end,
+    ok = snmpm:register_agent(Uid, NewAgentIp, AgentUdpPort),   
+    lists:foreach(fun({Item, Val}) ->
+			  snmpm:update_agent_info(Uid, NewAgentIp, 
+						  AgentUdpPort, Item, Val)
+		  end, AgentConf),
+    setup_managed_agents(Rest).
+%%%---------------------------------------------------------------------------
+setup_usm_users(UsmUsers, EngineID)->
+    lists:foreach(fun({UsmUser, Conf}) ->
+			  snmpm:register_usm_user(EngineID, UsmUser, Conf)
+		  end, UsmUsers).
+%%%---------------------------------------------------------------------------
+takedown_users(Users) ->
+     lists:foreach(fun({Id}) ->
+			  snmpm:unregister_user(Id)
+		   end, Users).
+%%%---------------------------------------------------------------------------
+takedown_managed_agents([{Uid, AgentIp, AgentUdpPort} |
+			 Rest]) ->
+    NewAgentIp = case AgentIp of
+		     IpTuple when is_tuple(IpTuple) ->
+			 IpTuple;
+		     HostName when is_list(HostName) ->
+			 {ok,Hostent} = inet:gethostbyname(HostName),
+			 [IpTuple|_] = Hostent#hostent.h_addr_list,
+			 IpTuple
+		 end,
+    ok = snmpm:unregister_agent(Uid, NewAgentIp, AgentUdpPort),   
+    takedown_managed_agents(Rest);
+
+takedown_managed_agents([]) ->
+    ok.
+%%%---------------------------------------------------------------------------
+do_update_usm_users(UsmUsers, EngineID) ->
+    lists:foreach(fun({UsmUser, {Item, Val}}) ->
+			  snmpm:update_usm_user_info(EngineID, UsmUser, 
+						     Item, Val)
+		  end, UsmUsers).
+%%%---------------------------------------------------------------------------  
+log(PrivDir, Agent, {_, _, Varbinds}, NewVarsAndVals) ->
+
+    Fun = fun(#varbind{oid = Oid, variabletype = Type, value = Value}) ->
+		  {Oid, Type, Value} 
+	  end,
+    OldVarsAndVals = lists:map(Fun, Varbinds),
+    
+    File = filename:join(PrivDir, ?CT_SNMP_LOG_FILE),
+    {ok, Fd} = file:open(File, [write, append]),
+    io:format(Fd, "~p.~n", [{Agent, OldVarsAndVals, NewVarsAndVals}]),
+    file:close(Fd),
+    ok.
+%%%---------------------------------------------------------------------------
+del_dir(Dir) ->
+    {ok, Files} = file:list_dir(Dir),
+    FullPathFiles = lists:map(fun(File) -> filename:join(Dir, File) end,
+			      Files),
+    lists:foreach(fun file:delete/1, FullPathFiles), 
+    file:del_dir(Dir),
+    ok.
+%%%---------------------------------------------------------------------------
+agent_conf(Agent, MgrAgentConfName) ->
+    Agents = ct:get_config({MgrAgentConfName, managed_agents}),
+    case lists:keysearch(Agent, 1, Agents) of
+	{value, {Agent, AgentConf}} ->
+	    AgentConf;
+	_ ->
+	    exit({error, {unknown_agent, Agent, Agents}})
+    end.
+%%%---------------------------------------------------------------------------
+override_default_configuration(Config, MgrAgentConfName) ->
+    override_contexts(Config,
+		      ct:get_config({MgrAgentConfName, agent_contexts}, undefined)),
+    override_community(Config,
+		       ct:get_config({MgrAgentConfName, agent_community}, undefined)),
+    override_sysinfo(Config,
+		     ct:get_config({MgrAgentConfName, agent_sysinfo}, undefined)),
+    override_vacm(Config,
+		  ct:get_config({MgrAgentConfName, agent_vacm}, undefined)),
+    override_usm(Config,
+		 ct:get_config({MgrAgentConfName, agent_usm}, undefined)),
+    override_notify(Config,
+		    ct:get_config({MgrAgentConfName, agent_notify_def}, undefined)),
+    override_target_address(Config,
+			    ct:get_config({MgrAgentConfName, 
+					   agent_target_address_def}, 
+					  undefined)),
+    override_target_params(Config, 
+			   ct:get_config({MgrAgentConfName, agent_target_param_def},
+					 undefined)).
+
+%%%---------------------------------------------------------------------------
+override_contexts(_, undefined) ->
+    ok;
+
+override_contexts(Config, {data_dir_file, File}) ->
+    Dir = ?config(data_dir, Config),
+    FullPathFile = filename:join(Dir, File),
+    {ok, ContextInfo} = file:consult(FullPathFile),
+    override_contexts(Config, ContextInfo);
+
+override_contexts(Config, Contexts) ->
+    Dir = ?config(priv_dir, Config),    
+    File = filename:join(Dir,"context.conf"),
+    file:delete(File),
+    snmp_config:write_agent_context_config(Dir, "", Contexts).
+		
+%%%---------------------------------------------------------------------------
+override_sysinfo(_, undefined) ->
+    ok;
+
+override_sysinfo(Config, {data_dir_file, File}) ->
+    Dir = ?config(data_dir, Config),
+    FullPathFile = filename:join(Dir, File),
+    {ok, SysInfo} = file:consult(FullPathFile),
+    override_sysinfo(Config, SysInfo);
+
+override_sysinfo(Config, SysInfo) ->   
+    Dir = ?config(priv_dir, Config),  
+    File = filename:join(Dir,"standard.conf"),
+    file:delete(File),
+    snmp_config:write_agent_standard_config(Dir, "", SysInfo).
+
+%%%---------------------------------------------------------------------------
+override_target_address(_, undefined) ->
+    ok;
+override_target_address(Config, {data_dir_file, File}) ->
+    Dir = ?config(data_dir, Config),
+    FullPathFile = filename:join(Dir, File),
+    {ok, TargetAddressConf} = file:consult(FullPathFile),
+    override_target_address(Config, TargetAddressConf);
+
+override_target_address(Config, TargetAddressConf) ->
+    Dir = ?config(priv_dir, Config),  
+    File = filename:join(Dir,"target_addr.conf"),
+    file:delete(File),
+    snmp_config:write_agent_target_addr_config(Dir, "", TargetAddressConf).
+
+
+%%%---------------------------------------------------------------------------
+override_target_params(_, undefined) ->
+    ok;
+override_target_params(Config, {data_dir_file, File}) ->
+    Dir = ?config(data_dir, Config),
+    FullPathFile = filename:join(Dir, File),
+    {ok, TargetParamsConf} = file:consult(FullPathFile),
+    override_target_params(Config, TargetParamsConf);
+
+override_target_params(Config, TargetParamsConf) ->
+    Dir = ?config(priv_dir, Config),  
+    File = filename:join(Dir,"target_params.conf"),
+    file:delete(File),
+    snmp_config:write_agent_target_params_config(Dir, "", TargetParamsConf). 
+
+%%%---------------------------------------------------------------------------
+override_notify(_, undefined) ->
+    ok;
+override_notify(Config, {data_dir_file, File}) ->
+    Dir = ?config(data_dir, Config),
+    FullPathFile = filename:join(Dir, File),
+    {ok, NotifyConf} = file:consult(FullPathFile),
+    override_notify(Config, NotifyConf);
+
+override_notify(Config, NotifyConf) ->
+    Dir = ?config(priv_dir, Config),  
+    File = filename:join(Dir,"notify.conf"),
+    file:delete(File),
+    snmp_config:write_agent_notify_config(Dir, "", NotifyConf).
+
+%%%---------------------------------------------------------------------------
+override_usm(_, undefined) ->
+    ok;
+override_usm(Config, {data_dir_file, File}) ->
+    Dir = ?config(data_dir, Config),
+    FullPathFile = filename:join(Dir, File),
+    {ok, UsmConf} = file:consult(FullPathFile),
+    override_usm(Config, UsmConf);
+
+override_usm(Config, UsmConf) ->
+    Dir = ?config(priv_dir, Config),  
+    File = filename:join(Dir,"usm.conf"),
+    file:delete(File),
+    snmp_config:write_agent_usm_config(Dir, "", UsmConf).
+
+%%%--------------------------------------------------------------------------
+override_community(_, undefined) ->
+    ok;
+override_community(Config, {data_dir_file, File}) ->
+    Dir = ?config(data_dir, Config),
+    FullPathFile = filename:join(Dir, File),
+    {ok, CommunityConf} = file:consult(FullPathFile),
+    override_community(Config, CommunityConf);
+
+override_community(Config, CommunityConf) ->
+    Dir = ?config(priv_dir, Config),  
+    File = filename:join(Dir,"community.conf"),
+    file:delete(File),
+    snmp_config:write_agent_community_config(Dir, "", CommunityConf).
+   
+%%%---------------------------------------------------------------------------
+
+override_vacm(_, undefined) ->
+    ok;
+override_vacm(Config, {data_dir_file, File}) ->
+    Dir = ?config(data_dir, Config),
+    FullPathFile = filename:join(Dir, File),
+    {ok, VacmConf} = file:consult(FullPathFile),
+    override_vacm(Config, VacmConf);
+
+override_vacm(Config, VacmConf) ->
+    Dir = ?config(priv_dir, Config),  
+       File = filename:join(Dir,"vacm.conf"),
+    file:delete(File),
+    snmp_config:write_agent_vacm_config(Dir, "", VacmConf).
diff --git a/lib/common_test/src/ct_ssh.erl b/lib/common_test/src/ct_ssh.erl
new file mode 100644
index 0000000000..f2b25b1fcd
--- /dev/null
+++ b/lib/common_test/src/ct_ssh.erl
@@ -0,0 +1,1346 @@
+%%
+%% %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%
+%%
+
+%%% @doc SSH/SFTP client module. 
+%%%
+%%% <p>ct_ssh uses the OTP ssh application and more detailed information 
+%%% about e.g. functions, types and options can be found in the 
+%%% documentation for this application.</p>
+%%%
+%%% <p>The <code>Server</code> argument in the SFTP functions should
+%%% only be used for SFTP sessions that have been started on existing
+%%% SSH connections (i.e. when the original connection type is 
+%%% <code>ssh</code>). Whenever the connection type is
+%%% <code>sftp</code>, use the SSH connection reference only.</p>
+%%%
+%%% <p>The following options are valid for specifying an SSH/SFTP
+%%% connection (i.e. may be used as config elements):</p> 
+%%%
+%%% <pre>
+%%%
+%%%  [{ConnType, Addr},
+%%%   {port, Port},
+%%%   {user, UserName}
+%%%   {password, Pwd}
+%%%   {user_dir, String}
+%%%   {public_key_alg, PubKeyAlg}
+%%%   {connect_timeout, Timeout}
+%%%   {key_cb, KeyCallbackMod}]
+%%% </pre>
+%%%
+%%% <p><code>ConnType = ssh | sftp</code>.</p> 
+%%% <p>Please see ssh(3) for other types.</p>
+%%%
+%%% <p>All timeout parameters in ct_ssh functions are values in
+%%% milliseconds.</p>
+%%%
+%%% @type connection() = handle() | ct:target_name()
+%%% @type handle() = ct_gen_conn:handle(). Handle for a specific
+%%% SSH/SFTP connection.
+%%% @type ssh_sftp_return() = term(). A return value from an ssh_sftp function.
+
+-module(ct_ssh).
+
+%% SSH Functions
+-export([connect/1, connect/2, connect/3,
+ 	 disconnect/1,
+ 	 session_open/1, session_open/2,
+ 	 session_close/2,
+ 	 send/3, send/4, send/5,
+ 	 receive_response/2, receive_response/3, receive_response/4,
+ 	 send_and_receive/3, send_and_receive/4, send_and_receive/5,
+	 send_and_receive/6,
+ 	 exec/2, exec/3, exec/4,
+ 	 subsystem/3, subsystem/4]).
+
+%% STFP Functions
+-export([sftp_connect/1, 
+
+	 read_file/2, write_file/3, list_dir/2, open/3, opendir/2, 
+	 close/2, read/3, pread/4, aread/3, apread/4, write/3, 
+	 pwrite/4, awrite/3, apwrite/4, position/3, read_file_info/2, 
+	 get_file_info/2, read_link_info/2, write_file_info/3, 
+	 read_link/2, make_symlink/3, rename/3, delete/2, make_dir/2, 
+	 del_dir/2,
+
+	 read_file/3, write_file/4, list_dir/3, open/4, opendir/3, 
+	 close/3, read/4, pread/5, aread/4, apread/5, write/4, 
+	 pwrite/5, awrite/4, apwrite/5, position/4, read_file_info/3, 
+	 get_file_info/3, read_link_info/3, write_file_info/4, 
+	 read_link/3, make_symlink/4, rename/4, delete/3, make_dir/3, 
+	 del_dir/3]).
+
+%% Callbacks
+-export([init/3, handle_msg/2, reconnect/2, terminate/2, close/1]).
+
+-define(DEFAULT_TIMEOUT, 10000).
+
+-record(state, {ssh_ref, conn_type, target}).
+
+
+%%%-----------------------------------------------------------------
+%%%------------------------ SSH COMMANDS ---------------------------
+
+%%%-----------------------------------------------------------------
+%%% @spec connect(KeyOrName) -> {ok,Handle} | {error,Reason}
+%%% @equiv connect(KeyOrName,host,[])
+connect(KeyOrName) ->
+    connect(KeyOrName, host).
+
+%%%-----------------------------------------------------------------
+%%% @spec connect(KeyOrName,ConnType) -> {ok,Handle} | {error,Reason}
+%%% @equiv connect(KeyOrName,ConnType,[])
+connect(KeyOrName, ConnType) when is_atom(ConnType) ->
+    connect(KeyOrName, ConnType, []);
+
+%%%-----------------------------------------------------------------
+%%% @spec connect(KeyOrName,ExtraOpts) -> {ok,Handle} | {error,Reason}
+%%% @equiv connect(KeyOrName,host,ExtraOpts)
+connect(KeyOrName, ExtraOpts) when is_list(ExtraOpts) ->
+    connect(KeyOrName, host, ExtraOpts).
+
+%%%-----------------------------------------------------------------
+%%% @spec connect(KeyOrName,ConnType,ExtraOpts) -> 
+%%%          {ok,Handle} | {error,Reason}
+%%%      KeyOrName = Key | Name
+%%%      Key = atom()
+%%%      Name = ct:target_name()
+%%%      ConnType = ssh | sftp | host
+%%%      ExtraOpts = ssh_connect_options()
+%%%      Handle = handle()
+%%%      Reason = term()
+%%%
+%%% @doc Open an SSH or SFTP connection using the information
+%%%      associated with <code>KeyOrName</code>. 
+%%%
+%%%      <p>If <code>Name</code> (an alias name for <code>Key</code>), 
+%%%      is used to identify the connection, this name may
+%%%      be used as connection reference for subsequent calls.
+%%%      It's only possible to have one open connection at a time 
+%%%      associated with <code>Name</code>. If <code>Key</code> is 
+%%%      used, the returned handle must be used for subsequent calls
+%%%      (multiple connections may be opened using the config
+%%%      data specified by <code>Key</code>).</p>
+%%%
+%%%      <p><code>ConnType</code> will always override the type
+%%%      specified in the address tuple in the configuration data (and
+%%%      in <code>ExtraOpts</code>). So it is possible to for example 
+%%%      open an sftp connection directly using data originally
+%%%      specifying an ssh connection. The value <code>host</code>
+%%%      means the connection type specified by the host option
+%%%      (either in the configuration data or in <code>ExtraOpts</code>)
+%%%      will be used.</p>
+%%%
+%%%      <p><code>ExtraOpts</code> (optional) are extra SSH options 
+%%%      to be added to the config data for <code>KeyOrName</code>. 
+%%%      The extra options will override any existing options with the
+%%%      same key in the config data. For details on valid SSH
+%%%      options, see the documentation for the OTP ssh application.</p>
+connect(KeyOrName, ConnType, ExtraOpts) ->
+    case ct:get_config(KeyOrName) of
+	undefined ->
+	    log(heading(connect,KeyOrName), "Failed: ~p\n",
+		[{not_available,KeyOrName}]),
+	    {error,{not_available,KeyOrName}};
+	SSHData ->
+	    AllOpts = ExtraOpts++SSHData,
+	    {ConnType1,Addr,AllOpts1} =
+		case ConnType of
+		    host ->
+			case proplists:get_value(ssh, AllOpts) of
+			    undefined ->
+				case proplists:get_value(sftp, AllOpts) of
+				    undefined ->
+					log(heading(connect,KeyOrName), 
+					    "No host information specified!\n",[]);
+				    SFTPAddr ->
+					{sftp,SFTPAddr,AllOpts}
+				end;
+			    SSHAddr ->
+				{ssh,SSHAddr,AllOpts}
+			end;
+		    _ ->
+			case proplists:get_value(ConnType, AllOpts) of
+			    undefined when ConnType == ssh ->
+				case proplists:get_value(sftp, AllOpts) of
+				    undefined ->
+					{ssh,undefined,AllOpts};
+				    SFTPAddr ->
+					log(heading(connect,KeyOrName), 
+					    "Note: Opening ssh connection to sftp host.\n",
+					    []),
+					{ssh,SFTPAddr,
+					 [{ssh,SFTPAddr}|proplists:delete(sftp, AllOpts)]}
+				end;
+			    undefined when ConnType == sftp ->
+				case proplists:get_value(ssh, AllOpts) of
+				    undefined ->
+					{sftp,undefined,AllOpts};
+				    SSHAddr ->
+					log(heading(connect,KeyOrName), 
+					    "Note: Opening sftp connection to ssh host.\n",
+					    []),
+					{sftp,SSHAddr,
+					 [{sftp,SSHAddr}|proplists:delete(ssh, AllOpts)]}
+				end;
+			    SSHorSFTPAddr ->
+				{ConnType,SSHorSFTPAddr,AllOpts}
+			end
+		end,
+	    case {Addr,proplists:get_value(port, AllOpts1)} of
+		{undefined,_} ->
+		    log(heading(connect,KeyOrName), "Failed: ~p\n",
+			[{not_available,{KeyOrName,ConnType1}}]),
+		    {error,{not_available,{KeyOrName,ConnType1}}};
+		{_,undefined} ->
+		    log(heading(connect,KeyOrName), 
+			"Opening ~w connection to ~p:22\n",
+			[ConnType1,Addr]),
+		    ct_gen_conn:start(KeyOrName, {ConnType1,Addr,22}, 
+				      AllOpts1, ?MODULE);		    
+		{_,Port} ->
+		    log(heading(connect,KeyOrName), 
+			"Opening ~w connection to ~p:~w\n",
+			[ConnType1,Addr,Port]),
+		    ct_gen_conn:start(KeyOrName, {ConnType1,Addr,Port}, 
+				      AllOpts1, ?MODULE)
+	    end
+    end.
+
+%%%-----------------------------------------------------------------
+%%% @spec disconnect(SSH) -> ok | {error,Reason}
+%%%      SSH = connection()
+%%%      Reason = term()
+%%%
+%%% @doc Close an SSH/SFTP connection.
+disconnect(SSH) ->
+    case get_handle(SSH) of
+	{ok,Pid} ->
+	    log(heading(disconnect,SSH), "Handle: ~p", [Pid]),
+	    case ct_gen_conn:stop(Pid) of
+		{error,{process_down,Pid,noproc}} ->
+		    {error,already_closed};
+		Result ->
+		    Result
+	    end;
+	Error ->
+	    Error
+    end.
+
+%%%-----------------------------------------------------------------
+%%% @spec session_open(SSH) -> {ok,ChannelId} | {error, Reason}
+%%% @equiv session_open(SSH,DefaultTimeout) 
+session_open(SSH) ->
+    call(SSH, {session_open,?DEFAULT_TIMEOUT}).
+
+%%%-----------------------------------------------------------------
+%%% @spec session_open(SSH,Timeout) -> {ok,ChannelId} | {error, Reason}
+%%%      SSH = connection()
+%%%      Timeout = integer()
+%%%      ChannelId = integer()
+%%%      Reason = term()
+%%%
+%%% @doc Opens a channel for an SSH session.
+session_open(SSH, Timeout) ->
+    call(SSH, {session_open,Timeout}).
+
+%%%-----------------------------------------------------------------
+%%% @spec session_close(SSH,ChannelId) -> ok | {error, Reason}
+%%%      SSH = connection()
+%%%      ChannelId = integer()
+%%%      Reason = term()
+%%%
+%%% @doc Closes an SSH session channel.
+session_close(SSH, ChannelId) ->
+    call(SSH, {session_close,ChannelId}).
+
+%%%-----------------------------------------------------------------
+%%% @spec exec(SSH,Command) -> {ok,Data} | {error,Reason}
+%%% @equiv exec(SSH,Command,DefaultTimeout)
+exec(SSH, Command) ->
+    exec(SSH, undefined, Command, ?DEFAULT_TIMEOUT).
+
+%%%-----------------------------------------------------------------
+%%% @spec exec(SSH,Command,Timeout) -> {ok,Data} | {error,Reason}
+%%%      SSH = connection()
+%%%      Command = string()
+%%%      Timeout = integer()
+%%%      Data = list()
+%%%      Reason = term()
+%%% 
+%%% @doc Requests server to perform <code>Command</code>. A session
+%%%      channel is opened automatically for the request.
+%%%      <code>Data</code> is received from the server as a result
+%%%      of the command.
+exec(SSH, Command, Timeout) when is_list(Command) ->
+    exec(SSH, undefined, Command, Timeout);
+
+%%%-----------------------------------------------------------------
+%%% @spec exec(SSH,ChannelId,Command) -> {ok,Data} | {error,Reason}
+%%% @equiv exec(SSH,ChannelId,Command,DefaultTimeout)
+exec(SSH, ChannelId, Command) when is_integer(ChannelId) ->
+    exec(SSH, ChannelId, Command, ?DEFAULT_TIMEOUT).
+
+%%%-----------------------------------------------------------------
+%%% @spec exec(SSH,ChannelId,Command,Timeout) -> {ok,Data} | {error,Reason}
+%%%      SSH = connection()
+%%%      ChannelId = integer()
+%%%      Command = string()
+%%%      Timeout = integer()
+%%%      Data = list()
+%%%      Reason = term()
+%%% 
+%%% @doc Requests server to perform <code>Command</code>. A previously
+%%%      opened session channel is used for the request.
+%%%      <code>Data</code> is received from the server as a result
+%%%      of the command.
+exec(SSH, ChannelId, Command, Timeout) ->
+    call(SSH, {exec,ChannelId,Command,Timeout}).
+
+%%%-----------------------------------------------------------------
+%%% @spec receive_response(SSH,ChannelId) -> {ok,Data} | {error,Reason}
+%%% @equiv receive_response(SSH,ChannelId,close)
+receive_response(SSH, ChannelId) ->
+    receive_response(SSH, ChannelId, close, ?DEFAULT_TIMEOUT).
+
+%%%-----------------------------------------------------------------
+%%% @spec receive_response(SSH,ChannelId,End) -> {ok,Data} | {error,Reason}
+%%% @equiv receive_response(SSH,ChannelId,End,DefaultTimeout)
+receive_response(SSH, ChannelId, End) when is_function(End) ->
+    receive_response(SSH, ChannelId, End, ?DEFAULT_TIMEOUT);
+
+%%%-----------------------------------------------------------------
+%%% @spec receive_response(SSH,ChannelId,Timeout) -> {ok,Data} | {error,Reason}
+%%% @equiv receive_response(SSH,ChannelId,close,Timeout)
+receive_response(SSH, ChannelId, Timeout) when is_integer(Timeout) ->
+    receive_response(SSH, ChannelId, close, Timeout).
+
+%%%-----------------------------------------------------------------
+%%% @spec receive_response(SSH,ChannelId,End,Timeout) -> 
+%%%                    {ok,Data} | {timeout,Data} | {error,Reason}
+%%%      SSH = connection()
+%%%      ChannelId = integer()
+%%%      End = Fun | close | timeout
+%%%      Timeout = integer()
+%%%      Data = list()
+%%%      Reason = term()
+%%%      
+%%% @doc Receives expected data from server on the specified
+%%%      session channel. 
+%%%
+%%%      <p>If <code>End == close</code>, data is returned
+%%%      to the caller when the channel is closed by the
+%%%      server. If a timeout occurs before this happens,
+%%%      the function returns <code>{timeout,Data}</code>
+%%%      (where <code>Data</code> is the data received so far).
+%%%      If <code>End == timeout</code>, a timeout is expected
+%%%      and <code>{ok,Data}</code> is returned both in the case
+%%%      of a timeout and when the channel is closed. If 
+%%%      <code>End</code> is a fun, this fun will be
+%%%      called with one argument - the data value in a received
+%%%      <code>ssh_cm</code> message (see ssh_connection(3)). The
+%%%      fun should return <code>true</code> to end the receiving 
+%%%      operation (and have the so far collected data returned), or
+%%%      <code>false</code> to wait for more data from the server.
+%%%      (Note that even if a fun is supplied, the function returns
+%%%      immediately if the server closes the channel).</p>
+receive_response(SSH, ChannelId, End, Timeout) ->
+    call(SSH, {receive_response,ChannelId,End,Timeout}).
+
+%%%-----------------------------------------------------------------
+%%% @spec send(SSH,ChannelId,Data) -> ok | {error,Reason}
+%%% @equiv send(SSH,ChannelId,0,Data,DefaultTimeout)
+send(SSH, ChannelId, Data) ->
+    send(SSH, ChannelId, 0, Data, ?DEFAULT_TIMEOUT).
+
+%%%-----------------------------------------------------------------
+%%% @spec send(SSH,ChannelId,Data,Timeout) -> ok | {error,Reason}
+%%% @equiv send(SSH,ChannelId,0,Data,Timeout)
+send(SSH, ChannelId, Data, Timeout) when is_integer(Timeout) ->
+    send(SSH, ChannelId, 0, Data, Timeout);
+
+%%%-----------------------------------------------------------------
+%%% @spec send(SSH,ChannelId,Type,Data) -> ok | {error,Reason}
+%%% @equiv send(SSH,ChannelId,Type,Data,DefaultTimeout)
+send(SSH, ChannelId, Type, Data) when is_integer(Type) ->
+    send(SSH, ChannelId, Type, Data, ?DEFAULT_TIMEOUT).
+
+%%%-----------------------------------------------------------------
+%%% @spec send(SSH,ChannelId,Type,Data,Timeout) -> ok | {error,Reason}
+%%%      SSH = connection()
+%%%      ChannelId = integer()
+%%%      Type = integer()
+%%%      Data = list()
+%%%      Timeout = integer()
+%%%      Reason = term()
+%%% 
+%%% @doc Send data to server on specified session channel.
+send(SSH, ChannelId, Type, Data, Timeout) ->
+    call(SSH, {send,ChannelId,Type,Data,Timeout}).
+
+%%%-----------------------------------------------------------------
+%%% @spec send_and_receive(SSH,ChannelId,Data) -> 
+%%%                   {ok,Data} | {error,Reason}
+%%% @equiv send_and_receive(SSH,ChannelId,Data,close)
+send_and_receive(SSH, ChannelId, Data) ->
+    send_and_receive(SSH, ChannelId, 0, Data, close, ?DEFAULT_TIMEOUT).
+
+%%%-----------------------------------------------------------------
+%%% @spec send_and_receive(SSH,ChannelId,Data,End) -> 
+%%%                   {ok,Data} | {error,Reason}
+%%% @equiv send_and_receive(SSH,ChannelId,0,Data,End,DefaultTimeout)
+send_and_receive(SSH, ChannelId, Data, End) when is_function(End) ->
+    send_and_receive(SSH, ChannelId, 0, Data, End, ?DEFAULT_TIMEOUT);
+
+%%%-----------------------------------------------------------------
+%%% @spec send_and_receive(SSH,ChannelId,Data,Timeout) -> 
+%%%                   {ok,Data} | {error,Reason}
+%%% @equiv send_and_receive(SSH,ChannelId,0,Data,close,Timeout)
+send_and_receive(SSH, ChannelId, Data, Timeout) when is_integer(Timeout) ->
+    send_and_receive(SSH, ChannelId, 0, Data, close, Timeout);
+
+%%%-----------------------------------------------------------------
+%%% @spec send_and_receive(SSH,ChannelId,Type,Data) -> 
+%%%                   {ok,Data} | {error,Reason}
+%%% @equiv send_and_receive(SSH,ChannelId,Type,Data,close,DefaultTimeout)
+send_and_receive(SSH, ChannelId, Type, Data) when is_integer(Type) ->
+    send_and_receive(SSH, ChannelId, Type, Data, close, ?DEFAULT_TIMEOUT).
+
+%%%-----------------------------------------------------------------
+%%% @spec send_and_receive(SSH,ChannelId,Data,End,Timeout) -> 
+%%%                   {ok,Data} | {error,Reason}
+%%% @equiv send_and_receive(SSH,ChannelId,0,Data,End,Timeout)
+send_and_receive(SSH, ChannelId, Data, End, Timeout) when is_integer(Timeout) ->
+    send_and_receive(SSH, ChannelId, 0, Data, End, Timeout);
+
+%%%-----------------------------------------------------------------
+%%% @spec send_and_receive(SSH,ChannelId,Type,Data,Timeout) -> 
+%%%                   {ok,Data} | {error,Reason}
+%%% @equiv send_and_receive(SSH,ChannelId,Type,Data,close,Timeout)
+send_and_receive(SSH, ChannelId, Type, Data, Timeout) when is_integer(Type) ->
+    send_and_receive(SSH, ChannelId, Type, Data, close, Timeout);
+
+%%%-----------------------------------------------------------------
+%%% @spec send_and_receive(SSH,ChannelId,Type,Data,End) -> 
+%%%                   {ok,Data} | {error,Reason}
+%%% @equiv send_and_receive(SSH,ChannelId,Type,Data,End,DefaultTimeout)
+send_and_receive(SSH, ChannelId, Type, Data, End) when is_function(End) ->
+    send_and_receive(SSH, ChannelId, Type, Data, End, ?DEFAULT_TIMEOUT).
+
+%%%-----------------------------------------------------------------
+%%% @spec send_and_receive(SSH,ChannelId,Type,Data,End,Timeout) -> 
+%%%                   {ok,Data} | {error,Reason}
+%%%      SSH = connection()
+%%%      ChannelId = integer()
+%%%      Type = integer()
+%%%      Data = list()
+%%%      End = Fun | close | timeout
+%%%      Timeout = integer()
+%%%      Reason = term()
+%%%
+%%% @doc Send data to server on specified session channel and wait
+%%%      to receive the server response. 
+%%%
+%%%      <p>See <code>receive_response/4</code> for details on the 
+%%%      <code>End</code> argument.</p>
+send_and_receive(SSH, ChannelId, Type, Data, End, Timeout) ->
+    call(SSH, {send_and_receive,ChannelId,Type,Data,End,Timeout}).
+
+%%%-----------------------------------------------------------------
+%%% @spec subsystem(SSH,ChannelId,Subsystem) -> Status | {error,Reason}
+%%% @equiv subsystem(SSH,ChannelId,Subsystem,DefaultTimeout)
+subsystem(SSH, ChannelId, Subsystem) ->
+    subsystem(SSH, ChannelId, Subsystem, ?DEFAULT_TIMEOUT).
+
+%%%-----------------------------------------------------------------
+%%% @spec subsystem(SSH,ChannelId,Subsystem,Timeout) -> 
+%%%             Status | {error,Reason}
+%%%      SSH = connection()
+%%%      ChannelId = integer()
+%%%      Subsystem = string()
+%%%      Timeout = integer()
+%%%      Status = success | failure
+%%%      Reason = term()
+%%% 
+%%% @doc Sends a request to execute a predefined subsystem.
+subsystem(SSH, ChannelId, Subsystem, Timeout) ->
+    call(SSH, {subsystem,ChannelId,Subsystem,Timeout}).
+
+
+%%%-----------------------------------------------------------------
+%%%------------------------ SFTP COMMANDS --------------------------
+
+%%%-----------------------------------------------------------------
+%%% @spec sftp_connect(SSH) -> {ok,Server} | {error,Reason}
+%%%      SSH = connection()
+%%%      Server = pid()
+%%%      Reason = term()
+%%% @doc Starts an SFTP session on an already existing SSH connection.
+%%%      <code>Server</code> identifies the new session and must be
+%%%      specified whenever SFTP requests are to be sent.
+sftp_connect(SSH) ->
+    call(SSH, sftp_connect).
+
+%%%-----------------------------------------------------------------
+%%% @spec read_file(SSH, File) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+read_file(SSH, File) ->
+    call(SSH, {read_file,sftp,File}).
+%%%-----------------------------------------------------------------
+%%% @spec read_file(SSH, Server, File) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+read_file(SSH, Server, File) ->
+    call(SSH, {read_file,Server,File}).
+
+%%%-----------------------------------------------------------------
+%%% @spec write_file(SSH, File, Iolist) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+write_file(SSH, File, Iolist) ->
+    call(SSH, {write_file,sftp,File,Iolist}).
+%%%-----------------------------------------------------------------
+%%% @spec write_file(SSH, Server, File, Iolist) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+write_file(SSH, Server, File, Iolist) ->
+    call(SSH, {write_file,Server,File,Iolist}).
+
+%%%-----------------------------------------------------------------
+%%% @spec list_dir(SSH, Path) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+list_dir(SSH, Path) ->
+    call(SSH, {list_dir,sftp,Path}).
+%%%-----------------------------------------------------------------
+%%% @spec list_dir(SSH, Server, Path) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+list_dir(SSH, Server, Path) ->
+    call(SSH, {list_dir,Server,Path}).
+
+%%%-----------------------------------------------------------------
+%%% @spec open(SSH, File, Mode) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+open(SSH, File, Mode) ->
+    call(SSH, {open,sftp,File,Mode}).
+%%%-----------------------------------------------------------------
+%%% @spec open(SSH, Server, File, Mode) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+open(SSH, Server, File, Mode) ->
+    call(SSH, {open,Server,File,Mode}).
+
+%%%-----------------------------------------------------------------
+%%% @spec opendir(SSH, Path) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+opendir(SSH, Path) ->
+    call(SSH, {opendir,sftp,Path}).
+%%%-----------------------------------------------------------------
+%%% @spec opendir(SSH, Server, Path) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+opendir(SSH, Server, Path) ->
+    call(SSH, {opendir,Server,Path}).
+
+%%%-----------------------------------------------------------------
+%%% @spec close(SSH, Handle) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+close(SSH, Handle) ->
+    call(SSH, {close,sftp,Handle}).
+%%%-----------------------------------------------------------------
+%%% @spec close(SSH, Server, Handle) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+close(SSH, Server, Handle) ->
+    call(SSH, {close,Server,Handle}).
+
+%%%-----------------------------------------------------------------
+%%% @spec read(SSH, Handle, Len) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+read(SSH, Handle, Len) ->
+    call(SSH, {read,sftp,Handle,Len}).
+%%%-----------------------------------------------------------------
+%%% @spec read(SSH, Server, Handle, Len) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+read(SSH, Server, Handle, Len) ->
+    call(SSH, {read,Server,Handle,Len}).
+
+%%%-----------------------------------------------------------------
+%%% @spec pread(SSH, Handle, Position, Length) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+pread(SSH, Handle, Position, Length) ->
+    call(SSH, {pread,sftp,Handle,Position,Length}).
+%%%-----------------------------------------------------------------
+%%% @spec pread(SSH, Server, Handle, Position, Length) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+pread(SSH, Server, Handle, Position, Length) ->
+    call(SSH, {pread,Server,Handle,Position,Length}).
+
+%%%-----------------------------------------------------------------
+%%% @spec aread(SSH, Handle, Len) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+aread(SSH, Handle, Len) ->
+    call(SSH, {aread,sftp,Handle,Len}).
+%%%-----------------------------------------------------------------
+%%% @spec aread(SSH, Server, Handle, Len) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+aread(SSH, Server, Handle, Len) ->
+    call(SSH, {aread,Server,Handle,Len}).
+
+%%%-----------------------------------------------------------------
+%%% @spec apread(SSH, Handle, Position, Length) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+apread(SSH, Handle, Position, Length) ->
+    call(SSH, {apread,sftp,Handle,Position,Length}).
+%%%-----------------------------------------------------------------
+%%% @spec apread(SSH, Server, Handle, Position, Length) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+apread(SSH, Server, Handle, Position, Length) ->
+    call(SSH, {apread,Server,Handle,Position,Length}).
+
+%%%-----------------------------------------------------------------
+%%% @spec write(SSH, Handle, Data) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+write(SSH, Handle, Data) ->
+    call(SSH, {write,sftp,Handle,Data}).
+%%%-----------------------------------------------------------------
+%%% @spec write(SSH, Server, Handle, Data) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+write(SSH, Server, Handle, Data) ->
+    call(SSH, {write,Server,Handle,Data}).
+
+%%%-----------------------------------------------------------------
+%%% @spec pwrite(SSH, Handle, Position, Data) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+pwrite(SSH, Handle, Position, Data) ->
+    call(SSH, {pwrite,sftp,Handle,Position,Data}).
+%%%-----------------------------------------------------------------
+%%% @spec pwrite(SSH, Server, Handle, Position, Data) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+pwrite(SSH, Server, Handle, Position, Data) ->
+    call(SSH, {pwrite,Server,Handle,Position,Data}).
+
+%%%-----------------------------------------------------------------
+%%% @spec awrite(SSH, Handle, Data) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+awrite(SSH, Handle, Data) ->
+    call(SSH, {awrite,sftp,Handle, Data}).
+%%%-----------------------------------------------------------------
+%%% @spec awrite(SSH, Server, Handle, Data) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+awrite(SSH, Server, Handle, Data) ->
+    call(SSH, {awrite,Server,Handle, Data}).
+
+%%%-----------------------------------------------------------------
+%%% @spec apwrite(SSH, Handle, Position, Data) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+apwrite(SSH, Handle, Position, Data) ->
+    call(SSH, {apwrite,sftp,Handle,Position,Data}).
+%%%-----------------------------------------------------------------
+%%% @spec apwrite(SSH, Server, Handle, Position, Data) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+apwrite(SSH, Server, Handle, Position, Data) ->
+    call(SSH, {apwrite,Server,Handle,Position,Data}).
+
+%%%-----------------------------------------------------------------
+%%% @spec position(SSH, Handle, Location) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+position(SSH, Handle, Location) ->
+    call(SSH, {position,sftp,Handle,Location}).
+%%%-----------------------------------------------------------------
+%%% @spec position(SSH, Server, Handle, Location) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+position(SSH, Server, Handle, Location) ->
+    call(SSH, {position,Server,Handle,Location}).
+
+%%%-----------------------------------------------------------------
+%%% @spec read_file_info(SSH, Name) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+read_file_info(SSH, Name) ->
+    call(SSH, {read_file_info,sftp,Name}).
+%%%-----------------------------------------------------------------
+%%% @spec read_file_info(SSH, Server, Name) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+read_file_info(SSH, Server, Name) ->
+    call(SSH, {read_file_info,Server,Name}).
+
+%%%-----------------------------------------------------------------
+%%% @spec get_file_info(SSH, Handle) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+get_file_info(SSH, Handle) ->
+    call(SSH, {get_file_info,sftp,Handle}).
+%%%-----------------------------------------------------------------
+%%% @spec get_file_info(SSH, Server, Handle) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+get_file_info(SSH, Server, Handle) ->
+    call(SSH, {get_file_info,Server,Handle}).
+
+%%%-----------------------------------------------------------------
+%%% @spec read_link_info(SSH, Name) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+read_link_info(SSH, Name) ->
+    call(SSH, {read_link_info,sftp,Name}).
+%%%-----------------------------------------------------------------
+%%% @spec read_link_info(SSH, Server, Name) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+read_link_info(SSH, Server, Name) ->
+    call(SSH, {read_link_info,Server,Name}).
+
+%%%-----------------------------------------------------------------
+%%% @spec write_file_info(SSH, Name, Info) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+write_file_info(SSH, Name, Info) ->
+    call(SSH, {write_file_info,sftp,Name,Info}).
+%%%-----------------------------------------------------------------
+%%% @spec write_file_info(SSH, Server, Name, Info) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+write_file_info(SSH, Server, Name, Info) ->
+    call(SSH, {write_file_info,Server,Name,Info}).
+
+%%%-----------------------------------------------------------------
+%%% @spec read_link(SSH, Name) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+read_link(SSH, Name) ->
+    call(SSH, {read_link,sftp,Name}).
+%%%-----------------------------------------------------------------
+%%% @spec read_link(SSH, Server, Name) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+read_link(SSH, Server, Name) ->
+    call(SSH, {read_link,Server,Name}).
+
+%%%-----------------------------------------------------------------
+%%% @spec make_symlink(SSH, Name, Target) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+make_symlink(SSH, Name, Target) ->
+    call(SSH, {make_symlink,sftp,Name,Target}).
+%%%-----------------------------------------------------------------
+%%% @spec make_symlink(SSH, Server, Name, Target) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+make_symlink(SSH, Server, Name, Target) ->
+    call(SSH, {make_symlink,Server,Name,Target}).
+
+%%%-----------------------------------------------------------------
+%%% @spec rename(SSH, OldName, NewName) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+rename(SSH, OldName, NewName) ->
+    call(SSH, {rename,sftp,OldName,NewName}).
+%%%-----------------------------------------------------------------
+%%% @spec rename(SSH, Server, OldName, NewName) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+rename(SSH, Server, OldName, NewName) ->
+    call(SSH, {rename,Server,OldName,NewName}).
+
+%%%-----------------------------------------------------------------
+%%% @spec delete(SSH, Name) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+delete(SSH, Name) ->
+    call(SSH, {delete,sftp,Name}).
+%%%-----------------------------------------------------------------
+%%% @spec delete(SSH, Server, Name) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+delete(SSH, Server, Name) ->
+    call(SSH, {delete,Server,Name}).
+
+%%%-----------------------------------------------------------------
+%%% @spec make_dir(SSH, Name) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+make_dir(SSH, Name) ->
+    call(SSH, {make_dir,sftp,Name}).
+%%%-----------------------------------------------------------------
+%%% @spec make_dir(SSH, Server, Name) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+make_dir(SSH, Server, Name) ->
+    call(SSH, {make_dir,Server,Name}).
+
+%%%-----------------------------------------------------------------
+%%% @spec del_dir(SSH, Name) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+del_dir(SSH, Name) ->
+    call(SSH, {del_dir,sftp,Name}).
+%%%-----------------------------------------------------------------
+%%% @spec del_dir(SSH, Server, Name) -> Result
+%%%      SSH = connection()
+%%%      Result = ssh_sftp_return() | {error,Reason}
+%%%      Reason = term()
+%%% @doc For info and other types, see ssh_sftp(3).
+del_dir(SSH, Server, Name) ->
+    call(SSH, {del_dir,Server,Name}).
+
+
+%%%=================================================================
+%%% Callback functions
+%%%=================================================================
+
+%% @hidden
+init(KeyOrName, {ConnType,Addr,Port}, AllOpts) ->
+    User = proplists:get_value(user, AllOpts),
+    Password = case proplists:get_value(password, AllOpts) of
+		   undefined -> "";
+		   Pwd -> Pwd
+	       end,
+    AllOpts1 = case proplists:get_value(connect_timeout, AllOpts) of
+		   undefined ->
+		       [{connect_timeout,?DEFAULT_TIMEOUT}|AllOpts];
+		   _ ->
+		       AllOpts		      
+	       end,
+    Options =
+	lists:foldl(fun({ssh,_},Opts) -> Opts;
+		       ({sftp,_},Opts) -> Opts;
+		       ({port,_},Opts) -> Opts;
+		       ({silently_accept_hosts,_},Opts) -> Opts;
+		       ({user_interaction,_},Opts) -> Opts;
+		       (Opt={Key,_},Opts) -> 
+			    case lists:keymember(Key, 1, Opts) of
+				true -> Opts;
+				false -> [Opt|Opts]
+			    end;
+		       (_,Opts) -> Opts
+		    end, [], AllOpts1),
+    FinalOptions = [{silently_accept_hosts,true},
+		    {user_interaction,false} | Options],
+    crypto:start(),
+    ssh:start(),
+    Result = case ConnType of
+		 ssh ->
+		     ssh:connect(Addr, Port, FinalOptions);
+		 sftp ->
+		     ssh_sftp:connect(Addr, Port, FinalOptions)
+	     end,
+    case Result of
+	{ok,SSHRef} ->
+	    log(heading(init,KeyOrName), 
+		"Opened ~w connection:\nHost: ~p (~p)\nUser: ~p\nPassword: ~p\n",
+		[ConnType,Addr,Port,User,lists:duplicate(length(Password),$*)]),
+	    {ok,SSHRef,#state{ssh_ref=SSHRef, conn_type=ConnType,
+			      target=KeyOrName}};
+	Error ->
+	    Error
+    end.
+
+%% @hidden
+handle_msg(sftp_connect, State) ->
+    #state{ssh_ref=SSHRef, target=Target} = State,
+    log(heading(sftp_connect,Target), "SSH Ref: ~p", [SSHRef]),
+    {ssh_sftp:connect(SSHRef),State};
+
+handle_msg({session_open,TO}, State) ->
+    #state{ssh_ref=SSHRef, target=Target} = State,
+    log(heading(session_open,Target), "SSH Ref: ~p, Timeout: ~p", [SSHRef,TO]),
+    {ssh_connection:session_channel(SSHRef, TO),State};
+
+handle_msg({session_close,Chn}, State) ->
+    #state{ssh_ref=SSHRef, target=Target} = State,
+    log(heading(session_close,Target), "SSH Ref: ~p, Chn: ~p", [SSHRef,Chn]),
+    {ssh_connection:close(SSHRef, Chn),State};
+
+handle_msg({exec,Chn,Command,TO}, State) ->
+    #state{ssh_ref=SSHRef, target=Target} = State,
+    Chn1 = 
+	if Chn == undefined ->
+		log(heading(exec,Target), 
+		    "Opening channel for exec, SSH Ref: ~p", [SSHRef]),
+		case ssh_connection:session_channel(SSHRef, TO) of	
+		    {ok,C} -> C;
+		    CErr -> CErr
+		end;
+	   true ->
+		Chn
+	end,
+    case Chn1 of
+	{error,_} = ChnError ->
+	    log(heading(exec,Target), "Opening channel failed: ~p", [ChnError]),
+	    {ChnError,State};
+	_ ->
+	    log(heading(exec,Target), 
+		"SSH Ref: ~p, Chn: ~p, Command: ~p, Timeout: ~p", 
+		[SSHRef,Chn1,Command,TO]),
+	    case ssh_connection:exec(SSHRef, Chn1, Command, TO) of
+		success ->
+		    Result = do_recv_response(SSHRef, Chn1, [], close, TO),
+		    ssh_connection:close(SSHRef, Chn1),
+		    {Result,State};
+		Other ->
+		    {{error,Other},State}
+	    end
+    end;
+
+handle_msg({receive_response,Chn,End,TO}, State) ->
+    #state{ssh_ref=SSHRef, target=Target} = State,
+    log(heading(receive_response,Target), 
+	"SSH Ref: ~p, Chn: ~p, Timeout: ~p", [SSHRef,Chn,TO]),
+    Result = do_recv_response(SSHRef, Chn, [], End, TO),
+    {Result,State};
+
+handle_msg({send,Chn,Type,Data,TO}, State) ->
+    #state{ssh_ref=SSHRef, target=Target} = State,
+    log(heading(send,Target), 
+	"SSH Ref: ~p, Chn: ~p, Type: ~p, Timeout: ~p~n"
+	"Data: ~p", [SSHRef,Chn,Type,TO,Data]),
+    Result = ssh_connection:send(SSHRef, Chn, Type, Data, TO),
+    {Result,State};
+
+handle_msg({send_and_receive,Chn,Type,Data,End,TO}, State) -> 
+    #state{ssh_ref=SSHRef, target=Target} = State,   
+    log(heading(send_and_receive,Target), 
+	"SSH Ref: ~p, Chn: ~p, Type: ~p, Timeout: ~p~n"
+	"Data: ~p", [SSHRef,Chn,Type,TO,Data]),
+    case ssh_connection:send(SSHRef, Chn, Type, Data, TO) of
+	ok ->
+	    Result = do_recv_response(SSHRef, Chn, [], End, TO),
+	    {Result,State};
+	Error ->
+	    {Error,State}
+    end;
+
+handle_msg({subsystem,Chn,Subsystem,TO}, State) ->
+    #state{ssh_ref=SSHRef, target=Target} = State,
+    log(heading(subsystem,Target), 
+	"SSH Ref: ~p, Chn: ~p, Subsys: ~p, Timeout: ~p", 
+	[SSHRef,Chn,Subsystem,TO]),
+    Result = ssh_connection:subsystem(SSHRef, Chn, Subsystem, TO),
+    {Result,State};
+
+%% --- SFTP Commands ---
+
+handle_msg({read_file,Srv,File}=Cmd, S=#state{ssh_ref=SSHRef}) ->
+    log(heading(sftp,S#state.target), 
+	"SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]),
+    {ssh_sftp:read_file(ref(Srv,SSHRef), File),S};
+
+handle_msg({write_file,Srv,File,Iolist}=Cmd, S=#state{ssh_ref=SSHRef}) ->
+    log(heading(sftp,S#state.target), 
+	"SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]),
+    {ssh_sftp:write_file(ref(Srv,SSHRef), File, Iolist),S};
+
+handle_msg({list_dir,Srv,Path}=Cmd, S=#state{ssh_ref=SSHRef}) ->
+    log(heading(sftp,S#state.target), 
+	"SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]),
+    {ssh_sftp:list_dir(ref(Srv,SSHRef), Path),S};
+
+handle_msg({open,Srv,File,Mode}=Cmd, S=#state{ssh_ref=SSHRef}) ->
+    log(heading(sftp,S#state.target), 
+	"SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]),
+    {ssh_sftp:open(ref(Srv,SSHRef), File, Mode),S};
+
+handle_msg({opendir,Srv,Path}=Cmd, S=#state{ssh_ref=SSHRef}) ->
+    log(heading(sftp,S#state.target), 
+	"SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]),
+    {ssh_sftp:opendir(ref(Srv,SSHRef), Path),S};
+
+handle_msg({close,Srv,Handle}=Cmd, S=#state{ssh_ref=SSHRef}) ->
+    log(heading(sftp,S#state.target), 
+	"SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]),
+    {ssh_sftp:close(ref(Srv,SSHRef), Handle),S};
+
+handle_msg({read,Srv,Handle,Len}=Cmd, S=#state{ssh_ref=SSHRef}) ->
+    log(heading(sftp,S#state.target), 
+	"SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]),
+    {ssh_sftp:read(ref(Srv,SSHRef), Handle, Len),S};
+
+handle_msg({pread,Srv,Handle,Position,Length}=Cmd, S=#state{ssh_ref=SSHRef}) ->
+    log(heading(sftp,S#state.target), 
+	"SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]),
+    {ssh_sftp:pread(ref(Srv,SSHRef),Handle,Position,Length),S};
+
+handle_msg({aread,Srv,Handle,Len}=Cmd, S=#state{ssh_ref=SSHRef}) ->
+    log(heading(sftp,S#state.target), 
+	"SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]),
+    {ssh_sftp:aread(ref(Srv,SSHRef), Handle, Len),S};
+
+handle_msg({apread,Srv,Handle,Position,Length}=Cmd, S=#state{ssh_ref=SSHRef}) ->
+    log(heading(sftp,S#state.target), 
+	"SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]),
+    {ssh_sftp:apread(ref(Srv,SSHRef), Handle, Position, Length),S};
+
+handle_msg({write,Srv,Handle,Data}=Cmd, S=#state{ssh_ref=SSHRef}) ->
+    log(heading(sftp,S#state.target), 
+	"SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]),
+    {ssh_sftp:write(ref(Srv,SSHRef), Handle, Data),S};
+
+handle_msg({pwrite,Srv,Handle,Position,Data}=Cmd, S=#state{ssh_ref=SSHRef}) ->
+    log(heading(sftp,S#state.target), 
+	"SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]),
+    {ssh_sftp:pwrite(ref(Srv,SSHRef), Handle, Position, Data),S};
+
+handle_msg({awrite,Srv,Handle,Data}=Cmd, S=#state{ssh_ref=SSHRef}) ->
+    log(heading(sftp,S#state.target), 
+	"SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]),
+    {ssh_sftp:awrite(ref(Srv,SSHRef), Handle, Data),S};
+
+handle_msg({apwrite,Srv,Handle,Position,Data}=Cmd, S=#state{ssh_ref=SSHRef}) ->
+    log(heading(sftp,S#state.target), 
+	"SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]),
+    {ssh_sftp:apwrite(ref(Srv,SSHRef), Handle, Position, Data),S};
+
+handle_msg({position,Srv,Handle,Location}=Cmd, S=#state{ssh_ref=SSHRef}) ->
+    log(heading(sftp,S#state.target), 
+	"SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]),
+    {ssh_sftp:position(ref(Srv,SSHRef), Handle, Location),S};
+
+handle_msg({read_file_info,Srv,Name}=Cmd, S=#state{ssh_ref=SSHRef}) ->
+    log(heading(sftp,S#state.target), 
+	"SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]),
+    {ssh_sftp:read_file_info(ref(Srv,SSHRef), Name),S};
+
+handle_msg({get_file_info,Srv,Handle}=Cmd, S=#state{ssh_ref=SSHRef}) ->
+    log(heading(sftp,S#state.target), 
+	"SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]),
+    {ssh_sftp:get_file_info(ref(Srv,SSHRef), Handle),S};
+
+handle_msg({read_link_info,Srv,Name}=Cmd, S=#state{ssh_ref=SSHRef}) ->
+    log(heading(sftp,S#state.target), 
+	"SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]),
+    {ssh_sftp:read_link_info(ref(Srv,SSHRef), Name),S};
+
+handle_msg({write_file_info,Srv,Name,Info}=Cmd, S=#state{ssh_ref=SSHRef}) ->
+    log(heading(sftp,S#state.target), 
+	"SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]),
+    {ssh_sftp:write_file_info(ref(Srv,SSHRef), Name, Info),S};
+
+handle_msg({read_link,Srv,Name}=Cmd, S=#state{ssh_ref=SSHRef}) ->
+    log(heading(sftp,S#state.target), 
+	"SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]),
+    {ssh_sftp:read_link(ref(Srv,SSHRef), Name),S};
+
+handle_msg({make_symlink,Srv,Name,Target}=Cmd, S=#state{ssh_ref=SSHRef}) ->
+    log(heading(sftp,S#state.target), 
+	"SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]),
+    {ssh_sftp:make_symlink(ref(Srv,SSHRef), Name, Target),S};
+
+handle_msg({rename,Srv,OldName,NewName}=Cmd, S=#state{ssh_ref=SSHRef}) ->
+    log(heading(sftp,S#state.target), 
+	"SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]),
+    {ssh_sftp:rename(ref(Srv,SSHRef), OldName, NewName),S};
+
+handle_msg({delete,Srv,Name}=Cmd, S=#state{ssh_ref=SSHRef}) ->
+    log(heading(sftp,S#state.target), 
+	"SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]),
+    {ssh_sftp:delete(ref(Srv,SSHRef), Name),S};
+
+handle_msg({make_dir,Srv,Name}=Cmd, S=#state{ssh_ref=SSHRef}) ->
+    log(heading(sftp,S#state.target), 
+	"SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]),
+    {ssh_sftp:make_dir(ref(Srv,SSHRef), Name),S};
+
+handle_msg({del_dir,Srv,Name}=Cmd, S=#state{ssh_ref=SSHRef}) ->
+    log(heading(sftp,S#state.target), 
+	"SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]),
+    {ssh_sftp:del_dir(ref(Srv,SSHRef), Name),S}.
+
+%% @hidden
+reconnect(_Addr,_State) ->
+    {error,no_reconnection_of_ssh}.
+
+%% @hidden
+close(SSHRef) ->
+    disconnect(SSHRef).
+
+%% @hidden
+terminate(SSHRef, State) ->
+    case State#state.conn_type of
+	ssh ->
+	    log(heading(disconnect_ssh,State#state.target),
+		"SSH Ref: ~p",[SSHRef]),
+	    ssh:close(SSHRef);
+	sftp ->
+	    log(heading(disconnect_sftp,State#state.target),
+		"SFTP Ref: ~p",[SSHRef]),
+	    ssh_sftp:stop(SSHRef)
+    end.
+
+
+%%%=================================================================
+%%% Internal functions
+
+%%%-----------------------------------------------------------------
+%%% 
+do_recv_response(SSH, Chn, Data, End, Timeout) ->
+    receive
+
+	{ssh_cm, SSH, {open,Chn,RemoteChn,{session}}} ->
+	    debug("RECVD open"),
+	    {ok,{open,Chn,RemoteChn,{session}}};
+	
+	{ssh_cm, SSH, {closed,Chn}} ->
+	    ssh_connection:close(SSH, Chn),
+	    debug("CLSD~n~p ~p", [SSH,Chn]),
+	    {ok,Data};
+
+	{ssh_cm, SSH, {data,Chn,_,NewData}} ->
+	    ssh_connection:adjust_window(SSH, Chn, size(NewData)),
+	    debug("RECVD~n~p", [binary_to_list(NewData)]),
+	    DataAcc = Data ++ binary_to_list(NewData),
+	    if is_function(End) ->
+		    case End(DataAcc) of
+			true -> 
+			    {ok,DataAcc};
+			false ->
+			    do_recv_response(SSH, Chn, DataAcc, End, Timeout)
+		    end;
+	       true ->
+		    do_recv_response(SSH, Chn, DataAcc, End, Timeout)
+	    end;
+
+	{ssh_cm, SSH, {eof,Chn}} ->
+	    debug("RECVD EOF~n~p ~p", [SSH,Chn]),
+	    {ok,Data};
+
+	{ssh_cm, SSH, {exit_signal,Chn,Signal,Err,_Lang}} ->
+	    debug("RECVD exit_signal~n~p ~p~n~p ~p", [SSH,Chn,Signal,Err]),
+	    do_recv_response(SSH, Chn, Data, End, Timeout);
+%%	    {ok,{exit_signal,Chn,Signal,Err,_Lang}};
+
+	{ssh_cm, SSH, {exit_status,Chn,Status}} ->
+	    debug("RECVD exit_status~n~p ~p~n~p", [SSH,Chn,Status]),
+	    do_recv_response(SSH, Chn, Data, End, Timeout);
+%%	    {ok,{exit_status,Chn,_Status}};
+
+
+%%      --- INTERACTIVE MESSAGES - NOT HANDLED ---
+%%
+%% 	{ssh_cm, SSH, {subsystem,Chn,WantReply,Name}} ->
+%% 	    debug("RECVD SUBS WNTRPLY~n~p ~p~n~p~n~p",
+%% 		  [SSH,Chn,WantReply]),
+%% 	    ssh_connection:reply_request(SSH, WantReply, success, Chn),
+%% 	    do_recv_response(SSH, Chn, Data, End, Timeout);
+	
+%% 	{ssh_cm, SSH, {shell,WantReply}} ->
+%% 	    debug("RECVD SHELL WNTRPLY~n~p ~p~n~p~n~p",
+%% 		  [SSH,Chn,WantReply]),
+%% 	    ssh_connection:reply_request(SSH, WantReply, success, Chn),
+%% 	    do_recv_response(SSH,Chn,Data,End,Timeout);
+	
+%% 	{ssh_cm, SSH, {pty,Chn,WantReply,Pty}} ->
+%% 	    debug("RECVD PTY WNTRPLY~n~p ~p~n~p~n~p",
+%% 		  [SSH,Chn,WantReply,Pty]),
+%% 	    ssh_connection:reply_request(SSH, WantReply, success, Chn),
+%% 	    do_recv_response(SSH, Chn, Data, End, Timeout);
+
+%%	{ssh_cm, SSH, WCh={window_change,_Chn,_Width,_Height,_PixWidth,_PixHeight}} ->
+%%	    debug("RECVD WINCH"),
+%%	    {ok,WCh};
+	
+	Other ->
+	    debug("UNEXPECTED MESSAGE~n~p ~p~n~p", [SSH,Chn,Other]),
+	    do_recv_response(SSH, Chn, Data, End, Timeout)
+
+    after Timeout ->
+	    case End of
+		timeout -> 
+		    {ok,Data};
+		_ -> 
+		    {timeout,Data}
+	    end
+    end.
+
+%%%-----------------------------------------------------------------
+%%% 
+get_handle(SSH) when is_pid(SSH) ->
+    {ok,SSH};
+get_handle(SSH) ->
+    case ct_util:get_connections(SSH, ?MODULE) of
+	{ok,[{Pid,_}]} ->
+	    {ok,Pid};
+	{ok,[]} ->
+	    connect(SSH);
+	Error ->
+	    Error
+    end.
+
+%%%-----------------------------------------------------------------
+%%% 
+call(SSH, Msg) ->
+    case get_handle(SSH) of
+	{ok,Pid} ->
+	    ct_gen_conn:call(Pid, Msg);
+	Error ->
+	    Error
+    end.
+
+%%%-----------------------------------------------------------------
+%%% 
+ref(sftp, SSHRef) -> SSHRef;
+ref(Server, _) -> Server.
+    
+%%%-----------------------------------------------------------------
+%%% 
+mod(Cmd) ->
+    [Op,_Server|Args] = tuple_to_list(Cmd),
+    list_to_tuple([Op|Args]).
+	
+%%%-----------------------------------------------------------------
+%%% 	  
+heading(Function, Ref) ->
+    io_lib:format("ct_ssh:~w ~p",[Function,Ref]).
+
+%%%-----------------------------------------------------------------
+%%% 
+log(Heading, Str, Args) ->
+    ct_gen_conn:log(Heading, Str, Args).  
+
+
+%%%-----------------------------------------------------------------
+%%% 
+debug(Str) ->
+    debug(Str, []).
+
+debug(_Str, _Args) ->
+%%    io:format("~n--- ct_ssh debug ---~n" ++ _Str ++ "~n", _Args),
+    ok.
diff --git a/lib/common_test/src/ct_telnet.erl b/lib/common_test/src/ct_telnet.erl
new file mode 100644
index 0000000000..c19d312f01
--- /dev/null
+++ b/lib/common_test/src/ct_telnet.erl
@@ -0,0 +1,1166 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 2003-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%
+%%
+
+%%% @doc Common Test specific layer on top of telnet client ct_telnet_client.erl
+%%%
+%%% <p>Use this module to set up telnet connections, send commands and
+%%% perform string matching on the result.
+%%% (See the <code>unix_telnet</code> manual page for information 
+%%% about how ct_telnet may be used specifically with unix hosts.)</p>
+%%% <p>The following default values are defined in ct_telnet:</p>
+%%% <pre>
+%%% Connection timeout = 10 sec (time to wait for connection)
+%%% Command timeout = 10 sec (time to wait for a command to return)
+%%% Max no of reconnection attempts = 3
+%%% Reconnection interval = 5 sek (time to wait in between reconnection attempts)
+%%% </pre>
+%%% <p>These parameters can be altered by the user with the following
+%%% configuration term:</p>
+%%% <pre>
+%%% {telnet_settings, [{connect_timeout,Millisec},
+%%%                    {command_timeout,Millisec},
+%%%                    {reconnection_attempts,N},
+%%%                    {reconnection_interval,Millisec}]}.
+%%% </pre>
+%%% <p><code>Millisec = integer(), N = integer()</code></p>
+%%% <p>Enter the <code>telnet_settings</code> term in a configuration 
+%%% file included in the test and ct_telnet will retrieve the information
+%%% automatically.</p>
+
+%%% @type connection_type() = telnet | ts1 | ts2
+
+%%% @type connection() = handle() |
+%%% {ct:target_name(),connection_type()} | ct:target_name()
+
+%%% @type handle() = ct_gen_conn:handle(). Handle for a
+%%% specific telnet connection.
+
+%%% @type prompt_regexp() = string(). A regular expression which
+%%% matches all possible prompts for a specific type of target. The
+%%% regexp must not have any groups i.e. when matching, re:run/3 shall
+%%% return a list with one single element.
+%%%
+%%% @see unix_telnet
+
+-module(ct_telnet).
+
+-compile(export_all).
+
+-export([open/1, open/2, open/3, open/4, close/1]).
+-export([cmd/2, cmd/3, cmdf/3, cmdf/4, get_data/1, 
+	 send/2, sendf/3, expect/2, expect/3]).
+
+%% Callbacks
+-export([init/3,handle_msg/2,reconnect/2,terminate/2]).
+
+%% Tool internals
+-export([silent_teln_expect/5, teln_receive_until_prompt/3,
+	 start_log/1, log/3, cont_log/2, end_log/0,
+	 try_start_log/1, try_log/3, try_cont_log/2, try_end_log/0]).
+
+
+-define(RECONNS,3).
+-define(RECONN_TIMEOUT,5000).
+-define(DEFAULT_TIMEOUT,10000).
+-define(DEFAULT_PORT,23).
+
+-include("ct_util.hrl").
+
+-record(state,{teln_pid,
+	       prx,
+	       type,
+	       buffer=[],
+	       prompt=false,
+	       name,
+	       target_mod,extra,
+	       conn_to=?DEFAULT_TIMEOUT, 
+	       com_to=?DEFAULT_TIMEOUT, 
+	       reconns=?RECONNS,
+	       reconn_int=?RECONN_TIMEOUT}).
+
+%%%-----------------------------------------------------------------
+%%% @spec open(Name) -> {ok,Handle} | {error,Reason}
+%%% @equiv open(Name,telnet)
+open(Name) ->
+    open(Name,telnet).
+
+%%%-----------------------------------------------------------------
+%%% @spec open(Name,ConnType) -> {ok,Handle} | {error,Reason}
+%%%      Name = target_name()
+%%%      ConnType = ct_telnet:connection_type()
+%%%      Handle = ct_telnet:handle()
+%%%
+%%% @doc Open a telnet connection to the specified target host.
+open(Name,ConnType) ->
+    case ct_util:get_key_from_name(Name) of
+	{ok, unix} -> % unix host
+	    open(Name, ConnType, unix_telnet, Name);
+	{ok, Key} -> % any other, e.g. interwatch (iw), etc.
+	    open(Name, ConnType, Key, Name);
+	Error ->
+	    Error
+    end.
+
+%%%-----------------------------------------------------------------
+%%% @spec open(KeyOrName,ConnType,TargetMod) -> 
+%%%                                     {ok,Handle} | {error,Reason}
+%%% @equiv open(KeyOrName,ConnType,TargetMod,[])
+open(KeyOrName,ConnType,TargetMod) ->
+    open(KeyOrName,ConnType,TargetMod,KeyOrName).
+
+%%%-----------------------------------------------------------------
+%%% @spec open(KeyOrName,ConnType,TargetMod,Extra) -> 
+%%%                                     {ok,Handle} | {error,Reason}
+%%%      KeyOrName = Key | Name
+%%%      Key = atom()
+%%%      Name = ct:target_name()
+%%%      ConnType = connection_type()
+%%%      TargetMod = atom()
+%%%      Extra = term()
+%%%      Handle = handle()
+%%%
+%%% @doc Open a telnet connection to the specified target host.
+%%%
+%%% <p>The target data must exist in a configuration file. The connection 
+%%% may be associated with either <code>Name</code> and/or the returned 
+%%% <code>Handle</code>. To allocate a name for the target,
+%%% use <code>ct:require/2</code> in a test case, or use a 
+%%% <code>require</code> statement in the suite info function 
+%%% (<code>suite/0</code>), or in a test case info function. 
+%%% If you want the connection to be associated with <code>Handle</code> only 
+%%% (in case you need to open multiple connections to a host for example), 
+%%% simply use <code>Key</code>, the configuration variable name, to 
+%%% specify the target. Note that a connection that has no associated target 
+%%% name can only be closed with the handle value.</p>
+%%% 
+%%% <p><code>TargetMod</code> is a module which exports the functions
+%%% <code>connect(Ip,Port,Extra)</code> and <code>get_prompt_regexp()</code>
+%%% for the given <code>TargetType</code> (e.g. <code>unix_telnet</code>).</p>
+open(KeyOrName,ConnType,TargetMod,Extra) ->
+    case ct:get_config({KeyOrName,ConnType}) of
+	undefined ->
+	    log(heading(open,{KeyOrName,ConnType}),"Failed: ~p",
+		[{not_available,KeyOrName}]),
+	    {error,{not_available,KeyOrName,ConnType}};
+	Addr ->
+	    Addr1 =
+		case Addr of
+		    {_IP,_Port} ->
+			Addr;
+		    IP ->
+			case ct:get_config({KeyOrName,port}) of
+			    undefined -> IP;
+			    P -> {IP,P}
+			end
+		end,
+	    log(heading(open,{KeyOrName,ConnType}),"Opening connection to: ~p",[Addr1]),
+	    ct_gen_conn:start(KeyOrName,full_addr(Addr1,ConnType),
+			      {TargetMod,Extra},?MODULE)
+    end.
+
+%%%-----------------------------------------------------------------
+%%% @spec close(Connection) -> ok | {error,Reason}
+%%%       Connection = ct_telnet:connection()
+%%%
+%%% @doc Close the telnet connection and stop the process managing it.
+%%% 
+%%% <p>A connection may be associated with a target name and/or a handle.
+%%% If <code>Connection</code> has no associated target name, it may only
+%%% be closed with the handle value (see the <code>open/4</code> 
+%%% function).</p>
+close(Connection) ->
+    case get_handle(Connection) of
+	{ok,Pid} ->
+	    log("ct_telnet:close","Handle: ~p",[Pid]),
+	    case ct_gen_conn:stop(Pid) of
+		{error,{process_down,Pid,noproc}} ->
+		    {error,already_closed};
+		Result ->
+		    Result
+	    end;
+	Error ->
+	    Error
+    end.
+
+%%%=================================================================
+%%% Test suite interface
+%%%-----------------------------------------------------------------
+%%% @spec cmd(Connection,Cmd) -> {ok,Data} | {error,Reason}
+%%% @equiv cmd(Connection,Cmd,DefaultTimeout)
+cmd(Connection,Cmd) ->
+    cmd(Connection,Cmd,default).
+%%%-----------------------------------------------------------------
+%%% @spec cmd(Connection,Cmd,Timeout) -> {ok,Data} | {error,Reason}
+%%%      Connection = ct_telnet:connection()
+%%%      Cmd = string()
+%%%      Timeout = integer()
+%%%      Data = [string()]
+%%% @doc Send a command via telnet and wait for prompt.
+cmd(Connection,Cmd,Timeout) ->
+    case get_handle(Connection) of
+	{ok,Pid} ->
+	    call(Pid,{cmd,Cmd,Timeout});
+	Error ->
+	    Error
+    end.
+%%%-----------------------------------------------------------------
+%%% @spec cmdf(Connection,CmdFormat,Args) -> {ok,Data} | {error,Reason}
+%%% @equiv cmdf(Connection,CmdFormat,Args,DefaultTimeout)
+cmdf(Connection,CmdFormat,Args) ->
+    cmdf(Connection,CmdFormat,Args,default).
+%%%-----------------------------------------------------------------
+%%% @spec cmdf(Connection,CmdFormat,Args,Timeout) -> {ok,Data} | {error,Reason}
+%%%      Connection = ct_telnet:connection()
+%%%      CmdFormat = string()
+%%%      Args = list()
+%%%      Timeout = integer()
+%%%      Data = [string()]
+%%% @doc Send a telnet command and wait for prompt 
+%%%      (uses a format string and list of arguments to build the command).
+%%%-----------------------------------------------------------------
+cmdf(Connection,CmdFormat,Args,Timeout) when is_list(Args) ->
+    Cmd = lists:flatten(io_lib:format(CmdFormat,Args)),
+    cmd(Connection,Cmd,Timeout).
+
+%%%-----------------------------------------------------------------
+%%% @spec get_data(Connection) -> {ok,Data} | {error,Reason}
+%%%      Connection = ct_telnet:connection()
+%%%      Data = [string()]
+%%% @doc Get all data which has been received by the telnet client
+%%% since last command was sent.
+get_data(Connection) ->
+    case get_handle(Connection) of
+	{ok,Pid} ->
+	    call(Pid,get_data);
+	Error ->
+	    Error
+    end.
+
+%%%-----------------------------------------------------------------
+%%% @spec send(Connection,Cmd) -> ok | {error,Reason}
+%%%      Connection = ct_telnet:connection()
+%%%      Cmd = string()
+%%% @doc Send a telnet command and return immediately.
+%%%
+%%% <p>The resulting output from the command can be read with
+%%% <code>get_data/1</code> or <code>expect/2/3</code>.</p>
+send(Connection,Cmd) ->
+    case get_handle(Connection) of
+	{ok,Pid} ->
+	    call(Pid,{send,Cmd});
+	Error ->
+	    Error
+    end.
+
+%%%-----------------------------------------------------------------
+%%% @spec sendf(Connection,CmdFormat,Args) -> ok | {error,Reason}
+%%%      Connection = ct_telnet:connection()
+%%%      CmdFormat = string()
+%%%      Args = list()
+%%% @doc Send a telnet command and return immediately (uses a format
+%%% string and a list of arguments to build the command).
+sendf(Connection,CmdFormat,Args) when is_list(Args) ->
+    Cmd = lists:flatten(io_lib:format(CmdFormat,Args)),
+    send(Connection,Cmd).
+
+%%%-----------------------------------------------------------------
+%%% @spec expect(Connection,Patterns) -> term()
+%%% @equiv expect(Connections,Patterns,[])
+expect(Connection,Patterns) ->
+    expect(Connection,Patterns,[]).
+
+%%%-----------------------------------------------------------------
+%%% @spec expect(Connection,Patterns,Opts) -> {ok,Match} | 
+%%%                                           {ok,MatchList,HaltReason} | 
+%%%                                           {error,Reason}
+%%%      Connection = ct_telnet:connection()
+%%%      Patterns = Pattern | [Pattern]
+%%%      Pattern = string() | {Tag,string()} | prompt | {prompt,Prompt}
+%%%      Prompt = string()
+%%%      Tag = term()
+%%%      Opts = [Opt]
+%%%      Opt = {timeout,Timeout} | repeat | {repeat,N} | sequence |
+%%%            {halt,HaltPatterns} | ignore_prompt
+%%%      Timeout = integer()
+%%%      N = integer()
+%%%      HaltPatterns = Patterns
+%%%      MatchList = [Match]
+%%%      Match = RxMatch | {Tag,RxMatch} | {prompt,Prompt}
+%%%      RxMatch = [string()]
+%%%      HaltReason = done | Match
+%%%      Reason = timeout | {prompt,Prompt}
+%%%
+%%% @doc Get data from telnet and wait for the expected pattern.
+%%%
+%%% <p><code>Pattern</code> can be a POSIX regular expression. If more
+%%% than one pattern is given, the function returns when the first
+%%% match is found.</p>
+%%%
+%%% <p><code>RxMatch</code> is a list of matched strings. It looks
+%%% like this: <code>[FullMatch, SubMatch1, SubMatch2, ...]</code>
+%%% where <code>FullMatch</code> is the string matched by the whole
+%%% regular expression and <code>SubMatchN</code> is the string that
+%%% matched subexpression no <code>N</code>. Subexpressions are
+%%% denoted with '(' ')' in the regular expression</p>
+%%%
+%%% <p>If a <code>Tag</code> is given, the returned <code>Match</code>
+%%% will also include the matched <code>Tag</code>. Else, only
+%%% <code>RxMatch</code> is returned.</p>
+%%%
+%%% <p>The function will always return when a prompt is found, unless
+%%% the <code>ignore_prompt</code> options is used.</p>
+%%%
+%%% <p>The <code>timeout</code> option indicates that the function
+%%% shall return if the telnet client is idle (i.e. if no data is
+%%% received) for more than <code>Timeout</code> milliseconds. Default
+%%% timeout is 10 seconds.</p>
+%%%
+%%% <p>The <code>repeat</code> option indicates that the pattern(s)
+%%% shall be matched multiple times. If <code>N</code> is given, the
+%%% pattern(s) will be matched <code>N</code> times, and the function
+%%% will return with <code>HaltReason = done</code>.</p>
+%%%
+%%% <p>The <code>sequence</code> option indicates that all patterns
+%%% shall be matched in a sequence. A match will not be concluded
+%%% untill all patterns are matched.</p>
+%%%
+%%% <p>Both <code>repeat</code> and <code>sequence</code> can be
+%%% interrupted by one or more <code>HaltPatterns</code>. When
+%%% <code>sequence</code> or <code>repeat</code> is used, there will
+%%% always be a <code>MatchList</code> returned, i.e. a list of
+%%% <code>Match</code> instead of only one <code>Match</code>. There
+%%% will also be a <code>HaltReason</code> returned.</p>
+%%%
+%%% <p><underline>Examples:</underline><br/>
+%%% <code>expect(Connection,[{abc,"ABC"},{xyz,"XYZ"}],
+%%% [sequence,{halt,[{nnn,"NNN"}]}]).</code><br/> will try to match
+%%% "ABC" first and then "XYZ", but if "NNN" appears the function will
+%%% return <code>{error,{nnn,["NNN"]}}</code>. If both "ABC" and "XYZ"
+%%% are matched, the function will return
+%%% <code>{ok,[AbcMatch,XyzMatch]}</code>.</p>
+%%%
+%%% <p><code>expect(Connection,[{abc,"ABC"},{xyz,"XYZ"}],
+%%% [{repeat,2},{halt,[{nnn,"NNN"}]}]).</code><br/> will try to match
+%%% "ABC" or "XYZ" twice. If "NNN" appears the function will return
+%%% with <code>HaltReason = {nnn,["NNN"]}</code>.</p>
+%%%
+%%% <p>The <code>repeat</code> and <code>sequence</code> options can be
+%%% combined in order to match a sequence multiple times.</p>
+expect(Connection,Patterns,Opts) ->
+    case get_handle(Connection) of
+	{ok,Pid} ->
+	    call(Pid,{expect,Patterns,Opts});
+	Error ->
+	    Error
+    end.
+
+%%%=================================================================
+%%% Callback functions
+%% @hidden
+init(Name,{Ip,Port,Type},{TargetMod,Extra}) ->
+    S0 = case ct:get_config(telnet_settings) of
+	     undefined ->
+		 #state{};
+	     Settings ->
+		 set_telnet_defaults(Settings,#state{})				    
+	 end,
+    case catch TargetMod:connect(Ip,Port,S0#state.conn_to,Extra) of
+	{ok,TelnPid} ->
+	    log(heading(init,{Name,Type}), 
+		"Opened telnet connection\n"
+		"IP: ~p\n"
+		"Port: ~p\n"
+		"Command timeout: ~p\n"
+		"Reconnection attempts: ~p\n"
+		"Reconnection interval: ~p\n"
+		"Connection timeout: ~p",
+		[Ip,Port,S0#state.com_to,S0#state.reconns,
+		 S0#state.reconn_int,S0#state.conn_to]),
+	    {ok,TelnPid,S0#state{teln_pid=TelnPid,
+				 type=type(Type),
+				 name={Name,Type},
+				 target_mod=TargetMod,
+				 extra=Extra,
+				 prx=TargetMod:get_prompt_regexp()}};
+	{'EXIT',Reason} ->
+	    {error,Reason};
+	Error ->
+	    Error
+    end.
+
+type(telnet) -> ip;
+type(TS) when TS==ts1;TS==ts2 -> ts.
+
+set_telnet_defaults([{connect_timeout,CnTo}|Ss],S) ->
+    set_telnet_defaults(Ss,S#state{conn_to=CnTo});
+set_telnet_defaults([{command_timeout,CmTo}|Ss],S) ->
+    set_telnet_defaults(Ss,S#state{com_to=CmTo});
+set_telnet_defaults([{reconnection_attempts,Rs}|Ss],S) ->
+    set_telnet_defaults(Ss,S#state{reconns=Rs});
+set_telnet_defaults([{reconnection_interval,RInt}|Ss],S) ->
+    set_telnet_defaults(Ss,S#state{reconn_int=RInt});
+set_telnet_defaults([],S) ->
+    S.
+
+%% @hidden
+handle_msg({cmd,Cmd,Timeout},State) ->
+    try_start_log(heading(cmd,State#state.name)),
+    try_cont_log("Cmd: ~p", [Cmd]),
+    debug_cont_log("Throwing Buffer:",[]),
+    debug_log_lines(State#state.buffer),
+    case {State#state.type,State#state.prompt} of
+	{ts,_} -> 
+	    silent_teln_expect(State#state.teln_pid,
+			       State#state.buffer,
+			       prompt,
+			       State#state.prx,
+			       [{timeout,2000}]);
+	{ip,false} -> 
+	    silent_teln_expect(State#state.teln_pid,
+			       State#state.buffer,
+			       prompt,
+			       State#state.prx,
+			       [{timeout,200}]);
+	{ip,true} ->
+	    ok
+    end,
+    TO = if Timeout == default -> State#state.com_to;
+	    true -> Timeout
+	 end,
+    {Return,NewBuffer,Prompt} = 
+	case teln_cmd(State#state.teln_pid, Cmd, State#state.prx, TO) of
+	    {ok,Data,_PromptType,Rest} ->
+		try_cont_log("Return: ~p", [{ok,Data}]),
+		{{ok,Data},Rest,true};
+	    Error ->
+		Retry = {retry,{Error,State#state.name,State#state.teln_pid,
+				{cmd,Cmd,TO}}},
+		try_cont_log("Return: ~p", [Error]),
+		{Retry,[],false}
+	end,
+    try_end_log(),
+    {Return,State#state{buffer=NewBuffer,prompt=Prompt}};
+handle_msg({send,Cmd},State) ->
+    try_log(heading(send,State#state.name),"Cmd: ~p",[Cmd]),
+    debug_cont_log("Throwing Buffer:",[]),
+    debug_log_lines(State#state.buffer),
+    case {State#state.type,State#state.prompt} of
+	{ts,_} -> 
+	    silent_teln_expect(State#state.teln_pid,
+			       State#state.buffer,
+			       prompt,
+			       State#state.prx,
+			       [{timeout,2000}]);
+	{ip,false} -> 
+	    silent_teln_expect(State#state.teln_pid,
+			       State#state.buffer,
+			       prompt,
+			       State#state.prx,
+			       [{timeout,200}]);
+	{ip,true} ->
+	    ok
+    end,
+    ct_telnet_client:send_data(State#state.teln_pid,Cmd),
+    {ok,State#state{buffer=[],prompt=false}};
+handle_msg(get_data,State) ->
+    try_start_log(heading(get_data,State#state.name)),
+    {ok,Data,Buffer} = teln_get_all_data(State#state.teln_pid,
+					 State#state.prx,
+					 State#state.buffer,
+					 [],[]),
+    try_cont_log("Return: ~p",[{ok,Data}]),
+    try_end_log(),
+    {{ok,Data},State#state{buffer=Buffer}};
+handle_msg({expect,Pattern,Opts},State) ->
+    try_start_log(heading(expect,State#state.name)),
+    try_cont_log("Expect: ~p\nOpts=~p\n",[Pattern,Opts]),
+    {Return,NewBuffer,Prompt} = 
+	case teln_expect(State#state.teln_pid,
+			 State#state.buffer,
+			 Pattern,
+			 State#state.prx,
+			 Opts) of
+	    {ok,Data,Rest} ->
+		P = check_if_prompt_was_reached(Data,[]),
+		{{ok,Data},Rest,P};
+	    {ok,Data,HaltReason,Rest} ->
+		force_cont_log("HaltReason: ~p",
+			       [HaltReason]),
+		P = check_if_prompt_was_reached(Data,HaltReason),
+		{{ok,Data,HaltReason},Rest,P};
+	    {error,Reason,Rest} ->
+		force_cont_log("Expect failed\n~p",[{error,Reason}]),
+		P = check_if_prompt_was_reached([],Reason),
+		{{error,Reason},Rest,P};
+	    {error,Reason} ->
+		force_cont_log("Expect failed\n~p",[{error,Reason}]),
+		P = check_if_prompt_was_reached([],Reason),
+		{{error,Reason},[],P}
+	end,
+    try_end_log(),
+    Return1 = case Return of
+		  {error,_} -> {retry,{Return,State#state.name,
+				       State#state.teln_pid,
+				       {expect,Pattern,Opts}}};
+		  _ -> Return
+	      end,	    
+    {Return1,State#state{buffer=NewBuffer,prompt=Prompt}}.
+
+
+%% @hidden
+reconnect({Ip,Port,_Type},State) ->
+    reconnect(Ip,Port,State#state.reconns,State).
+reconnect(Ip,Port,N,State=#state{target_mod=TargetMod,
+				 extra=Extra,
+				 conn_to=ConnTo,
+				 reconn_int=ReconnInt}) ->
+    case TargetMod:connect(Ip,Port,ConnTo,Extra) of
+	{ok, NewPid} ->
+	    {ok, NewPid, State#state{teln_pid=NewPid}};
+	Error when N==0 ->
+	    Error;
+	_Error ->
+	    log("Reconnect failed!","Retries left: ~p",[N]),
+	    timer:sleep(ReconnInt),
+	    reconnect(Ip,Port,N-1,State)
+    end.
+
+
+%% @hidden
+terminate(TelnPid,State) ->
+    log(heading(terminate,State#state.name),
+	"Closing telnet connection.\nId: ~p",
+	[TelnPid]),
+    ct_telnet_client:close(TelnPid).
+
+
+%%%=================================================================
+%%% Internal function
+get_handle(Pid) when is_pid(Pid) ->
+    {ok,Pid};
+get_handle({Name,Type}) when Type==telnet;Type==ts1;Type==ts2 ->
+    case ct_util:get_connections(Name,?MODULE) of
+	{ok,Conns} when Conns /= [] ->
+	    case get_handle(Type,Conns) of
+		{ok,Pid} -> 
+		    {ok,Pid};
+		_Error ->
+		    case ct_util:get_key_from_name(Name) of
+			{ok,node} ->
+			    open(Name,Type,ct_telnet_cello_node);
+			{ok,unix} -> % unix host
+			    open(Name,Type,unix_telnet,Name);
+			{ok,Key} -> % any other, e.g. interwatch (iw)
+			    open(Name,Type,Key,Name);
+			Error ->
+			    Error
+		    end
+	    end;
+	{ok,[]} ->
+	    {error,already_closed};
+	Error ->
+	    Error
+    end;
+get_handle(Name) ->
+    get_handle({Name,telnet}).
+
+get_handle(Type,[{Pid,{_,_,Type}}|_]) ->
+    {ok,Pid};
+get_handle(Type,[_H|T]) ->
+    get_handle(Type,T);
+get_handle(Type,[]) ->
+    {error,{no_such_connection,Type}}.
+
+full_addr({Ip,Port},Type) ->
+    {Ip,Port,Type};
+full_addr(Ip,Type) ->
+    {Ip,?DEFAULT_PORT,Type}.
+
+call(Pid,Msg) ->
+    ct_gen_conn:call(Pid,Msg).
+
+check_if_prompt_was_reached({prompt,_},_) ->
+    true;
+check_if_prompt_was_reached(_,{prompt,_}) ->
+    true;
+check_if_prompt_was_reached(Data,_) when is_list(Data) ->
+    lists:keymember(prompt,1,Data);
+check_if_prompt_was_reached(_,_) ->
+    false.
+
+%tc(Fun) ->
+%    Before = erlang:now(),
+%    Val = Fun(),
+%    After = erlang:now(),
+%    {now_diff(After, Before), Val}.
+%now_diff({A2, B2, C2}, {A1, B1, C1}) ->
+%    ((A2-A1)*1000000 + B2-B1)*1000000 + C2-C1.
+
+heading(Function,Name) ->
+    io_lib:format("~w:~w ~p",[?MODULE,Function,Name]).
+
+%%% @hidden
+%% Functions for regular (unconditional) logging, to be
+%% used during connect, reconnect, disconnect etc.
+log(Heading,Str,Args) ->
+    ct_gen_conn:log(Heading,Str,Args).
+%%% @hidden
+start_log(Heading) -> 
+    ct_gen_conn:start_log(Heading).
+cont_log(Str,Args) -> 
+    ct_gen_conn:cont_log(Str,Args).
+end_log() -> 
+    ct_gen_conn:end_log().
+
+%%% @hidden
+%% Functions for conditional logging, to be used by
+%% cmd, send, receive, expect etc (this output may be 
+%% silenced by user).
+try_start_log(Heading) -> 
+    do_try_log(start_log,[Heading]).
+%%% @hidden
+try_end_log() -> 
+    do_try_log(end_log,[]).
+
+%%% @hidden
+try_log(Heading,Str,Args) ->
+    do_try_log(log,[Heading,Str,Args]).
+
+%%% @hidden
+try_cont_log(Str,Args) -> 
+    do_try_log(cont_log,[Str,Args]).
+
+%%% @hidden
+do_try_log(Func,Args) ->
+    %% check if output is suppressed
+    case ct_util:is_silenced(telnet) of
+	true ->
+	    ok;
+	false ->
+	    apply(ct_gen_conn,Func,Args)
+    end.
+
+%%% @hidden
+%% Functions that will force printout even if ct_telnet
+%% output has been silenced, to be used for error printouts.
+force_cont_log(Str,Args) ->
+    case ct_util:is_silenced(telnet) of
+	true ->
+	    %% call log/3 now instead of cont_log/2 since 
+	    %% start_log/1 will not have been previously called
+	    log("ct_telnet info",Str,Args);
+	false ->
+	    cont_log(Str,Args)
+    end.
+
+%%% @hidden
+%% Debug printouts.
+debug_cont_log(Str,Args) ->
+    Old = put(silent,true),
+    cont_log(Str,Args),
+    put(silent,Old).
+
+
+
+%%%=================================================================
+%%% Abstraction layer on top of ct_telnet_client.erl
+teln_cmd(Pid,Cmd,Prx,Timeout) ->
+    ct_telnet_client:send_data(Pid,Cmd),
+    teln_receive_until_prompt(Pid,Prx,Timeout).
+
+
+teln_get_all_data(Pid,Prx,Data,Acc,LastLine) ->
+    case check_for_prompt(Prx,lists:reverse(LastLine) ++ Data) of
+	{prompt,Lines,_PromptType,Rest} ->
+	    teln_get_all_data(Pid,Prx,Rest,[Lines|Acc],[]);
+	{noprompt,Lines,LastLine1} ->
+	    case ct_telnet_client:get_data(Pid) of
+		{ok,[]} ->
+		    {ok,lists:reverse(lists:append([Lines|Acc])),
+		     lists:reverse(LastLine1)};
+		{ok,Data1} ->
+		    teln_get_all_data(Pid,Prx,Data1,[Lines|Acc],LastLine1)
+	    end
+    end.
+    
+%% Expect options record
+-record(eo,{teln_pid,
+	    prx,
+	    timeout,
+	    haltpatterns=[],
+	    seq=false,
+	    repeat=false,
+	    found_prompt=false}).
+
+%% @hidden
+%% @doc Externally the silent_teln_expect function shall only be used
+%% by the TargetModule, i.e. the target specific module which
+%% implements connect/2 and get_prompt_regexp/0.
+silent_teln_expect(Pid,Data,Pattern,Prx,Opts) ->
+    Old = put(silent,true),
+    try_cont_log("silent_teln_expect/5, Pattern = ~p",[Pattern]),
+    Result = teln_expect(Pid,Data,Pattern,Prx,Opts),
+    try_cont_log("silent_teln_expect -> ~p\n",[Result]),
+    put(silent,Old),
+    Result.
+
+%% teln_expect/5 
+%%
+%% This function implements the expect functionality over telnet. In
+%% general there are three possible ways to go:
+%% 1) Single: One or more patterns are given, and the function return
+%% when one of the patterns are matched.
+%% 2) Sequence: Several patterns are given, and they are matched in
+%% the order they appear in the pattern list.
+%% 3a) Repeat (single): 1) is repeated either N times or until a halt
+%% condition is fullfilled.
+%% 3b) Repeat (sequence): 2) is repeated either N times or until a
+%% halt condition is fullfilled.
+teln_expect(Pid,Data,Pattern0,Prx,Opts) -> HaltPatterns = case
+    get_ignore_prompt(Opts) of true -> get_haltpatterns(Opts); false
+    -> [prompt | get_haltpatterns(Opts)] end,
+
+    Seq = get_seq(Opts),
+    Pattern = convert_pattern(Pattern0,Seq),
+
+    Timeout = get_timeout(Opts),
+ 
+    EO = #eo{teln_pid=Pid,
+	     prx=Prx,
+	     timeout=Timeout,
+	     seq=Seq,
+	     haltpatterns=HaltPatterns},
+    
+    case get_repeat(Opts) of
+	false ->
+	    case teln_expect1(Data,Pattern,[],EO) of
+		{ok,Matched,Rest} ->
+		    {ok,Matched,Rest};
+		{halt,Why,Rest} ->
+		    {error,Why,Rest};
+		{error,Reason} ->
+		    {error,Reason}
+	    end;
+	N ->
+	    EO1 = EO#eo{repeat=N},
+	    repeat_expect(Data,Pattern,[],EO1)
+    end.
+
+convert_pattern(Pattern,Seq) 
+  when is_list(Pattern) and not is_integer(hd(Pattern)) ->
+    case Seq of
+	true -> Pattern;
+	false -> rm_dupl(Pattern,[])
+    end;
+convert_pattern(Pattern,_Seq) ->
+    [Pattern].
+
+rm_dupl([P|Ps],Acc) ->
+    case lists:member(P,Acc) of
+	true ->
+	    rm_dupl(Ps,Acc);
+	false ->
+	    rm_dupl(Ps,[P|Acc])
+    end;
+rm_dupl([],Acc) ->
+    lists:reverse(Acc).
+
+get_timeout(Opts) ->
+    case lists:keysearch(timeout,1,Opts) of
+	{value,{timeout,T}} -> T;
+	false -> ?DEFAULT_TIMEOUT
+    end.
+get_repeat(Opts) ->
+    case lists:keysearch(repeat,1,Opts) of
+	{value,{repeat,N}} when is_integer(N) ->
+	    N;
+	false ->
+	    case lists:member(repeat,Opts) of
+		true ->
+		    -1;
+		false ->
+		    false
+	    end
+    end.
+get_seq(Opts) ->
+    lists:member(sequence,Opts).
+get_haltpatterns(Opts) ->
+    case lists:keysearch(halt,1,Opts) of
+	{value,{halt,HaltPatterns}} ->
+	    convert_pattern(HaltPatterns,false);
+	false ->
+	    []
+    end.
+get_ignore_prompt(Opts) ->    
+    lists:member(ignore_prompt,Opts).
+	
+%% Repeat either single or sequence. All match results are accumulated
+%% and returned when a halt condition is fulllfilled.
+repeat_expect(Rest,_Pattern,Acc,#eo{repeat=0}) ->
+    {ok,lists:reverse(Acc),done,Rest};
+repeat_expect(Data,Pattern,Acc,EO) ->
+    case teln_expect1(Data,Pattern,[],EO) of
+	{ok,Matched,Rest} ->
+	    EO1 = EO#eo{repeat=EO#eo.repeat-1},
+	    repeat_expect(Rest,Pattern,[Matched|Acc],EO1);
+	{halt,Why,Rest} ->
+	    {ok,lists:reverse(Acc),Why,Rest};
+	{error,Reason} ->
+	    {error,Reason}
+    end.
+
+teln_expect1(Data,Pattern,Acc,EO) ->
+    ExpectFun = case EO#eo.seq of
+		    true -> fun() -> seq_expect(Data,Pattern,Acc,EO) end;
+		    false -> fun() -> one_expect(Data,Pattern,EO) end
+		end,
+    case ExpectFun() of
+	{match,Match,Rest} ->
+	    {ok,Match,Rest};
+	{halt,Why,Rest} ->
+	    {halt,Why,Rest};
+	NotFinished ->
+	    %% Get more data
+	    Fun = fun() -> get_data1(EO#eo.teln_pid) end,
+	    case ct_gen_conn:do_within_time(Fun, EO#eo.timeout) of
+		{error,Reason} -> 
+		    %% A timeout will occur when the telnet connection
+		    %% is idle for EO#eo.timeout milliseconds.
+		    {error,Reason};
+		{ok,Data1} ->
+		    case NotFinished of
+			{nomatch,Rest} ->
+			    %% One expect
+			    teln_expect1(Rest++Data1,Pattern,[],EO);
+			{continue,Patterns1,Acc1,Rest} ->
+			    %% Sequence
+			    teln_expect1(Rest++Data1,Patterns1,Acc1,EO)
+		    end
+	    end
+    end.
+
+get_data1(Pid) ->
+    case ct_telnet_client:get_data(Pid) of
+	{ok,[]} ->
+	    get_data1(Pid);
+	{ok,Data} ->
+	    {ok,Data}
+    end.
+
+%% 1) Single expect.
+%% First the whole data chunk is searched for a prompt (to avoid doing
+%% a regexp match for the prompt at each line).
+%% If we are searching for anyting else, the datachunk is split into
+%% lines and each line is matched against each pattern.
+
+%% one_expect: split data chunk at prompts
+one_expect(Data,Pattern,EO) ->
+    case match_prompt(Data,EO#eo.prx) of
+	{prompt,UptoPrompt,PromptType,Rest} ->
+	    case Pattern of 
+		[Prompt] when Prompt==prompt; Prompt=={prompt,PromptType} ->
+		    %% Only searching for prompt
+		    log_lines(UptoPrompt),
+		    try_cont_log("<b>PROMPT:</b> ~s", [PromptType]),
+		    {match,{prompt,PromptType},Rest};
+		[{prompt,_OtherPromptType}] ->
+		    %% Only searching for one specific prompt, not thisone
+		    log_lines(UptoPrompt),
+		    {nomatch,Rest};
+		_ ->
+		    one_expect1(UptoPrompt,Pattern,Rest,
+				EO#eo{found_prompt=PromptType})
+	    end;
+	noprompt ->
+	    case Pattern of
+		[Prompt] when Prompt==prompt; element(1,Prompt)==prompt ->
+		    %% Only searching for prompt
+		    LastLine = log_lines_not_last(Data),
+		    {nomatch,LastLine};
+		_ ->
+		    one_expect1(Data,Pattern,[],EO#eo{found_prompt=false})
+	    end
+    end.
+
+remove_zero(List) ->
+    [Ch || Ch <- List, Ch=/=0, Ch=/=13].
+
+%% one_expect1: split data chunk at lines
+one_expect1(Data,Pattern,Rest,EO) ->
+    case match_lines(Data,Pattern,EO) of
+	{match,Match,MatchRest} ->
+	    {match,Match,MatchRest++Rest};
+	{nomatch,prompt} ->
+	    one_expect(Rest,Pattern,EO);
+	{nomatch,NoMatchRest} ->
+	    {nomatch,NoMatchRest++Rest};
+	{halt,Why,HaltRest} ->
+	    {halt,Why,HaltRest++Rest}
+    end.
+    
+
+%% 2) Sequence.
+%% First the whole data chunk is searched for a prompt (to avoid doing
+%% a regexp match for the prompt at each line).
+%% If we are searching for anyting else, the datachunk is split into
+%% lines and each line is matched against the first pattern in the list.
+%% When a match is found, the match result is accumulated, and we keep
+%% searching for the next pattern in the list.
+
+%% seq_expect: Split data chunk at prompts
+seq_expect(Data,[],Acc,_EO) ->
+    {match,lists:reverse(Acc),Data};
+seq_expect([],Patterns,Acc,_EO) ->
+    {continue,Patterns,lists:reverse(Acc),[]};
+seq_expect(Data,Patterns,Acc,EO) ->
+    case match_prompt(Data,EO#eo.prx) of
+	{prompt,UptoPrompt,PromptType,Rest} ->
+	    seq_expect1(UptoPrompt,Patterns,Acc,Rest,
+			EO#eo{found_prompt=PromptType});
+	noprompt ->
+	    seq_expect1(Data,Patterns,Acc,[],EO#eo{found_prompt=false})
+    end.
+
+%% seq_expect1: For one prompt-chunk, match each pattern - line by
+%% line if it is other than the prompt we are seaching for.
+seq_expect1(Data,[prompt|Patterns],Acc,Rest,EO) ->
+    case EO#eo.found_prompt of
+	false ->
+	    LastLine = log_lines_not_last(Data),
+	    %% Rest==[] because no prompt is found
+	    {continue,[prompt|Patterns],Acc,LastLine};
+	PromptType ->
+	    log_lines(Data),
+	    try_cont_log("<b>PROMPT:</b> ~s", [PromptType]),
+	    seq_expect(Rest,Patterns,[{prompt,PromptType}|Acc],EO)
+    end;
+seq_expect1(Data,[{prompt,PromptType}|Patterns],Acc,Rest,EO) ->
+    case EO#eo.found_prompt of
+	false ->
+	    LastLine = log_lines_not_last(Data),
+	    %% Rest==[] because no prompt is found
+	    {continue,[{prompt,PromptType}|Patterns],Acc,LastLine};
+	PromptType ->
+	    log_lines(Data),
+	    try_cont_log("<b>PROMPT:</b> ~s", [PromptType]),
+	    seq_expect(Rest,Patterns,[{prompt,PromptType}|Acc],EO);
+	_OtherPromptType ->
+	    log_lines(Data),
+	    seq_expect(Rest,[{prompt,PromptType}|Patterns],Acc,EO)
+    end;
+seq_expect1(Data,[Pattern|Patterns],Acc,Rest,EO) ->
+    case match_lines(Data,[Pattern],EO) of
+	{match,Match,MatchRest} ->
+	    seq_expect1(MatchRest,Patterns,[Match|Acc],Rest,EO);
+	{nomatch,prompt} ->
+	    seq_expect(Rest,[Pattern|Patterns],Acc,EO);
+	{nomatch,NoMatchRest} when Rest==[] ->
+	    %% The data did not end with a prompt
+	    {continue,[Pattern|Patterns],Acc,NoMatchRest};
+	{halt,Why,HaltRest} ->
+	    {halt,Why,HaltRest++Rest}
+    end;
+seq_expect1(Data,[],Acc,Rest,_EO) ->
+    {match,lists:reverse(Acc),Data++Rest}.
+
+%% Split prompt-chunk at lines
+match_lines(Data,Patterns,EO) ->
+    FoundPrompt = EO#eo.found_prompt,
+    case one_line(Data,[]) of
+	{noline,Rest} when FoundPrompt=/=false ->
+	    %% This is the line including the prompt
+	    case match_line(Rest,Patterns,FoundPrompt,EO) of
+		nomatch ->
+		    {nomatch,prompt};
+		{Tag,Match} ->
+		    {Tag,Match,[]}
+	    end;
+	{noline,Rest} ->
+	    {nomatch,Rest};
+	{Line,Rest} ->
+	    case match_line(Line,Patterns,false,EO) of
+		nomatch ->
+		    match_lines(Rest,Patterns,EO);
+		{Tag,Match} ->
+		    {Tag,Match,Rest}
+	    end
+    end.
+    
+
+%% For one line, match each pattern
+match_line(Line,Patterns,FoundPrompt,EO) ->
+    match_line(Line,Patterns,FoundPrompt,EO,match).
+
+match_line(Line,[prompt|Patterns],false,EO,RetTag) ->
+    match_line(Line,Patterns,false,EO,RetTag);
+match_line(Line,[prompt|_Patterns],FoundPrompt,_EO,RetTag) ->
+    try_cont_log("       ~s", [Line]),
+    try_cont_log("<b>PROMPT:</b> ~s", [FoundPrompt]),
+    {RetTag,{prompt,FoundPrompt}};
+match_line(Line,[{prompt,PromptType}|_Patterns],FoundPrompt,_EO,RetTag) 
+  when PromptType==FoundPrompt ->
+    try_cont_log("       ~s", [Line]),
+    try_cont_log("<b>PROMPT:</b> ~s", [FoundPrompt]),
+    {RetTag,{prompt,FoundPrompt}};
+match_line(Line,[{prompt,PromptType}|Patterns],FoundPrompt,EO,RetTag) 
+  when PromptType=/=FoundPrompt ->
+    match_line(Line,Patterns,FoundPrompt,EO,RetTag);
+match_line(Line,[{Tag,Pattern}|Patterns],FoundPrompt,EO,RetTag) ->
+    case re:run(Line,Pattern,[{capture,all,list}]) of
+	nomatch ->
+	    match_line(Line,Patterns,FoundPrompt,EO,RetTag);
+	{match,Match} ->
+	    try_cont_log("<b>MATCH:</b> ~s", [Line]),
+	    {RetTag,{Tag,Match}}
+    end;
+match_line(Line,[Pattern|Patterns],FoundPrompt,EO,RetTag) ->
+    case re:run(Line,Pattern,[{capture,all,list}]) of
+	nomatch ->
+	    match_line(Line,Patterns,FoundPrompt,EO,RetTag);
+	{match,Match} ->
+	    try_cont_log("<b>MATCH:</b> ~s", [Line]),
+	    {RetTag,Match}
+    end;
+match_line(Line,[],FoundPrompt,EO,match) ->
+    match_line(Line,EO#eo.haltpatterns,FoundPrompt,EO,halt);
+match_line(Line,[],_FoundPrompt,_EO,halt) ->
+    try_cont_log("       ~s", [Line]),
+    nomatch.
+
+one_line([$\n|Rest],Line) ->
+    {lists:reverse(Line),Rest};
+one_line([$\r|Rest],Line) ->
+    one_line(Rest,Line);
+one_line([0|Rest],Line) ->
+    one_line(Rest,Line);
+one_line([Char|Rest],Line) ->
+    one_line(Rest,[Char|Line]);
+one_line([],Line) ->
+    {noline,lists:reverse(Line)}.
+
+debug_log_lines(String) ->
+    Old = put(silent,true),
+    log_lines(String),
+    put(silent,Old).
+
+log_lines(String) ->
+    case log_lines_not_last(String) of
+	[] ->
+	    ok;
+	LastLine ->
+	    try_cont_log("       ~s", [LastLine])
+    end.
+
+log_lines_not_last(String) ->
+    case add_tabs(String,[],[]) of
+	{[],LastLine} ->
+	    LastLine;
+	{String1,LastLine} ->
+	    try_cont_log("~s",[String1]),
+	    LastLine
+    end.
+
+add_tabs([0|Rest],Acc,LastLine) ->
+    add_tabs(Rest,Acc,LastLine);
+add_tabs([$\r|Rest],Acc,LastLine) ->
+    add_tabs(Rest,Acc,LastLine);
+add_tabs([$\n|Rest],Acc,LastLine) ->
+    add_tabs(Rest,[$\n|LastLine] ++ [$\s,$\s,$\s,$\s,$\s,$\s,$\s|Acc],[]);
+add_tabs([Ch|Rest],Acc,LastLine) ->
+    add_tabs(Rest,Acc,[Ch|LastLine]);
+add_tabs([],[$\n|Acc],LastLine) ->
+    {lists:reverse(Acc),lists:reverse(LastLine)};
+add_tabs([],[],LastLine) ->
+    {[],lists:reverse(LastLine)}.
+
+
+
+
+%%% @hidden
+teln_receive_until_prompt(Pid,Prx,Timeout) ->
+    Fun = fun() -> teln_receive_until_prompt(Pid,Prx,[],[]) end,
+    ct_gen_conn:do_within_time(Fun, Timeout).
+
+teln_receive_until_prompt(Pid,Prx,Acc,LastLine) ->
+    {ok,Data} = ct_telnet_client:get_data(Pid),
+    case check_for_prompt(Prx,LastLine ++ Data) of
+	{prompt,Lines,PromptType,Rest} ->
+	    Return = lists:reverse(lists:append([Lines|Acc])),
+	   {ok,Return,PromptType,Rest};
+	{noprompt,Lines,LastLine1} ->
+	    teln_receive_until_prompt(Pid,Prx,[Lines|Acc],LastLine1)
+   end.
+
+check_for_prompt(Prx,Data) ->
+    case match_prompt(Data,Prx) of
+	{prompt,UptoPrompt,PromptType,Rest} ->
+	    {RevLines,LastLine} = split_lines(UptoPrompt),
+	    {prompt,[LastLine|RevLines],PromptType,Rest};
+	noprompt ->
+	    {RevLines,Rest} = split_lines(Data),
+	    {noprompt,RevLines,Rest}
+    end.
+
+split_lines(String) ->
+    split_lines(String,[],[]).
+split_lines([$\n|Rest],Line,Lines) ->
+    split_lines(Rest,[],[lists:reverse(Line)|Lines]);
+split_lines([$\r|Rest],Line,Lines) ->
+    split_lines(Rest,Line,Lines);
+split_lines([0|Rest],Line,Lines) ->
+    split_lines(Rest,Line,Lines);
+split_lines([Char|Rest],Line,Lines) ->
+    split_lines(Rest,[Char|Line],Lines);
+split_lines([],Line,Lines) ->
+    {Lines,lists:reverse(Line)}.
+
+
+match_prompt(Str,Prx) ->
+    match_prompt(Str,Prx,[]).
+match_prompt(Str,Prx,Acc) ->
+    case re:run(Str,Prx) of
+	nomatch ->
+	    noprompt;
+	{match,[{Start,Len}]} ->
+	    case split_prompt_string(Str,Start+1,Start+Len,1,[],[]) of
+		{noprompt,Done,Rest} ->
+		    match_prompt(Rest,Prx,Done);
+		{prompt,UptoPrompt,Prompt,Rest} ->
+		    {prompt,lists:reverse(UptoPrompt++Acc),
+		     lists:reverse(Prompt),Rest}
+	    end
+    end.
+
+split_prompt_string([Ch|Str],Start,End,N,UptoPrompt,Prompt) when N<Start ->
+    split_prompt_string(Str,Start,End,N+1,[Ch|UptoPrompt],Prompt);
+split_prompt_string([Ch|Str],Start,End,N,UptoPrompt,Prompt) 
+  when N>=Start, N<End->
+    split_prompt_string(Str,Start,End,N+1,UptoPrompt,[Ch|Prompt]);
+split_prompt_string([Ch|Rest],_Start,End,N,UptoPrompt,Prompt) when N==End ->
+    case UptoPrompt of
+	[$",$=,$T,$P,$M,$O,$R,$P|_] ->
+	    %% This is a line from "listenv", it is not a real prompt
+	    {noprompt,[Ch|Prompt]++UptoPrompt,Rest};
+	[$\s,$t,$s,$a|_] when Prompt==":nigol" ->
+	    %% This is probably the "Last login:" statement which is
+	    %% written when telnet connection is openend.
+	    {noprompt,[Ch|Prompt]++UptoPrompt,Rest};
+	_ ->
+	    {prompt,[Ch|Prompt]++UptoPrompt,[Ch|Prompt],Rest}
+    end.
diff --git a/lib/common_test/src/ct_telnet_client.erl b/lib/common_test/src/ct_telnet_client.erl
new file mode 100644
index 0000000000..e460a50eac
--- /dev/null
+++ b/lib/common_test/src/ct_telnet_client.erl
@@ -0,0 +1,304 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 2003-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%
+%%
+
+%%---------------------------------------------------------------
+%% Basic negotiated options with Telnet (RFC 854)
+%%
+%% Side A request: I WILL set option Opt.
+%% Side B answer:  DO go ahead, or no, DON'T set it.
+%% 
+%% Side A request: Please DO set this option. 
+%% Side B answer:  Ok I WILL, or no, I WON'T set it.
+%%
+%% "Enable option" requests may be rejected. 
+%% "Disable option" requests must not.
+%%---------------------------------------------------------------
+
+-module(ct_telnet_client).
+
+-export([open/1, open/2, open/3, close/1]).
+-export([send_data/2, get_data/1]).
+
+-define(DBG, false).
+
+-define(TELNET_PORT, 23).
+-define(OPEN_TIMEOUT,10000).
+
+%% telnet control characters
+-define(SE,	240).
+-define(NOP,	241).
+-define(DM,	242).
+-define(BRK,	243).
+-define(IP,	244).
+-define(AO,	245).
+-define(AYT,	246).
+-define(EC,	247).
+-define(EL,	248).
+-define(GA,	249).
+-define(SB,	250).
+-define(WILL,	251).
+-define(WONT,	252).
+-define(DO,	253).
+-define(DONT,	254).
+-define(IAC,	255).
+
+%% telnet options
+-define(BINARY,            0).
+-define(ECHO,	           1).
+-define(SUPPRESS_GO_AHEAD, 3).
+-define(TERMINAL_TYPE,     24).  
+-define(WINDOW_SIZE,       31).
+
+-record(state,{get_data}).
+
+open(Server) ->
+    open(Server, ?TELNET_PORT, ?OPEN_TIMEOUT).
+
+open(Server, Port) ->
+    open(Server, Port, ?OPEN_TIMEOUT).
+
+open(Server, Port, Timeout) ->
+    Self = self(),
+    Pid = spawn(fun() -> init(Self, Server, Port, Timeout) end),
+    receive 
+	{open,Pid} ->
+	    {ok,Pid};
+	{Error,Pid} ->
+	    Error
+    end.
+
+close(Pid) ->
+    Pid ! close.
+
+send_data(Pid, Data) ->
+    Pid ! {send_data, Data++"\n"},
+    ok.
+
+get_data(Pid) ->
+    Pid ! {get_data, self()},
+    receive 
+	{data,Data} ->
+	    {ok, Data}
+    end.
+
+
+%%%-----------------------------------------------------------------
+%%% Internal functions
+init(Parent, Server, Port, Timeout) ->
+    case gen_tcp:connect(Server, Port, [list,{packet,0}], Timeout) of
+	{ok,Sock} ->
+	    dbg("Connected to: ~p\n", [Server]),
+	    send([?IAC,?DO,?SUPPRESS_GO_AHEAD], Sock),	      
+	    Parent ! {open,self()},
+	    loop(#state{get_data=10}, Sock, []),
+	    gen_tcp:close(Sock);
+        Error ->
+	    Parent ! {Error,self()}
+    end.
+
+
+
+loop(State, Sock, Acc) ->
+    receive
+	{tcp_closed,_} ->
+	    dbg("Connection closed\n", []),
+	    receive
+		{get_data,Pid} ->
+		    Pid ! closed
+	    after 100 ->
+		    ok
+	    end;
+	{tcp,_,Msg0} ->
+	    dbg("tcp msg: ~p~n",[Msg0]),
+	    Msg = check_msg(Sock,Msg0,[]),
+	    loop(State, Sock, [Msg | Acc]);
+	{send_data,Data} ->
+	    send(Data, Sock),
+	    loop(State, Sock, Acc);
+	{get_data,Pid} ->
+	    NewState = 
+		case Acc of
+		    [] ->
+			dbg("get_data nodata\n",[]),
+			erlang:send_after(100,self(),{get_data_delayed,Pid}),
+			State#state{get_data=State#state.get_data - 1};
+		    _ ->
+			Pid ! {data,lists:reverse(lists:append(Acc))},
+			State
+		end,
+	    loop(NewState, Sock, []);
+	{get_data_delayed,Pid} ->
+	    NewState = case State#state.get_data of
+			   0 ->
+			       send([?IAC,?DO,?NOP], Sock),
+			       dbg("delayed after 1000\n",[]),
+			       State#state{get_data=10};
+			   _ ->
+			       State
+		       end,
+	    NewAcc = 
+		case erlang:is_process_alive(Pid) of
+		    true ->
+			Pid ! {data,lists:reverse(lists:append(Acc))},
+			[];
+		    false ->
+			Acc
+		end,
+	    loop(NewState, Sock, NewAcc);
+			       
+	close ->
+	    dbg("Closing connection\n", []),
+	    gen_tcp:close(Sock),
+	    ok
+    after 1000 ->
+	    case Acc of
+		[] -> % no data buffered
+		    send([?IAC,?DO,?NOP], Sock),
+		    dbg("after 1000\n",[]);
+		_ ->
+		    true
+	    end,
+	    loop(State, Sock, Acc)
+    end.
+
+send(Data, Sock) ->
+    dbg("Sending: ~p\n", [Data]),
+    gen_tcp:send(Sock, Data),
+    ok.
+
+check_msg(Sock,[?IAC | Cs], Acc) ->
+    case get_cmd(Cs) of
+	{Cmd,Cs1} ->
+	    dbg("Got ", []), 
+	    cmd_dbg(Cmd),
+	    respond_cmd(Cmd, Sock),
+	    check_msg(Sock, Cs1, Acc); 
+	error ->
+	    Acc
+    end;
+check_msg(Sock,[H|T],Acc) ->
+    check_msg(Sock,T,[H|Acc]);
+check_msg(_Sock,[],Acc) ->
+    Acc.
+
+%% Positive responses (WILL and DO).
+
+respond_cmd([?WILL,?ECHO], Sock) ->
+    R = [?IAC,?DO,?ECHO],
+    cmd_dbg(R),
+    gen_tcp:send(Sock, R);
+
+respond_cmd([?DO,?ECHO], Sock) ->
+    R = [?IAC,?WILL,?ECHO],
+    cmd_dbg(R),
+    gen_tcp:send(Sock, R);
+
+%% Answers from server
+
+respond_cmd([?WILL,?SUPPRESS_GO_AHEAD], _Sock) ->
+    dbg("Server will suppress-go-ahead\n", []);
+
+respond_cmd([?WONT,?SUPPRESS_GO_AHEAD], _Sock) ->
+    dbg("Warning! Server won't suppress-go-ahead\n", []);
+
+respond_cmd([?DONT | _Opt], _Sock) ->		% server ack?
+    ok;						
+respond_cmd([?WONT | _Opt], _Sock) ->		% server ack?
+    ok;						
+
+%% Negative responses (WON'T and DON'T). These are default!
+
+respond_cmd([?WILL,Opt], Sock) ->
+    R = [?IAC,?DONT,Opt],
+    cmd_dbg(R),
+    gen_tcp:send(Sock, R);
+
+respond_cmd([?DO | Opt], Sock) ->
+    R = [?IAC,?WONT | Opt],
+    cmd_dbg(R),
+    gen_tcp:send(Sock, R);
+
+%% Unexpected messages.
+
+respond_cmd([Cmd | Opt], _Sock) when Cmd >= 240, Cmd =< 255 ->
+    dbg("Received cmd: ~w. Ignored!\n", [[Cmd | Opt]]);
+
+respond_cmd([Cmd | Opt], _Sock)  ->
+    dbg("WARNING: Received unknown cmd: ~w. Ignored!\n", [[Cmd | Opt]]).
+
+
+get_cmd([Cmd | Rest]) when Cmd == ?SB ->
+    get_subcmd(Rest, []);
+
+get_cmd([Cmd,Opt | Rest]) ->
+    {[Cmd,Opt], Rest};
+
+get_cmd(_Other) ->
+    error.
+
+get_subcmd([?SE | Rest], Acc) ->
+    {[?SE | lists:reverse(Acc)], Rest};
+
+get_subcmd([Opt | Rest], Acc) ->
+    get_subcmd(Rest, [Opt | Acc]).
+
+
+dbg(_Str,_Args) -> ok.
+%    if ?DBG -> io:format(_Str,_Args);
+%       true -> ok
+%    end.
+
+cmd_dbg(_Cmd) -> ok.
+%     if ?DBG ->
+% 	    case _Cmd of
+% 		[?IAC|Cmd1] ->
+% 		    cmd_dbg(Cmd1);
+% 		[Ctrl|Opts] ->
+% 		    CtrlStr = 
+% 			case Ctrl of
+% 			    ?DO ->   "DO";
+% 			    ?DONT -> "DONT";
+% 			    ?WILL -> "WILL";
+% 			    ?WONT -> "WONT";
+% 			    _ ->     "CMD"
+% 			end,
+% 		    Opts1 =
+% 			case Opts of 
+% 			    [Opt] -> Opt;
+% 			    _ -> Opts
+% 			end,
+% 		    io:format("~s(~w): ~w\n", [CtrlStr,Ctrl,Opts1]);
+% 		Any  ->
+% 		    io:format("Unexpected in cmd_dbg:~n~w~n",[Any])
+% 	    end;
+%        true -> ok
+%     end.
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/lib/common_test/src/ct_testspec.erl b/lib/common_test/src/ct_testspec.erl
new file mode 100644
index 0000000000..21a2f82a54
--- /dev/null
+++ b/lib/common_test/src/ct_testspec.erl
@@ -0,0 +1,780 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 2006-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%
+%%
+
+%%% @doc Common Test Framework functions handlig test specifikations.
+%%%
+%%% <p>This module exports functions that are used within CT to
+%%% scan and parse test specifikations.</p>
+-module(ct_testspec).
+
+-export([prepare_tests/1, prepare_tests/2, 
+	 collect_tests_from_list/2, collect_tests_from_list/3,
+	 collect_tests_from_file/2, collect_tests_from_file/3]).
+
+-include("ct_util.hrl").
+
+%%%------------------------------------------------------------------
+%%% NOTE:
+%%% Multiple testspecs may be used as input with the result that
+%%% the data is merged. It's in this case up to the user to ensure
+%%% there are no clashes in any "global" variables, such as logdir.
+%%%-------------------------------------------------------------------
+
+%%%-------------------------------------------------------------------
+%%% prepare_tests/2 compiles the testspec data into a list of tests
+%%% to be run and a list of tests to be skipped, either for one
+%%% particular node or for all nodes.
+%%%-------------------------------------------------------------------
+
+%%%-------------------------------------------------------------------
+%%% Version 1 - extract and return all tests and skips for Node 
+%%%             (incl all_nodes)
+%%%-------------------------------------------------------------------
+prepare_tests(TestSpec,Node) when is_record(TestSpec,testspec), is_atom(Node) ->
+    case lists:keysearch(Node,1,prepare_tests(TestSpec)) of
+	{value,{Node,Run,Skip}} ->
+	    {Run,Skip};
+	false ->
+	    {[],[]}
+    end.
+
+%%%-------------------------------------------------------------------
+%%% Version 2 - create and return a list of {Node,Run,Skip} tuples, 
+%%% one for each node specified in the test specification. 
+%%% The tuples in the Run list will have the form {Dir,Suites,Cases} 
+%%% and the tuples in the Skip list will have the form 
+%%% {Dir,Suites,Comment} or {Dir,Suite,Cases,Comment}. 
+%%%-------------------------------------------------------------------
+prepare_tests(TestSpec) when is_record(TestSpec,testspec) ->
+    Tests = TestSpec#testspec.tests,
+    %% Sort Tests into "flat" Run and Skip lists (not sorted per node).
+    {Run,Skip} = get_run_and_skip(Tests,[],[]),
+    %% Create initial list of {Node,{Run,Skip}} tuples
+    NodeList = lists:map(fun(N) -> {N,{[],[]}} end, list_nodes(TestSpec)),
+    %% Get all Run tests sorted per node basis.
+    NodeList1 = run_per_node(Run,NodeList),    
+    %% Get all Skip entries sorted per node basis.
+    NodeList2 = skip_per_node(Skip,NodeList1),
+    %% Change representation.
+    Result=
+	lists:map(fun({Node,{Run1,Skip1}}) ->
+			  Run2 = lists:map(fun({D,{Ss,Cs}}) ->
+						   {D,Ss,Cs}
+					   end, Run1),
+			  Skip2 = lists:map(fun({D,{Ss,Cmt}}) ->
+						    {D,Ss,Cmt};
+					       ({D,{S,Cs,Cmt}}) ->
+						    {D,S,Cs,Cmt}
+					    end, Skip1),
+			  {Node,Run2,Skip2}
+		  end, NodeList2),
+    Result.
+
+%% run_per_node/2 takes the Run list as input and returns a list
+%% of {Node,RunPerNode,[]} tuples where the tests have been sorted
+%% on a per node basis.
+run_per_node([{{Node,Dir},Test}|Ts],Result) ->
+    {value,{Node,{Run,Skip}}} = lists:keysearch(Node,1,Result),
+    Run1 = merge_tests(Dir,Test,Run),
+    run_per_node(Ts,insert_in_order({Node,{Run1,Skip}},Result));
+run_per_node([],Result) ->
+    Result.
+
+merge_tests(Dir,Test={all,_},TestDirs) ->
+    %% overwrite all previous entries for Dir
+    TestDirs1 = lists:filter(fun({D,_}) when D==Dir -> 
+				     false;
+				(_) -> 
+				     true
+			     end,TestDirs),
+    insert_in_order({Dir,Test},TestDirs1);
+merge_tests(Dir,Test={Suite,all},TestDirs) ->
+    TestDirs1 = lists:filter(fun({D,{S,_}}) when D==Dir,S==Suite -> 
+				     false;
+				(_) -> 
+				     true
+			     end,TestDirs),
+    TestDirs1++[{Dir,Test}];
+merge_tests(Dir,Test,TestDirs) ->
+    merge_suites(Dir,Test,TestDirs).
+
+merge_suites(Dir,{Suite,Cases},[{Dir,{Suite,Cases0}}|Dirs]) ->
+    Cases1 = insert_in_order(Cases,Cases0),
+    [{Dir,{Suite,Cases1}}|Dirs];
+merge_suites(Dir,Test,[Other|Dirs]) ->
+    [Other|merge_suites(Dir,Test,Dirs)];
+merge_suites(Dir,Test,[]) ->
+    [{Dir,Test}].
+
+%% skip_per_node/2 takes the Skip list as input and returns a list
+%% of {Node,RunPerNode,SkipPerNode} tuples where the skips have been 
+%% sorted on a per node basis.
+skip_per_node([{{Node,Dir},Test}|Ts],Result) ->
+    {value,{Node,{Run,Skip}}} = lists:keysearch(Node,1,Result),
+    Skip1 = [{Dir,Test}|Skip],
+    skip_per_node(Ts,insert_in_order({Node,{Run,Skip1}},Result));
+skip_per_node([],Result) -> 
+    Result.
+
+%% get_run_and_skip/3 takes a list of test terms as input and sorts
+%% them into a list of Run tests and a list of Skip entries. The
+%% elements all have the form 
+%%
+%%   {{Node,Dir},TestData} 
+%%
+%% TestData has the form:
+%%
+%%   Run entry:  {Suite,Cases}          
+%%
+%%   Skip entry: {Suites,Comment} or {Suite,Cases,Comment}
+%%
+get_run_and_skip([{{Node,Dir},Suites}|Tests],Run,Skip) ->    
+    TestDir = ct_util:get_testdir(Dir,catch element(1,hd(Suites))),
+    case lists:keysearch(all,1,Suites) of
+	{value,_} ->				% all Suites in Dir
+	    Skipped = get_skipped_suites(Node,TestDir,Suites),
+	    %% note: this adds an 'all' test even if only skip is specified,
+	    %% probably a good thing cause it gets logged as skipped then
+	    get_run_and_skip(Tests,
+			     [[{{Node,TestDir},{all,all}}]|Run],
+			     [Skipped|Skip]);
+	false ->
+	    {R,S} = prepare_suites(Node,TestDir,Suites,[],[]),
+	    get_run_and_skip(Tests,[R|Run],[S|Skip])
+    end;
+get_run_and_skip([],Run,Skip) ->
+    {lists:flatten(lists:reverse(Run)),
+     lists:flatten(lists:reverse(Skip))}.
+
+prepare_suites(Node,Dir,[{Suite,Cases}|Suites],Run,Skip) ->
+    case lists:member(all,Cases) of
+	true ->					% all Cases in Suite
+	    Skipped = get_skipped_cases(Node,Dir,Suite,Cases),
+	    %% note: this adds an 'all' test even if only skip is specified
+	    prepare_suites(Node,Dir,Suites,
+			   [[{{Node,Dir},{Suite,all}}]|Run],
+			   [Skipped|Skip]);
+	false ->
+	    {RL,SL} = prepare_cases(Node,Dir,Suite,Cases),
+	    prepare_suites(Node,Dir,Suites,[RL|Run],[SL|Skip])
+    end;
+prepare_suites(_Node,_Dir,[],Run,Skip) ->
+    {lists:flatten(lists:reverse(Run)),
+     lists:flatten(lists:reverse(Skip))}.
+
+prepare_cases(Node,Dir,Suite,Cases) ->
+    case get_skipped_cases(Node,Dir,Suite,Cases) of
+	SkipAll=[{{Node,Dir},{Suite,_Cmt}}] ->		% all cases to be skipped
+	    %% note: this adds an 'all' test even if only skip is specified
+	    {[{{Node,Dir},{Suite,all}}],SkipAll};
+	Skipped ->
+	    %% note: this adds a test even if only skip is specified
+	    PrepC = lists:foldr(fun({C,{skip,_Cmt}},Acc) ->
+					case lists:member(C,Cases) of
+					    true ->
+						Acc;
+					    false ->
+						[C|Acc]
+					end;
+				   (C,Acc) -> [C|Acc]
+				end, [], Cases),
+	    {{{Node,Dir},{Suite,PrepC}},Skipped}
+    end.
+
+get_skipped_suites(Node,Dir,Suites) ->
+    lists:flatten(get_skipped_suites1(Node,Dir,Suites)).
+
+get_skipped_suites1(Node,Dir,[{Suite,Cases}|Suites]) ->
+    SkippedCases = get_skipped_cases(Node,Dir,Suite,Cases),
+    [SkippedCases|get_skipped_suites1(Node,Dir,Suites)];
+get_skipped_suites1(_,_,[]) ->
+    [].
+
+get_skipped_cases(Node,Dir,Suite,Cases) ->
+    case lists:keysearch(all,1,Cases) of
+	{value,{all,{skip,Cmt}}} ->
+	    [{{Node,Dir},{Suite,Cmt}}];
+	false ->
+	    get_skipped_cases1(Node,Dir,Suite,Cases)
+    end.
+
+get_skipped_cases1(Node,Dir,Suite,[{Case,{skip,Cmt}}|Cs]) ->
+    [{{Node,Dir},{Suite,Case,Cmt}}|get_skipped_cases1(Node,Dir,Suite,Cs)];
+get_skipped_cases1(Node,Dir,Suite,[_Case|Cs]) ->
+    get_skipped_cases1(Node,Dir,Suite,Cs);
+get_skipped_cases1(_,_,_,[]) ->
+    [].	
+
+%%% collect_tests_from_file reads a testspec file and returns a record
+%%% containing the data found.
+collect_tests_from_file(Specs, Relaxed) ->
+    collect_tests_from_file(Specs,[node()],Relaxed).
+
+collect_tests_from_file(Specs,Nodes,Relaxed) when is_list(Nodes) ->
+    NodeRefs = lists:map(fun(N) -> {undefined,N} end, Nodes),
+    catch collect_tests_from_file1(Specs,#testspec{nodes=NodeRefs},Relaxed).
+
+collect_tests_from_file1([Spec|Specs],TestSpec,Relaxed) ->
+    case file:consult(Spec) of
+	{ok,Terms} ->	    
+	    TestSpec1 = collect_tests(Terms,TestSpec,Relaxed),
+	    collect_tests_from_file1(Specs,TestSpec1,Relaxed);
+	{error,Reason} ->
+	    throw({error,{Spec,Reason}})
+    end;
+collect_tests_from_file1([],TS=#testspec{config=Cfgs,event_handler=EvHs,
+					 include=Incl,tests=Tests},_) ->
+    TS#testspec{config=lists:reverse(Cfgs),
+		event_handler=lists:reverse(EvHs),
+		include=lists:reverse(Incl),
+		tests=lists:flatten(Tests)}.
+
+collect_tests_from_list(Terms,Relaxed) ->
+    collect_tests_from_list(Terms,[node()],Relaxed).
+
+collect_tests_from_list(Terms,Nodes,Relaxed) when is_list(Nodes) ->
+    NodeRefs = lists:map(fun(N) -> {undefined,N} end, Nodes),
+    case catch collect_tests(Terms,#testspec{nodes=NodeRefs},Relaxed) of
+	E = {error,_} ->
+	    E;
+	TS ->
+	    #testspec{config=Cfgs,event_handler=EvHs,include=Incl,tests=Tests} = TS,
+	    TS#testspec{config=lists:reverse(Cfgs),
+			event_handler=lists:reverse(EvHs),
+			include=lists:reverse(Incl),
+			tests=lists:flatten(Tests)}
+    end.
+    
+collect_tests(Terms,TestSpec,Relaxed) ->
+    put(relaxed,Relaxed),
+    TestSpec1 = get_global(Terms,TestSpec),
+    TestSpec2 = get_all_nodes(Terms,TestSpec1),
+    add_tests(Terms,TestSpec2).
+    
+get_global([{alias,Ref,Dir}|Ts],Spec=#testspec{alias=Refs}) ->
+    get_global(Ts,Spec#testspec{alias=[{Ref,get_absname(Dir)}|Refs]});
+get_global([{node,Ref,Node}|Ts],Spec=#testspec{nodes=Refs}) ->
+    get_global(Ts,Spec#testspec{nodes=[{Ref,Node}|lists:keydelete(Node,2,Refs)]});
+get_global([_|Ts],Spec) -> get_global(Ts,Spec);
+get_global([],Spec) -> Spec.
+
+get_absname(TestDir) ->
+    AbsName = filename:absname(TestDir),
+    TestDirName = filename:basename(AbsName),
+    Path = filename:dirname(AbsName),
+    TopDir = filename:basename(Path),
+    Path1 =
+	case TopDir of
+	    "." ->
+		[_|Rev] = lists:reverse(filename:split(Path)),
+		filename:join(lists:reverse(Rev));
+	    ".." ->
+		[_,_|Rev] = lists:reverse(filename:split(Path)),
+		filename:join(lists:reverse(Rev));
+	    _ ->
+		Path
+	end,
+    filename:join(Path1,TestDirName).
+
+%% go through all tests and register all nodes found
+get_all_nodes([{suites,Nodes,_,_}|Ts],Spec) when is_list(Nodes) ->
+    get_all_nodes(Ts,save_nodes(Nodes,Spec));
+get_all_nodes([{suites,Node,_,_}|Ts],Spec) ->
+    get_all_nodes(Ts,save_nodes([Node],Spec));
+get_all_nodes([{cases,Nodes,_,_,_}|Ts],Spec) when is_list(Nodes) ->
+    get_all_nodes(Ts,save_nodes(Nodes,Spec));
+get_all_nodes([{cases,Node,_,_,_}|Ts],Spec) ->
+    get_all_nodes(Ts,save_nodes([Node],Spec));
+get_all_nodes([{skip_suites,Nodes,_,_,_}|Ts],Spec) when is_list(Nodes) ->
+    get_all_nodes(Ts,save_nodes(Nodes,Spec));
+get_all_nodes([{skip_suites,Node,_,_,_}|Ts],Spec) ->
+    get_all_nodes(Ts,save_nodes([Node],Spec));
+get_all_nodes([{skip_cases,Nodes,_,_,_,_}|Ts],Spec) when is_list(Nodes) ->
+    get_all_nodes(Ts,save_nodes(Nodes,Spec));
+get_all_nodes([{skip_cases,Node,_,_,_,_}|Ts],Spec) ->
+    get_all_nodes(Ts,save_nodes([Node],Spec));
+get_all_nodes([_|Ts],Spec) ->
+    get_all_nodes(Ts,Spec);
+get_all_nodes([],Spec) ->
+    Spec.
+
+save_nodes(Nodes,Spec=#testspec{nodes=NodeRefs}) ->
+    NodeRefs1 =
+	lists:foldr(fun(all_nodes,NR) ->
+			    NR;
+		       (Node,NR) ->
+			    case lists:keymember(Node,1,NR) of
+				true ->
+				    NR;
+				false ->
+				    case lists:keymember(Node,2,NR) of
+					true -> 
+					    NR;
+					false -> 
+					    [{undefined,Node}|NR]
+				    end
+			    end
+		    end,NodeRefs,Nodes),
+    Spec#testspec{nodes=NodeRefs1}.    							
+
+list_nodes(#testspec{nodes=NodeRefs}) ->
+    lists:map(fun({_Ref,Node}) -> Node end, NodeRefs).		      
+
+%% Associate a "global" logdir with all nodes
+%% except those with specific logdir, e.g:
+%% ["/tmp/logdir",{ct1@finwe,"/tmp/logdir2"}]
+%% means all nodes should write to /tmp/logdir
+%% except ct1@finwe that should use /tmp/logdir2.
+
+%% --- logdir ---
+add_tests([{logdir,all_nodes,Dir}|Ts],Spec) ->
+    Dirs = Spec#testspec.logdir,
+    Tests = [{logdir,N,Dir} || N <- list_nodes(Spec),
+			       lists:keymember(ref2node(N,Spec#testspec.nodes),
+					       1,Dirs) == false],
+    add_tests(Tests++Ts,Spec);
+add_tests([{logdir,Nodes,Dir}|Ts],Spec) when is_list(Nodes) ->
+    Ts1 = separate(Nodes,logdir,[Dir],Ts,Spec#testspec.nodes),
+    add_tests(Ts1,Spec);    
+add_tests([{logdir,Node,Dir}|Ts],Spec) ->
+    Dirs = Spec#testspec.logdir,
+    Dirs1 = [{ref2node(Node,Spec#testspec.nodes),Dir} |
+	     lists:keydelete(ref2node(Node,Spec#testspec.nodes),1,Dirs)],
+    add_tests(Ts,Spec#testspec{logdir=Dirs1});
+add_tests([{logdir,Dir}|Ts],Spec) ->
+    add_tests([{logdir,all_nodes,Dir}|Ts],Spec);
+
+%% --- cover ---
+add_tests([{cover,all_nodes,File}|Ts],Spec) ->
+    Tests = lists:map(fun(N) -> {cover,N,File} end, list_nodes(Spec)),
+    add_tests(Tests++Ts,Spec);
+add_tests([{cover,Nodes,File}|Ts],Spec) when is_list(Nodes) ->
+    Ts1 = separate(Nodes,cover,[File],Ts,Spec#testspec.nodes),
+    add_tests(Ts1,Spec);    
+add_tests([{cover,Node,File}|Ts],Spec) ->
+    CoverFs = Spec#testspec.cover,
+    CoverFs1 = [{ref2node(Node,Spec#testspec.nodes),File} |
+		lists:keydelete(ref2node(Node,Spec#testspec.nodes),1,CoverFs)],
+    add_tests(Ts,Spec#testspec{cover=CoverFs1});
+add_tests([{cover,File}|Ts],Spec) ->
+    add_tests([{cover,all_nodes,File}|Ts],Spec);
+
+%% --- config ---
+add_tests([{config,all_nodes,Files}|Ts],Spec) ->
+    Tests = lists:map(fun(N) -> {config,N,Files} end, list_nodes(Spec)),
+    add_tests(Tests++Ts,Spec);
+add_tests([{config,Nodes,Files}|Ts],Spec) when is_list(Nodes) ->
+    Ts1 = separate(Nodes,config,[Files],Ts,Spec#testspec.nodes),
+    add_tests(Ts1,Spec);
+add_tests([{config,Node,[F|Fs]}|Ts],Spec) when is_list(F) ->
+    Cfgs = Spec#testspec.config,
+    Node1 = ref2node(Node,Spec#testspec.nodes),
+    add_tests([{config,Node,Fs}|Ts],Spec#testspec{config=[{Node1,F}|Cfgs]});
+add_tests([{config,_Node,[]}|Ts],Spec) ->
+    add_tests(Ts,Spec);
+add_tests([{config,Node,F}|Ts],Spec) ->
+    add_tests([{config,Node,[F]}|Ts],Spec);
+add_tests([{config,Files}|Ts],Spec) ->
+    add_tests([{config,all_nodes,Files}|Ts],Spec);
+
+%% --- event_handler ---
+add_tests([{event_handler,all_nodes,Hs}|Ts],Spec) ->
+    Tests = lists:map(fun(N) -> {event_handler,N,Hs,[]} end, list_nodes(Spec)),
+    add_tests(Tests++Ts,Spec);
+add_tests([{event_handler,all_nodes,Hs,Args}|Ts],Spec) when is_list(Args) ->
+    Tests = lists:map(fun(N) -> {event_handler,N,Hs,Args} end, list_nodes(Spec)),
+    add_tests(Tests++Ts,Spec);
+add_tests([{event_handler,Hs}|Ts],Spec) ->
+    add_tests([{event_handler,all_nodes,Hs,[]}|Ts],Spec);
+add_tests([{event_handler,HsOrNodes,HsOrArgs}|Ts],Spec) ->
+    case is_noderef(HsOrNodes,Spec#testspec.nodes) of
+	true ->					% HsOrNodes == Nodes, HsOrArgs == Hs
+	    case {HsOrNodes,HsOrArgs} of
+		{Nodes,Hs} when is_list(Nodes) ->
+		    Ts1 = separate(Nodes,event_handler,[Hs,[]],Ts,
+				   Spec#testspec.nodes),
+		    add_tests(Ts1,Spec);
+		{_Node,[]} ->		    
+		    add_tests(Ts,Spec);
+		{Node,HOrHs} ->
+		    EvHs = Spec#testspec.event_handler,
+		    Node1 = ref2node(Node,Spec#testspec.nodes),
+		    case HOrHs of
+			[H|Hs] when is_atom(H) ->
+			    add_tests([{event_handler,Node,Hs}|Ts],
+				      Spec#testspec{event_handler=[{Node1,H,[]}|EvHs]});
+			H when is_atom(H) ->
+			    add_tests(Ts,Spec#testspec{event_handler=[{Node1,H,[]}|EvHs]})
+		    end
+	    end;
+	false ->				% HsOrNodes == Hs, HsOrArgs == Args
+	    add_tests([{event_handler,all_nodes,HsOrNodes,HsOrArgs}|Ts],Spec)
+    end;
+add_tests([{event_handler,Nodes,Hs,Args}|Ts],Spec) when is_list(Nodes) ->
+    Ts1 = separate(Nodes,event_handler,[Hs,Args],Ts,Spec#testspec.nodes),
+    add_tests(Ts1,Spec);
+add_tests([{event_handler,Node,[H|Hs],Args}|Ts],Spec) when is_atom(H) ->
+    EvHs = Spec#testspec.event_handler,
+    Node1 = ref2node(Node,Spec#testspec.nodes),
+    add_tests([{event_handler,Node,Hs,Args}|Ts],
+	      Spec#testspec{event_handler=[{Node1,H,Args}|EvHs]});
+add_tests([{event_handler,_Node,[],_Args}|Ts],Spec) ->
+    add_tests(Ts,Spec);
+add_tests([{event_handler,Node,H,Args}|Ts],Spec) when is_atom(H) ->
+    EvHs = Spec#testspec.event_handler,
+    Node1 = ref2node(Node,Spec#testspec.nodes),
+    add_tests(Ts,Spec#testspec{event_handler=[{Node1,H,Args}|EvHs]});
+
+%% --- include ---
+add_tests([{include,all_nodes,InclDirs}|Ts],Spec) ->
+    Tests = lists:map(fun(N) -> {include,N,InclDirs} end, list_nodes(Spec)),
+    add_tests(Tests++Ts,Spec);
+add_tests([{include,Nodes,InclDirs}|Ts],Spec) when is_list(Nodes) ->
+    Ts1 = separate(Nodes,include,[InclDirs],Ts,Spec#testspec.nodes),
+    add_tests(Ts1,Spec);
+add_tests([{include,Node,[D|Ds]}|Ts],Spec) when is_list(D) ->
+    Dirs = Spec#testspec.include,
+    Node1 = ref2node(Node,Spec#testspec.nodes),
+    add_tests([{include,Node,Ds}|Ts],Spec#testspec{include=[{Node1,D}|Dirs]});
+add_tests([{include,_Node,[]}|Ts],Spec) ->
+    add_tests(Ts,Spec);
+add_tests([{include,Node,D}|Ts],Spec) ->
+    add_tests([{include,Node,[D]}|Ts],Spec);
+add_tests([{include,InclDirs}|Ts],Spec) ->
+    add_tests([{include,all_nodes,InclDirs}|Ts],Spec);
+
+%% --- suites ---
+add_tests([{suites,all_nodes,Dir,Ss}|Ts],Spec) ->
+    add_tests([{suites,list_nodes(Spec),Dir,Ss}|Ts],Spec);
+add_tests([{suites,Dir,Ss}|Ts],Spec) ->
+    add_tests([{suites,all_nodes,Dir,Ss}|Ts],Spec);
+add_tests([{suites,Nodes,Dir,Ss}|Ts],Spec) when is_list(Nodes) ->
+    Ts1 = separate(Nodes,suites,[Dir,Ss],Ts,Spec#testspec.nodes),
+    add_tests(Ts1,Spec);
+add_tests([{suites,Node,Dir,Ss}|Ts],Spec) ->
+    Tests = Spec#testspec.tests,
+    Tests1 = insert_suites(ref2node(Node,Spec#testspec.nodes),
+			   ref2dir(Dir,Spec#testspec.alias),
+			   Ss,Tests),
+    add_tests(Ts,Spec#testspec{tests=Tests1});
+
+%% --- cases ---
+add_tests([{cases,all_nodes,Dir,Suite,Cs}|Ts],Spec) ->
+    add_tests([{cases,list_nodes(Spec),Dir,Suite,Cs}|Ts],Spec);
+add_tests([{cases,Dir,Suite,Cs}|Ts],Spec) ->
+    add_tests([{cases,all_nodes,Dir,Suite,Cs}|Ts],Spec);
+add_tests([{cases,Nodes,Dir,Suite,Cs}|Ts],Spec) when is_list(Nodes) ->
+    Ts1 = separate(Nodes,cases,[Dir,Suite,Cs],Ts,Spec#testspec.nodes),
+    add_tests(Ts1,Spec);
+add_tests([{cases,Node,Dir,Suite,Cs}|Ts],Spec) ->
+    Tests = Spec#testspec.tests,
+    Tests1 = insert_cases(ref2node(Node,Spec#testspec.nodes),
+			  ref2dir(Dir,Spec#testspec.alias),
+			  Suite,Cs,Tests),
+    add_tests(Ts,Spec#testspec{tests=Tests1});
+
+%% --- skip_suites ---
+add_tests([{skip_suites,all_nodes,Dir,Ss,Cmt}|Ts],Spec) ->
+    add_tests([{skip_suites,list_nodes(Spec),Dir,Ss,Cmt}|Ts],Spec);
+add_tests([{skip_suites,Dir,Ss,Cmt}|Ts],Spec) ->
+    add_tests([{skip_suites,all_nodes,Dir,Ss,Cmt}|Ts],Spec);
+add_tests([{skip_suites,Nodes,Dir,Ss,Cmt}|Ts],Spec) when is_list(Nodes) ->
+    Ts1 = separate(Nodes,skip_suites,[Dir,Ss,Cmt],Ts,Spec#testspec.nodes),
+    add_tests(Ts1,Spec);
+add_tests([{skip_suites,Node,Dir,Ss,Cmt}|Ts],Spec) ->
+    Tests = Spec#testspec.tests,
+    Tests1 = skip_suites(ref2node(Node,Spec#testspec.nodes),
+			 ref2dir(Dir,Spec#testspec.alias),
+			 Ss,Cmt,Tests),
+    add_tests(Ts,Spec#testspec{tests=Tests1});
+
+%% --- skip_cases ---
+add_tests([{skip_cases,all_nodes,Dir,Suite,Cs,Cmt}|Ts],Spec) ->
+    add_tests([{skip_cases,list_nodes(Spec),Dir,Suite,Cs,Cmt}|Ts],Spec);
+add_tests([{skip_cases,Dir,Suite,Cs,Cmt}|Ts],Spec) ->
+    add_tests([{skip_cases,all_nodes,Dir,Suite,Cs,Cmt}|Ts],Spec);
+add_tests([{skip_cases,Nodes,Dir,Suite,Cs,Cmt}|Ts],Spec) when is_list(Nodes) ->
+    Ts1 = separate(Nodes,skip_cases,[Dir,Suite,Cs,Cmt],Ts,Spec#testspec.nodes),
+    add_tests(Ts1,Spec);
+add_tests([{skip_cases,Node,Dir,Suite,Cs,Cmt}|Ts],Spec) ->
+    Tests = Spec#testspec.tests,
+    Tests1 = skip_cases(ref2node(Node,Spec#testspec.nodes),
+			ref2dir(Dir,Spec#testspec.alias),
+			Suite,Cs,Cmt,Tests),
+    add_tests(Ts,Spec#testspec{tests=Tests1});
+
+%% --- handled/errors ---
+add_tests([{alias,_,_}|Ts],Spec) ->		% handled
+    add_tests(Ts,Spec);
+
+add_tests([{node,_,_}|Ts],Spec) ->		% handled
+    add_tests(Ts,Spec);
+
+%% check if it's a CT term that has bad format or if the user seems to
+%% have added something of his/her own, which we'll let pass if relaxed
+%% mode is enabled.
+add_tests([Other|Ts],Spec) when is_tuple(Other) ->
+    [Name|_] = tuple_to_list(Other),
+    case lists:keymember(Name,1,valid_terms()) of
+	true ->					% halt
+	    throw({error,{bad_term_in_spec,Other}});
+	false ->				% ignore
+	    case get(relaxed) of
+		true ->
+		    %% warn if name resembles a CT term
+		    case resembles_ct_term(Name,size(Other)) of
+			true ->
+			    io:format("~nSuspicious term, please check:~n"
+				      "~p~n", [Other]);
+			false ->
+			    ok
+		    end,
+		    add_tests(Ts,Spec);
+		false ->
+		    throw({error,{undefined_term_in_spec,Other}})
+	    end
+    end;
+
+add_tests([Other|Ts],Spec) ->	
+    case get(relaxed) of
+	true ->		
+	    add_tests(Ts,Spec);
+	false ->
+	    throw({error,{undefined_term_in_spec,Other}})
+    end;
+
+add_tests([],Spec) ->				% done
+    Spec.
+
+separate(Nodes,Tag,Data,Tests,Refs) ->
+    Separated = separate(Nodes,Tag,Data,Refs),
+    Separated ++ Tests.
+separate([N|Ns],Tag,Data,Refs) ->
+    [list_to_tuple([Tag,ref2node(N,Refs)|Data])|separate(Ns,Tag,Data,Refs)];
+separate([],_,_,_) ->
+    [].
+    
+
+%% Representation:
+%% {{Node,Dir},[{Suite1,[case11,case12,...]},{Suite2,[case21,case22,...]},...]}
+%% {{Node,Dir},[{Suite1,{skip,Cmt}},{Suite2,[{case21,{skip,Cmt}},case22,...]},...]}
+
+insert_suites(Node,Dir,[S|Ss],Tests) ->
+    Tests1 = insert_cases(Node,Dir,S,all,Tests),
+    insert_suites(Node,Dir,Ss,Tests1);
+insert_suites(_Node,_Dir,[],Tests) ->
+    Tests;
+insert_suites(Node,Dir,S,Tests) ->
+    insert_suites(Node,Dir,[S],Tests).
+
+insert_cases(Node,Dir,Suite,Cases,Tests) when is_list(Cases) ->
+    case lists:keysearch({Node,Dir},1,Tests) of
+	{value,{{Node,Dir},[{all,_}]}} ->
+	    Tests;
+	{value,{{Node,Dir},Suites0}} ->
+	    Suites1 = insert_cases1(Suite,Cases,Suites0),
+	    insert_in_order({{Node,Dir},Suites1},Tests);
+	false ->
+	    insert_in_order({{Node,Dir},[{Suite,Cases}]},Tests)
+    end;
+insert_cases(Node,Dir,Suite,Case,Tests) when is_atom(Case) ->
+    insert_cases(Node,Dir,Suite,[Case],Tests).
+
+insert_cases1(_Suite,_Cases,all) ->
+    all;
+insert_cases1(Suite,Cases,Suites0) ->
+    case lists:keysearch(Suite,1,Suites0) of
+	{value,{Suite,all}} ->
+	    Suites0;
+	{value,{Suite,Cases0}} ->
+	    Cases1 = insert_in_order(Cases,Cases0),
+	    insert_in_order({Suite,Cases1},Suites0);
+	false ->
+	    insert_in_order({Suite,Cases},Suites0)
+    end.
+
+skip_suites(Node,Dir,[S|Ss],Cmt,Tests) ->
+    Tests1 = skip_cases(Node,Dir,S,all,Cmt,Tests),
+    skip_suites(Node,Dir,Ss,Cmt,Tests1);
+skip_suites(_Node,_Dir,[],_Cmt,Tests) ->
+    Tests;
+skip_suites(Node,Dir,S,Cmt,Tests) ->
+    skip_suites(Node,Dir,[S],Cmt,Tests).
+
+skip_cases(Node,Dir,Suite,Cases,Cmt,Tests) when is_list(Cases) ->
+    Suites =
+	case lists:keysearch({Node,Dir},1,Tests) of
+	    {value,{{Node,Dir},Suites0}} ->
+		Suites0;
+	    false ->
+		[]
+	end,
+    Suites1 = skip_cases1(Suite,Cases,Cmt,Suites),
+    insert_in_order({{Node,Dir},Suites1},Tests);
+skip_cases(Node,Dir,Suite,Case,Cmt,Tests) when is_atom(Case) ->
+    skip_cases(Node,Dir,Suite,[Case],Cmt,Tests).
+
+skip_cases1(Suite,Cases,Cmt,Suites0) ->
+    SkipCases = lists:map(fun(C) ->
+				  {C,{skip,Cmt}}
+			  end,Cases),
+    case lists:keysearch(Suite,1,Suites0) of
+	{value,{Suite,Cases0}} ->
+	    Cases1 = Cases0 ++ SkipCases,
+	    insert_in_order({Suite,Cases1},Suites0);
+	false ->
+	    insert_in_order({Suite,SkipCases},Suites0)
+    end.
+
+insert_in_order([E|Es],List) ->
+    List1 = insert_elem(E,List,[]),
+    insert_in_order(Es,List1);
+insert_in_order([],List) ->
+    List;
+insert_in_order(E,List) ->
+    insert_elem(E,List,[]).
+
+%% replace an existing entry (same key) or add last in list
+insert_elem({Key,_}=E,[{Key,_}|Rest],SoFar) ->
+    lists:reverse([E|SoFar]) ++ Rest;
+insert_elem({E,_},[E|Rest],SoFar) ->
+    lists:reverse([E|SoFar]) ++ Rest;
+insert_elem(E,[E|Rest],SoFar) ->
+    lists:reverse([E|SoFar]) ++ Rest;
+insert_elem(E,[E1|Rest],SoFar) ->
+    insert_elem(E,Rest,[E1|SoFar]);
+insert_elem(E,[],SoFar) ->
+    lists:reverse([E|SoFar]).
+
+ref2node(all_nodes,_Refs) ->
+    all_nodes;
+ref2node(master,_Refs) ->
+    master;
+ref2node(RefOrNode,Refs) ->
+    case string:chr(atom_to_list(RefOrNode),$@) of
+	0 ->					% a ref	    
+	    case lists:keysearch(RefOrNode,1,Refs) of
+		{value,{RefOrNode,Node}} ->
+		    Node;
+		false ->
+		    throw({error,{noderef_missing,RefOrNode}})
+	    end;
+	_ ->					% a node
+	    RefOrNode
+    end.
+
+ref2dir(Ref,Refs) when is_atom(Ref) ->
+    case lists:keysearch(Ref,1,Refs) of
+	{value,{Ref,Dir}} ->
+	    Dir;
+	false ->
+	    throw({error,{alias_missing,Ref}})
+    end;
+ref2dir(Dir,_) when is_list(Dir) ->
+    Dir.
+
+is_noderef(What,Nodes) when is_atom(What) ->
+    is_noderef([What],Nodes);
+is_noderef([master|_],_Nodes) ->
+    true;
+is_noderef([What|_],Nodes) ->
+    case lists:keymember(What,1,Nodes) or
+	 lists:keymember(What,2,Nodes) of
+	true ->					
+	    true;
+	false ->
+	    false
+    end;
+is_noderef([],_) ->
+    false.
+
+valid_terms() ->
+    [
+     {node,3},
+     {cover,2},
+     {cover,3},
+     {config,2},
+     {config,3},
+     {alias,3},
+     {logdir,2},
+     {logdir,3},
+     {event_handler,2},
+     {event_handler,3},
+     {event_handler,4},
+     {include,2},
+     {include,3},
+
+     {suites,3},
+     {suites,4},
+     {cases,4},
+     {cases,5},
+     {skip_suites,4},
+     {skip_suites,5},
+     {skip_cases,5},
+     {skip_cases,6}
+    ].
+
+%% this function "guesses" if the user has misspelled a term name
+resembles_ct_term(Name,Size) when is_atom(Name) ->
+    resembles_ct_term2(atom_to_list(Name),Size);
+resembles_ct_term(_Name,_) ->
+    false.
+	
+resembles_ct_term2(Name,Size) when length(Name) > 3 ->
+    CTTerms = [{atom_to_list(Tag),Sz} || {Tag,Sz} <- valid_terms()],
+    compare_names(Name,Size,CTTerms);
+resembles_ct_term2(_,_) ->
+    false.
+
+compare_names(Name,Size,[{Term,Sz}|Ts]) ->
+    if abs(Size-Sz) > 0 ->
+	    compare_names(Name,Size,Ts);
+       true ->
+	    Diff = abs(length(Name)-length(Term)),
+	    if Diff > 1 ->
+		    compare_names(Name,Size,Ts);
+	       true ->
+		    Common = common_letters(Name,Term,0),
+		    Bad = abs(length(Name)-Common),
+		    if Bad > 2 ->
+			    compare_names(Name,Size,Ts);
+		       true ->
+			    true
+		    end
+	    end
+    end;
+compare_names(_,_,[]) ->
+    false.
+
+common_letters(_,[],Count) -> 
+    Count;
+common_letters([L|Ls],Term,Count) ->
+    case lists:member(L,Term) of
+	true ->
+	    Term1 = lists:delete(L,Term),
+	    common_letters(Ls,Term1,Count+1);
+	false ->
+	    common_letters(Ls,Term,Count)
+    end;
+common_letters([],_,Count) -> 
+    Count.
+
+
+    
+	
diff --git a/lib/common_test/src/ct_util.erl b/lib/common_test/src/ct_util.erl
new file mode 100644
index 0000000000..ba3d789f8d
--- /dev/null
+++ b/lib/common_test/src/ct_util.erl
@@ -0,0 +1,1303 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 2003-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%
+%%
+
+%%% @doc Common Test Framework Utilities.
+%%%
+%%% <p>This is a support module for the Common Test Framework. It
+%%% implements the process ct_util_server which acts like a data
+%%% holder for suite, configuration and connection data.</p>
+%%%
+-module(ct_util).
+
+-export([start/0,start/1,start/2,stop/1,update_last_run_index/0]).
+
+-export([register_connection/4,unregister_connection/1,
+	 does_connection_exist/3,get_key_from_name/1]).
+
+-export([require/1, require/2, get_config/1, get_config/2, get_config/3,	 
+	 set_default_config/2, set_default_config/3, delete_default_config/1,
+	 get_all_config/0, update_config/2, 
+	 release_allocated/0, close_connections/0]).
+
+-export([save_suite_data/3, save_suite_data/2, read_suite_data/1, 
+	 delete_suite_data/0, delete_suite_data/1, match_delete_suite_data/1,
+	 delete_testdata/0, delete_testdata/1, set_testdata/1, get_testdata/1,
+	 update_testdata/2]).
+
+-export([override_silence_all_connections/0, override_silence_connections/1, 
+	 get_overridden_silenced_connections/0, 
+	 delete_overridden_silenced_connections/0, 
+	 silence_all_connections/0, silence_connections/1, is_silenced/1, 
+	 reset_silent_connections/0]).
+
+-export([set_cwd/1, reset_cwd/0]).
+
+-export([parse_table/1]).
+
+-export([listenv/1]).
+
+-export([get_target_name/1, get_connections/2]).
+
+-export([is_test_dir/1, get_testdir/2]).
+
+-export([encrypt_config_file/2, encrypt_config_file/3,
+	 decrypt_config_file/2, decrypt_config_file/3]).
+
+-export([kill_attached/2, get_attached/1]).
+
+-export([warn_duplicates/1]).
+
+-include("ct_event.hrl").
+-include("ct_util.hrl").
+
+-record(ct_conf,{key,value,ref,name='_UNDEF',default=false}).  
+%% default = {true,suite} | {true,testcase} | false
+
+-record(suite_data, {key,name,value}).
+
+-define(cryptfile, ".ct_config.crypt").
+
+%%%-----------------------------------------------------------------
+%%% @spec start(Mode) -> Pid | exit(Error)
+%%%       Mode = normal | interactive
+%%%       Pid = pid()
+%%%
+%%% @doc Start start the ct_util_server process 
+%%% (tool-internal use only).
+%%%
+%%% <p>This function is called from ct_run.erl. It starts and initiates
+%%% the <code>ct_util_server</code></p>
+%%% 
+%%% <p>Returns the process identity of the
+%%% <code>ct_util_server</code>.</p>
+%%%
+%%% @see ct
+start() ->
+    start(normal,".").
+
+start(LogDir) when is_list(LogDir) ->
+    start(normal,LogDir);
+start(Mode) ->
+    start(Mode,".").
+
+start(Mode,LogDir) ->
+    case whereis(ct_util_server) of
+	undefined ->
+	    S = self(),
+	    Pid = spawn_link(fun() -> do_start(S,Mode,LogDir) end),
+	    receive 
+		{Pid,started} -> Pid;
+		{Pid,Error} -> exit(Error)
+	    end;
+	Pid ->
+	    case get_mode() of
+		interactive when Mode==interactive ->
+		    Pid;
+		interactive ->
+		    {error,interactive_mode};
+		_OtherMode ->
+		    Pid
+	    end
+    end.
+
+do_start(Parent,Mode,LogDir) ->
+    process_flag(trap_exit,true),
+    register(ct_util_server,self()),
+    create_table(?attr_table,bag,#ct_conf.key),
+    create_table(?conn_table,#conn.handle),
+    create_table(?board_table,2),
+    create_table(?suite_table,#suite_data.key),
+    {ok,StartDir} = file:get_cwd(),
+    case file:set_cwd(LogDir) of
+	ok -> ok;
+	E -> exit(E)
+    end,
+    Opts = case read_opts() of
+	       {ok,Opts1} ->
+		   Opts1;
+	       Error ->
+		   Parent ! {self(),Error},
+		   exit(Error)
+	   end,
+
+    %% start an event manager (if not already started by master)
+    case ct_event:start_link() of
+	{error,{already_started,_}} ->
+	    ok;
+	_ ->
+	    case whereis(vts) of
+		undefined ->
+		    ct_event:add_handler();
+		VtsPid ->
+		    ct_event:add_handler([{vts,VtsPid}])
+	    end
+    end,
+    case read_config_files(Opts) of
+	ok ->
+	    %% add user handlers
+	    case lists:keysearch(event_handler,1,Opts) of
+		{value,{_,Handlers}} ->
+		    Add = fun({H,Args}) ->
+				  case catch gen_event:add_handler(?CT_EVMGR_REF,H,Args) of
+				      ok -> ok;
+				      {'EXIT',Why} -> exit(Why);
+				      Other -> exit({event_handler,Other})
+				  end
+			  end,
+		    case catch lists:foreach(Add,Handlers) of
+			{'EXIT',Reason} ->
+			    Parent ! {self(),Reason};
+			_ ->
+			    ok
+		    end;
+		false ->
+		    ok
+	    end,
+	    {StartTime,TestLogDir} = ct_logs:init(Mode),
+	    ct_event:notify(#event{name=test_start,
+				   node=node(),
+				   data={StartTime,
+					 lists:flatten(TestLogDir)}}),
+	    Parent ! {self(),started},
+	    loop(Mode,[],StartDir);
+	ReadError ->
+	    Parent ! {self(),ReadError},
+	    exit(ReadError)
+    end.
+
+create_table(TableName,KeyPos) ->
+    create_table(TableName,set,KeyPos).
+create_table(TableName,Type,KeyPos) ->
+    catch ets:delete(TableName),
+    ets:new(TableName,[Type,named_table,public,{keypos,KeyPos}]).
+
+read_opts() ->
+    case file:consult(ct_run:variables_file_name("./")) of
+	{ok,Opts} ->
+	    {ok,Opts};
+	{error,enoent} ->
+	    {error,not_installed};
+	Error ->
+	    {error,{bad_installation,Error}}
+    end.
+
+read_config_files(Opts) ->
+    ConfigFiles =
+	lists:foldl(fun({config,Files},Acc) ->
+			    Acc ++ Files;
+		       (_,Acc) ->
+			    Acc
+		    end,[],Opts),
+    read_config_files1(ConfigFiles).
+
+read_config_files1([ConfigFile|Files]) ->
+    case file:consult(ConfigFile) of
+	{ok,Config} -> 
+	    set_config(Config),
+	    read_config_files1(Files);
+	{error,enoent} ->
+	    {user_error,{config_file_error,ConfigFile,enoent}};
+	{error,Reason} ->
+	    Key =
+		case application:get_env(common_test, decrypt) of
+		    {ok,KeyOrFile} ->
+			case KeyOrFile of
+			    {key,K} ->
+				K;
+			    {file,F} ->
+				get_crypt_key_from_file(F)
+			end;
+		    _ ->
+			get_crypt_key_from_file()
+		end,
+	    case Key of
+		{error,no_crypt_file} ->
+		    {user_error,{config_file_error,ConfigFile,Reason}};
+		{error,CryptError} ->
+		    {user_error,{decrypt_file_error,ConfigFile,CryptError}};
+		_ when is_list(Key) ->
+		    case decrypt_config_file(ConfigFile, undefined, {key,Key}) of
+			{ok,CfgBin} ->
+			    case read_config_terms(CfgBin) of
+				{error,ReadFail} ->
+				    {user_error,{config_file_error,ConfigFile,ReadFail}};
+				Config ->
+				    set_config(Config),
+				    read_config_files1(Files)
+			    end;
+			{error,DecryptFail} ->
+			    {user_error,{decrypt_config_error,ConfigFile,DecryptFail}}
+		    end;
+		_ ->
+		    {user_error,{bad_decrypt_key,ConfigFile,Key}}
+	    end
+    end;
+read_config_files1([]) ->
+    ok.
+
+read_config_terms(Bin) when is_binary(Bin) ->
+    case catch binary_to_list(Bin) of
+	{'EXIT',_} ->
+	    {error,invalid_textfile};
+	Lines ->
+	    read_config_terms(Lines)
+    end;
+read_config_terms(Lines) when is_list(Lines) ->
+    read_config_terms1(erl_scan:tokens([], Lines, 0), 1, [], []).
+
+read_config_terms1({done,{ok,Ts,EL},Rest}, L, Terms, _) ->
+    case erl_parse:parse_term(Ts) of
+	{ok,Term} when Rest == [] ->
+	    lists:reverse([Term|Terms]);
+	{ok,Term} ->
+	    read_config_terms1(erl_scan:tokens([], Rest, 0), 
+			       EL+1, [Term|Terms], Rest);
+	_ ->
+	    {error,{bad_term,{L,EL}}}
+    end;
+read_config_terms1({done,{eof,_},_}, _, Terms, Rest) when Rest == [] ->
+    lists:reverse(Terms);
+read_config_terms1({done,{eof,EL},_}, L, _, _) ->
+    {error,{bad_term,{L,EL}}};
+read_config_terms1({done,{error,Info,EL},_}, L, _, _) ->
+    {error,{Info,{L,EL}}};
+read_config_terms1({more,_}, L, Terms, Rest) ->
+    case string:tokens(Rest, [$\n,$\r,$\t]) of
+	[] ->
+	    lists:reverse(Terms);
+	_ ->
+	    {error,{bad_term,L}}
+    end.
+
+set_default_config(NewConfig, Scope) ->
+    call({set_default_config, {NewConfig, Scope}}).
+
+set_default_config(Name, NewConfig, Scope) ->
+    call({set_default_config, {Name, NewConfig, Scope}}).
+
+delete_default_config(Scope) ->
+    call({delete_default_config, Scope}).
+
+update_config(Name, Config) ->
+    call({update_config, {Name, Config}}).
+
+save_suite_data(Key, Value) ->
+    call({save_suite_data, {Key, undefined, Value}}).
+
+save_suite_data(Key, Name, Value) ->
+    call({save_suite_data, {Key, Name, Value}}).
+
+read_suite_data(Key) ->
+    call({read_suite_data, Key}).
+
+delete_suite_data() ->
+    call({delete_suite_data, all}).
+
+delete_suite_data(Key) ->
+    call({delete_suite_data, Key}).
+
+match_delete_suite_data(KeyPat) ->
+    call({match_delete_suite_data, KeyPat}).
+
+delete_testdata() ->
+    call(delete_testdata).
+
+delete_testdata(Key) ->
+    call({delete_testdata, Key}).
+
+update_testdata(Key, Fun) ->
+    call({update_testdata, Key, Fun}).
+
+set_testdata(TestData) ->
+    call({set_testdata, TestData}).
+
+get_testdata(Key) ->
+    call({get_testdata, Key}).
+
+set_cwd(Dir) ->
+    call({set_cwd,Dir}).
+
+reset_cwd() ->
+    call(reset_cwd).
+
+loop(Mode,TestData,StartDir) ->
+    receive 
+	{update_last_run_index,From} ->
+	    ct_logs:make_last_run_index(),
+	    return(From,ok),
+	    loop(Mode,TestData,StartDir);
+	{{require,Name,Tag,SubTags},From} ->
+	    Result = do_require(Name,Tag,SubTags),
+	    return(From,Result),
+	    loop(Mode,TestData,StartDir);
+	{{set_default_config,{Config,Scope}},From} ->
+	    set_config(Config,{true,Scope}),
+	    return(From,ok),
+	    loop(Mode,TestData,StartDir);
+	{{set_default_config,{Name,Config,Scope}},From} ->
+	    set_config(Name,Config,{true,Scope}),
+	    return(From,ok),
+	    loop(Mode,TestData,StartDir);
+	{{delete_default_config,Scope},From} ->
+	    delete_config({true,Scope}),
+	    return(From,ok),
+	    loop(Mode,TestData,StartDir);
+	{{update_config,{Name,NewConfig}},From} ->
+	    update_conf(Name,NewConfig),
+	    return(From,ok),
+	    loop(Mode,TestData,StartDir);
+	{{save_suite_data,{Key,Name,Value}},From} ->
+	    ets:insert(?suite_table, #suite_data{key=Key,
+						 name=Name,
+						 value=Value}),
+	    return(From,ok),
+	    loop(Mode,TestData,StartDir);
+	{{read_suite_data,Key},From} ->
+	    case ets:lookup(?suite_table, Key) of
+		[#suite_data{key=Key,name=undefined,value=Value}] ->
+		    return(From,Value);
+		[#suite_data{key=Key,name=Name,value=Value}] ->
+		    return(From,{Name,Value});
+		_ ->
+		    return(From,undefined)
+	    end,
+	    loop(Mode,TestData,StartDir);
+	{{delete_suite_data,Key},From} ->
+	    if Key == all ->
+		    ets:delete_all_objects(?suite_table);
+	       true ->
+		    ets:delete(?suite_table, Key)
+	    end,
+	    return(From,ok),
+	    loop(Mode,TestData,StartDir);
+	{{match_delete_suite_data,KeyPat},From} ->
+	    ets:match_delete(?suite_table, #suite_data{key=KeyPat,
+						       name='_',
+						       value='_'}),
+	    return(From,ok),
+	    loop(Mode,TestData,StartDir);
+	{delete_testdata,From} ->
+	    return(From,ok),
+	    loop(From,[],StartDir);	
+	{{delete_testdata,Key},From} ->
+	    TestData1 = lists:keydelete(Key,1,TestData),
+	    return(From,ok),
+	    loop(From,TestData1,StartDir);	
+	{{set_testdata,New = {Key,_Val}},From} ->
+	    TestData1 = lists:keydelete(Key,1,TestData),
+	    return(From,ok),
+	    loop(Mode,[New|TestData1],StartDir);
+	{{get_testdata,Key},From} ->
+	    case lists:keysearch(Key,1,TestData) of
+		{value,{Key,Val}} ->
+		    return(From,Val);
+		_ ->
+		    return(From,undefined)
+	    end,
+	    loop(From,TestData,StartDir);
+	{{update_testdata,Key,Fun},From} ->
+	    TestData1 =
+		case lists:keysearch(Key,1,TestData) of
+		    {value,{Key,Val}} ->
+			NewVal = Fun(Val),
+			return(From,NewVal),
+			[{Key,NewVal}|lists:keydelete(Key,1,TestData)];
+		    _ ->
+			return(From,undefined),
+			TestData
+		end,
+	    loop(From,TestData1,StartDir);	    
+	{{set_cwd,Dir},From} ->
+	    return(From,file:set_cwd(Dir)),
+	    loop(From,TestData,StartDir);
+	{reset_cwd,From} ->
+	    return(From,file:set_cwd(StartDir)),
+	    loop(From,TestData,StartDir);
+	{{stop,How},From} ->
+	    Time = calendar:local_time(),
+	    ct_event:sync_notify(#event{name=test_done,
+					node=node(),
+					data=Time}),
+	    ets:delete(?attr_table),
+	    close_connections(ets:tab2list(?conn_table)),
+	    ets:delete(?conn_table),
+	    ets:delete(?board_table),
+	    ets:delete(?suite_table),
+	    ct_logs:close(How),
+	    file:set_cwd(StartDir),
+	    ct_event:stop(),
+	    return(From,ok);
+	{get_mode,From} ->
+	    return(From,Mode),
+	    loop(Mode,TestData,StartDir);
+	{'EXIT',_Pid,normal} ->
+	    loop(Mode,TestData,StartDir);
+	{'EXIT',Pid,Reason} ->
+	    %% Let process crash in case of error, this shouldn't happen!
+	    io:format("\n\nct_util_server got EXIT from ~p: ~p\n\n",
+		      [Pid,Reason]),
+	    file:set_cwd(StartDir),
+	    exit(Reason)
+    end.
+
+
+close_connections([#conn{handle=Handle,callback=CB}|Conns]) ->
+    CB:close(Handle),
+    close_connections(Conns);
+close_connections([]) ->
+    ok.
+
+
+%%%-----------------------------------------------------------------
+%%% @spec register_connection(TargetName,Address,Callback,Handle) -> 
+%%%                                              ok | {error,Reason}
+%%%      TargetName = ct:target_name()
+%%%      Address = term()
+%%%      Callback = atom()
+%%%      Handle = term
+%%%
+%%% @doc Register a new connection (tool-internal use only).
+%%%
+%%% <p>This function can be called when a new connection is
+%%% established. The connection data is stored in the connection
+%%% table, and ct_util will close all registered connections when the
+%%% test is finished by calling <code>Callback:close/1</code>.</p>
+register_connection(TargetName,Address,Callback,Handle) ->
+    TargetRef = 
+	case get_ref_from_name(TargetName) of
+	    {ok,Ref} ->
+		Ref;
+	    _ ->
+		%% no config name associated with connection,
+		%% use handle for identification instead
+		Handle
+	end,
+    ets:insert(?conn_table,#conn{handle=Handle,
+				 targetref=TargetRef,
+				 address=Address,
+				 callback=Callback}),
+    ok.
+
+%%%-----------------------------------------------------------------
+%%% @spec unregister_connection(Handle) -> ok
+%%%      Handle = term
+%%%
+%%% @doc Unregister a connection (tool-internal use only).
+%%%
+%%% <p>This function should be called when a registered connection is
+%%% closed. It removes the connection data from the connection
+%%% table.</p>
+unregister_connection(Handle) ->
+    ets:delete(?conn_table,Handle),
+    ok.
+
+
+%%%-----------------------------------------------------------------
+%%% @spec does_connection_exist(TargetName,Address,Callback) -> 
+%%%                                              {ok,Handle} | false
+%%%      TargetName = ct:target_name()
+%%%      Address = address
+%%%      Callback = atom()
+%%%      Handle = term()
+%%%
+%%% @doc Check if a connection already exists.
+does_connection_exist(TargetName,Address,Callback) ->
+    case get_ref_from_name(TargetName) of
+	{ok,TargetRef} ->
+	    case ets:select(?conn_table,[{#conn{handle='$1',
+						targetref=TargetRef,
+						address=Address,
+						callback=Callback},
+					  [],
+					  ['$1']}]) of
+		[Handle] ->
+		    {ok,Handle};
+		[] ->
+		    false
+	    end;
+	_ ->
+	    false
+    end.
+
+%%%-----------------------------------------------------------------
+%%% @spec get_connections(TargetName,Callback) -> 
+%%%                                {ok,Connections} | {error,Reason}
+%%%      TargetName = ct:target_name()
+%%%      Callback = atom()
+%%%      Connections = [Connection]
+%%%      Connection = {Handle,Address}
+%%%      Handle = term()
+%%%      Address = term()
+%%%
+%%% @doc Return all connections for the <code>Callback</code> on the
+%%% given target (<code>TargetName</code>).
+get_connections(TargetName,Callback) ->
+    case get_ref_from_name(TargetName) of
+	{ok,Ref} ->
+	    {ok,ets:select(?conn_table,[{#conn{handle='$1',
+					       address='$2',
+					       targetref=Ref,
+					       callback=Callback},
+					 [],
+					 [{{'$1','$2'}}]}])};
+	Error ->
+	    Error
+    end.
+
+%%%-----------------------------------------------------------------
+%%% @hidden
+%%% @equiv ct:get_target_name/1
+get_target_name(ConnPid) ->
+    case ets:select(?conn_table,[{#conn{handle=ConnPid,targetref='$1',_='_'},
+				  [],
+				  ['$1']}]) of
+	[TargetRef] ->
+	    get_name_from_ref(TargetRef);
+	[] ->
+	    {error,{unknown_connection,ConnPid}}
+    end.
+
+
+%%%-----------------------------------------------------------------
+%%% @hidden
+%%% @equiv ct:require/1
+require(Key) when is_atom(Key) ->
+    require({Key,[]});
+require({Key,SubKeys}) when is_atom(Key) ->
+    allocate('_UNDEF',Key,to_list(SubKeys));
+require(Key) ->
+    {error,{invalid,Key}}.
+
+
+%%%-----------------------------------------------------------------
+%%% @hidden
+%%% @equiv ct:require/2
+require(Name,Key) when is_atom(Key) ->
+    require(Name,{Key,[]});
+require(Name,{Key,SubKeys}) when is_atom(Name), is_atom(Key) ->
+    call({require,Name,Key,to_list(SubKeys)});
+require(Name,Keys) ->
+    {error,{invalid,{Name,Keys}}}.
+
+to_list(X) when is_list(X) -> X;
+to_list(X) -> [X].
+
+do_require(Name,Key,SubKeys) when is_list(SubKeys) ->
+    case get_key_from_name(Name) of
+	{error,_} ->
+	    allocate(Name,Key,SubKeys);		    
+	{ok,Key} ->
+	    %% already allocated - check that it has all required subkeys
+	    Vals = [Val || {_Ref,Val} <- lookup_name(Name)],
+	    case get_subconfig(SubKeys,Vals) of
+		{ok,_SubMapped} ->
+		    ok;
+		Error ->
+		    Error
+	    end;
+	{ok,OtherKey} ->
+	    {error,{name_in_use,Name,OtherKey}}
+    end.
+
+allocate(Name,Key,SubKeys) ->
+    case ets:match_object(?attr_table,#ct_conf{key=Key,name='_UNDEF',_='_'}) of
+	[] ->
+	    {error,{not_available,Key}};
+	Available ->
+	    case allocate_subconfig(Name,SubKeys,Available,false) of
+		ok ->
+		    ok;
+		Error ->
+		    Error
+	    end
+    end.
+
+allocate_subconfig(Name,SubKeys,[C=#ct_conf{value=Value}|Rest],Found) ->
+    case do_get_config(SubKeys,Value,[]) of
+	{ok,_SubMapped} ->
+	    ets:insert(?attr_table,C#ct_conf{name=Name}),
+	    allocate_subconfig(Name,SubKeys,Rest,true);
+	_Error ->
+	    allocate_subconfig(Name,SubKeys,Rest,Found)
+    end;
+allocate_subconfig(_Name,_SubKeys,[],true) ->
+    ok;
+allocate_subconfig(_Name,SubKeys,[],false) ->
+    {error,{not_available,SubKeys}}.
+
+
+
+
+%%%-----------------------------------------------------------------
+%%% @hidden
+%%% @equiv ct:get_config/1
+get_config(KeyOrName) ->
+    get_config(KeyOrName,undefined,[]).
+
+%%%-----------------------------------------------------------------
+%%% @hidden
+%%% @equiv ct:get_config/2
+get_config(KeyOrName,Default) ->
+    get_config(KeyOrName,Default,[]).
+
+%%%-----------------------------------------------------------------
+%%% @hidden
+%%% @equiv ct:get_config/3
+get_config(KeyOrName,Default,Opts) when is_atom(KeyOrName) ->
+    case lookup_config(KeyOrName) of
+	[] ->
+	    Default;
+	[{_Ref,Val}|_] = Vals ->
+	    case {lists:member(all,Opts),lists:member(element,Opts)} of
+		{true,true} ->
+		    [{KeyOrName,V} || {_R,V} <- lists:sort(Vals)];
+		{true,false} ->
+		    [V || {_R,V} <- lists:sort(Vals)];
+		{false,true} ->
+		    {KeyOrName,Val};
+		{false,false} ->
+		    Val
+	    end
+    end;
+		
+get_config({KeyOrName,SubKey},Default,Opts) ->
+    case lookup_config(KeyOrName) of
+	[] ->
+	    Default;
+	Vals ->
+	    Vals1 = case [Val || {_Ref,Val} <- lists:sort(Vals)] of
+			Result=[L|_] when is_list(L) ->
+			    case L of
+				[{_,_}|_] ->
+				    Result;
+				_ ->
+				    []
+			    end;
+			_ ->
+			    []
+		    end,				    
+	    case get_subconfig([SubKey],Vals1,[],Opts) of
+		{ok,[{_,SubVal}|_]=SubVals} ->
+		    case {lists:member(all,Opts),lists:member(element,Opts)} of
+			{true,true} ->
+			    [{{KeyOrName,SubKey},Val} || {_,Val} <- SubVals];
+			{true,false} ->
+			    [Val || {_SubKey,Val} <- SubVals];
+			{false,true} ->
+			    {{KeyOrName,SubKey},SubVal};
+			{false,false} ->
+			    SubVal
+		    end;
+		_ ->
+		    Default
+	    end
+    end.
+		    
+
+get_subconfig(SubKeys,Values) ->
+    get_subconfig(SubKeys,Values,[],[]).
+
+get_subconfig(SubKeys,[Value|Rest],Mapped,Opts) ->
+    case do_get_config(SubKeys,Value,[]) of
+	{ok,SubMapped} ->
+	    case lists:member(all,Opts) of
+		true ->
+		    get_subconfig(SubKeys,Rest,Mapped++SubMapped,Opts);
+		false ->
+		    {ok,SubMapped}
+	    end;
+	_Error ->
+	    get_subconfig(SubKeys,Rest,Mapped,Opts)
+    end;
+get_subconfig(SubKeys,[],[],_) ->
+    {error,{not_available,SubKeys}};
+get_subconfig(_SubKeys,[],Mapped,_) ->
+    {ok,Mapped}.
+
+do_get_config([Key|Required],Available,Mapped) ->
+    case lists:keysearch(Key,1,Available) of
+	{value,{Key,Value}} ->
+	    NewAvailable = lists:keydelete(Key,1,Available),
+	    NewMapped = [{Key,Value}|Mapped],
+	    do_get_config(Required,NewAvailable,NewMapped);
+	false ->
+	    {error,{not_available,Key}}
+    end;
+do_get_config([],_Available,Mapped) ->
+    {ok,lists:reverse(Mapped)}.
+
+get_all_config() ->
+    ets:select(?attr_table,[{#ct_conf{name='$1',key='$2',value='$3',
+				      default='$4',_='_'},
+			     [],
+			     [{{'$1','$2','$3','$4'}}]}]).
+
+lookup_config(KeyOrName) ->
+    case lookup_name(KeyOrName) of
+	[] ->
+	    lookup_key(KeyOrName);
+	Values ->
+	    Values
+    end.
+
+lookup_name(Name) ->
+    ets:select(?attr_table,[{#ct_conf{ref='$1',value='$2',name=Name,_='_'},
+			     [],
+			     [{{'$1','$2'}}]}]).
+lookup_key(Key) ->
+    ets:select(?attr_table,[{#ct_conf{key=Key,ref='$1',value='$2',name='_UNDEF',_='_'},
+			     [],
+			     [{{'$1','$2'}}]}]).
+
+set_config(Config) ->
+    set_config('_UNDEF',Config,false).
+
+set_config(Config,Default) ->
+    set_config('_UNDEF',Config,Default).
+
+set_config(Name,Config,Default) ->
+    [ets:insert(?attr_table,
+		#ct_conf{key=Key,value=Val,ref=ct_make_ref(),
+			 name=Name,default=Default}) ||
+	{Key,Val} <- Config].
+
+delete_config(Default) ->
+    ets:match_delete(?attr_table,#ct_conf{default=Default,_='_'}),
+    ok.
+
+
+%%%-----------------------------------------------------------------
+%%% @spec release_allocated() -> ok
+%%%
+%%% @doc Release all allocated resources, but don't take down any
+%%% connections.
+release_allocated() ->
+    Allocated = ets:select(?attr_table,[{#ct_conf{name='$1',_='_'},
+					 [{'=/=','$1','_UNDEF'}],
+					 ['$_']}]),
+    release_allocated(Allocated).
+release_allocated([H|T]) ->
+    ets:delete_object(?attr_table,H),
+    ets:insert(?attr_table,H#ct_conf{name='_UNDEF'}),
+    release_allocated(T);
+release_allocated([]) ->
+    ok.
+
+%%%-----------------------------------------------------------------
+%%% @spec 
+%%%
+%%% @doc 
+update_conf(Name, NewConfig) ->
+    Old = ets:select(?attr_table,[{#ct_conf{name=Name,_='_'},[],['$_']}]),
+    lists:foreach(fun(OldElem) ->
+			  NewElem = OldElem#ct_conf{value=NewConfig},
+			  ets:delete_object(?attr_table, OldElem),
+			  ets:insert(?attr_table, NewElem)
+		  end, Old),
+    ok.
+				       
+%%%-----------------------------------------------------------------
+%%% @spec close_connections() -> ok
+%%%
+%%% @doc Close all open connections.
+close_connections() ->
+    close_connections(ets:tab2list(?conn_table)),
+    ok.
+
+%%%-----------------------------------------------------------------
+%%% @spec 
+%%%
+%%% @doc 
+override_silence_all_connections() ->
+    Protocols = [telnet,ftp,rpc,snmp],
+    override_silence_connections(Protocols),
+    Protocols.
+
+override_silence_connections(Conns) when is_list(Conns) ->
+    Conns1 = lists:map(fun({C,B}) -> {C,B};
+			  (C)     -> {C,true}
+		       end, Conns),
+    set_testdata({override_silent_connections,Conns1}).
+
+get_overridden_silenced_connections() ->
+    case get_testdata(override_silent_connections) of
+	{error,_} ->
+	    undefined;
+	Conns ->      % list() or undefined
+	    Conns
+    end.
+
+delete_overridden_silenced_connections() ->    
+    delete_testdata(override_silent_connections).
+
+silence_all_connections() ->
+    Protocols = [telnet,ftp,rpc,snmp],
+    silence_connections(Protocols),
+    Protocols.
+
+silence_connections(Conn) when is_tuple(Conn) ->
+    silence_connections([Conn]);
+silence_connections(Conn) when is_atom(Conn) ->
+    silence_connections([{Conn,true}]);
+silence_connections(Conns) when is_list(Conns) ->
+    Conns1 = lists:map(fun({C,B}) -> {C,B};
+			  (C)     -> {C,true}
+		       end, Conns),
+    set_testdata({silent_connections,Conns1}).
+
+is_silenced(Conn) ->
+    case get_testdata(silent_connections) of
+	Conns when is_list(Conns) ->
+	    case lists:keysearch(Conn,1,Conns) of
+		{value,{Conn,true}} ->
+		    true;
+		_ ->
+		    false
+	    end;
+	_ ->
+	    false
+    end.
+    
+reset_silent_connections() ->
+    delete_testdata(silent_connections).
+    
+
+%%%-----------------------------------------------------------------
+%%% @spec stop(How) -> ok
+%%%
+%%% @doc Stop the ct_util_server and close all existing connections
+%%% (tool-internal use only).
+%%%
+%%% @see ct
+stop(How) ->
+    case whereis(ct_util_server) of
+	undefined -> ok;
+	_ -> call({stop,How})
+    end.
+
+%%%-----------------------------------------------------------------
+%%% @spec update_last_run_index() -> ok
+%%%
+%%% @doc Update <code>ct_run.&lt;timestamp&gt;/index.html</code> 
+%%% (tool-internal use only).
+update_last_run_index() ->
+    call(update_last_run_index).
+
+
+%%%-----------------------------------------------------------------
+%%% @spec get_mode() -> Mode
+%%%   Mode = normal | interactive
+%%%
+%%% @doc Return the current mode of the ct_util_server
+%%% (tool-internal use only).
+get_mode() ->
+    call(get_mode).
+
+%%%-----------------------------------------------------------------
+%%% @hidden
+%%% @equiv ct:listenv/1
+listenv(Telnet) ->
+    case ct_telnet:send(Telnet,"listenv") of
+	ok ->
+	    {ok,Data,_} = ct_telnet:expect(Telnet,
+					   ["(^.+)=(.*$)"],
+					   [{timeout,seconds(3)},
+					    repeat]),
+	    {ok,[{Name,Val} || [_,Name,Val] <- Data]};
+	{error,Reason} ->
+	    {error,{could_not_send_command,Telnet,"listenv",Reason}}
+    end.
+
+%%%-----------------------------------------------------------------
+%%% @hidden
+%%% @equiv ct:parse_table/1
+parse_table(Data) ->
+    [Heading|Lines]=
+	[remove_space(string:tokens(L, "|"),[]) || L <- Data, hd(L)==$|],
+    {Heading,Lines}.
+
+remove_space([Str|Rest],Acc) ->
+    remove_space(Rest,[string:strip(string:strip(Str),both,$')|Acc]);
+remove_space([],Acc) ->
+    list_to_tuple(lists:reverse(Acc)).
+
+
+%%%-----------------------------------------------------------------
+%%% @spec 
+%%%
+%%% @doc
+is_test_dir(Dir) ->
+    lists:last(string:tokens(filename:basename(Dir), "_")) == "test".
+
+%%%-----------------------------------------------------------------
+%%% @spec 
+%%%
+%%% @doc
+get_testdir(Dir, all) ->
+    Abs = abs_name(Dir),
+    case is_test_dir(Abs) of
+	true ->
+	    Abs;
+	false ->
+	    AbsTest = filename:join(Abs, "test"),
+	    case filelib:is_dir(AbsTest) of
+		true -> AbsTest;
+		false -> Abs
+	    end		    
+    end;
+
+get_testdir(Dir, [Suite | _]) when is_atom(Suite) ->
+    get_testdir(Dir, atom_to_list(Suite));
+
+get_testdir(Dir, [Suite | _]) when is_list(Suite) ->
+    get_testdir(Dir, Suite);
+
+get_testdir(Dir, Suite) when is_atom(Suite) ->
+    get_testdir(Dir, atom_to_list(Suite));
+
+get_testdir(Dir, Suite) when is_list(Suite) ->
+    Abs = abs_name(Dir),
+    case is_test_dir(Abs) of
+	true ->
+	    Abs;
+	false ->
+	    AbsTest = filename:join(Abs, "test"),
+	    Mod = case filename:extension(Suite) of
+		      ".erl" -> Suite;
+		      _ -> Suite ++ ".erl"
+		  end,    
+	    case filelib:is_file(filename:join(AbsTest, Mod)) of
+		true -> AbsTest;
+		false -> Abs
+	    end		    
+    end;
+
+get_testdir(Dir, _) ->
+    get_testdir(Dir, all).
+
+%%%-----------------------------------------------------------------
+%%% @spec 
+%%%
+%%% @doc
+encrypt_config_file(SrcFileName, EncryptFileName) ->
+    case get_crypt_key_from_file() of
+	{error,_} = E ->
+	    E;
+	Key ->
+	    encrypt_config_file(SrcFileName, EncryptFileName, {key,Key})
+    end.
+
+%%%-----------------------------------------------------------------
+%%% @spec 
+%%%
+%%% @doc
+encrypt_config_file(SrcFileName, EncryptFileName, {file,KeyFile}) ->
+    case get_crypt_key_from_file(KeyFile) of
+	{error,_} = E ->
+	    E;
+	Key ->
+	    encrypt_config_file(SrcFileName, EncryptFileName, {key,Key})
+    end;
+
+encrypt_config_file(SrcFileName, EncryptFileName, {key,Key}) ->    
+    crypto:start(),
+    {K1,K2,K3,IVec} = make_crypto_key(Key),
+    case file:read_file(SrcFileName) of
+	{ok,Bin0} ->
+	    Bin1 = term_to_binary({SrcFileName,Bin0}),
+	    Bin2 = case byte_size(Bin1) rem 8 of
+		       0 -> Bin1;
+		       N -> list_to_binary([Bin1,random_bytes(8-N)])
+		   end,
+	    EncBin = crypto:des3_cbc_encrypt(K1, K2, K3, IVec, Bin2),
+	    case file:write_file(EncryptFileName, EncBin) of
+		ok ->
+		    io:format("~s --(encrypt)--> ~s~n", 
+			      [SrcFileName,EncryptFileName]),
+		    ok;
+		{error,Reason} ->
+		    {error,{Reason,EncryptFileName}}
+	    end;
+	{error,Reason} ->
+	    {error,{Reason,SrcFileName}}
+    end.		    
+
+%%%-----------------------------------------------------------------
+%%% @spec 
+%%%
+%%% @doc
+decrypt_config_file(EncryptFileName, TargetFileName) ->
+    case get_crypt_key_from_file() of
+	{error,_} = E ->
+	    E;
+	Key ->
+	    decrypt_config_file(EncryptFileName, TargetFileName, {key,Key})
+    end.
+    
+
+%%%-----------------------------------------------------------------
+%%% @spec 
+%%%
+%%% @doc
+decrypt_config_file(EncryptFileName, TargetFileName, {file,KeyFile}) ->
+    case get_crypt_key_from_file(KeyFile) of
+	{error,_} = E ->
+	    E;
+	Key ->
+	    decrypt_config_file(EncryptFileName, TargetFileName, {key,Key})
+    end;
+
+decrypt_config_file(EncryptFileName, TargetFileName, {key,Key}) ->
+    crypto:start(),
+    {K1,K2,K3,IVec} = make_crypto_key(Key),
+    case file:read_file(EncryptFileName) of
+	{ok,Bin} ->
+	    DecBin = crypto:des3_cbc_decrypt(K1, K2, K3, IVec, Bin),
+	    case catch binary_to_term(DecBin) of
+		{'EXIT',_} ->
+		    {error,bad_file};
+		{_SrcFile,SrcBin} ->
+		    case TargetFileName of
+			undefined ->
+			    {ok,SrcBin};
+			_ ->					  
+			    case file:write_file(TargetFileName, SrcBin) of
+				ok ->
+				    io:format("~s --(decrypt)--> ~s~n", 
+					      [EncryptFileName,TargetFileName]),
+				    ok;
+				{error,Reason} ->
+				    {error,{Reason,TargetFileName}}
+			    end
+		    end
+	    end;
+	{error,Reason} ->
+	    {error,{Reason,EncryptFileName}}
+    end.
+
+
+get_crypt_key_from_file(File) ->
+    case file:read_file(File) of
+	{ok,Bin} ->
+	    case catch string:tokens(binary_to_list(Bin), [$\n,$\r]) of
+		[Key] ->
+		    Key;
+		_ ->
+		    {error,{bad_crypt_file,File}}
+	    end;
+	{error,Reason} ->
+	    {error,{Reason,File}}
+    end.
+
+get_crypt_key_from_file() ->
+    CwdFile = filename:join(".",?cryptfile),
+    {Result,FullName} =
+	case file:read_file(CwdFile) of
+	    {ok,Bin} ->
+		{Bin,CwdFile};
+	    _ ->
+		case init:get_argument(home) of
+		    {ok,[[Home]]} ->
+			HomeFile = filename:join(Home,?cryptfile),
+			case file:read_file(HomeFile) of
+			    {ok,Bin} ->
+				{Bin,HomeFile};
+			    _ ->
+				{{error,no_crypt_file},noent}
+			end;
+		    _ ->
+			{{error,no_crypt_file},noent}
+		end
+	end,
+    case FullName of
+	noent ->
+	    Result;
+	_ ->
+	    case catch string:tokens(binary_to_list(Result), [$\n,$\r]) of
+		[Key] ->
+		    io:format("~nCrypt key file: ~s~n", [FullName]),
+		    Key;
+		_ ->
+		    {error,{bad_crypt_file,FullName}}
+	    end
+    end.
+
+make_crypto_key(String) ->
+    <<K1:8/binary,K2:8/binary>> = First = erlang:md5(String),
+    <<K3:8/binary,IVec:8/binary>> = erlang:md5([First|lists:reverse(String)]),
+    {K1,K2,K3,IVec}.
+
+random_bytes(N) ->
+    {A,B,C} = now(),
+    random:seed(A, B, C),
+    random_bytes_1(N, []).
+
+random_bytes_1(0, Acc) -> Acc;
+random_bytes_1(N, Acc) -> random_bytes_1(N-1, [random:uniform(255)|Acc]).
+
+
+%%%-----------------------------------------------------------------
+%%% @spec 
+%%%
+%%% @doc
+get_attached(TCPid) ->
+    case dbg_iserver:safe_call({get_attpid,TCPid}) of
+	{ok,AttPid} when is_pid(AttPid) ->
+	    AttPid;
+	_ ->
+	    undefined
+    end.
+
+%%%-----------------------------------------------------------------
+%%% @spec 
+%%%
+%%% @doc
+kill_attached(undefined,_AttPid) ->
+    ok;
+kill_attached(_TCPid,undefined) ->
+    ok;
+kill_attached(TCPid,AttPid) ->
+    case process_info(TCPid) of
+	undefined ->
+	    exit(AttPid,kill);
+	_ ->
+	    ok
+    end.
+	    
+
+%%%-----------------------------------------------------------------
+%%% @spec 
+%%%
+%%% @doc
+warn_duplicates(Suites) ->
+    Warn = 
+	fun(Mod) ->
+		case catch apply(Mod,sequences,[]) of
+		    {'EXIT',_} ->
+			ok;
+		    [] ->
+			ok;
+		    _ ->
+			io:format(user,"~nWARNING! Deprecated function: ~w:sequences/0.~n"
+				  "         Use group with sequence property instead.~n",[Mod])
+		end
+	end,
+    lists:foreach(Warn, Suites),
+    ok.
+
+
+%%%-----------------------------------------------------------------
+%%% Internal functions
+call(Msg) ->
+    MRef = erlang:monitor(process,whereis(ct_util_server)),
+    Ref = make_ref(),
+    ct_util_server ! {Msg,{self(),Ref}},
+    receive
+	{Ref, Result} -> 
+	    erlang:demonitor(MRef),
+	    Result;
+	{'DOWN',MRef,process,_,Reason}  -> 
+	    {error,{ct_util_server_down,Reason}}
+    end.
+
+return({To,Ref},Result) ->
+    To ! {Ref, Result}.
+
+seconds(T) ->
+    test_server:seconds(T).
+
+ct_make_ref() ->
+    Pid = case whereis(ct_make_ref) of
+	      undefined -> 
+		  spawn_link(fun() -> ct_make_ref_init() end);
+	      P -> 
+		  P
+	  end,
+    Pid ! {self(),ref_req},
+    receive
+	{Pid,Ref} -> Ref
+    end.
+
+ct_make_ref_init() ->
+    register(ct_make_ref,self()),
+    ct_make_ref_loop(0).
+
+ct_make_ref_loop(N) ->
+    receive
+	{From,ref_req} -> 
+	    From ! {self(),N},
+	    ct_make_ref_loop(N+1)
+    end.
+
+get_ref_from_name(Name) ->
+    case ets:select(?attr_table,[{#ct_conf{name=Name,ref='$1',_='_'},
+				  [],
+				  ['$1']}]) of
+	[Ref] ->
+	    {ok,Ref};
+	_ ->
+	    {error,{no_such_name,Name}}
+    end.
+    
+get_name_from_ref(Ref) ->
+    case ets:select(?attr_table,[{#ct_conf{name='$1',ref=Ref,_='_'},
+				  [],
+				  ['$1']}]) of
+	[Name] ->
+	    {ok,Name};
+	_ ->
+	    {error,{no_such_ref,Ref}}
+    end.
+    
+get_key_from_name(Name) ->
+    case ets:select(?attr_table,[{#ct_conf{name=Name,key='$1',_='_'},
+				  [],
+				  ['$1']}]) of
+	[Key|_] ->
+	    {ok,Key};
+	_ ->
+	    {error,{no_such_name,Name}}
+    end.
+ 
+   
+abs_name(Dir0) ->
+    Abs = filename:absname(Dir0),
+    Dir = case lists:reverse(Abs) of
+	      [$/|Rest] -> lists:reverse(Rest);
+	      _ -> Abs
+	  end,
+    abs_name1(Dir,[]).
+
+abs_name1([Drv,$:,$/],Acc) ->
+    Split = [[Drv,$:,$/]|Acc],
+    abs_name2(Split,[]);
+abs_name1("/",Acc) ->
+    Split = ["/"|Acc],
+    abs_name2(Split,[]);
+abs_name1(Dir,Acc) ->
+    abs_name1(filename:dirname(Dir),[filename:basename(Dir)|Acc]).
+
+abs_name2([".."|T],[_|Acc]) ->
+    abs_name2(T,Acc);
+abs_name2(["."|T],Acc) ->
+    abs_name2(T,Acc);
+abs_name2([H|T],Acc) ->
+    abs_name2(T,[H|Acc]);
+abs_name2([],Acc) ->
+    filename:join(lists:reverse(Acc)).
diff --git a/lib/common_test/src/ct_util.hrl b/lib/common_test/src/ct_util.hrl
new file mode 100644
index 0000000000..94ae2625cf
--- /dev/null
+++ b/lib/common_test/src/ct_util.hrl
@@ -0,0 +1,51 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 2003-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(attr_table,ct_attributes).
+-define(conn_table,ct_connections).
+-define(board_table,ct_boards).
+-define(suite_table,ct_suite_data).
+
+-record(conn, {handle,
+	       targetref,
+	       address,
+	       callback}).
+
+-record(testspec, {nodes=[],
+		   logdir=["."],
+		   cover=[],
+		   config=[],
+		   event_handler=[],
+		   include=[],
+		   alias=[],
+		   tests=[]}).
+
+-record(cover, {app=none,
+		level=details,
+		excl_mods=[],
+		incl_mods=[],
+		cross=[],
+		src=[]}).
+
+-define(CT_EVMGR, ct_event).
+-define(CT_EVMGR_REF, ct_event).
+-define(CT_MEVMGR, ct_master_event).
+-define(CT_MEVMGR_REF, ct_master_event).
+
+-define(missing_suites_info, "missing_suites.info").
diff --git a/lib/common_test/src/unix_telnet.erl b/lib/common_test/src/unix_telnet.erl
new file mode 100644
index 0000000000..14a70e9d22
--- /dev/null
+++ b/lib/common_test/src/unix_telnet.erl
@@ -0,0 +1,152 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 2004-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%
+%%
+
+%%% @doc Callback module for ct_telnet for talking telnet
+%%% to a unix host.
+%%% 
+%%% <p>It requires the following entry in the config file:</p>
+%%% <pre>
+%%% {unix,[{telnet,HostNameOrIpAddress},
+%%%        {port,PortNum},
+%%%        {username,UserName},
+%%%        {password,Password}]}.
+%%% </pre>
+%%%
+%%% <p>To talk telnet to the host specified by
+%%% <code>HostNameOrIpAddress</code>, use the interface functions in
+%%% <code>ct</code>, e.g. <code>open(Name), cmd(Name,Cmd), ...</code>.</p>
+%%%
+%%% <p><code>Name</code> is the name you allocated to the unix host in
+%%% your <code>require</code> statement. E.g.</p>
+%%% <pre>   suite() -> [{require,Name,{unix,[telnet,username,password]}}].</pre>
+%%% <p>or</p>
+%%% <pre>   ct:require(Name,{unix,[telnet,username,password]}).</pre>
+%%%
+%%% <p>Note that the <code>{port,PortNum}</code> tuple is optional and if
+%%% omitted, default telnet port 23 will be used.</p>
+%%%
+%%% @see ct
+%%% @see ct_telnet
+-module(unix_telnet).
+
+-compile(export_all).
+
+%% Callbacks for ct_telnet.erl
+-export([connect/4,get_prompt_regexp/0]).
+-import(ct_telnet,[start_log/1,cont_log/2,end_log/0]).
+
+-define(username,"login: ").
+-define(password,"Password: ").
+-define(prx,"login: |Password: |\\\$ |> ").
+
+%%%-----------------------------------------------------------------
+%%% @hidden
+%%% @spec get_prompt_regexp() -> PromptRegexp
+%%%      PromptRegexp = ct_telnet:prompt_regexp()
+%%%
+%%% @doc Callback for ct_telnet.erl.
+%%%
+%%% <p>Return the prompt regexp for telnet connections to the
+%%% interwatch instrument.</p>
+get_prompt_regexp() ->
+    ?prx.
+
+
+%%%-----------------------------------------------------------------
+%%% @hidden
+%%% @spec connect(Ip,Port,Timeout,Extra) -> {ok,Handle} | {error,Reason}
+%%%      Ip = string() | {integer(),integer(),integer(),integer()}
+%%%      Port = integer()
+%%%      Timeout = integer()
+%%%      Extra = {Username,Password}
+%%%      Username = string()
+%%%      Password = string()
+%%%      Handle = ct_telnet:handle()
+%%%
+%%% @doc Callback for ct_telnet.erl.
+%%%
+%%% <p>Setup telnet connection to a UNIX host.</p>
+connect(Ip,Port,Timeout,Extra) ->
+    case Extra of
+	{Username,Password} -> 
+	    connect(Ip,Port,Timeout,Username,Password);
+	Name ->
+	    case get_username_and_password(Name) of
+		{ok,{Username,Password}} -> 
+		    connect(Ip,Port,Timeout,Username,Password);
+		Error -> 
+		    Error
+	    end
+    end.
+
+connect(Ip,Port,Timeout,Username,Password) ->
+    start_log("unix_telnet:connect"),
+    Result = 
+	case ct_telnet_client:open(Ip,Port,Timeout) of
+	    {ok,Pid} ->
+		case ct_telnet:silent_teln_expect(Pid,[],[prompt],?prx,[]) of
+		    {ok,{prompt,?username},_} ->
+			ok = ct_telnet_client:send_data(Pid,Username),
+			cont_log("Username: ~s",[Username]),
+			case ct_telnet:silent_teln_expect(Pid,[],prompt,?prx,[]) of
+			    {ok,{prompt,?password},_} ->
+				ok = ct_telnet_client:send_data(Pid,Password),
+				Stars = lists:duplicate(length(Password),$*),
+				cont_log("Password: ~s",[Stars]),
+				ok = ct_telnet_client:send_data(Pid,""),
+				case ct_telnet:silent_teln_expect(Pid,[],prompt,
+								  ?prx,[]) of
+				    {ok,{prompt,Prompt},_} 
+				    when Prompt=/=?username, Prompt=/=?password ->
+					{ok,Pid};
+				    Error ->
+					cont_log("Password failed\n~p\n",
+						 [Error]),
+					{error,Error}
+				end;
+			    Error ->
+				cont_log("Login failed\n~p\n",[Error]),
+				{error,Error}
+			end;
+		    {ok,[{prompt,_OtherPrompt1},{prompt,_OtherPrompt2}],_} ->
+			{ok,Pid};
+		    Error ->
+			cont_log("Did not get expected prompt\n~p\n",[Error]),
+			{error,Error}
+		end;
+	    Error ->
+		cont_log("Could not open telnet connection\n~p\n",[Error]),
+		Error
+	end,
+    end_log(),
+    Result.
+
+get_username_and_password(Name) ->
+    case ct:get_config({Name,username}) of
+	undefined ->
+	    {error,{no_username,Name}};
+	Username ->
+	    case ct:get_config({Name,password}) of
+		undefined ->
+		    {error,{no_password,Name}};
+		Password ->
+		    {ok,{Username,Password}}
+	    end
+    end.
+	    
diff --git a/lib/common_test/src/vts.erl b/lib/common_test/src/vts.erl
new file mode 100644
index 0000000000..ad4845a7c3
--- /dev/null
+++ b/lib/common_test/src/vts.erl
@@ -0,0 +1,882 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 2003-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(vts).
+
+-export([start/0,
+	 init_data/4,
+	 stop/0,
+	 report/2]).
+
+-export([config_data/0,
+	 start_link/0]).
+
+-export([start_page/2,
+	 title_frame/2,
+	 menu_frame/2,
+	 welcome_frame/2,
+	 config_frame/2,
+	 add_config_file/2,
+	 remove_config_file/2,
+	 run_frame/2,
+	 add_test_dir/2,
+	 remove_test_dir/2,
+	 select_case/2,
+	 select_suite/2,
+	 run_test/2,
+	 result_frameset/2,
+	 result_summary_frame/2,
+	 no_result_log_frame/2,
+	 redirect_to_result_log_frame/2]).
+
+-export([test_info/3]).
+
+-define(START_PAGE,"/vts_erl/vts/start_page").
+
+-define(tests,vts_tests).
+
+%% Colors
+-define(INFO_BG_COLOR,"#C0C0EA").
+
+-record(state,{tests=[],config=[],event_handler=[],test_runner,
+	       running=0,reload_results=false,start_dir,current_log_dir,
+	       total=0,ok=0,fail=0,skip=0,testruns=[]}).
+
+
+%%%-----------------------------------------------------------------
+%%% User API
+start() ->
+    webtool:start(),
+    webtool:start_tools([],"app=vts").
+
+init_data(ConfigFiles,EvHandlers,LogDir,Tests) ->
+    call({init_data,ConfigFiles,EvHandlers,LogDir,Tests}).
+
+stop() ->
+    webtool:stop_tools([],"app=vts"),
+    webtool:stop().
+
+report(What,Data) ->
+    call({report,What,Data}).
+
+%%%-----------------------------------------------------------------
+%%% Return config data used by webtool
+config_data() ->
+    {ok,LogDir} =
+	case lists:keysearch(logdir,1,init:get_arguments()) of
+	    {value,{logdir,[LogD]}} -> {ok,filename:absname(LogD)};
+	    false -> file:get_cwd()
+	end,
+    {vts,
+     [{web_data,{"VisualTestServer",?START_PAGE}},
+      {alias,{erl_alias,"/vts_erl",[?MODULE]}},
+      {alias,{"/log_dir",LogDir}},
+      {start,{child,{{local,?MODULE},
+		     {?MODULE,start_link,[]},
+		     permanent,100,worker,[?MODULE]}}}
+	      ]}.
+
+start_link() ->
+    case whereis(?MODULE) of
+	undefined ->
+	    Self = self(),
+	    Pid = spawn_link(fun() -> init(Self) end),
+	    MRef = erlang:monitor(process,Pid),
+	    receive
+		{Pid,started} -> 
+		    erlang:demonitor(MRef),
+		    {ok,Pid};
+		{'DOWN',MRef,process,_,Reason} -> 
+		    {error,{vts,died,Reason}}
+	    end;
+	Pid ->
+	    {ok,Pid}
+    end.
+
+start_page(_Env,_Input) ->
+    call(start_page).
+title_frame(_Env,_Input) ->
+    call(title_frame).
+welcome_frame(_Env,_Input) ->
+    call(welcome_frame).
+menu_frame(_Env,_Input) ->
+    call(menu_frame).
+config_frame(_Env,_Input) ->
+    call(config_frame).
+add_config_file(_Env,Input) ->
+    call({add_config_file,Input}).
+remove_config_file(_Env,Input) ->
+    call({remove_config_file,Input}).
+run_frame(_Env,_Input) ->
+    call(run_frame).
+add_test_dir(_Env,Input) ->
+    call({add_test_dir,Input}).
+remove_test_dir(_Env,Input) ->
+    call({remove_test_dir,Input}).
+select_suite(_Env,Input) ->
+    call({select_suite,Input}).
+select_case(_Env,Input) ->
+    call({select_case,Input}).
+run_test(_Env,_Input) ->
+    call(run_test).
+result_frameset(_Env,_Input) ->
+    call(result_frameset).
+redirect_to_result_log_frame(_Env,_Input) ->
+    call(redirect_to_result_log_frame).
+result_summary_frame(_Env,_Input) ->
+    call(result_summary_frame).
+no_result_log_frame(_Env,_Input) ->
+    call(no_result_log_frame).
+
+aborted() ->
+    call(aborted).
+
+test_info(_VtsPid,Type,Data) ->
+    call({test_info,Type,Data}).
+
+init(Parent) ->
+    register(?MODULE,self()),
+    process_flag(trap_exit,true),
+    Parent ! {self(),started},
+    {ok,Cwd} = file:get_cwd(),
+    InitState = #state{start_dir=Cwd},
+    loop(InitState).
+
+loop(State) ->
+    receive
+	{{init_data,ConfigFiles,EvHandlers,LogDir,Tests},From} ->
+	    ct_install(State),
+	    return(From,ok),
+	    loop(#state{config=ConfigFiles,event_handler=EvHandlers,
+			current_log_dir=LogDir,tests=Tests});
+	{start_page,From} ->
+	    return(From,start_page1()),
+	    loop(State);
+	{title_frame,From} ->
+	    return(From,title_frame1()),
+	    loop(State);
+	{welcome_frame,From} ->
+	    return(From,welcome_frame1()),
+	    loop(State);
+	{menu_frame,From} ->
+	    return(From,menu_frame1()),
+	    loop(State);
+	{config_frame,From} ->
+	    return(From,config_frame1(State)),
+	    loop(State);
+	{{add_config_file,Input},From} ->
+	    {Return,State1} = add_config_file1(Input,State),
+	    ct_install(State1),
+	    return(From,Return),
+	    loop(State1);
+	{{remove_config_file,Input},From} ->
+	    {Return,State1} = remove_config_file1(Input,State),
+	    ct_install(State1),
+	    return(From,Return),
+	    loop(State1);
+	{run_frame,From} ->
+	    return(From,run_frame1(State)),
+	    loop(State);
+	{{add_test_dir,Input},From} ->
+	    {Return,State1} = add_test_dir1(Input,State),
+	    return(From,Return),
+	    loop(State1);
+	{{remove_test_dir,Input},From} ->
+	    {Return,State1} = remove_test_dir1(Input,State),
+	    return(From,Return),
+	    loop(State1);
+	{{select_suite,Input},From} ->
+	    {Return,State1} = select_suite1(Input,State),
+	    return(From,Return),
+	    loop(State1);
+	{{select_case,Input},From} ->
+	    {Return,State1} = select_case1(Input,State),
+	    return(From,Return),
+	    loop(State1);
+	{run_test,From} ->
+	    State1 = run_test1(State),
+	    return(From,redirect_to_result_frameset1()),
+	    loop(State1);
+	{result_frameset,From} ->
+	    return(From,result_frameset1(State)),
+	    loop(State);
+	{redirect_to_result_log_frame,From} ->
+	    return(From,redirect_to_result_log_frame1(State)),
+	    loop(State);
+	{result_summary_frame,From} ->
+	    return(From,result_summary_frame1(State)),
+	    loop(State);
+	stop_reload_results ->
+	    file:set_cwd(State#state.start_dir),
+	    loop(State#state{reload_results=false});
+	{no_result_log_frame,From} ->
+	    return(From,no_result_log_frame1()),
+	    loop(State);
+	{aborted,From} ->
+	    return(From,ok),
+	    loop(State#state{test_runner=undefined,running=0});
+	{{report,What,Data},From} ->
+	    State1 = report1(What,Data,State),
+	    return(From,ok),
+	    loop(State1);
+	{stop,From} -> 
+	    return(From,ok);
+	{'EXIT',Pid,Reason} ->
+	    case State#state.test_runner of
+		Pid -> io:format("ERROR: test runner crashed: ~p\n",[Reason]);
+		_ -> ignore
+	    end,
+	    loop(State);
+	{{test_info,_Type,_Data},From} ->
+	    return(From,ok),
+	    loop(State)
+    end.
+
+call(Msg) ->
+    case whereis(?MODULE) of
+	undefined -> {error,no_proc};
+	Pid ->
+	    MRef = erlang:monitor(process,Pid),
+	    Ref = make_ref(),
+	    Pid ! {Msg,{self(),Ref}},
+	    receive
+		{Ref, Result} -> 
+		    erlang:demonitor(MRef),
+		    Result;
+		{'DOWN',MRef,process,_,Reason}  -> 
+		    {error,{process_down,Pid,Reason}}
+	    end
+    end.
+
+return({To,Ref},Result) ->
+    To ! {Ref, Result}.
+
+
+run_test1(State=#state{tests=Tests,current_log_dir=LogDir}) ->
+    Self=self(),
+    RunTest = fun() ->
+		      case ct_run:do_run(Tests,[],LogDir) of
+			  {error,_Reason} ->
+			      aborted();
+			  _ ->
+			      ok
+		      end,
+		      unlink(Self)
+	      end,
+
+    Pid = spawn_link(RunTest),
+
+    Total =
+	receive 
+	    {{test_info,start_info,{_,_,Cases}},From} ->
+		return(From,ok),
+		Cases;
+	    EXIT = {'EXIT',_,_} ->
+		self() ! EXIT
+	after 30000 ->
+		0
+	end,
+    State#state{test_runner=Pid,running=length(Tests),
+		total=Total,ok=0,fail=0,skip=0,testruns=[]}.
+
+ 
+ct_install(#state{config=Config,event_handler=EvHandlers,
+		  current_log_dir=LogDir}) ->
+    ct_run:install([{config,Config},{event_handler,EvHandlers}],LogDir).
+    
+%%%-----------------------------------------------------------------
+%%% HTML
+start_page1() ->
+    header("Visual Test Server Start Page",start_page_frameset()).
+
+start_page_frameset() ->
+    frameset(
+      "ROWS=\"60,*\"",
+      [frame(["NAME=\"title\" SRC=\"./title_frame\""]),
+       frameset(
+	 "COLS=\"150,*\"",
+	 [frame(["NAME=\"menu\" SRC=\"./menu_frame\""]),
+	  frame(["NAME=\"main\" SRC=\"./welcome_frame\""])])]).
+
+
+title_frame1() ->
+    header(body("BGCOLOR=lightgrey TEXT=darkgreen",title_body())).
+
+title_body() ->
+    p("ALIGN=center",font("SIZE=\"+3\"",b("Visual Test Server"))).
+
+welcome_frame1() ->
+    header(body(welcome_body())).
+
+welcome_body() ->
+    table(
+      "WIDTH=100% HEIGHT=60%",
+      [tr("VALIGN=middle",
+	  td("ALIGN=center",
+	     font("SIZE=6",
+		  ["Welcome to the",br(),
+		   "Visual Test Server"])))]).
+
+menu_frame1() ->
+    header(body(menu_body())).
+
+menu_body() ->
+    [h2("Content"),
+     ul([
+	 li(href(["TARGET=\"main\""],"./config_frame","Config")),
+	 li(href(["TARGET=\"main\""],"./run_frame","Run")),
+	 li(href(["TARGET=\"main\""],"./result_frameset","Result"))
+	]),
+     h2("Logs"),
+     ul([
+	 li(href(["TARGET=\"new\""],"/log_dir/index.html","Last Runs")),
+	 li(href(["TARGET=\"new\""],"/log_dir/all_runs.html","All Runs"))
+	])
+    ].
+
+config_frame1(State) ->
+    header("Config",body(config_body(State))).
+    
+config_body(State) ->
+    Entry = [input("TYPE=file NAME=browse SIZE=40"),
+	     input("TYPE=hidden NAME=file")],
+    AddForm = 
+	form(
+	  "NAME=read_file_form METHOD=post ACTION=\"./add_config_file\"",
+	  table(
+	    "BORDER=0",
+	    [tr(
+	       [td(Entry),
+		td("ALIGN=center",
+		   input("TYPE=submit onClick=\"file.value=browse.value;\""
+			 " VALUE=\"Add\""))])])),
+    {Text,RemoveForm} = 
+	case State#state.config of
+	    [] ->
+		T = "To be able to run any tests, one or more configuration " 
+		    "files must be added. Enter the name of the configuration "
+		    "file below and click the \"Add\" button.",
+		R = "",
+		{T,R};
+	    Files ->
+		T = "The currently known configuration files are listed below. "
+		    "To add a file, type the filename in the entry and "
+		    "click the \"Add\" button. "
+		    "To remove a file, select it and click the \"Remove\" "
+		    "button.",
+		ConfigFiles = [option(File) || File <- Files],
+		Select = select("NAME=file TITLE=\"Select Config File\""
+				" MULTIPLE=true",
+				ConfigFiles),
+		R = 
+		    form(["NAME=remove_config METHOD=post ",
+			  "ACTION=\"./remove_config_file\""],
+			 table(
+			   "BORDER=0",
+			   [tr(td("ALIGN=center",Select)),
+			    tr(td("ALIGN=center",
+				  input("TYPE=submit VALUE=\"Remove\"")))])),
+		{T,R}
+	end,
+    
+    [h1("ALIGN=center","Config"),
+     table(
+       "WIDTH=600 ALIGN=center CELLPADDING=5",
+       [tr(td(["BGCOLOR=",?INFO_BG_COLOR],Text)),
+	tr(td("ALIGN=center",AddForm)),
+	tr(td("ALIGN=center",RemoveForm))])].
+
+
+add_config_file1(Input,State) ->
+    State1 = 
+	case get_input_data(Input,"file") of
+	    "" -> State;
+	    File -> State#state{config=[File|State#state.config]}
+	end,
+    Return = config_frame1(State1),
+    {Return,State1}.
+
+remove_config_file1(Input,State) ->
+    Files = get_all_input_data(Input,"file"),
+    State1 = State#state{config=State#state.config--Files},
+    Return = config_frame1(State1),
+    {Return,State1}.
+    
+
+
+run_frame1(State) ->
+    header("Run Test",body(run_body(State))).
+    
+run_body(#state{running=Running}) when Running>0 ->
+    [h1("ALIGN=center","Run Test"),
+     p(["Test are ongoing: ",href("./result_frameset","Results")])];
+run_body(State) ->
+    ConfigList = ul([li(File) || File <- State#state.config]),
+    ConfigFiles = [h3("Config Files"),
+		   ConfigList],
+    
+    AddDirForm = 
+	form(
+	  "NAME=add_dir_form METHOD=post ACTION=\"./add_test_dir\"",
+	  table(
+	    "BORDER=0",
+	    [tr(td("COLSPAN=2","Enter test directory")),
+	     tr(
+	       [td(input("TYPE=text NAME=dir SIZE=40")),
+		td("ALIGN=center",
+		   input("TYPE=submit onClick=\"dir.value=browse.value;\""
+			 " VALUE=\"Add Test Dir\""))])])),
+
+    {LoadedTestsTable,Submit} = 
+	case create_testdir_entries(State#state.tests,1) of
+	    [] -> {"",""};
+	    TestDirs ->
+		Heading = tr([th(""),
+			      th("ALIGN=left","Directory"),
+			      th("ALIGN=left","Suite"),
+			      th("ALIGN=left","Case")]),
+		{table("CELLPADDING=5",[Heading,TestDirs]),
+		submit_button()} 
+	end,
+
+    %% It should be ok to have no config-file!
+    Body = 
+	%% case State#state.config of %% [] -> %% p("ALIGN=center",
+	%% 	       href("./config_frame","Please select one or
+	%% 	       more config files")); %% _ ->
+	table(
+	  "WIDTH=100%",
+	  [tr(td(ConfigFiles)),
+	   tr(td("")),
+	   tr(td(AddDirForm)),
+	   tr(td("")),
+	   tr(td(LoadedTestsTable)),
+	   tr(td(Submit))]),
+    %%    end,
+    
+    [h1("ALIGN=center","Run Test"), Body].
+
+create_testdir_entries([{Dir,Suite,Case}|Tests],N) ->
+    [testdir_entry(Dir,Suite,Case,N)|create_testdir_entries(Tests,N+1)];
+create_testdir_entries([],_N) ->
+    [].
+
+testdir_entry(Dir,Suite,Case,N) ->
+    NStr = integer_to_list(N),
+    tr([td(delete_button(NStr)),
+	td(Dir),
+	td(suite_select(Dir,Suite,NStr)),
+	td(case_select(Dir,Suite,Case,NStr))]).
+
+delete_button(N) ->
+    form(["NAME=remove_dir_form METHOD=post ACTION=\"./remove_test_dir\""],
+	 [input(["TYPE=hidden NAME=dir VALUE=\'",N,"\'"]),
+	  input(["TYPE=submit VALUE=X"])]).
+
+suite_select(Dir,Suite,N) ->
+    case filelib:wildcard(filename:join(Dir,"*_SUITE.erl")) of
+	[] ->
+	    select("NAME=suite TITLE=\"Select suite\"","");
+	Suites0 ->
+	    Suites = [filename:basename(filename:rootname(S)) ||  S <- Suites0],
+	    select("NAME=suite TITLE=\"Select suite\"",
+		   options(["all"|Suites],atom_to_list(Suite),N,"select_suite"))
+    end.
+
+case_select(_Dir,all,_,N) ->
+    select("NAME=case TITLE=\"Select case\"",
+	   options(["all"],"all",N,"select_case"));
+case_select(Dir,Suite,Case,N) ->
+    MakeResult =
+	case application:get_env(common_test, auto_compile) of
+	    {ok,false} ->
+		ok;
+	    _ ->	    
+		UserInclude =
+		    case application:get_env(common_test, include) of
+			{ok,UserInclDirs} when length(UserInclDirs) > 0 ->
+			    [{i,UserInclDir} || UserInclDir <- UserInclDirs];
+			_ ->
+			    []
+		    end,
+		ct_run:run_make(Dir,Suite,UserInclude)
+	end,
+    case MakeResult of
+	ok ->
+	    code:add_pathz(Dir),
+	    case catch apply(Suite,all,[]) of
+		{'EXIT',Reason} ->
+		    io:format("\n~p\n",[Reason]),
+		    red(["COULD NOT READ TESTCASES!!",br(),
+			 "See erlang shell for info"]);
+		{skip,_Reason} ->
+		    select("NAME=case TITLE=\"Select case\"",
+			   options(["all"],"all",N,"select_case"));
+		AllCasesAtoms ->
+		    AllCases = [atom_to_list(C) || C <- AllCasesAtoms,
+						   is_atom(C)],
+		    select("NAME=case TITLE=\"Select case\"",
+			   options(["all"|AllCases],atom_to_list(Case),
+				   N,"select_case"))
+	    end;
+	_Error ->
+	    red(["COMPILATION ERROR!!",br(),
+		 "See erlang shell for info",br(),
+		 "Reload this page when errors are fixed"])
+    end.
+	    
+
+options([Selected|Elements],Selected,N,Func) ->
+    [option(["SELECTED ",
+	     "onClick=\"document.location.href=\'./",Func,"?n=",N,
+	     "&selected=",Selected,"\';\""],
+	    Selected)|
+     options(Elements,Selected,N,Func)];
+options([Element|Elements],Selected,N,Func) ->
+    [option(["onClick=\"document.location.href=\'./",Func,"?n=",N,
+	     "&selected=",Element,"\';\""],
+	    Element)|
+     options(Elements,Selected,N,Func)];
+options([],_Selected,_N,_Func) ->
+    [].
+
+add_test_dir1(Input,State) ->
+    State1 = 
+	case get_input_data(Input,"dir") of
+	    "" -> State;
+	    Dir0 ->
+		Dir = case ct_util:is_test_dir(Dir0) of
+			  true -> 
+			      Dir0;
+			  false -> filename:join(Dir0,"test")
+		      end,
+		case filelib:is_dir(Dir) of
+		    true -> 
+			Test = ct_run:tests(Dir),
+			State#state{tests=State#state.tests++Test};
+		    false ->
+			State
+		end
+	end,
+    Return = run_frame1(State1),
+    {Return,State1}.
+
+
+
+remove_test_dir1(Input,State) ->
+    N = list_to_integer(get_input_data(Input,"dir")),
+    State1 = State#state{tests=delete_test(N,State#state.tests)},
+    Return = run_frame1(State1),
+    {Return,State1}.
+
+delete_test(1,[_|T]) ->
+    T;
+delete_test(N,[H|T]) ->
+    [H|delete_test(N-1,T)].
+
+select_suite1(Input,State) ->
+    N = list_to_integer(get_input_data(Input,"n")),
+    Suite = list_to_atom(get_input_data(Input,"selected")),
+    Tests1 = replace_suite(N,Suite,State#state.tests),
+    State1 = State#state{tests=Tests1},
+    Return = run_frame1(State1),
+    {Return,State1}.
+
+replace_suite(1,Suite,[{Dir,_,_}|T]) ->
+    [Test] = ct_run:tests(Dir,Suite),
+    [Test|T];
+replace_suite(N,Suite,[H|T]) ->	    
+    [H|replace_suite(N-1,Suite,T)].
+
+select_case1(Input,State) ->
+    N = list_to_integer(get_input_data(Input,"n")),
+    Case = list_to_atom(get_input_data(Input,"selected")),
+    Tests1 = replace_case(N,Case,State#state.tests),
+    State1 = State#state{tests=Tests1},
+    Return = run_frame1(State1),
+    {Return,State1}.
+
+replace_case(1,Case,[{Dir,Suite,_}|T]) ->
+    [Test] = ct_run:tests(Dir,Suite,Case),
+    [Test|T];
+replace_case(N,Case,[H|T]) ->	    
+    [H|replace_case(N-1,Case,T)].
+
+
+submit_button() ->
+    form(["NAME=run_test_form METHOD=post ACTION=\"./run_test\""],
+	 [input("TYPE=submit VALUE=\"Run Test\"")]).
+	    
+
+redirect_to_result_frameset1() ->
+    Head = 
+	["<META HTTP-EQUIV=\"refresh\" CONTENT=\"1; URL=./result_frameset\">"],
+    [header("",Head,body("Please wait..."))].
+
+result_frameset1(State) ->
+     header("Results",result_frameset2(State)).
+
+result_frameset2(State) ->
+    ResultLog = 
+	case {State#state.current_log_dir,State#state.running} of
+	    {undefined,0} ->
+		"./no_result_log_frame";
+	    {undefined,_} ->
+		"./redirect_to_result_log_frame";
+	    {_Dir,0} ->
+		filename:join(["/log_dir","index.html"]);
+	    {_Dir,_} ->
+		{_,CurrentLog} = hd(State#state.testruns),
+		CurrentLog
+	end,
+    frameset(
+      "COLS=\"200,*\"",
+     [frame(["NAME=\"result_summary\" SRC=\"./result_summary_frame\""]),
+      frame(["NAME=\"result_log\" SRC=\"",ResultLog,"\""])]).
+
+redirect_to_result_log_frame1(State) ->
+    ResultLog = 
+	case {State#state.testruns,State#state.running} of
+	    {[],0} ->
+		"./no_result_log_frame";
+	    {[],_} ->
+		"./redirect_to_result_log_frame";
+	    {[{_,CurrentLog}|_],_} ->
+		CurrentLog
+	end,
+    Head = ["<META HTTP-EQUIV=\"refresh\" CONTENT=\"1; URL=",ResultLog,"\">"],
+    [header("",Head,body("Please wait..."))].
+
+result_summary_frame1(State) ->
+    case {State#state.running,State#state.reload_results} of
+	{0,false} ->
+	    header("Result Summary",body(result_summary_body(State)));
+	_ ->
+ 	    Head = 
+		"<SCRIPT LANGUAGE=\"JavaScript1.2\">\n"
+		"\n"
+		"function startReloadInterval() {\n"
+		"    intervalId = setInterval(\"reloadPage()\",5000)\n"
+		"}\n"
+		"\n"
+		"function reloadPage() {\n"
+		"    location.reload()\n"
+		"    parent.result_log.location.reload()\n"
+%		"    parent.result_log.scrollBy(0, window.innerHeight)\n"
+		"}\n"
+		"</SCRIPT>\n",
+ 	    header("Result Summary",Head,
+		   body("onLoad=\"startReloadInterval()\" BGCOLOR=\"#FFFFFF\"",
+			result_summary_body(State)))
+	end.
+    
+result_summary_body(State) ->
+    N = State#state.ok + State#state.fail + State#state.skip,
+    [h2("Result Summary"),
+     p([b(integer_to_list(N))," cases executed (of ",
+	b(integer_to_list(State#state.total)),")"]),
+     p([green([b(integer_to_list(State#state.ok))," successful"]),br(),
+	red([b(integer_to_list(State#state.fail))," failed"]),br(),
+	orange([b(integer_to_list(State#state.skip))," skipped"])]),
+    executed_test_list(State)].
+
+executed_test_list(#state{testruns=[]}) ->
+    [];
+executed_test_list(#state{testruns=TestRuns}) ->
+    [h2("Executed Tests"),
+     table(
+       "",
+       [tr(td(href("TARGET=\"result_log\"",Log,Name))) || 
+	   {Name,Log} <- lists:reverse(TestRuns)])].
+
+
+no_result_log_frame1() ->
+    header("Test Results",body(no_result_log_body())).
+
+no_result_log_body() ->
+    [h1("ALIGN=center","Test Results"),
+     p(["There are currently no test results available. ",
+	br(),href("TARGET=\"main\"","./run_frame","You can run tests here")])].
+
+report1(tests_start,{TestName,_N},State) ->
+    {ok,LogDir} = ct_logs:get_log_dir(),
+    TestRuns = 
+	case State#state.testruns of
+	    [{TestName,_}|_]=TR -> 
+		TR;
+	    TR -> 
+		[{TestName,get_test_log(TestName,LogDir)}|TR]
+	end,
+    State#state{testruns=TestRuns};
+report1(tests_done,{_Ok,_Fail,_Skip},State) ->
+    timer:send_after(5000, self(),stop_reload_results),
+    State#state{running=State#state.running-1,reload_results=true};
+report1(tc_start,{_Suite,_Case},State) ->
+    State;
+report1(tc_done,{_Suite,init_per_suite,_},State) ->
+    State;
+report1(tc_done,{_Suite,end_per_suite,_},State) ->
+    State;
+report1(tc_done,{_Suite,_Case,ok},State) ->
+    State#state{ok=State#state.ok+1};
+report1(tc_done,{_Suite,_Case,{failed,_Reason}},State) ->
+    State#state{fail=State#state.fail+1};
+report1(tc_done,{_Suite,_Case,{skipped,_Reason}},State) ->
+    State#state{skip=State#state.skip+1};
+report1(tc_user_skip,{_Suite,_Case,_Reason},State) ->
+    State#state{skip=State#state.skip+1}.
+
+get_test_log(TestName,LogDir) ->
+    [Log] = 
+	filelib:wildcard(
+	  filename:join([TestName++".logs","run*","suite.log.html"])),
+    filename:join(["/log_dir",LogDir,Log]).
+
+
+
+%get_description(Suite,Case) ->
+%    case erlang:function_exported(Suite,Case,0) of
+%	true ->
+%	    case catch apply(Suite,Case,[]) of
+%		{'EXIT',_Reason} ->
+%		    "-";
+%		Info ->
+%		    case lists:keysearch(doc,1,Info) of
+%			{value,{doc,Doc}} when is_list(Doc) ->
+%			    Doc;
+%			_ ->
+%			    "-"
+%		    end
+%	    end;
+%	false ->
+%	    "-"
+%    end.
+
+%%%-----------------------------------------------------------------
+%%% Internal library
+header(Body) ->
+    header("","",Body).
+header(Title,Body) ->
+    header(Title,"",Body).
+header(Title,Head,Body) ->
+    ["Pragma:no-cache\r\n",
+     "Content-type: text/html\r\n\r\n",
+     html_header(Title,Head,Body)].
+
+html_header(Title,Head,Body) ->    
+    ["<HTML>\n",
+     "<HEAD>\n",
+     "<TITLE>", Title,  "</TITLE>\n",
+     Head,
+     "</HEAD>\n",
+     Body,
+     "</HTML>"].
+
+body(Text) ->
+    ["<BODY BGCOLOR=\"#FFFFFF\">\n",Text,"<\BODY>\n"].
+body(Args,Text) ->
+    ["<BODY ", Args, ">\n", Text,"<\BODY>\n"].
+
+
+frameset(Args,Frames) ->
+    ["<FRAMESET ",Args,">\n", Frames, "\n</FRAMESET>\n"].
+frame(Args) ->
+    ["<FRAME ",Args, ">\n"].
+
+table(Args,Text) ->
+    ["<TABLE ", Args, ">\n", Text, "\n</TABLE>\n"].
+tr(Text) ->
+    ["<TR>\n", Text, "\n</TR>\n"].
+tr(Args,Text) ->
+    ["<TR ", Args, ">\n", Text, "\n</TR>\n"].
+th(Text) ->
+    ["<TH>", Text, "</TH>"].
+th(Args,Text) ->
+    ["<TH ", Args, ">\n", Text, "\n</TH>\n"].
+td(Text) ->
+    ["<TD>", Text, "</TD>"].
+td(Args,Text) ->
+    ["<TD ", Args, ">", Text, "</TD>"].
+
+b(Text) ->
+    ["<B>",Text,"</B>"].
+%em(Text) ->    
+%    ["<EM>",Text,"</EM>\n"].
+%pre(Text) ->
+%    ["<PRE>",Text,"</PRE>"].
+href(Link,Text) ->
+    ["<A HREF=\"",Link,"\">",Text,"</A>"].
+href(Args,Link,Text) ->
+    ["<A HREF=\"",Link,"\" ",Args,">",Text,"</A>"].
+form(Args,Text) ->
+    ["<FORM ",Args,">\n",Text,"\n</FORM>\n"].
+input(Args) ->
+    ["<INPUT ", Args, ">\n"].
+select(Args,Text) ->
+    ["<SELECT ", Args, ">\n", Text, "\n</SELECT>\n"].
+option(Text) ->
+    ["<OPTION>\n", Text, "\n</OPTION>\n"].
+option(Args,Text) ->
+    ["<OPTION ", Args, ">\n", Text, "\n</OPTION>\n"].
+h1(Args,Text) ->
+    ["<H1 ", Args, ">",Text,"</H1>\n"].
+h2(Text) ->
+    ["<H2>",Text,"</H2>\n"].
+h3(Text) ->
+    ["<H3>",Text,"</H3>\n"].
+font(Args,Text) ->
+    ["<FONT ",Args,">\n",Text,"\n</FONT>\n"].
+p(Text) ->    
+    ["<P>",Text,"</P>\n"].
+p(Args, Text) ->    
+    ["<P ", Args, ">",Text,"</P>\n"].
+ul(Text) ->
+    ["<UL>", Text, "</UL>\n"].
+li(Text) ->
+    ["<LI>", Text, "</LI>\n"].
+br() ->
+    "<BR>\n".
+
+red(Text) -> color(red,Text).
+green(Text) -> color(green,Text).
+orange(Text) -> color(orange,Text).
+color(Color,Text) when is_atom(Color) ->
+    font(["COLOR=",atom_to_list(Color)],Text).
+
+get_all_input_data(Input,Key)->
+    List = parse(Input),
+    get_all_input_data(List,Key,[]).
+get_all_input_data([{Key,Value}|List],Key,Acc) ->
+    get_all_input_data(List,Key,[Value|Acc]);
+get_all_input_data([{_OtherKey,_Value}|List],Key,Acc) ->
+    get_all_input_data(List,Key,Acc);
+get_all_input_data([],_Key,Acc) ->
+    Acc.
+
+get_input_data(Input,Key)->
+    case lists:keysearch(Key,1,parse(Input)) of
+	{value,{Key,Value}} ->
+	    Value;
+	false ->
+	    undefined
+    end.
+
+parse(Input) ->
+    httpd:parse_query(Input).
+