%%
%% %CopyrightBegin%
%%
%% Copyright Ericsson AB 2005-2010. 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(ssh_sample_cli).
%% api
-export([listen/1, listen/2]).
%% %% our shell function
%% -export([start_our_shell/1]).
%% our command functions
-export([cli_prime/1, cli_primes/1, cli_gcd/2, cli_lcm/2,
cli_factors/1, cli_exit/0, cli_rho/1, cli_help/0,
cli_crash/0, cli_self/0, cli_user/0, cli_host/0]).
listen(Port) ->
listen(Port, []).
listen(Port, Options) ->
crypto:start(),
ssh:start(),
ssh:daemon(any, Port, [{shell, fun(U, H) -> start_our_shell(U, H) end} | Options]).
%% our_routines
our_routines() ->
[
{"crash", cli_crash, " crash the cli"},
{"exit", cli_exit, " exit application"},
{"factors", cli_factors,"<int> prime factors of <int>"},
{"gcd", cli_gcd, "<int> <int> greatest common divisor"},
{"help", cli_help, " help text"},
{"lcm", cli_lcm, "<int> <int> least common multiplier"},
{"prime", cli_prime, "<int> check for primality"},
{"primes", cli_primes, "<int> print all primes up to <int>"},
{"rho", cli_rho, "<int> prime factors using rho's alg."},
{"user", cli_user, " print name of user"},
{"host", cli_host, " print host addr"},
{"self", cli_self, " print my pid"}
].
%% (we could of course generate this from module_info() something like this)
%% our_routines1() ->
%% {value, {exports, Exports}} =
%% lists:keysearch(exports, 1, module_info()),
%% get_cli(Exports, []).
%% our_args1(N) -> our_args1(N, "").
%% our_args1(0, S) -> S;
%% our_args1(N, S) -> our_args1(N-1, S ++ "<int> ").
%% get_cli([], Acc) ->
%% lists:sort(Acc);
%% get_cli([{A, Arity} | Rest], Acc) ->
%% L = atom_to_list(A),
%% case lists:prefix("cli_", L) of
%% true -> get_cli(Rest, [{tl4(L), A, our_args1(Arity)} | Acc]);
%% false -> get_cli(Rest, Acc)
%% end.
%% the longest common prefix of two strings
common_prefix([C | R1], [C | R2], Acc) ->
common_prefix(R1, R2, [C | Acc]);
common_prefix(_, _, Acc) ->
lists:reverse(Acc).
%% longest prefix in a list, given a prefix
longest_prefix(List, Prefix) ->
case [A || {A, _, _} <- List, lists:prefix(Prefix, A)] of
[] ->
{none, List};
[S | Rest] ->
NewPrefix0 =
lists:foldl(fun(A, P) ->
common_prefix(A, P, [])
end, S, Rest),
NewPrefix = nthtail(length(Prefix), NewPrefix0),
{prefix, NewPrefix, [S | Rest]}
end.
%%% our expand function (called when the user presses TAB)
%%% input: a reversed list with the row to left of the cursor
%%% output: {yes|no, Expansion, ListofPossibleMatches}
%%% where the atom no yields a beep
%%% Expansion is a string inserted at the cursor
%%% List... is a list that will be printed
%%% Here we beep on prefixes that don't match and when the command
%%% filled in
expand([$ | _]) ->
{no, "", []};
expand(RevBefore) ->
Before = lists:reverse(RevBefore),
case longest_prefix(our_routines(), Before) of
{prefix, P, [_]} ->
{yes, P ++ " ", []};
{prefix, "", M} ->
{yes, "", M};
{prefix, P, _M} ->
{yes, P, []};
{none, _M} ->
{no, "", []}
end.
%%% spawns out shell loop, we use plain io to input and output
%%% over ssh (the group module is our group leader, and takes
%%% care of sending input to the ssh_sample_cli server)
start_our_shell(User, Peer) ->
spawn(fun() ->
io:setopts([{expand_fun, fun(Bef) -> expand(Bef) end}]),
io:format("Enter command\n"),
put(user, User),
put(peer_name, Peer),
our_shell_loop()
end).
%%% an ordinary Read-Eval-Print-loop
our_shell_loop() ->
% Read
Line = io:get_line("CLI> "),
% Eval
Result = eval_cli(Line),
% Print
io:format("---> ~p\n", [Result]),
case Result of
done ->
exit(normal);
crash ->
1 / 0;
_ ->
our_shell_loop()
end.
%%% translate a command to a function
command_to_function(Command) ->
case lists:keysearch(Command, 1, our_routines()) of
{value, {_, Proc, _}} ->
Proc;
false ->
unknown_cli
end.
%%% evaluate a command line
eval_cli(Line) ->
case string:tokens(Line, " \n") of
[] -> [];
[Command | ArgStrings] ->
Proc = command_to_function(Command),
case fix_args(ArgStrings) of
{ok, Args} ->
case catch apply(?MODULE, Proc, Args) of
{'EXIT', Error} ->
{error, Error}; % wrong_number_of_arguments};
Result ->
Result
end;
Error ->
Error
end
end.
%%% make command arguments to integers
fix_args(ArgStrings) ->
case catch [list_to_integer(A) || A <- ArgStrings] of
{'EXIT', _} ->
{error, only_integer_arguments};
Args ->
{ok, Args}
end.
%%% the commands, check for reasonable arguments here too
cli_prime(N) when N < 1000000000 ->
rho(N) == [N] andalso is_prime(N);
cli_prime(N) when N < 10000 ->
is_prime(N).
cli_primes(N) when N < 1000000 ->
primes(N).
cli_gcd(A, B) when is_integer(A), is_integer(B) ->
gcd(A, B).
cli_lcm(A, B) when is_integer(A), is_integer(B) ->
lcm(A, B).
cli_factors(A) when A < 1000000 ->
factors(A).
cli_user() ->
get(user).
cli_host() ->
get(peer_name).
cli_self() ->
self().
cli_crash() ->
crash.
cli_rho(A) ->
rho(A).
cli_exit() ->
done.
help_str(L) ->
help_str(L, []).
help_str([], Acc) ->
lists:sort(Acc);
help_str([{CommandName, _, HelpS} | Rest], Acc) ->
C = string:left(CommandName, 10),
help_str(Rest, [[C, " ", HelpS, $\n] | Acc]).
cli_help() ->
HelpString = ["CLI Sample\n" | help_str(our_routines())],
io:format("~s\n", [HelpString]).
%% a quite simple Sieve of Erastothenes (not tail-recursive, though)
primes(Size) ->
era(math:sqrt(Size), lists:seq(2,Size)).
era(Max, [H|T]) when H =< Max ->
[H | era(Max, sieve([H|T], H))];
era(_Max, L) ->
L.
sieve([H|T], N) when H rem N =/= 0 ->
[H | sieve(T, N)];
sieve([_H|T], N) ->
sieve(T, N);
sieve([], _N) ->
[].
%% another sieve, for getting the next prime incrementally
next_prime([], _) ->
2;
next_prime([2], 2) ->
3;
next_prime(Primes, P) ->
next_prime1(Primes, P).
next_prime1(Primes, P) ->
P1 = P + 2,
case divides(Primes, trunc(math:sqrt(P1)), P1) of
false -> P1;
true -> next_prime1(Primes, P1)
end.
divides([], _, _) ->
false;
divides([A | _], Nsqrt, _) when A > Nsqrt ->
false;
divides([A | _], _, N) when N rem A == 0 ->
true;
divides([_ | R], Nsqrt, N) ->
divides(R, Nsqrt, N).
is_prime(P) ->
lists:all(fun(A) -> P rem A =/= 0 end, primes(trunc(math:sqrt(P)))).
%% Normal gcd, Euclid
gcd(R, Q) when abs(Q) < abs(R) -> gcd1(Q,R);
gcd(R, Q) -> gcd1(R,Q).
gcd1(0, Q) -> Q;
gcd1(R, Q) ->
gcd1(Q rem R, R).
%% Least common multiple of (R,Q)
lcm(0, _Q) -> 0;
lcm(_R, 0) -> 0;
lcm(R, Q) ->
(Q div gcd(R, Q)) * R.
%%% Prime factors of a number (na�ve implementation)
factors(N) ->
Nsqrt = trunc(math:sqrt(N)),
factors([], N, 2, Nsqrt, []).
factors(_Primes, N, Prime, Nsqrt, Factors) when Prime > Nsqrt ->
lists:reverse(Factors, [N]);
factors(Primes, N, Prime, Nsqrt, Factors) ->
case N rem Prime of
0 ->
%%io:format("factor ------- ~p\n", [Prime]),
N1 = N div Prime,
factors(Primes, N1, Prime, trunc(math:sqrt(N1)), [Prime|Factors]);
_ ->
Primes1 = Primes ++ [Prime],
Prime1 = next_prime(Primes1, Prime),
factors(Primes1, N, Prime1, Nsqrt, Factors)
end.
%%% Prime factors using Rho's algorithm ("reminded" from wikipedia.org)
%%% (should perhaps have used Brent instead, but it's not as readable)
rho_pseudo(X, C, N) ->
(X * X + C) rem N.
rho(N) when N > 1000 ->
case rho(2, 2, 1, N, fun(X) -> rho_pseudo(X, 1, N) end) of
failure ->
[N];
F ->
lists:sort(rho(F) ++ rho(N div F))
end;
rho(N) ->
factors(N).
rho(X, Y, 1, N, Pseudo) ->
X1 = Pseudo(X),
Y1 = Pseudo(Pseudo(Y)),
D = gcd(absdiff(X1, Y1), N),
rho(X1, Y1, D, N, Pseudo);
rho(_X, _Y, D, N, _Pseudo) when 1 < D, D < N ->
D;
rho(_X, _Y, D, N, _Pseudo) when D == N ->
failure.
absdiff(A, B) when A > B ->
A - B;
absdiff(A, B) ->
B - A.
%%% nthtail as in lists, but no badarg if n > the length of list
nthtail(0, A) -> A;
nthtail(N, [_ | A]) -> nthtail(N-1, A);
nthtail(_, _) -> [].
