You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
star/httpreverse/reverse.go

175 lines
4.4 KiB
Go

package httpreverse
import (
"b612.me/staros/sysconf"
"errors"
"io/ioutil"
"net/http"
"net/http/httputil"
"net/url"
"strings"
"sync"
)
type ReverseConfig struct {
Name string
Addr string
ReverseURL map[string]*url.URL
Port int
UsingSSL bool
Key string
Cert string
Host string
InHeader [][2]string
OutHeader [][2]string
Cookie [][3]string //[3]string should contains path::key::value
ReplaceList [][2]string
ReplaceOnce bool
proxy map[string]*httputil.ReverseProxy
XForwardMode int //0=off 1=useremote 2=add
httpmux http.ServeMux
httpserver http.Server
basicAuthUser string
basicAuthPwd string
protectAuthPage []string
blackip map[string]int
whiteip map[string]int
warningpage string
warnpagedata []byte
}
type HttpReverseServer struct {
Config []*ReverseConfig
}
func Parse(path string) (HttpReverseServer, error) {
var res HttpReverseServer
ini := sysconf.NewIni()
err := ini.ParseFromFile(path)
if err != nil {
return res, err
}
for _, v := range ini.Data {
var ins = ReverseConfig{
Name: v.Name,
Host: v.Get("host"),
Addr: v.Get("addr"),
Port: v.Int("port"),
UsingSSL: v.Bool("enablessl"),
Key: v.Get("key"),
Cert: v.Get("cert"),
ReplaceOnce: v.Bool("replaceonce"),
XForwardMode: v.Int("xforwardmode"),
basicAuthUser: v.Get("authuser"),
basicAuthPwd: v.Get("authpasswd"),
warningpage: v.Get("warnpage"),
}
if ins.warningpage != "" {
data, err := ioutil.ReadFile(ins.warningpage)
if err != nil {
return res, err
}
ins.warnpagedata = data
}
ins.proxy = make(map[string]*httputil.ReverseProxy)
ins.ReverseURL = make(map[string]*url.URL)
for _, reverse := range v.GetAll("reverse") {
kv := strings.SplitN(reverse, "::", 2)
if len(kv) != 2 {
return res, errors.New("reverse settings not correct:" + reverse)
}
ins.ReverseURL[strings.TrimSpace(kv[0])], err = url.Parse(strings.TrimSpace(kv[1]))
if err != nil {
return res, err
}
}
for _, header := range v.GetAll("inheader") {
kv := strings.SplitN(header, "::", 2)
if len(kv) != 2 {
return res, errors.New("header settings not correct:" + header)
}
ins.InHeader = append(ins.InHeader, [2]string{strings.TrimSpace(kv[0]), strings.TrimSpace(kv[1])})
}
for _, authpage := range v.GetAll("authpage") {
ins.protectAuthPage = append(ins.protectAuthPage, authpage)
}
ins.blackip = make(map[string]int)
for _, blackip := range v.GetAll("blackip") {
ip, cidr, err := IPCIDR(blackip)
if err != nil {
return res, err
}
ins.blackip[ip] = cidr
}
ins.whiteip = make(map[string]int)
for _, whiteip := range v.GetAll("whiteip") {
ip, cidr, err := IPCIDR(whiteip)
if err != nil {
return res, err
}
ins.whiteip[ip] = cidr
}
for _, header := range v.GetAll("outheader") {
kv := strings.SplitN(header, "::", 2)
if len(kv) != 2 {
return res, errors.New("header settings not correct:" + header)
}
ins.OutHeader = append(ins.OutHeader, [2]string{strings.TrimSpace(kv[0]), strings.TrimSpace(kv[1])})
}
for _, cookie := range v.GetAll("cookie") {
kv := strings.SplitN(cookie, "::", 3)
if len(kv) != 3 {
return res, errors.New("cookie settings not correct:" + cookie)
}
ins.Cookie = append(ins.Cookie, [3]string{strings.TrimSpace(kv[0]), strings.TrimSpace(kv[1]), strings.TrimSpace(kv[2])})
}
for _, replace := range v.GetAll("replace") {
kv := strings.SplitN(replace, "::", 2)
if len(kv) != 2 {
return res, errors.New("replace settings not correct:" + replace)
}
ins.ReplaceList = append(ins.ReplaceList, [2]string{strings.TrimSpace(kv[0]), strings.TrimSpace(kv[1])})
}
res.Config = append(res.Config, &ins)
}
return res, nil
}
func (h *HttpReverseServer) Run() error {
var wg sync.WaitGroup
var mu sync.Mutex
var haveErr string
for _, v := range h.Config {
wg.Add(1)
go func(v *ReverseConfig) {
defer wg.Done()
err := v.Run()
if err != nil {
mu.Lock()
haveErr += err.Error() + "\n"
mu.Unlock()
}
}(v)
}
wg.Wait()
if haveErr != "" {
return errors.New(haveErr)
}
return nil
}
func (h *HttpReverseServer) Close() error {
var haveErr string
for _, v := range h.Config {
err := v.Close()
if err != nil {
haveErr += err.Error() + "\n"
}
}
if haveErr != "" {
return errors.New(haveErr)
}
return nil
}