Humanized priorities

[nncp.git] / src / cypherpunks.ru / nncp / pkt.go

diff --git a/src/cypherpunks.ru/nncp/pkt.go b/src/cypherpunks.ru/nncp/pkt.go
index c24dad39cca7ed510fe4cad1fe857f805804c69b..1d1ff34bf0b082dc3bce06381513b3927372889a 100644 (file)
--- a/src/cypherpunks.ru/nncp/pkt.go
+++ b/src/cypherpunks.ru/nncp/pkt.go
@@ -1,6 +1,6 @@
 /*
 NNCP -- Node to Node copy, utilities for store-and-forward data exchange
-Copyright (C) 2016-2017 Sergey Matveev <stargrave@stargrave.org>
+Copyright (C) 2016-2018 Sergey Matveev <stargrave@stargrave.org>
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -42,20 +42,16 @@ const (
 
        PktTypeFile PktType = iota
        PktTypeFreq PktType = iota
-       PktTypeMail PktType = iota
+       PktTypeExec PktType = iota
        PktTypeTrns PktType = iota
 
        MaxPathSize = 1<<8 - 1
 
-       DefaultNiceMail = 64
-       DefaultNiceFreq = 64
-       DefaultNiceFile = 196
-
        NNCPBundlePrefix = "NNCP"
 )
 
 var (
-       MagicNNCPPv1 [8]byte = [8]byte{'N', 'N', 'C', 'P', 'P', 0, 0, 1}
+       MagicNNCPPv2 [8]byte = [8]byte{'N', 'N', 'C', 'P', 'P', 0, 0, 2}
        MagicNNCPEv3 [8]byte = [8]byte{'N', 'N', 'C', 'P', 'E', 0, 0, 3}
        BadMagic     error   = errors.New("Unknown magic number")
        BadPktType   error   = errors.New("Unknown packet type")
@@ -67,6 +63,7 @@ var (
 type Pkt struct {
        Magic   [8]byte
        Type    PktType
+       Nice    uint8
        PathLen uint8
        Path    *[MaxPathSize]byte
 }
@@ -120,18 +117,18 @@ func init() {
        PktEncOverhead = int64(n)
 }
 
-func NewPkt(typ PktType, path string) (*Pkt, error) {
-       pb := []byte(path)
-       if len(pb) > MaxPathSize {
+func NewPkt(typ PktType, nice uint8, path []byte) (*Pkt, error) {
+       if len(path) > MaxPathSize {
                return nil, errors.New("Too long path")
        }
        pkt := Pkt{
-               Magic:   MagicNNCPPv1,
+               Magic:   MagicNNCPPv2,
                Type:    typ,
-               PathLen: uint8(len(pb)),
+               Nice:    nice,
+               PathLen: uint8(len(path)),
                Path:    new([MaxPathSize]byte),
        }
-       copy(pkt.Path[:], pb)
+       copy(pkt.Path[:], path)
        return &pkt, nil
 }
 
@@ -173,7 +170,14 @@ func ae(keyEnc *[32]byte, r io.Reader, w io.Writer) (int, error) {
        return written, nil
 }
 
-func PktEncWrite(our *NodeOur, their *Node, pkt *Pkt, nice uint8, size, padSize int64, data io.Reader, out io.Writer) error {
+func PktEncWrite(
+       our *NodeOur,
+       their *Node,
+       pkt *Pkt,
+       nice uint8,
+       size, padSize int64,
+       data io.Reader,
+       out io.Writer) error {
        pubEph, prvEph, err := box.GenerateKey(rand.Reader)
        if err != nil {
                return err
@@ -252,7 +256,7 @@ func PktEncWrite(our *NodeOur, their *Node, pkt *Pkt, nice uint8, size, padSize
        if err != nil {
                return err
        }
-       lr := io.LimitedReader{data, size}
+       lr := io.LimitedReader{R: data, N: size}
        mr := io.MultiReader(&pktBuf, &lr)
        mw := io.MultiWriter(out, mac)
        fullSize := pktBuf.Len() + int(size)
@@ -270,7 +274,7 @@ func PktEncWrite(our *NodeOur, their *Node, pkt *Pkt, nice uint8, size, padSize
                if _, err = io.ReadFull(kdf, keyEnc[:]); err != nil {
                        return err
                }
-               lr = io.LimitedReader{DevZero{}, padSize}
+               lr = io.LimitedReader{R: DevZero{}, N: padSize}
                written, err = ae(keyEnc, &lr, out)
                if err != nil {
                        return err
@@ -297,7 +301,11 @@ func TbsVerify(our *NodeOur, their *Node, pktEnc *PktEnc) (bool, error) {
        return ed25519.Verify(their.SignPub, tbsBuf.Bytes(), pktEnc.Sign[:]), nil
 }
 
-func PktEncRead(our *NodeOur, nodes map[NodeId]*Node, data io.Reader, out io.Writer) (*Node, int64, error) {
+func PktEncRead(
+       our *NodeOur,
+       nodes map[NodeId]*Node,
+       data io.Reader,
+       out io.Writer) (*Node, int64, error) {
        var pktEnc PktEnc
        _, err := xdr.Unmarshal(data, &pktEnc)
        if err != nil {
@@ -372,7 +380,7 @@ func PktEncRead(our *NodeOur, nodes map[NodeId]*Node, data io.Reader, out io.Wri
        }
 
        fullSize := PktOverhead + size - 8 - 2*blake2b.Size256
-       lr := io.LimitedReader{data, fullSize}
+       lr := io.LimitedReader{R: data, N: fullSize}
        tr := io.TeeReader(&lr, mac)
        written, err := ae(keyEnc, tr, out)
        if err != nil {