We’ve been talking about Unix being a multi-user, multiprocessing system, but we haven’t really though of security yet, have we ? I mean, if there are several users using a system at the same time, your personal data can’t be safe, right ?

Wrong !

The designers of Unix also faced this problem … and fortunately they were smart enough to devise a solution for this.

We learned earlier ( did we ? ), that everything in Unix is a file. Well, it is, and every file has certain attributes associated with it. These attributes define the permissions that the file has, or rather, the permissions that a particular user has to access that file. All this getting too complicated ? An example would be perfect here:

$ ls -l

total 4

drwx–x–x  13 sharninder sharninder 4096 Sep 29 02:53 ./

drwxr-xr-x   3    root           root           4096 Mar  6  2008 ../

drwxr-x—   3   sharninder mail           4096 Mar  7  2008 etc/

-rwxrw-r–  10 sharninder sharninder 4096 Apr  4 01:52 test.sh

This is the listing you get when you look at a directory with the long listing option ( -l ) to ls. This listing can be broken down into 7 sections. Each line describes one line and from left to right, the various columns give the: the permissions, the number of links, the owner, the group owner, the size in bytes, the date and time of the last modification, and the file’s name. 

The first character of the permission column tells us what kind of file this is. ‘d’ stands for directory, hyphen (-) for regular file. The next three triplets of three characters each tell us, in order, the permissions on the file that apply to the file’s owner, the file’s group and the public.

So, for example, the file test.sh is a regular file (-), the owner has the permissions, rwx, the group has the permission, rw, and the public has only the ‘r’ permission. ‘r’ stands for read-only, ‘w’ stands for writing (which implies reading) and ‘x’ stands for executable. For directories, ‘x’ means that the directory can be browsed through.

Before, we learn how to set permissions, we should know what the third and fourth columns stand for. The third column of the file listing is name of the owner of the file and the fourth column lists the group the file owner belongs to.

Now, we’ll learn how to set permissions ourselves.

To set or change the permissions on a file, we use the chmod command. For example:

$ chmod a+rw test.sh

The above command will set the read-write (+rw) permission for the public (a – all) on the file test.sh. Similarly:

$ chmod a-rw test.sh

will remove the read-write (-rw) permission for the public (a -all) from the test.sh file.

$ chmod u+x test.sh 

This will set the executable permissions on the test.sh file for the user who owns the file (u – user).

$ chmod g-rw test.sh

Will take away the read-write permissions from the test.sh file for the user who belong to the group (g -group) of the file’s owner.

With the chmod command we can only deal with the permissions imposed on the owner/group of the file. What if we need to the owner/group itself. That is taken care of by the chown command.

$ chmod sharninder.root test.sh

The above command will set the user of the test.sh file as sharninder and the group as root. Basically, the format to use is <user>.<group>

Thats all for today. With those two commands in hand, you should be able to handle almost all Unix permissions. Read the man pages for both the commands and you should be good to go.

If you found this post interesting, you may also want to read ...

• Unix 101: Manipulating files – Copying, moving, deleting
• Unix 101: Unix processes
• Unix 101 – Help aka ‘man’ pages
• Unix 101: Listing and reading files and moving between directories

This post is the next in a series of posts we’re doing on Unix. The aim of the series is to get our readers familiar with the basics of working on a Unix or a Linux system.

Uptil now we’ve learned a bit about how the Unix system works and how to navigate around the filesystem. We can now login to a unix system and start viewing the files and moving around between different directories. We also know a little about processes on a Unix system.

What next ?

This post will teach you about different file manipulation operations. By file manipulation, I mean, commands to copy, move or delete files. Since, on a Unix/Linux system everything is a file, the commands that we learn about today can also be used to work with directories, with some changes.

Unix commands have a reputation for being terse and short, which goes back to the old days when all input to a system was through some complex circuit manipulations or the computer had to be fed punch cards to recognize input. It made sense to use short commands for the purpose back then and modern Unixes/Linuxes have just carried on the tradition.

Take for example, the command to copy a file, cp, the syntax for which is:

# cp <sourcefile> <destinationfile>

For eg:

# cp test1 test2

The above command will just make a copy named test2 of the file named test1. Simple, isn’t it ?

Continuing the tradition of terse commands is the command to move files, mv.

# mv <sourcefile> <destinationfile>

For eg:

# mv test1 testdirectory/test2

The above command will copy the file named test1 to the directory named testdirectory and will change the name of the file to test2. If you don’t give the name of the destination file (test2 in the example), the file will be moved with the same name as the source.

The last command that we’ll be talking about today is the remove command, or rm. rm is the command to use when you want to remove a file from the system.

# rm <filename>

For example,

# rm test1

The above command will delete the file named test1. Use the command with care, though, since unlike Windows there is no concept of a recycle bin in Unix/Linux and any file that you delete using rm will be gone forever and you cannot change your mind later.

The above commands also work on directories, since a directory is also a file in Unix, a special file.

That was a basic overview of the cp, mv and rm commands. As always, I’d urge you to RTFM (read the fine manual – man pages in this case) and try out these commands for yourself. The only way to understand Unix is to use it.

I really hope this series of posts is benefitting atleast someone out there. I would love to hear some feedback from you guys on how I can improve my next posts and also what would you like me to cover.

If you found this post interesting, you may also want to read ...

• Unix 101: Unix processes
• Unix 101 – Help aka ‘man’ pages
• Unix 101: Listing and reading files and moving between directories
• Unix 101 – Basic Unix skills

is a method for storing and organizing computer files and the data they contain to make it easy to find and access them.

It is the filesystem which provides us the abstraction of folders, directories and sub-directories that we use to store files on a computer. Infact, it is the filesystem only which lets us store and retrieve any data that we store in a computer.

Filesystems are usually a part of the kernel, the heart of the operating system and the code runs in a privileged mode known as kernel mode which means that only the operating system has access to that code. That is also the reason why developing a real filesystem is usually the domain of highly talented kernel developers.

FUSE changes all that. FUSE, which stands for “Filesystem in USErspace”, provides an API (application programming interface) for anyone to create their own filesystem, which runs like a normal user program. If all this is confusing you, don’t worry, cause you don’t really have to worry about these details.

How is FUSE useful for you ?

Like I said, FUSE provides an interface for anyone to create a filesystem without resorting to nifty trickery in the kernel world. This has led to a proliferation of a large number of rather useful filesystem hacks. Filesystems which let you view compressed archives, let you make backups or encrypt your files.

Let’s look at how to setup FUSE on an Ubuntu 8.04 based system and use that to mount an encrypted filesystem using sshfs. FUSE is a part of the Ubuntu ‘Hardy Heron’ kernel and the module should be loaded when the system boots up. Check for it using the lsmod command:

sharninder@blr-skhera:~$ lsmod|grep fuse
fuse 50708 3

Now, you should install the FUSE utilities package and the library package.

$ sudo apt-get install fuse-utils libfuse2

Now, you can go ahead and install sshfs using the following command:

sharninder@blr-skhera:~$ sudo apt-get install sshfs

You should now have a working installation of sshfs and you’re ready to mount a remote filesystem over an encrypted channel. Mounting an sshfs partition is as simple as:

sharninder@blr-skhera:~$ sshfs testuser@testserver:/home/testuser MP
testuser@testserver’s password:
sharninder@blr-skhera:~$ cd MP
sharninder@blr-skhera:~/MP$ ls
etc mail public_html tmp
sharninder@blr-skhera:~/MP$

The above command will mount the ‘/home/testuser’ directory from the testserver to the ‘MP’ mount point on the local system. The entire communication between the client and the server will be encrypted and the user testuser will be used to communicate with the server. This can be a handy way to access frequently used servers and all regular Unix commands like cp, rm, mv will work on the mount point as if it is a local directory.

To unmount the filesystem, use the following command:

$ fusermount -u MP

Where MP is the mount point.

Now, that you have used the sshfs module you’re all set to explore the countless other modules that have been developed for FUSE. Try playing with flickrfs, fuseiso, fusedav or fusesmb and let us know how it goes.

If you found this post interesting, you may also want to read ...

• Canonical Offers Sale of Proprietary Codecs for Ubuntu
• Will Open Source survive the economic crisis
• T-Mobile G1 – World’s first Android based Phone Launched
• Unix 101: Manipulating files – Copying, moving, deleting

Well, for one, you can create multiple users on linux and let all of them use the machine at the same time, by letting them login remotely (We’ll cover this later). And thus, Linux is a multiuser operating system.

Multitasking is a little more complicated.

You see, a Unix system at any time is always running more than one programs simultaneously. Ah, but I am only running my browser, you ask ? Well, yes and no. The browser is the only program that you are running but there is more to the operating system, than just the browser, right ? For example, the graphical interface that you’re running. And what if there are more people working on the same system (the multiuser part of it), then all of them would be running their own programs, right ? So, to cut things short, any Linux or Unix system at any time is always running multiple programs/tasks and thus, is a multitasking system. How does it do that ?

To make your browser run and take input from you or display images, a lot is going on in the background which you don’t see. Multitasking is one of those things. The operating system partitions the memory so that no other user can see the email that you’re working on, it makes sure that the email client has the resources it needs to send the email when it wants and various other sundry tasks. If you’re confused, I understand. These are more complicated operating system task should probably be reserved to the Unix 201 or 301 course :-)

Today we’re just going to play around a bit with processes on a Linux box.

To list all the processes running on your machine, use the following command:

$ ps

The output will be something like this:

  PID TTY          TIME CMD
 8551 pts/0    00:00:00 bash
 8600 pts/0    00:00:00 ps

That’s some terse output, isn’t it ? Well, what it tells you is that there are two process running on your system and those are bash and ps (ps is the command you ran to get this list, so while it was getting the list, it was one of the processes running and so it included itself in the list). The other thing that the output tell you is the process ID (PID) of the processes. This is an identifier that the system uses to identify processes internally. The PID for bash is 8551 and the PID for ps is 8600. The next time you run this command, the ps command will have a different PID because once the ps command has executed, the operating system clears all resources used by it and that includes the PID. When the command runs again, it gets all shiny, brand new resources.

Now, if you’ve noticed, the above ps output only shows you the commands that you are running. If you want to see all the processes that are running on the system at any time. Use the ps command with the following options:

$ ps -ef

That, I’m sure, is a lot more info that most of you are ready to digest, right ? If, the answer is No, then you shouldn’t be reading this :-)

Jokes apart, the basic info given in the output is the same but there are some other fields which might be interesting. You can read the man page for the ps command to read about all the fields or the various other options that the command supports. There are dozens and its not practical for me to cover all of them here.

We’ll be covering the ps command in more detail in a later post and learn to do more cool things with it.

Subscribe to this blog using your RSS reader or by Email.

If you found this post interesting, you may also want to read ...

• Unix 101: Manipulating files – Copying, moving, deleting
• Unix 101 – Help aka ‘man’ pages
• Unix 101: Listing and reading files and moving between directories
• Unix 101 – Basic Unix skills

“UNIX is basically a simple operating system, but you have to be a genius to understand the simplicity.”

- Dennis Ritchie

Dennis Ritchie is one of the creators of Unix and the above quote summarizes the philosophy behind Unix. The Unix command line is terse by design and it can take a new user a long time to understand (and remember) the nuances of a particular command line.

Fret not, cause man is at hand.

man is the unix/linux command line utility designed to display documentation about a given command. For example, suppose you’ve forgotten the option used to display the long list of files in a directory, you can use the following command to view the help manual for the ‘ls’ command:

$ man ls

That’s it.

This will display a page with a description of the ‘ls’ command and all the options that it supports. If you’re lucky, the man page writer would have also included some examples describing the usage of the command.

Now, try viewing the man page for all the other commands that we’ve discussed till now.

If you found this post interesting, you may also want to read ...

• Unix 101: Manipulating files – Copying, moving, deleting
• Unix 101: Unix processes
• Unix 101: Listing and reading files and moving between directories
• Unix 101 – Basic Unix skills

In this post we’ll learn how to start working with files. Creating, deleting and managing files is the reason you use a computer, right ?

Unix has a concept of directories, which is the same as a folder on Windows.

To list all the files in the current directory, use the following command:

$ ls

This will give you a list of directories in what is called the wide format.

If you want to see the listing of files in the long format, which is somewhat like the “dir” command output of windows, use the following command:

$ ls -l

Now, to view the contents of a particular file, use the “cat” command:

$ cat <filename>

Now, to change into a different directory than the current one, use the following command:

$ cd ./<directory name>

Notice the “./” in front of the name. Well, lets just say you’ll learn about this a while later and keep it as it is for now.

To see the directory that you are in currently, use the following command:

$ pwd

the pwd command will give you what is called the full path of the current working directory. Remember the folder based hierarchy that Windows has, where all folders begin with a folder in the c: or d: or x: ? Well, Unix/Linux all folders (directories) begin from what is called the root, which is denoted by a single slash (/).

When you give the pwd command the output would be something like:

/home/testuser/testfolder

This means that the home directory is under the root (/) and under the home directory there is a directory named testuser, and under that directory is a directory named testfolder, which is where the user is currently working.

By the way, when you used the ‘ls’ command to list the contents of the directory, did you notice the first two entries in the list ? The first two entries are special. Those are the . (dot) and .. (double dot). The dot stands for the current directory and the double dot stands for the directory which is one above the current directory in the hierarchy.

So, for example, if you are in the testfolder as shown by the pwd command, and type the following:

$ cd ..

That will take you to the “testuser” directory, since testuser is one level above the testfolder directory. If, on the other hand, you just do a “cd .” (single dot), you will still be in the same directory.

That should be enough to get you all started … till my next post.

If you found this post interesting, you may also want to read ...

• Unix 101: Manipulating files – Copying, moving, deleting
• Unix 101: Unix processes
• Unix 101 – Help aka ‘man’ pages
• Unix 101 – Basic Unix skills

I’ve also been interviewing people with basic Unix skills for various positions over the last couple of years. For some reason, I’ve found that Indian college curriculum doesn’t put too much emphasis on Unix and so, most people who come out of these colleges don’t know much beyond the flashy GUIs that most Unix/Linux distros have. Infact, a lot of people who come for interviews tend to thing that Redhat/Fedora IS Linux. And when asked, tell me that the only Linux they have experience on is Linux version 9 !

Anyway, I’ve decided to start series on basic Unix skills on this blog in the hope that this’ll be a useful reference for someone starting to learn Unix/Linux. I’ll be mostly concentrating on Linux as that is what I’m most comfortable with and currently work with, but if I do get requests for similar posts on other Unix systems, I’ll be happy to oblige.

Since, this is the first post in this series, I’ll keep things simple.

The “#” or “$” is the prompt that I will be using to depict the command line and anything after that is the actual command that you should be running.

The superuser or the Administrator on a Linux system is called “root”. When you first install a Linux distribution, you would have been asked to fill in a password during the install. This would be the password of the root user. Use this to login to your box for the first time.

It is usually not a good idea to continue using the system as the root user. As the superuser, you can give a nasty command to delete all files on the system and the operating system will not even let out a muffled cry.

If the idea is to learn linux, it is always a good idea to first create a new user and use that login to practice. The following command will let you add a new non privileged user to the system:

# adduser <username>

The user that you’ve just added needs a password to be able to login. Give a password to this user like this:

# passwd

Enter new Unix password:

Retype new Unix password:

Now, logout of the current session using:

# logout

Now, you’re all set to login as the new user you just created and start learning the nuances of this wonderful operating system.

PS: Some distributions like Ubuntu will let you do the above steps in just one command. So, if you’re using Ubuntu, just give the adduser command and it will create the user as well as ask you for the password. You don’t need to give the passwd command seperately.

Hopefully, you’ve found this post useful. I’ll continue with this series over the next couple of days. Let me know if you guys want me to write on something specific instead.

If you found this post interesting, you may also want to read ...

• Unix 101: Manipulating files – Copying, moving, deleting
• Unix 101: Unix processes
• Unix 101 – Help aka ‘man’ pages
• Unix 101: Listing and reading files and moving between directories