utils.go

/*===----------- utils.go - tracking utility written in go  -------------===
 *
 *
 * This file is licensed under the Apache 2 License. See LICENSE for details.
 *
 *  Copyright (c) 2018 Andrew Grosser. All Rights Reserved.
 *
 *                                     `...
 *                                    yNMMh`
 *                                    dMMMh`
 *                                    dMMMh`
 *                                    dMMMh`
 *                                    dMMMd`
 *                                    dMMMm.
 *                                    dMMMm.
 *                                    dMMMm.               /hdy.
 *                  ohs+`             yMMMd.               yMMM-
 *                 .mMMm.             yMMMm.               oMMM/
 *                 :MMMd`             sMMMN.               oMMMo
 *                 +MMMd`             oMMMN.               oMMMy
 *                 sMMMd`             /MMMN.               oMMMh
 *                 sMMMd`             /MMMN-               oMMMd
 *                 oMMMd`             :NMMM-               oMMMd
 *                 /MMMd`             -NMMM-               oMMMm
 *                 :MMMd`             .mMMM-               oMMMm`
 *                 -NMMm.             `mMMM:               oMMMm`
 *                 .mMMm.              dMMM/               +MMMm`
 *                 `hMMm.              hMMM/               /MMMm`
 *                  yMMm.              yMMM/               /MMMm`
 *                  oMMm.              oMMMo               -MMMN.
 *                  +MMm.              +MMMo               .MMMN-
 *                  +MMm.              /MMMo               .NMMN-
 *           `      +MMm.              -MMMs               .mMMN:  `.-.
 *          /hys:`  +MMN-              -NMMy               `hMMN: .yNNy
 *          :NMMMy` sMMM/              .NMMy                yMMM+-dMMMo
 *           +NMMMh-hMMMo              .mMMy                +MMMmNMMMh`
 *            /dMMMNNMMMs              .dMMd                -MMMMMNm+`
 *             .+mMMMMMN:              .mMMd                `NMNmh/`
 *               `/yhhy:               `dMMd                 /+:`
 *                                     `hMMm`
 *                                     `hMMm.
 *                                     .mMMm:
 *                                     :MMMd-
 *                                     -NMMh.
 *                                      ./:.
 *
 *===----------------------------------------------------------------------===
 */
package main

import (
	"crypto/sha1"
	"encoding/base64"
	"fmt"
	"hash/fnv"
	"net"
	"net/http"
	"os"
	"os/user"
	"path/filepath"
	"strings"
)

////////////////////////////////////////
// hash
////////////////////////////////////////
func hash(s string) uint32 {
	h := fnv.New32a()
	h.Write([]byte(s))
	return h.Sum32()
}

func sha(s string) string {
	hasher := sha1.New()
	hasher.Write([]byte(s))
	return base64.URLEncoding.EncodeToString(hasher.Sum(nil))
}

////////////////////////////////////////
// filterUrl
// matchGroup is a 1 indexed array (0 is default last)
// returns last match if no group, or group
////////////////////////////////////////
func filterUrl(c *Configuration, s *string, matchGroup *int) error {
	matches := regexFilterUrl.FindStringSubmatch(*s)
	mi := len(matches)
	if matchGroup == nil || *matchGroup == 0 {
		//Take the last one by default
		if mi > 0 {
			*s = matches[mi-1]
			return nil
		}
	} else {
		if mi > *matchGroup {
			*s = matches[*matchGroup]
			return nil
		}
	}
	//Fallback
	filterUrlAppendix(s)
	return fmt.Errorf("Mismatch Regex (Url Filter)")
}

func filterUrlAppendix(s *string) error {
	if s != nil {
		i := strings.Index(*s, "?")
		if i > -1 {
			*s = (*s)[:i]
		}
	}
	return nil
}

func filterUrlPrefix(s *string) error {
	if s != nil {
		*s = strings.ToLower(*s)
		i := strings.Index(*s, "https://")
		if i > -1 {
			*s = (*s)[i+6:]
			return nil
		}
		i = strings.Index(*s, "http://")
		if i > -1 {
			*s = (*s)[i+5:]
		}
	}
	return nil
}

func cleanInterfaceString(i interface{}) error {
	s := &i
	if temp, ok := (*s).(string); ok {
		*s = strings.ToLower(strings.TrimSpace(temp))
	}
	return nil
}

func cleanString(s *string) error {
	if s != nil && *s != "" {
		*s = strings.ToLower(strings.TrimSpace(*s))
	}
	return nil
}

////////////////////////////////////////
// cacheDir in /tmp for SSL
////////////////////////////////////////
func cacheDir() (dir string) {
	if u, _ := user.Current(); u != nil {
		dir = filepath.Join(os.TempDir(), "cache-golang-autocert-"+u.Username)
		//dir = filepath.Join(".", "cache-golang-autocert-"+u.Username)
		fmt.Println("Saving cache-go-lang-autocert-u.username to: ", dir)
		if err := os.MkdirAll(dir, 0700); err == nil {
			return dir
		}
	}
	return ""
}

func getIP(r *http.Request) string {
	ip := r.Header.Get("X-Forwarded-For")
	if ip == "" {
		var err error
		if ip, _, err = net.SplitHostPort(r.RemoteAddr); err != nil {
			return r.RemoteAddr
		}
	}
	return ip
}

func getHost(r *http.Request) string {
	if addr, _, err := net.SplitHostPort(r.Host); err != nil {
		return r.Host
	} else {
		return addr
	}
}