+ This is a tool to reveal certain information about your connection that the server sees. + Note that all of this information you see is sent by your client; + there was no probing/scanning or the like done from the server this site is hosted on. +

+ If you don't like this info being available to server administrators of the websites + you visit you may want to consider: +

Client/Browser Information{{ $linkico }}

+ Your IP Address is {{ $page.Info.IP.String }}. +
+ You are connecting with port {{ $page.Info.Port }} outbound. +

Raw Block ({{ $page.RawFmt }}){{ $linkico }}

User Agent Information{{ $linkico }}

Request Headers{{ $linkico }}

+ These are headers sent along with the request your browser sends for the page's content. + Note that some headers may have multiple values. +

+ + + + + + {{- range $hdrNm, $hdrVals := $page.Info.Req.Header }} + + {{- range $val := $hdrVals }} + + + {{- end }} + + {{- end }} +

Header	Value
{{ $hdrNm }}	{{ $val }}

+ +{{- end }} diff --git a/server/tpl/usage.html.tpl b/server/tpl/usage.html.tpl new file mode 100644 index 0000000..0e5ad1c --- /dev/null +++ b/server/tpl/usage.html.tpl @@ -0,0 +1,95 @@ +{{- /*gotype: r00t2.io/clientinfo/server.Page*/ -}} +{{- define "usage" }} +{{- $page := . -}} +{{- $linkico := "🔗" }} +{{- template "meta.top" $page }} +

Usage

Parameters{{ $linkico }}

+ You can control how the main page displays/renders. + By default, it will try to "guess" what you want; e.g. if you access it in Chrome, it will return HTML but if you fetch via Curl, you'll get raw JSON + (or your specified data format; see below). If the classification of client can't be determined and an Accept wasn't specified, + a fallback to text-mode (by default application/json) will be returned. +
+ + You can force a specific raw output by specifying the MIME type via + the Accept header (RFC 9110 § 12.5.1), which may be one of: +

application/json for JSON
application/xml for XML
application/yaml for YAML
text/html for HTML

+ For example: Accept: application/json will return JSON. +
+ + If unspecified and it is a text-mode client (e.g. Curl), the default is application/json. + text/html may be used to force an HTML response from a text-only client, + just as one of the application/* MIME types above may be used to force that "raw" text MIME type for a "graphical" browser client. + The specification as defined by RFC 9110 § 12.5.1 is completely + valid to pass and will be parsed without error (provided the header value is RFC-compliant and IANA-compliant), + though note that application/xml and text/html's charset parameter will be entirely ignored; + the returned XML/HTML is always Unicode (with UTF-8 encoding). +
+ + If no selectable MIME type is provided but an Accept was given, an error will be returned; specifically, a + 406 status code (RFC 9110 § 15.5.7). + In this case, supported MIME types will be returned in the response's Accept header. +
+ + Note that Lynx and Elinks are considered "graphical" + browsers by this program as they are HTML-centric. +

+ The following parameters control/modify behavior.{{ $linkico }} +

+ mime: Specify an explicit MIME type via URL instead of the Accept header as specified above. +
- This should only be used by clients in which it is impossible or particularly cumbersome to modify/specify headers. + Accept is more performant.
- Only the first supported instance of this parameter will be used.
- Any of the defined MIME types above may be specified (e.g. ?mime=application/json).
- If both this URL query parameter and the Accept header is specified, the URL query takes preference.
+
+ include: Include a <code> (or <pre>, depending on if indentation is needed/requested) block in the HTML for the specified MIME type as well.

Only the first supported instance of this parameter will be used.
+ The value must conform to the same rules/specifications as the mime parameter/Accept header. +
- include may not be text/html; it will be ignored if this is set. Just learn to ctrl+u.
+
Only used if the evaluated return is HTML, ignored otherwise.
Indentation can be specified via the indent parameter below (since indentation is otherwise meaningless to HTML returns).

+ indent: Enable/specify indentation for JSON and XML output; ignored for others. +
- The default is to not indent. (Commonly referred to as "condensed" or "compressed" JSON/XML.)
- Only the first specified instance of this parameter will be used.
- If specified with a string value, use that string as each indent. +
  - Be mindful of URL query parameter encoding, + per RFC 3986 § 3.4 + and RFC 8820 § 2.4
  - For quick reference and as an example, to indent with a tab + (\t, 0x09) for each level, use ?indent=%09
  +
- If indentation is specified without any value (?indent), the default is two + spaces (0x20); this would be represented + as ?indent=%20%20
- ?indent= (no value specified) is equal to ?indent.
+

+{{- template "meta.bottom" $page }} +{{- end }} diff --git a/server/types.go b/server/types.go new file mode 100644 index 0000000..9e3096c --- /dev/null +++ b/server/types.go @@ -0,0 +1,107 @@ +package server + +import ( + `encoding/xml` + `net` + `net/http` + `net/url` + `os` + + `github.com/mileusna/useragent` + `r00t2.io/clientinfo/args` + `r00t2.io/goutils/logging` +) + +type outerRenderer func(page *Page, resp http.ResponseWriter) (err error) +type XmlHeaders map[string][]string + +// R00tInfo is the structure of data returned to the client. +type R00tInfo struct { + // XMLName is the element name/namespace of this object ("info"). + XMLName xml.Name `json:"-" xml:"info" yaml:"-"` + // Client is the UA/Client info, if any passed by the client. + Client []*R00tClient `json:"ua,omitempty" xml:"ua,omitempty" yaml:"Client/User Agent,omitempty"` + // IP is the client IP address. + IP net.IP `json:"ip" xml:"ip,attr" yaml:"Client IP Address"` + // Port is the client's port number. + Port uint16 `json:"port" xml:"port,attr" yaml:"Client Port"` + // Headers are the collection of the request headers sent by the client. + Headers XmlHeaders `json:"headers" xml:"reqHeaders" yaml:"Request Headers"` + // Req contains the original request. It is not rendered but may be used for templating. + Req *http.Request `json:"-" xml:"-" yaml:"-"` +} + +// R00tClient is the UA/Client info, if any passed by the client. +type R00tClient struct { + // XMLName is the element name/namespace of this object ("ua"). + XMLName xml.Name `json:"-" xml:"ua" yaml:"-" uaField:"-" renderName:"-"` + // String contains the entire UA string. + String *string `json:"str,omitempty" xml:",chardata" yaml:"String"` + // ClientVer is a parsed version structure of the client version (see ClientVerStr for the combined string). + ClientVer *Ver `json:"ver,omitempty" xml:"version,omitempty" yaml:"Client Version,omitempty" uaField:"VersionNo" renderName:"-"` + // OSVer is the parsed OS version info of the client (see OsVersionStr for the combined string). + OSVer *Ver `json:"os_ver,omitempty" xml:"osVersion,omitempty" yaml:"Operating System Version,omitempty" uaField:"OSVersionNo" renderName:"-"` + // URL, if any, is the URL of the client. + URL *string `json:"url,omitempty" xml:"url,attr,omitempty" yaml:"URL,omitempty"` + // Name is the client software name. + Name *string `json:"name,omitempty" xml:"name,attr,omitempty" yaml:"Program/Name,omitempty"` + // ClientVerStr contains the full version as a string (see also Clientversion). + ClientVerStr *string `json:"ver_str,omitempty" xml:"verStr,attr,omitempty" yaml:"Client Version String,omitempty" uaField:"Version" renderName:"Client Version"` + // OS is the operating system of the client. + OS *string `json:"os,omitempty" xml:"os,attr,omitempty" yaml:"Operating System,omitempty"` + // OsVerStr is the version of the operating system of the client. + OsVerStr *string `json:"os_ver_str,omitempty" xml:"osVerStr,attr,omitempty" yaml:"Operating System Version String,omitempty" uaField:"OSVersion" renderName:"Operating System Version"` + // Dev is the device type. + Dev *string `json:"dev,omitempty" xml:"dev,attr,omitempty" yaml:"Device,omitempty" uaField:"Device"` + // IsMobile is true if this is a mobile device. + IsMobile bool `json:"mobile" xml:"mobile,attr" yaml:"Is Mobile" uaField:"Mobile"` + // sTablet is true if this is a tablet. + IsTablet bool `json:"tablet" xml:"tablet,attr" yaml:"Is Tablet" uaField:"Tablet"` + // IsDesktop is true if this is a desktop/laptop. + IsDesktop bool `json:"desktop" xml:"desktop,attr" yaml:"Is Desktop" uaField:"Desktop"` + // IsBot is true if this is a bot. + IsBot bool `json:"bot" xml:"bot,attr" yaml:"Is Bot" uaField:"Bot"` + ua *useragent.UserAgent +} + +type Ver struct { + // XMLName xml.Name `json:"-" xml:"version" yaml:"-"` + Major int `json:"major" xml:"maj,attr" yaml:"Major"` + Minor int `json:"minor" xml:"min,attr" yaml:"Minor"` + Patch int `json:"patch" xml:"patch,attr" yaml:"Patch"` +} + +// Page is only used for HTML rendering. +type Page struct { + Info *R00tInfo + // e.g. "index.html.tpl"; populated by handler + PageType string + // Nil unless `?include=` specified, otherwise a block of text to be wrapped in .... + Raw *string + // RawFmt is the MIME type for Raw, if `?include=` enabled/specified. + RawFmt *string + // Indent specifies the indentation string. + Indent string + // DoIndent indicates if indenting was enabled. + DoIndent bool +} + +type Server struct { + log logging.Logger + args *args.Args + listenUri *url.URL + isHttp bool + mux *http.ServeMux + sock net.Listener + doneChan chan bool + stopChan chan os.Signal + reloadChan chan os.Signal + isStopping bool +} + +// https://www.iana.org/assignments/media-types/media-types.xhtml +type parsedMIME struct { + MIME string + Weight float32 // Technically a param (q; "qualifier"?), but copied and converted here for easier sorting. + Params map[string]string +} diff --git a/version/consts.go b/version/consts.go new file mode 100644 index 0000000..04ec47a --- /dev/null +++ b/version/consts.go @@ -0,0 +1,32 @@ +package version + +import ( + "regexp" +) + +/* +These variables are automatically handled by the build script. + +DO NOT MODIFY THESE VARIABLES. +Refer to /build.sh for how these are generated at build time and populated. +*/ +var ( + sourceControl string = "git" + version string = "(unknown)" + commitHash string + commitShort string + numCommitsAfterTag string + isDirty string + buildTime string + buildUser string + buildSudoUser string + buildHost string +) + +var ( + patchRe *regexp.Regexp = regexp.MustCompile(`^(?P[0-9+])(?P

-[0-9A-Za-z.-]+)?(?P\+[0-9A-Za-z.-]+)?$`)
+	patchReIsolated *regexp.Regexp = regexp.MustCompile(`^([0-9]+)(?:[-+](.*)?)?$`)
+)
+
+// Ver is populated by main() from the build script and used in other places.
+var Ver *BuildInfo
diff --git a/version/funcs.go b/version/funcs.go
new file mode 100644
index 0000000..6624bd3
--- /dev/null
+++ b/version/funcs.go
@@ -0,0 +1,144 @@
+package version
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+
+	"golang.org/x/mod/semver"
+)
+
+// Version returns the build information. See build.sh.
+func Version() (b *BuildInfo, err error) {
+
+	var n int
+	var s string
+	var sb strings.Builder
+	var ok bool
+	var canonical string
+	var build strings.Builder
+	// Why a map?
+	// I forget but I had a reason for it once upon a time.
+	var raw map[string]string = map[string]string{
+		"sourceControl":  sourceControl,
+		"tag":            version,
+		"hash":           commitHash,
+		"shortHash":      commitShort,
+		"postTagCommits": numCommitsAfterTag,
+		"dirty":          isDirty,
+		"time":           buildTime,
+		"user":           buildUser,
+		"sudoUser":       buildSudoUser,
+		"host":           buildHost,
+	}
+	var i BuildInfo = BuildInfo{
+		SourceControl: raw["sourceControl"],
+		TagVersion:    raw["tag"],
+		// PostTagCommits: 0,
+		CommitHash:    raw["hash"],
+		CommitId:      raw["shortHash"],
+		BuildUser:     raw["user"],
+		RealBuildUser: raw["sudoUser"],
+		// BuildTime:     time.Time{},
+		BuildHost: raw["host"],
+		Dirty:     false,
+		isDefined: false,
+		raw:       raw,
+	}
+
+	if s, ok = raw["postTagCommits"]; ok && strings.TrimSpace(s) != "" {
+		if n, err = strconv.Atoi(s); err == nil {
+			i.PostTagCommits = uint(n)
+		}
+	}
+
+	if s, ok = raw["time"]; ok && strings.TrimSpace(s) != "" {
+		if n, err = strconv.Atoi(s); err == nil {
+			i.BuildTime = time.Unix(int64(n), 0).UTC()
+		}
+	}
+
+	switch strings.ToLower(raw["dirty"]) {
+	case "1":
+		i.Dirty = true
+	case "0", "":
+		i.Dirty = false
+	}
+
+	// Build the short form. We use this for both BuildInfo.short and BuildInfo.verSplit.
+	if i.TagVersion == "" {
+		sb.WriteString(i.SourceControl)
+	} else {
+		sb.WriteString(i.TagVersion)
+	}
+	/*
+		Now the mess. In order to conform to SemVer 2.0 (the spec this code targets):
+
+		1.) MAJOR.
+		2.) MINOR.
+		3.) PATCH
+		4.) -PRERELEASE (OPTIONAL)
+			(git commit, if building against a commit made past 1-3. Always included if untagged.)
+		5.) +BUILDINFO (OPTIONAL)
+			("+x[.y]", where x is # of commits past 4, or tag commit if 4 is empty. 0 is valid.
+			 y is optional, and is the string "dirty" if it is a "dirty" build - that is, uncommitted/unstaged changes.
+			 if x and y would be 0 and empty, respectively, then 5 is not included.)
+
+		1-3 are already written, or the source control software used if not.
+
+		Technically 4 and 5 are only included if 3 is present. We force patch to 0 if it's a tagged release and patch isn't present --
+		so this is not relevant.
+	*/
+	// PRERELEASE
+	if i.TagVersion == "" || i.PostTagCommits > 0 {
+		// We use the full commit hash for git versions, short identifier for tagged releases.
+		if i.TagVersion == "" {
+			i.Pre = i.CommitHash
+		} else {
+			i.Pre = i.CommitId
+		}
+		sb.WriteString(fmt.Sprintf("-%v", i.Pre))
+	}
+	// BUILD
+	if i.PostTagCommits > 0 || i.Dirty {
+		build.WriteString(strconv.Itoa(int(i.PostTagCommits)))
+		if i.Dirty {
+			build.WriteString(".dirty")
+		}
+		i.Build = build.String()
+		sb.WriteString(fmt.Sprintf("+%v", i.Build))
+	}
+
+	i.short = sb.String()
+	if semver.IsValid(i.short) {
+		// DON'T DO THIS. It strips the prerelease and build info.
+		// i.short = semver.Canonical(i.short)
+		// Do this instead.
+		canonical = semver.Canonical(i.short)
+		// Numeric versions...
+		if n, err = strconv.Atoi(strings.TrimPrefix(semver.Major(canonical), "v")); err != nil {
+			err = nil
+		} else {
+			i.Major = uint(n)
+		}
+		if n, err = strconv.Atoi(strings.Split(semver.MajorMinor(canonical), ".")[1]); err != nil {
+			err = nil
+		} else {
+			i.Minor = uint(n)
+		}
+		if n, err = strconv.Atoi(patchReIsolated.FindStringSubmatch(strings.Split(canonical, ".")[2])[1]); err != nil {
+			err = nil
+		} else {
+			i.Patch = uint(n)
+		}
+		// The other tag assignments were performed above.
+	}
+	// The default is 0 for the numerics, so no big deal.
+
+	i.isDefined = true
+
+	b = &i
+
+	return
+}
diff --git a/version/funcs_buildinfo.go b/version/funcs_buildinfo.go
new file mode 100644
index 0000000..0d27cdf
--- /dev/null
+++ b/version/funcs_buildinfo.go
@@ -0,0 +1,103 @@
+package version
+
+import (
+	"fmt"
+	"strings"
+
+	"golang.org/x/mod/semver"
+)
+
+// Detail returns a multiline string containing every possible piece of information we collect.
+func (b *BuildInfo) Detail() (ver string) {
+
+	var sb strings.Builder
+
+	sb.WriteString(fmt.Sprintf("%v\n\n", b.short))
+	sb.WriteString(fmt.Sprintf("====\nSource Control: %v\n", b.SourceControl))
+	if b.TagVersion != "" {
+		if b.PostTagCommits > 0 {
+			sb.WriteString(fmt.Sprintf("Version Base: %v\nCommit Hash: %v\n", b.TagVersion, b.CommitHash))
+		} else {
+			sb.WriteString(fmt.Sprintf("Version: %v\n", b.TagVersion))
+		}
+	} else {
+		sb.WriteString(fmt.Sprintf("Version: (Unversioned)\nCommit Hash: %v\n", b.CommitHash))
+	}
+
+	// Post-commits
+	if b.TagVersion != "" {
+		sb.WriteString(fmt.Sprintf("# of Commits Since %v: %v\n", b.TagVersion, b.PostTagCommits))
+	} else {
+		sb.WriteString(fmt.Sprintf("# of Commits Since %v: %v\n", b.CommitId, b.PostTagCommits))
+	}
+
+	sb.WriteString("Uncommitted/Unstaged Changes: ")
+	if b.Dirty {
+		sb.WriteString("yes (dirty/monkeypatched build)\n")
+	} else {
+		sb.WriteString("no (clean build)\n")
+	}
+
+	if b.TagVersion != "" {
+		sb.WriteString(
+			fmt.Sprintf(
+				"====\nMajor: %v\nMinor: %v\nPatch: %v\n",
+				b.Major, b.Minor, b.Patch,
+			),
+		)
+	}
+	sb.WriteString("====\n")
+	sb.WriteString(b.Meta())
+
+	ver = sb.String()
+
+	return
+}
+
+// Short returns a uniquely identifiable version string.
+func (b *BuildInfo) Short() (ver string) {
+
+	ver = b.short
+
+	return
+}
+
+// Meta returns the build/compile-time info.
+func (b *BuildInfo) Meta() (meta string) {
+
+	var sb strings.Builder
+
+	if b.RealBuildUser != b.BuildUser && b.RealBuildUser != "" {
+		sb.WriteString(fmt.Sprintf("Real Build User: %v\n", b.RealBuildUser))
+		sb.WriteString(fmt.Sprintf("Sudo Build User: %v\n", b.BuildUser))
+	} else {
+		sb.WriteString(fmt.Sprintf("Build User: %v\n", b.BuildUser))
+	}
+	sb.WriteString(fmt.Sprintf("Build Time: %v\nBuild Host: %v\n", b.BuildTime, b.BuildHost))
+
+	meta = sb.String()
+
+	return
+}
+
+// getReMap gets a regex map of map[pattern]match.
+func (b *BuildInfo) getReMap() (matches map[string]string) {
+
+	var s string = b.Short()
+	var sections []string
+
+	if !semver.IsValid(s) {
+		return
+	}
+
+	sections = strings.Split(s, ".")
+
+	// The split should contain everything in the third element.
+	// Or, if using a "simplified" semver, the last element.
+	matches = make(map[string]string)
+	for idx, str := range patchRe.FindStringSubmatch(sections[len(sections)-1]) {
+		matches[patchRe.SubexpNames()[idx]] = str
+	}
+
+	return
+}
diff --git a/version/types.go b/version/types.go
new file mode 100644
index 0000000..084e51d
--- /dev/null
+++ b/version/types.go
@@ -0,0 +1,51 @@
+package version
+
+import (
+	"time"
+)
+
+// BuildInfo contains nativized version information.
+type BuildInfo struct {
+	// TagVersion is the most recent tag name on the current branch.
+	TagVersion string
+	// PostTagCommits is the number of commits after BuildInfo.TagVersion's commit on the current branch.
+	PostTagCommits uint
+	// CommitHash is the full commit hash.
+	CommitHash string
+	// CommitId is the "short" version of BuildInfo.CommitHash.
+	CommitId string
+	// BuildUser is the user the program was compiled under.
+	BuildUser string
+	// If compiled under sudo, BuildInfo.RealBuildUser is the user that called sudo.
+	RealBuildUser string
+	// BuildTime is the time and date of the program's build time.
+	BuildTime time.Time
+	// BuildHost is the host the binary was compiled on.
+	BuildHost string
+	// Dirty specifies if the source was "dirty" (uncommitted/unstaged etc. files) at the time of compilation.
+	Dirty bool
+	// SourceControl is the source control version used. Only relevant if not a "clean" build or untagged.
+	SourceControl string
+	// Major is the major version, expressed as an uint per spec.
+	Major uint
+	// Minor is the minor version, expressed as an uint per spec.
+	Minor uint
+	// Patch is the patch version, expressed as an uint per spec.
+	Patch uint
+	// Pre
+	Pre string
+	// Build
+	Build string
+	// isDefined specifies if this version was retrieved from the built-in values.
+	isDefined bool
+	// raw is the raw variable values.
+	raw map[string]string
+	/*
+		verSplit is a slice of []string{Major, Minor, Patch, PreRelease, Build}
+
+		If using an actual point release, PreRelease and Build are probably blank.
+	*/
+	verSplit [5]string
+	// short is the condensed version of verSplit.
+	short string
+}