package server import ( "fmt" "io" "io/ioutil" "log" "net/http" "path/filepath" "sort" "text/template" ) const ( tmplApproval = "approval.html" tmplLogin = "login.html" tmplPassword = "password.html" tmplOOB = "oob.html" ) const coreOSLogoURL = "https://coreos.com/assets/images/brand/coreos-wordmark-135x40px.png" var requiredTmpls = []string{ tmplApproval, tmplLogin, tmplPassword, tmplOOB, } // TemplateConfig describes. type TemplateConfig struct { // TODO(ericchiang): Asking for a directory with a set of templates doesn't indicate // what the templates should look like and doesn't allow consumers of this package to // provide their own templates in memory. In the future clean this up. // Directory of the templates. If empty, these will be loaded from memory. Dir string `yaml:"dir"` // Defaults to the CoreOS logo and "dex". LogoURL string `yaml:"logoURL"` Issuer string `yaml:"issuerName"` } type globalData struct { LogoURL string Issuer string } func loadTemplates(config TemplateConfig) (*templates, error) { var tmpls *template.Template if config.Dir != "" { files, err := ioutil.ReadDir(config.Dir) if err != nil { return nil, fmt.Errorf("read dir: %v", err) } filenames := []string{} for _, file := range files { if file.IsDir() { continue } filenames = append(filenames, filepath.Join(config.Dir, file.Name())) } if len(filenames) == 0 { return nil, fmt.Errorf("no files in template dir %s", config.Dir) } if tmpls, err = template.ParseFiles(filenames...); err != nil { return nil, fmt.Errorf("parse files: %v", err) } } else { // Load templates from memory. This code is largely copied from the standard library's // ParseFiles source code. // See: https://goo.gl/6Wm4mN for name, data := range defaultTemplates { var t *template.Template if tmpls == nil { tmpls = template.New(name) } if name == tmpls.Name() { t = tmpls } else { t = tmpls.New(name) } if _, err := t.Parse(data); err != nil { return nil, fmt.Errorf("parsing %s: %v", name, err) } } } missingTmpls := []string{} for _, tmplName := range requiredTmpls { if tmpls.Lookup(tmplName) == nil { missingTmpls = append(missingTmpls, tmplName) } } if len(missingTmpls) > 0 { return nil, fmt.Errorf("missing template(s): %s", missingTmpls) } if config.LogoURL == "" { config.LogoURL = coreOSLogoURL } if config.Issuer == "" { config.Issuer = "dex" } return &templates{ globalData: config, loginTmpl: tmpls.Lookup(tmplLogin), approvalTmpl: tmpls.Lookup(tmplApproval), passwordTmpl: tmpls.Lookup(tmplPassword), oobTmpl: tmpls.Lookup(tmplOOB), }, nil } var scopeDescriptions = map[string]string{ "offline_access": "Have offline access", "profile": "View basic profile information", "email": "View your email", } type templates struct { globalData TemplateConfig loginTmpl *template.Template approvalTmpl *template.Template passwordTmpl *template.Template oobTmpl *template.Template } type connectorInfo struct { ID string Name string URL string } type byName []connectorInfo func (n byName) Len() int { return len(n) } func (n byName) Less(i, j int) bool { return n[i].Name < n[j].Name } func (n byName) Swap(i, j int) { n[i], n[j] = n[j], n[i] } func (t *templates) login(w http.ResponseWriter, connectors []connectorInfo, state string) { sort.Sort(byName(connectors)) data := struct { TemplateConfig Connectors []connectorInfo State string }{t.globalData, connectors, state} renderTemplate(w, t.loginTmpl, data) } func (t *templates) password(w http.ResponseWriter, state, callback, lastUsername string, lastWasInvalid bool) { data := struct { TemplateConfig State string PostURL string Username string Invalid bool }{t.globalData, state, callback, lastUsername, lastWasInvalid} renderTemplate(w, t.passwordTmpl, data) } func (t *templates) approval(w http.ResponseWriter, state, username, clientName string, scopes []string) { accesses := []string{} for _, scope := range scopes { access, ok := scopeDescriptions[scope] if ok { accesses = append(accesses, access) } } sort.Strings(accesses) data := struct { TemplateConfig User string Client string State string Scopes []string }{t.globalData, username, clientName, state, accesses} renderTemplate(w, t.approvalTmpl, data) } func (t *templates) oob(w http.ResponseWriter, code string) { data := struct { TemplateConfig Code string }{t.globalData, code} renderTemplate(w, t.oobTmpl, data) } // small io.Writer utilitiy to determine if executing the template wrote to the underlying response writer. type writeRecorder struct { wrote bool w io.Writer } func (w *writeRecorder) Write(p []byte) (n int, err error) { w.wrote = true return w.w.Write(p) } func renderTemplate(w http.ResponseWriter, tmpl *template.Template, data interface{}) { wr := &writeRecorder{w: w} if err := tmpl.Execute(wr, data); err != nil { log.Printf("Error rendering template %s: %s", tmpl.Name(), err) if !wr.wrote { // TODO(ericchiang): replace with better internal server error. http.Error(w, "Internal server error", http.StatusInternalServerError) } } return }