How to check file format for linux system

File system can be checked though one of below commands in linux system. these can be exeucted to check file system of given or all devices provided you have permission to do so.

1. using "df" disk filesystem command

   

-bash-3.2$ df -T | awk '{print $1,$2,$NF}' | grep "^/dev"

2. Using "/etc/fstab"

-bash-3.2$ cat /etc/fstab

3. Using "mount" command

-bash-3.2$ mount | grep "^/dev"

4. Using "file" command

file -sL /dev/sda1

5.  Using fsck command

fsck -N /dev/sda1

Directory permission in Linux

The permission on directory behaves differently than the normal files in Linux. below are meaning of permission bit on directory.

1. Write bit (w): allows the affected user to create, rename, or delete files within the directory, and modify the directory's attributes.
2. Read bit (r): allows the affected user to list the files within the directory.
3. Execute bit (x): allows the affected user to enter the directory, and access files and directories inside.

How to compare two files in Linux

There are various tools provided in various linux flavors to compare two text files, but there are few common ways of doing this i as below.

1. Using "diff" command.
    It compare two files line by line and list out the differences.

    Syntax: diff [options] file1 file 2
 
     Options: options can be used to change behavior of command scope
                    -b Instruct the system to ignore extra spaces and tabs.
                    -w Ignore all white spaces
                    -i Ignore any case differences
                    -E Ignore changes due to tab expansion.
                    -c useful in comparing tow code files and points ! to indicate difference,- for less and +                             for  more
                    <for more options refer manual>
 
     Example:
   

                 file1:

                         1

                         2

                         3

                         4

                         5

                         6

                         7

                         8

                         9

                 file2:

                        1

                        2

                        3

                        7

                        8

                        9

                       10

                       11

                       16

     
            $ diff file1 file2

                4,6d3

                < 4

                < 5

                < 6

               9a7,9

                > 10

                > 11

                > 16

The output is produced in ED line editor format, which suggest what changes to file will make it same as other file being compared. in above example 4,6d3 means delete 3 lines from 4-6 in first file and 9a7,9 means append at 9th position line 7-9 from second file.

Note: diff can be used to compare files in two different directory.

2. Using "vimdiff" or "vim -d" text editor functionality
    this tool will display the difference in file in vertical column and highlighting the difference.

    Syntax: vimdiff file1 file2

    Example: vimdiff 1 2 or vim -d 1 2

   
3. Using "comm" command
     This command will compare the files and will display the difference in  3 column.

    Syntax: comm [-123i] file1 file2
                  -1 to display difference in 1st file compared to 2nd file
                  -2 to display difference in 2nd file compared to 1st file.
                  -3 to display matching lines.
                  -i to do case sensitive comparison.

     Example: comm 1 2

                                           1

                                           2

                                           3

4

5

6

                                           7

                                           8

                                           9

                  10

                  11

                  16

Command Redirection

Output Redirection:

The output from a command normally intended for standard output can be easily can be diverted to a file instead. This capability is known as output redirection: this is useful to

If the notation > file is appended to any command that normally writes its output to standard output, the output of that command will be written to file instead of your terminal:

Check following who command which would redirect complete output of the command in users file.

$ who > users

Notice that no output appears at the terminal. This is because the output has been redirected from the default standard output device (the terminal) into the specified file. If you would check users file then it would have complete content:

$ cat users

root     :0           Nov  7 12:11

root     pts/0        Nov  7 12:12 (:0.0)

root     pts/1        Nov  7 12:20 (:0.0)

$

If a command has its output redirected to a file and the file already contains some data, that data will be lost. Consider this example:

$ echo line 1 > users

$ cat users

line 1

$

You can use >> operator to append the output in an existing file as follows:

$ echo line 2 >> users

$ cat users

line 1

line 2

$

Input Redirection:

Just as the output of a command can be redirected to a file, so can the input of a command be redirected from a file. As the greater-than character > is used for output redirection, the less-than character < is used to redirect the input of a command.

The commands that normally take their input from standard input can have their input redirected from a file in this manner. For example, to count the number of lines in the file users generated above, you can execute the command as follows:

$ wc -l users

2 users

$

Here it produces output 2 lines. You can count the number of lines in the file by redirecting the standard input of the wc command from the file users:

$ wc -l < users

2

$

Note that there is a difference in the output produced by the two forms of the wc command. In the first case, the name of the file users is listed with the line count; in the second case, it is not.

In the first case, wc knows that it is reading its input from the file users. In the second case, it only knows that it is reading its input from standard input so it does not display file name.

Here Document:

A here document is used to redirect input into an interactive shell script or program.

We can run an interactive program within a shell script without user action by supplying the required input for the interactive program, or interactive shell script.

The general form for a here document is:

command << delimiter

document

delimiter

Here the shell interprets the << operator as an instruction to read input until it finds a line containing the specified delimiter. All the input lines up to the line containing the delimiter are then fed into the standard input of the command.

The delimiter tells the shell that the here document has completed. Without it, the shell continues to read input forever. The delimiter must be a single word that does not contain spaces or tabs.

Following is the input to the command wc -l to count total number of line:

$wc -l << EOF

         This is a simple lookup program

         for good (and bad) restaurants

         in Cape Town.

EOF

3

$

You can use here document to print multiple lines using your script as follows:

#!/bin/sh

cat << EOF

This is a simple lookup program

for good (and bad) restaurants

in Cape Town.

EOF     

This would produce following result:

This is a simple lookup program

for good (and bad) restaurants

in Cape Town.

The following script runs a session with the vi text editor and save the input in the file test.txt.

#!/bin/sh

filename=test.txt

vi $filename <<EndOfCommands

i

This file was created automatically from

a shell script

^[

ZZ

EndOfCommands

If you run this script with vim acting as vi, then you will likely see output like the following:

$ sh test.sh

Vim: Warning: Input is not from a terminal

$

After running the script, you should see the following added to the file test.txt:

$ cat test.txt

This file was created automatically from

a shell script

$

Discard the output:

Sometimes you will need to execute a command, but you don't want the output displayed to the screen. In such cases you can discard the output by redirecting it to the file /dev/null:

$ command > /dev/null

Here command is the name of the command you want to execute. The file /dev/null is a special file that automatically discards all its input.

To discard both output of a command and its error output, use standard redirection to redirect STDERR to STDOUT:

$ command > /dev/null 2>&1

Here 2 represents STDERR and 1 represents STDOUT. You can display a message on to STDERR by redirecting STDIN into STDERR as follows:

$ echo message 1>&2

Redirection Commands:

Following is the complete list of commands which you can use for redirection:

Command	Description
pgm > file	Output of pgm is redirected to file
pgm < file	Program pgm reads its input from file.
pgm >> file	Output of pgm is appended to file.
n > file	Output from stream with descriptor n redirected to file.
n >> file	Output from stream with descriptor n appended to file.
n >& m	Merge output from stream n with stream m.
n <& m	Merge input from stream n with stream m.
<< tag	Standard input comes from here through next tag at start of line.
|	Takes output from one program, or process, and sends it to another.

Note that file descriptor 0 is normally standard input (STDIN), 1 is standard output (STDOUT), and 2 is standard error output (STDERR).

reference.

Delete Files Older Than n Days on Linux

The find utility on linux allows you to pass in a bunch of interesting arguments, including one to execute another command on each file. We’ll use this in order to figure out what files are older than a certain number of days, and then use the rm command to delete them.

Command Syntax

find /path/to/files* -mtime +5 -exec rm {} \;

Note that there are spaces between rm, {}, and \;

Explanation

• The first argument is the path to the files. This can be a path, a directory, or a wildcard as in the example above. I would recommend using the full path, and make sure that you run the command without the exec rm to make sure you are getting the right results.
• The second argument, -mtime, is used to specify the number of days old that the file is. If you enter +5, it will find files older than 5 days.
• The third argument, -exec, allows you to pass in a command such as rm. The {} \; at the end is required to end the command.

This should work on Ubuntu, Suse, Redhat, or pretty much any version of linux.

Reading self path/name/parameter from bash

Below is script and test run to get parameter,path,script file name etc.

#!/bin/bash

echo
echo "arguments called with ---->  ${@}     "
echo "\$1 ---------------------->  $1       "
echo "\$2 ---------------------->  $2       "
echo "path to me --------------->  ${0}     "
echo "parent path -------------->  ${0%/*}  "
echo "my name ------------------>  ${0##*/} "
echo
exit

# ------------- Test script------------- #

$  
/home/myscript/my_setting.sh
 "'My name is'" "'Ryan'"
# ------------- RESULTS ------------- #

 arguments called with --->  'My name is' 'Ryan'
 $1 ---------------------->  'My name is'
 $2 ---------------------->  'Ryan'
 path to me -------------->  /home/myscript/my_setting.sh
 parent path ------------->  /home/myscript my name ----------------->  my_setting.sh

Script converting seconds to time format

Here is simple script to convert seconds to time (hh:mm:ss) format.

#!/bin/bash
convertsectotime() {
 ((h=${1}/3600))
 ((m=(${1}%3600)/60))
 ((s=${1}%60))
 printf "%02d:%02d:%02d\n" $h $m $s
}
#TIME1="36"
echo "enter seconds:"
read TIME1
echo $(convertsectotime $TIME1)