mirror of
https://github.com/kata-containers/kata-containers.git
synced 2025-10-23 13:13:21 +00:00
The package has been deprecated as part of 1.16 and the same functionality is now provided by either the io or the os package. Signed-off-by: Fabiano Fidêncio <fabiano.fidencio@intel.com>
106 lines
1.7 KiB
Go
106 lines
1.7 KiB
Go
//
|
|
// Copyright (c) 2017-2018 Intel Corporation
|
|
//
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
//
|
|
|
|
package main
|
|
|
|
import (
|
|
"errors"
|
|
"io"
|
|
"os"
|
|
"strings"
|
|
)
|
|
|
|
// HexByteReader is an I/O Reader type.
|
|
type HexByteReader struct {
|
|
file string
|
|
f *os.File
|
|
data []byte
|
|
|
|
// total length of "data"
|
|
len int
|
|
|
|
// how much of "data" has been sent back to the caller
|
|
offset int
|
|
}
|
|
|
|
// NewHexByteReader returns a new hex byte reader that escapes all
|
|
// hex-encoded characters.
|
|
func NewHexByteReader(file string) *HexByteReader {
|
|
var f *os.File
|
|
|
|
// treat dash as an alias for standard input
|
|
if file == stdinFile {
|
|
f = os.Stdin
|
|
}
|
|
|
|
return &HexByteReader{
|
|
file: file,
|
|
f: f,
|
|
}
|
|
}
|
|
|
|
// Read is a Reader that converts "\x" to "\\x"
|
|
func (r *HexByteReader) Read(p []byte) (n int, err error) {
|
|
size := len(p)
|
|
|
|
if r.data == nil {
|
|
if r.f == nil {
|
|
r.f, err = os.Open(r.file)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
}
|
|
|
|
// read the entire file
|
|
bytes, err := io.ReadAll(r.f)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
// although logfmt is happy to parse an empty file, this is
|
|
// surprising to users, so make it an error.
|
|
if len(bytes) == 0 {
|
|
return 0, errors.New("file is empty")
|
|
}
|
|
|
|
// perform the conversion
|
|
s := string(bytes)
|
|
result := strings.Replace(s, `\x`, `\\x`, -1)
|
|
|
|
// store the data
|
|
r.data = []byte(result)
|
|
r.len = len(r.data)
|
|
r.offset = 0
|
|
}
|
|
|
|
// calculate how much data is left to copy
|
|
remaining := r.len - r.offset
|
|
|
|
if remaining == 0 {
|
|
return 0, io.EOF
|
|
}
|
|
|
|
// see how much data can be copied on this call
|
|
limit := size
|
|
|
|
if remaining < limit {
|
|
limit = remaining
|
|
}
|
|
|
|
for i := 0; i < limit; i++ {
|
|
// index into the stored data
|
|
src := r.offset
|
|
|
|
// copy
|
|
p[i] = r.data[src]
|
|
|
|
// update
|
|
r.offset++
|
|
}
|
|
|
|
return limit, nil
|
|
}
|