first commit

.gitignore

@@ -10,3 +10,5 @@
 
 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out
+
+check_ajp

README.md

@@ -0,0 +1,61 @@
+# check_ajp
+
+Nagios plugin for checking AJP13 Server
+
+## Usage
+
+```
+Usage:
+ check_ajp [OPTIONS]
+
+Application Options:
+ -A, --useragent= User-Agent header (default: check_http_go)
+ -a, --attr= Attributes (auth, jvmRoute,...)
+ -c, --crit= Critical time in second (default: 10.0)
+ -e, --expect= Expected status codes (csv)
+ -H, --vhost= Host header value
+ -I, --ipaddr= IP address or Server hostname (default: 127.0.0.1)
+ -k, --header= Additional headers
+ -m, --method= HTTP method (default: GET)
+ -P, --protocol= HTTP protocol (default: HTTP/1.0)
+ -p, --port= TCP Port (default: 8009)
+ -s, --ssl isSSL flag
+ -t, --timeout= Connect timeout in second (default: 1.0)
+ -u, --uri= URI (default: /)
+ -v, --verbose verbose output
+ -w, --warn= Warning time in second (default: 5.0)
+ -V, --version Show version
+ --json-key= JSON key
+ --json-value= Expected json value
+ --remote-addr= RemoteAddr header value
+ --remote-host= RemoteHost header value
+
+Help Options:
+ -h, --help Show this help message
+```
+
+### example
+
+```
+./check_ajp -I server -u /checkHealth
+AJP OK: 200 - 3 bytes in 0.013 second response time |time=0.012675s;;;0.000000 size=3B;;;0
+```
+
+```
+$ ./check_ajp -I server -u /healthcheck --json-key status --json-value "ok"
+AJP OK: 200 - 137 bytes in 0.012 second response time |time=0.012235s;;;0.000000 size=137B;;;0
+
+{
+ "status": "ok"
+}
+```
+
+## Limitations
+
+Current version supported `GET` and `HEAD` method only.
+
+## How to build
+
+```
+go build -o check_ajp
+```

ajp_request.go

@@ -0,0 +1,216 @@
+package main
+
+import (
+ "bytes"
+ "errors"
+ "fmt"
+ "github.com/lunixbochs/struc"
+ "io"
+ "strings"
+)
+
+var SC_REQ_HEADER = map[string][]byte{
+ "accept": {0xA0, 0x01},
+ "accept-charset": {0xA0, 0x02},
+ "accept-encoding": {0xA0, 0x03},
+ "accept-language": {0xA0, 0x04},
+ "authorization": {0xA0, 0x05},
+ "connection": {0xA0, 0x06},
+ "content-type": {0xA0, 0x07},
+ "content-length": {0xA0, 0x08},
+ "cookie": {0xA0, 0x09},
+ "cookie2": {0xA0, 0x0A},
+ "host": {0xA0, 0x0B},
+ "pragma": {0xA0, 0x0C},
+ "referer": {0xA0, 0x0D},
+ "user-agent": {0xA0, 0x0E},
+}
+
+var SC_REQ_ATTR = map[string][]byte{
+ "context": {0x01}, // Not currently implemented
+ "servlet_path": {0x02}, // Not currently implemented
+ "remote_user": {0x03},
+ "auth_type": {0x04}, // Basic, Digest
+ "query_string": {0x05},
+ "route": {0x06},
+ "ssl_cert": {0x07},
+ "ssl_cipher": {0x08},
+ "ssl_session": {0x09},
+ "req_attribute": {0x0A}, // Name (the name of the attribut follows)
+ "ssl_key_size": {0x0B},
+ "secret": {0x0C},
+ "stored_method": {0x0D},
+}
+
+var METHOD = map[string]int{
+ "GET": 2,
+ "HEAD": 3,
+/*
+ Other methods are not supported yet.
+
+ "OPTIONS": 1,
+ "POST": 4,
+ "PUT": 5,
+ "DELETE": 6,
+ "TRACE": 7,
+ "PROPFIND": 8,
+ "PROPPATCH": 9,
+ "MKCOL": 10,
+ "COPY": 11,
+ "MOVE": 12,
+ "LOCK": 13,
+ "UNLOCK": 14,
+ "ACL": 15,
+ "REPORT": 16,
+ "VERSION-CONTROL": 17,
+ "CHECKIN": 18,
+ "CHECKOUT": 19,
+ "UNCHECKOUT": 20,
+ "SEARCH": 21,
+ "MKWORKSPACE": 22,
+ "UPDATE": 23,
+ "LABEL": 24,
+ "MERGE": 25,
+ "BASELINE_CONTROL": 26,
+ "MKACTIVITY": 27,
+*/
+}
+
+const JK_AJP13_FORWARD_REQUEST = 0x02
+
+type RequestHeader struct {
+ Name string
+ Value string
+}
+
+type Attribute struct {
+ Code []byte
+ Value string
+}
+
+type AJP13ForwardRequest struct {
+ PrefixCode int
+ Method string
+ Uri string
+ Protocol string
+ RemoteAddr string
+ RemoteHost string
+ ServerName string
+ ServerPort int
+ IsSsl bool
+ Headers []*RequestHeader
+ Attributes []*Attribute
+}
+
+type encodeBool struct {
+ Value bool `struc:"bool"`
+}
+
+type encodeInt8 struct {
+ Value int `struc:"uint8"`
+}
+
+type encodeInt16 struct {
+ Value int `struc:"int16"`
+}
+
+type encodeString struct {
+ Size int `struc:"uint16,sizeof=Value"`
+ Value string `struc:[]byte`
+ Terminate []byte `struc:"[1]pad"`
+}
+
+func newAJP13ForwardRequest(o Options) AJP13ForwardRequest {
+ r := AJP13ForwardRequest{}
+ r.PrefixCode = JK_AJP13_FORWARD_REQUEST
+ r.Method = strings.ToUpper(o.Method)
+ r.Protocol = o.Protocol
+ r.IsSsl = o.Ssl
+ r.Uri = o.Uri
+ r.ServerName = o.Ipaddr
+ r.ServerPort = o.Port
+ if o.RemoteAddr != "" {
+ r.RemoteAddr = o.RemoteAddr
+ }
+ if o.RemoteHost != "" {
+ r.RemoteHost = o.RemoteHost
+ }
+ return r
+}
+
+func (r *AJP13ForwardRequest) appendHeader(header string) {
+ hdr := strings.SplitN(header, ": ", 2)
+ r.Headers = append(r.Headers, &RequestHeader{Name: strings.ToLower(hdr[0]), Value: hdr[1]})
+}
+
+func appendUint16(buf *bytes.Buffer, i int) {
+ struc.Pack(buf, &encodeInt16{Value: i})
+}
+
+func appendByte(buf *bytes.Buffer, i int) {
+ struc.Pack(buf, &encodeInt8{Value: i})
+}
+
+func appendString(buf *bytes.Buffer, s string) {
+ struc.Pack(buf, &encodeString{Value: s})
+}
+
+func appendBool(buf *bytes.Buffer, b bool) {
+ struc.Pack(buf, &encodeBool{Value: b})
+}
+
+func (r *AJP13ForwardRequest) validate() error {
+ var err error
+
+ if METHOD[r.Method] == 0 {
+ err = errors.New(fmt.Sprintf("%s method is not yet supported.", r.Method))
+ }
+
+ return err
+}
+
+func (r *AJP13ForwardRequest) sendRequest(w io.Writer) error {
+ var err error
+
+ var buf bytes.Buffer
+ appendByte(&buf, r.PrefixCode)
+ appendByte(&buf, METHOD[r.Method])
+ appendString(&buf, r.Protocol)
+ appendString(&buf, r.Uri)
+ appendString(&buf, r.RemoteAddr)
+ appendString(&buf, r.RemoteHost)
+ appendString(&buf, r.ServerName)
+ appendUint16(&buf, r.ServerPort)
+ appendBool(&buf, r.IsSsl)
+
+ // Headers
+ appendUint16(&buf, len(r.Headers))
+
+ for _, hdr := range r.Headers {
+ if SC_REQ_HEADER[strings.ToLower(hdr.Name)] != nil {
+ buf.Write(SC_REQ_HEADER[strings.ToLower(hdr.Name)])
+ } else {
+ appendString(&buf, strings.ToLower(hdr.Name))
+ }
+ appendString(&buf, hdr.Value)
+ }
+
+ // Attributes
+ for _, attr := range r.Attributes {
+ buf.Write(attr.Code)
+ appendString(&buf, attr.Value)
+ }
+
+ buf.Write([]byte{0xff})
+
+ // Packet Format (Server->Container)
+ // Byte 0 1 2 3 4...(n+3)
+ // Contents 0x12 0x34 Data Length (n) Data
+ _, err = w.Write([]byte{0x12, 0x34})
+ if err = struc.Pack(w, &encodeInt16{Value: buf.Len()}); err != nil {
+ return err
+ }
+ _, err = w.Write(buf.Bytes())
+
+ return err
+}