Unit 1: Linux Command Line and User Management - Subjective Questions

The Linux command line is a text-based interface used to execute commands and administer the system.

• Local console: A user can access a virtual terminal directly from the machine, usually by pressing a key combination such as Ctrl+Alt+F3. The user then logs in with a username and password. This method is useful when the graphical interface is unavailable.
• Desktop environment: A terminal emulator, such as GNOME Terminal, can be opened from the graphical desktop. It provides command-line access while allowing the user to continue using graphical applications.
• Main differences:
  • A local console does not require a graphical interface.
  • A desktop terminal runs within the graphical environment.
  • Both provide access to shells, commands, files, and system-management tools.

The local console is more suitable for system recovery, while a desktop terminal is convenient for everyday administration.

Bash is a command interpreter that reads commands entered by the user and executes them.

A typical command has the following structure:

command [options] [arguments]

• The shell prompt indicates that Bash is ready to accept input. For example, $ commonly represents a normal user, while # generally represents the root user.
• The command specifies the program to run, such as ls or pwd.
• Options modify command behavior. They commonly begin with - or --, such as ls -l.
• Arguments identify the objects on which the command operates, such as a file or directory.
• Bash searches directories listed in the PATH environment variable to locate commands.
• After execution, the command returns an exit status. A status of 0 usually means success, while a nonzero value indicates an error.

Bash also supports variables, pipes, redirection, wildcards, command history, and tab completion.

The Linux File System Hierarchy organizes files and directories in a tree structure that begins at the root directory, /.

• /: The top-level directory containing all other filesystems and directories.
• /home: Contains personal directories and files belonging to ordinary users.
• /etc: Stores system-wide configuration files.
• /var: Contains variable data, including logs, mail queues, caches, and spool files.
• /usr: Contains most user programs, libraries, documentation, and shared read-only data.
• /tmp: Stores temporary files created by applications and users. Its contents may be removed automatically.
• /root: The home directory of the root, or superuser, account.

Other important directories include /bin for essential commands, /dev for device files, /proc for process and kernel information, and /boot for boot-related files. Understanding this hierarchy helps administrators locate configuration files, user data, programs, and logs.

A pathname identifies the location of a file or directory.

• An absolute pathname starts from the root directory / and specifies the complete location. It does not depend on the user's current working directory. For example:
  • /home/student/notes.txt
  • /etc/ssh/sshd_config
• A relative pathname starts from the current working directory. It does not begin with /. For example, if the current directory is /home/student, then notes.txt refers to /home/student/notes.txt.
• . represents the current directory.
• .. represents the parent directory.

For example, cd /var/log always changes to the same directory, whereas cd ../admin depends on the current location. Absolute paths are reliable in scripts and administrative commands, while relative paths are shorter and convenient for interactive work.

Linux provides several commands for locating files by name.

• The find command searches directories in real time. Example:
  • find /home -name "report.txt"
  • find /var -type f -name "*.log"
• The locate command searches a prebuilt database of file paths. Example:
  • locate report.txt

Comparison:

• find searches the current filesystem directly, so it can locate recently created files.
• find supports conditions such as file type, owner, permissions, size, and modification time.
• locate is usually faster because it searches an indexed database.
• locate may not find files created after the database was last updated.
• Access restrictions may prevent either command from displaying certain paths.

Administrators should use find when accuracy and advanced conditions are required, and locate when a quick name-based search is sufficient.

Common file-management tools include:

• touch file.txt: Creates an empty file or updates its timestamp.
• mkdir project: Creates a directory.
• cp source.txt backup.txt: Copies a file.
• cp -r source_dir destination_dir: Recursively copies a directory.
• mv oldname.txt newname.txt: Moves or renames a file.
• rm file.txt: Deletes a file.
• rm -r directory: Deletes a directory and its contents recursively.
• rmdir emptydir: Removes an empty directory.
• ls: Lists directory contents.
• file filename: Identifies the type of a file.

The -i option can request confirmation before overwriting or deleting, while -v often displays the operation being performed. Administrators should verify pathnames carefully before using commands such as rm, especially with recursive or superuser privileges.

Bash performs pathname expansion, also called globbing, before executing a command. It replaces patterns with matching filenames.

• * matches any sequence of characters, including an empty sequence. Example: ls *.txt lists files ending in .txt.
• ? matches exactly one character. Example: ls file?.log matches file1.log but not file10.log.
• Bracket expressions match one character from a set or range. Examples:
  • file[12].txt matches file1.txt and file2.txt.
  • file[a-c].txt matches files containing a, b, or c in that position.
• A leading dot is usually not matched by * unless the pattern explicitly begins with ..

Pathname expansion is performed by the shell on filenames. Regular expressions are pattern languages used by tools such as grep, sed, and awk, and they have different rules and purposes.

Shell expansion allows Bash to replace special expressions with values before a command runs.

• Tilde expansion: ~ expands to the current user's home directory, while ~user refers to another user's home directory.
• Variable expansion: $HOME is replaced by the value of the HOME variable.
• Command substitution: $(date) replaces the expression with the output of the date command.
• Pathname expansion: Wildcards such as *.conf are expanded to matching filenames.

Quoting controls expansion:

• Single quotes: '${HOME}' preserve the characters literally; no variable or command substitution occurs.
• Double quotes: "$HOME" allow variable and command substitution but prevent word splitting and pathname expansion in the resulting value.
• Backslash: \ can escape the special meaning of the next character.

Correct quoting is important when filenames or variable values contain spaces, wildcard characters, or shell metacharacters.

Red Hat Enterprise Linux provides several documentation sources.

• The man command displays manual pages. For example, man ls opens the manual for ls. Manual pages are organized into sections, such as section 1 for user commands and section 5 for file formats. man 5 passwd specifically opens the password-file documentation.
• The pinfo command provides an interface for reading GNU Info documentation. It is useful for software whose documentation is organized as linked nodes rather than traditional manual pages.
• The /usr/share/doc directory contains package-specific documentation such as README files, examples, changelogs, and licensing information.
• Commands such as apropos keyword or man -k keyword search manual-page descriptions.

An administrator should begin with man for command syntax, use pinfo for detailed GNU documentation, and inspect /usr/share/doc for package-specific guidance and examples.

Red Hat provides multiple sources of technical assistance.

• Installed documentation: Manual pages, Info pages, package documentation, command help options, and configuration examples are available locally.
• Red Hat product documentation: Official online documentation explains installation, configuration, security, networking, storage, and system administration procedures for specific releases.
• Red Hat Knowledgebase: Subscribers can search solutions, known issues, technical articles, and troubleshooting procedures.
• Red Hat support cases: Customers with an applicable subscription can submit support cases and provide logs, configuration details, and diagnostic information.
• Community resources: Red Hat-related forums and project documentation can help with general questions, but official documentation should be preferred for supported procedures.

A good troubleshooting process is to identify the exact product version, reproduce the issue, inspect logs and error messages, consult local and official documentation, and then contact support with precise diagnostic information when necessary.

Text files can be managed using both commands and editors.

• touch file.txt creates an empty file.
• cat file.txt displays the complete contents of a short file and can combine multiple files.
• less file.txt displays a file page by page and supports searching and navigation. It is more suitable for large files.
• head file.txt displays the first lines, while tail file.txt displays the last lines.
• tail -f /var/log/messages can follow a log file as new lines are added.
• A shell editor such as vim or nano allows the user to create and modify text interactively.
• Output redirection can create a file from command output, for example, ls > listing.txt.

These tools are especially useful for inspecting logs, editing configuration files, and creating scripts when a graphical interface is unavailable.

Linux commands normally use standard input, standard output, and standard error.

• > redirects standard output to a file and overwrites the file if it exists:
  • ls -l > listing.txt
• >> appends standard output to a file:
  • date >> system.log
• 2> redirects standard error:
  • find / -name "config" 2> errors.txt
• &> redirects both standard output and standard error in Bash:
  • command &> result.txt
• A pipe, written as |, sends the output of one command directly to another command:
  • ps aux | less
  • grep "failed" /var/log/messages | wc -l

Redirection stores or transfers data, while a pipe connects commands into a processing sequence. Careful use of > is important because it can destroy existing file contents.

Text files can be edited through terminal-based editors or graphical editors.

Shell-based editing:

• Editors such as vim, vi, and nano run in a terminal.
• They work over remote connections and when no graphical environment is available.
• They are suitable for server configuration, scripts, and emergency recovery.
• vim provides powerful navigation, searching, macros, and automation but has a steeper learning curve.
• nano is simpler but provides fewer advanced features.

Graphical editing:

• Editors such as GNOME Text Editor provide menus, mouse support, syntax highlighting, and convenient text selection.
• They are easier for many beginners and useful for general document editing.
• They require a working graphical session and may not be available on remote or minimal servers.

Administrators should use a terminal editor for remote or recovery work and a graphical editor when convenience and desktop integration are more important.

Linux identifies users and groups numerically and symbolically.

• A user account represents an individual or service that can access the system.
• Each user has a unique UID, or user ID.
• A group is a collection of users used to manage shared access.
• Each group has a unique GID, or group ID.
• Every file has an owning user and an owning group.
• File permissions are defined for the owner, group, and other users.

For example, permissions such as -rw-r----- mean that the owner can read and write, members of the owning group can read, and all other users have no access. A user's primary group is associated with the account by default, while supplementary groups provide additional access. This model allows administrators to grant access to teams without assigning permissions individually to every user.

The superuser, commonly called root, has unrestricted control over the system.

• su - starts a login shell as root after authenticating with the root password. The - loads root's login environment.
• sudo command runs a single command with elevated privileges after authenticating according to the sudo policy.
• sudo -i starts an interactive root login shell when a complete administrative session is required.

Comparison:

• su changes the current identity and generally requires the root password.
• sudo grants controlled, logged, and often temporary privilege to authorized users.
• sudo supports fine-grained policies, allowing specific users to run selected commands.

Superuser commands can modify or delete critical system files, change permissions, or affect all users. Administrators should use the least privilege necessary, verify commands carefully, and avoid using root for routine activities.

Local user accounts are stored and managed on the individual Linux system.

• useradd username creates a user account. Options can specify the home directory, login shell, UID, and supplementary groups.
• usermod modifies an existing account. For example, usermod -aG developers alice adds alice to the developers supplementary group. The -a option is important because it preserves existing supplementary groups.
• userdel username removes an account. userdel -r username also removes the user's home directory and mail spool, so it must be used carefully.

Important account properties include the username, UID, primary group, supplementary groups, home directory, login shell, password status, and account expiration information. After creating a user, an administrator normally assigns a password and verifies ownership and group membership. Account changes should follow organizational security and naming policies.

Groups simplify the management of shared permissions.

• groupadd groupname creates a local group.
• groupmod changes group properties, such as its name or GID.
• groupdel groupname deletes a group, provided it is not the primary group of an existing user.
• usermod -aG groupname username adds a user to a supplementary group.
• gpasswd -d username groupname can remove a user from a supplementary group.
• id username displays the user's UID, primary GID, and supplementary groups.

The primary group is the default group associated with a user's new files and processes. A user can belong to multiple supplementary groups, which provide additional permissions to shared resources. Group membership changes may require the user to log out and log back in before the new group information appears in the session.

The passwd command is used to manage user passwords.

• A user can change their own password by running passwd.
• An administrator can set another user's password with sudo passwd username.
• passwd -l username locks a password, while passwd -u username unlocks it.
• passwd -e username forces the user to change the password at the next login.
• chage manages password aging, including minimum age, maximum age, warning period, and account expiration. For example, chage -l username displays aging information.

Password information is stored in protected form in /etc/shadow, while account information is commonly stored in /etc/passwd. Good practices include using long, unique passwords, enforcing suitable aging policies where required, avoiding shared accounts, locking inactive accounts, and protecting access to password databases.

These files contain core local account and group information.

• /etc/passwd contains one line per user. Important fields include username, a password placeholder such as x, UID, primary GID, comment or user information, home directory, and login shell.
• /etc/group contains group names, GIDs, and lists of supplementary group members.
• /etc/shadow stores password hashes and password-aging information, including the last password change, minimum and maximum age, warning period, and account expiration values.

The password hashes in /etc/shadow must be protected because they can be targeted for password cracking. Typically, /etc/passwd and /etc/group are readable by ordinary users so programs can resolve account information, while /etc/shadow is restricted to root and authorized system components. Administrators should use account-management commands instead of manually editing these files whenever possible.

A systematic diagnosis can proceed as follows:

1. Confirm the pathname and inspect the file:
   • ls -l /path/to/file
   • file /path/to/file
2. Check the user's identity and group membership:
   • id username
3. Examine each directory in the path because directory execute permission is required to traverse it:
   • namei -l /path/to/file
4. Compare the file's owner and group with the user's UID and groups.
5. Interpret the permission bits for owner, group, and others.
6. Check for special access controls if ordinary permissions appear correct, such as ACLs using getfacl.
7. Test access as the affected user rather than assuming the administrator's access is equivalent.
8. If authorized, use sudo for the required operation and record the reason.

The administrator should correct the ownership, group membership, or permissions with appropriate commands such as chown, chgrp, or chmod, while granting only the minimum required access.