// printDetailedEndpointInfo fetch and print detailed info for one endpoint
func printDetailedEndpointInfo(ap *sslscan.AnalyzeProgress, ip string) {
info, err := ap.DetailedInfo(ip)
if err != nil {
fmtc.Printf("\n{r}Can't fetch detailed info for %s{!}\n\n", ip)
return
}
if strings.ToUpper(info.StatusMessage) != "READY" {
fmtc.Printf("\n{r}%s{!}\n\n", info.StatusMessage)
return
}
details := info.Details
fmtc.NewLine()
printCertificateInfo(details)
printCertificationPathsInfo(details)
printProtocolsInfo(details)
suiteIndex := printCipherSuitesInfo(details)
printHandshakeSimulationInfo(details, suiteIndex)
printProtocolDetailsInfo(details)
printMiscellaneousInfo(info)
fmtutil.Separator(true)
fmtc.NewLine()
}
// findInfo search geven pattern in entities names
func findInfo(doc *Document, pattern string) {
fmtc.NewLine()
if doc.Constants != nil {
for _, c := range doc.Constants {
if strings.Contains(c.Name, pattern) {
renderConstant(c)
fmtc.NewLine()
}
}
}
if doc.Variables != nil {
for _, v := range doc.Variables {
if strings.Contains(v.Name, pattern) {
renderVariable(v)
fmtc.NewLine()
}
}
}
if doc.Methods != nil {
for _, m := range doc.Methods {
if strings.Contains(m.Name, pattern) {
renderMethod(m, true)
fmtc.NewLine()
}
}
}
}
// simpleRender print all document info to console
func simpleRender(doc *Document) {
if doc.HasAbout() {
fmtutil.Separator(false, "ABOUT")
for _, l := range doc.About {
fmtc.Printf(" %s\n", l)
}
}
if doc.HasConstants() {
fmtutil.Separator(false, "CONSTANTS")
totalConstants := len(doc.Constants)
for i, c := range doc.Constants {
renderConstant(c)
if i < totalConstants-1 {
fmtc.NewLine()
}
}
}
if doc.HasVariables() {
fmtutil.Separator(false, "GLOBAL VARIABLES")
totalVariables := len(doc.Variables)
for i, v := range doc.Variables {
renderVariable(v)
if i < totalVariables-1 {
fmtc.NewLine()
}
}
}
if doc.HasMethods() {
fmtutil.Separator(false, "METHODS")
totalMethods := len(doc.Methods)
for i, m := range doc.Methods {
renderMethod(m, false)
if i < totalMethods-1 {
fmtc.NewLine()
fmtc.NewLine()
}
}
}
fmtutil.Separator(false)
}
// renderOptions render options
func renderOptions(options []option, colorTag string) {
var (
curGroup string
opt option
maxSize int
)
maxSize = getMaxOptionSize(options)
for _, opt = range options {
if curGroup != opt.group {
printGroupHeader(opt.group)
curGroup = opt.group
}
fmtc.Printf(" "+colorTag+"%s{!}", opt.name)
if len(opt.args) != 0 {
fmtc.Printf(" " + renderArgs(opt.args))
}
fmtc.Printf(getBreadcrumbs(opt, maxSize))
fmtc.Printf(opt.desc)
fmtc.NewLine()
}
}
// Render print version info to console
func (about *About) Render() {
switch {
case about.Build != "":
fmtc.Printf(
"\n{*c}%s {c}%s{!}{s}%s{!} {s-}(%s){!} - %s\n\n",
about.App, about.Version,
about.Release, about.Build, about.Desc,
)
default:
fmtc.Printf(
"\n{*c}%s {c}%s{!}{s}%s{!} - %s\n\n",
about.App, about.Version,
about.Release, about.Desc,
)
}
if about.Owner != "" {
if about.Year == 0 {
fmtc.Printf("{s-}Copyright (C) %s{!}\n", about.Owner)
} else {
fmtc.Printf(
"{s-}Copyright (C) %d-%d %s{!}\n",
about.Year, time.Now().Year(), about.Owner,
)
}
}
if about.License != "" {
fmtc.Printf("{s-}%s{!}\n", about.License)
}
fmtc.NewLine()
}
// renderTemplate read template and render to file
func renderTemplate(doc *Document) {
projectDir := env.Get().GetS("GOPATH")
templateFile := path.Join(
projectDir, "src/github.com/essentialkaos/shdoc/templates",
arg.GetS(ARG_TEMPLATE)+".tpl",
)
if !fsutil.CheckPerms("FRS", templateFile) {
printError("Can't read template %s - file is not exist or empty", templateFile)
os.Exit(1)
}
outputFile := arg.GetS(ARG_OUTPUT)
if fsutil.IsExist(outputFile) {
os.Remove(outputFile)
}
fd, err := os.OpenFile(outputFile, os.O_CREATE|os.O_WRONLY, 0644)
if err != nil {
printError(err.Error())
os.Exit(1)
}
defer fd.Close()
tpl, err := ioutil.ReadFile(templateFile)
if err != nil {
printError(err.Error())
os.Exit(1)
}
t := template.New("Template")
t, err = t.Parse(string(tpl[:]))
err = t.Execute(fd, doc)
if err != nil {
printError(err.Error())
os.Exit(1)
}
fmtutil.Separator(false, doc.Title)
fmtc.Printf(" {*}Constants:{!} %d\n", len(doc.Constants))
fmtc.Printf(" {*}Variables:{!} %d\n", len(doc.Variables))
fmtc.Printf(" {*}Methods:{!} %d\n", len(doc.Methods))
fmtc.NewLine()
fmtc.Printf(
" {*}Output:{!} %s {s-}(%s){!}\n", outputFile,
fmtutil.PrettySize(fsutil.GetSize(outputFile)),
)
fmtutil.Separator(false)
}
// showServerMessage show message from SSL Labs API
func showServerMessage() {
serverMessage := strings.Join(api.Info.Messages, " ")
wrappedMessage := fmtutil.Wrap(serverMessage, "", 80)
var coloredMessage string
for _, line := range strings.Split(wrappedMessage, "\n") {
coloredMessage += "{s-}" + line + "{!}\n"
}
fmtc.NewLine()
fmtc.Println(coloredMessage)
}
// renderMethod print method info to console
func renderMethod(m *Method, showExamples bool) {
fmtc.Printf("{s-}%4d:{!} {b*}%s{!} {s}-{!} %s\n", m.Line, m.Name, m.UnitedDesc())
if len(m.Arguments) != 0 {
fmtc.NewLine()
for _, a := range m.Arguments {
switch {
case a.IsOptional:
fmtc.Printf(" {s-}%2s.{!} %s "+getVarTypeDesc(a.Type)+" {s-}[Optional]{!}\n", a.Index, a.Desc)
case a.IsWildcard:
fmtc.Printf(" {s-}%2s.{!} %s\n", a.Index, a.Desc)
default:
fmtc.Printf(" {s-}%2s.{!} %s "+getVarTypeDesc(a.Type)+"\n", a.Index, a.Desc)
}
}
}
if m.ResultCode {
fmtc.NewLine()
fmtc.Printf(" {*}Code:{!} 0 - ok, 1 - not ok\n")
}
if m.ResultEcho != nil {
fmtc.NewLine()
fmtc.Printf(" {*}Echo:{!} %s "+getVarTypeDesc(m.ResultEcho.Type)+"\n", strings.Join(m.ResultEcho.Desc, " "))
}
if m.Example != nil && showExamples {
fmtc.NewLine()
fmtc.Println(" {*}Example:{!}")
fmtc.NewLine()
for _, l := range m.Example {
fmtc.Printf(" %s\n", l)
}
}
}
// printDetailedInfo fetch and print detailed info for all endpoints
func printDetailedInfo(ap *sslscan.AnalyzeProgress, info *sslscan.AnalyzeInfo) {
showHeaders := len(info.Endpoints) > 1
if showHeaders {
fmtc.NewLine()
}
for index, endpoint := range info.Endpoints {
if showHeaders {
fmtc.Printf("\n{c} %s #%d (%s){!}\n\n", info.Host, index+1, endpoint.IPAdress)
}
printDetailedEndpointInfo(ap, endpoint.IPAdress)
}
}
// Render print usage info to console
func (info *Info) Render() {
usageMessage := "\n{*}Usage:{!} " + info.name
if len(info.commands) != 0 {
usageMessage += " " + CommandsColorTag + "{command}{!}"
}
if len(info.options) != 0 {
usageMessage += " " + OptionsColorTag + "{options}{!}"
}
if info.args != "" {
usageMessage += " " + info.args
}
fmtc.Println(usageMessage)
if info.spoiler != "" {
fmtc.NewLine()
fmtc.Println(info.spoiler)
}
if len(info.commands) != 0 {
renderOptions(info.commands, CommandsColorTag)
}
if len(info.options) != 0 {
renderOptions(info.options, OptionsColorTag)
}
if len(info.examples) != 0 {
renderExamples(info)
}
fmtc.NewLine()
}
// renderExamples render examples
func renderExamples(info *Info) {
printGroupHeader("Examples")
total := len(info.examples)
for index, example := range info.examples {
fmtc.Printf(" %s %s\n", info.name, example.cmd)
if example.desc != "" {
fmtc.Printf(" {s-}%s{!}\n", example.desc)
}
if index < total-1 {
fmtc.NewLine()
}
}
}
