func CfgParse(data []byte) (*CfgJSON, error) {
var err error
- if bytes.Compare(data[:8], MagicNNCPBv3.B[:]) == 0 {
+ if bytes.Equal(data[:8], MagicNNCPBv3.B[:]) {
os.Stderr.WriteString("Passphrase:")
password, err := term.ReadPassword(0)
if err != nil {
if err != nil {
return nil, err
}
- } else if bytes.Compare(data[:8], MagicNNCPBv2.B[:]) == 0 {
+ } else if bytes.Equal(data[:8], MagicNNCPBv2.B[:]) {
log.Fatalln(MagicNNCPBv2.TooOld())
- } else if bytes.Compare(data[:8], MagicNNCPBv1.B[:]) == 0 {
+ } else if bytes.Equal(data[:8], MagicNNCPBv1.B[:]) {
log.Fatalln(MagicNNCPBv1.TooOld())
}
var cfgGeneral map[string]interface{}
); err != nil {
return false, err
}
- return bytes.Compare(hsh.Sum(nil), checksum) == 0, nil
+ return bytes.Equal(hsh.Sum(nil), checksum), nil
}
func (ctx *Ctx) checkXxIsBad(nodeId *NodeId, xx TRxTx) bool {
); err != nil {
return 0, err
}
- if bytes.Compare(mth.Sum(nil), hshValue[:]) == 0 {
+ if bytes.Equal(mth.Sum(nil), hshValue[:]) {
gut = true
}
}
log.Fatalln(err)
}
os.Stderr.WriteString("\n")
- if bytes.Compare(password1, password2) != 0 {
+ if !bytes.Equal(password1, password2) {
log.Fatalln(errors.New("Passphrases do not match"))
}
eblob, err := nncp.NewEBlob(*sOpt, *tOpt, *pOpt, password1, data)
log.Fatalln(err)
}
fd.Close()
- if bytes.Compare(hsh.Sum(nil), metaPkt.Checksums[chunkNum][:]) != 0 {
+ if !bytes.Equal(hsh.Sum(nil), metaPkt.Checksums[chunkNum][:]) {
ctx.LogE(
"reass-chunk",
nncp.LEs{{K: "Path", V: path}, {K: "Chunk", V: chunkNum}},
if _, err := mth.PreaddFrom(bytes.NewReader(data), "", false); err != nil {
panic(err)
}
- if bytes.Compare(hsh0, mth.Sum(nil)) != 0 {
+ if !bytes.Equal(hsh0, mth.Sum(nil)) {
return false
}
mth = MTHSeqNew(0, 0)
mth.Write(data)
- if bytes.Compare(hsh0, mth.Sum(nil)) != 0 {
+ if !bytes.Equal(hsh0, mth.Sum(nil)) {
return false
}
panic(err)
}
hsh00 := mth.Sum(nil)
- if bytes.Compare(hsh0, hsh00) == 0 {
+ if bytes.Equal(hsh0, hsh00) {
return false
}
if _, err := mth.PreaddFrom(bytes.NewReader(data), "", false); err != nil {
panic(err)
}
- if bytes.Compare(hsh00, mth.Sum(nil)) != 0 {
+ if !bytes.Equal(hsh00, mth.Sum(nil)) {
return false
}
mth = MTHSeqNew(0, 0)
mth.Write(data)
- if bytes.Compare(hsh00, mth.Sum(nil)) != 0 {
- return false
- }
-
- return true
+ return bytes.Equal(hsh00, mth.Sum(nil))
}
if err := quick.Check(f, nil); err != nil {
t.Error(err)
if _, err := io.Copy(seq, bytes.NewReader(data)); err != nil {
panic(err)
}
- return bytes.Compare(hshFat, seq.Sum(nil)) == 0
+ return bytes.Equal(hshFat, seq.Sum(nil))
}
if err := quick.Check(f, nil); err != nil {
t.Error(err)
if _, err := seq.Write(nil); err != nil {
t.Error(err)
}
- if bytes.Compare(hshFat, seq.Sum(nil)) != 0 {
+ if !bytes.Equal(hshFat, seq.Sum(nil)) {
t.FailNow()
}
}
if err != nil {
panic(err)
}
- if bytes.Compare(ct[:n], pt[:n]) != 0 {
+ if !bytes.Equal(ct[:n], pt[:n]) {
err = errors.New("wrong pad value")
return
}
}
var pktBuf bytes.Buffer
xdr.Marshal(&pktBuf, &pkt)
- return bytes.Compare(pt.Bytes(), append(pktBuf.Bytes(), data...)) == 0
+ return bytes.Equal(pt.Bytes(), append(pktBuf.Bytes(), data...))
}
if err := quick.Check(f, nil); err != nil {
t.Error(err)
if hasherAndOffset != nil {
delete(state.fileHashers, filePath)
if hasherAndOffset.mth.PreaddSize() == 0 {
- if bytes.Compare(hasherAndOffset.mth.Sum(nil), file.Hash[:]) != 0 {
+ if !bytes.Equal(hasherAndOffset.mth.Sum(nil), file.Hash[:]) {
state.Ctx.LogE(
"sp-file-bad-checksum", lesp,
errors.New("checksum mismatch"),
)
expected = append(expected, []byte("BODY\n")...)
}
- return bytes.Compare(mbox, expected) == 0
+ return bytes.Equal(mbox, expected)
}
if err := quick.Check(f, nil); err != nil {
t.Error(err)
if err != nil {
panic(err)
}
- if bytes.Compare(data, fileData) != 0 {
+ if !bytes.Equal(data, fileData) {
return false
}
}
if pkt.Nice != replyNice {
return false
}
- dst := string(pkt.Path[:int(pkt.PathLen)])
- if bytes.Compare(buf.Bytes(), files[dst]) != 0 {
+ if !bytes.Equal(buf.Bytes(), files[string(pkt.Path[:int(pkt.PathLen)])]) {
return false
}
}
panic(err)
}
for k, data := range datum {
- if bytes.Compare(dataRead, data) == 0 {
+ if bytes.Equal(dataRead, data) {
delete(datum, k)
}
}
if !bytes.HasPrefix(pkt.Path[:], []byte(pathSrc)) {
return false
}
- if bytes.Compare(bufR.Bytes(), []byte(data)) != 0 {
+ if !bytes.Equal(bufR.Bytes(), []byte(data)) {
return false
}
} else {
if pkt.Type != PktTypeTrns {
return false
}
- if bytes.Compare(pkt.Path[:MTHSize], vias[i+1][:]) != 0 {
+ if !bytes.Equal(pkt.Path[:MTHSize], vias[i+1][:]) {
return false
}
}