---
# System prepended metadata

title: Linux
tags: [Linux]

---

# Linux 
###### tags: `Linux`
![](https://i.imgur.com/1g3PLMX.png)

Reference: https://ryanstutorials.net/linuxtutorial/


[TOC]

# Installation
The default package manager for:
* Centos is **yum**
* Debian/Ubuntu/Mint/Kali is **apt-get**

**Reference:** https://www.stechies.com/aptget-command-not-foundin-linux/

# pwd Command: Where are we?
We can check which folder we are in by using **pwd**
```linux===
root@zoo2:/apache-zookeeper-3.6.2-bin/bin# pwd

# Respond: 
/apache-zookeeper-3.6.2-bin/bin
```

# ls Command: What do we have?
If we use **ls**, it will show plain listing of our current location.
```linux===
root@bedbe2be73fe:/# ls

# Respond:
bin  boot  dev  etc  home  lib  lib32  lib64  libx32  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
```

## ls [options] [location]

### -l option
In the above example, the square brackets ( [ ] ) mean that those items are optional, we may run the command with or without them. 

By adding command line option **-l**, we indicated it should show a long listing.

**Example:**
```linux===
root@bedbe2be73fe:/# ls -l

# Respond:
total 48
lrwxrwxrwx   1 root root    7 Apr 16 05:11 bin -> usr/bin
drwxr-xr-x   2 root root 4096 Apr 15  2020 boot
drwxr-xr-x   5 root root  360 Apr 27 06:00 dev
drwxr-xr-x   1 root root 4096 Apr 27 06:00 etc
.
.
.
```

### Let's check each section of ls -l response!
* First character indicates whether it is a **normal file (-)** or **directory (d)**
* Next 9 characters are permissions for the file or directory
* The next field is the number of blocks
* The next field is the owner of the file or directory
* The next field is the group the file or directory belongs to
* Following this is the file size
* Next up is the file modification time.
* Finally we have the actual name of the file or directory.

> **drwxr-xr-x   2 root root 4096 Apr 15  2020 boot**
> It is a directory with permission rwxr-xr-x, that takes 2 blocks. Both owner and group belongs to root. This directory has file size of 4096 and was last modified in 2020 April 15. This directory is called boot. [color=#076080]

### ls [location]
When we ran ls with a command line argument (Example: /var ). When we do this it tells ls not to list our current directory but instead to list that directories contents.

**Example:**
```linux===
root@bedbe2be73fe:/# ls /var

# Respond:
backups  cache  lib  local  lock  log  mail  opt  run  spool  tmp
```

### ls -l [location]
We ran ls with both a command line option and argument. As such it did a long listing of the directory /var.

**Example:**
```linux===
root@bedbe2be73fe:/# ls -l /var

# Respond:
total 36
drwxr-xr-x 2 root root  4096 Apr 15  2020 backups
drwxr-xr-x 5 root root  4096 Apr 16 05:33 cache
drwxr-xr-x 1 root root  4096 Apr 16 05:11 lib
drwxrwsr-x 2 root staff 4096 Apr 15  2020 local
lrwxrwxrwx 1 root root     9 Apr 16 05:11 lock -> /run/lock
drwxr-xr-x 3 root root  4096 Apr 16 05:11 log
drwxrwsr-x 2 root mail  4096 Apr 16 05:11 mail
drwxr-xr-x 2 root root  4096 Apr 16 05:11 opt
lrwxrwxrwx 1 root root     4 Apr 16 05:11 run -> /run
drwxr-xr-x 2 root root  4096 Apr 16 05:11 spool
drwxrwxrwt 2 root root  4096 Apr 16 05:32 tmp
```

# Absolute and Relative Path
Before starting with the **2 types of path**, we have to understand **the linux file system hierarchical structure**.

## Linux File System Hierarchical Structure
The very top of structure, is what we called **root** directory. It is denoted by a slash(**/**). This one like any other directory, it will have subdirectories and so on.

## Absolute Path
This one will specify a location(file or directory) **in relation to the root directory**. This one will always **start with a forward slash(/)**.

## Relative Path
Specify a location (file or directory) **in relation to where we currently are in the system**. They **will NOT begin with a slash**.


## Absolute/Relative Path using ls 
We can either use **ls /absolutePath** or **ls relativePath**, but how we use it will differ.

Let's take below example a look:
>As we can see, we ran **ls alternatives** (Relative Path) in root directory at first, but **error: No such file or directory** was shown.
>[color=orange]
>However, if we move inside the **etc folder** by usind **cd folderName**, and retry the command, it works. Here we understand that relative path only works when you are in the right folder/location. Otherwise, you will not be able to run it.
>
>On the other hand, absolute path works anywhere, but if the location is deep inside, it takes too long to write the whole path. 

**Example:**
![](https://i.imgur.com/435tdrd.png)



## More about Paths
### ~(tilde) - ?? Directory

### .(dot) - Current Directory
. checks current directory
**Example:**
```linux===
root@bedbe2be73fe:/etc# ls ./alternatives

# Respond:
README  awk  nawk  pager  rmt  w
```


### ..(dotdot) - Parent Directory
.. Refers to parent, so when doing **ls ../../** means checking parent parent directory and list up.
**Example:**
```linux===
root@bedbe2be73fe:/etc/alternatives# ls ../../

# Respond:
bin  boot  dev  etc  home  lib  lib32  lib64  libx32  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
```
![](https://i.imgur.com/s5dabI4.png)

# Tools
## TAB completion
By using Tab, it can auto-complete names.
```linux===
[root@237409c00f01 /]# ls
anaconda-post.log  bin  dev  etc  home  lib  lib64  logs  media  mnt  nohup.out  opt  proc  root  run  sbin  scripts  srv  sys  tmp  usr  var
[root@237409c00f01 /]# vim an   (Before Press Tab)
[root@237409c00f01 /]# vim anaconda-post.log  (After)
```

## Quote 
```linux===
helloroot@bedbe2be73fe:/# cd 'home'
root@bedbe2be73fe:/home# pwd
/home
root@bedbe2be73fe:/home#
```

## man <command to look up>
### What is it for?
The manual(man) pages are a set of pages that explain every command available on your system including what they do, the specifics of how you run them and what command line arguments they accept. 

In order to access these manual pages, we use the so call **man** command.

**Note:**
>To exit the man pages press 'q' for quit. [color=red]

**Example:**
```linux===
root@bedbe2be73fe:/# man ls

# Respond:
NAME
       ls - list directory contents

SYNOPSIS
       ls [OPTION]... [FILE]...

DESCRIPTION
       List information about the FILEs (the current directory by default).  Sort entries alphabetically if none of -cftuvSUX nor --sort is specified.
.
.
.
```

### All **man commands**

>**man <command>**
// Look up the manual page for a particular command.[color=orange]

>**man -k <search term>**
Do a keyword search for all manual pages containing the given search term.[color=lightgreen]



### Install 'man' command if not found
```linux===
root@bedbe2be73fe:/# apt-get update
root@bedbe2be73fe:/# apt-get install man-db
```

# File
## Types of files

1. file.exe - an executable file, or program.
1. file.txt - a plain text file.
1. file.png, file.gif, file.jpg - an image.

## File Creation
Reference: https://linuxize.com/post/create-a-file-in-linux/
### **touch** Command
```linux===
root@bedbe2be73fe:/home# touch file1.txt file2.txt
root@bedbe2be73fe:/home# ls
file1.txt  file2.txt
```
### **cat > file** 
```linux===
root@bedbe2be73fe:/home# cat > file3.txt
hello (Pressed CTRL + D to save, CTRL + C to exit)
```

### Error: "bash: file: command not found"
```linux===
root@bedbe2be73fe:/# apt-get update
root@bedbe2be73fe:/# apt-get install file -y
```

## Remove file
Use **rm** to remove files.
```linux===
root@bedbe2be73fe:/home# ls
file2.txt  file3.txt  filedir

root@bedbe2be73fe:/home# rm file2.txt

root@bedbe2be73fe:/home# ls
file3.txt  filedir
```

# Directory
## Create Directory
Use **mkdir** to create directory.

```linux===
root@bedbe2be73fe:/home# ls
file3.txt  filedir
root@bedbe2be73fe:/home# mkdir test
root@bedbe2be73fe:/home# ls
file3.txt  filedir  test
```
## Remove Directory
Use **rmdir** to remove directory.
```linux===
root@bedbe2be73fe:/home# ls
file3.txt  filedir  test
root@bedbe2be73fe:/home# rmdir test
root@bedbe2be73fe:/home# ls
file3.txt  filedir
```

# Copying/Moving/Renaming File/Directory

> No matter what if it is a file/directory, we will use the same command[color=pink]

## cp - copy files
**Command:**
```linux===
cp [options] <source> <destination>
```

### Copying Command Example
```linux===
root@bedbe2be73fe:/home/filedir# ls
file3.txt  test2

root@bedbe2be73fe:/home/filedir# cp -r test2 test3

root@bedbe2be73fe:/home/filedir# ls
file3.txt  test2  test3
```


## mv - move (rename) files
```linux===
mv [options] <source> <destination>
```
### Moving Command Example
**Example file:**
```linux=
root@bedbe2be73fe:/# ls home
file3.txt  filedir  test

root@bedbe2be73fe:/# mv home/file3.txt home/filedir/file3.txt

root@bedbe2be73fe:/# ls home
filedir  test

root@bedbe2be73fe:/# ls home/filedir
file3.txt

```

**Example directory:**
```linux===
root@bedbe2be73fe:/# ls home
filedir  test

home/test:
root@bedbe2be73fe:/# mv home/test home/filedir/test

root@bedbe2be73fe:/# ls home
filedir
```

### Renaming Command Example
You are not dreaming! Indeed, the renaming way is using the **mv** command used for movement commands. In this case we just move to same place but with different name.

```linux===
root@bedbe2be73fe:/home/filedir# ls
file3.txt  test

root@bedbe2be73fe:/home/filedir# mv test test2

root@bedbe2be73fe:/home/filedir# ls
file3.txt  test2
```

# vi/vim command
**vi/vim** allows us to edit files. 

## vi vs vim
Vi stands for Visual. It is a text editor that is an early attempt to a visual text editor.

Vim stands for Vi IMproved. It is an implementation of the Vi standard with many additions. It is the most commonly used implementation of the standard. Most Linux distributions come with Vim already installed.

## Command Example
```linux===
root@bedbe2be73fe:/home/filedir# vi file3.txt
```

## Navigating a file in Vi/Vim
* **Arrow keys** - move the cursor around
* **j, k, h, l** - move the cursor down, up, left and right (similar to the arrow keys)
* **^ (caret)** - move cursor to beginning of current line
* **$** - move cursor to end of the current line
* **nG** - move to the nth line (eg 5G moves to 5th line)
* **G** - move to the last line
* **w** - move to the beginning of the next word
* **nw** - move forward n word (eg 2w moves two words forwards)
* **b** - move to the beginning of the previous word
* **nb** - move back n word
* **{** - move backward one paragraph
* **}** - move forward one paragraph

**:set nu**
>If you type **:set nu** in edit mode within vi it will enable line numbers. I find that turning line numbers on makes working with files a lot easier.[color=red]

## Insert Mode
Click **i** to enter insert mode, and exit insert mode by pressing **ESC**.

By using this mode, you can edit, insert, delete.

### How to check you are in insert mode?
![](https://i.imgur.com/5aF5KCS.png)


## Deleting content
Of course you can do it in **insert** mode.

* **x** - delete a single character
* **nx** - delete n characters (eg 5x deletes five characters)
* **dd** - delete the current line
* **dn** - d followed by a movement command. Delete to where the movement command would have taken you. (eg d5w means delete 5 words)

## Undoing Changes
Undoing changes in vi is fairly easy. It is the character u.

* **u** - Undo the last action (you may keep pressing u to keep undoing)
* **U (Note: capital)** - Undo all changes to the current line

## Saving and Exiting
* **ZZ** (Note: capitals) - Save and exit
* **:q!** - discard all changes, since the last save, and exit
* **:w** - save file but don't exit
* **:wq** - again, save and exit

## Install vi command if not present!
```linux===
//Ubuntu
root@bedbe2be73fe:/home/filedir# apt-get install vim -y

//Centos
[root@237409c00f01 logs]# yum install vim
```

# View files
## **cat** command for small files
**cat** which actually stands for concatenate, is used to view files.

**Command:**
```linux===
cat <file>
```

```linux===
root@bedbe2be73fe:/home/filedir# cat file3.txt
hello

I am testing vi command
press i to change to insert mode

root@bedbe2be73fe:/home/filedir#
```

## **less** command for large files
For larger files there is a better suited command which is less.

**Command:**
```linux===
less <file>
```

>less allows you to move up and down within a file using the arrow keys. 
You may go **forward a whole page using the SpaceBar or back a page by pressing b**. When you are done you can **press q for quit**. [color=orange]

```linux===
[root@237409c00f01 logs]# less info-2021-04-28.0.log
```

### How to quit less?
Quit by pressing **q**

# Permissions
## View Permissions

### Introduction
By using **ls -l**, we can check the permission.

**Where exactly is the permission stated?**
Just after the first character (- or d).

Let's take below as example:
> -rw-rw-r-- 1 root root 65 Apr 28 02:54 file3.txt [color=#B772FF]

Deducting the first character and the things after space, we get **rw-rw-r--**. This is the permission set for **user, ground and others** (stated in this same order).

### Permission Types and Permission owner
Taking last permission as example **rw-rw-r--**, we first have to understand the types of permission, someone can have.


**We mainly have ~*3 types of permission*~**
>* **r** read - you may view the contents of the file.
>* **w** write - you may change the contents of the file.
>* **x** execute - you may execute or run the file if it is a program or script.[color=#FFBBE5]

**As for who owns this permission, we have ~*3 types of people*~**
>* **owner** - a single person who owns the file. (typically the person who created the file but ownership may be granted to some one else by certain users)
>* **group** - every file belongs to a single group.
>* **others** - everyone else who is not in the group or the owner.[color=#BBF4FF]


![](https://i.imgur.com/TgZMfiz.png)

Note: 
If I do not state who do I provide permission to, then this permission will be given to all individuals. Ex: chmod +x 1.txt
However, this is not actually recommended. :-1: 

**Who owns each permission?**
We have to separate the permission in 3 parts, containing 3 characters.

**Example:**
rw-rw-r-- into 
1. rw- > User Permission contain read and write.
1. rw- > Group Permission contain read and write.
1. r-- > Other Permission only can read.

**Note:**
**\- (dash)** means absence of the permission.
The permission are stated in read, write, execute order (rwx), if all permissions are available **rwx** will be seen.

**Image Explanation:**
![](https://i.imgur.com/ghxIcg3.png)


### View Permission Example
**Check one file permission:**
```linux===
root@bedbe2be73fe:/home/filedir# ls -l file3.txt
-r--r--r-- 1 root root 65 Apr 28 02:54 file3.txt
```

**Check all files permission in same directory:**
```linux===
root@bedbe2be73fe:/home/filedir# ls -l
total 16
-r--r--r-- 1 root root   65 Apr 28 02:54 file3.txt
drwxr-xr-x 2 root root 4096 Apr 28 02:20 test2
drwxr-xr-x 3 root root 4096 Apr 28 02:43 test3
drwxr-xr-x 2 root root 4096 Apr 28 02:20 test4
```

## Change Permissions
To change permission we use **
** command.

**Command:**
```linux===
chmod [permissions] [path]
```

### How to use this command?
First of all you have to be able to state:
1. To which people you are changing the permission
1. Either add or revoke permission
1. Which permissions you want to add/revoke

**To whom I give permission?**
I can give permission to one or more people at once.

chmod **o**-w file3.txt  
chmod **gu**+rwx file3.txt
chmod **ugo**+rwx file3.txt 

As you are guessing, **u (user)**, **g(group)**, **o(other)**. We state our people before +/- and state permissions after +/i.

**Add or revoke permission?**
We use **+(plus)** / **-(minus)** to state **add** and **revoke** permission, by writing in between our people and permission.

chmod **u**-x file3.txt  = Remove execution permission to user
chmod **o**+rw file3.txt = Add read/write permission to others

**Where do we state our to be changed permissions?**
Just right after +(add)/-(revoke) in our command. Just as **View Permission** section stated. We can refer to our permissions by using **r(read), w(write), x(execute)**. 

We can make one or more permission changes at same time.

### **Example**
```linux===
root@bedbe2be73fe:/home/filedir# ls -l file3.txt
-rwxrw-r-- 1 root root 65 Apr 28 02:54 file3.txt

root@bedbe2be73fe:/home/filedir# chmod o+w file3.txt
root@bedbe2be73fe:/home/filedir# ls -l file3.txt
-rwxrw-rw- 1 root root 65 Apr 28 02:54 file3.txt
```

<details>
  <summary>Example Explanation</summary>

  >**rwxrw-r--**
  >User has permission to read, write and execute.
  >Group has permission to read and write.
  >Other only can read.[color=#FFD0BB]
</details>



# WildCards
## Basic Wildcards
* ***** - represents zero or more characters
* **?** - represents a single character
* **[]** - represents a range of characters
## Reference 
https://ryanstutorials.net/linuxtutorial/wildcards.php

# Filter
https://ryanstutorials.net/linuxtutorial/filters.php

# Grep and Regular Expressions

## egrep [command line options] <pattern> [path]
Search a given set of data and print each line containing given pattern.
![](https://i.imgur.com/xRrxWqo.png)

## Regular Expression
This is used to write patterns we would like to filter.

Basic blocks for regular expression:
* **. (dot)** - a single character.
* **?** - the preceding character matches 0 or 1 times only.
* ***** - the preceding character matches 0 or more times.
* **+** - the preceding character matches 1 or more times.
* **{n}** - the preceding character matches exactly n times.
* **{n,m}** - the preceding character matches at least n times and not more than m times.
* **[agd]** - the character is one of those included within the square brackets.
* **[^agd]** - the character is not one of those included within the square brackets.
* **[c-f]** - the dash within the square brackets operates as a range. In this case it means either the letters c, d, e or f.
* **()** - allows us to group several characters to behave as one.
* **|** (pipe symbol) - the logical OR operation.
* **^** - matches the beginning of the line.
* **$** - matches the end of the line.

**Example:**
```linux===
root@bedbe2be73fe:/home/filedir# egrep '^[a-zA-Z0-9]+[a-zA-Z0-9._-]+@+[a-zA-Z0-9]+.+[a-z]' file2.txt
```
![](https://i.imgur.com/TVlnq9y.png)

# htop Command
```linux===
[root@a8a00be5fa4c /]# yum -y install epel-release
[root@a8a00be5fa4c /]# htop
```
> Note: F10 to quit [color=red]

# Cheet Sheet
```linux
mkdir
Make Directory - ie. Create a directory.

rmdir
Remove Directory - ie. Delete a directory.

touch
Create a blank file.

cp
Copy - ie. Copy a file or directory.

mv
Move - ie. Move a file or directory (can also be used to rename).

rm
Remove - ie. Delete a file.

chmod
Change permissions on a file or directory.

ls -ld
View the permissions for a specific directory.
```


# Note
> **No undo**
>The Linux command line does not have an undo feature. Perform destructive actions carefully. [color = red]

