123 lines
3 KiB
Go
123 lines
3 KiB
Go
package links
|
|
|
|
import (
|
|
"fmt"
|
|
"net/url"
|
|
"strings"
|
|
)
|
|
|
|
const DefaultPublicBaseURL = "https://telesrv.net"
|
|
const MaxChatlistSlugBytes = 128
|
|
|
|
func NormalizeBaseURL(raw string) string {
|
|
raw = strings.TrimSpace(raw)
|
|
if raw == "" {
|
|
raw = DefaultPublicBaseURL
|
|
}
|
|
if !strings.Contains(raw, "://") {
|
|
raw = "https://" + raw
|
|
}
|
|
return strings.TrimRight(raw, "/")
|
|
}
|
|
|
|
// ValidateBaseURL normalizes and validates a client-visible HTTP(S) base URL.
|
|
// A path prefix is allowed, but credentials, query parameters, and fragments
|
|
// are not part of a stable public-link root.
|
|
func ValidateBaseURL(raw string) (string, error) {
|
|
normalized := NormalizeBaseURL(raw)
|
|
parsed, err := url.Parse(normalized)
|
|
if err != nil {
|
|
return "", fmt.Errorf("parse URL: %w", err)
|
|
}
|
|
if parsed.Opaque != "" || (parsed.Scheme != "http" && parsed.Scheme != "https") {
|
|
return "", fmt.Errorf("scheme must be http or https")
|
|
}
|
|
if parsed.Host == "" || parsed.Hostname() == "" {
|
|
return "", fmt.Errorf("host is required")
|
|
}
|
|
if parsed.User != nil {
|
|
return "", fmt.Errorf("credentials are not allowed")
|
|
}
|
|
if parsed.RawQuery != "" || parsed.ForceQuery {
|
|
return "", fmt.Errorf("query parameters are not allowed")
|
|
}
|
|
if parsed.Fragment != "" {
|
|
return "", fmt.Errorf("fragment is not allowed")
|
|
}
|
|
parsed.Path = strings.TrimRight(parsed.Path, "/")
|
|
return strings.TrimRight(parsed.String(), "/"), nil
|
|
}
|
|
|
|
func Build(baseURL, path string, query url.Values) string {
|
|
baseURL, err := ValidateBaseURL(baseURL)
|
|
if err != nil {
|
|
baseURL = DefaultPublicBaseURL
|
|
}
|
|
parsed, _ := url.Parse(baseURL)
|
|
basePath := strings.TrimRight(parsed.Path, "/")
|
|
path = strings.TrimLeft(path, "/")
|
|
if path != "" {
|
|
parsed.Path = basePath + "/" + path
|
|
} else if basePath != "" {
|
|
parsed.Path = basePath
|
|
}
|
|
parsed.RawQuery = query.Encode()
|
|
return parsed.String()
|
|
}
|
|
|
|
func Host(baseURL string) string {
|
|
baseURL, err := ValidateBaseURL(baseURL)
|
|
if err != nil {
|
|
return "telesrv.net"
|
|
}
|
|
parsed, _ := url.Parse(baseURL)
|
|
if host := parsed.Hostname(); host != "" {
|
|
return host
|
|
}
|
|
return parsed.Host
|
|
}
|
|
|
|
func CleanChatlistSlug(raw string) string {
|
|
raw = strings.TrimSpace(raw)
|
|
if raw == "" {
|
|
return ""
|
|
}
|
|
if strings.Contains(raw, "://") {
|
|
if parsed, err := url.Parse(raw); err == nil {
|
|
if slug := parsed.Query().Get("slug"); slug != "" {
|
|
raw = slug
|
|
} else {
|
|
raw = strings.Trim(parsed.Path, "/")
|
|
}
|
|
}
|
|
}
|
|
raw = strings.TrimPrefix(raw, "addlist/")
|
|
raw = strings.Trim(raw, "/")
|
|
if idx := strings.LastIndex(raw, "/"); idx >= 0 {
|
|
raw = raw[idx+1:]
|
|
}
|
|
if idx := strings.IndexAny(raw, "?#"); idx >= 0 {
|
|
raw = raw[:idx]
|
|
}
|
|
if decoded, err := url.PathUnescape(raw); err == nil {
|
|
raw = decoded
|
|
}
|
|
return raw
|
|
}
|
|
|
|
func ValidChatlistSlug(slug string) bool {
|
|
if slug == "" || len(slug) > MaxChatlistSlugBytes {
|
|
return false
|
|
}
|
|
for _, r := range slug {
|
|
switch {
|
|
case r >= 'a' && r <= 'z':
|
|
case r >= 'A' && r <= 'Z':
|
|
case r >= '0' && r <= '9':
|
|
case r == '_' || r == '-' || r == '.':
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|