cpepattern.go

// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//  http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.  

package main

// Run with
// wget -O- -q http://scap.nist.gov/schema/cpe/2.3/cpe-naming_2.3.xsd | go run cpepattern.go

import (
	"encoding/xml"
	"flag"
	"fmt"
	"log"
	"os"
	"slices"
	"strings"
)

type restriction struct {
	XMLName xml.Name `xml:"restriction"`
	Pattern struct {
		XMLName xml.Name `xml:"pattern"`
		Value   string   `xml:"value,attr"`
	}
}

type simpleType struct {
	XMLName     xml.Name    `xml:"simpleType"`
	Name        string      `xml:"name,attr"`
	Restriction restriction `xml:"restriction"`
}

type schema struct {
	XMLName     xml.Name     `xml:"schema"`
	SimpleTypes []simpleType `xml:"simpleType"`
}

func main() {
	var noNames bool
	var combine string
	flag.BoolVar(&noNames, "nonames", false, "dont display names")
	flag.StringVar(&combine, "combine", "",
		`build an "^((A)|(B)|...)$"  combined pattern from the found patterns "A,B,..."`)
	flag.Parse()
	var schema schema
	dec := xml.NewDecoder(os.Stdin)
	if err := dec.Decode(&schema); err != nil {
		log.Fatalf("error: cannot decode schema: %v\n", err)
	}
	for i := range schema.SimpleTypes {
		st := &schema.SimpleTypes[i]
		if noNames {
			fmt.Printf("%q\n", st.Restriction.Pattern.Value)
		} else {
			fmt.Printf("%s: %q\n", st.Name, st.Restriction.Pattern.Value)
		}
	}
	if combine != "" {
		first := true
		var b strings.Builder
		b.WriteString(`^(`)
		for _, pattern := range strings.Split(combine, ",") {
			idx := slices.IndexFunc(schema.SimpleTypes, func(st simpleType) bool {
				return st.Name == pattern
			})
			if idx == -1 {
				log.Fatalf("error: cannot find pattern %q\n", pattern)
			}
			if !first {
				b.WriteByte('|')
			} else {
				first = false
			}
			b.WriteByte('(')
			b.WriteString(schema.SimpleTypes[idx].Restriction.Pattern.Value)
			b.WriteByte(')')
		}
		b.WriteString(")$")
		if noNames {
			fmt.Printf("%q\n", b.String())
		} else {
			fmt.Printf("combine: %q\n", b.String())
		}
	}
}