# Linux commands

 This is the start of a list of useful Linux shell commands (generally "one liners") we use a lot

### Debian package management

The package management system used on Debian and the "downstream" distros based on it such as Ubuntu and Mint.

#### Searching for an installed package

Use dpkg and grep;

dpkg -l | grep java

will list all installed packages and filter to only those with "java" in the name

#### Searching for installable packages

apt-cache performs a variety of operations on APT´s package cache

apt-cache search java

lists all packages in the cache with java in the name that are installable

## SSH & SCP

### Screen

Screen is an essential utility to use during an SSH session over dodgy connections that can drop or when doing something mission-critical. Just use the screen command without any parameters and another shell session will start (if you exit you'll be back in the original shell session again). This new shell session will remain active even if the connection drops. To get back into the session again later, use screen -R. There are many other options for using multiple screen sessions and multiple windows onto a single session etc, see this screen cheatsheet for more details.

Note: One annoying issue with screen is that the normal scroll-back doesn't work, but you can user CTRL+A then ESC to activate "copy mode" which then allows you to scroll back using the cursor keys or page up/down. To exit "copy mode" use ESC again.

### Basic SCP syntax

Example of sending a file to a remote server:

scp -P 2222 /my/local/file.txt USER@example.com:/home/USER

Example of retrieving a file from a remote server:

scp -P 2222 USER@example.com:/home/USER/file.txt ./

Note using port forwarding for commonly accessed sites you can define non standard ports in your .ssh/config so you never need to explicitly state them above.

### Recovering from an interrupted transfer

This ability is included natively in Linux and used to be very useful for splitting large backups up so they could fit onto small media such as floppy disks. But there's one time when it's very useful nowadays too which is when a large file transfer gets interupted and there's no option for continuation such as when using SCP.

When this happens, go onto the target machine, check how many bytes were transferred of the target file and rename it to "xaa". Then on the local machine, do the following command to split the source file into two parts, the first being of the size of the number of bytes that have already been transferred (in this example 1234567 bytes).

split -b 1234567 foo.tar.gz

The resulting files are called "xaa" and "xab", and the latter is the containing the remaining content that needs to be transferred to the target server. Once you've transferred it across, you can then join the two files (remember you renamed the first part to "xaa" so there's no need to transfer that) together using cat as follows, and then remove all the xa* files from noth source and target servers.

cat xa* > foo.tar.gz

### Tar pipes

## From a local to remote machine
tar -zcvf - directory | ssh remote 'cd somewhere; tar -zxvf -'
## From remote machine to local machine
ssh remote 'cd somewhere; tar -zcvf - directory' | tar -zxf -
## remote tar and pipe to tgz
ssh remote 'cd somewhere; tar -zcf - directory' | cat - > directory.tar.gz

### Port forwarding with SSH

Use a remote port-forward for example so someone can give SSH access to their machine that's behind a firewall.

ssh -NR 1234:localhost:22 USER@SERVER

You can now ssh into their machine on port 1234 in the remote server instead.

A local port-forward would be used for example to create a local connection into a remote SQL server that's only available on localhost.

ssh -NL 1234:localhost:3306 USER@SERVER

Now you can access the database on the local machine on port 1234.

### Browsing the net through a remote server with SSH

Sometimes you need to browse using an IP address that's in another location, for example if the content you want to access is only available to local users or if you're buying something and the prices are based on the buyers location. If you have access to a server in the required location, or someone you know in that location is willing to temporarily set up an SSH server that you can access, the you can use the following syntax to set up a local port that your browser can use as a proxy server.

ssh -NCD 1080 USER@SERVER
• The N option means to use this SSH session only for tunnelling, not to open up a shell session as well.
• The C option means to compress the data in the tunnel which is a good idea if you're on a slow connection
• The D option is the main one that tells SSH to set up a tunnel connected to a local port with the port number specified

Next you need to configure your browser to connect via this local port. I use Firefox as my default browser, but for this purpose I find it easiest to use Chromium because it allows you to run it from the command-line specifying the proxy details as a command-line option, so there's no need to change the network configuration and then change it back afterwards. Simply open a shell window and use the following syntax (make sure there are no other Chromium windows open when you do this).

chromium-browser --proxy-server="socks5://localhost:1080"

## Files & Devices

### List all the storage devices and partitions attached to the system (even if they're unformatted or unmounted)

cat /proc/partitions

To check what filesystem a device has on it use file, e.g.

file -s /dev/sda1

### Get the size of a directory and its contents

du -sh /home/foo

Use this more specific version to find the size of a users Maildir folder:

du -sh /home/*/Maildir|sed 's|/home/||'|sed 's|/Maildir||'

### Search for file content recursively

Here's an example looking for a phrase within a specific file type recursively through a directory structure, and printing the file names and line numbers of the resulting matches.

grep -rn "Foo" *.php

There are other tips at stackoverflow.com.

### Search for file content recursively and tar

## Find and tar
find . -name "*.R" -print0 | xargs -0 tar -cvf Rfiles.tar
## check contents
tar -tvf Rfiles.tar

## Find and tar.gz
find . -name "*.R" -print0 | xargs -0 tar -zcvf Rfiles.tar.gz
## check contents
tar -ztvf Rfiles.tar.gz

### Search for file by name recursively

find . -name "*.R"

### Count occurrences of a word in a file or files

grep -roh "WORD" file*.txt | wc -

### Search and replace content in files

You could also use find and sed, but I find that this little line of perl works nicely.

perl -pi -w -e 's/SEARCH/REPLACE/g;' *.php
• -e means execute the following line of code.
• -i means edit in-place
• -w write warnings
• -p loop

EXTS="7z t7z"

### Mass renaming

mmv is a mass move/copy/renaming tool that uses standard wildcards to perform its functions. According to the manual the “;” wildcard is useful for matching files at any depth in the directory tree (ie it will go below the current directory, recursively).

Example
 mmv \*.JPG \#1.jpg

The first pattern matches anything with a “.JPG” and renames each file (the “#1” matches the first wildcard) to “.jpg”. Each time you use a \(wildcard) you can use a #x to get that wildcard. Where x is a positive number starting at 1. Copied off: http://tldp.org/LDP/GNU-Linux-Tools-Summary/html/mass-rename.html

### Compare two directory structures for differences

This is very handy if you need to know if two directory structures are the same or not including file content. It uses the diff command with the r switch to work recursively and the x switch to allow skipping of the .svn directories.

diff -qrx .svn DIR1 DIR2

See this HOWTO

### Mount a USB stick

If you don't know the device name of the stick, plug it in and find it with the following:

dmesg |grep SCSI

Then mount the first partition,

mkdir -p ~/memstick
mount -t vfat -o rw,users /dev/sdX1 ~/memstick

### Clone a device

Remember that this is a very low-level operation and so if you're cloning a live partition you may end up with partially written files or other corruption issues on the destination. Stop as many services as you can first, do an fsck afterwards and manually copy any directories that had issues.

dd if=/dev/sda of=/dev/sdb bs=32M

A good way to find more information about the devices first, for example if you have a number of unformatted devices of the same size and need more specific information about the hardware, is to use the 'lsscsi command which gives the following sample output:

[0:0:0:0]    disk    AMCC     9650SE-2LP DISK  4.10  /dev/sdb
[1:0:0:0]    disk    ATA      Hitachi HUA72201 JP4O  /dev/sda
[2:0:0:0]    disk    ATA      TOSHIBA MG03ACA1 FL1A  /dev/sdc

The sdb and sdc devices look identical with commands such as lsblk or fdisk -l, but one of the is a RAID pair and the other just a normal drive.

### Changing device UUIDs

It may sometimes be useful to change the UUIDs of partitions such as when they've been cloned with a low-level method like dd.

Note: the disk identifier should also be changed which you can do with fdisk from the expert menu.

Check what devices and UUIDs you have in the system:

# blkid
/dev/sda3: UUID="b56d82f7-5817-4a52-9763-0b38aa360e2b" TYPE="ext4"
/dev/sdc1: UUID="81d40a02-8019-4c1f-afb8-fb41d117c6d1" TYPE="ext3"
/dev/sdc2: UUID="c57f1400-129a-402a-90f1-820a22c6a2fe" TYPE="swap"
/dev/sdc3: UUID="c23ab65a-c32f-41e3-bd31-51ed563e0099" TYPE="ext4"

or:

# ls -l /dev/disk/by-uuid/
total 0
lrwxrwxrwx 1 root root 10 Sep  2 12:10 81d40a02-8019-4c1f-afb8-fb41d117c6d1 -> ../../sdc1
lrwxrwxrwx 1 root root 10 Sep  2 12:10 86ce60b7-ad4a-44aa-88e2-2aefd5c6c396 -> ../../sda2
lrwxrwxrwx 1 root root 10 Sep  2 12:10 b56d82f7-5817-4a52-9763-0b38aa360e2b -> ../../sda3
lrwxrwxrwx 1 root root 10 Sep  2 12:10 bc459b13-3aad-4017-a68b-ce8ab36275e1 -> ../../sda1
lrwxrwxrwx 1 root root 10 Sep  2 12:10 c23ab65a-c32f-41e3-bd31-51ed563e0099 -> ../../sdc3
lrwxrwxrwx 1 root root 10 Sep  2 12:27 c57f1400-129a-402a-90f1-820a22c6a2fe -> ../../sdc2

Check what swap partitions you have:

# cat /proc/swaps
Filename				Type		Size	Used	Priority
/dev/sda2                               partition	3999740	0	-1

Create a new UUID and assign it to and ext parition:

# uuidgen
81d40a02-8019-4c1f-afb8-fb41d117c6d1
#tune2fs /dev/sdb1 -U 81d40a02-8019-4c1f-afb8-fb41d117c6d1

Do the same for a swap partition:

# uuidgen
# swapoff /dev/sda2
Setting up swapspace version 1, size = 3999740 KiB
no label, UUID=86ce60b7-ad4a-44aa-88e2-2aefd5c6c396

### Updating device partition tables without rebooting

• partprobe /dev/sdx
• partx -u /dev/sdx
• echo 1 > /sys/block/sdX/device/rescan
• check partition information before and after with cat /proc/partitions

## Image manipulation

### Resizing JPG's and changing quality setting

The first line shows how to reduce and image to 25% and quality to 50% adding "_resized" to the results filename. The second command uses Perl to apply this same command to all JPG's in the current directory.

convert foo.jpg -resize 25% -quality 50% foo_resized.jpg

perl -e 'for (glob "*.jpg") { $img =$_; s/(....)$/_resized$1/; qx "convert \'$img\' -resize 25% -quality 50% \'$_\'"; }'

### Apply an opaque background of a specified colour to a directory of transparent PNG's

• This command requires ImageMagick to be installed
• It loops through all PNG's in the CWD and puts them in a directory called processed which must exist
perl -e 'qx "convert $_ -background #ff00ff -flatten foo/$_" for glob "*.png"'

## Audio & Video

### avconv (ffmpeg)

Note: Many operating systems including Ubuntu are now using the libav fork of ffmpegnow which means you should use the avconv command instead.

The following converts a .wav file to an mp3:

ffmpeg -i foo.wav foo.mp3

Here's a more complicated example which converts mp4 video into mp3 audio at a lower quality with only one channel at 11KHz and 32kbps.

ffmpeg -i foo.mp4 -acodec libmp3lame -ab 16k -ar 11025 -ac 1 foo.mp3

To do a whole directory you could do this:

perl -e 'qx "ffmpeg -i $_$_.mp3" for glob "*.wav"'

Or a little more complex; a whole directory with a proper name change accounting for names with spaces in them. This

perl -e 'for (glob "*.mp4") { $i=$_; s/.mp3$/.converted.wav/; qx "ffmpeg -i \"$i\" \"$_\"" }' Use the following commands to extract a small snippet out of a video (the -ar switch is only needed for outputting to flv I think). ffmpeg -i "foo.avi" -ss 00:10:10 -t 00:00:05 -ar 22050 "foo.flv" See also: ### Downloading Youtube from shell First install the Python youtube-dl tool, with pip: sudo pip install --upgrade youtube_dl Then use the tool to download the video, e.g. youtube-dl https://www.youtube.com/watch?v=f9m2yReECak ## System monitoring List the top 10 memory consuming processes ps -auxf | sort -nr -k 4 | head -10 List the top 10 CPU consuming processes ps -auxf | sort -nr -k 3 | head -10 ## Network commands ### Restart the network after changing configuration /etc/init.d/networking restart ### List all the listening sockets and their ports and programs netstat -lp ### Get current default gateway netstat -nr The default gateway is on the last line, it should have the U and G flags set ### Release DHCP lease dhclient -r ### Obtain a new DHCP lease dhclient ### Scan a local subnet for active IP addresses nmap -sP 192.168.1.0/24 ### Get the MAC address and hostname of an IP on the current subnet arp -a 192.168.1.1 ## Internet ### Download an url to a local file with continuation curl -L -O -C - http://www.foo.bar/file wget -c http://www.foo.bar/file ### Download a copy of an entire site This will download an entire site, if the site is already downloaded, then only newer files are transferred. wget -m http://foo.bar ## Port forwarding Port forwarding allows a remote client to gain access to a network so an intranet can be accessed. ssh -fN -L[PORT]:appserver:[PORT] username@sshdserver Then point your webbrowsers proxy server to appserver:[PORT] and access the intranet etc. To subvert a firewalled environment where outgoing ssh is allowed. $ ssh -D 9000 username@remotehost

Further it's possible to get ssh through a web proxy using corkscrew.

ssh -oProxyCommand='corkscrew local_web_proxy proxy_port %h %p' username@remotehost

## General

### Add and remove startup items

update-rc.d ITEM defaults
update-rc.d -f ITEM remove