gphoto2 allows you to directly connect a digital camera over USB and transfer the saved images and videos to your computer. This is very helpful when you don’t have access to a media card reader.

Install the gphoto2 package on your system.

In Gentoo:

# emerge media-gfx/gphoto2

In Ubuntu:

# aptitude install gphoto2

Start off by connecting your digital camera to your computer with a USB cable and turning on any transfer/playback mode that might exist.

Run the following command to see if your camera is auto-detected by gphoto2. It will show you the camera model that detected and what port it is on.

$ gphoto2 --auto-detect

This will show you all the files that are currently stored on your camera including images and videos. You will get data such as type, size, and location on the camera device.

$ gphoto2 --list-files

Change your current working directory to the location that you want the images saved on your system.

$ cd ~/camera_images/

Now you can download all the images and videos from your camera to your current working directory on your system.

$ gphoto2 --get-all-files

Once all images are downloaded to your computer you can clear the camera. Make sure your images are stored on your system correctly because there is no going back.

$ gphoto2 --delete-all-files

No related posts.

The lsof command stands for “list open files”. It can show all open files as well as sockets, memory mapped libraries, directories, pipes, and network sockets. It is an incredibly powerful tool which you can use to gather detailed information about what is happening on your system.

If you run lsof as a normal user you will be limited to only the the processes owned by that user. To get system wide results you must run the command as root or use sudo.

Running the command by itself will show information for all active process on the system.

# lsof

COMMAND    PID   USER   FD      TYPE             DEVICE     SIZE       NODE NAME
lsof    7289 root  cwd    DIR    8,3    4096  6504451 /home/ryan
lsof    7289 root  rtd    DIR    8,3    4096        2 /
lsof    7289 root  txt    REG    8,3  110280 11178207 /usr/bin/lsof
lsof    7289 root  mem    REG    8,3  114952 11504968 /lib64/ld-2.6.1.so
lsof    7289 root  mem    REG    8,3 1293456 11504986 /lib64/libc-2.6.1.so
lsof    7289 root    0u   CHR  136,1                3 /dev/pts/1
lsof    7289 root    1u   CHR  136,1                3 /dev/pts/1
lsof    7289 root    2u   CHR  136,1                3 /dev/pts/1
lsof    7289 root    3r   DIR    0,3       0        1 /proc
lsof    7289 root    4r   DIR    0,3       0    19745 /proc/7289/fd
lsof    7289 root    5w  FIFO    0,5            19759 pipe
lsof    7289 root    6r  FIFO    0,5            19760 pipe
lsof    7290 root  cwd    DIR    8,3    4096  6504451 /home/ryan
lsof    7290 root  rtd    DIR    8,3    4096        2 /
lsof    7290 root  txt    REG    8,3  110280 11178207 /usr/bin/lsof
lsof    7290 root  mem    REG    8,3  114952 11504968 /lib64/ld-2.6.1.so
lsof    7290 root  mem    REG    8,3 1293456 11504986 /lib64/libc-2.6.1.so
lsof    7290 root    4r  FIFO    0,5            19759 pipe
lsof    7290 root    7w  FIFO    0,5            19760 pipe
...

As you can see in the previous output each open file is associated with its program and PID and has many attributes such as type, size, file descriptor, device, and inode number.

You can narrow the results down to an individual process.

# lsof -p 12345

You can get results for every process that is owned by a specific user.

# lsof -u ryan

This will give you detailed information about all network socket connections.

# lsof -i

You can narrow the results down to only TCP connections.

# lsof -i TCP

You can get information on a specific port.

# lsof -i :80

You can get information about all instances of a specific program

# lsof -c bash

This will show all files that are open within the ‘/tmp’ directory.

# lsof +D /tmp

To get even more detailed output you can pipe these results to grep or use the ‘-a‘ option which combines any number of options.

For example you can view all network socket connections that are owned by the user ryan.

# lsof -a -i TCP -u ryan

No related posts.

The find command allows you to recursively search and locate files on your system based on specific criteria. You can search by name, owner, group, type, permissions, date, as well as many others.

The find command uses the following format:

find [search_path(s)] [search_criteria]

The following is the most basic way to run the find command. It will list every file and directory within your current working directory.

$ find

This produces the same output but you are specifically listing the current directory as the search path.

$ find .

To search the entire filesystem, specify root as the search path (this could take a long time).

$ find /

You may want to redirect stderr to “/dev/null” to separate the valid output from the errors you might encounter from searching in directories where you don’t have the correct permissions.

$ find / 2> /dev/null

To search for a file with a specific name. This will find all files named “myfile” within your home directory.

$ find ~/ -name myfile

This will find all files with a “.jpg” extension in your home directory. The double quotes are needed so the shell will not expand the wildcards in the search string before it passes it to the find command.

$ find ~/ -name "*.jpg"

You can limit the depth level of the search as well. Set the value to 1 to search within the specified directory without recursing into any subdirectories. Raising the value will extend the search into that many directory levels.

$ find ~/ -name "*.jpg" -maxdepth 1

Search for files by permissions. This will find all files in your home directory that have rwx permissions for everyone.

$ find ~/ -perm 777

Search for executables.

$ find ~/ -executable

Search for files in your home directory which have been modified in the last twenty-four hours.

$ find ~/ -mtime 0

Search for files that are owned by the user “ryan”.

$ find / -user ryan

The find command is great for locating files but you can also execute commands on those files that it finds. To execute commands use the ‘-exec‘ option. The command below will perform an ‘ls -l‘ on each jpeg file it finds in your home directory.

$ find ~/ -name "*.jpg" -exec ls -l {} \;

The ‘-ok‘ option is similar to ‘-exec‘ but it will prompt you for confirmation before executing each command. This is helpful when you want to execute a potentially dangerous command such as removing files with rm like the example below.

$ find ~/ -name "*.jpg" -ok rm {} \;

< rm ... /home/ryan/pic1.jpg > ? n
< rm ... /home/ryan/pic2.jpg > ? n
< rm ... /home/ryan/pic3.jpg > ? n

No related posts.

The ldd command allows you to view detailed information about library dependencies of dynamically linked programs and other shared libraries. ldd uses the runtime linker ld.so which reads the ELF formatted executable to generate the output. It is a helpful tool to have at your disposal when debugging broken programs.

Here ldd examines the ‘ls’ executable. The output displays the dependencies as well as how they will be resolved if run with the current environment.

$ ldd /bin/ls

	linux-vdso.so.1 =>  (0x00007fffe0dfe000)
	librt.so.1 => /lib/librt.so.1 (0x00002b4eca08e000)
	libacl.so.1 => /lib/libacl.so.1 (0x00002b4eca297000)
	libc.so.6 => /lib/libc.so.6 (0x00002b4eca49f000)
	libpthread.so.0 => /lib/libpthread.so.0 (0x00002b4eca7df000)
	/lib64/ld-linux-x86-64.so.2 (0x00002b4ec9e72000)
	libattr.so.1 => /lib/libattr.so.1 (0x00002b4eca9fa000)

Sometimes you will see that an application can’t resolve one or more libraries. It would most likely fail to execute at this moment if you see a “not found” entry like this.

$ ldd ~/myprogram

	librt.so.1 => /lib/librt.so.1 (0x00002b4eca08e000)
	libc.so.6 => /lib/libc.so.6 (0x00002b4eca49f000)
	libpthread.so.0 => /lib/libpthread.so.0 (0x00002b4eca7df000)
	/lib64/ld-linux-x86-64.so.2 (0x00002b4ec9e72000)
	libmylib.so.1 => not found

To resolve these type of issues you can either install the missing libraries, or if they are already installed, update the LD_LIBRARY_PATH environment variable with the path to the libraries.

Once you have done one of these two things, rerun ldd on the executable and verify that the library dependency can now be correctly resolved.

One last caveat, ldd will not display information about shared libraries that the program may try to open using the glibc function dl_open() during its execution.

No related posts.

Similar to the tail command which shows you the last few lines of a text file, the head command lets you to quickly view the first few lines.

The head command syntax.

head [options] file

By default head will show you the first 10 lines of a text file.

$ head textfile.txt

You can change the number of lines displayed by adding ‘-n‘ option and adding the number of lines.

$ head -n 3 textfile.txt

This will show the first 3 lines in the file.

No related posts.

Similar to the head command which shows you the first few lines of a text file, the tail command lets you to quickly view the last few lines of a text file. It also supports a monitoring mode which displays ongoing changes within the file.

The tail command syntax.

tail [options] file

By default tail will show you the last 10 lines of a text file.

$ tail textfile.txt

You can change the number of lines displayed by adding ‘-n‘ option and adding the number of lines.

$ tail -n 3 textfile.txt

This will show the last 3 lines in the file.

You can keep track of ongoing changes within the file by turning on monitoring mode with the ‘-f‘ option. It is especially helpful when you want to keep an eye on log files.

$ tail -f /var/log/syslog

As lines are appended to the log file they are also displayed by tail.

You can exit the program by pressing Ctrl-C.

No related posts.

The file command identifies the type or format of a file. It is a very handy command that can show you how to approach a file when the format is unknown. There are a variety of tests that it uses to determine its type, these tests include a filesystem test, magic number test, and language tests. The first successful test is the one that is printed to the user.

The magic number tests are used to check for files with data in particular fixed formats. To determine the format of a file in this manner, either a magic number identifier exists at the beginning of the file, or a specific identifier can be determined at a specific offset within the file. The file /usr/share/file/magic specifies what magic numbers are to be tested for, what message to print if a particular magic number is found, and additional information to extract from the file.

Here is an example with a directory which contains a variety of file types. The output lists the filename along with its type.

$ file *

data:        data
directory:   directory
emptyfile:   empty
program:     ELF 64-bit LSB executable, x86-64, version 1 (SYSV), for GNU/Linux 2.6.9, dynamically linked (uses shared libs), stripped
script.sh:   Bourne-Again shell script text executable
source.c:    ASCII C program text
symlink:     symbolic link to `program'
tarball.tar: POSIX tar archive (GNU)
tarball.tbz: bzip2 compressed data, block size = 900k
tarball.tgz: gzip compressed data, from Unix
text.txt:    ASCII text

This works equally well when the file names do not have have an extension, which is a very common case with Linux.

No related posts.

TAR is the GNU Tape ARchive utility. It is used to pack the contents of multiple files or directories in an archive file called a tarball. Tar can preserve directory organization including file ownership, permissions, links, as well as directory structure. To save space you can optionally enable compression with gzip, bzip2, or another external program.

For these examples I’m going to be using this sample directory which contains a few files.

/mydir
/mydir/script.sh
/mydir/picture.jpg
/mydir/document.txt

Lets create a tarball from this directory. Run the following command.

$ tar -cvf mydir.tar mydir

Lets go over these options.

-c create tarball
-v verbose
-f output file

To extract this tarball.

$ tar -xvf mydir.tar

The new option ‘-x‘ instructs tar to extract the archive.

Add compression with gzip when creating the archive by including the -z option.

$ tar -cvzf mydir.tgz mydir

Extracting the archive is similar. Make sure to include the gzip option as well.

$ tar -xvzf mydir.tgz

You can also use the bzip2 utility to compress the archive, use the -j option.

$ tar -cvjf mydir.tbz mydir

And extract it.

$ tar -xvjf mydir.tbz

To preserve permissions use ‘-p‘ when creating as well as extracting.

$ tar -cvzpf mydir.tgz mydir

$ tar -xvzpf mydir.tgz

You may have noticed the file extensions used on the archives are different. Here is a quick rundown on the naming conventions. Understanding the extensions allows you to quickly figure out how to extract it.

*.tar (uncompressed tar archive)
*.tgz or *.tar.gz (gzip compressed tar archive)
*.tbz or *.tar.bz2 (bzip2 compressed tar archive)

You want to avoid including files in the current working directory when creating a tarball. When extracted these files will be dumped into the user’s current working directory instead of its own subdirectory, potentially overwriting files and creating a big mess.

Another helpful option to use is ‘-C ‘. This will extract a tarball in a specific directory.

$ tar -xvzf mydir.tgz -C /tmp/testdir

A good way to check for any problems with extraction or to see exactly a tarball contains is to execute tar with the -t option. This will list the contents of a tarball and show the location they will be extracted.

$ tar -tf mydir.tgz

mydir/
mydir/script.sh
mydir/picture.jpg
mydir/document.txt

This will also help you avoid situations where a tarball might use an absolute path (path starting at root ‘/’) when extracting instead of a relative path (path that is relative to your current directory) like the previous examples. This is not necessarily a bad thing, but it can be dangerous if you don’t realize this before extracting, since an absolute path can install to anywhere on your system.

No related posts.

Watch runs a program at regular interval and continuously displays the output. This allows you keep track of the changes that are occurring in the program over time.

Run watch in the following way.

watch [options] command

By default watch updates the command output every 2 seconds. To change this interval us the ‘-n seconds‘ option.

This will keep an eye on the changes occurring in your home directory. This will update the command output every second.

$ watch -n 1 ls -l ~/

If you use the ‘-d‘ option, watch will highlight the differences between the current and previous update. Adding ‘-d=cumulative‘ will make the highlights permanent, allowing you to see what has changed throughout the entire run.

$ watch -d=cumulative ls -l ~/

String longer commands together by enclosing them in single quotes.

$ watch 'cat logfile | grep somestring'

Watch will continue to run until you exit the program by pressing Ctrl-C.

No related posts.

Among the most valuable tools at a Linux administrators disposal is sudo. It lets ordinary users temporarily submit commands as root or another user.

To use use this command simply put sudo before any command you want to run with root permissions.

sudo command

To submit commands as another user use the ‘-u‘ option and the username. This will submit a command as the user ryan.

sudo -u ryan command

The sudo configuration file is located at /etc/sudoers.

Although /etc/sudoers file is a regular text which root can edit manually, it is recommended that you only edit it using visudo. The visudo editor locks the sudoers file against multiple simultaneous edits, provides basic sanity checks, and checks for errors.

The /etc/sudoers file has the general format:

user hostlist = (userlist) commandlist

This is a basic configuration and will allow the user ryan to run any command, on any host, as any user.

# User privilege specification
root    ALL=(ALL) ALL
ryan    ALL=(ALL) ALL

Here is a more complex example.

ryan     tuxbox=(bob, bill)   /bin/kill

This will give ryan access to run “kill” as the users bob and bill using “sudo -u” on the host “tuxbox”.

When using the above configurations you will be prompted for ryan’s password before sudo will execute your command. After the pasword is accepted, you will have a 5 minute window to submit other commands without further password requests.

Submitting a password has its security benefits, but if you are ok without it, there is a way around this inconvenience. If you don’t want to enter a password add the NOPASSWD tag to the configuration file like this.

# User privilege specification
root    ALL=(ALL) ALL
ryan    ALL=(ALL) NOPASSWD: ALL

If there are configuration lines that contradict one another sudo will give priority to the line closest to the bottom of the file. So if you make changes and they don’t seem to take effect, check that this is not the case.

All calls to sudo are logged in /var/log/messages so you have the ability to keep track of who did what on the system.

No related posts.

There are many ways to take screenshot in Linux. If you have Gnome or KDE you can simply press your ‘print screen’ button and you are done.

If you don’t run either one of these desktops you can always use the screenshot functionality built into GNU Image Manipulation Program aka GIMP. Open up GIMP and navigate to File -> Create -> Screenshot.

The third method and my favorite is to do it from the command line.

To do this you need to use the import command which is part of ImageMagik package. You will need to make sure that this is installed before you continue.

The import command saves any visible window on an X server and outputs it as an image file. You can capture a single window, the entire screen, or any rectangular portion of the screen.

The format for import looks like this.

import [options] input-file

To create a screenshot of the entire root window and output in PNG format run this command.

$ import -window root screenimage.png

You can change the format of the image by simply changing the file extension. For example this command outputs the same root window but in JPEG format.

$ import -window root screenimage.jpg

Another great feature is that you can get a screenshot of a single window. Run this command.

$ import screenimage.jpg

After you enter this command your mouse curser will turn from a pointer into a crosshair. Now go and click on any window on your desktop and the screenshot that is created will be of only that window.

No related posts.

scp allows you to securely copy files locally or remotely across a network. It uses SSH for data transfer and uses the same authentication. If you do not have public key authentication enabled you will be prompted for a password.

This basic format for scp is this.

scp [options] [[user@]src_host1:]file1 [[user@]dest_host2:]file2

Assuming the remotehost has a username which matches username on the local host, this command will copy a a local file into the /tmp directory on remotehost. Notice that the colon separates the host from the location.

$ scp file.txt remotehost:/tmp/

You will be presented with the real-time statistics about the file transfer.

$ scp file.txt remotehost:/tmp/

file.txt                                      100%   22KB  21.9KB/s   00:00

This command is similar but the period instructs the file to be placed in the users home directory.

$ scp file.txt remotehost:.

You can specify another user and login using their username. This will copy the file to ryan’s home directory.

$ scp file.txt ryan@remotehost:.

Alternatively you can copy a remote file to your local host. The period in the destination path refers to the current working directory in this case.

$ scp ryan@remotehost:file.txt .

Likewise, you can copy to any other local path you have access, such as the /tmp directory.

$ scp ryan@remotehost:file.txt /tmp/

Copying directories is similar except that the ‘-r’ option is required. This command will copy a directory from the current working directory to the users home directory on remotehost.

$ scp -r mydir/ remotehost:.

You can even copy from one remote host to another.

$ scp remotehost1:file.txt remotehost2:file.txt

Use the -p option to preserve modification times, access times, and modes from the original file.

$ scp -p remotehost1:/tmp/file.txt remotehost2:/tmp/file.txt

No related posts.

The top command is a great way to keep track of processes executing on a system in real-time.

Launch top by entering this on the command line.

$ top

Here is an example of what you will see.

top - 09:13:11 up  1:29,  2 users,  load average: 0.20, 0.16, 0.10
Tasks:  85 total,   1 running,  84 sleeping,   0 stopped,   0 zombie
Cpu(s):  2.5%us,  1.0%sy,  0.0%ni, 96.0%id,  0.0%wa,  0.4%hi,  0.1%si,  0.0%st
Mem:   4050364k total,   459920k used,  3590444k free,    17028k buffers
Swap:  1956612k total,        0k used,  1956612k free,   174940k cached

  PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND
 5521 root      20   0  897m  49m 8924 S    7  1.3   8:18.19 X
 5574 ryan      20   0  139m  21m  10m S    2  0.6   0:48.17 compiz
 5932 ryan      20   0  142m  18m 9876 S    1  0.5   0:00.28 Terminal
 5589 ryan      20   0  174m  86m  19m S    0  2.2   1:37.46 firefox-bin
    1 root      20   0  3712  580  492 S    0  0.0   0:01.14 init
    2 root      15  -5     0    0    0 S    0  0.0   0:00.00 kthreadd
    3 root      RT  -5     0    0    0 S    0  0.0   0:00.00 migration/0
    4 root      15  -5     0    0    0 S    0  0.0   0:00.04 ksoftirqd/0
    5 root      RT  -5     0    0    0 S    0  0.0   0:00.00 migration/1
    6 root      15  -5     0    0    0 S    0  0.0   0:00.02 ksoftirqd/1

The ‘-d delay‘ option will change the amount of time between updates.
This will set the delay for half a second.

$ top -d 0.5

The ‘-n iterations‘ option allows you to define the number of iterations it displays before it exits. It is handy when you want to see a single snapshot of the system. To do this, enter this command.

$ top -n 1

The ‘-u user‘ option allows you to view the processes of a single user

$ top -u ryan

The ‘-p PID‘ option shows you a specific process or group of processes by listing their process IDs.

$ top -p 1001

$ top -p 1001,1002,1003

By default top is launched in interactive mode. In this mode you can submit commands that will change the behavior of the program.

Pressing ‘f‘ will allow you to select what fields to display.
You will see a screen similar to this.

Current Fields:  AEHIOQTWKNMbcdfgjplrsuvyzX  for window 1:Def
Toggle fields via field letter, type any other key to return 

* A: PID        = Process Id
* E: USER       = User Name
* H: PR         = Priority
* I: NI         = Nice value
* O: VIRT       = Virtual Image (kb)
* Q: RES        = Resident size (kb)
* T: SHR        = Shared Mem size (kb)
* W: S          = Process Status
* K: %CPU       = CPU usage
* N: %MEM       = Memory usage (RES)
* M: TIME+      = CPU Time, hundredths
  b: PPID       = Parent Process Pid
  c: RUSER      = Real user name
  d: UID        = User Id
  f: GROUP      = Group Name
  g: TTY        = Controlling Tty
  j: P          = Last used cpu (SMP)
  p: SWAP       = Swapped size (kb)
  l: TIME       = CPU Time
  r: CODE       = Code size (kb)
  s: DATA       = Data+Stack size (kb)
  u: nFLT       = Page Fault count
  v: nDRT       = Dirty Pages count
  y: WCHAN      = Sleeping in Function
  z: Flags      = Task Flags 
* X: COMMAND    = Command name/line

Similarly, ‘o‘ will allow you to change the order of the fields that are currently displayed.

If you have multiple CPUs or processor cores the pressing ‘1‘ will give you more individual information on each one.

top - 11:58:37 up  1:34,  2 users,  load average: 0.17, 0.13, 0.09
Tasks:  87 total,   2 running,  85 sleeping,   0 stopped,   0 zombie
Cpu0  :  5.7%us,  1.5%sy,  0.0%ni, 92.1%id,  0.3%wa,  0.2%hi,  0.1%si,  0.0%st
Cpu1  :  5.4%us,  1.5%sy,  0.0%ni, 92.3%id,  0.4%wa,  0.2%hi,  0.1%si,  0.0%st
Mem:   4050364k total,   510172k used,  3540192k free,    17264k buffers
Swap:  1956612k total,        0k used,  1956612k free,   245704k cached

You can exit by pressing Ctrl-C.

No related posts.