Home | History | Annotate | Download | only in pe 
      1 // Copyright 2016 The Go Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style
      3 // license that can be found in the LICENSE file.
      4 
      5 package pe
      6 
      7 import (
      8 	"encoding/binary"
      9 	"fmt"
     10 	"io"
     11 	"strconv"
     12 )
     13 
     14 // SectionHeader32 represents real PE COFF section header.
     15 type SectionHeader32 struct {
     16 	Name                 [8]uint8
     17 	VirtualSize          uint32
     18 	VirtualAddress       uint32
     19 	SizeOfRawData        uint32
     20 	PointerToRawData     uint32
     21 	PointerToRelocations uint32
     22 	PointerToLineNumbers uint32
     23 	NumberOfRelocations  uint16
     24 	NumberOfLineNumbers  uint16
     25 	Characteristics      uint32
     26 }
     27 
     28 // fullName finds real name of section sh. Normally name is stored
     29 // in sh.Name, but if it is longer then 8 characters, it is stored
     30 // in COFF string table st instead.
     31 func (sh *SectionHeader32) fullName(st StringTable) (string, error) {
     32 	if sh.Name[0] != '/' {
     33 		return cstring(sh.Name[:]), nil
     34 	}
     35 	i, err := strconv.Atoi(cstring(sh.Name[1:]))
     36 	if err != nil {
     37 		return "", err
     38 	}
     39 	return st.String(uint32(i))
     40 }
     41 
     42 // TODO(brainman): copy all IMAGE_REL_* consts from ldpe.go here
     43 
     44 // Reloc represents a PE COFF relocation.
     45 // Each section contains its own relocation list.
     46 type Reloc struct {
     47 	VirtualAddress   uint32
     48 	SymbolTableIndex uint32
     49 	Type             uint16
     50 }
     51 
     52 func readRelocs(sh *SectionHeader, r io.ReadSeeker) ([]Reloc, error) {
     53 	if sh.NumberOfRelocations <= 0 {
     54 		return nil, nil
     55 	}
     56 	_, err := r.Seek(int64(sh.PointerToRelocations), seekStart)
     57 	if err != nil {
     58 		return nil, fmt.Errorf("fail to seek to %q section relocations: %v", sh.Name, err)
     59 	}
     60 	relocs := make([]Reloc, sh.NumberOfRelocations)
     61 	err = binary.Read(r, binary.LittleEndian, relocs)
     62 	if err != nil {
     63 		return nil, fmt.Errorf("fail to read section relocations: %v", err)
     64 	}
     65 	return relocs, nil
     66 }
     67 
     68 // SectionHeader is similar to SectionHeader32 with Name
     69 // field replaced by Go string.
     70 type SectionHeader struct {
     71 	Name                 string
     72 	VirtualSize          uint32
     73 	VirtualAddress       uint32
     74 	Size                 uint32
     75 	Offset               uint32
     76 	PointerToRelocations uint32
     77 	PointerToLineNumbers uint32
     78 	NumberOfRelocations  uint16
     79 	NumberOfLineNumbers  uint16
     80 	Characteristics      uint32
     81 }
     82 
     83 // Section provides access to PE COFF section.
     84 type Section struct {
     85 	SectionHeader
     86 	Relocs []Reloc
     87 
     88 	// Embed ReaderAt for ReadAt method.
     89 	// Do not embed SectionReader directly
     90 	// to avoid having Read and Seek.
     91 	// If a client wants Read and Seek it must use
     92 	// Open() to avoid fighting over the seek offset
     93 	// with other clients.
     94 	io.ReaderAt
     95 	sr *io.SectionReader
     96 }
     97 
     98 // Data reads and returns the contents of the PE section s.
     99 func (s *Section) Data() ([]byte, error) {
    100 	dat := make([]byte, s.sr.Size())
    101 	n, err := s.sr.ReadAt(dat, 0)
    102 	if n == len(dat) {
    103 		err = nil
    104 	}
    105 	return dat[0:n], err
    106 }
    107 
    108 // Open returns a new ReadSeeker reading the PE section s.
    109 func (s *Section) Open() io.ReadSeeker {
    110 	return io.NewSectionReader(s.sr, 0, 1<<63-1)
    111 }
    112