Although the name suggests that it will mercilessly murder the process, its more a signal thrower. Signals tell processes to take determinate actions such as pause, continue, terminate, interrupt current work etc.

Anatomy of process’ death process

There are basically four forms to terminate a process:

Wrong way to terminate a process

Signal 15, SIGTERM. The Terminate Call

Tells your process to end the task cleanly, closing all network connections, file handles, notifying child processes, resetting the terminal and go home in peace. The first thing to do when it becomes unresponsive.

Signal 2, SIGINT. The Interrupt – A slap on the face

Tells your process to stop what it is doing right now and leave immediately. The only way when SIGTERM fails to do the job cleanly. CTRL+C will throw this signal too.

Signal 1, SIGHUP. The Hangup – Kick on the tummy

Quite similar to SIGINT, SIGHUP is one step up. The Hangup is equivalent to the physical medium holding the process going down. It was very common on dial-up lines to indicate that the line had hang-up the call thus terminating the connection.

Signal 9, SIGKILL. The Kill – A bullet on process’ head

SIGKILL will wipe the process out from your tree leaving all the crap it was using. Its the worst way of terminating a process since it will keep your resources open and can lead to any sort of mayhem.

So what to do?

As mentioned on UUK9 (Useless use of Kill -9):

Generally, send 15 (SIGTERM), and wait a second or two, and if that doesn’t
work, send 2 (SIGINT), and if that doesn’t work, send 1 (SIGHUP). If that doesn’t,
REMOVE THE BINARY because the program is badly behaved!

Quite extremist, but totally true!

Treat your processes with dignity, and they won’t betray you! HTH!

Related posts:

1. Automating human intervention tasks with Expect

Some of my clients are hosted on shared hostings and some of them doesn’t allow password-less authentication “in behalf of my security”. Well, I can’t really afford opening my password manager, locating it and then copying and pasting back to my terminal. Too much time spent.

I have heard about expect long ago but never quite stopped to look at it since I never really had that need but in this case it came quite handy. Hop in aboard the new less typing world!

Expect is a Unix automation and testing tool, written by Don Libes [from NIST] as an extension to the Tcl scripting language, for interactive applications such as telnet, ftp, passwd, fsck, rlogin, tip, ssh, and others. It uses Unix pseudo terminals to wrap up subprocesses transparently, allowing the automation of arbitrary applications that are accessed over a terminal. With Tk, interactive applications can be wrapped in X11 GUIs.

Source: Wikipedia

Expect Overview

Expect runs a very simple kind of script file in its own language. This script contains the logic to perform the automation and it’s called as first argument to the expect command. For a argument-less script named fake_ssh_host-x.exp the call would be.

expect fake_ssh_host-x.exp

If it took any argument it would just be appended to the call:

expect fake_ssh_host-x.exp somefile.txt

Quick Expect anatomy

Expect directives are line-separated and not terminated. Expect even has some object-notation for grouping expect events.

Variables

Variables are assigned in expect with the set directive.

set pass "mypass"

Variables are further referenced prefixed with a dollar-sign $.

Command-line arguments

Command-line arguments are get through the $argv variable and the lindex call. Now that we have learned how to assign variables, let’s assign one with a command-line argument.

set filename [lindex $argv 0]

Note that indexes start at 0, as the standard.
You can have multiple command-line arguments:

set filename [lindex $argv 0]
set user [lindex $argv 1]
set host [lindex $argv 2]

Spawning the tampered process

We use Expect in order to tamper output from a process and thus automate the inputs. We need to tell our Expect script which process it must spawn. This is done though the spawn directive that prefixes a normal command-line statement for that call.

spawn ssh user@host

Timeout

Timeout determines the number of seconds that the process has to respond before being considered jammed (or b0rked) and is set through the timeout directive, much like as a variable is.

# one minute timeout
set timeout 60

timeout is disabled if set to -1

Observing data

The expect directive tells the script which text to expect from standard output.

expect "String"

Posting data

Posting data to standard input is done through the send directive. This statement when precede by an expect statement will execute only when given string matched.

send $pass

Grouping expectations and posts

This kinda object-notation is used to couple expect/send statements.

expect {
	"password:" {
		send "$pass\r"
	}
} 
# or shortened
expect {
	"password:" { send "$pass\r" }
}

If you need to append more commands on an expect block just append the line within the expected element closure (in expanded form) or append to the line in a semi-colon delimited form.

expect {
	"password:" {
		send "$pass\r"
		set timeout -1
	}
} 
# or shortened
expect {
	"password:" { send "$pass\r" ; set timeout -1 }
}

Coupling multiple expectations is also easy:

expect {
	"yes/no):" send "yes"
	"password:" { send "$pass\r" ; set timeout -1 }
	eof exit
}

Printing messages on screen

If you want to send messages to the standard output rather than the process’ input, you do exactly like the send statement described earlier in this article but the command is send_user.

send_user "Connected to host"

Outputting to a file

Sure, you can always pipe the output natively from the shell with the output redirectors > but we can also do that within Expect by setting the file variable coupled with the open directive.

# filename in example is set to expect.out
# 'w' opens file for writing, 'a' to append
set file [open expect.out w]

More documentation can be found on Expect’s website or in its man page.

man expect

Faking a private key authentication AKA Automating a password authentication

For both examples we will need variables and the expect, send and spawn directives.

SSH Session

We will expect the message asking us if we want to accept the key and send yes to accept it. Then we will expect for the password: string and send our password stored in a variable.

#!/usr/bin/expect -f
set timeout -1
spawn ssh username@host
set pass "mypass"
expect {
        password: { send "$pass\r"  }
	} "yes/no)?" {
		send "yes\r"
		set timeout -1
        } eof {
                exit
        }
}

SCP Session

We will follow the same logic from the above example but we’ll add some command-line arguments to catch the filename and path to be transfered.

#!/usr/bin/expect -f
set timeout -1
set filename [lindex $argv 0]
set dst_path [lindex $argv 1]
spawn scp $filename username@host:$dst_path
set pass "mypass"
expect {
        password: { send "$pass\r"  }
	} "yes/no)?" {
		send "yes\r"
		set timeout -1
        } eof {
                exit
        }
}

And you’re done. No more typing and unnecessary time spending.

Related posts:

1. Typing less with SSH
2. Smartly resolving your WordPress pages and posts JavaScript and CSS dependences
3. Scytale, a greek cryptography system implemented in C++

For me as a Linux^w user I always had to type long lines to start my SSH^w sessions. It’s no rocket science, you know, but for he who types thousands of characters each day, each character save is golden.

We usally start our SSH sessions by typing the following command string:

ssh user@domain.tld

I’ve tried to shorten this by adding the domain and its TLD^w to my hosts file with a shorter alias like

hname hostname.tld

But obviously that crashed against Apache^w Vhost^w capability, the request never make it to the other end.

I personally have SSH keys on some of my servers to avoid typing passwords, that is good to prevent against MITM^w attacks and keyloggers, but I still have to type the string mentioned lines above.

Then, with 3 lines in a SSH’s configuration file on my home directory (yes, you don’t need to alter the server’s SSH configuration file and yes, you can do that on your shared hosting’s shell account).

It’s very simple. SSH allows some user-based configuration in your ~/.ssh directory (note that ~ stands for your home directory (usually /home/yourusername) and it also provides Aliases^w capability.

The aliases can be configured in such a way that you won’t need to type neither the FQDN^w nor even type a single username EVER MORE!

Your old

ssh user@domain.tld

will be shortened to

ssh aliasname

Ok, talk is cheap, show me the code!

Creating the need files and directories

All the magic occurs on the config in your already-mentioned ~/.ssh/ directory. If you don’t have one, create it and secure it, as the following:

mkdir ~/.ssh/
chmod 700 ~/.ssh/

If the file does not exists, create it and secure it propperly, like:

touch ~/.ssh/config
chmod 600 ~/.ssh/config

Syntax model

Host [alias name]
HostName [host's fqdn]
User [username to log-in as]

Without the braces, please!

For a user called jdoe on mydomain.com being shorted md, the code would be the following:

Host md
HostName mydomain.com
User jdoe

Save the file and you can start typing less with SSH:

ssh md

And that’s IT!

Wow that’s great! What else this beauty can do?

Omnipresence

Do you have the same username in a large number of machines, like in a local network? So you have to love the * wildcard.

Host *
User jdoe

I have many names

Want to follow a naming pattern but also wants to have shorter ones? Give multiple aliases!

Host gdf gandalf
HostName gandalf.mydomain.com
User jdoe

Avoid the front door

Security through obscurity is always fun! Have your SSH aliases even in hosts with sshd running in a different port.

Host md
HostName mydomain.com
User jdoe
Port 11

Be backwards compatible

Have outdated SSH servers? I hope not! But if you do, you may also define a different protocol in a host-based manner.

Host md
HostName mydomain.com
User jdoe
Protocol 1

Handle multiple keys

You may specify the specific (what?) SSH key file for a host.

Host md
HostName mydomain.com
User jdoe
IdentityFile ~/mykey.pub

And it also works on SCP!

Oh yeah, file transfers are easier now!

scp somefile.txt md:/path/to/upload

More parameters can be found on SSH manual, page 5.

man ssh 5

Phew! That’s all folks! Hope it helps someone as much as helped me! Anyone have any neat SSH trick?

No related posts.

To avoid this simply add a rule to a .htaccess file in your root directory:

<IfModule mod_rewrite.c>
RewriteEngine On
RewriteCond %{HTTP_HOST} !^www\.yourdomain\.com [NC]
RewriteRule ^(.*)$ http://www.yourdomain.com/$1 [R=301,L]
</IfModule>

NOTE: You need to have mod_rewrite enabled in your server in order to do this.

Related posts:

1. Typing less with SSH

Ubuntu emerged to aid home-users and be more user-friendly, having and startup installation that would recognize and install all your drivers and give you a starting setup of the most common used tools like e-mail clients, IM clients, web browser and an office suite.

Things started well, I myself preferred installing an Ubuntu distribution rather than spending hours (or weeks) configuring a Gentoo workstation as I’m a developer and need a working station to start developing quickly.

The first releases worked well, the weight of the loaded modules was rather unnoticeable and the OS was running lean but as time passed Ubuntu went further down in those facilitations and the module-shard grew exponentially.

One of the biggest complains about Windows among power-users is that you have to spend good time removing unwanted software and you keep lots of unwanted drivers in the suburbs of your OS and Ubuntu is going each day further this approach.

The result
Ubuntu has become each day heavier and it’s starting to lose stability. Some friends are switching back to their Debian 5 installs or falling back to other distributions. Others predicted that (or are masochists) and never left out their Gentoo installs.

Pros & Cons of the Windows-like behavior
PROS
It’s indeed a good thing to having an OS working out-of-the-box and for home-users it’s a must-have solution. This behavior is good as it introduced Linux to a whole new set of users and it still worthy if this user is going to use the installation to home use or office use. The easy operation makes intuitive use of the tools, the menus are well-placed and update routine is just piece of cake.

CONS
Weight has considerably risen since new versions of the distribution (and bundled software) came out thus making the environment unstable and a little untrustworthy for heavy users (like developers and sysadmins). As most power users kept their old installs and did not adhere to Ubuntu, the support forums are maintained mostly by regular/home users and the solutions are either noneffective or poorly explained. The contrast of this last item is well seen in comparison with Gentoo Wiki Documentation. The Ubuntu Lauchpad (a Bugzilla-like) is a good way to find little more trustworthy information.

Conclusion
Ubuntu shouldn’t be crucified or left away. It serves well the purpose which it was built for of serving home-users but it’s each day leaving power users (the ones that adhered) behind even those who used to tune up Ubuntu for performance gain. I think that an online on-demand driver recognition, download and install would be less costly (but it would demand that basic hardware was already properly detected and installed) or an after-install cleanup would just reduce the damages.

Related posts:

1. Typing less with SSH
2. Sustainability application under Software Development

But I’ve personally ran into many bad experiences that Google helped me solve.

So, here are my advices for logging into SSH to a linux machine:

1. Change your Terminal Emulation to “linux”: Connection-> Data -> Terminal-Type String = linux
2. Change your escape sequence to “Linux”: Terminal -> Keyboad -> “The Function Keys and Keypad” -> Linux
3. Set the terminal to UTF-8: Window -> Translation -> “Character set translation on received data” -> UTF-8

That’s it, if someone has other tips envolving PuTTY SSH Client, please share at the comments!

Related posts:

1. Brazillian Portuguese (pt_BR) language file for WP-Filebase released