Unit2 - Subjective Questions

In Linux, standard permissions (r, w, x) behave differently depending on whether the target is a file or a directory:

1. Read (r)

• For Files: Allows the contents of the file to be opened and read (e.g., using cat or a text editor).
• For Directories: Allows the user to list the contents of the directory (e.g., using ls). However, without execute permission, metadata details cannot be accessed.

2. Write (w)

• For Files: Allows the user to modify the file's contents (save changes). It does not automatically allow deleting the file (that depends on the parent directory's permissions).
• For Directories: Allows the user to create, delete, and rename files within that directory. This is a powerful permission as it allows deleting files even if the user does not have write permission on the file itself.

3. Execute (x)

• For Files: Allows the file to be run as a program or script.
• For Directories: Allows access to enter (cd) the directory and access files/inodes within it. Without this, you cannot enter the directory even if you have read permissions.

The chmod command changes file mode bits. In the Octal method, permissions are represented by numbers:

• Read (r) = 4
• Write (w) = 2
• Execute (x) = 1
• No permission = 0

The sum of these numbers represents the permission set for the User (u), Group (g), and Others (o).

Syntax: chmod [octal_value] filename

Examples:

1. Full Permissions for User, Read/Execute for Group/Others:

   • User:
   • Group:
   • Others:
   • Command: chmod 755 filename

2. Read/Write for User, Read-only for Group, No access for Others:

   • User:
   • Group: $4$
   • Others: $0$
   • Command: chmod 640 filename

Definition: umask (User File Creation Mode Mask) determines the default permissions assigned to newly created files and directories. It works by subtracting permissions from the system base default.

Base Defaults:

• Files: 666 (rw-rw-rw-) — Files are not created with execute permissions by default for security.
• Directories: 777 (rwxrwxrwx)

Calculation for umask 022:

1. For Directories:

   • Base: $777$
   • Umask: $022$
   • Result:
   • Permissions: User (rwx), Group (r-x), Others (r-x).

2. For Files:

   • Base: $666$
   • Umask: $022$
   • Result:
   • Permissions: User (rw-), Group (r--), Others (r--).

Special permissions provide additional functionality beyond standard rwx.

1. Set User ID (SUID)

• Function: When applied to an executable file, it runs with the permissions of the file owner rather than the user who executes it (e.g., passwd command).
• Symbolic: Appears as an s in the user execute position (e.g., rwsr-xr-x).
• Numeric Value: 4000

2. Set Group ID (SGID)

• Function on Files: Runs with the permissions of the file's group.
• Function on Directories: New files created inside inherit the directory's group ownership, not the creator's primary group. Used for shared folders.
• Symbolic: Appears as an s in the group execute position (e.g., rwxr-sr-x).
• Numeric Value: 2000

3. Sticky Bit

• Function: Applied to directories (like /tmp). Ensures that only the file owner, directory owner, or root can delete or rename files within that directory, preventing users from deleting each other's files.
• Symbolic: Appears as a t in the others execute position (e.g., rwxrwxrwt).
• Numeric Value: 1000

Hard Links and Soft Links are methods to reference files, but they function differently:

Access Control Lists (ACLs) provide a more flexible permission mechanism than the standard User-Group-Others model. They allow assigning permissions to specific individual users or groups that are not the owner or the primary group.

1. Viewing ACLs (getfacl):
Displays the file name, owner, group, and the Access Control List.

• Syntax: getfacl filename
• Output: Shows lines like user:alice:rw- indicating specific user permissions.

2. Setting ACLs (setfacl):
Used to modify the ACL entries.

• Syntax: setfacl -m [u/g]:[name]:[perms] filename
• Example: Give user 'bob' read and write access to 'file.txt':
  setfacl -m u:bob:rw file.txt
• Remove ACL: setfacl -x u:bob file.txt
• Remove all ACLs: setfacl -b file.txt

The FHS defines the directory structure of Linux:

• /etc: Contains system-wide configuration files and shell scripts used to boot the system. No binary programs should be stored here (e.g., /etc/passwd, /etc/ssh/sshd_config).
• /var: Contains variable data files that change while the system is running. This includes log files (/var/log), spool files for printers/mail (/var/spool), and temporary files preserved between reboots.
• /home: Contains the home directories for all regular users. Personal files, settings, and documents are stored here (e.g., /home/john).
• /bin: Contains essential user binary executables (programs) required for booting and repairing the system in single-user mode (e.g., ls, cp, cat).
• /dev: Contains special device files that represent hardware components (e.g., /dev/sda for hard drive, /dev/tty for terminals).

Definition: An inode (Index Node) is a data structure on a Linux filesystem that stores all the metadata about a file except its name and its actual data content.

Information Stored in an Inode:

1. File Type: (Regular file, directory, link, etc.)
2. Permissions: (Read, Write, Execute for U/G/O)
3. Ownership: User ID (UID) and Group ID (GID)
4. File Size: Size in bytes.
5. Timestamps: Access time (atime), Modification time (mtime), and Change time (ctime).
6. Link Count: Number of hard links pointing to the inode.
7. Data Block Pointers: Addresses of the physical disk blocks where the file content is stored.

The find command searches for files in a directory hierarchy based on various criteria.

Syntax: find [path] [options] [expression]

Examples:

1. Find by Name:

   • Find all files named "report.txt" in the /home directory.
   • find /home -name "report.txt"
   • (Use -iname for case-insensitive search).

2. Find by Size:

   • Find files larger than 100MB in the current directory.
   • find . -size +100M

3. Find by Modification Time:

   • Find files modified in the last 7 days in /var/log.
   • find /var/log -mtime -7

4. Find by Type:

   • Find only directories inside /tmp.
   • find /tmp -type d

1. Locate:

• Mechanism: Searches a pre-built database (mlocate.db) of files on the system.
• Speed: Extremely fast, as it reads a database file rather than scanning the hard drive.
• Accuracy: Can be inaccurate (outdated). If a file was created recently but the database hasn't been updated (usually via updatedb), locate won't find it. Conversely, it might list deleted files.

2. Find:

• Mechanism: Scans the live file system hierarchy in real-time.
• Speed: Slower, especially for large file systems, as it traverses directories physically.
• Accuracy: Always accurate. It reflects the current state of the file system immediately.

Vim operates in three primary modes:

1. Command Mode (Normal Mode):

• Purpose: The default mode for navigation, copying, deleting, and pasting text. Keys act as commands.
• Entry: Press Esc from any other mode.
• Actions: x (delete char), dd (delete line), yy (copy line), p (paste).

2. Insert Mode:

• Purpose: Used for typing and editing text content.
• Entry: From Command mode, press i (insert before cursor), a (append after cursor), or o (open new line below).
• Exit: Press Esc to return to Command Mode.

3. Last Line Mode (Ex Mode):

• Purpose: Used for saving files, exiting, searching, and configuring the environment.
• Entry: From Command mode, press : (colon).
• Actions: :w (save), :q (quit), :wq (save and quit), :q! (force quit without saving), /pattern (search).

1. chown (Change Owner):

• Purpose: Changes the user ownership (and optionally group ownership) of a file or directory.
• Syntax: chown [new_owner] [filename]
• Combined Syntax: chown [user]:[group] [filename]
• Example: chown alice report.txt (Changes owner to alice). chown alice:developers report.txt (Changes owner to alice and group to developers).
• Recursive: chown -R alice /data (Applied to directory and contents).

2. chgrp (Change Group):

• Purpose: Changes only the group ownership of a file or directory.
• Syntax: chgrp [new_group] [filename]
• Example: chgrp managers sales_data.txt
• Recursive: chgrp -R managers /data/sales

Wildcards (file globbing) are special characters used by the shell to match patterns of filenames.

• *Asterisk (``):**

  • Matches zero or more characters.
  • Example: ls *.txt lists all files ending in .txt. rm data* removes all files starting with "data".

• Question Mark (?):

  • Matches exactly one arbitrary character.
  • Example: ls file?.txt matches file1.txt, fileA.txt, but not file10.txt.

• Square Brackets ([]):

  • Matches one character from a specified range or set.
  • Example: ls file[1-3].txt matches file1.txt, file2.txt, and file3.txt. ls [Aa]*.txt matches files starting with A or a.

The ls command lists directory contents.

• ls -l (Long Listing):

  • Displays detailed information including permissions, link count, owner, group, size (in bytes), modification date, and filename.
  • Example Output: -rw-r--r-- 1 user group 4096 Jan 1 12:00 file.txt

• ls -a (All):

  • Shows all files, including hidden files (those starting with a dot .), such as .bashrc.

• ls -h (Human Readable):

  • Must be used with -l or -s. Converts file sizes from bytes to KB, MB, GB (e.g., shows 4.0K instead of 4096).

• ls -R (Recursive):

  • Lists the contents of the current directory and all subdirectories recursively.

grep (Global Regular Expression Print) searches for a specific string or pattern within text files and outputs the lines containing the match.

Basic Syntax: grep [pattern] [file]

Common Options & Examples:

1. Standard Search:

   • grep "error" /var/log/syslog (Prints lines containing "error").

2. Case-Insensitive Search (-i):

   • Ignores case distinctions (matches "Error", "ERROR", "error").
   • grep -i "failed" auth.log

3. Recursive Search (-r or -R):

   • Searches all files in the specified directory and its subdirectories.
   • grep -r "config" /etc/

4. Invert Match (-v):

   • Prints lines that do not match the pattern.
   • grep -v "#" config.txt (Displays lines that are not comments).

1. cp (Copy):

• Function: Creates a duplicate of the source file/directory at the destination. The original file remains unchanged.
• Syntax: cp source destination
• Flag: Use -r to copy directories recursively.

2. mv (Move):

• Function: Moves a file/directory from one location to another. Also used for Renaming files if the destination is in the same directory but has a different name.
• Syntax: mv source destination
• Note: The original file is removed from the source location.

3. rm (Remove):

• Function: Deletes files or directories. In Linux, this is often permanent (no Recycle Bin via command line).
• Syntax: rm filename
• Flags: -r for directories, -f to force delete without confirmation.

1. head:

• Purpose: Outputs the beginning part of files.
• Default: Shows the first 10 lines.
• Custom: head -n 5 file.txt (Shows first 5 lines).

2. tail:

• Purpose: Outputs the end part of files.
• Default: Shows the last 10 lines.
• Custom: tail -n 20 file.txt (Shows last 20 lines).

Real-time Monitoring (-f):

• Using the -f (follow) option allows an administrator to view lines appended to a file in real-time. This is essential for troubleshooting logs.
• Command: tail -f /var/log/syslog
• As new log entries are written by the system, they immediately appear on the screen.

The string drwxr-xr-- represents the file type and permission settings.

It is broken down into 4 parts (1 char + 3 sets of 3):

1. File Type (1st character):

   • d: Indicates this is a Directory.
   • (- would indicate a regular file, l a symbolic link).

2. User/Owner Permissions (Next 3 chars - rwx):

   • r: Read enabled.
   • w: Write enabled.
   • x: Execute enabled.
   • Interpretation: The owner can read, modify, and enter the directory.

3. Group Permissions (Next 3 chars - r-x):

   • r: Read enabled.
   • -: Write disabled.
   • x: Execute enabled.
   • Interpretation: Group members can list and enter the directory but cannot create/delete files in it.

4. Others Permissions (Last 3 chars - r--):

   • r: Read enabled.
   • -: Write disabled.
   • -: Execute disabled.
   • Interpretation: Everyone else can list the contents but cannot enter the directory or modify it.

Redirection changes the source of input or the destination of output for commands.

1. Standard Output Redirection (>):

   • Redirects output to a file, overwriting existing content.
   • ls > filelist.txt

2. Append Output Redirection (>>):

   • Redirects output to a file, appending to the end of existing content.
   • date >> log.txt

3. Standard Input Redirection (<):

   • Feeds the contents of a file into a command as input.
   • wc -l < file.txt (Counts lines in file.txt).

4. Standard Error Redirection (2>):

   • Redirects error messages (File Descriptor 2) to a file instead of the screen.
   • ls /nonexistent_folder 2> errors.log

1. wc (Word Count):

• Counts newlines, words, and bytes in a file.
• Options: -l (lines), -w (words), -c (bytes).
• Example: wc -l file.txt returns the line count.

2. cut:

• Extracts specific sections from each line of a file.
• Options: -d (delimiter), -f (field number).
• Example: cut -d ":" -f 1 /etc/passwd extracts the first field (usernames) separated by colons.

3. sort:

• Sorts lines of text files.
• Options: -n (numeric sort), -r (reverse order), -u (unique, removes duplicates).
• Example: sort -n numbers.txt sorts a list of numbers in ascending order.