File Coverage

blib/lib/Terminal/Identify.pm

Criterion	Covered	Total	%
statement	139	206	67.4
branch	21	64	32.8
condition	13	24	54.1
subroutine	20	23	86.9
pod	0	16	0.0
total	193	333	57.9

package Terminal::Identify;

# Load the basic Perl pragmas.
use 5.010100;
use strict;
use warnings;

# Load the Perl pragma Exporter.
use vars qw(@ISA @EXPORT @EXPORT_OK);
use Exporter 'import';

# Export the implemented subroutines and the global variable.
our @EXPORT = qw(
    whichterminalami
    whichtermami
    which_terminal
    identify_terminal
    terminal_identify
    $OutputFormat
);

# Base class of this module.
our @ISA = qw(Exporter);

# Set the package version.
our $VERSION = '0.29';

# Load the Perl modules.
use POSIX qw(ttyname);

# Set the global output format.
our $OutputFormat = "";

# Set the global term hash variable.
our %termhash = ();

# Define the Perl BEGIN block.
BEGIN {
    # Set the subroutine aliases.
    *whichtermami = \&whichterminalami;
    *which_terminal = \&whichterminalami;
    *identify_terminal = \&whichterminalami;
    *terminal_identify = \&whichterminalami;
};

# ++++++++++++++++++++++++++++++++
# Perform some preliminary checks.
# ++++++++++++++++++++++++++++++++

# Check if the operating system is Windows.
if ($^O eq "MSWin32") {
    # Print a message into the terminal window.
    print "This module works not on Windows. Bye.\n";
    # Exit the script with error code 1.
    exit 1;
};

# Check if the Linux command 'which' exists.
my $exitcode = system("which which > /dev/null 2>&1");
if ($exitcode != 0) {
    # Print a message into the terminal window.
    print "The Linux command 'which' does not exist. Bye.\n";
    # Exit the script with error code 2.
    exit 1;
};

# Check if the Linux command 'grep' exists.
if (!defined `which grep 2>/dev/null` || `which grep 2>/dev/null` eq "") {
    # Print a message into the terminal window.
    print "The Linux command 'grep' does not exist. Bye.\n";
    # Exit the script with error code 3.
    exit 3;
};

# Check if the Linux command 'users' exists.
if (!defined `which users 2>/dev/null` || `which users 2>/dev/null` eq "") {
    # Print a message into the terminal window.
    print "The Linux command 'grep' does not exist. Bye.\n";
    # Exit the script with error code 4.
    exit 4;
};

# Check if the Linux command 'ps' exists.
if (!defined `which ps 2>/dev/null` || `which ps 2>/dev/null` eq "") {
    # Print a message into the terminal window.
    print "The Linux command 'ps' does not exist. Bye.\n";
    # Exit the script with error code 5.
    exit 5;
};

# Set some variables.
our $FN_PASSWD = "/etc/passwd";
our $FN_SHELLS = "/etc/shells";

# Check if passwd exists.
if (! -e $FN_PASSWD) {
    die "$!, $FN_PASSWD not exists.\n";
};

# Check if shells exists.
if (! -e $FN_SHELLS) {
    die "$!, $FN_SHELLS not exists.\n";
};

# ++++++++++++++++++++++++++++++++++++++++++
# Create a dictionary from __DATA__ section.
# ++++++++++++++++++++++++++++++++++++++++++

# Initialise some variables.
my $line = "";
my $key = "";
my $value = "";

# Read data from __DATA__ section.
while () {
    # Read data only between the two given boundaries.
    if (/# Begin terminals/../# End terminals/) {
        next if /# Begin terminals/ || /# End terminals/;
        $line = $_;
        my @parts = split /=>/, $line, 2;
        $key = $parts[0];
        $key =~ s/^\s+|\s+$//g;
        $value = $parts[1];
        $value =~ s/^\s+|\s+$//g;
        $termhash{$key} = $value;
    };
};

# ============================================================================ #
# Subroutine trim                                                              #
#                                                                              #
# Description:                                                                 #
# The subroutine removes white spaces from both ends of a string. This is done #
# by a logical or operation and using \s from regular expressions. Anchors are #
# begin ^ of string and end $ of string.                                       #
#                                                                              #
# @argument: $_[0] => $string  String to trim  (scalar)                        #
# @return:   $string           Trimmed string  (scalar)                        #
# ============================================================================ #
sub trim {
    # Assign the function argument to the local string variable $str.
    my $string = ((defined $_[0] && $_[0] ne "") ? $_[0] : "");
    # Trim the string from the left side and the right side.
    $string =~ s/^\s+|\s+$//g;
    # Return the trimmed string.
    return $string;
};

# ============================================================================ #
# Subroutine search_brackets                                                   #
#                                                                              #
# Description:                                                                 #
# The subroutine adds the square brackets [ and ] to the searchstring for      #
# use with grep. E.g. shell becomes [s]hell. Therefor the string must have     #
# a minumum length of 1.                                                       #
#                                                                              #
# @argument: $_[0] => $str  Searchstring                       (scalar)        #
# @return:   $str           Searchstring with square brackets  (scalar)        #
# ============================================================================ #
sub search_brackets {
    # Initialise the local variable $searchstring.
    my $searchstring = "";
    # Check if $searchstring is defined and is not empty.
    if ((defined $_[0]) && (length($_[0]) > 0)) {
        # Assign the subroutine argument to the local variable.
        $searchstring = $_[0];
    } else {
        # Return string of length 0.
        return "";
    }
    # Add square brackets [ and ] to the given string.
    substr($searchstring, 0, 0) = '[';
    substr($searchstring, 2, 0) = ']';
    # Return the modified string.
    return $searchstring;
};

# ============================================================================ #
# Subroutine read_file                                                         #
#                                                                              #
# Description:                                                                 #
# Read the complete content of a file in one chunk. The retrieved content is   #
# stored in a string variable.                                                 #
#                                                                              #
# @argument: $_[0] => $file  Text filename  (scalar)                           #
# @return:   $content        File content   (scalar)                           #
# ============================================================================ #
sub read_file {
    # Assign the function argument to the local variable.
    my $file = $_[0];
    # Initialise the return variable.
    my $content = "";
    # If file not exists, return an empty string.
    if (-f $file) {
        # Open a file handler for reading the file.
        open(my $fh, "<", $file);
        # Read the complete content from the file.
        $content = do {local $/; <$fh>};
        # Close the file handler.
        close($fh);
    };
    # Return the file content.
    return $content;
};

# ============================================================================ #
# Subroutine login_users                                                       #
#                                                                              #
# Description:                                                                 #
# Split the logged-in users by sperator space and store them to an array.      #
#                                                                              #
# @argument: None                                                              #
# @return:   $user_arr  Array with the logged-in users  (array)                #
# ============================================================================ #
sub login_users {
    # Initialise the return array.
    my @user_array = ();
    # Get the logged-in users from the Linux command users.
    my $user = `users`;
    # Check if the variable $user is defined and not empty.
    if (defined $user && $user ne "") {
        # Split the logged-in users and store them to the array.
        @user_array = split ' ', $user;
    };
    # Return the array with the logged-in users.
    return @user_array;
};

# ============================================================================ #
# Subroutine login_shells                                                      #
#                                                                              #
# Description:                                                                 #
# Read the content of the file /etc/shells and store the content in a string   #
# variable. Then the content is splited up into lines. In a loop the lines     #
# are used where a valid login shell is given. Then the path is removed from   #
# the line with the login shell. The login shell is added to an array. In a    #
# last step douple entries are removed from the array.                         #
#                                                                              #
# @argument: None                                                              #
# @return:   @login_shells  Array with valid login shells  (array)             #
# ============================================================================ #
sub login_shells {
    # Declare the login shells array.
    my @login_shells;
    # Set the file for reading.
    my $file = $FN_SHELLS;
    # Read the content from the file.
    my $content = read_file($file);
    # Loop over the lines of the file content.
    foreach (split '\n', $content) {
        # Trim the new line.
        my $line = trim($_);
        # Use only a line with a valid login shell.
        if ($line =~ /^\/.*\/(.*)$/) {
            # Remove the path from the line with the login shell.
            my ($shell) = $line =~ /^\/.*\/(.*)$/;
            # Add the login shell to the array.
            push(@login_shells, $shell);
        };
    };
    # Remove the double entries from the array.
    my %login_hash = map({$_, 1} @login_shells);
    @login_shells = keys %login_hash;
    # Return the array with the unique login shells.
    return @login_shells;
};

# ============================================================================ #
# Subroutine get_ppid                                                          #
#                                                                              #
# Description:                                                                 #
# Determine the PPID of the calling Perl script using the Linux command ps.    #
#                                                                              #
# @argument: $_[0] => $pid  PID   (scalar)                                     #
# @return:   $ppid          PPID  (scalar)                                     #
# ============================================================================ #
sub get_ppid {
    # Assign the subroutine argument to the local variable $pid.
    my $pid = $_[0];
    # Store the output of the Linux command ps in the local variable $ppid.
    my $ppid = `ps --no-headers -o ppid:1 -p $pid --sort lstart 2>/dev/null`;
    # Split a multiline Perl scalar with the PPID's in parts.
    my @parts = split /\s+/, $ppid;
    # If there is more than one PPID, use the first PPID.
    $ppid = $parts[0];
    # Trim the Perl scalar with the PPID.
    $ppid = trim($ppid);
    # Return the PPID.
    return $ppid;
};

# ============================================================================ #
# Subroutine get_termpath                                                      #
# ============================================================================ #
sub get_termpath {
    # Initialise the local variables.
    my $fileno = fileno(STDIN);
    my $term_path = "";
    # Get the terminal path.
    # $term_path = TermPath();
    $term_path = ttyname($fileno);
    # Check the terminal path
    $term_path = (defined $term_path ? $term_path : "");
    # Return the terminal path.
    return $term_path;
};

# ============================================================================ #
# Subroutine get_user_name                                                     #
# ============================================================================ #
sub get_username {
    # Initialise the username.
    my $username = "";
    # Define the methods for getting the username.
    my $method1 = getlogin();
    my $method2 = (getpwuid($<))[0];
    my $method3 = $ENV{LOGNAME};
    my $method4 = $ENV{USER};
    # Extract the username.
    $username = ($method1 || $method2 || $method3 || $method4);
    # Return the username.
    return $username;
};

# ============================================================================ #
# Subroutine term_user_shell                                                   #
#                                                                              #
# Description:                                                                 #
# Create a multi dimensional array with term, user and shell.                  #
#                                                                              #
# @arguments: $_[0] => $passwd_content  Content of passwd      (scalar)        #
#             @{$_[1]} => @user_array   User array             (array)         #
#             @{$_[2]} => @shell_array  Shell array            (array)         #
# @return:    @result_array             Array with the result  (array)         #
# ============================================================================ #
sub term_user_shell {
    # Assign the subroutine arguments to the local variables.
    my $passwd_content = $_[0];
    my @user_array = @{$_[1]};
    my @shell_array = @{$_[2]};
    # Initialise variable $term.
    my $term = "";
    # Get the username related to the terminal.
    my $username = get_username();
    # Declare the return array.
    my @result_array = ();
    # Get the terminal path.
    my $term_path = get_termpath();
    # If $term_path is not defined or empty set $term to ?.
    if (!defined $term_path || $term_path eq "") {
        # Set variable $term_path.
        $term = "?";
    } else {
        # Check on pts and tty.
        if ($term_path =~ /^.*\/dev\/(pts\/\d+)$/) {
            # Extract the pseudo terminal slave.
            ($term) = $term_path =~ /^.*\/dev\/(pts\/\d+)$/;
        } elsif ($term_path =~ /^.*\/dev\/(tty\d+)$/) {
            # Extract the terminal TeleTYpewriter.
            ($term) = $term_path =~ /^.*\/dev\/(tty\d+)$/;
        } else {
            $term = "?";
        };
    };
    # Loop over the array with the lines of $passwd_content.
    foreach (split '\n', $passwd_content) {
        # Get user and shell from each line of the content.
        my ($user) = $_ =~ /^(.*?):.*/;
        my ($shell) = $_ =~ /^.*\/(.*)$/;
        if ($shell ne "nologin" && $shell ne "sync" && $shell ne "false") {
            # Check user and shell against the given arrays.
            if (grep(/^$user$/, @user_array) &&
                grep(/^$shell$/, @shell_array)) {
                # Assemble a new list.
                my @tmp = ($term, $user, $shell);
                # Add data to array.
                push(@result_array, \@tmp);
            } elsif ($user eq $username) {
                # Assemble a new list.
                my @tmp = ($term, $user, $shell);
                # Add data to array.
                push(@result_array, \@tmp);
            };
        };
    };
    # Return the array.
    return @result_array;
};

# ============================================================================ #
# Subroutine terminal_process                                                  #
#                                                                              #
# Description:                                                                 #
# Get the process related to term, user and shell.                             #
#                                                                              #
# @argument: @{$_[0]} => @data  Array with term, user and shell  (array)       #
# @return:   @result            Array with matching processes    (array)       #
# ============================================================================ #
sub terminal_process {
    # Assign the subroutine argument to the local variable.
    my @data = @{$_[0]};
    # Initialise the return array.
    my @match = ();
    # Set command.
    my $ps_cmd = "ps aux --sort lstart 2>/dev/null";
    # Loop over the elements of the array.
    foreach my $item (@data) {
        # Get term, user and shell from the array.
        my $term = $item->[0];
        my $user = $item->[1];
        my $shell = $item->[2];
        $term = search_brackets($term);
        $user = search_brackets($user);
        $shell = search_brackets($shell);
        # Search for processes which is matching shell, user and terminal.
        my $grep_shell = "grep $shell 2>/dev/null";
        my $grep_user = "grep $user 2>/dev/null";
        my $grep_term = "grep $term 2>/dev/null";
        my $process = `${ps_cmd} | ${grep_shell} | ${grep_user} | ${grep_term}`;
        # Check if the result is not empty.
        if ($process ne "") {
            # Add the process to the return array.
            push(@match, $process);
        };
    };
    # If array @match is empty, it is not a local process.
    if (@match == 0) {
        # Loop over the elements of the array.
        foreach my $item (@data) {
            # Get term and user from the array.
            my $term = $item->[0];
            my $user = $item->[1];
            # Add square brackets to searchstrings.
            $term = search_brackets($term);
            $user = search_brackets($user);
            # Search for processes which is matching shell and terminal.
            my $grep_term = "grep $term 2>/dev/null";
            my $grep_user = "grep $user 2>/dev/null";
            my $process = `${ps_cmd} | ${grep_user} | ${grep_term} | grep "?" | grep "sshd"`;
            # Check if the result is not empty.
            if ($process ne "") {
                # Add the process to the return array.
                push(@match, $process);
            };
        };
    };
    # Return the array.
    return @match;
};

# ============================================================================ #
# Subroutine terminal_command_line                                             #
#                                                                              #
# Description:                                                                 #
# Use the Linux command ps to get the command line of the process which is     #
# related to the terminal in use.                                              #
#                                                                              #
# @argument  $_[0] => $ppid  PPID                   (scalar)                   #
# @return    $termproc       Terminal command line  (scalar)                   #
# ============================================================================ #
sub terminal_command_line {
    # Assign the subroutine argument to the local variable $ppid.
    my $ppid = $_[0];
    # Get the command column from the ps output.
    my $termproc = `ps --no-headers -o cmd:1 -p $ppid --sort lstart 2>/dev/null`;
    # Trim the command line output string.
    $termproc = trim($termproc);
    # Return the process related to the terminal in use.
    return $termproc
};

# ============================================================================ #
# Subroutine terminal_identifier                                               #
#                                                                              #
# Description:                                                                 #
# Identify the process command line of the terminal in use.                    #
#                                                                              #
# @argument: None                                                              #
# @return:   $terminal_command  Process command line  (scalar)                 #
# ============================================================================ #
sub terminal_identifier {
    # Declare the return variable $terminal_command.
    my $terminal_command;
    # Set the filename.
    my $filename = $FN_PASSWD;
    # Get the logged-in users.
    my @user_arr = login_users();
    # Get the available login shells.
    my @shell_arr = login_shells();
    # Read the file /etc/passwd in and store it in the variable $content.
    my $content = read_file($filename);
    # Create the array with user and shell.
    my @result = term_user_shell($content, \@user_arr, \@shell_arr);
    # check if @result is empty.
    if (@result == 0) {
        # Set terminal command.
        $terminal_command = "";
        # Return an empty string.
        return $terminal_command;
    };
    # Create the array with user and term.
    my @match = terminal_process(\@result);
    # Check if array is empty.
    if (@match > 0) {
        # Split up the process by lines and white spaces.
        my @columns = split /\s+/, $match[0];
        # Extract the PID from the array.
        my $pid = $columns[1];
        # Get the PPID from the command ps.
        my $ppid = get_ppid($pid);
        # Get the terminal in use from the command ps.
        $terminal_command = terminal_command_line($ppid);
    } else {
        # Set terminal command.
        $terminal_command = "";
    };
    # Return the terminal process command.
    return $terminal_command;
};

# ============================================================================ #
# Subroutine get_terminal_path                                                 #
# ============================================================================ #
sub get_terminal_path {
    # Assign the subroutine argument to the local variable.
    my $terminal_command = $_[0];
    # Initialise the return variable.
    my $terminal_path = "";
    # Define the regular expression for white spaces.
    my $re_ws = qr/\s+/;
    # Define the regular expression for command line arguments.
    my $re_args = qr/(?<= )(-.*?)(?= |$)/;
    # Check terminal command on white spaces.
    if ($terminal_command =~ /$re_ws/) {
        # Initialise the progs array.
        my @progs = ();
        # Assign terminal command to raw string.
        my $raw_string = $terminal_command;
        # Remove all terminal command line arguments.
        $raw_string =~ s/$re_args//g;
        # Split the terminal command line by white spaces.
        my @parts = split /$re_ws/, $raw_string;
        # Loop over the elements of the array.
        foreach (@parts) {
            # Check if the element is an executable.
            if (`which $_` ne "") {
                # Add executable to new array.
                push(@progs, $_);
            };
        };
        # Check number of executables.
        if (@progs == 0) {
            # Assign first element to path.
            $terminal_path = $parts[0];
        } else {
            if (@progs > 1) {
                # Assign first element to path.
                $terminal_path = $progs[1];
            } else {
                # Assign second element to path.
                $terminal_path = $progs[0];
            };
        };
    } else {
        # Set variable $terminal_path.
        $terminal_path = $terminal_command;
    };
    # Return the terminal name.
    return $terminal_path;
};

# ============================================================================ #
# Subroutine get_terminal_name                                                 #
# ============================================================================ #
sub get_terminal_name {
    # Assign the subroutine argument to the local variable.
    my $terminal_path = $_[0];
    # Initialise the return variable.
    my $terminal_name = "";
    # Define the regular expression for program pathes.
    my $re_pp = qr/^\/.*\//;
    # Check the variable $terminal_path on the existence of a path.
    if ($terminal_path =~ /$re_pp/) {
        # Remove the path from variable $terminal_path.
        $terminal_name = $terminal_path =~ s/$re_pp//r;
    } else {
        # Assign variable $terminal_path to variable $terminal_name.
        $terminal_name = $terminal_path;
    };
    # Return the terminal name.
    return $terminal_name;
};

# ============================================================================ #
# Subroutine get_terminal_ftn                                                  #
# ============================================================================ #
sub get_terminal_ftn {
    # Assign the subroutine argument to the local variable.
    my $terminal_name = $_[0];
    # Initialise the return variable.
    my $terminal_ftn = "";
    # Convert terminal name to lower case.
    $terminal_name = lc($terminal_name);
    # Check terminal name.
    if (defined $termhash{$terminal_name}) {
        # Get the friendly terminal name.
        $terminal_ftn = $termhash{$terminal_name};
    } else {
        # Set the friendly terminal name.
        $terminal_ftn = $terminal_name;
    };
    # Return the friendly terminal name.
    return $terminal_ftn;
};

# ============================================================================ #
# Subroutine whichterminalami                                                  #
#                                                                              #
# Description:                                                                 #
# Identify the terminal emulator.                                              #
#                                                                              #
# @argument: $_[0] => $flag  Output format flag  (scalar)                      #
# @return:   $terminal       Terminal name       (scalar)                      #
# ============================================================================ #
sub whichterminalami {
    # Initialise the output format flag variable.
    my $flag = "";
    # Set the output format flag.
    if ($OutputFormat ne "") {
        # Set the output format flag variable based on the global variable.
        $flag = $OutputFormat;
    } else {
        # Get the output format flag variable from the subroutine argument.
        $flag = (defined $_[0] ? $_[0] : '');
    };
    # Initialise the terminal variables.
    my $terminal = "";
    my $terminal_ftn = "";
    my $terminal_name = "";
    my $terminal_path = "";
    # Identify the terminal process command line.
    my $terminal_command = terminal_identifier();
    # If terminal process command line is an empty string it is an unknown terminal.
    if ($terminal_command eq "") {
        # Return unknown terminal.
        return "Unknown Terminal";
    };
    # Get the terminal path.
    $terminal_path = get_terminal_path($terminal_command);
    # Get the terminal name.
    $terminal_name = get_terminal_name($terminal_path);
    # Get the friendly terminal name.
    $terminal_ftn = get_terminal_ftn($terminal_name);
    # Return remote console or system console based on sshd or login.
    if (($terminal_name) =~ /^sshd.*/) {
        return "Remote Console";
    } elsif (($terminal_name) =~ /^login.*/) {
        return "System Console";
    };
    # Return the terminal string based on the flag setting.
    if ($flag eq "") {
        $terminal = $terminal_name;
    } elsif ($flag eq "FTN") {
        $terminal = $terminal_ftn;
    } elsif ($flag eq "PATH") {
        $terminal = $terminal_path;
    } elsif ($flag eq "PROC") {
        $terminal = $terminal_command;
    };
    # Return the found terminal string.
    return $terminal;
};

1;

__DATA__