func (mi *MfgImage) loadRawEntry(
entryIdx int, rawEntry map[string]string) (MfgRawEntry, error) {
raw := MfgRawEntry{}
var err error
deviceStr := rawEntry["device"]
if deviceStr == "" {
return raw, mi.loadError(
"raw entry %d missing required \"device\" field", entryIdx)
}
raw.device, err = util.AtoiNoOct(deviceStr)
if err != nil {
return raw, mi.loadError(
"raw entry %d contains invalid offset: %s", entryIdx, deviceStr)
}
offsetStr := rawEntry["offset"]
if offsetStr == "" {
return raw, mi.loadError(
"raw entry %d missing required \"offset\" field", entryIdx)
}
raw.offset, err = util.AtoiNoOct(offsetStr)
if err != nil {
return raw, mi.loadError(
"raw entry %d contains invalid offset: %s", entryIdx, offsetStr)
}
raw.filename = rawEntry["file"]
if raw.filename == "" {
return raw, mi.loadError(
"raw entry %d missing required \"file\" field", entryIdx)
}
if !strings.HasPrefix(raw.filename, "/") {
raw.filename = mi.basePkg.BasePath() + "/" + raw.filename
}
raw.data, err = ioutil.ReadFile(raw.filename)
if err != nil {
return raw, mi.loadError(
"error loading file for raw entry %d; filename=%s: %s",
entryIdx, raw.filename, err.Error())
}
return raw, nil
}
func targetSyscfgKVFromStr(str string) (map[string]string, error) {
vals := map[string]string{}
if strings.TrimSpace(str) == "" {
return vals, nil
}
// Separate syscfg vals are delimited by ':'.
fields := strings.Split(str, ":")
// Key-value pairs are delimited by '='. If no '=' is present, assume the
// string is the key name and the value is 1.
for _, f := range fields {
if _, err := util.AtoiNoOct(f); err == nil {
return nil, util.FmtNewtError(
"Invalid setting name \"%s\"; must not be a number", f)
}
kv := strings.SplitN(f, "=", 2)
switch len(kv) {
case 1:
vals[f] = "1"
case 2:
vals[kv[0]] = kv[1]
}
}
return vals, nil
}
func ValueIsTrue(val string) bool {
if val == "" {
return false
}
i, err := util.AtoiNoOct(val)
if err == nil && i == 0 {
return false
}
return true
}
func parseSize(val string) (int, error) {
lower := strings.ToLower(val)
multiplier := 1
if strings.HasSuffix(lower, "kb") {
multiplier = 1024
lower = strings.TrimSuffix(lower, "kb")
}
num, err := util.AtoiNoOct(lower)
if err != nil {
return 0, err
}
return num * multiplier, nil
}
func parseFlashArea(
name string, ymlFields map[string]interface{}) (FlashArea, error) {
area := FlashArea{
Name: name,
}
idPresent := false
devicePresent := false
offsetPresent := false
sizePresent := false
var isSystem bool
area.Id, isSystem = SYSTEM_AREA_NAME_ID_MAP[name]
var err error
fields := cast.ToStringMapString(ymlFields)
for k, v := range fields {
switch k {
case "user_id":
if isSystem {
return area, flashAreaErr(name,
"system areas cannot specify a user ID")
}
userId, err := util.AtoiNoOct(v)
if err != nil {
return area, flashAreaErr(name, "invalid user id: %s", v)
}
area.Id = userId + AREA_USER_ID_MIN
idPresent = true
case "device":
area.Device, err = util.AtoiNoOct(v)
if err != nil {
return area, flashAreaErr(name, "invalid device: %s", v)
}
devicePresent = true
case "offset":
area.Offset, err = util.AtoiNoOct(v)
if err != nil {
return area, flashAreaErr(name, "invalid offset: %s", v)
}
offsetPresent = true
case "size":
area.Size, err = parseSize(v)
if err != nil {
return area, flashAreaErr(name, err.Error())
}
sizePresent = true
default:
util.StatusMessage(util.VERBOSITY_QUIET,
"Warning: flash area \"%s\" contains unrecognized field: %s",
name, k)
}
}
if !isSystem && !idPresent {
return area, flashAreaErr(name, "required field \"user_id\" missing")
}
if !devicePresent {
return area, flashAreaErr(name, "required field \"device\" missing")
}
if !offsetPresent {
return area, flashAreaErr(name, "required field \"offset\" missing")
}
if !sizePresent {
return area, flashAreaErr(name, "required field \"size\" missing")
}
return area, nil
}
func calcPriorities(cfg Cfg, settingType CfgSettingType, max int,
allowDups bool) error {
// setting-name => entry
anyEntries := map[string]CfgEntry{}
// priority-value => entry
valEntries := map[int]CfgEntry{}
for name, entry := range cfg.Settings {
if entry.SettingType == settingType {
if entry.Value == SYSCFG_PRIO_ANY {
anyEntries[name] = entry
} else {
prio, err := util.AtoiNoOct(entry.Value)
if err != nil {
return util.FmtNewtError(
"invalid priority value: setting=%s value=%s pkg=%s",
name, entry.Value, entry.History[0].Name())
}
if prio > max {
return util.FmtNewtError(
"invalid priority value: value too great (> %d); "+
"setting=%s value=%s pkg=%s",
max, entry.Name, entry.Value,
mostRecentPoint(entry).Name())
}
if !allowDups {
if oldEntry, ok := valEntries[prio]; ok {
return util.FmtNewtError(
"duplicate priority value: setting1=%s "+
"setting2=%s pkg1=%s pkg2=%s value=%s",
oldEntry.Name, entry.Name, entry.Value,
oldEntry.History[0].Name(),
entry.History[0].Name())
}
}
valEntries[prio] = entry
}
}
}
greatest := 0
for prio, _ := range valEntries {
if prio > greatest {
greatest = prio
}
}
anyNames := make([]string, 0, len(anyEntries))
for name, _ := range anyEntries {
anyNames = append(anyNames, name)
}
sort.Strings(anyNames)
for _, name := range anyNames {
entry := anyEntries[name]
greatest++
if greatest > max {
return util.FmtNewtError("could not assign 'any' priority: "+
"value too great (> %d); setting=%s value=%s pkg=%s",
max, name, greatest,
mostRecentPoint(entry).Name())
}
entry.Value = strconv.Itoa(greatest)
cfg.Settings[name] = entry
}
return nil
}
