{"id":13185,"date":"2019-04-01T06:54:04","date_gmt":"2019-04-01T06:54:04","guid":{"rendered":"http:\/\/www.appservgrid.com\/paw92\/?p=13185"},"modified":"2019-04-01T06:54:04","modified_gmt":"2019-04-01T06:54:04","slug":"bash-shell","status":"publish","type":"post","link":"https:\/\/www.appservgrid.com\/paw92\/index.php\/2019\/04\/01\/bash-shell\/","title":{"rendered":"BASH SHELL"},"content":{"rendered":"

Understand Linux Shell and Basic Shell Scripting Language Tips \u2013 Part I<\/h1>\n

Picture speak more than words and the below picture says all about the working of\u00a0Linux<\/strong>.<\/p>\n

 <\/p>\n

\n

\"Understanding<\/a><\/p>\n

Understanding Linux Shell<\/p>\n<\/div>\n

Read Also<\/strong><\/p>\n

    \n
  1. 5 Shell Scripts to Learn Shell Programming \u2013 Part II<\/a><\/li>\n
  2. Sailing Through The World of Linux BASH Scripting \u2013 Part III<\/a><\/li>\n<\/ol>\n

    Understanding Linux Shell<\/h3>\n
      \n
    1. Shell<\/strong>: A Command-Line Interpretor that connects a user to\u00a0Operating System<\/strong>\u00a0and allows to execute the commands or by creating text script.<\/li>\n
    2. Process<\/strong>: Any task that a user run in the system is called a process. A process is little more complex than just a task.<\/li>\n
    3. File<\/strong>: It resides on hard disk (hdd<\/strong>) and contains data owned by a\u00a0user<\/strong>.<\/li>\n
    4. X-windows aka windows<\/strong>: A mode of Linux where screen (monitor<\/strong>) can be split in small \u201cparts<\/strong>\u201d called\u00a0windows<\/strong>, that allow a\u00a0user<\/strong>\u00a0to do several things at the same time and\/or switch from one task to another easily and view graphics in a nice way.<\/li>\n
    5. Text terminal<\/strong>: A monitor that has only the capability of displaying text stuff, no graphics or a very basic graphics display.<\/li>\n
    6. Session<\/strong>: Time between\u00a0logging<\/strong>\u00a0on<\/strong>\u00a0and\u00a0logging out<\/strong>\u00a0of the system.<\/li>\n<\/ol>\n

      Types of Shell on a Standard Linux Distribution<\/h3>\n

      Bourne shell<\/strong>\u00a0: The Bourne shell was one of the major shells used in early versions and became a de facto standard. It was written by\u00a0Stephen Bourne<\/strong>\u00a0at\u00a0Bell Labs<\/strong>. Every Unix-like system has at least one shell compatible with the Bourne shell. The Bourne shell program name is \u201csh<\/strong>\u201d and it is typically located in the file system hierarchy at\u00a0\/bin\/sh<\/strong>.<\/p>\n

      C shell<\/strong>: The\u00a0C shell<\/strong>\u00a0was developed by\u00a0Bill Joy<\/strong>\u00a0for the\u00a0Berkeley Software Distribution<\/strong>. Its syntax is modelled after the\u00a0C<\/strong>\u00a0programming language. It is used primarily for interactive terminal use, but less frequently for scripting and operating system control.\u00a0C<\/strong>\u00a0shell has many interactive commands.<\/p>\n

      Beginning the Fun! (Linux Shell)<\/h3>\n

      There exist thousands of commands for command-line user, how about remembering all of them? Hmmm! Simply you can not. The real power of computer is to ease the ease your work, you need to automate the process and hence you need scripts.<\/p>\n

      Scripts are collections of commands, stored in a file. The shell can read this file and act on the commands as if they were typed at the keyboard. The shell also provides a variety of useful programming features to make scripts truly powerful.<\/p>\n

      Basics of Shell Programming<\/h3>\n
        \n
      1. To get a Linux shell, you need to start a terminal.<\/li>\n
      2. To see what shell you have,\u00a0run: echo $SHELL<\/strong>.<\/li>\n
      3. In Linux, the dollar sign ($<\/strong>) stands for a shell variable.<\/li>\n
      4. The \u2018echo<\/strong>\u2018 command just returns whatever you type in.<\/li>\n
      5. The pipeline instruction (|<\/strong>) comes to rescue, when chaining several commands.<\/li>\n
      6. Linux commands have their own syntax, Linux won\u2019t forgive you whatsoever is the mistakes. If you get a command wrong, you won\u2019t flunk or damage anything, but it won\u2019t work.<\/li>\n
      7. #!\/bin\/sh<\/strong>\u00a0\u2013 It is called shebang. It is written at the top of a shell script and it passes the instruction to the program\u00a0\/bin\/sh<\/strong>.<\/li>\n<\/ol>\n

        About shell Script<\/h3>\n

        Shell script is just a simple text file with \u201c.sh<\/strong>\u201d extension, having executable permission.<\/p>\n

        Process of writing and executing a script<\/h4>\n
          \n
        1. Open terminal.<\/li>\n
        2. Navigate to the place where you want to create script using \u2018cd<\/strong>\u2018 command.<\/li>\n
        3. Cd<\/strong>\u00a0(enter) [This will bring the prompt at\u00a0Your home Directory<\/strong>].<\/li>\n
        4. touch\u00a0hello.sh<\/strong>\u00a0(Here we named the script as\u00a0hello<\/strong>, remember the \u2018.sh<\/strong>\u2018 extension is compulsory).<\/li>\n
        5. vi\u00a0hello.sh<\/strong>\u00a0(nano\u00a0hello.sh<\/strong>) [You can use your favourite editor, to edit the script].<\/li>\n
        6. chmod 744 hello.sh<\/strong>\u00a0(making the script executable).<\/li>\n
        7. sh hello.sh<\/strong>\u00a0or\u00a0.\/hello.sh<\/strong>\u00a0(running the script)<\/li>\n<\/ol>\n
          Writing your First Script<\/h5>\n
          #!\/bin\/bash\r\n# My first script\r\n\r\necho \"Hello World!\"<\/pre>\n
          Save the above lines on a text file, make it executable and run it, as described above.<\/p>\n
          Sample Output<\/h4>\n
          Hello World!<\/pre>\n
          In the above code.<\/p>\n
          #!\/bin\/bash (is the shebang.)\r\n# My first script (is comment, anything following '#' is a comment)\r\necho \u201cHello World!\u201d (is the main part of this script)<\/pre>\n
          Writing your Second Script<\/h5>\n
          OK time to move to the next script. This script will tell you, your\u2019s \u201cusername<\/strong>\u201d and list the running\u00a0processes<\/strong>.<\/p>\n
          #! \/bin\/bash\r\necho \"Hello $USER\"\r\necho \"Hey i am\" $USER \"and will be telling you about the current processes\"\r\necho \"Running processes List\"\r\nps<\/pre>\n
          Create a file with above codes, save it to anything you want, but with extension \u201c.sh<\/strong>\u201c, make it executable and run it, from you terminal.<\/p>\n
          Sample Output<\/h4>\n
          Hello tecmint\r\nHey i am tecmint and will be telling you about the current processes\r\nRunning processes List\r\n  PID TTY          TIME CMD\r\n 1111 pts\/0    00:00:00 bash\r\n 1287 pts\/0    00:00:00 sh\r\n 1288 pts\/0    00:00:00 ps<\/pre>\n
          Was this cool<\/strong>? Writing script is as simple as getting an idea and writing pipelined commands. There are some restrictions, too. Shell scripts are excellent for concise filesystem operations and scripting the combination of existing functionality in filters and command line tools via pipes.<\/p>\n
          When your needs are greater \u2013 whether in\u00a0functionality<\/strong>,\u00a0robustness<\/strong>,\u00a0performance<\/strong>,\u00a0efficiency<\/strong>\u00a0etc \u2013 then you can move to a more full-featured language.<\/p>\n
          If you already know\u00a0C<\/strong>\/Perl<\/strong>\/Python<\/strong>\u00a0programming language or any other programming language, learning the scripting language won\u2019t be much difficult.<\/p>\n
          Writing your Third Script<\/h5>\n
          Moving to, write our third and last script for this article. This script acts as an interactive script. Why don\u2019t you, yourself execute this simple yet interactive script and tell us how you felt.<\/p>\n
          #! \/bin\/bash\r\necho \"Hey what's Your First Name?\";\r\nread a;\r\necho \"welcome Mr.\/Mrs. $a, would you like to tell us, Your Last Name\";\r\nread b;\r\necho \"Thanks Mr.\/Mrs. $a $b for telling us your name\";\r\necho \"*******************\"\r\necho \"Mr.\/Mrs. $b, it's time to say you good bye\"<\/pre>\n
          Sample Output<\/h4>\n
          Hey what's Your First Name?\r\nAvishek\r\nwelcome Mr.\/Mrs. Avishek, would you like to tell us, Your Last Name\r\nKumar\r\nThanks Mr.\/Mrs. Avishek Kumar for telling us your name\r\n******************************************************\r\nMr.\/Mrs. Kumar, it's time to say you good bye<\/pre>\n
          Well this is not an end. We tried to bring a taste of scripting to you. In our future article we will elaborate this scripting language topic, rather a never ending scripting language topic, to be more perfect. Your\u00a0valuable thoughts<\/strong>\u00a0in comments is highly appreciated,\u00a0Like and share<\/strong>\u00a0us and help us to spread. Till then just chill, keep connected, stay tuned.<\/p>\n
          Read Also<\/strong>\u00a0:\u00a05 Shell Scripts to Learn Shell Programming \u2013 Part II<\/a><\/p>\n
          5 Shell Scripts for Linux Newbies to Learn Shell Programming \u2013 Part II<\/h1>\n
          To Learn something you need to do it, without the fear of being unsuccessful. I believe in practicality and hence will be accompanying you to the practical world of Scripting Language.<\/p>\n
          \n
          \"Learn<\/a><\/p>\n
          Learn Basic Shell Scripting<\/p>\n<\/div>\n
          This article is an extension of our First article\u00a0Understand Linux Shell and Basic Shell Scripting \u2013 Part I<\/a>, where we gave you a taste of Scripting, continuing that we won\u2019t disappoint you in this article.<\/p>\n
          Script 1: Drawing a Special Pattern<\/h3>\n
          #!\/bin\/bash\r\nMAX_NO=0\r\necho -n \"Enter Number between (5 to 9) : \"\r\nread MAX_NO\r\nif ! [ $MAX_NO -ge 5 -a $MAX_NO -le 9 ] ; then\r\n   echo \"WTF... I ask to enter number between 5 and 9, Try Again\"\r\n   exit 1\r\nfi\r\nclear\r\nfor (( i=1; i<=MAX_NO; i++ )) do     for (( s=MAX_NO; s>=i; s-- ))\r\n    do\r\n       echo -n \" \"\r\n    done\r\n    for (( j=1; j<=i;  j++ ))     do      echo -n \" .\"      done     echo \"\" done ###### Second stage ###################### for (( i=MAX_NO; i>=1; i-- ))\r\ndo\r\n    for (( s=i; s<=MAX_NO; s++ ))\r\n    do\r\n       echo -n \" \"\r\n    done\r\n    for (( j=1; j<=i;  j++ ))\r\n    do\r\n     echo -n \" .\"\r\n    done\r\n    echo \"\"\r\ndone\r\necho -e \"\\n\\n\\t\\t\\t Whenever you need help, Tecmint.com is always there\"<\/pre>\n
          Most of the above \u2018key words<\/strong>\u2018 would be known to you and most of them are self explanatory. e.g.,\u00a0MAX<\/strong>\u00a0sets the maximum value of the variable, for is a loop and anything within the loop gets on executing again and again till the loop is valid for given value of input.<\/p>\n
          Sample Output<\/h5>\n
          [root@tecmint ~]# chmod 755 Special_Pattern.sh\r\n[root@tecmint ~]# .\/Special_Pattern.sh\r\nEnter Number between (5 to 9) : 6\r\n       .\r\n      . .\r\n     . . .\r\n    . . . .\r\n   . . . . .\r\n  . . . . . .\r\n  . . . . . .\r\n   . . . . .\r\n    . . . .\r\n     . . .\r\n      . .\r\n       .\r\n\r\n                         Whenever you need help, Tecmint.com is always there<\/pre>\n
          If you are a little aware of any programming language, learning the above script is not difficult, even if you are new to computation, programming and Linux it is not going to be much difficult.<\/p>\n
          Download Special_Pattern.sh<\/a><\/p>\n
          Script 2: Creating Colorful Script<\/h3>\n
           <\/p>\n
          Who says,\u00a0Linux is colorless<\/strong>\u00a0and boring, save the codes below to anything [dot<\/strong>]\u00a0sh<\/strong>, make it executable and Run it, don\u2019t forget to tell me how it was, Think what you can achieve, implementing it somewhere.<\/p>\n
          #!\/bin\/bash\r\nclear \r\necho -e \"33[1m Hello World\"\r\n# bold effect\r\necho -e \"33[5m Blink\"\r\n# blink effect\r\necho -e \"33[0m Hello World\"\r\n# back to normal\r\necho -e \"33[31m Hello World\"\r\n# Red color\r\necho -e \"33[32m Hello World\"\r\n# Green color\r\necho -e \"33[33m Hello World\"\r\n# See remaining on screen\r\necho -e \"33[34m Hello World\"\r\necho -e \"33[35m Hello World\"\r\necho -e \"33[36m Hello World\"\r\necho -e -n \"33[0m\"\r\n# back to normal\r\necho -e \"33[41m Hello World\"\r\necho -e \"33[42m Hello World\"\r\necho -e \"33[43m Hello World\"\r\necho -e \"33[44m Hello World\"\r\necho -e \"33[45m Hello World\"\r\necho -e \"33[46m Hello World\"\r\necho -e \"33[0m Hello World\"<\/pre>\n
          Note<\/strong>: Don\u2019t bother about the color code now, Those important to you will be at your tongue, gradually.<\/p>\n
          Warning<\/strong>: Your terminal might not have the facility of blinking.<\/p>\n
          Sample Output<\/h5>\n
          [root@tecmint ~]# chmod 755 Colorfull.sh\r\n[root@tecmint ~]# .\/Colorfull.sh\r\n\r\nHello World\r\nBlink\r\nHello World\r\nHello World\r\nHello World\r\nHello World\r\nHello World\r\nHello World\r\nHello World\r\nHello World\r\nHello World\r\nHello World\r\nHello World\r\nHello World\r\nHello World\r\nHello World<\/pre>\n
          Download Colorfull.sh<\/a><\/p>\n
          Script 3: Encrypt a File\/Directory<\/h3>\n
          This script will encrypt a\u00a0file<\/strong>\u00a0(remember?\u00a0directory<\/strong>\/driver<\/strong>\/\u2026. everything is treated as file, in\u00a0Linux<\/strong>). The current limitation of the above script is that it don\u2019t support auto completion of name using\u00a0TAB<\/strong>. Moreover, you need to place the script and file to be encrypted in the same folder. You may need to install \u201cpinentry-gui<\/strong>\u201d, using\u00a0yum<\/strong>\u00a0or\u00a0apt<\/strong>\u00a0the package, if required.<\/p>\n
          [root@midstage ~]# yum install pinentry-gui\r\n[root@midstage ~]# apt-get install pinentry-gui<\/pre>\n
          Crete a file called \u201cEncrypt.sh<\/strong>\u201d and place the following script, make it executable and run it as shown.<\/p>\n
          #!\/bin\/bash\r\necho \"Welcome, I am ready to encrypt a file\/folder for you\"\r\necho \"currently I have a limitation, Place me to thh same folder, where a file to be \r\nencrypted is present\"\r\necho \"Enter the Exact File Name with extension\"\r\nread file;\r\ngpg -c $file\r\necho \"I have encrypted the file successfully...\"\r\necho \"Now I will be removing the original file\"\r\nrm -rf $file<\/pre>\n
          Sample Output<\/h3>\n
          [root@tecmint ~]# chmod 755 Encrypt.sh\r\n[root@tecmint ~]# .\/Encrypt.sh\r\n\r\nWelcome, I am ready to encrypt a file\/folder for you\r\ncurrently I have a limitation, Place me to the same folder, where a file to be\r\n\r\nencrypted is present\r\nEnter the Exact File Name with extension\r\n\r\npackage.xml\r\n\r\n                                                   \u250c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510\r\n                                                   \u2502 Enter passphrase                                    \u2502\r\n                                                   \u2502                                                     \u2502\r\n                                                   \u2502                                                     \u2502\r\n                                                   \u2502 Passphrase *******_________________________________ \u2502\r\n                                                   \u2502                                                     \u2502\r\n                                                   \u2502       <OK>                             <Cancel>     \u2502\r\n                                                   \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\r\n\r\nPlease re-enter this passphrase\r\n\r\n                                                   \u250c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510\r\n                                                   \u2502 Please re-enter this passphrase                     \u2502\r\n                                                   \u2502                                                     \u2502\r\n                                                   \u2502 Passphrase ********________________________________ \u2502\r\n                                                   \u2502                                                     \u2502\r\n                                                   \u2502       <OK>                             <Cancel>     \u2502\r\n                                                   \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\r\n\r\nI have encrypted the file successfully...\r\nNow I will be removing the original file\r\n<\/pre><\/pre>\n
          gpg -c<\/strong>\u00a0: This will encrypt your file, using a passkey aka\u00a0password<\/strong>. In this process of learning you would have never thought that the actual process of learning could be that much easy. So after encrypting a file what you need? Obviously! decrypting the file. And I want you \u2013 the learner, the reader to write the decryption script yourself, don\u2019t worry I am not leaving you in the middle, I just want you to gain something out of this article.<\/p>\n
          Note<\/strong>:\u00a0gpg -d filename.gpg<\/strong>\u00a0>\u00a0filename<\/strong>\u00a0is what you need to implement in your decryption script. You may post you script in comment if successful, if not you may ask me to write it for you.<\/p>\n
          Download Encrypt.sh<\/a><\/p>\n
          Script 4: Checking Server Utilization<\/h3>\n
          Checking the server utilization is one of the important task of an administrator, and a good administrator is one who knows how to automate his day to day task. Below is the script that will give many such information about your server. Check it yourself.<\/p>\n
          #!\/bin\/bash\r\n    date;\r\n    echo \"uptime:\"\r\n    uptime\r\n    echo \"Currently connected:\"\r\n    w\r\n    echo \"--------------------\"\r\n    echo \"Last logins:\"\r\n    last -a |head -3\r\n    echo \"--------------------\"\r\n    echo \"Disk and memory usage:\"\r\n    df -h | xargs | awk '{print \"Free\/total disk: \" $11 \" \/ \" $9}'\r\n    free -m | xargs | awk '{print \"Free\/total memory: \" $17 \" \/ \" $8 \" MB\"}'\r\n    echo \"--------------------\"\r\n    start_log=`head -1 \/var\/log\/messages |cut -c 1-12`\r\n    oom=`grep -ci kill \/var\/log\/messages`\r\n    echo -n \"OOM errors since $start_log :\" $oom\r\n    echo \"\"\r\n    echo \"--------------------\"\r\n    echo \"Utilization and most expensive processes:\"\r\n    top -b |head -3\r\n    echo\r\n\ttop -b |head -10 |tail -4\r\n    echo \"--------------------\"\r\n    echo \"Open TCP ports:\"\r\n    nmap -p- -T4 127.0.0.1\r\n    echo \"--------------------\"\r\n    echo \"Current connections:\"\r\n    ss -s\r\n    echo \"--------------------\"\r\n    echo \"processes:\"\r\n    ps auxf --width=200\r\n    echo \"--------------------\"\r\n    echo \"vmstat:\"\r\n    vmstat 1 5<\/pre>\n
          Sample Output<\/h5>\n
          [root@tecmint ~]# chmod 755 Server-Health.sh\r\n[root@tecmint ~]# .\/Server-Health.sh\r\n\r\nTue Jul 16 22:01:06 IST 2013\r\nuptime:\r\n 22:01:06 up 174 days,  4:42,  1 user,  load average: 0.36, 0.25, 0.18\r\nCurrently connected:\r\n 22:01:06 up 174 days,  4:42,  1 user,  load average: 0.36, 0.25, 0.18\r\nUSER     TTY      FROM              LOGIN@   IDLE   JCPU   PCPU WHAT\r\ntecmint   pts\/0    116.72.134.162   21:48    0.00s  0.03s  0.03s sshd: tecmint [priv]\r\n--------------------\r\nLast logins:\r\ntecmint   pts\/0        Tue Jul 16 21:48   still logged in    116.72.134.162\r\ntecmint   pts\/0        Tue Jul 16 21:24 - 21:43  (00:19)     116.72.134.162\r\n--------------------\r\nDisk and memory usage:\r\nFree\/total disk: 292G \/ 457G\r\nFree\/total memory: 3510 \/ 3838 MB\r\n--------------------\r\nOOM errors since Jul 14 03:37 : 0\r\n--------------------\r\nUtilization and most expensive processes:\r\ntop - 22:01:07 up 174 days,  4:42,  1 user,  load average: 0.36, 0.25, 0.18\r\nTasks: 149 total,   1 running, 148 sleeping,   0 stopped,   0 zombie\r\nCpu(s):  0.1%us,  0.0%sy,  0.0%ni, 99.3%id,  0.6%wa,  0.0%hi,  0.0%si,  0.0%st\r\n\r\n  PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND\r\n    1 root      20   0  3788 1128  932 S  0.0  0.0   0:32.94 init\r\n    2 root      20   0     0    0    0 S  0.0  0.0   0:00.00 kthreadd\r\n    3 root      RT   0     0    0    0 S  0.0  0.0   0:14.07 migration\/0<\/pre>\n
          Note<\/strong>: I have given you the script that gives the output in the terminal itself, how about getting the output in a file for future reference. Implement it using redirect operator.<\/p>\n
            \n
          1. \u2018><\/strong>\u2018 : the redirection operator causes a file creation, and if it does exist, the contents are overwritten.<\/li>\n
          2. \u2018>><\/strong>\u2018 : when you use >>, you are adding information, rather than replacing it.<\/li>\n
          3. \u2018>><\/strong>\u2018 is safe, as compared to \u2018><\/strong>\u2018<\/li>\n<\/ol>\n
            Download Server-Health.sh<\/a><\/p>\n
            Script 5: Check Disk Space and Sends an Email Alert<\/h3>\n
            How about getting an email when disk use in partition\u00a0PART<\/strong>\u00a0is bigger than Maximum allowed, it is a life saver script for web administrators with little modification.<\/p>\n
            MAX=95\r\nEMAIL=USER@domain.com\r\nPART=sda1\r\nUSE=`df -h |grep $PART | awk '{ print $5 }' | cut -d'%' -f1`\r\nif [ $USE -gt $MAX ]; then\r\n  echo \"Percent used: $USE\" | mail -s \"Running out of disk space\" $EMAIL\r\nfi<\/pre>\n
            Note<\/strong>: Remove \u201cUSER<\/strong>\u201d with your user name. You can check mail using using \u2018mail<\/strong>\u2018 command.<\/p>\n
            Download Check-Disk-Space.sh<\/a><\/p>\n
            Script writing and programming is beyond boundaries, anything and everything could be implemented as required. That\u2019s all for now, In my very next article I will be giving your some different flavors of scripting. Till then stay cool and tuned, enjoy.<\/p>\n
            Sailing Through The World of Linux BASH Scripting \u2013 Part III<\/h1>\n
            The Previous following articles of \u2018Shell Scripting<\/strong>\u2018 series were highly appreciated and hence I am writing this article to extend the never ending process of learning.<\/p>\n
            \n
            \"Basic<\/a><\/p>\n
            Basic Shell Scripting Part-3<\/p>\n<\/div>\n
              \n
            1. Understand Basic Linux Shell Scripting Language Tips \u2013 Part I<\/a><\/li>\n
            2. 5 Shell Scripts for Linux Newbies to Learn Shell Programming \u2013 Part II<\/a><\/li>\n<\/ol>\n
              Bash Keywords<\/h5>\n
              A\u00a0keyword<\/strong>\u00a0is a word or symbol that has a special meaning to a computer language. The following symbols and words have special meanings to\u00a0Bash<\/strong>\u00a0when they are unquoted and the first word of a command.<\/p>\n
              ! \t\t\tesac \t\t\tselect \t\t} \r\ncase \t\t\tfi \t\t\tthen \t\t[[ \r\ndo \t\t\tfor \t\t\tuntil \t\t]] \r\ndone \t\t\tfunction \t\twhile \t\telif\r\nif \t\t\ttime \t\t\telse \t\tin \t\t{<\/pre>\n
              Unlike most computer languages,\u00a0Bash<\/strong>\u00a0allows keywords to be used as\u00a0variable names<\/strong>\u00a0even though this can make scripts difficult to read. To keep scripts understandable, key-words should not be used for variable names.<\/p>\n
              A command is implemented in shell as\u00a0$<\/strong>(command). You might have to include the full path of command. e.g.,\u00a0$(\/bin\/date)<\/strong>, for correct execution.<\/p>\n
               <\/p>\n
              You may know the path of specific program using \u2018whereis<\/strong>\u2018 command. e.g.,\u00a0whereis date<\/strong><\/p>\n
              [root@tecmint \/]# whereis date\r\ndate: \/bin\/date \/usr\/share\/man\/man1\/date.1.gz<\/pre>\n
              That\u2019s enough for now. We won\u2019t be talking much about these theory now. Coming to Scripts.<\/p>\n
              Move Current Working Directory<\/h3>\n
              Move from current working directory to any level up by just providing the numerical value at the end of script while executing.<\/p>\n
              #! \/bin\/bash \r\nLEVEL=$1 \r\nfor ((i = 1; i <= LEVEL; i++)) \r\ndo \r\nCDIR=..\/$CDIR \r\ndone \r\ncd $CDIR \r\necho \"You are in: \"$PWD \r\nexec \/bin\/bash<\/pre>\n
              Save the above codes as \u201cup.sh<\/strong>\u201c, on your desktop. Make it executable (chmod 755 up.sh<\/strong>). Run:<\/p>\n
              .\/up.sh 2<\/strong>\u00a0(will Move the current working directory to two level up).
              \n.\/up.sh 4<\/strong>\u00a0(will Move the current working directory to four level up).<\/p>\n
              Use and Area of Application<\/h5>\n
              In larger scripts which contains folder inside folder inside\u2026 containing\u00a0libraries<\/strong>,\u00a0binaries<\/strong>,\u00a0icons<\/strong>,\u00a0executables<\/strong>, etc at different location, You as a developer can implement this script to move to the desired location in a very automated fashion.<\/p>\n
              Note<\/strong>: For is a loop in the above script and it will continue to execute till the values are true for the loop.<\/p>\n
              Sample Output<\/h5>\n
              [root@tecmint \/]# chmod 755 up\r\n[root@tecmint \/]# .\/up.sh 2\r\nYou are in: \/\r\n\r\n[root@tecmint \/]# .\/up.sh 4 \r\nYou are in: \/ \r\n\r\n[root@tecmint \/]#<\/pre>\n
              Download up.sh<\/a><\/p>\n
              Create a Random File or Folder<\/h3>\n
              Create a random file (folder) with no chance of duplication.<\/p>\n
              #! \/bin\/bash\r\n\r\necho \"Hello $USER\";\r\necho \"$(uptime)\" >> \"$(date)\".txt\r\necho \"Your File is being saved to $(pwd)\"<\/pre>\n
              This is a Simple script but it\u2019s working is not that much simple.<\/p>\n
                \n
              1. \u2018echo<\/strong>\u2018 : Prints everything written within the quotes.<\/li>\n
              2. \u2018$<\/strong>\u2018 : Is a shell variable.<\/li>\n
              3. \u2018>><\/strong>\u2018 : The output is redirected to the output of\u00a0date<\/strong>\u00a0command followed by\u00a0txt<\/strong>\u00a0extension.<\/li>\n<\/ol>\n
                We know the output of\u00a0date<\/strong>\u00a0command is\u00a0date<\/strong>, and\u00a0time<\/strong>\u00a0in\u00a0hour<\/strong>,\u00a0minute,<\/strong>\u00a0second<\/strong>\u00a0along with\u00a0year<\/strong>. Hence we could get output on an organised file name without the chance of filename duplication. It could be very much useful when user needs the file created with\u00a0time stamp<\/strong>\u00a0for future reference.<\/p>\n
                Sample Output<\/h5>\n
                [root@tecmint \/]# .\/randomfile.sh  \r\nHello server \r\nYour File is being saved to \/home\/server\/Desktop<\/pre>\n
                You can view the file which is created on desktop with Today\u2019s Date and current time.<\/p>\n
                [root@tecmint \/]# nano Sat\\ Jul\\ 20\\ 13\\:51\\:52\\ IST\\ 2013.txt \r\n13:51:52 up  3:54,  1 user,  load average: 0.09, 0.12, 0.08<\/pre>\n
                A more detailed implementation of the above script is given below, which works on the above principle and is very useful in gathering the network information of a\u00a0Linux<\/strong>\u00a0server.<\/p>\n
                Download randomfile.sh<\/a><\/p>\n
                Script to Collect Network Information<\/h3>\n
                Gathers network information on a\u00a0Linux<\/strong>\u00a0server. The script is too large and it\u2019s not possible to post the whole code and output of the script here. So, it\u2019s better you can download the script using below download link and test it yourself.<\/p>\n
                Note<\/strong>: You might need to install\u00a0lsb-core<\/strong>\u00a0package and other required packages and dependency.\u00a0Apt<\/strong>\u00a0or\u00a0Yum<\/strong>\u00a0the required packages. Obviously you need to be\u00a0root<\/strong>\u00a0to run the script because most of the commands used here are configured to be run as\u00a0root<\/strong>.<\/p>\n
                Sample Output<\/h5>\n
                [root@tecmint \/]# .\/collectnetworkinfo.sh  \r\n\r\nThe Network Configuration Info Written To network.20-07-13.info.txt<\/strong>. Please email this file to your_name@service_provider.com<\/strong>. ktop<\/pre>\n
                You can change the above email address in your script to get it being mailed to you. The Automatically generated file can be viewed.<\/p>\n
                Download collectnetworkinfo.sh<\/a><\/p>\n
                Script to Converts UPPERCASE to lowercase<\/h3>\n
                A script that converts\u00a0UPPERCASE<\/strong>\u00a0to\u00a0lowercase<\/strong>\u00a0and redirects the output to a text file \u201csmall.txt<\/strong>\u201d which can be modified as required.<\/p>\n
                #!\/bin\/bash \r\n\r\necho -n \"Enter File Name : \" \r\nread fileName \r\n\r\nif [ ! -f $fileName ]; then \r\n  echo \"Filename $fileName does not exists\" \r\n  exit 1 \r\nfi \r\n\r\ntr '[A-Z]' '[a-z]' < $fileName >> small.txt<\/pre>\n
                This above script can convert the case of a file of any length with a single click from\u00a0uppercase<\/strong>\u00a0to\u00a0lowercase<\/strong>and vice-versa if required, with little modification.<\/p>\n
                Sample Output<\/h5>\n
                [root@tecmint \/]# .\/convertlowercase.sh  \r\nEnter File Name : a.txt \r\n\r\nInitial File: \r\nA\r\nB\r\nC\r\nD\r\nE\r\nF\r\nG\r\nH\r\nI\r\nJ\r\nK\r\n...<\/pre>\n
                New File (small.txt<\/strong>) output:<\/p>\n
                a\r\nb\r\nc\r\nd\r\ne\r\nf\r\ng\r\nh\r\ni\r\nj\r\nk\r\n...<\/pre>\n
                Download convertlowercase.sh<\/a><\/p>\n
                Simple Calculator Program<\/h3>\n
                #! \/bin\/bash \r\nclear \r\nsum=0 \r\ni=\"y\" \r\n\r\necho \" Enter one no.\" \r\nread n1 \r\necho \"Enter second no.\" \r\nread n2 \r\nwhile [ $i = \"y\" ] \r\ndo \r\necho \"1.Addition\" \r\necho \"2.Subtraction\" \r\necho \"3.Multiplication\" \r\necho \"4.Division\" \r\necho \"Enter your choice\" \r\nread ch \r\ncase $ch in \r\n    1)sum=`expr $n1 + $n2` \r\n     echo \"Sum =\"$sum;; \r\n        2)sum=`expr $n1 - $n2` \r\n     echo \"Sub = \"$sum;; \r\n    3)sum=`expr $n1 \\* $n2` \r\n     echo \"Mul = \"$sum;; \r\n    4)sum=`expr $n1 \/ $n2` \r\n     echo \"Div = \"$sum;; \r\n    *)echo \"Invalid choice\";; \r\nesac \r\necho \"Do u want to continue (y\/n)) ?\" \r\nread i \r\nif [ $i != \"y\" ] \r\nthen \r\n    exit \r\nfi \r\ndone<\/pre>\n
                Sample Output<\/h5>\n
                [root@tecmint \/]# .\/simplecalc.sh \r\n\r\nEnter one no. \r\n12 \r\nEnter second no. \r\n14 \r\n1.Addition \r\n2.Subtraction \r\n3.Multiplication \r\n4.Division \r\nEnter your choice \r\n1 \r\nSum =26 \r\nDo u want to continue (y\/n)) ? \r\ny\r\n1.Addition \r\n2.Subtraction \r\n3.Multiplication \r\n4.Division \r\nEnter your choice \r\n3 \r\nmul = 14812\r\nDo u want to continue (y\/n)) ? \r\nn<\/pre>\n
                Download simplecalc.sh<\/a><\/p>\n
                So did you saw how easy it was to create a powerful program as calculations such a simple way. Its\u2019 not the end. We will be comping up with at least one more article of this series, covering broad perspective from administration view.<\/p>\n
                That\u2019s all for now. Being the reader and the best critic don\u2019t forget to tell us how much and what you enjoyed in this article and what you want to see in the future article. Any question is highly welcome in comment. Till then stay\u00a0healthy<\/strong>,\u00a0safe<\/strong>\u00a0and\u00a0tuned<\/strong>.\u00a0Like<\/strong>\u00a0and\u00a0Share<\/strong>\u00a0us and help us spread.<\/p>\n
                Mathematical Aspect of Linux Shell Programming \u2013 Part IV<\/h1>\n
                In this post I will be discussing the Scripts<\/strong>\u00a0from the\u00a0Mathematical<\/strong>\u00a0and\u00a0Number<\/strong>\u00a0point of view. Although I have posted a more complex script (Simple Calculator<\/strong>) in the previous post, but on a user part it was difficult to understand and hence I thought to make you people learn the other useful side of learning in small packets.<\/p>\n
                \n
                \"Learn<\/a><\/p>\n
                Shell Scripting Part 4<\/p>\n<\/div>\n
                Prior to this article, three article of\u00a0Shell Scripting Series<\/strong>\u00a0are published and they are:<\/p>\n
                  \n
                1. Understand Linux Shell and Basic Shell Scripting \u2013 Part I<\/a><\/li>\n
                2. 5 Shell Scripts to Learn Shell Programming \u2013 Part II<\/a><\/li>\n
                3. Sailing Through The World of Linux BASH Scripting \u2013 Part III<\/a><\/li>\n<\/ol>\n
                  Let\u2019s start the further learning process with some new exciting scripts, start with\u00a0Mathematics<\/strong>\u00a0scripts:<\/p>\n
                  Script 1: Additions<\/h3>\n
                  Create a file \u201cAddition.sh<\/strong>\u201d and\u00a0chmod 755<\/strong>\u00a0to the script as described in previous post and run it.<\/p>\n
                  #!\/bin\/bash\r\necho \u201cEnter the First Number: \u201d \r\nread a \r\necho \u201cEnter the Second Number: \u201d \r\nread b \r\nx=$(expr \"$a\" + \"$b\") \r\necho $a + $b = $x<\/pre>\n
                  Sample Output<\/h5>\n
                  [root@tecmint ~]# vi Additions.sh\r\n[root@tecmint ~]# chmod 755 Additions.sh\r\n[root@tecmint ~]# .\/Additions.sh\r\n\r\n\u201cEnter the First Number: \u201d \r\n12 \r\n\u201cEnter the Second Number: \u201d \r\n13 \r\n12 + 13 = 25<\/pre>\n
                  Download Additions.sh<\/a><\/p>\n
                  Script 2: Substraction<\/h3>\n
                  #!\/bin\/bash\r\necho \u201cEnter the First Number: \u201d \r\nread a \r\necho \u201cEnter the Second Number: \u201d \r\nread b \r\nx=$(($a - $b)) \r\necho $a - $b = $x<\/pre>\n
                   <\/p>\n
                  Note<\/strong>: Here we replaced the\u00a0expr<\/strong>\u00a0and let the mathematical calculation be performed in shell.<\/p>\n
                  Sample Output<\/h5>\n
                  [root@tecmint ~]# vi Substraction.sh\r\n[root@tecmint ~]# chmod 755 Substraction.sh\r\n[root@tecmint ~]# .\/Substraction.sh\r\n\r\n\u201cEnter the First Number: \u201d \r\n13 \r\n\u201cEnter the Second Number: \u201d \r\n20 \r\n13 - 20 = -7<\/pre>\n
                  Download Substraction.sh<\/a><\/p>\n
                  Script 3: Multiplication<\/h3>\n
                  So far you would be enjoying a lot, learning scripts in such an easy way, so the next in chronological order is\u00a0Multiplication<\/strong>.<\/p>\n
                  #!\/bin\/bash\r\necho \u201cEnter the First Number: \u201d \r\nread a \r\necho \u201cEnter the Second Number: \u201d \r\nread b \r\necho \"$a * $b = $(expr $a \\* $b)\"<\/pre>\n
                  Note<\/strong>: Yup! Here we didn\u2019t put the value of multiplication in a variable but performed it directly in output statement.<\/p>\n
                  Sample Output<\/h5>\n
                  [root@tecmint ~]# vi Multiplication.sh\r\n[root@tecmint ~]# chmod 755 Multiplication.sh\r\n[root@tecmint ~]# .\/Multiplication.sh\r\n\r\n\u201cEnter the First Number: \u201d \r\n11 \r\n\u201cEnter the Second Number: \u201d \r\n11 \r\n11 * 11 = 121<\/pre>\n
                  Download Multiplication.sh<\/a><\/p>\n
                  Script 4: Division<\/h3>\n
                  Right! Next is\u00a0Division<\/strong>, and again it is a very simple script. Check it Yourself.<\/p>\n
                  #!\/bin\/bash\r\necho \u201cEnter the First Number: \u201d \r\nread a \r\necho \u201cEnter the Second Number: \u201d \r\nread b \r\necho \"$a \/ $b = $(expr $a \/ $b)\"<\/pre>\n
                  Sample Output<\/h5>\n
                  [root@tecmint ~]# vi Division.sh\r\n[root@tecmint ~]# chmod 755 Division.sh\r\n[root@tecmint ~]# .\/Division.sh\r\n\r\n\u201cEnter the First Number: \u201d \r\n12 \r\n\u201cEnter the Second Number: \u201d \r\n3 \r\n12 \/ 3 = 4<\/pre>\n
                  Download Division.sh<\/a><\/p>\n
                  Script 5: Table<\/h3>\n
                  Fine! What after these basic mathematical operation. Lets write a script that prints table of any number.<\/p>\n
                  #!\/bin\/bash\r\necho \u201cEnter The Number upto which you want to Print Table: \u201d \r\nread n \r\ni=1 \r\nwhile [ $i -ne 10 ] \r\ndo \r\ni=$(expr $i + 1) \r\ntable=$(expr $i \\* $n) \r\necho $table \r\ndone<\/pre>\n
                  Sample Output<\/h5>\n
                  [root@tecmint ~]# vi Table.sh\r\n[root@tecmint ~]# chmod 755 Table.sh\r\n[root@tecmint ~]# .\/Table.sh\r\n\r\n\u201cEnter The Number upto which you want to Print Table: \u201d \r\n29 \r\n58 \r\n87 \r\n116 \r\n145 \r\n174 \r\n203 \r\n232 \r\n261 \r\n290<\/pre>\n
                  Download Table.sh<\/a><\/p>\n
                  Script 6: EvenOdd<\/h3>\n
                  We as a child always have carried out calculation to find if the number is odd or even. Won\u2019t it be a good idea to implement it in script.<\/p>\n
                  #!\/bin\/bash\r\necho \"Enter The Number\" \r\nread n \r\nnum=$(expr $n % 2) \r\nif [ $num -eq 0 ] \r\nthen \r\necho \"is a Even Number\" \r\nelse \r\necho \"is a Odd Number\" \r\nfi<\/pre>\n
                  Sample Output<\/h5>\n
                  [root@tecmint ~]# vi EvenOdd.sh\r\n[root@tecmint ~]# chmod 755 EvenOdd.sh\r\n[root@tecmint ~]# .\/EvenOdd.sh\r\n\r\nEnter The Number \r\n12 \r\nis a Even Number<\/pre>\n
                  [root@tecmint ~]# .\/EvenOdd.sh\r\n\r\nEnter The Number \r\n11 \r\nis a Odd Number<\/pre>\n
                  Download EvenOdd.sh<\/a><\/p>\n
                  Script 7: Factorial<\/h3>\n
                  Next is to find the Factorial.<\/p>\n
                  #!\/bin\/bash \r\necho \"Enter The Number\" \r\nread a \r\nfact=1 \r\nwhile [ $a -ne 0 ] \r\ndo \r\nfact=$(expr $fact \\* $a) \r\na=$(expr $a - 1) \r\ndone \r\necho $fact<\/pre>\n
                  Sample Output<\/h5>\n
                  [root@tecmint ~]# vi Factorial.sh\r\n[root@tecmint ~]# chmod 755 Factorial.sh\r\n[root@tecmint ~]# .\/Factorial.sh\r\n\r\nEnter The Number \r\n12 \r\n479001600<\/pre>\n
                  You may now relax with a feeling that calculating\u00a012*11*10*9*7*7*6*5*4*3*2*1<\/strong>\u00a0would be more difficult than a simple script as produced above. Think of the situation where you require to find\u00a099!<\/strong>\u00a0or something like that. Sure! This script will be very much handy in that situation.<\/p>\n
                  Download Factorial.sh<\/a><\/p>\n
                  Script 8: Armstrong<\/h3>\n
                  Armstrong Number<\/strong>! Ohhh You forget what an\u00a0Armstrong Number<\/strong>\u00a0is. Well an Armstrong number of three digits is an integer such that the sum of the cubes of its digits is equal to the number itself. For example,\u00a0371<\/strong>\u00a0is an Armstrong number since\u00a03**3 + 7**3 + 1**3 = 371<\/strong>.<\/p>\n
                  #!\/bin\/bash \r\necho \"Enter A Number\" \r\nread n \r\narm=0 \r\ntemp=$n \r\nwhile [ $n -ne 0 ] \r\ndo \r\nr=$(expr $n % 10) \r\narm=$(expr $arm + $r \\* $r \\* $r) \r\nn=$(expr $n \/ 10) \r\ndone \r\necho $arm \r\nif [ $arm -eq $temp ] \r\nthen \r\necho \"Armstrong\" \r\nelse \r\necho \"Not Armstrong\" \r\nfi<\/pre>\n
                  Sample Output<\/h5>\n
                  [root@tecmint ~]# vi Armstrong.sh\r\n[root@tecmint ~]# chmod 755 Armstrong.sh\r\n[root@tecmint ~]# .\/Armstrong.sh\r\n\r\nEnter A Number \r\n371 \r\n371 \r\nArmstrong<\/pre>\n
                  [root@tecmint ~]# .\/Armstrong.sh\r\n\r\nEnter A Number \r\n123 \r\n36 \r\nNot Armstrong<\/pre>\n
                  Download Armstrong.sh<\/a><\/p>\n
                  Script 9: Prime<\/h3>\n
                  The last script is to distinguish whether a number is prime or not.<\/p>\n
                  #!\/bin\/bash \r\necho \u201cEnter Any Number\u201d\r\nread n\r\ni=1\r\nc=1\r\nwhile [ $i -le $n ]\r\ndo\r\ni=$(expr $i + 1)\r\nr=$(expr $n % $i)\r\nif [ $r -eq 0 ]\r\nthen\r\nc=$(expr $c + 1)\r\nfi\r\ndone\r\nif [ $c -eq 2 ]\r\nthen\r\necho \u201cPrime\u201d\r\nelse\r\necho \u201cNot Prime\u201d\r\nfi<\/pre>\n
                  Sample Output<\/h5>\n
                  [root@tecmint ~]# vi Prime.sh\r\n[root@tecmint ~]# chmod 755 Prime.sh\r\n[root@tecmint ~]# .\/Prime.sh\r\n\r\n\u201cEnter Any Number\u201d \r\n12 \r\n\r\n\u201cNot Prime\u201d<\/pre>\n
                  Download Prime.sh<\/a><\/p>\n
                  That\u2019s all for now. In our very next article we will be covering other mathematical programs in the shell Scripting programming language. Don\u2019t forget to mention your views regarding article in the Comment section. Like and share us and help us spread. Come Visiting\u00a0tecmint.com<\/strong>\u00a0for\u00a0News<\/strong>\u00a0and articles relating to\u00a0FOSS<\/strong>. Till then Stay tuned.<\/p>\n
                  Calculating Mathematical Expressions in Shell Scripting Language \u2013 Part V<\/h1>\n
                  You People would be feeling comfortable, understanding\u00a0Shell Scripts<\/strong>\u00a0and writing them fluently, as per your need. This is the last post of this tutorial series, where we will be carrying out a bit complex\u00a0Mathematical Operations<\/strong>\u00a0using scripting language. The last four articles of\u00a0Shell Scripting<\/strong>\u00a0series which are chronologically.<\/p>\n
                  \n
                  \"Learn<\/a><\/p>\n
                  Learn Shell Scripting Part \u2013 V<\/p>\n<\/div>\n
                    \n
                  1. Understand Basic Linux Shell Scripting Language Tips \u2013 Part I<\/a><\/li>\n
                  2. 5 Shell Scripts for Linux Newbies to Learn Shell Programming \u2013 Part II<\/a><\/li>\n
                  3. Sailing Through The World of Linux BASH Scripting \u2013 Part III<\/a><\/li>\n
                  4. Mathematical Aspect of Linux Shell Programming \u2013 Part IV<\/a><\/li>\n<\/ol>\n
                    Lets start with Fibonacci Series<\/h3>\n
                    A pattern of numbers where each number is the sum of two preceding numbers. The series is\u00a00<\/strong>,\u00a01<\/strong>,\u00a01<\/strong>,\u00a02<\/strong>,\u00a03<\/strong>,\u00a05<\/strong>,\u00a08<\/strong>\u2026\u2026 By definition, the first two numbers in the\u00a0Fibonccai<\/strong>\u00a0sequence are 0 and 1.<\/p>\n
                    Script 1: Fibonacci.sh<\/h5>\n
                    #!\/bin\/bash\r\necho \"How many numbers do you want of Fibonacci series ?\" \r\n  read total \r\n  x=0 \r\n  y=1 \r\n  i=2 \r\n  echo \"Fibonacci Series up to $total terms :: \" \r\n  echo \"$x\" \r\n  echo \"$y\" \r\n  while [ $i -lt $total ] \r\n  do \r\n      i=`expr $i + 1 ` \r\n      z=`expr $x + $y ` \r\n      echo \"$z\" \r\n      x=$y \r\n      y=$z \r\n  done<\/pre>\n
                    Sample Output<\/h5>\n
                    [root@tecmint ~]# chmod 755 Fibonacci.sh\r\n[root@tecmint ~]# .\/Fibonacci.sh\r\n\r\nHow many numbers do you want of Fibonacci series ? \r\n10 \r\nFibonacci Series up to 10 terms :: \r\n0 \r\n1 \r\n1 \r\n2 \r\n3 \r\n5 \r\n8 \r\n13 \r\n21 \r\n34<\/pre>\n
                    Download Fibonacci.sh<\/a><\/p>\n
                    You are Familiar with the fact that computer understand only in the Binary Format, i.e., \u20180<\/strong>\u2018 and \u20181<\/strong>\u2018 and most of us have enjoyed learning the conversion of\u00a0Decimal<\/strong>\u00a0to\u00a0Binary<\/strong>. How about writing a simple script for this complex operation.<\/p>\n
                    Script 2: Decimal2Binary.sh<\/h5>\n
                    #!\/bin\/bash \r\n\r\nfor ((i=32;i>=0;i--)); do \r\n        r=$(( 2**$i)) \r\n        Probablity+=( $r  ) \r\ndone \r\n\r\n[[ $# -eq 0 ]] &echo -en \"Decimal\\t\\tBinary\\n\" \r\nfor input_int in $@; do \r\ns=0 \r\ntest ${#input_int} -gt 11 &printf \"%-10s\\t\" \"$input_int\" \r\n\r\n        for n in ${Probablity[@]}; do \r\n\r\n                if [[ $input_int -lt ${n} ]]; then \r\n                        [[ $s = 1 ]] && printf \"%d\" 0 \r\n                else \r\n                        printf \"%d\" 1 ; s=1 \r\n                        input_int=$(( $input_int - ${n} )) \r\n                fi \r\n        done \r\necho -e \r\ndone<\/pre>\n
                    Sample Output<\/h5>\n
                    [root@tecmint ~]# chmod 755 Decimal2Binary.sh\r\n[root@tecmint ~]# .\/Decimal2Binary.sh 1121\r\n\r\nDecimal\t\tBinary \r\n1121      \t10001100001<\/pre>\n
                    Note<\/strong>: The above script accept Input at run time, which obviously is an aid.<\/p>\n
                    Download Decimal2Binary.sh<\/a><\/p>\n
                    Well the inbuilt \u2018bc<\/strong>\u2018 command can convert a\u00a0decimal<\/strong>\u00a0to\u00a0binary<\/strong>\u00a0in a script of single line. Run, at your terminal.<\/p>\n
                    [root@tecmint ~]# echo \"obase=2; NUM\" | bc<\/pre>\n
                    Replace \u2018NUM<\/strong>\u2018 with the number, which you want to convert from\u00a0Decimal<\/strong>\u00a0to\u00a0Binary<\/strong>. For example,<\/p>\n
                    [root@tecmint ~]# echo \"obase=2; 121\" | bc \r\n\r\n1111001<\/pre>\n
                    Next we will be writing a script which function just opposite of the above script,\u00a0Converting Binary Values<\/strong>\u00a0to\u00a0Decimal<\/strong>.<\/p>\n
                    Script 3: Binary2Decimal.sh<\/h5>\n
                    #!\/bin\/bash \r\necho \"Enter a number :\" \r\nread Binary \r\nif [ $Binary -eq 0 ] \r\nthen \r\necho \"Enter a valid number \" \r\nelse \r\nwhile [ $Binary -ne 0 ] \r\ndo \r\nBnumber=$Binary \r\nDecimal=0 \r\npower=1 \r\nwhile [ $Binary -ne 0 ] \r\ndo \r\nrem=$(expr $Binary % 10 ) \r\nDecimal=$((Decimal+(rem*power))) \r\npower=$((power*2)) \r\nBinary=$(expr $Binary \/ 10) \r\ndone \r\necho  \" $Decimal\" \r\ndone \r\nfi<\/pre>\n
                    Sample Output<\/h5>\n
                    [root@tecmint ~]# chmod 755 Binary2Decimal.sh\r\n[root@tecmint ~]# .\/Binary2Decimal.sh\r\n\r\nEnter a number : \r\n11 \r\n3<\/pre>\n
                    Note<\/strong>: The above function can be performed in terminal using \u2018bc<\/strong>\u2018 command as.<\/p>\n
                    [root@tecmint ~]# echo \"ibase=2; BINARY\" | bc<\/pre>\n
                    Replace \u2018BINARY<\/strong>\u2018 with the Binary number, viz.,<\/p>\n
                    [root@tecmint ~]# echo \"ibase=2; 11010101\" | bc \r\n\r\n213<\/pre>\n
                    Download Binary2Decimal.sh<\/a><\/p>\n
                    Similarly you can write conversion from\u00a0octal<\/strong>,\u00a0hexadecimal<\/strong>\u00a0to\u00a0decimal<\/strong>\u00a0and vice-versa yourself. Accomplishing the above result in terminal using \u2018bc<\/strong>\u2018 command is.<\/p>\n
                    Decimal to Octal<\/h5>\n
                    [root@tecmint ~]# echo \"obase=8; Decimal\" | bc<\/pre>\n
                    Decimal to Hexadecimal<\/h5>\n
                    [root@tecmint ~]# echo \"obase=16; Decimal\" | bc<\/pre>\n
                    Octal to Decimal<\/h5>\n
                    [root@tecmint ~]# echo \"ibase=8; Octal\" | bc<\/pre>\n
                    Hexadecimal to Decimal<\/h5>\n
                    [root@tecmint ~]# echo \"ibase=16; Hexadecimal\" | bc<\/pre>\n
                    Binary to Octal<\/h5>\n
                    [root@tecmint ~]# echo \"ibase=2;obase=8 Binary\" | bc<\/pre>\n
                    Some of the\u00a0Common Numeric<\/strong>\u00a0tests used in shell scripting language with description is.<\/p>\n
                    Test : INTEGER1 -eq INTEGER2\r\nMeaning: INTEGER1 is equal to INTEGER2<\/pre>\n
                    Test : INTEGER1 -ge INTEGER2\r\nMeaning: INTEGER1 is greater than or equal to INTEGER2<\/pre>\n
                    Test: INTEGER1 -gt INTEGER2\r\nMeaning: INTEGER1 is greater than INTEGER2<\/pre>\n
                    Test:INTEGER1 -le INTEGER2\r\nMeaning: INTEGER1 is less than or equal to INTEGER2<\/pre>\n
                    Test: INTEGER1 -lt INTEGER2\r\nMeaning: INTEGER1 is less than INTEGER2<\/pre>\n
                    Test: INTEGER1 -ne INTEGER2\r\nMeaning: INTEGER1 is not equal to INTEGER2<\/pre>\n
                    That\u2019s all for this article, and the article series. This is the last article of\u00a0Shell Script Series<\/strong>\u00a0and it does not means that no article on Scripting language will be here again, it only means the shell scripting tutorial is over and whenever we find an interesting topic worth knowing or a query from you people, we will be happy to continue the series from here.<\/p>\n
                    Stay healthy, tuned and connected to\u00a0Tecmint<\/strong>. Very soon I will be coming with another interesting topic, you people will love to read. Share your valuable thoughts in\u00a0Comment Section<\/strong>.<\/p>\n
                    Learning Shell Scripting Language: A Guide from Newbies to System Administrator<\/h1>\n
                    Linux<\/strong>\u00a0is built with certain powerful tools, which are unavailable in\u00a0Windows<\/strong>. One of such important tool is\u00a0Shell Scripting<\/strong>.\u00a0Windows<\/strong>\u00a0however comes with such a tool but as usual it is much weak as compared to it\u2019s\u00a0Linux Counterpart<\/strong>. Shell scripting\/programming makes it possible to execute command(s), piped to get desired output in order to automate day-to-day usages. In-fact automating these day-to-day task on server is an important task, system administrator has to perform and most of the admins achieve this by writing scripts to be executed as and when required.<\/p>\n
                    \n
                    \"Linux<\/a><\/p>\n
                    Linux Shell Script Guide<\/p>\n<\/div>\n
                    The most commonly used shell in\u00a0Linux<\/strong>\u00a0is\u00a0BASH<\/strong>\u00a0which stands for\u00a0Bourne Again Shell<\/strong>. Other Shell commonly found in Linux are:<\/p>\n
                      \n
                    1. Almquist shell (ash<\/strong>)<\/li>\n
                    2. Bourne shell (sh<\/strong>)<\/li>\n
                    3. Debian Almquist shell (dash<\/strong>)<\/li>\n
                    4. korn shell (ksh<\/strong>)<\/li>\n
                    5. Public domain korn shell (pdksh<\/strong>)<\/li>\n
                    6. MirBSD korn shell (mksh<\/strong>)<\/li>\n
                    7. Z shell (zsh<\/strong>)<\/li>\n
                    8. Busybox, etc.<\/li>\n<\/ol>\n
                      We have tried to cover a large variety of shell programming on a number of aspect in\u00a05 different posts<\/strong>.<\/p>\n
                      Understand Linux Shell and Basic Shell Scripting \u2013 Part I<\/h3>\n
                      I was a bit hesitating to write on scripting Language, as I was not sure if the users were going to accept it or not, but the response received is a history, in itself. We tried to provide you with the basic knowledge of scripting Language and how to use it, writing basic commands, Need of comment lines and how to write it, talking shebang, making a script executable and its\u2019 execution.<\/p>\n
                      Hello.sh<\/h5>\n
                       <\/p>\n
                      The first and the introductory script was aimed to get a simple output, thus making you comfortable with the world of shell scripting.<\/p>\n
                      Process.sh<\/h5>\n
                      The second script was there, to tell you how you can execute more than one command in a script, however not piped, at this stage.<\/p>\n
                      Interactive.sh<\/h5>\n
                      The third and last script of this post was a simple but very much interactive script which ask for you first name, store it, again ask for your last name, store it and address you with your full name, and last name in different lines of output.<\/p>\n
                      At the end of this post you were supposed to know how to execute Linux commands independently from a shell script, storing and manipulating data, as required and store data at the run-time.<\/p>\n
                      Shell Script Part I<\/strong>\u00a0:\u00a0Understand Linux Shell and Basic Shell Scripting Language<\/a><\/p>\n
                      Feeling proud with the response received on first article, writing next article of the series was the first thought, that hit my mind and hence the second article of the series was:<\/p>\n
                      5 Shell Scripts for Linux Newbies to Learn Scripting \u2013 Part II<\/h3>\n
                      Very much clear from the caption, here 5-Shell Scripts were listed. But to list which kind of script here, was a cumbersome job for us. We thought to dedicate this post to design and colours in shell. Our principal thinking behind this was to tell you that Linux terminal is not boring and colourless and you can perform your task in a very much colourful manner.<\/p>\n
                      Special_patter.sh<\/h5>\n
                      The first script of this post draws a special pattern, say a diamond pattern with dots(.), the implementation of for loop here was what you learned from this specific script.<\/p>\n
                      Colourfull.sh<\/h5>\n
                      The second script of this post, provided you with the output of several colours. You learned certain colour codes (not necessary to memorise) changing the text and background colour individually and the learning process was very much colourful<\/p>\n
                      Encrypt.sh<\/h5>\n
                      The third article of this post was a script of less than 10 lines, but was a very useful script which encrypts a file\/folder with password. Security implementation was never so easy ever. We didn\u2019t write a decryption script here, but provided you with the command you need to decrypt a file\/folder and ask you to write the decryption script yourself.<\/p>\n
                      Server-Health.sh<\/h5>\n
                      The fourth script of this post was a bit long script (long, at this point of learning) which reports server related information and can be redirected to a file for future reference. We utilised Linux commands in a pipelined fashion to get desired result and thus pipeline an important tool in scripting language, was in your knowledge.<\/p>\n
                      Disk_space.sh<\/h5>\n
                      The fifth and the last script of this post was a very useful script specially for web administrator, where automatic email will be send to user if the disk space crosses the limit. Let a user registered for 5 GB of web space and as soon as his web upload limit counts reaches 4.75 GB, an automatic email will be send to user for web space increment.<\/p>\n
                      Shell Script Part II<\/strong>\u00a0:\u00a05 Shell Scripts to Learn Shell Programming<\/a><\/p>\n
                      Sailing Through The World of Linux BASH Scripting \u2013 Part III<\/h3>\n
                      It was time to tell you about certain key words used and reserved in Scripting Language, so that we could refine our scripts in a very much professional manner. We discussed here, the implementation of Linux commands in shell script.<\/p>\n
                      up.sh<\/h5>\n
                      The first script of this post aimed to tell you how to move up a directory in shell script. Well during Linux package installation you would have seen that the file gets stored at several location, automatically and this script comes handy if you need any such task.<\/p>\n
                      Randomfile.sh<\/h5>\n
                      The second script of this post is a very useful script, and useful to Administrators. It can create unique file\/folder automatically with date and time stamp, so as to remove any chance of overwriting data.<\/p>\n
                      Collectnetworkinfo.sh<\/h5>\n
                      The third article of this post gathers information related to server and stores it into a text file, so that it could be sent\/stored for future references.<\/p>\n
                      Convertlowercase.sh<\/h5>\n
                      The fourth article of this post converts data either from the file or standard input to lowercase in a one go.<\/p>\n
                      Simplecacl.sh<\/h5>\n
                      The last article of this post is a simple calculator which is capable of doing four basic Mathematical operation interactively.<\/p>\n
                      Shell Script Part III<\/strong>\u00a0:\u00a0Sailing Through The World of Linux BASH Scripting<\/a><\/p>\n
                      Mathematical Aspect of Linux Shell Programming \u2013 Part IV<\/h3>\n
                      The mathematical theme based article is the result of an email I received, where a Linux Enthusiastic didn\u2019t understood the last script of the third post, yup! The calculator script. Well to simplify the mathematical operations, we created independent scripts for individual mathematical operation.<\/p>\n
                      Addition.sh<\/h5>\n
                      Very much clear from the name this script performs addition of two numbers. We have used \u2018expr\u2019 to perform the operation.<\/p>\n
                      Subtraction.sh<\/strong>,\u00a0Multiplication.sh<\/strong>,\u00a0Division.sh<\/strong>\u00a0are second, third and fourth script of the post respectively which performs mathematical operations according to their name.<\/p>\n
                      Table.sh<\/h5>\n
                      The fifth script of this post generates table of a number, which can be provided at run-time.<\/p>\n
                      EvenOdd.sh<\/h5>\n
                      The next script of the post checks if a number input from standard input is odd or even and prints the result on standard output.<\/p>\n
                      Factorial.sh<\/h5>\n
                      The seventh script of this post generates the factorial of a number. Calculating factorial on black and white (paper) is a painful task, but here it is a fun.<\/p>\n
                      Armstrong.sh<\/h5>\n
                      The script checks if a provided number is Armstrong or not.<\/p>\n
                      Prime.sh<\/h5>\n
                      The last script of this post check if a number is prime or not and generates the corresponding output.<\/p>\n
                      Shell Script Part IV<\/strong>\u00a0:\u00a0Mathematical Aspect of Linux Shell Programming<\/a><\/p>\n
                      Calculating Mathematical Expressions in Scripting \u2013 Part V<\/h3>\n
                      Fibonacci.sh<\/h5>\n
                      The first script of this post test if a number being entered is a Fibonacci or not.<\/p>\n
                      Decimal2Binary.sh<\/h5>\n
                      The second script of this post converts Decimal Number to Binary. This is one of the most common project you would have had in your summer vacation assignments.<\/p>\n
                      Binry2Decimal.sh<\/h5>\n
                      The third script of this post converts Binary Number back to decimal, just vice-versa of above process.<\/p>\n
                      However, we didn\u2019t wrote proper script for the below mathematical conversions but provided one liner command, so that you yourself can implement it in your own script.<\/p>\n
                        \n
                      1. Decimal to octal<\/li>\n
                      2. Decimal to Hexadecimal<\/li>\n
                      3. Octal to Decimal<\/li>\n
                      4. Hexadecimal to Decimal<\/li>\n
                      5. Binary to Octal , falls into the above category.<\/li>\n<\/ol>\n
                        Shell Script Part V<\/strong>\u00a0:\u00a0Calculating Mathematical Expressions in Shell Scripting Language<\/a><\/p>\n
                        We have tested all the scripts, ourselves to ensure, every script you get runs 100% perfectly in your terminal. Moreover, we have included sample output in most of the scripts, so that you don\u2019t gets confused.<\/p>\n
                        Well that\u2019s all for now, from me. I will be here again with an interesting article, you people will love to read. Till then keep connected to\u00a0Tecmint<\/strong>. Stay Fit, Healthy and Tuned. Don\u2019t forget to provide us with your valuable thoughts in comment, which is highly appreciated.<\/p>\n
                        10 Useful Chaining Operators in Linux with Practical Examples<\/h1>\n
                        Chaining of Linux commands means, combining several commands and make them execute based upon the behaviour of operator used in between them. Chaining of commands in Linux, is something like you are writing\u00a0short shell scripts<\/a>\u00a0at the shell itself, and executing them from the terminal directly. Chaining makes it possible to automate the process. Moreover, an unattended machine can function in a much systematic way with the help of chaining operators.<\/p>\n
                        \n
                        \"Chaining<\/a><\/p>\n
                        10 Chaining Operators in Linux<\/p>\n<\/div>\n
                        Read Also:<\/b>\u00a0How to Use Awk and Regular Expressions to Filter Text in Files<\/a><\/p>\n
                        This Article aims at throwing light on frequently used\u00a0command\u00ad-chaining operators<\/strong>, with short descriptions and corresponding examples which surely will increase your productivity and lets you write short and meaningful codes beside reducing system load, at times.<\/p>\n
                        1. Ampersand Operator (&)<\/h3>\n
                        The function of \u2018&<\/strong>\u2018 is to make the command run in background. Just type the command followed with a white space and \u2018&<\/strong>\u2018. You can execute more than one command in the background, in a single go.<\/p>\n
                        Run one command in the background:<\/p>\n
                        tecmint@localhost:~$ ping \u00adc5 www.tecmint.com &<\/pre>\n
                         <\/p>\n
                        Run two command in background, simultaneously:<\/p>\n
                        root@localhost:\/home\/tecmint# apt-get update & apt-get upgrade &<\/pre>\n
                        2. semi-colon Operator (;)<\/h3>\n
                        The semi-colon operator makes it possible to run, several commands in a single go and the execution of command occurs sequentially.<\/p>\n
                        root@localhost:\/home\/tecmint# apt-get update ; apt-get upgrade ; mkdir test<\/pre>\n
                        The above command combination will first execute\u00a0update<\/strong>\u00a0instruction, then\u00a0upgrade<\/strong>\u00a0instruction and finally will create a \u2018test<\/strong>\u2018 directory under the current working directory.<\/p>\n
                        3. AND Operator (&&)<\/h3>\n
                        The\u00a0AND Operator<\/strong>\u00a0(&&<\/strong>) would execute the second command only, if the execution of first command\u00a0SUCCEEDS<\/strong>, i.e., the exit status of the first command is\u00a00<\/strong>. This command is very useful in checking the execution status of last command.<\/p>\n
                        For example, I want to visit website\u00a0tecmint.com<\/strong>\u00a0using\u00a0links command<\/a>, in terminal but before that I need to check if the host is\u00a0live<\/strong>\u00a0or\u00a0not<\/strong>.<\/p>\n
                        root@localhost:\/home\/tecmint# ping -c3 www.tecmint.com && links www.tecmint.com<\/pre>\n
                        4. OR Operator (||)<\/h3>\n
                        The\u00a0OR Operator<\/strong>\u00a0(||<\/strong>) is much like an \u2018else<\/strong>\u2018 statement in programming. The above operator allow you to execute second command only if the execution of first command fails, i.e., the exit status of first command is \u20181<\/strong>\u2018.<\/p>\n
                        For example, I want to execute \u2018apt-get update<\/strong>\u2018 from non-root account and if the first command fails, then the second\u00a0\u2018links www.tecmint.com<\/strong>\u2018 command will execute.<\/p>\n
                        tecmint@localhost:~$ apt-get update || links tecmint.com<\/pre>\n
                        In the above command, since the\u00a0user<\/strong>\u00a0was not allowed to\u00a0update<\/strong>\u00a0system, it means that the exit status of first command is\u00a0\u20181\u2019<\/strong>\u00a0and hence the last command \u2018links tecmint.com<\/strong>\u2018 gets executed.<\/p>\n
                        What if the first command is executed successfully, with an exit status \u20180<\/strong>\u2018? Obviously! Second command won\u2019t execute.<\/p>\n
                        tecmint@localhost:~$ mkdir test || links tecmint.com<\/pre>\n
                        Here, the user creates a folder \u2018test<\/strong>\u2018 in his home directory, for which user is permitted. The command executed successfully giving an exit status \u20180<\/strong>\u2018 and hence the last part of the command is not executed.<\/p>\n
                        5. NOT Operator (!)<\/h3>\n
                        The\u00a0NOT Operator<\/strong>\u00a0(!<\/strong>) is much like an \u2018except<\/strong>\u2018 statement. This command will execute all except the condition provided. To understand this, create a directory \u2018tecmint<\/strong>\u2018 in your home directory and \u2018cd<\/strong>\u2018 to it.<\/p>\n
                        tecmint@localhost:~$ mkdir tecmint \r\ntecmint@localhost:~$ cd tecmint<\/pre>\n
                        Next, create several types of files in the folder \u2018tecmint<\/strong>\u2018.<\/p>\n
                        tecmint@localhost:~\/tecmint$ touch a.doc b.doc a.pdf b.pdf a.xml b.xml a.html b.html<\/pre>\n
                        See we\u2019ve created all the new files within the folder \u2018tecmint<\/strong>\u2018.<\/p>\n
                        tecmint@localhost:~\/tecmint$ ls \r\n\r\na.doc  a.html  a.pdf  a.xml  b.doc  b.html  b.pdf  b.xml<\/pre>\n
                        Now delete all the files except \u2018html<\/strong>\u2018 file all at once, in a smart way.<\/p>\n
                        tecmint@localhost:~\/tecmint$ rm -r !(*.html)<\/pre>\n
                        Just to verify, last execution. List all of the available files using\u00a0ls command<\/a>.<\/p>\n
                        tecmint@localhost:~\/tecmint$ ls \r\n\r\na.html  b.html<\/pre>\n
                        6. AND \u2013 OR operator (&& \u2013 ||)<\/h3>\n
                        The above operator is actually a combination of \u2018AND<\/strong>\u2018 and \u2018OR<\/strong>\u2018 Operator. It is much like an \u2018if-else<\/strong>\u2018 statement.<\/p>\n
                        For example, let\u2019s do ping to\u00a0tecmint.com<\/strong>, if success echo \u2018Verified<\/strong>\u2018 else echo \u2018Host Down<\/strong>\u2018.<\/p>\n
                        tecmint@localhost:~\/tecmint$ ping -c3 www.tecmint.com && echo \"Verified\" || echo \"Host Down\"<\/pre>\n
                        Sample Output<\/h5>\n
                        PING www.tecmint.com (212.71.234.61) 56(84) bytes of data. \r\n64 bytes from www.tecmint.com (212.71.234.61): icmp_req=1 ttl=55 time=216 ms \r\n64 bytes from www.tecmint.com (212.71.234.61): icmp_req=2 ttl=55 time=224 ms \r\n64 bytes from www.tecmint.com (212.71.234.61): icmp_req=3 ttl=55 time=226 ms \r\n\r\n--- www.tecmint.com ping statistics --- \r\n3 packets transmitted, 3 received, 0% packet loss, time 2001ms \r\nrtt min\/avg\/max\/mdev = 216.960\/222.789\/226.423\/4.199 ms \r\nVerified<\/strong><\/pre>\n
                        Now, disconnect your internet connection, and try same command again.<\/p>\n
                        tecmint@localhost:~\/tecmint$ ping -c3 www.tecmint.com && echo \"verified\" || echo \"Host Down\"<\/pre>\n
                        Sample Output<\/h5>\n
                        ping: unknown host www.tecmint.com \r\nHost Down<\/strong><\/pre>\n
                        7. PIPE Operator (|)<\/h3>\n
                        This\u00a0PIPE<\/strong>\u00a0operator is very useful where the output of first command acts as an input to the second command. For example, pipeline the output of \u2018ls -l<\/strong>\u2018 to \u2018less<\/strong>\u2018 and see the output of the command.<\/p>\n
                        tecmint@localhost:~$ ls -l | less<\/pre>\n
                        8. Command Combination Operator {}<\/h3>\n
                        Combine two or more commands, the second command depends upon the execution of the first command.<\/p>\n
                        For example, check if a directory \u2018bin<\/strong>\u2018 is available or not, and output corresponding output.<\/p>\n
                        tecmint@localhost:~$ [ -d bin ] || { echo Directory does not exist, creating directory now.; mkdir bin; } && echo Directory exists.\r\n<\/pre>\n
                        9. Precedence Operator ()<\/h3>\n
                        The Operator makes it possible to execute command in precedence order.<\/p>\n
                        Command_x1 &&Command_x2 || Command_x3 && Command_x4.<\/pre>\n
                        In the above pseudo command, what if the\u00a0Command_x1<\/strong>\u00a0fails? Neither of the\u00a0Command_x2<\/strong>,\u00a0Command_x3<\/strong>,\u00a0Command_x4<\/strong>\u00a0would executed, for this we use\u00a0Precedence Operator<\/strong>, as:<\/p>\n
                        (Command_x1 &&Command_x2) || (Command_x3 && Command_x4)<\/pre>\n
                        In the above pseudo command, if\u00a0Command_x1<\/strong>\u00a0fails,\u00a0Command_x2<\/strong>\u00a0also fails but Still\u00a0Command_x3<\/strong>\u00a0and\u00a0Command_x4<\/strong>\u00a0executes depends upon exit status of\u00a0Command_x3<\/strong>.<\/p>\n
                        10. Concatenation Operator (\\)<\/h3>\n
                        The\u00a0Concatenation Operator<\/strong>\u00a0(\\<\/strong>) as the name specifies, is used to concatenate large commands over several lines in the shell. For example, The below command will open text file\u00a0test(1).txt<\/strong>.<\/p>\n
                        tecmint@localhost:~\/Downloads$ nano test\\(1\\).txt<\/pre>\n
                        That\u2019s all for now. I am coming up with another interesting article very soon.<\/p>\n
                        rbash \u2013 A Restricted Bash Shell Explained with Practical Examples<\/h1>\n
                        Linux Shell<\/strong>\u00a0is one of the most fascinating and powerful\u00a0GNU<\/strong>\/Linux<\/strong>\u00a0powered tool. All the application, including\u00a0X<\/strong>, is built over shell and Linux shell is so powerful that the whole Linux system can be controlled precisely, using it. The other aspect of Linux shell is that, it can be potentially harmful, when you executed a system command, without knowing its consequence or unknowingly.<\/p>\n
                        \n
                        \"Restrict<\/a><\/p>\n
                        Restricted Bash Shell<\/p>\n<\/div>\n
                        Being an ignorant user. For this purpose we are introducing restricted shell. We will be discussing restricted shell in details, the restrictions implemented, and a lot more.<\/p>\n
                        What is rbash?<\/h3>\n
                        The\u00a0Restricted Shell<\/strong>\u00a0is a Linux Shell that restrict some of the features of bash shell, and is very clear from the name. The restriction is well implemented for the command as well as script running in restricted shell. It provides an additional layer for security to bash shell in Linux.<\/p>\n
                        Restrictions Implemented in rbash<\/h3>\n
                          \n
                        1. cd command (Change Directory)<\/li>\n
                        2. PATH (setting\/ unsetting)<\/li>\n
                        3. ENV aka BASH_ENV (Environment Setting\/ unsetting)<\/li>\n
                        4. Importing Function<\/li>\n
                        5. Specifying file name containing argument \u2018\/\u2019<\/li>\n
                        6. Specifying file name containing argument \u2018-\u2018<\/li>\n
                        7. Redirecting output using \u2018><\/strong>\u2018, \u2018>><\/strong>\u2018, \u2018>|<\/strong>\u2018, \u2018<><\/strong>\u2018, \u2018>&<\/strong>\u2018, \u2018&><\/strong>\u2018<\/li>\n
                        8. turning off restriction using \u2018set +r<\/strong>\u2018 or \u2018set +o<\/strong>\u2018<\/li>\n<\/ol>\n
                          Note<\/strong>: Restrictions of rbash is enforced after any startup files are read.<\/p>\n
                          Enabling Restricted Shell<\/h3>\n
                           <\/p>\n
                          In some version of\u00a0GNU<\/strong>\/Linux<\/strong>\u00a0viz.,\u00a0Red Hat<\/strong>\/CentOS<\/strong>, rbash may not be implemented directly and needs symbolic links to be created.<\/p>\n
                          # cd \/bin\r\n\r\n# ln -s bash rbash<\/pre>\n
                          In most of the today\u2019s\u00a0GNU<\/strong>\/Linux<\/strong>\u00a0standard distributions, rbash is available by default. If not, you can\u00a0download source tarball<\/a>\u00a0and install it from source in your system.<\/p>\n
                          Starting rbash<\/h4>\n
                          To start rbash restricted shell in Linux, execute the following command.<\/p>\n
                          # bash -r\r\n\r\nOR\r\n\r\n# rbash<\/pre>\n
                          Note<\/strong>: If rbash is started successfully, it returns 0.<\/p>\n
                          Testing a Few Restrictions<\/h4>\n
                          Here, we executing few commands on the rbash shell to check restrictions.<\/p>\n
                          # cd\r\n\r\nrbash: cd: restricted<\/strong><\/pre>\n
                          # pwd > a.txt\r\n\r\nbash: a.txt: restricted: cannot redirect outpu<\/strong>t<\/pre>\n
                          Pros of Restricted Shell<\/h5>\n
                            \n
                          1. Restricted shell is used in conjunction with a chroot jail, in a further attempt to limit access to the system as a whole.<\/li>\n<\/ol>\n
                            Cons of Restricted Shell<\/h5>\n
                              \n
                            1. Insufficient to allow execution of entirely untrusted software.<\/li>\n
                            2. When a command that is found to be a shell script is executed, rbash turns off any restrictions in the shell spawned to execute the script.<\/li>\n
                            3. When users run bash or dash from rbash then they got unrestricted shells.<\/li>\n
                            4. rbash should only be used within a chroot unless you know what you are doing.<\/li>\n
                            5. There are many ways to break out a restricted bash shell that are not easy to predict in advance.<\/li>\n<\/ol>\n
                              Conclusion<\/h3>\n
                              rbash is a fantastic tool to work on, within restricted environment and works brilliant. You must give it a try and you wont be disappointed.<\/p>\n
                              That\u2019s all for now. I\u2019ll soon be here again here with another interesting and knowledgeable topic you people would love to read. Don\u2019t forget to provide us with your valuable feedback in our comment section.<\/p>\n
                              Accessing Clipboard Contents Across Multiple Instances of Vim from Terminal<\/h1>\n
                              Vim<\/strong>\u00a0(Vi IMproved<\/strong>) is one of the most favourite text editors among programmers. It has its own specialities in performing different operations with short hand commands.<\/p>\n
                              \n
                              \"Accessing<\/a><\/p>\n
                              Accessing Clipboard Contents from Vim<\/p>\n<\/div>\n
                              For example, to copy the highlighted text we use the \u2018y<\/strong>\u2018 command and \u2018x<\/strong>\u2018 to cut the same. But, by default\u00a0vim<\/strong>(and not\u00a0gVim<\/strong>) clipboard contents cannot be accessed after closing vim instances.<\/p>\n
                              Vim uses the \u2018+<\/strong>\u2018 register to refer to the system clipboard. You can run \u2018vim \u00ad\u00ad\u2013version<\/strong>\u2018 and if you cannot see something like \u201c+xterm_clipboard<\/strong>\u201d and instead \u201c\u00adxterm_clipboard<\/strong>\u201c, then internal clipboard contents will not be available outside\u00a0vim<\/strong>.<\/p>\n
                              Install gvim and parcellite<\/h4>\n
                              In order to access the vim clipboard contents, you need to install\u00a0gvim<\/strong>\u00a0package. The\u00a0gVim<\/strong>\u00a0is a GUI mode for vim editor where clipboard option is enabled by default.<\/p>\n
                              # yum install -y gvim<\/pre>\n
                               <\/p>\n
                              Next, enable\u00a0RPMForge Repository<\/a>\u00a0to install\u00a0parcellite<\/strong>\u00a0package. The Parcellite is a lightweight, tiny and free clipboard manager for Linux.<\/p>\n
                              # yum install -y parcellite<\/pre>\n
                              Once installed, run the following command. Where argument \u2018&<\/strong>\u2019 is used to send parcellite for running as a background process.<\/p>\n
                              # parcellite &<\/pre>\n
                              Check whether the option is enabled in gvim.<\/p>\n
                              # gvim --version<\/pre>\n
                              Make sure you have the \u201c+xterm_clipboard<\/strong>\u201d option displayed in the output as shown below.<\/p>\n
                              VIM - Vi IMproved 7.2 (2008 Aug 9, compiled Apr  5 2012 10:12:08)\r\nIncluded patches: 1-411\r\nModified by <bugzilla@redhat.com>\r\nCompiled by <bugzilla@redhat.com>\r\nHuge version with GTK2 GUI.  Features included (+) or not (-):\r\n+arabic +autocmd +balloon_eval +browse ++builtin_terms +byte_offset +cindent \r\n+clientserver +clipboard +cmdline_compl +cmdline_hist +cmdline_info +comments \r\n+cryptv +cscope +cursorshape +dialog_con_gui +diff +digraphs +dnd -ebcdic \r\n+emacs_tags +eval +ex_extra +extra_search +farsi +file_in_path +find_in_path \r\n+float +folding -footer +fork() +gettext -hangul_input +iconv +insert_expand \r\n+jumplist +keymap +langmap +libcall +linebreak +lispindent +listcmds +localmap \r\n+menu +mksession +modify_fname +mouse +mouseshape +mouse_dec +mouse_gpm \r\n-mouse_jsbterm +mouse_netterm -mouse_sysmouse +mouse_xterm +multi_byte \r\n+multi_lang -mzscheme +netbeans_intg -osfiletype +path_extra +perl +postscript \r\n+printer +profile +python +quickfix +reltime +rightleft -ruby +scrollbind \r\n+signs +smartindent -sniff +startuptime +statusline -sun_workshop +syntax \r\n+tag_binary +tag_old_static -tag_any_white -tcl +terminfo +termresponse \r\n+textobjects +title +toolbar +user_commands +vertsplit +virtualedit +visual \r\n+visualextra +viminfo +vreplace +wildignore +wildmenu +windows +writebackup \r\n+X11 -xfontset +xim +xsmp_interact +xterm_clipboard<\/strong> -xterm_save<\/pre>\n
                              Open up user\u2019s .bashrc file.<\/p>\n
                              # vim ~\/.bashrc<\/pre>\n
                              And add the alias and save the file (press \u2018i<\/strong>\u2019 to insert line and press\u00a0ESC<\/strong>, then run\u00a0:wq<\/strong>\u00a0to save and exit).<\/p>\n
                              # .bashrc\r\n\r\n# User specific aliases and functions\r\n\r\nalias rm='rm -i'\r\nalias cp='cp -i'\r\nalias mv='mv -i'\r\nalias vim='gvim -v'<\/strong>\r\n# Source global definitions\r\nif [ -f \/etc\/bashrc ]; then\r\n        . \/etc\/bashrc\r\nfi<\/pre>\n
                              This alias is a built-in used to bypass some command to another. Thus every time when vim command is issued, the corresponding alias goes to gvim with clipboard enabled by default.<\/p>\n
                              Now edit your \u2018.vimrc<\/strong>\u2018 file in a similar way (In case if you don\u2019t have a\u00a0.vimrc<\/strong>\u00a0file, generate one such file through and then get back here.<\/p>\n
                              # vim ~\/.vimrc<\/pre>\n
                              Append the following line and save the file.<\/p>\n
                              autocmd VimLeave * call system(\"echo -n $'\" . escape(getreg(), \"'\") . \"' | xsel -ib\")<\/pre>\n
                              Now open any file in vim and highlight the portion of text (using \u2018v\u2018 command) and press \u201c+y. Try to paste anywhere outside vim (after closing or without closing vim) and you are done.<\/p>\n
                              Generating .vimrc File<\/h4>\n
                              Run the following command to generate\u00a0.vimrc<\/strong>\u00a0file (skip this part if you already have one).<\/p>\n
                              # cd   [This will put you in home directory]       \r\n# vim .vimrc<\/pre>\n
                              In vim run the following after pressing the ESC key (In vim every command is run after pressing ESC key which puts you in command mode).<\/p>\n
                              :r $VIMRUNTIME\/vimrc_example.vim \r\n:w<\/pre>\n
                              Understanding and Writing functions in Shell Scripts \u2013 Part VI<\/h1>\n
                              Functions play an important role in any programming language. Like many real programming languages, bash has functions which are used with limited implementation.<\/p>\n
                              \n
                              \"Shell<\/a><\/p>\n
                              Understanding Linux Shell Script Functions<\/p>\n<\/div>\n
                              What are functions?<\/h3>\n
                              In programming, functions are named sections of a program that performs a specific task. In this sense, a function is a type of procedure or routine. When a function is called the program leaves the current section of code and begins to execute the first line inside the function. Whenever there is repetitive code or when a task repeats, consider using a function instead.<\/p>\n
                              For example, consider the case where we need to\u00a0find the factorial of a number at several stages of a particular program. Instead of writing the whole code (for calculating the factorial) each and every time, we can write that part of code which calculates the factorial once inside a block and reuse the same at multiple occasions.<\/p>\n
                              Why do we write functions?<\/h4>\n
                                \n
                              1. It helps us to reuse the code.<\/li>\n
                              2. Improve the readability of program.<\/li>\n
                              3. Efficient use of variables inside the program.<\/li>\n
                              4. Allows us to test the program part by part.<\/li>\n
                              5. Displays program\u00a0as a bunch of sub-steps.<\/li>\n<\/ol>\n
                                Functions in shell scripts<\/h5>\n
                                The general syntax for writing functions in shell script includes the following ways.<\/p>\n
                                function func_name {\r\n\t. . .\r\n\tcommands\r\n\t. . .\r\n}\r\n\r\nor\r\n\r\nfunc_name ( ) {\r\n\t. . .\r\n\tcommands\r\n\t. . .\r\n}\r\n\r\nOpening curly braces can also be used in the second line as well.\r\n\r\nfunc_name ( )\r\n{\r\n\t. . .\r\n\tcommands\r\n\t. . .\r\n}<\/pre>\n
                                 <\/p>\n
                                You are always free to write valid commands inside these function blocks as we do normally in shell scripts. Now let\u2019s try to write one simple script with a small function inside it.<\/p>\n
                                #!\/bin\/bash\r\n\r\ncall_echo ( ) {\r\n\techo \u2018This is inside function\u2019\r\n}\r\n\r\nop=$1\r\n\r\nif [ $# -ne 1 ]; then\r\n\techo \"Usage: $0 <1\/0>\"\r\nelse\r\n\tif [ $1 = 0 ] ; then\r\n\t\techo \u2018This is outside function\u2019\r\n\telif [ $1 = 1 ] ; then\r\n\t\tcall_echo\r\n\telse\r\n\t\techo \u2018Invalid argument\u2019\r\n\tfi\r\nfi\r\n\r\nexit 0<\/pre>\n
                                The function definition must precede the first call to it. There is nothing like \u2018declaring the function\u2019 before calling it. And we can always nest functions inside functions.<\/p>\n
                                Note<\/strong>:- Writing empty functions always results in syntax errors.<\/p>\n
                                When same function is defined multiple times, the final version is what is invoked. Let\u2019s take an example.<\/p>\n
                                #!\/bin\/bash\r\n\r\nfunc_same ( ) {\r\n\techo \u2018First definition\u2019\r\n}\r\n\r\nfunc_same ( ) {\r\n\techo \u2018Second definition\u2019\r\n}\r\n\r\nfunc_same\r\n\r\nexit 0<\/pre>\n
                                Functions taking parameters and returning values<\/h5>\n
                                Let\u2019s get deeper by considering functions taking parameters and returning values. To return a value from a function we use the \u2018return\u2019 shell built-in. Syntax is as follows.<\/p>\n
                                func_name ( ) {\r\n\t. . .\r\n\tcommands\r\n\t. . .\r\n\treturn $ret_val\r\n}<\/pre>\n
                                Similarly we can pass arguments to the functions separated with spaces as given below.<\/p>\n
                                func_name $arg_1 $arg_2 $arg_3<\/pre>\n
                                Inside the function we can access the arguments in order as $1, $2, $3 and so on. Look at the following example script to find the maximum of two integers using function to add more clarity.<\/p>\n
                                #!\/bin\/bash\r\n\r\nUSG_ERR=7\r\n\r\nmax_two ( ) {\r\n\tif [ \"$1\" -eq \"$2\" ] ; then\r\n\t\techo 'Equal'\r\n\t\texit 0\r\n\telif [ \"$1\" -gt \"$2\" ] ; then\r\n\t\techo $1\r\n\telse\r\n\t\techo $2\r\n\tfi\r\n}\r\n\r\nerr_str ( ) {\r\n\techo \"Usage: $0 <number1>  <number2>\"\r\n\texit $USG_ERR\r\n}\r\n\r\nNUM_1=$1\r\nNUM_2=$2\r\nx\r\nif [ $# -ne 2 ] ; then\r\n\terr_str\r\nelif [ `expr $NUM_1 : '[0-9]*'` -eq ${#NUM_1} ] ; then\r\n\tif [ `expr $NUM_2 : '[0-9]*'` -eq ${#NUM_2} ] ; then  \r\n\t\tmax_two $NUM_1 $NUM_2\r\n\telse\r\n\t\terr_str\r\n\tfi\r\nelse\r\n\terr_str\r\nfi\r\n\r\nexit 0<\/pre>\n
                                The above looks like a bit complex, but it\u2019s simple if we read through the lines. First nested if-else if lines for validation purposes i.e., to check number and type of arguments with the help of regular expressions. After that we call the function with two command line arguments and displays the result there itself. This is because we cannot return large integers from a function. Another way to work around this problem is to use global variables to store the result inside function. The script below explains this method.<\/p>\n
                                #!\/bin\/bash\r\n\r\nUSG_ERR=7\r\nret_val=\r\n\r\nmax_two ( ) {\r\n\tif [ \"$1\" -eq \"$2\" ] ; then\r\n\t\techo 'Equal'\r\n\t\texit 0\r\n\telif [ \"$1\" -gt \"$2\" ] ; then\r\n\t\tret_val=$1\r\n\telse\r\n\t\tret_val=$2\r\n\tfi\r\n}\r\n\r\nerr_str ( ) {\r\n\techo \"Usage: $0 <number1>  <number2>\"\r\n\texit $USG_ERR\r\n}\r\n\r\nNUM_1=$1\r\nNUM_2=$2\r\n\r\nif [ $# -ne 2 ] ; then\r\n\terr_str\r\nelif [ `expr $NUM_1 : '[0-9]*'` -eq ${#NUM_1} ] ; then\r\n\tif [ `expr $NUM_2 : '[0-9]*'` -eq ${#NUM_2} ] ; then  \r\n\t\tmax_two $NUM_1 $NUM_2\r\n\t\techo $ret_val\r\n\telse\r\n\t\terr_str\r\n\tfi\r\nelse\r\n\terr_str\r\nfi\r\n\r\nexit 0<\/pre>\n
                                Now try out some exciting problems that were explained in the previous shell scripting series using functions as follows.<\/p>\n
                                  \n
                                1. Understand Basic Linux Shell Scripting Language Tips \u2013 Part I<\/a><\/li>\n
                                2. 5 Shell Scripts for Linux Newbies to Learn Shell Programming \u2013 Part II<\/a><\/li>\n
                                3. Sailing Through The World of Linux BASH Scripting \u2013 Part III<\/a><\/li>\n
                                4. Mathematical Aspect of Linux Shell Programming \u2013 Part IV<\/a><\/li>\n
                                5. Calculating Mathematical Expressions in Shell Scripting Language \u2013 Part V<\/a><\/li>\n<\/ol>\n
                                  I will get back with more insight to functional features like using local variables, recursion etc in the next part. Stay updated with comments.<\/p>\n
                                  Deeper into Function Complexities with Shell Scripting \u2013 Part VII<\/h1>\n
                                  My previous article on \u201cUnderstanding and Writing functions in Shell Scripts<\/a>\u201d might have given you a basic idea on how to write functions under shell scripts. Now it is time to get deeper into functional features like the usage of local variables and recursion.<\/p>\n
                                  \n
                                  \"Learn<\/a><\/p>\n
                                  Function Complexities with Shell Scripting<\/p>\n<\/div>\n
                                  Local Variables<\/h4>\n
                                  What makes a variable local? It depends on that particular block where the variable is declared. A variable declared as\u00a0local<\/em>\u00a0will be accessible from that block of code where it appears i.e. its scope is local. In order to explain this thing let\u2019s look into one example below.<\/p>\n
                                  #!\/bin\/bash \r\n\r\nfunc( ) { \r\n\tlocal i=10 \r\n\tj=20 \r\n\techo \"i from func = $i\" \r\n\techo \"j from func = $j\" \r\n} \r\n\r\necho \"i outside func = $i\" \r\necho \"j outside func = $j\" \r\n\r\nfunc \r\n\r\necho \"i outside func = $i\" \r\necho \"j outside func = $j\" \r\n\r\nexit 0<\/pre>\n
                                  On executing the above script the output will be.<\/p>\n
                                  i outside func = \r\nj outside func = \r\ni from func = 10 \r\nj from func = 20 \r\ni outside func = \r\nj outside func = 20<\/pre>\n
                                  This is because the function\u00a0func<\/em>\u00a0has not yet called while the\u00a0first 2<\/strong>\u00a0echo statements were executed. After calling the function\u00a0func<\/em>\u00a0the same\u00a02 echo statements<\/strong>\u00a0produce a different result. Now the variable\u00a0j<\/em>, which was declared inside\u00a0func<\/em>\u00a0and not local, could be accessed afterwards.<\/p>\n
                                   <\/p>\n
                                  Thus value for\u00a0j<\/em>\u00a0becomes\u00a020<\/strong>. What about the local variable\u00a0i<\/em>? Since its scope was inside the function\u00a0func<\/em>, value\u00a010<\/strong>\u00a0could not be accessed from outside. Note that the variable\u00a0j<\/em>\u00a0normally declared inside\u00a0func<\/em>\u00a0is global by default.<\/p>\n
                                  Now you are familiar with local variables and how to use them inside function blocks. Let us move on to the most interesting section under functions, the recursion.<\/p>\n
                                  What is Recursion?<\/h4>\n
                                  A function calling itself is generally termed as the recursion procedure. Or it can be defined as expressing an algorithm by using a simpler version of that same algorithm. Consider the example of finding factorial of a number. We know that\u00a0n! = 1 x 2 x 3 x \u2026 x (n-1) x n<\/strong>. Thus we can write a recurrence relation as:<\/p>\n
                                  n! = (n-1)! x n<\/pre>\n
                                  So its easy for us to recursively call the same function and use the return value from each call to multiply with the previous result, i.e.<\/p>\n
                                  5! = 4! x 5\r\n4! = 3! x 4\r\n3! = 2! x 3\r\n2! = 1! x 2\r\n1! = 0! x 1<\/pre>\n
                                  Recursion using Local Variables<\/h4>\n
                                  Here we try to write a script for finding factorial of a number using local variables and recursion.<\/p>\n
                                  #!\/bin\/bash \r\n\r\nfact( ) { \r\n\tlocal num=$1 \r\n\tif [ $num -eq 0 ]; then \r\n\t\tret=1 \r\n\telse \r\n\t\ttemp=$((num-1)) \r\n\t\tfact $temp \r\n\t\tret=$((num*$?)) \r\n\tfi \r\n\treturn $ret \r\n} \r\n\r\nfact 5 \r\n\r\necho \"Factorial of 5 = $?\" \r\n\r\nexit 0<\/pre>\n
                                  num<\/em>\u00a0is a local variable used to store each\u00a0n-1<\/strong>\u00a0value on each call. Here the base condition checks whether the number is equal to zero or not (since 0! = 1 and factorial is not defined for negative numbers). On arriving this base condition it returns the value\u00a01<\/strong>\u00a0to its caller. Now\u00a0num = 1<\/em>\u00a0and\u00a0ret = 1 x 1<\/em>.<\/p>\n
                                  At this instant it returns\u00a01<\/strong>\u00a0to its caller. Now\u00a0num = 2<\/em>\u00a0and\u00a0ret = 2 x 1<\/em>\u00a0and so on. Finally when\u00a0num = 5<\/em>\u00a0return value will be\u00a024<\/strong>\u00a0and final result is\u00a0ret = 5 x 24<\/em>. The final result\u00a0120<\/strong>\u00a0is passed down to the initial caller statement and is displayed.<\/p>\n
                                  There is one problem in the above script. As I explained in the previous article, functions cannot return large integers. So its left to users to find a solution for the above issue.<\/p>\n
                                  Q.<\/strong>\u00a0Can we perform recursion without using local variables? Answer is\u00a0Yes<\/strong>.<\/p>\n
                                  Recursion without Local Variables<\/h4>\n
                                  Look at the following example for displaying the\u00a0Fibonacci series<\/strong>\u00a0using recursion. The basic recurrence relation is:<\/p>\n
                                  fib(0) = 0 \r\nfib(1) = 1 \r\nelse \r\n\tfib(n) = fib(n-1) + fib(n-2)\r\n\r\nFibonacci series using recursion\r\n\r\n#!\/bin\/bash \r\n\r\nfib( ) { \r\n\ta=$1 \r\n\tif [ $a -lt 2 ]; then \r\n\t\techo $a \r\n\telse \r\n\t\t((--a)) \r\n\t\tb=$(fib $a) \r\n\r\n\t\t((--a)) \r\n\t\tc=$(fib $a) \r\n\r\n\t\techo $((b+c)) \r\n\tfi \r\n} \r\n\r\nfor i in $(seq 0 15) \r\ndo \r\n\tout=$(fib $i) \r\n\techo $out \r\ndone \r\n\r\nexit 0<\/pre>\n
                                  No local variables are used in the above script. I hope you can understand the flow of script during execution.<\/p>\n
                                  Here the value\u00a015<\/strong>\u00a0represents the number of terms in the\u00a0Fibonacci series<\/strong>\u00a0to be displayed. Did you notice anything special regarding the execution of above script. It takes a while, doesn\u2019t it? Recursion in a script is slower than a recursion in programming languages like\u00a0C<\/strong>.<\/p>\n
                                  With this article, I plan to conclude the functions part in shell scripting. Stay updated with\u00a0the upcoming articles on\u00a0arrays<\/strong>\u00a0and much more\u2026<\/p>\n
                                  Working with Arrays in Linux Shell Scripting \u2013 Part 8<\/h1>\n
                                  We cannot imagine a programming language without the concept of arrays. It doesn\u2019t matter how they are implemented among various languages. Instead arrays help us in consolidating data, similar or different, under one symbolic name.<\/p>\n
                                  \n
                                  \"Working<\/a><\/p>\n
                                  Working With Arrays in Shell Scripting<\/p>\n<\/div>\n
                                  Here as we are concerned about shell scripting, this article will help you in playing around with some shell scripts which make use of this concept of arrays.<\/p>\n
                                  Array Initialization and Usage<\/h3>\n
                                  With newer versions of bash, it supports one-dimensional arrays. An array can be explicitly declared by the\u00a0declare<\/em>\u00a0shell-builtin.<\/p>\n
                                  declare -a var  \r\n<\/pre>\n
                                  But it is not necessary to declare array variables as above. We can insert individual elements to array directly as follows.<\/p>\n
                                  var[XX]=<value>\r\n<\/pre>\n
                                  where \u2018XX\u2019 denotes the array index. To dereference array elements use the curly bracket syntax, i.e.<\/p>\n
                                  ${var[XX]}\r\n<\/pre>\n
                                  Note<\/strong>: Array indexing always start with 0.<\/p>\n
                                  Another convenient way of initializing an entire array is by using the pair of parenthesis as shown below.<\/p>\n
                                  var=( element1 element2 element3 . . . elementN )\r\n<\/pre>\n
                                  There is yet another way of assigning values to arrays. This way of initialization is a sub-category of the previously explained method.<\/p>\n
                                  array=( [XX]=<value> [XX]=<value> . . . )\r\n<\/pre>\n
                                  We can also read\/assign values to array during the execution time using the\u00a0read<\/em>\u00a0shell-builtin.<\/p>\n
                                  read -a array\r\n<\/pre>\n
                                  Now upon executing the above statement inside a script, it waits for some input. We need to provide the array elements separated by space (and not carriage return). After entering the values press enter to terminate.<\/p>\n
                                  To traverse through the array elements we can also use for loop.<\/p>\n
                                  for i in \u201c${array[@]}\u201d\r\ndo\r\n\t#access each element as $i. . .\r\ndone \r\n<\/pre>\n
                                  The following script summarizes the contents of this particular section.<\/p>\n
                                  #!\/bin\/bash \r\n\r\narray1[0]=one \r\narray1[1]=1 \r\necho ${array1[0]} \r\necho ${array1[1]} \r\n\r\narray2=( one two three ) \r\necho ${array2[0]} \r\necho ${array2[2]} \r\n\r\narray3=( [9]=nine [11]=11 ) \r\necho ${array3[9]} \r\necho ${array3[11]} \r\n\r\nread -a array4 \r\nfor i in \"${array4[@]}\" \r\ndo \r\n\techo $i \r\ndone \r\n\r\nexit 0\r\n<\/pre>\n
                                  Various Operations on Arrays<\/h4>\n
                                  Many of the standard string operations work on arrays . Look at the following sample script which implements some operations on arrays (including string operations).<\/p>\n
                                  #!\/bin\/bash \r\n\r\narray=( apple bat cat dog elephant frog ) \r\n\r\n#print first element \r\necho ${array[0]} \r\necho ${array:0} \r\n\r\n#display all elements \r\necho ${array[@]} \r\necho ${array[@]:0} \r\n\r\n#display all elements except first one \r\necho ${array[@]:1} \r\n\r\n#display elements in a range \r\necho ${array[@]:1:4} \r\n\r\n#length of first element \r\necho ${#array[0]} \r\necho ${#array} \r\n\r\n#number of elements \r\necho ${#array[*]} \r\necho ${#array[@]} \r\n\r\n#replacing substring \r\necho ${array[@]\/\/a\/A} \r\n\r\nexit 0\r\n<\/pre>\n
                                  Following is the output produced on executing the above script.<\/p>\n
                                  apple \r\napple \r\napple bat cat dog elephant frog \r\napple bat cat dog elephant frog \r\nbat cat dog elephant frog \r\nbat cat dog elephant \r\n5 \r\n5 \r\n6 \r\n6 \r\nApple bAt cAt dog elephAnt frog\r\n<\/pre>\n
                                  I think there is no significance in explaining the above script in detail as it is self-explanatory. If necessary I will dedicate one part in this series exclusively on string manipulations.<\/p>\n
                                  Command Substitution with Arrays<\/h4>\n
                                  Command substitution assigns the output of a command or multiple commands into another context. Here in this context of arrays we can insert the output of commands as individual elements of arrays. Syntax is as follows.<\/p>\n
                                  array=( $(command) )\r\n<\/pre>\n
                                  By default the contents in the output of command separated by white spaces are plugged into array as individual elements. The following script list the contents of a directory, which are files with 755 permissions.<\/p>\n
                                  #!\/bin\/bash \r\n\r\nERR=27 \r\nEXT=0 \r\n\r\nif [ $# -ne 1 ]; then \r\n\techo \"Usage: $0 <path>\" \r\n\texit $ERR \r\nfi \r\n\r\nif [ ! -d $1 ]; then \r\n\techo \"Directory $1 doesn't exists\" \r\n\texit $ERR \r\nfi \r\n\r\ntemp=( $(find $1 -maxdepth 1 -type f) ) \r\n\r\nfor i in \"${temp[@]}\" \r\ndo \r\n\tperm=$(ls -l $i) \r\n\tif [ `expr ${perm:0:10} : \"-rwxr-xr-x\"` -eq 10 ]; then \r\n\t\techo ${i##*\/} \r\n\tfi \r\ndone \r\n\r\nexit $EXT\r\n<\/pre>\n
                                  Simulating Two-dimensional Arrays<\/h4>\n
                                  We can easily represent a 2-dimensional matrix using a 1-dimensional array. In\u00a0row major order<\/em>\u00a0representation elements in each row of a matrix are progressively stored in array indexes in a sequential manner. For an mXn matrix, formula for the same can be written as.<\/p>\n
                                  matrix[i][j]=array[n*i+j]\r\n<\/pre>\n
                                  Look at another sample script for adding 2 matrices and printing the resultant matrix.<\/p>\n
                                  #!\/bin\/bash \r\n\r\nread -p \"Enter the matrix order [mxn] : \" t \r\nm=${t:0:1} \r\nn=${t:2:1} \r\n\r\necho \"Enter the elements for first matrix\" \r\nfor i in `seq 0 $(($m-1))` \r\ndo \r\n\tfor j in `seq 0 $(($n-1))` \r\n\tdo \r\n\t\tread x[$(($n*$i+$j))] \r\n\tdone \r\ndone \r\n\r\necho \"Enter the elements for second matrix\" \r\nfor i in `seq 0 $(($m-1))` \r\ndo \r\n\tfor j in `seq 0 $(($n-1))` \r\n\tdo \r\n\t\tread y[$(($n*$i+$j))] \r\n\t\tz[$(($n*$i+$j))]=$((${x[$(($n*$i+$j))]}+${y[$(($n*$i+$j))]})) \r\n\tdone \r\ndone \r\n\r\necho \"Matrix after addition is\" \r\nfor i in `seq 0 $(($m-1))` \r\ndo \r\n\tfor j in `seq 0 $(($n-1))` \r\n\tdo \r\n\t\techo -ne \"${z[$(($n*$i+$j))]}\\t\" \r\n\tdone \r\n\techo -e \"\\n\" \r\ndone \r\n\r\nexit 0 \r\n<\/pre>\n
                                  Even though there are limitations for implementing arrays inside shell scripting, it becomes useful in a handful of situations, especially when we handle with command substitution. Looking from an administrative point of view, the concept of arrays paved the way for development of many background scripts in GNU\/Linux systems.<\/p>\n
                                  An Insight of Linux \u201cVariables\u201d in Shell Scripting Language \u2013 Part 9<\/h1>\n
                                  We already have written a series of articles on\u00a0Linux Shell Scripting<\/strong>\u00a0which was warm welcomed that time and it was much relevant even now. Here is the link to the collection of articles on shell scripting.<\/p>\n
                                    \n
                                  1. Learn Linux Shell Scripting<\/a><\/li>\n<\/ol>\n
                                    Here in this article we will see the\u00a0variables<\/strong>, its execution and its implementation in shell script.<\/p>\n
                                    \n
                                    \"Linux<\/a><\/p>\n
                                    Linux Variables Shell Scripting<\/p>\n<\/div>\n
                                    Saving an Output<\/h4>\n
                                    The output of a command can be redirected to standard output or a file and can be stored in a variable, as well. If the output of a command is large enough such that it does not fit the screen we are left only with the option of saving output to a file to in a variable. One advantage of saving output to variable is faster examination speed. Variables are saved into memory and hence it tends to be fast as compared to retrieval from file.<\/p>\n
                                    Variables in scripting Language<\/h4>\n
                                    Variables are an important component used in Shell scripting and are declared using bash command \u201cDeclare<\/strong>\u201d. To declare a variable say \u2018level<\/strong>\u2018, we need to execute the below command.<\/p>\n
                                    $ declare LEVEL<\/pre>\n
                                    Note<\/strong>: We need to use \u201ctypecast<\/strong>\u201d, a built in statement for korn shell compatibility. The \u2018declare\u2019 is more advanced and contains all the features, hence is recommended when using BASH.<\/p>\n
                                    Rules<\/h5>\n
                                      \n
                                    1. A variable name must justify, the use of variable in the script.<\/li>\n
                                    2. Using the same variable name throughout the program is strongly advised.<\/li>\n
                                    3. Variables name can be uppercase as well as lowercase but by convention shell commands are in lowercase and hence we should use variables name in uppercase, so as to remove any confusion. e.g., TOTAL_BILLED_AMOUNT, SELL_REPORT, ORDER_RECEIPT, etc.<\/li>\n<\/ol>\n
                                      Implementation<\/h4>\n
                                      A variable can be assigned a value using an equal sign (=<\/strong>). To assign an empty string to a variable we must not supply any value after equal sign.<\/p>\n
                                      $ LEVEL =<\/pre>\n
                                      Check the value stored in variable \u2018LEVEL\u2019 as.<\/p>\n
                                      $ printf \"%i\" $LEVEL<\/pre>\n
                                      printf<\/strong>, the command most of \u2018C<\/strong>\u2018 programmers are aware of, prints data.\u00a0%i<\/strong>\u00a0\u2013 Represents Integer. We can replace it with\u00a0%c<\/strong>\u00a0for Character or\u00a0%c<\/strong>\u00a0for string, as and when required.<\/p>\n
                                      $LEVEL: Note the \u2018$<\/strong>\u2018 which works as value substituter for the variable \u2018LEVEL\u2019<\/strong>.<\/p>\n
                                      Sample Output<\/h5>\n
                                      $ printf \"%i\" $LEVEL\r\n0<\/pre>\n
                                      Assign a value to the variable.<\/p>\n
                                      $ LEVEL=0<\/pre>\n
                                      Check the stored data in variable.<\/p>\n
                                      $ printf \"%i\" $LEVEL\r\n0<\/pre>\n
                                      NOTE<\/strong>: It is interesting to note that in both the cases, when we didn\u2019t assigned the value to variable and when we assigned the value \u20180<\/strong>\u2018 to the variable \u2018LEVEL<\/strong>\u2018 outputs\u00a00<\/strong>. Although the output are same in both the cases but shell script handles both the variable declaration differently.<\/p>\n
                                      Assign a new value to the variable.<\/p>\n
                                      $ LEVEL=121<\/pre>\n
                                      Check the stored data in variable.<\/p>\n
                                      $ printf \"%i\" $LEVEL\r\n121<\/pre>\n
                                      Unset a Variable<\/h4>\n
                                      Declare<\/strong>\u00a0is a BASH command and it creates variable only when executed. The variable so created remains in memory till the script stops or the variable is destroyed.<\/p>\n
                                      $ unset LEVEL<\/pre>\n
                                      Predefined Variables in BASH<\/h4>\n
                                      BASH has over\u00a050<\/strong>\u00a0variables predefined. Some of these variables has a special meaning attached to BASH e.g., a variable\u00a0RANDOM<\/strong>\u00a0outputs a random number. If it is unset and then defined again, the original variable value is lost forever. Hence it is advised not to use any system defined variable.<\/p>\n
                                      Here is a list of some useful BASH variables.<\/p>\n
                                        \n
                                      1. BASH\u2014The full pathname of Bash.<\/li>\n
                                      2. BASH_ENV\u2014In a shell script, the name of the profile file executed before the script was started.<\/li>\n
                                      3. BASH_VERSION\u2014The version of Bash (for example, 2.04.0(1)-release).<\/li>\n
                                      4. COLUMNS\u2014The number of characters per line on your display (for example, 80).<\/li>\n
                                      5. HOSTNAME\u2014The name of the computer. Under some versions of Linux, this can be the machine name. On others, it can be a fully qualified domain name.<\/li>\n
                                      6. HOSTTYPE\u2014Type of computer.<\/li>\n
                                      7. HOME\u2014The name of your home directory.<\/li>\n
                                      8. OSTYPE\u2014The name of the operating system.<\/li>\n
                                      9. PATH\u2014Colon-separated list of search paths to find a command to execute.<\/li>\n
                                      10. PPID\u2014The process ID of the shell\u2019s parent process.<\/li>\n
                                      11. PROMPT_COMMAND\u2014Command to execute before the setting of the PS1 primary prompt string.<\/li>\n
                                      12. PWD\u2014The current working directory (as set by the cd command).<\/li>\n
                                      13. RANDOM\u2014Returns a random number between 0 and 32767 each time it is referenced.<\/li>\n
                                      14. SHELL\u2014The preferred shell to use; for programs that start a shell for you.<\/li>\n
                                      15. TERM\u2014The terminal emulation type (for example, console).<\/li>\n<\/ol>\n
                                        The Rule of Word Splitting.<\/p>\n
                                        $ LEVEL=0\r\n$ printf \"%i\" $LEVEL\r\n0\r\n\r\nAND\r\n\r\n$ LEVEL=\u201d0\u201d\r\n$ printf \"%i\" $LEVEL\r\n0<\/pre>\n
                                        In both the cases output remains same. So what\u2019s the difference in result while using quotation?<\/p>\n
                                        Lets check the same with different variable data.<\/p>\n
                                        $ LEVEL=0 ; 1 ; 2 ; 3 ; 4 ; 5\r\nbash: 1: command not found \r\nbash: 2: command not found \r\nbash: 3: command not found \r\nbash: 4: command not found \r\nbash: 5: command not found<\/pre>\n
                                        $ printf \"%i\" $LEVEL\r\n0<\/pre>\n
                                        Not to mention, the output is not correct. BASH is taking the space after \u20180<\/strong>\u2018 as termination and hence the value of variable is set as \u20180<\/strong>\u2018. Now we try to use quotation for variables as below.<\/p>\n
                                        $ LEVEL=\u201d0 ; 1 ; 2 ; 3 ; 4 ; 5\u201d\r\n$ printf \"%s\" $LEVEL \r\n0;1;2;3;4;5<\/pre>\n
                                        Still the result is not correct. BASH took the variable values and removed all the spaces in between them. Hence\u00a0printf<\/strong>\u00a0didn\u2019t interpreted 0,1,2,3,4,5 as distinct values. So what\u2019s the solution?<\/p>\n
                                        printf \"%s\" \"$LEVEL\" \r\n0 ; 1 ; 2 ; 3 ; 4 ; 5<\/pre>\n
                                        Yeah! Putting the Variable substitution under quotes is the solution. Quotations groups characters in shell and interpret the special characters in a meaningful way.<\/p>\n
                                        Quotations can be used back-to-back and it is a good idea to enclose variable substitutions with quotes. Moreover it can be used to separate overall text from quotations. Here is an example.<\/p>\n
                                        $ LEVEL=5 \r\n$ FLAG_MESSAGE=\"I HAVE CLEARED LEVEL\"\"$LEVEL\"\". I Deserve appreciation.\" \r\n$ printf \u201c%s\u201d \u201c$FLAG_MESSAGE\u201d<\/pre>\n
                                        \u201cI HAVE CLEARED LEVEL5. I Deserve appreciation.\u201d<\/pre>\n
                                        Separating chunks of quoted text with space will result into the same problem as discussed above. The bash will treat white space as termination. Another way of variable substitution is.<\/p>\n
                                        $ LEVEL=5\r\n\r\n$ FLAG_MESSAGE=\"I HAVE CLEARED LEVEL ${LEVEL}. I Deserve appreciation.\" \r\n\r\n$ printf \u201c%s\u201d \"$FLAG_MESSAGE\" \r\n\u201cI HAVE CLEARED LEVEL 5. I Deserve appreciation.\u201d<\/pre>\n
                                        Single quotes restricts BASH from printing Special characters.<\/p>\n
                                        $ printf \u201c%s\u201d '$FLAG_MESSAGE'\r\n\u201c$FLAG_MESSAGE\u201d<\/pre>\n
                                        The Backslash (\/)<\/h4>\n
                                        Backslash works like single quote for one character. Have you thought how will you print (\u201c<\/strong>)?<\/p>\n
                                        $ printf \"%c\" \"\\\"\"<\/pre>\n
                                        When\u00a0%q<\/strong>\u00a0grouped with\u00a0printf<\/strong>, provides backslash after every word to ensure word spacing.<\/p>\n
                                        $ LEVEL=5\r\n\r\n$ FLAG_MESSAGE=\"I HAVE CLEARED LEVEL ${LEVEL}. I Deserve appreciation.\" \r\n\r\n$ printf \u201c%q\u201d \"$FLAG_MESSAGE\" \r\n\u201cI\\ HAVE\\ CLEARED\\ LEVEL\\ 5.\\ I\\ Deserve\\ appreciation.\u201d<\/pre>\n
                                        That\u2019s all for now. We always try to provide our readers with articles that are useful for them every now and then. The above covered article is vast hence rest of the topics with examples will be produced in the next article which will include \u2018Attributes of variable\u2019, \u2018Variable exporting\u2019 etc.<\/p>\n
                                        Understanding and Writing \u2018Linux Variables\u2019 in Shell Scripting \u2013 Part 10<\/h1>\n
                                        The Linux shell scripting language has always been a hot topic and will always be in the future. The Shell Scripting Language is magical and its so easy to do a program in scripting language as in any other Language. However, it needs an in-depth knowledge of what we are doing and what the result is expected.<\/p>\n
                                        \n
                                        \"Understanding<\/a><\/p>\n
                                        Understanding Variables in Shell Scripting<\/p>\n<\/div>\n
                                        All the shell scripting articles we have written for our readers are highly appreciated including the last one \u201cAn Insight of Linux Variables<\/a>\u201d. We are extending the last article to a new Level.<\/p>\n
                                        Variable Attributes<\/h3>\n
                                        Each Variable in Linux Environment has certain options, and those are called \u2018attributes\u2019. These options or attributes can be turned\u00a0On<\/b>\u00a0and\u00a0Off<\/b>, when required according to the situation using a command \u201cdeclare\u201d.<\/p>\n
                                        An Example of variable attribute is using a switch say \u2018-i<\/b>\u2018 which will turn on the integer attribute for the corresponding variable. Even if a non-numeric value is passed to switch \u2018-i<\/b>\u2018 it won\u2019t throw an error message and output \u20180<\/b>\u2018 as integer interpretation. Here it becomes more clear from the example below.<\/p>\n
                                        Declare a variable Integer, bill = 121<\/p>\n
                                        avi@localhost:~$ declare -i bill=121<\/pre>\n
                                        Printf the value of variable bill.<\/p>\n
                                        avi@localhost:~$ printf \"%d\\n\" \"$bill\" \r\n\r\n121<\/pre>\n
                                        Let the variable value be a string. The variable bill is already declared, no need to declare it second time. Just change the value of variable as.<\/p>\n
                                        avi@localhost:~$ bill=tecmint<\/pre>\n
                                        Now, again printf the value of variable bill.<\/p>\n
                                        avi@localhost:~$ printf \"%d\\n\" \"$bill\" \r\n\r\n0<\/pre>\n
                                        Notice \u20180<\/b>\u2018 in the place of error message.<\/p>\n
                                        Now, the question is, how to know the attributes of already declared variables?<\/h6>\n
                                        avi@localhost:~$ declare -p bill \r\n\r\ndeclare -i bill=\"121\"<\/pre>\n
                                        Here, a\u00a0-p<\/b>\u00a0(stands for print) switch comes to rescue.<\/p>\n
                                        Again, what should I do to switch off the attributes of a variable?<\/h6>\n
                                        In order to switch\u00a0Off<\/b>\u00a0the attributes of a variable what we need all is to put a\u00a0+<\/b>\u00a0(plus<\/b>) sign just before the switch. Here it is more clear from the example below.<\/p>\n
                                        Switch\u00a0Off<\/b>\u00a0the integer attribute for the above variable.<\/p>\n
                                        avi@localhost:~$ declare +i bill<\/pre>\n
                                        Check the value of the variable.<\/p>\n
                                        avi@localhost:~$ printf \"%d\\n\" \"$bill\" \r\n\r\nbash: printf: bill: invalid number\r\n0<\/pre>\n
                                        Now print the value of variable using switch string.<\/p>\n
                                        avi@localhost:~$ printf \"%s\\n\" \"$bill\" \r\n\r\ntecmint<\/pre>\n
                                        Here in the above example, bash could not judge non-numeric value as error, however\u00a0printf<\/b>\u00a0is interpreting, what could be a number and what could not be.<\/p>\n
                                        Read-only Variables<\/h3>\n
                                        You might have heard Read Only Memory (ROM<\/b>), but what is Read-only Variable? Has it any similarity with ROM?<\/p>\n
                                        Well Read-only Variables like Read-only Memory is something the value of which can\u2019t be change once it is assigned. Hence it is called Read-only. You can\u2019t write, edit or modify a new value for that variable. Here is an illustration using example.<\/p>\n
                                        Decalre a read only (-r<\/b>) variable name, the value of which is \u201cTecmint.com\u201d.<\/p>\n
                                        avi@localhost:~$ declare -r name=\"Tecmint.com\"<\/pre>\n
                                        Printf the value of above declared variable.<\/p>\n
                                        avi@localhost:~$ printf \"%s\\n\" \"$name\" \r\n\r\nTecmint.com<\/pre>\n
                                        Try to change the value of variable.<\/p>\n
                                        avi@localhost:~$ declare -r name=\"Avishek\" \r\n\r\nbash: declare: name: readonly variable<\/pre>\n
                                        As discussed above the attributes of a read-only Variable can be changed using \u2018+<\/b>\u2018 sign.<\/p>\n
                                        Exporting Variables in Linux<\/h3>\n
                                        All the shell variables declared in a shell script are available till the script is running. Outside of the script the variable from the script does not exist. The process of making variables available outside of the script is called exporting variables.<\/p>\n
                                        A Variable can be exported outside of the shell using switch\u00a0declare -x<\/b>\u00a0(export), which acknowledge the shell what you wanted to export. A declare export switch can be used as.<\/p>\n
                                        avi@localhost:~$ declare -x variable=\u201dConstant_Value\u201d<\/pre>\n
                                        All the changes made to the variable while the script is running, is lost when the variable is exported outside of the script. Exporting variable is very important in shell scripting.<\/p>\n
                                        We want to have a variable that should be read-only and available outside of the script, we need to use switch\u00a0-r<\/b>and switch\u00a0-x<\/b>\u00a0at the same time.<\/p>\n
                                        avi@localhost:~$ declare -rx variable=\u201dConstant_Value\u201d<\/pre>\n
                                        Environment Variables<\/h3>\n
                                        The variables that are shared between the program and the program that execute them. Environment variables can be exported but the attributes can\u2019t be assigned to it.<\/p>\n
                                        Understanding the above theory practically. Here we have two scripts\u00a00.sh<\/b>\u00a0and\u00a01.sh<\/b>.<\/p>\n
                                        # 0.sh\r\n#!\/bin\/bash \r\ndeclare -rx name=Tecmint \r\nbash 0.sh \r\nexit 0<\/pre>\n
                                        And the second script is.<\/p>\n
                                        # 1.sh\r\n#!\/bin\/bash \r\nprintf \"%s\\n\" \"$name\" \r\nname=Tecmint.com \r\nprintf \"%s\\n\" \"$name\"\r\nexit 0<\/pre>\n
                                        Here what is going on, is a variable (name) is declared as read only and exported and immediately after that second script is called.<\/p>\n
                                        The second script just printed the variable from the first script that was exported in the first\u00a0printf<\/b>\u00a0statement. In the second printf statement it shows the new value assigned to variable \u2018name<\/b>\u2018.<\/p>\n
                                        No need to worry, that the variable was read-only, how can it be reassigned. Don\u2019t you remember that \u201cAll the changes made to the variable while the script is running, is lost when the variable is exported outside of the script.\u201d<\/p>\n
                                        References<\/h5>\n
                                        The\u00a0declare<\/b>\u00a0command allows all the switches below along with their combination.<\/p>\n
                                          \n
                                        1. -a<\/b>\u00a0: Declares an array.<\/li>\n
                                        2. -f<\/b>\u00a0: Display Function and Definition.<\/li>\n
                                        3. -F<\/b>\u00a0: Display Function Name.<\/li>\n
                                        4. -r<\/b>\u00a0: Declare variable as read-only.<\/li>\n
                                        5. -x<\/b>\u00a0: Declare Variable as Exportable.<\/li>\n
                                        6. -I<\/b>\u00a0: Declare variable as Integer.<\/li>\n<\/ol>\n
                                          That\u2019s all for now. In the very next article we will be discussing ways to substitute variables using \u2018eval<\/b>\u2018 command and the variables already defined in bash before closing this topic.<\/p>\n
                                          Nested Variable Substitution and Predefined BASH Variables in Linux \u2013 Part 11<\/h1>\n
                                          The last two article on BASH Shell, where we discussed variables in detail were highly appreciated among our readers. We as\u00a0Tecmint-Team<\/strong>\u00a0are very keen to provide you with Latest, Up-to-date and relevant topics covered in details. Moreover we always try to touch major perspectives of the corresponding topics.<\/p>\n
                                          \n
                                          \"Nested<\/a><\/p>\n
                                          Nested Variables in Shell Scripting<\/p>\n<\/div>\n
                                          Here is the last article on Linux Variables where we are going to see variables substitution and variables defined in Shell before closing this topic.<\/p>\n
                                          Bash performs variable substitution before the command is really executed. The Linux Bash Shell searches for all the \u2018$\u2019 sign before executing the command and replace it with the value of variable. The process of Bash Variable substitution is performed only once. What if we have nested variables?<\/p>\n
                                          Note<\/strong>: By nested variable we mean, variable declared inside variable. Lets see the above scenario in the example below.<\/p>\n
                                          Declare a variable which is Read-Only and Executable as below.<\/p>\n
                                          avi@localhost:~$ declare -rx Linux_best_website=\"www.tecmint.com\"<\/pre>\n
                                          Check the value of variable stored.<\/p>\n
                                          avi@localhost:~$ printf \"%s\" \"$Linux_best_website\" \r\n\r\nwww.tecmint.com<\/pre>\n
                                          Now declare another variable which again is Read-Only and Executable.<\/p>\n
                                          avi@localhost:~$ declare -rx Linux_website=\"Linux_best_website\"<\/pre>\n
                                          Now the situation is, we have defined two variables.<\/p>\n
                                          \u2018Linux_best_website\u2019, the value of which is \u201cwww.tecmint.com\u201d
                                          \nand, \u2018Linux_website\u2019, the value of which is \u201cLinux_best_website\u201d<\/p>\n
                                          What would be the result, if we run the below one-line command?<\/p>\n
                                          avi@localhost:~$ printf \"%s\" \"$Linux_website\"<\/pre>\n
                                          It should first replace the variable \u2018$Linux_website<\/b>\u2018, with value \u201cLinux_best_website<\/b>\u201d and then \u201c$Linux_best_website<\/b>\u201d is again a variable the value of which is \u201cwww.tecmint.com<\/b>\u201d. So the final output of running the below command should be.<\/p>\n
                                          avi@localhost:~$ printf \"%s\" \"$Linux_website\" \r\n\r\nwww.tecmint.com<\/pre>\n
                                          But unfortunately, this is not the situation, the output we are getting is\u00a0Linux_best_website<\/b>.<\/p>\n
                                          Reason? Yup! Bash substitute the value of variable only once. What about complex scripts and programs where we need to substitute variables frequently as well as needs to substitute the variable more than once?<\/p>\n
                                          Here comes the command \u2018eval<\/b>\u2018 which performs additional work of variable substitution more than once in a script. Here is an example to make the whole working as clear as glass.<\/p>\n
                                          Declare a variable\u00a0x<\/b>, the value of which is\u00a010<\/b>.<\/p>\n
                                          avi@localhost:~\/Desktop$ declare x=10<\/pre>\n
                                          Check the value of variable\u00a0x<\/b>, we just defined.<\/p>\n
                                          avi@localhost:~\/Desktop$ echo $yx\r\n\r\nx10<\/pre>\n
                                          Declare a variable\u00a0y<\/b>, the value of which is\u00a0x<\/b>.<\/p>\n
                                          avi@localhost:~\/Desktop$ declare y=x<\/pre>\n
                                          Check the value of variable\u00a0y<\/b>, we just defined.<\/p>\n
                                          avi@localhost:~\/Desktop$ echo $y \r\n\r\nx<\/pre>\n
                                          Here is the problem of\u00a0BASH<\/b>\u00a0one time variable substitution, which don\u2019t performs an extra round of variable substitution. We are using \u2018eval<\/b>\u2018 command to fix this.<\/p>\n
                                          avi@localhost:~\/Desktop$ eval y=$x<\/pre>\n
                                          Now check the Value of variable \u2018y<\/b>\u2018.<\/p>\n
                                          avi@localhost:~\/Desktop$ echo $y \r\n\r\n10<\/pre>\n
                                          Hurrah! The issue was fixed and \u2018eval<\/strong>\u2018 command won the race \ud83d\ude42<\/p>\n
                                          Not to mention, \u2018eval<\/b>\u2018 command is very helpful in large script programs and is a very handy tool.<\/p>\n
                                          The last but not the least part of this post is BASH predefined variables. No! Don\u2019t get panic seeing this list. You never need to remember the whole list before you start writing scripts except a few. As a part of learning process, we are presenting the BASH predefined variable List.<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
                                          No.<\/strong><\/td>\nBASH VARIABLE<\/strong><\/td>\nRESULT<\/strong><\/td>\n<\/tr>\n
                                          1<\/td>\nauto_resume<\/td>\nProcess command completion for the stopped jobs.<\/td>\n<\/tr>\n
                                          2<\/td>\nBASH<\/td>\nPATH of the shell.<\/td>\n<\/tr>\n
                                          3<\/td>\nBASH_ENV<\/td>\nShows the name of the profile file<\/td>\n<\/tr>\n
                                          4<\/td>\nBASH_VERSION<\/td>\nShows the version of Bash<\/td>\n<\/tr>\n
                                          5<\/td>\nBASH_VERSINFO<\/td>\nShows Detailed version information.<\/td>\n<\/tr>\n
                                          6<\/td>\nBASH_VERSINFO[0]<\/td>\nThe major version number (the release).<\/td>\n<\/tr>\n
                                          7<\/td>\nBASH_VERSINFO[1]<\/td>\nThe minor version number (the version).<\/td>\n<\/tr>\n
                                          8<\/td>\nBASH_VERSINFO[2]<\/td>\nThe patch level.<\/td>\n<\/tr>\n
                                          9<\/td>\nBASH_VERSINFO[3]<\/td>\nThe build version.<\/td>\n<\/tr>\n
                                          10<\/td>\nBASH_VERSINFO[4]<\/td>\nThe release status (for example, beta1 ).<\/td>\n<\/tr>\n
                                          11<\/td>\nBASH_VERSINFO[5]<\/td>\nThe value of MACHTYPE .<\/td>\n<\/tr>\n
                                          12<\/td>\nCDPATH<\/td>\nList of directories separated by colon.<\/td>\n<\/tr>\n
                                          13<\/td>\nCOLUMNS<\/td>\nNumber of Characters per line on Standard Output.<\/td>\n<\/tr>\n
                                          14<\/td>\nEUID<\/td>\nUser ID of the current user.<\/td>\n<\/tr>\n
                                          15<\/td>\nFCEDIT<\/td>\nThe default text editor for the fc command.<\/td>\n<\/tr>\n
                                          16<\/td>\nFUNCNAME<\/td>\nThe name of the fun<\/td>\n<\/tr>\n
                                          17<\/td>\nGROUPS<\/td>\nGroups of which the user is a Member.<\/td>\n<\/tr>\n
                                          18<\/td>\nHISTFILE<\/td>\nThe file containing the command history.<\/td>\n<\/tr>\n
                                          19<\/td>\nHOME<\/td>\nThe name of your home directory.<\/td>\n<\/tr>\n
                                          20<\/td>\nLINES<\/td>\nNumber of horizontal lines on Standard Output.<\/td>\n<\/tr>\n
                                          21<\/td>\nMAIL<\/td>\nName of a file to check for incoming mail<\/td>\n<\/tr>\n
                                          22<\/td>\nOSTYPE<\/td>\nName of the operating system.<\/td>\n<\/tr>\n
                                          23<\/td>\nOLDPWD<\/td>\nThe previous working directory<\/td>\n<\/tr>\n
                                          24<\/td>\nPWD<\/td>\nThe current working directory<\/td>\n<\/tr>\n
                                          25<\/td>\nRANDOM<\/td>\nPrints a random number<\/td>\n<\/tr>\n
                                          26<\/td>\nSHELL<\/td>\nThe preferred shell to use<\/td>\n<\/tr>\n
                                          27<\/td>\nTIMEFORMAT<\/td>\nThe format for the time command.<\/td>\n<\/tr>\n
                                          28<\/td>\nUID<\/td>\nThe ID of the current user<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                                          There are a huge list of Predefined BASH Variable. We have tried to produce a list of most frequently used.<\/p>\n
                                          That\u2019s all for now.<\/p>\n
                                          SSH Passwordless Login Using SSH Keygen in 5 Easy Steps<\/h1>\n
                                          SSH<\/strong>\u00a0(Secure SHELL<\/strong>) is an open source and most trusted network protocol that is used to login into remote servers for execution of commands and programs. It is also used to transfer files from one computer to another computer over the network using secure copy (SCP<\/strong>) Protocol.<\/p>\n
                                          In this article we will show you how to setup password-less login on\u00a0RHEL\/CentOS 7.x\/6.x\/5.x<\/strong>\u00a0and\u00a0Fedora<\/strong>\u00a0using\u00a0ssh keys<\/strong>\u00a0to connect to remote\u00a0Linux<\/strong>\u00a0servers without entering password. Using Password-less login with\u00a0SSH keys<\/strong>\u00a0will increase the trust between two\u00a0Linux<\/strong>\u00a0servers for easy file synchronization or transfer.<\/p>\n
                                          \n
                                          \"SSH<\/a><\/p>\n
                                          Setup SSH Passwordless Login<\/p>\n<\/div>\n
                                          My Setup Environment<\/h5>\n
                                          SSH Client : 192.168.0.12 ( Fedora 21 )\r\nSSH Remote Host : 192.168.0.11 ( CentOS 7 )\r\n<\/pre>\n
                                          If you are dealing with number of\u00a0Linux<\/strong>\u00a0remote servers, then\u00a0SSH Password-less<\/strong>\u00a0login is one of the best way to automate tasks such as automatic backups with scripts, synchronization files using scp and remote command execution.<\/p>\n
                                          In this example we will setup\u00a0SSH password-less<\/strong>\u00a0automatic login from server\u00a0192.168.0.12<\/strong>\u00a0as user\u00a0tecmint<\/strong>\u00a0to\u00a0192.168.0.11<\/strong>\u00a0with user\u00a0sheena<\/strong>.<\/p>\n
                                          Step 1: Create Authentication SSH-Kegen Keys on \u2013 (192.168.0.12)<\/h3>\n
                                           <\/p>\n
                                          First login into server\u00a0192.168.0.12<\/strong>\u00a0with user\u00a0tecmint<\/strong>\u00a0and generate a pair of public keys using following command.<\/p>\n
                                          [tecmint@tecmint.com ~]$ ssh-keygen -t rsa<\/strong>\r\n\r\nGenerating public\/private rsa key pair.\r\nEnter file in which to save the key (\/home\/tecmint\/.ssh\/id_rsa): [Press enter key]\r\nCreated directory '\/home\/tecmint\/.ssh'.\r\nEnter passphrase (empty for no passphrase): [Press enter key]\r\nEnter same passphrase again: [Press enter key]\r\nYour identification has been saved in \/home\/tecmint\/.ssh\/id_rsa.\r\nYour public key has been saved in \/home\/tecmint\/.ssh\/id_rsa.pub.\r\nThe key fingerprint is:\r\n5f:ad:40:00:8a:d1:9b:99:b3:b0:f8:08:99:c3:ed:d3 tecmint@tecmint.com\r\nThe key's randomart image is:\r\n+--[ RSA 2048]----+\r\n|        ..oooE.++|\r\n|         o. o.o  |\r\n|          ..   . |\r\n|         o  . . o|\r\n|        S .  . + |\r\n|       . .    . o|\r\n|      . o o    ..|\r\n|       + +       |\r\n|        +.       |\r\n+-----------------+\r\n<\/pre>\n
                                          \n
                                          \"Create<\/a><\/p>\n
                                          Create SSH RSA Key<\/p>\n<\/div>\n
                                          Step 2: Create .ssh Directory on \u2013 192.168.0.11<\/h3>\n
                                          Use SSH from server\u00a0192.168.0.12<\/strong>\u00a0to connect server\u00a0192.168.0.11<\/strong>\u00a0using\u00a0sheena<\/strong>\u00a0as user and create\u00a0.ssh<\/strong>directory under it, using following command.<\/p>\n
                                          [tecmint@tecmint ~]$ ssh sheena@192.168.0.11 mkdir -p .ssh<\/strong>\r\n\r\nThe authenticity of host '192.168.0.11 (192.168.0.11)' can't be established.\r\nRSA key fingerprint is 45:0e:28:11:d6:81:62:16:04:3f:db:38:02:la:22:4e.\r\nAre you sure you want to continue connecting (yes\/no)? yes\r\nWarning: Permanently added '192.168.0.11' (ECDSA) to the list of known hosts.\r\nsheena<\/strong>@192.168.0.11's password: [Enter Your Password Here<\/strong>]<\/pre>\n
                                          \n
                                          \"Create<\/a><\/p>\n
                                          Create SSH Directory Under User Home<\/p>\n<\/div>\n
                                          Step 3: Upload Generated Public Keys to \u2013 192.168.0.11<\/h3>\n
                                          Use SSH from server\u00a0192.168.0.12<\/strong>\u00a0and upload new generated public key (id_rsa.pub<\/strong>) on server\u00a0192.168.0.11<\/strong>under\u00a0sheena<\/strong>\u2018s\u00a0.ssh<\/strong>\u00a0directory as a file name\u00a0authorized_keys<\/strong>.<\/p>\n
                                          [tecmint@tecmint ~]$ cat .ssh\/id_rsa.pub | ssh sheena@192.168.0.11 'cat >> .ssh\/authorized_keys'<\/strong>\r\n\r\nsheena<\/strong>@192.168.1.2's password: [Enter Your Password Here<\/strong>]<\/pre>\n
                                          \n
                                          \"Upload<\/a><\/p>\n
                                          Upload RSA Key<\/p>\n<\/div>\n
                                          Step 4: Set Permissions on \u2013 192.168.0.11<\/h3>\n
                                          Due to different SSH versions on servers, we need to set permissions on .ssh directory and authorized_keys file.<\/p>\n
                                          [tecmint@tecmint ~]$ ssh sheena@192.168.0.11 \"chmod 700 .ssh; chmod 640 .ssh\/authorized_keys\"<\/strong>\r\n\r\nsheena<\/strong>@192.168.0.11's password: [Enter Your Password Here<\/strong>]<\/pre>\n
                                          \n
                                          \"Set<\/a><\/p>\n
                                          Set Permission on SSH Key<\/p>\n<\/div>\n
                                          Step 5: Login from 192.168.0.12 to 192.168.0.11 Server without Password<\/h3>\n
                                          From now onwards you can log into\u00a0192.168.0.11<\/strong>\u00a0as\u00a0sheena<\/strong>\u00a0user from server\u00a0192.168.0.12<\/strong>\u00a0as\u00a0tecmint<\/strong>\u00a0user without password.<\/p>\n
                                          [tecmint@tecmint ~]$ ssh sheena@192.168.0.11<\/strong><\/pre>\n
                                          \n
                                          \"SSH<\/a><\/p>\n
                                          SSH Remote Passwordless Login<\/p>\n<\/div>\n
                                          4 Free Shell Scripting eBooks for Linux Newbies and Administrators<\/h1>\n
                                          System Administration<\/strong>\u00a0is a branch of Information Technology that deals with reliable operation of multi-user computer systems and servers. A person who is responsible for reliable operation of multiuser computer system and server is called\u00a0System Administrator<\/strong>.<\/p>\n
                                          A System Administrator whose area of expertise is Linux is called Linux System Administrator. A typical Linux System Administrator role may vary over a large aspect of things which may include but not restricted to \u2013 Hardware Maintenance, System Maintenance, User Administration, Network Administration, System Performance, Resource utilization Monitoring, Backup, Ensure Security, Update System, Implement Policies, Documentation, Application Installation and blah, blah, blah\u2026<\/p>\n
                                          There is a\u00a0Quote<\/strong>\u00a0in Information Technology Field \u2013 \u201cA Programmer is known when he\/she do something good while an Administrator is known if he\/she does something bad<\/strong>.\u201d It is always good to be an unknown administrator than a known administrator. Why? because if you are known, it means your setup don\u2019t work as it should and you are called often for assistance and fixing.<\/p>\n
                                          There are three rules that every System Administrator must follow and should never break.<\/p>\n
                                            \n
                                          1. Rule 1\u00a0<\/strong>: Backup Everything<\/li>\n
                                          2. Rule 2<\/strong>\u00a0: Master Command Line<\/li>\n
                                          3. Rule 3<\/strong>\u00a0: Automate task probably using any Scripting Language or Shell Script<\/li>\n<\/ol>\n
                                            Analyze # Rule 1<\/h6>\n
                                            Why Backup Everything? Well you never know when the server or a file system may start acting strange or the storage unit just collapse. You must have backup of everything so that if something goes wrong you don\u2019t have to break a sweat, just restore.<\/p>\n
                                            Analyze # Rule 2<\/h6>\n
                                            If you are a true Linux Administrator and Understand Linux System you know that you get immense power while using Command Line. While using command Line you have direct access to system calls. Most of the admin work on a headless server (no-GUI) and then Linux Command Line is your only friend and mind it it is more powerful than you believe.<\/p>\n
                                            Analyze # Rule 3<\/h6>\n
                                            Automate task, but why? well an administrator at the first point is lazy and he want to perform various attended task like backup automatically. An Intelligent Administrator would like to automate all his work using some kind of script so that he don\u2019t need to intervene every time. He would schedule backup, log and every other thing possible. As you move up in the levels of System Administration you need scripting not only for automating task but also for looking inside the configuration files and other. Shell Scripting is a Computer Program which can run on UNIX\/Linux Shell.<\/p>\n
                                            Learning Scripting<\/h4>\n
                                            The\u00a0Shell Scripting<\/strong>\u00a0(bash scripting) Language is easy and fun. If you know any other Programming Language you would probably understand most of the Shell Scripts and may start writing your\u2019s own very soon. Even if you don\u2019t have knowledge of any programming Language, learning Scripting won\u2019t be any difficult.<\/p>\n
                                            There are other Scripting Language like Python, Perl, Ruby etc which provides you with more function and helps you achieve the result easily. But if you are novice and want to start from shell scripting.<\/p>\n
                                            Where to Learn Shell Scripting Language?<\/h6>\n
                                            We have already posted a series of easy to understand articles on shell scripting which you may find in the link below.<\/p>\n
                                              \n
                                            1. Learn Linux Shell Scripting<\/a><\/li>\n<\/ol>\n
                                              We will be extending this series very soon, before that we\u2019ve compiled a list of 4 books on Shell Scripting. These books are free to download and will help you mentoring your shell scripting skills. No matter you are experienced or newbie you must have these handy documents with you if you are in the field of Linux.<\/p>\n
                                              1. Bash Guide for Beginners<\/h3>\n
                                              This book contains a total of 12 chapters spread over 165 pages. This book is written by\u00a0Machtelt Garrels<\/strong>. This book is must for anyone working on UNIX and like environment. If you are a System Administrator and want to make your life easier this resource is for you. If you are experienced Linux User, this book aims at giving you an insight of the System. The documents are very encouraging and it will help you writing your own scripts. Detailed and wide list of topics covered in easy to understand language is another plus point of this guide.<\/p>\n
                                              <\/a><\/center>Download \u2013 Bash Guide for Beginners<\/a><\/p>\n
                                              2. Advanced Bash-Scripting Guide<\/h3>\n
                                              This book contains 38 chapters and spread over 901 pages. Having detailed description of everything you may need to learn yet in language that is easy to understand. This book is written by\u00a0Mendel Cooper<\/strong>\u00a0and it contains plenty of practical examples. The tutorial in the book assumes that you don\u2019t have any previous knowledge of scripting and Programming but progress rapidly to intermediate and advanced level of Instruction. The detailed description in the book makes it a self study guide.<\/p>\n
                                              <\/a><\/center>Download \u2013 Advanced Bash-Scripting Guide<\/a><\/p>\n
                                              3. Shell Scripting: Expert Recipes for Linux<\/h3>\n
                                              This book is written by\u00a0Steve Parker<\/strong>. Though you can not download this book completely for free, the first 40 pages are free. It is sufficient to know what the book contains. Personally I am an admirer of Steve for this wonderful piece of guide. His skills and writing style is awesome. Plenty of practical examples, easy to understand theory and his style of presenting adds to the list. The original book is voluminous. You may download the 40 page guide to learn and see if you are going to get around scripting.<\/p>\n
                                              <\/a><\/center>Download \u2013 Shell Scripting: Expert Recipes for Linux<\/a><\/p>\n
                                              4. Linux Shell Scripting Cookbook, Second Edition<\/h3>\n
                                              This book contains a total of 9 chapters spread over 40 pages. This book is written by\u00a0Shantanu Tushar<\/strong>\u00a0who is a GNU\/Linux user since his early days. This guide contains a balanced combination of theory and practical. I don\u2019t want you to loose your interest for this 40 page guide which may be life Saviour for you. Download and see how this is useful for you.<\/p>\n
                                              <\/a><\/center>Download \u2013 Linux Shell Scripting Cookbook, Second Edition<\/a><\/p>\n
                                              In order to download any book from our partner site you need to fill a small form. All your information are safe with our partner site and we won\u2019t\u00a0SPAM<\/strong>\u00a0you. Even we hate SPAM. Fill the form with relevant information so that you may get notification and Information from time-to-time. You may opt out to receive any information. You just have to register once and you may Download any books for any number of times and that too free.<\/p>\n
                                              It has lots of books on different domains and by registering once you are entitled to download the whole library and be choosy what you want to have in your library. The above shell scripting books will bring a huge change in your skill and will take you to the next level. So what are you waiting for? Want a career in Linux, want to revamp your skill sets, learn something new and interesting, Download the books, have fun!<\/p>\n
                                              A Shell Script to Monitor Network, Disk Usage, Uptime, Load Average and RAM Usage in Linux<\/h1>\n
                                              The duty of\u00a0System Administrator<\/strong>\u00a0is really tough as he\/she has to monitor the servers, users, logs, create backup and blah blah blah. For the most repetitive task most of the administrator write a script to automate their day-to-day repetitive task. Here we have written a shell Script that do not aims to automate the task of a typical system admin, but it may be helpful at places and specially for those newbies who can get most of the information they require about their System, Network, Users, Load, Ram, host, Internal IP, External IP, Uptime, etc.<\/p>\n
                                              We have taken care of formatting the output (to certain extent). The Script don\u2019t contains any Malicious contents and it can be run using Normal user Account. In-fact it is recommended to run this script as user and not as root.<\/p>\n
                                              \n
                                              \"Linux<\/a><\/p>\n
                                              Shell Script to Monitor Linux System Health<\/p>\n<\/div>\n
                                              You are free to use\/modify\/redistribute the below piece of code by giving proper credit to\u00a0Tecmint<\/strong>\u00a0and\u00a0Author<\/strong>. We have tried to customize the output to the extent that nothing other than the required output is generated. We have tried to use those variables which are generally not used by Linux System and are probably free.<\/p>\n
                                              Minimum System Requirement<\/h5>\n
                                              All you need to have is a working Linux box.<\/p>\n
                                              DependencY<\/h5>\n
                                              There is no dependency required to use this package for a standard Linux Distribution. Moreover the script don\u2019t requires root permission for execution purpose. However if you want to Install it, you need to enter root password once.<\/p>\n
                                              Security<\/h5>\n
                                              We have taken care to ensure security of the system. Nothing additional package is required\/installed. No root access required to run. Moreover code has been released under\u00a0Apache 2.0 License<\/strong>, that means you are free to edit, modify and re-distribute by keeping Tecmint copyright.<\/p>\n
                                              How Do I Install and Run Script?<\/h3>\n
                                              First, use following\u00a0wget command<\/a>\u00a0to download the monitor script\u00a0\"tecmint_monitor.sh\"<\/code>\u00a0and make it executable by setting appropriate permissions.<\/p>\n
                                              # wget https:\/\/tecmint.com\/wp-content\/scripts\/tecmint_monitor.sh\r\n# chmod 755 tecmint_monitor.sh\r\n<\/pre>\n
                                              It is strongly advised to install the script as user and not as root. It will ask for root password and will install the necessary components at required places.<\/p>\n
                                              To install\u00a0\"tecmint_monitor.sh\"<\/code>\u00a0script, simple use\u00a0-i<\/strong>\u00a0(install) option as shown below.<\/p>\n
                                              .\/tecmint_monitor.sh -i \r\n<\/pre>\n
                                              Enter\u00a0root<\/strong>\u00a0password when prompted. If everything goes well you will get a success message like shown below.<\/p>\n
                                              Password: \r\nCongratulations! Script Installed, now run monitor Command\r\n<\/pre>\n
                                              After installation, you can run the script by calling command\u00a0'monitor'<\/code>\u00a0from any location or user. If you don\u2019t like to install it, you need to include the location every-time you want to run it.<\/p>\n
                                              # .\/Path\/to\/script\/tecmint_monitor.sh\r\n<\/pre>\n
                                              Now run monitor command from anywhere using any user account simply as:<\/p>\n
                                              $ monitor\r\n<\/pre>\n
                                              \"TecMint<\/a><\/p>\n
                                              As soon as you run the command you get various System related information which are:<\/p>\n
                                                \n
                                              1. Internet Connectivity<\/li>\n
                                              2. OS Type<\/li>\n
                                              3. OS Name<\/li>\n
                                              4. OS Version<\/li>\n
                                              5. Architecture<\/li>\n
                                              6. Kernel Release<\/li>\n
                                              7. Hostname<\/li>\n
                                              8. Internal IP<\/li>\n
                                              9. External IP<\/li>\n
                                              10. Name Servers<\/li>\n
                                              11. Logged In users<\/li>\n
                                              12. Ram Usages<\/li>\n
                                              13. Swap Usages<\/li>\n
                                              14. Disk Usages<\/li>\n
                                              15. Load Average<\/li>\n
                                              16. System Uptime<\/li>\n<\/ol>\n
                                                Check the installed version of script using\u00a0-v<\/strong>\u00a0(version) switch.<\/p>\n
                                                $ monitor -v\r\n\r\ntecmint_monitor version 0.1\r\nDesigned by Tecmint.com\r\nReleased Under Apache 2.0 License\r\n<\/pre>\n
                                                Conclusion<\/h3>\n
                                                This script is working out of the box on a few machines I have checked. It should work the same for you as well. If you find any bug let us know in the comments. This is not the end. This is the beginning. You can take it to any level from here.<\/p>\n
                                                We\u2019ve received few complaints that the script is not working on the few Linux distributions, and one of our regular reader\u00a0Mr. Andres Tarallo<\/strong>, has taken the initiative and made the script compatible with all Linux distributions, you can find the updated script on\u00a0GitHub<\/strong>\u00a0at\u00a0https:\/\/github.com\/atarallo\/TECMINT_MONITOR\/<\/a>.<\/p>\n
                                                If you feel like editing the script and carry it further you are free to do so giving us proper credit and also share the updated script with us so that we can update this article by giving you proper credit.<\/p>\n
                                                Don\u2019t forget to share your thoughts or your script with us. We will be here to help you. Thank you for all the love you have given us. Keep Connected! Stay tuned.<\/p>\n
                                                Powerline \u2013 Adds Powerful Statuslines and Prompts to Vim Editor and Bash Terminal<\/h1>\n
                                                Powerline<\/strong>\u00a0is a great statusline plugin for\u00a0Vim editor<\/a>, which is developed in\u00a0Python<\/strong>\u00a0and provides statuslines and prompts for many other applications such as bash, zsh, tmux and many more.<\/p>\n
                                                \n
                                                \"Install<\/a><\/p>\n
                                                Add Power to Linux Terminal with Powerline Tool<\/p>\n<\/div>\n
                                                Features<\/h4>\n
                                                  \n
                                                1. It is written in Python, which makes it extensible and feature rich.<\/li>\n
                                                2. Stable and testable code base, which works well with Python 2.6+ and Python 3.<\/li>\n
                                                3. It also supports prompts and statuslines in several Linux utilities and tools.<\/li>\n
                                                4. It has configurations and decorator colors developed using JSON.<\/li>\n
                                                5. Fast and lightweight, with daemon support, which provides even more better performance.<\/li>\n<\/ol>\n
                                                  Powerline Screenshots<\/h4>\n
                                                  \n
                                                  \"Powerline<\/a><\/p>\n
                                                  Powerline Vim Statuslines<\/p>\n<\/div>\n
                                                  In this article, I will show you how to install\u00a0Powerline<\/strong>\u00a0and\u00a0Powerline fonts<\/strong>\u00a0and how to use with\u00a0Bash<\/strong>\u00a0and\u00a0Vim<\/strong>under\u00a0RedHat<\/strong>\u00a0and\u00a0Debian<\/strong>\u00a0based systems.<\/p>\n
                                                  Step 1: Installing Generic Requirements for Powerline<\/h3>\n
                                                  Due to a naming conflict with some other unrelated projects, powerline program is available on\u00a0PyPI<\/strong>\u00a0(Python Package Index<\/strong>) under the package name as\u00a0powerline-status<\/strong>.<\/p>\n
                                                  To install packages from\u00a0PyPI<\/strong>, we need a \u2018pip<\/strong>\u2018 (package management tool for installing Python packages). So, let\u2019s first install\u00a0pip<\/strong>\u00a0tool under our Linux systems.<\/p>\n
                                                  Install Pip on Debian, Ubuntu and Linux Mint<\/h4>\n
                                                  # apt-get install python-pip\r\n<\/pre>\n
                                                  Sample Output<\/h5>\n
                                                  Reading package lists... Done\r\nBuilding dependency tree       \r\nReading state information... Done\r\nRecommended packages:\r\n  python-dev-all python-wheel\r\nThe following NEW packages will be installed:\r\n  python-pip\r\n0 upgraded, 1 newly installed, 0 to remove and 533 not upgraded.\r\nNeed to get 97.2 kB of archives.\r\nAfter this operation, 477 kB of additional disk space will be used.\r\nGet:1 http:\/\/archive.ubuntu.com\/ubuntu\/ trusty-updates\/universe python-pip all 1.5.4-1ubuntu3 [97.2 kB]\r\nFetched 97.2 kB in 1s (73.0 kB\/s)     \r\nSelecting previously unselected package python-pip.\r\n(Reading database ... 216258 files and directories currently installed.)\r\nPreparing to unpack ...\/python-pip_1.5.4-1ubuntu3_all.deb ...\r\nUnpacking python-pip (1.5.4-1ubuntu3) ...\r\nProcessing triggers for man-db (2.6.7.1-1ubuntu1) ...\r\nSetting up python-pip (1.5.4-1ubuntu3) ...\r\n<\/pre>\n
                                                  Install Pip on CentOS, RHEL and Fedora<\/h4>\n
                                                  Under Fedora-based systems, you need to first\u00a0enable epel-repository<\/a>\u00a0and then install\u00a0pip<\/strong>\u00a0package as shown.<\/p>\n
                                                  # yum install python-pip          \r\n# dnf install python-pip                     [On Fedora 22+<\/strong> versions]           \r\n<\/pre>\n
                                                  Sample Output<\/h5>\n
                                                  Installing:\r\n python-pip          noarch          7.1.0-1.el7             epel          1.5 M\r\n\r\nTransaction Summary\r\n=================================================================================\r\nInstall  1 Package\r\n\r\nTotal download size: 1.5 M\r\nInstalled size: 6.6 M\r\nIs this ok [y\/d\/N]: y\r\nDownloading packages:\r\npython-pip-7.1.0-1.el7.noarch.rpm                         | 1.5 MB  00:00:01     \r\nRunning transaction check\r\nRunning transaction test\r\nTransaction test succeeded\r\nRunning transaction\r\n  Installing : python-pip-7.1.0-1.el7.noarch                                 1\/1 \r\n  Verifying  : python-pip-7.1.0-1.el7.noarch                                 1\/1 \r\n\r\nInstalled:\r\n  python-pip.noarch 0:7.1.0-1.el7                                                \r\n\r\nComplete!\r\n<\/pre>\n
                                                  Step 2: Installing Powerline Tool in Linux<\/h3>\n
                                                  Now it\u2019s\u2019 time to install\u00a0Powerline<\/strong>\u00a0latest development version from the\u00a0Git<\/strong>\u00a0repository. For this, your system must have git package installed in order to fetch the packages from Git.<\/p>\n
                                                  # apt-get install git\r\n# yum install git\r\n# dnf install git\r\n<\/pre>\n
                                                  Next you can install\u00a0Powerline<\/strong>\u00a0with the help of\u00a0pip<\/strong>\u00a0command as shown.<\/p>\n
                                                  # pip install git+git:\/\/github.com\/Lokaltog\/powerline\r\n<\/pre>\n
                                                  Sample Output<\/h5>\n
                                                   Cloning git:\/\/github.com\/Lokaltog\/powerline to \/tmp\/pip-WAlznH-build\r\n  Running setup.py (path:\/tmp\/pip-WAlznH-build\/setup.py) egg_info for package from git+git:\/\/github.com\/Lokaltog\/powerline\r\n    \r\n    warning: no previously-included files matching '*.pyc' found under directory 'powerline\/bindings'\r\n    warning: no previously-included files matching '*.pyo' found under directory 'powerline\/bindings'\r\nInstalling collected packages: powerline-status\r\n  Found existing installation: powerline-status 2.2\r\n    Uninstalling powerline-status:\r\n      Successfully uninstalled powerline-status\r\n  Running setup.py install for powerline-status\r\n    \r\n    warning: no previously-included files matching '*.pyc' found under directory 'powerline\/bindings'\r\n    warning: no previously-included files matching '*.pyo' found under directory 'powerline\/bindings'\r\n    changing mode of build\/scripts-2.7\/powerline-lint from 644 to 755\r\n    changing mode of build\/scripts-2.7\/powerline-daemon from 644 to 755\r\n    changing mode of build\/scripts-2.7\/powerline-render from 644 to 755\r\n    changing mode of build\/scripts-2.7\/powerline-config from 644 to 755\r\n    changing mode of \/usr\/local\/bin\/powerline-config to 755\r\n    changing mode of \/usr\/local\/bin\/powerline-lint to 755\r\n    changing mode of \/usr\/local\/bin\/powerline-render to 755\r\n    changing mode of \/usr\/local\/bin\/powerline-daemon to 755\r\nSuccessfully installed powerline-status\r\nCleaning up...\r\n<\/pre>\n
                                                  Step 3: Installing Powerline Fonts in Linux<\/h3>\n
                                                  Powerline uses special\u00a0glyphs<\/strong>\u00a0to show special arrow effect and symbols for developers. For this, you must have a symbol font or a patched font installed on your systems.<\/p>\n
                                                  Download the most recent version of the symbol font and fontconfig configuration file using following\u00a0wget command<\/a>.<\/p>\n
                                                  # wget https:\/\/github.com\/powerline\/powerline\/raw\/develop\/font\/PowerlineSymbols.otf\r\n# wget https:\/\/github.com\/powerline\/powerline\/raw\/develop\/font\/10-powerline-symbols.conf\r\n<\/pre>\n
                                                  Then you need to move the font to your fonts directory,\u00a0\/usr\/share\/fonts\/<\/strong>\u00a0or\u00a0\/usr\/local\/share\/fonts<\/strong>\u00a0as follows or you can get the valid font paths by using command\u00a0xset q<\/code>.<\/p>\n
                                                  # mv PowerlineSymbols.otf \/usr\/share\/fonts\/\r\n<\/pre>\n
                                                  Next, you need to update your system\u2019s font cache as follows.<\/p>\n
                                                  # fc-cache -vf \/usr\/share\/fonts\/\r\n<\/pre>\n
                                                  Now install the fontconfig file.<\/p>\n
                                                  # mv 10-powerline-symbols.conf \/etc\/fonts\/conf.d\/\r\n<\/pre>\n
                                                  Note<\/strong>: If custom symbols doesn\u2019t appear, then try to close all terminal sessions and restart X window for the changes to take effect.<\/p>\n
                                                  Step 4: Setting Powerline for Bash Shell and Vim Statuslines<\/h3>\n
                                                  In this section we shall look at configuring Powerline for bash shell and vim editor. First make your terminal to support\u00a0256color<\/strong>\u00a0by adding the following line to\u00a0~\/.bashrc<\/strong>\u00a0file as follows.<\/p>\n
                                                  export TERM=\u201dscreen-256color\u201d \r\n<\/pre>\n
                                                  Enable Powerline on Bash Shell<\/h4>\n
                                                  To enable Powerline in bash shell by default, you need to add the following snippet to your\u00a0~\/.bashrc<\/strong>\u00a0file.<\/p>\n
                                                  First get the location of installed\u00a0powerline<\/strong>\u00a0using following command.<\/p>\n
                                                  # pip show powerline-status<\/strong>\r\n\r\nName: powerline-status\r\nVersion: 2.2.dev9999-git.aa33599e3fb363ab7f2744ce95b7c6465eef7f08\r\nLocation: \/usr\/local\/lib\/python2.7\/dist-packages<\/strong>\r\nRequires: \r\n<\/pre>\n
                                                  Once you know the actual location of\u00a0powerline<\/strong>, make sure to replace the location in the below line as per your system suggested.<\/p>\n
                                                  powerline-daemon -q\r\nPOWERLINE_BASH_CONTINUATION=1\r\nPOWERLINE_BASH_SELECT=1\r\n. \/usr\/local\/lib\/python2.7\/dist-packages\/<\/strong>powerline\/bindings\/bash\/powerline.sh\r\n<\/pre>\n
                                                  Now try to logout and login back again, you will see powerline statuesline as shown below.<\/p>\n
                                                  \"Bash<\/a><\/p>\n
                                                  Try changing or switching to different directories and keep a eye on \u201cbreadcrumb<\/strong>\u201d prompt changes to show your current location.<\/p>\n
                                                  You will also be able to watch pending background jobs and if powerline is installed on a remote Linux machine, you can notice that the prompt adds the hostname when you connect via SSH.<\/p>\n
                                                  Enable Powerline for Vim<\/h4>\n
                                                  If\u00a0vim<\/strong>\u00a0is your favorite editor, luckily there is a powerful plugin for vim, too. To enable this plugin, add these lines to\u00a0~\/.vimrc<\/code>\u00a0file.<\/p>\n
                                                  set  rtp+=\/usr\/local\/lib\/python2.7\/dist-packages\/powerline\/bindings\/vim\/\r\nset laststatus=2\r\nset t_Co=256\r\n<\/pre>\n
                                                  Now you can launch vim and see a spiffy new status line:<\/p>\n
                                                  \"Vim<\/a><\/p>\n
                                                  Summary<\/h3>\n
                                                  Powerline<\/strong>\u00a0helps to set colorful and beautiful statuslines and prompts in several applications, good for coding environments. I hope you find this guide helpful and remember to post a comment if you need any help or have additional ideas.<\/p>\n
                                                  How To Enable Shell Script Debugging Mode in Linux<\/h1>\n
                                                  A script is simply a list of commands stored in a file. Instead of running a sequence of commands by typing them one by one all the time on the terminal, a system user can store all of them (commands) in a file and repeatedly invokes the file to re-execute the commands several times.<\/p>\n
                                                  While\u00a0learning scripting<\/a>\u00a0or during the early stages of writing scripts, we normally start by writing small or short scripts with a few lines of commands. And we usually debug such scripts by doing nothing more than looking at their output and ensuring that they work as we intended.<\/p>\n
                                                  However, as we begin to write very long and advanced scripts with thousands of lines of commands, for instance scripts that modify system settings,\u00a0perform critical backups over networks<\/a>\u00a0and many more, we will realize that only looking at the output of a script is not enough to find bugs within a script.<\/p>\n
                                                  Therefore, in this shell script debugging in Linux series, we will walk through how to enable shell script debugging, move over to explain the different shell script debugging modes and how to use them in the subsequent series.<\/p>\n
                                                  How To Start A Script<\/h3>\n
                                                   <\/p>\n
                                                  A script is distinguished from other files by its first line, that contains a\u00a0#!<\/code>\u00a0(She-bang<\/strong>\u00a0\u2013 defines the file type) and a path name (path to interpreter) which informs the system that the file is a collection of commands that will be interpreted by the specified program (interpreter).<\/p>\n
                                                  Below are examples of the \u201cfirst lines\u201d in different types of scripts:<\/p>\n
                                                  #!\/bin\/sh          [For sh<\/strong> scripting]\r\n#!\/bin\/bash        [For bash<\/strong> scripting] \r\n#!\/usr\/bin\/perl    [For perl<\/strong> programming]\r\n#!\/bin\/awk -f      [For awk<\/strong> scripting]   \r\n<\/pre>\n
                                                  Note<\/strong>: The first line or\u00a0#!<\/code>\u00a0can be left out if a script contains only of a set of standard system commands, without any internal shell directives.<\/p>\n
                                                  How To Execute A Shell Script in Linux<\/h3>\n
                                                  The conventional syntax for invoking a shell script is:<\/p>\n
                                                  $ script_name  argument1 ... argumentN\r\n<\/pre>\n
                                                  Another possible form is by clearly specifying the shell that will execute the script as below:<\/p>\n
                                                  $ shell script_name argument1 ... argumentN  \r\n<\/pre>\n
                                                  For example:<\/p>\n
                                                  $ \/bin\/bash script_name argument1 ... argumentN     [For bash<\/strong> scripting]\r\n$ \/bin\/ksh script_name argument1 ... argumentN      [For ksh<\/strong> scripting]\r\n$ \/bin\/sh script_name argument1 ... argumentN       [For sh<\/strong> scripting]\r\n<\/pre>\n
                                                  For scripts that do not have\u00a0#!<\/code>\u00a0as the first line and only contain basic system commands such as the one below:<\/p>\n
                                                  #script containing standard system commands\r\ncd \/home\/$USER\r\nmkdir tmp\r\necho \"tmp directory created under \/home\/$USER\"\r\n<\/pre>\n
                                                  Simply make it executable and run it as follows:<\/p>\n
                                                  $ chmod +x  script_name\r\n$ .\/script_name \r\n<\/pre>\n
                                                  Methods of Enabling Shell Script Debugging Mode<\/h3>\n
                                                  Below are the primary shell script debugging options:<\/p>\n
                                                    \n
                                                  1. -v<\/code>\u00a0(short for verbose) \u2013 tells the shell to show all lines in a script while they are read, it activates verbose mode.<\/li>\n
                                                  2. -n<\/code>\u00a0(short for noexec or no ecxecution) \u2013 instructs the shell read all the commands, however doesn\u2019t execute them. This options activates syntax checking mode.<\/li>\n
                                                  3. -x<\/code>\u00a0(short for xtrace or execution trace) \u2013 tells the shell to display all commands and their arguments on the terminal while they are executed. This option enables shell tracing mode.<\/li>\n<\/ol>\n
                                                    1. Modifying the First Line of a Shell Script<\/h4>\n
                                                    The first mechanism is by altering the first line of a shell script as below, this will enable debugging of the whole script.<\/p>\n
                                                    #!\/bin\/sh option(s)\r\n<\/pre>\n
                                                    In the form above, option can be one or combination of the debugging options above.<\/p>\n
                                                    2. Invoking Shell With Debugging Options<\/h4>\n
                                                    The second is by invoking the shell with debugging options as follows, this method will also turn on debugging of the entire script.<\/p>\n
                                                    $ shell option(s) script_name argument1 ... argumentN\r\n<\/pre>\n
                                                    For example:<\/p>\n
                                                    $ \/bin\/bash option(s) script_name argument1 ... argumentN   \r\n<\/pre>\n
                                                    3. Using set Shell Built-in Command<\/h4>\n
                                                    The third method is by using the set built-in command to debug a given section of a shell script such as a function. This mechanism is important, as it allows us to activate debugging at any segment of a shell script.<\/p>\n
                                                    We can turn on debugging mode using\u00a0set<\/strong>\u00a0command in form below, where option is any of the debugging options.<\/p>\n
                                                    $ set option \r\n<\/pre>\n
                                                    To enable debugging mode, use:<\/p>\n
                                                    $ set -option\r\n<\/pre>\n
                                                    To disable debugging mode, use:<\/p>\n
                                                    $ set +option\r\n<\/pre>\n
                                                    In addition, if we have enabled several debugging modes in different segments of a shell script, we can disable all of them at once like so:<\/p>\n
                                                    $ set -\r\n<\/pre>\n
                                                    That is it for now with enabling shell script debugging mode. As we have seen, we can either debug an entire shell script or a particular section of a script.<\/p>\n
                                                    In the next two episode of this series, we will cover how to use the shell script debugging options to\u00a0explain verbose<\/strong>,\u00a0syntax checking<\/strong>\u00a0and\u00a0shell tracing debugging<\/strong>\u00a0modes with examples.<\/p>\n
                                                    Importantly, do not forget to ask any questions about this guide or perhaps provide us feedback through the comment section below.<\/p>\n
                                                    How to Perform Syntax Checking Debugging Mode in Shell Scripts<\/h1>\n
                                                    We started the shell script debugging series by explaining the different debugging options and\u00a0how to enable shell script debugging modes<\/a>.<\/p>\n
                                                    After writing your shell scripts, it is recommended that we practically check the syntax in the scripts before running them, as opposed to looking at their output to confirm that they are working correctly.<\/p>\n
                                                    In this part of the series, we will go through how to use syntax checking debugging mode. Remember we explained the different debugging options in the first part of this series and here, we will use them to perform script debugging.<\/p>\n
                                                    Enabling Verbose Debugging Mode<\/h4>\n
                                                    Before we move to the primary focus of this guide, let us briefly explore the\u00a0verbose mode<\/strong>. It is enabled by the\u00a0-v<\/code>\u00a0debugging option, which tells the shell to display all lines in a script while they are read.<\/p>\n
                                                    To demonstrate how this works, below is a sample shell script to\u00a0batch convert PNG images to JPG format<\/a>.<\/p>\n
                                                    Type ( or copy and paste) it in a file.<\/p>\n
                                                    #!\/bin\/bash\r\n#convert\r\nfor image in *.png; do\r\n        convert  \"$image\"  \"${image%.png}.jpg\"\r\n        echo \"image $image converted to ${image%.png}.jpg\"\r\ndone\r\nexit 0\r\n<\/pre>\n
                                                    Then save the file and make the script executable using the command below:<\/p>\n
                                                    $ chmod +x script.sh\r\n<\/pre>\n
                                                    We can invoke the script and display all the lines in it as they are read by the shell like so:<\/p>\n
                                                    $ bash -v script.sh\r\n<\/pre>\n
                                                    \n
                                                    \"Display<\/a><\/p>\n
                                                    Display All Lines in Shell Script<\/p>\n<\/div>\n
                                                    Enabling Syntax Checking Debugging Mode in Shell Scripts<\/h4>\n
                                                    Coming back to our topic of emphasis, The\u00a0-n<\/code>\u00a0activates syntax checking mode. It instructs the shell to basically read all the commands, however doesn\u2019t execute them, it (shell) only examines the syntax used.<\/p>\n
                                                    In case there are errors in your shell script, the shell will output the errors on the terminal, otherwise, it displays nothing.<\/p>\n
                                                    The syntax for activating syntax checking is as follows:<\/p>\n
                                                    $ bash -n script.sh\r\n<\/pre>\n
                                                    Because the syntax in the script is correct, the command above will not display any output. Therefore, let us try to remove the\u00a0done<\/code>\u00a0word that closes the for loop and see if it shows an error:<\/p>\n
                                                    Below is the modified shell script to batch convert png images to jpg format that contains a bug.<\/p>\n
                                                    #!\/bin\/bash\r\n#script with a bug\r\n#convert\r\nfor image in *.png; do\r\n        convert  \"$image\"  \"${image%.png}.jpg\"\r\n        echo \"image $image converted to ${image%.png}.jpg\"\r\n\r\nexit 0\r\n<\/pre>\n
                                                    Save the file, then run it while performing syntax checking in it:<\/p>\n
                                                    $ bash -n script.sh\r\n<\/pre>\n
                                                    \n
                                                    \"Check<\/a><\/p>\n
                                                    Check Syntax in Shell Script<\/p>\n<\/div>\n
                                                    From the output above, we can see that there is a syntax problem with our script, the for loop is missing a closing\u00a0done<\/code>\u00a0keyword word. And the shell looked for it up to the end of the file and once it did not find it (done<\/strong>), the shell printed a syntax error:<\/p>\n
                                                    script.sh: line 11: syntax error: unexpected end of file\r\n<\/pre>\n
                                                    We can as well combine the verbose mode and syntax checking mode together:<\/p>\n
                                                    $ bash -vn script.sh\r\n<\/pre>\n
                                                    \n
                                                    \"Enable<\/a><\/p>\n
                                                    Enable Verbose and Syntax Checking in Script<\/p>\n<\/div>\n
                                                    Alternatively, we can enable syntax checking by modifying the first line of the script above as in the next example.<\/p>\n
                                                    #!\/bin\/bash -n<\/strong>\r\n#altering the first line of a script to enable syntax checking\r\n\r\n#convert\r\nfor image in *.png; do\r\n    convert  \"$image\"  \"${image%.png}.jpg\"\r\n    echo \"image $image converted to ${image%.png}.jpg\"\r\n\r\nexit 0\r\n<\/pre>\n
                                                    As before, save the file and run it while performing syntax checking:<\/p>\n
                                                    $ .\/script.sh\r\n\r\nscript.sh: line 12: syntax error: unexpected end of file<\/strong>\r\n<\/pre>\n
                                                    In addition, we can employ the set shell built-in command to enable debugging mode in the script above.<\/p>\n
                                                    In the example below, we are only checking the syntax of the for loop in our script.<\/p>\n
                                                    #!\/bin\/bash\r\n#using set shell built-in command to enable debugging\r\n#convert\r\n\r\n#enable debugging\r\nset -n\r\nfor image in *.png; do\r\n    convert  \"$image\"  \"${image%.png}.jpg\"\r\n    echo \"image $image converted to ${image%.png}.jpg\"\r\n\r\n#disable debugging\r\nset +n\r\nexit 0\r\n<\/pre>\n
                                                    Once again, save the file and invoke the script:<\/p>\n
                                                    $ .\/script.sh \r\n<\/pre>\n
                                                    In summary, we should always ensure that we syntactically check our shell scripts to capture any error before executing them.<\/p>\n
                                                    To send us any questions or feedback concerning this guide, use the response form below. In the third part of this series, we shall move to explaining and using shell tracing debugging mode.<\/p>\n
                                                    How to Trace Execution of Commands in Shell Script with Shell Tracing<\/h1>\n
                                                    In this article of the\u00a0shell script debugging series<\/a>, we will explain the third shell script debugging mode, that is shell tracing and look at some examples to demonstrate how it works, and how it can be used.<\/p>\n
                                                    The previous part of this series clearly throws light upon the two other shell script debugging modes:\u00a0verbose mode<\/strong>\u00a0and\u00a0syntax checking<\/strong>\u00a0mode with easy-to-understand examples of how to enable shell script debugging in these modes.<\/p>\n
                                                      \n
                                                    1. How To Enable Shell Script Debugging Mode in Linux \u2013 Part 1<\/a><\/li>\n
                                                    2. How to Perform Syntax Checking Debugging Mode in Shell Scripts \u2013 Part 2<\/a><\/li>\n<\/ol>\n
                                                      Shell tracing simply means tracing the execution of the commands in a shell script. To switch on shell tracing, use the\u00a0-x<\/code>\u00a0debugging option.<\/p>\n
                                                      This directs the shell to display all commands and their arguments on the terminal as they are executed.<\/p>\n
                                                      We will use the\u00a0sys_info.sh<\/code>\u00a0shell script below, which briefly prints your system date and time, number of users logged in and the system uptime. However, it contains syntax errors that we need to find and correct.<\/p>\n
                                                      #!\/bin\/bash\r\n#script to print brief system info\r\n\r\nROOT_ID=\"0\"\r\n\r\nDATE=`date`\r\nNO_USERS=`who | wc -l`\r\nUPTIME=`uptime`\r\n\r\ncheck_root(){\r\n    if [ \"$UID\" -ne \"$ROOT_ID\" ]; then\r\n        echo \"You are not allowed to execute this program!\"\r\n        exit 1;    \r\n}\r\n\r\nprint_sys_info(){\r\n    echo \"System Time    : $DATE\"\r\n    echo \"Number of users: $NO_USERS\"\r\n    echo \"System Uptime  : $UPTIME\r\n}\r\n\r\ncheck_root\r\nprint_sys_info\r\n\r\nexit 0\r\n<\/pre>\n
                                                      Save the file and make the script executable. The script can only be run by root, therefore employ the\u00a0sudo command<\/a>\u00a0to run it as below:<\/p>\n
                                                      $ chmod +x sys_info.sh\r\n$ sudo bash -x sys_info.sh\r\n<\/pre>\n
                                                      \n
                                                      \"Shell<\/a><\/p>\n
                                                      Shell Tracing \u2013 Show Error in Script<\/p>\n<\/div>\n
                                                      From the output above, we can observe that, a command is first executed before its output is substituted as the value of a variable.<\/p>\n
                                                      For example, the\u00a0date<\/strong>\u00a0was first executed and the its output was substituted as the value of the variable\u00a0DATE<\/strong>.<\/p>\n
                                                      We can perform syntax checking to only display the syntax errors as follows:<\/p>\n
                                                      $ sudo bash -n sys_info.sh \r\n<\/pre>\n
                                                      \n
                                                      \"Syntax<\/a><\/p>\n
                                                      Syntax Checking in Script<\/p>\n<\/div>\n
                                                      If we look at the shell script critically, we will realize that the\u00a0if statement<\/code>\u00a0is missing a closing\u00a0fi<\/code>\u00a0word. Therefore, let us add it and the new script should now look like below:<\/p>\n
                                                      #!\/bin\/bash\r\n#script to print brief system info\r\n\r\nROOT_ID=\"0\"\r\n\r\nDATE=`date`\r\nNO_USERS=`who | wc -l`\r\nUPTIME=`uptime`\r\n\r\ncheck_root(){\r\n    if [ \"$UID\" -ne \"$ROOT_ID\" ]; then\r\n        echo \"You are not allowed to execute this program!\"\r\n        exit 1;\r\n   fi    \r\n}\r\n\r\nprint_sys_info(){\r\n    echo \"System Time    : $DATE\"\r\n    echo \"Number of users: $NO_USERS\"\r\n    echo \"System Uptime  : $UPTIME\r\n}\r\n\r\ncheck_root\r\nprint_sys_info\r\n\r\nexit 0\r\n<\/pre>\n
                                                      Save the file again and invoke it as root and do some syntax checking:<\/p>\n
                                                      $ sudo bash -n sys_info.sh\r\n<\/pre>\n
                                                      \n
                                                      \"Perform<\/a><\/p>\n
                                                      Perform Syntax Check in Shell Scripts<\/p>\n<\/div>\n
                                                      The result of our syntax checking operation above still shows that there is one more bug in our script on\u00a0line 21<\/strong>. So, we still have some syntax correction to do.<\/p>\n
                                                      If we look through the script analytically one more time, the error on\u00a0line 21<\/strong>\u00a0is due to a missing closing double quote\u00a0(\u201d)<\/code>\u00a0in the last\u00a0echo command<\/a>\u00a0inside the\u00a0print_sys_info<\/code>\u00a0function.<\/p>\n
                                                      We will add the closing double quote in the\u00a0echo<\/strong>\u00a0command and save the file. The changed script is below:<\/p>\n
                                                      #!\/bin\/bash\r\n#script to print brief system info\r\n\r\nROOT_ID=\"0\"\r\n\r\nDATE=`date`\r\nNO_USERS=`who | wc -l`\r\nUPTIME=`uptime`\r\n\r\ncheck_root(){\r\n    if [ \"$UID\" -ne \"$ROOT_ID\" ]; then\r\n        echo \"You are not allowed to execute this program!\"\r\n        exit 1;\r\n    fi\r\n}\r\n\r\nprint_sys_info(){\r\n    echo \"System Time    : $DATE\"\r\n    echo \"Number of users: $NO_USERS\"\r\n    echo \"System Uptime  : $UPTIME\"\r\n}\r\n\r\ncheck_root\r\nprint_sys_info\r\n\r\nexit 0\r\n<\/pre>\n
                                                      Now syntactically check the script one more time.<\/p>\n
                                                      $ sudo bash -n sys_info.sh\r\n<\/pre>\n
                                                      The command above will not produce any output because our script is now syntactically correct. We can as well trace the execution of the script all for a second time and it should work well:<\/p>\n
                                                      $ sudo bash -x sys_info.sh\r\n<\/pre>\n
                                                      \n
                                                      \"Trace<\/a><\/p>\n
                                                      Trace Shell Script Execution<\/p>\n<\/div>\n
                                                      Now run the script.<\/p>\n
                                                      $ sudo .\/sys_info.sh\r\n<\/pre>\n
                                                      \n
                                                      \"Shell<\/a><\/p>\n
                                                      Shell Script to Show Date, Time and Uptime<\/p>\n<\/div>\n
                                                      Importance of Shell Script Execution Tracing<\/h3>\n
                                                      Shell script tracing helps us identify syntax errors and more importantly, logical errors. Take for instance the\u00a0check_root<\/code>\u00a0function in the\u00a0sys_info.sh<\/code>\u00a0shell script, which is intended to determine if a user is root or not, since the script is only allowed to be executed by the superuser.<\/p>\n
                                                      check_root(){\r\n    if [ \"$UID\" -ne \"$ROOT_ID\" ]; then\r\n        echo \"You are not allowed to execute this program!\"\r\n        exit 1;\r\n    fi\r\n}\r\n<\/pre>\n
                                                      The magic here is controlled by the\u00a0if statement<\/code>\u00a0expression\u00a0[ \"$UID\" -ne \"$ROOT_ID\" ]<\/code>, once we do not use the suitable numerical operator (-ne<\/code>\u00a0in this case, which means not equal ), we end up with a possible logical error.<\/p>\n
                                                      Assuming that we used\u00a0-eq<\/code>\u00a0( means equal to), this would permit any system user as well as the root user to run the script, hence a logical error.<\/p>\n
                                                      check_root(){\r\n    if [ \"$UID\" -eq \"$ROOT_ID\" ]; then\r\n        echo \"You are not allowed to execute this program!\"\r\n        exit 1;\r\n    fi\r\n}\r\n<\/pre>\n
                                                      Note<\/strong>: As we looked at before at the start of this series, the set shell built-in command can activate debugging in a particular section of a shell script.<\/p>\n
                                                      Therefore, the line below will help us find this logical error in the function by tracing its execution:<\/p>\n
                                                      The script with a logical error:<\/p>\n
                                                      #!\/bin\/bash\r\n#script to print brief system info\r\n\r\nROOT_ID=\"0\"\r\n\r\nDATE=`date`\r\nNO_USERS=`who | wc -l`\r\nUPTIME=`uptime`\r\n\r\ncheck_root(){\r\n    if [ \"$UID\" -eq \"$ROOT_ID\" ]; then\r\n        echo \"You are not allowed to execute this program!\"\r\n        exit 1;\r\n    fi\r\n}\r\n\r\nprint_sys_info(){\r\n    echo \"System Time    : $DATE\"\r\n    echo \"Number of users: $NO_USERS\"\r\n    echo \"System Uptime  : $UPTIME\"\r\n}\r\n\r\n#turning on and off debugging of check_root function\r\nset -x ; check_root;  set +x ;\r\nprint_sys_info\r\n\r\nexit 0\r\n<\/pre>\n
                                                      Save the file and invoke the script, we can see that a regular system user can run the script without\u00a0sudo<\/strong>\u00a0as in the output below. This is because the value of\u00a0USER_ID<\/strong>\u00a0is\u00a0100<\/strong>\u00a0which is not equal to root\u00a0ROOT_ID<\/strong>\u00a0which is\u00a00<\/strong>.<\/p>\n
                                                      $ .\/sys_info.sh\r\n<\/pre>\n
                                                      \n
                                                      \"Run<\/a><\/p>\n
                                                      Run Shell Script Without Sudo<\/p>\n<\/div>\n
                                                      Well, that is it for now, we have come to the end of the\u00a0shell script debugging series<\/a>, the response form below can be used to address any questions or feedback to us, concerning this guide or the whole 3-part series.<\/p>\n
                                                      How to Customize Bash Colors and Content in Linux Terminal Prompt<\/h1>\n
                                                      Today, Bash is the default shell in most (if not all) modern Linux distributions. However, you may have noticed that the text color in the terminal and the prompt content can be different from one distro to another.<\/p>\n
                                                      Suggested Read:<\/b>\u00a05 Most Frequently Used Open Source Shells for Linux<\/a><\/p>\n
                                                      In case you have been wondering how to customize this for better accessibility or mere whim, keep reading \u2013 in this article we will explain how to do just that.<\/p>\n
                                                      The PS1 Bash Environment Variable<\/h3>\n
                                                      The command prompt and terminal appearance are governed by an environment variable called\u00a0PS1<\/code>. According to the\u00a0Bash<\/strong>\u00a0man page,\u00a0PS1<\/strong>\u00a0represents the primary prompt string which is displayed when the shell is ready to read a command.<\/p>\n
                                                      The allowed content in\u00a0PS1<\/strong>\u00a0consists of several backslash-escaped special characters whose meaning is listed in the\u00a0PROMPTING<\/strong>\u00a0section of the man page.<\/p>\n
                                                      To illustrate, let\u2019s display the current content of\u00a0PS1<\/code>\u00a0in our system (this may be somewhat different in your case):<\/p>\n
                                                      $ echo $PS1\r\n\r\n[\\u@\\h \\W]$<\/strong>\r\n<\/pre>\n
                                                      We will now explain how to customize\u00a0PS1<\/strong>\u00a0as per our needs.<\/p>\n
                                                      Customizing the PS1 Format<\/h4>\n
                                                      According to the PROMPTING section in the man page, this is the meaning of each special character:<\/p>\n
                                                        \n
                                                      1. \\u:<\/code>\u00a0the\u00a0username<\/strong>\u00a0of the current user.<\/li>\n
                                                      2. \\h:<\/code>\u00a0the\u00a0hostname<\/strong>\u00a0up to the first dot\u00a0(.)<\/strong>\u00a0in the Fully-Qualified Domain Name.<\/li>\n
                                                      3. \\W:<\/code>\u00a0the\u00a0basename<\/strong>\u00a0of the current working directory, with\u00a0$HOME<\/strong>\u00a0abbreviated with a tilde\u00a0(~)<\/strong>.<\/li>\n
                                                      4. \\$:<\/code>\u00a0If the current user is root, display\u00a0#<\/strong>,\u00a0$<\/strong>\u00a0otherwise.<\/li>\n<\/ol>\n
                                                        For example, we may want to consider adding\u00a0\\!<\/code>\u00a0If we want to display the history number of the current command, or\u00a0\\H<\/code>\u00a0if we want to display the FQDN instead of the short server name.<\/p>\n
                                                        In the following example we will import both into our current environment by executing this command:<\/p>\n
                                                        PS1=\"[\\u@\\H \\W \\!]$\"\r\n<\/pre>\n
                                                        When you press\u00a0Enter<\/strong>\u00a0you will see that the prompt content changes as shown below. Compare the prompt before and after executing the above command:<\/p>\n
                                                        \n
                                                        \"Customize<\/a><\/p>\n
                                                        Customize Linux Terminal Prompt PS1<\/p>\n<\/div>\n
                                                        Now let\u2019s go one step further and change the color of the\u00a0user<\/strong>\u00a0and\u00a0hostname<\/strong>\u00a0in command prompt \u2013 both the text and its surrounding background.<\/p>\n
                                                        Actually, we can customize 3 aspects of the prompt:<\/p>\n\n\n\n\n\n\n\n\n\n\n\n
                                                        Text Format<\/b><\/td>\nForeground (text) color<\/b><\/td>\nBackground color<\/b><\/td>\n<\/tr>\n
                                                        0: normal text<\/td>\n30: Black<\/td>\n40: Black<\/td>\n<\/tr>\n
                                                        1: bold<\/td>\n31: Red<\/td>\n41: Red<\/td>\n<\/tr>\n
                                                        4: Underlined text<\/td>\n32: Green<\/td>\n42: Green<\/td>\n<\/tr>\n
                                                        <\/td>\n33: Yellow<\/td>\n43: Yellow<\/td>\n<\/tr>\n
                                                        <\/td>\n34: Blue<\/td>\n44: Blue<\/td>\n<\/tr>\n
                                                        <\/td>\n35: Purple<\/td>\n45: Purple<\/td>\n<\/tr>\n
                                                        <\/td>\n36: Cyan<\/td>\n46: Cyan<\/td>\n<\/tr>\n
                                                        <\/td>\n37: White<\/td>\n47: White<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                                                        We will use the\u00a0\\e<\/code>\u00a0special character at the beginning and an\u00a0m<\/code>\u00a0at the end to indicate that what follows is a color sequence.<\/p>\n
                                                        In this sequence the three values (background<\/strong>,\u00a0format<\/strong>, and\u00a0foreground<\/strong>) are separated by commas (if no value is given the default is assumed).<\/p>\n
                                                        Suggested Read:<\/b>\u00a0Learn Bash Shell Scripting in Linux<\/a><\/p>\n
                                                        Also, since the value ranges are different, it does not matter which one (background<\/strong>,\u00a0format<\/strong>, or\u00a0foreground<\/strong>) you specify first.<\/p>\n
                                                        For example, the following\u00a0PS1<\/code>\u00a0will cause the prompt to appear in\u00a0yellow<\/strong>\u00a0underlined text with\u00a0red<\/strong>\u00a0background:<\/p>\n
                                                        PS1=\"\\e[41;4;33m[\\u@\\h \\W]$ \"<\/strong>\r\n<\/pre>\n
                                                        \n
                                                        \"Change<\/a><\/p>\n
                                                        Change Linux Terminal Color Prompt PS1<\/p>\n<\/div>\n
                                                        As good as it looks, this customization will only last for the current user session. If you close your terminal or exit the session, the changes will be lost.<\/p>\n
                                                        In order to make these changes permanent, you will have to add the following line to\u00a0~\/.bashrc<\/code>\u00a0or\u00a0~\/.bash_profile<\/code>\u00a0depending on your distribution:<\/p>\n
                                                        PS1=\"\\e[41;4;33m[\\u@\\h \\W]$ \"<\/strong>\r\n<\/pre>\n
                                                        Feel free to play around with the colors to find what works best for you.<\/p>\n
                                                        Summary<\/h5>\n
                                                        In this article we have explained how to customize the color and content of your Bash prompt. If you have questions or suggestions about this post, feel free to use the comment form below to reach us. We look forward to hearing from you!<\/p>\n
                                                        How To Write and Use Custom Shell Functions and Libraries<\/h1>\n
                                                        In Linux, shell scripts help us in so many different ways including performing or even\u00a0automating certain system administration tasks<\/a>, creating simple command line tools and many more.<\/p>\n
                                                        In this guide, we will show new Linux users where to reliably store custom shell scripts, explain how to write custom shell functions and libraries, use functions from libraries in other scripts.<\/p>\n
                                                        Where to Store Shell Scripts<\/h3>\n
                                                        In order to run your scripts without typing a full\/absolute path, they must be stored in one of the directories in the\u00a0$PATH<\/strong>\u00a0environment variable.<\/p>\n
                                                        To check your\u00a0$PATH<\/strong>, issues the command below:<\/p>\n
                                                        $ echo $PATH<\/strong>\r\n\r\n\/usr\/local\/sbin:\/usr\/local\/bin:\/usr\/sbin:\/usr\/bin:\/sbin:\/bin:\/usr\/games:\/usr\/local\/games\r\n<\/pre>\n
                                                        Normally, if the directory\u00a0bin<\/strong>\u00a0exists in a users home directory, it is automatically included in his\/her\u00a0$PATH<\/strong>. You can store your shell scripts here.<\/p>\n
                                                        Therefore, create the\u00a0bin<\/strong>\u00a0directory (which may also store\u00a0Perl<\/strong>,\u00a0Awk<\/a>\u00a0or\u00a0Python<\/strong>\u00a0scripts or any other programs):<\/p>\n
                                                        $ mkdir ~\/bin\r\n<\/pre>\n
                                                        Next, create a directory called\u00a0lib<\/strong>\u00a0(short for libraries) where you\u2019ll keep your own libraries. You can also keep libraries for other languages such as C, Python and so on, in it. Under it, create another directory called\u00a0sh<\/strong>; this will particularly store you shell libraries:<\/p>\n
                                                        $ mkdir -p ~\/lib\/sh \r\n<\/pre>\n
                                                        Create Your Own Shell Functions and Libraries<\/h3>\n
                                                        A\u00a0shell function<\/strong>\u00a0is a group of commands that perform a special task in a script. They work similarly to procedures, subroutines and functions in other programming languages.<\/p>\n
                                                        The syntax for writing a function is:<\/p>\n
                                                        function_name() { list of commands }\r\n<\/pre>\n
                                                        For example, you can write a function in a script to show the\u00a0date<\/strong>\u00a0as follows:<\/p>\n
                                                        showDATE() {date;}\r\n<\/pre>\n
                                                        Every time you want to display\u00a0date<\/strong>, simply invoke the function above using its name:<\/p>\n
                                                        $ showDATE\r\n<\/pre>\n
                                                        A\u00a0shell library<\/strong>\u00a0is simply a shell script, however, you can write a library to only store your functions that you can later call from other shell scripts.<\/p>\n
                                                        Below is an example of a library called\u00a0libMYFUNCS.sh<\/strong>\u00a0in my\u00a0~\/lib\/sh<\/strong>\u00a0directory with more examples of functions:<\/p>\n
                                                        #!\/bin\/bash \r\n\r\n#Function to clearly list directories in PATH \r\nshowPATH() { \r\n        oldifs=\"$IFS\"   #store old internal field separator\r\n        IFS=:              #specify a new internal field separator\r\n        for DIR in $PATH ;  do echo $DIR ;  done\r\n        IFS=\"$oldifs\"    #restore old internal field separator\r\n}\r\n\r\n#Function to show logged user\r\nshowUSERS() {\r\n        echo -e \u201cBelow are the user logged on the system:\\n\u201d\r\n        w\r\n}\r\n\r\n#Print a user\u2019s details \r\nprintUSERDETS() {\r\n        oldifs=\"$IFS\"    #store old internal field separator\r\n        IFS=:                 #specify a new internal field separator\r\n        read -p \"Enter user name to be searched:\" uname   #read username\r\n        echo \"\"\r\n       #read and store from a here string values into variables using : as  a  field delimiter\r\n    read -r username pass uid gid comments homedir shell <<< \"$(cat \/etc\/passwd | grep   \"^$uname\")\"\r\n       #print out captured values\r\n        echo  -e \"Username is            : $username\\n\"\r\n        echo  -e \"User's ID                 : $uid\\n\"\r\n        echo  -e \"User's GID              : $gid\\n\"\r\n        echo  -e \"User's Comments    : $comments\\n\"\r\n        echo  -e \"User's Home Dir     : $homedir\\n\"\r\n        echo  -e \"User's Shell             : $shell\\n\"\r\n        IFS=\"$oldifs\"         #store old internal field separator\r\n}\r\n<\/pre>\n
                                                        Save the file and make the script executable.<\/p>\n
                                                        How To Invoke Functions From a Library<\/h3>\n
                                                        To use a function in a\u00a0lib<\/strong>, you need to first of all include the\u00a0lib<\/strong>\u00a0in the shell script where the function will be used, in the form below:<\/p>\n
                                                        $ .\/path\/to\/lib\r\nOR\r\n$ source \/path\/to\/lib\r\n<\/pre>\n
                                                        So you would use the function\u00a0printUSERDETS<\/strong>\u00a0from the lib\u00a0~\/lib\/sh\/libMYFUNCS.sh<\/strong>\u00a0in another script as shown below.<\/p>\n
                                                        You do not have to write another code in this script to print a particular user\u2019s details, simply call an existing function.<\/p>\n
                                                        Open a new file with the name\u00a0test.sh<\/strong>:<\/p>\n
                                                        #!\/bin\/bash \r\n\r\n#include lib\r\n.  ~\/lib\/sh\/libMYFUNCS.sh\r\n\r\n#use function from lib\r\nprintUSERDETS\r\n\r\n#exit script\r\nexit 0\r\n<\/pre>\n
                                                        Save it, then make the script executable and run it:<\/p>\n
                                                        $ chmod 755 test.sh\r\n$ .\/test.sh \r\n<\/pre>\n
                                                        \n
                                                        \"Write<\/a><\/p>\n
                                                        Write Shell Functions<\/p>\n<\/div>\n
                                                        In this article, we showed you where to reliably store shell scripts, how to write your own shell functions and libraries, invoke functions from libraries in normal shell scripts.<\/p>\n
                                                        Next, we will explain a straight forward way of configuring\u00a0Vim<\/strong>\u00a0as an\u00a0IDE<\/strong>\u00a0for Bash scripting. Until then, always stay connected to TecMint and also share your thoughts about this guide via the feedback form below.<\/p>\n
                                                        Understanding Shell Initialization Files and User Profiles in Linux<\/h1>\n
                                                        Linux is a multi-user, time sharing system, implying that more than one user can log in and use a system. And system administrators have the task of managing various aspects of how different users can operate a system in terms of\u00a0installing\/updating\/removing software<\/a>, programs they can run, files they can view\/edit and so on.<\/p>\n
                                                        Linux also allows users\u2019 environments to be created or maintained in two major ways: using system-wide (global) and user-specific (personal) configurations. Normally, the basic method of working with a Linux system is the shell, and the shell creates an environment depending on certain files it reads during its initialization after a successful user login.<\/p>\n
                                                        Suggested Read:<\/b>\u00a0How to Set Environment Variables in Linux<\/a><\/p>\n
                                                        In this article, we will explain shell initialization files in relation to user profiles for local user management in Linux. We will let you know where to keep custom shell functions, aliases, variables as well as startup programs.<\/p>\n
                                                        Important<\/strong>: For the purpose of this article, we will focus on\u00a0bash<\/strong>, a\u00a0sh<\/strong>\u00a0compatible shell which is the\u00a0most popular\/used shell on Linux systems<\/a>\u00a0out there.<\/p>\n
                                                        If you are using a different shell (zsh, ash, fish etc..) program, read through its documentation to find out more about some of the related files we will talk about here.<\/p>\n
                                                        Shell Initialization in Linux<\/h3>\n
                                                        When the shell is invoked, there are certain initialization\/startup files it reads which help to\u00a0setup an environment for the shell<\/a>\u00a0itself and the system user; that is predefined (and customized) functions, variables, aliases and so on.<\/p>\n
                                                        There are two categories of initialization files read by the shell:<\/p>\n