internal/binres: provide decoding of resources.arsc in platform sdk

This decodes enough information to allow validation of resource
names but not their values, though a simple method for querying
does not yet exist.

Change-Id: I32023f3de0eda390b12d5c1df6c06202ee4d0778
Reviewed-on: https://go-review.googlesource.com/18055
Reviewed-by: David Crawshaw <crawshaw@golang.org>
This commit is contained in:
Daniel Skinner 2015-12-19 11:30:21 -06:00 committed by David Crawshaw
parent d6f00813f9
commit cc29d844e9
5 changed files with 345 additions and 146 deletions

View File

@ -50,6 +50,19 @@ import (
"fmt"
)
type ErrWrongType struct {
have ResType
want []ResType
}
func errWrongType(have ResType, want ...ResType) ErrWrongType {
return ErrWrongType{have, want}
}
func (err ErrWrongType) Error() string {
return fmt.Sprintf("wrong resource type %s, want one of %v", err.have, err.want)
}
type ResType uint16
func (t ResType) IsSupported() bool {
@ -59,7 +72,8 @@ func (t ResType) IsSupported() bool {
t == ResXMLStartElement || t == ResXMLEndElement ||
t == ResXMLCharData ||
t == ResXMLResourceMap ||
t == ResTable || t == ResTablePackage
t == ResTable || t == ResTablePackage ||
t == ResTableTypeSpec || t == ResTableType
}
// explicitly defined for clarity and resolvability with apt source
@ -80,6 +94,7 @@ const (
ResTablePackage ResType = 0x0200
ResTableType ResType = 0x0201
ResTableTypeSpec ResType = 0x0202
ResTableLibrary ResType = 0x0203
)
var (
@ -133,6 +148,7 @@ func (hdr chunkHeader) MarshalBinary() ([]byte, error) {
if !hdr.typ.IsSupported() {
return nil, fmt.Errorf("%s not supported", hdr.typ)
}
bin := make([]byte, 8)
putu16(bin, uint16(hdr.typ))
putu16(bin[2:], hdr.headerByteSize)

View File

@ -8,14 +8,14 @@ const (
_ResType_name_0 = "ResNullResStringPoolResTableResXML"
_ResType_name_1 = "ResXMLStartNamespaceResXMLEndNamespaceResXMLStartElementResXMLEndElementResXMLCharData"
_ResType_name_2 = "ResXMLResourceMap"
_ResType_name_3 = "ResTablePackageResTableTypeResTableTypeSpec"
_ResType_name_3 = "ResTablePackageResTableTypeResTableTypeSpecResTableLibrary"
)
var (
_ResType_index_0 = [...]uint8{7, 20, 28, 34}
_ResType_index_1 = [...]uint8{20, 38, 56, 72, 86}
_ResType_index_2 = [...]uint8{17}
_ResType_index_3 = [...]uint8{15, 27, 43}
_ResType_index_3 = [...]uint8{15, 27, 43, 58}
)
func (i ResType) String() string {
@ -35,7 +35,7 @@ func (i ResType) String() string {
return _ResType_name_1[lo:_ResType_index_1[i]]
case i == 384:
return _ResType_name_2
case 512 <= i && i <= 514:
case 512 <= i && i <= 515:
i -= 512
lo := uint8(0)
if i > 0 {

View File

@ -5,7 +5,6 @@
package binres
import (
"archive/zip"
"bytes"
"encoding"
"encoding/xml"
@ -15,6 +14,7 @@ import (
"log"
"math"
"os"
"path"
"sort"
"strings"
"testing"
@ -146,11 +146,11 @@ func retset(xs []string) []string {
return fo
}
type ByNamespace []xml.Attr
type byNamespace []xml.Attr
func (a ByNamespace) Len() int { return len(a) }
func (a ByNamespace) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a ByNamespace) Less(i, j int) bool {
func (a byNamespace) Len() int { return len(a) }
func (a byNamespace) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a byNamespace) Less(i, j int) bool {
if a[j].Name.Space == "" {
return a[i].Name.Space != ""
}
@ -191,18 +191,18 @@ func TestEncode(t *testing.T) {
Space: "",
Local: "platformBuildVersionCode",
},
Value: "10",
Value: "15",
}
bvn := xml.Attr{
Name: xml.Name{
Space: "",
Local: "platformBuildVersionName",
},
Value: "2.3.3",
Value: "4.0.3",
}
attrs = append(attrs, bvc, bvn)
sort.Sort(ByNamespace(attrs))
sort.Sort(byNamespace(attrs))
var names, vals []string
for _, attr := range attrs {
if strings.HasSuffix(attr.Name.Space, "tools") {
@ -228,44 +228,41 @@ func TestEncode(t *testing.T) {
}
}
func TestAndroidJar(t *testing.T) {
zr, err := zip.OpenReader("/home/daniel/local/android-sdk/platforms/android-10/android.jar")
func TestOpenTable(t *testing.T) {
sdkdir := os.Getenv("ANDROID_HOME")
if sdkdir == "" {
t.Fatal("ANDROID_HOME env var not set")
}
tbl, err := OpenTable(path.Join(sdkdir, "platforms/android-15/android.jar"))
if err != nil {
t.Fatal(err)
}
defer zr.Close()
if len(tbl.pkgs) == 0 {
t.Fatal("failed to decode any resource packages")
}
buf := new(bytes.Buffer)
for _, f := range zr.File {
if f.Name == "resources.arsc" {
rc, err := f.Open()
if err != nil {
t.Fatal(err)
pkg := tbl.pkgs[0]
t.Log("package name:", pkg.name)
for i, x := range pkg.typePool.strings {
t.Logf("typePool[i=%v]: %s\n", i, x)
}
for i, spec := range pkg.specs {
t.Logf("spec[i=%v]: %v %q\n", i, spec.id, pkg.typePool.strings[spec.id-1])
for j, typ := range spec.types {
t.Logf("\ttype[i=%v]: %v\n", j, typ.id)
for k, nt := range typ.entries {
if nt == nil { // NoEntry
continue
}
t.Logf("\t\tentry[i=%v]: %v %q\n", k, nt.key, pkg.keyPool.strings[nt.key])
if k > 5 {
t.Logf("\t\t... truncating output")
break
}
}
_, err = io.Copy(buf, rc)
if err != nil {
t.Fatal(err)
}
rc.Close()
break
}
}
if buf.Len() == 0 {
t.Fatal("failed to read resources.arsc")
}
bin := buf.Bytes()
tbl := &Table{}
if err := tbl.UnmarshalBinary(bin); err != nil {
t.Fatal(err)
}
t.Logf("%+v\n", tbl.TableHeader)
t.Logf("%+v\n", tbl.pool.chunkHeader)
for i, x := range tbl.pool.strings[:10] {
t.Logf("pool(%v) %s\n", i, x)
}
t.Logf("%+v\n", tbl.pkg)
}

View File

@ -1,101 +0,0 @@
// 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 binres
type TableHeader struct {
chunkHeader
packageCount uint32
}
func (hdr *TableHeader) UnmarshalBinary(bin []byte) error {
if err := (&hdr.chunkHeader).UnmarshalBinary(bin); err != nil {
return err
}
hdr.packageCount = btou32(bin[8:])
return nil
}
func (hdr TableHeader) MarshalBinary() ([]byte, error) {
bin := make([]byte, 12)
b, err := hdr.chunkHeader.MarshalBinary()
if err != nil {
return nil, err
}
copy(bin, b)
putu32(b[8:], hdr.packageCount)
return bin, nil
}
// TODO next up: package chunk
// https://justanapplication.wordpress.com/2011/09/16/
type Table struct {
TableHeader
pool *Pool
pkg *Package
}
func (tbl *Table) UnmarshalBinary(bin []byte) error {
buf := bin
if err := (&tbl.TableHeader).UnmarshalBinary(buf); err != nil {
return err
}
buf = buf[tbl.headerByteSize:]
tbl.pool = new(Pool)
if err := tbl.pool.UnmarshalBinary(buf); err != nil {
return err
}
buf = buf[tbl.pool.size():]
tbl.pkg = new(Package)
if err := tbl.pkg.UnmarshalBinary(buf); err != nil {
return err
}
return nil
}
type Package struct {
chunkHeader
// If this is a base package, its ID. Package IDs start
// at 1 (corresponding to the value of the package bits in a
// resource identifier). 0 means this is not a base package.
id uint32
// name of package, zero terminated
name [128]uint16
// Offset to a ResStringPool_header defining the resource
// type symbol table. If zero, this package is inheriting from
// another base package (overriding specific values in it).
typeStrings uint32
// Last index into typeStrings that is for public use by others.
lastPublicType uint32
// Offset to a ResStringPool_header defining the resource
// key symbol table. If zero, this package is inheriting from
// another base package (overriding specific values in it).
keyStrings uint32
// Last index into keyStrings that is for public use by others.
lastPublicKey uint32
typeIdOffset uint32
}
func (pkg *Package) UnmarshalBinary(bin []byte) error {
if err := (&pkg.chunkHeader).UnmarshalBinary(bin); err != nil {
return err
}
pkg.id = btou32(bin[8:])
for i := range pkg.name {
pkg.name[i] = btou16(bin[12+i*2:])
}
pkg.typeStrings = btou32(bin[140:])
pkg.lastPublicType = btou32(bin[144:])
pkg.keyStrings = btou32(bin[148:])
pkg.lastPublicKey = btou32(bin[152:])
pkg.typeIdOffset = btou32(bin[156:])
return nil
}

287
internal/binres/table.go Normal file
View File

@ -0,0 +1,287 @@
// 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 binres
import (
"archive/zip"
"bytes"
"fmt"
"io"
"unicode/utf16"
)
const NoEntry = 0xFFFFFFFF
// TableRef uniquely identifies entries within a resource table.
type TableRef uint32
// Table is a container for packaged resources. Resource values within a package
// are obtained through pool while resource names and identifiers are obtained
// through each package's type and key pools respectively.
//
// TODO provide method for querying resource types.
type Table struct {
chunkHeader
pool *Pool
pkgs []*Package
}
// OpenTable decodes resources.arsc from an sdk platform jar.
func OpenTable(path string) (*Table, error) {
zr, err := zip.OpenReader(path)
if err != nil {
return nil, err
}
defer zr.Close()
buf := new(bytes.Buffer)
for _, f := range zr.File {
if f.Name == "resources.arsc" {
rc, err := f.Open()
if err != nil {
return nil, err
}
_, err = io.Copy(buf, rc)
if err != nil {
return nil, err
}
rc.Close()
break
}
}
if buf.Len() == 0 {
return nil, fmt.Errorf("failed to read resources.arsc")
}
tbl := new(Table)
if err := tbl.UnmarshalBinary(buf.Bytes()); err != nil {
return nil, err
}
return tbl, nil
}
func (tbl *Table) UnmarshalBinary(bin []byte) error {
if err := (&tbl.chunkHeader).UnmarshalBinary(bin); err != nil {
return err
}
if tbl.typ != ResTable {
return fmt.Errorf("unexpected resource type %s, want %s", tbl.typ, ResTable)
}
npkgs := btou32(bin[8:])
tbl.pkgs = make([]*Package, npkgs)
buf := bin[tbl.headerByteSize:]
tbl.pool = new(Pool)
if err := tbl.pool.UnmarshalBinary(buf); err != nil {
return err
}
buf = buf[tbl.pool.size():]
for i := range tbl.pkgs {
pkg := new(Package)
if err := pkg.UnmarshalBinary(buf); err != nil {
return err
}
tbl.pkgs[i] = pkg
buf = buf[pkg.byteSize:]
}
return nil
}
// Package contains a collection of resource data types.
type Package struct {
chunkHeader
id uint32
name string
lastPublicType uint32 // last index into typePool that is for public use
lastPublicKey uint32 // last index into keyPool that is for public use
typePool *Pool // type names; e.g. theme
keyPool *Pool // resource names; e.g. Theme.NoTitleBar
specs []*TypeSpec
}
func (pkg *Package) UnmarshalBinary(bin []byte) error {
if err := (&pkg.chunkHeader).UnmarshalBinary(bin); err != nil {
return err
}
if pkg.typ != ResTablePackage {
return errWrongType(pkg.typ, ResTablePackage)
}
pkg.id = btou32(bin[8:])
var name []uint16
for i := 0; i < 128; i++ {
x := btou16(bin[12+i*2:])
if x == 0 {
break
}
name = append(name, x)
}
pkg.name = string(utf16.Decode(name))
typeOffset := btou32(bin[268:]) // 0 if inheriting from another package
pkg.lastPublicType = btou32(bin[272:])
keyOffset := btou32(bin[276:]) // 0 if inheriting from another package
pkg.lastPublicKey = btou32(bin[280:])
var idOffset uint32 // value determined by either typePool or keyPool below
if typeOffset != 0 {
pkg.typePool = new(Pool)
if err := pkg.typePool.UnmarshalBinary(bin[typeOffset:]); err != nil {
return err
}
idOffset = typeOffset + pkg.typePool.byteSize
}
if keyOffset != 0 {
pkg.keyPool = new(Pool)
if err := pkg.keyPool.UnmarshalBinary(bin[keyOffset:]); err != nil {
return err
}
idOffset = keyOffset + pkg.keyPool.byteSize
}
if idOffset == 0 {
return nil
}
buf := bin[idOffset:]
for len(pkg.specs) < len(pkg.typePool.strings) {
t := ResType(btou16(buf))
switch t {
case ResTableTypeSpec:
spec := new(TypeSpec)
if err := spec.UnmarshalBinary(buf); err != nil {
return err
}
pkg.specs = append(pkg.specs, spec)
buf = buf[spec.byteSize:]
case ResTableType:
typ := new(Type)
if err := typ.UnmarshalBinary(buf); err != nil {
return err
}
last := pkg.specs[len(pkg.specs)-1]
last.types = append(last.types, typ)
buf = buf[typ.byteSize:]
default:
return errWrongType(t, ResTableTypeSpec, ResTableType)
}
}
return nil
}
// TypeSpec provides a specification for the resources defined by a particular type.
type TypeSpec struct {
chunkHeader
id uint8 // id-1 is name index in Package.typePool
res0 uint8 // must be 0
res1 uint16 // must be 0
entryCount uint32 // number of uint32 entry configuration masks that follow
entries []uint32
types []*Type
}
func (spec *TypeSpec) UnmarshalBinary(bin []byte) error {
if err := (&spec.chunkHeader).UnmarshalBinary(bin); err != nil {
return err
}
if spec.typ != ResTableTypeSpec {
return errWrongType(spec.typ, ResTableTypeSpec)
}
spec.id = uint8(bin[8])
spec.res0 = uint8(bin[9])
spec.res1 = btou16(bin[10:])
spec.entryCount = btou32(bin[12:])
spec.entries = make([]uint32, spec.entryCount)
for i := range spec.entries {
spec.entries[i] = btou32(bin[16+i*4:])
}
return nil
}
type Type struct {
chunkHeader
id uint8
res0 uint8 // must be 0
res1 uint16 // must be 0
entryCount uint32 // number of uint32 entry configuration masks that follow
entriesStart uint32 // offset from header where Entry data starts
// TODO implement and decode Config if strictly necessary
// config Config // configuration this collection of entries is designed for
indices []uint32 // values that map to typePool
entries []*Entry
}
func (typ *Type) UnmarshalBinary(bin []byte) error {
if err := (&typ.chunkHeader).UnmarshalBinary(bin); err != nil {
return err
}
if typ.typ != ResTableType {
return errWrongType(typ.typ, ResTableType)
}
typ.id = uint8(bin[8])
typ.res0 = uint8(bin[9])
typ.res1 = btou16(bin[10:])
typ.entryCount = btou32(bin[12:])
typ.entriesStart = btou32(bin[16:])
if typ.res0 != 0 || typ.res1 != 0 {
return fmt.Errorf("res0 res1 not zero")
}
buf := bin[typ.headerByteSize:typ.entriesStart]
for len(buf) > 0 {
typ.indices = append(typ.indices, btou32(buf))
buf = buf[4:]
}
if len(typ.indices) != int(typ.entryCount) {
return fmt.Errorf("indices len[%v] doesn't match entryCount[%v]", len(typ.indices), typ.entryCount)
}
typ.entries = make([]*Entry, typ.entryCount)
for i, x := range typ.indices {
if x == NoEntry {
continue
}
nt := &Entry{}
if err := nt.UnmarshalBinary(bin[typ.entriesStart+x:]); err != nil {
return err
}
typ.entries[i] = nt
}
return nil
}
// Entry is a resource key typically followed by a value or resource map.
type Entry struct {
size uint16
flags uint16
key PoolRef // ref into key pool
}
func (nt *Entry) UnmarshalBinary(bin []byte) error {
nt.size = btou16(bin)
nt.flags = btou16(bin[2:])
nt.key = PoolRef(btou32(bin[4:]))
return nil
}