gitlab.science.ru.nl/irma/gomobile.git@v0.0.0-20200320223732-da812b634d1f/cmd/gomobile/binary_xml.go

// Copyright 2015 The Go Authors.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import (
	"encoding/xml"
	"fmt"
	"io"
	"sort"
	"strconv"
	"strings"
	"unicode/utf16"
)

// binaryXML converts XML into Android's undocumented binary XML format.
//
// The best source of information on this format seems to be the source code
// in AOSP frameworks-base. Android "resource" types seem to describe the
// encoded bytes, in particular:
//
//	ResChunk_header
//	ResStringPool_header
//	ResXMLTree_node
//
// These are defined in:
//
//	https://android.googlesource.com/platform/frameworks/base/+/master/include/androidfw/ResourceTypes.h
//
// The rough format of the file is a resource chunk containing a sequence of
// chunks. Each chunk is made up of a header and a body. The header begins with
// the contents of the ResChunk_header struct, which includes the size of both
// the header and the body.
//
// Both the header and body are 4-byte aligned.
//
// Values are encoded as little-endian.
//
// The android source code for encoding is done in the aapt tool. Its source
// code lives in AOSP:
//
//	https://android.googlesource.com/platform/frameworks/base.git/+/master/tools/aapt
//
// A sample layout:
//
//	File Header (ResChunk_header, type XML)
//	Chunk: String Pool (type STRING_POOL)
//	Sequence of strings, each with the format:
//		uint16 length
//		uint16 extended_length -- only if top bit set on length
//		UTF-16LE string
//		two zero bytes
//	Resource Map
//		The [i]th 4-byte entry in the resource map corresponds with
//		the [i]th string from the string pool. The 4-bytes are a
//		Resource ID constant defined:
//			http://developer.android.com/reference/android/R.attr.html
//		This appears to be a way to map strings onto enum values.
//	Chunk: Namespace Start (ResXMLTree_node; ResXMLTree_namespaceExt)
//	Chunk: Element Start
//		ResXMLTree_node
//		ResXMLTree_attrExt
//		ResXMLTree_attribute (repeated attributeCount times)
//	Chunk: Element End
//		(ResXMLTree_node; ResXMLTree_endElementExt)
//	...
//	Chunk: Namespace End
func binaryXML(r io.Reader) ([]byte, error) {
	lr := &lineReader{r: r}
	d := xml.NewDecoder(lr)

	pool := new(binStringPool)
	depth := 0
	elements := []chunk{}
	namespaceEnds := make(map[int][]binEndNamespace)

	for {
		line := lr.line(d.InputOffset())
		tok, err := d.Token()
		if err != nil {
			if err == io.EOF {
				break
			}
			return nil, err
		}
		switch tok := tok.(type) {
		case xml.StartElement:
			// uses-sdk is synthesized by the writer, disallow declaration in manifest.
			if tok.Name.Local == "uses-sdk" {
				return nil, fmt.Errorf("unsupported manifest tag <uses-sdk .../>")
			} else if tok.Name.Local == "application" {
				// synthesize <uses-sdk/> before handling <application> token
				attr := xml.Attr{
					Name: xml.Name{
						Space: "http://schemas.android.com/apk/res/android",
						Local: "minSdkVersion",
					},
					Value: "15",
				}
				ba, err := pool.getAttr(attr)
				if err != nil {
					return nil, fmt.Errorf("failed to synthesize attr minSdkVersion=\"15\"")
				}
				elements = append(elements,
					&binStartElement{
						line: line - 1, // current testing strategy is not friendly to synthesized tags, -1 for would-be location
						ns:   pool.getNS(""),
						name: pool.get("uses-sdk"),
						attr: []*binAttr{ba},
					},
					&binEndElement{
						line: line - 1,
						ns:   pool.getNS(""),
						name: pool.get("uses-sdk"),
					})
			}
			// Intercept namespace definitions.
			var attr []*binAttr
			for _, a := range tok.Attr {
				if a.Name.Space == "xmlns" {
					elements = append(elements, binStartNamespace{
						line:   line,
						prefix: pool.get(a.Name.Local),
						url:    pool.get(a.Value),
					})
					namespaceEnds[depth] = append([]binEndNamespace{{
						line:   line,
						prefix: pool.get(a.Name.Local),
						url:    pool.get(a.Value),
					}}, namespaceEnds[depth]...)
					continue
				}
				ba, err := pool.getAttr(a)
				if err != nil {
					return nil, fmt.Errorf("%d: %s: %v", line, a.Name.Local, err)
				}
				attr = append(attr, ba)
			}

			depth++
			elements = append(elements, &binStartElement{
				line: line,
				ns:   pool.getNS(tok.Name.Space),
				name: pool.get(tok.Name.Local),
				attr: attr,
			})
		case xml.EndElement:
			elements = append(elements, &binEndElement{
				line: line,
				ns:   pool.getNS(tok.Name.Space),
				name: pool.get(tok.Name.Local),
			})
			depth--
			if nsEnds := namespaceEnds[depth]; len(nsEnds) > 0 {
				delete(namespaceEnds, depth)
				for _, nsEnd := range nsEnds {
					elements = append(elements, nsEnd)
				}
			}
		case xml.CharData:
			// The aapt tool appears to "compact" leading and
			// trailing whitepsace. See XMLNode::removeWhitespace in
			// https://android.googlesource.com/platform/frameworks/base.git/+/master/tools/aapt/XMLNode.cpp
			if len(tok) == 0 {
				continue
			}
			start, end := 0, len(tok)
			for start < len(tok) && isSpace(tok[start]) {
				start++
			}
			for end > start && isSpace(tok[end-1]) {
				end--
			}
			if start == end {
				continue // all whitespace, skip it
			}

			// Preserve one character of whitespace.
			if start > 0 {
				start--
			}
			if end < len(tok) {
				end++
			}

			elements = append(elements, &binCharData{
				line: line,
				data: pool.get(string(tok[start:end])),
			})
		case xml.Comment:
			// Ignored by Anroid Binary XML format.
		case xml.ProcInst:
			// Ignored by Anroid Binary XML format?
		case xml.Directive:
			// Ignored by Anroid Binary XML format.
		default:
			return nil, fmt.Errorf("apk: unexpected token: %v (%T)", tok, tok)
		}
	}

	sortPool(pool)
	for _, e := range elements {
		if e, ok := e.(*binStartElement); ok {
			sortAttr(e, pool)
		}
	}

	resMap := &binResMap{pool}

	size := 8 + pool.size() + resMap.size()
	for _, e := range elements {
		size += e.size()
	}

	b := make([]byte, 0, size)
	b = appendHeader(b, headerXML, size)
	b = pool.append(b)
	b = resMap.append(b)
	for _, e := range elements {
		b = e.append(b)
	}

	return b, nil
}

func isSpace(b byte) bool {
	switch b {
	case '\t', '\n', '\v', '\f', '\r', ' ', 0x85, 0xA0:
		return true
	}
	return false
}

type headerType uint16

const (
	headerXML            headerType = 0x0003
	headerStringPool                = 0x0001
	headerResourceMap               = 0x0180
	headerStartNamespace            = 0x0100
	headerEndNamespace              = 0x0101
	headerStartElement              = 0x0102
	headerEndElement                = 0x0103
	headerCharData                  = 0x0104
)

func appendU16(b []byte, v uint16) []byte {
	return append(b, byte(v), byte(v>>8))
}

func appendU32(b []byte, v uint32) []byte {
	return append(b, byte(v), byte(v>>8), byte(v>>16), byte(v>>24))
}

func appendHeader(b []byte, typ headerType, size int) []byte {
	b = appendU16(b, uint16(typ))
	b = appendU16(b, 8)
	b = appendU16(b, uint16(size))
	b = appendU16(b, 0)
	return b
}

// Attributes of the form android:key are mapped to resource IDs, which are
// embedded into the Binary XML format.
//
// http://developer.android.com/reference/android/R.attr.html
var resourceCodes = map[string]uint32{
	"versionCode":       0x0101021b,
	"versionName":       0x0101021c,
	"minSdkVersion":     0x0101020c,
	"windowFullscreen":  0x0101020d,
	"theme":             0x01010000,
	"label":             0x01010001,
	"hasCode":           0x0101000c,
	"debuggable":        0x0101000f,
	"name":              0x01010003,
	"screenOrientation": 0x0101001e,
	"configChanges":     0x0101001f,
	"value":             0x01010024,
}

// http://developer.android.com/reference/android/R.attr.html#configChanges
var configChanges = map[string]uint32{
	"mcc":                0x0001,
	"mnc":                0x0002,
	"locale":             0x0004,
	"touchscreen":        0x0008,
	"keyboard":           0x0010,
	"keyboardHidden":     0x0020,
	"navigation":         0x0040,
	"orientation":        0x0080,
	"screenLayout":       0x0100,
	"uiMode":             0x0200,
	"screenSize":         0x0400,
	"smallestScreenSize": 0x0800,
	"layoutDirection":    0x2000,
	"fontScale":          0x40000000,
}

// http://developer.android.com/reference/android/R.attr.html#screenOrientation
var screenOrientation = map[string]int{
	"unspecified":      -1,
	"landscape":        0,
	"portrait":         1,
	"user":             2,
	"behind":           3,
	"sensor":           4,
	"nosensor":         5,
	"sensorLandscape":  6,
	"sensorPortrait":   7,
	"reverseLandscape": 8,
	"reversePortrait":  9,
	"fullSensor":       10,
	"userLandscape":    11,
	"userPortrait":     12,
	"fullUser":         13,
	"locked":           14,
}

// reference is an alias used to write out correct type in bin.
type reference uint32

// http://developer.android.com/reference/android/R.style.html
var theme = map[string]reference{
	"Theme":                                   0x01030005,
	"Theme_NoTitleBar":                        0x01030006,
	"Theme_NoTitleBar_Fullscreen":             0x01030007,
	"Theme_Black":                             0x01030008,
	"Theme_Black_NoTitleBar":                  0x01030009,
	"Theme_Black_NoTitleBar_Fullscreen":       0x0103000a,
	"Theme_Light":                             0x0103000c,
	"Theme_Light_NoTitleBar":                  0x0103000d,
	"Theme_Light_NoTitleBar_Fullscreen":       0x0103000e,
	"Theme_Translucent":                       0x0103000f,
	"Theme_Translucent_NoTitleBar":            0x01030010,
	"Theme_Translucent_NoTitleBar_Fullscreen": 0x01030011,
}

type lineReader struct {
	off   int64
	lines []int64
	r     io.Reader
}

func (r *lineReader) Read(p []byte) (n int, err error) {
	n, err = r.r.Read(p)
	for i := 0; i < n; i++ {
		if p[i] == '\n' {
			r.lines = append(r.lines, r.off+int64(i))
		}
	}
	r.off += int64(n)
	return n, err
}

func (r *lineReader) line(pos int64) int {
	return sort.Search(len(r.lines), func(i int) bool {
		return pos < r.lines[i]
	}) + 1
}

type bstring struct {
	ind uint32
	str string
	enc []byte // 2-byte length, utf16le, 2-byte zero
}

type chunk interface {
	size() int
	append([]byte) []byte
}

type binResMap struct {
	pool *binStringPool
}

func (p *binResMap) append(b []byte) []byte {
	b = appendHeader(b, headerResourceMap, p.size())
	for _, bstr := range p.pool.s {
		c, ok := resourceCodes[bstr.str]
		if !ok {
			break
		}
		b = appendU32(b, c)
	}
	return b
}

func (p *binResMap) size() int {
	count := 0
	for _, bstr := range p.pool.s {
		if _, ok := resourceCodes[bstr.str]; !ok {
			break
		}
		count++
	}
	return 8 + 4*count
}

type binStringPool struct {
	s []*bstring
	m map[string]*bstring
}

func (p *binStringPool) get(str string) *bstring {
	if p.m == nil {
		p.m = make(map[string]*bstring)
	}
	res := p.m[str]
	if res != nil {
		return res
	}
	res = &bstring{
		ind: uint32(len(p.s)),
		str: str,
	}
	p.s = append(p.s, res)
	p.m[str] = res

	if len(str)>>16 > 0 {
		panic(fmt.Sprintf("string lengths over 1<<15 not yet supported, got len %d for string that starts %q", len(str), str[:100]))
	}
	strUTF16 := utf16.Encode([]rune(str))
	res.enc = appendU16(nil, uint16(len(strUTF16)))
	for _, w := range strUTF16 {
		res.enc = appendU16(res.enc, w)
	}
	res.enc = appendU16(res.enc, 0)
	return res
}

func (p *binStringPool) getNS(ns string) *bstring {
	if ns == "" {
		// Register empty string for inclusion in output (like aapt),
		// but do not reference it from namespace elements.
		p.get("")
		return nil
	}
	return p.get(ns)
}

func (p *binStringPool) getAttr(attr xml.Attr) (*binAttr, error) {
	a := &binAttr{
		ns:   p.getNS(attr.Name.Space),
		name: p.get(attr.Name.Local),
	}
	if attr.Name.Space != "http://schemas.android.com/apk/res/android" {
		a.data = p.get(attr.Value)
		return a, nil
	}

	// Some android attributes have interesting values.
	switch attr.Name.Local {
	case "versionCode", "minSdkVersion":
		v, err := strconv.Atoi(attr.Value)
		if err != nil {
			return nil, err
		}
		a.data = int(v)
	case "hasCode", "debuggable":
		v, err := strconv.ParseBool(attr.Value)
		if err != nil {
			return nil, err
		}
		a.data = v
	case "configChanges":
		v := uint32(0)
		for _, c := range strings.Split(attr.Value, "|") {
			v |= configChanges[c]
		}
		a.data = v
	case "screenOrientation":
		v := 0
		for _, c := range strings.Split(attr.Value, "|") {
			v |= screenOrientation[c]
		}
		a.data = v
	case "theme":
		v := attr.Value
		// strip prefix if present as only platform themes are supported
		if idx := strings.Index(attr.Value, "/"); idx != -1 {
			v = v[idx+1:]
		}
		v = strings.Replace(v, ".", "_", -1)
		a.data = theme[v]
	default:
		a.data = p.get(attr.Value)
	}
	return a, nil
}

const stringPoolPreamble = 0 +
	8 + // chunk header
	4 + // string count
	4 + // style count
	4 + // flags
	4 + // strings start
	4 + // styles start
	0

func (p *binStringPool) unpaddedSize() int {
	strLens := 0
	for _, s := range p.s {
		strLens += len(s.enc)
	}
	return stringPoolPreamble + 4*len(p.s) + strLens
}

func (p *binStringPool) size() int {
	size := p.unpaddedSize()
	size += size % 0x04
	return size
}

// overloaded for testing.
var (
	sortPool = func(p *binStringPool) {
		sort.Sort(p)

		// Move resourceCodes to the front.
		s := make([]*bstring, 0)
		m := make(map[string]*bstring)
		for str := range resourceCodes {
			bstr := p.m[str]
			if bstr == nil {
				continue
			}
			bstr.ind = uint32(len(s))
			s = append(s, bstr)
			m[str] = bstr
			delete(p.m, str)
		}
		for _, bstr := range p.m {
			bstr.ind = uint32(len(s))
			s = append(s, bstr)
		}
		p.s = s
		p.m = m
	}
	sortAttr = func(e *binStartElement, p *binStringPool) {}
)

func (b *binStringPool) Len() int           { return len(b.s) }
func (b *binStringPool) Less(i, j int) bool { return b.s[i].str < b.s[j].str }
func (b *binStringPool) Swap(i, j int) {
	b.s[i], b.s[j] = b.s[j], b.s[i]
	b.s[i].ind, b.s[j].ind = b.s[j].ind, b.s[i].ind
}

func (p *binStringPool) append(b []byte) []byte {
	stringsStart := uint32(stringPoolPreamble + 4*len(p.s))
	b = appendU16(b, uint16(headerStringPool))
	b = appendU16(b, 0x1c) // chunk header size
	b = appendU16(b, uint16(p.size()))
	b = appendU16(b, 0)
	b = appendU32(b, uint32(len(p.s)))
	b = appendU32(b, 0) // style count
	b = appendU32(b, 0) // flags
	b = appendU32(b, stringsStart)
	b = appendU32(b, 0) // styles start

	off := 0
	for _, bstr := range p.s {
		b = appendU32(b, uint32(off))
		off += len(bstr.enc)
	}
	for _, bstr := range p.s {
		b = append(b, bstr.enc...)
	}

	for i := p.unpaddedSize() % 0x04; i > 0; i-- {
		b = append(b, 0)
	}
	return b
}

type binStartElement struct {
	line int
	ns   *bstring
	name *bstring
	attr []*binAttr
}

func (e *binStartElement) size() int {
	return 8 + // chunk header
		4 + // line number
		4 + // comment
		4 + // ns
		4 + // name
		2 + 2 + 2 + // attribute start, size, count
		2 + 2 + 2 + // id/class/style index
		len(e.attr)*(4+4+4+4+4)
}

func (e *binStartElement) append(b []byte) []byte {
	b = appendU16(b, uint16(headerStartElement))
	b = appendU16(b, 0x10) // chunk header size
	b = appendU16(b, uint16(e.size()))
	b = appendU16(b, 0)
	b = appendU32(b, uint32(e.line))
	b = appendU32(b, 0xffffffff) // comment
	if e.ns == nil {
		b = appendU32(b, 0xffffffff)
	} else {
		b = appendU32(b, e.ns.ind)
	}
	b = appendU32(b, e.name.ind)
	b = appendU16(b, 0x14) // attribute start
	b = appendU16(b, 0x14) // attribute size
	b = appendU16(b, uint16(len(e.attr)))
	b = appendU16(b, 0) // ID index (none)
	b = appendU16(b, 0) // class index (none)
	b = appendU16(b, 0) // style index (none)
	for _, a := range e.attr {
		b = a.append(b)
	}
	return b
}

type binAttr struct {
	ns   *bstring
	name *bstring
	data interface{} // either int (INT_DEC) or *bstring (STRING)
}

func (a *binAttr) append(b []byte) []byte {
	if a.ns != nil {
		b = appendU32(b, a.ns.ind)
	} else {
		b = appendU32(b, 0xffffffff)
	}
	b = appendU32(b, a.name.ind)
	switch v := a.data.(type) {
	case int:
		b = appendU32(b, 0xffffffff) // raw value
		b = appendU16(b, 8)          // size
		b = append(b, 0)             // unused padding
		b = append(b, 0x10)          // INT_DEC
		b = appendU32(b, uint32(v))
	case bool:
		b = appendU32(b, 0xffffffff) // raw value
		b = appendU16(b, 8)          // size
		b = append(b, 0)             // unused padding
		b = append(b, 0x12)          // INT_BOOLEAN
		if v {
			b = appendU32(b, 0xffffffff)
		} else {
			b = appendU32(b, 0)
		}
	case uint32:
		b = appendU32(b, 0xffffffff) // raw value
		b = appendU16(b, 8)          // size
		b = append(b, 0)             // unused padding
		b = append(b, 0x11)          // INT_HEX
		b = appendU32(b, uint32(v))
	case reference:
		b = appendU32(b, 0xffffffff) // raw value
		b = appendU16(b, 8)          // size
		b = append(b, 0)             // unused padding
		b = append(b, 0x01)          // REFERENCE
		b = appendU32(b, uint32(v))
	case *bstring:
		b = appendU32(b, v.ind) // raw value
		b = appendU16(b, 8)     // size
		b = append(b, 0)        // unused padding
		b = append(b, 0x03)     // STRING
		b = appendU32(b, v.ind)
	default:
		panic(fmt.Sprintf("unexpected attr type: %T (%v)", v, v))
	}
	return b
}

type binEndElement struct {
	line int
	ns   *bstring
	name *bstring
	attr []*binAttr
}

func (*binEndElement) size() int {
	return 8 + // chunk header
		4 + // line number
		4 + // comment
		4 + // ns
		4 // name
}

func (e *binEndElement) append(b []byte) []byte {
	b = appendU16(b, uint16(headerEndElement))
	b = appendU16(b, 0x10) // chunk header size
	b = appendU16(b, uint16(e.size()))
	b = appendU16(b, 0)
	b = appendU32(b, uint32(e.line))
	b = appendU32(b, 0xffffffff) // comment
	if e.ns == nil {
		b = appendU32(b, 0xffffffff)
	} else {
		b = appendU32(b, e.ns.ind)
	}
	b = appendU32(b, e.name.ind)
	return b
}

type binStartNamespace struct {
	line   int
	prefix *bstring
	url    *bstring
}

func (binStartNamespace) size() int {
	return 8 + // chunk header
		4 + // line number
		4 + // comment
		4 + // prefix
		4 // url
}

func (e binStartNamespace) append(b []byte) []byte {
	b = appendU16(b, uint16(headerStartNamespace))
	b = appendU16(b, 0x10) // chunk header size
	b = appendU16(b, uint16(e.size()))
	b = appendU16(b, 0)
	b = appendU32(b, uint32(e.line))
	b = appendU32(b, 0xffffffff) // comment
	b = appendU32(b, e.prefix.ind)
	b = appendU32(b, e.url.ind)
	return b
}

type binEndNamespace struct {
	line   int
	prefix *bstring
	url    *bstring
}

func (binEndNamespace) size() int {
	return 8 + // chunk header
		4 + // line number
		4 + // comment
		4 + // prefix
		4 // url
}

func (e binEndNamespace) append(b []byte) []byte {
	b = appendU16(b, uint16(headerEndNamespace))
	b = appendU16(b, 0x10) // chunk header size
	b = appendU16(b, uint16(e.size()))
	b = appendU16(b, 0)
	b = appendU32(b, uint32(e.line))
	b = appendU32(b, 0xffffffff) // comment
	b = appendU32(b, e.prefix.ind)
	b = appendU32(b, e.url.ind)
	return b
}

type binCharData struct {
	line int
	data *bstring
}

func (*binCharData) size() int {
	return 8 + // chunk header
		4 + // line number
		4 + // comment
		4 + // data
		8 // junk
}

func (e *binCharData) append(b []byte) []byte {
	b = appendU16(b, uint16(headerCharData))
	b = appendU16(b, 0x10) // chunk header size
	b = appendU16(b, 0x1c) // size
	b = appendU16(b, 0)
	b = appendU32(b, uint32(e.line))
	b = appendU32(b, 0xffffffff) // comment
	b = appendU32(b, e.data.ind)
	b = appendU16(b, 0x08)
	b = appendU16(b, 0)
	b = appendU16(b, 0)
	b = appendU16(b, 0)
	return b
}