@@ -540,7 +540,17 @@ func (cli *DockerCli) forwardAllSignals(cid string) chan os.Signal {

 			if s == syscall.SIGCHLD {

 				continue

 			}

-			if _, _, err := readBody(cli.call("POST", fmt.Sprintf("/containers/%s/kill?signal=%d", cid, s), nil, false)); err != nil {

+			var sig string

+			for sigStr, sigN := range signal.SignalMap {

+				if sigN == s {

+					sig = sigStr

+					break

+				}

+			}

+			if sig == "" {

+				utils.Errorf("Unsupported signal: %d. Discarding.", s)

+			}

+			if _, _, err := readBody(cli.call("POST", fmt.Sprintf("/containers/%s/kill?signal=%s", cid, sig), nil, false)); err != nil {

 				utils.Debugf("Error sending signal: %s", err)

 			}

 		}

@@ -7,7 +7,7 @@ import (

 func CatchAll(sigc chan os.Signal) {

 	handledSigs := []os.Signal{}

-	for _, s := range signalMap {

+	for _, s := range SignalMap {

 		handledSigs = append(handledSigs, s)

 	}

 	signal.Notify(sigc, handledSigs...)

@@ -4,37 +4,37 @@ import (

 	"syscall"

 )

-var signalMap = map[string]syscall.Signal{

-	"ABRT": syscall.SIGABRT,

-	"ALRM": syscall.SIGALRM,

-	"BUG": syscall.SIGBUS,

-	"CHLD": syscall.SIGCHLD,

-	"CONT": syscall.SIGCONT,

-	"EMT": syscall.SIGEMT,

-	"FPE": syscall.SIGFPE,

-	"HUP": syscall.SIGHUP,

-	"ILL": syscall.SIGILL,

-	"INFO": syscall.SIGINFO,

-	"INT": syscall.SIGINT,

-	"IO": syscall.SIGIO,

-	"IOT": syscall.SIGIOT,

-	"KILL": syscall.SIGKILL,

-	"PIPE": syscall.SIGPIPE,

-	"PROF": syscall.SIGPROF,

-	"QUIT": syscall.SIGQUIT,

-	"SEGV": syscall.SIGSEGV,

-	"STOP": syscall.SIGSTOP,

-	"SYS": syscall.SIGSYS,

-	"TERM": syscall.SIGTERM,

-	"TRAP": syscall.SIGTRAP,

-	"TSTP": syscall.SIGTSTP,

-	"TTIN": syscall.SIGTTIN,

-	"TTOU": syscall.SIGTTOU,

-	"URG": syscall.SIGURG,

-	"USR1": syscall.SIGUSR1,

-	"USR2": syscall.SIGUSR2,

+var SignalMap = map[string]syscall.Signal{

+	"ABRT":   syscall.SIGABRT,

+	"ALRM":   syscall.SIGALRM,

+	"BUG":    syscall.SIGBUS,

+	"CHLD":   syscall.SIGCHLD,

+	"CONT":   syscall.SIGCONT,

+	"EMT":    syscall.SIGEMT,

+	"FPE":    syscall.SIGFPE,

+	"HUP":    syscall.SIGHUP,

+	"ILL":    syscall.SIGILL,

+	"INFO":   syscall.SIGINFO,

+	"INT":    syscall.SIGINT,

+	"IO":     syscall.SIGIO,

+	"IOT":    syscall.SIGIOT,

+	"KILL":   syscall.SIGKILL,

+	"PIPE":   syscall.SIGPIPE,

+	"PROF":   syscall.SIGPROF,

+	"QUIT":   syscall.SIGQUIT,

+	"SEGV":   syscall.SIGSEGV,

+	"STOP":   syscall.SIGSTOP,

+	"SYS":    syscall.SIGSYS,

+	"TERM":   syscall.SIGTERM,

+	"TRAP":   syscall.SIGTRAP,

+	"TSTP":   syscall.SIGTSTP,

+	"TTIN":   syscall.SIGTTIN,

+	"TTOU":   syscall.SIGTTOU,

+	"URG":    syscall.SIGURG,

+	"USR1":   syscall.SIGUSR1,

+	"USR2":   syscall.SIGUSR2,

 	"VTALRM": syscall.SIGVTALRM,

-	"WINCH": syscall.SIGWINCH,

-	"XCPU": syscall.SIGXCPU,

-	"XFSZ": syscall.SIGXFSZ,

+	"WINCH":  syscall.SIGWINCH,

+	"XCPU":   syscall.SIGXCPU,

+	"XFSZ":   syscall.SIGXFSZ,

 }

@@ -6,7 +6,7 @@ import (

 	"syscall"

 )

-var signalMap = map[string]syscall.Signal{

+var SignalMap = map[string]syscall.Signal{

 	"ABRT":   syscall.SIGABRT,

 	"ALRM":   syscall.SIGALRM,

 	"BUF":    syscall.SIGBUS,

@@ -4,7 +4,7 @@ import (

 	"syscall"

 )

-var signalMap = map[string]syscall.Signal{

+var SignalMap = map[string]syscall.Signal{

 	"ABRT":   syscall.SIGABRT,

 	"ALRM":   syscall.SIGALRM,

 	"BUS":    syscall.SIGBUS,

@@ -6,4 +6,4 @@ import (

 	"syscall"

 )

-var signalMap = map[string]syscall.Signal{}

+var SignalMap = map[string]syscall.Signal{}

@@ -8,6 +8,7 @@ import (

 	"github.com/dotcloud/docker/dockerversion"

 	"github.com/dotcloud/docker/engine"

 	"github.com/dotcloud/docker/pkg/graphdb"

+	"github.com/dotcloud/docker/pkg/signal"

 	"github.com/dotcloud/docker/registry"

 	"github.com/dotcloud/docker/runconfig"

 	"github.com/dotcloud/docker/utils"

@@ -18,7 +19,7 @@ import (

 	"net/url"

 	"os"

 	"os/exec"

-	"os/signal"

+	gosignal "os/signal"

 	"path"

 	"path/filepath"

 	"runtime"

@@ -47,7 +48,7 @@ func InitServer(job *engine.Job) engine.Status {

 	}

 	job.Logf("Setting up signal traps")

 	c := make(chan os.Signal, 1)

-	signal.Notify(c, os.Interrupt, syscall.SIGTERM, syscall.SIGQUIT)

+	gosignal.Notify(c, os.Interrupt, syscall.SIGTERM, syscall.SIGQUIT)

 	go func() {

 		sig := <-c

 		log.Printf("Received signal '%v', exiting\n", sig)

@@ -122,56 +123,30 @@ func (v *simpleVersionInfo) Version() string {

 // for the container to exit.

 // If a signal is given, then just send it to the container and return.

 func (srv *Server) ContainerKill(job *engine.Job) engine.Status {

-	signalMap := map[string]syscall.Signal{

-		"HUP":  syscall.SIGHUP,

-		"INT":  syscall.SIGINT,

-		"QUIT": syscall.SIGQUIT,

-		"ILL":  syscall.SIGILL,

-		"TRAP": syscall.SIGTRAP,

-		"ABRT": syscall.SIGABRT,

-		"BUS":  syscall.SIGBUS,

-		"FPE":  syscall.SIGFPE,

-		"KILL": syscall.SIGKILL,

-		"USR1": syscall.SIGUSR1,

-		"SEGV": syscall.SIGSEGV,

-		"USR2": syscall.SIGUSR2,

-		"PIPE": syscall.SIGPIPE,

-		"ALRM": syscall.SIGALRM,

-		"TERM": syscall.SIGTERM,

-		//"STKFLT": syscall.SIGSTKFLT,

-		"CHLD":   syscall.SIGCHLD,

-		"CONT":   syscall.SIGCONT,

-		"STOP":   syscall.SIGSTOP,

-		"TSTP":   syscall.SIGTSTP,

-		"TTIN":   syscall.SIGTTIN,

-		"TTOU":   syscall.SIGTTOU,

-		"URG":    syscall.SIGURG,

-		"XCPU":   syscall.SIGXCPU,

-		"XFSZ":   syscall.SIGXFSZ,

-		"VTALRM": syscall.SIGVTALRM,

-		"PROF":   syscall.SIGPROF,

-		"WINCH":  syscall.SIGWINCH,

-		"IO":     syscall.SIGIO,

-		//"PWR":    syscall.SIGPWR,

-		"SYS": syscall.SIGSYS,

-	}

-

 	if n := len(job.Args); n < 1 || n > 2 {

 		return job.Errorf("Usage: %s CONTAINER [SIGNAL]", job.Name)

 	}

-	name := job.Args[0]

-	var sig uint64

+	var (

+		name = job.Args[0]

+		sig  uint64

+		err  error

+	)

+

+	// If we have a signal, look at it. Otherwise, do nothing

 	if len(job.Args) == 2 && job.Args[1] != "" {

-		sig = uint64(signalMap[job.Args[1]])

-		if sig == 0 {

-			var err error

-			// The largest legal signal is 31, so let's parse on 5 bits

-			sig, err = strconv.ParseUint(job.Args[1], 10, 5)

-			if err != nil {

+		// Check if we passed the singal as a number:

+		// The largest legal signal is 31, so let's parse on 5 bits

+		sig, err = strconv.ParseUint(job.Args[1], 10, 5)

+		if err != nil {

+			// The signal is not a number, treat it as a string

+			sig = uint64(signal.SignalMap[job.Args[1]])

+			if sig == 0 {

 				return job.Errorf("Invalid signal: %s", job.Args[1])

 			}

+

 		}

 	}

+

 	if container := srv.runtime.Get(name); container != nil {

 		// If no signal is passed, or SIGKILL, perform regular Kill (SIGKILL + wait())

 		if sig == 0 || syscall.Signal(sig) == syscall.SIGKILL {